mitkVtkPropRenderer.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 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);
    mitkNewMacro3Param(VtkPropRenderer, const char *, vtkRenderWindow *, mitk::RenderingManager *);
    mitkNewMacro4Param(VtkPropRenderer,
                       const char *,
                       vtkRenderWindow *,
                       mitk::RenderingManager *,
                       mitk::BaseRenderer::RenderingMode::Type);

    typedef std::map<int, Mapper *> MappersMapType;

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

    int Render(RenderType type);

    virtual void PrepareRender();

    // Active current renderwindow
    virtual void MakeCurrent();

    virtual void SetDataStorage(
      mitk::DataStorage *storage) override; 

    virtual void InitRenderer(vtkRenderWindow *renderwindow) override;
    virtual void Update(mitk::DataNode *datatreenode);
    virtual void SetMapperID(const MapperSlotId mapperId) override;

    // Size
    virtual void InitSize(int w, int h) override;
    virtual void Resize(int w, int h) override;

    // Picking
    enum PickingMode
    {
      WorldPointPicking,
      PointPicking,
      CellPicking
    };
    itkSetEnumMacro(PickingMode, PickingMode);
    itkGetEnumMacro(PickingMode, PickingMode);

    virtual void PickWorldPoint(const Point2D &displayPoint, Point3D &worldPoint) const override;
    virtual 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));

    virtual 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,
      mitk::RenderingManager *rm = nullptr,
      mitk::BaseRenderer::RenderingMode::Type renderingMode = mitk::BaseRenderer::RenderingMode::Standard);
    virtual ~VtkPropRenderer();
    virtual 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();

    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;
  };
} // namespace mitk

#endif /* mitkVtkPropRenderer_h */