itkConstShapedNeighborhoodIterator.h

Go to the documentation of this file.

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

  Program:   Insight Segmentation & Registration Toolkit
  Module:    $RCSfile: itkConstShapedNeighborhoodIterator.h,v $
  Language:  C++
  Date:      $Date: 2008-10-07 12:04:18 $
  Version:   $Revision: 1.15 $

  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 __itkConstShapedNeighborhoodIterator_h
#define __itkConstShapedNeighborhoodIterator_h

#include <vector>
#include <list>
#include "itkNeighborhoodIterator.h"

namespace itk 
{

template<class TImage,  class TBoundaryCondition
                       = ZeroFluxNeumannBoundaryCondition<TImage> >
class ITK_EXPORT ConstShapedNeighborhoodIterator
  :  private NeighborhoodIterator<TImage, TBoundaryCondition>
{
public:

  typedef typename TImage::InternalPixelType InternalPixelType;
  typedef typename TImage::PixelType         PixelType;

  itkStaticConstMacro(Dimension, unsigned int, TImage::ImageDimension);

  typedef ConstShapedNeighborhoodIterator                  Self;
  typedef NeighborhoodIterator<TImage, TBoundaryCondition> 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 TImage                                   ImageType;
  typedef typename TImage::RegionType              RegionType;
  typedef Index<itkGetStaticConstMacro(Dimension)> IndexType;
  typedef typename IndexType::IndexValueType       IndexValueType;
  typedef Neighborhood<PixelType, itkGetStaticConstMacro(Dimension)> 
                                                   NeighborhoodType;

  typedef std::list<unsigned int> IndexListType;

  typedef TBoundaryCondition BoundaryConditionType;

  typedef ImageBoundaryCondition<ImageType> *ImageBoundaryConditionPointerType;

  struct ConstIterator
    {
    ConstIterator() { m_NeighborhoodIterator = 0; }
    ConstIterator(Self *s)
      {
      m_NeighborhoodIterator = s;
      this->GoToBegin();
      }
    ~ConstIterator() {}
    const ConstIterator &operator=(const ConstIterator &o)
      {
      m_NeighborhoodIterator = o.m_NeighborhoodIterator;
      m_ListIterator = o.m_ListIterator;
      return *this;
      }

    ConstIterator(const ConstIterator &o)
      {
      m_NeighborhoodIterator = o.m_NeighborhoodIterator;
      m_ListIterator = o.m_ListIterator;
      }

    void operator++(int)
      { m_ListIterator++; }

    void operator--(int)
      { m_ListIterator--; }
      
    const ConstIterator &operator++()
      {
      m_ListIterator++;
      return *this;
      }
    const ConstIterator &operator--()
      {
      m_ListIterator--;
      return *this;
      }
      
    bool operator!=(const ConstIterator &o) const
      { return m_ListIterator != o.m_ListIterator; }
    bool operator==(const ConstIterator &o) const
      { return m_ListIterator == o.m_ListIterator; }

    bool IsAtEnd() const
      {
      if (m_ListIterator == m_NeighborhoodIterator->GetActiveIndexList().end())
        {
        return true; 
        }
      else 
        { 
        return false; 
        }
      }

    void GoToBegin()
      {
      m_ListIterator = m_NeighborhoodIterator->GetActiveIndexList().begin();
      }

    void GoToEnd()
      {
      m_ListIterator = m_NeighborhoodIterator->GetActiveIndexList().end();
      }

    PixelType Get() const
      { return m_NeighborhoodIterator->GetPixel(*m_ListIterator); }

    OffsetType GetNeighborhoodOffset() const
      { return m_NeighborhoodIterator->GetOffset(*m_ListIterator); }

    typename IndexListType::value_type GetNeighborhoodIndex() const
      { return *m_ListIterator; }

  protected:
      
    Self *m_NeighborhoodIterator;
      
    typename IndexListType::const_iterator m_ListIterator;

    void ProtectedSet(const PixelType &v) const
      { m_NeighborhoodIterator->SetPixel(*m_ListIterator, v); } 
    };

  const ConstIterator &Begin() const
    { return m_ConstBeginIterator; }

  const ConstIterator &End() const
    { return m_ConstEndIterator; }

  ConstShapedNeighborhoodIterator()
    {
    m_ConstBeginIterator = ConstIterator(this);
    m_ConstEndIterator = ConstIterator(this);
    m_ConstEndIterator.GoToEnd();
    m_CenterIsActive = false;
    }

  virtual ~ConstShapedNeighborhoodIterator()  { }

  ConstShapedNeighborhoodIterator(const SizeType &radius,
                       const ImageType * ptr,
                       const RegionType &region) 
                   : Superclass (radius, const_cast<ImageType*>(ptr), region)
    {
    m_ConstBeginIterator = ConstIterator(this);
    m_ConstEndIterator = ConstIterator(this);
    m_ConstEndIterator.GoToEnd();
    m_CenterIsActive = false;
    }

  // Expose the following methods from the superclass.  This is a restricted
  // subset of the methods available for ConstNeighborhoodIterator.
  Superclass::GetImagePointer;
  Superclass::GetRadius;
  Superclass::GetIndex;
  Superclass::GetNeighborhoodIndex;
  Superclass::GetCenterNeighborhoodIndex;
  Superclass::GetRegion;
  Superclass::GetBeginIndex;
  Superclass::GoToBegin;
  Superclass::GoToEnd;
  Superclass::IsAtBegin;
  Superclass::IsAtEnd;
  Superclass::GetOffset;
  Superclass::operator==;
  Superclass::operator!=;
  Superclass::operator<;
  Superclass::operator>;
  Superclass::operator>=;
  Superclass::operator<=;
  Superclass::operator[];
  Superclass::GetElement;
  Superclass::SetLocation;
  Superclass::GetCenterPointer;
  Superclass::GetCenterPixel;
  Superclass::OverrideBoundaryCondition;
  Superclass::ResetBoundaryCondition;
  Superclass::GetBoundaryCondition;
  Superclass::Print;
  Superclass::operator-;
 
  Superclass::GetPixel;
  
  Self &operator=(const Self& orig)
    {
    Superclass::operator=(orig);
    m_ActiveIndexList = orig.m_ActiveIndexList;
    m_CenterIsActive = orig.m_CenterIsActive;

    // Reset begin and end pointers
    m_ConstBeginIterator.GoToBegin();
    m_ConstEndIterator.GoToBegin();
    return *this;
    }

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

  virtual void ActivateOffset(const OffsetType& off)
    { this->ActivateIndex( Superclass::GetNeighborhoodIndex(off) ); }
  virtual void DeactivateOffset(const OffsetType& off)
    { this->DeactivateIndex( Superclass::GetNeighborhoodIndex(off) );}

  virtual void ClearActiveList()
    {
    m_ActiveIndexList.clear();
    m_ConstBeginIterator.GoToBegin();
    m_ConstEndIterator.GoToEnd();
    m_CenterIsActive = false;
    }

  const IndexListType &GetActiveIndexList() const
    { return m_ActiveIndexList; }

  typename IndexListType::size_type GetActiveIndexListSize() const
    { return m_ActiveIndexList.size(); }

  Self &operator++();

  Self &operator--();

  Self &operator+=(const OffsetType &);

  Self &operator-=(const OffsetType &);

  // Should be protected, but Borland compiler will not allow it.  A workaround
  // must be found.
  Superclass::SetPixel;
  Superclass::SetCenterPixel;
protected:
  ConstShapedNeighborhoodIterator( const ConstShapedNeighborhoodIterator & );
  // purposely not implemented

  friend struct ConstIterator;
  
  //  Superclass::SetPixel;
  //  Superclass::SetCenterPixel;

  virtual void ActivateIndex(const unsigned int);
  virtual void DeactivateIndex(const unsigned int);

  bool          m_CenterIsActive;
  IndexListType m_ActiveIndexList;
  ConstIterator m_ConstEndIterator;
  ConstIterator m_ConstBeginIterator;
};


} // namespace itk


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

#endif

---