Measuring the repeatability of a detector

---

Detailed Description

Functions to load a repeatability dataset, and compute the repeatability of a list of detected points.

The dataset

The dataset consists of a number of registered images. The images are stored in frames/frame_X.pgm where X is an integer counting from zero. The frames must all be the same size. The warps are stored in waprs/warp_Y_Z.warp. The file warp_Y_Z.warp contains one line for every pixel in image Y (pixels arranged in raster-scan order). The line is the position that the pixel warps to in image Z. If location of -1, -1 indicates that this pixel does not appear in image Z.

Functions
vector< ImageRef >	generate_disc (int radius)
Image< bool >	paint_circles (const vector< ImageRef > &corners, const vector< ImageRef > &circle, ImageRef size)
float	compute_repeatability (const vector< vector< Image< array< float, 2 > > > > &warps, const vector< vector< ImageRef > > &corners, int r, ImageRef size)
double	compute_repeatability_exact (const vector< vector< Image< array< float, 2 > > > > &warps, const vector< vector< ImageRef > > &corners, double r)
void	compute_repeatability_all (const vector< Image< byte > > &images, const vector< vector< Image< array< float, 2 > > > > &warps, const DetectN &detector, const vector< int > &cpf, double fuzz)
void	compute_repeatability_noise (const vector< Image< byte > > &images, const vector< vector< Image< array< float, 2 > > > > &warps, const DetectN &detector, int cpf, float n, double fuzz)
void	mmain (int argc, char **argv)

---

Function Documentation

vector<ImageRef> generate_disc

(

int

radius

)

Generate a disc of ImageRefs.

Parameters:

radius

Radius of the disc

Returns:

the disc of ImageRefs

Definition at line 131 of file learn_detector.cc.

Referenced by compute_repeatability().

{
    vector<ImageRef> ret;
    ImageRef p;

    for(p.y = -radius; p.y <= radius; p.y++)
        for(p.x = -radius; p.x <= radius; p.x++)
            if((int)p.mag_squared() <= radius)
                ret.push_back(p);
    return ret;
}

Image<bool> paint_circles	(	const vector< ImageRef > &	corners,
		const vector< ImageRef > &	circle,
		ImageRef	size
	)

Paint shapes (a vector<ImageRef>) safely in to an image This is used to paint discs at corner locations in order to perform rapid proximity checking.

Parameters:

	corners	Locations to paint shapes
	circle	Shape to paint
	size	Image size to be painted in to

Returns:

Image with shapes painted in to it.

Definition at line 153 of file learn_detector.cc.

Referenced by compute_repeatability().

{   
    Image<bool> im(size, 0);


    for(unsigned int i=0; i < corners.size(); i++)
        for(unsigned int j=0; j < circle.size(); j++)
            if(im.in_image(corners[i] + circle[j]))
                im[corners[i] + circle[j]] = 1;

    return im;
}

float compute_repeatability	(	const vector< vector< Image< array< float, 2 > > > > &	warps,
		const vector< vector< ImageRef > > &	corners,
		int	r,
		ImageRef	size
	)

Computes repeatability the quick way, by caching, but has small rounding errors.

This function paints a disc of true around each detected corner in to an image. If a corner warps to a pixel which has the value true then it is a repeat.

Parameters:

	warps	Every warping where warps[i][j] specifies warp from image i to image j.
	corners	Detected corners
	r	A corner must be as close as this to be considered repeated
	size	Size of the region for cacheing. All images must be this size.

Returns:

The repeatability.

Definition at line 176 of file learn_detector.cc.

References generate_disc(), ir_rounded(), and paint_circles().

Referenced by learn_detector().

{
    unsigned int n = corners.size();

    vector<ImageRef> disc = generate_disc(r);

    vector<Image<bool> >  detected;
    for(unsigned int i=0; i < n; i++)
        detected.push_back(paint_circles(corners[i], disc, size));
    
    int corners_tested = 0;
    int good_corners = 0;

    for(unsigned int i=0; i < n; i++)
        for(unsigned int j=0; j < n; j++)
        {
            if(i==j)
                continue;
            
            for(unsigned int k=0; k < corners[i].size(); k++)
            {   
                ImageRef dest = ir_rounded(warps[i][j][corners[i][k]]);

                if(dest.x != -1)
                {
                    corners_tested++;
                    if(detected[j][dest])
                        good_corners++;
                }
            }
        }
    
    return 1.0 * good_corners / (DBL_EPSILON + corners_tested);
}

double compute_repeatability_exact	(	const vector< vector< Image< array< float, 2 > > > > &	warps,
		const vector< vector< ImageRef > > &	corners,
		double	r
	)

Computes repeatability the slow way to avoid rounding errors, by comparing the warped corner position to every detected corner.

A warp to x=-1, y=? is considered to be outside the image, so it is not counted.

Parameters:

	warps	Every warping where warps[i][j] specifies warp from image i to image j.
	corners	Detected corners
	r	A corner must be as close as this to be considered repeated

Returns:

The repeatability. No corners means zero repeatability.

Definition at line 76 of file test_repeatability.cc.

Referenced by compute_repeatability_all(), and compute_repeatability_noise().

