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

cornerdetection.hxx
1 /************************************************************************/
2 /* */
3 /* Copyright 1998-2004 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_CORNERDETECTION_HXX
38 #define VIGRA_CORNERDETECTION_HXX
39 
40 #include "utilities.hxx"
41 #include "numerictraits.hxx"
42 #include "stdimage.hxx"
43 #include "combineimages.hxx"
44 #include "convolution.hxx"
45 #include "functortraits.hxx"
46 
47 namespace vigra {
48 
49 template <class SrcType>
50 struct CornerResponseFunctor
51 {
52  typedef typename NumericTraits<SrcType>::RealPromote argument_type;
53  typedef argument_type result_type;
54 
55  result_type operator()(argument_type a1,
56  argument_type a2, argument_type a3) const
57  {
58  return detail::RequiresExplicitCast<result_type>::cast((a1*a2 - a3*a3) - 0.04 * (a1 + a2) * (a1 + a2));
59  }
60 };
61 
62 template <class T>
63 class FunctorTraits<CornerResponseFunctor<T> >
64 : public FunctorTraitsBase<CornerResponseFunctor<T> >
65 {
66  public:
67  typedef VigraTrueType isTernaryFunctor;
68 };
69 
70 template <class SrcType>
71 struct FoerstnerCornerFunctor
72 {
73  typedef typename NumericTraits<SrcType>::RealPromote argument_type;
74  typedef argument_type result_type;
75 
76  result_type operator()(argument_type a1,
77  argument_type a2, argument_type a3) const
78  {
79  return (a1*a2 - a3*a3) / (a1 + a2);
80  }
81 };
82 
83 template <class T>
84 class FunctorTraits<FoerstnerCornerFunctor<T> >
85 : public FunctorTraitsBase<FoerstnerCornerFunctor<T> >
86 {
87  public:
88  typedef VigraTrueType isTernaryFunctor;
89 };
90 
91 template <class SrcType>
92 struct RohrCornerFunctor
93 {
94  typedef typename NumericTraits<SrcType>::RealPromote argument_type;
95  typedef argument_type result_type;
96 
97  result_type operator()(argument_type a1,
98  argument_type a2, argument_type a3) const
99  {
100  return (a1*a2 - a3*a3);
101  }
102 };
103 
104 template <class T>
105 class FunctorTraits<RohrCornerFunctor<T> >
106 : public FunctorTraitsBase<RohrCornerFunctor<T> >
107 {
108  public:
109  typedef VigraTrueType isTernaryFunctor;
110 };
111 
112 template <class SrcType>
113 struct BeaudetCornerFunctor
114 {
115  typedef typename NumericTraits<SrcType>::RealPromote argument_type;
116  typedef argument_type result_type;
117 
118  result_type operator()(argument_type a1,
119  argument_type a2, argument_type a3) const
120  {
121  return (a3*a3 - a1*a2);
122  }
123 };
124 
125 template <class T>
126 class FunctorTraits<BeaudetCornerFunctor<T> >
127 : public FunctorTraitsBase<BeaudetCornerFunctor<T> >
128 {
129  public:
130  typedef VigraTrueType isTernaryFunctor;
131 };
132 
133 /** \addtogroup CornerDetection Corner Detection
134  Measure the 'cornerness' at each pixel.
135  Note: The Kitchen-Rosenfeld detector is not implemented because of its
136  inferior performance. The SUSAN detector is missing because it's patented.
137 */
138 //@{
139 
140 /********************************************************/
141 /* */
142 /* cornerResponseFunction */
143 /* */
144 /********************************************************/
145 
146 /** \brief Find corners in an image (1).
147 
148  This algorithm implements the so called 'corner response function'
149  to measure the 'cornerness' of each pixel in the image, according to
150  [C.G. Harris and M.J. Stevens: <em> "A Combined Corner and Edge Detector"</em>,
151  Proc. of 4th Alvey Vision Conference, 1988]. Several studies have found this to be a
152  very robust corner detector, although it moves the corners somewhat into one
153  region, depending on the scale.
154 
155  The algorithm first determines the structure tensor at each pixel by calling
156  \ref structureTensor(). Then the entries of the structure tensor are combined as
157 
158  \f[
159  \mbox{\rm CornerResponse} = \mbox{\rm det(StructureTensor)} - 0.04 \mbox{\rm tr(StructureTensor)}^2
160  = A B - C^2 - 0.04 (A + B)^2
161  \f]
162 
163  The local maxima of the corner response denote the corners in the gray level
164  image.
165 
166  The source value type must be a linear algebra, i.e. addition, subtraction, and
167  multiplication with itself, multiplication with doubles and
168  \ref NumericTraits "NumericTraits" must
169  be defined.
170 
171  <b> Declarations:</b>
172 
173  pass arguments explicitly:
174  \code
175  namespace vigra {
176  template <class SrcIterator, class SrcAccessor,
177  class DestIterator, class DestAccessor>
178  void
179  cornerResponseFunction(SrcIterator sul, SrcIterator slr, SrcAccessor as,
180  DestIterator dul, DestAccessor ad,
181  double scale)
182  }
183  \endcode
184 
185  use argument objects in conjunction with \ref ArgumentObjectFactories :
186  \code
187  namespace vigra {
188  template <class SrcIterator, class SrcAccessor,
189  class DestIterator, class DestAccessor>
190  inline
191  void cornerResponseFunction(
192  triple<SrcIterator, SrcIterator, SrcAccessor> src,
193  pair<DestIterator, DestAccessor> dest,
194  double scale)
195  }
196  \endcode
197 
198  <b> Usage:</b>
199 
200  <b>\#include</b> <vigra/cornerdetection.hxx><br>
201  Namespace: vigra
202 
203  \code
204  vigra::BImage src(w,h), corners(w,h);
205  vigra::FImage corner_response(w,h);
206 
207  // empty corner image
208  corners.init(0.0);
209  ...
210 
211  // find corner response at scale 1.0
212  vigra::cornerResponseFunction(srcImageRange(src), destImage(corner_response),
213  1.0);
214 
215  // find local maxima of corner response, mark with 1
216  vigra::localMaxima(srcImageRange(corner_response), destImage(corners));
217 
218  // threshold corner response to keep only strong corners (above 400.0)
219  transformImage(srcImageRange(corner_response), destImage(corner_response),
220  vigra::Threshold<double, double>(
221  400.0, std::numeric_limits<double>::max(), 0.0, 1.0));
222 
223  // combine thresholding and local maxima
224  vigra::combineTwoImages(srcImageRange(corners), srcImage(corner_response),
225  destImage(corners), std::multiplies<float>());
226  \endcode
227 
228  <b> Required Interface:</b>
229 
230  \code
231  SrcImageIterator src_upperleft, src_lowerright;
232  DestImageIterator dest_upperleft;
233 
234  SrcAccessor src_accessor;
235  DestAccessor dest_accessor;
236 
237  SrcAccessor::value_type u = src_accessor(src_upperleft);
238  double d;
239 
240  u = u + u
241  u = u - u
242  u = u * u
243  u = d * u
244 
245  dest_accessor.set(u, dest_upperleft);
246  \endcode
247 */
248 doxygen_overloaded_function(template <...> void cornerResponseFunction)
249 
250 template <class SrcIterator, class SrcAccessor,
251  class DestIterator, class DestAccessor>
252 void
253 cornerResponseFunction(SrcIterator sul, SrcIterator slr, SrcAccessor as,
254  DestIterator dul, DestAccessor ad,
255  double scale)
256 {
257  vigra_precondition(scale > 0.0,
258  "cornerResponseFunction(): Scale must be > 0");
259 
260  int w = slr.x - sul.x;
261  int h = slr.y - sul.y;
262 
263  if(w <= 0 || h <= 0) return;
264 
265  typedef typename
266  NumericTraits<typename SrcAccessor::value_type>::RealPromote TmpType;
267 
268  typedef BasicImage<TmpType> TmpImage;
269 
270  TmpImage gx(w,h);
271  TmpImage gy(w,h);
272  TmpImage gxy(w,h);
273 
274  structureTensor(srcIterRange(sul, slr, as),
275  destImage(gx), destImage(gxy), destImage(gy),
276  scale, scale);
277  CornerResponseFunctor<typename SrcAccessor::value_type > cf;
278 
279  combineThreeImages(srcImageRange(gx), srcImage(gy), srcImage(gxy),
280  destIter(dul, ad), cf );
281 }
282 
283 template <class SrcIterator, class SrcAccessor,
284  class DestIterator, class DestAccessor>
285 inline
287  triple<SrcIterator, SrcIterator, SrcAccessor> src,
288  pair<DestIterator, DestAccessor> dest,
289  double scale)
290 {
291  cornerResponseFunction(src.first, src.second, src.third,
292  dest.first, dest.second,
293  scale);
294 }
295 
296 /********************************************************/
297 /* */
298 /* foerstnerCornerDetector */
299 /* */
300 /********************************************************/
301 
302 /** \brief Find corners in an image (2).
303 
304  This algorithm implements the so called 'Foerstner Corner Detector'
305  to measure the 'cornerness' of each pixel in the image, according to
306  [W. F&ouml;rstner: <em> "A feature based correspondence algorithms for image
307  matching"</em>, Intl. Arch. Photogrammetry and Remote Sensing, vol. 24, pp 160-166,
308  1986]. It is also known as the "Plessey Detector" by Harris. However, it should not
309  be confused with the
310  "\link cornerResponseFunction Corner Response Function\endlink ",
311  another detector invented by Harris.
312 
313  The algorithm first determines the structure tensor at each pixel by calling
314  \ref structureTensor(). Then the entries of the structure tensor are combined as
315 
316  \f[
317  \mbox{\rm FoerstnerCornerStrength} = \frac{\mbox{\rm det(StructureTensor)}}{\mbox{\rm tr(StructureTensor)}} =
318  \frac{A B - C^2}{A + B}
319  \f]
320 
321  The local maxima of the corner strength denote the corners in the gray level
322  image. Its performance is similar to the \ref cornerResponseFunction().
323 
324  The source value type must be a division algebra, i.e. addition, subtraction,
325  multiplication, and division with itself, multiplication with doubles and
326  \ref NumericTraits "NumericTraits" must
327  be defined.
328 
329  <b> Declarations:</b>
330 
331  pass arguments explicitly:
332  \code
333  namespace vigra {
334  template <class SrcIterator, class SrcAccessor,
335  class DestIterator, class DestAccessor>
336  void
337  foerstnerCornerDetector(SrcIterator sul, SrcIterator slr, SrcAccessor as,
338  DestIterator dul, DestAccessor ad,
339  double scale)
340  }
341  \endcode
342 
343  use argument objects in conjunction with \ref ArgumentObjectFactories :
344  \code
345  namespace vigra {
346  template <class SrcIterator, class SrcAccessor,
347  class DestIterator, class DestAccessor>
348  inline
349  void foerstnerCornerDetector(
350  triple<SrcIterator, SrcIterator, SrcAccessor> src,
351  pair<DestIterator, DestAccessor> dest,
352  double scale)
353  }
354  \endcode
355 
356  <b> Usage:</b>
357 
358  <b>\#include</b> <vigra/cornerdetection.hxx><br>
359  Namespace: vigra
360 
361  \code
362  vigra::BImage src(w,h), corners(w,h);
363  vigra::FImage foerstner_corner_strength(w,h);
364 
365  // empty corner image
366  corners.init(0.0);
367  ...
368 
369  // find corner response at scale 1.0
370  vigra::foerstnerCornerDetector(srcImageRange(src), destImage(foerstner_corner_strength),
371  1.0);
372 
373  // find local maxima of corner response, mark with 1
374  vigra::localMaxima(srcImageRange(foerstner_corner_strength), destImage(corners));
375  \endcode
376 
377  <b> Required Interface:</b>
378 
379  \code
380  SrcImageIterator src_upperleft, src_lowerright;
381  DestImageIterator dest_upperleft;
382 
383  SrcAccessor src_accessor;
384  DestAccessor dest_accessor;
385 
386  SrcAccessor::value_type u = src_accessor(src_upperleft);
387  double d;
388 
389  u = u + u
390  u = u - u
391  u = u * u
392  u = u / u
393  u = d * u
394 
395  dest_accessor.set(u, dest_upperleft);
396  \endcode
397 */
398 doxygen_overloaded_function(template <...> void foerstnerCornerDetector)
399 
400 template <class SrcIterator, class SrcAccessor,
401  class DestIterator, class DestAccessor>
402 void
403 foerstnerCornerDetector(SrcIterator sul, SrcIterator slr, SrcAccessor as,
404  DestIterator dul, DestAccessor ad,
405  double scale)
406 {
407  vigra_precondition(scale > 0.0,
408  "foerstnerCornerDetector(): Scale must be > 0");
409 
410  int w = slr.x - sul.x;
411  int h = slr.y - sul.y;
412 
413  if(w <= 0 || h <= 0) return;
414 
415  typedef typename
416  NumericTraits<typename SrcAccessor::value_type>::RealPromote TmpType;
417 
418  typedef BasicImage<TmpType> TmpImage;
419 
420  TmpImage gx(w,h);
421  TmpImage gy(w,h);
422  TmpImage gxy(w,h);
423 
424  structureTensor(srcIterRange(sul, slr, as),
425  destImage(gx), destImage(gxy), destImage(gy),
426  scale, scale);
427  FoerstnerCornerFunctor<typename SrcAccessor::value_type > cf;
428 
429  combineThreeImages(srcImageRange(gx), srcImage(gy), srcImage(gxy),
430  destIter(dul, ad), cf );
431 }
432 
433 template <class SrcIterator, class SrcAccessor,
434  class DestIterator, class DestAccessor>
435 inline
437  triple<SrcIterator, SrcIterator, SrcAccessor> src,
438  pair<DestIterator, DestAccessor> dest,
439  double scale)
440 {
441  foerstnerCornerDetector(src.first, src.second, src.third,
442  dest.first, dest.second,
443  scale);
444 }
445 
446 /********************************************************/
447 /* */
448 /* rohrCornerDetector */
449 /* */
450 /********************************************************/
451 
452 /** \brief Find corners in an image (3).
453 
454  This algorithm implements yet another structure tensor-based corner detector,
455  according to [K. Rohr: <em>"Untersuchung von grauwertabh&auml;ngigen
456  Transformationen zur Ermittlung der optischen Flusses in Bildfolgen"</em>,
457  Diploma thesis, Inst. f&uuml;r Nachrichtensysteme, Univ. Karlsruhe, 1987, see also
458  K. Rohr: <em>"Modelling and Identification of Characteristic Intensity Variations"</em>,
459  Image and Vision Computing 10:2 (1992) 66-76 and K. Rohr: <em>"Localization Properties of
460  Direct Corner Detectors"</em>, J. of Mathematical Imaging and Vision 4:2 (1994) 139-150].
461 
462  The algorithm first determines the structure tensor at each pixel by calling
463  \ref structureTensor(). Then the entries of the structure tensor are combined as
464 
465  \f[
466  \mbox{\rm RohrCornerStrength} = \mbox{\rm det(StructureTensor)} = A B - C^2
467  \f]
468 
469  The local maxima of the corner strength denote the corners in the gray level
470  image. Its performance is similar to the \ref cornerResponseFunction().
471 
472  The source value type must be a linear algebra, i.e. addition, subtraction, and
473  multiplication with itself, multiplication with doubles and
474  \ref NumericTraits "NumericTraits" must
475  be defined.
476 
477  <b> Declarations:</b>
478 
479  pass arguments explicitly:
480  \code
481  namespace vigra {
482  template <class SrcIterator, class SrcAccessor,
483  class DestIterator, class DestAccessor>
484  void
485  rohrCornerDetector(SrcIterator sul, SrcIterator slr, SrcAccessor as,
486  DestIterator dul, DestAccessor ad,
487  double scale)
488  }
489  \endcode
490 
491  use argument objects in conjunction with \ref ArgumentObjectFactories :
492  \code
493  namespace vigra {
494  template <class SrcIterator, class SrcAccessor,
495  class DestIterator, class DestAccessor>
496  inline
497  void rohrCornerDetector(
498  triple<SrcIterator, SrcIterator, SrcAccessor> src,
499  pair<DestIterator, DestAccessor> dest,
500  double scale)
501  }
502  \endcode
503 
504  <b> Usage:</b>
505 
506  <b>\#include</b> <vigra/cornerdetection.hxx><br>
507  Namespace: vigra
508 
509  \code
510  vigra::BImage src(w,h), corners(w,h);
511  vigra::FImage rohr_corner_strength(w,h);
512 
513  // empty corner image
514  corners.init(0.0);
515  ...
516 
517  // find corner response at scale 1.0
518  vigra::rohrCornerDetector(srcImageRange(src), destImage(rohr_corner_strength),
519  1.0);
520 
521  // find local maxima of corner response, mark with 1
522  vigra::localMaxima(srcImageRange(rohr_corner_strength), destImage(corners));
523  \endcode
524 
525  <b> Required Interface:</b>
526 
527  \code
528  SrcImageIterator src_upperleft, src_lowerright;
529  DestImageIterator dest_upperleft;
530 
531  SrcAccessor src_accessor;
532  DestAccessor dest_accessor;
533 
534  SrcAccessor::value_type u = src_accessor(src_upperleft);
535  double d;
536 
537  u = u + u
538  u = u - u
539  u = u * u
540  u = d * u
541 
542  dest_accessor.set(u, dest_upperleft);
543  \endcode
544 */
545 doxygen_overloaded_function(template <...> void rohrCornerDetector)
546 
547 template <class SrcIterator, class SrcAccessor,
548  class DestIterator, class DestAccessor>
549 void
550 rohrCornerDetector(SrcIterator sul, SrcIterator slr, SrcAccessor as,
551  DestIterator dul, DestAccessor ad,
552  double scale)
553 {
554  vigra_precondition(scale > 0.0,
555  "rohrCornerDetector(): Scale must be > 0");
556 
557  int w = slr.x - sul.x;
558  int h = slr.y - sul.y;
559 
560  if(w <= 0 || h <= 0) return;
561 
562  typedef typename
563  NumericTraits<typename SrcAccessor::value_type>::RealPromote TmpType;
564 
565  typedef BasicImage<TmpType> TmpImage;
566 
567  TmpImage gx(w,h);
568  TmpImage gy(w,h);
569  TmpImage gxy(w,h);
570 
571  structureTensor(srcIterRange(sul, slr, as),
572  destImage(gx), destImage(gxy), destImage(gy),
573  scale, scale);
574  RohrCornerFunctor<typename SrcAccessor::value_type > cf;
575 
576  combineThreeImages(srcImageRange(gx), srcImage(gy), srcImage(gxy),
577  destIter(dul, ad), cf );
578 }
579 
580 template <class SrcIterator, class SrcAccessor,
581  class DestIterator, class DestAccessor>
582 inline
583 void rohrCornerDetector(
584  triple<SrcIterator, SrcIterator, SrcAccessor> src,
585  pair<DestIterator, DestAccessor> dest,
586  double scale)
587 {
588  rohrCornerDetector(src.first, src.second, src.third,
589  dest.first, dest.second,
590  scale);
591 }
592 
593 /********************************************************/
594 /* */
595 /* beaudetCornerDetector */
596 /* */
597 /********************************************************/
598 
599 /** \brief Find corners in an image (4).
600 
601  This algorithm implements a corner detector
602  according to [P.R. Beaudet: <em> "Rotationally Invariant Image Operators"</em>,
603  Proc. Intl. Joint Conf. on Pattern Recognition, Kyoto, Japan, 1978, pp. 579-583].
604 
605  The algorithm calculates the corner strength as the negative determinant of the
606  \link hessianMatrixOfGaussian() Hessian Matrix\endlink.
607  The local maxima of the corner strength denote the corners in the gray level
608  image.
609 
610  The source value type must be a linear algebra, i.e. addition, subtraction, and
611  multiplication with itself, multiplication with doubles and
612  \ref NumericTraits "NumericTraits" must
613  be defined.
614 
615  <b> Declarations:</b>
616 
617  pass arguments explicitly:
618  \code
619  namespace vigra {
620  template <class SrcIterator, class SrcAccessor,
621  class DestIterator, class DestAccessor>
622  void
623  beaudetCornerDetector(SrcIterator sul, SrcIterator slr, SrcAccessor as,
624  DestIterator dul, DestAccessor ad,
625  double scale)
626  }
627  \endcode
628 
629  use argument objects in conjunction with \ref ArgumentObjectFactories :
630  \code
631  namespace vigra {
632  template <class SrcIterator, class SrcAccessor,
633  class DestIterator, class DestAccessor>
634  inline
635  void beaudetCornerDetector(
636  triple<SrcIterator, SrcIterator, SrcAccessor> src,
637  pair<DestIterator, DestAccessor> dest,
638  double scale)
639  }
640  \endcode
641 
642  <b> Usage:</b>
643 
644  <b>\#include</b> <vigra/cornerdetection.hxx><br>
645  Namespace: vigra
646 
647  \code
648  vigra::BImage src(w,h), corners(w,h);
649  vigra::FImage beaudet_corner_strength(w,h);
650 
651  // empty corner image
652  corners.init(0.0);
653  ...
654 
655  // find corner response at scale 1.0
656  vigra::beaudetCornerDetector(srcImageRange(src), destImage(beaudet_corner_strength),
657  1.0);
658 
659  // find local maxima of corner response, mark with 1
660  vigra::localMaxima(srcImageRange(beaudet_corner_strength), destImage(corners));
661  \endcode
662 
663  <b> Required Interface:</b>
664 
665  \code
666  SrcImageIterator src_upperleft, src_lowerright;
667  DestImageIterator dest_upperleft;
668 
669  SrcAccessor src_accessor;
670  DestAccessor dest_accessor;
671 
672  SrcAccessor::value_type u = src_accessor(src_upperleft);
673  double d;
674 
675  u = u + u
676  u = u - u
677  u = u * u
678  u = d * u
679 
680  dest_accessor.set(u, dest_upperleft);
681  \endcode
682 */
683 doxygen_overloaded_function(template <...> void beaudetCornerDetector)
684 
685 template <class SrcIterator, class SrcAccessor,
686  class DestIterator, class DestAccessor>
687 void
688 beaudetCornerDetector(SrcIterator sul, SrcIterator slr, SrcAccessor as,
689  DestIterator dul, DestAccessor ad,
690  double scale)
691 {
692  vigra_precondition(scale > 0.0,
693  "beaudetCornerDetector(): Scale must be > 0");
694 
695  int w = slr.x - sul.x;
696  int h = slr.y - sul.y;
697 
698  if(w <= 0 || h <= 0) return;
699 
700  typedef typename
701  NumericTraits<typename SrcAccessor::value_type>::RealPromote TmpType;
702 
703  typedef BasicImage<TmpType> TmpImage;
704 
705  TmpImage gx(w,h);
706  TmpImage gy(w,h);
707  TmpImage gxy(w,h);
708 
709  hessianMatrixOfGaussian(srcIterRange(sul, slr, as),
710  destImage(gx), destImage(gxy), destImage(gy),
711  scale);
712  BeaudetCornerFunctor<typename SrcAccessor::value_type > cf;
713 
714  combineThreeImages(srcImageRange(gx), srcImage(gy), srcImage(gxy),
715  destIter(dul, ad), cf );
716 }
717 
718 template <class SrcIterator, class SrcAccessor,
719  class DestIterator, class DestAccessor>
720 inline
722  triple<SrcIterator, SrcIterator, SrcAccessor> src,
723  pair<DestIterator, DestAccessor> dest,
724  double scale)
725 {
726  beaudetCornerDetector(src.first, src.second, src.third,
727  dest.first, dest.second,
728  scale);
729 }
730 
731 
732 //@}
733 
734 } // namespace vigra
735 
736 #endif // VIGRA_CORNERDETECTION_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 (Sat Oct 5 2013)