vtkMRMLMarkupsDisplayNode.h

Go to the documentation of this file.

/*==============================================================================
 
  Program: 3D Slicer
 
  Portions (c) Copyright Brigham and Women's Hospital (BWH) All Rights Reserved.
 
  See COPYRIGHT.txt
  or http://www.slicer.org/copyright/copyright.txt for details.
 
  Unless required by applicable law or agreed to in writing, software
  distributed under the License is distributed on an "AS IS" BASIS,
  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  See the License for the specific language governing permissions and
  limitations under the License.
 
==============================================================================*/
 
// .NAME vtkMRMLMarkupsDisplayNode - MRML node to represent display properties for markups
// .SECTION Description
// vtkMRMLMarkupsDisplayNode nodes store display properties of markups,
// keeping elements that are applicable to all parts of the markups in this superclass
//
 
#ifndef __vtkMRMLMarkupsDisplayNode_h
#define __vtkMRMLMarkupsDisplayNode_h
 
#include "vtkMRMLExport.h"
 
#include "vtkMRMLDisplayNode.h"
#include "vtkMRMLMarkupsNode.h"
 
// vtkAddon includes
#include <vtkAddonSetGet.h>
 
// STD includes
#include <map>
 
// VTK include
#include <vtkTextProperty.h>
 
class vtkMRMLInteractionEventData;
class vtkMRMLProceduralColorNode;
 
class VTK_MRML_EXPORT vtkMRMLMarkupsDisplayNode : public vtkMRMLDisplayNode
{
public:
  static vtkMRMLMarkupsDisplayNode* New();
  vtkTypeMacro(vtkMRMLMarkupsDisplayNode, vtkMRMLDisplayNode);
  void PrintSelf(ostream& os, vtkIndent indent) override;
 
  //--------------------------------------------------------------------------
  // MRMLNode methods
  //--------------------------------------------------------------------------
 
  vtkMRMLNode* CreateNodeInstance() override;

  void ReadXMLAttributes(const char** atts) override;

  void WriteXML(ostream& of, int indent) override;

  vtkMRMLCopyContentMacro(vtkMRMLMarkupsDisplayNode);

  const char* GetNodeTagName() override { return "MarkupsDisplay"; };

  void UpdateScene(vtkMRMLScene* scene) override;

  void ProcessMRMLEvents(vtkObject* /*caller*/, unsigned long /*event*/, void* /*callData*/) override;

  vtkMRMLMarkupsNode* GetMarkupsNode();

  static const std::string GetDefaultContextName() { return ""; };

  int GetActiveComponentType(std::string context = vtkMRMLMarkupsDisplayNode::GetDefaultContextName());
  enum ComponentType
  {
    ComponentNone = 0,
    ComponentControlPoint,
    ComponentCenterPoint,
    ComponentLine,
    ComponentPlane,
    ComponentRotationHandle,
    ComponentTranslationHandle,
    ComponentScaleHandle,
    Component_Last
  };
  struct ComponentInfo
  {
    ComponentInfo()
    {
      this->Type = ComponentNone;
      this->Index = -1;
    }
    int Type;
    int Index;
  };

  int GetActiveComponentIndex(std::string context = vtkMRMLMarkupsDisplayNode::GetDefaultContextName());

  void SetActiveComponent(int componentType, int componentIndex, std::string context = vtkMRMLMarkupsDisplayNode::GetDefaultContextName());

  bool HasActiveComponent();

  std::vector<std::string> GetActiveComponentInteractionContexts();

  void SetActiveControlPoint(int controlPointIndex);

  int UpdateActiveControlPointWorld(int controlPointIndex,
                                    vtkMRMLInteractionEventData* eventData,
                                    double accurateWorldOrientationMatrix[9],
                                    const char* viewNodeID,
                                    const char* associatedNodeID,
                                    int positionStatus);

  void GetActiveControlPoints(std::vector<int>& controlPointIndices);
  int GetActiveControlPoint(std::string context = vtkMRMLMarkupsDisplayNode::GetDefaultContextName());

  static const char* GetMovingInSliceViewAttributeName() { return "Markups.MovingInSliceView"; }
  static const char* GetMovingMarkupIndexAttributeName() { return "Markups.MovingMarkupIndex"; }

