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

details vigra/cornerdetection.hxx VIGRA

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_CORNERDETECTION_HXX
00025 #define VIGRA_CORNERDETECTION_HXX
00026 
00027 #include <vigra/utilities.hxx>
00028 #include <vigra/numerictraits.hxx>
00029 #include <vigra/stdimage.hxx>
00030 #include <vigra/combineimages.hxx>
00031 #include <vigra/convolution.hxx>
00032 
00033 namespace vigra {
00034 
00035 template <class SrcType>
00036 struct CornerResponseFunctor
00037 {
00038     typedef typename NumericTraits<SrcType>::RealPromote argument_type;
00039     typedef argument_type result_type;
00040     
00041     result_type operator()(argument_type a1, 
00042                         argument_type a2, argument_type a3) const
00043     {
00044     return (a1*a2 - a3*a3) - 0.04 * (a1 + a2) * (a1 + a2);
00045     }
00046 };
00047 
00048 template <class SrcType>
00049 struct FoerstnerCornerFunctor
00050 {
00051     typedef typename NumericTraits<SrcType>::RealPromote argument_type;
00052     typedef argument_type result_type;
00053     
00054     result_type operator()(argument_type a1, 
00055                            argument_type a2, argument_type a3) const
00056     {
00057     return (a1*a2 - a3*a3) / (a1 + a2);
00058     }
00059 };
00060 
00061 template <class SrcType>
00062 struct RohrCornerFunctor
00063 {
00064     typedef typename NumericTraits<SrcType>::RealPromote argument_type;
00065     typedef argument_type result_type;
00066     
00067     result_type operator()(argument_type a1, 
00068                         argument_type a2, argument_type a3) const
00069     {
00070     return (a1*a2 - a3*a3);
00071     }
00072 };
00073 
00074 template <class SrcType>
00075 struct BeaudetCornerFunctor
00076 {
00077     typedef typename NumericTraits<SrcType>::RealPromote argument_type;
00078     typedef argument_type result_type;
00079     
00080     result_type operator()(argument_type a1, 
00081                         argument_type a2, argument_type a3) const
00082     {
00083     return (a3*a3 - a1*a2);
00084     }
00085 };
00086 
00087 /** \addtogroup CornerDetection Corner Detection
00088     Measure the 'cornerness' at each pixel.
00089     Note: The Kitchen-Rosenfeld detector is not implemented because of its
00090     inferior performance. The SUSAN detector is missing because it's patented.
00091 */
00092 //@{ 
00093                                     
00094 /********************************************************/
00095 /*                                                      */
00096 /*                 cornerResponseFunction               */
00097 /*                                                      */
00098 /********************************************************/
00099 
00100 /** \brief Find corners in an image (1).
00101 
00102     This algorithm implements the so called 'corner response function'
00103     to measure the 'cornerness' of each pixel in the image, according to
00104     [C.G. Harris and M.J. Stevens: <em> "A Combined Corner and Edge Detector"</em>,
00105     Proc. of 4th Alvey Vision Conference, 1988]. Several studies have found this to be a
00106     very robust corner detector, although it moves the corners somewhat into one
00107     region, depending on the scale.
00108     
00109     The algorithm first determines the structure tensor at each pixel by calling
00110     \link CommonConvolutionFilters#structureTensor structureTensor\endlink(). 
00111     Then the entries of the structure tensor are combined as 
00112     
00113     \f[
00114         \mbox{\rm CornerResponse} = \mbox{\rm det(StructureTensor)} - 0.04 \mbox{\rm tr(StructureTensor)}^2
00115         = A B - C^2 - 0.04 (A + B)^2
00116     \f]
00117     
00118     The local maxima of the corner response denote the corners in the gray level 
00119     image.
00120     
00121     The source value type must be a linaer algebra, i.e. addition, subtraction, and
00122     multiplication with itself, multiplication with doubles and 
00123     \ref NumericTraits "NumericTraits" must 
00124     be defined. 
00125     
00126     <b> Declarations:</b>
00127     
00128     pass arguments explicitly:
00129     \code
00130     namespace vigra {
00131         template <class SrcIterator, class SrcAccessor,
00132               class DestIterator, class DestAccessor>
00133         void
00134         cornerResponseFunction(SrcIterator sul, SrcIterator slr, SrcAccessor as,
00135                    DestIterator dul, DestAccessor ad,
00136                    double scale)
00137     }
00138     \endcode
00139     
00140     use argument objects in conjuction with \ref ArgumentObjectFactories:
00141     \code
00142     namespace vigra {
00143         template <class SrcIterator, class SrcAccessor,
00144               class DestIterator, class DestAccessor>
00145         inline 
00146         void cornerResponseFunction(
00147                triple<SrcIterator, SrcIterator, SrcAccessor> src,
00148                pair<DestIterator, DestAccessor> dest,
00149                double scale)
00150     }
00151     \endcode
00152     
00153     <b> Usage:</b>
00154     
00155         <b>\#include</b> "<a href="cornerdetection_8hxx-source.html">vigra/cornerdetection.hxx</a>"<br>
00156     Namespace: vigra
00157     
00158     \code
00159     vigra::BImage src(w,h), corners(w,h);
00160     vigra::FImage corner_response(w,h);
00161     
00162     // empty corner image
00163     corners.init(0.0);
00164     ...
00165     
00166     // find corner response at scale 1.0
00167     vigra::cornerResponseFunction(srcImageRange(src), destImage(corner_response), 
00168                            1.0);
00169     
00170     // find local maxima of corner response, mark with 1
00171     vigra::localMaxima(srcImageRange(corner_response), destImage(corners));
00172     
00173     // threshold corner response to keep only strong corners (above 400.0)
00174     transformImage(srcImageRange(corner_response), destImage(corner_response),
00175           vigra::Threshold<double, double>(
00176                400.0, std::numeric_limits<double>::max(), 0.0, 1.0)); 
00177 
00178     // combine thresholding and local maxima
00179     vigra::combineTwoImages(srcImageRange(corners), srcImage(corner_response),
00180                      destImage(corners), std::multiplies<float>());
00181     \endcode
00182 
00183     <b> Required Interface:</b>
00184     
00185     \code
00186     SrcImageIterator src_upperleft, src_lowerright;
00187     DestImageIterator dest_upperleft;
00188     
00189     SrcAccessor src_accessor;
00190     DestAccessor dest_accessor;
00191     
00192     SrcAccessor::value_type u = src_accessor(src_upperleft);
00193     double d;
00194     
00195     u = u + u
00196     u = u - u
00197     u = u * u
00198     u = d * u
00199     
00200     dest_accessor.set(u, dest_upperleft);
00201     \endcode
00202 */
00203 template <class SrcIterator, class SrcAccessor,
00204           class DestIterator, class DestAccessor>
00205 void
00206 cornerResponseFunction(SrcIterator sul, SrcIterator slr, SrcAccessor as,
00207                        DestIterator dul, DestAccessor ad,
00208                double scale)
00209 {
00210     vigra_precondition(scale > 0.0,
00211                  "cornerResponseFunction(): Scale must be > 0");
00212          
00213     int w = slr.x - sul.x;
00214     int h = slr.y - sul.y;
00215     
00216     if(w <= 0 || h <= 0) return;
00217     
00218     typedef typename 
00219         NumericTraits<typename SrcAccessor::value_type>::RealPromote TmpType;
00220     
00221     typedef BasicImage<TmpType> TmpImage;
00222     
00223     TmpImage gx(w,h);
00224     TmpImage gy(w,h);
00225     TmpImage gxy(w,h);
00226 
00227     structureTensor(srcIterRange(sul, slr, as), 
00228                     destImage(gx), destImage(gxy), destImage(gy), 
00229                     scale, scale);
00230     CornerResponseFunctor<typename SrcAccessor::value_type > cf;
00231                     
00232     combineThreeImages(srcImageRange(gx), srcImage(gy), srcImage(gxy), 
00233                        destIter(dul, ad), cf );
00234 }
00235 
00236 template <class SrcIterator, class SrcAccessor,
00237           class DestIterator, class DestAccessor>
00238 inline 
00239 void cornerResponseFunction(
00240            triple<SrcIterator, SrcIterator, SrcAccessor> src,
00241        pair<DestIterator, DestAccessor> dest,
00242        double scale)
00243 {
00244     cornerResponseFunction(src.first, src.second, src.third,
00245                             dest.first, dest.second,
00246                 scale);
00247 }
00248 
00249 /********************************************************/
00250 /*                                                      */
00251 /*               foerstnerCornerDetector                */
00252 /*                                                      */
00253 /********************************************************/
00254 
00255 /** \brief Find corners in an image (2).
00256 
00257     This algorithm implements the so called 'Foerstner Corner Detector'
00258     to measure the 'cornerness' of each pixel in the image, according to
00259     [W. F&ouml;rstner: <em> "A feature based correspondence algorithms for image
00260     matching"</em>, Intl. Arch. Photogrammetry and Remote Sensing, vol. 24, pp 160-166, 
00261     1986]. It is also known as the "Plessey Detector" by Harris. However, it should not 
00262     be confused with the
00263     "\link CornerDetection#cornerResponseFunction Corner Repsonse Function\endlink ",
00264     another detector invented by Harris.
00265     
00266     The algorithm first determines the structure tensor at each pixel by calling
00267     \link CommonConvolutionFilters#structureTensor structureTensor\endlink(). 
00268     Then the entries of the structure tensor are combined as 
00269     
00270     \f[
00271         \mbox{\rm FoerstnerCornerStrength} = \frac{\mbox{\rm det(StructureTensor)}}{\mbox{\rm tr(StructureTensor)}} = 
00272         \frac{A B - C^2}{A + B}
00273     \f]
00274     
00275     The local maxima of the corner strength denote the corners in the gray level 
00276     image. Its performance is similar to the 
00277     \link CornerDetection#cornerResponseFunction cornerResponseFunction\endlink().
00278     
00279     The source value type must be a division algebra, i.e. addition, subtraction,
00280     multiplication, and division with itself, multiplication with doubles and 
00281     \ref NumericTraits "NumericTraits" must 
00282     be defined.
00283     
00284     <b> Declarations:</b>
00285     
00286     pass arguments explicitly:
00287     \code
00288     namespace vigra {
00289         template <class SrcIterator, class SrcAccessor,
00290               class DestIterator, class DestAccessor>
00291         void
00292         foerstnerCornerDetector(SrcIterator sul, SrcIterator slr, SrcAccessor as,
00293                    DestIterator dul, DestAccessor ad,
00294                    double scale)
00295     }
00296     \endcode
00297     
00298     use argument objects in conjuction with \ref ArgumentObjectFactories:
00299     \code
00300     namespace vigra {
00301         template <class SrcIterator, class SrcAccessor,
00302               class DestIterator, class DestAccessor>
00303         inline 
00304         void foerstnerCornerDetector(
00305                triple<SrcIterator, SrcIterator, SrcAccessor> src,
00306                pair<DestIterator, DestAccessor> dest,
00307                double scale)
00308     }
00309     \endcode
00310     
00311     <b> Usage:</b>
00312     
00313         <b>\#include</b> "<a href="cornerdetection_8hxx-source.html">vigra/cornerdetection.hxx</a>"<br>
00314     Namespace: vigra
00315     
00316     \code
00317     vigra::BImage src(w,h), corners(w,h);
00318     vigra::FImage foerstner_corner_strength(w,h);
00319     
00320     // empty corner image
00321     corners.init(0.0);
00322     ...
00323     
00324     // find corner response at scale 1.0
00325     vigra::foerstnerCornerDetector(srcImageRange(src), destImage(foerstner_corner_strength), 
00326                                    1.0);
00327     
00328     // find local maxima of corner response, mark with 1
00329     vigra::localMaxima(srcImageRange(foerstner_corner_strength), destImage(corners));
00330     \endcode
00331 
00332     <b> Required Interface:</b>
00333     
00334     \code
00335     SrcImageIterator src_upperleft, src_lowerright;
00336     DestImageIterator dest_upperleft;
00337     
00338     SrcAccessor src_accessor;
00339     DestAccessor dest_accessor;
00340     
00341     SrcAccessor::value_type u = src_accessor(src_upperleft);
00342     double d;
00343     
00344     u = u + u
00345     u = u - u
00346     u = u * u
00347     u = u / u
00348     u = d * u
00349     
00350     dest_accessor.set(u, dest_upperleft);
00351     \endcode
00352 */
00353 template <class SrcIterator, class SrcAccessor,
00354           class DestIterator, class DestAccessor>
00355 void
00356 foerstnerCornerDetector(SrcIterator sul, SrcIterator slr, SrcAccessor as,
00357                        DestIterator dul, DestAccessor ad,
00358                double scale)
00359 {
00360     vigra_precondition(scale > 0.0,
00361                  "foerstnerCornerDetector(): Scale must be > 0");
00362          
00363     int w = slr.x - sul.x;
00364     int h = slr.y - sul.y;
00365     
00366     if(w <= 0 || h <= 0) return;
00367     
00368     typedef typename 
00369         NumericTraits<typename SrcAccessor::value_type>::RealPromote TmpType;
00370     
00371     typedef BasicImage<TmpType> TmpImage;
00372     
00373     TmpImage gx(w,h);
00374     TmpImage gy(w,h);
00375     TmpImage gxy(w,h);
00376 
00377     structureTensor(srcIterRange(sul, slr, as), 
00378                     destImage(gx), destImage(gxy), destImage(gy), 
00379                     scale, scale);
00380     FoerstnerCornerFunctor<typename SrcAccessor::value_type > cf;
00381                     
00382     combineThreeImages(srcImageRange(gx), srcImage(gy), srcImage(gxy), 
00383                        destIter(dul, ad), cf );
00384 }
00385 
00386 template <class SrcIterator, class SrcAccessor,
00387           class DestIterator, class DestAccessor>
00388 inline 
00389 void foerstnerCornerDetector(
00390            triple<SrcIterator, SrcIterator, SrcAccessor> src,
00391        pair<DestIterator, DestAccessor> dest,
00392        double scale)
00393 {
00394     foerstnerCornerDetector(src.first, src.second, src.third,
00395                             dest.first, dest.second,
00396                 scale);
00397 }
00398 
00399 /********************************************************/
00400 /*                                                      */
00401 /*                   rohrCornerDetector                 */
00402 /*                                                      */
00403 /********************************************************/
00404 
00405 /** \brief Find corners in an image (3).
00406 
00407     This algorithm implements yet another structure tensor-based corner detector, 
00408     according to [K. Rohr: <em> "Untersuchung von grauwertabh&auml;ngigen 
00409     Transformationen zur Ermittlung der optischen Flusses in Bildfolgen"</em>, 
00410     Diploma thesis, Inst. f&uuml;r Nachrichtensysteme, Univ. Karlsruhe, 1987]. 
00411     
00412     The algorithm first determines the structure tensor at each pixel by calling
00413     \link CommonConvolutionFilters#structureTensor structureTensor\endlink(). 
00414     Then the entries of the structure tensor are combined as 
00415     
00416     \f[
00417         \mbox{\rm RohrCornerStrength} = \mbox{\rm det(StructureTensor)} = A B - C^2
00418     \f]
00419     
00420     The local maxima of the corner strength denote the corners in the gray level 
00421     image. Its performance is similar to the 
00422     \link CornerDetection#cornerResponseFunction cornerResponseFunction\endlink().
00423     
00424     The source value type must be a linear algebra, i.e. addition, subtraction, and
00425     multiplication with itself, multiplication with doubles and 
00426     \ref NumericTraits "NumericTraits" must 
00427     be defined.
00428     
00429     <b> Declarations:</b>
00430     
00431     pass arguments explicitly:
00432     \code
00433     namespace vigra {
00434         template <class SrcIterator, class SrcAccessor,
00435               class DestIterator, class DestAccessor>
00436         void
00437         rohrCornerDetector(SrcIterator sul, SrcIterator slr, SrcAccessor as,
00438                DestIterator dul, DestAccessor ad,
00439                double scale)
00440     }
00441     \endcode
00442     
00443     use argument objects in conjuction with \ref ArgumentObjectFactories:
00444     \code
00445     namespace vigra {
00446         template <class SrcIterator, class SrcAccessor,
00447               class DestIterator, class DestAccessor>
00448         inline 
00449         void rohrCornerDetector(
00450                triple<SrcIterator, SrcIterator, SrcAccessor> src,
00451                pair<DestIterator, DestAccessor> dest,
00452                double scale)
00453     }
00454     \endcode
00455     
00456     <b> Usage:</b>
00457     
00458         <b>\#include</b> "<a href="cornerdetection_8hxx-source.html">vigra/cornerdetection.hxx</a>"<br>
00459     Namespace: vigra
00460     
00461     \code
00462     vigra::BImage src(w,h), corners(w,h);
00463     vigra::FImage rohr_corner_strength(w,h);
00464     
00465     // empty corner image
00466     corners.init(0.0);
00467     ...
00468     
00469     // find corner response at scale 1.0
00470     vigra::rohrCornerDetector(srcImageRange(src), destImage(rohr_corner_strength), 
00471                               1.0);
00472     
00473     // find local maxima of corner response, mark with 1
00474     vigra::localMaxima(srcImageRange(rohr_corner_strength), destImage(corners));
00475     \endcode
00476 
00477     <b> Required Interface:</b>
00478     
00479     \code
00480     SrcImageIterator src_upperleft, src_lowerright;
00481     DestImageIterator dest_upperleft;
00482     
00483     SrcAccessor src_accessor;
00484     DestAccessor dest_accessor;
00485     
00486     SrcAccessor::value_type u = src_accessor(src_upperleft);
00487     double d;
00488     
00489     u = u + u
00490     u = u - u
00491     u = u * u
00492     u = d * u
00493     
00494     dest_accessor.set(u, dest_upperleft);
00495     \endcode
00496 */
00497 template <class SrcIterator, class SrcAccessor,
00498           class DestIterator, class DestAccessor>
00499 void
00500 rohrCornerDetector(SrcIterator sul, SrcIterator slr, SrcAccessor as,
00501                        DestIterator dul, DestAccessor ad,
00502                double scale)
00503 {
00504     vigra_precondition(scale > 0.0,
00505                  "rohrCornerDetector(): Scale must be > 0");
00506          
00507     int w = slr.x - sul.x;
00508     int h = slr.y - sul.y;
00509     
00510     if(w <= 0 || h <= 0) return;
00511     
00512     typedef typename 
00513         NumericTraits<typename SrcAccessor::value_type>::RealPromote TmpType;
00514     
00515     typedef BasicImage<TmpType> TmpImage;
00516     
00517     TmpImage gx(w,h);
00518     TmpImage gy(w,h);
00519     TmpImage gxy(w,h);
00520 
00521     structureTensor(srcIterRange(sul, slr, as), 
00522                     destImage(gx), destImage(gxy), destImage(gy), 
00523                     scale, scale);
00524     RohrCornerFunctor<typename SrcAccessor::value_type > cf;
00525                     
00526     combineThreeImages(srcImageRange(gx), srcImage(gy), srcImage(gxy), 
00527                        destIter(dul, ad), cf );
00528 }
00529 
00530 template <class SrcIterator, class SrcAccessor,
00531           class DestIterator, class DestAccessor>
00532 inline 
00533 void rohrCornerDetector(
00534            triple<SrcIterator, SrcIterator, SrcAccessor> src,
00535        pair<DestIterator, DestAccessor> dest,
00536        double scale)
00537 {
00538     rohrCornerDetector(src.first, src.second, src.third,
00539                             dest.first, dest.second,
00540                 scale);
00541 }
00542 
00543 /********************************************************/
00544 /*                                                      */
00545 /*                 beaudetCornerDetector                */
00546 /*                                                      */
00547 /********************************************************/
00548 
00549 /** \brief Find corners in an image (4).
00550 
00551     This algorithm implements a corner detector  
00552     according to [P.R. Beaudet: <em> "Rotationally Invariant Image Operators"</em>, 
00553     Proc. Intl. Joint Conf. on Pattern Recognition, Kyoto, Japan, 1978, pp. 579-583]. 
00554     
00555     The algorithm calculates the corner strength as the negative determinant of the 
00556     \link CommonConvolutionFilters#hessianMatrixOfGaussian Hessian Matrix\endlink. 
00557     The local maxima of the corner strength denote the corners in the gray level 
00558     image. 
00559     
00560     The source value type must be a linear algebra, i.e. addition, subtraction, and
00561     multiplication with itself, multiplication with doubles and 
00562     \ref NumericTraits "NumericTraits" must 
00563     be defined.
00564     
00565     <b> Declarations:</b>
00566     
00567     pass arguments explicitly:
00568     \code
00569     namespace vigra {
00570         template <class SrcIterator, class SrcAccessor,
00571               class DestIterator, class DestAccessor>
00572         void
00573         beaudetCornerDetector(SrcIterator sul, SrcIterator slr, SrcAccessor as,
00574                DestIterator dul, DestAccessor ad,
00575                double scale)
00576     }
00577     \endcode
00578     
00579     use argument objects in conjuction with \ref ArgumentObjectFactories:
00580     \code
00581     namespace vigra {
00582         template <class SrcIterator, class SrcAccessor,
00583               class DestIterator, class DestAccessor>
00584         inline 
00585         void beaudetCornerDetector(
00586                triple<SrcIterator, SrcIterator, SrcAccessor> src,
00587                pair<DestIterator, DestAccessor> dest,
00588                double scale)
00589     }
00590     \endcode
00591     
00592     <b> Usage:</b>
00593     
00594         <b>\#include</b> "<a href="cornerdetection_8hxx-source.html">vigra/cornerdetection.hxx</a>"<br>
00595     Namespace: vigra
00596     
00597     \code
00598     vigra::BImage src(w,h), corners(w,h);
00599     vigra::FImage beaudet_corner_strength(w,h);
00600     
00601     // empty corner image
00602     corners.init(0.0);
00603     ...
00604     
00605     // find corner response at scale 1.0
00606     vigra::beaudetCornerDetector(srcImageRange(src), destImage(beaudet_corner_strength), 
00607                               1.0);
00608     
00609     // find local maxima of corner response, mark with 1
00610     vigra::localMaxima(srcImageRange(beaudet_corner_strength), destImage(corners));
00611     \endcode
00612 
00613     <b> Required Interface:</b>
00614     
00615     \code
00616     SrcImageIterator src_upperleft, src_lowerright;
00617     DestImageIterator dest_upperleft;
00618     
00619     SrcAccessor src_accessor;
00620     DestAccessor dest_accessor;
00621     
00622     SrcAccessor::value_type u = src_accessor(src_upperleft);
00623     double d;
00624     
00625     u = u + u
00626     u = u - u
00627     u = u * u
00628     u = d * u
00629     
00630     dest_accessor.set(u, dest_upperleft);
00631     \endcode
00632 */
00633 template <class SrcIterator, class SrcAccessor,
00634           class DestIterator, class DestAccessor>
00635 void
00636 beaudetCornerDetector(SrcIterator sul, SrcIterator slr, SrcAccessor as,
00637                        DestIterator dul, DestAccessor ad,
00638                double scale)
00639 {
00640     vigra_precondition(scale > 0.0,
00641                  "beaudetCornerDetector(): Scale must be > 0");
00642          
00643     int w = slr.x - sul.x;
00644     int h = slr.y - sul.y;
00645     
00646     if(w <= 0 || h <= 0) return;
00647     
00648     typedef typename 
00649         NumericTraits<typename SrcAccessor::value_type>::RealPromote TmpType;
00650     
00651     typedef BasicImage<TmpType> TmpImage;
00652     
00653     TmpImage gx(w,h);
00654     TmpImage gy(w,h);
00655     TmpImage gxy(w,h);
00656 
00657     hessianMatrixOfGaussian(srcIterRange(sul, slr, as), 
00658                     destImage(gx), destImage(gxy), destImage(gy), 
00659                     scale);
00660     BeaudetCornerFunctor<typename SrcAccessor::value_type > cf;
00661                     
00662     combineThreeImages(srcImageRange(gx), srcImage(gy), srcImage(gxy), 
00663                        destIter(dul, ad), cf );
00664 }
00665 
00666 template <class SrcIterator, class SrcAccessor,
00667           class DestIterator, class DestAccessor>
00668 inline 
00669 void beaudetCornerDetector(
00670            triple<SrcIterator, SrcIterator, SrcAccessor> src,
00671        pair<DestIterator, DestAccessor> dest,
00672        double scale)
00673 {
00674     beaudetCornerDetector(src.first, src.second, src.third,
00675                             dest.first, dest.second,
00676                 scale);
00677 }
00678 
00679 
00680 //@}
00681 
00682 } // namespace vigra
00683 
00684 #endif // VIGRA_CORNERDETECTION_HXX

© Ullrich Köthe (koethe@informatik.uni-hamburg.de)
Cognitive Systems Group, University of Hamburg, Germany

html generated using doxygen and Python
VIGRA 1.2.0 (7 Aug 2003)