vtkMRMLModelDisplayNode.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: vtkMRMLModelDisplayNode.h,v $
  Date:      $Date: 2006/03/19 17:12:28 $
  Version:   $Revision: 1.6 $
 
=========================================================================auto=*/
 
#ifndef __vtkMRMLModelDisplayNode_h
#define __vtkMRMLModelDisplayNode_h
 
// MRML includes
#include "vtkMRMLDisplayNode.h"
 
// VTK includes
class vtkAlgorithm;
class vtkAlgorithmOutput;
class vtkAssignAttribute;
class vtkGeometryFilter;
class vtkThreshold;
class vtkPassThrough;
class vtkPointSet;
class vtkPolyData;
class vtkStaticCleanUnstructuredGrid;
class vtkUnstructuredGrid;

class VTK_MRML_EXPORT vtkMRMLModelDisplayNode : public vtkMRMLDisplayNode
{
public:
  static vtkMRMLModelDisplayNode* New();
  vtkTypeMacro(vtkMRMLModelDisplayNode, vtkMRMLDisplayNode);
  void PrintSelf(ostream& os, vtkIndent indent) override;
 
  enum SliceDisplayModeType
  {
    SliceDisplayIntersection,              
    SliceDisplayProjection,                
    SliceDisplayDistanceEncodedProjection, 
    SliceDisplayMode_Last                  // placeholder after the last valid value, this must be the last in the list of modes
  };

  void ReadXMLAttributes(const char** atts) override;

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

  vtkMRMLCopyContentMacro(vtkMRMLModelDisplayNode);
 
  vtkMRMLNode* CreateNodeInstance() override;

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

  virtual void SetInputMeshConnection(vtkAlgorithmOutput* meshConnection);
  virtual void SetInputPolyDataConnection(vtkAlgorithmOutput* polyDataConnection);

  virtual vtkAlgorithmOutput* GetInputMeshConnection();
  virtual vtkAlgorithmOutput* GetInputPolyDataConnection();

  virtual vtkPointSet* GetInputMesh();
  virtual vtkPolyData* GetInputPolyData();
  virtual vtkUnstructuredGrid* GetInputUnstructuredGrid();

  virtual vtkPointSet* GetOutputMesh();
  virtual vtkPolyData* GetOutputPolyData();
  virtual vtkUnstructuredGrid* GetOutputUnstructuredGrid();

  virtual vtkAlgorithmOutput* GetOutputMeshConnection();
  virtual vtkAlgorithmOutput* GetOutputPolyDataConnection(); 

  void SetActiveScalarName(const char* scalarName) override;

  void SetActiveAttributeLocation(int location) override;

  void SetThresholdEnabled(bool enabled);
  vtkBooleanMacro(ThresholdEnabled, bool);

  vtkGetMacro(ThresholdEnabled, bool);

  void SetThresholdRange(double min, double max);
  void SetThresholdRange(double range[2]);

  void GetThresholdRange(double range[2]);
  double* GetThresholdRange() VTK_SIZEHINT(2);
  double GetThresholdMin();
  double GetThresholdMax();

  void SetMergeCoincidentPoints(bool merge);
  vtkGetMacro(MergeCoincidentPoints, bool);
  vtkBooleanMacro(MergeCoincidentPoints, bool);

  vtkGetMacro(SliceDisplayMode, int);
  vtkSetMacro(SliceDisplayMode, int);
  void SetSliceDisplayModeToIntersection();
  void SetSliceDisplayModeToProjection();
  void SetSliceDisplayModeToDistanceEncodedProjection();

  static const char* GetSliceDisplayModeAsString(int id);
  static int GetSliceDisplayModeFromString(const char* name);

  virtual void SetAndObserveDistanceEncodedProjectionColorNodeID(const char* colorNodeID);
  virtual const char* GetDistanceEncodedProjectionColorNodeID();
  virtual vtkMRMLColorNode* GetDistanceEncodedProjectionColorNode();

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

  vtkSetVector3Macro(BackfaceColorHSVOffset, double);
  vtkGetVector3Macro(BackfaceColorHSVOffset, double);
 
  vtkSetMacro(ClippingCapSurface, bool);
  vtkGetMacro(ClippingCapSurface, bool);
  vtkBooleanMacro(ClippingCapSurface, bool);
 
  vtkSetMacro(ClippingOutline, bool);
  vtkGetMacro(ClippingOutline, bool);
  vtkBooleanMacro(ClippingOutline, bool);
 
  vtkSetMacro(ClippingCapOpacity, double);
  vtkGetMacro(ClippingCapOpacity, double);
 
  vtkSetVector3Macro(ClippingCapColorHSVOffset, double);
  vtkGetVector3Macro(ClippingCapColorHSVOffset, double);
 
protected:
  vtkMRMLModelDisplayNode();
  ~vtkMRMLModelDisplayNode() override;
  vtkMRMLModelDisplayNode(const vtkMRMLModelDisplayNode&);
  void operator=(const vtkMRMLModelDisplayNode&);
 
  void ProcessMRMLEvents(vtkObject* caller, unsigned long event, void* callData) override;

  virtual void SetInputToMeshPipeline(vtkAlgorithmOutput* meshConnection);

  virtual void UpdateAssignedAttribute() override;

  void UpdateThresholdComponent();

  vtkAssignAttribute* AssignAttribute;

  vtkPassThrough* PassThrough;

  vtkThreshold* ThresholdFilter;

  vtkGeometryFilter* ConvertToPolyDataFilter;

  vtkStaticCleanUnstructuredGrid* MergeCoincidentPointsFilter;

  bool ThresholdEnabled;
 
  int SliceDisplayMode;
 
  bool MergeCoincidentPoints{ true };

  double ThresholdRangeTemp[2];
 
  double BackfaceColorHSVOffset[3];
 
  bool ClippingCapSurface{ false };
  double ClippingCapOpacity{ 1.0 };
  bool ClippingOutline{ false };
  double ClippingCapColorHSVOffset[3];
};
 
#endif