mitkRenderingManager.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 mitkRenderingManager_h
#define mitkRenderingManager_h
 
#include <MitkCoreExports.h>
 
#include <vtkCallbackCommand.h>
 
#include <itkObject.h>
#include <itkObjectFactory.h>
 
#include <mitkProperties.h>
#include <mitkPropertyList.h>
#include <mitkTimeGeometry.h>
#include <mitkAntiAliasing.h>
 
class vtkRenderWindow;
class vtkObject;
 
namespace mitk
{
  class RenderingManagerFactory;
  class BaseGeometry;
  class SliceNavigationController;
  class BaseRenderer;
  class DataStorage;
 
  class MITKCORE_EXPORT RenderingManager : public itk::Object
  {
  public:
    mitkClassMacroItkParent(RenderingManager, itk::Object);
 
    typedef std::vector<vtkRenderWindow *> RenderWindowVector;
    typedef std::vector<float> FloatVector;
    typedef std::vector<bool> BoolVector;
 
    typedef itk::SmartPointer<DataStorage> DataStoragePointer;
 
    enum RequestType
    {
      REQUEST_UPDATE_ALL = 0,
      REQUEST_UPDATE_2DWINDOWS,
      REQUEST_UPDATE_3DWINDOWS
    };
 
    static Pointer New();
 
    static void SetFactory(RenderingManagerFactory *factory);
 
    static const RenderingManagerFactory *GetFactory();
 
    static bool HasFactory();
 
    static RenderingManager *GetInstance();
 
    static bool IsInstantiated();
 
    void AddRenderWindow(vtkRenderWindow *renderWindow);
 
    void RemoveRenderWindow(vtkRenderWindow *renderWindow);
 
    const RenderWindowVector &GetAllRegisteredRenderWindows();
 
    void RequestUpdate(vtkRenderWindow *renderWindow);
 
    void ForceImmediateUpdate(vtkRenderWindow *renderWindow);
 
    void RequestUpdateAll(RequestType type = REQUEST_UPDATE_ALL);
 
    void ForceImmediateUpdateAll(RequestType type = REQUEST_UPDATE_ALL);
 
    virtual void InitializeViewsByBoundingObjects(const DataStorage* dataStorage);
 
    virtual void InitializeViewByBoundingObjects(vtkRenderWindow* renderWindow,
                                                 const DataStorage* dataStorage,
                                                 bool resetCamera = true);
 
    virtual bool InitializeViews(const BaseGeometry *geometry,
                                 RequestType type = REQUEST_UPDATE_ALL,
                                 bool resetCamera = true);
 
    virtual bool InitializeViews(const TimeGeometry *geometry,
                                 RequestType type = REQUEST_UPDATE_ALL,
                                 bool resetCamera = true);
 
    virtual bool InitializeViews(RequestType type = REQUEST_UPDATE_ALL);
 
    virtual bool InitializeView(vtkRenderWindow *renderWindow,
                                const BaseGeometry *geometry,
                                bool resetCamera = true);
 
    virtual bool InitializeView(vtkRenderWindow *renderWindow,
                                const TimeGeometry *geometry,
                                bool resetCamera = true);
 
    virtual bool InitializeView(vtkRenderWindow *renderWindow);
 
    const SliceNavigationController *GetTimeNavigationController() const;
 
    SliceNavigationController *GetTimeNavigationController();
 
    ~RenderingManager() override;
 
    virtual void ExecutePendingRequests();
 
    bool IsRendering() const;
    void AbortRendering();
 
    itkSetMacro(LODIncreaseBlocked, bool);
 
    itkGetMacro(LODIncreaseBlocked, bool);
 
    itkBooleanMacro(LODIncreaseBlocked);
 
    itkSetMacro(LODAbortMechanismEnabled, bool);
 
    itkGetMacro(LODAbortMechanismEnabled, bool);
 
    itkBooleanMacro(LODAbortMechanismEnabled);
 
    virtual void StartOrResetTimer(){};
 
    void ExecutePendingHighResRenderingRequest();
 
    virtual void DoStartRendering(){};
    virtual void DoMonitorRendering(){};
    virtual void DoFinishAbortRendering(){};
 
    int GetNextLOD(BaseRenderer *renderer);
 
    void SetMaximumLOD(unsigned int max);
 
    void SetShading(bool state, unsigned int lod);
    bool GetShading(unsigned int lod);
 
