Computer Vision

Classes
struct	CVD::Morphology::BasicBinary< T >
struct	CVD::Morphology::BasicGray< T, Cmp >
struct	CVD::Morphology::BasicGrayByte
struct	CVD::Morphology::BinaryDilate< T >
struct	CVD::Morphology::BinaryErode< T >
struct	CVD::Morphology::BinaryMedian< T >
class	Camera::Cubic
class	CVD::Morphology::Dilate< T >
class	CVD::Morphology::Dilate< byte >
class	CVD::Morphology::Erode< T >
class	CVD::Morphology::Erode< byte >
class	Camera::Harris
struct	CVD::Harris::HarrisScore
class	Camera::Linear
class	CVD::Morphology::Median< byte >
struct	CVD::multiplyBy< T >
struct	CVD::Harris::PairInserter
class	CVD::Morphology::Percentile< byte >
struct	CVD::Harris::PosInserter
class	Camera::Quintic
struct	CVD::Harris::ShiTomasiScore
Namespaces
namespace	Camera
namespace	CVD::Morphology
Functions
void	CVD::connected_components (const std::vector< ImageRef > &v, std::vector< std::vector< ImageRef > > &r)
template<class T >
void	CVD::convolveWithBox (const BasicImage< T > &I, BasicImage< T > &J, ImageRef hwin)
template<class C >
Image< TooN::Matrix< 2 > >	CVD::dense_tensor_vote_gradients (const SubImage< C > &image, double sigma, double ratio, double cutoff=0.001, unsigned int num_divs=4096)
void	CVD::fast_corner_detect_10 (const BasicImage< byte > &im, std::vector< ImageRef > &corners, int barrier)
void	CVD::fast_corner_detect_11 (const BasicImage< byte > &im, std::vector< ImageRef > &corners, int barrier)
void	CVD::fast_corner_detect_12 (const BasicImage< byte > &im, std::vector< ImageRef > &corners, int barrier)
void	CVD::fast_corner_detect_7 (const BasicImage< byte > &im, std::vector< ImageRef > &corners, int barrier)
void	CVD::fast_corner_detect_8 (const BasicImage< byte > &im, std::vector< ImageRef > &corners, int barrier)
void	CVD::fast_corner_detect_9 (const BasicImage< byte > &im, std::vector< ImageRef > &corners, int barrier)
void	CVD::fast_corner_detect_9_nonmax (const BasicImage< byte > &im, std::vector< ImageRef > &max_corners, int barrier)
void	CVD::fast_corner_score_10 (const SubImage< byte > &i, const std::vector< ImageRef > &corners, int b, std::vector< int > &scores)
void	CVD::fast_corner_score_11 (const SubImage< byte > &i, const std::vector< ImageRef > &corners, int b, std::vector< int > &scores)
void	CVD::fast_corner_score_12 (const SubImage< byte > &i, const std::vector< ImageRef > &corners, int b, std::vector< int > &scores)
void	CVD::fast_corner_score_7 (const SubImage< byte > &i, const std::vector< ImageRef > &corners, int b, std::vector< int > &scores)
void	CVD::fast_corner_score_8 (const SubImage< byte > &i, const std::vector< ImageRef > &corners, int b, std::vector< int > &scores)
void	CVD::fast_corner_score_9 (const SubImage< byte > &i, const std::vector< ImageRef > &corners, int b, std::vector< int > &scores)
void	CVD::fast_nonmax (const BasicImage< byte > &im, const std::vector< ImageRef > &corners, int barrier, std::vector< ImageRef > &max_corners)
void	CVD::fast_nonmax_with_scores (const BasicImage< byte > &im, const std::vector< ImageRef > &corners, int barrier, std::vector< std::pair< ImageRef, int > > &max_corners)
template<class T >
T	CVD::gaussianKernel (std::vector< T > &k, T maxval, double stddev)
template<class S , class T >
void	CVD::gradient (const BasicImage< S > &im, BasicImage< T > &out)
template<class It >
void	CVD::haar1D (It from, int size)
template<class It >
void	CVD::haar1D (It from, It to)
template<class T >
void	CVD::haar2D (SubImage< T > &I)
template<class It >
void	CVD::haar2D (It from, const int width, const int height, int stride=-1)
template<class T >
Image< T >	CVD::halfSample (Image< T > in, unsigned int octaves)
template<class T >
Image< T >	CVD::halfSample (const BasicImage< T > &in)
template<class T >
void	CVD::halfSample (const BasicImage< T > &in, BasicImage< T > &out)
template<class Score , class Inserter , class C , class B >
void	CVD::harrislike_corner_detect (const SubImage< B > &i, C &c, unsigned int N, float blur, float sigmas, BasicImage< float > &xx, BasicImage< float > &xy, BasicImage< float > &yy)
template<class S , class D >
void	CVD::integral_image (const SubImage< S > &in, SubImage< D > &out)
double	CVD::interpolate_extremum (double d1, double d2, double d3)
template<class I >
std::pair< TooN::Vector < 2 >, double >	CVD::interpolate_extremum_value (const SubImage< I > &i, ImageRef p)
std::pair< TooN::Vector < 2 >, double >	CVD::interpolate_extremum_value (double I__1__1, double I__1_0, double I__1_1, double I_0__1, double I_0_0, double I_0_1, double I_1__1, double I_1_0, double I_1_1)
template<class It >
void	CVD::inv_haar1D (It from, int size)
template<class It >
void	CVD::inv_haar1D (It from, It to)
template<class Accumulator , class T >
void	CVD::morphology (const SubImage< T > &in, const std::vector< ImageRef > &selem, const Accumulator &a_, SubImage< T > &out)
void	CVD::nonmax_suppression (const std::vector< ImageRef > &corners, const std::vector< int > &scores, std::vector< ImageRef > &nmax_corners)
void	CVD::nonmax_suppression_strict (const std::vector< ImageRef > &corners, const std::vector< int > &scores, std::vector< ImageRef > &nmax_corners)
void	CVD::nonmax_suppression_with_scores (const std::vector< ImageRef > &corners, const std::vector< int > &socres, std::vector< std::pair< ImageRef, int > > &max_corners)
template<class S , class T >
T	CVD::scaleKernel (const std::vector< S > &k, std::vector< T > &scaled, T maxval)
template<class T >
void	CVD::stats (const BasicImage< T > &im, T &mean, T &stddev)
template<class T >
void	CVD::threshold (BasicImage< T > &im, const T &minimum, const T &hi)
template<class C >
void	CVD::twoThirdsSample (const SubImage< C > &in, SubImage< C > &out)
Variables
const ImageRef	CVD::fast_pixel_ring [16]

