vigra - vigra/imagecontainer.hxx Source File

[ 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
43 namespace 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 */
70 template <class ImageType,
71 class Alloc = typename ImageType::allocator_type::template rebind<ImageType>::other >
72 class ImageArray
73 {
74 Size2D imageSize_;
75
76 protected:
77 typedef ArrayVector<ImageType, Alloc> ImageVector;
78 ImageVector images_;
79
80 public:
81 /** the type of the contained values/images
82 */
83 typedef ImageType value_type;
84
85 typedef typename ImageVector::iterator iterator;
86 typedef typename ImageVector::const_iterator const_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;
90 typedef typename ImageVector::const_reference const_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>
133 ImageArray(InputIterator begin, InputIterator end, Alloc const & alloc = Alloc())
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 */
144 reference operator [](size_type index)
145 {
146 return images_[index];
147 }
148
149 /** Operator for a vector-like access to the contained images
150 (STL-Vector interface)
151 */
152 const_reference operator [](size_type index) const
153 {
154 return images_[index];
155 }
156
157 /** Returns an iterator pointing to the first image
158 (STL-Container interface)
159 */
160 iterator begin()
161 {
162 return images_.begin();
163 }
164
165 /** Returns an iterator pointing to the first image
166 (STL-Container interface)
167 */
168 const_iterator begin() const
169 {
170 return images_.begin();
171 }
172
173 /** Returns an iterator pointing behind the last image
174 (STL-Container interface)
175 */
176 iterator end()
177 {
178 return images_.end();
179 }
180
181 /** Returns an iterator pointing behind the last image
182 (STL-Container interface)
183 */
184 const_iterator end() const
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 */
228 size_type size() const
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 */
237 size_type max_size() const
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 */
255 bool operator ==(const ImageArray<ImageType, Alloc> &other)
256 {
257 return (imageSize() == other.imageSize())
258 && (images_ == other.images_);
259 }
260
261 /** Insert image at/before pos. (STL-Sequence interface)
262 */
263 iterator insert(iterator pos, const_reference image)
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>
277 void insert(iterator pos, InputIterator begin, InputIterator end)
278 {
279 images_.insert(pos, begin, end);
280 }
281
282 /** Removes the image at pos from this array. (STL-Sequence
283 interface)
284 */
285 iterator erase(iterator pos)
286 {
287 return images_.erase(pos);
288 }
289
290 /** Removes the images from [begin, end) from this
291 array. (STL-Sequence interface)
292 */
293 iterator erase(iterator begin, iterator end)
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 */
310 void resize(size_type newSize)
311 {
312 if (newSize != size())
313 {
314 size_type oldSize= size();
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 */
327 void resize(size_type newSize, ImageType &image)
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 */
339 reference front()
340 {
341 return images_.front();
342 }
343
344 /** return the first image. (STL-Sequence interface)
345 */
346 const_reference front() const
347 {
348 return images_.front();
349 }
350
351 /** return the last image. (STL-Vector interface)
352 */
353 reference back()
354 {
355 return images_.back();
356 }
357
358 /** return the last image. (STL-Vector interface)
359 */
360 const_reference back() const
361 {
362 return images_.back();
363 }
364
365 /** append image to array (STL-Back Insertion Sequence interface)
366 */
367 void push_back(const_reference image)
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 */
382 void swap(const_reference other)
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 */
393 size_type capacity() const
394 {
395 return images_.capacity();
396 }
397
398 /** increase capacity(). (STL-Vector interface)
399 */
400 void reserve(size_type n)
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 */
411 Size2D imageSize() const
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 */
466 template <class ImageType,
467 class Alloc = typename ImageType::allocator_type::template rebind<ImageType>::other >
468 class ImagePyramid
469 {
470 int lowestLevel_, highestLevel_;
471
472 protected:
473 typedef ArrayVector<ImageType, Alloc> ImageVector;
474 ImageVector images_;
475
476 public:
477 /** the type of the contained values/images
478 */
479 typedef ImageType value_type;
480
481 typedef typename ImageVector::iterator iterator;
482 typedef typename ImageVector::const_iterator const_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;
486 typedef typename ImageVector::const_reference const_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 */
503 ImagePyramid(int lowestLevel, int highestLevel,
504 const Diff2D &imageSize, int sizeAppliesToLevel = 0,
505 Alloc const & alloc = Alloc())
506 : lowestLevel_(0), highestLevel_(-1),
507 images_(alloc)
508 {
509 resize(lowestLevel, highestLevel, imageSize, sizeAppliesToLevel);
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 */
524 ImagePyramid(int lowestLevel, int highestLevel,
525 const ImageType &image, int copyImageToLevel = 0,
526 Alloc const & alloc = Alloc())
527 : lowestLevel_(0), highestLevel_(-1),
528 images_(alloc)
529 {
530 resize(lowestLevel, highestLevel, image.size(), copyImageToLevel);
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>
547 ImagePyramid(int lowestLevel, int highestLevel,
548 SrcIterator ul, SrcIterator lr, SrcAccessor src,
549 int copyImageToLevel = 0,
550 Alloc const & alloc = Alloc())
551 : lowestLevel_(0), highestLevel_(-1),
552 images_(alloc)
553 {
554 resize(lowestLevel, highestLevel, lr - ul, copyImageToLevel);
555 copyImage(srcIterRange(ul, lr, src), destImage((*this)[copyImageToLevel]));
556 }
557
558 /** Init an empty pyramid. Use the specified allocator.
559 */
560 ImagePyramid(Alloc const & alloc = Alloc())
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 */
584 reference operator [](size_type index)
585 {
586 return images_[index - lowestLevel_];
587 }
588
589 /** Operator for a vector-like access to the contained images
590 (STL-Vector interface)
591 */
592 const_reference operator [](size_type index) const
593 {
594 return images_[index - lowestLevel_];
595 }
596
597 /** Returns an iterator pointing to the first image
598 (STL-Container interface)
599 */
600 iterator begin()
601 {
602 return images_.begin();
603 }
604
605 /** Returns an iterator pointing to the first image
606 (STL-Container interface)
607 */
608 const_iterator begin() const
609 {
610 return images_.begin();
611 }
612
613 /** Returns an iterator pointing behind the last image
614 (STL-Container interface)
615 */
616 iterator end()
617 {
618 return images_.end();
619 }
620
621 /** Returns an iterator pointing behind the last image
622 (STL-Container interface)
623 */
624 const_iterator end() const
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 */
668 size_type size() const
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 */
686 bool operator ==(const ImagePyramid<ImageType, Alloc> &other) const
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 */
706 void resize(int lowestLevel, int highestLevel,
707 const Diff2D &imageSize, int sizeAppliesToLevel = 0)
708 {
709 vigra_precondition(lowestLevel <= highestLevel,
710 "ImagePyramid::resize(): lowestLevel <= highestLevel required.");
711 vigra_precondition(lowestLevel <= sizeAppliesToLevel && sizeAppliesToLevel <= highestLevel,
712 "ImagePyramid::resize(): sizeAppliesToLevel must be between lowest and highest level (inclusive).");
713
714 ImageVector images(highestLevel - lowestLevel + 1, ImageType());
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 */
737 reference front()
738 {
739 return images_.front();
740 }
741
742 /** return the first image (lowestLevel()). (STL-Sequence interface)
743 */
744 const_reference front() const
745 {
746 return images_.front();
747 }
748
749 /** return the last image (highestLevel()). (STL-Vector interface)
750 */
751 reference back()
752 {
753 return images_.back();
754 }
755
756 /** return the last image (highestLevel()). (STL-Vector interface)
757 */
758 const_reference back() const
759 {
760 return images_.back();
761 }
762
763 /** swap contents of this array with the contents of other
764 (STL-Container interface)
765 */
766 void swap(ImagePyramid<ImageType, Alloc> &other)
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
vigra::ImageArray::imageSize
Size2D imageSize() const
Definition: imagecontainer.hxx:411
vigra::ImageArray::front
const_reference front() const
Definition: imagecontainer.hxx:346
vigra::ArrayVectorView::back
reference back()
Definition: array_vector.hxx:321
vigra::ImageArray
Fundamental class template for arrays of equal-sized images.
Definition: imagecontainer.hxx:72
vigra::ImagePyramid::rbegin
reverse_iterator rbegin()
Definition: imagecontainer.hxx:633
vigra::ImagePyramid::back
const_reference back() const
Definition: imagecontainer.hxx:758
vigra::ImagePyramid::ImagePyramid
ImagePyramid(int lowestLevel, int highestLevel, SrcIterator ul, SrcIterator lr, SrcAccessor src, int copyImageToLevel=0, Alloc const &alloc=Alloc())
Definition: imagecontainer.hxx:547
vigra::ImageArray::insert
void insert(iterator pos, InputIterator begin, InputIterator end)
Definition: imagecontainer.hxx:277
vigra::ImageArray::resize
void resize(size_type newSize, ImageType &image)
Definition: imagecontainer.hxx:327
vigra::ImageArray::clear
void clear()
Definition: imagecontainer.hxx:300
vigra::ImagePyramid::value_type
ImageType value_type
Definition: imagecontainer.hxx:479
vigra::ImagePyramid::rend
const_reverse_iterator rend() const
Definition: imagecontainer.hxx:660
vigra::ArrayVectorView::empty
bool empty() const
Definition: array_vector.hxx:351
vigra::ImagePyramid::size
size_type size() const
Definition: imagecontainer.hxx:668
vigra::ImageArray::end
const_iterator end() const
Definition: imagecontainer.hxx:184
vigra::ArrayVectorView::begin
const_iterator begin() const
Definition: array_vector.hxx:223
vigra::ImageArray::erase
iterator erase(iterator begin, iterator end)
Definition: imagecontainer.hxx:293
vigra::ImagePyramid::end
const_iterator end() const
Definition: imagecontainer.hxx:624
vigra::ImagePyramid::ImagePyramid
ImagePyramid(Alloc const &alloc=Alloc())
Definition: imagecontainer.hxx:560
vigra::ImageArray::push_back
void push_back(const_reference image)
Definition: imagecontainer.hxx:367
vigra::ArrayVectorView::rend
reverse_iterator rend()
Definition: array_vector.hxx:279
vigra::ImagePyramid::front
reference front()
Definition: imagecontainer.hxx:737
vigra::Diff2D
Two dimensional difference vector.
Definition: diff2d.hxx:185
vigra::ImageArray::value_type
ImageType value_type
Definition: imagecontainer.hxx:83
vigra::ImageArray::back
const_reference back() const
Definition: imagecontainer.hxx:360
vigra::ImagePyramid::operator==
bool operator==(const ImagePyramid< ImageType, Alloc > &other) const
Definition: imagecontainer.hxx:686
vigra::ImageArray::begin
iterator begin()
Definition: imagecontainer.hxx:160
vigra::ImageArray::operator[]
reference operator[](size_type index)
Definition: imagecontainer.hxx:144
vigra::ImagePyramid::empty
bool empty()
Definition: imagecontainer.hxx:676
vigra::ImagePyramid::begin
iterator begin()
Definition: imagecontainer.hxx:600
vigra::Size2D
Two dimensional size object.
Definition: diff2d.hxx:482
vigra::ImageArray::empty
bool empty()
Definition: imagecontainer.hxx:245
vigra::ImageArray::ImageArray
ImageArray(unsigned int numImages, const Diff2D &imageSize, Alloc const &alloc=Alloc())
Definition: imagecontainer.hxx:99
vigra::ImagePyramid::rend
reverse_iterator rend()
Definition: imagecontainer.hxx:651
vigra::ImagePyramid::resize
void resize(int lowestLevel, int highestLevel, const Diff2D &imageSize, int sizeAppliesToLevel=0)
Definition: imagecontainer.hxx:706
vigra::ArrayVector< ImageType, Alloc >
vigra::ImageArray::back
reference back()
Definition: imagecontainer.hxx:353
vigra::ImageArray::ImageArray
ImageArray(unsigned int numImages=0, Alloc const &alloc=Alloc())
Definition: imagecontainer.hxx:112
vigra::ImageArray::operator==
bool operator==(const ImageArray< ImageType, Alloc > &other)
Definition: imagecontainer.hxx:255
vigra::ImageArray::front
reference front()
Definition: imagecontainer.hxx:339
vigra::ArrayVectorView::front
reference front()
Definition: array_vector.hxx:307
vigra::ImageArray::ImageArray
ImageArray(InputIterator begin, InputIterator end, Alloc const &alloc=Alloc())
Definition: imagecontainer.hxx:133
vigra::ImagePyramid::clear
void clear()
Definition: imagecontainer.hxx:694
vigra::ImageArray::resizeImages
void resizeImages(int width, int height)
Definition: imagecontainer.hxx:435
vigra::ImageArray::size
size_type size() const
Definition: imagecontainer.hxx:228
vigra::ImageArray::swap
void swap(const_reference other)
Definition: imagecontainer.hxx:382
vigra::ImageArray::rbegin
const_reverse_iterator rbegin() const
Definition: imagecontainer.hxx:202
vigra::copyImage
void copyImage(...)
Copy source image into destination image.
vigra::ImageArray::rend
reverse_iterator rend()
Definition: imagecontainer.hxx:211
utilities.hxx
vigra::ImagePyramid::end
iterator end()
Definition: imagecontainer.hxx:616
vigra::ImageArray::reserve
void reserve(size_type n)
Definition: imagecontainer.hxx:400
vigra::ImagePyramid::ImagePyramid
ImagePyramid(int lowestLevel, int highestLevel, const ImageType &image, int copyImageToLevel=0, Alloc const &alloc=Alloc())
Definition: imagecontainer.hxx:524
vigra::ImageArray::ImageArray
ImageArray(unsigned int numImages, const ImageType &image, Alloc const &alloc=Alloc())
Definition: imagecontainer.hxx:121
vigra::ImageArray::max_size
size_type max_size() const
Definition: imagecontainer.hxx:237
vigra::ImageArray::rend
const_reverse_iterator rend() const
Definition: imagecontainer.hxx:220
vigra::ImagePyramid::ImagePyramid
ImagePyramid(int lowestLevel, int highestLevel, const Diff2D &imageSize, int sizeAppliesToLevel=0, Alloc const &alloc=Alloc())
Definition: imagecontainer.hxx:503
vigra::ImagePyramid::highestLevel
int highestLevel() const
Definition: imagecontainer.hxx:576
vigra::ImageArray::resize
void resize(size_type newSize)
Definition: imagecontainer.hxx:310
vigra::ImageArray::pop_back
void pop_back()
Definition: imagecontainer.hxx:374
vigra::ArrayVectorView::rbegin
reverse_iterator rbegin()
Definition: array_vector.hxx:265
vigra::ImagePyramid::lowestLevel
int lowestLevel() const
Definition: imagecontainer.hxx:569
vigra::ArrayVectorView::end
const_iterator end() const
Definition: array_vector.hxx:237
vigra::ArrayVectorView::size
size_type size() const
Definition: array_vector.hxx:358
vigra::ImagePyramid::operator[]
reference operator[](size_type index)
Definition: imagecontainer.hxx:584
vigra::ImageArray::erase
iterator erase(iterator pos)
Definition: imagecontainer.hxx:285
vigra::ImageArray::end
iterator end()
Definition: imagecontainer.hxx:176
vigra::ImageArray::rbegin
reverse_iterator rbegin()
Definition: imagecontainer.hxx:193
vigra::ImagePyramid::back
reference back()
Definition: imagecontainer.hxx:751
vigra::ImagePyramid
Class template for logarithmically tapering image pyramids.
Definition: imagecontainer.hxx:468
vigra::ImageArray::resizeImages
virtual void resizeImages(const Diff2D &newSize)
Definition: imagecontainer.hxx:418
vigra::ImagePyramid::begin
const_iterator begin() const
Definition: imagecontainer.hxx:608
vigra::ImageArray::capacity
size_type capacity() const
Definition: imagecontainer.hxx:393
vigra::ImagePyramid::swap
void swap(ImagePyramid< ImageType, Alloc > &other)
Definition: imagecontainer.hxx:766
vigra::ImagePyramid::front
const_reference front() const
Definition: imagecontainer.hxx:744
vigra::ImagePyramid::rbegin
const_reverse_iterator rbegin() const
Definition: imagecontainer.hxx:642
vigra::ImageArray::insert
iterator insert(iterator pos, const_reference image)
Definition: imagecontainer.hxx:263
vigra::ImageArray::begin
const_iterator begin() const
Definition: imagecontainer.hxx:168

© 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.0 (Fri May 19 2017)