mitkBaseRenderer.h

Go to the documentation of this file.

/*============================================================================
 
The Medical Imaging Interaction Toolkit (MITK)
 
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
 
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
 
============================================================================*/
 
#ifndef mitkBaseRenderer_h
#define mitkBaseRenderer_h
 
#include <mitkDataStorage.h>
#include <mitkPlaneGeometry.h>
#include <mitkPlaneGeometryData.h>
#include <mitkTimeGeometry.h>
 
#include <mitkCameraController.h>
#include <mitkCameraRotationController.h>
#include <mitkSliceNavigationController.h>
#include <mitkTimeNavigationController.h>
 
#include <mitkBindDispatcherInteractor.h>
#include <mitkDispatcher.h>
 
#include <vtkRenderWindow.h>
#include <vtkRenderer.h>
 
#include <map>
#include <set>
 
namespace mitk
{
  class Mapper;
  class BaseLocalStorageHandler;
 
#pragma GCC visibility push(default)
  itkEventMacroDeclaration(RendererResetEvent, itk::AnyEvent);
#pragma GCC visibility pop
 
  /*
   * \brief Organizes the rendering process
   *
   * A BaseRenderer contains a reference to a given vtkRenderWindow
   * and a corresponding vtkRenderer.
   * The BaseRenderer defines which mapper should be used (2D / 3D)
   * and which view direction should be rendered.
   *
   * All existing BaseRenderer are stored in a static variable
   * that can be accessed / modified via the static functions.
   * VtkPropRenderer is a concrete implementation of a BaseRenderer.
   */
  class MITKCORE_EXPORT BaseRenderer : public itk::Object
  {
  public:
 
    typedef std::map<vtkRenderWindow*, BaseRenderer*> BaseRendererMapType;
    static BaseRendererMapType baseRendererMap;
 
    enum StandardMapperSlot
    {
      Standard2D = 1,
      Standard3D = 2
    };
 
    static BaseRenderer* GetInstance(vtkRenderWindow* renderWindow);
    static void AddInstance(vtkRenderWindow* renderWindow, BaseRenderer* baseRenderer);
    static void RemoveInstance(vtkRenderWindow* renderWindow);
 
    static BaseRenderer* GetByName(const std::string& name);
    static vtkRenderWindow* GetRenderWindowByName(const std::string& name);
 
    static BaseRendererMapType GetSpecificRenderWindows(MapperSlotId mapper);
 
    static BaseRendererMapType GetAll2DRenderWindows();
 
    static BaseRendererMapType GetAll3DRenderWindows();
 
    mitkClassMacroItkParent(BaseRenderer, itk::Object);
 
    BaseRenderer(const char* name = nullptr, vtkRenderWindow* renderWindow = nullptr);
 
    void RemoveAllLocalStorages();
    void RegisterLocalStorageHandler(BaseLocalStorageHandler* lsh);
    void UnregisterLocalStorageHandler(BaseLocalStorageHandler* lsh);
 
    virtual void SetDataStorage(DataStorage* storage);
 
    virtual DataStorage::Pointer GetDataStorage() const
    {
      return m_DataStorage.GetPointer();
    }
 
    vtkRenderWindow* GetRenderWindow() const
    {
      return m_RenderWindow;
    }
 
    vtkRenderer* GetVtkRenderer() const
    {
      return m_VtkRenderer;
    }
 
    Dispatcher::Pointer GetDispatcher() const;
 
    virtual void Resize(int w, int h);
 
    virtual void InitRenderer(vtkRenderWindow* renderwindow);
 
    virtual void InitSize(int w, int h);
 
    virtual void DrawOverlayMouse(Point2D&)
    {
      MITK_INFO << "BaseRenderer::DrawOverlayMouse() should be in concret implementation OpenGLRenderer." << std::endl;
    }
 
    virtual void SetWorldTimeGeometry(const TimeGeometry* geometry);
    itkGetConstObjectMacro(WorldTimeGeometry, TimeGeometry);
 
    virtual void SetInteractionReferenceGeometry(const TimeGeometry* geometry);
 
    itkGetConstObjectMacro(InteractionReferenceGeometry, TimeGeometry);
 
    itkGetMacro(ReferenceGeometryAligned, bool);
 
    itkGetConstObjectMacro(CurrentWorldGeometry, BaseGeometry);
 
    itkGetConstObjectMacro(CurrentWorldPlaneGeometry, PlaneGeometry);
 
    virtual bool SetWorldGeometryToDataStorageBounds()
    {
      return false;
    }
 
    virtual void SetSlice(unsigned int slice);
 
    itkGetConstMacro(Slice, unsigned int);
 
    virtual void SetTimeStep(unsigned int timeStep);
 
    itkGetConstMacro(TimeStep, unsigned int);
 
    TimeStepType GetTimeStep(const BaseData* data) const;
 
    ScalarType GetTime() const;
 
    virtual void SetGeometry(const itk::EventObject& geometrySliceEvent);
 
    virtual void UpdateGeometry(const itk::EventObject& geometrySliceEvent);
 
    virtual void SetGeometrySlice(const itk::EventObject& geometrySliceEvent);
 
