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

details vigra/initimage.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.2.0, Aug 07 2003 )                                    */
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  
00024 #ifndef VIGRA_INITIMAGE_HXX
00025 #define VIGRA_INITIMAGE_HXX
00026 
00027 #include "vigra/utilities.hxx"
00028 #include "vigra/iteratortraits.hxx"
00029 
00030 namespace vigra {
00031 
00032 /** \addtogroup InitAlgo Algorithms to Initialize Images
00033     
00034     Init images or image borders
00035 */
00036 //@{
00037 
00038 /********************************************************/
00039 /*                                                      */
00040 /*                       initLine                       */
00041 /*                                                      */
00042 /********************************************************/
00043 
00044 template <class DestIterator, class DestAccessor, class VALUETYPE>
00045 void
00046 initLine(DestIterator d, DestIterator dend, DestAccessor dest,
00047          VALUETYPE v)
00048 {
00049     for(; d != dend; ++d)
00050         dest.set(v, d);
00051 }
00052 
00053 template <class DestIterator, class DestAccessor, 
00054           class MaskIterator, class MaskAccessor, 
00055           class VALUETYPE>
00056 void
00057 initLineIf(DestIterator d, DestIterator dend, DestAccessor dest,
00058            MaskIterator m, MaskAccessor mask,
00059            VALUETYPE v)
00060 {
00061     for(; d != dend; ++d, ++m)
00062         if(mask(m))
00063             dest.set(v, d);
00064 }
00065 
00066 template <class DestIterator, class DestAccessor, class FUNCTOR>
00067 void
00068 initLineFunctor(DestIterator d, DestIterator dend, DestAccessor dest,
00069          FUNCTOR f)
00070 {
00071     for(; d != dend; ++d)
00072         dest.set(f(), d);
00073 }
00074 
00075 template <class DestIterator, class DestAccessor, 
00076           class MaskIterator, class MaskAccessor, 
00077           class FUNCTOR>
00078 void
00079 initLineFunctorIf(DestIterator d, DestIterator dend, DestAccessor dest,
00080            MaskIterator m, MaskAccessor mask,
00081            FUNCTOR f)
00082 {
00083     for(; d != dend; ++d, ++m)
00084         if(mask(m))
00085             dest.set(f(), d);
00086 }
00087 
00088 /********************************************************/
00089 /*                                                      */
00090 /*                        initImage                     */
00091 /*                                                      */
00092 /********************************************************/
00093 
00094 /** \brief Write a value to every pixel in an image or rectangular ROI.
00095 
00096     This function can be used to init the image.
00097     It uses an accessor to access the pixel data.
00098     
00099     <b> Declarations:</b>
00100     
00101     pass arguments explicitly:
00102     \code
00103     namespace vigra {
00104         template <class ImageIterator, class Accessor, class VALUETYPE>
00105         void
00106         initImage(ImageIterator upperleft, ImageIterator lowerright, 
00107               Accessor a, VALUETYPE v)
00108     }
00109     \endcode
00110 
00111     use argument objects in conjuction with \ref ArgumentObjectFactories:
00112     \code
00113     namespace vigra {
00114         template <class ImageIterator, class Accessor, class VALUETYPE>
00115         void
00116         initImage(triple<ImageIterator, ImageIterator, Accessor> img, VALUETYPE v)
00117     }
00118     \endcode
00119     
00120     <b> Usage:</b>
00121     
00122         <b>\#include</b> "<a href="initimage_8hxx-source.html">vigra/initimage.hxx</a>"<br>
00123         Namespace: vigra
00124     
00125     \code
00126     vigra::BImage img(100, 100);
00127     
00128     // zero the image
00129     vigra::initImage(destImageRange(img),
00130                      vigra::NumericTraits<vigra::BImage::PixelType>::zero());
00131     \endcode
00132 
00133     <b> Required Interface:</b>
00134     
00135     \code
00136     ImageIterator upperleft, lowerright;
00137     ImageIterator::row_iterator ix = upperleft.rowIterator();
00138     
00139     Accessor accessor;
00140     VALUETYPE v;
00141     
00142     accessor.set(v, ix); 
00143     \endcode
00144     
00145 */
00146 template <class ImageIterator, class Accessor, class VALUETYPE>
00147 void
00148 initImage(ImageIterator upperleft, ImageIterator lowerright, 
00149           Accessor a,  VALUETYPE v)
00150 {
00151     int w = lowerright.x - upperleft.x;
00152     
00153     for(; upperleft.y < lowerright.y; ++upperleft.y)
00154     {
00155         initLine(upperleft.rowIterator(), 
00156                  upperleft.rowIterator() + w, a, v);
00157     }
00158 }
00159     
00160 template <class ImageIterator, class Accessor, class VALUETYPE>
00161 inline 
00162 void
00163 initImage(triple<ImageIterator, ImageIterator, Accessor> img, VALUETYPE v)
00164 {
00165     initImage(img.first, img.second, img.third, v);
00166 }
00167     
00168 /********************************************************/
00169 /*                                                      */
00170 /*                        initImage                     */
00171 /*                                                      */
00172 /********************************************************/
00173 
00174 /** \brief Write the result of a functor call to every pixel in an image or rectangular ROI.
00175 
00176     This function can be used to init the image by calling the given 
00177     functor for each pixel.
00178     It uses an accessor to access the pixel data.
00179     
00180     <b> Declarations:</b>
00181     
00182     pass arguments explicitly:
00183     \code
00184     namespace vigra {
00185         template <class ImageIterator, class Accessor, class FUNCTOR>
00186         void
00187         initImageWithFunctor(ImageIterator upperleft, ImageIterator lowerright, 
00188                   Accessor a,  FUNCTOR f);
00189     }
00190     \endcode
00191 
00192     use argument objects in conjuction with \ref ArgumentObjectFactories:
00193     \code
00194     namespace vigra {
00195         template <class ImageIterator, class Accessor, class FUNCTOR>
00196         void
00197         initImageWithFunctor(triple<ImageIterator, ImageIterator, Accessor> img, FUNCTOR f);
00198     }
00199     \endcode
00200     
00201     <b> Usage:</b>
00202     
00203         <b>\#include</b> "<a href="initimage_8hxx-source.html">vigra/initimage.hxx</a>"<br>
00204         Namespace: vigra
00205     
00206     \code
00207     struct Counter {
00208         Counter() : count(0) {}
00209         
00210         int operator()() const { return count++; }
00211     
00212         mutable int count;
00213     };
00214     
00215     vigra::IImage img(100, 100);
00216     
00217     // write the current count in every pixel
00218     vigra::initImageWithFunctor(destImageRange(img), Counter());
00219     \endcode
00220 
00221     <b> Required Interface:</b>
00222     
00223     \code
00224     ImageIterator upperleft, lowerright;
00225     ImageIterator::row_iterator ix = upperleft.rowIterator();
00226     
00227     Accessor accessor;
00228     Functor f;
00229     
00230     accessor.set(f(), ix); 
00231     \endcode
00232     
00233 */
00234 template <class ImageIterator, class Accessor, class FUNCTOR>
00235 void
00236 initImageWithFunctor(ImageIterator upperleft, ImageIterator lowerright, 
00237           Accessor a,  FUNCTOR f)
00238 {
00239     int w = lowerright.x - upperleft.x;
00240     
00241     for(; upperleft.y < lowerright.y; ++upperleft.y)
00242     {
00243         initLineFunctor(upperleft.rowIterator(), 
00244                  upperleft.rowIterator() + w, a, f);
00245     }
00246 }
00247     
00248 template <class ImageIterator, class Accessor, class FUNCTOR>
00249 inline 
00250 void
00251 initImageWithFunctor(triple<ImageIterator, ImageIterator, Accessor> img, FUNCTOR f)
00252 {
00253     initImageWithFunctor(img.first, img.second, img.third, f);
00254 }
00255     
00256 /********************************************************/
00257 /*                                                      */
00258 /*                      initImageIf                     */
00259 /*                                                      */
00260 /********************************************************/
00261 
00262 /** \brief Write value to pixel in the image if mask is true.
00263 
00264     This function can be used to init a region-of-interest of the image.
00265     It uses an accessor to access the pixel data.
00266     
00267     <b> Declarations:</b>
00268     
00269     pass arguments explicitly:
00270     \code
00271     namespace vigra {
00272         template <class ImageIterator, class Accessor, 
00273               class MaskImageIterator, class MaskAccessor,
00274               class VALUETYPE>
00275         void
00276         initImageIf(ImageIterator upperleft, ImageIterator lowerright, Accessor a,
00277               MaskImageIterator mask_upperleft, MaskAccessor ma,
00278               VALUETYPE v)
00279     }
00280     \endcode    
00281     
00282     use argument objects in conjuction with \ref ArgumentObjectFactories:
00283     \code
00284     namespace vigra {
00285         template <class ImageIterator, class Accessor, 
00286               class MaskImageIterator, class MaskAccessor,
00287               class VALUETYPE>
00288         void
00289         initImageIf(triple<ImageIterator, ImageIterator, Accessor> img, 
00290             pair<MaskImageIterator, MaskAccessor> mask,
00291             VALUETYPE v)
00292     }
00293     \endcode
00294     
00295     <b> Usage:</b>
00296     
00297         <b>\#include</b> "<a href="initimage_8hxx-source.html">vigra/initimage.hxx</a>"<br>
00298         Namespace: vigra
00299     
00300     \code
00301     vigra::BImage img(100, 100);
00302     vigra::BImage mask(100, 100);
00303     
00304     // zero the ROI
00305     vigra::initImageIf(destImageRange(img), 
00306                 maskImage(mask),
00307                 vigra::NumericTraits<vigra::BImage::PixelType>::zero());
00308     \endcode
00309 
00310     <b> Required Interface:</b>
00311     
00312     \code
00313     ImageIterator upperleft, lowerright;
00314     MaskImageIterator mask_upperleft;
00315     ImageIterator::row_iterator ix = upperleft.rowIterator();
00316     MaskImageIterator::row_iterator mx = mask_upperleft.rowIterator();
00317     
00318     Accessor accessor;
00319     MaskAccessor mask_accessor;
00320     VALUETYPE v;
00321     
00322     if(mask_accessor(mx)) accessor.set(v, ix); 
00323     \endcode
00324     
00325 */
00326 template <class ImageIterator, class Accessor, 
00327           class MaskImageIterator, class MaskAccessor,
00328           class VALUETYPE>
00329 void
00330 initImageIf(ImageIterator upperleft, ImageIterator lowerright, Accessor a,
00331           MaskImageIterator mask_upperleft, MaskAccessor ma,
00332           VALUETYPE v)
00333 {
00334     int w = lowerright.x - upperleft.x;
00335         
00336     for(; upperleft.y < lowerright.y; ++upperleft.y, ++mask_upperleft.y)
00337     {
00338         initLineIf(upperleft.rowIterator(), 
00339                    upperleft.rowIterator() + w, a, 
00340                    mask_upperleft.rowIterator(), ma, v);
00341     }
00342 }
00343     
00344 template <class ImageIterator, class Accessor, 
00345           class MaskImageIterator, class MaskAccessor,
00346           class VALUETYPE>
00347 inline 
00348 void
00349 initImageIf(triple<ImageIterator, ImageIterator, Accessor> img, 
00350             pair<MaskImageIterator, MaskAccessor> mask,
00351             VALUETYPE v)
00352 {
00353     initImageIf(img.first, img.second, img.third, mask.first, mask.second, v);
00354 }
00355     
00356 /********************************************************/
00357 /*                                                      */
00358 /*                    initImageBorder                   */
00359 /*                                                      */
00360 /********************************************************/
00361 
00362 /** \brief Write value to the specified border pixels in the image.
00363 
00364     A pixel is initialized if its distance to the border 
00365     is at most 'borderwidth'.
00366     It uses an accessor to access the pixel data.
00367     
00368     <b> Declarations:</b>
00369     
00370     pass arguments explicitly:
00371     \code
00372     namespace vigra {
00373         template <class ImageIterator, class Accessor, class VALUETYPE>
00374         void
00375         initImageBorder(ImageIterator upperleft, ImageIterator lowerright, 
00376                 Accessor a,  int border_width, VALUETYPE v)
00377     }
00378     \endcode
00379 
00380     use argument objects in conjuction with \ref ArgumentObjectFactories:
00381     \code
00382     namespace vigra {
00383         template <class ImageIterator, class Accessor, class VALUETYPE>
00384         void
00385         initImageBorder(triple<ImageIterator, ImageIterator, Accessor> img, 
00386                 int border_width, VALUETYPE v)
00387     }
00388     \endcode
00389     
00390     <b> Usage:</b>
00391     
00392         <b>\#include</b> "<a href="initimage_8hxx-source.html">vigra/initimage.hxx</a>"<br>
00393         Namespace: vigra
00394     
00395     \code
00396     vigra::BImage img(100, 100);
00397     
00398     // zero a border of 5 pixel
00399     vigra::initImageBorder(destImageRange(img),
00400                     5, vigra::NumericTraits<vigra::BImage::PixelType>::zero());
00401     \endcode
00402 
00403     <b> Required Interface:</b>
00404     
00405     see \ref initImage()
00406     
00407 */
00408 template <class ImageIterator, class Accessor, class VALUETYPE>
00409 inline 
00410 void
00411 initImageBorder(ImageIterator upperleft, ImageIterator lowerright, 
00412                 Accessor a,  int border_width, VALUETYPE v)
00413 {
00414     int w = lowerright.x - upperleft.x;
00415     int h = lowerright.y - upperleft.y;
00416     
00417     int hb = (border_width > h) ? h : border_width;
00418     int wb = (border_width > w) ? w : border_width;
00419     
00420     initImage(upperleft, upperleft+Diff2D(w,hb), a, v);
00421     initImage(upperleft, upperleft+Diff2D(wb,h), a, v);
00422     initImage(upperleft+Diff2D(0,h-hb), lowerright, a, v);
00423     initImage(upperleft+Diff2D(w-wb,0), lowerright, a, v);
00424 }
00425     
00426 template <class ImageIterator, class Accessor, class VALUETYPE>
00427 inline 
00428 void
00429 initImageBorder(triple<ImageIterator, ImageIterator, Accessor> img, 
00430                 int border_width, VALUETYPE v)
00431 {
00432     initImageBorder(img.first, img.second, img.third, border_width, v);
00433 }
00434     
00435 //@}
00436 
00437 
00438 } // namespace vigra
00439 
00440 #endif // VIGRA_INITIMAGE_HXX

© Ullrich Köthe (koethe@informatik.uni-hamburg.de)
Cognitive Systems Group, University of Hamburg, Germany

html generated using doxygen and Python
VIGRA 1.2.0 (7 Aug 2003)