37 #ifndef VIGRA_CORNERDETECTION_HXX 
   38 #define VIGRA_CORNERDETECTION_HXX 
   41 #include "numerictraits.hxx" 
   42 #include "stdimage.hxx" 
   43 #include "combineimages.hxx" 
   44 #include "convolution.hxx" 
   45 #include "functortraits.hxx" 
   46 #include "multi_shape.hxx" 
   50 template <
class SrcType>
 
   51 struct CornerResponseFunctor
 
   53     typedef typename NumericTraits<SrcType>::RealPromote argument_type;
 
   54     typedef argument_type result_type;
 
   56     result_type operator()(argument_type a1, 
 
   57                         argument_type a2, argument_type a3)
 const 
   59       return detail::RequiresExplicitCast<result_type>::cast((a1*a2 - a3*a3) - 0.04 * (a1 + a2) * (a1 + a2));
 
   64 class FunctorTraits<CornerResponseFunctor<T> >
 
   65 : 
public FunctorTraitsBase<CornerResponseFunctor<T> >
 
   68     typedef VigraTrueType isTernaryFunctor;
 
   71 template <
class SrcType>
 
   72 struct FoerstnerCornerFunctor
 
   74     typedef typename NumericTraits<SrcType>::RealPromote argument_type;
 
   75     typedef argument_type result_type;
 
   77     result_type operator()(argument_type a1, 
 
   78                            argument_type a2, argument_type a3)
 const 
   80         return (a1*a2 - a3*a3) / (a1 + a2);
 
   85 class FunctorTraits<FoerstnerCornerFunctor<T> >
 
   86 : 
public FunctorTraitsBase<FoerstnerCornerFunctor<T> >
 
   89     typedef VigraTrueType isTernaryFunctor;
 
   92 template <
class SrcType>
 
   93 struct RohrCornerFunctor
 
   95     typedef typename NumericTraits<SrcType>::RealPromote argument_type;
 
   96     typedef argument_type result_type;
 
   98     result_type operator()(argument_type a1, 
 
   99                         argument_type a2, argument_type a3)
 const 
  101         return (a1*a2 - a3*a3);
 
  106 class FunctorTraits<RohrCornerFunctor<T> >
 
  107 : 
public FunctorTraitsBase<RohrCornerFunctor<T> >
 
  110     typedef VigraTrueType isTernaryFunctor;
 
  113 template <
class SrcType>
 
  114 struct BeaudetCornerFunctor
 
  116     typedef typename NumericTraits<SrcType>::RealPromote argument_type;
 
  117     typedef argument_type result_type;
 
  119     result_type operator()(argument_type a1, 
 
  120                         argument_type a2, argument_type a3)
 const 
  122         return (a3*a3 - a1*a2);
 
  127 class FunctorTraits<BeaudetCornerFunctor<T> >
 
  128 : 
public FunctorTraitsBase<BeaudetCornerFunctor<T> >
 
  131     typedef VigraTrueType isTernaryFunctor;
 
  283 template <
class SrcIterator, 
class SrcAccessor,
 
  284           class DestIterator, 
class DestAccessor>
 
  287                        DestIterator dul, DestAccessor ad,
 
  290     vigra_precondition(scale > 0.0,
 
  291                  "cornerResponseFunction(): Scale must be > 0");
 
  293     int w = slr.x - sul.x;
 
  294     int h = slr.y - sul.y;
 
  296     if(w <= 0 || h <= 0) 
return;
 
  299         NumericTraits<typename SrcAccessor::value_type>::RealPromote TmpType;
 
  301     typedef BasicImage<TmpType> TmpImage;
 
  308                     destImage(gx), destImage(gxy), destImage(gy), 
 
  310     CornerResponseFunctor<typename SrcAccessor::value_type > cf;
 
  313                        destIter(dul, ad), cf );
 
  316 template <
class SrcIterator, 
class SrcAccessor,
 
  317           class DestIterator, 
class DestAccessor>
 
  320            triple<SrcIterator, SrcIterator, SrcAccessor> src,
 
  321            pair<DestIterator, DestAccessor> dest,
 
  325                             dest.first, dest.second,
 
  329 template <
class T1, 
class S1,
 
  333                        MultiArrayView<2, T2, S2> dest,
 
  336     vigra_precondition(src.shape() == dest.shape(),
 
  337         "cornerResponseFunction(): shape mismatch between input and output.");
 
  470 template <
class SrcIterator, 
class SrcAccessor,
 
  471           class DestIterator, 