    void SetClippingPlaneStatus(bool status);
    bool GetClippingPlaneStatus();
 
    void SetShadingValues(float ambient, float diffuse, float specular, float specpower);
 
    FloatVector &GetShadingValues();
 
    PropertyList::Pointer GetPropertyList() const;
 
    BaseProperty *GetProperty(const char *propertyKey) const;
 
    void SetProperty(const char *propertyKey, BaseProperty *propertyValue);
 
    void SetDataStorage(DataStorage *storage);
 
    itkGetMacro(DataStorage, DataStorage*);
    itkGetConstMacro(DataStorage, DataStorage*);
 
    void SetRenderWindowFocus(vtkRenderWindow *focusWindow);
    itkGetMacro(FocusedRenderWindow, vtkRenderWindow *);
 
    itkSetMacro(ConstrainedPanningZooming, bool);
    itkGetConstMacro(ConstrainedPanningZooming, bool);
 
    void SetAntiAliasing(AntiAliasing antiAliasing);
    itkGetConstMacro(AntiAliasing, AntiAliasing);
 
  protected:
    enum
    {
      RENDERING_INACTIVE = 0,
      RENDERING_REQUESTED,
      RENDERING_INPROGRESS
    };
 
    RenderingManager();
 
    virtual void GenerateRenderingRequestEvent() = 0;
 
    virtual void InitializePropertyList();
 
    bool m_UpdatePending;
 
    typedef std::map<BaseRenderer *, unsigned int> RendererIntMap;
    typedef std::map<BaseRenderer *, bool> RendererBoolMap;
 
    RendererBoolMap m_RenderingAbortedMap;
 
    RendererIntMap m_NextLODMap;
 
    unsigned int m_MaxLOD;
 
    bool m_LODIncreaseBlocked;
 
    bool m_LODAbortMechanismEnabled;
 
    BoolVector m_ShadingEnabled;
 
    bool m_ClippingPlaneEnabled;
 
    FloatVector m_ShadingValues;
 
    static void RenderingStartCallback(vtkObject *caller, unsigned long eid, void *clientdata, void *calldata);
    static void RenderingProgressCallback(vtkObject *caller, unsigned long eid, void *clientdata, void *calldata);
    static void RenderingEndCallback(vtkObject *caller, unsigned long eid, void *clientdata, void *calldata);
 
    typedef std::map<vtkRenderWindow *, int> RenderWindowList;
 
    RenderWindowList m_RenderWindowList;
    RenderWindowVector m_AllRenderWindows;
 
    struct RenderWindowCallbacks
    {
      vtkCallbackCommand *commands[3u];
    };
 
    typedef std::map<vtkRenderWindow *, RenderWindowCallbacks> RenderWindowCallbacksList;
 
    RenderWindowCallbacksList m_RenderWindowCallbacksList;
 
    itk::SmartPointer<SliceNavigationController> m_TimeNavigationController;
 
    static RenderingManager::Pointer s_Instance;
    static RenderingManagerFactory *s_RenderingManagerFactory;
 
    PropertyList::Pointer m_PropertyList;
 
    DataStoragePointer m_DataStorage;
 
    bool m_ConstrainedPanningZooming;
 
  private:
 
    void InternalViewInitialization(BaseRenderer *baseRenderer,
                                    const TimeGeometry *geometry,
                                    bool boundingBoxInitialized,
                                    int mapperID,
                                    bool resetCamera);
 
    bool ExtendGeometryForBoundingBox(const TimeGeometry* originalGeometry, TimeGeometry::Pointer& modifiedGeometry);
 
    vtkRenderWindow *m_FocusedRenderWindow;
    AntiAliasing m_AntiAliasing;
  };
 
#pragma GCC visibility push(default)
 
  itkEventMacroDeclaration(RenderingManagerEvent, itk::AnyEvent);
  itkEventMacroDeclaration(RenderingManagerViewsInitializedEvent, RenderingManagerEvent);
 
#pragma GCC visibility pop
 
  itkEventMacroDeclaration(FocusChangedEvent, itk::AnyEvent);
 
  class MITKCORE_EXPORT TestingRenderingManager : public RenderingManager
  {
  public:
    mitkClassMacro(TestingRenderingManager, RenderingManager);
    itkFactorylessNewMacro(Self);
    itkCloneMacro(Self);
 
  protected:
    
    void GenerateRenderingRequestEvent() override {};
  };
 
} // namespace mitk
 
#endif