Corner Detection

Functions
template<... >
void	beaudetCornerDetector (...)
	Find corners in an image (4). More...
template<... >
void	cornerResponseFunction (...)
	Find corners in an image (1). More...
template<... >
void	foerstnerCornerDetector (...)
	Find corners in an image (2). More...
template<... >
void	rohrCornerDetector (...)
	Find corners in an image (3). More...

Detailed Description

Measure the 'cornerness' at each pixel. Note: The Kitchen-Rosenfeld detector is not implemented because of its inferior performance. The SUSAN detector is missing because it's patented.

Function Documentation

void vigra::cornerResponseFunction

(

...

)

Find corners in an image (1).

This algorithm implements the so called 'corner response function' to measure the 'cornerness' of each pixel in the image, according to [C.G. Harris and M.J. Stevens: "A Combined Corner and Edge Detector", Proc. of 4th Alvey Vision Conference, 1988]. Several studies have found this to be a very robust corner detector, although it moves the corners somewhat into one region, depending on the scale.

The algorithm first determines the structure tensor at each pixel by calling structureTensor(). Then the entries of the structure tensor are combined as

The local maxima of the corner response denote the corners in the gray level image.

The source value type must be a linear algebra, i.e. addition, subtraction, and multiplication with itself, multiplication with doubles and NumericTraits must be defined.

Declarations:

pass 2D array views:

namespace vigra {
    template <class T1, class S1,
              class T2, class S2>
    void 
    cornerResponseFunction(MultiArrayView<2, T1, S1> const & src,
                           MultiArrayView<2, T2, S2> dest,
                           double scale);
}

show deprecated declarations

pass Image Iterators and Data Accessors :

namespace vigra {
    template <class SrcIterator, class SrcAccessor,
              class DestIterator, class DestAccessor>
    void
    cornerResponseFunction(SrcIterator sul, SrcIterator slr, SrcAccessor as,
                           DestIterator dul, DestAccessor ad,
                           double scale)
}

use argument objects in conjunction with Argument Object Factories :

namespace vigra {
    template <class SrcIterator, class SrcAccessor,
              class DestIterator, class DestAccessor>
    void cornerResponseFunction(
               triple<SrcIterator, SrcIterator, SrcAccessor> src,
               pair<DestIterator, DestAccessor> dest,
               double scale)
}

Usage:

#include <vigra/cornerdetection.hxx>
Namespace: vigra

MultiArray<2, unsigned char> src(w,h), corners(w,h);
MultiArray<2, float>         corner_response(w,h);
...

// find corner response at scale 1.0
cornerResponseFunction(src, corner_response, 1.0);

// find local maxima of corner response, mark with 1
localMaxima(corner_response, corners);

// threshold corner response to keep only strong corners (above 400.0)
transformImage(corner_response, corner_response,
               Threshold<double, double>(400.0, std::numeric_limits<double>::max(), 0.0, 1.0)); 

// combine thresholding and local maxima
combineTwoImages(corners, corner_response,
                 corners, std::multiplies<float>());

show deprecated examples

vigra::BImage src(w,h), corners(w,h);
vigra::FImage corner_response(w,h);

// empty corner image
corners.init(0.0);
...

// find corner response at scale 1.0
vigra::cornerResponseFunction(srcImageRange(src), destImage(corner_response), 
                       1.0);

// find local maxima of corner response, mark with 1
vigra::localMaxima(srcImageRange(corner_response), destImage(corners));

// threshold corner response to keep only strong corners (above 400.0)
transformImage(srcImageRange(corner_response), destImage(corner_response),
      vigra::Threshold<double, double>(
           400.0, std::numeric_limits<double>::max(), 0.0, 1.0)); 

// combine thresholding and local maxima
vigra::combineTwoImages(srcImageRange(corners), srcImage(corner_response),
                 destImage(corners), std::multiplies<float>());

Required Interface:

SrcImageIterator src_upperleft, src_lowerright;
DestImageIterator dest_upperleft;

SrcAccessor src_accessor;
DestAccessor dest_accessor;

SrcAccessor::value_type u = src_accessor(src_upperleft);
double d;

u = u + u
u = u - u
u = u * u
u = d * u

dest_accessor.set(u, dest_upperleft);

void vigra::foerstnerCornerDetector

(

...

)

Find corners in an image (2).

This algorithm implements the so called 'Foerstner Corner Detector' to measure the 'cornerness' of each pixel in the image, according to [W. Förstner: "A feature based correspondence algorithms for image matching", Intl. Arch. Photogrammetry and Remote Sensing, vol. 24, pp 160-166, 1986]. It is also known as the "Plessey Detector" by Harris. However, it should not be confused with the "\link cornerResponseFunction Corner Response Function\endlink ", another detector invented by Harris.

