1342 lines
46 KiB
C#
1342 lines
46 KiB
C#
|
|
using OpenCVForUnity.CoreModule;
|
|
using OpenCVForUnity.UtilsModule;
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.Runtime.InteropServices;
|
|
|
|
namespace OpenCVForUnity.Xfeatures2dModule
|
|
{
|
|
|
|
// C++: class PCTSignatures
|
|
/**
|
|
* 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
|
|
*/
|
|
|
|
public class PCTSignatures : Algorithm
|
|
{
|
|
|
|
protected override void Dispose(bool disposing)
|
|
{
|
|
|
|
try
|
|
{
|
|
if (disposing)
|
|
{
|
|
}
|
|
if (IsEnabledDispose)
|
|
{
|
|
if (nativeObj != IntPtr.Zero)
|
|
xfeatures2d_PCTSignatures_delete(nativeObj);
|
|
nativeObj = IntPtr.Zero;
|
|
}
|
|
}
|
|
finally
|
|
{
|
|
base.Dispose(disposing);
|
|
}
|
|
|
|
}
|
|
|
|
protected internal PCTSignatures(IntPtr addr) : base(addr) { }
|
|
|
|
// internal usage only
|
|
public static new PCTSignatures __fromPtr__(IntPtr addr) { return new PCTSignatures(addr); }
|
|
|
|
// C++: enum cv.xfeatures2d.PCTSignatures.DistanceFunction
|
|
public const int L0_25 = 0;
|
|
public const int L0_5 = 1;
|
|
public const int L1 = 2;
|
|
public const int L2 = 3;
|
|
public const int L2SQUARED = 4;
|
|
public const int L5 = 5;
|
|
public const int L_INFINITY = 6;
|
|
// C++: enum cv.xfeatures2d.PCTSignatures.PointDistribution
|
|
public const int UNIFORM = 0;
|
|
public const int REGULAR = 1;
|
|
public const int NORMAL = 2;
|
|
// C++: enum cv.xfeatures2d.PCTSignatures.SimilarityFunction
|
|
public const int MINUS = 0;
|
|
public const int GAUSSIAN = 1;
|
|
public const int HEURISTIC = 2;
|
|
//
|
|
// C++: static Ptr_PCTSignatures cv::xfeatures2d::PCTSignatures::create(int initSampleCount = 2000, int initSeedCount = 400, int pointDistribution = 0)
|
|
//
|
|
|
|
/**
|
|
* Creates PCTSignatures algorithm using sample and seed count.
|
|
* It generates its own sets of sampling points and clusterization seed indexes.
|
|
* param initSampleCount Number of points used for image sampling.
|
|
* param initSeedCount Number of initial clusterization seeds.
|
|
* Must be lower or equal to initSampleCount
|
|
* param pointDistribution Distribution of generated points. Default: UNIFORM.
|
|
* Available: UNIFORM, REGULAR, NORMAL.
|
|
* return Created algorithm.
|
|
*/
|
|
public static PCTSignatures create(int initSampleCount, int initSeedCount, int pointDistribution)
|
|
{
|
|
|
|
|
|
return PCTSignatures.__fromPtr__(DisposableObject.ThrowIfNullIntPtr(xfeatures2d_PCTSignatures_create_10(initSampleCount, initSeedCount, pointDistribution)));
|
|
|
|
|
|
}
|
|
|
|
/**
|
|
* Creates PCTSignatures algorithm using sample and seed count.
|
|
* It generates its own sets of sampling points and clusterization seed indexes.
|
|
* param initSampleCount Number of points used for image sampling.
|
|
* param initSeedCount Number of initial clusterization seeds.
|
|
* Must be lower or equal to initSampleCount
|
|
* Available: UNIFORM, REGULAR, NORMAL.
|
|
* return Created algorithm.
|
|
*/
|
|
public static PCTSignatures create(int initSampleCount, int initSeedCount)
|
|
{
|
|
|
|
|
|
return PCTSignatures.__fromPtr__(DisposableObject.ThrowIfNullIntPtr(xfeatures2d_PCTSignatures_create_11(initSampleCount, initSeedCount)));
|
|
|
|
|
|
}
|
|
|
|
/**
|
|
* Creates PCTSignatures algorithm using sample and seed count.
|
|
* It generates its own sets of sampling points and clusterization seed indexes.
|
|
* param initSampleCount Number of points used for image sampling.
|
|
* Must be lower or equal to initSampleCount
|
|
* Available: UNIFORM, REGULAR, NORMAL.
|
|
* return Created algorithm.
|
|
*/
|
|
public static PCTSignatures create(int initSampleCount)
|
|
{
|
|
|
|
|
|
return PCTSignatures.__fromPtr__(DisposableObject.ThrowIfNullIntPtr(xfeatures2d_PCTSignatures_create_12(initSampleCount)));
|
|
|
|
|
|
}
|
|
|
|
/**
|
|
* Creates PCTSignatures algorithm using sample and seed count.
|
|
* It generates its own sets of sampling points and clusterization seed indexes.
|
|
* Must be lower or equal to initSampleCount
|
|
* Available: UNIFORM, REGULAR, NORMAL.
|
|
* return Created algorithm.
|
|
*/
|
|
public static PCTSignatures create()
|
|
{
|
|
|
|
|
|
return PCTSignatures.__fromPtr__(DisposableObject.ThrowIfNullIntPtr(xfeatures2d_PCTSignatures_create_13()));
|
|
|
|
|
|
}
|
|
|
|
|
|
//
|
|
// C++: static Ptr_PCTSignatures cv::xfeatures2d::PCTSignatures::create(vector_Point2f initSamplingPoints, 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.
|
|
* param initSamplingPoints Sampling points used in image sampling.
|
|
* param initSeedCount Number of initial clusterization seeds.
|
|
* Must be lower or equal to initSamplingPoints.size().
|
|
* return Created algorithm.
|
|
*/
|
|
public static PCTSignatures create(MatOfPoint2f initSamplingPoints, int initSeedCount)
|
|
{
|
|
if (initSamplingPoints != null) initSamplingPoints.ThrowIfDisposed();
|
|
Mat initSamplingPoints_mat = initSamplingPoints;
|
|
return PCTSignatures.__fromPtr__(DisposableObject.ThrowIfNullIntPtr(xfeatures2d_PCTSignatures_create_14(initSamplingPoints_mat.nativeObj, initSeedCount)));
|
|
|
|
|
|
}
|
|
|
|
|
|
//
|
|
// C++: static Ptr_PCTSignatures cv::xfeatures2d::PCTSignatures::create(vector_Point2f initSamplingPoints, vector_int initClusterSeedIndexes)
|
|
//
|
|
|
|
/**
|
|
* Creates PCTSignatures algorithm using pre-generated sampling points
|
|
* and clusterization seeds indexes.
|
|
* param initSamplingPoints Sampling points used in image sampling.
|
|
* param initClusterSeedIndexes Indexes of initial clusterization seeds.
|
|
* Its size must be lower or equal to initSamplingPoints.size().
|
|
* return Created algorithm.
|
|
*/
|
|
public static PCTSignatures create(MatOfPoint2f initSamplingPoints, MatOfInt initClusterSeedIndexes)
|
|
{
|
|
if (initSamplingPoints != null) initSamplingPoints.ThrowIfDisposed();
|
|
if (initClusterSeedIndexes != null) initClusterSeedIndexes.ThrowIfDisposed();
|
|
Mat initSamplingPoints_mat = initSamplingPoints;
|
|
Mat initClusterSeedIndexes_mat = initClusterSeedIndexes;
|
|
return PCTSignatures.__fromPtr__(DisposableObject.ThrowIfNullIntPtr(xfeatures2d_PCTSignatures_create_15(initSamplingPoints_mat.nativeObj, initClusterSeedIndexes_mat.nativeObj)));
|
|
|
|
|
|
}
|
|
|
|
|
|
//
|
|
// C++: void cv::xfeatures2d::PCTSignatures::computeSignature(Mat image, Mat& signature)
|
|
//
|
|
|
|
/**
|
|
* Computes signature of given image.
|
|
* param image Input image of CV_8U type.
|
|
* param signature Output computed signature.
|
|
*/
|
|
public void computeSignature(Mat image, Mat signature)
|
|
{
|
|
ThrowIfDisposed();
|
|
if (image != null) image.ThrowIfDisposed();
|
|
if (signature != null) signature.ThrowIfDisposed();
|
|
|
|
xfeatures2d_PCTSignatures_computeSignature_10(nativeObj, image.nativeObj, signature.nativeObj);
|
|
|
|
|
|
}
|
|
|
|
|
|
//
|
|
// C++: void cv::xfeatures2d::PCTSignatures::computeSignatures(vector_Mat images, vector_Mat signatures)
|
|
//
|
|
|
|
/**
|
|
* Computes signatures for multiple images in parallel.
|
|
* param images Vector of input images of CV_8U type.
|
|
* param signatures Vector of computed signatures.
|
|
*/
|
|
public void computeSignatures(List<Mat> images, List<Mat> signatures)
|
|
{
|
|
ThrowIfDisposed();
|
|
Mat images_mat = Converters.vector_Mat_to_Mat(images);
|
|
Mat signatures_mat = Converters.vector_Mat_to_Mat(signatures);
|
|
xfeatures2d_PCTSignatures_computeSignatures_10(nativeObj, images_mat.nativeObj, signatures_mat.nativeObj);
|
|
|
|
|
|
}
|
|
|
|
|
|
//
|
|
// C++: static void cv::xfeatures2d::PCTSignatures::drawSignature(Mat source, Mat signature, Mat& 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.
|
|
* param source Source image.
|
|
* param signature Image signature.
|
|
* param result Output result.
|
|
* param radiusToShorterSideRatio Determines maximal radius of signature in the output image.
|
|
* param borderThickness Border thickness of the visualized signature.
|
|
*/
|
|
public static void drawSignature(Mat source, Mat signature, Mat result, float radiusToShorterSideRatio, int borderThickness)
|
|
{
|
|
if (source != null) source.ThrowIfDisposed();
|
|
if (signature != null) signature.ThrowIfDisposed();
|
|
if (result != null) result.ThrowIfDisposed();
|
|
|
|
xfeatures2d_PCTSignatures_drawSignature_10(source.nativeObj, signature.nativeObj, result.nativeObj, radiusToShorterSideRatio, borderThickness);
|
|
|
|
|
|
}
|
|
|
|
/**
|
|
* 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.
|
|
* param source Source image.
|
|
* param signature Image signature.
|
|
* param result Output result.
|
|
* param radiusToShorterSideRatio Determines maximal radius of signature in the output image.
|
|
*/
|
|
public static void drawSignature(Mat source, Mat signature, Mat result, float radiusToShorterSideRatio)
|
|
{
|
|
if (source != null) source.ThrowIfDisposed();
|
|
if (signature != null) signature.ThrowIfDisposed();
|
|
if (result != null) result.ThrowIfDisposed();
|
|
|
|
xfeatures2d_PCTSignatures_drawSignature_11(source.nativeObj, signature.nativeObj, result.nativeObj, radiusToShorterSideRatio);
|
|
|
|
|
|
}
|
|
|
|
/**
|
|
* 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.
|
|
* param source Source image.
|
|
* param signature Image signature.
|
|
* param result Output result.
|
|
*/
|
|
public static void drawSignature(Mat source, Mat signature, Mat result)
|
|
{
|
|
if (source != null) source.ThrowIfDisposed();
|
|
if (signature != null) signature.ThrowIfDisposed();
|
|
if (result != null) result.ThrowIfDisposed();
|
|
|
|
xfeatures2d_PCTSignatures_drawSignature_12(source.nativeObj, signature.nativeObj, result.nativeObj);
|
|
|
|
|
|
}
|
|
|
|
|
|
//
|
|
// C++: static void cv::xfeatures2d::PCTSignatures::generateInitPoints(vector_Point2f initPoints, int count, int pointDistribution)
|
|
//
|
|
|
|
/**
|
|
* Generates initial sampling points according to selected point distribution.
|
|
* param initPoints Output vector where the generated points will be saved.
|
|
* param count Number of points to generate.
|
|
* param pointDistribution Point distribution selector.
|
|
* Available: UNIFORM, REGULAR, NORMAL.
|
|
* <b>Note:</b> Generated coordinates are in range [0..1)
|
|
*/
|
|
public static void generateInitPoints(MatOfPoint2f initPoints, int count, int pointDistribution)
|
|
{
|
|
if (initPoints != null) initPoints.ThrowIfDisposed();
|
|
Mat initPoints_mat = initPoints;
|
|
xfeatures2d_PCTSignatures_generateInitPoints_10(initPoints_mat.nativeObj, count, pointDistribution);
|
|
|
|
|
|
}
|
|
|
|
|
|
//
|
|
// C++: int cv::xfeatures2d::PCTSignatures::getSampleCount()
|
|
//
|
|
|
|
/**
|
|
* Number of initial samples taken from the image.
|
|
* return automatically generated
|
|
*/
|
|
public int getSampleCount()
|
|
{
|
|
ThrowIfDisposed();
|
|
|
|
return xfeatures2d_PCTSignatures_getSampleCount_10(nativeObj);
|
|
|
|
|
|
}
|
|
|
|
|
|
//
|
|
// C++: int cv::xfeatures2d::PCTSignatures::getGrayscaleBits()
|
|
//
|
|
|
|
/**
|
|
* 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.
|
|
* return automatically generated
|
|
*/
|
|
public int getGrayscaleBits()
|
|
{
|
|
ThrowIfDisposed();
|
|
|
|
return xfeatures2d_PCTSignatures_getGrayscaleBits_10(nativeObj);
|
|
|
|
|
|
}
|
|
|
|
|
|
//
|
|
// C++: void cv::xfeatures2d::PCTSignatures::setGrayscaleBits(int grayscaleBits)
|
|
//
|
|
|
|
/**
|
|
* 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.
|
|
* param grayscaleBits automatically generated
|
|
*/
|
|
public void setGrayscaleBits(int grayscaleBits)
|
|
{
|
|
ThrowIfDisposed();
|
|
|
|
xfeatures2d_PCTSignatures_setGrayscaleBits_10(nativeObj, grayscaleBits);
|
|
|
|
|
|
}
|
|
|
|
|
|
//
|
|
// C++: int cv::xfeatures2d::PCTSignatures::getWindowRadius()
|
|
//
|
|
|
|
/**
|
|
* 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).
|
|
* return automatically generated
|
|
*/
|
|
public int getWindowRadius()
|
|
{
|
|
ThrowIfDisposed();
|
|
|
|
return xfeatures2d_PCTSignatures_getWindowRadius_10(nativeObj);
|
|
|
|
|
|
}
|
|
|
|
|
|
//
|
|
// C++: void cv::xfeatures2d::PCTSignatures::setWindowRadius(int radius)
|
|
//
|
|
|
|
/**
|
|
* 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).
|
|
* param radius automatically generated
|
|
*/
|
|
public void setWindowRadius(int radius)
|
|
{
|
|
ThrowIfDisposed();
|
|
|
|
xfeatures2d_PCTSignatures_setWindowRadius_10(nativeObj, radius);
|
|
|
|
|
|
}
|
|
|
|
|
|
//
|
|
// C++: float cv::xfeatures2d::PCTSignatures::getWeightX()
|
|
//
|
|
|
|
/**
|
|
* 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)
|
|
* return automatically generated
|
|
*/
|
|
public float getWeightX()
|
|
{
|
|
ThrowIfDisposed();
|
|
|
|
return xfeatures2d_PCTSignatures_getWeightX_10(nativeObj);
|
|
|
|
|
|
}
|
|
|
|
|
|
//
|
|
// C++: void cv::xfeatures2d::PCTSignatures::setWeightX(float weight)
|
|
//
|
|
|
|
/**
|
|
* 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)
|
|
* param weight automatically generated
|
|
*/
|
|
public void setWeightX(float weight)
|
|
{
|
|
ThrowIfDisposed();
|
|
|
|
xfeatures2d_PCTSignatures_setWeightX_10(nativeObj, weight);
|
|
|
|
|
|
}
|
|
|
|
|
|
//
|
|
// C++: float cv::xfeatures2d::PCTSignatures::getWeightY()
|
|
//
|
|
|
|
/**
|
|
* 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)
|
|
* return automatically generated
|
|
*/
|
|
public float getWeightY()
|
|
{
|
|
ThrowIfDisposed();
|
|
|
|
return xfeatures2d_PCTSignatures_getWeightY_10(nativeObj);
|
|
|
|
|
|
}
|
|
|
|
|
|
//
|
|
// C++: void cv::xfeatures2d::PCTSignatures::setWeightY(float weight)
|
|
//
|
|
|
|
/**
|
|
* 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)
|
|
* param weight automatically generated
|
|
*/
|
|
public void setWeightY(float weight)
|
|
{
|
|
ThrowIfDisposed();
|
|
|
|
xfeatures2d_PCTSignatures_setWeightY_10(nativeObj, weight);
|
|
|
|
|
|
}
|
|
|
|
|
|
//
|
|
// C++: float cv::xfeatures2d::PCTSignatures::getWeightL()
|
|
//
|
|
|
|
/**
|
|
* 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)
|
|
* return automatically generated
|
|
*/
|
|
public float getWeightL()
|
|
{
|
|
ThrowIfDisposed();
|
|
|
|
return xfeatures2d_PCTSignatures_getWeightL_10(nativeObj);
|
|
|
|
|
|
}
|
|
|
|
|
|
//
|
|
// C++: void cv::xfeatures2d::PCTSignatures::setWeightL(float weight)
|
|
//
|
|
|
|
/**
|
|
* 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)
|
|
* param weight automatically generated
|
|
*/
|
|
public void setWeightL(float weight)
|
|
{
|
|
ThrowIfDisposed();
|
|
|
|
xfeatures2d_PCTSignatures_setWeightL_10(nativeObj, weight);
|
|
|
|
|
|
}
|
|
|
|
|
|
//
|
|
// C++: float cv::xfeatures2d::PCTSignatures::getWeightA()
|
|
//
|
|
|
|
/**
|
|
* 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)
|
|
* return automatically generated
|
|
*/
|
|
public float getWeightA()
|
|
{
|
|
ThrowIfDisposed();
|
|
|
|
return xfeatures2d_PCTSignatures_getWeightA_10(nativeObj);
|
|
|
|
|
|
}
|
|
|
|
|
|
//
|
|
// C++: void cv::xfeatures2d::PCTSignatures::setWeightA(float weight)
|
|
//
|
|
|
|
/**
|
|
* 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)
|
|
* param weight automatically generated
|
|
*/
|
|
public void setWeightA(float weight)
|
|
{
|
|
ThrowIfDisposed();
|
|
|
|
xfeatures2d_PCTSignatures_setWeightA_10(nativeObj, weight);
|
|
|
|
|
|
}
|
|
|
|
|
|
//
|
|
// C++: float cv::xfeatures2d::PCTSignatures::getWeightB()
|
|
//
|
|
|
|
/**
|
|
* 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)
|
|
* return automatically generated
|
|
*/
|
|
public float getWeightB()
|
|
{
|
|
ThrowIfDisposed();
|
|
|
|
return xfeatures2d_PCTSignatures_getWeightB_10(nativeObj);
|
|
|
|
|
|
}
|
|
|
|
|
|
//
|
|
// C++: void cv::xfeatures2d::PCTSignatures::setWeightB(float weight)
|
|
//
|
|
|
|
/**
|
|
* 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)
|
|
* param weight automatically generated
|
|
*/
|
|
public void setWeightB(float weight)
|
|
{
|
|
ThrowIfDisposed();
|
|
|
|
xfeatures2d_PCTSignatures_setWeightB_10(nativeObj, weight);
|
|
|
|
|
|
}
|
|
|
|
|
|
//
|
|
// C++: float cv::xfeatures2d::PCTSignatures::getWeightContrast()
|
|
//
|
|
|
|
/**
|
|
* 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)
|
|
* return automatically generated
|
|
*/
|
|
public float getWeightContrast()
|
|
{
|
|
ThrowIfDisposed();
|
|
|
|
return xfeatures2d_PCTSignatures_getWeightContrast_10(nativeObj);
|
|
|
|
|
|
}
|
|
|
|
|
|
//
|
|
// C++: void cv::xfeatures2d::PCTSignatures::setWeightContrast(float weight)
|
|
//
|
|
|
|
/**
|
|
* 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)
|
|
* param weight automatically generated
|
|
*/
|
|
public void setWeightContrast(float weight)
|
|
{
|
|
ThrowIfDisposed();
|
|
|
|
xfeatures2d_PCTSignatures_setWeightContrast_10(nativeObj, weight);
|
|
|
|
|
|
}
|
|
|
|
|
|
//
|
|
// C++: float cv::xfeatures2d::PCTSignatures::getWeightEntropy()
|
|
//
|
|
|
|
/**
|
|
* 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)
|
|
* return automatically generated
|
|
*/
|
|
public float getWeightEntropy()
|
|
{
|
|
ThrowIfDisposed();
|
|
|
|
return xfeatures2d_PCTSignatures_getWeightEntropy_10(nativeObj);
|
|
|
|
|
|
}
|
|
|
|
|
|
//
|
|
// C++: void cv::xfeatures2d::PCTSignatures::setWeightEntropy(float weight)
|
|
//
|
|
|
|
/**
|
|
* 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)
|
|
* param weight automatically generated
|
|
*/
|
|
public void setWeightEntropy(float weight)
|
|
{
|
|
ThrowIfDisposed();
|
|
|
|
xfeatures2d_PCTSignatures_setWeightEntropy_10(nativeObj, weight);
|
|
|
|
|
|
}
|
|
|
|
|
|
//
|
|
// C++: vector_Point2f cv::xfeatures2d::PCTSignatures::getSamplingPoints()
|
|
//
|
|
|
|
/**
|
|
* Initial samples taken from the image.
|
|
* These sampled features become the input for clustering.
|
|
* return automatically generated
|
|
*/
|
|
public MatOfPoint2f getSamplingPoints()
|
|
{
|
|
ThrowIfDisposed();
|
|
|
|
return MatOfPoint2f.fromNativeAddr(DisposableObject.ThrowIfNullIntPtr(xfeatures2d_PCTSignatures_getSamplingPoints_10(nativeObj)));
|
|
|
|
|
|
}
|
|
|
|
|
|
//
|
|
// C++: void cv::xfeatures2d::PCTSignatures::setWeight(int idx, float value)
|
|
//
|
|
|
|
/**
|
|
* Weights (multiplicative constants) that linearly stretch individual axes of the feature space.
|
|
* param idx ID of the weight
|
|
* param value Value of the weight
|
|
* <b>Note:</b>
|
|
* WEIGHT_IDX = 0;
|
|
* X_IDX = 1;
|
|
* Y_IDX = 2;
|
|
* L_IDX = 3;
|
|
* A_IDX = 4;
|
|
* B_IDX = 5;
|
|
* CONTRAST_IDX = 6;
|
|
* ENTROPY_IDX = 7;
|
|
*/
|
|
public void setWeight(int idx, float value)
|
|
{
|
|
ThrowIfDisposed();
|
|
|
|
xfeatures2d_PCTSignatures_setWeight_10(nativeObj, idx, value);
|
|
|
|
|
|
}
|
|
|
|
|
|
//
|
|
// C++: void cv::xfeatures2d::PCTSignatures::setWeights(vector_float weights)
|
|
//
|
|
|
|
/**
|
|
* Weights (multiplicative constants) that linearly stretch individual axes of the feature space.
|
|
* param weights Values of all weights.
|
|
* <b>Note:</b>
|
|
* WEIGHT_IDX = 0;
|
|
* X_IDX = 1;
|
|
* Y_IDX = 2;
|
|
* L_IDX = 3;
|
|
* A_IDX = 4;
|
|
* B_IDX = 5;
|
|
* CONTRAST_IDX = 6;
|
|
* ENTROPY_IDX = 7;
|
|
*/
|
|
public void setWeights(MatOfFloat weights)
|
|
{
|
|
ThrowIfDisposed();
|
|
if (weights != null) weights.ThrowIfDisposed();
|
|
Mat weights_mat = weights;
|
|
xfeatures2d_PCTSignatures_setWeights_10(nativeObj, weights_mat.nativeObj);
|
|
|
|
|
|
}
|
|
|
|
|
|
//
|
|
// C++: void cv::xfeatures2d::PCTSignatures::setTranslation(int idx, float value)
|
|
//
|
|
|
|
/**
|
|
* Translations of the individual axes of the feature space.
|
|
* param idx ID of the translation
|
|
* param value Value of the translation
|
|
* <b>Note:</b>
|
|
* WEIGHT_IDX = 0;
|
|
* X_IDX = 1;
|
|
* Y_IDX = 2;
|
|
* L_IDX = 3;
|
|
* A_IDX = 4;
|
|
* B_IDX = 5;
|
|
* CONTRAST_IDX = 6;
|
|
* ENTROPY_IDX = 7;
|
|
*/
|
|
public void setTranslation(int idx, float value)
|
|
{
|
|
ThrowIfDisposed();
|
|
|
|
xfeatures2d_PCTSignatures_setTranslation_10(nativeObj, idx, value);
|
|
|
|
|
|
}
|
|
|
|
|
|
//
|
|
// C++: void cv::xfeatures2d::PCTSignatures::setTranslations(vector_float translations)
|
|
//
|
|
|
|
/**
|
|
* Translations of the individual axes of the feature space.
|
|
* param translations Values of all translations.
|
|
* <b>Note:</b>
|
|
* WEIGHT_IDX = 0;
|
|
* X_IDX = 1;
|
|
* Y_IDX = 2;
|
|
* L_IDX = 3;
|
|
* A_IDX = 4;
|
|
* B_IDX = 5;
|
|
* CONTRAST_IDX = 6;
|
|
* ENTROPY_IDX = 7;
|
|
*/
|
|
public void setTranslations(MatOfFloat translations)
|
|
{
|
|
ThrowIfDisposed();
|
|
if (translations != null) translations.ThrowIfDisposed();
|
|
Mat translations_mat = translations;
|
|
xfeatures2d_PCTSignatures_setTranslations_10(nativeObj, translations_mat.nativeObj);
|
|
|
|
|
|
}
|
|
|
|
|
|
//
|
|
// C++: void cv::xfeatures2d::PCTSignatures::setSamplingPoints(vector_Point2f samplingPoints)
|
|
//
|
|
|
|
/**
|
|
* Sets sampling points used to sample the input image.
|
|
* param samplingPoints Vector of sampling points in range [0..1)
|
|
* <b>Note:</b> Number of sampling points must be greater or equal to clusterization seed count.
|
|
*/
|
|
public void setSamplingPoints(MatOfPoint2f samplingPoints)
|
|
{
|
|
ThrowIfDisposed();
|
|
if (samplingPoints != null) samplingPoints.ThrowIfDisposed();
|
|
Mat samplingPoints_mat = samplingPoints;
|
|
xfeatures2d_PCTSignatures_setSamplingPoints_10(nativeObj, samplingPoints_mat.nativeObj);
|
|
|
|
|
|
}
|
|
|
|
|
|
//
|
|
// C++: vector_int cv::xfeatures2d::PCTSignatures::getInitSeedIndexes()
|
|
//
|
|
|
|
/**
|
|
* Initial seeds (initial number of clusters) for the k-means algorithm.
|
|
* return automatically generated
|
|
*/
|
|
public MatOfInt getInitSeedIndexes()
|
|
{
|
|
ThrowIfDisposed();
|
|
|
|
return MatOfInt.fromNativeAddr(DisposableObject.ThrowIfNullIntPtr(xfeatures2d_PCTSignatures_getInitSeedIndexes_10(nativeObj)));
|
|
|
|
|
|
}
|
|
|
|
|
|
//
|
|
// C++: void cv::xfeatures2d::PCTSignatures::setInitSeedIndexes(vector_int initSeedIndexes)
|
|
//
|
|
|
|
/**
|
|
* Initial seed indexes for the k-means algorithm.
|
|
* param initSeedIndexes automatically generated
|
|
*/
|
|
public void setInitSeedIndexes(MatOfInt initSeedIndexes)
|
|
{
|
|
ThrowIfDisposed();
|
|
if (initSeedIndexes != null) initSeedIndexes.ThrowIfDisposed();
|
|
Mat initSeedIndexes_mat = initSeedIndexes;
|
|
xfeatures2d_PCTSignatures_setInitSeedIndexes_10(nativeObj, initSeedIndexes_mat.nativeObj);
|
|
|
|
|
|
}
|
|
|
|
|
|
//
|
|
// C++: int cv::xfeatures2d::PCTSignatures::getInitSeedCount()
|
|
//
|
|
|
|
/**
|
|
* Number of initial seeds (initial number of clusters) for the k-means algorithm.
|
|
* return automatically generated
|
|
*/
|
|
public int getInitSeedCount()
|
|
{
|
|
ThrowIfDisposed();
|
|
|
|
return xfeatures2d_PCTSignatures_getInitSeedCount_10(nativeObj);
|
|
|
|
|
|
}
|
|
|
|
|
|
//
|
|
// C++: int cv::xfeatures2d::PCTSignatures::getIterationCount()
|
|
//
|
|
|
|
/**
|
|
* 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).
|
|
* return automatically generated
|
|
*/
|
|
public int getIterationCount()
|
|
{
|
|
ThrowIfDisposed();
|
|
|
|
return xfeatures2d_PCTSignatures_getIterationCount_10(nativeObj);
|
|
|
|
|
|
}
|
|
|
|
|
|
//
|
|
// C++: void cv::xfeatures2d::PCTSignatures::setIterationCount(int iterationCount)
|
|
//
|
|
|
|
/**
|
|
* 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).
|
|
* param iterationCount automatically generated
|
|
*/
|
|
public void setIterationCount(int iterationCount)
|
|
{
|
|
ThrowIfDisposed();
|
|
|
|
xfeatures2d_PCTSignatures_setIterationCount_10(nativeObj, iterationCount);
|
|
|
|
|
|
}
|
|
|
|
|
|
//
|
|
// C++: int cv::xfeatures2d::PCTSignatures::getMaxClustersCount()
|
|
//
|
|
|
|
/**
|
|
* Maximal number of generated clusters. If the number is exceeded,
|
|
* the clusters are sorted by their weights and the smallest clusters are cropped.
|
|
* return automatically generated
|
|
*/
|
|
public int getMaxClustersCount()
|
|
{
|
|
ThrowIfDisposed();
|
|
|
|
return xfeatures2d_PCTSignatures_getMaxClustersCount_10(nativeObj);
|
|
|
|
|
|
}
|
|
|
|
|
|
//
|
|
// C++: void cv::xfeatures2d::PCTSignatures::setMaxClustersCount(int maxClustersCount)
|
|
//
|
|
|
|
/**
|
|
* Maximal number of generated clusters. If the number is exceeded,
|
|
* the clusters are sorted by their weights and the smallest clusters are cropped.
|
|
* param maxClustersCount automatically generated
|
|
*/
|
|
public void setMaxClustersCount(int maxClustersCount)
|
|
{
|
|
ThrowIfDisposed();
|
|
|
|
xfeatures2d_PCTSignatures_setMaxClustersCount_10(nativeObj, maxClustersCount);
|
|
|
|
|
|
}
|
|
|
|
|
|
//
|
|
// C++: int cv::xfeatures2d::PCTSignatures::getClusterMinSize()
|
|
//
|
|
|
|
/**
|
|
* 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.
|
|
* return automatically generated
|
|
*/
|
|
public int getClusterMinSize()
|
|
{
|
|
ThrowIfDisposed();
|
|
|
|
return xfeatures2d_PCTSignatures_getClusterMinSize_10(nativeObj);
|
|
|
|
|
|
}
|
|
|
|
|
|
//
|
|
// C++: void cv::xfeatures2d::PCTSignatures::setClusterMinSize(int clusterMinSize)
|
|
//
|
|
|
|
/**
|
|
* 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.
|
|
* param clusterMinSize automatically generated
|
|
*/
|
|
public void setClusterMinSize(int clusterMinSize)
|
|
{
|
|
ThrowIfDisposed();
|
|
|
|
xfeatures2d_PCTSignatures_setClusterMinSize_10(nativeObj, clusterMinSize);
|
|
|
|
|
|
}
|
|
|
|
|
|
//
|
|
// C++: float cv::xfeatures2d::PCTSignatures::getJoiningDistance()
|
|
//
|
|
|
|
/**
|
|
* 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.
|
|
* return automatically generated
|
|
*/
|
|
public float getJoiningDistance()
|
|
{
|
|
ThrowIfDisposed();
|
|
|
|
return xfeatures2d_PCTSignatures_getJoiningDistance_10(nativeObj);
|
|
|
|
|
|
}
|
|
|
|
|
|
//
|
|
// C++: void cv::xfeatures2d::PCTSignatures::setJoiningDistance(float joiningDistance)
|
|
//
|
|
|
|
/**
|
|
* 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.
|
|
* param joiningDistance automatically generated
|
|
*/
|
|
public void setJoiningDistance(float joiningDistance)
|
|
{
|
|
ThrowIfDisposed();
|
|
|
|
xfeatures2d_PCTSignatures_setJoiningDistance_10(nativeObj, joiningDistance);
|
|
|
|
|
|
}
|
|
|
|
|
|
//
|
|
// C++: float cv::xfeatures2d::PCTSignatures::getDropThreshold()
|
|
//
|
|
|
|
/**
|
|
* Remove centroids in k-means whose weight is lesser or equal to given threshold.
|
|
* return automatically generated
|
|
*/
|
|
public float getDropThreshold()
|
|
{
|
|
ThrowIfDisposed();
|
|
|
|
return xfeatures2d_PCTSignatures_getDropThreshold_10(nativeObj);
|
|
|
|
|
|
}
|
|
|
|
|
|
//
|
|
// C++: void cv::xfeatures2d::PCTSignatures::setDropThreshold(float dropThreshold)
|
|
//
|
|
|
|
/**
|
|
* Remove centroids in k-means whose weight is lesser or equal to given threshold.
|
|
* param dropThreshold automatically generated
|
|
*/
|
|
public void setDropThreshold(float dropThreshold)
|
|
{
|
|
ThrowIfDisposed();
|
|
|
|
xfeatures2d_PCTSignatures_setDropThreshold_10(nativeObj, dropThreshold);
|
|
|
|
|
|
}
|
|
|
|
|
|
//
|
|
// C++: int cv::xfeatures2d::PCTSignatures::getDistanceFunction()
|
|
//
|
|
|
|
/**
|
|
* Distance function selector used for measuring distance between two points in k-means.
|
|
* return automatically generated
|
|
*/
|
|
public int getDistanceFunction()
|
|
{
|
|
ThrowIfDisposed();
|
|
|
|
return xfeatures2d_PCTSignatures_getDistanceFunction_10(nativeObj);
|
|
|
|
|
|
}
|
|
|
|
|
|
//
|
|
// C++: void cv::xfeatures2d::PCTSignatures::setDistanceFunction(int distanceFunction)
|
|
//
|
|
|
|
/**
|
|
* Distance function selector used for measuring distance between two points in k-means.
|
|
* Available: L0_25, L0_5, L1, L2, L2SQUARED, L5, L_INFINITY.
|
|
* param distanceFunction automatically generated
|
|
*/
|
|
public void setDistanceFunction(int distanceFunction)
|
|
{
|
|
ThrowIfDisposed();
|
|
|
|
xfeatures2d_PCTSignatures_setDistanceFunction_10(nativeObj, distanceFunction);
|
|
|
|
|
|
}
|
|
|
|
|
|
#if (UNITY_IOS || UNITY_WEBGL) && !UNITY_EDITOR
|
|
const string LIBNAME = "__Internal";
|
|
#else
|
|
const string LIBNAME = "opencvforunity";
|
|
#endif
|
|
|
|
|
|
|
|
// C++: static Ptr_PCTSignatures cv::xfeatures2d::PCTSignatures::create(int initSampleCount = 2000, int initSeedCount = 400, int pointDistribution = 0)
|
|
[DllImport(LIBNAME)]
|
|
private static extern IntPtr xfeatures2d_PCTSignatures_create_10(int initSampleCount, int initSeedCount, int pointDistribution);
|
|
[DllImport(LIBNAME)]
|
|
private static extern IntPtr xfeatures2d_PCTSignatures_create_11(int initSampleCount, int initSeedCount);
|
|
[DllImport(LIBNAME)]
|
|
private static extern IntPtr xfeatures2d_PCTSignatures_create_12(int initSampleCount);
|
|
[DllImport(LIBNAME)]
|
|
private static extern IntPtr xfeatures2d_PCTSignatures_create_13();
|
|
|
|
// C++: static Ptr_PCTSignatures cv::xfeatures2d::PCTSignatures::create(vector_Point2f initSamplingPoints, int initSeedCount)
|
|
[DllImport(LIBNAME)]
|
|
private static extern IntPtr xfeatures2d_PCTSignatures_create_14(IntPtr initSamplingPoints_mat_nativeObj, int initSeedCount);
|
|
|
|
// C++: static Ptr_PCTSignatures cv::xfeatures2d::PCTSignatures::create(vector_Point2f initSamplingPoints, vector_int initClusterSeedIndexes)
|
|
[DllImport(LIBNAME)]
|
|
private static extern IntPtr xfeatures2d_PCTSignatures_create_15(IntPtr initSamplingPoints_mat_nativeObj, IntPtr initClusterSeedIndexes_mat_nativeObj);
|
|
|
|
// C++: void cv::xfeatures2d::PCTSignatures::computeSignature(Mat image, Mat& signature)
|
|
[DllImport(LIBNAME)]
|
|
private static extern void xfeatures2d_PCTSignatures_computeSignature_10(IntPtr nativeObj, IntPtr image_nativeObj, IntPtr signature_nativeObj);
|
|
|
|
// C++: void cv::xfeatures2d::PCTSignatures::computeSignatures(vector_Mat images, vector_Mat signatures)
|
|
[DllImport(LIBNAME)]
|
|
private static extern void xfeatures2d_PCTSignatures_computeSignatures_10(IntPtr nativeObj, IntPtr images_mat_nativeObj, IntPtr signatures_mat_nativeObj);
|
|
|
|
// C++: static void cv::xfeatures2d::PCTSignatures::drawSignature(Mat source, Mat signature, Mat& result, float radiusToShorterSideRatio = 1.0 / 8, int borderThickness = 1)
|
|
[DllImport(LIBNAME)]
|
|
private static extern void xfeatures2d_PCTSignatures_drawSignature_10(IntPtr source_nativeObj, IntPtr signature_nativeObj, IntPtr result_nativeObj, float radiusToShorterSideRatio, int borderThickness);
|
|
[DllImport(LIBNAME)]
|
|
private static extern void xfeatures2d_PCTSignatures_drawSignature_11(IntPtr source_nativeObj, IntPtr signature_nativeObj, IntPtr result_nativeObj, float radiusToShorterSideRatio);
|
|
[DllImport(LIBNAME)]
|
|
private static extern void xfeatures2d_PCTSignatures_drawSignature_12(IntPtr source_nativeObj, IntPtr signature_nativeObj, IntPtr result_nativeObj);
|
|
|
|
// C++: static void cv::xfeatures2d::PCTSignatures::generateInitPoints(vector_Point2f initPoints, int count, int pointDistribution)
|
|
[DllImport(LIBNAME)]
|
|
private static extern void xfeatures2d_PCTSignatures_generateInitPoints_10(IntPtr initPoints_mat_nativeObj, int count, int pointDistribution);
|
|
|
|
// C++: int cv::xfeatures2d::PCTSignatures::getSampleCount()
|
|
[DllImport(LIBNAME)]
|
|
private static extern int xfeatures2d_PCTSignatures_getSampleCount_10(IntPtr nativeObj);
|
|
|
|
// C++: int cv::xfeatures2d::PCTSignatures::getGrayscaleBits()
|
|
[DllImport(LIBNAME)]
|
|
private static extern int xfeatures2d_PCTSignatures_getGrayscaleBits_10(IntPtr nativeObj);
|
|
|
|
// C++: void cv::xfeatures2d::PCTSignatures::setGrayscaleBits(int grayscaleBits)
|
|
[DllImport(LIBNAME)]
|
|
private static extern void xfeatures2d_PCTSignatures_setGrayscaleBits_10(IntPtr nativeObj, int grayscaleBits);
|
|
|
|
// C++: int cv::xfeatures2d::PCTSignatures::getWindowRadius()
|
|
[DllImport(LIBNAME)]
|
|
private static extern int xfeatures2d_PCTSignatures_getWindowRadius_10(IntPtr nativeObj);
|
|
|
|
// C++: void cv::xfeatures2d::PCTSignatures::setWindowRadius(int radius)
|
|
[DllImport(LIBNAME)]
|
|
private static extern void xfeatures2d_PCTSignatures_setWindowRadius_10(IntPtr nativeObj, int radius);
|
|
|
|
// C++: float cv::xfeatures2d::PCTSignatures::getWeightX()
|
|
[DllImport(LIBNAME)]
|
|
private static extern float xfeatures2d_PCTSignatures_getWeightX_10(IntPtr nativeObj);
|
|
|
|
// C++: void cv::xfeatures2d::PCTSignatures::setWeightX(float weight)
|
|
[DllImport(LIBNAME)]
|
|
private static extern void xfeatures2d_PCTSignatures_setWeightX_10(IntPtr nativeObj, float weight);
|
|
|
|
// C++: float cv::xfeatures2d::PCTSignatures::getWeightY()
|
|
[DllImport(LIBNAME)]
|
|
private static extern float xfeatures2d_PCTSignatures_getWeightY_10(IntPtr nativeObj);
|
|
|
|
// C++: void cv::xfeatures2d::PCTSignatures::setWeightY(float weight)
|
|
[DllImport(LIBNAME)]
|
|
private static extern void xfeatures2d_PCTSignatures_setWeightY_10(IntPtr nativeObj, float weight);
|
|
|
|
// C++: float cv::xfeatures2d::PCTSignatures::getWeightL()
|
|
[DllImport(LIBNAME)]
|
|
private static extern float xfeatures2d_PCTSignatures_getWeightL_10(IntPtr nativeObj);
|
|
|
|
// C++: void cv::xfeatures2d::PCTSignatures::setWeightL(float weight)
|
|
[DllImport(LIBNAME)]
|
|
private static extern void xfeatures2d_PCTSignatures_setWeightL_10(IntPtr nativeObj, float weight);
|
|
|
|
// C++: float cv::xfeatures2d::PCTSignatures::getWeightA()
|
|
[DllImport(LIBNAME)]
|
|
private static extern float xfeatures2d_PCTSignatures_getWeightA_10(IntPtr nativeObj);
|
|
|
|
// C++: void cv::xfeatures2d::PCTSignatures::setWeightA(float weight)
|
|
[DllImport(LIBNAME)]
|
|
private static extern void xfeatures2d_PCTSignatures_setWeightA_10(IntPtr nativeObj, float weight);
|
|
|
|
// C++: float cv::xfeatures2d::PCTSignatures::getWeightB()
|
|
[DllImport(LIBNAME)]
|
|
private static extern float xfeatures2d_PCTSignatures_getWeightB_10(IntPtr nativeObj);
|
|
|
|
// C++: void cv::xfeatures2d::PCTSignatures::setWeightB(float weight)
|
|
[DllImport(LIBNAME)]
|
|
private static extern void xfeatures2d_PCTSignatures_setWeightB_10(IntPtr nativeObj, float weight);
|
|
|
|
// C++: float cv::xfeatures2d::PCTSignatures::getWeightContrast()
|
|
[DllImport(LIBNAME)]
|
|
private static extern float xfeatures2d_PCTSignatures_getWeightContrast_10(IntPtr nativeObj);
|
|
|
|
// C++: void cv::xfeatures2d::PCTSignatures::setWeightContrast(float weight)
|
|
[DllImport(LIBNAME)]
|
|
private static extern void xfeatures2d_PCTSignatures_setWeightContrast_10(IntPtr nativeObj, float weight);
|
|
|
|
// C++: float cv::xfeatures2d::PCTSignatures::getWeightEntropy()
|
|
[DllImport(LIBNAME)]
|
|
private static extern float xfeatures2d_PCTSignatures_getWeightEntropy_10(IntPtr nativeObj);
|
|
|
|
// C++: void cv::xfeatures2d::PCTSignatures::setWeightEntropy(float weight)
|
|
[DllImport(LIBNAME)]
|
|
private static extern void xfeatures2d_PCTSignatures_setWeightEntropy_10(IntPtr nativeObj, float weight);
|
|
|
|
// C++: vector_Point2f cv::xfeatures2d::PCTSignatures::getSamplingPoints()
|
|
[DllImport(LIBNAME)]
|
|
private static extern IntPtr xfeatures2d_PCTSignatures_getSamplingPoints_10(IntPtr nativeObj);
|
|
|
|
// C++: void cv::xfeatures2d::PCTSignatures::setWeight(int idx, float value)
|
|
[DllImport(LIBNAME)]
|
|
private static extern void xfeatures2d_PCTSignatures_setWeight_10(IntPtr nativeObj, int idx, float value);
|
|
|
|
// C++: void cv::xfeatures2d::PCTSignatures::setWeights(vector_float weights)
|
|
[DllImport(LIBNAME)]
|
|
private static extern void xfeatures2d_PCTSignatures_setWeights_10(IntPtr nativeObj, IntPtr weights_mat_nativeObj);
|
|
|
|
// C++: void cv::xfeatures2d::PCTSignatures::setTranslation(int idx, float value)
|
|
[DllImport(LIBNAME)]
|
|
private static extern void xfeatures2d_PCTSignatures_setTranslation_10(IntPtr nativeObj, int idx, float value);
|
|
|
|
// C++: void cv::xfeatures2d::PCTSignatures::setTranslations(vector_float translations)
|
|
[DllImport(LIBNAME)]
|
|
private static extern void xfeatures2d_PCTSignatures_setTranslations_10(IntPtr nativeObj, IntPtr translations_mat_nativeObj);
|
|
|
|
// C++: void cv::xfeatures2d::PCTSignatures::setSamplingPoints(vector_Point2f samplingPoints)
|
|
[DllImport(LIBNAME)]
|
|
private static extern void xfeatures2d_PCTSignatures_setSamplingPoints_10(IntPtr nativeObj, IntPtr samplingPoints_mat_nativeObj);
|
|
|
|
// C++: vector_int cv::xfeatures2d::PCTSignatures::getInitSeedIndexes()
|
|
[DllImport(LIBNAME)]
|
|
private static extern IntPtr xfeatures2d_PCTSignatures_getInitSeedIndexes_10(IntPtr nativeObj);
|
|
|
|
// C++: void cv::xfeatures2d::PCTSignatures::setInitSeedIndexes(vector_int initSeedIndexes)
|
|
[DllImport(LIBNAME)]
|
|
private static extern void xfeatures2d_PCTSignatures_setInitSeedIndexes_10(IntPtr nativeObj, IntPtr initSeedIndexes_mat_nativeObj);
|
|
|
|
// C++: int cv::xfeatures2d::PCTSignatures::getInitSeedCount()
|
|
[DllImport(LIBNAME)]
|
|
private static extern int xfeatures2d_PCTSignatures_getInitSeedCount_10(IntPtr nativeObj);
|
|
|
|
// C++: int cv::xfeatures2d::PCTSignatures::getIterationCount()
|
|
[DllImport(LIBNAME)]
|
|
private static extern int xfeatures2d_PCTSignatures_getIterationCount_10(IntPtr nativeObj);
|
|
|
|
// C++: void cv::xfeatures2d::PCTSignatures::setIterationCount(int iterationCount)
|
|
[DllImport(LIBNAME)]
|
|
private static extern void xfeatures2d_PCTSignatures_setIterationCount_10(IntPtr nativeObj, int iterationCount);
|
|
|
|
// C++: int cv::xfeatures2d::PCTSignatures::getMaxClustersCount()
|
|
[DllImport(LIBNAME)]
|
|
private static extern int xfeatures2d_PCTSignatures_getMaxClustersCount_10(IntPtr nativeObj);
|
|
|
|
// C++: void cv::xfeatures2d::PCTSignatures::setMaxClustersCount(int maxClustersCount)
|
|
[DllImport(LIBNAME)]
|
|
private static extern void xfeatures2d_PCTSignatures_setMaxClustersCount_10(IntPtr nativeObj, int maxClustersCount);
|
|
|
|
// C++: int cv::xfeatures2d::PCTSignatures::getClusterMinSize()
|
|
[DllImport(LIBNAME)]
|
|
private static extern int xfeatures2d_PCTSignatures_getClusterMinSize_10(IntPtr nativeObj);
|
|
|
|
// C++: void cv::xfeatures2d::PCTSignatures::setClusterMinSize(int clusterMinSize)
|
|
[DllImport(LIBNAME)]
|
|
private static extern void xfeatures2d_PCTSignatures_setClusterMinSize_10(IntPtr nativeObj, int clusterMinSize);
|
|
|
|
// C++: float cv::xfeatures2d::PCTSignatures::getJoiningDistance()
|
|
[DllImport(LIBNAME)]
|
|
private static extern float xfeatures2d_PCTSignatures_getJoiningDistance_10(IntPtr nativeObj);
|
|
|
|
// C++: void cv::xfeatures2d::PCTSignatures::setJoiningDistance(float joiningDistance)
|
|
[DllImport(LIBNAME)]
|
|
private static extern void xfeatures2d_PCTSignatures_setJoiningDistance_10(IntPtr nativeObj, float joiningDistance);
|
|
|
|
// C++: float cv::xfeatures2d::PCTSignatures::getDropThreshold()
|
|
[DllImport(LIBNAME)]
|
|
private static extern float xfeatures2d_PCTSignatures_getDropThreshold_10(IntPtr nativeObj);
|
|
|
|
// C++: void cv::xfeatures2d::PCTSignatures::setDropThreshold(float dropThreshold)
|
|
[DllImport(LIBNAME)]
|
|
private static extern void xfeatures2d_PCTSignatures_setDropThreshold_10(IntPtr nativeObj, float dropThreshold);
|
|
|
|
// C++: int cv::xfeatures2d::PCTSignatures::getDistanceFunction()
|
|
[DllImport(LIBNAME)]
|
|
private static extern int xfeatures2d_PCTSignatures_getDistanceFunction_10(IntPtr nativeObj);
|
|
|
|
// C++: void cv::xfeatures2d::PCTSignatures::setDistanceFunction(int distanceFunction)
|
|
[DllImport(LIBNAME)]
|
|
private static extern void xfeatures2d_PCTSignatures_setDistanceFunction_10(IntPtr nativeObj, int distanceFunction);
|
|
|
|
// native support for java finalize()
|
|
[DllImport(LIBNAME)]
|
|
private static extern void xfeatures2d_PCTSignatures_delete(IntPtr nativeObj);
|
|
|
|
}
|
|
}
|