itkImageConstIteratorWithIndex.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 __itkImageConstIteratorWithIndex_h
#define __itkImageConstIteratorWithIndex_h

#include "itkIndex.h"
#include "itkImage.h"
#include <memory>

namespace itk
{
template< typename TImage >
class ImageConstIteratorWithIndex
{
public:
  typedef ImageConstIteratorWithIndex Self;

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

  typedef typename TImage::IndexType         IndexType;
  typedef typename IndexType::IndexValueType IndexValueType;

  typedef typename TImage::SizeType        SizeType;
  typedef typename SizeType::SizeValueType SizeValueType;

  typedef typename TImage::RegionType RegionType;

  typedef TImage ImageType;

  typedef typename TImage::PixelContainer  PixelContainer;
  typedef typename PixelContainer::Pointer PixelContainerPointer;

  typedef typename TImage::InternalPixelType InternalPixelType;

  typedef typename TImage::PixelType PixelType;

  typedef typename TImage::AccessorType        AccessorType;
  typedef typename TImage::AccessorFunctorType AccessorFunctorType;

  typedef typename TImage::OffsetType          OffsetType;
  typedef typename OffsetType::OffsetValueType OffsetValueType;

  ImageConstIteratorWithIndex();

  ImageConstIteratorWithIndex(const Self & it);

  ImageConstIteratorWithIndex(const TImage *ptr,
                              const RegionType & region);

  virtual ~ImageConstIteratorWithIndex() {};

  Self & operator=(const Self & it);

  static unsigned int GetImageDimension()
  {
    return ImageDimension;
  }

  bool
  operator!=(const Self & it) const
  {
    // two iterators are the same if they "point to" the same memory location
    return ( m_Position ) != ( it.m_Position );
  }

  bool
  operator==(const Self & it) const
  {
    // two iterators are the same if they "point to" the same memory location
    return ( m_Position ) == ( it.m_Position );
  }

  bool
  operator<=(const Self & it) const
  {
    // an iterator is "less than" another if it "points to" a lower
    // memory location
    return ( m_Position ) <= ( it.m_Position );
  }

  bool
  operator<(const Self & it) const
  {
    // an iterator is "less than" another if it "points to" a lower
    // memory location
    return ( m_Position ) < ( it.m_Position );
  }

  bool
  operator>=(const Self & it) const
  {
    // an iterator is "greater than" another if it "points to" a higher
    // memory location
    return ( m_Position ) >= ( it.m_Position );
  }

  bool
  operator>(const Self & it) const
  {
    // an iterator is "greater than" another if it "points to" a higher
    // memory location
    return ( m_Position ) > ( it.m_Position );
  }

  const IndexType & GetIndex() const
  {
    return m_PositionIndex;
  }

  const RegionType & GetRegion() const
  {
    return m_Region;
  }

  void SetIndex(const IndexType & ind)
  {
    m_Position = m_Image->GetBufferPointer() + m_Image->ComputeOffset(ind);
    m_PositionIndex = ind;
  }

  PixelType Get(void) const
  {
    return m_PixelAccessorFunctor.Get(*m_Position);
  }

  const PixelType & Value(void) const
  {
    return *m_Position;
  }

  itkLegacyMacro(Self Begin(void) const);

  void GoToBegin(void);

  itkLegacyMacro(Self End(void) const);

  void GoToReverseBegin(void);

  bool IsAtReverseEnd(void) const
  {
    return !m_Remaining;
  }

  bool IsAtEnd(void) const
  {
    return !m_Remaining;
  }

  bool Remaining()
  {
    return m_Remaining;
  }

protected: //made protected so other iterators can access
  typename TImage::ConstWeakPointer m_Image;

  IndexType m_PositionIndex;        // Index where we currently are
  IndexType m_BeginIndex;           // Index to start iterating over
  IndexType m_EndIndex;             // Index to finish iterating:
                                    // one pixel past the end of each
                                    // row, col, slice, etc....

  RegionType m_Region;              // region to iterate over

  OffsetValueType m_OffsetTable[ImageDimension + 1];

  const InternalPixelType *m_Position;
  const InternalPixelType *m_Begin;
  const InternalPixelType *m_End;

  bool m_Remaining;

  AccessorType        m_PixelAccessor;
  AccessorFunctorType m_PixelAccessorFunctor;
};
} // end namespace itk

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

#endif