PCTSignatures (JavaCPP Presets for OpenCV 4.3.0-1.5.3 API)

java.lang.Object
- org.bytedeco.javacpp.Pointer
- - org.bytedeco.opencv.opencv_core.Algorithm
  - - org.bytedeco.opencv.opencv_xfeatures2d.PCTSignatures

All Implemented Interfaces:

AutoCloseable
```
@Namespace(value="cv::xfeatures2d")
 @Properties(inherit=opencv_xfeatures2d.class)
public class PCTSignatures
extends Algorithm
```
\brief Class implementing PCT (position-color-texture) signature extraction as described in \cite KrulisLS16. 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. \cite KrulisLS16 \cite BeecksUS10

Nested Class Summary
- Nested classes/interfaces inherited from class org.bytedeco.javacpp.Pointer
  Pointer.CustomDeallocator, Pointer.Deallocator, Pointer.NativeDeallocator, Pointer.ReferenceCounter

Field Summary

Fields
Modifier and Type	Field and Description
`static int`	`GAUSSIAN` enum cv::xfeatures2d::PCTSignatures::SimilarityFunction
`static int`	`HEURISTIC` enum cv::xfeatures2d::PCTSignatures::SimilarityFunction
`static int`	`L_INFINITY` enum cv::xfeatures2d::PCTSignatures::DistanceFunction
`static int`	`L0_25` enum cv::xfeatures2d::PCTSignatures::DistanceFunction
`static int`	`L0_5` enum cv::xfeatures2d::PCTSignatures::DistanceFunction
`static int`	`L1` enum cv::xfeatures2d::PCTSignatures::DistanceFunction
`static int`	`L2` enum cv::xfeatures2d::PCTSignatures::DistanceFunction
`static int`	`L2SQUARED` enum cv::xfeatures2d::PCTSignatures::DistanceFunction
`static int`	`L5` enum cv::xfeatures2d::PCTSignatures::DistanceFunction
`static int`	`MINUS` enum cv::xfeatures2d::PCTSignatures::SimilarityFunction
`static int`	`NORMAL` enum cv::xfeatures2d::PCTSignatures::PointDistribution
`static int`	`REGULAR` enum cv::xfeatures2d::PCTSignatures::PointDistribution
`static int`	`UNIFORM` enum cv::xfeatures2d::PCTSignatures::PointDistribution

Fields inherited from class org.bytedeco.javacpp.Pointer
address, capacity, limit, position

Constructor Summary

Constructors
Constructor and Description

PCTSignatures(Pointer p)
Pointer cast constructor.

