itkImageRegionReverseConstIterator.h

Go to the documentation of this file.

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

  Program:   Insight Segmentation & Registration Toolkit
  Module:    $RCSfile: itkImageRegionReverseConstIterator.h,v $
  Language:  C++
  Date:      $Date: 2008-10-18 21:13:25 $
  Version:   $Revision: 1.8 $

  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 __itkImageRegionReverseConstIterator_h
#define __itkImageRegionReverseConstIterator_h

#include "itkImageReverseConstIterator.h"
#include "itkImageRegionIterator.h"

namespace itk
{

template<typename TImage>
class ITK_EXPORT ImageRegionReverseConstIterator : public ImageReverseConstIterator<TImage>
{
public:

  typedef ImageRegionReverseConstIterator       Self;
  typedef ImageReverseConstIterator<TImage>     Superclass;

  enum { ImageIteratorDimension = Superclass::ImageIteratorDimension };

  typedef typename Superclass::IndexType        IndexType;
  typedef typename Superclass::IndexValueType   IndexValueType;

  typedef typename Superclass::SizeType         SizeType;
  typedef typename Superclass::SizeValueType    SizeValueType;

  typedef typename Superclass::OffsetType       OffsetType;
  typedef typename Superclass::OffsetValueType  OffsetValueType;

  typedef typename Superclass::RegionType       RegionType;

  typedef typename Superclass::ImageType ImageType;

  typedef typename Superclass::PixelContainer   PixelContainer;
  typedef typename PixelContainer::Pointer      PixelContainerPointer;

  typedef typename Superclass::InternalPixelType   InternalPixelType;

  typedef typename Superclass::PixelType   PixelType;

  typedef typename Superclass::AccessorType     AccessorType;

  itkTypeMacro(ImageRegionReverseConstIterator, ImageReverseConstIterator);

  ImageRegionReverseConstIterator() : Superclass()
    {
    m_SpanBeginOffset = 0;
    m_SpanEndOffset = 0;
    }

  ImageRegionReverseConstIterator(ImageType *ptr, const RegionType &region)
    : Superclass(ptr, region)
    {
    m_SpanBeginOffset = this->m_BeginOffset;
    m_SpanEndOffset = this->m_BeginOffset - static_cast<long>(this->m_Region.GetSize()[0]);
    }

  ImageRegionReverseConstIterator( const ImageConstIterator<TImage> &it):Superclass(it)
    {
    IndexType ind = this->GetIndex();
    m_SpanBeginOffset = this->m_Offset + static_cast<long>(this->m_Region.GetSize()[0]) 
      - (ind[0] - this->m_Region.GetIndex()[0]);
    m_SpanEndOffset = m_SpanBeginOffset - static_cast<long>(this->m_Region.GetSize()[0]);
    }

  ImageRegionReverseConstIterator( const ImageReverseConstIterator<TImage> &it):Superclass(it)
    {
    IndexType ind = this->GetIndex();
    m_SpanBeginOffset = this->m_Offset + static_cast<long>(this->m_Region.GetSize()[0]) 
      - (ind[0] - this->m_Region.GetIndex()[0]);
    m_SpanEndOffset = m_SpanBeginOffset - static_cast<long>(this->m_Region.GetSize()[0]);
    }

  ImageRegionReverseConstIterator( const ImageRegionIterator<TImage> &it):Superclass(it)
    {
    IndexType ind = this->GetIndex();
    m_SpanBeginOffset = this->m_Offset + static_cast<long>(this->m_Region.GetSize()[0]) 
      - (ind[0] - this->m_Region.GetIndex()[0]);
    m_SpanEndOffset = m_SpanBeginOffset - static_cast<long>(this->m_Region.GetSize()[0]);
    }

  void GoToBegin()
    {
    Superclass::GoToBegin();

    // reset the span offsets
    m_SpanBeginOffset = this->m_BeginOffset;
    m_SpanEndOffset   = this->m_BeginOffset - static_cast<long>(this->m_Region.GetSize()[0]);
    }
  
  void GoToEnd()
    {
    Superclass::GoToEnd();

    // reset the span offsets
    m_SpanEndOffset = this->m_EndOffset;
    m_SpanBeginOffset = m_SpanEndOffset + static_cast<long>(this->m_Region.GetSize()[0]);
    }

  Self Begin(void) const;

  Self End(void) const;


  void SetIndex(const IndexType &ind)
    {
    Superclass::SetIndex(ind);
    m_SpanBeginOffset = this->m_Offset + static_cast<long>(this->m_Region.GetSize()[0]) 
      - (ind[0] - this->m_Region.GetIndex()[0]);
    m_SpanEndOffset = m_SpanBeginOffset - static_cast<long>(this->m_Region.GetSize()[0]);
    }

