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
#define mitkPointSet_h
 
#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);
 
  itkEventMacroDeclaration(PointSetEvent, itk::AnyEvent);
  itkEventMacroDeclaration(PointSetMoveEvent, PointSetEvent);
  itkEventMacroDeclaration(PointSetSizeChangeEvent, PointSetEvent);
  itkEventMacroDeclaration(PointSetAddEvent, PointSetSizeChangeEvent);
  itkEventMacroDeclaration(PointSetRemoveEvent, PointSetSizeChangeEvent);
  itkEventMacroDeclaration(PointSetExtendTimeRangeEvent, PointSetEvent);
 
} // namespace mitk
 
#endif