Constructors
Constructor and Description
`PCTSignatures(Pointer p)` Pointer cast constructor.

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`void`	`computeSignature(GpuMat image, GpuMat signature)`
`void`	`computeSignature(Mat image, Mat signature)` \brief Computes signature of given image.
`void`	`computeSignature(UMat image, UMat signature)`
`void`	`computeSignatures(MatVector images, MatVector signatures)` \brief Computes signatures for multiple images in parallel.
`static PCTSignatures`	`create()`
`static PCTSignatures`	`create(int initSampleCount, int initSeedCount, int pointDistribution)` \brief Creates PCTSignatures algorithm using sample and seed count.
`static PCTSignatures`	`create(Point2fVector initSamplingPoints, int initSeedCount)` \brief Creates PCTSignatures algorithm using pre-generated sampling points and number of clusterization seeds.
`static PCTSignatures`	`create(Point2fVector initSamplingPoints, int[] initClusterSeedIndexes)`
`static PCTSignatures`	`create(Point2fVector initSamplingPoints, IntBuffer initClusterSeedIndexes)`
`static PCTSignatures`	`create(Point2fVector initSamplingPoints, IntPointer initClusterSeedIndexes)` \brief Creates PCTSignatures algorithm using pre-generated sampling points and clusterization seeds indexes.
`static void`	`drawSignature(GpuMat source, GpuMat signature, GpuMat result)`
`static void`	`drawSignature(GpuMat source, GpuMat signature, GpuMat result, float radiusToShorterSideRatio, int borderThickness)`
`static void`	`drawSignature(Mat source, Mat signature, Mat result)`
`static void`	`drawSignature(Mat source, Mat signature, Mat result, float radiusToShorterSideRatio, int borderThickness)` \brief Draws signature in the source image and outputs the result.
`static void`	`drawSignature(UMat source, UMat signature, UMat result)`
`static void`	`drawSignature(UMat source, UMat signature, UMat result, float radiusToShorterSideRatio, int borderThickness)`
`static void`	`generateInitPoints(Point2fVector initPoints, int count, int pointDistribution)` \brief Generates initial sampling points according to selected point distribution.
`int`	`getClusterMinSize()` \brief This parameter multiplied by the index of iteration gives lower limit for cluster size.
`int`	`getDistanceFunction()` \brief Distance function selector used for measuring distance between two points in k-means.
`float`	`getDropThreshold()` \brief Remove centroids in k-means whose weight is lesser or equal to given threshold.
`int`	`getGrayscaleBits()` \brief Color resolution of the greyscale bitmap represented in allocated bits (i.e., value 4 means that 16 shades of grey are used).
`int`	`getInitSeedCount()` \brief Number of initial seeds (initial number of clusters) for the k-means algorithm.
`IntPointer`	`getInitSeedIndexes()` \brief Initial seeds (initial number of clusters) for the k-means algorithm.
`int`	`getIterationCount()` \brief Number of iterations of the k-means clustering.
`float`	`getJoiningDistance()` \brief Threshold euclidean distance between two centroids.
`int`	`getMaxClustersCount()` \brief Maximal number of generated clusters.
`int`	`getSampleCount()` \brief Number of initial samples taken from the image.
`Point2fVector`	`getSamplingPoints()` \brief Initial samples taken from the image.
`float`	`getWeightA()` \brief 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.
`float`	`getWeightB()` \brief 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.
`float`	`getWeightContrast()` \brief 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.
`float`	`getWeightEntropy()` \brief 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.
`float`	`getWeightL()` \brief 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.
`float`	`getWeightX()` \brief 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.
`float`	`getWeightY()` \brief 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.
`int`	`getWindowRadius()` \brief 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).
`void`	`setClusterMinSize(int clusterMinSize)` \brief This parameter multiplied by the index of iteration gives lower limit for cluster size.
`void`	`setDistanceFunction(int distanceFunction)` \brief Distance function selector used for measuring distance between two points in k-means.
`void`	`setDropThreshold(float dropThreshold)` \brief Remove centroids in k-means whose weight is lesser or equal to given threshold.
`void`	`setGrayscaleBits(int grayscaleBits)` \brief Color resolution of the greyscale bitmap represented in allocated bits (i.e., value 4 means that 16 shades of grey are used).
`void`	`setInitSeedIndexes(int[] initSeedIndexes)`
`void`	`setInitSeedIndexes(IntBuffer initSeedIndexes)`
`void`	`setInitSeedIndexes(IntPointer initSeedIndexes)` \brief Initial seed indexes for the k-means algorithm.
`void`	`setIterationCount(int iterationCount)` \brief Number of iterations of the k-means clustering.
`void`	`setJoiningDistance(float joiningDistance)` \brief Threshold euclidean distance between two centroids.
`void`	`setMaxClustersCount(int maxClustersCount)` \brief Maximal number of generated clusters.
`void`	`setSamplingPoints(Point2fVector samplingPoints)` \brief Sets sampling points used to sample the input image.
`void`	`setTranslation(int idx, float value)` \brief Translations of the individual axes of the feature space.
`void`	`setTranslations(float[] translations)`
`void`	`setTranslations(FloatBuffer translations)`
`void`	`setTranslations(FloatPointer translations)` \brief Translations of the individual axes of the feature space.
`void`	`setWeight(int idx, float value)` \brief Weights (multiplicative constants) that linearly stretch individual axes of the feature space.
`void`	`setWeightA(float weight)` \brief 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.
`void`	`setWeightB(float weight)` \brief 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.
`void`	`setWeightContrast(float weight)` \brief 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.
`void`	`setWeightEntropy(float weight)` \brief 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.
`void`	`setWeightL(float weight)` \brief 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.
`void`	`setWeights(float[] weights)`
`void`	`setWeights(FloatBuffer weights)`
`void`	`setWeights(FloatPointer weights)` \brief Weights (multiplicative constants) that linearly stretch individual axes of the feature space.
`void`	`setWeightX(float weight)` \brief 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.
`void`	`setWeightY(float weight)` \brief 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.
`void`	`setWindowRadius(int radius)` \brief 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).

Methods inherited from class org.bytedeco.opencv.opencv_core.Algorithm
clear, empty, getDefaultName, position, read, save, save, write, write, write

