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

initimage.hxx
1 /************************************************************************/
2 /* */
3 /* Copyright 1998-2002 by Ullrich Koethe */
4 /* */
5 /* This file is part of the VIGRA computer vision library. */
6 /* The VIGRA Website is */
7 /* http://hci.iwr.uni-heidelberg.de/vigra/ */
8 /* Please direct questions, bug reports, and contributions to */
9 /* ullrich.koethe@iwr.uni-heidelberg.de or */
10 /* vigra@informatik.uni-hamburg.de */
11 /* */
12 /* Permission is hereby granted, free of charge, to any person */
13 /* obtaining a copy of this software and associated documentation */
14 /* files (the "Software"), to deal in the Software without */
15 /* restriction, including without limitation the rights to use, */
16 /* copy, modify, merge, publish, distribute, sublicense, and/or */
17 /* sell copies of the Software, and to permit persons to whom the */
18 /* Software is furnished to do so, subject to the following */
19 /* conditions: */
20 /* */
21 /* The above copyright notice and this permission notice shall be */
22 /* included in all copies or substantial portions of the */
23 /* Software. */
24 /* */
25 /* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND */
26 /* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES */
27 /* OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND */
28 /* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT */
29 /* HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, */
30 /* WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING */
31 /* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR */
32 /* OTHER DEALINGS IN THE SOFTWARE. */
33 /* */
34 /************************************************************************/
35 
36 
37 #ifndef VIGRA_INITIMAGE_HXX
38 #define VIGRA_INITIMAGE_HXX
39 
40 #include "utilities.hxx"
41 #include "iteratortraits.hxx"
42 #include "functortraits.hxx"
43 
44 namespace vigra {
45 
46 /** \addtogroup InitAlgo Algorithms to Initialize Images
47 
48  Init images or image borders
49 */
50 //@{
51 
52 /********************************************************/
53 /* */
54 /* initLine */
55 /* */
56 /********************************************************/
57 
58 template <class DestIterator, class DestAccessor, class VALUETYPE>
59 inline void
60 initLineImpl(DestIterator d, DestIterator dend, DestAccessor dest,
61  VALUETYPE const & v, VigraFalseType)
62 {
63  for(; d != dend; ++d)
64  dest.set(v, d);
65 }
66 
67 template <class DestIterator, class DestAccessor, class FUNCTOR>
68 inline void
69 initLineImpl(DestIterator d, DestIterator dend, DestAccessor dest,
70  FUNCTOR const & f, VigraTrueType)
71 {
72  for(; d != dend; ++d)
73  dest.set(f(), d);
74 }
75 
76 template <class DestIterator, class DestAccessor, class VALUETYPE>
77 inline void
78 initLine(DestIterator d, DestIterator dend, DestAccessor dest,
79  VALUETYPE const & v)
80 {
81  initLineImpl(d, dend, dest, v, typename FunctorTraits<VALUETYPE>::isInitializer());
82 }
83 
84 template <class DestIterator, class DestAccessor, class FUNCTOR>
85 inline void
86 initLineFunctor(DestIterator d, DestIterator dend, DestAccessor dest,
87  FUNCTOR & f)
88 {
89  for(; d != dend; ++d)
90  dest.set(f(), d);
91 }
92 
93 template <class DestIterator, class DestAccessor,
94  class MaskIterator, class MaskAccessor,
95  class VALUETYPE>
96 inline void
97 initLineIfImpl(DestIterator d, DestIterator dend, DestAccessor dest,
98  MaskIterator m, MaskAccessor mask,
99  VALUETYPE const & v, VigraFalseType)
100 {
101  for(; d != dend; ++d, ++m)
102  if(mask(m))
103  dest.set(v, d);
104 }
105 
106 template <class DestIterator, class DestAccessor,
107  class MaskIterator, class MaskAccessor,
108  class FUNCTOR>
109 inline void
110 initLineIfImpl(DestIterator d, DestIterator dend, DestAccessor dest,
111  MaskIterator m, MaskAccessor mask,
112  FUNCTOR const & f, VigraTrueType)
113 {
114  for(; d != dend; ++d, ++m)
115  if(mask(m))
116  dest.set(f(), d);
117 }
118 
119 template <class DestIterator, class DestAccessor,
120  class MaskIterator, class MaskAccessor,
121  class VALUETYPE>
122 inline void
123 initLineIf(DestIterator d, DestIterator dend, DestAccessor dest,
124  MaskIterator m, MaskAccessor mask,
125  VALUETYPE const & v)
126 {
127  initLineIfImpl(d, dend, dest, m, mask, v, typename FunctorTraits<VALUETYPE>::isInitializer());
128 }
129 
130 template <class DestIterator, class DestAccessor,
131  class MaskIterator, class MaskAccessor,
132  class FUNCTOR>
133 inline void
134 initLineFunctorIf(DestIterator d, DestIterator dend, DestAccessor dest,
135  MaskIterator m, MaskAccessor mask,
136  FUNCTOR & f)
137 {
138  for(; d != dend; ++d, ++m)
139  if(mask(m))
140  dest.set(f(), d);
141 }
142 
143 /********************************************************/
144 /* */
145 /* initImage */
146 /* */
147 /********************************************************/
148 
149 /** \brief Write a value to every pixel in an image or rectangular ROI.
150 
151  This function can be used to init the image.
152  It uses an accessor to access the pixel data.
153 
154  The initial value can either be a constant of appropriate type (compatible with
155  the destination's value_type), or a functor with compatible result_type. These two
156  cases are automatically distinguished when <tt>FunctorTraits<FUNCTOR>::isInitializer</tt>
157  yields <tt>VigraTrueType</tt>. Since the functor is passed by <tt>const</tt> reference, its
158  <tt>operator()</tt> must be const, and its internal state may need to be <tt>mutable</tt>.
159 
160  <b> Declarations:</b>
161 
162  pass arguments explicitly:
163  \code
164  namespace vigra {
165  template <class ImageIterator, class Accessor, class VALUETYPE>
166  void initImage(ImageIterator upperleft, ImageIterator lowerright,
167  Accessor a, VALUETYPE const & v);
168 
169  template <class ImageIterator, class Accessor, class FUNCTOR>
170  void initImage(ImageIterator upperleft, ImageIterator lowerright,
171  Accessor a, FUNCTOR const & v);
172  }
173  \endcode
174 
175  use argument objects in conjunction with \ref ArgumentObjectFactories :
176  \code
177  namespace vigra {
178  template <class ImageIterator, class Accessor, class VALUETYPE>
179  void initImage(triple<ImageIterator, ImageIterator, Accessor> img, VALUETYPE const & v);
180 
181  template <class ImageIterator, class Accessor, class FUNCTOR>
182  void initImage(triple<ImageIterator, ImageIterator, Accessor> img, FUNCTOR const & v);
183  }
184  \endcode
185 
186  <b> Usage:</b>
187 
188  <b>\#include</b> <vigra/initimage.hxx><br>
189  Namespace: vigra
190 
191  Initialize with a constant:
192 
193  \code
194  vigra::BImage img(100, 100);
195 
196  // init the image with the value 128
197  vigra::initImage(destImageRange(img), 128);
198  \endcode
199 
200  Initialize with a functor:
201 
202  \code
203  struct Counter {
204  Counter() : count(0) {}
205 
206  int operator()() const { return count++; }
207 
208  mutable int count;
209  };
210 
211  vigra::IImage img(100, 100);
212 
213  // write the current count in every pixel
214  vigra::initImage(destImageRange(img), Counter());
215  \endcode
216 
217 
218  <b> Required Interface:</b>
219 
220  \code
221  ImageIterator upperleft, lowerright;
222  ImageIterator::row_iterator ix = upperleft.rowIterator();
223 
224  Accessor accessor;
225  VALUETYPE v;
226 
227  accessor.set(v, ix);
228  \endcode
229 
230 */
231 doxygen_overloaded_function(template <...> void initImage)
232 
233 template <class ImageIterator, class Accessor, class VALUETYPE>
234 void
235 initImage(ImageIterator upperleft, ImageIterator lowerright,
236  Accessor a, VALUETYPE const & v)
237 {
238  int w = lowerright.x - upperleft.x;
239 
240  for(; upperleft.y < lowerright.y; ++upperleft.y)
241  {
242  initLineImpl(upperleft.rowIterator(), upperleft.rowIterator() + w, a,
243  v, typename FunctorTraits<VALUETYPE>::isInitializer());
244  }
245 }
246 
247 template <class ImageIterator, class Accessor, class VALUETYPE>
248 inline
249 void
250 initImage(triple<ImageIterator, ImageIterator, Accessor> img, VALUETYPE const & v)
251 {
252  initImage(img.first, img.second, img.third, v);
253 }
254 
255 /********************************************************/
256 /* */
257 /* initImageWithFunctor */
258 /* */
259 /********************************************************/
260 
261 /** \brief Write the result of a functor call to every pixel in an image or rectangular ROI.
262 
263  This function can be used to init the image by calling the given
264  functor for each pixel. It uses an accessor to access the pixel data. The functor is
265  passed by reference, so that its internal state can be updated in each call.
266 
267  <b> Declarations:</b>
268 
269  pass arguments explicitly:
270  \code
271  namespace vigra {
272  template <class ImageIterator, class Accessor, class FUNCTOR>
273  void
274  initImageWithFunctor(ImageIterator upperleft, ImageIterator lowerright,
275  Accessor a, FUNCTOR & f);
276  }
277  \endcode
278 
279  use argument objects in conjunction with \ref ArgumentObjectFactories :
280  \code
281  namespace vigra {
282  template <class ImageIterator, class Accessor, class FUNCTOR>
283  void
284  initImageWithFunctor(triple<ImageIterator, ImageIterator, Accessor> img, FUNCTOR & f);
285  }
286  \endcode
287 
288  <b> Usage:</b>
289 
290  <b>\#include</b> <vigra/initimage.hxx><br>
291  Namespace: vigra
292 
293  \code
294  struct Counter {
295  Counter() : count(0) {}
296 
297  int operator()() const { return count++; }
298 
299  mutable int count;
300  };
301 
302  vigra::IImage img(100, 100);
303 
304  // write the current count in every pixel
305  Counter counter;
306  vigra::initImageWithFunctor(destImageRange(img), counter);
307  \endcode
308 
309  <b> Required Interface:</b>
310 
311  \code
312  ImageIterator upperleft, lowerright;
313  ImageIterator::row_iterator ix = upperleft.rowIterator();
314 
315  Accessor accessor;
316  Functor f;
317 
318  accessor.set(f(), ix);
319  \endcode
320 
321 */
322 doxygen_overloaded_function(template <...> void initImageWithFunctor)
323 
324 template <class ImageIterator, class Accessor, class FUNCTOR>
325 void
326 initImageWithFunctor(ImageIterator upperleft, ImageIterator lowerright,
327  Accessor a, FUNCTOR & f)
328 {
329  int w = lowerright.x - upperleft.x;
330 
331  for(; upperleft.y < lowerright.y; ++upperleft.y)
332  {
333  initLineFunctor(upperleft.rowIterator(), upperleft.rowIterator() + w, a, f);
334  }
335 }
336 
337 template <class ImageIterator, class Accessor, class FUNCTOR>
338 inline
339 void
340 initImageWithFunctor(triple<ImageIterator, ImageIterator, Accessor> img, FUNCTOR & f)
341 {
342  initImageWithFunctor(img.first, img.second, img.third, f);
343 }
344 
345 /********************************************************/
346 /* */
347 /* initImageIf */
348 /* */
349 /********************************************************/
350 
351 /** \brief Write value to pixel in the image if mask is true.
352 
353  This function can be used to init a region-of-interest of the image.
354  It uses an accessor to access the pixel data.
355 
356  The initial value can either be a constant of appropriate type (compatible with
357  the destination's value_type), or a functor with compatible result_type. These two
358  cases are automatically distinguished when <tt>FunctorTraits<FUNCTOR>::isInitializer</tt>
359  yields <tt>VigraTrueType</tt>. Since the functor is passed by <tt>const</tt> reference, its
360  <tt>operator()</tt> must be const, and its internal state may need to be <tt>mutable</tt>.
361 
362  <b> Declarations:</b>
363 
364  pass arguments explicitly:
365  \code
366  namespace vigra {
367  template <class ImageIterator, class Accessor,
368  class MaskImageIterator, class MaskAccessor,
369  class VALUETYPE>
370  void initImageIf(ImageIterator upperleft, ImageIterator lowerright, Accessor a,
371  MaskImageIterator mask_upperleft, MaskAccessor ma,
372  VALUETYPE const & v);
373 
374  template <class ImageIterator, class Accessor,
375  class MaskImageIterator, class MaskAccessor,
376  class FUNCTOR>
377  void initImageIf(ImageIterator upperleft, ImageIterator lowerright, Accessor a,
378  MaskImageIterator mask_upperleft, MaskAccessor ma,
379  FUNCTOR const & v);
380  }
381  \endcode
382 
383  use argument objects in conjunction with \ref ArgumentObjectFactories :
384  \code
385  namespace vigra {
386  template <class ImageIterator, class Accessor,
387  class MaskImageIterator, class MaskAccessor,
388  class VALUETYPE>
389  void initImageIf(triple<ImageIterator, ImageIterator, Accessor> img,
390  pair<MaskImageIterator, MaskAccessor> mask,
391  VALUETYPE const & v);
392 
393  template <class ImageIterator, class Accessor,
394  class MaskImageIterator, class MaskAccessor,
395  class FUNCTOR>
396  void initImageIf(triple<ImageIterator, ImageIterator, Accessor> img,
397  pair<MaskImageIterator, MaskAccessor> mask,
398  FUNCTOR const & v);
399  }
400  \endcode
401 
402  <b> Usage:</b>
403 
404  <b>\#include</b> <vigra/initimage.hxx><br>
405  Namespace: vigra
406 
407  \code
408  vigra::BImage img(100, 100);
409  vigra::BImage mask(100, 100);
410 
411  // zero the ROI
412  vigra::initImageIf(destImageRange(img),
413  maskImage(mask),
414  vigra::NumericTraits<vigra::BImage::PixelType>::zero());
415  \endcode
416 
417  <b> Required Interface:</b>
418 
419  \code
420  ImageIterator upperleft, lowerright;
421  MaskImageIterator mask_upperleft;
422  ImageIterator::row_iterator ix = upperleft.rowIterator();
423  MaskImageIterator::row_iterator mx = mask_upperleft.rowIterator();
424 
425  Accessor accessor;
426  MaskAccessor mask_accessor;
427  VALUETYPE v;
428 
429  if(mask_accessor(mx)) accessor.set(v, ix);
430  \endcode
431 
432 */
433 doxygen_overloaded_function(template <...> void initImageIf)
434 
435 template <class ImageIterator, class Accessor,
436  class MaskImageIterator, class MaskAccessor,
437  class VALUETYPE>
438 void
439 initImageIf(ImageIterator upperleft, ImageIterator lowerright, Accessor a,
440  MaskImageIterator mask_upperleft, MaskAccessor ma,
441  VALUETYPE const & v)
442 {
443  int w = lowerright.x - upperleft.x;
444 
445  for(; upperleft.y < lowerright.y; ++upperleft.y, ++mask_upperleft.y)
446  {
447  initLineIfImpl(upperleft.rowIterator(),
448  upperleft.rowIterator() + w, a,
449  mask_upperleft.rowIterator(), ma,
450  v, typename FunctorTraits<VALUETYPE>::isInitializer());
451  }
452 }
453 
454 template <class ImageIterator, class Accessor,
455  class MaskImageIterator, class MaskAccessor,
456  class VALUETYPE>
457 inline
458 void
459 initImageIf(triple<ImageIterator, ImageIterator, Accessor> img,
460  pair<MaskImageIterator, MaskAccessor> mask,
461  VALUETYPE const & v)
462 {
463  initImageIf(img.first, img.second, img.third, mask.first, mask.second, v);
464 }
465 
466 /********************************************************/
467 /* */
468 /* initImageBorder */
469 /* */
470 /********************************************************/
471 
472 /** \brief Write value to the specified border pixels in the image.
473 
474  A pixel is initialized if its distance to the border
475  is at most 'borderwidth'. It uses an accessor to access the pixel data.
476 
477  The initial value can either be a constant of appropriate type (compatible with
478  the destination's value_type), or a functor with compatible result_type. These two
479  cases are automatically distinguished when <tt>FunctorTraits<FUNCTOR>::isInitializer</tt>
480  yields <tt>VigraTrueType</tt>. Since the functor is passed by <tt>const</tt> reference, its
481  <tt>operator()</tt> must be const, and its internal state may need to be <tt>mutable</tt>.
482 
483  <b> Declarations:</b>
484 
485  pass arguments explicitly:
486  \code
487  namespace vigra {
488  template <class ImageIterator, class Accessor, class VALUETYPE>
489  void initImageBorder(ImageIterator upperleft, ImageIterator lowerright, Accessor a,
490  int border_width, VALUETYPE const & v);
491 
492  template <class ImageIterator, class Accessor, class FUNCTOR>
493  void initImageBorder(ImageIterator upperleft, ImageIterator lowerright, Accessor a,
494  int border_width, FUNCTOR const & v);
495  }
496  \endcode
497 
498  use argument objects in conjunction with \ref ArgumentObjectFactories :
499  \code
500  namespace vigra {
501  template <class ImageIterator, class Accessor, class VALUETYPE>
502  void initImageBorder(triple<ImageIterator, ImageIterator, Accessor> img,
503  int border_width, VALUETYPE const & v);
504 
505  template <class ImageIterator, class Accessor, class FUNCTOR>
506  void initImageBorder(triple<ImageIterator, ImageIterator, Accessor> img,
507  int border_width, FUNCTOR const & v);
508  }
509  \endcode
510 
511  <b> Usage:</b>
512 
513  <b>\#include</b> <vigra/initimage.hxx><br>
514  Namespace: vigra
515 
516  \code
517  vigra::BImage img(100, 100);
518 
519  // zero a border of 5 pixel
520  vigra::initImageBorder(destImageRange(img),
521  5, vigra::NumericTraits<vigra::BImage::PixelType>::zero());
522  \endcode
523 
524  <b> Required Interface:</b>
525 
526  see \ref initImage()
527 
528 */
529 doxygen_overloaded_function(template <...> void initImageBorder)
530 
531 template <class ImageIterator, class Accessor, class VALUETYPE>
532 inline
533 void
534 initImageBorder(ImageIterator upperleft, ImageIterator lowerright,
535  Accessor a, int border_width, VALUETYPE const & v)
536 {
537  int w = lowerright.x - upperleft.x;
538  int h = lowerright.y - upperleft.y;
539 
540  int hb = (border_width > h) ? h : border_width;
541  int wb = (border_width > w) ? w : border_width;
542 
543  initImage(upperleft, upperleft+Diff2D(w,hb), a, v);
544  initImage(upperleft, upperleft+Diff2D(wb,h), a, v);
545  initImage(upperleft+Diff2D(0,h-hb), lowerright, a, v);
546  initImage(upperleft+Diff2D(w-wb,0), lowerright, a, v);
547 }
548 
549 template <class ImageIterator, class Accessor, class VALUETYPE>
550 inline
551 void
552 initImageBorder(triple<ImageIterator, ImageIterator, Accessor> img,
553  int border_width, VALUETYPE const & v)
554 {
555  initImageBorder(img.first, img.second, img.third, border_width, v);
556 }
557 
558 //@}
559 
560 
561 } // namespace vigra
562 
563 #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 (Wed Feb 27 2013)