mitkPointSetVtkMapper2D.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 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;
 
    vtkProp *GetVtkProp(mitk::BaseRenderer *renderer) override;
 
    static void SetDefaultProperties(mitk::DataNode *node, mitk::BaseRenderer *renderer = nullptr, bool overwrite = false);
 
    class LocalStorage : public mitk::Mapper::BaseLocalStorage
    {
    public:
      /* constructor */
      LocalStorage();
 
      /* destructor */
      ~LocalStorage() override;
 
      // points
      vtkSmartPointer<vtkPoints> m_UnselectedPoints;
      vtkSmartPointer<vtkPoints> m_SelectedPoints;
      vtkSmartPointer<vtkPoints> m_ContourPoints;
 
      // scales
      vtkSmartPointer<vtkFloatArray> m_UnselectedScales;
      vtkSmartPointer<vtkFloatArray> m_SelectedScales;
      vtkSmartPointer<vtkFloatArray> m_SelectedContourScales;
 
      // 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;
      vtkSmartPointer<vtkGlyphSource2D> m_SelectedContourGlyphSource2D;
 
      // glyph
      vtkSmartPointer<vtkGlyph3D> m_UnselectedGlyph3D;
      vtkSmartPointer<vtkGlyph3D> m_SelectedGlyph3D;
      vtkSmartPointer<vtkGlyph3D> m_SelectedContourGlyph3D;
 
      // polydata
      vtkSmartPointer<vtkPolyData> m_VtkUnselectedPointListPolyData;
      vtkSmartPointer<vtkPolyData> m_VtkSelectedPointListPolyData;
      vtkSmartPointer<vtkPolyData> m_VtkSelectedContourPointListPolyData;
      vtkSmartPointer<vtkPolyData> m_VtkContourPolyData;
 
      // actor
      vtkSmartPointer<vtkActor> m_UnselectedActor;
      vtkSmartPointer<vtkActor> m_SelectedActor;
      vtkSmartPointer<vtkActor> m_SelectedContourActor;
      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_VtkSelectedContourPolyDataMapper;
      vtkSmartPointer<vtkPolyDataMapper> m_VtkContourPolyDataMapper;
 
      // propassembly
      vtkSmartPointer<vtkPropAssembly> m_PropAssembly;
    };
 
    mitk::LocalStorageHandler<LocalStorage> m_LSH;
 
  protected:
    /* constructor */
    PointSetVtkMapper2D();
 
    /* destructor */
    ~PointSetVtkMapper2D() override;
 
    /* \brief Applies the color and opacity properties and calls CreateVTKRenderObjects */
    void GenerateDataForRenderer(mitk::BaseRenderer *renderer) override;
    /* \brief Called in mitk::Mapper::Update
    * If TimeGeometry or time step is not valid of point set: reset mapper so that nothing is
    * displayed e.g. toggle visibility of the propassembly */
    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 sagittal and coronal 2D-render window. The solution to this is to rotate the glyphs in order
   * to be orthogonal to the current view vector. To achieve this, the rotation (vtktransform) of the current
   * PlaneGeometry is applied to the orientation 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
    bool m_FixedSizeOnScreen;     // "Pointset.2D.fixed size on screen" property
    int m_Resolution;             // "Pointset.2D.resolution" property
    bool m_KeepShapeWhenSelected; // "Pointset.2D.keep shape when selected" property
    bool m_ShowSelectedContour;   // "Pointset.2D.selected.show contour" property
  };
 
} // namespace mitk
 
#endif