mitkContourModel.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_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 mitk::ContourElement::VertexType VertexType;
    typedef mitk::ContourElement::VertexListType VertexListType;
    typedef mitk::ContourElement::VertexIterator VertexIterator;
    typedef mitk::ContourElement::ConstVertexIterator ConstVertexIterator;
    typedef std::vector<mitk::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(mitk::Point3D &vertex, int timestep = 0);

    void AddVertex(VertexType &vertex, int timestep = 0);

    void AddVertex(const VertexType *vertex, int timestep = 0);

    void AddVertex(mitk::Point3D &vertex, bool isControlPoint, int timestep = 0);

    void AddVertexAtFront(mitk::Point3D &vertex, int timestep = 0);

    void AddVertexAtFront(VertexType &vertex, int timestep = 0);

    void AddVertexAtFront(mitk::Point3D &vertex, bool isControlPoint, int timestep = 0);

    void InsertVertexAtIndex(mitk::Point3D &vertex, int index, bool isControlPoint = false, int timestep = 0);

    bool SetVertexAt(int pointId, const mitk::Point3D &point, unsigned int timestep = 0);

    bool SetVertexAt(int pointId, const VertexType *vertex, unsigned int timestep = 0);

    bool IsClosed(int timestep = 0) const;

    void Concatenate(mitk::ContourModel *other, int timestep = 0, bool check = false);

    VertexIterator Begin(int timestep = 0) const;

    VertexIterator IteratorBegin(int timestep = 0) const;

    VertexIterator End(int timestep = 0) const;

    VertexIterator IteratorEnd(int timestep = 0) const;

    virtual void Close(int timestep = 0);

    virtual void Open(int timestep = 0);

    virtual void SetClosed(bool isClosed, int timestep = 0);

    int GetNumberOfVertices(int timestep = 0) const;

    virtual bool IsEmpty(int timestep) const;

    virtual bool IsEmpty() const override;

    virtual const VertexType *GetVertexAt(int index, int timestep = 0) const;

    int GetIndex(const VertexType *vertex, int timestep = 0);

    virtual bool IsEmptyTimeStep(unsigned int t) const override;

    virtual bool IsNearContour(mitk::Point3D &point, float eps, int timestep);

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

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

    bool SelectVertexAt(mitk::Point3D &point, float eps, int 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(mitk::Point3D &point, float eps, int timestep = 0);

    bool RemoveVertexAt(int index, int timestep = 0);

    bool RemoveVertex(const VertexType *vertex, int timestep = 0);

    bool RemoveVertexAt(mitk::Point3D &point, float eps, int timestep = 0);

    void ShiftSelectedVertex(mitk::Vector3D &translate);

    void ShiftContour(mitk::Vector3D &translate, int timestep = 0);

    virtual void Clear(int timestep);

    virtual void Initialize() override;

    void Initialize(mitk::ContourModel &other);

    /*++++++++++++++++++ method inherit from base data +++++++++++++++++++++++++++*/
    virtual void SetRequestedRegionToLargestPossibleRegion() override;

    virtual bool RequestedRegionIsOutsideOfTheBufferedRegion() override;

    virtual bool VerifyRequestedRegion() override;

    virtual const mitk::BaseGeometry *GetUpdatedGeometry(int t = 0);

    virtual mitk::BaseGeometry *GetGeometry(int t = 0) const;

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

    virtual void Expand(unsigned int timeSteps) override;

    virtual void UpdateOutputInformation() override;

    virtual void Clear() override;

    void ExecuteOperation(Operation *operation) override;

    virtual void RedistributeControlVertices(int period, int timestep);

  protected:
    mitkCloneMacro(Self);

    ContourModel();
    ContourModel(const mitk::ContourModel &other);
    virtual ~ContourModel();

    // inherit from BaseData. called by Clear()
    virtual void ClearData() override;

    // inherit from BaseData. Initial state of a contour with no vertices and a single timestep.
    virtual void InitializeEmpty() override;

    // Shift a vertex
    void ShiftVertex(VertexType *vertex, mitk::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