Curvature Corner Detector. More...

#include <CornerDetectorCSS.h>

Inheritance diagram for icl::cv::CornerDetectorCSS:

Classes
struct	GaussianKernel
	1 dim gaussian kernel More...
Public Member Functions
	CornerDetectorCSS (float angle_thresh=162., float rc_coeff=1.5, float sigma=3., float curvature_cutoff=100., float straight_line_thresh=0.1, bool accurate=false)
	Default constructor with given arguments.
	~CornerDetectorCSS ()
	Destructor.
virtual void	setPropertyValue (const std::string &propertyName, const utils::Any &value) throw (utils::ICLException)
	sets value of a property (always call call_callbacks(propertyName) or Configurable::setPropertyValue)
virtual std::vector< std::string >	getPropertyList () const
	returns Configurable property list
virtual std::string	getPropertyType (const std::string &propertyName) const
	returns type of given property
virtual std::string	getPropertyInfo (const std::string &propertyName) const
	returns info for given property
virtual utils::Any	getPropertyValue (const std::string &propertyName) const
	returns value for given property
virtual int	getPropertyVolatileness (const std::string &propertyName) const
	returns volatileness for given property
virtual std::string	getPropertyToolTip (const std::string &propertyName) const
	returns property descriptions
template<class T >
ICLCV_API const std::vector < std::vector< utils::Point32f > > &	detectCorners (const std::vector< std::vector< T > > &boundaries, const std::vector< icl32f > &sigmas)
	detects the corners in the passed contour
template<class T >
ICLCV_API const std::vector < utils::Point32f > &	detectCorners (const std::vector< T > &boundary)
const std::vector < utils::Point32f > &	getLastCorners () const
	returns the result of last detectCorners call
void	setAngleThreshold (float value)
void	setRCCoeff (float value)
void	setSigma (float value)
void	setCurvatureCutoff (float value)
void	setStraightLineThreshold (float value)
void	setAccurate (bool value)
float	getAngleThreshold () const
float	getRCCoeff () const
float	getSigma () const
float	getCurvatureCutoff () const
float	getStraightLineThreshold () const
bool	getAccurate () const
Static Public Member Functions
static int	gaussian (GaussianKernel &gauss, float sigma, float cutoff)
	calculates a normalized 1d gaussian std::vector
static void	convolute_1D (float vec, int dim, float kernel, int kernelDim, float *dst)
	Small wrapper for ippsConv_32f.
Private Member Functions
int	gauss_radius (float sigma, float cutoff)
void	fill_gauss (float *mask, float sigma, int width)
void	convolute (const float data, int data_length, const float mask, int mask_length, float *convoluted)
void	calculate_curvatures (const float smoothed_x, const float smoothed_y, int length, float curvature_cutoff, float *curvatures)
void	calculate_curvatures_bulk (int array_length, int num_boundaries, const int lengths, const int indices, const int indices_padded, const float smoothed_x, const float smoothed_y, float curvature_cutoff, float curvature)
int	findExtrema (int extrema, int num_extrema_out, float *k, int length)
void	removeRoundCorners (float rc_coeff, int maxima_offset, float k, int length, int extrema, int num_extrema, int new_extrema, int num_new_extrema_out)
void	removeRoundCornersAccurate (float rc_coeff, int maxima_offset, float k, int length, int extrema, int num_extrema, int extrema_out, int num_extrema_out)
float	cornerAngle (float x, float y, int prev, int current, int next, int length, float straight_line_thresh)
float	cornerAngleAccurate (float x, float y, int prev, int current, int next, int array_length, float straight_line_thresh)
void	removeFalseCorners (float angle_thresh, float x, float y, float k, int length, int maxima, int num_maxima, int maxima_out, int num_maxima_out)
Private Attributes
float	angle_thresh
	parameters
float	rc_coeff
float	sigma
float	curvature_cutoff
float	straight_line_thresh
bool	accurate
	use acurate corner detection
std::vector< utils::Point32f >	corners
std::vector< std::vector < utils::Point32f > >	corners_list
CLCurvature *	clcurvature
bool	useOpenCL

Detailed Description

Curvature Corner Detector.

Implementation of the Curvature Scale Space corner detection algorithm described in the paper "Corner detector based on global and local curvature properties", by Chen He, Xiao and Yung, Nelson H.C. in Optical Engineering 2008. There also is a Matlab implementation of the algorithm by Chen He, Xiao available at http://www.mathworks.com/matlabcentral/fileexchange/7652

