vtkMRMLSliceNode.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: vtkMRMLSliceNode.h,v $
  Date:      $Date: 2006/03/19 17:12:29 $
  Version:   $Revision: 1.3 $
 
=========================================================================auto=*/
 
#ifndef __vtkMRMLSliceNode_h
#define __vtkMRMLSliceNode_h
 
// MRML includes
#include "vtkMRMLAbstractViewNode.h"
class vtkMRMLVolumeNode;
 
// VTK includes
class vtkImplicitFunction;
class vtkMatrix3x3;
class vtkMatrix4x4;
class vtkPlane;
 
class VTK_MRML_EXPORT vtkMRMLSliceNode : public vtkMRMLAbstractViewNode
{
  public:
  static vtkMRMLSliceNode *New();
  vtkTypeMacro(vtkMRMLSliceNode,vtkMRMLAbstractViewNode);
  void PrintSelf(ostream& os, vtkIndent indent) override;
 
  vtkMRMLNode* CreateNodeInstance() override;
 
  void ReadXMLAttributes( const char** atts) override;
 
  void WriteXML(ostream& of, int indent) override;
 
  vtkMRMLCopyContentMacro(vtkMRMLSliceNode);
 
  void Reset(vtkMRMLNode* defaultNode) override;
 
  const char* GetNodeTagName() override {return "Slice";};
 
  virtual vtkMatrix4x4 *GetSliceToRAS();
 
  vtkGetMacro(SliceVisible, int);
  vtkSetMacro(SliceVisible, int);
 
  vtkGetMacro(SliceEdgeVisibility3D, bool);
  vtkSetMacro(SliceEdgeVisibility3D, bool);
  vtkBooleanMacro(SliceEdgeVisibility3D, bool);
 
  vtkGetMacro(WidgetVisible, int);
  vtkSetMacro(WidgetVisible, int);
 
  vtkGetMacro(WidgetOutlineVisible, int);
  vtkSetMacro(WidgetOutlineVisible, int);
 
  void AddThreeDViewID(const char* viewNodeID);
  void RemoveThreeDViewID(char* viewNodeID);
  void RemoveAllThreeDViewIDs();
  int GetNumberOfThreeDViewIDs()const;
  const char* GetNthThreeDViewID(unsigned int index);
  inline std::vector< std::string > GetThreeDViewIDs()const;
  bool IsThreeDViewIDPresent(const char* ThreeDViewID)const;
  bool IsDisplayableInThreeDView(const char* viewNodeID)const;
 
  vtkGetMacro(WidgetNormalLockedToCamera, int);
  vtkSetMacro(WidgetNormalLockedToCamera, int);
 
  vtkGetMacro(UseLabelOutline, int);
  vtkSetMacro(UseLabelOutline, int);
  vtkBooleanMacro(UseLabelOutline, int);
 
  bool SetOrientationToAxial();
  bool SetOrientationToSagittal();
  bool SetOrientationToCoronal();
 
  bool SetOrientationToDefault();
 
  std::string GetOrientation();
 
  std::string GetOrientation(vtkMatrix4x4* sliceToRAS);
 
  bool SetOrientation(const char* orientation);
 
  vtkSetStringMacro(DefaultOrientation);
  vtkGetStringMacro(DefaultOrientation);
 
  virtual const char* GetOrientationString();
 
protected:
 
  vtkGetStringMacro(OrientationReference);
  vtkSetStringMacro(OrientationReference);
 
public:
 
  vtkMatrix3x3 *GetSliceOrientationPreset(const std::string& name);
 
  std::string GetSliceOrientationPresetName(vtkMatrix3x3* orientationMatrix);
 
  void GetSliceOrientationPresetNames(vtkStringArray* presetOrientationNames);
 
  int GetNumberOfSliceOrientationPresets() const;
 
  bool AddSliceOrientationPreset(const std::string& name, vtkMatrix3x3* orientationMatrix);
 
  bool RemoveSliceOrientationPreset(const std::string& name);
 
  bool RenameSliceOrientationPreset(const std::string& name, const std::string& updatedName);
 
  bool HasSliceOrientationPreset(const std::string& name);
 
  static const char* GetReformatOrientationName() { return "Reformat"; }
 
  static void GetAxialSliceToRASMatrix(vtkMatrix3x3* orientationMatrix, bool patientRightIsScreenLeft=true);
 
  static void GetSagittalSliceToRASMatrix(vtkMatrix3x3* orientationMatrix, bool patientRightIsScreenLeft=true);
 
  static void GetCoronalSliceToRASMatrix(vtkMatrix3x3* orientationMatrix, bool patientRightIsScreenLeft=true);
 