Methods inherited from class org.bytedeco.javacpp.Pointer
address, asBuffer, asByteBuffer, availablePhysicalBytes, calloc, capacity, capacity, close, deallocate, deallocate, deallocateReferences, deallocator, deallocator, equals, fill, formatBytes, free, hashCode, isNull, isNull, limit, limit, malloc, maxBytes, maxPhysicalBytes, memchr, memcmp, memcpy, memmove, memset, offsetof, parseBytes, physicalBytes, position, put, realloc, referenceCount, releaseReference, retainReference, setNull, sizeof, toString, totalBytes, totalPhysicalBytes, withDeallocator, zero

Methods inherited from class java.lang.Object
clone, finalize, getClass, notify, notifyAll, wait, wait, wait

- Field Detail
  - L0_25
```
public static final int L0_25
```
    enum cv::xfeatures2d::PCTSignatures::DistanceFunction
    
    See Also:
    
    Constant Field Values
  - L0_5
```
public static final int L0_5
```
    enum cv::xfeatures2d::PCTSignatures::DistanceFunction
    
    See Also:
    
    Constant Field Values
  - L1
```
public static final int L1
```
    enum cv::xfeatures2d::PCTSignatures::DistanceFunction
    
    See Also:
    
    Constant Field Values
  - L2
```
public static final int L2
```
    enum cv::xfeatures2d::PCTSignatures::DistanceFunction
    
    See Also:
    
    Constant Field Values
  - L2SQUARED
```
public static final int L2SQUARED
```
    enum cv::xfeatures2d::PCTSignatures::DistanceFunction
    
    See Also:
    
    Constant Field Values
  - L5
```
public static final int L5
```
    enum cv::xfeatures2d::PCTSignatures::DistanceFunction
    
    See Also:
    
    Constant Field Values
  - L_INFINITY
```
public static final int L_INFINITY
```
    enum cv::xfeatures2d::PCTSignatures::DistanceFunction
    
    See Also:
    
    Constant Field Values
  - UNIFORM
```
public static final int UNIFORM
```
    enum cv::xfeatures2d::PCTSignatures::PointDistribution
    
    See Also:
    
    Constant Field Values
  - REGULAR
```
public static final int REGULAR
```
    enum cv::xfeatures2d::PCTSignatures::PointDistribution
    
    See Also:
    
    Constant Field Values
  - NORMAL
```
public static final int NORMAL
```
    enum cv::xfeatures2d::PCTSignatures::PointDistribution
    
    See Also:
    
    Constant Field Values
  - MINUS
```
public static final int MINUS
```
    enum cv::xfeatures2d::PCTSignatures::SimilarityFunction
    
    See Also:
    
    Constant Field Values
  - GAUSSIAN
```
public static final int GAUSSIAN
```
    enum cv::xfeatures2d::PCTSignatures::SimilarityFunction
    
    See Also:
    
    Constant Field Values
  - HEURISTIC
```
public static final int HEURISTIC
```
    enum cv::xfeatures2d::PCTSignatures::SimilarityFunction
    
    See Also:
    
    Constant Field Values
- Constructor Detail
  - PCTSignatures
```
public PCTSignatures(Pointer p)
```
    Pointer cast constructor. Invokes Pointer.Pointer(Pointer).
- Method Detail
  - create
```
@opencv_core.Ptr
public static PCTSignatures create(int initSampleCount,
                                                    int initSeedCount,
                                                    int pointDistribution)
```
    \brief 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
```
@opencv_core.Ptr
public static PCTSignatures create()
```
  - create
```
@opencv_core.Ptr
public static PCTSignatures create(@Const @ByRef
                                                    Point2fVector initSamplingPoints,
                                                    int initSeedCount)
```
    \brief 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
```
@opencv_core.Ptr
public static PCTSignatures create(@Const @ByRef
                                                    Point2fVector initSamplingPoints,
                                                    @StdVector
                                                    IntPointer initClusterSeedIndexes)
```
    \brief 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.
  - create
```
@opencv_core.Ptr
public static PCTSignatures create(@Const @ByRef
                                                    Point2fVector initSamplingPoints,
                                                    @StdVector
                                                    IntBuffer initClusterSeedIndexes)
```
  - create
```
@opencv_core.Ptr
public static PCTSignatures create(@Const @ByRef
                                                    Point2fVector initSamplingPoints,
                                                    @StdVector
                                                    int[] initClusterSeedIndexes)
```
  - computeSignature
