harrisdog Struct Reference
[Functions for detecting corners of various types.]

#include <dog.h>

Inheritance diagram for harrisdog:

List of all members.

---

Detailed Description

Class wrapping the Harris-Laplace detector.

Definition at line 43 of file dog.h.

Public Member Functions
virtual void	operator() (const CVD::Image< CVD::byte > &i, std::vector< CVD::ImageRef > &c, unsigned int N) const

---

Member Function Documentation

void harrisdog::operator()	(	const CVD::Image< CVD::byte > &	i,
		std::vector< CVD::ImageRef > &	c,
		unsigned int	N
	)			const [virtual]

Detecto corners.

Parameters:

	i	Image in which to detect corners
	c	Detected corners are inserted in to this container
	N	Number of corners to detect

Implements DetectN.

Definition at line 226 of file dog.cc.

References HarrisDetector().

{
    int s = GV3::get<int>("harrislaplace.dog.divisions_per_octave", 11);    //Divisions per octave
    int octaves=GV3::get<int>("harrislaplace.dog.octaves", 4, 1);
    double sigma = GV3::get<double>("harrislaplace.dog.sigma", 0.8);

    float hblur = GV3::get<float>("harrislaplace.harris.blur", 2.5);
    float hsigmas = GV3::get<float>("harrislaplace.harris.sigmas", 2.0, 1);

    double k = pow(2, 1.0/s);

    Image<float> im = convert_image(i);

    //convolveGaussian(im, sigma);

    Image<float> d1, d2, d3;
    Image<float> im1, im2, im3;
    c.clear();
    vector<pair<float, ImageRef> > corners;
    corners.reserve(50000);

    int scalemul=1;
    int d1m = 1, d2m = 1, d3m = 1;

    for(int o=0; o < octaves; o++)
    {

        for(int j=0; j < s; j++)
        {
            float delta_sigma = sigma * sqrt(k*k-1);
            //hblur *= sqrt(k*k-1);

            //Blur im, and put the result in blurred.
            //im is already blurred from the previous layers
            Image<float> blurred(im.size(), 0);
            convolveGaussian_fir(im, blurred, delta_sigma);
            
            //For DoG, at this point, we don't need im anymore, since blurred
            //will be used as "im" for the next layer. However, we do need it for 
            //HarrisDoG, since we need to do a HarrisDetect on it.
            Image<float>  diff(im.size(), 0);
            for(fi i1=im.begin(), i2 = blurred.begin(), d = diff.begin(); i1!= im.end(); ++i1, ++i2, ++d)
                *d = (*i2 - *i1);
            
            //Insert the current image, and the current difference
            //in to the ring buffer
            d1 = d2;
            d2 = d3;
            d3 = diff;

            im1 = im2;
            im2 = im3;
            im3 = im;


            im = blurred;

            d1m = d2m;
            d2m = d3m;
            d3m = scalemul;

            //Find maxima
            if(d1.size().x != 0)
            {
                //First, find Harris maxima
                vector<pair<float, ImageRef> > layer_corners;
                HarrisDetector(im2, layer_corners, N, hblur, hsigmas);
                
                //Keep if they are LoG (or really DoG) maxima across scales.
                //The Harris score olny is used.
                for(unsigned int c=0; c < layer_corners.size(); c++)
                    if(is_scale_maximum(d1, d2, d3, layer_corners[c].second))
                        corners.push_back(layer_corners[c]);
            }
            
            sigma *= k;
        }
        
        if(o != octaves - 1)
        {
            scalemul *=2;
            sigma /=2;
            Image<float> tmp(im.size()/2);
            halfSample(im,tmp);
            im=tmp;
        }
    }
    

    if(corners.size() > N)
    {
        nth_element(corners.begin(), corners.begin() + N, corners.end());
        corners.resize(N);
    }
    
    c.clear();

    for(unsigned int i=0; i < corners.size(); i++)
        c.push_back(corners[i].second);

}

---

The documentation for this struct was generated from the following files:

• dog.h
• dog.cc

---