vtkMRMLSliceLogic.h

Go to the documentation of this file.

/*=auto=========================================================================
 
  Portions (c) Copyright 2005 Brigham and Women's Hospital (BWH) All Rights Reserved.
 
  See COPYRIGHT.txt
  or http://www.slicer.org/copyright/copyright.txt for details.
 
  Program:   3D Slicer
  Module:    $RCSfile: vtkMRMLSliceLogic.h,v $
  Date:      $Date$
  Version:   $Revision: 18866
 
=========================================================================auto=*/
 
#ifndef __vtkMRMLSliceLogic_h
#define __vtkMRMLSliceLogic_h
 
// MRMLLogic includes
#include "vtkMRMLAbstractLogic.h"
 
// STD includes
#include <deque>
#include <vector>
 
// MRML includes
#include <vtkMRMLSliceCompositeNode.h>
class vtkMRMLDisplayNode;
class vtkMRMLLinearTransformNode;
class vtkMRMLModelDisplayNode;
class vtkMRMLModelNode;
class vtkMRMLSliceDisplayNode;
class vtkMRMLSliceLayerLogic;
class vtkMRMLSliceNode;
class vtkMRMLVolumeNode;
 
// VTK includes
class vtkAlgorithmOutput;
class vtkCollection;
class vtkImageBlend;
class vtkImageMathematics;
class vtkImageReslice;
 
struct BlendPipeline;
struct SliceLayerInfo;

class VTK_MRML_LOGIC_EXPORT vtkMRMLSliceLogic : public vtkMRMLAbstractLogic
{
public:
  static vtkMRMLSliceLogic *New();
  vtkTypeMacro(vtkMRMLSliceLogic,vtkMRMLAbstractLogic);
  void PrintSelf(ostream& os, vtkIndent indent) override;

  enum
  {
    CompositeModifiedEvent = 18000
  };
 
  enum
  {
    LayerNone = vtkMRMLSliceCompositeNode::LayerNone,
    LayerBackground = vtkMRMLSliceCompositeNode::LayerBackground,
    LayerForeground = vtkMRMLSliceCompositeNode::LayerForeground,
    LayerLabel = vtkMRMLSliceCompositeNode::LayerLabel,
    Layer_Last // must be last
  };

  vtkGetObjectMacro (SliceNode, vtkMRMLSliceNode);
  void SetSliceNode (vtkMRMLSliceNode * newSliceNode);

  vtkMRMLSliceNode* AddSliceNode(const char* layoutName);

  vtkGetObjectMacro (SliceCompositeNode, vtkMRMLSliceCompositeNode);
  void SetSliceCompositeNode (vtkMRMLSliceCompositeNode *SliceCompositeNode);

  vtkMRMLSliceLayerLogic* GetBackgroundLayer();
  void SetBackgroundLayer (vtkMRMLSliceLayerLogic *BackgroundLayer);

  vtkMRMLSliceLayerLogic* GetForegroundLayer();
  void SetForegroundLayer (vtkMRMLSliceLayerLogic *ForegroundLayer);

  vtkMRMLSliceLayerLogic* GetLabelLayer();
  void SetLabelLayer (vtkMRMLSliceLayerLogic *LabelLayer);
 
  vtkMRMLSliceLayerLogic* GetNthLayer(int layerIndex);
  void SetNthLayer(int layerIndex, vtkMRMLSliceLayerLogic *layer);
 
  vtkAlgorithmOutput* GetNthLayerImageDataConnection(int layerIndex);
  vtkAlgorithmOutput* GetNthLayerImageDataConnectionUVW(int layerIndex);

  vtkMRMLVolumeNode* GetNthLayerVolumeNode(int layerIndex);

  void SetBackgroundWindowLevel(double window, double level);

  void GetBackgroundWindowLevelAndRange(double& window, double& level,
                                        double& rangeLow, double& rangeHigh, bool& autoWindowLevel);

  void GetBackgroundWindowLevelAndRange(double& window, double& level,
                                        double& rangeLow, double& rangeHigh);

  void SetForegroundWindowLevel(double window, double level);

  void GetForegroundWindowLevelAndRange(double& window, double& level,
                                        double& rangeLow, double& rangeHigh, bool& autoWindowLevel);

  void GetForegroundWindowLevelAndRange(double& window, double& level,
                                        double& rangeLow, double& rangeHigh);

