Class implementing PCT (position-color-texture) signature extraction as described in [152]. The algorithm is divided to a feature sampler and a clusterizer. Feature sampler produces samples at given set of coordinates. Clusterizer then produces clusters of these samples using k-means algorithm. Resulting set of clusters is the signature of the input image. More...

#include <opencv2/xfeatures2d.hpp>

Collaboration diagram for cv::xfeatures2d::PCTSignatures:

Public Types
enum	DistanceFunction { L0_25 , L0_5 , L1 , L2 , L2SQUARED , L5 , L_INFINITY }
	Lp distance function selector. More...

enum	PointDistribution { UNIFORM , REGULAR , NORMAL }
	Point distributions supported by random point generator. More...

enum	SimilarityFunction { MINUS , GAUSSIAN , HEURISTIC }
	Similarity function selector. More...

Public Member Functions
virtual void	computeSignature (InputArray image, OutputArray signature) const =0
	Computes signature of given image.

virtual void	computeSignatures (const std::vector< Mat > &images, std::vector< Mat > &signatures) const =0
	Computes signatures for multiple images in parallel.

virtual int	getClusterMinSize () const =0
	This parameter multiplied by the index of iteration gives lower limit for cluster size. Clusters containing fewer points than specified by the limit have their centroid dismissed and points are reassigned.

virtual int	getDistanceFunction () const =0
	Distance function selector used for measuring distance between two points in k-means.

virtual float	getDropThreshold () const =0
	Remove centroids in k-means whose weight is lesser or equal to given threshold.

virtual int	getGrayscaleBits () const =0
	Color resolution of the greyscale bitmap represented in allocated bits (i.e., value 4 means that 16 shades of grey are used). The greyscale bitmap is used for computing contrast and entropy values.

virtual int	getInitSeedCount () const =0
	Number of initial seeds (initial number of clusters) for the k-means algorithm.

virtual std::vector< int >	getInitSeedIndexes () const =0
	Initial seeds (initial number of clusters) for the k-means algorithm.

virtual int	getIterationCount () const =0
	Number of iterations of the k-means clustering. We use fixed number of iterations, since the modified clustering is pruning clusters (not iteratively refining k clusters).

virtual float	getJoiningDistance () const =0
	Threshold euclidean distance between two centroids. If two cluster centers are closer than this distance, one of the centroid is dismissed and points are reassigned.

virtual int	getMaxClustersCount () const =0
	Maximal number of generated clusters. If the number is exceeded, the clusters are sorted by their weights and the smallest clusters are cropped.

virtual int	getSampleCount () const =0
	Number of initial samples taken from the image.

virtual std::vector< Point2f >	getSamplingPoints () const =0
	Initial samples taken from the image. These sampled features become the input for clustering.

virtual float	getWeightA () const =0
	Weights (multiplicative constants) that linearly stretch individual axes of the feature space (x,y = position; L,a,b = color in CIE Lab space; c = contrast. e = entropy)

virtual float	getWeightB () const =0
	Weights (multiplicative constants) that linearly stretch individual axes of the feature space (x,y = position; L,a,b = color in CIE Lab space; c = contrast. e = entropy)

virtual float	getWeightContrast () const =0
	Weights (multiplicative constants) that linearly stretch individual axes of the feature space (x,y = position; L,a,b = color in CIE Lab space; c = contrast. e = entropy)

virtual float	getWeightEntropy () const =0
	Weights (multiplicative constants) that linearly stretch individual axes of the feature space (x,y = position; L,a,b = color in CIE Lab space; c = contrast. e = entropy)

virtual float	getWeightL () const =0
	Weights (multiplicative constants) that linearly stretch individual axes of the feature space (x,y = position; L,a,b = color in CIE Lab space; c = contrast. e = entropy)

virtual float	getWeightX () const =0
	Weights (multiplicative constants) that linearly stretch individual axes of the feature space (x,y = position; L,a,b = color in CIE Lab space; c = contrast. e = entropy)

virtual float	getWeightY () const =0
	Weights (multiplicative constants) that linearly stretch individual axes of the feature space (x,y = position; L,a,b = color in CIE Lab space; c = contrast. e = entropy)

virtual int	getWindowRadius () const =0
	Size of the texture sampling window used to compute contrast and entropy (center of the window is always in the pixel selected by x,y coordinates of the corresponding feature sample).

virtual void	setClusterMinSize (int clusterMinSize)=0
	This parameter multiplied by the index of iteration gives lower limit for cluster size. Clusters containing fewer points than specified by the limit have their centroid dismissed and points are reassigned.