class DestAccessor>
 
  474                        DestIterator dul, DestAccessor ad,
 
  477     vigra_precondition(scale > 0.0,
 
  478                  "foerstnerCornerDetector(): Scale must be > 0");
 
  480     int w = slr.x - sul.x;
 
  481     int h = slr.y - sul.y;
 
  483     if(w <= 0 || h <= 0) 
return;
 
  486         NumericTraits<typename SrcAccessor::value_type>::RealPromote TmpType;
 
  488     typedef BasicImage<TmpType> TmpImage;
 
  495                     destImage(gx), destImage(gxy), destImage(gy), 
 
  497     FoerstnerCornerFunctor<typename SrcAccessor::value_type > cf;
 
  500                        destIter(dul, ad), cf );
 
  503 template <
class SrcIterator, 
class SrcAccessor,
 
  504           class DestIterator, 
class DestAccessor>
 
  507                         pair<DestIterator, DestAccessor> dest,
 
  511                             dest.first, dest.second,
 
  515 template <
class T1, 
class S1,
 
  519                         MultiArrayView<2, T2, S2> dest,
 
  522     vigra_precondition(src.shape() == dest.shape(),
 
  523         "foerstnerCornerDetector(): shape mismatch between input and output.");
 
  654 template <
class SrcIterator, 
class SrcAccessor,
 
  655           class DestIterator, 
class DestAccessor>
 
  658                        DestIterator dul, DestAccessor ad,
 
  661     vigra_precondition(scale > 0.0,
 
  662                  "rohrCornerDetector(): Scale must be > 0");
 
  664     int w = slr.x - sul.x;
 
  665     int h = slr.y - sul.y;
 
  667     if(w <= 0 || h <= 0) 
return;
 
  670         NumericTraits<typename SrcAccessor::value_type>::RealPromote TmpType;
 
  672     typedef BasicImage<TmpType> TmpImage;
 
  679                     destImage(gx), destImage(gxy), destImage(gy), 
 
  681     RohrCornerFunctor<typename SrcAccessor::value_type > cf;
 
  684                        destIter(dul, ad), cf );
 
  687 template <
class SrcIterator, 
class SrcAccessor,
 
  688           class DestIterator, 
class DestAccessor>
 
  691                    pair<DestIterator, DestAccessor> dest,
 
  695                        dest.first, dest.second,
 
  699 template <
class T1, 
class S1,
 
  703                    MultiArrayView<2, T2, S2> dest,
 
  706     vigra_precondition(src.shape() == dest.shape(),
 
  707         "rohrCornerDetector(): shape mismatch between input and output.");
 
  829 template <
class SrcIterator, 
class SrcAccessor,
 
  830           class DestIterator, 
class DestAccessor>
 
  833                        DestIterator dul, DestAccessor ad,
 
  836     vigra_precondition(scale > 0.0,
 
  837                  "beaudetCornerDetector(): Scale must be > 0");
 
  839     int w = slr.x - sul.x;
 
  840     int h = slr.y - sul.y;
 
  842     if(w <= 0 || h <= 0) 
return;
 
  845         NumericTraits<typename SrcAccessor::value_type>::RealPromote TmpType;
 
  847     typedef BasicImage<TmpType> TmpImage;
 
  854                     destImage(gx), destImage(gxy), destImage(gy), 
 
  856     BeaudetCornerFunctor<typename SrcAccessor::value_type > cf;
 
  859                        destIter(dul, ad), cf );
 
  862 template <
class SrcIterator, 
class SrcAccessor,
 
  863           class DestIterator, 
class DestAccessor>
 
  866                       pair<DestIterator, DestAccessor> dest,
 
  870                           dest.first, dest.second,
 
  874 template <
class T1, 
class S1,
 
  878                       MultiArrayView<2, T2, S2> dest,
 
  881     vigra_precondition(src.shape() == dest.shape(),
 
  882         "beaudetCornerDetector(): shape mismatch between input and output.");
 
  893 #endif // VIGRA_CORNERDETECTION_HXX 
void foerstnerCornerDetector(...)
Find corners in an image (2). 
void rohrCornerDetector(...)
Find corners in an image (3). 
void hessianMatrixOfGaussian(...)
Filter image with the 2nd derivatives of the Gaussian at the given scale to get the Hessian matrix...
doxygen_overloaded_function(template<...> void separableConvolveBlockwise) template< unsigned int N
Separated convolution on ChunkedArrays. 
void structureTensor(...)
Calculate the Structure Tensor for each pixel of and image, using Gaussian (derivative) filters...
void beaudetCornerDetector(...)
Find corners in an image (4). 
void combineThreeImages(...)
Combine three source images into destination image. 
void cornerResponseFunction(...)
Find corners in an image (1).