detectors.cc

/*

    This file is part of the FAST-ER machine learning system.
    Copyright (C) 2008  Edward Rosten and Los Alamos National Laboratory

    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 2 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License along
    with this program; if not, write to the Free Software Foundation, Inc.,
    51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/
#include "detectors.h"
#include "harrislike.h"
#include "dog.h"
#ifdef USESUSAN
	#include "susan.h"
#endif
#include "cvd_fast.h"
//#include "faster_block.h"
#include "faster_detector.h"

#include <memory>
#include <cstdlib>
#include <gvars3/instances.h>

using namespace std;
using namespace CVD;
using namespace GVars3;

/** This takes a detector which requires a threshold and uses binary search to get as
close as possible to the requested number of corners.

@param i The image in which to detect corners.
@param c The detected corners to be returned.
@param N The target number of corners.
@param detector The corner detector.
@ingroup gDetect
*/
int binary_search_threshold(const Image<CVD::byte>& i, vector<ImageRef>& c, unsigned int N, const DetectT& detector)
{
	//Corners for high, low and midpoint thresholds.
	vector<ImageRef> ch, cl, cm;
	
	//The high and low thresholds.
	unsigned int t_high = 256;
	unsigned int t_low = 0;


	detector(i, ch, t_high);
	detector(i, cl, t_low);

	while(t_high > t_low + 1)
	{
	
		cm.clear();
		unsigned int t = (t_high + t_low	) / 2;
		detector(i, cm, t);

		if(cm.size() == N)
		{
			c = cm;
			return t;
		}
		else if(cm.size() < N) //If we detected too few points, then the t is too high
		{
			t_high = t;
			ch = cm;
		}
		else //We detected too many points to t is too low.
		{
			t_low = t;
			cl = cm;
		}
	}

	//Pick the closest
	//If there is ambiguity, go with the lower threshold (more corners).
	//The only reason for this is that the evaluation code in the FAST-ER
	//system uses this rule.
	if( N - ch.size() >= cl.size() - N)
	{
		c = cl;
		return t_low;
	}
	else
	{ 
		c = ch;
		return t_high;
	}
}

///This class wraps a ::DetectT class with ::binary_search_threshold and presents
///is as a DetectN class.
///@ingroup gDetect
struct SearchThreshold:public DetectN
{
	///@param d Detector to wrap. This will be managed by SearchThreshold
	SearchThreshold(DetectT* d)
	:detector(d)
	{
	}
    
	///Detect corners
	///@param im Image in which to detect corners
	///@param corners Detected corners are inserted in to this array
	///@param N number of corners to detect
	virtual void operator()(const Image<CVD::byte>& im, vector<ImageRef>& corners, unsigned int N)const
	{
		int t = binary_search_threshold(im, corners, N, *detector);	
	}
	
	private: 
	///Detector to wrap
	unique_ptr<DetectT> detector; 
};

///@ingroup gDetect
///Detector which randomly scatters corners around an image.
struct Random:public DetectN
{
	///Detect corners by scattering points around at random
	///@param im Image in which to detect corners
	///@param corners Detected corners are inserted in to this array
	///@param N number of corners to detect
	virtual void operator()(const Image<CVD::byte>& im, vector<ImageRef>& corners, unsigned int N)const
	{
		for(unsigned int i=0; i < N; i++)
			corners.push_back(ImageRef(rand() % im.size().x, rand() % im.size().y));
	}
};

///Very simple factory function for getting detector objects.
///Paramaters (including the detector type) are drawn from 
///the GVars database. The parameter "detector" determines the
///detector type. Valid options are:
///  - \link ::Random random \endlink Randomly scatter corners around the image.
///  - \link ::dog dog \endlink Difference of Gaussians detector
///  - \link ::harrisdog harrisdog \endlink Harris-Laplace (actually implemented as Harris-DoG) detector
///  - \link ::HarrisDetect harris\endlink Harris detector with Gaussian blur
///  - \link ::ShiTomasiDetect shitomasi\endlink Shi-Tomasi detector
///  - \link ::SUSAN susan\endlink Reference implementation of the SUSAN detector
///  - \link ::fast_9 fast9\endlink libCVD's builtin FAST-9 detector
///  - \link ::fast_9_old fast9old\endlink libCVD's builtin FAST-9 detector with the old
///          scoring algorithm, as seen in [Rosten, Drummond 2006].
///  - \link ::fast_12 fast12\endlink libCVD's builtin FAST-12 detector
///  - \link ::faster_learn faster2\endlink A FAST-ER detector loaded from a file containing the tree
///@ingroup gDetect
unique_ptr<DetectN> get_detector()
{
	
	string d = GV3::get<string>("detector", "fast9", 1);
	
	if(d == "random")
		return unique_ptr<DetectN>(new Random);
	else if(d == "dog")
		return unique_ptr<DetectN>(new dog);
	else if(d == "harrisdog")
		return unique_ptr<DetectN>(new harrisdog);
	else if(d == "shitomasi")
		return unique_ptr<DetectN>(new ShiTomasiDetect);
	else if(d == "harris")
		return unique_ptr<DetectN>(new HarrisDetect);
	#ifdef USESUSAN
		else if(d == "susan")
			return unique_ptr<DetectN>(new SearchThreshold(new SUSAN));
	#endif
	else if(d == "fast9")
		return unique_ptr<DetectN>(new SearchThreshold(new fast_9));
	else if(d == "fast9old")
		return unique_ptr<DetectN>(new SearchThreshold(new fast_9_old));
	else if(d == "fast12")
		return unique_ptr<DetectN>(new SearchThreshold(new fast_12));
	else if(d == "faster2")
		return unique_ptr<DetectN>(new SearchThreshold(new faster_learn(GV3::get<string>("faster2"))));
	else
	{
		cerr << "Unknown detector: " << d << endl;
		exit(1);
	}
}