vtkMRMLModelDisplayableManager.h

Go to the documentation of this file.

/*=========================================================================

  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:   SlicerViewerWidget
  Module:    $HeadURL: http://svn.slicer.org/Slicer4/trunk/Base/GUI/vtkMRMLModelDisplayableManager.h $
  Date:      $Date: 2010-05-12 08:34:19 -0400 (Wed, 12 May 2010) $
  Version:   $Revision: 13332 $

==========================================================================*/

#ifndef __vtkMRMLModelDisplayableManager_h
#define __vtkMRMLModelDisplayableManager_h

// MRMLDisplayableManager includes
#include "vtkMRMLAbstractThreeDViewDisplayableManager.h"
#include "vtkMRMLDisplayableManagerExport.h"

// MRMLLogic includes
#include "vtkMRMLModelHierarchyLogic.h"

// MRML includes
#include <vtkMRMLModelNode.h>
class vtkMRMLClipModelsNode;
class vtkMRMLDisplayNode;
class vtkMRMLDisplayableNode;
class vtkMRMLModelHierarchyLogic;
class vtkMRMLModelHierarchyNode;
class vtkMRMLSelectionNode;
class vtkMRMLTransformNode;

// VTK includes
#include "vtkRenderWindow.h"
class vtkActor;
class vtkActorText;
class vtkAlgorithm;
class vtkBoundingBox;
class vtkCellArray;
class vtkCellPicker;
class vtkClipPolyData;
class vtkFollower;
class vtkImplicitBoolean;
class vtkLookupTable;
class vtkMatrix4x4;
class vtkPMatrix4x4;
class vtkPlane;
class vtkPlane;
class vtkPointPicker;
class vtkPolyData;
class vtkProp3D;
class vtkPropPicker;
class vtkWorldPointPicker;

class VTK_MRML_DISPLAYABLEMANAGER_EXPORT vtkMRMLModelDisplayableManager
  : public vtkMRMLAbstractThreeDViewDisplayableManager
{
public:
  static vtkMRMLModelDisplayableManager* New();
  vtkTypeMacro(vtkMRMLModelDisplayableManager,vtkMRMLAbstractThreeDViewDisplayableManager);
  void PrintSelf(ostream& os, vtkIndent indent) VTK_OVERRIDE;

  vtkMRMLClipModelsNode* GetClipModelsNode();
  void SetClipModelsNode(vtkMRMLClipModelsNode *snode);

  vtkProp3D *GetActorByID(const char *id);

  const char *GetIDByActor(vtkProp3D *actor);

  vtkWorldPointPicker* GetWorldPointPicker();

  vtkPropPicker* GetPropPicker();

  vtkCellPicker* GetCellPicker();

  vtkPointPicker* GetPointPicker();

  int Pick(int x, int y);

  double GetPickTolerance();
  void SetPickTolerance(double tolerance);

  const char *GetPickedNodeID();

  double* GetPickedRAS();
  void SetPickedRAS(double* newPickedRAS);

  vtkIdType GetPickedCellID();
  void SetPickedCellID(vtkIdType newCellID);

  vtkIdType GetPickedPointID();
  void SetPickedPointID(vtkIdType newPointID);

  vtkMRMLModelHierarchyLogic* GetModelHierarchyLogic();

  void SetClipPlaneFromMatrix(vtkMatrix4x4 *sliceMatrix,
                             int planeDirection,
                             vtkPlane *plane);

  bool IsModelDisplayable(vtkMRMLDisplayableNode* node)const;
  bool IsModelDisplayable(vtkMRMLDisplayNode* node)const;

  static vtkLookupTable* CreateLookupTableCopy(vtkLookupTable* source);

  static bool IsCellScalarsActive(vtkMRMLDisplayNode* displayNode,
    vtkMRMLModelNode* model = 0);

protected:

  vtkMRMLModelDisplayableManager();
  virtual ~vtkMRMLModelDisplayableManager();

  virtual void AdditionalInitializeStep() VTK_OVERRIDE;
  virtual int ActiveInteractionModes() VTK_OVERRIDE;

  virtual void UnobserveMRMLScene() VTK_OVERRIDE;

  virtual void OnMRMLSceneStartClose() VTK_OVERRIDE;
  virtual void OnMRMLSceneEndClose() VTK_OVERRIDE;
  virtual void UpdateFromMRMLScene() VTK_OVERRIDE;
  virtual void OnMRMLSceneNodeAdded(vtkMRMLNode* node) VTK_OVERRIDE;
  virtual void OnMRMLSceneNodeRemoved(vtkMRMLNode* node) VTK_OVERRIDE;

  virtual void OnInteractorStyleEvent(int eventId) VTK_OVERRIDE;
  virtual void ProcessMRMLNodesEvents(vtkObject *caller, unsigned long event, void *callData) VTK_OVERRIDE;

  bool OnMRMLDisplayableModelNodeModifiedEvent(vtkMRMLDisplayableNode * modelNode);

  virtual void UpdateFromMRML() VTK_OVERRIDE;

  virtual void RemoveMRMLObservers() VTK_OVERRIDE;

  friend class vtkThreeDViewInteractorStyle; // Access to RequestRender();

  void RemoveModelProps();
  void RemoveModelObservers(int clearCache);
  void RemoveDisplayable(vtkMRMLDisplayableNode* model);
  void RemoveDisplayableNodeObservers(vtkMRMLDisplayableNode *model);

  void UpdateModelsFromMRML();
  void UpdateModel(vtkMRMLDisplayableNode *model);
  void UpdateModelMesh(vtkMRMLDisplayableNode *model);
  void UpdateModifiedModel(vtkMRMLDisplayableNode *model);

  void SetModelDisplayProperty(vtkMRMLDisplayableNode *model);
  int GetDisplayedModelsVisibility(vtkMRMLDisplayNode *model);

  const char* GetActiveScalarName(vtkMRMLDisplayNode* displayNode,
                                  vtkMRMLModelNode* model = 0);

  int UpdateClipSlicesFromMRML();
  vtkAlgorithm *CreateTransformedClipper(vtkMRMLTransformNode *tnode,
                                         vtkMRMLModelNode::MeshTypeHint type);

  void AddHierarchyObservers();
  void RemoveHierarchyObservers(int clearCache);

  void CheckModelHierarchies();
  void UpdateModelHierarchies();
  void UpdateModelHierarchyVisibility(vtkMRMLModelHierarchyNode* mhnode, int visibility );
  void UpdateModelHierarchyDisplay(vtkMRMLDisplayableNode *model);

  vtkMRMLDisplayNode*  GetHierarchyDisplayNode(vtkMRMLDisplayableNode *model);

  void RemoveDispalyedID(std::string &id);

  vtkMRMLSelectionNode* GetSelectionNode();

private:

  vtkMRMLModelDisplayableManager(const vtkMRMLModelDisplayableManager&); // Not implemented
  void operator=(const vtkMRMLModelDisplayableManager&);                 // Not Implemented

  class vtkInternal;
  vtkInternal* Internal;
};

#endif