itkConstNeighborhoodIterator.h

Go to the documentation of this file.

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

  Program:   Insight Segmentation & Registration Toolkit
  Module:    $RCSfile: itkConstNeighborhoodIterator.h,v $
  Language:  C++
  Date:      $Date: 2002/09/11 19:39:03 $
  Version:   $Revision: 1.18 $

  Copyright (c) 2002 Insight 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"

namespace itk {

template<class 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::SizeType SizeType;
  typedef typename Superclass::SizeValueType SizeValueType;
  typedef TImage ImageType;
  typedef typename TImage::RegionType RegionType;
  typedef Index<itkGetStaticConstMacro(Dimension)> IndexType;
  typedef typename IndexType::IndexValueType IndexValueType;
  typedef Offset<itkGetStaticConstMacro(Dimension)> OffsetType;
  typedef typename OffsetType::OffsetValueType OffsetValueType;
  typedef typename Superclass::RadiusType RadiusType;
  typedef Neighborhood<PixelType, itkGetStaticConstMacro(Dimension)> NeighborhoodType;
  typedef typename Superclass::Iterator Iterator;
    
  typedef typename Superclass::ConstIterator ConstIterator;

  typedef ImageBoundaryCondition<ImageType> *ImageBoundaryConditionPointerType;

  ConstNeighborhoodIterator();

  virtual ~ConstNeighborhoodIterator() {}
  
  ConstNeighborhoodIterator( const ConstNeighborhoodIterator & );
  
  ConstNeighborhoodIterator(const SizeType &radius,
                       const ImageType * ptr,
                       const RegionType &region
                       )
    {      this->Initialize(radius, ptr, region);  }

  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 *( this->GetCenterPointer() );  }

  const ImageType * GetImagePointer(void)
    { return m_ConstImage; }
 
  virtual IndexType GetIndex(void) const
    { return m_Loop;  }
  
  virtual NeighborhoodType GetNeighborhood() const;

  InternalPixelType *GetOutputBuffer() const
    {    return m_OutputBuffer;  }
  
  OffsetType GetOutputWrapOffsetModifier() const
    {  return m_OutputWrapOffsetModifier;  }

  virtual PixelType GetPixel(const unsigned long i) const
    {  return *(this->operator[](i));  }

  RegionType GetRegion() const
    { return m_Region; }
  
  IndexType GetBeginIndex() const
    { return m_BeginIndex; }
  
  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 );
    }
  
  virtual const Self &operator++();
  
  virtual const 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();  }

  virtual void OverrideBoundaryCondition(const ImageBoundaryConditionPointerType)
    { /* default case is do nothing */ }
 
  void SetLocation( const IndexType& position )
    {
      this->SetLoop(position);
      this->SetPixelPointers(position);
    }
  
  void SetOutputBuffer(InternalPixelType *i)
    {    m_OutputBuffer = i;   }

  void SetOutputWrapOffsetModifier( const OffsetType &modifiers);

  virtual void ResetBoundaryCondition()
    { /* default case is do nothing */ }
 
protected:
  void ComputeStrideTable()
    {
      for (unsigned int i = 0; i < Dimension; ++i)
        { m_StrideTable[i] = this->GetStride(i); }
    }
  
  virtual void SetLoop( const IndexType& p )
    {  m_Loop = p; }
  
  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::ConstPointer m_ConstImage;

  /*
   * A pointer to one past the last pixel in the iteration region.
   */
  const InternalPixelType *m_End;

  IndexType m_EndIndex;

  IndexType m_Loop;
 
  InternalPixelType *m_OutputBuffer;
  
  OffsetType m_OutputWrapOffsetModifier;
  
  RegionType m_Region;

  unsigned long m_StrideTable[Dimension];

  OffsetType m_WrapOffset;
};

} // namespace itk


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

#endif

---