[ VIGRA Homepage | Class Index | Function Index | File Index | Main Page ]
![]() |
vigra/cornerdetection.hxx | ![]() |
---|
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ö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ängigen 00409 Transformationen zur Ermittlung der optischen Flusses in Bildfolgen"</em>, 00410 Diploma thesis, Inst. fü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) |
html generated using doxygen and Python
|