itkImageConstIteratorWithOnlyIndex.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 __itkImageConstIteratorWithOnlyIndex_h
#define __itkImageConstIteratorWithOnlyIndex_h

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

namespace itk
{
template< typename TImage >
class ITK_EXPORT ImageConstIteratorWithOnlyIndex
{
public:
  typedef ImageConstIteratorWithOnlyIndex 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::OffsetType          OffsetType;
  typedef typename OffsetType::OffsetValueType OffsetValueType;

  ImageConstIteratorWithOnlyIndex();

  ImageConstIteratorWithOnlyIndex(const Self & it);

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

  virtual ~ImageConstIteratorWithOnlyIndex() {};

  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_PositionIndex ) != ( it.m_PositionIndex );
  }

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

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

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

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

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

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

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

  void SetIndex(const IndexType & ind)
  {
    m_PositionIndex = ind;
  }

  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::ConstPointer 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];

  bool m_Remaining;

};
} // end namespace itk

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

#endif