    virtual void SetGeometryTime(const itk::EventObject& geometryTimeEvent);
 
    itkGetObjectMacro(CurrentWorldPlaneGeometryNode, DataNode);
 
    void SendUpdateSlice();
 
    itkGetMacro(CurrentWorldPlaneGeometryUpdateTime, unsigned long);
 
    itkGetMacro(TimeStepUpdateTime, unsigned long);
 
    virtual void PickWorldPoint(const Point2D& diplayPosition, Point3D& worldPosition) const = 0;
 
    virtual DataNode* PickObject(const Point2D& /*displayPosition*/, Point3D& /*worldPosition*/) const
    {
      return nullptr;
    }
 
    itkGetMacro(MapperID, MapperSlotId);
    itkGetConstMacro(MapperID, MapperSlotId);
 
    virtual void SetMapperID(MapperSlotId id);
 
    virtual int* GetSize() const;
    virtual int* GetViewportSize() const;
 
    void SetSliceNavigationController(SliceNavigationController* SlicenavigationController);
    itkGetObjectMacro(CameraController, CameraController);
    itkGetObjectMacro(SliceNavigationController, SliceNavigationController);
    itkGetObjectMacro(CameraRotationController, CameraRotationController);
    itkGetMacro(EmptyWorldGeometry, bool);
 
    itkGetMacro(KeepDisplayedRegion, bool);
    itkSetMacro(KeepDisplayedRegion, bool);
 
    const char* GetName() const
    {
      return m_Name.c_str();
    }
 
    int GetSizeX() const
    {
      return this->GetSize()[0];
    }
 
    int GetSizeY() const
    {
      return this->GetSize()[1];
    }
 
    const double* GetBounds() const;
 
    void RequestUpdate();
    void ForceImmediateUpdate();
 
    unsigned int GetNumberOfVisibleLODEnabledMappers() const;
 
    void DisplayToWorld(const Point2D& displayPoint, Point3D& worldIndex) const;
 
    void DisplayToPlane(const Point2D& displayPoint, Point2D& planePointInMM) const;
 
    void WorldToDisplay(const Point3D& worldIndex, Point2D& displayPoint) const;
 
    void WorldToView(const Point3D& worldIndex, Point2D& viewPoint) const;
 
    void PlaneToDisplay(const Point2D& planePointInMM, Point2D& displayPoint) const;
 
    void PlaneToView(const Point2D& planePointInMM, Point2D& viewPoint) const;
 
    double GetScaleFactorMMPerDisplayUnit() const;
 
    Point2D GetDisplaySizeInMM() const;
    Point2D GetViewportSizeInMM() const;
 
    Point2D GetOriginInMM() const;
 
    itkGetConstMacro(ConstrainZoomingAndPanning, bool)
    virtual void SetConstrainZoomingAndPanning(bool constrain);
 
  protected:
 
    ~BaseRenderer() override;
 
    virtual void Update() = 0;
 
    vtkRenderWindow* m_RenderWindow;
    vtkRenderer* m_VtkRenderer;
 
    MapperSlotId m_MapperID;
    DataStorage::Pointer m_DataStorage;
    unsigned long m_LastUpdateTime;
 
    CameraController::Pointer m_CameraController;
    CameraRotationController::Pointer m_CameraRotationController;
    SliceNavigationController::Pointer m_SliceNavigationController;
 
    void UpdateCurrentGeometries();
    virtual void SetCurrentWorldPlaneGeometry(const PlaneGeometry* geometry2d);
    virtual void SetCurrentWorldGeometry(const BaseGeometry *geometry);
 
  private:
 
    TimeGeometry::ConstPointer m_WorldTimeGeometry;
 
    TimeGeometry::ConstPointer m_InteractionReferenceGeometry;
 
    BaseGeometry::ConstPointer m_CurrentWorldGeometry;
 
    PlaneGeometry::Pointer m_CurrentWorldPlaneGeometry;
 
    unsigned int m_Slice;
    unsigned int m_TimeStep;
 
    itk::TimeStamp m_CurrentWorldPlaneGeometryUpdateTime;
    itk::TimeStamp m_TimeStepUpdateTime;
 
    BindDispatcherInteractor* m_BindDispatcherInteractor;
 
    bool m_KeepDisplayedRegion;
    bool m_ReferenceGeometryAligned;
 
  protected:
 
    void PrintSelf(std::ostream& os, itk::Indent indent) const override;
 
    PlaneGeometryData::Pointer m_CurrentWorldPlaneGeometryData;
    DataNode::Pointer m_CurrentWorldPlaneGeometryNode;
    unsigned long m_CurrentWorldPlaneGeometryTransformTime;
 
    std::string m_Name;
 
    double m_Bounds[6];
 
    bool m_EmptyWorldGeometry;
 
    typedef std::set<Mapper*> LODEnabledMappersType;
 
    unsigned int m_NumberOfVisibleLODEnabledMappers;
 
    std::list<BaseLocalStorageHandler*> m_RegisteredLocalStorageHandlers;
 
    bool m_ConstrainZoomingAndPanning;
  };
} // namespace mitk
 
#endif