itkConstNeighborhoodIterator.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 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 OffsetType = typename Superclass::OffsetType;
  using RadiusType = typename Superclass::RadiusType;
  using SizeType = typename Superclass::SizeType;
  using Iterator = typename Superclass::Iterator;
  using ConstIterator = 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();

  ~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; }

  ITK_ITERATOR_VIRTUAL IndexType GetIndex() const ITK_ITERATOR_FINAL
  { return m_Loop;  }

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

  ITK_ITERATOR_VIRTUAL NeighborhoodType GetNeighborhood() const ITK_ITERATOR_FINAL;

  ITK_ITERATOR_VIRTUAL PixelType GetPixel(const NeighborIndexType i) const ITK_ITERATOR_FINAL
  {
    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);
  }

  ITK_ITERATOR_VIRTUAL PixelType GetPixel(NeighborIndexType i, bool & IsInBounds) const ITK_ITERATOR_FINAL;

  ITK_ITERATOR_VIRTUAL PixelType GetPixel(const OffsetType & o) const ITK_ITERATOR_FINAL
  {
    bool inbounds;

    return ( this->GetPixel(this->GetNeighborhoodIndex(o), inbounds) );
  }

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

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

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

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

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

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

  ITK_ITERATOR_VIRTUAL IndexType GetIndex(NeighborIndexType i) const ITK_ITERATOR_FINAL
  { 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];   }

  ITK_ITERATOR_VIRTUAL void GoToBegin() ITK_ITERATOR_FINAL;

  ITK_ITERATOR_VIRTUAL void GoToEnd() ITK_ITERATOR_FINAL;

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

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

  ITK_ITERATOR_VIRTUAL bool IsAtEnd() const ITK_ITERATOR_FINAL
  {
    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();   }

  bool operator!=(const Self & it) const
  {    return it.GetCenterPointer() != this->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();  }

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

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

  ITK_ITERATOR_VIRTUAL void ResetBoundaryCondition() ITK_ITERATOR_FINAL
  { 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;
  }

  ITK_ITERATOR_VIRTUAL void SetRegion(const RegionType & region) ITK_ITERATOR_FINAL;

protected:

  ITK_ITERATOR_VIRTUAL void SetLoop(const IndexType & p) ITK_ITERATOR_FINAL
  {  m_Loop = p; m_IsInBoundsValid = false; }

  ITK_ITERATOR_VIRTUAL void SetBound(const SizeType &) ITK_ITERATOR_FINAL;

  ITK_ITERATOR_VIRTUAL void SetPixelPointers(const IndexType &) ITK_ITERATOR_FINAL;

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

  ITK_ITERATOR_VIRTUAL void SetEndIndex() ITK_ITERATOR_FINAL;

  IndexType m_BeginIndex;

  IndexType m_Bound;

  const InternalPixelType *m_Begin;

  typename ImageType::ConstWeakPointer m_ConstImage;

  const InternalPixelType *m_End;

  IndexType m_EndIndex;

  IndexType m_Loop;

  RegionType m_Region;

  OffsetType m_WrapOffset;

  ImageBoundaryConditionPointerType m_BoundaryCondition;

  mutable bool m_InBounds[Dimension];

  mutable bool m_IsInBounds{false};

  mutable bool m_IsInBoundsValid{false};

  IndexType m_InnerBoundsLow;

  IndexType m_InnerBoundsHigh;

  TBoundaryCondition m_InternalBoundaryCondition;

  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