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 vtkMRMLSliceLayerLogic;
class vtkMRMLSliceNode;
class vtkMRMLVolumeNode;

class vtkAlgorithmOutput;
class vtkCollection;
class vtkImageBlend;
class vtkTransform;
class vtkImageData;
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);

  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);

  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();

  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();

  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);

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                        AddingSliceModelNodes;

  vtkMRMLSliceNode *          SliceNode;
  vtkMRMLSliceCompositeNode * SliceCompositeNode;
  vtkMRMLSliceLayerLogic *    BackgroundLayer;
  vtkMRMLSliceLayerLogic *    ForegroundLayer;
  vtkMRMLSliceLayerLogic *    LabelLayer;

  BlendPipeline* Pipeline;
  BlendPipeline* PipelineUVW;
  vtkImageReslice * ExtractModelTexture;
  vtkAlgorithmOutput *    ImageDataConnection;
  vtkTransform *    ActiveSliceTransform;

  vtkMRMLModelNode *            SliceModelNode;
  vtkMRMLModelDisplayNode *     SliceModelDisplayNode;
  vtkMRMLLinearTransformNode *  SliceModelTransformNode;
  double                        SliceSpacing[3];

private:

  vtkMRMLSliceLogic(const vtkMRMLSliceLogic&) = delete;
  void operator=(const vtkMRMLSliceLogic&) = delete;

};

#endif