mitkContourModel.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 mitkContourModel_h
#define mitkContourModel_h
 
#include <mitkBaseData.h>
#include <mitkCommon.h>
#include <MitkContourModelExports.h>
 
#include <mitkContourElement.h>
 
namespace mitk
{
  class MITKCONTOURMODEL_EXPORT ContourModel : public BaseData
  {
  public:
    mitkClassMacro(ContourModel, BaseData);
 
    itkFactorylessNewMacro(Self);
 
    itkCloneMacro(Self);
 
    /*+++++++++++++++ typedefs +++++++++++++++++++++++++++++++*/
    typedef ContourElement::VertexType VertexType;
    typedef ContourElement::VertexListType VertexListType;
    typedef ContourElement::VertexIterator VertexIterator;
    typedef ContourElement::ConstVertexIterator ConstVertexIterator;
    typedef std::vector<ContourElement::Pointer> ContourModelSeries;
    /*+++++++++++++++ END typedefs ++++++++++++++++++++++++++++*/
 
    enum LineSegmentInterpolation
    {
      LINEAR,   
      B_SPLINE  
    };
 
    /*++++++++++++++++  inline methods  +++++++++++++++++++++++*/
 
    VertexType *GetSelectedVertex() { return this->m_SelectedVertex; }
 
    void Deselect() { this->m_SelectedVertex = nullptr; }
 
    void SetSelectedVertexAsControlPoint(bool isControlPoint = true)
    {
      if (this->m_SelectedVertex)
      {
        m_SelectedVertex->IsControlPoint = isControlPoint;
        this->Modified();
      }
    }
 
    void SetLineSegmentInterpolation(LineSegmentInterpolation interpolation)
    {
      this->m_lineInterpolation = interpolation;
      this->Modified();
    }
 
    LineSegmentInterpolation GetLineSegmentInterpolation() { return this->m_lineInterpolation; }
    /*++++++++++++++++  END inline methods  +++++++++++++++++++++++*/
 
    void AddVertex(const Point3D &vertex, TimeStepType timestep = 0);
 
    void AddVertex(const VertexType &vertex, TimeStepType timestep = 0);
 
    void AddVertex(const Point3D& vertex, bool isControlPoint, TimeStepType timestep = 0);
 
    void UpdateContour(const ContourModel* sourceModel, TimeStepType destinationTimeStep, TimeStepType sourceTimeStep);
 
    void AddVertexAtFront(const Point3D &vertex, TimeStepType timestep = 0);
 
    void AddVertexAtFront(const VertexType &vertex, TimeStepType timestep = 0);
 
    void AddVertexAtFront(const Point3D &vertex, bool isControlPoint, TimeStepType timestep = 0);
 
    void InsertVertexAtIndex(const Point3D &vertex, int index, bool isControlPoint = false, TimeStepType timestep = 0);
 
    bool SetVertexAt(int pointId, const Point3D &point, TimeStepType timestep = 0);
 
    bool SetVertexAt(int pointId, const VertexType *vertex, TimeStepType timestep = 0);
 
    bool IsClosed(int timestep = 0) const;
 
    void Concatenate(ContourModel *other, TimeStepType timestep = 0, bool check = false);
 
    VertexIterator Begin(TimeStepType timestep = 0) const;
 
    VertexIterator IteratorBegin(TimeStepType timestep = 0) const;
 
    VertexIterator End(TimeStepType timestep = 0) const;
 
    VertexIterator IteratorEnd(TimeStepType timestep = 0) const;
 
    virtual void Close(TimeStepType timestep = 0);
 
    virtual void Open(TimeStepType timestep = 0);
 
    virtual void SetClosed(bool isClosed, TimeStepType timestep = 0);
 
    int GetNumberOfVertices(TimeStepType timestep = 0) const;
 
    virtual bool IsEmpty(TimeStepType timestep) const;
 
    bool IsEmpty() const override;
 
    virtual const VertexType *GetVertexAt(int index, TimeStepType timestep = 0) const;
 
    const VertexType *GetVertexAt(mitk::Point3D &point, float eps, TimeStepType timestep) const;
 
    virtual const VertexType *GetNextControlVertexAt(mitk::Point3D &point, float eps, TimeStepType timestep) const;
 
    virtual const VertexType *GetPreviousControlVertexAt(mitk::Point3D &point, float eps, TimeStepType timestep) const;
 
