vigra - vigra/initimage.hxx Source File

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

vigra/initimage.hxx |

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