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

details vigra/imagecontainer.hxx VIGRA

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)
Cognitive Systems Group, University of Hamburg, Germany

html generated using doxygen and Python
VIGRA 1.4.0 (21 Dec 2005)