[ 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 /* 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) |
html generated using doxygen and Python
|