itkShapedNeighborhoodIterator.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 itkShapedNeighborhoodIterator_h
#define itkShapedNeighborhoodIterator_h

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

namespace itk
{
template< typename TImage,  typename TBoundaryCondition =
            ZeroFluxNeumannBoundaryCondition< TImage > >
class ShapedNeighborhoodIterator:
  public ConstShapedNeighborhoodIterator< TImage, TBoundaryCondition >
{
public:
  typedef typename TImage::InternalPixelType InternalPixelType;
  typedef typename TImage::PixelType         PixelType;

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

  typedef ShapedNeighborhoodIterator Self;
  typedef ConstShapedNeighborhoodIterator< 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 typename Superclass::ConstIterator                     ConstIterator;
  typedef typename Superclass::IndexListType                     IndexListType;
  typedef typename Superclass::BoundaryConditionType             BoundaryConditionType;
  typedef typename Superclass::ImageBoundaryConditionPointerType ImageBoundaryConditionPointerType;
  typedef typename Superclass::NeighborhoodType                  NeighborhoodType;
  typedef typename Superclass::IndexType                         IndexType;
  typedef typename Superclass::ImageType                         ImageType;
  typedef typename Superclass::RegionType                        RegionType;
  typedef typename Superclass::IndexValueType                    IndexValueType;

  struct Iterator:public ConstIterator {
    Iterator() {}
    Iterator(Self *s):ConstIterator(s) {}

    ~Iterator() {}
    Iterator & operator=(const Iterator & o)
    {
      ConstIterator::operator=(o);
      return *this;
    }

    // Promote to public
    void Set(const PixelType & v) const
    { ConstIterator::ProtectedSet(v); }
  };

  ShapedNeighborhoodIterator()
  {
    m_BeginIterator = Iterator(this);
    m_EndIterator = Iterator(this);
    m_EndIterator.GoToEnd();
  }

  virtual ~ShapedNeighborhoodIterator() {}

  ShapedNeighborhoodIterator(const SizeType & radius,
                             const ImageType *ptr,
                             const RegionType & region
                             ):Superclass(radius, const_cast< ImageType * >( ptr ),
                                          region)
  {
    m_BeginIterator = Iterator(this);
    m_EndIterator = Iterator(this);
    m_EndIterator.GoToEnd();
  }

  // Expose the following methods from the superclass.  This is a restricted
  // subset of the methods available for NeighborhoodIterator.
  using Superclass::SetPixel;
  using Superclass::SetCenterPixel;


  Self & operator=(const Self & orig)
  {
    Superclass::operator=(orig);

    // Reset begin and end pointer locations
    m_BeginIterator.GoToBegin();
    m_EndIterator.GoToEnd();
    return *this;
  }

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

  Iterator & Begin() {    return m_BeginIterator;  }
  Iterator & End()   {   return m_EndIterator;     }

  const ConstIterator & End() const
  { return this->m_ConstEndIterator; }

  void ClearActiveList()
  {
    Superclass::ClearActiveList();
    m_EndIterator.GoToEnd();
    m_BeginIterator.GoToBegin();
  }

protected:

  ShapedNeighborhoodIterator(const ShapedNeighborhoodIterator & o);
  // purposely not implemented

  typedef typename Superclass::NeighborIndexType NeighborIndexType;

  void ActivateIndex(NeighborIndexType n)
  {
    Superclass::ActivateIndex(n);
    m_EndIterator.GoToEnd();
    m_BeginIterator.GoToBegin();
  }

  void DeactivateIndex(NeighborIndexType n)
  {
    Superclass::DeactivateIndex(n);
    m_EndIterator.GoToEnd();
    m_BeginIterator.GoToBegin();
  }

  Iterator m_EndIterator;
  Iterator m_BeginIterator;
};
} // namespace itk

#ifndef ITK_MANUAL_INSTANTIATION
#include "itkShapedNeighborhoodIterator.hxx"
#endif

#endif