Detailed Description

Functions and classes to support common computer vision concepts and operations

Function Documentation

void CVD::connected_components	(	const std::vector< ImageRef > &	v,
		std::vector< std::vector< ImageRef > > &	r
	)

Find the connected components of the input, using 4-way floodfill. This is implemented as the graph based algorithm. There is no restriction on the input except that positions can not be INT_MIN or INT_MAX.

The pixels in the resulting segments are not sorted.

Parameters:

	v	List of pixel positions
	r	List of segments.

template<class T >

void CVD::convolveWithBox	(	const BasicImage< T > &	I,
		BasicImage< T > &	J,
		ImageRef	hwin
	)			`[inline]`

convolves an image with a box of given size.

Parameters:

	I	input image, modified in place
	hwin	window size, this is half of the box size

Definition at line 150 of file convolution.h.

template<class C >

Image<TooN::Matrix<2> > CVD::dense_tensor_vote_gradients	(	const SubImage< C > &	image,
		double	sigma,
		double	ratio,
		double	cutoff = `0.001`,
		unsigned int	num_divs = `4096`
	)			`[inline]`

This function performs tensor voting on the gradients of an image. The voting is performed densely at each pixel, and the contribution of each pixel is scaled by its gradient magnitude. The kernel for voting is computed as follows. Consider that there is a point at $(0,0)$ , with gradient normal $(0,1)$ . This will make a contribution to the point $(x,y)$ .

The arc-length, $l$ , of the arc passing through $(0,0)$ , tangent to the gradient at this point and also passing through $(x, y)$ is:

$l = 2 r \theta$

Where

$\theta = \tan^{-1}\frac{y}{x}$

and the radius of the arc, $r$ is:

$r = \frac{x^2 + y^2}{2y}.$

The scale of the contribution is:

$s = e^{-\frac{l^2}{\sigma^2} - \kappa\frac{\sigma^2}{r^2}}.$