virtual void	setDistanceFunction (int distanceFunction)=0
	Distance function selector used for measuring distance between two points in k-means. Available: L0_25, L0_5, L1, L2, L2SQUARED, L5, L_INFINITY.

virtual void	setDropThreshold (float dropThreshold)=0
	Remove centroids in k-means whose weight is lesser or equal to given threshold.

virtual void	setGrayscaleBits (int grayscaleBits)=0
	Color resolution of the greyscale bitmap represented in allocated bits (i.e., value 4 means that 16 shades of grey are used). The greyscale bitmap is used for computing contrast and entropy values.

virtual void	setInitSeedIndexes (std::vector< int > initSeedIndexes)=0
	Initial seed indexes for the k-means algorithm.

virtual void	setIterationCount (int iterationCount)=0
	Number of iterations of the k-means clustering. We use fixed number of iterations, since the modified clustering is pruning clusters (not iteratively refining k clusters).

virtual void	setJoiningDistance (float joiningDistance)=0
	Threshold euclidean distance between two centroids. If two cluster centers are closer than this distance, one of the centroid is dismissed and points are reassigned.

virtual void	setMaxClustersCount (int maxClustersCount)=0
	Maximal number of generated clusters. If the number is exceeded, the clusters are sorted by their weights and the smallest clusters are cropped.

virtual void	setSamplingPoints (std::vector< Point2f > samplingPoints)=0
	Sets sampling points used to sample the input image.

virtual void	setTranslation (int idx, float value)=0
	Translations of the individual axes of the feature space.

virtual void	setTranslations (const std::vector< float > &translations)=0
	Translations of the individual axes of the feature space.

virtual void	setWeight (int idx, float value)=0
	Weights (multiplicative constants) that linearly stretch individual axes of the feature space.

virtual void	setWeightA (float weight)=0
	Weights (multiplicative constants) that linearly stretch individual axes of the feature space (x,y = position; L,a,b = color in CIE Lab space; c = contrast. e = entropy)

virtual void	setWeightB (float weight)=0
	Weights (multiplicative constants) that linearly stretch individual axes of the feature space (x,y = position; L,a,b = color in CIE Lab space; c = contrast. e = entropy)

virtual void	setWeightContrast (float weight)=0
	Weights (multiplicative constants) that linearly stretch individual axes of the feature space (x,y = position; L,a,b = color in CIE Lab space; c = contrast. e = entropy)

virtual void	setWeightEntropy (float weight)=0
	Weights (multiplicative constants) that linearly stretch individual axes of the feature space (x,y = position; L,a,b = color in CIE Lab space; c = contrast. e = entropy)

virtual void	setWeightL (float weight)=0
	Weights (multiplicative constants) that linearly stretch individual axes of the feature space (x,y = position; L,a,b = color in CIE Lab space; c = contrast. e = entropy)

virtual void	setWeights (const std::vector< float > &weights)=0
	Weights (multiplicative constants) that linearly stretch individual axes of the feature space.

virtual void	setWeightX (float weight)=0
	Weights (multiplicative constants) that linearly stretch individual axes of the feature space (x,y = position; L,a,b = color in CIE Lab space; c = contrast. e = entropy)

virtual void	setWeightY (float weight)=0
	Weights (multiplicative constants) that linearly stretch individual axes of the feature space (x,y = position; L,a,b = color in CIE Lab space; c = contrast. e = entropy)

virtual void	setWindowRadius (int radius)=0
	Size of the texture sampling window used to compute contrast and entropy (center of the window is always in the pixel selected by x,y coordinates of the corresponding feature sample).

Public Member Functions inherited from cv::Algorithm
	Algorithm ()

virtual	~Algorithm ()

virtual void	clear ()
	Clears the algorithm state.

