[ 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.2.0, Aug 07 2003 ) */ 00008 /* You may use, modify, and distribute this software according */ 00009 /* to the terms stated in the LICENSE file included in */ 00010 /* the VIGRA distribution. */ 00011 /* */ 00012 /* The VIGRA Website is */ 00013 /* http://kogs-www.informatik.uni-hamburg.de/~koethe/vigra/ */ 00014 /* Please direct questions, bug reports, and contributions to */ 00015 /* koethe@informatik.uni-hamburg.de */ 00016 /* */ 00017 /* THIS SOFTWARE IS PROVIDED AS IS AND WITHOUT ANY EXPRESS OR */ 00018 /* IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED */ 00019 /* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. */ 00020 /* */ 00021 /************************************************************************/ 00022 00023 00024 #ifndef VIGRA_INITIMAGE_HXX 00025 #define VIGRA_INITIMAGE_HXX 00026 00027 #include "vigra/utilities.hxx" 00028 #include "vigra/iteratortraits.hxx" 00029 00030 namespace vigra { 00031 00032 /** \addtogroup InitAlgo Algorithms to Initialize Images 00033 00034 Init images or image borders 00035 */ 00036 //@{ 00037 00038 /********************************************************/ 00039 /* */ 00040 /* initLine */ 00041 /* */ 00042 /********************************************************/ 00043 00044 template <class DestIterator, class DestAccessor, class VALUETYPE> 00045 void 00046 initLine(DestIterator d, DestIterator dend, DestAccessor dest, 00047 VALUETYPE v) 00048 { 00049 for(; d != dend; ++d) 00050 dest.set(v, d); 00051 } 00052 00053 template <class DestIterator, class DestAccessor, 00054 class MaskIterator, class MaskAccessor, 00055 class VALUETYPE> 00056 void 00057 initLineIf(DestIterator d, DestIterator dend, DestAccessor dest, 00058 MaskIterator m, MaskAccessor mask, 00059 VALUETYPE v) 00060 { 00061 for(; d != dend; ++d, ++m) 00062 if(mask(m)) 00063 dest.set(v, d); 00064 } 00065 00066 template <class DestIterator, class DestAccessor, class FUNCTOR> 00067 void 00068 initLineFunctor(DestIterator d, DestIterator dend, DestAccessor dest, 00069 FUNCTOR f) 00070 { 00071 for(; d != dend; ++d) 00072 dest.set(f(), d); 00073 } 00074 00075 template <class DestIterator, class DestAccessor, 00076 class MaskIterator, class MaskAccessor, 00077 class FUNCTOR> 00078 void 00079 initLineFunctorIf(DestIterator d, DestIterator dend, DestAccessor dest, 00080 MaskIterator m, MaskAccessor mask, 00081 FUNCTOR f) 00082 { 00083 for(; d != dend; ++d, ++m) 00084 if(mask(m)) 00085 dest.set(f(), d); 00086 } 00087 00088 /********************************************************/ 00089 /* */ 00090 /* initImage */ 00091 /* */ 00092 /********************************************************/ 00093 00094 /** \brief Write a value to every pixel in an image or rectangular ROI. 00095 00096 This function can be used to init the image. 00097 It uses an accessor to access the pixel data. 00098 00099 <b> Declarations:</b> 00100 00101 pass arguments explicitly: 00102 \code 00103 namespace vigra { 00104 template <class ImageIterator, class Accessor, class VALUETYPE> 00105 void 00106 initImage(ImageIterator upperleft, ImageIterator lowerright, 00107 Accessor a, VALUETYPE v) 00108 } 00109 \endcode 00110 00111 use argument objects in conjuction with \ref ArgumentObjectFactories: 00112 \code 00113 namespace vigra { 00114 template <class ImageIterator, class Accessor, class VALUETYPE> 00115 void 00116 initImage(triple<ImageIterator, ImageIterator, Accessor> img, VALUETYPE v) 00117 } 00118 \endcode 00119 00120 <b> Usage:</b> 00121 00122 <b>\#include</b> "<a href="initimage_8hxx-source.html">vigra/initimage.hxx</a>"<br> 00123 Namespace: vigra 00124 00125 \code 00126 vigra::BImage img(100, 100); 00127 00128 // zero the image 00129 vigra::initImage(destImageRange(img), 00130 vigra::NumericTraits<vigra::BImage::PixelType>::zero()); 00131 \endcode 00132 00133 <b> Required Interface:</b> 00134 00135 \code 00136 ImageIterator upperleft, lowerright; 00137 ImageIterator::row_iterator ix = upperleft.rowIterator(); 00138 00139 Accessor accessor; 00140 VALUETYPE v; 00141 00142 accessor.set(v, ix); 00143 \endcode 00144 00145 */ 00146 template <class ImageIterator, class Accessor, class VALUETYPE> 00147 void 00148 initImage(ImageIterator upperleft, ImageIterator lowerright, 00149 Accessor a, VALUETYPE v) 00150 { 00151 int w = lowerright.x - upperleft.x; 00152 00153 for(; upperleft.y < lowerright.y; ++upperleft.y) 00154 { 00155 initLine(upperleft.rowIterator(), 00156 upperleft.rowIterator() + w, a, v); 00157 } 00158 } 00159 00160 template <class ImageIterator, class Accessor, class VALUETYPE> 00161 inline 00162 void 00163 initImage(triple<ImageIterator, ImageIterator, Accessor> img, VALUETYPE v) 00164 { 00165 initImage(img.first, img.second, img.third, v); 00166 } 00167 00168 /********************************************************/ 00169 /* */ 00170 /* initImage */ 00171 /* */ 00172 /********************************************************/ 00173 00174 /** \brief Write the result of a functor call to every pixel in an image or rectangular ROI. 00175 00176 This function can be used to init the image by calling the given 00177 functor for each pixel. 00178 It uses an accessor to access the pixel data. 00179 00180 <b> Declarations:</b> 00181 00182 pass arguments explicitly: 00183 \code 00184 namespace vigra { 00185 template <class ImageIterator, class Accessor, class FUNCTOR> 00186 void 00187 initImageWithFunctor(ImageIterator upperleft, ImageIterator lowerright, 00188 Accessor a, FUNCTOR f); 00189 } 00190 \endcode 00191 00192 use argument objects in conjuction with \ref ArgumentObjectFactories: 00193 \code 00194 namespace vigra { 00195 template <class ImageIterator, class Accessor, class FUNCTOR> 00196 void 00197 initImageWithFunctor(triple<ImageIterator, ImageIterator, Accessor> img, FUNCTOR f); 00198 } 00199 \endcode 00200 00201 <b> Usage:</b> 00202 00203 <b>\#include</b> "<a href="initimage_8hxx-source.html">vigra/initimage.hxx</a>"<br> 00204 Namespace: vigra 00205 00206 \code 00207 struct Counter { 00208 Counter() : count(0) {} 00209 00210 int operator()() const { return count++; } 00211 00212 mutable int count; 00213 }; 00214 00215 vigra::IImage img(100, 100); 00216 00217 // write the current count in every pixel 00218 vigra::initImageWithFunctor(destImageRange(img), Counter()); 00219 \endcode 00220 00221 <b> Required Interface:</b> 00222 00223 \code 00224 ImageIterator upperleft, lowerright; 00225 ImageIterator::row_iterator ix = upperleft.rowIterator(); 00226 00227 Accessor accessor; 00228 Functor f; 00229 00230 accessor.set(f(), ix); 00231 \endcode 00232 00233 */ 00234 template <class ImageIterator, class Accessor, class FUNCTOR> 00235 void 00236 initImageWithFunctor(ImageIterator upperleft, ImageIterator lowerright, 00237 Accessor a, FUNCTOR f) 00238 { 00239 int w = lowerright.x - upperleft.x; 00240 00241 for(; upperleft.y < lowerright.y; ++upperleft.y) 00242 { 00243 initLineFunctor(upperleft.rowIterator(), 00244 upperleft.rowIterator() + w, a, f); 00245 } 00246 } 00247 00248 template <class ImageIterator, class Accessor, class FUNCTOR> 00249 inline 00250 void 00251 initImageWithFunctor(triple<ImageIterator, ImageIterator, Accessor> img, FUNCTOR f) 00252 { 00253 initImageWithFunctor(img.first, img.second, img.third, f); 00254 } 00255 00256 /********************************************************/ 00257 /* */ 00258 /* initImageIf */ 00259 /* */ 00260 /********************************************************/ 00261 00262 /** \brief Write value to pixel in the image if mask is true. 00263 00264 This function can be used to init a region-of-interest of the image. 00265 It uses an accessor to access the pixel data. 00266 00267 <b> Declarations:</b> 00268 00269 pass arguments explicitly: 00270 \code 00271 namespace vigra { 00272 template <class ImageIterator, class Accessor, 00273 class MaskImageIterator, class MaskAccessor, 00274 class VALUETYPE> 00275 void 00276 initImageIf(ImageIterator upperleft, ImageIterator lowerright, Accessor a, 00277 MaskImageIterator mask_upperleft, MaskAccessor ma, 00278 VALUETYPE v) 00279 } 00280 \endcode 00281 00282 use argument objects in conjuction with \ref ArgumentObjectFactories: 00283 \code 00284 namespace vigra { 00285 template <class ImageIterator, class Accessor, 00286 class MaskImageIterator, class MaskAccessor, 00287 class VALUETYPE> 00288 void 00289 initImageIf(triple<ImageIterator, ImageIterator, Accessor> img, 00290 pair<MaskImageIterator, MaskAccessor> mask, 00291 VALUETYPE v) 00292 } 00293 \endcode 00294 00295 <b> Usage:</b> 00296 00297 <b>\#include</b> "<a href="initimage_8hxx-source.html">vigra/initimage.hxx</a>"<br> 00298 Namespace: vigra 00299 00300 \code 00301 vigra::BImage img(100, 100); 00302 vigra::BImage mask(100, 100); 00303 00304 // zero the ROI 00305 vigra::initImageIf(destImageRange(img), 00306 maskImage(mask), 00307 vigra::NumericTraits<vigra::BImage::PixelType>::zero()); 00308 \endcode 00309 00310 <b> Required Interface:</b> 00311 00312 \code 00313 ImageIterator upperleft, lowerright; 00314 MaskImageIterator mask_upperleft; 00315 ImageIterator::row_iterator ix = upperleft.rowIterator(); 00316 MaskImageIterator::row_iterator mx = mask_upperleft.rowIterator(); 00317 00318 Accessor accessor; 00319 MaskAccessor mask_accessor; 00320 VALUETYPE v; 00321 00322 if(mask_accessor(mx)) accessor.set(v, ix); 00323 \endcode 00324 00325 */ 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 int w = lowerright.x - upperleft.x; 00335 00336 for(; upperleft.y < lowerright.y; ++upperleft.y, ++mask_upperleft.y) 00337 { 00338 initLineIf(upperleft.rowIterator(), 00339 upperleft.rowIterator() + w, a, 00340 mask_upperleft.rowIterator(), ma, v); 00341 } 00342 } 00343 00344 template <class ImageIterator, class Accessor, 00345 class MaskImageIterator, class MaskAccessor, 00346 class VALUETYPE> 00347 inline 00348 void 00349 initImageIf(triple<ImageIterator, ImageIterator, Accessor> img, 00350 pair<MaskImageIterator, MaskAccessor> mask, 00351 VALUETYPE v) 00352 { 00353 initImageIf(img.first, img.second, img.third, mask.first, mask.second, v); 00354 } 00355 00356 /********************************************************/ 00357 /* */ 00358 /* initImageBorder */ 00359 /* */ 00360 /********************************************************/ 00361 00362 /** \brief Write value to the specified border pixels in the image. 00363 00364 A pixel is initialized if its distance to the border 00365 is at most 'borderwidth'. 00366 It uses an accessor to access the pixel data. 00367 00368 <b> Declarations:</b> 00369 00370 pass arguments explicitly: 00371 \code 00372 namespace vigra { 00373 template <class ImageIterator, class Accessor, class VALUETYPE> 00374 void 00375 initImageBorder(ImageIterator upperleft, ImageIterator lowerright, 00376 Accessor a, int border_width, VALUETYPE v) 00377 } 00378 \endcode 00379 00380 use argument objects in conjuction with \ref ArgumentObjectFactories: 00381 \code 00382 namespace vigra { 00383 template <class ImageIterator, class Accessor, class VALUETYPE> 00384 void 00385 initImageBorder(triple<ImageIterator, ImageIterator, Accessor> img, 00386 int border_width, VALUETYPE v) 00387 } 00388 \endcode 00389 00390 <b> Usage:</b> 00391 00392 <b>\#include</b> "<a href="initimage_8hxx-source.html">vigra/initimage.hxx</a>"<br> 00393 Namespace: vigra 00394 00395 \code 00396 vigra::BImage img(100, 100); 00397 00398 // zero a border of 5 pixel 00399 vigra::initImageBorder(destImageRange(img), 00400 5, vigra::NumericTraits<vigra::BImage::PixelType>::zero()); 00401 \endcode 00402 00403 <b> Required Interface:</b> 00404 00405 see \ref initImage() 00406 00407 */ 00408 template <class ImageIterator, class Accessor, class VALUETYPE> 00409 inline 00410 void 00411 initImageBorder(ImageIterator upperleft, ImageIterator lowerright, 00412 Accessor a, int border_width, VALUETYPE v) 00413 { 00414 int w = lowerright.x - upperleft.x; 00415 int h = lowerright.y - upperleft.y; 00416 00417 int hb = (border_width > h) ? h : border_width; 00418 int wb = (border_width > w) ? w : border_width; 00419 00420 initImage(upperleft, upperleft+Diff2D(w,hb), a, v); 00421 initImage(upperleft, upperleft+Diff2D(wb,h), a, v); 00422 initImage(upperleft+Diff2D(0,h-hb), lowerright, a, v); 00423 initImage(upperleft+Diff2D(w-wb,0), lowerright, a, v); 00424 } 00425 00426 template <class ImageIterator, class Accessor, class VALUETYPE> 00427 inline 00428 void 00429 initImageBorder(triple<ImageIterator, ImageIterator, Accessor> img, 00430 int border_width, VALUETYPE v) 00431 { 00432 initImageBorder(img.first, img.second, img.third, border_width, v); 00433 } 00434 00435 //@} 00436 00437 00438 } // namespace vigra 00439 00440 #endif // VIGRA_INITIMAGE_HXX
© Ullrich Köthe (koethe@informatik.uni-hamburg.de) |
html generated using doxygen and Python
|