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 <vector>
#include <deque>
 
class vtkMRMLDisplayNode;
class vtkMRMLLinearTransformNode;
class vtkMRMLModelDisplayNode;
class vtkMRMLModelNode;
class vtkMRMLSliceCompositeNode;
class vtkMRMLSliceDisplayNode;
class vtkMRMLSliceLayerLogic;
class vtkMRMLSliceNode;
class vtkMRMLVolumeNode;
 
class vtkAlgorithmOutput;
class vtkCollection;
class vtkImageBlend;
class vtkTransform;
class vtkImageData;
class vtkImageMathematics;
class vtkImageReslice;
class vtkTransform;
 
struct SliceLayerInfo;
struct BlendPipeline;
 
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 = -1,
    LayerBackground = 0,
    LayerForeground = 1,
    LayerLabel = 2
    };
 
  vtkGetObjectMacro (SliceNode, vtkMRMLSliceNode);
  void SetSliceNode (vtkMRMLSliceNode * newSliceNode);
 
  vtkMRMLSliceNode* AddSliceNode(const char* layoutName);
 
  vtkGetObjectMacro (SliceCompositeNode, vtkMRMLSliceCompositeNode);
  void SetSliceCompositeNode (vtkMRMLSliceCompositeNode *SliceCompositeNode);
 
  vtkGetObjectMacro (BackgroundLayer, vtkMRMLSliceLayerLogic);
  void SetBackgroundLayer (vtkMRMLSliceLayerLogic *BackgroundLayer);
 
  vtkGetObjectMacro (ForegroundLayer, vtkMRMLSliceLayerLogic);
  void SetForegroundLayer (vtkMRMLSliceLayerLogic *ForegroundLayer);
 
  vtkGetObjectMacro (LabelLayer, vtkMRMLSliceLayerLogic);
  void SetLabelLayer (vtkMRMLSliceLayerLogic *LabelLayer);
 
  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();
 
  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 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 FitSliceToBackground(int width, int height);
 
  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 SetWindowLevel(double window, double level, int layer);
 
  bool UpdateBlendLayers(vtkImageBlend* blend, const std::deque<SliceLayerInfo> &layers);
 
  bool UpdateFractions(vtkImageMathematics* fraction, double opacity);
 
  static void UpdateReconstructionSlab(vtkMRMLSliceLogic* sliceLogic, vtkMRMLSliceLayerLogic* sliceLayerLogic);
 
  bool IsEventInsideVolume(bool background, double worldPos[3]);
 
  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                        AddingSliceModelNodes;
 
  vtkMRMLSliceNode *          SliceNode;
  vtkMRMLSliceCompositeNode * SliceCompositeNode;
  vtkMRMLSliceLayerLogic *    BackgroundLayer;
  vtkMRMLSliceLayerLogic *    ForegroundLayer;
  vtkMRMLSliceLayerLogic *    LabelLayer;
 
  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;
 
};
 
#endif