[ VIGRA Homepage | Class Index | Function Index | File Index | 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.4.0, Dec 21 2005 ) */ 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 /* koethe@informatik.uni-hamburg.de or */ 00012 /* vigra@kogs1.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 "vigra/utilities.hxx" 00043 #include "vigra/iteratortraits.hxx" 00044 #include "vigra/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 void 00062 initLineImpl(DestIterator d, DestIterator dend, DestAccessor dest, 00063 VALUETYPE v, VigraFalseType) 00064 { 00065 for(; d != dend; ++d) 00066 dest.set(v, d); 00067 } 00068 00069 template <class DestIterator, class DestAccessor, class FUNCTOR> 00070 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 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 initLineImpl(d, dend, dest, f, VigraTrueType()); 00092 } 00093 00094 template <class DestIterator, class DestAccessor, 00095 class MaskIterator, class MaskAccessor, 00096 class VALUETYPE> 00097 void 00098 initLineIfImpl(DestIterator d, DestIterator dend, DestAccessor dest, 00099 MaskIterator m, MaskAccessor mask, 00100 VALUETYPE 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 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 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 void 00135 initLineFunctorIf(DestIterator d, DestIterator dend, DestAccessor dest, 00136 MaskIterator m, MaskAccessor mask, 00137 FUNCTOR f) 00138 { 00139 initLineIfImpl(d, dend, dest, m, mask, f, VigraTrueType()); 00140 } 00141 00142 /********************************************************/ 00143 /* */ 00144 /* initImage */ 00145 /* */ 00146 /********************************************************/ 00147 00148 /** \brief Write a value to every pixel in an image or rectangular ROI. 00149 00150 This function can be used to init the image. 00151 It uses an accessor to access the pixel data. 00152 00153 <b> Declarations:</b> 00154 00155 pass arguments explicitly: 00156 \code 00157 namespace vigra { 00158 template <class ImageIterator, class Accessor, class VALUETYPE> 00159 void 00160 initImage(ImageIterator upperleft, ImageIterator lowerright, 00161 Accessor a, VALUETYPE v) 00162 } 00163 \endcode 00164 00165 use argument objects in conjunction with \ref ArgumentObjectFactories: 00166 \code 00167 namespace vigra { 00168 template <class ImageIterator, class Accessor, class VALUETYPE> 00169 void 00170 initImage(triple<ImageIterator, ImageIterator, Accessor> img, VALUETYPE v) 00171 } 00172 \endcode 00173 00174 <b> Usage:</b> 00175 00176 <b>\#include</b> "<a href="initimage_8hxx-source.html">vigra/initimage.hxx</a>"<br> 00177 Namespace: vigra 00178 00179 \code 00180 vigra::BImage img(100, 100); 00181 00182 // zero the image 00183 vigra::initImage(destImageRange(img), 00184 vigra::NumericTraits<vigra::BImage::PixelType>::zero()); 00185 \endcode 00186 00187 <b> Required Interface:</b> 00188 00189 \code 00190 ImageIterator upperleft, lowerright; 00191 ImageIterator::row_iterator ix = upperleft.rowIterator(); 00192 00193 Accessor accessor; 00194 VALUETYPE v; 00195 00196 accessor.set(v, ix); 00197 \endcode 00198 00199 */ 00200 template <class ImageIterator, class Accessor, class VALUETYPE> 00201 void 00202 initImage(ImageIterator upperleft, ImageIterator lowerright, 00203 Accessor a, VALUETYPE v) 00204 { 00205 int w = lowerright.x - upperleft.x; 00206 00207 for(; upperleft.y < lowerright.y; ++upperleft.y) 00208 { 00209 initLine(upperleft.rowIterator(), 00210 upperleft.rowIterator() + w, a, v); 00211 } 00212 } 00213 00214 template <class ImageIterator, class Accessor, class VALUETYPE> 00215 inline 00216 void 00217 initImage(triple<ImageIterator, ImageIterator, Accessor> img, VALUETYPE v) 00218 { 00219 initImage(img.first, img.second, img.third, v); 00220 } 00221 00222 /********************************************************/ 00223 /* */ 00224 /* initImage */ 00225 /* */ 00226 /********************************************************/ 00227 00228 /** \brief Write the result of a functor call to every pixel in an image or rectangular ROI. 00229 00230 This function can be used to init the image by calling the given 00231 functor for each pixel. 00232 It uses an accessor to access the pixel data. 00233 00234 <b> Declarations:</b> 00235 00236 pass arguments explicitly: 00237 \code 00238 namespace vigra { 00239 template <class ImageIterator, class Accessor, class FUNCTOR> 00240 void 00241 initImageWithFunctor(ImageIterator upperleft, ImageIterator lowerright, 00242 Accessor a, FUNCTOR f); 00243 } 00244 \endcode 00245 00246 use argument objects in conjunction with \ref ArgumentObjectFactories: 00247 \code 00248 namespace vigra { 00249 template <class ImageIterator, class Accessor, class FUNCTOR> 00250 void 00251 initImageWithFunctor(triple<ImageIterator, ImageIterator, Accessor> img, FUNCTOR f); 00252 } 00253 \endcode 00254 00255 <b> Usage:</b> 00256 00257 <b>\#include</b> "<a href="initimage_8hxx-source.html">vigra/initimage.hxx</a>"<br> 00258 Namespace: vigra 00259 00260 \code 00261 struct Counter { 00262 Counter() : count(0) {} 00263 00264 int operator()() const { return count++; } 00265 00266 mutable int count; 00267 }; 00268 00269 vigra::IImage img(100, 100); 00270 00271 // write the current count in every pixel 00272 vigra::initImageWithFunctor(destImageRange(img), Counter()); 00273 \endcode 00274 00275 <b> Required Interface:</b> 00276 00277 \code 00278 ImageIterator upperleft, lowerright; 00279 ImageIterator::row_iterator ix = upperleft.rowIterator(); 00280 00281 Accessor accessor; 00282 Functor f; 00283 00284 accessor.set(f(), ix); 00285 \endcode 00286 00287 */ 00288 template <class ImageIterator, class Accessor, class FUNCTOR> 00289 void 00290 initImageWithFunctor(ImageIterator upperleft, ImageIterator lowerright, 00291 Accessor a, FUNCTOR f) 00292 { 00293 int w = lowerright.x - upperleft.x; 00294 00295 for(; upperleft.y < lowerright.y; ++upperleft.y) 00296 { 00297 initLineFunctor(upperleft.rowIterator(), 00298 upperleft.rowIterator() + w, a, f); 00299 } 00300 } 00301 00302 template <class ImageIterator, class Accessor, class FUNCTOR> 00303 inline 00304 void 00305 initImageWithFunctor(triple<ImageIterator, ImageIterator, Accessor> img, FUNCTOR f) 00306 { 00307 initImageWithFunctor(img.first, img.second, img.third, f); 00308 } 00309 00310 /********************************************************/ 00311 /* */ 00312 /* initImageIf */ 00313 /* */ 00314 /********************************************************/ 00315 00316 /** \brief Write value to pixel in the image if mask is true. 00317 00318 This function can be used to init a region-of-interest of the image. 00319 It uses an accessor to access the pixel data. 00320 00321 <b> Declarations:</b> 00322 00323 pass arguments explicitly: 00324 \code 00325 namespace vigra { 00326 template <class ImageIterator, class Accessor, 00327 class MaskImageIterator, class MaskAccessor, 00328 class VALUETYPE> 00329 void 00330 initImageIf(ImageIterator upperleft, ImageIterator lowerright, Accessor a, 00331 MaskImageIterator mask_upperleft, MaskAccessor ma, 00332 VALUETYPE v) 00333 } 00334 \endcode 00335 00336 use argument objects in conjunction with \ref ArgumentObjectFactories: 00337 \code 00338 namespace vigra { 00339 template <class ImageIterator, class Accessor, 00340 class MaskImageIterator, class MaskAccessor, 00341 class VALUETYPE> 00342 void 00343 initImageIf(triple<ImageIterator, ImageIterator, Accessor> img, 00344 pair<MaskImageIterator, MaskAccessor> mask, 00345 VALUETYPE v) 00346 } 00347 \endcode 00348 00349 <b> Usage:</b> 00350 00351 <b>\#include</b> "<a href="initimage_8hxx-source.html">vigra/initimage.hxx</a>"<br> 00352 Namespace: vigra 00353 00354 \code 00355 vigra::BImage img(100, 100); 00356 vigra::BImage mask(100, 100); 00357 00358 // zero the ROI 00359 vigra::initImageIf(destImageRange(img), 00360 maskImage(mask), 00361 vigra::NumericTraits<vigra::BImage::PixelType>::zero()); 00362 \endcode 00363 00364 <b> Required Interface:</b> 00365 00366 \code 00367 ImageIterator upperleft, lowerright; 00368 MaskImageIterator mask_upperleft; 00369 ImageIterator::row_iterator ix = upperleft.rowIterator(); 00370 MaskImageIterator::row_iterator mx = mask_upperleft.rowIterator(); 00371 00372 Accessor accessor; 00373 MaskAccessor mask_accessor; 00374 VALUETYPE v; 00375 00376 if(mask_accessor(mx)) accessor.set(v, ix); 00377 \endcode 00378 00379 */ 00380 template <class ImageIterator, class Accessor, 00381 class MaskImageIterator, class MaskAccessor, 00382 class VALUETYPE> 00383 void 00384 initImageIf(ImageIterator upperleft, ImageIterator lowerright, Accessor a, 00385 MaskImageIterator mask_upperleft, MaskAccessor ma, 00386 VALUETYPE v) 00387 { 00388 int w = lowerright.x - upperleft.x; 00389 00390 for(; upperleft.y < lowerright.y; ++upperleft.y, ++mask_upperleft.y) 00391 { 00392 initLineIf(upperleft.rowIterator(), 00393 upperleft.rowIterator() + w, a, 00394 mask_upperleft.rowIterator(), ma, v); 00395 } 00396 } 00397 00398 template <class ImageIterator, class Accessor, 00399 class MaskImageIterator, class MaskAccessor, 00400 class VALUETYPE> 00401 inline 00402 void 00403 initImageIf(triple<ImageIterator, ImageIterator, Accessor> img, 00404 pair<MaskImageIterator, MaskAccessor> mask, 00405 VALUETYPE v) 00406 { 00407 initImageIf(img.first, img.second, img.third, mask.first, mask.second, v); 00408 } 00409 00410 /********************************************************/ 00411 /* */ 00412 /* initImageBorder */ 00413 /* */ 00414 /********************************************************/ 00415 00416 /** \brief Write value to the specified border pixels in the image. 00417 00418 A pixel is initialized if its distance to the border 00419 is at most 'borderwidth'. 00420 It uses an accessor to access the pixel data. 00421 00422 <b> Declarations:</b> 00423 00424 pass arguments explicitly: 00425 \code 00426 namespace vigra { 00427 template <class ImageIterator, class Accessor, class VALUETYPE> 00428 void 00429 initImageBorder(ImageIterator upperleft, ImageIterator lowerright, 00430 Accessor a, int border_width, VALUETYPE v) 00431 } 00432 \endcode 00433 00434 use argument objects in conjunction with \ref ArgumentObjectFactories: 00435 \code 00436 namespace vigra { 00437 template <class ImageIterator, class Accessor, class VALUETYPE> 00438 void 00439 initImageBorder(triple<ImageIterator, ImageIterator, Accessor> img, 00440 int border_width, VALUETYPE v) 00441 } 00442 \endcode 00443 00444 <b> Usage:</b> 00445 00446 <b>\#include</b> "<a href="initimage_8hxx-source.html">vigra/initimage.hxx</a>"<br> 00447 Namespace: vigra 00448 00449 \code 00450 vigra::BImage img(100, 100); 00451 00452 // zero a border of 5 pixel 00453 vigra::initImageBorder(destImageRange(img), 00454 5, vigra::NumericTraits<vigra::BImage::PixelType>::zero()); 00455 \endcode 00456 00457 <b> Required Interface:</b> 00458 00459 see \ref initImage() 00460 00461 */ 00462 template <class ImageIterator, class Accessor, class VALUETYPE> 00463 inline 00464 void 00465 initImageBorder(ImageIterator upperleft, ImageIterator lowerright, 00466 Accessor a, int border_width, VALUETYPE v) 00467 { 00468 int w = lowerright.x - upperleft.x; 00469 int h = lowerright.y - upperleft.y; 00470 00471 int hb = (border_width > h) ? h : border_width; 00472 int wb = (border_width > w) ? w : border_width; 00473 00474 initImage(upperleft, upperleft+Diff2D(w,hb), a, v); 00475 initImage(upperleft, upperleft+Diff2D(wb,h), a, v); 00476 initImage(upperleft+Diff2D(0,h-hb), lowerright, a, v); 00477 initImage(upperleft+Diff2D(w-wb,0), lowerright, a, v); 00478 } 00479 00480 template <class ImageIterator, class Accessor, class VALUETYPE> 00481 inline 00482 void 00483 initImageBorder(triple<ImageIterator, ImageIterator, Accessor> img, 00484 int border_width, VALUETYPE v) 00485 { 00486 initImageBorder(img.first, img.second, img.third, border_width, v); 00487 } 00488 00489 //@} 00490 00491 00492 } // namespace vigra 00493 00494 #endif // VIGRA_INITIMAGE_HXX
© Ullrich Köthe (koethe@informatik.uni-hamburg.de) |
html generated using doxygen and Python
|