    int GetIndex(const VertexType *vertex, TimeStepType timestep = 0);
 
    bool IsEmptyTimeStep(unsigned int t) const override;
 
    bool IsNearContour(Point3D &point, float eps, TimeStepType timestep) const;
 
    bool GetLineSegmentForPoint(Point3D &point,
                            float eps,
                            TimeStepType timestep,
                            mitk::ContourElement::VertexType *previousVertex = nullptr,
                            mitk::ContourElement::VertexType *nextVertex = nullptr);
 
    bool GetLineSegmentForPoint(const mitk::Point3D& point,
      float eps, TimeStepType timestep, ContourElement::VertexSizeType& segmentStartIndex,
      ContourElement::VertexSizeType& segmentEndIndex, mitk::Point3D& closestContourPoint,
      bool findClosest = true) const;
 
    bool SelectVertexAt(int index, TimeStepType timestep = 0);
 
    bool SetControlVertexAt(int index, TimeStepType timestep = 0);
 
    bool SelectControlVertexAt(const Point3D &point, float eps, TimeStepType timestep = 0);
 
    bool SelectVertexAt(const Point3D &point, float eps, TimeStepType timestep = 0);
 
    /*
        \param point - query point in 3D space
        \param eps - radius for nearest neighbour search (error bound).
        \param timestep - search at this timestep
 
        @return true = vertex found;  false = no vertex found
        */
    bool SetControlVertexAt(Point3D &point, float eps, TimeStepType timestep = 0);
 
    bool RemoveVertexAt(int index, TimeStepType timestep = 0);
 
    bool RemoveVertex(const VertexType *vertex, TimeStepType timestep = 0);
 
    bool RemoveVertexAt(Point3D &point, float eps, TimeStepType timestep = 0);
 
    void ShiftSelectedVertex(Vector3D &translate);
 
    void ShiftContour(Vector3D &translate, TimeStepType timestep = 0);
 
    virtual void Clear(TimeStepType timestep);
 
    void Initialize() override;
 
    void Initialize(const ContourModel &other);
 
    VertexListType GetControlVertices(TimeStepType timestep);
 
    VertexListType GetVertexList(TimeStepType timestep);
 
    /*++++++++++++++++++ method inherit from base data +++++++++++++++++++++++++++*/
    void SetRequestedRegionToLargestPossibleRegion() override;
 
    bool RequestedRegionIsOutsideOfTheBufferedRegion() override;
 
    bool VerifyRequestedRegion() override;
 
    void SetRequestedRegion(const itk::DataObject *data) override;
 
    void Expand(unsigned int timeSteps) override;
 
    void UpdateOutputInformation() override;
 
    void Clear() override;
 
    void ExecuteOperation(Operation *operation) override;
 
    virtual void RedistributeControlVertices(int period, TimeStepType timestep);
 
  protected:
    mitkCloneMacro(Self);
 
    ContourModel();
    ContourModel(const ContourModel &other);
    ~ContourModel() override;
 
    // inherit from BaseData. called by Clear()
    void ClearData() override;
 
    // inherit from BaseData. Initial state of a contour with no vertices and a single timestep.
    void InitializeEmpty() override;
 
    // Shift a vertex
    static void ShiftVertex(VertexType *vertex, Vector3D &vector);
 
    // Storage with time resolved support.
    ContourModelSeries m_ContourSeries;
 
    // The currently selected vertex.
    VertexType *m_SelectedVertex;
 
    // The interpolation of the line segment between control points.
    LineSegmentInterpolation m_lineInterpolation;
 
    // only update the bounding geometry if necessary
    bool m_UpdateBoundingBox;
  };
 
  itkEventMacroDeclaration(ContourModelEvent, itk::AnyEvent);
  itkEventMacroDeclaration(ContourModelShiftEvent, ContourModelEvent);
  itkEventMacroDeclaration(ContourModelSizeChangeEvent, ContourModelEvent);
  itkEventMacroDeclaration(ContourModelAddEvent, ContourModelSizeChangeEvent);
  itkEventMacroDeclaration(ContourModelRemoveEvent, ContourModelSizeChangeEvent);
  itkEventMacroDeclaration(ContourModelExpandTimeBoundsEvent, ContourModelEvent);
  itkEventMacroDeclaration(ContourModelClosedEvent, ContourModelEvent);
}
#endif