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

initimage.hxx VIGRA

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 #include "multi_shape.hxx"
44 
45 namespace vigra {
46 
47 /** \addtogroup InitAlgo Algorithms to Initialize Images
48 
49  Init images or image borders
50 */
51 //@{
52 
53 /********************************************************/
54 /* */
55 /* initLine */
56 /* */
57 /********************************************************/
58 
59 template <class DestIterator, class DestAccessor, class VALUETYPE>
60 inline void
61 initLineImpl(DestIterator d, DestIterator dend, DestAccessor dest,
62  VALUETYPE const & v, VigraFalseType)
63 {
64  for(; d != dend; ++d)
65  dest.set(v, d);
66 }
67 
68 template <class DestIterator, class DestAccessor, class FUNCTOR>
69 inline void
70 initLineImpl(DestIterator d, DestIterator dend, DestAccessor dest,
71  FUNCTOR const & f, VigraTrueType)
72 {
73  for(; d != dend; ++d)
74  dest.set(f(), d);
75 }
76 
77 template <class DestIterator, class DestAccessor, class VALUETYPE>
78 inline void
79 initLine(DestIterator d, DestIterator dend, DestAccessor dest,
80  VALUETYPE const & v)
81 {
82  initLineImpl(d, dend, dest, v, typename FunctorTraits<VALUETYPE>::isInitializer());
83 }
84 
85 template <class DestIterator, class DestAccessor, class FUNCTOR>
86 inline void
87 initLineFunctor(DestIterator d, DestIterator dend, DestAccessor dest,
88  FUNCTOR & f)
89 {
90  for(; d != dend; ++d)
91  dest.set(f(), d);
92 }
93 
94 template <class DestIterator, class DestAccessor,
95  class MaskIterator, class MaskAccessor,
96  class VALUETYPE>
97 inline void
98 initLineIfImpl(DestIterator d, DestIterator dend, DestAccessor dest,
99  MaskIterator m, MaskAccessor mask,
100  VALUETYPE const & v, VigraFalseType)
101 {
102  for(; d != dend; ++d, ++m)
103  if(mask(m))
104  dest.set(v, d);
105 }
106 
107 template <class DestIterator, class DestAccessor,
108  class MaskIterator, class MaskAccessor,
109  class FUNCTOR>
110 inline void
111 initLineIfImpl(DestIterator d, DestIterator dend, DestAccessor dest,
112  MaskIterator m, MaskAccessor mask,
113  FUNCTOR const & f, VigraTrueType)
114 {
115  for(; d != dend; ++d, ++m)
116  if(mask(m))
117  dest.set(f(), d);
118 }
119 
120 template <class DestIterator, class DestAccessor,
121  class MaskIterator, class MaskAccessor,
122  class VALUETYPE>
123 inline void
124 initLineIf(DestIterator d, DestIterator dend, DestAccessor dest,
125  MaskIterator m, MaskAccessor mask,
126  VALUETYPE const & v)
127 {
128  initLineIfImpl(d, dend, dest, m, mask, v, typename FunctorTraits<VALUETYPE>::isInitializer());
129 }
130 
131 template <class DestIterator, class DestAccessor,
132  class MaskIterator, class MaskAccessor,
133  class FUNCTOR>
134 inline void
135 initLineFunctorIf(DestIterator d, DestIterator dend, DestAccessor dest,
136  MaskIterator m, MaskAccessor mask,
137  FUNCTOR & f)
138 {
139  for(; d != dend; ++d, ++m)
140  if(mask(m))
141  dest.set(f(), d);
142 }
143 
144 /********************************************************/
145 /* */
146 /* initImage */
147 /* */
148 /********************************************************/
149 
150 /** \brief Write a value to every pixel in an image or rectangular ROI.
151 
152  This function can be used to init the image.
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  Function \ref initMultiArray() implements the same functionality for arbitrary dimensional
161  arrays. In many situations, the assignment functions of \ref vigra::MultiArrayView offer
162  a simpler and more readable alternative to the init functions.
163 
164  <b> Declarations:</b>
165 
166  pass 2D array views:
167  \code
168  namespace vigra {
169  template <class T, class S, class VALUETYPE>
170  void
171  initImage(MultiArrayView<2, T, S> img, VALUETYPE const & v);
172 
173  template <class T, class S, class FUNCTOR>
174  void
175  initImage(MultiArrayView<2, T, S> img, FUNCTOR const & v);
176  }
177  \endcode
178 
179  \deprecatedAPI{initImage}
180  pass \ref ImageIterators and \ref DataAccessors :
181  \code
182  namespace vigra {
183  template <class ImageIterator, class Accessor, class VALUETYPE>
184  void initImage(ImageIterator upperleft, ImageIterator lowerright,
185  Accessor a, VALUETYPE const & v);
186 
187  template <class ImageIterator, class Accessor, class FUNCTOR>
188  void initImage(ImageIterator upperleft, ImageIterator lowerright,
189  Accessor a, FUNCTOR const & v);
190  }
191  \endcode
192  use argument objects in conjunction with \ref ArgumentObjectFactories :
193  \code
194  namespace vigra {
195  template <class ImageIterator, class Accessor, class VALUETYPE>
196  void initImage(triple<ImageIterator, ImageIterator, Accessor> img, VALUETYPE const & v);
197 
198  template <class ImageIterator, class Accessor, class FUNCTOR>
199  void initImage(triple<ImageIterator, ImageIterator, Accessor> img, FUNCTOR const & v);
200  }
201  \endcode
202  \deprecatedEnd
203 
204  <b> Usage:</b>
205 
206  <b>\#include</b> <vigra/initimage.hxx><br>
207  Namespace: vigra
208 
209  Initialize with a constant:
210  \code
211  MultiArray<2, unsigned char> img(100, 100);
212 
213  // init the image with the value 128
214  initImage(img, 128);
215 
216  // init the interior with the value 1
217  initImage(img.subarray(Shape2(10), Shape2(-10)), 1);
218 
219  // equivalent to
220  img = 128;
221  img.init(128);
222  img.subarray(Shape2(10), Shape2(-10)) = 1;
223  \endcode
224 
225  Initialize with a functor:
226  \code
227  struct Counter {
228  Counter() : count(0) {}
229 
230  int operator()() const { return count++; }
231 
232  mutable int count;
233  };
234 
235  MultiArray<2, int> img(100, 100);
236 
237  // write the current count in every pixel
238  initImage(img, Counter());
239 
240  // equivalent to
241  #include <vigra/algorithm.hxx>
242 
243  linearSequence(img.begin(), img.end());
244  \endcode
245 
246  \deprecatedUsage{initImage}
247  \code
248  vigra::BImage img(100, 100);
249 
250  // init the image with the value 128
251  vigra::initImage(destImageRange(img), 128);
252 
253  // Initialize with a functor:
254  struct Counter {
255  Counter() : count(0) {}
256 
257  int operator()() const { return count++; }
258 
259  mutable int count;
260  };
261 
262  // write the current count in every pixel
263  vigra::initImage(destImageRange(img), Counter());
264  \endcode
265  <b> Required Interface:</b>
266  \code
267  ImageIterator upperleft, lowerright;
268  ImageIterator::row_iterator ix = upperleft.rowIterator();
269 
270  Accessor accessor;
271  VALUETYPE v;
272 
273  accessor.set(v, ix);
274  \endcode
275  \deprecatedEnd
276 */
277 doxygen_overloaded_function(template <...> void initImage)
278 
279 template <class ImageIterator, class Accessor, class VALUETYPE>
280 void
281 initImage(ImageIterator upperleft, ImageIterator lowerright,
282  Accessor a, VALUETYPE const & v)
283 {
284  int w = lowerright.x - upperleft.x;
285 
286  for(; upperleft.y < lowerright.y; ++upperleft.y)
287  {
288  initLineImpl(upperleft.rowIterator(), upperleft.rowIterator() + w, a,
289  v, typename FunctorTraits<VALUETYPE>::isInitializer());
290  }
291 }
292 
293 template <class ImageIterator, class Accessor, class VALUETYPE>
294 inline void
295 initImage(triple<ImageIterator, ImageIterator, Accessor> img, VALUETYPE const & v)
296 {
297  initImage(img.first, img.second, img.third, v);
298 }
299 
300 template <class T, class S, class VALUETYPE>
301 inline void
302 initImage(MultiArrayView<2, T, S> img, VALUETYPE const & v)
303 {
304  initImage(destImageRange(img), v);
305 }
306 
307 /********************************************************/
308 /* */
309 /* initImageWithFunctor */
310 /* */
311 /********************************************************/
312 
313 /** \brief Write the result of a functor call to every pixel in an image or rectangular ROI.
314 
315  This function can be used to init the image by calling the given
316  functor for each pixel. The functor is
317  passed by reference, so that its internal state can be updated in each call.
318 
319  <b> Declarations:</b>
320 
321  pass 2D array views:
322  \code
323  namespace vigra {
324  template <class T, class S, class FUNCTOR>
325  void
326  initImageWithFunctor(MultiArrayView<2, T, S> img, FUNCTOR & f);
327  }
328  \endcode
329 
330  \deprecatedAPI{initImageWithFunctor}
331  pass \ref ImageIterators and \ref DataAccessors :
332  \code
333  namespace vigra {
334  template <class ImageIterator, class Accessor, class FUNCTOR>
335  void
336  initImageWithFunctor(ImageIterator upperleft, ImageIterator lowerright,
337  Accessor a, FUNCTOR & f);
338  }
339  \endcode
340  use argument objects in conjunction with \ref ArgumentObjectFactories :
341  \code
342  namespace vigra {
343  template <class ImageIterator, class Accessor, class FUNCTOR>
344  void
345  initImageWithFunctor(triple<ImageIterator, ImageIterator, Accessor> img, FUNCTOR & f);
346  }
347  \endcode
348  \deprecatedEnd
349 
350  <b> Usage:</b>
351 
352  <b>\#include</b> <vigra/initimage.hxx><br>
353  Namespace: vigra
354 
355  \code
356  struct Counter {
357  Counter() : count(0) {}
358 
359  int operator()() const { return count++; }
360 
361  int count;
362  };
363 
364  MultiArray<2, int> img(100, 100);
365 
366  // write the current count in every pixel
367  Counter counter;
368  initImageWithFunctor(img, counter);
369 
370  // equivalent to
371  #include <vigra/algorithm.hxx>
372 
373  linearSequence(img.begin(), img.end());
374  \endcode
375 
376  \deprecatedUsage{initImageWithFunctor}
377  \code
378  struct Counter {
379  Counter() : count(0) {}
380 
381  int operator()() const { return count++; }
382 
383  mutable int count;
384  };
385 
386  vigra::IImage img(100, 100);
387 
388  // write the current count in every pixel
389  Counter counter;
390  vigra::initImageWithFunctor(destImageRange(img), counter);
391  \endcode
392  <b> Required Interface:</b>
393  \code
394  ImageIterator upperleft, lowerright;
395  ImageIterator::row_iterator ix = upperleft.rowIterator();
396 
397  Accessor accessor;
398  Functor f;
399 
400  accessor.set(f(), ix);
401  \endcode
402  \deprecatedEnd
403 */
404 doxygen_overloaded_function(template <...> void initImageWithFunctor)
405 
406 template <class ImageIterator, class Accessor, class FUNCTOR>
407 void
408 initImageWithFunctor(ImageIterator upperleft, ImageIterator lowerright,
409  Accessor a, FUNCTOR & f)
410 {
411  int w = lowerright.x - upperleft.x;
412 
413  for(; upperleft.y < lowerright.y; ++upperleft.y)
414  {
415  initLineFunctor(upperleft.rowIterator(), upperleft.rowIterator() + w, a, f);
416  }
417 }
418 
419 template <class ImageIterator, class Accessor, class FUNCTOR>
420 inline void
421 initImageWithFunctor(triple<ImageIterator, ImageIterator, Accessor> img, FUNCTOR & f)
422 {
423  initImageWithFunctor(img.first, img.second, img.third, f);
424 }
425 
426 template <class T, class S, class FUNCTOR>
427 inline void
428 initImageWithFunctor(MultiArrayView<2, T, S> img, FUNCTOR & f)
429 {
430  initImageWithFunctor(destImageRange(img), f);
431 }
432 
433 /********************************************************/
434 /* */
435 /* initImageIf */
436 /* */
437 /********************************************************/
438 
439 /** \brief Write value to pixel in the image if mask is true.
440 
441  This function can be used to init a region-of-interest of the image.
442 
443  The initial value can either be a constant of appropriate type (compatible with
444  the destination's value_type), or a functor with compatible result_type. These two
445  cases are automatically distinguished when <tt>FunctorTraits<FUNCTOR>::isInitializer</tt>
446  yields <tt>VigraTrueType</tt>. Since the functor is passed by <tt>const</tt> reference, its
447  <tt>operator()</tt> must be const, and its internal state may need to be <tt>mutable</tt>.
448 
449  <b> Declarations:</b>
450 
451  pass 2D array views:
452  \code
453  namespace vigra {
454  template <class T, class S,
455  class TM, class SM,
456  class VALUETYPE>
457  void
458  initImageIf(MultiArrayView<2, T, S> img,
459  MultiArrayView<2, TM, SM> const & mask,
460  VALUETYPE const & v);
461 
462  template <class T, class S,
463  class TM, class SM,
464  class FUNCTOR>
465  void
466  initImageIf(MultiArrayView<2, T, S> img,
467  MultiArrayView<2, TM, SM> const & mask,
468  FUNCTOR const & v);
469  }
470  \endcode
471  \deprecatedAPI{initImageIf}
472  pass \ref ImageIterators and \ref DataAccessors :
473  \code
474  namespace vigra {
475  template <class ImageIterator, class Accessor,
476  class MaskImageIterator, class MaskAccessor,
477  class VALUETYPE>
478  void initImageIf(ImageIterator upperleft, ImageIterator lowerright, Accessor a,
479  MaskImageIterator mask_upperleft, MaskAccessor ma,
480  VALUETYPE const & v);
481 
482  template <class ImageIterator, class Accessor,
483  class MaskImageIterator, class MaskAccessor,
484  class FUNCTOR>
485  void initImageIf(ImageIterator upperleft, ImageIterator lowerright, Accessor a,
486  MaskImageIterator mask_upperleft, MaskAccessor ma,
487  FUNCTOR const & v);
488  }
489  \endcode
490  use argument objects in conjunction with \ref ArgumentObjectFactories :
491  \code
492  namespace vigra {
493  template <class ImageIterator, class Accessor,
494  class MaskImageIterator, class MaskAccessor,
495  class VALUETYPE>
496  void initImageIf(triple<ImageIterator, ImageIterator, Accessor> img,
497  pair<MaskImageIterator, MaskAccessor> mask,
498  VALUETYPE const & v);
499 
500  template <class ImageIterator, class Accessor,
501  class MaskImageIterator, class MaskAccessor,
502  class FUNCTOR>
503  void initImageIf(triple<ImageIterator, ImageIterator, Accessor> img,
504  pair<MaskImageIterator, MaskAccessor> mask,
505  FUNCTOR const & v);
506  }
507  \endcode
508  \deprecatedEnd
509 
510  <b> Usage:</b>
511 
512  <b>\#include</b> <vigra/initimage.hxx><br>
513  Namespace: vigra
514 
515  \code
516  MultiArray<2, RGBValue<unsigned char> > img(100, 100),
517  MultiArray<2, unsigned char> mask(100, 100);
518  ... // init the ROI mask
519 
520  // set the ROI to one
521  initImageIf(img, mask,
522  NumericTraits<RGBValue<unsigned char> >::one());
523  \endcode
524 
525  \deprecatedUsage{initImageIf}
526  \code
527  vigra::BImage img(100, 100);
528  vigra::BImage mask(100, 100);
529 
530  // zero the ROI
531  vigra::initImageIf(destImageRange(img),
532  maskImage(mask),
533  vigra::NumericTraits<vigra::BImage::PixelType>::zero());
534  \endcode
535  <b> Required Interface:</b>
536  \code
537  ImageIterator upperleft, lowerright;
538  MaskImageIterator mask_upperleft;
539  ImageIterator::row_iterator ix = upperleft.rowIterator();
540  MaskImageIterator::row_iterator mx = mask_upperleft.rowIterator();
541 
542  Accessor accessor;
543  MaskAccessor mask_accessor;
544  VALUETYPE v;
545 
546  if(mask_accessor(mx)) accessor.set(v, ix);
547  \endcode
548  \deprecatedEnd
549 */
550 doxygen_overloaded_function(template <...> void initImageIf)
551 
552 template <class ImageIterator, class Accessor,
553  class MaskImageIterator, class MaskAccessor,
554  class VALUETYPE>
555 void
556 initImageIf(ImageIterator upperleft, ImageIterator lowerright, Accessor a,
557  MaskImageIterator mask_upperleft, MaskAccessor ma,
558  VALUETYPE const & v)
559 {
560  int w = lowerright.x - upperleft.x;
561 
562  for(; upperleft.y < lowerright.y; ++upperleft.y, ++mask_upperleft.y)
563  {
564  initLineIfImpl(upperleft.rowIterator(),
565  upperleft.rowIterator() + w, a,
566  mask_upperleft.rowIterator(), ma,
567  v, typename FunctorTraits<VALUETYPE>::isInitializer());
568  }
569 }
570 
571 template <class ImageIterator, class Accessor,
572  class MaskImageIterator, class MaskAccessor,
573  class VALUETYPE>
574 inline void
575 initImageIf(triple<ImageIterator, ImageIterator, Accessor> img,
576  pair<MaskImageIterator, MaskAccessor> mask,
577  VALUETYPE const & v)
578 {
579  initImageIf(img.first, img.second, img.third, mask.first, mask.second, v);
580 }
581 
582 template <class T, class S,
583  class TM, class SM,
584  class VALUETYPE>
585 inline void
586 initImageIf(MultiArrayView<2, T, S> img,
587  MultiArrayView<2, TM, SM> const & mask,
588  VALUETYPE const & v)
589 {
590  vigra_precondition(img.shape() == mask.shape(),
591  "initImageIf(): shape mismatch between input and mask.");
592  initImageIf(destImageRange(img), maskImage(mask), v);
593 }
594 
595 /********************************************************/
596 /* */
597 /* initImageBorder */
598 /* */
599 /********************************************************/
600 
601 /** \brief Write value to the specified border pixels in the image.
602 
603  A pixel is initialized if its distance to the border
604  is at most 'borderwidth'.
605 
606  The initial value can either be a constant of appropriate type (compatible with
607  the destination's value_type), or a functor with compatible result_type. These two
608  cases are automatically distinguished when <tt>FunctorTraits<FUNCTOR>::isInitializer</tt>
609  yields <tt>VigraTrueType</tt>. Since the functor is passed by <tt>const</tt> reference, its
610  <tt>operator()</tt> must be const, and its internal state may need to be <tt>mutable</tt>.
611 
612  <b> Declarations:</b>
613 
614  pass 2D array views:
615  \code
616  namespace vigra {
617  template <class T, class S, class VALUETYPE>
618  void
619  initImageBorder(MultiArrayView<2, T, S> img,
620  int border_width, VALUETYPE const & v);
621 
622  template <class T, class S, class FUNCTOR>
623  void
624  initImageBorder(MultiArrayView<2, T, S> img,
625  int border_width, FUNCTOR const & v);
626  }
627  \endcode
628 
629  \deprecatedAPI{initImageBorder}
630  pass \ref ImageIterators and \ref DataAccessors :
631  \code
632  namespace vigra {
633  template <class ImageIterator, class Accessor, class VALUETYPE>
634  void initImageBorder(ImageIterator upperleft, ImageIterator lowerright, Accessor a,
635  int border_width, VALUETYPE const & v);
636 
637  template <class ImageIterator, class Accessor, class FUNCTOR>
638  void initImageBorder(ImageIterator upperleft, ImageIterator lowerright, Accessor a,
639  int border_width, FUNCTOR const & v);
640  }
641  \endcode
642  use argument objects in conjunction with \ref ArgumentObjectFactories :
643  \code
644  namespace vigra {
645  template <class ImageIterator, class Accessor, class VALUETYPE>
646  void initImageBorder(triple<ImageIterator, ImageIterator, Accessor> img,
647  int border_width, VALUETYPE const & v);
648 
649  template <class ImageIterator, class Accessor, class FUNCTOR>
650  void initImageBorder(triple<ImageIterator, ImageIterator, Accessor> img,
651  int border_width, FUNCTOR const & v);
652  }
653  \endcode
654  \deprecatedEnd
655 
656  <b> Usage:</b>
657 
658  <b>\#include</b> <vigra/initimage.hxx><br>
659  Namespace: vigra
660 
661  \code
662  #include <vigra/random.hxx>
663 
664  MultiArray<2, int> img(100, 100);
665 
666  // fill a border of 5 pixels with random numbers
667  initImageBorder(img, 5, MersenneTwister());
668  \endcode
669 
670  \deprecatedUsage{initImageBorder}
671  \code
672  vigra::BImage img(100, 100);
673 
674  // zero a border of 5 pixel
675  vigra::initImageBorder(destImageRange(img),
676  5, vigra::NumericTraits<vigra::BImage::PixelType>::zero());
677  \endcode
678  <b> Required Interface:</b>
679  <br/>see \ref initImage()
680  \deprecatedEnd
681 */
682 doxygen_overloaded_function(template <...> void initImageBorder)
683 
684 template <class ImageIterator, class Accessor, class VALUETYPE>
685 inline
686 void
687 initImageBorder(ImageIterator upperleft, ImageIterator lowerright,
688  Accessor a, int border_width, VALUETYPE const & v)
689 {
690  int w = lowerright.x - upperleft.x;
691  int h = lowerright.y - upperleft.y;
692 
693  int hb = (border_width > h) ? h : border_width;
694  int wb = (border_width > w) ? w : border_width;
695 
696  initImage(upperleft, upperleft+Diff2D(w,hb), a, v);
697  initImage(upperleft, upperleft+Diff2D(wb,h), a, v);
698  initImage(upperleft+Diff2D(0,h-hb), lowerright, a, v);
699  initImage(upperleft+Diff2D(w-wb,0), lowerright, a, v);
700 }
701 
702 template <class ImageIterator, class Accessor, class VALUETYPE>
703 inline void
704 initImageBorder(triple<ImageIterator, ImageIterator, Accessor> img,
705  int border_width, VALUETYPE const & v)
706 {
707  initImageBorder(img.first, img.second, img.third, border_width, v);
708 }
709 
710 template <class T, class S, class VALUETYPE>
711 inline void
712 initImageBorder(MultiArrayView<2, T, S> img,
713  int border_width, VALUETYPE const & v)
714 {
715  initImageBorder(destImageRange(img), border_width, v);
716 }
717 
718 //@}
719 
720 
721 } // namespace vigra
722 
723 #endif // VIGRA_INITIMAGE_HXX
vigra::initImage
void initImage(...)
Write a value to every pixel in an image or rectangular ROI.
vigra::initImageWithFunctor
void initImageWithFunctor(...)
Write the result of a functor call to every pixel in an image or rectangular ROI. ...
vigra::doxygen_overloaded_function
doxygen_overloaded_function(template<...> void separableConvolveBlockwise) template< unsigned int N
Separated convolution on ChunkedArrays.
vigra::initImageBorder
void initImageBorder(...)
Write value to the specified border pixels in the image.
vigra::initImageIf
void initImageIf(...)
Write value to pixel in the image if mask is true.

© 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.11.1 (Fri May 19 2017)