Note that this is achieved by scaling $x$ and $y$ by $\sigma$ , so $\kappa$ controls the kernel shape independent of the size. The complete tensor contribution is therefore:

$e^{-\frac{l^2}{\sigma^2} - \kappa\frac{\sigma^2}{r^2}} \left[ \begin{array}{c} \cos 2\theta\\ \sin 2\theta \end{array} \right] [ \cos 2\theta\ \ \sin 2\theta]$

Parameters:

	image	The image on which to perform tensor voting
	sigma	$\sigma$
	ratio	$\kappa$
	cutoff	When points drop below the cutoff, it is set to zero.
	num_divs	The voting kernels are quantized by angle in to this many dicisions in the half-circle.

Definition at line 80 of file tensor_voting.h.

void CVD::fast_corner_detect_10	(	const BasicImage< byte > &	im,
		std::vector< ImageRef > &	corners,
		int	barrier
	)

Perform tree based 10 point FAST feature detection If you use this, please cite the paper given in fast_corner_detect

Parameters:

	im	The input image
	corners	The resulting container of corner locations
	barrier	Corner detection threshold

void CVD::fast_corner_detect_11	(	const BasicImage< byte > &	im,
		std::vector< ImageRef > &	corners,
		int	barrier
	)

Perform tree based 11 point FAST feature detection If you use this, please cite the paper given in fast_corner_detect_9

Parameters:

	im	The input image
	corners	The resulting container of corner locations
	barrier	Corner detection threshold

void CVD::fast_corner_detect_12	(	const BasicImage< byte > &	im,
		std::vector< ImageRef > &	corners,
		int	barrier
	)

Perform tree based 12 point FAST feature detection If you use this, please cite the paper given in fast_corner_detect_9

Parameters:

	im	The input image
	corners	The resulting container of corner locations
	barrier	Corner detection threshold

void CVD::fast_corner_detect_7	(	const BasicImage< byte > &	im,
		std::vector< ImageRef > &	corners,
		int	barrier
	)

Perform tree based 7 point FAST feature detection. This is more like an edge detector. If you use this, please cite the paper given in fast_corner_detect_9

Parameters:

	im	The input image
	corners	The resulting container of corner locations
	barrier	Corner detection threshold

void CVD::fast_corner_detect_8	(	const BasicImage< byte > &	im,
		std::vector< ImageRef > &	corners,
		int	barrier
	)

Perform tree based 8 point FAST feature detection. This is more like an edge detector. If you use this, please cite the paper given in fast_corner_detect_9

Parameters:

	im	The input image
	corners	The resulting container of corner locations
	barrier	Corner detection threshold

void CVD::fast_corner_detect_9	(	const BasicImage< byte > &	im,
		std::vector< ImageRef > &	corners,
		int	barrier
	)

Perform tree based 9 point FAST feature detection as described in: Machine Learning for High Speed Corner Detection, E. Rosten and T. Drummond. Results show that this is both the fastest and the best of the detectors. If you use this in published work, please cite:

@inproceedings{rosten2006machine,
	title       =    "Machine Learning for High Speed Corner Detection",
	author      =    "Edward Rosten and Tom Drummond",
	year        =    "2006",     
	month       =    "May",     
	booktitle   =    "9th European Conference on Computer Vision",
}

Parameters:

	im	The input image
	corners	The resulting container of corner locations
	barrier	Corner detection threshold

void CVD::fast_corner_detect_9_nonmax	(	const BasicImage< byte > &	im,
		std::vector< ImageRef > &	max_corners,
		int	barrier
	)

Perform FAST-9 corner detection (see fast_corner_detect_9), with nonmaximal suppression (see fast_corner_score_9 and nonmax_suppression)

Parameters:

	im	The input image
	corners	The resulting container of locally maximal corner locations
	barrier	Corner detection threshold

void CVD::fast_corner_score_10	(	const SubImage< byte > &	i,
		const std::vector< ImageRef > &	corners,
		int	b,
		std::vector< int > &	scores
	)

Compute the 10 point score (as the maximum threshold at which the point will still be detected) for a std::vector of features.

Parameters:

	im	The input image
	corners	The resulting container of corner locations
	barrier	Initial corner detection threshold. Using the same threshold as for corner detection will produce the quickest results, but any lower value (e.g. 0) will produce correct results.

