itkConstShapedNeighborhoodIterator.h

Go to the documentation of this file.

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

  Program:   Insight Segmentation & Registration Toolkit
  Module:    $RCSfile: itkConstShapedNeighborhoodIterator.h,v $
  Language:  C++
  Date:      $Date: 2005/10/20 13:25:24 $
  Version:   $Revision: 1.11 $

  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.operator!=(o.m_ListIterator); }
    bool operator==(const ConstIterator &o) const
    { return m_ListIterator.operator==(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

---