  vtkGetMacro(TextScale, double);
  vtkSetMacro(TextScale, double);


  vtkSetMacro(PointLabelsVisibility, bool);
  vtkGetMacro(PointLabelsVisibility, bool);
  vtkBooleanMacro(PointLabelsVisibility, bool);


  vtkSetMacro(PropertiesLabelVisibility, bool);
  vtkGetMacro(PropertiesLabelVisibility, bool);
  vtkBooleanMacro(PropertiesLabelVisibility, bool);


  vtkSetMacro(FillVisibility, bool);
  vtkGetMacro(FillVisibility, bool);
  vtkBooleanMacro(FillVisibility, bool);


  vtkSetMacro(OutlineVisibility, bool);
  vtkGetMacro(OutlineVisibility, bool);
  vtkBooleanMacro(OutlineVisibility, bool);


  vtkSetMacro(FillOpacity, double);
  vtkGetMacro(FillOpacity, double);
  vtkBooleanMacro(FillOpacity, double);


  vtkSetMacro(OutlineOpacity, double);
  vtkGetMacro(OutlineOpacity, double);
  vtkBooleanMacro(OutlineOpacity, double);

  enum SnapModes
  {
    SnapModeUnconstrained,    //< point is moved independently from displayed objects in 3D views (e.g., in parallel with camera plane)
    SnapModeToVisibleSurface, //< point is snapped to any visible surface in 3D views
    // SnapModeToNode //< point is snapped to a specific node, not implemented yet
    SnapMode_Last // insert new items above this line
  };

  enum GlyphShapes
  {
    GlyphTypeInvalid = 0,
    StarBurst2D,
    Cross2D,
    CrossDot2D,
    ThickCross2D,
    Dash2D,
    Sphere3D,
    Vertex2D,
    Circle2D,
    Triangle2D,
    Square2D,
    Diamond2D,
    Arrow2D,
    ThickArrow2D,
    HookedArrow2D,
    GlyphType_Last // insert new types above this line
  };

  static int GetMinimumGlyphType() { return 1; };
  static int GetMaximumGlyphType() { return vtkMRMLMarkupsDisplayNode::GlyphType_Last - 1; };

  vtkSetMacro(GlyphType, int);
  vtkGetMacro(GlyphType, int);
  int GlyphTypeIs3D(int glyphType);
  int GlyphTypeIs3D() { return this->GlyphTypeIs3D(this->GlyphType); };

  const char* GetGlyphTypeAsString();
  void SetGlyphTypeFromString(const char* glyphString);
 
  static const char* GetGlyphTypeAsString(int g);
  static int GetGlyphTypeFromString(const char*);

  vtkSetMacro(SnapMode, int);
  vtkGetMacro(SnapMode, int);
 
  static const char* GetSnapModeAsString(int g);
  static int GetSnapModeFromString(const char*);

  vtkSetMacro(GlyphScale, double);
  vtkGetMacro(GlyphScale, double);

  vtkSetMacro(GlyphSize, double);
  vtkGetMacro(GlyphSize, double);

  vtkSetMacro(UseGlyphScale, bool);
  vtkGetMacro(UseGlyphScale, bool);
  vtkBooleanMacro(UseGlyphScale, bool);
 
  enum
  {
    ResetToDefaultsEvent = 19001, //< reset this node to the default values, request completed by markups logic
    JumpToPointEvent,             
    ActionEvent,                  
    CustomActionEvent1,           
    CustomActionEvent2,           
    CustomActionEvent3,           
    CustomActionEvent4,           
    CustomActionEvent5,           
    CustomActionEvent6,           
  };

  vtkSetMacro(SliceProjection, bool);
  vtkGetMacro(SliceProjection, bool);
  vtkBooleanMacro(SliceProjection, bool);

  vtkSetMacro(SliceProjectionUseFiducialColor, bool);
  vtkGetMacro(SliceProjectionUseFiducialColor, bool);
  vtkBooleanMacro(SliceProjectionUseFiducialColor, bool);