  static void AddDefaultSliceOrientationPresets(vtkMRMLScene* scene, bool patientRightIsScreenLeft=true);
 
  vtkGetVector3Macro(FieldOfView, double);
  void SetFieldOfView(double x, double y, double z);
  void SetFieldOfView(double xyz[3]) { SetFieldOfView(xyz[0], xyz[1], xyz[2]); }
 
  vtkGetVector3Macro(XYZOrigin, double);
  void SetXYZOrigin(double x, double y, double z);
  void SetXYZOrigin(double xyz[3]) { SetXYZOrigin(xyz[0], xyz[1], xyz[2]); }
 
 
  vtkGetVectorMacro(Dimensions,int,3);
  void SetDimensions(int x, int y, int z);
  void SetDimensions(int xyz[3]) { SetDimensions(xyz[0], xyz[1], xyz[2]); }
 
  vtkGetVectorMacro(UVWDimensions,int,3);
  void SetUVWDimensions(int x, int y, int z);
  void SetUVWDimensions(int xyz[3]);
 
  vtkGetVectorMacro(UVWMaximumDimensions,int,3);
  void SetUVWMaximumDimensions(int x, int y, int z);
  void SetUVWMaximumDimensions(int xyz[3]);
 
  vtkGetVector3Macro(UVWExtents, double);
  void SetUVWExtents(double x, double y, double z);
  void SetUVWExtents(double xyz[3]);
 
  vtkGetVector3Macro(UVWOrigin, double);
  void SetUVWOrigin(double x, double y, double z);
  void SetUVWOrigin(double xyz[3]);
 
  void SetSliceOrigin(double xyz[3]);
  void SetSliceOrigin(double x, double y, double z);
 
  void SetUVWExtentsAndDimensions (double extents[3], int dimensions[3]);
 
 
  vtkMatrix4x4 *GetXYToSlice();
 
  vtkMatrix4x4 *GetXYToRAS();
 
  vtkMatrix4x4 *GetUVWToSlice();
 
  vtkMatrix4x4 *GetUVWToRAS();
 
  bool MatrixAreEqual(const vtkMatrix4x4 *m1, const vtkMatrix4x4 *m2);
 
  bool MatrixAreEqual(const vtkMatrix4x4 *matrix,
                      const vtkMatrix3x3 *orientationMatrix);
  void UpdateMatrices();
 
  void SetLayoutGrid( int rows, int columns );
 
  vtkGetMacro(LayoutGridRows, int);
  virtual void SetLayoutGridRows(int rows);
 
  vtkGetMacro(LayoutGridColumns, int);
  virtual void SetLayoutGridColumns(int cols);
 
  void SetSliceToRASByNTP(double Nx, double Ny, double Nz,
                          double Tx, double Ty, double Tz,
                          double Px, double Py, double Pz,
                          int Orientation);
 
  void JumpSlice(double r, double a, double s);
  void JumpAllSlices(double r, double a, double s);
  static void JumpAllSlices(vtkMRMLScene* scene, double r, double a, double s,
    int jumpMode = vtkMRMLSliceNode::DefaultJumpSlice, int viewGroup = -1, vtkMRMLSliceNode* exclude = nullptr);
  void JumpSliceByOffsetting(double r, double a, double s);
  void JumpSliceByOffsetting(int k, double r, double a, double s);
  void JumpSliceByCentering(double r, double a, double s);
 
  enum {DefaultJumpSlice=-1, CenteredJumpSlice=0, OffsetJumpSlice};
 
  vtkSetMacro(JumpMode, int);
  vtkGetMacro(JumpMode, int);
  void SetJumpModeToCentered();
  void SetJumpModeToOffset();
 
  enum {AutomaticSliceSpacingMode=0, PrescribedSliceSpacingMode};
 
  vtkGetMacro(SliceSpacingMode, int);
  vtkSetMacro(SliceSpacingMode, int);
  void SetSliceSpacingModeToAutomatic();
  void SetSliceSpacingModeToPrescribed();
 
  vtkSetVector3Macro(PrescribedSliceSpacing, double);
  vtkGetVector3Macro(PrescribedSliceSpacing, double);
 
  double GetSliceOffset();
  void SetSliceOffset(double offset);
 
  vtkSetMacro(ActiveSlice, int);
  vtkGetMacro(ActiveSlice, int);
 
  void RotateToVolumePlane(vtkMRMLVolumeNode *volumeNode, bool forceSlicePlaneToSingleSlice=true);
 
  void RotateToAxes(vtkMatrix4x4 *referenceToRAS, int sliceNormalAxisIndex=-1);
 
  void SetInteracting(int);
  vtkGetMacro(Interacting, int);
  vtkBooleanMacro(Interacting, int);
 
