[ VIGRA Homepage | Function Index | Class Index | Namespaces | File List | Main Page ]
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) |
html generated using doxygen and Python
|