vtkMRMLDisplayNode.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: vtkMRMLDisplayNode.h,v $
  Date:      $Date: 2006/03/19 17:12:29 $
  Version:   $Revision: 1.3 $
 
=========================================================================auto=*/
 
#ifndef __vtkMRMLDisplayNode_h
#define __vtkMRMLDisplayNode_h
 
// MRML includes
#include "vtkMRMLNode.h"
 
// STD includes
#include <vector>
 
class vtkAlgorithmOutput;
class vtkMRMLClipNode;
class vtkDataSet;
class vtkImageData;
class vtkMRMLColorNode;
class vtkMRMLDisplayableNode;
class vtkPolyData;
class vtkTextProperty;
 
class VTK_MRML_EXPORT vtkMRMLDisplayNode : public vtkMRMLNode
{
public:
  vtkTypeMacro(vtkMRMLDisplayNode,vtkMRMLNode);
  void PrintSelf(ostream& os, vtkIndent indent) override;
 
  enum RepresentationType
  {
    PointsRepresentation = 0,
    WireframeRepresentation,
    SurfaceRepresentation
  };
 
  enum InterpolationType
  {
    FlatInterpolation = 0,
    GouraudInterpolation,
    PhongInterpolation,
    PBRInterpolation
  };
 
  enum ScalarRangeFlagType
  {
    UseManualScalarRange = 0,
    UseDataScalarRange,
    UseColorNodeScalarRange,
    UseDataTypeScalarRange,
    UseDirectMapping,
    // insert types above this line
    NUM_SCALAR_RANGE_FLAGS
  };
 
  enum ShowModeType
  {
    ShowDefault = 0, 
    ShowIgnore, 
    ShowMode_Last
  };
 
  enum
  {
    MenuEvent = 16100, 
  };
 
  static const char* GetScalarRangeFlagTypeAsString(int flag);
  static int GetScalarRangeFlagTypeFromString(const char* name);
 
  virtual vtkMRMLDisplayableNode* GetDisplayableNode();
 
  void ReadXMLAttributes( const char** atts) override;
 
  void WriteXML(ostream& of, int indent) override;
 
  vtkMRMLCopyContentMacro(vtkMRMLDisplayNode);
 
  void ProcessMRMLEvents(vtkObject *caller, unsigned long event,
                                 void *callData) override;
 
  void SetSceneReferences() override;
 
  void UpdateReferences() override;
 
  void UpdateScene(vtkMRMLScene *scene) override;
 
  void UpdateReferenceID(const char *oldID, const char *newID) override;
 
  vtkSetVector3Macro(Color, double);
  vtkGetVector3Macro(Color, double);
 
  vtkSetVector3Macro(EdgeColor, double);
  vtkGetVector3Macro(EdgeColor, double);
 
  vtkSetVector3Macro(SelectedColor, double);
  vtkGetVector3Macro(SelectedColor, double);
 
  vtkSetMacro(SelectedAmbient, double);
  vtkGetMacro(SelectedAmbient, double);
 
  vtkSetMacro(SelectedSpecular, double);
  vtkGetMacro(SelectedSpecular, double);
 
  vtkSetMacro(PointSize, double);
  vtkGetMacro(PointSize, double);
 
  vtkSetMacro(LineWidth, double);
  vtkGetMacro(LineWidth, double);
 
  vtkSetMacro(Representation, int);
  vtkGetMacro(Representation, int);
 
  vtkSetMacro(Opacity, double);
  vtkGetMacro(Opacity, double);
 
  vtkSetMacro(SliceIntersectionOpacity, double);
  vtkGetMacro(SliceIntersectionOpacity, double);
 
  vtkSetMacro(Ambient, double);
  vtkGetMacro(Ambient, double);
 
  vtkSetMacro(Diffuse, double);
  vtkGetMacro(Diffuse, double);
 
  vtkSetMacro(Specular, double);
  vtkGetMacro(Specular, double);
 
  vtkSetMacro(Power, double);
  vtkGetMacro(Power, double);
 
 
  vtkSetMacro(Metallic, double);
  vtkGetMacro(Metallic, double);
 
 
  vtkSetMacro(Roughness, double);
  vtkGetMacro(Roughness, double);
 
