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 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) VTK_OVERRIDE;

  //--------------------------------------------------------------------------
  //--------------------------------------------------------------------------

  virtual vtkMRMLNode* CreateNodeInstance() VTK_OVERRIDE;

  virtual const char* GetNodeTagName() VTK_OVERRIDE {return "Model";};

  virtual void Copy(vtkMRMLNode *node) VTK_OVERRIDE;

  virtual void ProcessMRMLEvents ( vtkObject * /*caller*/,
                                   unsigned long /*event*/,
                                   void * /*callData*/ ) VTK_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();

  typedef enum {
    PolyDataMeshType = 0,
    UnstructuredGridMeshType
  } 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);

  virtual void GetRASBounds(double bounds[6]) VTK_OVERRIDE;

  virtual void GetBounds(double bounds[6]) VTK_OVERRIDE;

  virtual void TransformBoundsToRAS(double inputBounds_Local[6], double outputBounds_RAS[6]);

  virtual bool CanApplyNonLinearTransforms()const VTK_OVERRIDE;
  virtual void ApplyTransform(vtkAbstractTransform* transform) VTK_OVERRIDE;

  virtual vtkMRMLStorageNode* CreateDefaultStorageNode() VTK_OVERRIDE;

  virtual std::string GetDefaultStorageNodeClassName(const char* filename /* =NULL */) VTK_OVERRIDE;

  virtual void CreateDefaultDisplayNodes() VTK_OVERRIDE;

  virtual bool GetModifiedSinceRead() VTK_OVERRIDE;

protected:
  vtkMRMLModelNode();
  ~vtkMRMLModelNode();
  vtkMRMLModelNode(const vtkMRMLModelNode&);
  void operator=(const vtkMRMLModelNode&);

  virtual void SetMeshConnection(vtkAlgorithmOutput *inputPort);

  virtual void UpdateDisplayNodeMesh(vtkMRMLDisplayNode *dnode);

  virtual void OnNodeReferenceAdded(vtkMRMLNodeReference *reference) VTK_OVERRIDE;

  virtual void OnNodeReferenceModified(vtkMRMLNodeReference *reference) VTK_OVERRIDE;


  void SetMeshToDisplayNodes();

  virtual void SetMeshToDisplayNode(vtkMRMLModelDisplayNode* modelDisplayNode);

  vtkAlgorithmOutput* MeshConnection;
  vtkEventForwarderCommand* DataEventForwarder;
  MeshTypeHint MeshType;
};

#endif