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