mitkPlanarFigure.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 _MITK_PLANAR_FIGURE_H_
#define _MITK_PLANAR_FIGURE_H_

#include "mitkBaseData.h"
#include "mitkCommon.h"
#include <MitkPlanarFigureExports.h>

#include <deque>

namespace mitk
{
  class PlaneGeometry;

  class MITKPLANARFIGURE_EXPORT PlanarFigure : public BaseData
  {
  public:
    mitkClassMacro(PlanarFigure, BaseData) itkCloneMacro(Self)

      typedef Point2D PolyLineElement;

    typedef itk::VectorContainer<unsigned long, bool> BoolContainerType;

    typedef std::deque<Point2D> ControlPointListType;
    typedef std::vector<PolyLineElement> PolyLineType;

    virtual void SetPlaneGeometry(mitk::PlaneGeometry *geometry);

    virtual const PlaneGeometry *GetPlaneGeometry() const;

    virtual bool IsClosed() const;

    virtual bool IsPlaced() const { return m_FigurePlaced; };
    virtual void PlaceFigure(const Point2D &point);

    virtual bool AddControlPoint(const Point2D &point, int index = -1);

    virtual bool SetControlPoint(unsigned int index, const Point2D &point, bool createIfDoesNotExist = false);

    virtual bool SetCurrentControlPoint(const Point2D &point);

    unsigned int GetNumberOfControlPoints() const;

    virtual unsigned int GetMinimumNumberOfControlPoints() const = 0;

    virtual unsigned int GetMaximumNumberOfControlPoints() const = 0;

    virtual bool SelectControlPoint(unsigned int index);

    virtual bool DeselectControlPoint();

    virtual int GetSelectedControlPoint() const { return m_SelectedControlPoint; }
    Point2D GetControlPoint(unsigned int index) const;

    virtual int GetControlPointForPolylinePoint(int indexOfPolylinePoint, int polyLineIndex) const;

    Point3D GetWorldControlPoint(unsigned int index) const;

    const PolyLineType GetPolyLine(unsigned int index);

    const PolyLineType GetPolyLine(unsigned int index) const;

    const PolyLineType GetHelperPolyLine(unsigned int index, double mmPerDisplayUnit, unsigned int displayHeight);

    void SetPreviewControlPoint(const Point2D &point);

    void ResetPreviewContolPoint();

    bool IsPreviewControlPointVisible() const;

    Point2D GetPreviewControlPoint() const;

    virtual unsigned int GetNumberOfFeatures() const;

    const char *GetFeatureName(unsigned int index) const;

    const char *GetFeatureUnit(unsigned int index) const;

    double GetQuantity(unsigned int index) const;

    bool IsFeatureActive(unsigned int index) const;

    bool IsFeatureVisible(unsigned int index) const;

    void SetFeatureVisible(unsigned int index, bool visible);

    virtual void EvaluateFeatures();

    virtual void UpdateOutputInformation() override;

    virtual void SetRequestedRegionToLargestPossibleRegion() override;

    virtual bool RequestedRegionIsOutsideOfTheBufferedRegion() override;

    virtual bool VerifyRequestedRegion() override;

    virtual void SetRequestedRegion(const itk::DataObject *data) override;

    virtual unsigned short GetPolyLinesSize();

    virtual unsigned short GetHelperPolyLinesSize() const;

    virtual bool IsHelperToBePainted(unsigned int index) const;

    virtual bool ResetOnPointSelect();
    virtual bool ResetOnPointSelectNeeded() const;

    virtual void RemoveControlPoint(unsigned int index);

    virtual void RemoveLastControlPoint();

    virtual Point2D ApplyControlPointConstraints(unsigned int /*index*/, const Point2D &point);

    virtual bool Equals(const mitk::PlanarFigure &other) const;

  protected:
    PlanarFigure();

    PlanarFigure(const Self &other);

    void ResetNumberOfControlPoints(int numberOfControlPoints);

    virtual unsigned int AddFeature(const char *featureName, const char *unitName);

    void SetFeatureName(unsigned int index, const char *featureName);

    void SetFeatureUnit(unsigned int index, const char *unitName);

    void SetQuantity(unsigned int index, double quantity);

    void ActivateFeature(unsigned int index);

    void DeactivateFeature(unsigned int index);

    virtual void GeneratePolyLine() = 0;

    virtual void GenerateHelperPolyLine(double mmPerDisplayUnit, unsigned int displayHeight) = 0;

    virtual void EvaluateFeaturesInternal() = 0;

    virtual void InitializeTimeGeometry(unsigned int timeSteps = 1) override;

    void SetNumberOfPolyLines(unsigned int numberOfPolyLines);

    void AppendPointToPolyLine(unsigned int index, PolyLineElement element);

    void ClearPolyLines();

    void SetNumberOfHelperPolyLines(unsigned int numberOfHelperPolyLines);

    void AppendPointToHelperPolyLine(unsigned int index, PolyLineElement element);

    void ClearHelperPolyLines();

    virtual void PrintSelf(std::ostream &os, itk::Indent indent) const override;

    ControlPointListType m_ControlPoints;
    unsigned int m_NumberOfControlPoints;

    // Currently selected control point; -1 means no point selected
    int m_SelectedControlPoint;

    std::vector<PolyLineType> m_PolyLines;
    std::vector<PolyLineType> m_HelperPolyLines;
    BoolContainerType::Pointer m_HelperPolyLinesToBePainted;

    // this point is used to store the coordiantes an additional 'ControlPoint' that is rendered
    // when the mouse cursor is above the figure (and not a control-point) and when the
    // property 'planarfigure.isextendable' is set to true
    Point2D m_PreviewControlPoint;
    bool m_PreviewControlPointVisible;

    bool m_FigurePlaced;

  private:
    // not implemented to prevent PlanarFigure::New() calls which would create an itk::Object.
    static Pointer New();

    struct Feature
    {
      Feature(const char *name, const char *unit) : Name(name), Unit(unit), Quantity(0.0), Active(true), Visible(true)
      {
      }

      std::string Name;
      std::string Unit;
      double Quantity;
      bool Active;
      bool Visible;
    };

    virtual itk::LightObject::Pointer InternalClone() const override = 0;

    PlaneGeometry *m_PlaneGeometry;

    bool m_PolyLineUpToDate;
    bool m_HelperLinesUpToDate;
    bool m_FeaturesUpToDate;

    // Vector of features available for this geometric figure
    typedef std::vector<Feature> FeatureVectorType;
    FeatureVectorType m_Features;

    unsigned long m_FeaturesMTime;

    // this pair is used to store the mmInDisplayUnits (m_DisplaySize.first) and the displayHeight
    // (m_DisplaySize.second)
    // that the helperPolyLines have been calculated for.
    // It's used to determine whether or not GetHelperPolyLine() needs to recalculate the HelperPolyLines.
    std::pair<double, unsigned int> m_DisplaySize;
  };

  MITKPLANARFIGURE_EXPORT bool Equal(const mitk::PlanarFigure &leftHandSide,
                                     const mitk::PlanarFigure &rightHandSide,
                                     ScalarType eps,
                                     bool verbose);

} // namespace mitk

#endif //_MITK_PLANAR_FIGURE_H_