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

  enum InterpolationType
  {
    FlatInterpolation = 0,
    GouraudInterpolation,
    PhongInterpolation,
    PBRInterpolation
  };
  enum InterpolationType {…};

  enum ScalarRangeFlagType
  {
    UseManualScalarRange = 0,
    UseDataScalarRange,
    UseColorNodeScalarRange,
    UseDataTypeScalarRange,
    UseDirectMapping,
    // insert types above this line
    NUM_SCALAR_RANGE_FLAGS
  };
  enum ScalarRangeFlagType {…};

  enum ShowModeType
  {
    ShowDefault = 0, 
    ShowIgnore, 
    ShowMode_Last
  };
  enum ShowModeType {…};
 
  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);
};
class VTK_MRML_EXPORT vtkMRMLDisplayNode : public vtkMRMLNode {…};
 
//----------------------------------------------------------------------------
int vtkMRMLDisplayNode::GetNumberOfViewNodeIDs()const
{
  return static_cast<int>(this->ViewNodeIDs.size());
}
int vtkMRMLDisplayNode::GetNumberOfViewNodeIDs()const {…}
 
//----------------------------------------------------------------------------
std::vector< std::string > vtkMRMLDisplayNode::GetViewNodeIDs()const
{
  return this->ViewNodeIDs;
}
std::vector< std::string > vtkMRMLDisplayNode::GetViewNodeIDs()const {…}
 
#endif