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

vigra/initimage.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 /*    The VIGRA Website is                                              */
00008 /*        http://kogs-www.informatik.uni-hamburg.de/~koethe/vigra/      */
00009 /*    Please direct questions, bug reports, and contributions to        */
00010 /*        ullrich.koethe@iwr.uni-heidelberg.de    or                    */
00011 /*        vigra@informatik.uni-hamburg.de                               */
00012 /*                                                                      */
00013 /*    Permission is hereby granted, free of charge, to any person       */
00014 /*    obtaining a copy of this software and associated documentation    */
00015 /*    files (the "Software"), to deal in the Software without           */
00016 /*    restriction, including without limitation the rights to use,      */
00017 /*    copy, modify, merge, publish, distribute, sublicense, and/or      */
00018 /*    sell copies of the Software, and to permit persons to whom the    */
00019 /*    Software is furnished to do so, subject to the following          */
00020 /*    conditions:                                                       */
00021 /*                                                                      */
00022 /*    The above copyright notice and this permission notice shall be    */
00023 /*    included in all copies or substantial portions of the             */
00024 /*    Software.                                                         */
00025 /*                                                                      */
00026 /*    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND    */
00027 /*    EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES   */
00028 /*    OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND          */
00029 /*    NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT       */
00030 /*    HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,      */
00031 /*    WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING      */
00032 /*    FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR     */
00033 /*    OTHER DEALINGS IN THE SOFTWARE.                                   */                
00034 /*                                                                      */
00035 /************************************************************************/
00036  
00037  
00038 #ifndef VIGRA_INITIMAGE_HXX
00039 #define VIGRA_INITIMAGE_HXX
00040 
00041 #include "utilities.hxx"
00042 #include "iteratortraits.hxx"
00043 #include "functortraits.hxx"
00044 
00045 namespace vigra {
00046 
00047 /** \addtogroup InitAlgo Algorithms to Initialize Images
00048     
00049     Init images or image borders
00050 */
00051 //@{
00052 
00053 /********************************************************/
00054 /*                                                      */
00055 /*                       initLine                       */
00056 /*                                                      */
00057 /********************************************************/
00058 
00059 template <class DestIterator, class DestAccessor, class VALUETYPE>
00060 inline void
00061 initLineImpl(DestIterator d, DestIterator dend, DestAccessor dest,
00062              VALUETYPE const & v, VigraFalseType)
00063 {
00064     for(; d != dend; ++d)
00065         dest.set(v, d);
00066 }
00067 
00068 template <class DestIterator, class DestAccessor, class FUNCTOR>
00069 inline void
00070 initLineImpl(DestIterator d, DestIterator dend, DestAccessor dest,
00071              FUNCTOR const & f, VigraTrueType)
00072 {
00073     for(; d != dend; ++d)
00074         dest.set(f(), d);
00075 }
00076 
00077 template <class DestIterator, class DestAccessor, class VALUETYPE>
00078 inline void
00079 initLine(DestIterator d, DestIterator dend, DestAccessor dest,
00080          VALUETYPE const & v)
00081 {
00082     initLineImpl(d, dend, dest, v, typename FunctorTraits<VALUETYPE>::isInitializer());
00083 }
00084 
00085 template <class DestIterator, class DestAccessor, class FUNCTOR>
00086 inline void
00087 initLineFunctor(DestIterator d, DestIterator dend, DestAccessor dest,
00088          FUNCTOR & f)
00089 {
00090     for(; d != dend; ++d)
00091         dest.set(f(), d);
00092 }
00093 
00094 template <class DestIterator, class DestAccessor, 
00095           class MaskIterator, class MaskAccessor, 
00096           class VALUETYPE>
00097 inline void
00098 initLineIfImpl(DestIterator d, DestIterator dend, DestAccessor dest,
00099                MaskIterator m, MaskAccessor mask,
00100                VALUETYPE const & v, VigraFalseType)
00101 {
00102     for(; d != dend; ++d, ++m)
00103         if(mask(m))
00104             dest.set(v, d);
00105 }
00106 
00107 template <class DestIterator, class DestAccessor, 
00108           class MaskIterator, class MaskAccessor, 
00109           class FUNCTOR>
00110 inline void
00111 initLineIfImpl(DestIterator d, DestIterator dend, DestAccessor dest,
00112                MaskIterator m, MaskAccessor mask,
00113                FUNCTOR const & f, VigraTrueType)
00114 {
00115     for(; d != dend; ++d, ++m)
00116         if(mask(m))
00117             dest.set(f(), d);
00118 }
00119 
00120 template <class DestIterator, class DestAccessor, 
00121           class MaskIterator, class MaskAccessor, 
00122           class VALUETYPE>
00123 inline void
00124 initLineIf(DestIterator d, DestIterator dend, DestAccessor dest,
00125            MaskIterator m, MaskAccessor mask,
00126            VALUETYPE const & v)
00127 {
00128     initLineIfImpl(d, dend, dest, m, mask, v, typename FunctorTraits<VALUETYPE>::isInitializer());
00129 }
00130 
00131 template <class DestIterator, class DestAccessor, 
00132           class MaskIterator, class MaskAccessor, 
00133           class FUNCTOR>
00134 inline void
00135 initLineFunctorIf(DestIterator d, DestIterator dend, DestAccessor dest,
00136                   MaskIterator m, MaskAccessor mask,
00137                   FUNCTOR & f)
00138 {
00139     for(; d != dend; ++d, ++m)
00140         if(mask(m))
00141             dest.set(f(), d);
00142 }
00143 
00144 /********************************************************/
00145 /*                                                      */
00146 /*                        initImage                     */
00147 /*                                                      */
00148 /********************************************************/
00149 
00150 /** \brief Write a value to every pixel in an image or rectangular ROI.
00151 
00152     This function can be used to init the image.
00153     It uses an accessor to access the pixel data.    
00154     
00155     The initial value can either be a constant of appropriate type (compatible with 
00156     the destination's value_type), or a functor with compatible result_type. These two 
00157     cases are automatically distinguished when <tt>FunctorTraits<FUNCTOR>::isInitializer</tt>
00158     yields <tt>VigraTrueType</tt>. Since the functor is passed by <tt>const</tt> reference, its 
00159     <tt>operator()</tt> must be const, and its internal state may need to be <tt>mutable</tt>.
00160 
00161     <b> Declarations:</b>
00162     
00163     pass arguments explicitly:
00164     \code
00165     namespace vigra {
00166         template <class ImageIterator, class Accessor, class VALUETYPE>
00167         void initImage(ImageIterator upperleft, ImageIterator lowerright, 
00168                        Accessor a, VALUETYPE const & v);
00169 
00170         template <class ImageIterator, class Accessor, class FUNCTOR>
00171         void initImage(ImageIterator upperleft, ImageIterator lowerright, 
00172                        Accessor a, FUNCTOR const & v);
00173     }
00174     \endcode
00175 
00176     use argument objects in conjunction with \ref ArgumentObjectFactories :
00177     \code
00178     namespace vigra {
00179         template <class ImageIterator, class Accessor, class VALUETYPE>
00180         void initImage(triple<ImageIterator, ImageIterator, Accessor> img, VALUETYPE const & v);
00181 
00182         template <class ImageIterator, class Accessor, class FUNCTOR>
00183         void initImage(triple<ImageIterator, ImageIterator, Accessor> img, FUNCTOR const & v);
00184     }
00185     \endcode
00186     
00187     <b> Usage:</b>
00188     
00189         <b>\#include</b> <<a href="initimage_8hxx-source.html">vigra/initimage.hxx</a>><br>
00190         Namespace: vigra
00191     
00192     Initialize with a constant:
00193     
00194     \code
00195     vigra::BImage img(100, 100);
00196     
00197     // init the image with the value 128
00198     vigra::initImage(destImageRange(img), 128);
00199     \endcode
00200 
00201     Initialize with a functor:
00202     
00203     \code
00204     struct Counter {
00205         Counter() : count(0) {}
00206         
00207         int operator()() const { return count++; }
00208     
00209         mutable int count;
00210     };
00211     
00212     vigra::IImage img(100, 100);
00213         
00214     // write the current count in every pixel
00215     vigra::initImage(destImageRange(img), Counter());
00216     \endcode
00217     
00218 
00219     <b> Required Interface:</b>
00220     
00221     \code
00222     ImageIterator upperleft, lowerright;
00223     ImageIterator::row_iterator ix = upperleft.rowIterator();
00224     
00225     Accessor accessor;
00226     VALUETYPE v;
00227     
00228     accessor.set(v, ix); 
00229     \endcode
00230     
00231 */
00232 doxygen_overloaded_function(template <...> void initImage)
00233 
00234 template <class ImageIterator, class Accessor, class VALUETYPE>
00235 void
00236 initImage(ImageIterator upperleft, ImageIterator lowerright, 
00237           Accessor a,  VALUETYPE const & v)
00238 {
00239     int w = lowerright.x - upperleft.x;
00240     
00241     for(; upperleft.y < lowerright.y; ++upperleft.y)
00242     {
00243         initLineImpl(upperleft.rowIterator(), upperleft.rowIterator() + w, a, 
00244                      v, typename FunctorTraits<VALUETYPE>::isInitializer());
00245     }
00246 }
00247     
00248 template <class ImageIterator, class Accessor, class VALUETYPE>
00249 inline 
00250 void
00251 initImage(triple<ImageIterator, ImageIterator, Accessor> img, VALUETYPE const & v)
00252 {
00253     initImage(img.first, img.second, img.third, v);
00254 }
00255     
00256 /********************************************************/
00257 /*                                                      */
00258 /*                 initImageWithFunctor                 */
00259 /*                                                      */
00260 /********************************************************/
00261 
00262 /** \brief Write the result of a functor call to every pixel in an image or rectangular ROI.
00263 
00264     This function can be used to init the image by calling the given 
00265     functor for each pixel. It uses an accessor to access the pixel data. The functor is 
00266     passed by reference, so that its internal state can be updated in each call.
00267     
00268     <b> Declarations:</b>
00269     
00270     pass arguments explicitly:
00271     \code
00272     namespace vigra {
00273         template <class ImageIterator, class Accessor, class FUNCTOR>
00274         void
00275         initImageWithFunctor(ImageIterator upperleft, ImageIterator lowerright, 
00276                   Accessor a,  FUNCTOR & f);
00277     }
00278     \endcode
00279 
00280     use argument objects in conjunction with \ref ArgumentObjectFactories :
00281     \code
00282     namespace vigra {
00283         template <class ImageIterator, class Accessor, class FUNCTOR>
00284         void
00285         initImageWithFunctor(triple<ImageIterator, ImageIterator, Accessor> img, FUNCTOR & f);
00286     }
00287     \endcode
00288     
00289     <b> Usage:</b>
00290     
00291         <b>\#include</b> <<a href="initimage_8hxx-source.html">vigra/initimage.hxx</a>><br>
00292         Namespace: vigra
00293     
00294     \code
00295     struct Counter {
00296         Counter() : count(0) {}
00297         
00298         int operator()() const { return count++; }
00299     
00300         mutable int count;
00301     };
00302     
00303     vigra::IImage img(100, 100);
00304         
00305     // write the current count in every pixel
00306     Counter counter;
00307     vigra::initImageWithFunctor(destImageRange(img), counter);
00308     \endcode
00309 
00310     <b> Required Interface:</b>
00311     
00312     \code
00313     ImageIterator upperleft, lowerright;
00314     ImageIterator::row_iterator ix = upperleft.rowIterator();
00315     
00316     Accessor accessor;
00317     Functor f;
00318     
00319     accessor.set(f(), ix); 
00320     \endcode
00321     
00322 */
00323 doxygen_overloaded_function(template <...> void initImageWithFunctor)
00324 
00325 template <class ImageIterator, class Accessor, class FUNCTOR>
00326 void
00327 initImageWithFunctor(ImageIterator upperleft, ImageIterator lowerright, 
00328           Accessor a,  FUNCTOR & f)
00329 {
00330     int w = lowerright.x - upperleft.x;
00331     
00332     for(; upperleft.y < lowerright.y; ++upperleft.y)
00333     {
00334         initLineFunctor(upperleft.rowIterator(), upperleft.rowIterator() + w, a, f);
00335     }
00336 }
00337     
00338 template <class ImageIterator, class Accessor, class FUNCTOR>
00339 inline 
00340 void
00341 initImageWithFunctor(triple<ImageIterator, ImageIterator, Accessor> img, FUNCTOR & f)
00342 {
00343     initImageWithFunctor(img.first, img.second, img.third, f);
00344 }
00345     
00346 /********************************************************/
00347 /*                                                      */
00348 /*                      initImageIf                     */
00349 /*                                                      */
00350 /********************************************************/
00351 
00352 /** \brief Write value to pixel in the image if mask is true.
00353 
00354     This function can be used to init a region-of-interest of the image.
00355     It uses an accessor to access the pixel data.
00356     
00357     The initial value can either be a constant of appropriate type (compatible with 
00358     the destination's value_type), or a functor with compatible result_type. These two 
00359     cases are automatically distinguished when <tt>FunctorTraits<FUNCTOR>::isInitializer</tt>
00360     yields <tt>VigraTrueType</tt>. Since the functor is passed by <tt>const</tt> reference, its 
00361     <tt>operator()</tt> must be const, and its internal state may need to be <tt>mutable</tt>.
00362     
00363     <b> Declarations:</b>
00364     
00365     pass arguments explicitly:
00366     \code
00367     namespace vigra {
00368         template <class ImageIterator, class Accessor, 
00369                   class MaskImageIterator, class MaskAccessor,
00370                   class VALUETYPE>
00371         void initImageIf(ImageIterator upperleft, ImageIterator lowerright, Accessor a,
00372                          MaskImageIterator mask_upperleft, MaskAccessor ma,
00373                          VALUETYPE const & v);
00374 
00375         template <class ImageIterator, class Accessor, 
00376                   class MaskImageIterator, class MaskAccessor,
00377                   class FUNCTOR>
00378         void initImageIf(ImageIterator upperleft, ImageIterator lowerright, Accessor a,
00379                          MaskImageIterator mask_upperleft, MaskAccessor ma,
00380                          FUNCTOR const & v);
00381     }
00382     \endcode    
00383     
00384     use argument objects in conjunction with \ref ArgumentObjectFactories :
00385     \code
00386     namespace vigra {
00387         template <class ImageIterator, class Accessor, 
00388                   class MaskImageIterator, class MaskAccessor,
00389                   class VALUETYPE>
00390         void initImageIf(triple<ImageIterator, ImageIterator, Accessor> img, 
00391                          pair<MaskImageIterator, MaskAccessor> mask,
00392                          VALUETYPE const & v);
00393 
00394         template <class ImageIterator, class Accessor, 
00395                   class MaskImageIterator, class MaskAccessor,
00396                   class FUNCTOR>
00397         void initImageIf(triple<ImageIterator, ImageIterator, Accessor> img, 
00398                          pair<MaskImageIterator, MaskAccessor> mask,
00399                          FUNCTOR const & v);
00400     }
00401     \endcode
00402     
00403     <b> Usage:</b>
00404     
00405         <b>\#include</b> <<a href="initimage_8hxx-source.html">vigra/initimage.hxx</a>><br>
00406         Namespace: vigra
00407     
00408     \code
00409     vigra::BImage img(100, 100);
00410     vigra::BImage mask(100, 100);
00411     
00412     // zero the ROI
00413     vigra::initImageIf(destImageRange(img), 
00414                 maskImage(mask),
00415                 vigra::NumericTraits<vigra::BImage::PixelType>::zero());
00416     \endcode
00417 
00418     <b> Required Interface:</b>
00419     
00420     \code
00421     ImageIterator upperleft, lowerright;
00422     MaskImageIterator mask_upperleft;
00423     ImageIterator::row_iterator ix = upperleft.rowIterator();
00424     MaskImageIterator::row_iterator mx = mask_upperleft.rowIterator();
00425     
00426     Accessor accessor;
00427     MaskAccessor mask_accessor;
00428     VALUETYPE v;
00429     
00430     if(mask_accessor(mx)) accessor.set(v, ix); 
00431     \endcode
00432     
00433 */
00434 doxygen_overloaded_function(template <...> void initImageIf)
00435 
00436 template <class ImageIterator, class Accessor, 
00437           class MaskImageIterator, class MaskAccessor,
00438           class VALUETYPE>
00439 void
00440 initImageIf(ImageIterator upperleft, ImageIterator lowerright, Accessor a,
00441           MaskImageIterator mask_upperleft, MaskAccessor ma,
00442           VALUETYPE const & v)
00443 {
00444     int w = lowerright.x - upperleft.x;
00445         
00446     for(; upperleft.y < lowerright.y; ++upperleft.y, ++mask_upperleft.y)
00447     {
00448         initLineIfImpl(upperleft.rowIterator(), 
00449                    upperleft.rowIterator() + w, a, 
00450                    mask_upperleft.rowIterator(), ma, 
00451                    v, typename FunctorTraits<VALUETYPE>::isInitializer());
00452     }
00453 }
00454     
00455 template <class ImageIterator, class Accessor, 
00456           class MaskImageIterator, class MaskAccessor,
00457           class VALUETYPE>
00458 inline 
00459 void
00460 initImageIf(triple<ImageIterator, ImageIterator, Accessor> img, 
00461             pair<MaskImageIterator, MaskAccessor> mask,
00462             VALUETYPE const & v)
00463 {
00464     initImageIf(img.first, img.second, img.third, mask.first, mask.second, v);
00465 }
00466     
00467 /********************************************************/
00468 /*                                                      */
00469 /*                    initImageBorder                   */
00470 /*                                                      */
00471 /********************************************************/
00472 
00473 /** \brief Write value to the specified border pixels in the image.
00474 
00475     A pixel is initialized if its distance to the border 
00476     is at most 'borderwidth'. It uses an accessor to access the pixel data.
00477     
00478     The initial value can either be a constant of appropriate type (compatible with 
00479     the destination's value_type), or a functor with compatible result_type. These two 
00480     cases are automatically distinguished when <tt>FunctorTraits<FUNCTOR>::isInitializer</tt>
00481     yields <tt>VigraTrueType</tt>. Since the functor is passed by <tt>const</tt> reference, its 
00482     <tt>operator()</tt> must be const, and its internal state may need to be <tt>mutable</tt>.
00483     
00484     <b> Declarations:</b>
00485     
00486     pass arguments explicitly:
00487     \code
00488     namespace vigra {
00489         template <class ImageIterator, class Accessor, class VALUETYPE>
00490         void initImageBorder(ImageIterator upperleft, ImageIterator lowerright, Accessor a,
00491                              int border_width, VALUETYPE const & v);
00492 
00493         template <class ImageIterator, class Accessor, class FUNCTOR>
00494         void initImageBorder(ImageIterator upperleft, ImageIterator lowerright, Accessor a,
00495                              int border_width, FUNCTOR const & v);
00496     }
00497     \endcode
00498 
00499     use argument objects in conjunction with \ref ArgumentObjectFactories :
00500     \code
00501     namespace vigra {
00502         template <class ImageIterator, class Accessor, class VALUETYPE>
00503         void initImageBorder(triple<ImageIterator, ImageIterator, Accessor> img, 
00504                              int border_width, VALUETYPE const & v);
00505 
00506         template <class ImageIterator, class Accessor, class FUNCTOR>
00507         void initImageBorder(triple<ImageIterator, ImageIterator, Accessor> img, 
00508                              int border_width, FUNCTOR const & v);
00509     }
00510     \endcode
00511     
00512     <b> Usage:</b>
00513     
00514         <b>\#include</b> <<a href="initimage_8hxx-source.html">vigra/initimage.hxx</a>><br>
00515         Namespace: vigra
00516     
00517     \code
00518     vigra::BImage img(100, 100);
00519     
00520     // zero a border of 5 pixel
00521     vigra::initImageBorder(destImageRange(img),
00522                     5, vigra::NumericTraits<vigra::BImage::PixelType>::zero());
00523     \endcode
00524 
00525     <b> Required Interface:</b>
00526     
00527     see \ref initImage()
00528     
00529 */
00530 doxygen_overloaded_function(template <...> void initImageBorder)
00531 
00532 template <class ImageIterator, class Accessor, class VALUETYPE>
00533 inline 
00534 void
00535 initImageBorder(ImageIterator upperleft, ImageIterator lowerright, 
00536                 Accessor a,  int border_width, VALUETYPE const & v)
00537 {
00538     int w = lowerright.x - upperleft.x;
00539     int h = lowerright.y - upperleft.y;
00540     
00541     int hb = (border_width > h) ? h : border_width;
00542     int wb = (border_width > w) ? w : border_width;
00543     
00544     initImage(upperleft, upperleft+Diff2D(w,hb), a, v);
00545     initImage(upperleft, upperleft+Diff2D(wb,h), a, v);
00546     initImage(upperleft+Diff2D(0,h-hb), lowerright, a, v);
00547     initImage(upperleft+Diff2D(w-wb,0), lowerright, a, v);
00548 }
00549     
00550 template <class ImageIterator, class Accessor, class VALUETYPE>
00551 inline 
00552 void
00553 initImageBorder(triple<ImageIterator, ImageIterator, Accessor> img, 
00554                 int border_width, VALUETYPE const & v)
00555 {
00556     initImageBorder(img.first, img.second, img.third, border_width, v);
00557 }
00558     
00559 //@}
00560 
00561 
00562 } // namespace vigra
00563 
00564 #endif // VIGRA_INITIMAGE_HXX

© 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.6.0 (5 Nov 2009)