  vtkGetObjectMacro(SliceModelNode, vtkMRMLModelNode);

  vtkGetObjectMacro(SliceModelDisplayNode, vtkMRMLModelDisplayNode);

  vtkMRMLSliceDisplayNode* GetSliceDisplayNode();

  vtkGetObjectMacro(SliceModelTransformNode, vtkMRMLLinearTransformNode);

  vtkImageBlend* GetBlend();
  vtkImageBlend* GetBlendUVW();

  vtkGetObjectMacro(ExtractModelTexture, vtkImageReslice);

  vtkAlgorithmOutput *GetImageDataConnection();

  bool HasInputs();

  bool HasUVWInputs();

  void UpdatePipeline();

  void UpdateImageData();

  virtual bool EnterMRMLCallback() const;

  void UpdateSliceNode();

  void UpdateSliceNodeFromLayout();

  void UpdateSliceCompositeNode();

  vtkMRMLVolumeNode *GetLayerVolumeNode(int layer);

  static void GetVolumeRASBox(vtkMRMLVolumeNode *volumeNode, double rasDimensions[3], double rasCenter[3]);

  void GetVolumeSliceDimensions(vtkMRMLVolumeNode *volumeNode, double sliceDimensions[3], double sliceCenter[3]);

  double* GetVolumeSliceSpacing(vtkMRMLVolumeNode *volumeNode) VTK_SIZEHINT(3);

  void GetVolumeSliceBounds(vtkMRMLVolumeNode *volumeNode, double sliceBounds[6], bool useVoxelCenter=false);

  void FitSliceToVolume(vtkMRMLVolumeNode *volumeNode, int width, int height);

  void FitSliceToVolumes(vtkCollection *volumeNodes, int width, int height);

  void GetBackgroundRASBox(double rasDimensions[3], double rasCenter[3]);

  void GetBackgroundSliceDimensions(double sliceDimensions[3], double sliceCenter[3]);

  double* GetBackgroundSliceSpacing() VTK_SIZEHINT(3);

  void GetBackgroundSliceBounds(double sliceBounds[6]);

  void RotateSliceToLowestVolumeAxes(bool forceSlicePlaneToSingleSlice = true);

  void FitSliceToFirst(int width = -1, int height = -1);

  void FitSliceToBackground(int width = -1, int height = -1);

  void FitSliceToAll(int width = -1, int height = -1);

  void FitFOVToBackground(double fov);

  void ResizeSliceNode(double newWidth, double newHeight);

  double* GetLowestVolumeSliceSpacing() VTK_SIZEHINT(3);

  void GetLowestVolumeSliceBounds(double sliceBounds[6], bool useVoxelCenter=false);

  double GetSliceOffset();
  void SetSliceOffset(double offset);

  void GetSliceBounds(double sliceBounds[6]);

  void SetSliceExtentsToSliceNode();

  void StartSliceNodeInteraction(unsigned int parameters);

  void EndSliceNodeInteraction();

  void StartSliceCompositeNodeInteraction(unsigned int parameters);

  void EndSliceCompositeNodeInteraction();

  void StartSliceOffsetInteraction();

  void EndSliceOffsetInteraction();

  void SnapSliceOffsetToIJK();
 
  static const int SLICE_INDEX_ROTATED;
  static const int SLICE_INDEX_OUT_OF_VOLUME;
  static const int SLICE_INDEX_NO_VOLUME;

  int GetSliceIndexFromOffset(double sliceOffset, vtkMRMLVolumeNode *volumeNode);

  int GetSliceIndexFromOffset(double sliceOffset);

  void CreateSliceModel();
  void DeleteSliceModel();

  std::vector< vtkMRMLDisplayNode*> GetPolyDataDisplayNodes();
  static vtkMRMLSliceCompositeNode* GetSliceCompositeNode(vtkMRMLSliceNode* node);
  static vtkMRMLSliceNode* GetSliceNode(vtkMRMLSliceCompositeNode* node);

  static const std::string SLICE_MODEL_NODE_NAME_SUFFIX;

  static bool IsSliceModelNode(vtkMRMLNode *mrmlNode);
  static bool IsSliceModelDisplayNode(vtkMRMLDisplayNode *mrmlDisplayNode);

  int GetEditableLayerAtWorldPosition(double worldPos[3], bool backgroundVolumeEditable = true, bool foregroundVolumeEditable = true);

