mitkPointSetVtkMapper2D.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 mitkPointSetVtkMapper2D_h
#define mitkPointSetVtkMapper2D_h

#include "mitkBaseRenderer.h"
#include "mitkLocalStorageHandler.h"
#include "mitkVtkMapper.h"
#include <MitkCoreExports.h>
#include <mitkPointSetShapeProperty.h>

// VTK
#include <vtkSmartPointer.h>
class vtkActor;
class vtkPropAssembly;
class vtkPolyData;
class vtkPolyDataMapper;
class vtkGlyphSource2D;
class vtkGlyph3D;
class vtkFloatArray;
class vtkCellArray;

namespace mitk
{
  class PointSet;

  class MITKCORE_EXPORT PointSetVtkMapper2D : public VtkMapper
  {
  public:
    mitkClassMacro(PointSetVtkMapper2D, VtkMapper);

    itkFactorylessNewMacro(Self) itkCloneMacro(Self)

      virtual const mitk::PointSet *GetInput() const;

    virtual vtkProp *GetVtkProp(mitk::BaseRenderer *renderer) override;

    static void SetDefaultProperties(mitk::DataNode *node, mitk::BaseRenderer *renderer = NULL, bool overwrite = false);

    class LocalStorage : public mitk::Mapper::BaseLocalStorage
    {
    public:
      /* constructor */
      LocalStorage();

      /* destructor */
      ~LocalStorage();

      // points
      vtkSmartPointer<vtkPoints> m_UnselectedPoints;
      vtkSmartPointer<vtkPoints> m_SelectedPoints;
      vtkSmartPointer<vtkPoints> m_ContourPoints;

      // scales
      vtkSmartPointer<vtkFloatArray> m_UnselectedScales;
      vtkSmartPointer<vtkFloatArray> m_SelectedScales;

      // distances
      vtkSmartPointer<vtkFloatArray> m_DistancesBetweenPoints;

      // lines
      vtkSmartPointer<vtkCellArray> m_ContourLines;

      // glyph source (provides different shapes for the points)
      vtkSmartPointer<vtkGlyphSource2D> m_UnselectedGlyphSource2D;
      vtkSmartPointer<vtkGlyphSource2D> m_SelectedGlyphSource2D;

      // glyph
      vtkSmartPointer<vtkGlyph3D> m_UnselectedGlyph3D;
      vtkSmartPointer<vtkGlyph3D> m_SelectedGlyph3D;

      // polydata
      vtkSmartPointer<vtkPolyData> m_VtkUnselectedPointListPolyData;
      vtkSmartPointer<vtkPolyData> m_VtkSelectedPointListPolyData;
      vtkSmartPointer<vtkPolyData> m_VtkContourPolyData;

      // actor
      vtkSmartPointer<vtkActor> m_UnselectedActor;
      vtkSmartPointer<vtkActor> m_SelectedActor;
      vtkSmartPointer<vtkActor> m_ContourActor;
      vtkSmartPointer<vtkTextActor> m_VtkTextActor;

      std::vector<vtkSmartPointer<vtkTextActor>> m_VtkTextLabelActors;
      std::vector<vtkSmartPointer<vtkTextActor>> m_VtkTextDistanceActors;
      std::vector<vtkSmartPointer<vtkTextActor>> m_VtkTextAngleActors;

      // mappers
      vtkSmartPointer<vtkPolyDataMapper> m_VtkUnselectedPolyDataMapper;
      vtkSmartPointer<vtkPolyDataMapper> m_VtkSelectedPolyDataMapper;
      vtkSmartPointer<vtkPolyDataMapper> m_VtkContourPolyDataMapper;

      // propassembly
      vtkSmartPointer<vtkPropAssembly> m_PropAssembly;
    };

    mitk::LocalStorageHandler<LocalStorage> m_LSH;

  protected:
    /* constructor */
    PointSetVtkMapper2D();

    /* destructor */
    virtual ~PointSetVtkMapper2D();

    /* \brief Applies the color and opacity properties and calls CreateVTKRenderObjects */
    virtual void GenerateDataForRenderer(mitk::BaseRenderer *renderer) override;
    /* \brief Called in mitk::Mapper::Update
    * If TimeSlicedGeometry or time step is not valid of point set: reset mapper so that nothing is
    * displayed e.g. toggle visiblity of the propassembly */
    virtual void ResetMapper(BaseRenderer *renderer) override;

    /* \brief Fills the vtk objects, thus it is only called when the point set has been changed.
   * This function iterates over the input point set and determines the glyphs which lie in a specific
   * range around the current slice. Those glyphs are rendered using a specific shape defined in vtk glyph source
   * to mark each point. The shape can be changed in MITK using the property "PointSet.2D.shape".
   *
   * There were issues when rendering vtk glyphs in the 2D-render windows. By default, the glyphs are
   * rendered within the x-y plane in each 2D-render window, so you would only see them from the
   * side in the saggital and coronal 2D-render window. The solution to this is to rotate the glyphs in order
   * to be ortogonal to the current view vector. To achieve this, the rotation (vtktransform) of the current
   * PlaneGeometry is applied to the orienation of the glyphs. */
    virtual void CreateVTKRenderObjects(mitk::BaseRenderer *renderer);

    // member variables holding the current value of the properties used in this mapper
    bool m_ShowContour;           // "show contour" property
    bool m_CloseContour;          // "close contour" property
    bool m_ShowPoints;            // "show points" property
    bool m_ShowDistances;         // "show distances" property
    int m_DistancesDecimalDigits; // "distance decimal digits" property
    bool m_ShowAngles;            // "show angles" property
    bool m_ShowDistantLines;      // "show distant lines" property
    int m_LineWidth;              // "line width" property
    int m_PointLineWidth;         // "point line width" property
    float m_Point2DSize;          // "point 2D size" property
    int m_IDShapeProperty;        // ID for mitkPointSetShape Enumeration Property "Pointset.2D.shape"
    bool m_FillShape;             // "Pointset.2D.fill shape" property
    float m_DistanceToPlane;      // "Pointset.2D.distance to plane" property
  };

} // namespace mitk

#endif /* mitkPointSetVtkMapper2D_h */