itkContourSpatialObject.h

Go to the documentation of this file.

/*=========================================================================
 *
 *  Copyright NumFOCUS
 *
 *  Licensed under the Apache License, Version 2.0 (the "License");
 *  you may not use this file except in compliance with the License.
 *  You may obtain a copy of the License at
 *
 *         https://www.apache.org/licenses/LICENSE-2.0.txt
 *
 *  Unless required by applicable law or agreed to in writing, software
 *  distributed under the License is distributed on an "AS IS" BASIS,
 *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *  See the License for the specific language governing permissions and
 *  limitations under the License.
 *
 *=========================================================================*/
#ifndef itkContourSpatialObject_h
#define itkContourSpatialObject_h
 
#include <list>
 
#include "itkPointBasedSpatialObject.h"
#include "itkContourSpatialObjectPoint.h"
 
namespace itk
{
/*** \class ContourSpatialObjectEnums
 *
 * \brief Enum classes for the ContourSpatialObject class.
 *
 * \ingroup ITKSpatialObjects
 */
class ContourSpatialObjectEnums
{
public:
  /*** \class InterpolationMethodEnum
   * \ingroup ITKSpatialObjects
   * Hold interpolation method type
   */
  enum class InterpolationMethod : uint8_t
  {
    NO_INTERPOLATION = 0,
    EXPLICIT_INTERPOLATION,
    BEZIER_INTERPOLATION,
    LINEAR_INTERPOLATION
  };
};
// Define how to print enumeration
extern ITKSpatialObjects_EXPORT std::ostream &
                                operator<<(std::ostream & out, ContourSpatialObjectEnums::InterpolationMethod value);
 
template <unsigned int TDimension = 3>
class ITK_TEMPLATE_EXPORT ContourSpatialObject
  : public PointBasedSpatialObject<TDimension, ContourSpatialObjectPoint<TDimension>>
{
public:
  ITK_DISALLOW_COPY_AND_MOVE(ContourSpatialObject);
 
  using Self = ContourSpatialObject;
  using Superclass = PointBasedSpatialObject<TDimension, ContourSpatialObjectPoint<TDimension>>;
  using Pointer = SmartPointer<Self>;
  using ConstPointer = SmartPointer<const Self>;
 
  using ScalarType = double;
 
  using ContourPointType = ContourSpatialObjectPoint<TDimension>;
  using ContourPointListType = std::vector<ContourPointType>;
  using ControlPointType = ContourSpatialObjectPoint<TDimension>;
  using ControlPointListType = std::vector<ControlPointType>;
 
  using typename Superclass::PointType;
  using typename Superclass::TransformType;
  using typename Superclass::BoundingBoxType;
  using PointContainerType = VectorContainer<IdentifierType, PointType>;
  using PointContainerPointer = SmartPointer<PointContainerType>;
 
  using InterpolationMethodEnum = ContourSpatialObjectEnums::InterpolationMethod;
#if !defined(ITK_LEGACY_REMOVE)
 
  // We need to expose the enum values at the class level
  // for backwards compatibility
  static constexpr InterpolationMethodEnum NO_INTERPOLATION = InterpolationMethodEnum::NO_INTERPOLATION;
  static constexpr InterpolationMethodEnum EXPLICIT_INTERPOLATION = InterpolationMethodEnum::EXPLICIT_INTERPOLATION;
  static constexpr InterpolationMethodEnum BEZIER_INTERPOLATION = InterpolationMethodEnum::BEZIER_INTERPOLATION;
  static constexpr InterpolationMethodEnum LINEAR_INTERPOLATION = InterpolationMethodEnum::LINEAR_INTERPOLATION;
#endif
 
  itkNewMacro(Self);
 
  itkOverrideGetNameOfClassMacro(ContourSpatialObject);
 
  void
  Clear() override;
 
  ControlPointListType &
  GetControlPoints()
  {
    return m_ControlPoints;
  }
 
  const ControlPointListType &
  GetControlPoints() const
  {
    return m_ControlPoints;
  }
 
  void
  SetControlPoints(const ControlPointListType & points);
 
  void
  AddControlPoint(const ControlPointType & point);
 
  const ControlPointType *
  GetControlPoint(IdentifierType id) const
  {
    return &(m_ControlPoints[id]);
  }
 
  ControlPointType *
  GetControlPoint(IdentifierType id)
  {
    return &(m_ControlPoints[id]);
  }
 
  SizeValueType
  GetNumberOfControlPoints() const
  {
    return static_cast<SizeValueType>(m_ControlPoints.size());
  }
 
  itkSetEnumMacro(InterpolationMethod, InterpolationMethodEnum);
 
  itkGetConstMacro(InterpolationMethod, InterpolationMethodEnum);
 
  itkSetMacro(InterpolationFactor, unsigned int);
 
  itkGetConstMacro(InterpolationFactor, unsigned int);
 
  itkSetMacro(IsClosed, bool);
 
  itkGetConstMacro(IsClosed, bool);
 
  itkBooleanMacro(IsClosed);
 
  int
  GetOrientationInObjectSpace() const;
 
  itkSetMacro(AttachedToSlice, int);
 
  itkGetConstMacro(AttachedToSlice, int);
 
  void
  Update() override;
 
protected:
  ContourSpatialObject();
  ~ContourSpatialObject() override = default;
 
  void
  PrintSelf(std::ostream & os, Indent indent) const override;
 
  typename LightObject::Pointer
  InternalClone() const override;
 
private:
  ContourPointListType m_ControlPoints{};
 
  InterpolationMethodEnum m_InterpolationMethod{};
  unsigned int            m_InterpolationFactor{};
 
  mutable bool             m_IsClosed{};
  mutable int              m_OrientationInObjectSpace{};
  mutable ModifiedTimeType m_OrientationInObjectSpaceMTime{};
  int                      m_AttachedToSlice{};
};
} // end namespace itk
 
#ifndef ITK_MANUAL_INSTANTIATION
#  include "itkContourSpatialObject.hxx"
#endif
 
#endif // itkContourSpatialObject_h