```
public void computeSignature(@ByVal
                             Mat image,
                             @ByVal
                             Mat signature)
```
    \brief Computes signature of given image.
    
    Parameters:
    
    image - Input image of CV_8U type.
    
    signature - Output computed signature.
  - computeSignature
```
public void computeSignature(@ByVal
                             UMat image,
                             @ByVal
                             UMat signature)
```
  - computeSignature
```
public void computeSignature(@ByVal
                             GpuMat image,
                             @ByVal
                             GpuMat signature)
```
  - computeSignatures
```
public void computeSignatures(@Const @ByRef
                              MatVector images,
                              @ByRef
                              MatVector signatures)
```
    \brief Computes signatures for multiple images in parallel.
    
    Parameters:
    
    images - Vector of input images of CV_8U type.
    
    signatures - Vector of computed signatures.
  - drawSignature
```
public static void drawSignature(@ByVal
                                 Mat source,
                                 @ByVal
                                 Mat signature,
                                 @ByVal
                                 Mat result,
                                 float radiusToShorterSideRatio,
                                 int borderThickness)
```
    \brief 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.
  - drawSignature
```
public static void drawSignature(@ByVal
                                 Mat source,
                                 @ByVal
                                 Mat signature,
                                 @ByVal
                                 Mat result)
```
  - drawSignature
```
public static void drawSignature(@ByVal
                                 UMat source,
                                 @ByVal
                                 UMat signature,
                                 @ByVal
                                 UMat result,
                                 float radiusToShorterSideRatio,
                                 int borderThickness)
```
  - drawSignature
```
public static void drawSignature(@ByVal
                                 UMat source,
                                 @ByVal
                                 UMat signature,
                                 @ByVal
                                 UMat result)
```
  - drawSignature
```
public static void drawSignature(@ByVal
                                 GpuMat source,
                                 @ByVal
                                 GpuMat signature,
                                 @ByVal
                                 GpuMat result,
                                 float radiusToShorterSideRatio,
                                 int borderThickness)
```
  - drawSignature
```
public static void drawSignature(@ByVal
                                 GpuMat source,
                                 @ByVal
                                 GpuMat signature,
                                 @ByVal
                                 GpuMat result)
```
  - generateInitPoints
```
public static void generateInitPoints(@ByRef
                                      Point2fVector initPoints,
                                      int count,
                                      int pointDistribution)
```
    \brief 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)
  - getSampleCount
```
public int getSampleCount()
```
    \brief Number of initial samples taken from the image.
  - getGrayscaleBits
```
public int getGrayscaleBits()
```
    \brief 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.
  - setGrayscaleBits
```
public void setGrayscaleBits(int grayscaleBits)
```
    \brief 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.
  - getWindowRadius
```
public int getWindowRadius()
```
    \brief 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).
  - setWindowRadius
```
public void setWindowRadius(int radius)
```
    \brief 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).
  - getWeightX
```
public float getWeightX()
```
    \brief 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)
  - setWeightX
```
public void setWeightX(float weight)
```
    \brief 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
```
public float getWeightY()
```
    \brief 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
```
public void setWeightY(float weight)
```
    \brief 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
```
public float getWeightL()
```
    \brief 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
```
public void setWeightL(float weight)
```
    \brief 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)
  - getWeightA
```
public float getWeightA()
```
    \brief 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)
  - setWeightA
```
public void setWeightA(float weight)
```
    \brief 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
```
public float getWeightB()
```
    \brief 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
```
public void setWeightB(float weight)
```
    \brief 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
```
public float getWeightContrast()
```
    \brief 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
```
public void setWeightContrast(float weight)
```
    \brief 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
```
public float getWeightEntropy()
```
    \brief 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
```
public void setWeightEntropy(float weight)
```
    \brief 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)
  - getSamplingPoints
```
@ByVal
public Point2fVector getSamplingPoints()
```
    \brief Initial samples taken from the image. These sampled features become the input for clustering.
  - setWeight
```
public void setWeight(int idx,
                      float value)
```
    \brief 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;
  - setWeights
```
public void setWeights(@StdVector
                       FloatPointer weights)
```
    \brief 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;
  - setWeights
```
public void setWeights(@StdVector
                       FloatBuffer weights)
```
  - setWeights
```
public void setWeights(@StdVector
                       float[] weights)
```
  - setTranslation
```
public void setTranslation(int idx,
                           float value)
```
    \brief 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