The algorithm first determines the structure tensor at each pixel by calling structureTensor(), where the given scale is used for both the inner and outer scales. Then the entries of the structure tensor are combined as

The local maxima of the corner strength denote the corners in the gray level image. Its performance is similar to the cornerResponseFunction().

The source value type must be a division algebra, i.e. addition, subtraction, multiplication, and division with itself, multiplication with doubles and NumericTraits must be defined.

Declarations:

pass 2D array views:

namespace vigra {
    template <class T1, class S1,
              class T2, class S2>
    void
    foerstnerCornerDetector(MultiArrayView<2, T1, S1> const & src,
                            MultiArrayView<2, T2, S2> dest,
                            double scale);
}

show deprecated declarations

pass Image Iterators and Data Accessors :

namespace vigra {
    template <class SrcIterator, class SrcAccessor,
              class DestIterator, class DestAccessor>
    void
    foerstnerCornerDetector(SrcIterator sul, SrcIterator slr, SrcAccessor as,
                           DestIterator dul, DestAccessor ad,
                           double scale)
}

use argument objects in conjunction with Argument Object Factories :

namespace vigra {
    template <class SrcIterator, class SrcAccessor,
              class DestIterator, class DestAccessor>
     void foerstnerCornerDetector(
               triple<SrcIterator, SrcIterator, SrcAccessor> src,
               pair<DestIterator, DestAccessor> dest,
               double scale)
}

Usage:

#include <vigra/cornerdetection.hxx>
Namespace: vigra

MultiArray<2, unsigned char> src(w,h), corners(w,h);
MultiArray<2, float>         foerstner_corner_strength(w,h);
...

// find corner response at scale 1.0
foerstnerCornerDetector(src, foerstner_corner_strength, 1.0);

// find local maxima of corner response, mark with 1
localMaxima(foerstner_corner_strength, corners);

show deprecated examples

vigra::BImage src(w,h), corners(w,h);
vigra::FImage foerstner_corner_strength(w,h);

// empty corner image
corners.init(0.0);
...

// find corner response at scale 1.0
vigra::foerstnerCornerDetector(srcImageRange(src), destImage(foerstner_corner_strength), 
                               1.0);

// find local maxima of corner response, mark with 1
vigra::localMaxima(srcImageRange(foerstner_corner_strength), destImage(corners));

Required Interface:

SrcImageIterator src_upperleft, src_lowerright;
DestImageIterator dest_upperleft;

SrcAccessor src_accessor;
DestAccessor dest_accessor;

SrcAccessor::value_type u = src_accessor(src_upperleft);
double d;

u = u + u
u = u - u
u = u * u
u = u / u
u = d * u

dest_accessor.set(u, dest_upperleft);

void vigra::rohrCornerDetector

(

...

)

Find corners in an image (3).

This algorithm implements yet another structure tensor-based corner detector, according to [K. Rohr: "Untersuchung von grauwertabh&auml;ngigen Transformationen zur Ermittlung der optischen Flusses in Bildfolgen", Diploma thesis, Inst. für Nachrichtensysteme, Univ. Karlsruhe, 1987, see also K. Rohr: "Modelling and Identification of Characteristic Intensity Variations", Image and Vision Computing 10:2 (1992) 66-76 and K. Rohr: "Localization Properties of Direct Corner Detectors", J. of Mathematical Imaging and Vision 4:2 (1994) 139-150].

The algorithm first determines the structure tensor at each pixel by calling structureTensor(), where the given scale is used for both the inner and outer scales. Then the entries of the structure tensor are combined as

The local maxima of the corner strength denote the corners in the gray level image. Its performance is similar to the cornerResponseFunction().

The source value type must be a linear algebra, i.e. addition, subtraction, and multiplication with itself, multiplication with doubles and NumericTraits must be defined.

Declarations:

pass 2D array views:

namespace vigra {
    template <class T1, class S1,
              class T2, class S2>
    void
    rohrCornerDetector(MultiArrayView<2, T1, S1> const & src,
                       MultiArrayView<2, T2, S2> dest,
                       double scale);
}

show deprecated declarations

pass Image Iterators and Data Accessors :

namespace vigra {
    template <class SrcIterator, class SrcAccessor,
              class DestIterator, class DestAccessor>
    void
    rohrCornerDetector(SrcIterator sul, SrcIterator slr, SrcAccessor as,
                       DestIterator dul, DestAccessor ad,
                       double scale)
}