The algorithm takes an array of contour points as input, that are then smoothed by a gaussian filter. Afterwards the curvature function is calculated and its maxima positions are taken as corner candidates. Afterwards all candidates which belong to round or "false" (noise induced, etc.) corners are removed and finally a list of corners is given back.

Parameters for the algorithm are:

rc_coeff denotes the minimum ratio of major axis to minor axis of an ellipse, whose vertex could be detected as a corner by proposed detector The default value is 1.5.
angle_thresh denotes the maximum obtuse angle that a corner can have when it is detected as a true corner, default value is 162.
sigma denotes the standard deviation of the Gaussian filter when computeing curvature. The default sig is 3.
straight_line_thresh to estimate the angle of a corner, either a circle or a straight line approximation of the left and right surrounding is used. The straight line approximation is used, if the angle between the left neigbour, corner candidate and and the point on the contour half way between them is smaller than straight_line_thresh. 0 leads to circle approximation only, 180 to straight line approximation only.

Diffent to the reference implementation of Xiao He, the second half of the contour is copied before the start of the contour and the first half of the contour is copied behind the end of the contour. That way, the (artificially) first and last corners in the closed contour are calculated more acurately, since there are no discontinuities.

usage example:

        const std::vector<icl::Region> &rs = d.detect(&image);
        const std::vector<Point32f> &boundary = getThinnedBoundary(rs[0].getBoundary());
        CornerDetectorCSS css;
        const std::vector<Point32f> &corners = css.detectCorners(boundary);

Constructor & Destructor Documentation

icl::cv::CornerDetectorCSS::CornerDetectorCSS	(	float	angle_thresh = `162.`,
		float	rc_coeff = `1.5`,
		float	sigma = `3.`,
		float	curvature_cutoff = `100.`,
		float	straight_line_thresh = `0.1`,
		bool	accurate = `false`
	)

Default constructor with given arguments.

icl::cv::CornerDetectorCSS::~CornerDetectorCSS ( )

Destructor.

Member Function Documentation

void icl::cv::CornerDetectorCSS::calculate_curvatures	(	const float *	smoothed_x,
		const float *	smoothed_y,
		int	length,
		float	curvature_cutoff,
		float *	curvatures
	)		`[private]`

void icl::cv::CornerDetectorCSS::calculate_curvatures_bulk	(	int	array_length,
		int	num_boundaries,
		const int *	lengths,
		const int *	indices,
		const int *	indices_padded,
		const float *	smoothed_x,
		const float *	smoothed_y,
		float	curvature_cutoff,
		float *	curvature
	)		`[private]`

void icl::cv::CornerDetectorCSS::convolute	(	const float *	data,
		int	data_length,
		const float *	mask,
		int	mask_length,
		float *	convoluted
	)		`[private]`

static void icl::cv::CornerDetectorCSS::convolute_1D	(	float *	vec,
		int	dim,
		float *	kernel,
		int	kernelDim,
		float *	dst
	)		`[static]`

Small wrapper for ippsConv_32f.

Parameters:

vec
dim
kernel
kernelDim
dst	destination data pointer of size dim+kernelDim -1

Performs the following operation

$\mbox{dst}[n] = \sum\limits_{k=0}^n \mbox{src}[k] \cdot \mbox{kernel}[n-k]$

for all $n \in [0,\mbox{dim}+\mbox{kernelDim}-1]$

with $\mbox{src}[x] = 0$ for $x \not\in [0,\mbox{dim}-1]$ and $\mbox{kernel}[x] = 0$ for $x \not\in [0,\mbox{kernelDim}-1]$

float icl::cv::CornerDetectorCSS::cornerAngle	(	float *	x,
		float *	y,
		int	prev,
		int	current,
		int	next,
		int	length,
		float	straight_line_thresh
	)		`[private]`

float icl::cv::CornerDetectorCSS::cornerAngleAccurate	(	float *	x,
		float *	y,
		int	prev,
		int	current,
		int	next,
		int	array_length,
		float	straight_line_thresh
	)		`[private]`

template<class T >

ICLCV_API const std::vector<std::vector<utils::Point32f> >& icl::cv::CornerDetectorCSS::detectCorners	(	const std::vector< std::vector< T > > &	boundaries,
		const std::vector< icl32f > &	sigmas
	)

detects the corners in the passed contour

Use this function to detect the corners in an image.
A reference to the contour in which the corners should be detected must be passed. The contour should be "thinned", meaning that it should look e.g. like

          ooox                ooxx
          ooxo  and not like  oxxo
          oxoo                xxoo
          xooo                xooo

