mitkPlanarFigureMapper2D.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 mitkPlanarFigureMapper2D_h
#define mitkPlanarFigureMapper2D_h
 
#include "mitkCommon.h"
#include "mitkMapper.h"
#include "mitkPlanarFigure.h"
#include "mitkPlanarFigureControlPointStyleProperty.h"
#include <MitkPlanarFigureExports.h>
#include "vtkNew.h"
#include "vtkPen.h"
 
class vtkContext2D;
 
namespace mitk
{
  class BaseRenderer;
  class Contour;
 
  class MITKPLANARFIGURE_EXPORT PlanarFigureMapper2D : public Mapper
  {
  public:
    mitkClassMacro(PlanarFigureMapper2D, Mapper);
 
    itkFactorylessNewMacro(Self);
 
    itkCloneMacro(Self);
 
      void MitkRender(mitk::BaseRenderer *renderer, mitk::VtkPropRenderer::RenderType type) override;
 
    static void SetDefaultProperties(mitk::DataNode *node, mitk::BaseRenderer *renderer = nullptr, bool overwrite = false);
 
    void ApplyColorAndOpacityProperties(mitk::BaseRenderer *renderer, vtkActor *actor = nullptr) override;
 
  protected:
    enum PlanarFigureDisplayMode
    {
      PF_DEFAULT = 0,
      PF_HOVER = 1,
      PF_SELECTED = 2,
 
      PF_COUNT = 3 // helper variable
    };
 
    PlanarFigureMapper2D();
 
    ~PlanarFigureMapper2D() override;
 
    void RenderLines(const PlanarFigureDisplayMode lineDisplayMode,
                     mitk::PlanarFigure *planarFigure,
                     mitk::Point2D &anchorPoint,
                     const mitk::PlaneGeometry *planarFigurePlaneGeometry,
                     const mitk::PlaneGeometry *rendererPlaneGeometry,
                     const mitk::BaseRenderer *renderer,
                     vtkContext2D* context2D);
 
    void RenderQuantities(const mitk::PlanarFigure *planarFigure,
                          mitk::BaseRenderer *renderer,
                          const mitk::Point2D anchorPoint,
                          double &annotationOffset,
                          float globalOpacity,
                          const PlanarFigureDisplayMode lineDisplayMode,
                          vtkContext2D* context2D);
 
    void RenderAnnotations(mitk::BaseRenderer *renderer,
                           const std::string name,
                           const mitk::Point2D anchorPoint,
                           float globalOpacity,
                           const PlanarFigureDisplayMode lineDisplayMode,
                           double &annotationOffset,
                           vtkContext2D* context2D);
 
    void RenderControlPoints(const mitk::PlanarFigure *planarFigure,
                             const PlanarFigureDisplayMode lineDisplayMode,
                             const mitk::PlaneGeometry *planarFigurePlaneGeometry,
                             const mitk::PlaneGeometry *rendererPlaneGeometry,
                             mitk::BaseRenderer *renderer,
                             vtkContext2D* context2D);
 
    void TransformObjectToDisplay(const mitk::Point2D &point2D,
                                  mitk::Point2D &displayPoint,
                                  const mitk::PlaneGeometry *objectGeometry,
                                  const mitk::PlaneGeometry *,
                                  const mitk::BaseRenderer *renderer);
 
    void DrawMarker(const mitk::Point2D &point,
                    float *lineColor,
                    float lineOpacity,
                    float *markerColor,
                    float markerOpacity,
                    float lineWidth,
                    PlanarFigureControlPointStyleProperty::Shape shape,
                    const mitk::PlaneGeometry *objectGeometry,
                    const mitk::PlaneGeometry *rendererGeometry,
                    const mitk::BaseRenderer *renderer,
                    vtkContext2D* context2D);
 
    void PaintPolyLine(const PlanarFigure::PolyLineType& vertices,
                       bool closed,
                       Point2D &anchorPoint,
                       const PlaneGeometry *planarFigurePlaneGeometry,
                       const PlaneGeometry *rendererPlaneGeometry,
                       const mitk::BaseRenderer *renderer,
                       vtkContext2D* context2D);
 
    void DrawMainLines(mitk::PlanarFigure *figure,
                       Point2D &anchorPoint,
                       const PlaneGeometry *planarFigurePlaneGeometry,
                       const PlaneGeometry *rendererPlaneGeometry,
                       const mitk::BaseRenderer *renderer,
                       vtkContext2D* context2D);
 
    void DrawHelperLines(mitk::PlanarFigure *figure,
                         Point2D &anchorPoint,
                         const PlaneGeometry *planarFigurePlaneGeometry,
                         const PlaneGeometry *rendererPlaneGeometry,
                         const mitk::BaseRenderer *renderer,
                         vtkContext2D* context2D);
 
    void InitializeDefaultPlanarFigureProperties();
 
    void InitializePlanarFigurePropertiesFromDataNode(const mitk::DataNode *node);
 
    void SetColorProperty(float property[3][3], PlanarFigureDisplayMode mode, float red, float green, float blue)
    {
      property[mode][0] = red;
      property[mode][1] = green;
      property[mode][2] = blue;
    }
 
    void SetFloatProperty(float *property, PlanarFigureDisplayMode mode, float value) { property[mode] = value; }
    void OnNodeModified();
 
    void Initialize(mitk::BaseRenderer *renderer);
 
  private:
 
    bool m_IsSelected;
    bool m_IsHovering;
    bool m_DrawOutline;
    bool m_DrawQuantities;
    bool m_DrawShadow;
    bool m_DrawControlPoints;
    bool m_DrawName;
    bool m_DrawDashed;
    bool m_DrawHelperDashed;
    bool m_AnnotationsShadow;
 
    std::string m_AnnotationFontFamily;
    bool m_DrawAnnotationBold;
    bool m_DrawAnnotationItalic;
    int m_AnnotationSize;
 
    // the width of the shadow is defined as 'm_LineWidth * m_ShadowWidthFactor'
    float m_LineWidth;
    float m_ShadowWidthFactor;
    float m_OutlineWidth;
    float m_HelperlineWidth;
    // float m_PointWidth;
 
    float m_DevicePixelRatio;
 
    PlanarFigureControlPointStyleProperty::Shape m_ControlPointShape;
 
    float m_LineColor[3][3];
    float m_LineOpacity[3];
    float m_OutlineColor[3][3];
    float m_OutlineOpacity[3];
    float m_HelperlineColor[3][3];
    float m_HelperlineOpacity[3];
    float m_MarkerlineColor[3][3];
    float m_MarkerlineOpacity[3];
    float m_MarkerColor[3][3];
    float m_MarkerOpacity[3];
    float m_AnnotationColor[3][3];
 
    // Bool flag that represents whether or not the DataNode has been modified.
    bool m_NodeModified;
 
    // Observer-tag for listening to itk::ModifiedEvents on the DataNode
    unsigned long m_NodeModifiedObserverTag;
 
    // Bool flag that indicates if a node modified observer was added
    bool m_NodeModifiedObserverAdded;
 
    bool m_Initialized;
 
    vtkSmartPointer<vtkPen> m_Pen;
  };
 
} // namespace mitk
 
#endif