[ VIGRA Homepage | Function Index | Class Index | Namespaces | File List | Main Page ]
00001 /************************************************************************/ 00002 /* */ 00003 /* Copyright 1998-2002 by Ullrich Koethe */ 00004 /* Cognitive Systems Group, University of Hamburg, Germany */ 00005 /* */ 00006 /* This file is part of the VIGRA computer vision library. */ 00007 /* ( Version 1.6.0, Aug 13 2008 ) */ 00008 /* The VIGRA Website is */ 00009 /* http://kogs-www.informatik.uni-hamburg.de/~koethe/vigra/ */ 00010 /* Please direct questions, bug reports, and contributions to */ 00011 /* ullrich.koethe@iwr.uni-heidelberg.de or */ 00012 /* vigra@informatik.uni-hamburg.de */ 00013 /* */ 00014 /* Permission is hereby granted, free of charge, to any person */ 00015 /* obtaining a copy of this software and associated documentation */ 00016 /* files (the "Software"), to deal in the Software without */ 00017 /* restriction, including without limitation the rights to use, */ 00018 /* copy, modify, merge, publish, distribute, sublicense, and/or */ 00019 /* sell copies of the Software, and to permit persons to whom the */ 00020 /* Software is furnished to do so, subject to the following */ 00021 /* conditions: */ 00022 /* */ 00023 /* The above copyright notice and this permission notice shall be */ 00024 /* included in all copies or substantial portions of the */ 00025 /* Software. */ 00026 /* */ 00027 /* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND */ 00028 /* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES */ 00029 /* OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND */ 00030 /* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT */ 00031 /* HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, */ 00032 /* WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING */ 00033 /* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR */ 00034 /* OTHER DEALINGS IN THE SOFTWARE. */ 00035 /* */ 00036 /************************************************************************/ 00037 00038 #ifndef VIGRA_IMAGECONTAINER_HXX 00039 #define VIGRA_IMAGECONTAINER_HXX 00040 00041 #include "utilities.hxx" 00042 #include "array_vector.hxx" 00043 #include "copyimage.hxx" 00044 00045 namespace vigra { 00046 00047 /** \addtogroup ImageContainers Image Containers 00048 Classes to manage multiple images (ImageArray..) 00049 */ 00050 //@{ 00051 00052 /********************************************************/ 00053 /* */ 00054 /* ImageArray */ 00055 /* */ 00056 /********************************************************/ 00057 00058 /** \brief Fundamental class template for arrays of equal-sized images. 00059 00060 An ImageArray manages an array of images of the type given as 00061 template parameter. Use it like a ArrayVector<ImageType>, it has 00062 the same interface, only operator< is missing from ImageArray. It 00063 offers additional functions for resizing the images and querying 00064 their common size. See \ref imageSize() for additional notes. 00065 00066 A custimized allocator can be passed as a template argument and via the constructor. 00067 By default, the allocator of the <tt>ImageType</tt> is reused. 00068 00069 <b>\#include</b> <<a href="imagecontainer_8hxx-source.html">vigra/imagecontainer.hxx</a>> 00070 00071 Namespace: vigra 00072 */ 00073 template <class ImageType, 00074 class Alloc = typename ImageType::allocator_type::template rebind<ImageType>::other > 00075 class ImageArray 00076 { 00077 Size2D imageSize_; 00078 00079 protected: 00080 typedef ArrayVector<ImageType, Alloc> ImageVector; 00081 ImageVector images_; 00082 00083 public: 00084 /** the type of the contained values/images 00085 */ 00086 typedef ImageType value_type; 00087 00088 typedef typename ImageVector::iterator iterator; 00089 typedef typename ImageVector::const_iterator const_iterator; 00090 typedef typename ImageVector::reverse_iterator reverse_iterator; 00091 typedef typename ImageVector::const_reverse_iterator const_reverse_iterator; 00092 typedef typename ImageVector::reference reference; 00093 typedef typename ImageVector::const_reference const_reference; 00094 #if !defined(_MSC_VER) || _MSC_VER >= 1300 00095 typedef typename ImageVector::pointer pointer; 00096 #endif 00097 typedef typename ImageVector::difference_type difference_type; 00098 typedef typename ImageVector::size_type size_type; 00099 00100 /** init an array of numImages equal-sized images; use the specified allocator. 00101 */ 00102 ImageArray(unsigned int numImages, const Diff2D &imageSize, 00103 Alloc const & alloc = Alloc()) 00104 : imageSize_(imageSize), 00105 images_(numImages, ImageType(), alloc) 00106 { 00107 for(unsigned int i=0; i<numImages; i++) 00108 images_[i].resize(Size2D(imageSize)); 00109 } 00110 00111 /** Init an array of numImages equal-sized images. The size 00112 depends on ImageType's default constructor (so it will 00113 usually be 0x0); use the specified allocator. 00114 */ 00115 ImageArray(unsigned int numImages= 0, Alloc const & alloc = Alloc()) 00116 : images_(numImages, alloc) 00117 { 00118 imageSize_= empty()? Size2D(0, 0) : front().size(); 00119 } 00120 00121 /** fill constructor: Init an array with numImages copies of 00122 the given image. (STL-Sequence interface); use the specified allocator. 00123 */ 00124 ImageArray(unsigned int numImages, const ImageType &image, Alloc const & alloc = Alloc()) 00125 : imageSize_(image.size()), 00126 images_(numImages, image, alloc) 00127 { 00128 } 00129 00130 /** range constructor: Construct an array containing copies of 00131 the images in [begin, end). Those images must all have the 00132 same size, see \ref imageSize(). (STL-Sequence interface); 00133 use the specified allocator. 00134 */ 00135 template<class InputIterator> 00136 ImageArray(InputIterator begin, InputIterator end, Alloc const & alloc = Alloc()) 00137 : imageSize_(begin!=end? (*begin).size() : Size2D(0,0)), 00138 images_(begin, end, alloc) 00139 { 00140 } 00141 00142 virtual ~ImageArray() {} 00143 00144 /** Operator for a vector-like access to the contained images 00145 (STL-Vector interface) 00146 */ 00147 reference operator [](size_type index) 00148 { 00149 return images_[index]; 00150 } 00151 00152 /** Operator for a vector-like access to the contained images 00153 (STL-Vector interface) 00154 */ 00155 const_reference operator [](size_type index) const 00156 { 00157 return images_[index]; 00158 } 00159 00160 /** Returns an iterator pointing to the first image 00161 (STL-Container interface) 00162 */ 00163 iterator begin() 00164 { 00165 return images_.begin(); 00166 } 00167 00168 /** Returns an iterator pointing to the first image 00169 (STL-Container interface) 00170 */ 00171 const_iterator begin() const 00172 { 00173 return images_.begin(); 00174 } 00175 00176 /** Returns an iterator pointing behind the last image 00177 (STL-Container interface) 00178 */ 00179 iterator end() 00180 { 00181 return images_.end(); 00182 } 00183 00184 /** Returns an iterator pointing behind the last image 00185 (STL-Container interface) 00186 */ 00187 const_iterator end() const 00188 { 00189 return images_.end(); 00190 } 00191 00192 /** Returns a reverse_iterator pointing to the first image of 00193 the reversed view of this array (STL-Reversable Container 00194 interface) 00195 */ 00196 reverse_iterator rbegin() 00197 { 00198 return images_.rbegin(); 00199 } 00200 00201 /** Returns a reverse_iterator pointing to the first image of 00202 the reversed view of this array (STL-Reversable Container 00203 interface) 00204 */ 00205 const_reverse_iterator rbegin() const 00206 { 00207 return images_.rbegin(); 00208 } 00209 00210 /** Returns a reverse_iterator pointing behind the last image 00211 of the reversed view of this array (STL-Reversable 00212 Container interface) 00213 */ 00214 reverse_iterator rend() 00215 { 00216 return images_.rend(); 00217 } 00218 00219 /** Returns a reverse_iterator pointing behind the last image 00220 of the reversed view of this array (STL-Reversable 00221 Container interface) 00222 */ 00223 const_reverse_iterator rend() const 00224 { 00225 return images_.rend(); 00226 } 00227 00228 /** Query size of this ImageArray, that is: the number of 00229 images. (STL-Container interface) 00230 */ 00231 size_type size() const 00232 { 00233 return images_.size(); 00234 } 00235 00236 /** Query maximum size of this ImageArray, that is: the 00237 max. parameter you may pass to resize(). (STL-Container 00238 interface) 00239 */ 00240 size_type max_size() const 00241 { 00242 return images_.max_size(); 00243 } 00244 00245 /** Returns true if and only if there are no contained 00246 images. (STL-Container interface) 00247 */ 00248 bool empty() 00249 { 00250 return images_.empty(); 00251 } 00252 00253 /** Returns true if and only if both ImageArrays have exactly 00254 the same contents and all images did compare equal with the 00255 corresponding image in the other ImageArray. (STL-Forward 00256 Container interface) 00257 */ 00258 bool operator ==(const ImageArray<ImageType> &other) 00259 { 00260 return (imageSize() == other.imageSize()) 00261 && (images_ == other.images_); 00262 } 00263 00264 /** Insert image at/before pos. (STL-Sequence interface) 00265 */ 00266 iterator insert(iterator pos, const_reference image) 00267 { 00268 return images_.insert(pos, image); 00269 } 00270 00271 /** Insert count copies of image at/before pos. (STL-Sequence 00272 interface) 00273 */ 00274 void insert (iterator pos, size_type count, const_reference image); 00275 00276 /** Insert copies of images from [begin, end) at/before 00277 pos. (STL-Sequence interface) 00278 */ 00279 template<class InputIterator> 00280 void insert(iterator pos, InputIterator begin, InputIterator end) 00281 { 00282 images_.insert(pos, begin, end); 00283 } 00284 00285 /** Removes the image at pos from this array. (STL-Sequence 00286 interface) 00287 */ 00288 iterator erase(iterator pos) 00289 { 00290 return images_.erase(pos); 00291 } 00292 00293 /** Removes the images from [begin, end) from this 00294 array. (STL-Sequence interface) 00295 */ 00296 iterator erase(iterator begin, iterator end) 00297 { 00298 return images_.erase(begin, end); 00299 } 00300 00301 /** Empty this array. (STL-Sequence interface) 00302 */ 00303 void clear() 00304 { 00305 images_.clear(); 00306 } 00307 00308 /** Resize this ImageArray, throwing the last images away if 00309 you make the array smaller or appending new images of the 00310 right size at the end of the array if you make it 00311 larger. (STL-Sequence interface) 00312 */ 00313 void resize(size_type newSize) 00314 { 00315 if (newSize != size()) 00316 { 00317 size_type oldSize= size(); 00318 images_.resize(newSize); 00319 for (size_type i= oldSize; i<newSize; i++) 00320 images_[i].resize(imageSize()); 00321 } 00322 } 00323 00324 /** Resize this ImageArray, throwing the last images away if 00325 you make the array smaller or appending new copies of image 00326 at the end of the array if you make it larger. 00327 precondition: <tt>image.size() == imageSize()</tt> 00328 (STL-Sequence interface) 00329 */ 00330 void resize(size_type newSize, ImageType &image) 00331 { 00332 if (newSize != size()) 00333 { 00334 vigra_precondition(image.size() == imageSize(), 00335 "trying to append images of wrong size to ImageArray with resize()"); 00336 images_.resize(newSize, image); 00337 } 00338 } 00339 00340 /** return the first image. (STL-Sequence interface) 00341 */ 00342 reference front() 00343 { 00344 return images_.front(); 00345 } 00346 00347 /** return the first image. (STL-Sequence interface) 00348 */ 00349 const_reference front() const 00350 { 00351 return images_.front(); 00352 } 00353 00354 /** return the last image. (STL-Vector interface) 00355 */ 00356 reference back() 00357 { 00358 return images_.back(); 00359 } 00360 00361 /** return the last image. (STL-Vector interface) 00362 */ 00363 const_reference back() const 00364 { 00365 return images_.back(); 00366 } 00367 00368 /** append image to array (STL-Back Insertion Sequence interface) 00369 */ 00370 void push_back(const_reference image) 00371 { 00372 images_.push_back(image); 00373 } 00374 00375 /** remove last image from array (STL-Back Insertion Sequence interface) 00376 */ 00377 void pop_back() 00378 { 00379 images_.pop_back(); 00380 } 00381 00382 /** swap contents of this array with the contents of other 00383 (STL-Container interface) 00384 */ 00385 void swap(const_reference other) 00386 { 00387 Size2D oldImageSize = imageSize_; 00388 images_.swap(other.images_); 00389 imageSize_ = other.imageSize_; 00390 other.imageSize_ = oldImageSize; 00391 } 00392 00393 /** number of image objects for which memory has been allocated 00394 (STL-Vector interface) 00395 */ 00396 size_type capacity() const 00397 { 00398 return images_.capacity(); 00399 } 00400 00401 /** increase capacity(). (STL-Vector interface) 00402 */ 00403 void reserve(size_type n) 00404 { 00405 images_.reserve(n); 00406 } 00407 00408 /** Query the size of the contained images. ImageArray will 00409 maintain an array of equal-sized images of this 00410 size. However, <em>do not resize the contained images 00411 manually</em>. ImageArray currently has no way to detect or 00412 prevent this. 00413 */ 00414 Size2D imageSize() const 00415 { return imageSize_; } 00416 00417 /** Resize all images to a common new size (No-op if 00418 <tt>newSize == imageSize()</tt>). See \ref imageSize() for 00419 an important note about resizing the images. 00420 */ 00421 virtual void resizeImages(const Diff2D &newSize) 00422 { 00423 if (newSize!=imageSize()) 00424 { 00425 for(unsigned int i=0; i<size(); i++) 00426 images_[i].resize(Size2D(newSize)); 00427 imageSize_= newSize; 00428 } 00429 } 00430 00431 /** Resize all images to a common new size (No-op if 00432 <tt>newSize == imageSize()</tt>). See \ref imageSize() for 00433 an important note about resizing the images. 00434 00435 (Convenience function, same as calling 00436 <tt>resizeImages(Diff2D(width, height));</tt>.) 00437 */ 00438 void resizeImages(int width, int height) 00439 { 00440 resizeImages(Size2D(width, height)); 00441 } 00442 }; 00443 00444 /********************************************************/ 00445 /* */ 00446 /* ImagePyramid */ 00447 /* */ 00448 /********************************************************/ 00449 00450 /** \brief Class template for logarithmically tapering image pyramids. 00451 00452 An ImagePyramid manages an array of images of the type given as 00453 template parameter, where each level has half the width and height 00454 of its predecessor. It actually represents a sequence of pyramid 00455 levels whose start and end index are configurable. For Burt-style 00456 pyramids, see also \ref pyramidReduceBurtFilter and \ref 00457 pyramidExpandBurtFilter. 00458 00459 A custimized allocator can be passed as a template argument and 00460 via the constructor. By default, the allocator of the 00461 <tt>ImageType</tt> is reused. 00462 00463 <b>\#include</b> <<a href="imagecontainer_8hxx-source.html">vigra/imagecontainer.hxx</a>> 00464 00465 Namespace: vigra 00466 */ 00467 template <class ImageType, 00468 class Alloc = typename ImageType::allocator_type::template rebind<ImageType>::other > 00469 class ImagePyramid 00470 { 00471 int lowestLevel_, highestLevel_; 00472 00473 protected: 00474 typedef ArrayVector<ImageType, Alloc> ImageVector; 00475 ImageVector images_; 00476 00477 public: 00478 /** the type of the contained values/images 00479 */ 00480 typedef ImageType value_type; 00481 00482 typedef typename ImageVector::iterator iterator; 00483 typedef typename ImageVector::const_iterator const_iterator; 00484 typedef typename ImageVector::reverse_iterator reverse_iterator; 00485 typedef typename ImageVector::const_reverse_iterator const_reverse_iterator; 00486 typedef typename ImageVector::reference reference; 00487 typedef typename ImageVector::const_reference const_reference; 00488 #if !defined(_MSC_VER) || _MSC_VER >= 1300 00489 typedef typename ImageVector::pointer pointer; 00490 #endif 00491 typedef typename ImageVector::difference_type difference_type; 00492 typedef int size_type; 00493 00494 /** Init a pyramid between the given levels (inclusive). 00495 * 00496 * Allocate the given \a imageSize at the pyramid level given 00497 * in \a sizeAppliesToLevel (default: level 0 / bottom) and 00498 * size the other levels using recursive reduction/expansion 00499 * by factors of 2. Use the specified allocator for image 00500 * creation. The image type must be default constructible and 00501 * resizable. sizeAppliesToLevel must be the in range 00502 * lowestLevel..highestLevel (inclusive). 00503 */ 00504 ImagePyramid(int lowestLevel, int highestLevel, 00505 const Diff2D &imageSize, int sizeAppliesToLevel = 0, 00506 Alloc const & alloc = Alloc()) 00507 : lowestLevel_(0), highestLevel_(-1), 00508 images_(alloc) 00509 { 00510 resize(lowestLevel, highestLevel, imageSize, sizeAppliesToLevel); 00511 } 00512 00513 /** 00514 * Init a pyramid between the given levels (inclusive). 00515 * 00516 * Copy the given \a image into the pyramid level given in \a 00517 * copyImageToLevel (default: level 0 / bottom) and size the 00518 * other levels using recursive reduction/expansion by factors 00519 * of 2 (their image data is not initialized). Use the 00520 * specified allocator for image creation. The image type 00521 * must be default constructible and resizable. 00522 * sizeAppliesToLevel must be the in range 00523 * lowestLevel..highestLevel (inclusive). 00524 */ 00525 ImagePyramid(int lowestLevel, int highestLevel, 00526 const ImageType &image, int copyImageToLevel = 0, 00527 Alloc const & alloc = Alloc()) 00528 : lowestLevel_(0), highestLevel_(-1), 00529 images_(alloc) 00530 { 00531 resize(lowestLevel, highestLevel, image.size(), copyImageToLevel); 00532 copyImage(srcImageRange(image), destImage((*this)[copyImageToLevel])); 00533 } 00534 00535 /** 00536 * Init a pyramid between the given levels (inclusive). 00537 * 00538 * Copy the image given by the range \a ul to \a lr into the 00539 * pyramid level given in \a copyImageToLevel (default: level 00540 * 0 / bottom) and size the other levels using recursive 00541 * reduction/expansion by factors of 2 (their image data is 00542 * not initialized). Use the specified allocator for image 00543 * creation. The image type must be default constructible and 00544 * resizable. sizeAppliesToLevel must be the in range 00545 * lowestLevel..highestLevel (inclusive). 00546 */ 00547 template <class SrcIterator, class SrcAccessor> 00548 ImagePyramid(int lowestLevel, int highestLevel, 00549 SrcIterator ul, SrcIterator lr, SrcAccessor src, 00550 int copyImageToLevel = 0, 00551 Alloc const & alloc = Alloc()) 00552 : lowestLevel_(0), highestLevel_(-1), 00553 images_(alloc) 00554 { 00555 resize(lowestLevel, highestLevel, lr - ul, copyImageToLevel); 00556 copyImage(srcIterRange(ul, lr, src), destImage((*this)[copyImageToLevel])); 00557 } 00558 00559 /** Init an empty pyramid. Use the specified allocator. 00560 */ 00561 ImagePyramid(Alloc const & alloc = Alloc()) 00562 : lowestLevel_(0), highestLevel_(-1), 00563 images_(alloc) 00564 {} 00565 00566 virtual ~ImagePyramid() {} 00567 00568 /** Get the index of the lowest allocated level of the pyramid. 00569 */ 00570 int lowestLevel() const 00571 { 00572 return lowestLevel_; 00573 } 00574 00575 /** Get the index of the highest allocated level of the pyramid. 00576 */ 00577 int highestLevel() const 00578 { 00579 return highestLevel_; 00580 } 00581 00582 /** Operator for a vector-like access to the contained images 00583 (STL-Vector interface) 00584 */ 00585 reference operator [](size_type index) 00586 { 00587 return images_[index - lowestLevel_]; 00588 } 00589 00590 /** Operator for a vector-like access to the contained images 00591 (STL-Vector interface) 00592 */ 00593 const_reference operator [](size_type index) const 00594 { 00595 return images_[index - lowestLevel_]; 00596 } 00597 00598 /** Returns an iterator pointing to the first image 00599 (STL-Container interface) 00600 */ 00601 iterator begin() 00602 { 00603 return images_.begin(); 00604 } 00605 00606 /** Returns an iterator pointing to the first image 00607 (STL-Container interface) 00608 */ 00609 const_iterator begin() const 00610 { 00611 return images_.begin(); 00612 } 00613 00614 /** Returns an iterator pointing behind the last image 00615 (STL-Container interface) 00616 */ 00617 iterator end() 00618 { 00619 return images_.end(); 00620 } 00621 00622 /** Returns an iterator pointing behind the last image 00623 (STL-Container interface) 00624 */ 00625 const_iterator end() const 00626 { 00627 return images_.end(); 00628 } 00629 00630 /** Returns a reverse_iterator pointing to the first image of 00631 the reversed view of this array (STL-Reversable Container 00632 interface) 00633 */ 00634 reverse_iterator rbegin() 00635 { 00636 return images_.rbegin(); 00637 } 00638 00639 /** Returns a reverse_iterator pointing to the first image of 00640 the reversed view of this array (STL-Reversable Container 00641 interface) 00642 */ 00643 const_reverse_iterator rbegin() const 00644 { 00645 return images_.rbegin(); 00646 } 00647 00648 /** Returns a reverse_iterator pointing behind the last image 00649 of the reversed view of this array (STL-Reversable 00650 Container interface) 00651 */ 00652 reverse_iterator rend() 00653 { 00654 return images_.rend(); 00655 } 00656 00657 /** Returns a reverse_iterator pointing behind the last image 00658 of the reversed view of this array (STL-Reversable 00659 Container interface) 00660 */ 00661 const_reverse_iterator rend() const 00662 { 00663 return images_.rend(); 00664 } 00665 00666 /** Query size of this ImageArray, that is: the number of 00667 images. (STL-Container interface) 00668 */ 00669 size_type size() const 00670 { 00671 return images_.size(); 00672 } 00673 00674 /** Returns true if and only if there are no contained 00675 images. (STL-Container interface) 00676 */ 00677 bool empty() 00678 { 00679 return images_.empty(); 00680 } 00681 00682 /** Returns true if and only if both ImageArrays have exactly 00683 the same contents and all images did compare equal with the 00684 corresponding image in the other ImageArray. (STL-Forward 00685 Container interface) 00686 */ 00687 bool operator ==(const ImagePyramid<ImageType, Alloc> &other) const 00688 { 00689 return (lowestLevel_ == other.lowestLevel_) && (highestLevel_ == other.highestLevel_) && 00690 (images_ == other.images_); 00691 } 00692 00693 /** Empty this array. (STL-Sequence interface) 00694 */ 00695 void clear() 00696 { 00697 images_.clear(); 00698 lowestLevel_ = 0; 00699 highestLevel_ = -1; 00700 } 00701 00702 /** Resize this ImageArray, throwing the last images away if 00703 you make the array smaller or appending new images of the 00704 right size at the end of the array if you make it 00705 larger. (STL-Sequence interface) 00706 */ 00707 void resize(int lowestLevel, int highestLevel, 00708 const Diff2D &imageSize, int sizeAppliesToLevel = 0) 00709 { 00710 vigra_precondition(lowestLevel <= highestLevel, 00711 "ImagePyramid::resize(): lowestLevel <= highestLevel required."); 00712 vigra_precondition(lowestLevel <= sizeAppliesToLevel && sizeAppliesToLevel <= highestLevel, 00713 "ImagePyramid::resize(): sizeAppliesToLevel must be between lowest and highest level (inclusive)."); 00714 00715 ImageVector images(highestLevel - lowestLevel + 1, ImageType()); 00716 00717 images[sizeAppliesToLevel - lowestLevel].resize(imageSize); 00718 for(int i=sizeAppliesToLevel + 1; i<=highestLevel; ++i) 00719 { 00720 unsigned int w = (images[i - 1 - lowestLevel].width() + 1) / 2; 00721 unsigned int h = (images[i - 1 - lowestLevel].height() + 1) / 2; 00722 images[i - lowestLevel].resize(w, h); 00723 } 00724 for(int i=sizeAppliesToLevel - 1; i>=lowestLevel; --i) 00725 { 00726 unsigned int w = 2*images[i + 1 - lowestLevel].width() - 1; 00727 unsigned int h = 2*images[i + 1 - lowestLevel].height() - 1; 00728 images[i - lowestLevel].resize(w, h); 00729 } 00730 00731 images_.swap(images); 00732 lowestLevel_ = lowestLevel; 00733 highestLevel_ = highestLevel; 00734 } 00735 00736 /** return the first image (lowestLevel()). (STL-Sequence interface) 00737 */ 00738 reference front() 00739 { 00740 return images_.front(); 00741 } 00742 00743 /** return the first image (lowestLevel()). (STL-Sequence interface) 00744 */ 00745 const_reference front() const 00746 { 00747 return images_.front(); 00748 } 00749 00750 /** return the last image (highestLevel()). (STL-Vector interface) 00751 */ 00752 reference back() 00753 { 00754 return images_.back(); 00755 } 00756 00757 /** return the last image (highestLevel()). (STL-Vector interface) 00758 */ 00759 const_reference back() const 00760 { 00761 return images_.back(); 00762 } 00763 00764 /** swap contents of this array with the contents of other 00765 (STL-Container interface) 00766 */ 00767 void swap(const ImagePyramid<ImageType, Alloc> &other) 00768 { 00769 images_.swap(other.images_); 00770 std::swap(lowestLevel_, other.lowestLevel_); 00771 std::swap(highestLevel_, other.highestLevel_); 00772 } 00773 }; 00774 00775 //@} 00776 00777 } // namespace vigra 00778 00779 #endif // VIGRA_IMAGECONTAINER_HXX
© Ullrich Köthe (ullrich.koethe@iwr.uni-heidelberg.de) |
html generated using doxygen and Python
|