void CVD::fast_corner_score_11	(	const SubImage< byte > &	i,
		const std::vector< ImageRef > &	corners,
		int	b,
		std::vector< int > &	scores
	)

Compute the 11 point score (as the maximum threshold at which the point will still be detected) for a std::vector of features.

Parameters:

	im	The input image
	corners	The resulting container of corner locations
	barrier	Initial corner detection threshold. Using the same threshold as for corner detection will produce the quickest results, but any lower value (e.g. 0) will produce correct results.

void CVD::fast_corner_score_12	(	const SubImage< byte > &	i,
		const std::vector< ImageRef > &	corners,
		int	b,
		std::vector< int > &	scores
	)

Compute the 11 point score (as the maximum threshold at which the point will still be detected) for a std::vector of features.

Parameters:

	im	The input image
	corners	The resulting container of corner locations
	barrier	Initial corner detection threshold. Using the same threshold as for corner detection will produce the quickest results, but any lower value (e.g. 0) will produce correct results.

void CVD::fast_corner_score_7	(	const SubImage< byte > &	i,
		const std::vector< ImageRef > &	corners,
		int	b,
		std::vector< int > &	scores
	)

Compute the 7 point score (as the maximum threshold at which the point will still be detected) for a std::vector of features.

Parameters:

	im	The input image
	corners	The resulting container of corner locations
	barrier	Initial corner detection threshold. Using the same threshold as for corner detection will produce the quickest results, but any lower value (e.g. 0) will produce correct results.

void CVD::fast_corner_score_8	(	const SubImage< byte > &	i,
		const std::vector< ImageRef > &	corners,
		int	b,
		std::vector< int > &	scores
	)

Compute the 8 point score (as the maximum threshold at which the point will still be detected) for a std::vector of features.

Parameters:

	im	The input image
	corners	The resulting container of corner locations
	barrier	Initial corner detection threshold. Using the same threshold as for corner detection will produce the quickest results, but any lower value (e.g. 0) will produce correct results.

void CVD::fast_corner_score_9	(	const SubImage< byte > &	i,
		const std::vector< ImageRef > &	corners,
		int	b,
		std::vector< int > &	scores
	)

Compute the 9 point score (as the maximum threshold at which the point will still be detected) for a std::vector of features.

Parameters:

	im	The input image
	corners	The resulting container of corner locations
	barrier	Initial corner detection threshold. Using the same threshold as for corner detection will produce the quickest results, but any lower value (e.g. 0) will produce correct results.

void CVD::fast_nonmax	(	const BasicImage< byte > &	im,
		const std::vector< ImageRef > &	corners,
		int	barrier,
		std::vector< ImageRef > &	max_corners
	)

Perform non-maximal suppression on a set of FAST features. This cleans up areas where there are multiple adjacent features, using a computed score function to leave only the 'best' features. This function is typically called immediately after a call to fast_corner_detect() (or one of its variants). This uses the scoring function given in the paper given in fast_corner_detect_9:

Parameters:

	im	The image used to generate the FAST features
	corners	The FAST features previously detected (e.g. by calling fast_corner_detect())
	barrier	The barrier used to calculate the score, which should be the same as that passed to fast_corner_detect()
	max_corners	Vector to be filled with the new list of locally maximal corners.

void CVD::fast_nonmax_with_scores	(	const BasicImage< byte > &	im,
		const std::vector< ImageRef > &	corners,
		int	barrier,
		std::vector< std::pair< ImageRef, int > > &	max_corners
	)

Perform non-maximal suppression on a set of FAST features, also returning the score for each remaining corner. This function cleans up areas where there are multiple adjacent features, using a computed score function to leave only the 'best' features. This function is typically called immediately after a call to fast_corner_detect() (or one of its variants).

Parameters:

	im	The image used to generate the FAST features
	corners	The FAST features previously detected (e.g. by calling fast_corner_detect())
	barrier	The barrier used to calculate the score, which should be the same as that passed to fast_corner_detect()
	max_corners	Vector to be filled with the new list of locally maximal corners, and their scores. `non_maxcorners[i].first` gives the location and `non_maxcorners[i].second` gives the score (higher is better).

template<class T >

