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

#include <dog.h>

Inheritance diagram for dog:

List of all members.

---

Detailed Description

Class wrapping the Difference of Gaussians detector.

Definition at line 32 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 dog::operator()	(	const CVD::Image< CVD::byte > &	i,
		std::vector< CVD::ImageRef > &	c,
		unsigned int	N
	)			const [virtual]

Detect 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 109 of file dog.cc.

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

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

    double sigma = GV3::get<double>("dog.sigma", 0.8, 1);

    Image<float> im = convert_image(i);

    convolveGaussian_fir(im, im, sigma);
    

    Image<float> d1, d2, d3;
    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);
            Image<float> blurred(im.size());
            convolveGaussian_fir(im, blurred, delta_sigma);
            
            for(fi i1=im.begin(), i2 = blurred.begin(); i1!= im.end(); ++i1, ++i2)
                *i1 = (*i2 - *i1);

            //im is now dog
            //blurred 

            d1 = d2;
            d2 = d3;
            d3 = im;
            im = blurred;

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

            //Find maxima
            if(d1.size().x != 0)
            {
                if(d1.size() == d2.size())
                    if(d2.size() == d3.size())
                        local_maxima<Equal, Equal>(d1, d2, d3, corners, d2m);
                    else
                        local_maxima<Equal, Smaller>(d1, d2, d3, corners, d2m);
                else
                    if(d2.size() == d3.size())
                        local_maxima<Larger, Equal>(d1, d2, d3, corners, d2m);
                    else
                        local_maxima<Larger, Smaller>(d1, d2, d3, corners, d2m);
            }
            

            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);
    }


    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

---