itkSpatialObject.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 itkSpatialObject_h
#define itkSpatialObject_h
 
// Disable warning for lengthy symbol names in this file only
 
#include "itkCovariantVector.h"
#include "itkMacro.h"
#include <list>
#include "itkSpatialObjectProperty.h"
#include "itkProcessObject.h"
#include "itkIndex.h"
#include "itkImageRegion.h"
#include "itkAffineTransform.h"
#include "itkVectorContainer.h"
#include "itkBoundingBox.h"
#include <limits>
 
namespace itk
{
 
template <unsigned int VDimension = 3>
class ITK_TEMPLATE_EXPORT SpatialObject : public DataObject
{
public:
  ITK_DISALLOW_COPY_AND_MOVE(SpatialObject);
 
  using ScalarType = double;
 
  using ObjectDimensionType = unsigned int;
 
  static constexpr ObjectDimensionType ObjectDimension = VDimension;
 
  static constexpr unsigned int MaximumDepth = std::numeric_limits<unsigned int>::max();

  unsigned int
  GetMaximumDepth() const
  {
    return MaximumDepth;
  }
 
  using Self = SpatialObject<VDimension>;
  using Superclass = DataObject;
 
  using Pointer = SmartPointer<Self>;
  using ConstPointer = SmartPointer<const Self>;
 
 
  // Spatial Function Iterator needs the following type alias
  using InputType = Point<ScalarType, VDimension>;
 
  using PointType = Point<ScalarType, VDimension>;
  using PointPointer = PointType *;
  using VectorType = Vector<ScalarType, VDimension>;
  using CovariantVectorType = CovariantVector<ScalarType, VDimension>;
  using VectorPointer = VectorType *;
 
  using DerivativeVectorType = CovariantVector<ScalarType, VDimension>;
  using DerivativeVectorPointer = DerivativeVectorType *;
 
  using DerivativeOffsetType = Vector<double, VDimension>;
 
  using TransformType = AffineTransform<ScalarType, VDimension>;
  using TransformPointer = typename TransformType::Pointer;
  using TransformConstPointer = const TransformType *;
 
  using VectorContainerType = VectorContainer<PointType>;
 
  using BoundingBoxType = BoundingBox<IdentifierType, VDimension, ScalarType, VectorContainerType>;
  using BoundingBoxPointer = typename BoundingBoxType::Pointer;

  using ChildrenListType = std::list<Pointer>;
  using ChildrenConstListType = std::list<ConstPointer>;
  using ChildrenListPointer = ChildrenListType *;
  using ChildrenConstListPointer = ChildrenConstListType *;
 
  using ObjectListType = std::list<Pointer>;
  using ObjectConstListType = std::list<ConstPointer>;
 
  using RegionType = ImageRegion<VDimension>;
 
  using PropertyType = SpatialObjectProperty;
 
  /* These are needed to participate in a Pipeline */
  using IndexType = Index<VDimension>;
  using SizeType = Size<VDimension>;

  unsigned int
  GetObjectDimension() const
  {
    return VDimension;
  }

  itkNewMacro(Self);

  itkOverrideGetNameOfClassMacro(SpatialObject);

  void
  SetId(int id);
  itkGetConstReferenceMacro(Id, int);

  itkSetMacro(TypeName, std::string);

  virtual std::string
  GetTypeName() const
  {
    return m_TypeName;
  }

  virtual std::string
  GetClassNameAndDimension() const;

  virtual void
  Clear();

  void
  SetProperty(const PropertyType & property)
  {
    this->m_Property = property;
    this->Modified();
  }

  const PropertyType &
  GetProperty() const
  {
    return this->m_Property;
  }
 
  PropertyType &
  GetProperty()
  {
    return this->m_Property;
  }

  ModifiedTimeType
  GetMTime() const override;

  ModifiedTimeType
  GetMyMTime() const
  {
    return Superclass::GetMTime();
  }
 
 
  /**************/
  /* Transforms */
 
  /**************/

  void
  SetObjectToWorldTransform(const TransformType * transform);
  itkGetModifiableObjectMacro(ObjectToWorldTransform, TransformType);
  const TransformType *
  GetObjectToWorldTransformInverse() const;

  void
  SetObjectToParentTransform(const TransformType * transform);
  itkGetModifiableObjectMacro(ObjectToParentTransform, TransformType);
  const TransformType *
  GetObjectToParentTransformInverse() const;

  void
  ComputeObjectToParentTransform();
 