T CVD::gaussianKernel	(	std::vector< T > &	k,
		T	maxval,
		double	stddev
	)			`[inline]`

creates a Gaussian kernel with given maximum value and standard deviation. All elements of the passed vector are filled up, therefore the vector defines the size of the computed kernel. The normalizing value is returned.

Parameters:

	k	vector of T's holds the kernel values
	maxval	the maximum value to be used
	stddev	standard deviation of the kernel

Returns:: the sum of the kernel elements for normalization

Definition at line 47 of file convolution.h.

template<class S , class T >

void CVD::gradient	(	const BasicImage< S > &	im,
		BasicImage< T > &	out
	)			`[inline]`

computes the gradient image from an image. The gradient image contains two components per pixel holding the x and y components of the gradient.

Parameters:

	im	input image
	out	output image, must have the same dimensions as input image

Exceptions:

IncompatibleImageSizes

if out does not have same dimensions as im

Definition at line 260 of file vision.h.

template<class It >

void CVD::haar1D	(	It	from,
		int	size
	)			`[inline]`

computes the 1D Haar transform of a signal in place. Will only work correctly on 2^N data points.

Parameters:

	from	iterator pointing to the beginning of the data
	size	number of data points, should be 2^N

Definition at line 83 of file haar.h.

template<class It >

void CVD::haar1D	(	It	from,
		It	to
	)			`[inline]`

computes the 1D Haar transform of a signal in place. This version takes two iterators, and the data between them will be transformed. Will only work correctly on 2^N data points.

Parameters:

	from	iterator pointing to the beginning of the data
	to	iterator pointing to the end (after the last element)

Definition at line 58 of file haar.h.

template<class T >

void CVD::haar2D ( SubImage< T > & I ) [inline]

computes the 2D Haar transform of an image in place. Works only with images with power of two dimensions, 2^N x 2^ M.

Parameters:

I

image to be transformed

Definition at line 137 of file haar.h.

template<class It >

void CVD::haar2D	(	It	from,
		const int	width,
		const int	height,
		int	stride = `-1`
	)			`[inline]`

computes the 2D Haar transform of a signal in place. Works only with data with power of two dimensions, 2^N x 2^ M.

Parameters:

	from	iterator pointing to the beginning of the data
	width	columns of data, should be 2^N
	height	rows of data, should be 2^M
	stride	offset between rows, if negative will be set to width

Definition at line 105 of file haar.h.

template<class T >

Image<T> CVD::halfSample	(	Image< T >	in,
		unsigned int	octaves
	)			`[inline]`

subsamples an image repeatedly by half its size by averaging 2x2 pixel blocks. This version will not create a copy for 0 octaves because it receives already an Image and will reuse the data.

Parameters:

	in	input image
	octaves	number of halfsamplings

Returns:: The output image

Exceptions:

IncompatibleImageSizes

if out does not have half the dimensions of in

Definition at line 165 of file vision.h.

template<class T >

Image<T> CVD::halfSample ( const BasicImage< T > & in ) [inline]

subsamples an image to half its size by averaging 2x2 pixel blocks

Parameters:

in

input image

Returns:: The output image

Exceptions:

IncompatibleImageSizes

if out does not have half the dimensions of in

Definition at line 149 of file vision.h.

template<class T >

void CVD::halfSample	(	const BasicImage< T > &	in,
		BasicImage< T > &	out
	)			`[inline]`

subsamples an image to half its size by averaging 2x2 pixel blocks

Parameters:

	in	input image
	out	output image, must have the right dimensions versus input image

Exceptions:

IncompatibleImageSizes

if out does not have half the dimensions of in

Definition at line 118 of file vision.h.

template<class Score , class Inserter , class C , class B >

void CVD::harrislike_corner_detect	(	const SubImage< B > &	i,
		C &	c,
		unsigned int	N,
		float	blur,
		float	sigmas,
		BasicImage< float > &	xx,
		BasicImage< float > &	xy,
		BasicImage< float > &	yy
	)			`[inline]`

Generic Harris corner detection function. This can use any scoring metric and can store corners in any container. The images used to hold the intermediate results must be passed to this function.

Parameters:

	i	Input image.
	c	Container holding detected corners
	N	Number of corners to detect
	blur	Blur radius to use
	sigmas	Number of sigmas to use in blur.
	xx	Holds the result of blurred, squared X gradient.
	xy	Holds the result of blurred, X times Y gradient.
	yy	Holds the result of blurred, squared Y gradient.