{
    unsigned int n = corners.size();

    int repeatable_corners = 0;
    int repeated_corners = 0;

    r *= r;

    for(unsigned int i=0; i < n; i++)
        for(unsigned int j=0; j < n; j++)
        {
            if(i==j)
                continue;

            for(unsigned int k=0; k < corners[i].size(); k++)
            {
                const array<float, 2>& p = warps[i][j][corners[i][k]];

                if(p[0] != -1) //pixel does not warp to inside image j
                {

                    repeatable_corners++;

                    for(unsigned int l=0; l < corners[j].size(); l++)
                    {
                        Vector<2> d = Vec(p) - vec(corners[j][l]);

                        if(d*d < r)
                        {
                            repeated_corners++;
                            break;
                        }
                    }
                }
            }
        }
    
    return 1.0 * (repeated_corners) / (repeatable_corners + DBL_EPSILON);
}

void compute_repeatability_all	(	const vector< Image< byte > > &	images,
		const vector< vector< Image< array< float, 2 > > > > &	warps,
		const DetectN &	detector,
		const vector< int > &	cpf,
		double	fuzz
	)

This wrapper function computed the repeatability for a given detector and a given container of corner densities.

The result is printed to stdout.

Parameters:

	images	Images to test repeatability on
	warps	Every warping where warps[i][j] specifies warp from image i to image j.
	detector	Pointer to the corner detection function.
	cpf	The number of corners per frame to be tested.
	fuzz	A corner must be as close as this to be considered repeated

Definition at line 126 of file test_repeatability.cc.

References compute_repeatability_exact().

Referenced by mmain().

{
    
    for(unsigned int i=0; i < cpf.size(); i++)
    {
        //Detect corners in each if the frames
        vector<vector<ImageRef> > corners;
        double  num_corners = 0;

        for(unsigned int j=0; j < images.size(); j++)
        {
            vector<ImageRef> c;
            detector(images[j], c, cpf[i]);
            corners.push_back(c);

            num_corners += c.size();
        }

        //Compute and print the repeatability.
        cout << print << num_corners / images.size() << compute_repeatability_exact(warps, corners, fuzz);
    }
}

void compute_repeatability_noise	(	const vector< Image< byte > > &	images,
		const vector< vector< Image< array< float, 2 > > > > &	warps,
		const DetectN &	detector,
		int	cpf,
		float	n,
		double	fuzz
	)

This wrapper function computed the repeatability for a given detector and a given container of corner densities for variable levels of noise, from 0 to n in steps of 1 The result is printed to stdout.

Parameters:

	images	Images to test repeatability on
	warps	Every warping where warps[i][j] specifies warp from image i to image j.
	detector	Pointer to the corner detection function.
	cpf	The number of corners per frame to be tested.
	n	The initial noise level
	fuzz	A corner must be as close as this to be considered repeated

Definition at line 161 of file test_repeatability.cc.

References compute_repeatability_exact().

Referenced by mmain().

{
        
    for(float s=0; s <= n; s++)
    {


        //Detect corners in each if the frames
        vector<vector<ImageRef> > corners;
        double  num_corners = 0;

        for(unsigned int j=0; j < images.size(); j++)
        {
            Image<byte> ni = images[j].copy_from_me();

            //Add noise to the image
            for(Image<byte>::iterator i=ni.begin(); i != ni.end(); i++)
                *i = max(0, min(255, (int)floor(*i + rand_g() * s + .5)));

            vector<ImageRef> c;
            detector(ni, c, cpf);
            corners.push_back(c);

            num_corners += c.size();
        }

        //Compute and print the repeatability.
        cout << print << s << compute_repeatability_exact(warps, corners, fuzz) << num_corners / images.size();
    }
}

void mmain	(	int	argc,
		char **	argv
	)

This is the driver function.

It reads the command line arguments and calls functions to load the data and compute the repeatability.

Parameters:

	argc	Number of command line argumentsd.
	argv	Pointer to command line arguments.

Definition at line 199 of file test_repeatability.cc.

References compute_repeatability_all(), compute_repeatability_noise(), get_detector(), and load_data().

Referenced by main().

{
    GUI.LoadFile("test_repeatability.cfg");
    GUI.parseArguments(argc, argv);

    vector<Image<byte> > images;
    vector<vector<Image<array<float, 2> > > > warps;


    int n = GV3::get<int>("num", 2, 1);
    string dir = GV3::get<string>("dir", "./", 1);
    string format = GV3::get<string>("type", "cambridge", 1);
    double fuzz = GV3::get<double>("r", 5, 1);
    vector<int> cpf = GV3::get<vector<int> >("cpf", "0 10 20 30 40 50 60 70 80 90 100 150 200 250 300 350 400 450 500 550 600 650 700 750 800 850 900 950 1000 1100 1200 1300 1400 1500 1600 1700 1800 1900 2000 2200", 1);
    int ncpf = GV3::get<int>("ncpf", 500, 1);
    float nmax = GV3::get<int>("nmax", 50, 1);
    string test = GV3::get<string>("test", "normal", 1);
    
    auto_ptr<DetectN> detector = get_detector();

    rpair(images, warps) = load_data(dir, n, format);
    
    if(test == "noise")
        compute_repeatability_noise(images, warps, *detector, ncpf, nmax, fuzz);
    else
        compute_repeatability_all(images, warps, *detector, cpf, fuzz);

}

---