```
public void setTranslations(@StdVector
                            FloatPointer translations)
```
    \brief 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;
  - setTranslations
```
public void setTranslations(@StdVector
                            FloatBuffer translations)
```
  - setTranslations
```
public void setTranslations(@StdVector
                            float[] translations)
```
  - setSamplingPoints
```
public void setSamplingPoints(@ByVal
                              Point2fVector samplingPoints)
```
    \brief 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.
  - getInitSeedIndexes
```
@StdVector
public IntPointer getInitSeedIndexes()
```
    \brief Initial seeds (initial number of clusters) for the k-means algorithm.
  - setInitSeedIndexes
```
public void setInitSeedIndexes(@StdVector
                               IntPointer initSeedIndexes)
```
    \brief Initial seed indexes for the k-means algorithm.
  - setInitSeedIndexes
```
public void setInitSeedIndexes(@StdVector
                               IntBuffer initSeedIndexes)
```
  - setInitSeedIndexes
```
public void setInitSeedIndexes(@StdVector
                               int[] initSeedIndexes)
```
  - getInitSeedCount
```
public int getInitSeedCount()
```
    \brief Number of initial seeds (initial number of clusters) for the k-means algorithm.
  - getIterationCount
```
public int getIterationCount()
```
    \brief 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).
  - setIterationCount
```
public void setIterationCount(int iterationCount)
```
    \brief 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).
  - getMaxClustersCount
```
public int getMaxClustersCount()
```
    \brief Maximal number of generated clusters. If the number is exceeded, the clusters are sorted by their weights and the smallest clusters are cropped.
  - setMaxClustersCount
```
public void setMaxClustersCount(int maxClustersCount)
```
    \brief Maximal number of generated clusters. If the number is exceeded, the clusters are sorted by their weights and the smallest clusters are cropped.
  - getClusterMinSize
```
public int getClusterMinSize()
```
    \brief 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.
  - setClusterMinSize
```
public void setClusterMinSize(int clusterMinSize)
```
    \brief 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.
  - getJoiningDistance
```
public float getJoiningDistance()
```
    \brief 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.
  - setJoiningDistance
```
public void setJoiningDistance(float joiningDistance)
```
    \brief 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.
  - getDropThreshold
```
public float getDropThreshold()
```
    \brief Remove centroids in k-means whose weight is lesser or equal to given threshold.
  - setDropThreshold
```
public void setDropThreshold(float dropThreshold)
```
    \brief Remove centroids in k-means whose weight is lesser or equal to given threshold.
  - getDistanceFunction
```
public int getDistanceFunction()
```
    \brief Distance function selector used for measuring distance between two points in k-means.
  - setDistanceFunction
```
public void setDistanceFunction(int distanceFunction)
```
    \brief Distance function selector used for measuring distance between two points in k-means. Available: L0_25, L0_5, L1, L2, L2SQUARED, L5, L_INFINITY.

Class PCTSignatures

Nested Class Summary

Nested classes/interfaces inherited from class org.bytedeco.javacpp.Pointer

Field Summary

Fields inherited from class org.bytedeco.javacpp.Pointer

Constructor Summary

Method Summary

Methods inherited from class org.bytedeco.opencv.opencv_core.Algorithm

Methods inherited from class org.bytedeco.javacpp.Pointer

Methods inherited from class java.lang.Object

Field Detail

L0_25

L0_5

L1

L2

L2SQUARED

L5

L_INFINITY

UNIFORM

REGULAR

NORMAL

MINUS

GAUSSIAN

HEURISTIC

Constructor Detail

PCTSignatures

Method Detail

create

create

create

create

create

create

computeSignature

computeSignature

computeSignature

computeSignatures

drawSignature

drawSignature

drawSignature

drawSignature

drawSignature

drawSignature

generateInitPoints

getSampleCount

getGrayscaleBits

setGrayscaleBits

getWindowRadius

setWindowRadius

getWeightX

setWeightX

getWeightY

setWeightY

getWeightL

setWeightL

getWeightA

setWeightA

getWeightB

setWeightB

getWeightContrast

setWeightContrast

getWeightEntropy

setWeightEntropy

getSamplingPoints

setWeight

setWeights

setWeights

setWeights

setTranslation

setTranslations

setTranslations

setTranslations

setSamplingPoints

getInitSeedIndexes

setInitSeedIndexes

setInitSeedIndexes

setInitSeedIndexes

getInitSeedCount

getIterationCount

setIterationCount