  vtkSetMacro(SliceProjectionOutlinedBehindSlicePlane, bool);
  vtkGetMacro(SliceProjectionOutlinedBehindSlicePlane, bool);
  vtkBooleanMacro(SliceProjectionOutlinedBehindSlicePlane, bool);

  vtkSetVector3Macro(SliceProjectionColor, double);
  vtkGetVector3Macro(SliceProjectionColor, double);

  vtkSetClampMacro(SliceProjectionOpacity, double, 0.0, 1.0);
  vtkGetMacro(SliceProjectionOpacity, double);

  enum CurveLineSizeModes
  {
    UseLineThickness = 0,
    UseLineDiameter,
    CurveLineSizeMode_Last // insert new types above this line
  };

  vtkSetMacro(CurveLineSizeMode, int);
  vtkGetMacro(CurveLineSizeMode, int);
  const char* GetCurveLineSizeModeAsString();
  void SetCurveLineSizeModeFromString(const char* modeString);
  static const char* GetCurveLineSizeModeAsString(int mode);
  static int GetCurveLineSizeModeFromString(const char*);

  vtkGetMacro(LineThickness, double);
  vtkSetMacro(LineThickness, double);

  vtkGetMacro(LineDiameter, double);
  vtkSetMacro(LineDiameter, double);

  vtkGetMacro(LineColorFadingStart, double);
  vtkSetMacro(LineColorFadingStart, double);

  vtkGetMacro(LineColorFadingEnd, double);
  vtkSetMacro(LineColorFadingEnd, double);

  vtkSetClampMacro(LineColorFadingSaturation, double, 0.0, 1.0);
  vtkGetMacro(LineColorFadingSaturation, double);

  vtkSetClampMacro(LineColorFadingHueOffset, double, 0.0, 1.0);
  vtkGetMacro(LineColorFadingHueOffset, double);

  vtkSetMacro(LineDirectionVisibility, bool);
  vtkGetMacro(LineDirectionVisibility, bool);
  vtkBooleanMacro(LineDirectionVisibility, bool);

  vtkSetMacro(LineDirectionVisibility3D, bool);
  vtkGetMacro(LineDirectionVisibility3D, bool);
  vtkBooleanMacro(LineDirectionVisibility3D, bool);

  vtkSetMacro(LineDirectionVisibility2D, bool);
  vtkGetMacro(LineDirectionVisibility2D, bool);
  vtkBooleanMacro(LineDirectionVisibility2D, bool);

  static constexpr double LineDirectionMarkerBaseScaleFactor = 3.0;

  vtkSetMacro(LineDirectionMarkerScale, double);
  vtkGetMacro(LineDirectionMarkerScale, double);

  vtkSetMacro(LineDirectionMarkerSpacingScale, double);
  vtkGetMacro(LineDirectionMarkerSpacingScale, double);

  vtkSetMacro(LineDirectionFirstToLastControlPoint, bool);
  vtkGetMacro(LineDirectionFirstToLastControlPoint, bool);
  vtkBooleanMacro(LineDirectionFirstToLastControlPoint, bool);

  vtkSetMacro(LineSliceIntersectionPointVisibility, bool);
  vtkGetMacro(LineSliceIntersectionPointVisibility, bool);
  vtkBooleanMacro(LineSliceIntersectionPointVisibility, bool);

  virtual void SetLineColorNodeID(const char* lineColorNodeID);

  const char* GetLineColorNodeID();

  vtkMRMLProceduralColorNode* GetLineColorNode();
  virtual const char* GetLineColorNodeReferenceRole();

  vtkGetMacro(OccludedVisibility, bool);
  vtkSetMacro(OccludedVisibility, bool);
  vtkBooleanMacro(OccludedVisibility, bool);

  vtkGetMacro(OccludedOpacity, double);
  vtkSetMacro(OccludedOpacity, double);

  vtkGetObjectMacro(TextProperty, vtkTextProperty);

  vtkSetVector3Macro(ActiveColor, double);
  vtkGetVector3Macro(ActiveColor, double);


