mitkPlanarFigure.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 mitkPlanarFigure_h
#define mitkPlanarFigure_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;
 
    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();
 
    void UpdateOutputInformation() override;
 
    void SetRequestedRegionToLargestPossibleRegion() override;
 
    bool RequestedRegionIsOutsideOfTheBufferedRegion() override;
 
    bool VerifyRequestedRegion() override;
 
    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;
 
    void ResetNumberOfControlPoints(int numberOfControlPoints);
 
  protected:
    PlanarFigure();
 
    PlanarFigure(const Self &other);
 
    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;
 
    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();
 
    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 coordinates 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;
    };
 
    itk::LightObject::Pointer InternalClone() const override = 0;
 
    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