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 vtkTextActor;
class vtkTextProperty;
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;

    // Render - called by vtkMitkRenderProp, returns the number of props rendered
    enum RenderType
    {
      Opaque,
      Translucent,
      Overlay,
      Volumetric
    };

    void SetPropertyKeys(vtkInformation *info);

    int Render(RenderType type);

    virtual void PrepareRender();

    // Active current renderwindow
    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;

    // Size
    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;

    DEPRECATED(int WriteSimpleText(std::string text,
                                   double posX,
                                   double posY,
                                   double color1 = 0.0,
                                   double color2 = 1.0,
                                   double color3 = 0.0,
                                   float opacity = 1.0));

    DEPRECATED(vtkTextProperty *GetTextLabelProperty(int text_id));

    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;

    // rendering of text
    vtkRenderer *m_TextRenderer;
    typedef std::map<unsigned int, vtkTextActor *> TextMapType;
    TextMapType m_TextCollection;

    vtkInformation* m_VtkRenderInfo = nullptr;
  };
} // namespace mitk

#endif /* mitkVtkPropRenderer_h */