00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
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
00135 typedef typename TImage::AccessorFunctorType AccessorFunctorType;
00136
00139 ImageReverseConstIterator()
00140 :m_PixelAccessor(),
00141 m_PixelAccessorFunctor()
00142 {
00143 m_Buffer = 0;
00144 m_Offset = 0;
00145 m_BeginOffset = 0;
00146 m_EndOffset = 0;
00147 m_PixelAccessorFunctor.SetBegin( m_Buffer );
00148 }
00150
00152 virtual ~ImageReverseConstIterator() {};
00153
00156 ImageReverseConstIterator(const Self& it)
00157 {
00158 m_Image = it.m_Image;
00159
00160 m_Region = it.m_Region;
00161
00162 m_Buffer = it.m_Buffer;
00163 m_Offset = it.m_Offset;
00164 m_BeginOffset = it.m_BeginOffset;
00165 m_EndOffset = it.m_EndOffset;
00166 m_PixelAccessor = it.m_PixelAccessor;
00167 m_PixelAccessorFunctor = it.m_PixelAccessorFunctor;
00168 m_PixelAccessorFunctor.SetBegin( m_Buffer );
00169 }
00170
00173 ImageReverseConstIterator(ImageType *ptr,
00174 const RegionType ®ion)
00175 {
00176 unsigned long offset;
00177 m_Image = ptr;
00178 m_Buffer = m_Image->GetBufferPointer();
00179 m_Region = region;
00181
00182
00183 offset = m_Image->ComputeOffset( m_Region.GetIndex() );
00184 m_EndOffset = offset-1;
00185
00186
00187 IndexType ind(m_Region.GetIndex());
00188 SizeType size(m_Region.GetSize());
00189 for (unsigned int i=0; i < TImage::ImageDimension; ++i)
00190 {
00191 ind[i] += (size[i] - 1);
00192 }
00193 m_BeginOffset = m_Image->ComputeOffset( ind );
00194 m_Offset = m_BeginOffset;
00195
00196 m_PixelAccessor = ptr->GetPixelAccessor();
00197 m_PixelAccessorFunctor.SetPixelAccessor( m_PixelAccessor );
00198 m_PixelAccessorFunctor.SetBegin( m_Buffer );
00199 }
00200
00208 ImageReverseConstIterator( const ImageConstIterator<TImage> &it)
00209 {
00210 m_Image = it.GetImage();
00211 m_Region = it.GetRegion();
00212 m_Buffer = m_Image->GetBufferPointer();
00214
00215 IndexType ind = it.GetIndex();
00216
00217 m_Offset = m_Image->ComputeOffset( ind );
00218
00219
00220 m_EndOffset = m_Image->ComputeOffset( m_Region.GetIndex() ) - 1;
00221
00222
00223 IndexType regInd(m_Region.GetIndex());
00224 SizeType regSize(m_Region.GetSize());
00225 for (unsigned int i=0; i < TImage::ImageDimension; ++i)
00226 {
00227 regInd[i] += (regSize[i] - 1);
00228 }
00229 m_BeginOffset = m_Image->ComputeOffset( regInd );
00230
00231 m_PixelAccessor = m_Image->GetPixelAccessor();
00232 m_PixelAccessorFunctor.SetPixelAccessor( m_PixelAccessor );
00233 m_PixelAccessorFunctor.SetBegin( m_Buffer );
00234 }
00235
00238 Self &operator=(const Self& it)
00239 {
00240 m_Image = it.m_Image;
00241 m_Region = it.m_Region;
00242
00243 m_Buffer = it.m_Buffer;
00244 m_Offset = it.m_Offset;
00245 m_BeginOffset = it.m_BeginOffset;
00246 m_EndOffset = it.m_EndOffset;
00247 m_PixelAccessor = it.m_PixelAccessor;
00248 m_PixelAccessorFunctor.SetPixelAccessor( m_PixelAccessor );
00249 m_PixelAccessorFunctor.SetBegin( m_Buffer );
00250 return *this;
00251 }
00252
00255 Self &operator=(const ImageConstIterator<TImage>& it)
00256 {
00257 m_Image = it.GetImage();
00258 m_Region = it.GetRegion();
00259 m_Buffer = m_Image->GetBufferPointer();
00261
00262 IndexType ind = it.GetIndex();
00263
00264 m_Offset = m_Image->ComputeOffset( ind );
00265
00266
00267 m_EndOffset = m_Image->ComputeOffset( m_Region.GetIndex() ) - 1;
00268
00269
00270 IndexType regInd(m_Region.GetIndex());
00271 SizeType regSize(m_Region.GetSize());
00272 for (unsigned int i=0; i < TImage::ImageDimension; ++i)
00273 {
00274 regInd[i] += (regSize[i] - 1);
00275 }
00276 m_BeginOffset = m_Image->ComputeOffset( regInd );
00277
00278 m_PixelAccessor = m_Image->GetPixelAccessor();
00279 m_PixelAccessorFunctor.SetPixelAccessor( m_PixelAccessor );
00280 m_PixelAccessorFunctor.SetBegin( m_Buffer );
00281
00282 return *this;
00283 }
00284
00286 static unsigned int GetImageIteratorDimension()
00287 {return TImage::ImageDimension;}
00288
00291 bool
00292 operator!=(const Self &it) const
00293 {
00294
00295 return (m_Buffer + m_Offset) != (it.m_Buffer + it.m_Offset);
00296 };
00298
00301 bool
00302 operator==(const Self &it) const
00303 {
00304
00305 return (m_Buffer + m_Offset) == (it.m_Buffer + it.m_Offset);
00306 };
00308
00309 #if 0
00310
00316 bool
00317 operator<=(const Self &it) const
00318 {
00319
00320
00321 return (m_Buffer + m_Offset) <= (it.m_Buffer + it.m_Offset);
00322 };
00324
00327 bool
00328 operator<(const Self &it) const
00329 {
00330
00331
00332 return (m_Buffer + m_Offset) < (it.m_Buffer + it.m_Offset);
00333 };
00335
00338 bool
00339 operator>=(const Self &it) const
00340 {
00341
00342
00343 return (m_Buffer + m_Offset) >= (it.m_Buffer + it.m_Offset);
00344 };
00346
00349 bool
00350 operator>(const Self &it) const
00351 {
00352
00353
00354 return (m_Buffer + m_Offset) > (it.m_Buffer + it.m_Offset);
00355 };
00356 #endif
00357
00358
00359
00364 const IndexType GetIndex()
00365 { return m_Image->ComputeIndex( m_Offset ); }
00366
00369 virtual void SetIndex(const IndexType &ind)
00370 { m_Offset = m_Image->ComputeOffset( ind ); }
00371
00372
00375 const RegionType& GetRegion() const
00376 { return m_Region; };
00377
00379 const PixelType Get(void) const
00380 { return m_PixelAccessorFunctor.Get(*(m_Buffer+m_Offset)); }
00381
00383 void Set( const PixelType & value) const
00384 { m_PixelAccessorFunctor.Set(*(m_Buffer+m_Offset),value); }
00385
00389 const PixelType & Value(void) const
00390 { return *(m_Buffer+m_Offset); }
00391
00395 PixelType & Value(void)
00396 { return *(m_Buffer+m_Offset); }
00397
00401 Self Begin() const;
00402
00405 void GoToBegin()
00406 {
00407 m_Offset = m_BeginOffset;
00408 };
00409
00413 Self End() const;
00414
00417 void GoToEnd()
00418 {
00419 m_Offset = m_EndOffset;
00420 };
00421
00424 bool IsAtBegin()
00425 {
00426 return (m_Offset == m_BeginOffset);
00427 }
00428
00431 bool IsAtEnd()
00432 {
00433 return (m_Offset == m_EndOffset);
00434 }
00435
00436 protected:
00437 typename ImageType::ConstWeakPointer m_Image;
00438 RegionType m_Region;
00439
00440 unsigned long m_Offset;
00441 unsigned long m_BeginOffset;
00442 unsigned long m_EndOffset;
00443
00444 const InternalPixelType *m_Buffer;
00445
00446 AccessorType m_PixelAccessor;
00447 AccessorFunctorType m_PixelAccessorFunctor;
00448 };
00449
00450 }
00451
00452 #ifndef ITK_MANUAL_INSTANTIATION
00453 #include "itkImageReverseConstIterator.txx"
00454 #endif
00455
00456 #endif
00457