itkImageRegionReverseConstIterator.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 itkImageRegionReverseConstIterator_h
#define itkImageRegionReverseConstIterator_h

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

namespace itk
{
template< typename TImage >
class ImageRegionReverseConstIterator:public ImageReverseConstIterator< TImage >
{
public:

  typedef ImageRegionReverseConstIterator     Self;
  typedef ImageReverseConstIterator< TImage > Superclass;

  enum { ImageIteratorDimension = Superclass::ImageIteratorDimension };

  typedef typename Superclass::IndexType      IndexType;

  typedef typename Superclass::SizeType      SizeType;

  typedef typename Superclass::OffsetType      OffsetType;

  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(const ImageType *ptr, const RegionType & region):
    Superclass(ptr, region)
  {
    m_SpanBeginOffset = this->m_BeginOffset;
    m_SpanEndOffset = this->m_BeginOffset - static_cast< OffsetValueType >( this->m_Region.GetSize()[0] );
  }

  ImageRegionReverseConstIterator(const ImageConstIterator< TImage > & it):Superclass(it)
  {
    IndexType ind = this->GetIndex();

    m_SpanBeginOffset = this->m_Offset + static_cast< OffsetValueType >( this->m_Region.GetSize()[0] )
                        - ( ind[0] - this->m_Region.GetIndex()[0] );
    m_SpanEndOffset = m_SpanBeginOffset - static_cast< OffsetValueType >( this->m_Region.GetSize()[0] );
  }

  ImageRegionReverseConstIterator(const ImageReverseConstIterator< TImage > & it):Superclass(it)
  {
    IndexType ind = this->GetIndex();

    m_SpanBeginOffset = this->m_Offset + static_cast< OffsetValueType >( this->m_Region.GetSize()[0] )
                        - ( ind[0] - this->m_Region.GetIndex()[0] );
    m_SpanEndOffset = m_SpanBeginOffset - static_cast< OffsetValueType >( this->m_Region.GetSize()[0] );
  }

  ImageRegionReverseConstIterator(const ImageRegionIterator< TImage > & it):Superclass(it)
  {
    IndexType ind = this->GetIndex();

    m_SpanBeginOffset = this->m_Offset + static_cast< OffsetValueType >( this->m_Region.GetSize()[0] )
                        - ( ind[0] - this->m_Region.GetIndex()[0] );
    m_SpanEndOffset = m_SpanBeginOffset - static_cast< OffsetValueType >( 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< OffsetValueType >( this->m_Region.GetSize()[0] );
  }

  void GoToEnd()
  {
    Superclass::GoToEnd();

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

  itkLegacyMacro(Self Begin(void) const);

  itkLegacyMacro(Self End(void) const);

  void SetIndex(const IndexType & ind) ITK_OVERRIDE
  {
    Superclass::SetIndex(ind);
    m_SpanBeginOffset = this->m_Offset + static_cast< OffsetValueType >( this->m_Region.GetSize()[0] )
                        - ( ind[0] - this->m_Region.GetIndex()[0] );
    m_SpanEndOffset = m_SpanBeginOffset - static_cast< OffsetValueType >( 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< OffsetValueType >( size[dim] ) - 1;
          ind[++dim]--;
          }
        }
      this->m_Offset = this->m_Image->ComputeOffset(ind);
      m_SpanBeginOffset = this->m_Offset;
      m_SpanEndOffset = m_SpanBeginOffset - static_cast< OffsetValueType >( 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< OffsetValueType >( size[0] ) );
      for ( unsigned int i = 1; done && i < ImageIteratorDimension; i++ )
        {
        done = ( ind[i] == startIndex[i] + static_cast< OffsetValueType >( 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< OffsetValueType >( 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< OffsetValueType >( size[0] );
      }
    return *this;
  }

protected:
  SizeValueType m_SpanBeginOffset; // offset to last pixel in the row
  SizeValueType m_SpanEndOffset;   // offset to one pixel before the row
};
} // end namespace itk

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

#endif