  /**********************************************************************/
  /* These are the three member functions that a subclass will typically
   *    override.
   *    * ComputeMyBoundingBox (protected:)
   *    * IsInsideInObjectSpace
   *    * Update
   *  Optionally, a subclass may also wish to override
   *    * ValueAtInObjectSpace
   *    * IsEvaluableAtInObjectSpace - if the extent is beyond IsInside.
   */
 
  /**********************************************************************/

  bool
  IsInsideInObjectSpace(const PointType & point, unsigned int depth, const std::string & name = "") const;

  virtual bool
  IsInsideInObjectSpace(const PointType & point) const;

  void
  Update() override;
 

  virtual bool
  ValueAtInObjectSpace(const PointType &   point,
                       double &            value,
                       unsigned int        depth = 0,
                       const std::string & name = "") const;

  virtual bool
  IsEvaluableAtInObjectSpace(const PointType & point, unsigned int depth = 0, const std::string & name = "") const;
 
  /********************************************************/
  /* Helper functions to recurse queries through children */
 
  /********************************************************/

  virtual bool
  IsInsideChildrenInObjectSpace(const PointType & point, unsigned int depth = 0, const std::string & name = "") const;

  virtual bool
  ValueAtChildrenInObjectSpace(const PointType &   point,
                               double &            value,
                               unsigned int        depth = 0,
                               const std::string & name = "") const;

  virtual bool
  IsEvaluableAtChildrenInObjectSpace(const PointType &   point,
                                     unsigned int        depth = 0,
                                     const std::string & name = "") const;
 
 
  /**************************/
  /* Values and derivatives */
 
  /**************************/

  itkSetMacro(DefaultInsideValue, double);
  itkGetConstMacro(DefaultInsideValue, double);

  itkSetMacro(DefaultOutsideValue, double);
  itkGetConstMacro(DefaultOutsideValue, double);

#ifndef ITK_FUTURE_LEGACY_REMOVE
  virtual
#endif
    bool
    ValueAtInWorldSpace(const PointType &   point,
                        double &            value,
                        unsigned int        depth = 0,
                        const std::string & name = "") const;

#ifndef ITK_FUTURE_LEGACY_REMOVE
  virtual
#endif
    bool
    IsInsideInWorldSpace(const PointType & point, unsigned int depth, const std::string & name = "") const;

  bool
  IsInsideInWorldSpace(const PointType & point) const;

#ifndef ITK_FUTURE_LEGACY_REMOVE
  virtual
#endif
    bool
    IsEvaluableAtInWorldSpace(const PointType & point, unsigned int depth = 0, const std::string & name = "") const;
 

  virtual void
  DerivativeAtInObjectSpace(const PointType &            point,
                            short unsigned int           order,
                            CovariantVectorType &        value,
                            unsigned int                 depth = 0,
                            const std::string &          name = "",
                            const DerivativeOffsetType & offset = MakeFilled<DerivativeOffsetType>(1));

#ifndef ITK_FUTURE_LEGACY_REMOVE
  virtual
#endif
    void
    DerivativeAtInWorldSpace(const PointType &            point,
                             short unsigned int           order,
                             CovariantVectorType &        value,
                             unsigned int                 depth = 0,
                             const std::string &          name = "",
                             const DerivativeOffsetType & offset = MakeFilled<DerivativeOffsetType>(1));
 
 
  /*********************/
  /* Deal with Parents */
 
  /*********************/

  void
  SetParent(Self * parent);

  virtual bool
  HasParent() const;

  virtual const Self *
  GetParent() const;

  virtual Self *
  GetParent();

  itkSetMacro(ParentId, int);
  itkGetConstReferenceMacro(ParentId, int);
 
  /**********************/
  /* Deal with Children */
 
  /**********************/

  void
  SetChildren(ChildrenListType & children);

  void
  AddChild(Self * pointer);

  bool
  RemoveChild(Self * pointer);

  void
  RemoveAllChildren(unsigned int depth = MaximumDepth);

  virtual ChildrenListType *
  GetChildren(unsigned int depth = 0, const std::string & name = "") const;

  virtual ChildrenConstListType *
  GetConstChildren(unsigned int depth = 0, const std::string & name = "") const;
 
  virtual void
  AddChildrenToList(ChildrenListType * childrenList, unsigned int depth = 0, const std::string & name = "") const;
 
  virtual void
  AddChildrenToConstList(ChildrenConstListType * childrenCList,
                         unsigned int            depth = 0,
                         const std::string &     name = "") const;

  unsigned int
  GetNumberOfChildren(unsigned int depth = 0, const std::string & name = "") const;

  SpatialObject<VDimension> *
  GetObjectById(int id);

  bool
  FixParentChildHierarchyUsingParentIds();

  bool
  CheckIdValidity() const;

  void
  FixIdValidity();

