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.
 
==========================================================================*/
 
#ifndef __vtkMRMLModelDisplayableManager_h
#define __vtkMRMLModelDisplayableManager_h
 
// MRMLDisplayableManager includes
#include "vtkMRMLAbstractThreeDViewDisplayableManager.h"
#include "vtkMRMLDisplayableManagerExport.h"
 
// MRML includes
#include <vtkMRMLModelNode.h>
class vtkMRMLClipNode;
class vtkMRMLDisplayNode;
class vtkMRMLDisplayableNode;
class vtkMRMLTransformNode;
 
// VTK includes
#include "vtkRenderWindow.h"
class vtkActor;
class vtkAlgorithm;
class vtkCellPicker;
class vtkLookupTable;
class vtkMatrix4x4;
class vtkMapper;
class vtkPlane;
class vtkPointPicker;
class vtkProp3D;
class vtkPropPicker;
class vtkTransform;
class vtkWorldPointPicker;

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

  vtkProp3D* GetActorByID(const char* id);

  const char* GetIDByActor(vtkProp3D* actor);

  vtkWorldPointPicker* GetWorldPointPicker();

  vtkPropPicker* GetPropPicker();

  vtkCellPicker* GetCellPicker();

  vtkPointPicker* GetPointPicker();

  int Pick(int x, int y);

  int Pick3D(double ras[3]) override;

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

  const char* GetPickedNodeID() override;

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

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

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

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

  static bool IsCellScalarsActive(vtkMRMLDisplayNode* displayNode, vtkMRMLModelNode* model = nullptr);
 
protected:
  int ActiveInteractionModes() override;
 
  void UnobserveMRMLScene() override;
 
  void OnMRMLSceneStartClose() override;
  void OnMRMLSceneEndClose() override;
  void UpdateFromMRMLScene() override;
  void OnMRMLSceneNodeAdded(vtkMRMLNode* node) override;
  void OnMRMLSceneNodeRemoved(vtkMRMLNode* node) override;
 
  void OnInteractorStyleEvent(int eventId) override;
  void ProcessMRMLNodesEvents(vtkObject* caller, unsigned long event, void* callData) override;

  bool OnMRMLDisplayableModelNodeModifiedEvent(vtkMRMLDisplayableNode* modelNode);

  void UpdateFromMRML() override;
 
  void RemoveMRMLObservers() override;
 
  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* displayNode);
 
  const char* GetActiveScalarName(vtkMRMLDisplayNode* displayNode,
                                  vtkMRMLModelNode* model = nullptr);

  vtkAlgorithm* GetClipper(vtkMRMLDisplayNode* dnode,
                           vtkMRMLModelNode::MeshTypeHint type,
                           vtkImplicitFunction* clipFunction,
                           int clipMethod);
 
  void RemoveDisplayedID(const std::string& id);
  void ClearDisplayMaps();
 
  void UpdateMapperProperties(vtkMRMLModelNode* modelNode, vtkMRMLDisplayNode* displayNode,
    vtkMapper* actor);
  void UpdateActorProperties(vtkMRMLModelNode* modelNode, vtkMRMLModelDisplayNode* modelDisplayNode, vtkMRMLDisplayNode* displayNode,
    vtkActor* actor, double opacity);
  void UpdateCapActorProperties(vtkMRMLModelNode* modelNode, vtkMRMLModelDisplayNode* modelDisplayNode, vtkMRMLDisplayNode* displayNode,
    vtkActor* capActor, double opacity);
 
protected:
  vtkMRMLModelDisplayableManager();
  ~vtkMRMLModelDisplayableManager() override;
 
private:
  vtkMRMLModelDisplayableManager(const vtkMRMLModelDisplayableManager&) = delete;
  void operator=(const vtkMRMLModelDisplayableManager&) = delete;
 
  class vtkInternal;
  vtkInternal* Internal;
};
class VTK_MRML_DISPLAYABLEMANAGER_EXPORT vtkMRMLModelDisplayableManager {…};
 
#endif