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