virtual bool	empty () const
	Returns true if the Algorithm is empty (e.g. in the very beginning or after unsuccessful read.

virtual String	getDefaultName () const

virtual void	read (const FileNode &fn)
	Reads algorithm parameters from a file storage.

virtual void	save (const String &filename) const

void	write (const Ptr< FileStorage > &fs, const String &name=String()) const

virtual void	write (FileStorage &fs) const
	Stores algorithm parameters in a file storage.

void	write (FileStorage &fs, const String &name) const

Static Public Member Functions
static Ptr< PCTSignatures >	create (const int initSampleCount=2000, const int initSeedCount=400, const int pointDistribution=0)
	Creates PCTSignatures algorithm using sample and seed count. It generates its own sets of sampling points and clusterization seed indexes.

static Ptr< PCTSignatures >	create (const std::vector< Point2f > &initSamplingPoints, const int initSeedCount)
	Creates PCTSignatures algorithm using pre-generated sampling points and number of clusterization seeds. It uses the provided sampling points and generates its own clusterization seed indexes.

static Ptr< PCTSignatures >	create (const std::vector< Point2f > &initSamplingPoints, const std::vector< int > &initClusterSeedIndexes)
	Creates PCTSignatures algorithm using pre-generated sampling points and clusterization seeds indexes.

static void	drawSignature (InputArray source, InputArray signature, OutputArray result, float radiusToShorterSideRatio=1.0/8, int borderThickness=1)
	Draws signature in the source image and outputs the result. Signatures are visualized as a circle with radius based on signature weight and color based on signature color. Contrast and entropy are not visualized.

static void	generateInitPoints (std::vector< Point2f > &initPoints, const int count, int pointDistribution)
	Generates initial sampling points according to selected point distribution.

Static Public Member Functions inherited from cv::Algorithm
template<typename _Tp >
static Ptr< _Tp >	load (const String &filename, const String &objname=String())
	Loads algorithm from the file.

template<typename _Tp >
static Ptr< _Tp >	loadFromString (const String &strModel, const String &objname=String())
	Loads algorithm from a String.

template<typename _Tp >
static Ptr< _Tp >	read (const FileNode &fn)
	Reads algorithm from the file node.

Additional Inherited Members
Protected Member Functions inherited from cv::Algorithm
void	writeFormat (FileStorage &fs) const

Detailed Description

Class implementing PCT (position-color-texture) signature extraction as described in [152]. The algorithm is divided to a feature sampler and a clusterizer. Feature sampler produces samples at given set of coordinates. Clusterizer then produces clusters of these samples using k-means algorithm. Resulting set of clusters is the signature of the input image.

A signature is an array of SIGNATURE_DIMENSION-dimensional points. Used dimensions are: weight, x, y position; lab color, contrast, entropy. [152] [22]

Member Enumeration Documentation

◆ DistanceFunction

enum cv::xfeatures2d::PCTSignatures::DistanceFunction

Lp distance function selector.

Enumerator
L0_25
L0_5
L1
L2
L2SQUARED
L5
L_INFINITY

◆ PointDistribution

enum cv::xfeatures2d::PCTSignatures::PointDistribution

Point distributions supported by random point generator.

Enumerator
UNIFORM	Generate numbers uniformly.
REGULAR	Generate points in a regular grid.
NORMAL	Generate points with normal (gaussian) distribution.

◆ SimilarityFunction

enum cv::xfeatures2d::PCTSignatures::SimilarityFunction

Similarity function selector.

See also: Christian Beecks, Merih Seran Uysal, Thomas Seidl. Signature quadratic form distance. In Proceedings of the ACM International Conference on Image and Video Retrieval, pages 438-445. ACM, 2010. [22]

Note

For selected distance function:

\[ d(c_i, c_j) \]

and parameter:

\[ \alpha \]

Enumerator
MINUS	\[ -d(c_i, c_j) \]
GAUSSIAN	\[ e^{ -\alpha * d^2(c_i, c_j)} \]
HEURISTIC	\[ \frac{1}{\alpha + d(c_i, c_j)} \]

Member Function Documentation

◆ computeSignature()

virtual void cv::xfeatures2d::PCTSignatures::computeSignature	(	InputArray	image,
		OutputArray	signature
	)		const

pure virtual

Python:
	cv.xfeatures2d.PCTSignatures.computeSignature(	image[, signature]	) ->	signature

Computes signature of given image.

Parameters

image	Input image of CV_8U type.
signature	Output computed signature.

◆ computeSignatures()

virtual void cv::xfeatures2d::PCTSignatures::computeSignatures	(	const std::vector< Mat > &	images,
		std::vector< Mat > &	signatures
	)		const

pure virtual

Python:
	cv.xfeatures2d.PCTSignatures.computeSignatures(	images, signatures	) ->	None

Computes signatures for multiple images in parallel.

Parameters

images	Vector of input images of CV_8U type.
signatures	Vector of computed signatures.

◆ create() [1/3]

static Ptr< PCTSignatures > cv::xfeatures2d::PCTSignatures::create	(	const int	initSampleCount = `2000`,
		const int	initSeedCount = `400`,
		const int	pointDistribution = `0`
	)

static


cv.xfeatures2d.PCTSignatures.create(	[, initSampleCount[, initSeedCount[, pointDistribution]]]	) ->	retval
cv.xfeatures2d.PCTSignatures.create(	initSamplingPoints, initSeedCount	) ->	retval
cv.xfeatures2d.PCTSignatures.create(	initSamplingPoints, initClusterSeedIndexes	) ->	retval
cv.xfeatures2d.PCTSignatures_create(	[, initSampleCount[, initSeedCount[, pointDistribution]]]	) ->	retval
cv.xfeatures2d.PCTSignatures_create(	initSamplingPoints, initSeedCount	) ->	retval
cv.xfeatures2d.PCTSignatures_create(	initSamplingPoints, initClusterSeedIndexes	) ->	retval

Creates PCTSignatures algorithm using sample and seed count. It generates its own sets of sampling points and clusterization seed indexes.

Parameters

initSampleCount	Number of points used for image sampling.
initSeedCount	Number of initial clusterization seeds. Must be lower or equal to initSampleCount
pointDistribution	Distribution of generated points. Default: UNIFORM. Available: UNIFORM, REGULAR, NORMAL.

Returns: Created algorithm.

◆ create() [2/3]

static Ptr< PCTSignatures > cv::xfeatures2d::PCTSignatures::create	(	const std::vector< Point2f > &	initSamplingPoints,
		const int	initSeedCount
	)

static


cv.xfeatures2d.PCTSignatures.create(	[, initSampleCount[, initSeedCount[, pointDistribution]]]	) ->	retval
cv.xfeatures2d.PCTSignatures.create(	initSamplingPoints, initSeedCount	) ->	retval
cv.xfeatures2d.PCTSignatures.create(	initSamplingPoints, initClusterSeedIndexes	) ->	retval
cv.xfeatures2d.PCTSignatures_create(	[, initSampleCount[, initSeedCount[, pointDistribution]]]	) ->	retval
cv.xfeatures2d.PCTSignatures_create(	initSamplingPoints, initSeedCount	) ->	retval
cv.xfeatures2d.PCTSignatures_create(	initSamplingPoints, initClusterSeedIndexes	) ->	retval

Creates PCTSignatures algorithm using pre-generated sampling points and number of clusterization seeds. It uses the provided sampling points and generates its own clusterization seed indexes.

Parameters

initSamplingPoints	Sampling points used in image sampling.
initSeedCount	Number of initial clusterization seeds. Must be lower or equal to initSamplingPoints.size().

Returns: Created algorithm.

◆ create() [3/3]

static Ptr< PCTSignatures > cv::xfeatures2d::PCTSignatures::create	(	const std::vector< Point2f > &	initSamplingPoints,
		const std::vector< int > &	initClusterSeedIndexes
	)

static


cv.xfeatures2d.PCTSignatures.create(	[, initSampleCount[, initSeedCount[, pointDistribution]]]	) ->	retval
cv.xfeatures2d.PCTSignatures.create(	initSamplingPoints, initSeedCount	) ->	retval
cv.xfeatures2d.PCTSignatures.create(	initSamplingPoints, initClusterSeedIndexes	) ->	retval
cv.xfeatures2d.PCTSignatures_create(	[, initSampleCount[, initSeedCount[, pointDistribution]]]	) ->	retval
cv.xfeatures2d.PCTSignatures_create(	initSamplingPoints, initSeedCount	) ->	retval
cv.xfeatures2d.PCTSignatures_create(	initSamplingPoints, initClusterSeedIndexes	) ->	retval

Creates PCTSignatures algorithm using pre-generated sampling points and clusterization seeds indexes.

Parameters

initSamplingPoints	Sampling points used in image sampling.
initClusterSeedIndexes	Indexes of initial clusterization seeds. Its size must be lower or equal to initSamplingPoints.size().

Returns: Created algorithm.

◆ drawSignature()

static void cv::xfeatures2d::PCTSignatures::drawSignature	(	InputArray	source,
		InputArray	signature,
		OutputArray	result,
		float	radiusToShorterSideRatio = `1.0/8`,
		int	borderThickness = `1`
	)

static

Python:
	cv.xfeatures2d.PCTSignatures.drawSignature(	source, signature[, result[, radiusToShorterSideRatio[, borderThickness]]]	) ->	result
	cv.xfeatures2d.PCTSignatures_drawSignature(	source, signature[, result[, radiusToShorterSideRatio[, borderThickness]]]	) ->	result

Draws signature in the source image and outputs the result. Signatures are visualized as a circle with radius based on signature weight and color based on signature color. Contrast and entropy are not visualized.

Parameters

source	Source image.
signature	Image signature.
result	Output result.
radiusToShorterSideRatio	Determines maximal radius of signature in the output image.
borderThickness	Border thickness of the visualized signature.

◆ generateInitPoints()

static void cv::xfeatures2d::PCTSignatures::generateInitPoints	(	std::vector< Point2f > &	initPoints,
		const int	count,
		int	pointDistribution
	)

static

Python:
	cv.xfeatures2d.PCTSignatures.generateInitPoints(	initPoints, count, pointDistribution	) ->	None
	cv.xfeatures2d.PCTSignatures_generateInitPoints(	initPoints, count, pointDistribution	) ->	None

Generates initial sampling points according to selected point distribution.

Parameters

initPoints	Output vector where the generated points will be saved.
count	Number of points to generate.
pointDistribution	Point distribution selector. Available: UNIFORM, REGULAR, NORMAL.

Note: Generated coordinates are in range [0..1)

◆ getClusterMinSize()

virtual int cv::xfeatures2d::PCTSignatures::getClusterMinSize ( ) const

pure virtual

Python:
	cv.xfeatures2d.PCTSignatures.getClusterMinSize(		) ->	retval

This parameter multiplied by the index of iteration gives lower limit for cluster size. Clusters containing fewer points than specified by the limit have their centroid dismissed and points are reassigned.

◆ getDistanceFunction()

virtual int cv::xfeatures2d::PCTSignatures::getDistanceFunction ( ) const

pure virtual

Python:
	cv.xfeatures2d.PCTSignatures.getDistanceFunction(		) ->	retval

Distance function selector used for measuring distance between two points in k-means.

◆ getDropThreshold()

virtual float cv::xfeatures2d::PCTSignatures::getDropThreshold ( ) const

pure virtual

Python:
	cv.xfeatures2d.PCTSignatures.getDropThreshold(		) ->	retval

Remove centroids in k-means whose weight is lesser or equal to given threshold.

◆ getGrayscaleBits()

virtual int cv::xfeatures2d::PCTSignatures::getGrayscaleBits ( ) const

pure virtual

Python:
	cv.xfeatures2d.PCTSignatures.getGrayscaleBits(		) ->	retval

Color resolution of the greyscale bitmap represented in allocated bits (i.e., value 4 means that 16 shades of grey are used). The greyscale bitmap is used for computing contrast and entropy values.

◆ getInitSeedCount()

virtual int cv::xfeatures2d::PCTSignatures::getInitSeedCount ( ) const

pure virtual

Python:
	cv.xfeatures2d.PCTSignatures.getInitSeedCount(		) ->	retval

Number of initial seeds (initial number of clusters) for the k-means algorithm.

◆ getInitSeedIndexes()

virtual std::vector< int > cv::xfeatures2d::PCTSignatures::getInitSeedIndexes ( ) const

pure virtual

Python:
	cv.xfeatures2d.PCTSignatures.getInitSeedIndexes(		) ->	retval

Initial seeds (initial number of clusters) for the k-means algorithm.

◆ getIterationCount()

virtual int cv::xfeatures2d::PCTSignatures::getIterationCount ( ) const

pure virtual

Python:
	cv.xfeatures2d.PCTSignatures.getIterationCount(		) ->	retval

Number of iterations of the k-means clustering. We use fixed number of iterations, since the modified clustering is pruning clusters (not iteratively refining k clusters).

◆ getJoiningDistance()

virtual float cv::xfeatures2d::PCTSignatures::getJoiningDistance ( ) const

pure virtual

Python:
	cv.xfeatures2d.PCTSignatures.getJoiningDistance(		) ->	retval

Threshold euclidean distance between two centroids. If two cluster centers are closer than this distance, one of the centroid is dismissed and points are reassigned.

◆ getMaxClustersCount()

virtual int cv::xfeatures2d::PCTSignatures::getMaxClustersCount ( ) const

pure virtual

Python:
	cv.xfeatures2d.PCTSignatures.getMaxClustersCount(		) ->	retval

Maximal number of generated clusters. If the number is exceeded, the clusters are sorted by their weights and the smallest clusters are cropped.

◆ getSampleCount()

virtual int cv::xfeatures2d::PCTSignatures::getSampleCount ( ) const

pure virtual

Python:
	cv.xfeatures2d.PCTSignatures.getSampleCount(		) ->	retval

Number of initial samples taken from the image.

◆ getSamplingPoints()

virtual std::vector< Point2f > cv::xfeatures2d::PCTSignatures::getSamplingPoints ( ) const

pure virtual

Python:
	cv.xfeatures2d.PCTSignatures.getSamplingPoints(		) ->	retval

Initial samples taken from the image. These sampled features become the input for clustering.

◆ getWeightA()

virtual float cv::xfeatures2d::PCTSignatures::getWeightA ( ) const

pure virtual

Python:
	cv.xfeatures2d.PCTSignatures.getWeightA(		) ->	retval

Weights (multiplicative constants) that linearly stretch individual axes of the feature space (x,y = position; L,a,b = color in CIE Lab space; c = contrast. e = entropy)

◆ getWeightB()

virtual float cv::xfeatures2d::PCTSignatures::getWeightB ( ) const

pure virtual

Python:
	cv.xfeatures2d.PCTSignatures.getWeightB(		) ->	retval

Weights (multiplicative constants) that linearly stretch individual axes of the feature space (x,y = position; L,a,b = color in CIE Lab space; c = contrast. e = entropy)

◆ getWeightContrast()

virtual float cv::xfeatures2d::PCTSignatures::getWeightContrast ( ) const

pure virtual

Python:
	cv.xfeatures2d.PCTSignatures.getWeightContrast(		) ->	retval

Weights (multiplicative constants) that linearly stretch individual axes of the feature space (x,y = position; L,a,b = color in CIE Lab space; c = contrast. e = entropy)

◆ getWeightEntropy()

virtual float cv::xfeatures2d::PCTSignatures::getWeightEntropy ( ) const

pure virtual

Python:
	cv.xfeatures2d.PCTSignatures.getWeightEntropy(		) ->	retval

Weights (multiplicative constants) that linearly stretch individual axes of the feature space (x,y = position; L,a,b = color in CIE Lab space; c = contrast. e = entropy)

◆ getWeightL()

virtual float cv::xfeatures2d::PCTSignatures::getWeightL ( ) const

pure virtual

Python:
	cv.xfeatures2d.PCTSignatures.getWeightL(		) ->	retval

Weights (multiplicative constants) that linearly stretch individual axes of the feature space (x,y = position; L,a,b = color in CIE Lab space; c = contrast. e = entropy)

◆ getWeightX()

virtual float cv::xfeatures2d::PCTSignatures::getWeightX ( ) const

pure virtual

Python:
	cv.xfeatures2d.PCTSignatures.getWeightX(		) ->	retval

Weights (multiplicative constants) that linearly stretch individual axes of the feature space (x,y = position; L,a,b = color in CIE Lab space; c = contrast. e = entropy)

◆ getWeightY()

virtual float cv::xfeatures2d::PCTSignatures::getWeightY ( ) const

pure virtual

Python:
	cv.xfeatures2d.PCTSignatures.getWeightY(		) ->	retval

Weights (multiplicative constants) that linearly stretch individual axes of the feature space (x,y = position; L,a,b = color in CIE Lab space; c = contrast. e = entropy)

◆ getWindowRadius()

virtual int cv::xfeatures2d::PCTSignatures::getWindowRadius ( ) const

pure virtual

Python:
	cv.xfeatures2d.PCTSignatures.getWindowRadius(		) ->	retval

Size of the texture sampling window used to compute contrast and entropy (center of the window is always in the pixel selected by x,y coordinates of the corresponding feature sample).

◆ setClusterMinSize()

virtual void cv::xfeatures2d::PCTSignatures::setClusterMinSize ( int clusterMinSize )

pure virtual

Python:
	cv.xfeatures2d.PCTSignatures.setClusterMinSize(	clusterMinSize	) ->	None

This parameter multiplied by the index of iteration gives lower limit for cluster size. Clusters containing fewer points than specified by the limit have their centroid dismissed and points are reassigned.

◆ setDistanceFunction()

virtual void cv::xfeatures2d::PCTSignatures::setDistanceFunction ( int distanceFunction )

pure virtual

Python:
	cv.xfeatures2d.PCTSignatures.setDistanceFunction(	distanceFunction	) ->	None

Distance function selector used for measuring distance between two points in k-means. Available: L0_25, L0_5, L1, L2, L2SQUARED, L5, L_INFINITY.

◆ setDropThreshold()

virtual void cv::xfeatures2d::PCTSignatures::setDropThreshold ( float dropThreshold )

pure virtual

Python:
	cv.xfeatures2d.PCTSignatures.setDropThreshold(	dropThreshold	) ->	None

Remove centroids in k-means whose weight is lesser or equal to given threshold.

◆ setGrayscaleBits()

virtual void cv::xfeatures2d::PCTSignatures::setGrayscaleBits ( int grayscaleBits )

pure virtual

Python:
	cv.xfeatures2d.PCTSignatures.setGrayscaleBits(	grayscaleBits	) ->	None

Color resolution of the greyscale bitmap represented in allocated bits (i.e., value 4 means that 16 shades of grey are used). The greyscale bitmap is used for computing contrast and entropy values.

◆ setInitSeedIndexes()

virtual void cv::xfeatures2d::PCTSignatures::setInitSeedIndexes ( std::vector< int > initSeedIndexes )

pure virtual

Python:
	cv.xfeatures2d.PCTSignatures.setInitSeedIndexes(	initSeedIndexes	) ->	None

Initial seed indexes for the k-means algorithm.

◆ setIterationCount()

virtual void cv::xfeatures2d::PCTSignatures::setIterationCount ( int iterationCount )

pure virtual

Python:
	cv.xfeatures2d.PCTSignatures.setIterationCount(	iterationCount	) ->	None

Number of iterations of the k-means clustering. We use fixed number of iterations, since the modified clustering is pruning clusters (not iteratively refining k clusters).

◆ setJoiningDistance()

virtual void cv::xfeatures2d::PCTSignatures::setJoiningDistance ( float joiningDistance )

pure virtual

Python:
	cv.xfeatures2d.PCTSignatures.setJoiningDistance(	joiningDistance	) ->	None

Threshold euclidean distance between two centroids. If two cluster centers are closer than this distance, one of the centroid is dismissed and points are reassigned.

◆ setMaxClustersCount()

virtual void cv::xfeatures2d::PCTSignatures::setMaxClustersCount ( int maxClustersCount )

pure virtual

Python:
	cv.xfeatures2d.PCTSignatures.setMaxClustersCount(	maxClustersCount	) ->	None

Maximal number of generated clusters. If the number is exceeded, the clusters are sorted by their weights and the smallest clusters are cropped.

◆ setSamplingPoints()

virtual void cv::xfeatures2d::PCTSignatures::setSamplingPoints ( std::vector< Point2f > samplingPoints )

pure virtual

Python:
	cv.xfeatures2d.PCTSignatures.setSamplingPoints(	samplingPoints	) ->	None

Sets sampling points used to sample the input image.

Parameters

samplingPoints Vector of sampling points in range [0..1)

Note: Number of sampling points must be greater or equal to clusterization seed count.

◆ setTranslation()

virtual void cv::xfeatures2d::PCTSignatures::setTranslation	(	int	idx,
		float	value
	)

pure virtual

Python:
	cv.xfeatures2d.PCTSignatures.setTranslation(	idx, value	) ->	None

Translations of the individual axes of the feature space.

Parameters

idx	ID of the translation
value	Value of the translation

Note: WEIGHT_IDX = 0; X_IDX = 1; Y_IDX = 2; L_IDX = 3; A_IDX = 4; B_IDX = 5; CONTRAST_IDX = 6; ENTROPY_IDX = 7;

◆ setTranslations()

virtual void cv::xfeatures2d::PCTSignatures::setTranslations ( const std::vector< float > & translations )

pure virtual

Python:
	cv.xfeatures2d.PCTSignatures.setTranslations(	translations	) ->	None

Translations of the individual axes of the feature space.

Parameters

translations Values of all translations.

Note: WEIGHT_IDX = 0; X_IDX = 1; Y_IDX = 2; L_IDX = 3; A_IDX = 4; B_IDX = 5; CONTRAST_IDX = 6; ENTROPY_IDX = 7;

◆ setWeight()

virtual void cv::xfeatures2d::PCTSignatures::setWeight	(	int	idx,
		float	value
	)

pure virtual

Python:
	cv.xfeatures2d.PCTSignatures.setWeight(	idx, value	) ->	None

Weights (multiplicative constants) that linearly stretch individual axes of the feature space.

Parameters

idx	ID of the weight
value	Value of the weight

Note: WEIGHT_IDX = 0; X_IDX = 1; Y_IDX = 2; L_IDX = 3; A_IDX = 4; B_IDX = 5; CONTRAST_IDX = 6; ENTROPY_IDX = 7;

◆ setWeightA()

virtual void cv::xfeatures2d::PCTSignatures::setWeightA ( float weight )

pure virtual

Python:
	cv.xfeatures2d.PCTSignatures.setWeightA(	weight	) ->	None

Weights (multiplicative constants) that linearly stretch individual axes of the feature space (x,y = position; L,a,b = color in CIE Lab space; c = contrast. e = entropy)

◆ setWeightB()

virtual void cv::xfeatures2d::PCTSignatures::setWeightB ( float weight )

pure virtual

Python:
	cv.xfeatures2d.PCTSignatures.setWeightB(	weight	) ->	None

Weights (multiplicative constants) that linearly stretch individual axes of the feature space (x,y = position; L,a,b = color in CIE Lab space; c = contrast. e = entropy)

◆ setWeightContrast()

virtual void cv::xfeatures2d::PCTSignatures::setWeightContrast ( float weight )

pure virtual

Python:
	cv.xfeatures2d.PCTSignatures.setWeightContrast(	weight	) ->	None

Weights (multiplicative constants) that linearly stretch individual axes of the feature space (x,y = position; L,a,b = color in CIE Lab space; c = contrast. e = entropy)

◆ setWeightEntropy()

virtual void cv::xfeatures2d::PCTSignatures::setWeightEntropy ( float weight )

pure virtual

Python:
	cv.xfeatures2d.PCTSignatures.setWeightEntropy(	weight	) ->	None

Weights (multiplicative constants) that linearly stretch individual axes of the feature space (x,y = position; L,a,b = color in CIE Lab space; c = contrast. e = entropy)

◆ setWeightL()

virtual void cv::xfeatures2d::PCTSignatures::setWeightL ( float weight )

pure virtual

Python:
	cv.xfeatures2d.PCTSignatures.setWeightL(	weight	) ->	None

Weights (multiplicative constants) that linearly stretch individual axes of the feature space (x,y = position; L,a,b = color in CIE Lab space; c = contrast. e = entropy)

◆ setWeights()

virtual void cv::xfeatures2d::PCTSignatures::setWeights ( const std::vector< float > & weights )

pure virtual

Python:
	cv.xfeatures2d.PCTSignatures.setWeights(	weights	) ->	None

Weights (multiplicative constants) that linearly stretch individual axes of the feature space.

Parameters

weights Values of all weights.

Note: WEIGHT_IDX = 0; X_IDX = 1; Y_IDX = 2; L_IDX = 3; A_IDX = 4; B_IDX = 5; CONTRAST_IDX = 6; ENTROPY_IDX = 7;

◆ setWeightX()

virtual void cv::xfeatures2d::PCTSignatures::setWeightX ( float weight )

pure virtual

Python:
	cv.xfeatures2d.PCTSignatures.setWeightX(	weight	) ->	None

Weights (multiplicative constants) that linearly stretch individual axes of the feature space (x,y = position; L,a,b = color in CIE Lab space; c = contrast. e = entropy)

◆ setWeightY()

virtual void cv::xfeatures2d::PCTSignatures::setWeightY ( float weight )

pure virtual

Python:
	cv.xfeatures2d.PCTSignatures.setWeightY(	weight	) ->	None

Weights (multiplicative constants) that linearly stretch individual axes of the feature space (x,y = position; L,a,b = color in CIE Lab space; c = contrast. e = entropy)

◆ setWindowRadius()

virtual void cv::xfeatures2d::PCTSignatures::setWindowRadius ( int radius )

pure virtual

Python:
	cv.xfeatures2d.PCTSignatures.setWindowRadius(	radius	) ->	None

Size of the texture sampling window used to compute contrast and entropy (center of the window is always in the pixel selected by x,y coordinates of the corresponding feature sample).

The documentation for this class was generated from the following file:

opencv2/xfeatures2d.hpp

Public Types

Public Member Functions

Static Public Member Functions

Additional Inherited Members

Detailed Description

Member Enumeration Documentation

◆ DistanceFunction

◆ PointDistribution

◆ SimilarityFunction

Member Function Documentation

◆ computeSignature()

◆ computeSignatures()

◆ create() [1/3]

◆ create() [2/3]

◆ create() [3/3]

◆ drawSignature()

◆ generateInitPoints()

◆ getClusterMinSize()

◆ getDistanceFunction()

◆ getDropThreshold()

◆ getGrayscaleBits()

◆ getInitSeedCount()

◆ getInitSeedIndexes()

◆ getIterationCount()

◆ getJoiningDistance()

◆ getMaxClustersCount()

◆ getSampleCount()

◆ getSamplingPoints()

◆ getWeightA()

◆ getWeightB()

◆ getWeightContrast()

◆ getWeightEntropy()

◆ getWeightL()

◆ getWeightX()

◆ getWeightY()

◆ getWindowRadius()

◆ setClusterMinSize()

◆ setDistanceFunction()

◆ setDropThreshold()

◆ setGrayscaleBits()

◆ setInitSeedIndexes()

◆ setIterationCount()

◆ setJoiningDistance()

◆ setMaxClustersCount()

◆ setSamplingPoints()

◆ setTranslation()

◆ setTranslations()

◆ setWeight()

◆ setWeightA()

◆ setWeightB()

◆ setWeightContrast()

◆ setWeightEntropy()

◆ setWeightL()

◆ setWeights()

◆ setWeightX()

◆ setWeightY()

◆ setWindowRadius()