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