  Self &
  operator++()
    {
    if (--this->m_Offset <= m_SpanEndOffset)
      {
      // We have past the beginning of the span (row), need to wrap around.

      // First move forward one pixel, because we are going to use a different
      // algorithm to compute the next pixel
      this->m_Offset++;
      
      // Get the index of the first pixel on the span (row)
      typename ImageConstIterator<TImage>::IndexType
        ind = this->m_Image->ComputeIndex( static_cast<OffsetValueType>(this->m_Offset) );

      const typename ImageConstIterator<TImage>::IndexType&
        startIndex = this->m_Region.GetIndex();
      const typename ImageConstIterator<TImage>::SizeType&
        size = this->m_Region.GetSize();

      // Deccrement along a row, then wrap at the beginning of the region row.
      bool done;
      unsigned int dim;

      // Check to see if we are past the first pixel in the region
      // Note that --ind[0] moves to the previous pixel along the row.
      done = (--ind[0] == startIndex[0] - 1);
      for (unsigned int i=1; done && i < ImageIteratorDimension; i++)
        {
        done = (ind[i] == startIndex[i]);
        }
      
      // if the iterator is outside the region (but not past region begin) then
      // we need to wrap around the region
      dim = 0;
      if (!done)
        {
        while ( (dim < ImageIteratorDimension - 1)
                && (ind[dim] < startIndex[dim]) )
          {
          ind[dim] = startIndex[dim] + static_cast<long>(size[dim]) - 1;
          ind[++dim]--;
          }
        }
      this->m_Offset = this->m_Image->ComputeOffset( ind );
      m_SpanBeginOffset = this->m_Offset;
      m_SpanEndOffset = m_SpanBeginOffset - static_cast<long>(size[0]);
      }
    return *this;
    }

  Self & operator--()
    {
    if (++this->m_Offset >= m_SpanBeginOffset)
      {
      // We have reached the end of the span (row), need to wrap around.

      // First back up one pixel, because we are going to use a different
      // algorithm to compute the next pixel
      --this->m_Offset;
      
      // Get the index of the last pixel on the span (row)
      typename ImageConstIterator<TImage>::IndexType
        ind = this->m_Image->ComputeIndex( static_cast<OffsetValueType>(this->m_Offset) );

      const typename ImageIterator<TImage>::IndexType&
        startIndex = this->m_Region.GetIndex();
      const typename ImageIterator<TImage>::SizeType&
        size = this->m_Region.GetSize();

      // Increment along a row, then wrap at the end of the region row.
      bool done;
      unsigned int dim;

      // Check to see if we are past the last pixel in the region
      // Note that ++ind[0] moves to the next pixel along the row.
      done = (++ind[0] == startIndex[0] + static_cast<long>(size[0]));
      for (unsigned int i=1; done && i < ImageIteratorDimension; i++)
        {
        done = (ind[i] == startIndex[i] + static_cast<long>(size[i]) - 1);
        }
      
      // if the iterator is outside the region (but not past region end) then
      // we need to wrap around the region
      dim = 0;
      if (!done)
        {
        while ( (dim < ImageIteratorDimension - 1)
                && (ind[dim] > startIndex[dim] + static_cast<long>(size[dim]) - 1) )
          {
          ind[dim] = startIndex[dim];
          ind[++dim]++;
          }
        }
      this->m_Offset = this->m_Image->ComputeOffset( ind );
      m_SpanBeginOffset = this->m_Offset;
      m_SpanEndOffset = this->m_Offset - static_cast<long>(size[0]);
      }
    return *this;
    }

protected:
  unsigned long m_SpanBeginOffset;  // offset to last pixel in the row
  unsigned long m_SpanEndOffset;  // offset to one pixel before the row
       
};

} // end namespace itk

// Define instantiation macro for this template.
#define ITK_TEMPLATE_ImageRegionReverseConstIterator(_, EXPORT, x, y) namespace itk { \
  _(1(class EXPORT ImageRegionReverseConstIterator< ITK_TEMPLATE_1 x >)) \
  namespace Templates { typedef ImageRegionReverseConstIterator< ITK_TEMPLATE_1 x > ImageRegionReverseConstIterator##y; } \
  }

#if ITK_TEMPLATE_EXPLICIT
# include "Templates/itkImageRegionReverseConstIterator+-.h"
#endif

#if ITK_TEMPLATE_TXX
# include "itkImageRegionReverseConstIterator.txx"
#endif

#endif