itkSpatialObject.h

Go to the documentation of this file.

/*=========================================================================
 *
 *  Copyright Insight Software Consortium
 *
 *  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
 *
 *         http://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 "itkExceptionObject.h"
#include <list>
#include "itkSpatialObjectProperty.h"
#include "itkProcessObject.h"
#include "itkIndex.h"
#include "itkImageRegion.h"
#include "itkAffineTransform.h"
#include "itkVectorContainer.h"
#include "itkBoundingBox.h"

namespace itk
{
template< unsigned int VDimension = 3 >
class ITK_TEMPLATE_EXPORT SpatialObject:
  public DataObject
{
public:
  ITK_DISALLOW_COPY_AND_ASSIGN(SpatialObject);

  using ScalarType = double;

  using ObjectDimensionType = unsigned int;

  static constexpr ObjectDimensionType ObjectDimension = VDimension;

  static constexpr unsigned int MaximumDepth = 9999999;

  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< IdentifierType, PointType >;

  using BoundingBoxType = BoundingBox< IdentifierType, VDimension,
          ScalarType, VectorContainerType >;
  using BoundingBoxPointer = typename BoundingBoxType::Pointer;

  using ChildrenListType = std::list< Pointer >;
  using ChildrenListPointer = ChildrenListType *;

  using ObjectListType = std::list< Pointer >;

  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);

  itkTypeMacro(SpatialObject, DataObject);

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

  itkSetMacro(TypeName, std::string);

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

  virtual std::string GetClassNameAndDimension( void ) const;

  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 ComputeObjectToWorldTransform();

  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
   *    overwrite.
   *    * ComputeMyBoundingBox
   *    * IsInsideInObjectSpace
   *    * Update
   *  Optionally, a subclass may also wish to overwrite
   *    * ValueAtInObjectSpace
   *    * IsEvaluableAtInObjectSpace - if the extent is beyond IsInisde.
   */

/**********************************************************************/

  virtual bool ComputeMyBoundingBox() const;

  virtual bool IsInsideInObjectSpace(const PointType & point,
                        unsigned int depth = 0,
                        const std::string & name = "") 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);

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

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

  virtual 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 & spacing = 1);

  virtual void DerivativeAtInWorldSpace(const PointType & point,
                            short unsigned int order,
                            CovariantVectorType & value,
                            unsigned int depth = 0,
                            const std::string & name = "",
                            const DerivativeOffsetType & spacing = 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 *object);

  void RemoveAllChildren( unsigned int depth = MaximumDepth );

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

  virtual void AddChildrenToList(ChildrenListType * children,
    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); }


protected:

  SpatialObject();

  ~SpatialObject() override;

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

  BoundingBoxType * GetModifiableMyBoundingBoxInObjectSpace() const
  { return m_MyBoundingBoxInObjectSpace.GetPointer(); }

  typename LightObject::Pointer InternalClone() const override;

private:

  int             m_Id;

  std::string     m_TypeName;

  PropertyType    m_Property;

  int             m_ParentId;
  Self *          m_Parent;

  RegionType      m_LargestPossibleRegion;
  RegionType      m_RequestedRegion;
  RegionType      m_BufferedRegion;

  BoundingBoxPointer m_MyBoundingBoxInObjectSpace;
  BoundingBoxPointer m_MyBoundingBoxInWorldSpace;
  BoundingBoxPointer m_FamilyBoundingBoxInObjectSpace;
  BoundingBoxPointer m_FamilyBoundingBoxInWorldSpace;

  TransformPointer m_ObjectToParentTransform;
  TransformPointer m_ObjectToParentTransformInverse;

  TransformPointer m_ObjectToWorldTransform;
  TransformPointer m_ObjectToWorldTransformInverse;

  ChildrenListType m_ChildrenList;

  double m_DefaultInsideValue;

  double m_DefaultOutsideValue;

};

} // end of namespace itk

#if !defined( ITK_WRAPPING_PARSER )
#ifndef ITK_MANUAL_INSTANTIATION
#include "itkSpatialObject.hxx"
#endif
#endif

#endif // itkSpatialObject_h