@opencvjs/types 4.10.0-release.1

package/lib/opencv/core_cluster.d.ts

@@ -0,0 +1,80 @@
+import type {
+  InputArray,
+  InputOutputArray,
+  OutputArray,
+  TermCriteria,
+} from "./helpers";
+import type { double, int } from "./missing";
+
+/*
+ * # Clustering
+ *
+ */
+/**
+ * The function kmeans implements a k-means algorithm that finds the centers of cluster_count clusters
+ * and groups the input samples around the clusters. As an output, `$\\texttt{bestLabels}_i$` contains
+ * a 0-based cluster index for the sample stored in the `$i^{th}$` row of the samples matrix.
+ *
+ * (Python) An example on K-means clustering can be found at
+ * opencv_source_code/samples/python/kmeans.py
+ *
+ * The function returns the compactness measure that is computed as `\\[\\sum _i \\| \\texttt{samples}
+ * _i - \\texttt{centers} _{ \\texttt{labels} _i} \\| ^2\\]` after every attempt. The best (minimum)
+ * value is chosen and the corresponding labels and the compactness value are returned by the function.
+ * Basically, you can use only the core of the function, set the number of attempts to 1, initialize
+ * labels each time using a custom algorithm, pass them with the ( flags = [KMEANS_USE_INITIAL_LABELS]
+ * ) flag, and then choose the best (most-compact) clustering.
+ *
+ * @param data Data for clustering. An array of N-Dimensional points with float coordinates is needed.
+ * Examples of this array can be:
+ * Mat points(count, 2, CV_32F);Mat points(count, 1, CV_32FC2);Mat points(1, count,
+ * CV_32FC2);std::vector<cv::Point2f> points(sampleCount);
+ *
+ * @param K Number of clusters to split the set by.
+ *
+ * @param bestLabels Input/output integer array that stores the cluster indices for every sample.
+ *
+ * @param criteria The algorithm termination criteria, that is, the maximum number of iterations and/or
+ * the desired accuracy. The accuracy is specified as criteria.epsilon. As soon as each of the cluster
+ * centers moves by less than criteria.epsilon on some iteration, the algorithm stops.
+ *
+ * @param attempts Flag to specify the number of times the algorithm is executed using different
+ * initial labellings. The algorithm returns the labels that yield the best compactness (see the last
+ * function parameter).
+ *
+ * @param flags Flag that can take values of cv::KmeansFlags
+ *
+ * @param centers Output matrix of the cluster centers, one row per each cluster center.
+ */
+export declare function kmeans(
+  data: InputArray,
+  K: int,
+  bestLabels: InputOutputArray,
+  criteria: TermCriteria,
+  attempts: int,
+  flags: int,
+  centers?: OutputArray,
+): double;
+
+/**
+ * The generic function partition implements an `$O(N^2)$` algorithm for splitting a set of `$N$`
+ * elements into one or more equivalency classes, as described in  . The function returns the number of
+ * equivalency classes.
+ *
+ * @param _vec Set of elements stored as a vector.
+ *
+ * @param labels Output vector of labels. It contains as many elements as vec. Each label labels[i] is
+ * a 0-based cluster index of vec[i].
+ *
+ * @param predicate Equivalence predicate (pointer to a boolean function of two arguments or an
+ * instance of the class that has the method bool operator()(const _Tp& a, const _Tp& b) ). The
+ * predicate returns true when the elements are certainly in the same class, and returns false if they
+ * may or may not be in the same class.
+ */
+export declare function partition(
+  arg119: any,
+  arg120: any,
+  _vec: any,
+  labels: any,
+  predicate?: any,
+): any;

package/lib/opencv/core_hal_interface.d.ts