  int
  GetNextAvailableId() const;
 
 
  /**********************/
  /* Bounding Box       */
 
  /**********************/

  itkGetConstObjectMacro(MyBoundingBoxInObjectSpace, BoundingBoxType);

  virtual const BoundingBoxType *
  GetMyBoundingBoxInWorldSpace() const;

  virtual bool
  ComputeFamilyBoundingBox(unsigned int depth = 0, const std::string & name = "") const;

  itkGetConstObjectMacro(FamilyBoundingBoxInObjectSpace, BoundingBoxType);

  virtual const BoundingBoxType *
  GetFamilyBoundingBoxInWorldSpace() const;
 
 
  /******************************/
  /* Regions used by DataObject */
 
  /******************************/

  virtual void
  SetLargestPossibleRegion(const RegionType & region);

  virtual const RegionType &
  GetLargestPossibleRegion() const
  {
    return m_LargestPossibleRegion;
  }

  virtual void
  SetBufferedRegion(const RegionType & region);

  virtual const RegionType &
  GetBufferedRegion() const
  {
    return m_BufferedRegion;
  }

  virtual void
  SetRequestedRegion(const RegionType & region);

  void
  SetRequestedRegion(const DataObject * data) override;

  virtual const RegionType &
  GetRequestedRegion() const
  {
    return m_RequestedRegion;
  }

  void
  SetRequestedRegionToLargestPossibleRegion() override;

  bool
  RequestedRegionIsOutsideOfTheBufferedRegion() override;

  bool
  VerifyRequestedRegion() override;

  void
  UpdateOutputInformation() override;

  void
  CopyInformation(const DataObject * data) override;
 
  /*************************************/
  /* Evaluate used by SpatialFunctions */
 
  /*************************************/

  bool
  Evaluate(const PointType & point) const
  {
    return this->IsInsideInWorldSpace(point);
  }
 
#if !defined(ITK_LEGACY_REMOVE)
  itkLegacyMacro(void ComputeObjectToWorldTransform())
  {
    this->Update(); /* Update() should be used instead of ProtectedComputeObjectToWorldTransform() */
  }
 
  itkLegacyMacro(void ComputeBoundingBox())
  {
    this->Update(); /* Update() should be used instead of outdated ComputeBoundingBox() */
  }

  itkLegacyMacro(virtual bool IsInside(const PointType & point, unsigned int depth = 0, const std::string & name = "")
                   const)
  {
    return IsInsideInObjectSpace(point, depth, name);
  }
 
#endif
 
protected:
  void
  ProtectedComputeObjectToWorldTransform();

  virtual void
  ComputeMyBoundingBox();

  SpatialObject() = default;

  ~SpatialObject() override;
 
  void
  PrintSelf(std::ostream & os, Indent indent) const override;
 
  BoundingBoxType *
  GetModifiableMyBoundingBoxInObjectSpace()
  {
    return m_MyBoundingBoxInObjectSpace.GetPointer();
  }
 
  typename LightObject::Pointer
  InternalClone() const override;
 
private:
  int m_Id{ -1 };

  std::string m_TypeName{ "SpatialObject" };
 
  PropertyType m_Property{};
 
  int    m_ParentId{ -1 };
  Self * m_Parent{ nullptr };
 
  RegionType m_LargestPossibleRegion{};
  RegionType m_RequestedRegion{};
  RegionType m_BufferedRegion{};
 
  const BoundingBoxPointer m_MyBoundingBoxInObjectSpace{ BoundingBoxType::New() };
  const BoundingBoxPointer m_MyBoundingBoxInWorldSpace{ BoundingBoxType::New() };
  const BoundingBoxPointer m_FamilyBoundingBoxInObjectSpace{ BoundingBoxType::New() };
  const BoundingBoxPointer m_FamilyBoundingBoxInWorldSpace{ BoundingBoxType::New() };
 
  const TransformPointer m_ObjectToParentTransform{ TransformType::New() };
  const TransformPointer m_ObjectToParentTransformInverse{ TransformType::New() };
 
  const TransformPointer m_ObjectToWorldTransform{ TransformType::New() };
  const TransformPointer m_ObjectToWorldTransformInverse{ TransformType::New() };
 
  ChildrenListType m_ChildrenList{};

  double m_DefaultInsideValue{ 1.0 };

  double m_DefaultOutsideValue{ 0.0 };
};
 
} // end of namespace itk
 
#if !defined(ITK_WRAPPING_PARSER)
#  ifndef ITK_MANUAL_INSTANTIATION
#    include "itkSpatialObject.hxx"
#  endif
#endif
 
#endif // itkSpatialObject_h