mitkRenderingManager.h

Go to the documentation of this file.

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

Program:   Medical Imaging & Interaction Toolkit
Language:  C++
Date:      $Date$
Version:   $Revision$

Copyright (c) German Cancer Research Center, Division of Medical and
Biological Informatics. All rights reserved.
See MITKCopyright.txt or https://www.mitk.org/copyright.html for details.

This software is distributed WITHOUT ANY WARRANTY; without even
the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
PURPOSE.  See the above copyright notices for more information.

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


#ifndef MITKRENDERINGMANAGER_H_HEADER_INCLUDED_C135A197
#define MITKRENDERINGMANAGER_H_HEADER_INCLUDED_C135A197

#include "mitkCommon.h"

#include <vtkCallbackCommand.h>

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

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

class vtkRenderWindow;
class vtkObject;

namespace mitk
{

class RenderingManager;
class RenderingManagerFactory;
class Geometry3D;
class SliceNavigationController;
class BaseRenderer;
class DataStorage;
class GlobalInteraction;

class MITK_CORE_EXPORT RenderingManager : public itk::Object
{
public:

  mitkClassMacro(RenderingManager,itk::Object);

  typedef std::vector< vtkRenderWindow* > RenderWindowVector;
  typedef std::vector< float > FloatVector;
  typedef std::vector< bool > BoolVector;

  typedef itk::SmartPointer< DataStorage > DataStoragePointer;
  typedef itk::SmartPointer< GlobalInteraction > GlobalInteractionPointer;

  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 Geometry3D *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 Geometry3D *geometry, bool initializeGlobalTimeSNC = false);

  virtual bool InitializeView( vtkRenderWindow *renderWindow );


  void SetTimeNavigationController( SliceNavigationController *nc );

  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 );

  void SetDepthPeelingEnabled(bool enabled);
  void SetMaxNumberOfPeels(int maxNumber);


  virtual void DoStartRendering() {};
  virtual void DoMonitorRendering() {};
  virtual void DoFinishAbortRendering() {};

  int GetNextLOD( BaseRenderer* renderer );

  void SetNextLOD( unsigned int lod, BaseRenderer *renderer = NULL );
  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 SetGlobalInteraction( mitk::GlobalInteraction* globalInteraction );

  mitk::GlobalInteraction* GetGlobalInteraction();


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;

  SliceNavigationController *m_TimeNavigationController;

  static RenderingManager::Pointer s_Instance;
  static RenderingManagerFactory *s_RenderingManagerFactory;

  PropertyList::Pointer m_PropertyList;

  DataStoragePointer m_DataStorage;

  GlobalInteractionPointer m_GlobalInteraction;

private:

  void InternalViewInitialization(
      mitk::BaseRenderer *baseRenderer, const mitk::Geometry3D *geometry,
      bool boundingBoxInitialized, int mapperID );

};

itkEventMacro( RenderingManagerEvent, itk::AnyEvent );
itkEventMacro( RenderingManagerViewsInitializedEvent, RenderingManagerEvent );


class MITK_CORE_EXPORT TestingRenderingManager : public RenderingManager
{
public:
  mitkClassMacro(TestingRenderingManager,RenderingManager);
  itkNewMacro(Self);

protected:
  virtual void GenerateRenderingRequestEvent()
  {
  };

};


} // namespace mitk

#endif /* MITKRenderingManager_H_HEADER_INCLUDED_C135A197 */