[ VIGRA Homepage | Function Index | Class Index | Namespaces | File List | Main Page ]

imagecontainer.hxx
1/************************************************************************/
2/* */
3/* Copyright 1998-2002 by Ullrich Koethe */
4/* */
5/* This file is part of the VIGRA computer vision library. */
6/* The VIGRA Website is */
7/* http://hci.iwr.uni-heidelberg.de/vigra/ */
8/* Please direct questions, bug reports, and contributions to */
9/* ullrich.koethe@iwr.uni-heidelberg.de or */
10/* vigra@informatik.uni-hamburg.de */
11/* */
12/* Permission is hereby granted, free of charge, to any person */
13/* obtaining a copy of this software and associated documentation */
14/* files (the "Software"), to deal in the Software without */
15/* restriction, including without limitation the rights to use, */
16/* copy, modify, merge, publish, distribute, sublicense, and/or */
17/* sell copies of the Software, and to permit persons to whom the */
18/* Software is furnished to do so, subject to the following */
19/* conditions: */
20/* */
21/* The above copyright notice and this permission notice shall be */
22/* included in all copies or substantial portions of the */
23/* Software. */
24/* */
25/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND */
26/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES */
27/* OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND */
28/* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT */
29/* HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, */
30/* WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING */
31/* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR */
32/* OTHER DEALINGS IN THE SOFTWARE. */
33/* */
34/************************************************************************/
35
36#ifndef VIGRA_IMAGECONTAINER_HXX
37#define VIGRA_IMAGECONTAINER_HXX
38
39#include "utilities.hxx"
40#include "array_vector.hxx"
41#include "copyimage.hxx"
42
43namespace vigra {
44
45/** \addtogroup ImageContainers Image Containers
46 Classes to manage multiple images (ImageArray..)
47*/
48//@{
49
50/********************************************************/
51/* */
52/* ImageArray */
53/* */
54/********************************************************/
55
56/** \brief Fundamental class template for arrays of equal-sized images.
57
58 An ImageArray manages an array of images of the type given as
59 template parameter. Use it like a ArrayVector<ImageType>, it has
60 the same interface, only operator< is missing from ImageArray. It
61 offers additional functions for resizing the images and querying
62 their common size. See \ref imageSize() for additional notes.
63
64 A customized allocator can be passed as a template argument and via the constructor.
65 By default, the allocator of the <tt>ImageType</tt> is reused.
66
67 <b>\#include</b> <vigra/imagecontainer.hxx> <br/>
68 Namespace: vigra
69*/
70template <class ImageType,
71 class Alloc = typename ImageType::allocator_type::template rebind<ImageType>::other >
73{
74 Size2D imageSize_;
75
76protected:
78 ImageVector images_;
79
80public:
81 /** the type of the contained values/images
82 */
84
85 typedef typename ImageVector::iterator iterator;
87 typedef typename ImageVector::reverse_iterator reverse_iterator;
88 typedef typename ImageVector::const_reverse_iterator const_reverse_iterator;
89 typedef typename ImageVector::reference reference;
91#if !defined(_MSC_VER) || _MSC_VER >= 1300
92 typedef typename ImageVector::pointer pointer;
93#endif
94 typedef typename ImageVector::difference_type difference_type;
95 typedef typename ImageVector::size_type size_type;
96
97 /** init an array of numImages equal-sized images; use the specified allocator.
98 */
99 ImageArray(unsigned int numImages, const Diff2D &imageSize,
100 Alloc const & alloc = Alloc())
101 : imageSize_(imageSize),
102 images_(numImages, ImageType(), alloc)
103 {
104 for(unsigned int i=0; i<numImages; i++)
105 images_[i].resize(Size2D(imageSize));
106 }
107
108 /** Init an array of numImages equal-sized images. The size
109 depends on ImageType's default constructor (so it will
110 usually be 0x0); use the specified allocator.
111 */
112 ImageArray(unsigned int numImages= 0, Alloc const & alloc = Alloc())
113 : images_(numImages, alloc)
114 {
115 imageSize_= empty()? Size2D(0, 0) : front().size();
116 }
117
118 /** fill constructor: Init an array with numImages copies of
119 the given image. (STL-Sequence interface); use the specified allocator.
120 */
121 ImageArray(unsigned int numImages, const ImageType &image, Alloc const & alloc = Alloc())
122 : imageSize_(image.size()),
123 images_(numImages, image, alloc)
124 {
125 }
126
127 /** range constructor: Construct an array containing copies of
128 the images in [begin, end). Those images must all have the
129 same size, see \ref imageSize(). (STL-Sequence interface);
130 use the specified allocator.
131 */
132 template<class InputIterator>
134 : imageSize_(begin!=end? (*begin).size() : Size2D(0,0)),
135 images_(begin, end, alloc)
136 {
137 }
138
139 virtual ~ImageArray() {}
140
141 /** Operator for a vector-like access to the contained images
142 (STL-Vector interface)
143 */
145 {
146 return images_[index];
147 }
148
149 /** Operator for a vector-like access to the contained images
150 (STL-Vector interface)
151 */
153 {
154 return images_[index];
155 }
156
157 /** Returns an iterator pointing to the first image
158 (STL-Container interface)
159 */
161 {
162 return images_.begin();
163 }
164
165 /** Returns an iterator pointing to the first image
166 (STL-Container interface)
167 */
169 {
170 return images_.begin();
171 }
172
173 /** Returns an iterator pointing behind the last image
174 (STL-Container interface)
175 */
177 {
178 return images_.end();
179 }
180
181 /** Returns an iterator pointing behind the last image
182 (STL-Container interface)
183 */
185 {
186 return images_.end();
187 }
188
189 /** Returns a reverse_iterator pointing to the first image of
190 the reversed view of this array (STL-Reversable Container
191 interface)
192 */
193 reverse_iterator rbegin()
194 {
195 return images_.rbegin();
196 }
197
198 /** Returns a reverse_iterator pointing to the first image of
199 the reversed view of this array (STL-Reversable Container
200 interface)
201 */
202 const_reverse_iterator rbegin() const
203 {
204 return images_.rbegin();
205 }
206
207 /** Returns a reverse_iterator pointing behind the last image
208 of the reversed view of this array (STL-Reversable
209 Container interface)
210 */
211 reverse_iterator rend()
212 {
213 return images_.rend();
214 }
215
216 /** Returns a reverse_iterator pointing behind the last image
217 of the reversed view of this array (STL-Reversable
218 Container interface)
219 */
220 const_reverse_iterator rend() const
221 {
222 return images_.rend();
223 }
224
225 /** Query size of this ImageArray, that is: the number of
226 images. (STL-Container interface)
227 */
229 {
230 return images_.size();
231 }
232
233 /** Query maximum size of this ImageArray, that is: the
234 max. parameter you may pass to resize(). (STL-Container
235 interface)
236 */
238 {
239 return images_.max_size();
240 }
241
242 /** Returns true if and only if there are no contained
243 images. (STL-Container interface)
244 */
245 bool empty()
246 {
247 return images_.empty();
248 }
249
250 /** Returns true if and only if both ImageArrays have exactly
251 the same contents and all images did compare equal with the
252 corresponding image in the other ImageArray. (STL-Forward
253 Container interface)
254 */
256 {
257 return (imageSize() == other.imageSize())
258 && (images_ == other.images_);
259 }
260
261 /** Insert image at/before pos. (STL-Sequence interface)
262 */
264 {
265 return images_.insert(pos, image);
266 }
267
268 /** Insert count copies of image at/before pos. (STL-Sequence
269 interface)
270 */
271 void insert (iterator pos, size_type count, const_reference image);
272
273 /** Insert copies of images from [begin, end) at/before
274 pos. (STL-Sequence interface)
275 */
276 template<class InputIterator>
278 {
279 images_.insert(pos, begin, end);
280 }
281
282 /** Removes the image at pos from this array. (STL-Sequence
283 interface)
284 */
286 {
287 return images_.erase(pos);
288 }
289
290 /** Removes the images from [begin, end) from this
291 array. (STL-Sequence interface)
292 */
294 {
295 return images_.erase(begin, end);
296 }
297
298 /** Empty this array. (STL-Sequence interface)
299 */
300 void clear()
301 {
302 images_.clear();
303 }
304
305 /** Resize this ImageArray, throwing the last images away if
306 you make the array smaller or appending new images of the
307 right size at the end of the array if you make it
308 larger. (STL-Sequence interface)
309 */
311 {
312 if (newSize != size())
313 {
315 images_.resize(newSize);
316 for (size_type i= oldSize; i<newSize; i++)
317 images_[i].resize(imageSize());
318 }
319 }
320
321 /** Resize this ImageArray, throwing the last images away if
322 you make the array smaller or appending new copies of image
323 at the end of the array if you make it larger.
324 precondition: <tt>image.size() == imageSize()</tt>
325 (STL-Sequence interface)
326 */
328 {
329 if (newSize != size())
330 {
331 vigra_precondition(image.size() == imageSize(),
332 "trying to append images of wrong size to ImageArray with resize()");
333 images_.resize(newSize, image);
334 }
335 }
336
337 /** return the first image. (STL-Sequence interface)
338 */
340 {
341 return images_.front();
342 }
343
344 /** return the first image. (STL-Sequence interface)
345 */
347 {
348 return images_.front();
349 }
350
351 /** return the last image. (STL-Vector interface)
352 */
354 {
355 return images_.back();
356 }
357
358 /** return the last image. (STL-Vector interface)
359 */
361 {
362 return images_.back();
363 }
364
365 /** append image to array (STL-Back Insertion Sequence interface)
366 */
368 {
369 images_.push_back(image);
370 }
371
372 /** remove last image from array (STL-Back Insertion Sequence interface)
373 */
374 void pop_back()
375 {
376 images_.pop_back();
377 }
378
379 /** swap contents of this array with the contents of other
380 (STL-Container interface)
381 */
383 {
384 Size2D oldImageSize = imageSize_;
385 images_.swap(other.images_);
386 imageSize_ = other.imageSize_;
387 other.imageSize_ = oldImageSize;
388 }
389
390 /** number of image objects for which memory has been allocated
391 (STL-Vector interface)
392 */
394 {
395 return images_.capacity();
396 }
397
398 /** increase capacity(). (STL-Vector interface)
399 */
401 {
402 images_.reserve(n);
403 }
404
405 /** Query the size of the contained images. ImageArray will
406 maintain an array of equal-sized images of this
407 size. However, <em>do not resize the contained images
408 manually</em>. ImageArray currently has no way to detect or
409 prevent this.
410 */
412 { return imageSize_; }
413
414 /** Resize all images to a common new size (No-op if
415 <tt>newSize == imageSize()</tt>). See \ref imageSize() for
416 an important note about resizing the images.
417 */
418 virtual void resizeImages(const Diff2D &newSize)
419 {
420 if (newSize!=imageSize())
421 {
422 for(unsigned int i=0; i<size(); i++)
423 images_[i].resize(Size2D(newSize));
424 imageSize_= newSize;
425 }
426 }
427
428 /** Resize all images to a common new size (No-op if
429 <tt>newSize == imageSize()</tt>). See \ref imageSize() for
430 an important note about resizing the images.
431
432 (Convenience function, same as calling
433 <tt>resizeImages(Diff2D(width, height));</tt>.)
434 */
435 void resizeImages(int width, int height)
436 {
437 resizeImages(Size2D(width, height));
438 }
439};
440
441/********************************************************/
442/* */
443/* ImagePyramid */
444/* */
445/********************************************************/
446
447/** \brief Class template for logarithmically tapering image pyramids.
448
449 An ImagePyramid manages an array of images of the type given as
450 template parameter, where each level has half the width and height
451 of its predecessor. It actually represents a sequence of pyramid
452 levels whose start and end index are configurable.
453
454 To initialize all pyramid levels in the sense of a Gaussian pyramid,
455 use \ref pyramidReduceBurtFilter() and \ref pyramidExpandBurtFilter().
456 To create and reconstruct a Laplcaian pyramid, use
457 \ref pyramidReduceBurtLaplacian() and \ref pyramidExpandBurtLaplacian().
458
459 A customized allocator can be passed as a template argument and
460 via the constructor. By default, the allocator of the
461 <tt>ImageType</tt> is reused.
462
463 <b>\#include</b> <vigra/imagecontainer.hxx> <br/>
464 Namespace: vigra
465*/
466template <class ImageType,
467 class Alloc = typename ImageType::allocator_type::template rebind<ImageType>::other >
469{
470 int lowestLevel_, highestLevel_;
471
472protected:
474 ImageVector images_;
475
476public:
477 /** the type of the contained values/images
478 */
480
481 typedef typename ImageVector::iterator iterator;
483 typedef typename ImageVector::reverse_iterator reverse_iterator;
484 typedef typename ImageVector::const_reverse_iterator const_reverse_iterator;
485 typedef typename ImageVector::reference reference;
487#if !defined(_MSC_VER) || _MSC_VER >= 1300
488 typedef typename ImageVector::pointer pointer;
489#endif
490 typedef typename ImageVector::difference_type difference_type;
491 typedef int size_type;
492
493 /** Init a pyramid between the given levels (inclusive).
494 *
495 * Allocate the given \a imageSize at the pyramid level given
496 * in \a sizeAppliesToLevel (default: level 0 / bottom) and
497 * size the other levels using recursive reduction/expansion
498 * by factors of 2. Use the specified allocator for image
499 * creation. The image type must be default constructible and
500 * resizable. sizeAppliesToLevel must be the in range
501 * lowestLevel..highestLevel (inclusive).
502 */
504 const Diff2D &imageSize, int sizeAppliesToLevel = 0,
505 Alloc const & alloc = Alloc())
506 : lowestLevel_(0), highestLevel_(-1),
507 images_(alloc)
508 {
510 }
511
512 /**
513 * Init a pyramid between the given levels (inclusive).
514 *
515 * Copy the given \a image into the pyramid level given in \a
516 * copyImageToLevel (default: level 0 / bottom) and size the
517 * other levels using recursive reduction/expansion by factors
518 * of 2 (their image data is not initialized). Use the
519 * specified allocator for image creation. The image type
520 * must be default constructible and resizable.
521 * sizeAppliesToLevel must be the in range
522 * lowestLevel..highestLevel (inclusive).
523 */
525 const ImageType &image, int copyImageToLevel = 0,
526 Alloc const & alloc = Alloc())
527 : lowestLevel_(0), highestLevel_(-1),
528 images_(alloc)
529 {
531 copyImage(srcImageRange(image), destImage((*this)[copyImageToLevel]));
532 }
533
534 /**
535 * Init a pyramid between the given levels (inclusive).
536 *
537 * Copy the image given by the range \a ul to \a lr into the
538 * pyramid level given in \a copyImageToLevel (default: level
539 * 0 / bottom) and size the other levels using recursive
540 * reduction/expansion by factors of 2 (their image data is
541 * not initialized). Use the specified allocator for image
542 * creation. The image type must be default constructible and
543 * resizable. sizeAppliesToLevel must be the in range
544 * lowestLevel..highestLevel (inclusive).
545 */
546 template <class SrcIterator, class SrcAccessor>
549 int copyImageToLevel = 0,
550 Alloc const & alloc = Alloc())
551 : lowestLevel_(0), highestLevel_(-1),
552 images_(alloc)
553 {
555 copyImage(srcIterRange(ul, lr, src), destImage((*this)[copyImageToLevel]));
556 }
557
558 /** Init an empty pyramid. Use the specified allocator.
559 */
561 : lowestLevel_(0), highestLevel_(-1),
562 images_(alloc)
563 {}
564
565 virtual ~ImagePyramid() {}
566
567 /** Get the index of the lowest allocated level of the pyramid.
568 */
569 int lowestLevel() const
570 {
571 return lowestLevel_;
572 }
573
574 /** Get the index of the highest allocated level of the pyramid.
575 */
576 int highestLevel() const
577 {
578 return highestLevel_;
579 }
580
581 /** Operator for a vector-like access to the contained images
582 (STL-Vector interface)
583 */
585 {
586 return images_[index - lowestLevel_];
587 }
588
589 /** Operator for a vector-like access to the contained images
590 (STL-Vector interface)
591 */
593 {
594 return images_[index - lowestLevel_];
595 }
596
597 /** Returns an iterator pointing to the first image
598 (STL-Container interface)
599 */
601 {
602 return images_.begin();
603 }
604
605 /** Returns an iterator pointing to the first image
606 (STL-Container interface)
607 */
609 {
610 return images_.begin();
611 }
612
613 /** Returns an iterator pointing behind the last image
614 (STL-Container interface)
615 */
617 {
618 return images_.end();
619 }
620
621 /** Returns an iterator pointing behind the last image
622 (STL-Container interface)
623 */
625 {
626 return images_.end();
627 }
628
629 /** Returns a reverse_iterator pointing to the first image of
630 the reversed view of this array (STL-Reversable Container
631 interface)
632 */
633 reverse_iterator rbegin()
634 {
635 return images_.rbegin();
636 }
637
638 /** Returns a reverse_iterator pointing to the first image of
639 the reversed view of this array (STL-Reversable Container
640 interface)
641 */
642 const_reverse_iterator rbegin() const
643 {
644 return images_.rbegin();
645 }
646
647 /** Returns a reverse_iterator pointing behind the last image
648 of the reversed view of this array (STL-Reversable
649 Container interface)
650 */
651 reverse_iterator rend()
652 {
653 return images_.rend();
654 }
655
656 /** Returns a reverse_iterator pointing behind the last image
657 of the reversed view of this array (STL-Reversable
658 Container interface)
659 */
660 const_reverse_iterator rend() const
661 {
662 return images_.rend();
663 }
664
665 /** Query size of this ImageArray, that is: the number of
666 images. (STL-Container interface)
667 */
669 {
670 return images_.size();
671 }
672
673 /** Returns true if and only if there are no contained
674 images. (STL-Container interface)
675 */
676 bool empty()
677 {
678 return images_.empty();
679 }
680
681 /** Returns true if and only if both ImageArrays have exactly
682 the same contents and all images did compare equal with the
683 corresponding image in the other ImageArray. (STL-Forward
684 Container interface)
685 */
687 {
688 return (lowestLevel_ == other.lowestLevel_) && (highestLevel_ == other.highestLevel_) &&
689 (images_ == other.images_);
690 }
691
692 /** Empty this array. (STL-Sequence interface)
693 */
694 void clear()
695 {
696 images_.clear();
697 lowestLevel_ = 0;
698 highestLevel_ = -1;
699 }
700
701 /** Resize this ImageArray, throwing the last images away if
702 you make the array smaller or appending new images of the
703 right size at the end of the array if you make it
704 larger. (STL-Sequence interface)
705 */
707 const Diff2D &imageSize, int sizeAppliesToLevel = 0)
708 {
709 vigra_precondition(lowestLevel <= highestLevel,
710 "ImagePyramid::resize(): lowestLevel <= highestLevel required.");
712 "ImagePyramid::resize(): sizeAppliesToLevel must be between lowest and highest level (inclusive).");
713
715
716 images[sizeAppliesToLevel - lowestLevel].resize(imageSize);
717 for(int i=sizeAppliesToLevel + 1; i<=highestLevel; ++i)
718 {
719 unsigned int w = (images[i - 1 - lowestLevel].width() + 1) / 2;
720 unsigned int h = (images[i - 1 - lowestLevel].height() + 1) / 2;
721 images[i - lowestLevel].resize(w, h);
722 }
723 for(int i=sizeAppliesToLevel - 1; i>=lowestLevel; --i)
724 {
725 unsigned int w = 2*images[i + 1 - lowestLevel].width() - 1;
726 unsigned int h = 2*images[i + 1 - lowestLevel].height() - 1;
727 images[i - lowestLevel].resize(w, h);
728 }
729
730 images_.swap(images);
731 lowestLevel_ = lowestLevel;
732 highestLevel_ = highestLevel;
733 }
734
735 /** return the first image (lowestLevel()). (STL-Sequence interface)
736 */
738 {
739 return images_.front();
740 }
741
742 /** return the first image (lowestLevel()). (STL-Sequence interface)
743 */
745 {
746 return images_.front();
747 }
748
749 /** return the last image (highestLevel()). (STL-Vector interface)
750 */
752 {
753 return images_.back();
754 }
755
756 /** return the last image (highestLevel()). (STL-Vector interface)
757 */
759 {
760 return images_.back();
761 }
762
763 /** swap contents of this array with the contents of other
764 (STL-Container interface)
765 */
767 {
768 images_.swap(other.images_);
769 std::swap(lowestLevel_, other.lowestLevel_);
770 std::swap(highestLevel_, other.highestLevel_);
771 }
772};
773
774//@}
775
776} // namespace vigra
777
778#endif // VIGRA_IMAGECONTAINER_HXX
Two dimensional difference vector.
Definition diff2d.hxx:186
Fundamental class template for arrays of equal-sized images.
Definition imagecontainer.hxx:73
void pop_back()
Definition imagecontainer.hxx:374
const_reverse_iterator rend() const
Definition imagecontainer.hxx:220
const_reference front() const
Definition imagecontainer.hxx:346
void insert(iterator pos, size_type count, const_reference image)
void resize(size_type newSize, ImageType &image)
Definition imagecontainer.hxx:327
const_iterator begin() const
Definition imagecontainer.hxx:168
void push_back(const_reference image)
Definition imagecontainer.hxx:367
bool empty()
Definition imagecontainer.hxx:245
ImageArray(unsigned int numImages, const ImageType &image, Alloc const &alloc=Alloc())
Definition imagecontainer.hxx:121
void reserve(size_type n)
Definition imagecontainer.hxx:400
iterator insert(iterator pos, const_reference image)
Definition imagecontainer.hxx:263
virtual void resizeImages(const Diff2D &newSize)
Definition imagecontainer.hxx:418
size_type size() const
Definition imagecontainer.hxx:228
const_reference back() const
Definition imagecontainer.hxx:360
reverse_iterator rend()
Definition imagecontainer.hxx:211
reference front()
Definition imagecontainer.hxx:339
void swap(const_reference other)
Definition imagecontainer.hxx:382
void resize(size_type newSize)
Definition imagecontainer.hxx:310
void resizeImages(int width, int height)
Definition imagecontainer.hxx:435
void insert(iterator pos, InputIterator begin, InputIterator end)
Definition imagecontainer.hxx:277
size_type max_size() const
Definition imagecontainer.hxx:237
reference operator[](size_type index)
Definition imagecontainer.hxx:144
ImageType value_type
Definition imagecontainer.hxx:83
Size2D imageSize() const
Definition imagecontainer.hxx:411
ImageArray(InputIterator begin, InputIterator end, Alloc const &alloc=Alloc())
Definition imagecontainer.hxx:133
void clear()
Definition imagecontainer.hxx:300
ImageArray(unsigned int numImages, const Diff2D &imageSize, Alloc const &alloc=Alloc())
Definition imagecontainer.hxx:99
iterator end()
Definition imagecontainer.hxx:176
ImageArray(unsigned int numImages=0, Alloc const &alloc=Alloc())
Definition imagecontainer.hxx:112
const_iterator end() const
Definition imagecontainer.hxx:184
reverse_iterator rbegin()
Definition imagecontainer.hxx:193
size_type capacity() const
Definition imagecontainer.hxx:393
iterator erase(iterator begin, iterator end)
Definition imagecontainer.hxx:293
iterator begin()
Definition imagecontainer.hxx:160
bool operator==(const ImageArray< ImageType, Alloc > &other)
Definition imagecontainer.hxx:255
const_reverse_iterator rbegin() const
Definition imagecontainer.hxx:202
reference back()
Definition imagecontainer.hxx:353
iterator erase(iterator pos)
Definition imagecontainer.hxx:285
Class template for logarithmically tapering image pyramids.
Definition imagecontainer.hxx:469
const_reverse_iterator rend() const
Definition imagecontainer.hxx:660
const_reference front() const
Definition imagecontainer.hxx:744
const_iterator begin() const
Definition imagecontainer.hxx:608
void resize(int lowestLevel, int highestLevel, const Diff2D &imageSize, int sizeAppliesToLevel=0)
Definition imagecontainer.hxx:706
bool empty()
Definition imagecontainer.hxx:676
ImagePyramid(int lowestLevel, int highestLevel, SrcIterator ul, SrcIterator lr, SrcAccessor src, int copyImageToLevel=0, Alloc const &alloc=Alloc())
Definition imagecontainer.hxx:547
ImagePyramid(Alloc const &alloc=Alloc())
Definition imagecontainer.hxx:560
int highestLevel() const
Definition imagecontainer.hxx:576
size_type size() const
Definition imagecontainer.hxx:668
const_reference back() const
Definition imagecontainer.hxx:758
reverse_iterator rend()
Definition imagecontainer.hxx:651
reference front()
Definition imagecontainer.hxx:737
void swap(ImagePyramid< ImageType, Alloc > &other)
Definition imagecontainer.hxx:766
reference operator[](size_type index)
Definition imagecontainer.hxx:584
ImagePyramid(int lowestLevel, int highestLevel, const Diff2D &imageSize, int sizeAppliesToLevel=0, Alloc const &alloc=Alloc())
Definition imagecontainer.hxx:503
ImageType value_type
Definition imagecontainer.hxx:479
void clear()
Definition imagecontainer.hxx:694
bool operator==(const ImagePyramid< ImageType, Alloc > &other) const
Definition imagecontainer.hxx:686
ImagePyramid(int lowestLevel, int highestLevel, const ImageType &image, int copyImageToLevel=0, Alloc const &alloc=Alloc())
Definition imagecontainer.hxx:524
iterator end()
Definition imagecontainer.hxx:616
const_iterator end() const
Definition imagecontainer.hxx:624
reverse_iterator rbegin()
Definition imagecontainer.hxx:633
iterator begin()
Definition imagecontainer.hxx:600
int lowestLevel() const
Definition imagecontainer.hxx:569
const_reverse_iterator rbegin() const
Definition imagecontainer.hxx:642
reference back()
Definition imagecontainer.hxx:751
Class for a single RGB value.
Definition rgbvalue.hxx:128
Two dimensional size object.
Definition diff2d.hxx:483
size_type size() const
Definition tinyvector.hxx:913
iterator end()
Definition tinyvector.hxx:864
iterator begin()
Definition tinyvector.hxx:861
void copyImage(...)
Copy source image into destination image.

© Ullrich Köthe (ullrich.koethe@iwr.uni-heidelberg.de)
Heidelberg Collaboratory for Image Processing, University of Heidelberg, Germany

html generated using doxygen and Python
vigra 1.11.1