itkConstNeighborhoodIterator.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 itkConstNeighborhoodIterator_h
#define itkConstNeighborhoodIterator_h
 
#include <vector>
#include <cstring>
#include <iostream>
#include "itkImage.h"
#include "itkNeighborhood.h"
#include "itkMacro.h"
#include "itkZeroFluxNeumannBoundaryCondition.h"
 
namespace itk
{
template <typename TImage, typename TBoundaryCondition = ZeroFluxNeumannBoundaryCondition<TImage>>
class ITK_TEMPLATE_EXPORT ConstNeighborhoodIterator
  : public Neighborhood<typename TImage::InternalPixelType *, TImage::ImageDimension>
{
public:
  using InternalPixelType = typename TImage::InternalPixelType;
  using PixelType = typename TImage::PixelType;

  using DimensionValueType = unsigned int;

  static constexpr DimensionValueType Dimension = TImage::ImageDimension;

  using Self = ConstNeighborhoodIterator;
  using Superclass = Neighborhood<InternalPixelType *, Self::Dimension>;

  using typename Superclass::OffsetType;
  using typename Superclass::RadiusType;
  using typename Superclass::SizeType;
  using typename Superclass::Iterator;
  using typename Superclass::ConstIterator;

  using ImageType = TImage;
  using RegionType = typename TImage::RegionType;
  using IndexType = Index<Self::Dimension>;
  using NeighborhoodType = Neighborhood<PixelType, Self::Dimension>;
 

  using BoundaryConditionType = TBoundaryCondition;
 
  using OutputImageType = typename BoundaryConditionType::OutputImageType;

  using NeighborIndexType = typename NeighborhoodType::NeighborIndexType;

  using NeighborhoodAccessorFunctorType = typename ImageType::NeighborhoodAccessorFunctorType;

  using ImageBoundaryConditionPointerType = ImageBoundaryCondition<ImageType, OutputImageType> *;
  using ImageBoundaryConditionConstPointerType = const ImageBoundaryCondition<ImageType, OutputImageType> *;

  ConstNeighborhoodIterator() = default;

  ~ConstNeighborhoodIterator() override = default;

  ConstNeighborhoodIterator(const ConstNeighborhoodIterator &);

  ConstNeighborhoodIterator(const SizeType & radius, const ImageType * ptr, const RegionType & region)
  {
    this->Initialize(radius, ptr, region);
    for (DimensionValueType i = 0; i < Dimension; ++i)
    {
      m_InBounds[i] = false;
    }
    this->ResetBoundaryCondition();
    m_NeighborhoodAccessorFunctor = ptr->GetNeighborhoodAccessor();
    m_NeighborhoodAccessorFunctor.SetBegin(ptr->GetBufferPointer());
  }


  Self &
  operator=(const Self & orig);

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

  OffsetType
  ComputeInternalIndex(const NeighborIndexType n) const;

  IndexType
  GetBound() const
  {
    return m_Bound;
  }

  IndexValueType
  GetBound(NeighborIndexType n) const
  {
    return m_Bound[n];
  }

  const InternalPixelType *
  GetCenterPointer() const
  {
    return (this->operator[]((this->Size()) >> 1));
  }

  PixelType
  GetCenterPixel() const
  {
    return m_NeighborhoodAccessorFunctor.Get(this->GetCenterPointer());
  }

  const ImageType *
  GetImagePointer() const
  {
    return m_ConstImage;
  }

  IndexType
  GetIndex() const
  {
    return m_Loop;
  }
 
  inline IndexType
  GetFastIndexPlusOffset(const OffsetType & o) const
  {
    return m_Loop + o;
  }

  NeighborhoodType
  GetNeighborhood() const;

  PixelType
  GetPixel(const NeighborIndexType i) const
  {
    if (!m_NeedToUseBoundaryCondition || this->InBounds())
    {
      return (m_NeighborhoodAccessorFunctor.Get(this->operator[](i)));
    }
 
    OffsetType internalIndex;
    OffsetType offset;
 
    return this->IndexInBounds(i, internalIndex, offset)
             ? m_NeighborhoodAccessorFunctor.Get(this->operator[](i))
             : m_NeighborhoodAccessorFunctor.BoundaryCondition(internalIndex, offset, this, m_BoundaryCondition);
  }

  PixelType
  GetPixel(NeighborIndexType n, bool & IsInBounds) const;

  PixelType
  GetPixel(const OffsetType & o) const
  {
    bool inbounds;
 
    return (this->GetPixel(this->GetNeighborhoodIndex(o), inbounds));
  }

  PixelType
  GetPixel(const OffsetType & o, bool & IsInBounds) const
  {
    return (this->GetPixel(this->GetNeighborhoodIndex(o), IsInBounds));
  }

  PixelType
  GetNext(const unsigned int axis, NeighborIndexType i) const
  {
    return (this->GetPixel(this->GetCenterNeighborhoodIndex() + (i * this->GetStride(axis))));
  }

  PixelType
  GetNext(const unsigned int axis) const
  {
    return (this->GetPixel(this->GetCenterNeighborhoodIndex() + this->GetStride(axis)));
  }

  PixelType
  GetPrevious(const unsigned int axis, NeighborIndexType i) const
  {
    return (this->GetPixel(this->GetCenterNeighborhoodIndex() - (i * this->GetStride(axis))));
  }

  PixelType
  GetPrevious(const unsigned int axis) const
  {
    return (this->GetPixel(this->GetCenterNeighborhoodIndex() - this->GetStride(axis)));
  }

  IndexType
  GetIndex(const OffsetType & o) const
  {
    return (this->GetIndex() + o);
  }

  IndexType
  GetIndex(NeighborIndexType i) const
  {
    return (this->GetIndex() + this->GetOffset(i));
  }

  RegionType
  GetRegion() const
  {
    return m_Region;
  }

  IndexType
  GetBeginIndex() const
  {
    return m_BeginIndex;
  }

  RegionType
  GetBoundingBoxAsImageRegion() const;

  OffsetType
  GetWrapOffset() const
  {
    return m_WrapOffset;
  }

  OffsetValueType
  GetWrapOffset(NeighborIndexType n) const
  {
    return m_WrapOffset[n];
  }

  void
  GoToBegin();

  void
  GoToEnd();

  void
  Initialize(const SizeType & radius, const ImageType * ptr, const RegionType & region);

  bool
  IsAtBegin() const
  {
    return (this->GetCenterPointer() == m_Begin);
  }

  bool
  IsAtEnd() const
  {
    if (this->GetCenterPointer() > m_End)
    {
      ExceptionObject    e(__FILE__, __LINE__);
      std::ostringstream msg;
      msg << "In method IsAtEnd, CenterPointer = " << this->GetCenterPointer() << " is greater than End = " << m_End
          << std::endl
          << "  " << *this;
      e.SetDescription(msg.str().c_str());
      throw e;
    }
    return (this->GetCenterPointer() == m_End);
  }


  Self &
  operator++();

  Self &
  operator--();

  bool
  operator==(const Self & it) const
  {
    return it.GetCenterPointer() == this->GetCenterPointer();
  }
 
  ITK_UNEQUAL_OPERATOR_MEMBER_FUNCTION(Self);

  bool
  operator<(const Self & it) const
  {
    return this->GetCenterPointer() < it.GetCenterPointer();
  }

  bool
  operator<=(const Self & it) const
  {
    return this->GetCenterPointer() <= it.GetCenterPointer();
  }

  bool
  operator>(const Self & it) const
  {
    return this->GetCenterPointer() > it.GetCenterPointer();
  }

  bool
  operator>=(const Self & it) const
  {
    return this->GetCenterPointer() >= it.GetCenterPointer();
  }

  void
  SetLocation(const IndexType & position)
  {
    this->SetLoop(position);
    this->SetPixelPointers(position);
  }


  Self &
  operator+=(const OffsetType &);

  Self &
  operator-=(const OffsetType &);

  OffsetType
  operator-(const Self & b) const
  {
    return m_Loop - b.m_Loop;
  }

  bool
  InBounds() const;

  bool
  IndexInBounds(const NeighborIndexType n, OffsetType & internalIndex, OffsetType & offset) const;

  bool
  IndexInBounds(const NeighborIndexType n) const;

  void
  OverrideBoundaryCondition(const ImageBoundaryConditionPointerType i)
  {
    m_BoundaryCondition = i;
  }

  void
  ResetBoundaryCondition()
  {
    m_BoundaryCondition = &m_InternalBoundaryCondition;
  }

  void
  SetBoundaryCondition(const TBoundaryCondition & c)
  {
    m_InternalBoundaryCondition = c;
  }

  ImageBoundaryConditionPointerType
  GetBoundaryCondition() const
  {
    return m_BoundaryCondition;
  }

  void
  NeedToUseBoundaryConditionOn()
  {
    this->SetNeedToUseBoundaryCondition(true);
  }
 
  void
  NeedToUseBoundaryConditionOff()
  {
    this->SetNeedToUseBoundaryCondition(false);
  }
 
  void
  SetNeedToUseBoundaryCondition(bool b)
  {
    m_NeedToUseBoundaryCondition = b;
  }
 
  bool
  GetNeedToUseBoundaryCondition() const
  {
    return m_NeedToUseBoundaryCondition;
  }

  void
  SetRegion(const RegionType & region);
 
protected:
  void
  SetLoop(const IndexType & p)
  {
    m_Loop = p;
    m_IsInBoundsValid = false;
  }

  void
  SetBound(const SizeType &);

  void
  SetPixelPointers(const IndexType &);

  void
  SetBeginIndex(const IndexType & start)
  {
    m_BeginIndex = start;
  }

  void
  SetEndIndex();

  IndexType m_BeginIndex{ { 0 } };

  IndexType m_Bound{ { 0 } };

  const InternalPixelType * m_Begin{ nullptr };

  typename ImageType::ConstWeakPointer m_ConstImage{};

  const InternalPixelType * m_End{ nullptr };

  IndexType m_EndIndex{ { 0 } };

  IndexType m_Loop{ { 0 } };

  RegionType m_Region{};

  OffsetType m_WrapOffset{ { 0 } };

  TBoundaryCondition m_InternalBoundaryCondition{};

  ImageBoundaryConditionPointerType m_BoundaryCondition{ &m_InternalBoundaryCondition };

  mutable bool m_InBounds[Dimension]{ false };

  mutable bool m_IsInBounds{ false };

  mutable bool m_IsInBoundsValid{ false };

  IndexType m_InnerBoundsLow{};

  IndexType m_InnerBoundsHigh{};

  bool m_NeedToUseBoundaryCondition{ false };

  NeighborhoodAccessorFunctorType m_NeighborhoodAccessorFunctor{};
};
 
template <typename TImage>
inline ConstNeighborhoodIterator<TImage>
operator+(const ConstNeighborhoodIterator<TImage> &                      it,
          const typename ConstNeighborhoodIterator<TImage>::OffsetType & ind)
{
  ConstNeighborhoodIterator<TImage> ret(it);
  ret += ind;
  return ret;
}
 
template <typename TImage>
inline ConstNeighborhoodIterator<TImage>
operator+(const typename ConstNeighborhoodIterator<TImage>::OffsetType & ind,
          const ConstNeighborhoodIterator<TImage> &                      it)
{
  return (it + ind);
}
 
template <typename TImage>
inline ConstNeighborhoodIterator<TImage>
operator-(const ConstNeighborhoodIterator<TImage> &                      it,
          const typename ConstNeighborhoodIterator<TImage>::OffsetType & ind)
{
  ConstNeighborhoodIterator<TImage> ret(it);
  ret -= ind;
  return ret;
}
} // namespace itk
 
#ifndef ITK_MANUAL_INSTANTIATION
#  include "itkConstNeighborhoodIterator.hxx"
#endif
 
#endif