Definition at line 79 of file harris_corner.h.

template<class S , class D >

void CVD::integral_image	(	const SubImage< S > &	in,
		SubImage< D > &	out
	)			`[inline]`

Compute an integral image. In an integral image, pixel (x,y) is equal to the sum of all the pixels in the rectangle from (0,0) to (x,y) in the original image. and reallocation is not performed if b is unique and of the correct size.

Parameters:

	D	The destination image pixel type
	S	The source image pixel type
	in	The source image.
	out	The source image.

Definition at line 37 of file integral_image.h.

double CVD::interpolate_extremum	(	double	d1,
		double	d2,
		double	d3
	)

Interploate a 1D local extremem by fitting a quadratic tho the three data points and interpolating. The middle argument must be the most extreme, and the extremum position is returned relative to 0.

Arguments are checked for extremeness by means of assert.

Parameters:

	d1	Data point value for $x=-1$
	d2	Data point value for $x=0$
	d3	Data point value for $x=1$

Returns:: The $x$ coordinate of the extremum.

Definition at line 43 of file interpolate.h.

template<class I >

std::pair<TooN::Vector<2>, double> CVD::interpolate_extremum_value	(	const SubImage< I > &	i,
		ImageRef	p
	)			`[inline]`

Interpolate a 2D local maximum, by fitting a quadratic.

Parameters:

	i	Image in which to interpolate extremum
	p	Point at which to interpolate extremum

Returns:: pair containing Location of local extremum in image coordinates and the value of the extemum

Definition at line 193 of file interpolate.h.

std::pair<TooN::Vector<2>, double> CVD::interpolate_extremum_value	(	double	I__1__1,
		double	I__1_0,
		double	I__1_1,
		double	I_0__1,
		double	I_0_0,
		double	I_0_1,
		double	I_1__1,
		double	I_1_0,
		double	I_1_1
	)

Interpolate a 2D local maximum, by fitting a quadratic. This is done by using using the 9 datapoints to compute the local Hessian using finite differences and finding the location where the gradient is zero. This version returns also the value of the extremum.

Given the grid of pixels:

	    a b c
	    d e f
	    g h i

The centre pixel (e) must be the most extreme of all the pixels.

Parameters:

	I__1__1	Pixel $(-1, -1)$ relative to the centre (a)
	I__1_0	Pixel $(-1, 0)$ relative to the centre (b)
	I__1_1	Pixel $(-1, 1)$ relative to the centre (c)
	I_0__1	Pixel $( 0, -1)$ relative to the centre (d)
	I_0_0	Pixel $( 0, 0)$ relative to the centre (e)
	I_0_1	Pixel $( 0, 1)$ relative to the centre (f)
	I_1__1	Pixel $( 1, -1)$ relative to the centre (g)
	I_1_0	Pixel $( 1, 0)$ relative to the centre (h)
	I_1_1	Pixel $( 1, 1)$ relative to the centre (i)

Returns:: pair containing Location of the local extrema and the value

Definition at line 156 of file interpolate.h.

template<class It >

void CVD::inv_haar1D	(	It	from,
		int	size
	)			`[inline]`

computes the inverse 1D Haar transform of a signal in place. Will only work correctly on 2^N data points.

Parameters:

	from	iterator pointing to the beginning of the data
	size	number of data points, should be 2^N

Definition at line 93 of file haar.h.

template<class It >

void CVD::inv_haar1D	(	It	from,
		It	to
	)			`[inline]`

computes the inverse 1D Haar transform of a signal in place. This version takes two iterators, and the data between them will be transformed. Will only work correctly on 2^N data points.

Parameters:

	from	iterator pointing to the beginning of the data
	to	iterator pointing to the end (after the last element)

Definition at line 71 of file haar.h.

template<class Accumulator , class T >

void CVD::morphology	(	const SubImage< T > &	in,
		const std::vector< ImageRef > &	selem,
		const Accumulator &	a_,
		SubImage< T > &	out
	)			`[inline]`

Perform a morphological operation on the image.

At the edge of the image, the structuring element is cropped to the image boundary. This function is for homogenous structuring elements, so it is suitable for erosion, dialtion and etc, not hit-and-miss and so on.