template<class T >

ICLCV_API const std::vector<utils::Point32f>& icl::cv::CornerDetectorCSS::detectCorners ( const std::vector< T > & boundary )

void icl::cv::CornerDetectorCSS::fill_gauss	(	float *	mask,
		float	sigma,
		int	width
	)		`[private]`

int icl::cv::CornerDetectorCSS::findExtrema	(	int *	extrema,
		int *	num_extrema_out,
		float *	k,
		int	length
	)		`[private]`

int icl::cv::CornerDetectorCSS::gauss_radius	(	float	sigma,
		float	cutoff
	)		`[private]`

static int icl::cv::CornerDetectorCSS::gaussian	(	GaussianKernel &	gauss,
		float	sigma,
		float	cutoff
	)		`[static]`

calculates a normalized 1d gaussian std::vector

Parameters:

gauss	reference to GaussianKernel struct
sigma	sigma^2 is the variance of the gaussian, default is 1
cutoff	if value of gaussian drops below this value, it is set to zero, default is 0.001

Returns:: width of the gaussian tails, so the size of the returned std::vector is 2*width+1

bool icl::cv::CornerDetectorCSS::getAccurate ( ) const [inline]

float icl::cv::CornerDetectorCSS::getAngleThreshold ( ) const [inline]

float icl::cv::CornerDetectorCSS::getCurvatureCutoff ( ) const [inline]

const std::vector<utils::Point32f>& icl::cv::CornerDetectorCSS::getLastCorners ( ) const [inline]

returns the result of last detectCorners call

This function can be used as optimization e.g. whithin ICLCV::Region implementation

virtual std::string icl::cv::CornerDetectorCSS::getPropertyInfo ( const std::string & propertyName ) const [virtual]

returns info for given property

Reimplemented from icl::utils::Configurable.

virtual std::vector<std::string> icl::cv::CornerDetectorCSS::getPropertyList ( ) const [virtual]

returns Configurable property list

Reimplemented from icl::utils::Configurable.

virtual std::string icl::cv::CornerDetectorCSS::getPropertyToolTip ( const std::string & propertyName ) const [virtual]

returns property descriptions

Reimplemented from icl::utils::Configurable.

virtual std::string icl::cv::CornerDetectorCSS::getPropertyType ( const std::string & propertyName ) const [virtual]

returns type of given property

Reimplemented from icl::utils::Configurable.

virtual utils::Any icl::cv::CornerDetectorCSS::getPropertyValue ( const std::string & propertyName ) const [virtual]

returns value for given property

Reimplemented from icl::utils::Configurable.

virtual int icl::cv::CornerDetectorCSS::getPropertyVolatileness ( const std::string & propertyName ) const [inline, virtual]

returns volatileness for given property

Reimplemented from icl::utils::Configurable.

float icl::cv::CornerDetectorCSS::getRCCoeff ( ) const [inline]

float icl::cv::CornerDetectorCSS::getSigma ( ) const [inline]

float icl::cv::CornerDetectorCSS::getStraightLineThreshold ( ) const [inline]

void icl::cv::CornerDetectorCSS::removeFalseCorners	(	float	angle_thresh,
		float *	x,
		float *	y,
		float *	k,
		int	length,
		int *	maxima,
		int	num_maxima,
		int *	maxima_out,
		int *	num_maxima_out
	)		`[private]`

void icl::cv::CornerDetectorCSS::removeRoundCorners	(	float	rc_coeff,
		int	maxima_offset,
		float *	k,
		int	length,
		int *	extrema,
		int	num_extrema,
		int *	new_extrema,
		int *	num_new_extrema_out
	)		`[private]`

void icl::cv::CornerDetectorCSS::removeRoundCornersAccurate	(	float	rc_coeff,
		int	maxima_offset,
		float *	k,
		int	length,
		int *	extrema,
		int	num_extrema,
		int *	extrema_out,
		int *	num_extrema_out
	)		`[private]`

void icl::cv::CornerDetectorCSS::setAccurate ( bool value ) [inline]

void icl::cv::CornerDetectorCSS::setAngleThreshold ( float value ) [inline]

void icl::cv::CornerDetectorCSS::setCurvatureCutoff ( float value ) [inline]

virtual void icl::cv::CornerDetectorCSS::setPropertyValue	(	const std::string &	propertyName,
		const utils::Any &	value
	)		throw (utils::ICLException) `[virtual]`