  vtkGetMacro(HandlesInteractive, bool);
  vtkSetMacro(HandlesInteractive, bool);
  vtkBooleanMacro(HandlesInteractive, bool);
  vtkGetMacro(TranslationHandleVisibility, bool);
  vtkSetMacro(TranslationHandleVisibility, bool);
  vtkBooleanMacro(TranslationHandleVisibility, bool);
  vtkGetMacro(RotationHandleVisibility, bool);
  vtkSetMacro(RotationHandleVisibility, bool);
  vtkBooleanMacro(RotationHandleVisibility, bool);
  vtkGetMacro(ScaleHandleVisibility, bool);
  vtkSetMacro(ScaleHandleVisibility, bool);
  vtkBooleanMacro(ScaleHandleVisibility, bool);
  void SetHandleVisibility(int handleType, bool visibility);
  bool GetHandleVisibility(int handleType);


  vtkSetMacro(InteractionHandleScale, double);
  vtkGetMacro(InteractionHandleScale, double);


  vtkSetVector4Macro(RotationHandleComponentVisibility, bool);
  vtkGetVector4Macro(RotationHandleComponentVisibility, bool);
  vtkSetVector4Macro(ScaleHandleComponentVisibility, bool);
  vtkGetVector4Macro(ScaleHandleComponentVisibility, bool);
  vtkSetVector4Macro(TranslationHandleComponentVisibility, bool);
  vtkGetVector4Macro(TranslationHandleComponentVisibility, bool);

  virtual vtkDataSet* GetScalarDataSet() override;
  virtual vtkDataArray* GetActiveScalarArray() override;

  virtual void UpdateAssignedAttribute() override;
 
  virtual void SetScalarVisibility(int visibility) override;

  vtkGetMacro(CanDisplayScaleHandles, bool);
 
protected:
  vtkMRMLMarkupsDisplayNode();
  ~vtkMRMLMarkupsDisplayNode() override;
  vtkMRMLMarkupsDisplayNode(const vtkMRMLMarkupsDisplayNode&);
  void operator=(const vtkMRMLMarkupsDisplayNode&);
 
  // Set the text style from a string
  // String format follows html-style conventions
  void SetTextPropertyFromString(std::string textPropertyString);
 
  // Return a string representing the text style
  // String format follows html-style conventions
  std::string GetTextPropertyAsString();

  std::map<std::string, ComponentInfo> ActiveComponents;
 
  int SnapMode;
 
  bool PropertiesLabelVisibility;
  bool PointLabelsVisibility;
  bool FillVisibility;
  bool OutlineVisibility;
  double FillOpacity;
  double OutlineOpacity;
  double TextScale;
  int GlyphType;
  double GlyphScale;
  double GlyphSize;
  bool UseGlyphScale;
 
  bool SliceProjection;
  bool SliceProjectionUseFiducialColor;
  bool SliceProjectionOutlinedBehindSlicePlane;
  double SliceProjectionColor[3];
  double SliceProjectionOpacity;
 
  virtual const char* GetLineColorNodeReferenceMRMLAttributeName();
 
  static const char* LineColorNodeReferenceRole;
  static const char* LineColorNodeReferenceMRMLAttributeName;
 
  int CurveLineSizeMode;
  double LineThickness;
  double LineDiameter;
 
  double LineColorFadingStart;
  double LineColorFadingEnd;
  double LineColorFadingSaturation;
  double LineColorFadingHueOffset;
 
  bool LineDirectionVisibility;
  bool LineDirectionVisibility3D;
  bool LineDirectionVisibility2D;
  double LineDirectionMarkerScale;
  double LineDirectionMarkerSpacingScale;
  bool LineDirectionFirstToLastControlPoint;
  bool LineSliceIntersectionPointVisibility;
 
  bool OccludedVisibility;
  double OccludedOpacity;
 
  vtkTextProperty* TextProperty;
 
  double ActiveColor[3];
 
  bool HandlesInteractive;
  bool TranslationHandleVisibility;
  bool RotationHandleVisibility;
  bool ScaleHandleVisibility;
  double InteractionHandleScale;
 
  bool RotationHandleComponentVisibility[4];
  bool ScaleHandleComponentVisibility[4];
  bool TranslationHandleComponentVisibility[4];
 
  bool CanDisplayScaleHandles;
};
#endif