For example:

     Image<byte> image, eroded;
     vector<ImageRef> structuring_element = getDisc(10);
     
     ...
     
     morphology(image, structure_element, Erode<byte>(), eroded);

Morphology is performed efficiently using an incremental algorithm. As the structuring element is moved across the images, only pixels on it's edge are added and removed. Other morphological operators can be added by creating a class with the following methods:

 template<class T> struct Operation
 {
     void insert(const T&); //Add a pixel
     void remove(const T&); //Remove a pixel
     void clear(const T&);  //Remove all pixels
     T get();               //Get the current value.
 }

Grayscale erode could be implemented with a multiset to store and remove pixels. Get would simply return the first element in the multiset.

Parameters:

	in	The source image.
	selem	The structuring element. See e.g. getDisc()
	a_	The morphological operation to perform. See Morphology
	out	The destination image.

Definition at line 82 of file morphology.h.

void CVD::nonmax_suppression	(	const std::vector< ImageRef > &	corners,
		const std::vector< int > &	scores,
		std::vector< ImageRef > &	nmax_corners
	)

Perform nonmaximal suppression on a set of features, in a 3 by 3 window. The test is non-strict: a point must be at least as large as its neighbours.

Parameters:

	corners	The corner locations
	scores	The corners' scores
	max_corners	The locally maximal corners.

void CVD::nonmax_suppression_strict	(	const std::vector< ImageRef > &	corners,
		const std::vector< int > &	scores,
		std::vector< ImageRef > &	nmax_corners
	)

Perform nonmaximal suppression on a set of features, in a 3 by 3 window. The test is strict: a point must be greater than its neighbours.

Parameters:

	corners	The corner locations
	scores	The corners' scores
	max_corners	The locally maximal corners.

void CVD::nonmax_suppression_with_scores	(	const std::vector< ImageRef > &	corners,
		const std::vector< int > &	socres,
		std::vector< std::pair< ImageRef, int > > &	max_corners
	)

Perform nonmaximal suppression on a set of features, in a 3 by 3 window. Non strict.

Parameters:

	corners	The corner locations
	scores	The corners' scores
	max_corners	The locally maximal corners, and their scores.

template<class S , class T >

T CVD::scaleKernel	(	const std::vector< S > &	k,
		std::vector< T > &	scaled,
		T	maxval
	)			`[inline]`

scales a GaussianKernel to a different maximum value. The new kernel is returned in scaled. The new normalizing value is returned.

Parameters:

	k	input kernel
	scaled	output vector to hold the resulting kernel
	maxval	the new maximum value

Returns:: sum of the new kernel elements for normalization

Definition at line 72 of file convolution.h.

template<class T >

void CVD::stats	(	const BasicImage< T > &	im,
		T &	mean,
		T &	stddev
	)			`[inline]`

computes mean and stddev of intensities in an image. These are computed for each component of the pixel type, therefore the output are two pixels with mean and stddev for each component.

Parameters:

	im	input image
	mean	pixel element containing the mean of intensities in the image for each component
	stddev	pixel element containing the standard deviation for each component

Definition at line 198 of file vision.h.

template<class T >

void CVD::threshold	(	BasicImage< T > &	im,
		const T &	minimum,
		const T &	hi
	)			`[inline]`

thresholds an image by setting all pixel values below a minimum to 0 and all values above to a given maximum

Parameters:

	im	input image changed in place
	minimum	threshold value
	hi	maximum value for values above the threshold

Definition at line 178 of file vision.h.

template<class C >

void CVD::twoThirdsSample	(	const SubImage< C > &	in,
		SubImage< C > &	out
	)			`[inline]`

Subsamples an image to 2/3 of its size by averaging 3x3 blocks in to 2x2 blocks.

Parameters:

	in	input image
	out	output image (muze be `out.size() == in.size()/2*3` )

Exceptions:

IncompatibleImageSizes

if out does not have the correct dimensions.

Definition at line 47 of file vision.h.

Variable Documentation

const ImageRef CVD::fast_pixel_ring[16]

The 16 offsets from the centre pixel used in FAST feature detection.

Computer Vision

Classes

Namespaces

Functions

Variables

Detailed Description

Function Documentation

Variable Documentation