  vtkSetMacro(Visibility, int);
  vtkGetMacro(Visibility, int);
  vtkBooleanMacro(Visibility, int);
  virtual bool GetVisibility(const char* viewNodeID);
 
  vtkSetMacro(Visibility2D, int);
  vtkGetMacro(Visibility2D, int);
  vtkBooleanMacro(Visibility2D, int);
 
  vtkSetMacro(Visibility3D, int);
  vtkGetMacro(Visibility3D, int);
  vtkBooleanMacro(Visibility3D, int);
 
  vtkSetMacro(EdgeVisibility, int);
  vtkBooleanMacro(EdgeVisibility, int);
  vtkGetMacro(EdgeVisibility, int);
 
  vtkSetMacro(Clipping, int);
  vtkGetMacro(Clipping, int);
  vtkBooleanMacro(Clipping, int);
 
  void SetSliceIntersectionVisibility(int on);
  int GetSliceIntersectionVisibility();
  void SliceIntersectionVisibilityOn();
  void SliceIntersectionVisibilityOff();
 
  vtkSetMacro(SliceIntersectionThickness, int);
  vtkGetMacro(SliceIntersectionThickness, int);
 
 
  vtkSetMacro(FrontfaceCulling, int);
  vtkGetMacro(FrontfaceCulling, int);
  vtkBooleanMacro(FrontfaceCulling, int);
  vtkSetMacro(BackfaceCulling, int);
  vtkGetMacro(BackfaceCulling, int);
  vtkBooleanMacro(BackfaceCulling, int);
 
  vtkSetMacro(Lighting, int);
  vtkGetMacro(Lighting, int);
  vtkBooleanMacro(Lighting, int);
 
  vtkSetMacro(Interpolation, int);
  vtkGetMacro(Interpolation, int);
 
  vtkSetMacro(Shading, int);
  vtkGetMacro(Shading, int);
 
  vtkSetMacro(ScalarVisibility, int);
  vtkGetMacro(ScalarVisibility, int);
  vtkBooleanMacro(ScalarVisibility, int);
 
  vtkSetMacro(VectorVisibility, int);
  vtkGetMacro(VectorVisibility, int);
  vtkBooleanMacro(VectorVisibility, int);
 
  vtkSetMacro(TensorVisibility, int);
  vtkGetMacro(TensorVisibility, int);
  vtkBooleanMacro(TensorVisibility, int);
 
  void SetAutoScalarRange(int b);
  int GetAutoScalarRange();
  void AutoScalarRangeOn();
  void AutoScalarRangeOff();
  virtual void UpdateAssignedAttribute() {};
  virtual void UpdateScalarRange();
 
  vtkSetVector2Macro(ScalarRange, double);
  vtkGetVector2Macro(ScalarRange, double);
 
  virtual void SetScalarRangeFlag(int flag);
  vtkGetMacro(ScalarRangeFlag, int);
  const char* GetScalarRangeFlagAsString();
  void SetScalarRangeFlagFromString(const char* str);
 
  vtkSetMacro(FolderDisplayOverrideAllowed, bool);
  vtkGetMacro(FolderDisplayOverrideAllowed, bool);
  vtkBooleanMacro(FolderDisplayOverrideAllowed, bool);
 
 
  vtkSetMacro(ShowMode, int);
  vtkGetMacro(ShowMode, int);
  bool IsShowModeDefault() { return this->GetShowMode() == vtkMRMLDisplayNode::ShowDefault; }
 
 
  static const char* GetShowModeAsString(int flag);
  static int GetShowModeFromString(const char* name);
 
  virtual void SetTextureImageDataConnection(vtkAlgorithmOutput *ImageDataConnection);
  vtkGetObjectMacro(TextureImageDataConnection, vtkAlgorithmOutput);
 
  vtkSetMacro(InterpolateTexture, int);
  vtkGetMacro(InterpolateTexture, int);
  vtkBooleanMacro(InterpolateTexture, int);
 
