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

  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;
};
class VTK_MRML_EXPORT vtkMRMLModelNode : public vtkMRMLDisplayableNode {…};
 
#endif