@@ -0,0 +1,159 @@
+import type { cvhalDFT, int, size_t, uchar } from "./_types";
+/*
+ * # Interface
+ * Define your functions to override default implementations:
+ *
+ * ```cpp
+ * #undef hal_add8u
+ * #define hal_add8u my_add8u
+ * ```
+ */
+/**
+ * @param context pointer to context storing all necessary data
+ *
+ * @param src_data source image data and step
+ *
+ * @param dst_data destination image data and step
+ */
+export declare function hal_ni_dct2D(
+  context: cvhalDFT,
+  src_data: uchar,
+  src_step: size_t,
+  dst_data: uchar,
+  dst_step: size_t,
+): cvhalDFT;
+
+/**
+ * @param context pointer to context storing all necessary data
+ */
+export declare function hal_ni_dctFree2D(context: cvhalDFT): cvhalDFT;
+
+/**
+ * @param context double pointer to context storing all necessary data
+ *
+ * @param width image dimensions
+ *
+ * @param depth image type (CV_32F or CV64F)
+ *
+ * @param flags algorithm options (combination of CV_HAL_DFT_INVERSE, ...)
+ */
+export declare function hal_ni_dctInit2D(
+  context: cvhalDFT,
+  width: int,
+  height: int,
+  depth: int,
+  flags: int,
+): cvhalDFT;
+
+/**
+ * @param context pointer to context storing all necessary data
+ *
+ * @param src source data
+ *
+ * @param dst destination data
+ */
+export declare function hal_ni_dft1D(
+  context: cvhalDFT,
+  src: uchar,
+  dst: uchar,
+): cvhalDFT;
+
+/**
+ * @param context pointer to context storing all necessary data
+ *
+ * @param src_data source image data and step
+ *
+ * @param dst_data destination image data and step
+ */
+export declare function hal_ni_dft2D(
+  context: cvhalDFT,
+  src_data: uchar,
+  src_step: size_t,
+  dst_data: uchar,
+  dst_step: size_t,
+): cvhalDFT;
+
+/**
+ * @param context pointer to context storing all necessary data
+ */
+export declare function hal_ni_dftFree1D(context: cvhalDFT): cvhalDFT;
+
+/**
+ * @param context pointer to context storing all necessary data
+ */
+export declare function hal_ni_dftFree2D(context: cvhalDFT): cvhalDFT;
+
+/**
+ * @param context double pointer to context storing all necessary data
+ *
+ * @param len transformed array length
+ *
+ * @param count estimated transformation count
+ *
+ * @param depth array type (CV_32F or CV_64F)
+ *
+ * @param flags algorithm options (combination of CV_HAL_DFT_INVERSE, CV_HAL_DFT_SCALE, ...)
+ *
+ * @param needBuffer pointer to boolean variable, if valid pointer provided, then variable value should
+ * be set to true to signal that additional memory buffer is needed for operations
+ */
+export declare function hal_ni_dftInit1D(
+  context: cvhalDFT,
+  len: int,
+  count: int,
+  depth: int,
+  flags: int,
+  needBuffer: any,
+): cvhalDFT;
+
+/**
+ * @param context double pointer to context storing all necessary data
+ *
+ * @param width image dimensions
+ *
+ * @param depth image type (CV_32F or CV64F)
+ *
+ * @param src_channels number of channels in input image
+ *
+ * @param dst_channels number of channels in output image
+ *
+ * @param flags algorithm options (combination of CV_HAL_DFT_INVERSE, ...)
+ *
+ * @param nonzero_rows number of nonzero rows in image, can be used for optimization
+ */
+export declare function hal_ni_dftInit2D(
+  context: cvhalDFT,
+  width: int,
+  height: int,
+  depth: int,
+  src_channels: int,
+  dst_channels: int,
+  flags: int,
+  nonzero_rows: int,
+): cvhalDFT;
+
+/**
+ * @param src_data Source image
+ *
+ * @param width Source image dimensions
+ *
+ * @param depth Depth of source image
+ *
+ * @param minVal Pointer to the returned global minimum and maximum in an array.
+ *
+ * @param minIdx Pointer to the returned minimum and maximum location.
+ *
+ * @param mask Specified array region.
+ */
+export declare function hal_ni_minMaxIdx(
+  src_data: uchar,
+  src_step: size_t,
+  width: int,
+  height: int,
+  depth: int,
+  minVal: any,
+  maxVal: any,
+  minIdx: any,
+  maxIdx: any,
+  mask: uchar,
+): uchar;