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 vtkMatrix3x3;
class vtkMatrix4x4;

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(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 InitializeAxialMatrix(vtkMatrix3x3* orientationMatrix);

  static void InitializeSagittalMatrix(vtkMatrix3x3* orientationMatrix);

  static void InitializeCoronalMatrix(vtkMatrix3x3* orientationMatrix);

  static void AddDefaultSliceOrientationPresets(vtkMRMLScene* scene);

  vtkGetVector3Macro(FieldOfView, double);
  void SetFieldOfView(double x, double y, double z);

  vtkGetVector3Macro(XYZOrigin, double);
  void SetXYZOrigin(double x, double y, double z);

  vtkGetVectorMacro(Dimensions,int,3)
  void SetDimensions(int x, int y, int z);

  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,
    SliceSpacingFlag = 256,
    ResetOrientationFlag = 512,
    RotateToBackgroundVolumePlaneFlag = 1024
  };

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

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;

  double FieldOfView[3];
  double XYZOrigin[3];
  double UVWOrigin[3];
  int Dimensions[3];

  int SliceResolutionMode;
  double UVWExtents[3];
  int UVWDimensions[3];
  int UVWMaximumDimensions[3];

  // 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;
};

//----------------------------------------------------------------------------
std::vector< std::string > vtkMRMLSliceNode::GetThreeDViewIDs()const
{
  return this->ThreeDViewIDs;
}

#endif