[ VIGRA Homepage | Class Index | Function Index | File Index | Main Page ]
![]() |
vigra/imagecontainer.hxx | ![]() |
---|
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.4.0, Dec 21 2005 ) */ 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 /* koethe@informatik.uni-hamburg.de or */ 00012 /* vigra@kogs1.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 "vigra/utilities.hxx" 00042 #include "vigra/array_vector.hxx" 00043 00044 namespace vigra { 00045 00046 /** \addtogroup ImageContainers Image Containers 00047 Classes to manage multiple images (ImageArray..) 00048 */ 00049 //@{ 00050 00051 /********************************************************/ 00052 /* */ 00053 /* ImageArray */ 00054 /* */ 00055 /********************************************************/ 00056 00057 /** \brief Fundamental class template for arrays of equal-sized images. 00058 00059 An ImageArray manages an array of images of the type given as 00060 template parameter. Use it like a ArrayVector<ImageType>, it has 00061 the same interface, only operator< is missing from ImageArray. It 00062 offers additional functions for resizing the images and querying 00063 their common size. See \ref imageSize() for additional notes. 00064 00065 A custimized allocator can be passed as a template argument and via the constructor. 00066 By default, the allocator of the <tt>ImageType</tt> is reused. 00067 00068 <b>\#include</b> "<a href="imagecontainer_8hxx-source.html">vigra/imagecontainer.hxx</a>" 00069 00070 Namespace: vigra 00071 */ 00072 template <class ImageType, 00073 class Alloc = typename ImageType::allocator_type::template rebind<ImageType>::other > 00074 class ImageArray 00075 { 00076 Size2D imageSize_; 00077 00078 protected: 00079 typedef ArrayVector<ImageType, Alloc> ImageVector; 00080 ImageVector images_; 00081 00082 public: 00083 /** the type of the contained values/images 00084 */ 00085 typedef ImageType value_type; 00086 00087 typedef typename ImageVector::iterator iterator; 00088 typedef typename ImageVector::const_iterator const_iterator; 00089 typedef typename ImageVector::reverse_iterator reverse_iterator; 00090 typedef typename ImageVector::const_reverse_iterator const_reverse_iterator; 00091 typedef typename ImageVector::reference reference; 00092 typedef typename ImageVector::const_reference const_reference; 00093 #if !defined(_MSC_VER) || _MSC_VER >= 1300 00094 typedef typename ImageVector::pointer pointer; 00095 #endif 00096 typedef typename ImageVector::difference_type difference_type; 00097 typedef typename ImageVector::size_type size_type; 00098 00099 /** init an array of numImages equal-sized images; use the specified allocator. 00100 */ 00101 ImageArray(unsigned int numImages, const Diff2D &imageSize, 00102 Alloc const & alloc = Alloc()) 00103 : imageSize_(imageSize), 00104 images_(numImages, ImageType(), alloc) 00105 { 00106 for(unsigned int i=0; i<numImages; i++) 00107 images_[i].resize(Size2D(imageSize)); 00108 } 00109 00110 /** Init an array of numImages equal-sized images. The size 00111 depends on ImageType's default constructor (so it will 00112 usually be 0x0); use the specified allocator. 00113 */ 00114 ImageArray(unsigned int numImages= 0, Alloc const & alloc = Alloc()) 00115 : images_(numImages, alloc) 00116 { 00117 imageSize_= empty()? Size2D(0, 0) : front().size(); 00118 } 00119 00120 /** fill constructor: Init an array with numImages copies of 00121 the given image. (STL-Sequence interface); use the specified allocator. 00122 */ 00123 ImageArray(unsigned int numImages, const ImageType &image, Alloc const & alloc = Alloc()) 00124 : imageSize_(image.size()), 00125 images_(numImages, image, alloc) 00126 { 00127 } 00128 00129 /** range constructor: Construct an array containing copies of 00130 the images in [begin, end). Those images must all have the 00131 same size, see \ref imageSize(). (STL-Sequence interface); 00132 use the specified allocator. 00133 */ 00134 template<class InputIterator> 00135 ImageArray(InputIterator begin, InputIterator end, Alloc const & alloc = Alloc()) 00136 : imageSize_(begin!=end? (*begin).size() : Size2D(0,0)), 00137 images_(begin, end, alloc) 00138 { 00139 } 00140 00141 virtual ~ImageArray() {} 00142 00143 /** Operator for a vector-like access to the contained images 00144 (STL-Vector interface) 00145 */ 00146 reference operator [](size_type index) 00147 { 00148 return images_[index]; 00149 } 00150 00151 /** Operator for a vector-like access to the contained images 00152 (STL-Vector interface) 00153 */ 00154 const_reference operator [](size_type index) const 00155 { 00156 return images_[index]; 00157 } 00158 00159 /** Returns an iterator pointing to the first image 00160 (STL-Container interface) 00161 */ 00162 iterator begin() 00163 { 00164 return images_.begin(); 00165 } 00166 00167 /** Returns an iterator pointing to the first image 00168 (STL-Container interface) 00169 */ 00170 const_iterator begin() const 00171 { 00172 return images_.begin(); 00173 } 00174 00175 /** Returns an iterator pointing behind the last image 00176 (STL-Container interface) 00177 */ 00178 iterator end() 00179 { 00180 return images_.end(); 00181 } 00182 00183 /** Returns an iterator pointing behind the last image 00184 (STL-Container interface) 00185 */ 00186 const_iterator end() const 00187 { 00188 return images_.end(); 00189 } 00190 00191 /** Returns a reverse_iterator pointing to the first image of 00192 the reversed view of this array (STL-Reversable Container 00193 interface) 00194 */ 00195 reverse_iterator rbegin() 00196 { 00197 return images_.rbegin(); 00198 } 00199 00200 /** Returns a reverse_iterator pointing to the first image of 00201 the reversed view of this array (STL-Reversable Container 00202 interface) 00203 */ 00204 const_reverse_iterator rbegin() const 00205 { 00206 return images_.rbegin(); 00207 } 00208 00209 /** Returns a reverse_iterator pointing behind the last image 00210 of the reversed view of this array (STL-Reversable 00211 Container interface) 00212 */ 00213 reverse_iterator rend() 00214 { 00215 return images_.rend(); 00216 } 00217 00218 /** Returns a reverse_iterator pointing behind the last image 00219 of the reversed view of this array (STL-Reversable 00220 Container interface) 00221 */ 00222 const_reverse_iterator rend() const 00223 { 00224 return images_.rend(); 00225 } 00226 00227 /** Query size of this ImageArray, that is: the number of 00228 images. (STL-Container interface) 00229 */ 00230 size_type size() const 00231 { 00232 return images_.size(); 00233 } 00234 00235 /** Query maximum size of this ImageArray, that is: the 00236 max. parameter you may pass to resize(). (STL-Container 00237 interface) 00238 */ 00239 size_type max_size() const 00240 { 00241 return images_.max_size(); 00242 } 00243 00244 /** Returns true if and only if there are no contained 00245 images. (STL-Container interface) 00246 */ 00247 bool empty() 00248 { 00249 return images_.empty(); 00250 } 00251 00252 /** Returns true if and only if both ImageArrays have exactly 00253 the same contents and all images did compare equal with the 00254 corresponding image in the other ImageArray. (STL-Forward 00255 Container interface) 00256 */ 00257 bool operator ==(const ImageArray<ImageType> &other) 00258 { 00259 return (imageSize() == other.imageSize()) 00260 && (images_ == other.images_); 00261 } 00262 00263 /** Insert image at/before pos. (STL-Sequence interface) 00264 */ 00265 iterator insert(iterator pos, const_reference image) 00266 { 00267 return images_.insert(pos, image); 00268 } 00269 00270 /** Insert count copies of image at/before pos. (STL-Sequence 00271 interface) 00272 */ 00273 void insert (iterator pos, size_type count, const_reference image); 00274 00275 /** Insert copies of images from [begin, end) at/before 00276 pos. (STL-Sequence interface) 00277 */ 00278 template<class InputIterator> 00279 void insert(iterator pos, InputIterator begin, InputIterator end) 00280 { 00281 images_.insert(pos, begin, end); 00282 } 00283 00284 /** Removes the image at pos from this array. (STL-Sequence 00285 interface) 00286 */ 00287 iterator erase(iterator pos) 00288 { 00289 return images_.erase(pos); 00290 } 00291 00292 /** Removes the images from [begin, end) from this 00293 array. (STL-Sequence interface) 00294 */ 00295 iterator erase(iterator begin, iterator end) 00296 { 00297 return images_.erase(begin, end); 00298 } 00299 00300 /** Empty this array. (STL-Sequence interface) 00301 */ 00302 void clear() 00303 { 00304 images_.clear(); 00305 } 00306 00307 /** Resize this ImageArray, throwing the last images away if 00308 you make the array smaller or appending new images of the 00309 right size at the end of the array if you make it 00310 larger. (STL-Sequence interface) 00311 */ 00312 void resize(size_type newSize) 00313 { 00314 if (newSize != size()) 00315 { 00316 size_type oldSize= size(); 00317 images_.resize(newSize); 00318 for (size_type i= oldSize; i<newSize; i++) 00319 images_[i].resize(imageSize()); 00320 } 00321 } 00322 00323 /** Resize this ImageArray, throwing the last images away if 00324 you make the array smaller or appending new copies of image 00325 at the end of the array if you make it larger. 00326 precondition: <tt>image.size() == imageSize()</tt> 00327 (STL-Sequence interface) 00328 */ 00329 void resize(size_type newSize, ImageType &image) 00330 { 00331 if (newSize != size()) 00332 { 00333 vigra_precondition(image.size() == imageSize(), 00334 "trying to append images of wrong size to ImageArray with resize()"); 00335 images_.resize(newSize, image); 00336 } 00337 } 00338 00339 /** return the first image. (STL-Sequence interface) 00340 */ 00341 reference front() 00342 { 00343 return images_.front(); 00344 } 00345 00346 /** return the first image. (STL-Sequence interface) 00347 */ 00348 const_reference front() const 00349 { 00350 return images_.front(); 00351 } 00352 00353 /** return the last image. (STL-Vector interface) 00354 */ 00355 reference back() 00356 { 00357 return images_.back(); 00358 } 00359 00360 /** return the last image. (STL-Vector interface) 00361 */ 00362 const_reference back() const 00363 { 00364 return images_.back(); 00365 } 00366 00367 /** append image to array (STL-Back Insertion Sequence interface) 00368 */ 00369 void push_back(const_reference image) 00370 { 00371 images_.push_back(image); 00372 } 00373 00374 /** remove last image from array (STL-Back Insertion Sequence interface) 00375 */ 00376 void pop_back() 00377 { 00378 images_.pop_back(); 00379 } 00380 00381 /** swap contents of this array with the contents of other 00382 (STL-Container interface) 00383 */ 00384 void swap(const_reference other) 00385 { 00386 Size2D oldImageSize = imageSize_; 00387 images_.swap(other.images_); 00388 imageSize_ = other.imageSize_; 00389 other.imageSize_ = oldImageSize; 00390 } 00391 00392 /** number of image objects for which memory has been allocated 00393 (STL-Vector interface) 00394 */ 00395 size_type capacity() const 00396 { 00397 return images_.capacity(); 00398 } 00399 00400 /** increase capacity(). (STL-Vector interface) 00401 */ 00402 void reserve(size_type n) 00403 { 00404 images_.reserve(n); 00405 } 00406 00407 /** Query the size of the contained images. ImageArray will 00408 maintain an array of equal-sized images of this 00409 size. However, <em>do not resize the contained images 00410 manually</em>. ImageArray currently has no way to detect or 00411 prevent this. 00412 */ 00413 Size2D imageSize() const 00414 { return imageSize_; } 00415 00416 /** Resize all images to a common new size (No-op if 00417 <tt>newSize == imageSize()</tt>). See \ref imageSize() for 00418 an important note about resizing the images. 00419 */ 00420 virtual void resizeImages(const Diff2D &newSize) 00421 { 00422 if (newSize!=imageSize()) 00423 { 00424 for(unsigned int i=0; i<size(); i++) 00425 images_[i].resize(Size2D(newSize)); 00426 imageSize_= newSize; 00427 } 00428 } 00429 00430 /** Resize all images to a common new size (No-op if 00431 <tt>newSize == imageSize()</tt>). See \ref imageSize() for 00432 an important note about resizing the images. 00433 00434 (Convenience function, same as calling 00435 <tt>resizeImages(Diff2D(width, height));</tt>.) 00436 */ 00437 void resizeImages(int width, int height) 00438 { 00439 resizeImages(Size2D(width, height)); 00440 } 00441 }; 00442 00443 //@} 00444 00445 } // namespace vigra 00446 00447 #endif // VIGRA_IMAGECONTAINER_HXX
© Ullrich Köthe (koethe@informatik.uni-hamburg.de) |
html generated using doxygen and Python
|