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,
  };
  enum InteractionFlagType {…};

  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
  };
  enum SliceResolutionModeType {…};

  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;
};
class VTK_MRML_EXPORT vtkMRMLSliceNode : public vtkMRMLAbstractViewNode {…};
 
//----------------------------------------------------------------------------
std::vector< std::string > vtkMRMLSliceNode::GetThreeDViewIDs()const
{
  return this->ThreeDViewIDs;
}
std::vector< std::string > vtkMRMLSliceNode::GetThreeDViewIDs()const {…}
 
#endif