use argument objects in conjunction with Argument Object Factories :

namespace vigra {
    template <class SrcIterator, class SrcAccessor,
              class DestIterator, class DestAccessor>
    void rohrCornerDetector(
               triple<SrcIterator, SrcIterator, SrcAccessor> src,
               pair<DestIterator, DestAccessor> dest,
               double scale)
}

Usage:

#include <vigra/cornerdetection.hxx>
Namespace: vigra

MultiArray<2, unsigned char> src(w,h), corners(w,h);
MultiArray<2, float>         rohr_corner_strength(w,h);
...

// find corner response at scale 1.0
rohrCornerDetector(src, rohr_corner_strength, 1.0);

// find local maxima of corner response, mark with 1
localMaxima(rohr_corner_strength, corners);

show deprecated examples

vigra::BImage src(w,h), corners(w,h);
vigra::FImage rohr_corner_strength(w,h);

// empty corner image
corners.init(0.0);
...

// find corner response at scale 1.0
vigra::rohrCornerDetector(srcImageRange(src), destImage(rohr_corner_strength), 
                          1.0);

// find local maxima of corner response, mark with 1
vigra::localMaxima(srcImageRange(rohr_corner_strength), destImage(corners));

Required Interface:

SrcImageIterator src_upperleft, src_lowerright;
DestImageIterator dest_upperleft;

SrcAccessor src_accessor;
DestAccessor dest_accessor;

SrcAccessor::value_type u = src_accessor(src_upperleft);
double d;

u = u + u
u = u - u
u = u * u
u = d * u

dest_accessor.set(u, dest_upperleft);

void vigra::beaudetCornerDetector

(

...

)

Find corners in an image (4).

This algorithm implements a corner detector according to [P.R. Beaudet: "Rotationally Invariant Image Operators", Proc. Intl. Joint Conf. on Pattern Recognition, Kyoto, Japan, 1978, pp. 579-583].

The algorithm calculates the corner strength as the negative determinant of the Hessian Matrix. The local maxima of the corner strength denote the corners in the gray level image.

The source value type must be a linear algebra, i.e. addition, subtraction, and multiplication with itself, multiplication with doubles and NumericTraits must be defined.

Declarations:

pass 2D array views:

namespace vigra {
    template <class T1, class S1,
              class T2, class S2>
    void
    beaudetCornerDetector(MultiArrayView<2, T1, S1> const & src,
                          MultiArrayView<2, T2, S2> dest,
                          double scale);
}

show deprecated declarations

pass Image Iterators and Data Accessors :

namespace vigra {
    template <class SrcIterator, class SrcAccessor,
              class DestIterator, class DestAccessor>
    void
    beaudetCornerDetector(SrcIterator sul, SrcIterator slr, SrcAccessor as,
                       DestIterator dul, DestAccessor ad,
                       double scale)
}

use argument objects in conjunction with Argument Object Factories :

namespace vigra {
    template <class SrcIterator, class SrcAccessor,
              class DestIterator, class DestAccessor>
    void beaudetCornerDetector(
               triple<SrcIterator, SrcIterator, SrcAccessor> src,
               pair<DestIterator, DestAccessor> dest,
               double scale)
}

Usage:

#include <vigra/cornerdetection.hxx>
Namespace: vigra

MultiArray<2, unsigned char> src(w,h), corners(w,h);
MultiArray<2, float>         beaudet_corner_strength(w,h);
...

// find corner response at scale 1.0
beaudetCornerDetector(src, beaudet_corner_strength, 1.0);

// find local maxima of corner response, mark with 1
localMaxima(beaudet_corner_strength, corners);

show deprecated examples

vigra::BImage src(w,h), corners(w,h);
vigra::FImage beaudet_corner_strength(w,h);

// empty corner image
corners.init(0.0);
...

// find corner response at scale 1.0
vigra::beaudetCornerDetector(srcImageRange(src), destImage(beaudet_corner_strength), 
                          1.0);

// find local maxima of corner response, mark with 1
vigra::localMaxima(srcImageRange(beaudet_corner_strength), destImage(corners));

Required Interface:

SrcImageIterator src_upperleft, src_lowerright;
DestImageIterator dest_upperleft;

SrcAccessor src_accessor;
DestAccessor dest_accessor;

SrcAccessor::value_type u = src_accessor(src_upperleft);
double d;

u = u + u
u = u - u
u = u * u
u = d * u

dest_accessor.set(u, dest_upperleft);