vtkMRMLModelNode.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: vtkMRMLModelNode.h,v $
  Date:      $Date: 2006/03/19 17:12:28 $
  Version:   $Revision: 1.6 $
 
=========================================================================auto=*/
 
#ifndef __vtkMRMLModelNode_h
#define __vtkMRMLModelNode_h
 
// MRML includes
#include "vtkMRMLDisplayableNode.h"
class vtkMRMLModelDisplayNode;
class vtkMRMLStorageNode;
 
// VTK includes
class vtkAlgorithmOutput;
class vtkAssignAttributes;
class vtkEventForwarderCommand;
class vtkDataArray;
class vtkImplicitPolyDataDistance;
class vtkPointSet;
class vtkPolyData;
class vtkTransformFilter;
class vtkUnstructuredGrid;
class vtkMRMLDisplayNode;
 
class VTK_MRML_EXPORT vtkMRMLModelNode : public vtkMRMLDisplayableNode
{
public:
  static vtkMRMLModelNode *New();
  vtkTypeMacro(vtkMRMLModelNode,vtkMRMLDisplayableNode);
  void PrintSelf(ostream& os, vtkIndent indent) override;
 
  //--------------------------------------------------------------------------
  //--------------------------------------------------------------------------
 
  vtkMRMLNode* CreateNodeInstance() override;
 
  const char* GetNodeTagName() override {return "Model";};
 
  vtkMRMLCopyContentMacro(vtkMRMLModelNode);
 
  void ProcessMRMLEvents ( vtkObject * /*caller*/,
                                   unsigned long /*event*/,
                                   void * /*callData*/ ) override;
 
  vtkMRMLModelDisplayNode* GetModelDisplayNode();
 
  virtual void SetAndObserveMesh(vtkPointSet *Mesh);
 
  virtual void SetAndObservePolyData(vtkPolyData *polyData);
 
  virtual vtkPointSet* GetMesh();
 
  virtual vtkPolyData* GetPolyData();
 
  virtual vtkUnstructuredGrid* GetUnstructuredGrid();
 
  virtual void SetPolyDataConnection(vtkAlgorithmOutput *inputPort);
 
  virtual void SetUnstructuredGridConnection(vtkAlgorithmOutput *inputPort);
 
  vtkGetObjectMacro(MeshConnection,vtkAlgorithmOutput);
 
  virtual vtkAlgorithmOutput* GetPolyDataConnection();
 
  virtual vtkAlgorithmOutput* GetUnstructuredGridConnection();
 
  enum MeshTypeHint
  {
    PolyDataMeshType = 0,
    UnstructuredGridMeshType
  };
 
  vtkGetMacro(MeshType, MeshTypeHint);
 
  enum
  {
    MeshModifiedEvent = 17001,
    PolyDataModifiedEvent = 17001 
  };
 
  void AddPointScalars(vtkDataArray *array);
 
  void AddCellScalars(vtkDataArray *array);
 
  void AddScalars(vtkDataArray *array, int location);
 
  void RemoveScalars(const char *scalarName);
 
  bool HasPointScalarName(const char* scalarName);
 
  bool HasCellScalarName(const char* scalarName);
 
  int SetActivePointScalars(const char *scalarName, int attributeType);
 
  const char *GetActivePointScalarName(int type);
 
  int SetActiveCellScalars(const char *scalarName, int attributeType);
 
  const char *GetActiveCellScalarName(int type);
 
  static int GetAttributeTypeFromString(const char* typeName);
 
  int CompositeScalars(const char* backgroundName, const char* overlayName,
                       float overlayMin, float overlayMax,
                       int showOverlayPositive, int showOverlayNegative,
                       int reverseOverlay);
 
  void GetRASBounds(double bounds[6]) override;
 
  void GetBounds(double bounds[6]) override;
 
  virtual void TransformBoundsToRAS(double inputBounds_Local[6], double outputBounds_RAS[6]);
 
  bool CanApplyNonLinearTransforms()const override;
  void ApplyTransform(vtkAbstractTransform* transform) override;
 
  vtkMRMLStorageNode* CreateDefaultStorageNode() override;
 
  std::string GetDefaultStorageNodeClassName(const char* filename /* =nullptr */) override;
 
  void CreateDefaultDisplayNodes() override;
 
  bool GetModifiedSinceRead() override;
 
  bool ShowDefaultScalarData();
 
  vtkImplicitFunction* GetImplicitFunctionWorld() override;
 
protected:
  vtkMRMLModelNode();
  ~vtkMRMLModelNode() override;
  vtkMRMLModelNode(const vtkMRMLModelNode&);
  void operator=(const vtkMRMLModelNode&);
 
  virtual void SetMeshConnection(vtkAlgorithmOutput *inputPort);
 
  virtual void UpdateDisplayNodeMesh(vtkMRMLDisplayNode *dnode);
 
  void OnNodeReferenceAdded(vtkMRMLNodeReference *reference) override;
 
  void OnNodeReferenceModified(vtkMRMLNodeReference *reference) override;
 
 
  void SetMeshToDisplayNodes();
 
  virtual void SetMeshToDisplayNode(vtkMRMLModelDisplayNode* modelDisplayNode);
 
  void UpdateImplicitDistanceFunction();
 
  vtkAlgorithmOutput* MeshConnection;
  vtkEventForwarderCommand* DataEventForwarder;
  MeshTypeHint MeshType;
 
  vtkSmartPointer<vtkTransformFilter> PolyDataLocalToWorldTransformFilter;
  vtkSmartPointer<vtkImplicitPolyDataDistance> ImplicitPolyDataDistanceWorld;
};
 
#endif