vtkMRMLLayerDMLayerManager.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 __vtkMRMLLayerDMLayerManager_h
#define __vtkMRMLLayerDMLayerManager_h
 
#include "vtkSlicerLayerDMModuleMRMLDisplayableManagerExport.h"
 
#include "vtkMRMLLayerDMPipeline.h"
 
// VTK includes
#include <vtkObject.h>
#include <vtkSmartPointer.h>
#include <vtkWeakPointer.h>
 
// STL includes
#include <array>
#include <cstdint>
#include <map>
#include <set>
#include <vector>
 
class vtkMRMLLayerDMPipeline;
class vtkRenderWindow;
class vtkRenderer;
class vtkCamera;
class vtkMRMLLayerDMObjectEventObserver;

class VTK_SLICER_LAYERDM_MODULE_MRMLDISPLAYABLEMANAGER_EXPORT vtkMRMLLayerDMLayerManager : public vtkObject
{
public:
  using LayerKey = std::tuple<unsigned int, std::uintptr_t>;
 
  static vtkMRMLLayerDMLayerManager* New();
  vtkTypeMacro(vtkMRMLLayerDMLayerManager, vtkObject);
  void PrintSelf(ostream& os, vtkIndent indent) override;

  void AddPipeline(vtkMRMLLayerDMPipeline* pipeline);
 
  int GetNumberOfDistinctLayers() const;
  int GetNumberOfManagedLayers() const;

  int GetNumberOfRenderers() const;

  void RemovePipeline(vtkMRMLLayerDMPipeline* pipeline);

  void ResetCameraClippingRange() const;

  void SetRenderWindow(vtkRenderWindow* renderWindow);

  void SetDefaultCamera(const vtkSmartPointer<vtkCamera>& camera);
 
protected:
  vtkMRMLLayerDMLayerManager();
  ~vtkMRMLLayerDMLayerManager() override;
 
private:
  vtkRenderer* GetRendererMatchingKey(const LayerKey& key);
  vtkRenderer* GetDefaultRenderer() const;
 
  void AddMissingLayers();
  static std::array<double, 6> ComputeRenderersVisibleBounds(const std::vector<vtkWeakPointer<vtkRenderer>>& renderers);
  bool ContainsLayerKey(const LayerKey& key);
  static std::uintptr_t GetCameraId(vtkCamera* camera);
  vtkCamera* GetCameraForLayer(const LayerKey& key, const std::set<vtkMRMLLayerDMPipeline*>& pipelines) const;
  int GetKeyIndex(const LayerKey& key) const;
  void RemoveAllLayers();
  void RemoveAllPipelineRenderers();
  static void RemovePipelineRenderer(vtkMRMLLayerDMPipeline* pipeline);
  void RemoveOutdatedLayers();
  void RemoveOutdatedPipelines();
  void RemoveRenderer(const vtkSmartPointer<vtkRenderer>& renderer);
  static void ResetRenderersCameraClippingRange(const std::vector<vtkWeakPointer<vtkRenderer>>& renderers, const std::array<double, 6>& bounds);
  void SynchronizePipelineRenderers();
  void UpdateRenderWindowNumberOfLayers() const;
  void UpdateLayers();
  void UpdateRendererLayerOrdering() const;
  void UpdateRendererCamera();
 
  bool AddPipelineLayers(vtkMRMLLayerDMPipeline* pipeline);
  void RemovePipelineLayers(vtkMRMLLayerDMPipeline* pipeline);
 
  // Map of pipeline layers ordered by ascending <layer value, camera synchronization mode>
  std::map<LayerKey, std::set<vtkMRMLLayerDMPipeline*>> PipelineLayers;
 
  // Pipeline observer listening for \sa vtkMRMLLayerDMPipeline::RenderGroupingModified events and pipeline
  // destruction.
  vtkSmartPointer<vtkMRMLLayerDMObjectEventObserver> Observer;
 
  // Placeholder empty pipeline with target layer = 0 and camera sync to layer 0 for default renderer
  vtkSmartPointer<vtkMRMLLayerDMPipeline> EmptyPipeline;
 
  // Pointer to the current render window
  vtkWeakPointer<vtkRenderWindow> RenderWindow;
 
  // Pointer to the default camera
  vtkSmartPointer<vtkCamera> DefaultCamera;
 
  // Renderers managed by the layer manager
  std::vector<vtkSmartPointer<vtkRenderer>> Renderers;
 
  // Camera to renderer map grouped by the camera they are synchronized on.
  std::map<std::uintptr_t, std::vector<vtkWeakPointer<vtkRenderer>>> CameraRendererMap;
};
 
#endif