mitkVtkPropRenderer.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 mitkVtkPropRenderer_h
#define mitkVtkPropRenderer_h
 
#include <mitkBaseRenderer.h>
#include <MitkCoreExports.h>
#include <itkCommand.h>
#include <mitkDataStorage.h>
#include <mitkRenderingManager.h>
 
#include <map>
#include <utility>
 
class vtkRenderWindow;
class vtkLight;
class vtkLightKit;
class vtkWorldPointPicker;
class vtkPointPicker;
class vtkCellPicker;
class vtkAssemblyPath;
 
#include <vtkAssemblyPaths.h>
#include <vtkSmartPointer.h>
 
namespace mitk
{
  class Mapper;
 
  class MITKCORE_EXPORT VtkPropRenderer : public BaseRenderer
  {
    // Workaround for Displaylistbug
  private:
    bool didCount;
    void checkState();
 
    // Workaround END
 
  public:
    mitkClassMacro(VtkPropRenderer, BaseRenderer);
    mitkNewMacro2Param(VtkPropRenderer, const char*, vtkRenderWindow*);
 
    typedef std::map<int, Mapper *> MappersMapType;
 
    enum RenderType
    {
      Opaque,
      Translucent,
      Overlay,
      Volumetric
    };
 
    void SetPropertyKeys(vtkInformation *info);
 
    int Render(RenderType type);
 
    virtual void PrepareRender();
 
    virtual void MakeCurrent();
 
    void SetDataStorage(mitk::DataStorage *storage) override;
 
    void InitRenderer(vtkRenderWindow *renderwindow) override;
 
    virtual void Update(mitk::DataNode *datatreenode);
 
    void SetMapperID(const MapperSlotId mapperId) override;
 
    void InitSize(int w, int h) override;
 
    void Resize(int w, int h) override;
 
    // Picking
    enum PickingMode
    {
      WorldPointPicking,
      PointPicking,
      CellPicking
    };
    itkSetEnumMacro(PickingMode, PickingMode);
    itkGetEnumMacro(PickingMode, PickingMode);
 
    void PickWorldPoint(const Point2D &displayPoint, Point3D &worldPoint) const override;
 
    mitk::DataNode *PickObject(const Point2D &displayPosition, Point3D &worldPosition) const override;
 
    bool SetWorldGeometryToDataStorageBounds() override;
 
    void InitPathTraversal();
 
    vtkAssemblyPath *GetNextPath();
 
    int GetNumberOfPaths();
 
    const vtkWorldPointPicker *GetWorldPointPicker() const;
 
    const vtkPointPicker *GetPointPicker() const;
 
    const vtkCellPicker *GetCellPicker() const;
 
    virtual void ReleaseGraphicsResources(vtkWindow *renWin);
 
    MappersMapType GetMappersMap() const;
 
    static bool useImmediateModeRendering();
 
  protected:
    VtkPropRenderer(const char *name = "VtkPropRenderer", vtkRenderWindow *renWin = nullptr);
    ~VtkPropRenderer() override;
    void Update() override;
 
    static void RenderingCallback(vtkObject *caller, unsigned long eid, void *clientdata, void *calldata);
 
    virtual void UpdatePaths(); // apply transformations and properties recursively
 
  private:
    vtkSmartPointer<vtkAssemblyPaths> m_Paths;
    vtkTimeStamp m_PathTime;
 
    // prepare all mitk::mappers for rendering
    void PrepareMapperQueue();
 
    void PropagateRenderInfoToMappers();
 
    bool Initialize2DvtkCamera();
 
    bool m_InitNeeded;
    bool m_ResizeNeeded;
    MapperSlotId m_CameraInitializedForMapperID;
 
    // Picking
    vtkWorldPointPicker *m_WorldPointPicker;
    vtkPointPicker *m_PointPicker;
    vtkCellPicker *m_CellPicker;
 
    PickingMode m_PickingMode;
 
    // Explicit use of SmartPointer to avoid circular #includes
    itk::SmartPointer<mitk::Mapper> m_CurrentWorldPlaneGeometryMapper;
 
    vtkLightKit *m_LightKit;
 
    // sorted list of mappers
    MappersMapType m_MappersMap;
 
    vtkInformation* m_VtkRenderInfo = nullptr;
  };
} // namespace mitk
 
#endif