  virtual void SetAndObserveColorNodeID(const char *ColorNodeID);
  void SetAndObserveColorNodeID(const std::string& ColorNodeID);
  vtkGetStringMacro(ColorNodeID);
 
  virtual vtkMRMLColorNode* GetColorNode();
 
  vtkSetStringMacro(ActiveScalarName);
  vtkGetStringMacro(ActiveScalarName);
 
  vtkSetMacro(ActiveAttributeLocation, int);
  vtkGetMacro(ActiveAttributeLocation, int);
  const char* GetActiveAttributeLocationAsString();
  void SetActiveAttributeLocationFromString(const char* str);
  virtual void SetActiveScalar(const char *scalarName, int location);
 
  virtual vtkDataSet* GetScalarDataSet() { return nullptr; };
  virtual vtkDataArray* GetActiveScalarArray() { return nullptr; };
 
  void AddViewNodeID(const char* viewNodeID);
  void RemoveViewNodeID(char* viewNodeID);
  void RemoveAllViewNodeIDs();
  inline int GetNumberOfViewNodeIDs()const;
  const char* GetNthViewNodeID(unsigned int index);
  inline std::vector< std::string > GetViewNodeIDs()const;
  bool IsViewNodeIDPresent(const char* viewNodeID)const;
  bool IsDisplayableInView(const char* viewNodeID)const;
  void SetDisplayableOnlyInView(const char *viewNodeID);
  void SetViewNodeIDs(const std::vector< std::string >& viewNodeIDs);
 
  static const char* GetAttributeLocationAsString(int id);
  static int GetAttributeLocationFromString(const char* name);
 
  static std::string GetTextPropertyAsString(vtkTextProperty* property);
 
  static void UpdateTextPropertyFromString(std::string inputString, vtkTextProperty* property);
 
  virtual void SetAndObserveClipNodeID(const char* id);
  virtual vtkMRMLClipNode* GetClipNode();
  virtual const char* GetClipNodeReferenceRole() const;
 
protected:
  vtkMRMLDisplayNode();
  ~vtkMRMLDisplayNode() override;
  vtkMRMLDisplayNode(const vtkMRMLDisplayNode&);
  void operator=(const vtkMRMLDisplayNode&);
 
  virtual void SetColorNodeInternal(vtkMRMLColorNode* newColorNode);
 
  static void GetColorFromString(const std::string& colorString, double color[4]);
 
  vtkAlgorithmOutput *TextureImageDataConnection;
 
  char *ColorNodeID;
  vtkMRMLColorNode *ColorNode;
 
  char *ActiveScalarName;
  int ActiveAttributeLocation;
 
  double Opacity;
  double SliceIntersectionOpacity;
  double Ambient;
  double Diffuse;
  double Specular;
  double Power;
 
  double Metallic;
  double Roughness;
 
  double SelectedAmbient;
  double SelectedSpecular;
 
  double PointSize;
 
  double LineWidth;
 
  int Representation;
 
  int Lighting;
 
  int Interpolation;
 
  int Shading;
 
  int Visibility;
  int Visibility2D;
  int Visibility3D;
  int EdgeVisibility;
  int Clipping;
  int SliceIntersectionThickness;
  int FrontfaceCulling;
  int BackfaceCulling;
  int ScalarVisibility;
  int VectorVisibility;
  int TensorVisibility;
  int InterpolateTexture;
 
  double ScalarRange[2];
 
  double Color[3];
  double EdgeColor[3];
  double SelectedColor[3];
 
  std::vector< std::string > ViewNodeIDs;
 
  int ScalarRangeFlag;
 
  bool FolderDisplayOverrideAllowed;
 
  int ShowMode;
 
  vtkWeakPointer<vtkMRMLDisplayableNode> LastFoundDisplayableNode;
private:
  void SetColorNodeID(const char* id);
};
 
//----------------------------------------------------------------------------
int vtkMRMLDisplayNode::GetNumberOfViewNodeIDs()const
{
  return static_cast<int>(this->ViewNodeIDs.size());
}
 
//----------------------------------------------------------------------------
std::vector< std::string > vtkMRMLDisplayNode::GetViewNodeIDs()const
{
  return this->ViewNodeIDs;
}
 
#endif