mitkPointSet.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 MITKPointSet_H_HEADER_INCLUDED
#define MITKPointSet_H_HEADER_INCLUDED

#include "mitkBaseData.h"

#include <itkDefaultDynamicMeshTraits.h>
#include <itkMesh.h>

namespace mitk
{
  class MITKCORE_EXPORT PointSet : public BaseData
  {
  public:
    mitkClassMacro(PointSet, BaseData);

    itkFactorylessNewMacro(Self);

    itkCloneMacro(Self);

      typedef mitk::ScalarType CoordinateType;
    typedef mitk::ScalarType InterpolationWeightType;

    static const unsigned int PointDimension = 3;
    static const unsigned int MaxTopologicalDimension = 3;

    struct MITKCORE_EXPORT PointDataType
    {
      unsigned int id;                        // to give the point a special ID
      bool selected;                          // information about if the point is selected
      mitk::PointSpecificationType pointSpec; // specifies the type of the point

      bool operator==(const PointDataType &other) const;
    };

    typedef std::vector<unsigned int> SelectedLinesType;
    typedef SelectedLinesType::iterator SelectedLinesIter;
    struct CellDataType
    {
      // used to set the whole cell on selected
      bool selected;

      // indexes of selected lines. 0 is between pointId 0 and 1
      SelectedLinesType selectedLines;

      // is the polygon already finished and closed
      bool closed;
    };

    typedef itk::DefaultDynamicMeshTraits<PointDataType,
                                          PointDimension,
                                          MaxTopologicalDimension,
                                          CoordinateType,
                                          InterpolationWeightType,
                                          CellDataType>
      MeshTraits;
    typedef itk::Mesh<PointDataType, PointDimension, MeshTraits> MeshType;

    typedef MeshType DataType;
    typedef Point3D PointType;
    typedef DataType::PointIdentifier PointIdentifier;
    typedef DataType::PointsContainer PointsContainer;
    typedef DataType::PointsContainerIterator PointsIterator;
    typedef DataType::PointsContainer::ConstIterator PointsConstIterator;
    typedef DataType::PointDataContainer PointDataContainer;
    typedef DataType::PointDataContainerIterator PointDataIterator;
    typedef DataType::PointDataContainerIterator PointDataConstIterator;

    void Expand(unsigned int timeSteps) override;

    void ExecuteOperation(Operation *operation) override;

    virtual int GetSize(unsigned int t = 0) const;

    virtual unsigned int GetPointSetSeriesSize() const;

    virtual DataType::Pointer GetPointSet(int t = 0) const;

    PointsIterator Begin(int t = 0);

    PointsConstIterator Begin(int t = 0) const;

    PointsIterator End(int t = 0);

    PointsConstIterator End(int t = 0) const;

    PointsIterator GetMaxId(int t = 0);

    PointType GetPoint(PointIdentifier id, int t = 0) const;

    bool GetPointIfExists(PointIdentifier id, PointType *point, int t = 0) const;

    void SetPoint(PointIdentifier id, PointType point, int t = 0);

    void SetPoint(PointIdentifier id, PointType point, PointSpecificationType spec, int t = 0);

    void InsertPoint(PointIdentifier id, PointType point, int t = 0);

    void InsertPoint(PointIdentifier id, PointType point, PointSpecificationType spec, int t);

    PointIdentifier InsertPoint(PointType point, int t = 0);

    bool RemovePointIfExists(PointIdentifier id, int t = 0);

    PointsIterator RemovePointAtEnd(int t = 0);

    bool SwapPointPosition(PointIdentifier id, bool moveUpwards, int t = 0);

    virtual int SearchSelectedPoint(int t = 0) const;

    virtual bool IndexExists(int position, int t = 0) const;

    virtual bool GetSelectInfo(int position, int t = 0) const;

    virtual void SetSelectInfo(int position, bool selected, int t = 0);

    virtual PointSpecificationType GetSpecificationTypeInfo(int position, int t) const;

    virtual int GetNumberOfSelected(int t = 0) const;

    int SearchPoint(Point3D point, ScalarType distance, int t = 0) const;

    bool IsEmptyTimeStep(unsigned int t) const override;

    // virtual methods, that need to be implemented
    void UpdateOutputInformation() override;
    void SetRequestedRegionToLargestPossibleRegion() override;
    bool RequestedRegionIsOutsideOfTheBufferedRegion() override;
    bool VerifyRequestedRegion() override;
    void SetRequestedRegion(const itk::DataObject *data) override;

    // Method for subclasses
    virtual void OnPointSetChange(){};

  protected:
    mitkCloneMacro(Self);

    PointSet();
    PointSet(const PointSet &other);
    ~PointSet() override;

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

    void ClearData() override;

    void InitializeEmpty() override;

    bool SwapPointContents(PointIdentifier id1, PointIdentifier id2, int t = 0);

    typedef std::vector<DataType::Pointer> PointSetSeries;

    PointSetSeries m_PointSetSeries;

    DataType::PointsContainer::Pointer m_EmptyPointsContainer;

    bool m_CalculateBoundingBox;
  };

  DEPRECATED(MITKCORE_EXPORT bool Equal(const mitk::PointSet *leftHandSide,
                                        const mitk::PointSet *rightHandSide,
                                        mitk::ScalarType eps,
                                        bool verbose,
                                        bool checkGeometry = true));

  MITKCORE_EXPORT bool Equal(const mitk::PointSet &leftHandSide,
                             const mitk::PointSet &rightHandSide,
                             mitk::ScalarType eps,
                             bool verbose,
                             bool checkGeometry = true);

  itkEventMacro(PointSetEvent, itk::AnyEvent);
  itkEventMacro(PointSetMoveEvent, PointSetEvent);
  itkEventMacro(PointSetSizeChangeEvent, PointSetEvent);
  itkEventMacro(PointSetAddEvent, PointSetSizeChangeEvent);
  itkEventMacro(PointSetRemoveEvent, PointSetSizeChangeEvent);
  itkEventMacro(PointSetExtendTimeRangeEvent, PointSetEvent);

} // namespace mitk

#endif /* MITKPointSet_H_HEADER_INCLUDED */