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

| vigra/basicimageview.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.3.2, Jan 27 2005 )                                    */
    00008 /*    You may use, modify, and distribute this software according       */
    00009 /*    to the terms stated in the LICENSE file included in               */
    00010 /*    the VIGRA distribution.                                           */
    00011 /*                                                                      */
    00012 /*    The VIGRA Website is                                              */
    00013 /*        http://kogs-www.informatik.uni-hamburg.de/~koethe/vigra/      */
    00014 /*    Please direct questions, bug reports, and contributions to        */
    00015 /*        koethe@informatik.uni-hamburg.de                              */
    00016 /*                                                                      */
    00017 /*  THIS SOFTWARE IS PROVIDED AS IS AND WITHOUT ANY EXPRESS OR          */
    00018 /*  IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED      */
    00019 /*  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. */
    00020 /*                                                                      */
    00021 /************************************************************************/
    00022
    00023 #ifndef VIGRA_BASICIMAGEVIEW_HXX
    00024 #define VIGRA_BASICIMAGEVIEW_HXX
    00025
    00026 #include "vigra/imageiterator.hxx"
    00027 #include "vigra/initimage.hxx"
    00028
    00029 namespace vigra {
    00030
    00031
    00032 /********************************************************/
    00033 /*                                                      */
    00034 /*                     BasicImageView                   */
    00035 /*                                                      */
    00036 /********************************************************/
    00037
    00038 /** \brief BasicImage using foreign memory.
    00039
    00040     This class provides the same interface as \ref vigra::BasicImage
    00041     (with the exception of <tt>resize()</tt>) but the image's
    00042     memory is provided from the outside instead of allocated internally.
    00043
    00044     A <tt>BasicImageView</tt> can also be created from a
    00045     \ref vigra::MultiArrayView with the appropriate shape -- see
    00046     \ref MultiArrayToImage.
    00047
    00048     <b>\#include</b> "<a href="basicimageview_8hxx-source.html">vigra/basicimageview.hxx</a>"
    00049
    00050     Namespace: vigra
    00051 */
    00052 template <class PIXELTYPE>
    00053 class BasicImageView
    00054 {
    00055   public:
    00056
    00057         /** the BasicImageView's pixel type
    00058         */
    00059     typedef PIXELTYPE value_type;
    00060
    00061         /** the BasicImageView's pixel type
    00062         */
    00063     typedef PIXELTYPE PixelType;
    00064
    00065         /** the BasicImageView's reference type (i.e. the
    00066             return type of image[diff] and image(dx,dy))
    00067         */
    00068     typedef PIXELTYPE &       reference;
    00069
    00070         /** the BasicImageView's const reference type (i.e. the
    00071             return type of image[diff] and image(dx,dy) when image is const)
    00072         */
    00073     typedef PIXELTYPE const & const_reference;
    00074
    00075         /** the BasicImageView's pointer type
    00076         */
    00077     typedef PIXELTYPE *       pointer;
    00078
    00079         /** the BasicImageView's const pointer type
    00080         */
    00081     typedef PIXELTYPE const * const_pointer;
    00082
    00083         /** the BasicImageView's 1D random access iterator
    00084             (note: lower case 'iterator' is a STL compatible 1D random
    00085              access iterator, don't confuse with capitalized Iterator)
    00086         */
    00087     typedef PIXELTYPE * iterator;
    00088
    00089         /** deprecated, use <TT>iterator</TT> instead
    00090         */
    00091     typedef PIXELTYPE * ScanOrderIterator;
    00092
    00093         /** the BasicImageView's 1D random access const iterator
    00094             (note: lower case 'const_iterator' is a STL compatible 1D
    00095             random access const iterator)
    00096         */
    00097     typedef PIXELTYPE const * const_iterator;
    00098
    00099         /** deprecated, use <TT>const_iterator</TT> instead
    00100         */
    00101     typedef PIXELTYPE const * ConstScanOrderIterator;
    00102
    00103         /** the BasicImageView's 2D random access iterator ('traverser')
    00104         */
    00105     typedef ImageIterator<value_type> traverser;
    00106
    00107         /** deprecated, use <TT>traverser</TT> instead
    00108         */
    00109     typedef ImageIterator<value_type> Iterator;
    00110
    00111         /** the BasicImageView's 2D random access const iterator ('const traverser')
    00112         */
    00113     typedef ConstImageIterator<value_type> const_traverser;
    00114
    00115         /** deprecated, use <TT>const_traverser</TT> instead
    00116         */
    00117     typedef ConstImageIterator<value_type> ConstIterator;
    00118
    00119         /** the BasicImageView's difference type (argument type of image[diff])
    00120         */
    00121     typedef Diff2D difference_type;
    00122
    00123          /** the BasicImageView's size type (result type of image.size())
    00124         */
    00125     typedef Size2D size_type;
    00126
    00127        /** the BasicImageView's default accessor
    00128         */
    00129     typedef typename
    00130           IteratorTraits<traverser>::DefaultAccessor Accessor;
    00131
    00132         /** the BasicImageView's default const accessor
    00133         */
    00134     typedef typename
    00135           IteratorTraits<const_traverser>::DefaultAccessor ConstAccessor;
    00136
    00137         /** construct image of size 0x0
    00138         */
    00139     BasicImageView()
    00140     : data_(0),
    00141       width_(0),
    00142       height_(0),
    00143       stride_(0)
    00144     {}
    00145
    00146         /** construct view of size w x h
    00147         */
    00148     BasicImageView(const_pointer data, int w, int h, int stride = 0)
    00149     : data_(const_cast<pointer>(data)),
    00150       width_(w),
    00151       height_(h),
    00152       stride_(stride == 0 ? w : stride)
    00153     {}
    00154
    00155         /** construct view of size size.x x size.y
    00156         */
    00157     BasicImageView(const_pointer data, difference_type const & size, int stride = 0)
    00158     : data_(const_cast<pointer>(data)),
    00159       width_(size.x),
    00160       height_(size.y),
    00161       stride_(stride == 0 ? size.x : stride)
    00162     {}
    00163
    00164         /** set Image with const value
    00165         */
    00166     BasicImageView & init(value_type const & pixel)
    00167     {
    00168         initImage(upperLeft(), lowerRight(), accessor(), pixel);
    00169
    00170         return *this;
    00171     }
    00172
    00173         /** width of Image
    00174         */
    00175     int width() const
    00176     {
    00177         return width_;
    00178     }
    00179
    00180         /** height of Image
    00181         */
    00182     int height() const
    00183     {
    00184         return height_;
    00185     }
    00186
    00187         /** stride of Image.
    00188             Memory offset between the start of two successive rows.
    00189         */
    00190     int stride() const
    00191     {
    00192         return stride_;
    00193     }
    00194
    00195         /** size of Image
    00196         */
    00197     size_type size() const
    00198     {
    00199         return size_type(width(), height());
    00200     }
    00201
    00202         /** test whether a given coordinate is inside the image
    00203         */
    00204     bool isInside(difference_type const & d) const
    00205     {
    00206         return d.x >= 0 && d.y >= 0 &&
    00207                d.x < width() && d.y < height();
    00208     }
    00209
    00210         /** access pixel at given location. <br>
    00211         usage: <TT> value_type value = image[Diff2D(1,2)] </TT>
    00212         */
    00213     reference operator[](difference_type const & d)
    00214     {
    00215         return data_[d.y*stride_ + d.x];
    00216     }
    00217
    00218         /** read pixel at given location. <br>
    00219         usage: <TT> value_type value = image[Diff2D(1,2)] </TT>
    00220         */
    00221     const_reference operator[](difference_type const & d) const
    00222     {
    00223         return data_[d.y*stride_ + d.x];
    00224     }
    00225
    00226         /** access pixel at given location. <br>
    00227         usage: <TT> value_type value = image(1,2) </TT>
    00228         */
    00229     reference operator()(int dx, int dy)
    00230     {
    00231         return data_[dy*stride_ + dx];
    00232     }
    00233
    00234         /** read pixel at given location. <br>
    00235         usage: <TT> value_type value = image(1,2) </TT>
    00236         */
    00237     const_reference operator()(int dx, int dy) const
    00238     {
    00239         return data_[dy*stride_ + dx];
    00240     }
    00241
    00242         /** access pixel at given location.
    00243             Note that the 'x' index is the trailing index. <br>
    00244         usage: <TT> value_type value = image[2][1] </TT>
    00245         */
    00246     pointer operator[](int dy)
    00247     {
    00248         return data_ + dy*stride_;
    00249     }
    00250
    00251         /** read pixel at given location.
    00252             Note that the 'x' index is the trailing index. <br>
    00253         usage: <TT> value_type value = image[2][1] </TT>
    00254         */
    00255     const_pointer operator[](int dy) const
    00256     {
    00257         return data_ + dy*stride_;
    00258     }
    00259
    00260         /** init 2D random access iterator poining to upper left pixel
    00261         */
    00262     traverser upperLeft()
    00263     {
    00264         return traverser(data_, stride_);
    00265     }
    00266
    00267         /** init 2D random access iterator poining to
    00268          pixel(width, height), i.e. one pixel right and below lower right
    00269          corner of the image as is common in C/C++.
    00270         */
    00271     traverser lowerRight()
    00272     {
    00273         return upperLeft() + size();
    00274     }
    00275
    00276         /** init 2D random access const iterator poining to upper left pixel
    00277         */
    00278     const_traverser upperLeft() const
    00279     {
    00280         return const_traverser(data_, stride_);
    00281     }
    00282
    00283         /** init 2D random access const iterator poining to
    00284          pixel(width, height), i.e. one pixel right and below lower right
    00285          corner of the image as is common in C/C++.
    00286         */
    00287     const_traverser lowerRight() const
    00288     {
    00289         return upperLeft() + size();
    00290     }
    00291
    00292         /** init 1D random access iterator pointing to first pixel.
    00293             Note: Only works if stride equals width.
    00294         */
    00295     iterator begin()
    00296     {
    00297         vigra_precondition(stride_ == width_,
    00298             "BasicImageView::begin(): "
    00299             "can only create scan order iterator if width() == stride().");
    00300         return data_;
    00301     }
    00302
    00303         /** init 1D random access iterator pointing past the end.
    00304             Note: Only works if stride equals width.
    00305         */
    00306     iterator end()
    00307     {
    00308         vigra_precondition(stride_ == width_,
    00309             "BasicImageView::end(): "
    00310             "can only create scan order iterator if width() == stride().");
    00311         return data_ + width() * height();
    00312     }
    00313
    00314         /** init 1D random access const iterator pointing to first pixel.
    00315             Note: Only works if stride equals width.
    00316         */
    00317     const_iterator begin() const
    00318     {
    00319         vigra_precondition(stride_ == width_,
    00320             "BasicImageView::begin(): "
    00321             "can only create scan order iterator if width() == stride().");
    00322         return data_;
    00323     }
    00324
    00325         /** init 1D random access const iterator pointing past the end.
    00326             Note: Only works if stride equals width.
    00327         */
    00328     const_iterator end() const
    00329     {
    00330         vigra_precondition(stride_ == width_,
    00331             "BasicImageView::end(): "
    00332             "can only create scan order iterator if width() == stride().");
    00333         return data_ + width() * height();
    00334     }
    00335
    00336         /** return default accessor
    00337         */
    00338     Accessor accessor()
    00339     {
    00340         return Accessor();
    00341     }
    00342
    00343         /** return default const accessor
    00344         */
    00345     ConstAccessor accessor() const
    00346     {
    00347         return ConstAccessor();
    00348     }
    00349
    00350   private:
    00351
    00352     pointer data_;
    00353     int width_, height_, stride_;
    00354 };
    00355
    00356
    00357 /********************************************************/
    00358 /*                                                      */
    00359 /*              argument object factories               */
    00360 /*                                                      */
    00361 /********************************************************/
    00362
    00363 template <class PixelType, class Accessor>
    00364 inline triple<typename BasicImageView<PixelType>::const_traverser,
    00365               typename BasicImageView<PixelType>::const_traverser, Accessor>
    00366 srcImageRange(BasicImageView<PixelType> const & img, Accessor a)
    00367 {
    00368     return triple<typename BasicImageView<PixelType>::const_traverser,
    00369                   typename BasicImageView<PixelType>::const_traverser,
    00370           Accessor>(img.upperLeft(),
    00371                     img.lowerRight(),
    00372                     a);
    00373 }
    00374
    00375 template <class PixelType, class Accessor>
    00376 inline pair<typename BasicImageView<PixelType>::const_traverser, Accessor>
    00377 srcImage(BasicImageView<PixelType> const & img, Accessor a)
    00378 {
    00379     return pair<typename BasicImageView<PixelType>::const_traverser,
    00380                 Accessor>(img.upperLeft(), a);
    00381 }
    00382
    00383 template <class PixelType, class Accessor>
    00384 inline triple<typename BasicImageView<PixelType>::traverser,
    00385               typename BasicImageView<PixelType>::traverser, Accessor>
    00386 destImageRange(BasicImageView<PixelType> & img, Accessor a)
    00387 {
    00388     return triple<typename BasicImageView<PixelType>::traverser,
    00389                   typename BasicImageView<PixelType>::traverser,
    00390           Accessor>(img.upperLeft(),
    00391                     img.lowerRight(),
    00392                     a);
    00393 }
    00394
    00395 template <class PixelType, class Accessor>
    00396 inline pair<typename BasicImageView<PixelType>::traverser, Accessor>
    00397 destImage(BasicImageView<PixelType> & img, Accessor a)
    00398 {
    00399     return pair<typename BasicImageView<PixelType>::traverser,
    00400                 Accessor>(img.upperLeft(), a);
    00401 }
    00402
    00403 template <class PixelType, class Accessor>
    00404 inline pair<typename BasicImageView<PixelType>::const_traverser, Accessor>
    00405 maskImage(BasicImageView<PixelType> const & img, Accessor a)
    00406 {
    00407     return pair<typename BasicImageView<PixelType>::const_traverser,
    00408                 Accessor>(img.upperLeft(), a);
    00409 }
    00410
    00411 /****************************************************************/
    00412
    00413 template <class PixelType>
    00414 inline triple<typename BasicImageView<PixelType>::const_traverser,
    00415               typename BasicImageView<PixelType>::const_traverser,
    00416               typename BasicImageView<PixelType>::ConstAccessor>
    00417 srcImageRange(BasicImageView<PixelType> const & img)
    00418 {
    00419     return triple<typename BasicImageView<PixelType>::const_traverser,
    00420                   typename BasicImageView<PixelType>::const_traverser,
    00421                   typename BasicImageView<PixelType>::ConstAccessor>(img.upperLeft(),
    00422                                                                      img.lowerRight(),
    00423                                                                      img.accessor());
    00424 }
    00425
    00426 template <class PixelType>
    00427 inline pair< typename BasicImageView<PixelType>::const_traverser,
    00428              typename BasicImageView<PixelType>::ConstAccessor>
    00429 srcImage(BasicImageView<PixelType> const & img)
    00430 {
    00431     return pair<typename BasicImageView<PixelType>::const_traverser,
    00432                 typename BasicImageView<PixelType>::ConstAccessor>(img.upperLeft(),
    00433                                                                    img.accessor());
    00434 }
    00435
    00436 template <class PixelType>
    00437 inline triple< typename BasicImageView<PixelType>::traverser,
    00438                typename BasicImageView<PixelType>::traverser,
    00439                typename BasicImageView<PixelType>::Accessor>
    00440 destImageRange(BasicImageView<PixelType> & img)
    00441 {
    00442     return triple<typename BasicImageView<PixelType>::traverser,
    00443                   typename BasicImageView<PixelType>::traverser,
    00444                   typename BasicImageView<PixelType>::Accessor>(img.upperLeft(),
    00445                                                                 img.lowerRight(),
    00446                                                                 img.accessor());
    00447 }
    00448
    00449 template <class PixelType>
    00450 inline pair< typename BasicImageView<PixelType>::traverser,
    00451              typename BasicImageView<PixelType>::Accessor>
    00452 destImage(BasicImageView<PixelType> & img)
    00453 {
    00454     return pair<typename BasicImageView<PixelType>::traverser,
    00455                 typename BasicImageView<PixelType>::Accessor>(img.upperLeft(),
    00456                                                               img.accessor());
    00457 }
    00458
    00459 template <class PixelType>
    00460 inline pair< typename BasicImageView<PixelType>::const_traverser,
    00461              typename BasicImageView<PixelType>::ConstAccessor>
    00462 maskImage(BasicImageView<PixelType> const & img)
    00463 {
    00464     return pair<typename BasicImageView<PixelType>::const_traverser,
    00465                 typename BasicImageView<PixelType>::ConstAccessor>(img.upperLeft(),
    00466                                                                    img.accessor());
    00467 }
    00468
    00469 } // namespace vigra
    00470
    00471 #endif /* VIGRA_BASICIMAGEVIEW_HXX */

© Ullrich Köthe (koethe@informatik.uni-hamburg.de) Cognitive Systems Group, University of Hamburg, Germany | html generated using doxygen and Python VIGRA 1.3.2 (27 Jan 2005)