vtkMRMLLayerDMPipeline.h

Go to the documentation of this file.

/*==============================================================================
 
  Program: 3D Slicer
 
  Copyright (c) Kitware SAS
 
  See COPYRIGHT.txt
  or http://www.slicer.org/copyright/copyright.txt for details.
 
  Unless required by applicable law or agreed to in writing, software
  distributed under the License is distributed on an "AS IS" BASIS,
  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  See the License for the specific language governing permissions and
  limitations under the License.
 
  This file was originally developed by Thibault Pelletier, Kitware SAS,
  and was partially funded by ANR grants ANR-22-CE45-0034 and ANR-18-RHUS-005.
 
==============================================================================*/
 
#ifndef __vtkMRMLLayerDMPipeline_h
#define __vtkMRMLLayerDMPipeline_h
 
#include "vtkSlicerLayerDMModuleMRMLDisplayableManagerExport.h"
 
// Slicer includes
#include <vtkMRMLAbstractViewNode.h>
 
// VTK includes
#include <vtkCommand.h>
#include <vtkObject.h>
 
class vtkCamera;
class vtkMRMLAbstractViewNode;
class vtkMRMLInteractionEventData;
class vtkMRMLLayerDMPipeline;
class vtkMRMLLayerDMPipelineManager;
class vtkMRMLNode;
class vtkMRMLScene;
class vtkMRMLLayerDMObjectEventObserver;
class vtkRenderer;

class VTK_SLICER_LAYERDM_MODULE_MRMLDISPLAYABLEMANAGER_EXPORT vtkMRMLLayerDMPipeline : public vtkObject
{
public:
  static vtkMRMLLayerDMPipeline* New();
  vtkTypeMacro(vtkMRMLLayerDMPipeline, vtkObject);
  void PrintSelf(ostream& os, vtkIndent indent) override;
 
  enum Events
  {
    RenderGroupingModified = vtkCommand::UserEvent + 1
  };

  virtual bool CanProcessInteractionEvent(vtkMRMLInteractionEventData* eventData, double& distance2);

  virtual vtkCamera* GetCustomCamera() const;
  virtual vtkCamera* GetCustomCamera(unsigned int renderOrder) const;

  virtual int GetMouseCursor() const;

  virtual unsigned int GetRenderOrder() const;

  virtual std::vector<unsigned int> GetRenderOrders() const;

  unsigned int GetMaxRenderOrder() const;

  unsigned int GetVtkRendererOrder(const vtkRenderer* renderer) const;

  virtual int GetWidgetState() const;

  virtual void LoseFocus(vtkMRMLInteractionEventData* eventData);

  virtual void OnDefaultCameraModified(vtkCamera* camera);

  virtual void OnReferenceToDisplayNodeAdded(vtkMRMLNode* fromNode, const std::string& role);
  virtual void OnReferenceToDisplayNodeRemoved(vtkMRMLNode* fromNode, const std::string& role);

  virtual void OnRendererAdded(vtkRenderer* renderer);

  virtual void OnRendererRemoved(vtkRenderer* renderer);

  virtual bool ProcessInteractionEvent(vtkMRMLInteractionEventData* eventData);

  virtual void SetDisplayNode(vtkMRMLNode* displayNode);

  virtual void SetPipelineManager(vtkMRMLLayerDMPipelineManager* pipelineManager);

  virtual void SetScene(vtkMRMLScene* scene);

  virtual void SetViewNode(vtkMRMLAbstractViewNode* viewNode);

  virtual void UpdateFromMRML();

  bool BlockUpdateDisplay(bool isBlocked);

  bool BlockInteractionProcessing(bool isBlocked);
  bool IsInteractionProcessingBlocked() const;

  bool BlockUpdateObserver(bool isBlocked) const;
  bool IsUpdateObserverBlocked() const;

  void SetFrozen(bool isFrozen);
  bool IsFrozen() const;

  vtkMRMLNode* GetDisplayNode() const;

  vtkMRMLLayerDMPipeline* GetNodePipeline(vtkMRMLNode* node) const;

  vtkMRMLLayerDMPipelineManager* GetPipelineManager() const;

  vtkRenderer* GetRenderer() const;

  vtkRenderer* GetRenderer(unsigned int renderOrder) const;

  std::vector<vtkRenderer*> GetRenderers() const;

  vtkMRMLScene* GetScene() const;

  vtkMRMLAbstractViewNode* GetViewNode() const;

  bool UpdateObservation(vtkObject* prevObj, vtkObject* obj, const std::vector<unsigned long>& events) const;
  bool UpdateObservation(vtkObject* prevObj, vtkObject* obj, unsigned long event = vtkCommand::ModifiedEvent) const;

  void RemoveObservations(vtkObject* prevObj) const;

  void RequestRender() const;

  void UpdateDisplay();

  void SetRenderers(const std::vector<vtkRenderer*>& renderers, const std::vector<unsigned int>& renderOrders);

  void SetRenderer(vtkRenderer* renderer);
 
protected:
  vtkMRMLLayerDMPipeline();
  ~vtkMRMLLayerDMPipeline() override = default;

  virtual void OnUpdate(vtkObject* obj, unsigned long eventId, void* callData);
 
private:
  bool RenderersMatchPipelineRenderers(const std::vector<vtkRenderer*>& renderers, const std::vector<unsigned int>& renderOrders);
 
  vtkWeakPointer<vtkMRMLAbstractViewNode> ViewNode;
  vtkWeakPointer<vtkMRMLNode> DisplayNode;
  std::map<unsigned int, vtkWeakPointer<vtkRenderer>> RenderersMap;
  bool IsUpdateDisplayBlocked;
  bool Frozen;
  bool InteractionProcessingBlocked;
  vtkSmartPointer<vtkMRMLLayerDMObjectEventObserver> Observer;
  vtkWeakPointer<vtkMRMLLayerDMPipelineManager> PipelineManager;
  vtkWeakPointer<vtkMRMLScene> Scene;
};
 
#endif