Main Page   Groups   Namespace List   Class Hierarchy   Alphabetical List   Compound List   File List   Namespace Members   Compound Members   File Members   Concepts

itkImageReverseConstIterator.h

Go to the documentation of this file.
00001 /*=========================================================================
00002 
00003   Program:   Insight Segmentation & Registration Toolkit
00004   Module:    $RCSfile: itkImageReverseConstIterator.h,v $
00005   Language:  C++
00006   Date:      $Date: 2004/11/01 21:16:31 $
00007   Version:   $Revision: 1.6 $
00008 
00009   Copyright (c) Insight Software Consortium. All rights reserved.
00010   See ITKCopyright.txt or http://www.itk.org/HTML/Copyright.htm for details.
00011 
00012      This software is distributed WITHOUT ANY WARRANTY; without even 
00013      the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR 
00014      PURPOSE.  See the above copyright notices for more information.
00015 
00016 =========================================================================*/
00017 #ifndef __itkImageReverseConstIterator_h
00018 #define __itkImageReverseConstIterator_h
00019 
00020 #include "itkIndex.h"
00021 #include "itkSize.h"
00022 #include "itkImage.h"
00023 #include "itkImageConstIterator.h"
00024 #include <memory>
00025 
00026 namespace itk
00027 {
00028 
00086 template<typename TImage>
00087 class ITK_EXPORT ImageReverseConstIterator
00088 {
00089 public:
00091   typedef ImageReverseConstIterator Self;
00092   
00097   itkStaticConstMacro(ImageIteratorDimension, unsigned int,
00098                       TImage::ImageDimension);
00099 
00101   typedef typename TImage::IndexType        IndexType;
00102   typedef typename TImage::IndexValueType   IndexValueType;
00103     
00105   typedef typename TImage::SizeType         SizeType;
00106   typedef typename TImage::SizeValueType    SizeValueType;
00107   
00109   typedef typename TImage::OffsetType       OffsetType;
00110   typedef typename TImage::OffsetValueType  OffsetValueType;
00111   
00113   typedef typename TImage::RegionType       RegionType;
00114 
00116   typedef TImage   ImageType;
00117 
00121   typedef typename TImage::PixelContainer PixelContainer;
00122   typedef typename PixelContainer::Pointer PixelContainerPointer;
00123   
00125   typedef typename TImage::InternalPixelType   InternalPixelType;
00126 
00128   typedef typename TImage::PixelType   PixelType;
00129 
00132   typedef typename TImage::AccessorType     AccessorType;
00133 
00136   ImageReverseConstIterator()
00137     :m_PixelAccessor()
00138   {
00139     m_Buffer = 0;
00140     m_Offset = 0;
00141     m_BeginOffset = 0;
00142     m_EndOffset = 0;
00143   }
00144 
00146   virtual ~ImageReverseConstIterator() {};
00147 
00150   ImageReverseConstIterator(const Self& it)
00151   {
00152     m_Image = it.m_Image;     // copy the smart pointer
00153 
00154     m_Region = it.m_Region;
00155     
00156     m_Buffer = it.m_Buffer;
00157     m_Offset = it.m_Offset;
00158     m_BeginOffset = it.m_BeginOffset;
00159     m_EndOffset = it.m_EndOffset;
00160     m_PixelAccessor = it.m_PixelAccessor;
00161   }
00162 
00165   ImageReverseConstIterator(ImageType *ptr,
00166                 const RegionType &region)
00167   {
00168     unsigned long offset;
00169     m_Image = ptr;
00170     m_Buffer = m_Image->GetBufferPointer();
00171     m_Region = region;
00172 
00173     // Compute the end offset, one pixel before the first pixel
00174     offset = m_Image->ComputeOffset( m_Region.GetIndex() );
00175     m_EndOffset = offset-1;
00176     
00177     // Compute the begin offset, the last pixel in the region
00178     IndexType ind(m_Region.GetIndex());
00179     SizeType size(m_Region.GetSize());
00180     for (unsigned int i=0; i < TImage::ImageDimension; ++i)
00181       {
00182       ind[i] += (size[i] - 1);
00183       }
00184     m_BeginOffset = m_Image->ComputeOffset( ind );
00185     m_Offset = m_BeginOffset;
00186 
00187     m_PixelAccessor = ptr->GetPixelAccessor();
00188   }
00189   
00197   ImageReverseConstIterator( const ImageConstIterator<TImage> &it)
00198   {
00199     m_Image = it.GetImage();
00200     m_Region = it.GetRegion();
00201     m_Buffer = m_Image->GetBufferPointer();
00202     
00203     IndexType ind = it.GetIndex();
00204 
00205     m_Offset = m_Image->ComputeOffset( ind );
00206 
00207     // Compute the end offset, one pixel before the first pixel
00208     m_EndOffset = m_Image->ComputeOffset( m_Region.GetIndex() ) - 1;
00209     
00210     // Compute the begin offset, the last pixel in the region
00211     IndexType regInd(m_Region.GetIndex());
00212     SizeType regSize(m_Region.GetSize());
00213     for (unsigned int i=0; i < TImage::ImageDimension; ++i)
00214       {
00215       regInd[i] += (regSize[i] - 1);
00216       }
00217     m_BeginOffset = m_Image->ComputeOffset( regInd );
00218     
00219     m_PixelAccessor = m_Image->GetPixelAccessor();
00220   }
00221 
00224   Self &operator=(const Self& it)
00225   {
00226     m_Image = it.m_Image;     // copy the smart pointer
00227     m_Region = it.m_Region;
00228     
00229     m_Buffer = it.m_Buffer;
00230     m_Offset = it.m_Offset;
00231     m_BeginOffset = it.m_BeginOffset;
00232     m_EndOffset = it.m_EndOffset;
00233     m_PixelAccessor = it.m_PixelAccessor;
00234     return *this;
00235   }
00236   
00239   Self &operator=(const ImageConstIterator<TImage>& it)
00240   {
00241     m_Image = it.GetImage();
00242     m_Region = it.GetRegion();
00243     m_Buffer = m_Image->GetBufferPointer();
00244     
00245     IndexType ind = it.GetIndex();
00246 
00247     m_Offset = m_Image->ComputeOffset( ind );
00248 
00249     // Compute the end offset, one pixel before the first pixel
00250     m_EndOffset = m_Image->ComputeOffset( m_Region.GetIndex() ) - 1;
00251     
00252     // Compute the begin offset, the last pixel in the region
00253     IndexType regInd(m_Region.GetIndex());
00254     SizeType regSize(m_Region.GetSize());
00255     for (unsigned int i=0; i < TImage::ImageDimension; ++i)
00256       {
00257       regInd[i] += (regSize[i] - 1);
00258       }
00259     m_BeginOffset = m_Image->ComputeOffset( regInd );
00260     
00261     m_PixelAccessor = m_Image->GetPixelAccessor();
00262     
00263     return *this;
00264   }
00265   
00267   static unsigned int GetImageIteratorDimension() 
00268     {return TImage::ImageDimension;}
00269 
00272   bool
00273   operator!=(const Self &it) const
00274     {
00275     // two iterators are the same if they "point to" the same memory location
00276     return (m_Buffer + m_Offset) != (it.m_Buffer + it.m_Offset);
00277     };
00278 
00281   bool
00282   operator==(const Self &it) const
00283     {
00284     // two iterators are the same if they "point to" the same memory location
00285     return (m_Buffer + m_Offset) == (it.m_Buffer + it.m_Offset);
00286     };
00287   
00288 #if 0
00289 
00295   bool
00296   operator<=(const Self &it) const
00297     {
00298     // an iterator is "less than" another if it "points to" a lower
00299     // memory location
00300     return (m_Buffer + m_Offset) <= (it.m_Buffer + it.m_Offset);
00301     };
00302 
00305   bool
00306   operator<(const Self &it) const
00307     {
00308     // an iterator is "less than" another if it "points to" a lower
00309     // memory location
00310     return (m_Buffer + m_Offset) < (it.m_Buffer + it.m_Offset);
00311     };
00312 
00315   bool
00316   operator>=(const Self &it) const
00317     {
00318     // an iterator is "greater than" another if it "points to" a higher
00319     // memory location
00320     return (m_Buffer + m_Offset) >= (it.m_Buffer + it.m_Offset);
00321     };
00322 
00325   bool
00326   operator>(const Self &it) const
00327     {
00328     // an iterator is "greater than" another if it "points to" a higher
00329     // memory location
00330     return (m_Buffer + m_Offset) > (it.m_Buffer + it.m_Offset);
00331     };
00332 #endif
00333 
00334   
00339   const IndexType GetIndex()
00340     { return m_Image->ComputeIndex( m_Offset );  }
00341 
00344   virtual void SetIndex(const IndexType &ind)
00345     { m_Offset = m_Image->ComputeOffset( ind ); }
00346 
00347 
00350   const RegionType& GetRegion() const
00351     { return m_Region; };
00352 
00354   const PixelType & Get(void) const  
00355     { return m_PixelAccessor.Get(*(m_Buffer+m_Offset)); }
00356   
00358   void Set( const PixelType & value) const  
00359     { m_PixelAccessor.Set(*(m_Buffer+m_Offset),value); }
00360 
00364   const PixelType & Value(void) const  
00365     { return *(m_Buffer+m_Offset); }
00366  
00370   PixelType & Value(void) 
00371     { return *(m_Buffer+m_Offset); }
00372 
00376   Self Begin() const;
00377 
00380   void GoToBegin()
00381     {
00382     m_Offset = m_BeginOffset;
00383     };
00384 
00388   Self End() const;
00389 
00392   void GoToEnd()
00393     {
00394     m_Offset = m_EndOffset;
00395     };
00396 
00399   bool IsAtBegin()
00400     {
00401     return (m_Offset == m_BeginOffset);
00402     }
00403 
00406   bool IsAtEnd()
00407     {
00408     return (m_Offset == m_EndOffset);
00409     }
00410   
00411 protected: //made protected so other iterators can access 
00412   typename ImageType::ConstWeakPointer    m_Image;
00413   RegionType                          m_Region;      // region to iterate over
00414   
00415   unsigned long  m_Offset;
00416   unsigned long  m_BeginOffset; // offset to last pixel in region
00417   unsigned long  m_EndOffset;   // offset to one pixel before first pixel
00418 
00419   const InternalPixelType        *m_Buffer;
00420 
00421   AccessorType                    m_PixelAccessor;
00422 };
00423 
00424 } // end namespace itk
00425 
00426 #ifndef ITK_MANUAL_INSTANTIATION
00427 #include "itkImageReverseConstIterator.txx"
00428 #endif
00429 
00430 #endif 

Generated at Tue Mar 29 23:57:54 2005 for ITK by doxygen 1.3.9.1 written by Dimitri van Heesch, © 1997-2000