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

combineimages.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_COMBINEIMAGES_HXX
38 #define VIGRA_COMBINEIMAGES_HXX
39 
40 #include "utilities.hxx"
41 #include "numerictraits.hxx"
42 #include "functortraits.hxx"
43 #include <cmath>
44 
45 namespace vigra {
46 
47 /** \addtogroup CombineAlgo Algorithms to Combine Images
48 
49  Apply functor to calculate a pixelwise transformation depending on multiple images.
50  Note that the binary functors of the STL may be used with these functions.
51 */
52 //@{
53 
54 /********************************************************/
55 /* */
56 /* combine...Lines */
57 /* */
58 /********************************************************/
59 
60 template <class SrcIterator1, class SrcAccessor1,
61  class SrcIterator2, class SrcAccessor2,
62  class DestIterator, class DestAccessor, class Functor>
63 void
64 combineTwoLines(SrcIterator1 s1,
65  SrcIterator1 s1end, SrcAccessor1 src1,
66  SrcIterator2 s2, SrcAccessor2 src2,
67  DestIterator d, DestAccessor dest,
68  Functor const & f)
69 {
70  for(; s1 != s1end; ++s1, ++s2, ++d)
71  dest.set(f(src1(s1), src2(s2)), d);
72 }
73 
74 template <class SrcIterator1, class SrcAccessor1,
75  class SrcIterator2, class SrcAccessor2,
76  class MaskIterator, class MaskAccessor,
77  class DestIterator, class DestAccessor, class Functor>
78 void
79 combineTwoLinesIf(SrcIterator1 s1,
80  SrcIterator1 s1end, SrcAccessor1 src1,
81  SrcIterator2 s2, SrcAccessor2 src2,
82  MaskIterator m, MaskAccessor mask,
83  DestIterator d, DestAccessor dest,
84  Functor const & f)
85 {
86  for(; s1 != s1end; ++s1, ++s2, ++m, ++d)
87  if(mask(m))
88  dest.set(f(src1(s1), src2(s2)), d);
89 }
90 
91 template <class SrcIterator1, class SrcAccessor1,
92  class SrcIterator2, class SrcAccessor2,
93  class SrcIterator3, class SrcAccessor3,
94  class DestIterator, class DestAccessor, class Functor>
95 void
96 combineThreeLines(SrcIterator1 s1,
97  SrcIterator1 s1end, SrcAccessor1 src1,
98  SrcIterator2 s2, SrcAccessor2 src2,
99  SrcIterator3 s3, SrcAccessor3 src3,
100  DestIterator d, DestAccessor dest,
101  Functor const & f)
102 {
103  for(; s1 != s1end; ++s1, ++s2, ++s3, ++d)
104  dest.set(f(src1(s1), src2(s2), src3(s3)), d);
105 }
106 
107 /********************************************************/
108 /* */
109 /* combineTwoImages */
110 /* */
111 /********************************************************/
112 
113 /** \brief Combine two source images into destination image.
114 
115  The transformation given by the functor is applied to the source
116  pixels and the result written into the corresponding destination pixel.
117  This is typically used for operations like add and subtract.
118  The function uses accessors to access the pixel data.
119  Note that the binary functors of the STL can be used in addition to
120  the functors specifically defined in \ref CombineFunctor.
121  Creation of new functors is easiest by using \ref FunctorExpressions.
122 
123  <b> Declarations:</b>
124 
125  pass arguments explicitly:
126  \code
127  namespace vigra {
128  template <class SrcImageIterator1, class SrcAccessor1,
129  class SrcImageIterator2, class SrcAccessor2,
130  class DestImageIterator, class DestAccessor,
131  class Functor>
132  void
133  combineTwoImages(SrcImageIterator1 src1_upperleft,
134  SrcImageIterator1 src1_lowerright, SrcAccessor1 sa1,
135  SrcImageIterator2 src2_upperleft, SrcAccessor2 sa2,
136  DestImageIterator dest_upperleft, DestAccessor da,
137  Functor const & f)
138  }
139  \endcode
140 
141 
142  use argument objects in conjunction with \ref ArgumentObjectFactories :
143  \code
144  namespace vigra {
145  template <class SrcImageIterator1, class SrcAccessor1,
146  class SrcImageIterator2, class SrcAccessor2,
147  class DestImageIterator, class DestAccessor,
148  class Functor>
149  void
150  combineTwoImages(triple<SrcImageIterator1, SrcImageIterator1, SrcAccessor1> src1,
151  pair<SrcImageIterator2, SrcAccessor2> src2,
152  pair<DestImageIterator, DestAccessor> dest,
153  Functor const & f)
154  }
155  \endcode
156 
157  <b> Usage:</b>
158 
159  <b>\#include</b> <vigra/combineimages.hxx><br>
160  Namespace: vigra
161 
162  \code
163  #include <functional> // for plus
164 
165  vigra::combineTwoImages(
166  srcIterRange(src1.upperLeft(), src1.lowerRight()),
167  srcIter(src2.upperLeft()),
168  destIter(dest.upperLeft()),
169  std::plus<SrcValueType>());
170 
171  \endcode
172 
173  Note that <TT>SrcValueType</TT> must be replaced with the appropriate type (e.g.
174  the promote type of the input images' pixel type, see also
175  \ref NumericPromotionTraits)
176 
177  <b> Required Interface:</b>
178 
179  \code
180  SrcImageIterator1 src1_upperleft, src1_lowerright;
181  SrcImageIterator2 src2_upperleft;
182  DestImageIterator dest_upperleft;
183  SrcImageIterator1::row_iterator sx1 = src1_upperleft.rowIterator();
184  SrcImageIterator2::row_iterator sx2 = src2_upperleft.rowIterator();
185  DestImageIterator::row_iterator dx = dest_upperleft.rowIterator();
186 
187  SrcAccessor1 src1_accessor;
188  SrcAccessor2 src2_accessor;
189  DestAccessor dest_accessor;
190 
191  Functor functor;
192 
193  dest_accessor.set(
194  functor(src1_accessor(sx1), src2_accessor(sx2)),
195  dx);
196 
197  \endcode
198 
199 
200 */
201 doxygen_overloaded_function(template <...> void combineTwoImages)
202 
203 template <class SrcImageIterator1, class SrcAccessor1,
204  class SrcImageIterator2, class SrcAccessor2,
205  class DestImageIterator, class DestAccessor,
206  class Functor>
207 void
208 combineTwoImages(SrcImageIterator1 src1_upperleft,
209  SrcImageIterator1 src1_lowerright, SrcAccessor1 sa1,
210  SrcImageIterator2 src2_upperleft, SrcAccessor2 sa2,
211  DestImageIterator dest_upperleft, DestAccessor da,
212  Functor const & f)
213 {
214  int w = src1_lowerright.x - src1_upperleft.x;
215 
216  for(; src1_upperleft.y < src1_lowerright.y;
217  ++src1_upperleft.y, ++src2_upperleft.y, ++dest_upperleft.y)
218  {
219  combineTwoLines(src1_upperleft.rowIterator(),
220  src1_upperleft.rowIterator() + w, sa1,
221  src2_upperleft.rowIterator(), sa2,
222  dest_upperleft.rowIterator(), da, f);
223  }
224 }
225 
226 template <class SrcImageIterator1, class SrcAccessor1,
227  class SrcImageIterator2, class SrcAccessor2,
228  class DestImageIterator, class DestAccessor,
229  class Functor>
230 inline
231 void
232 combineTwoImages(triple<SrcImageIterator1, SrcImageIterator1, SrcAccessor1> src1,
233  pair<SrcImageIterator2, SrcAccessor2> src2,
234  pair<DestImageIterator, DestAccessor> dest,
235  Functor const & f)
236 {
237  combineTwoImages(src1.first, src1.second, src1.third,
238  src2.first, src2.second,
239  dest.first, dest.second, f);
240 }
241 
242 /********************************************************/
243 /* */
244 /* combineTwoImagesIf */
245 /* */
246 /********************************************************/
247 
248 /** \brief Combine ROI of two source images into destination image.
249 
250  The transformation given by the functor is applied to all source
251  pixels in the ROI (i.e. whenever the return value of the mask's accessor
252  is not zero)
253  and the result written into the corresponding destination pixel.
254  This is typically used for operations like add and subtract.
255  The function uses accessors to access the pixel data.
256  Note that the binary functors of the STL can be used in addition to
257  the functors specifically defined in \ref CombineFunctor.
258  Creation of new functors is easiest by using \ref FunctorExpressions.
259 
260  <b> Declarations:</b>
261 
262  pass arguments explicitly:
263  \code
264  namespace vigra {
265  template <class SrcImageIterator1, class SrcAccessor1,
266  class SrcImageIterator2, class SrcAccessor2,
267  class MaskImageIterator, class MaskAccessor,
268  class DestImageIterator, clas DestAccessor,
269  class Functor>
270  void
271  combineTwoImagesIf(SrcImageIterator1 src1_upperleft,
272  SrcImageIterator1 src1_lowerright, SrcAccessor1 sa1,
273  SrcImageIterator2 src2_upperleft, SrcAccessor2 sa2,
274  MaskImageIterator mask_upperleft, MaskAccessor ma,
275  DestImageIterator dest_upperleft, DestAccessor da,
276  Functor const & f)
277  }
278  \endcode
279 
280 
281  use argument objects in conjunction with \ref ArgumentObjectFactories :
282  \code
283  namespace vigra {
284  template <class SrcImageIterator1, class SrcAccessor1,
285  class SrcImageIterator2, class SrcAccessor2,
286  class MaskImageIterator, class MaskAccessor,
287  class DestImageIterator, clas DestAccessor,
288  class Functor>
289  void
290  combineTwoImagesIf(triple<SrcImageIterator1, SrcImageIterator1, SrcAccessor1> src1,
291  pair<SrcImageIterator2, SrcAccessor2> src2,
292  pair<MaskImageIterator, MaskAccessor> mask,
293  pair<DestImageIterator, DestAccessor> dest,
294  Functor const & f)
295  }
296  \endcode
297 
298  <b> Usage:</b>
299 
300  <b>\#include</b> <vigra/combineimages.hxx><br>
301  Namespace: vigra
302 
303  \code
304  #include <functional> // for plus
305 
306  vigra::combineTwoImagesIf(
307  srcIterRange(src1.upperLeft(), src1.lowerRight()),
308  srcIter(src2.upperLeft()),
309  maskIter(mask.upperLeft()),
310  destIter(dest.upperLeft()),
311  std::plus<SrcValueType>());
312 
313  \endcode
314 
315  Note that <TT>SrcValueType</TT> must be replaced with the appropriate type (e.g.
316  the promote type of the input images' pixel type, see also
317  \ref NumericPromotionTraits)
318 
319  <b> Required Interface:</b>
320 
321  \code
322  SrcImageIterator1 src1_upperleft, src1_lowerright;
323  SrcImageIterator2 src2_upperleft;
324  MaskImageIterator mask_upperleft;
325  DestImageIterator dest_upperleft;
326  SrcImageIterator1::row_iterator sx1 = src1_upperleft.rowIterator();
327  SrcImageIterator2::row_iterator sx2 = src2_upperleft.rowIterator();
328  MaskImageIterator::row_iterator mx = mask_upperleft.rowIterator();
329  DestImageIterator::row_iterator dx = dest_upperleft.rowIterator();
330 
331 
332  SrcAccessor1 src1_accessor;
333  SrcAccessor2 src2_accessor;
334  MaskAccessor mask_accessor;
335  DestAccessor dest_accessor;
336 
337  Functor functor;
338 
339  if(mask_accessor(mx))
340  dest_accessor.set(
341  functor(src1_accessor(sx1), src2_accessor(sx2)),
342  dx);
343 
344  \endcode
345 
346 */
347 doxygen_overloaded_function(template <...> void combineTwoImagesIf)
348 
349 template <class SrcImageIterator1, class SrcAccessor1,
350  class SrcImageIterator2, class SrcAccessor2,
351  class MaskImageIterator, class MaskAccessor,
352  class DestImageIterator, class DestAccessor,
353  class Functor>
354 void
355 combineTwoImagesIf(SrcImageIterator1 src1_upperleft,
356  SrcImageIterator1 src1_lowerright, SrcAccessor1 sa1,
357  SrcImageIterator2 src2_upperleft, SrcAccessor2 sa2,
358  MaskImageIterator mask_upperleft, MaskAccessor ma,
359  DestImageIterator dest_upperleft, DestAccessor da,
360  Functor const & f)
361 {
362  int w = src1_lowerright.x - src1_upperleft.x;
363 
364  for(; src1_upperleft.y < src1_lowerright.y;
365  ++src1_upperleft.y, ++src2_upperleft.y,
366  ++dest_upperleft.y, ++mask_upperleft.y)
367  {
368  combineTwoLinesIf(src1_upperleft.rowIterator(),
369  src1_upperleft.rowIterator() + w, sa1,
370  src2_upperleft.rowIterator(), sa2,
371  mask_upperleft.rowIterator(), ma,
372  dest_upperleft.rowIterator(), da, f);
373  }
374 }
375 
376 template <class SrcImageIterator1, class SrcAccessor1,
377  class SrcImageIterator2, class SrcAccessor2,
378  class MaskImageIterator, class MaskAccessor,
379  class DestImageIterator, class DestAccessor,
380  class Functor>
381 inline
382 void
383 combineTwoImagesIf(triple<SrcImageIterator1, SrcImageIterator1, SrcAccessor1> src1,
384  pair<SrcImageIterator2, SrcAccessor2> src2,
385  pair<MaskImageIterator, MaskAccessor> mask,
386  pair<DestImageIterator, DestAccessor> dest,
387  Functor const & f)
388 {
389  combineTwoImagesIf(src1.first, src1.second, src1.third,
390  src2.first, src2.second,
391  mask.first, mask.second,
392  dest.first, dest.second, f);
393 }
394 
395 /********************************************************/
396 /* */
397 /* combineThreeImages */
398 /* */
399 /********************************************************/
400 
401 /** \brief Combine three source images into destination image.
402 
403  The transformation given by the functor is applied to the source
404  pixels and the result written into the corresponding destination pixel.
405  The function uses accessors to access the pixel data.
406  Creation of new functors is easiest by using \ref FunctorExpressions.
407 
408  <b> Declarations:</b>
409 
410  pass arguments explicitly:
411  \code
412  namespace vigra {
413  template <class SrcImageIterator1, class SrcAccessor1,
414  class SrcImageIterator2, class SrcAccessor2,
415  class SrcImageIterator3, class SrcAccessor3,
416  class DestImageIterator, class DestAccessor,
417  class Functor>
418  void
419  combineThreeImages(SrcImageIterator1 src1_upperleft,
420  SrcImageIterator1 src1_lowerright, SrcAccessor1 sa1,
421  SrcImageIterator2 src2_upperleft, SrcAccessor2 sa2,
422  SrcImageIterator3 src2_upperleft, SrcAccessor3 sa3,
423  DestImageIterator dest_upperleft, DestAccessor da,
424  Functor const & f)
425  }
426  \endcode
427 
428 
429  use argument objects in conjunction with \ref ArgumentObjectFactories :
430  \code
431  namespace vigra {
432  template <class SrcImageIterator1, class SrcAccessor1,
433  class SrcImageIterator2, class SrcAccessor2,
434  class SrcImageIterator3, class SrcAccessor3,
435  class DestImageIterator, class DestAccessor,
436  class Functor>
437  void
438  combineThreeImages(triple<SrcImageIterator1, SrcImageIterator1, SrcAccessor1> src1,
439  pair<SrcImageIterator2, SrcAccessor2> src2,
440  pair<SrcImageIterator3, SrcAccessor3> src3,
441  pair<DestImageIterator, DestAccessor> dest,
442  Functor const & f)
443  }
444  \endcode
445 
446  <b> Usage:</b>
447 
448  <b>\#include</b> <vigra/combineimages.hxx><br>
449  Namespace: vigra
450 
451  \code
452  vigra::combineThreeImages(
453  srcIterRange(src1.upperLeft(), src1.lowerRight()),
454  srcIter(src2.upperLeft()),
455  srcIter(src3.upperLeft()),
456  destIter(dest.upperLeft()),
457  SomeThreeArgumentFunctor());
458 
459  \endcode
460 
461  <b> Required Interface:</b>
462 
463  \code
464  SrcImageIterator1 src1_upperleft, src1_lowerright;
465  SrcImageIterator2 src2_upperleft;
466  SrcImageIterator3 src3_upperleft;
467  DestImageIterator dest_upperleft;
468  SrcImageIterator1::row_iterator sx1 = src1_upperleft.rowIterator();
469  SrcImageIterator2::row_iterator sx2 = src2_upperleft.rowIterator();
470  SrcImageIterator3::row_iterator sx3 = src3_upperleft.rowIterator();
471  DestImageIterator::row_iterator dx = dest_upperleft.rowIterator();
472 
473  SrcAccessor1 src1_accessor;
474  SrcAccessor2 src2_accessor;
475  SrcAccessor3 src3_accessor;
476  DestAccessor dest_accessor;
477 
478  Functor functor;
479 
480  dest_accessor.set(
481  functor(src1_accessor(sx1),
482  src2_accessor(sx2),
483  src3_accessor(sx3)),
484  dx);
485 
486  \endcode
487 
488 
489 */
490 doxygen_overloaded_function(template <...> void combineThreeImages)
491 
492 template <class SrcImageIterator1, class SrcAccessor1,
493  class SrcImageIterator2, class SrcAccessor2,
494  class SrcImageIterator3, class SrcAccessor3,
495  class DestImageIterator, class DestAccessor,
496  class Functor>
497 void
498 combineThreeImages(SrcImageIterator1 src1_upperleft,
499  SrcImageIterator1 src1_lowerright, SrcAccessor1 sa1,
500  SrcImageIterator2 src2_upperleft, SrcAccessor2 sa2,
501  SrcImageIterator3 src3_upperleft, SrcAccessor3 sa3,
502  DestImageIterator dest_upperleft, DestAccessor da,
503  Functor const & f)
504 {
505  int w = src1_lowerright.x - src1_upperleft.x;
506 
507  for(; src1_upperleft.y < src1_lowerright.y;
508  ++src1_upperleft.y, ++src2_upperleft.y, ++src3_upperleft.y,
509  ++dest_upperleft.y)
510  {
511  combineThreeLines(src1_upperleft.rowIterator(),
512  src1_upperleft.rowIterator() + w, sa1,
513  src2_upperleft.rowIterator(), sa2,
514  src3_upperleft.rowIterator(), sa3,
515  dest_upperleft.rowIterator(), da, f);
516  }
517 }
518 
519 template <class SrcImageIterator1, class SrcAccessor1,
520  class SrcImageIterator2, class SrcAccessor2,
521  class SrcImageIterator3, class SrcAccessor3,
522  class DestImageIterator, class DestAccessor,
523  class Functor>
524 inline
525 void
526 combineThreeImages(triple<SrcImageIterator1, SrcImageIterator1, SrcAccessor1> src1,
527  pair<SrcImageIterator2, SrcAccessor2> src2,
528  pair<SrcImageIterator3, SrcAccessor3> src3,
529  pair<DestImageIterator, DestAccessor> dest,
530  Functor const & f)
531 {
532  combineThreeImages(src1.first, src1.second, src1.third,
533  src2.first, src2.second,
534  src3.first, src3.second,
535  dest.first, dest.second, f);
536 }
537 
538 
539 //@}
540 
541 /** \addtogroup CombineFunctor Functors to Combine Images
542 
543  Common functors with several arguments
544 */
545 //@{
546 
547 /********************************************************/
548 /* */
549 /* MagnitudeFunctor */
550 /* */
551 /********************************************************/
552 
553 /** Calculate the magnitude from two arguments.
554  Can be used in conjunction with \ref gradientBasedTransform().
555 
556  If the gradient is represented by a vector-valued image instead of
557  a pair of scalar images, use \ref vigra::VectorNormFunctor.
558 
559  <b> Traits defined:</b>
560 
561  <tt>FunctorTraits::isBinaryFunctor</tt> are true (<tt>VigraTrueType</tt>)
562 */
563 template <class ValueType>
565 {
566  public:
567  /** the functor's first argument type
568  */
569  typedef ValueType first_argument_type;
570 
571  /** the functor's second argument type
572  */
573  typedef ValueType second_argument_type;
574 
575  /** the functor's result type
576  */
577  typedef typename SquareRootTraits<typename NormTraits<ValueType>::SquaredNormType>::SquareRootResult result_type;
578 
579  /** \deprecated use first_argument_type, second_argument_type, result_type
580  */
581  typedef ValueType value_type;
582 
583  /** calculate transform '<TT>sqrt(squaredNorm(v1) + squaredNorm(v2))</TT>'.
584 
585  */
587  {
588  return VIGRA_CSTD::sqrt(squaredNorm(v1) + squaredNorm(v2));
589  }
590 };
591 
592 template <class T>
593 class FunctorTraits<MagnitudeFunctor<T> >
594 : public FunctorTraitsBase<MagnitudeFunctor<T> >
595 {
596 public:
597  typedef VigraTrueType isBinaryFunctor;
598 };
599 
600 /********************************************************/
601 /* */
602 /* RGBGradientMagnitudeFunctor */
603 /* */
604 /********************************************************/
605 
606 
607 /** Calculate the gradient magnitude from RGB arguments.
608  Can be used in conjunction with \ref gradientBasedTransform().
609 
610  <b> Traits defined:</b>
611 
612  <tt>FunctorTraits::isBinaryFunctor</tt> are true (<tt>VigraTrueType</tt>)
613 */
614 template <class ValueType>
616 {
617  public:
618  /** the functor's first argument type
619  */
621 
622  /** the functor's second argument type
623  */
625 
626  /** the functor's result type
627  */
628  typedef typename NumericTraits<ValueType>::RealPromote result_type;
629 
630  /** \deprecated use first_argument_type, second_argument_type, result_type
631  */
632  typedef ValueType value_type;
633 
634  /** Calculate the gradient magnitude form given RGB components.
635  The function returns
636 
637  \f[ \sqrt{|\nabla red|^2 + |\nabla green|^2 + |\nabla blue|^2}
638  \f]
639 
640  where \f$|\nabla red|^2\f$ is defined by <TT>gx.red()*gx.red() + gy.red()*gy.red()</TT>.
641 
642  <TT>ValueType</TT> (the RGB's component type) must support addition, multiplication,
643  abd <TT>sqrt()</TT>.
644  */
645  result_type
647  {
648  return VIGRA_CSTD::sqrt(gx.red()*gx.red() + gx.green()*gx.green() +
649  gx.blue()*gx.blue() + gy.red()*gy.red() +
650  gy.green()*gy.green() + gy.blue()*gy.blue());
651  }
652 };
653 
654 template <class T>
655 class FunctorTraits<RGBGradientMagnitudeFunctor<T> >
656 : public FunctorTraitsBase<RGBGradientMagnitudeFunctor<T> >
657 {
658 public:
659  typedef VigraTrueType isBinaryFunctor;
660 };
661 
662 //@}
663 
664 } // namespace vigra
665 
666 #endif // VIGRA_COMBINEIMAGES_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)