mitkRenderingManager.h

Go to the documentation of this file.

/*===================================================================

The Medical Imaging Interaction Toolkit (MITK)

Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.

This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.

See LICENSE.txt or http://www.mitk.org for details.

===================================================================*/

#ifndef MITKRENDERINGMANAGER_H_HEADER_INCLUDED_C135A197
#define MITKRENDERINGMANAGER_H_HEADER_INCLUDED_C135A197

#include <MitkCoreExports.h>

#include <vtkCallbackCommand.h>

#include <itkObject.h>
#include <itkObjectFactory.h>
#include <string>

#include "mitkProperties.h"
#include "mitkPropertyList.h"
#include "mitkTimeGeometry.h"

class vtkRenderWindow;
class vtkObject;

namespace mitk
{
  class RenderingManager;
  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 bool InitializeViews( const DataStorage *storage, const DataNode* node = NULL,
    //   RequestType type = REQUEST_UPDATE_ALL, bool preserveRoughOrientationInWorldSpace = false );

    virtual bool InitializeViews(const BaseGeometry *geometry,
                                 RequestType type = REQUEST_UPDATE_ALL,
                                 bool preserveRoughOrientationInWorldSpace = false);
    virtual bool InitializeViews(const TimeGeometry *geometry,
                                 RequestType type = REQUEST_UPDATE_ALL,
                                 bool preserveRoughOrientationInWorldSpace = false);

    virtual bool InitializeViews(RequestType type = REQUEST_UPDATE_ALL);

    // virtual bool InitializeView( vtkRenderWindow *renderWindow, const DataStorage* ds, const DataNode* node = NULL,
    // bool initializeGlobalTimeSNC = false );

    virtual bool InitializeView(vtkRenderWindow *renderWindow,
                                const BaseGeometry *geometry,
                                bool initializeGlobalTimeSNC = false);
    virtual bool InitializeView(vtkRenderWindow *renderWindow,
                                const TimeGeometry *geometry,
                                bool initializeGlobalTimeSNC = false);

    virtual bool InitializeView(vtkRenderWindow *renderWindow);

    virtual void InitializeViewsByBoundingObjects(const DataStorage *);

    const SliceNavigationController *GetTimeNavigationController() const;

    SliceNavigationController *GetTimeNavigationController();

    virtual ~RenderingManager();

    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(mitk::DataStorage *storage);

    mitk::DataStorage *GetDataStorage();

    void SetRenderWindowFocus(vtkRenderWindow *focusWindow);

    itkGetMacro(FocusedRenderWindow, vtkRenderWindow *)

      itkSetMacro(ConstrainedPanningZooming, bool);

  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(mitk::BaseRenderer *baseRenderer,
                                    const mitk::TimeGeometry *geometry,
                                    bool boundingBoxInitialized,
                                    int mapperID);

    vtkRenderWindow *m_FocusedRenderWindow;
  };

#pragma GCC visibility push(default)

  itkEventMacro(RenderingManagerEvent, itk::AnyEvent);
  itkEventMacro(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 : virtual void GenerateRenderingRequestEvent() override{
                    // ForceImmediateUpdateAll();
                  };
  };

} // namespace mitk

#endif /* MITKRenderingManager_H_HEADER_INCLUDED_C135A197 */