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 _MITK_CONTOURMODEL_H_
#define _MITK_CONTOURMODEL_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;

    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;

    virtual bool IsNearContour(Point3D &point, float eps, TimeStepType timestep);


    bool SelectVertexAt(int index, TimeStepType timestep = 0);

    bool SetControlVertexAt(int index, TimeStepType timestep = 0);

    bool SelectControlVertexAt(Point3D &point, float eps, TimeStepType timestep = 0);

    bool SelectVertexAt(Point3D &point, float eps, TimeStepType timestep = 0);

    /*
        \pararm point - query point in 3D space
        \pararm eps - radius for nearest neighbour search (error bound).
        \pararm 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;
  };

  itkEventMacro(ContourModelEvent, itk::AnyEvent);
  itkEventMacro(ContourModelShiftEvent, ContourModelEvent);
  itkEventMacro(ContourModelSizeChangeEvent, ContourModelEvent);
  itkEventMacro(ContourModelAddEvent, ContourModelSizeChangeEvent);
  itkEventMacro(ContourModelRemoveEvent, ContourModelSizeChangeEvent);
  itkEventMacro(ContourModelExpandTimeBoundsEvent, ContourModelEvent);
  itkEventMacro(ContourModelClosedEvent, ContourModelEvent);
}
#endif