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_TEMPLATE_EXPORT ImageConstIteratorWithOnlyIndex
{
public:
  using Self = ImageConstIteratorWithOnlyIndex;

  static constexpr unsigned int ImageDimension = TImage::ImageDimension;

  using IndexType = typename TImage::IndexType;
  using IndexValueType = typename IndexType::IndexValueType;

  using SizeType = typename TImage::SizeType;
  using SizeValueType = typename SizeType::SizeValueType;

  using RegionType = typename TImage::RegionType;

  using ImageType = TImage;

  using OffsetType = typename TImage::OffsetType;
  using OffsetValueType = typename OffsetType::OffsetValueType;

  ImageConstIteratorWithOnlyIndex();

  ImageConstIteratorWithOnlyIndex(const Self & it);

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

  virtual ~ImageConstIteratorWithOnlyIndex() = default;

  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;
  }

  void GoToBegin();

  void GoToReverseBegin();

  bool IsAtReverseEnd() const
  {
    return !m_Remaining;
  }

  bool IsAtEnd() 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