  enum InteractionFlagType
  {
    None = 0,
    SliceToRASFlag = 1,
    FieldOfViewFlag = 2, // broadcast a specific field of view setting
    OrientationFlag = 4,
    ResetFieldOfViewFlag = 8, // broadcast a reset to all viewers
    MultiplanarReformatFlag = 16, // broadcast reformat widget transformation
    XYZOriginFlag = 32,
    LabelOutlineFlag = 64,
    SliceVisibleFlag = 128,
    SliceEdgeVisibility3DFlag = 256,
    SliceSpacingFlag = 512,
    ResetOrientationFlag = 1024,
    RotateToBackgroundVolumePlaneFlag = 2048,
    UpdateSlabReconstructionThicknessFlag = 4096,
  };
 
  void SetInteractionFlags(unsigned int);
  vtkGetMacro(InteractionFlags, unsigned int);
 
  void SetInteractionFlagsModifier(unsigned int);
  vtkGetMacro(InteractionFlagsModifier, unsigned int);
 
  void ResetInteractionFlagsModifier();
 
 
 
 
  enum SliceResolutionModeType
  {
    SliceResolutionMatchVolumes=0,
    SliceResolutionMatch2DView,
    SliceFOVMatch2DViewSpacingMatchVolumes,
    SliceFOVMatchVolumesSpacingMatch2DView,
    SliceResolutionCustom
  };
 
  virtual void SetSliceResolutionMode(int mode);
  vtkGetMacro(SliceResolutionMode, int);
 
  vtkGetMacro(SlabReconstructionEnabled, bool);
  vtkSetMacro(SlabReconstructionEnabled, bool);
  vtkBooleanMacro(SlabReconstructionEnabled, bool);
 
  vtkGetMacro(SlabReconstructionType, int);
  vtkSetMacro(SlabReconstructionType, int);
  static const char* GetSlabReconstructionTypeAsString(int slabReconstructionType);
  static int GetSlabReconstructionTypeFromString(const char* name);
 
  vtkGetMacro(SlabReconstructionThickness, double);
  vtkSetMacro(SlabReconstructionThickness, double);
 
  vtkGetMacro(SlabReconstructionOversamplingFactor, double);
  vtkSetMacro(SlabReconstructionOversamplingFactor, double);
 
  virtual vtkImplicitFunction* GetImplicitFunctionWorld();
 
protected:
  vtkMRMLSliceNode();
  ~vtkMRMLSliceNode() override;
  vtkMRMLSliceNode(const vtkMRMLSliceNode&);
  void operator=(const vtkMRMLSliceNode&);
 
  vtkSmartPointer<vtkMatrix4x4> SliceToRAS;
 
  vtkSmartPointer<vtkMatrix4x4> XYToSlice;
  vtkSmartPointer<vtkMatrix4x4> XYToRAS;
 
  vtkSmartPointer<vtkMatrix4x4> UVWToSlice;
  vtkSmartPointer<vtkMatrix4x4> UVWToRAS;
 
  typedef std::pair <std::string, vtkSmartPointer<vtkMatrix3x3> > OrientationPresetType;
  std::vector< OrientationPresetType > OrientationMatrices;
 
  int JumpMode;
 
  int SliceVisible;
  int WidgetVisible;
  int WidgetOutlineVisible;
  int WidgetNormalLockedToCamera;
  int UseLabelOutline;
  bool SliceEdgeVisibility3D;
 
  double FieldOfView[3];
  double XYZOrigin[3];
  double UVWOrigin[3];
  int Dimensions[3];
 
  int SliceResolutionMode;
  double UVWExtents[3];
  int UVWDimensions[3];
  int UVWMaximumDimensions[3];
 
  bool SlabReconstructionEnabled;
  int SlabReconstructionType;
  double SlabReconstructionThickness;
  double SlabReconstructionOversamplingFactor;
 
  // Hold the string returned by GetOrientationString
  std::string OrientationString;
 
  char* DefaultOrientation;
 
  char* OrientationReference;
 
  int LayoutGridRows;
  int LayoutGridColumns;
 
  int SliceSpacingMode;
  double PrescribedSliceSpacing[3];
 
  int ActiveSlice;
 
  int Interacting;
  unsigned int InteractionFlags;
  unsigned int InteractionFlagsModifier;
 
  int IsUpdatingMatrices;
 
  std::vector< std::string > ThreeDViewIDs;
 
  vtkSmartPointer<vtkPlane> ImplicitFunction;
};
 
//----------------------------------------------------------------------------
std::vector< std::string > vtkMRMLSliceNode::GetThreeDViewIDs()const
{
  return this->ThreeDViewIDs;
}
 
#endif