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 images, List 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. * Note: 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 * 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; */ 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. * 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; */ 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 * 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; */ 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. * 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; */ 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) * Note: 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); } }