itkConstNeighborhoodIterator.h

Go to the documentation of this file.

/*=========================================================================

  Program:   Insight Segmentation & Registration Toolkit
  Module:    $RCSfile: itkConstNeighborhoodIterator.h,v $
  Language:  C++
  Date:      $Date: 2005/09/07 14:46:30 $
  Version:   $Revision: 1.34 $

  Copyright (c) Insight Software Consortium. All rights reserved.
  See ITKCopyright.txt or http://www.itk.org/HTML/Copyright.htm for details.

     This software is distributed WITHOUT ANY WARRANTY; without even 
     the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR 
     PURPOSE.  See the above copyright notices for more information.

=========================================================================*/
#ifndef __itkConstNeighborhoodIterator_h
#define __itkConstNeighborhoodIterator_h

#include <vector>
#include <string.h>
#include <iostream>
#include "itkImage.h"
#include "itkIndex.h"
#include "itkOffset.h"
#include "itkSize.h"
#include "itkImageRegion.h"
#include "itkMacro.h"
#include "itkNeighborhood.h"
#include "itkImageBoundaryCondition.h"
#include "itkExceptionObject.h"
#include "itkZeroFluxNeumannBoundaryCondition.h"

namespace itk {

template<class TImage,  class TBoundaryCondition
                       = ZeroFluxNeumannBoundaryCondition<TImage> >
class ITK_EXPORT ConstNeighborhoodIterator
  :  public Neighborhood<ITK_TYPENAME TImage::InternalPixelType *,
                         ::itk::GetImageDimension<TImage>::ImageDimension>
{
public:
  typedef typename TImage::InternalPixelType InternalPixelType;
  typedef typename TImage::PixelType PixelType;
    
  itkStaticConstMacro(Dimension, unsigned int, TImage::ImageDimension);
  
  typedef ConstNeighborhoodIterator Self;
  typedef Neighborhood<InternalPixelType *, itkGetStaticConstMacro(Dimension)> Superclass;

  typedef typename Superclass::OffsetType OffsetType;
  typedef typename OffsetType::OffsetValueType OffsetValueType;
  typedef typename Superclass::RadiusType RadiusType;  
  typedef typename Superclass::SizeType SizeType;
  typedef typename Superclass::SizeValueType SizeValueType;
  typedef typename Superclass::Iterator Iterator;
  typedef typename Superclass::ConstIterator ConstIterator;
  
  typedef TImage ImageType;
  typedef typename TImage::RegionType RegionType;
  typedef Index<itkGetStaticConstMacro(Dimension)> IndexType;
  typedef typename IndexType::IndexValueType IndexValueType;
  typedef Neighborhood<PixelType, itkGetStaticConstMacro(Dimension)> NeighborhoodType;

  typedef typename ImageType::NeighborhoodAccessorFunctorType NeighborhoodAccessorFunctorType;

  typedef TBoundaryCondition BoundaryConditionType;
  
  typedef ImageBoundaryCondition<ImageType> *ImageBoundaryConditionPointerType;
  typedef ImageBoundaryCondition<ImageType> const *ImageBoundaryConditionConstPointerType;

  ConstNeighborhoodIterator();

  virtual ~ConstNeighborhoodIterator() {}

  ConstNeighborhoodIterator( const ConstNeighborhoodIterator & );

  ConstNeighborhoodIterator(const SizeType &radius,
                       const ImageType * ptr,
                       const RegionType &region
                       )
  {
    this->Initialize(radius, ptr, region);
    for (unsigned int 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);

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

  OffsetType ComputeInternalIndex(unsigned int n) const;

  IndexType GetBound() const
    {    return m_Bound;   }

  long GetBound(unsigned int 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(void) const
    { return m_ConstImage; }
 
  virtual IndexType GetIndex(void) const
    { return m_Loop;  }
  
  virtual NeighborhoodType GetNeighborhood() const;

  virtual PixelType GetPixel(const unsigned i) const
    { 
    if( !m_NeedToUseBoundaryCondition )
      {
      return ( m_NeighborhoodAccessorFunctor.Get( this->operator[]( i ) ) );
      }
    bool inbounds; 
    return this->GetPixel( i, inbounds ); 
    }

  virtual PixelType GetPixel(const unsigned i, bool& IsInBounds) const;

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

  virtual PixelType GetPixel(const OffsetType &o,
                             bool& IsInBounds) const
  { return (this->GetPixel(this->GetNeighborhoodIndex(o), IsInBounds)); }
  
  virtual PixelType GetNext(const unsigned axis, const unsigned i) const
  {    return (this->GetPixel(this->GetCenterNeighborhoodIndex()
                           + (i * this->GetStride(axis)))); }

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

  virtual PixelType GetPrevious(const unsigned axis, const unsigned i) const
  { return (this->GetPixel(this->GetCenterNeighborhoodIndex()
                           - (i * this->GetStride(axis)))); }
  
  virtual PixelType GetPrevious(const unsigned axis) const
  { return (this->GetPixel(this->GetCenterNeighborhoodIndex()
                           - this->GetStride(axis))); } 
  
  virtual IndexType GetIndex(const OffsetType &o) const
  { return (this->GetIndex() + o); }

  virtual IndexType GetIndex(const unsigned 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(unsigned int n) const
    {    return m_WrapOffset[n];   }

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

  virtual bool IsAtBegin() const
    {    return ( this->GetCenterPointer() == m_Begin );   }
  
  virtual bool IsAtEnd() const
    {
      if ( this->GetCenterPointer() > m_End )
        {
        ExceptionObject e(__FILE__, __LINE__);
        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;

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

  virtual void ResetBoundaryCondition()
    { m_BoundaryCondition = &m_InternalBoundaryCondition;  }

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

  const BoundaryConditionType *GetBoundaryCondition() const
  { return dynamic_cast<BoundaryConditionType *>(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;
  }
  
  
protected:
  
  virtual void SetLoop( const IndexType& p )
    {  m_Loop = p; m_IsInBoundsValid = false;}
  
  virtual void SetBound(const SizeType &);

  virtual void SetPixelPointers(const IndexType &);

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

  virtual void SetEndIndex();
  
  IndexType m_BeginIndex;

  IndexType m_Bound;

  const InternalPixelType *m_Begin;
  
  typename ImageType::ConstWeakPointer m_ConstImage;

  /*
   * A pointer to one past the last pixel in the iteration region.
   */
  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;
  
  mutable bool m_IsInBoundsValid;
  
  IndexType m_InnerBoundsLow;
  
  IndexType m_InnerBoundsHigh;

  TBoundaryCondition m_InternalBoundaryCondition;

  bool m_NeedToUseBoundaryCondition;

  NeighborhoodAccessorFunctorType m_NeighborhoodAccessorFunctor;

};

template<class TImage>
inline ConstNeighborhoodIterator<TImage>
operator+(const ConstNeighborhoodIterator<TImage> &it,
          const typename ConstNeighborhoodIterator<TImage>
          ::OffsetType &ind)
{
  ConstNeighborhoodIterator<TImage> ret;
  ret = it;
  ret += ind;
  return ret;
}

template<class TImage>
inline ConstNeighborhoodIterator<TImage>
operator+(const typename ConstNeighborhoodIterator<TImage>
          ::OffsetType &ind,
          const ConstNeighborhoodIterator<TImage> &it)
{  return (it + ind); }

template<class TImage>
inline ConstNeighborhoodIterator<TImage>
operator-(const ConstNeighborhoodIterator<TImage> &it,
          const typename ConstNeighborhoodIterator<TImage>
          ::OffsetType &ind)
{
  ConstNeighborhoodIterator<TImage> ret;
  ret = it;
  ret -= ind;
  return ret;
}












  
} // namespace itk


#ifndef ITK_MANUAL_INSTANTIATION
#include "itkConstNeighborhoodIterator.txx"
#endif

#endif

---