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
#include <vtkObject.h>
#include <vtkWeakPointer.h>
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);

  vtkGetObjectMacro(DisplayableManagerGroup, vtkObject);
  void SetDisplayableManagerGroup(vtkObject* obj);
 
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;
  };
 
  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];
 
  // Weak reference to the view's displayable manager group.
  //
  // Stored as vtkObject to keep MRMLLogic independent of
  // MRMLDisplayableManager headers. The expected dynamic type is
  // vtkMRMLDisplayableManagerGroup.
  //
  // Set by the layout factories when the view widget is created, and used by
  // vtkSlicerApplicationLogic::GetViewDisplayableManagerByClassName() to
  // resolve managers without Qt. This works because vtkSlicerApplicationLogic
  // lives in SlicerBaseLogic, which can depend on MRMLDisplayableManager.
  //
  // Ownership: the group is owned by the view/widget; this logic holds only a
  // weak pointer. May be nullptr (e.g., headless or before view creation).
  // Type is validated in SetDisplayableManagerGroup().
  vtkWeakPointer<vtkObject> DisplayableManagerGroup;
 
private:
  vtkMRMLSliceLogic(const vtkMRMLSliceLogic&) = delete;
  void operator=(const vtkMRMLSliceLogic&) = delete;
};
 
#endif