  bool GetSliceOffsetRangeResolution(double range[2], double& resolution);
 
protected:
 
  vtkMRMLSliceLogic();
  ~vtkMRMLSliceLogic() override;
 
  void SetMRMLSceneInternal(vtkMRMLScene * newScene) override;

  void ProcessMRMLLogicsEvents(vtkObject * caller,
                               unsigned long event,
                               void * callData) override;
  void ProcessMRMLLogicsEvents();
 
  void OnMRMLSceneNodeAdded(vtkMRMLNode* node) override;
  void OnMRMLSceneNodeRemoved(vtkMRMLNode* node) override;
  void UpdateFromMRMLScene() override;
  void OnMRMLSceneStartClose() override;
  void OnMRMLSceneEndImport() override;
  void OnMRMLSceneEndRestore() override;
 
  void UpdateSliceNodes();
  void SetupCrosshairNode();
 
  void OnMRMLNodeModified(vtkMRMLNode* node) override;
  static vtkMRMLSliceCompositeNode* GetSliceCompositeNode(vtkMRMLScene* scene,
                                                          const char* layoutName);
  static vtkMRMLSliceNode* GetSliceNode(vtkMRMLScene* scene,
    const char* layoutName);

  void SetNthLayerVolumeNode(int layerIndex, vtkMRMLVolumeNode* volumeNode);

  void SetWindowLevel(int layer, double window, double level);
  void GetWindowLevelAndRange(int layer, double& window, double& level,
                                      double& rangeLow, double& rangeHigh, bool& autoWindowLevel);

  static bool UpdateBlendLayers(vtkImageBlend* blend, const std::deque<SliceLayerInfo> &layers, bool clipToBackgroundVolume);

  static bool UpdateAddSubOperation(vtkImageMathematics* addSubMath, int compositing);

  static bool UpdateFractions(vtkImageMathematics* fraction, double opacity);

  static bool UpdateFractions(BlendPipeline* pipeline, const std::vector<vtkAlgorithmOutput*>& imagePorts, const std::vector<double>& opacities);

  static void UpdateReconstructionSlab(vtkMRMLSliceLogic* sliceLogic, vtkMRMLSliceLayerLogic* sliceLayerLogic);

  bool IsEventInsideVolume(bool background, double worldPos[3]);

  vtkMRMLVolumeNode* GetFirstVolumeNode();

  bool VolumeWindowLevelEditable(const char* vtkNotUsed(volumeNodeID))
  {
    vtkWarningMacro("vtkMRMLSliceLogic::VolumeWindowLevelEditable method is deprecated. Volume Window Level is always editable. Use the interaction node to check if in editing mode. "
                    "e.g. slicer.app.applicationLogic().GetInteractionNode().GetCurrentInteractionMode() == slicer.vtkMRMLInteractionNode.AdjustWindowLevel");
    return true;
  };
  bool VolumeWindowLevelEditable(const char* vtkNotUsed(volumeNodeID)) {…}
 
  typedef vtkSmartPointer<vtkMRMLSliceLayerLogic> LayerListItem;
  typedef std::vector<LayerListItem> LayerList;
  typedef std::vector<LayerListItem>::iterator LayerListIterator;
  typedef std::vector<LayerListItem>::const_iterator LayerListConstIterator;
 
  LayerList Layers;
 
  bool                          AddingSliceModelNodes;
 
  vtkMRMLSliceNode*             SliceNode;
  vtkMRMLSliceCompositeNode*    SliceCompositeNode;
 
  BlendPipeline*                Pipeline;
  BlendPipeline*                PipelineUVW;
  vtkImageReslice*              ExtractModelTexture;
  vtkAlgorithmOutput*           ImageDataConnection;
 
  vtkMRMLModelNode*             SliceModelNode;
  vtkMRMLModelDisplayNode*      SliceModelDisplayNode;
  vtkMRMLLinearTransformNode*   SliceModelTransformNode;
  double                        SliceSpacing[3];
 
private:
 
  vtkMRMLSliceLogic(const vtkMRMLSliceLogic&) = delete;
  void operator=(const vtkMRMLSliceLogic&) = delete;
 
};
class VTK_MRML_LOGIC_EXPORT vtkMRMLSliceLogic : public vtkMRMLAbstractLogic {…};
 
#endif