@techstark/opencv-js 4.8.0-release.1 → 4.8.0-release.10

package/dist/src/types/opencv/core_array.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=core_array.js.map

package/dist/src/types/opencv/core_array.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"core_array.js","sourceRoot":"","sources":["../../../../src/types/opencv/core_array.ts"],"names":[],"mappings":""}

package/dist/src/types/opencv/core_cluster.d.ts

@@ -0,0 +1,54 @@
+import { double, InputArray, InputOutputArray, int, OutputArray, TermCriteria, _EqPredicate } from "./_types";
+/**
+ * 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?: _EqPredicate): any;

package/dist/src/types/opencv/core_cluster.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=core_cluster.js.map

package/dist/src/types/opencv/core_cluster.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"core_cluster.js","sourceRoot":"","sources":["../../../../src/types/opencv/core_cluster.ts"],"names":[],"mappings":""}

package/dist/src/types/opencv/core_hal_interface.d.ts

@@ -0,0 +1,92 @@
+import { cvhalDFT, int, size_t, uchar } from "./_types";
+/**
+ * @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;

package/dist/src/types/opencv/core_hal_interface.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=core_hal_interface.js.map

package/dist/src/types/opencv/core_hal_interface.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"core_hal_interface.js","sourceRoot":"","sources":["../../../../src/types/opencv/core_hal_interface.ts"],"names":[],"mappings":""}

package/dist/src/types/opencv/core_utils.d.ts

@@ -0,0 +1,510 @@
+import { AsyncArray, bool, double, ErrorCallback, float, float16_t, InputArray, InputArrayOfArrays, InputOutputArray, InputOutputArrayOfArrays, int, int64, schar, short, size_t, uchar, uint64, unsigned, ushort, _Tp } from "./_types";
+/**
+ * The function returns the aligned pointer of the same type as the input pointer:
+ * `\\[\\texttt{(_Tp*)(((size_t)ptr + n-1) & -n)}\\]`
+ *
+ * @param ptr Aligned pointer.
+ *
+ * @param n Alignment size that must be a power of two.
+ */
+export declare function alignPtr(arg92: any, ptr: any, n?: int): any;
+/**
+ * The function returns the minimum number that is greater than or equal to sz and is divisible by n :
+ * `\\[\\texttt{(sz + n-1) & -n}\\]`
+ *
+ * @param sz Buffer size to align.
+ *
+ * @param n Alignment size that must be a power of two.
+ */
+export declare function alignSize(sz: size_t, n: int): size_t;
+/**
+ * The function returns true if the host hardware supports the specified feature. When user calls
+ * setUseOptimized(false), the subsequent calls to [checkHardwareSupport()] will return false until
+ * setUseOptimized(true) is called. This way user can dynamically switch on and off the optimized code
+ * in OpenCV.
+ *
+ * @param feature The feature of interest, one of cv::CpuFeatures
+ */
+export declare function checkHardwareSupport(feature: int): bool;
+/**
+ * proxy for hal::Cholesky
+ */
+export declare function Cholesky(A: any, astep: size_t, m: int, b: any, bstep: size_t, n: int): bool;
+/**
+ * proxy for hal::Cholesky
+ */
+export declare function Cholesky(A: any, astep: size_t, m: int, b: any, bstep: size_t, n: int): bool;
+/**
+ * The function cubeRoot computes `$\\sqrt[3]{\\texttt{val}}$`. Negative arguments are handled
+ * correctly. NaN and Inf are not handled. The accuracy approaches the maximum possible accuracy for
+ * single-precision data.
+ *
+ * @param val A function argument.
+ */
+export declare function cubeRoot(val: float): float;
+export declare function cv_abs(arg93: any, x: _Tp): any;
+export declare function cv_abs(x: uchar): uchar;
+export declare function cv_abs(x: schar): schar;
+export declare function cv_abs(x: ushort): ushort;
+export declare function cv_abs(x: short): int;
+export declare function CV_XADD(addr: any, delta: int): any;
+/**
+ * The function computes an integer i such that: `\\[i \\le \\texttt{value} < i+1\\]`
+ *
+ * @param value floating-point number. If the value is outside of INT_MIN ... INT_MAX range, the result
+ * is not defined.
+ */
+export declare function cvCeil(value: double): int;
+/**
+ * This is an overloaded member function, provided for convenience. It differs from the above function
+ * only in what argument(s) it accepts.
+ */
+export declare function cvCeil(value: float): int;
+/**
+ * This is an overloaded member function, provided for convenience. It differs from the above function
+ * only in what argument(s) it accepts.
+ */
+export declare function cvCeil(value: int): int;
+/**
+ * The function computes an integer i such that: `\\[i \\le \\texttt{value} < i+1\\]`
+ *
+ * @param value floating-point number. If the value is outside of INT_MIN ... INT_MAX range, the result
+ * is not defined.
+ */
+export declare function cvFloor(value: double): int;
+/**
+ * This is an overloaded member function, provided for convenience. It differs from the above function
+ * only in what argument(s) it accepts.
+ */
+export declare function cvFloor(value: float): int;
+/**
+ * This is an overloaded member function, provided for convenience. It differs from the above function
+ * only in what argument(s) it accepts.
+ */
+export declare function cvFloor(value: int): int;
+/**
+ * The function returns 1 if the argument is a plus or minus infinity (as defined by IEEE754 standard)
+ * and 0 otherwise.
+ *
+ * @param value The input floating-point value
+ */
+export declare function cvIsInf(value: double): int;
+/**
+ * This is an overloaded member function, provided for convenience. It differs from the above function
+ * only in what argument(s) it accepts.
+ */
+export declare function cvIsInf(value: float): int;
+/**
+ * The function returns 1 if the argument is Not A Number (as defined by IEEE754 standard), 0
+ * otherwise.
+ *
+ * @param value The input floating-point value
+ */
+export declare function cvIsNaN(value: double): int;
+/**
+ * This is an overloaded member function, provided for convenience. It differs from the above function
+ * only in what argument(s) it accepts.
+ */
+export declare function cvIsNaN(value: float): int;
+/**
+ * @param value floating-point number. If the value is outside of INT_MIN ... INT_MAX range, the result
+ * is not defined.
+ */
+export declare function cvRound(value: double): int;
+/**
+ * This is an overloaded member function, provided for convenience. It differs from the above function
+ * only in what argument(s) it accepts.
+ */
+export declare function cvRound(value: float): int;
+/**
+ * This is an overloaded member function, provided for convenience. It differs from the above function
+ * only in what argument(s) it accepts.
+ */
+export declare function cvRound(value: int): int;
+/**
+ * Use this function instead of `ceil((float)a / b)` expressions.
+ *
+ * [alignSize]
+ */
+export declare function divUp(a: int, b: any): int;
+/**
+ * This is an overloaded member function, provided for convenience. It differs from the above function
+ * only in what argument(s) it accepts.
+ */
+export declare function divUp(a: size_t, b: any): size_t;
+export declare function dumpInputArray(argument: InputArray): String;
+export declare function dumpInputArrayOfArrays(argument: InputArrayOfArrays): String;
+export declare function dumpInputOutputArray(argument: InputOutputArray): String;
+export declare function dumpInputOutputArrayOfArrays(argument: InputOutputArrayOfArrays): String;
+/**
+ * By default the function prints information about the error to stderr, then it either stops if
+ * [cv::setBreakOnError()] had been called before or raises the exception. It is possible to alternate
+ * error processing by using [redirectError()].
+ *
+ * @param exc the exception raisen.
+ */
+export declare function error(exc: any): void;
+/**
+ * By default the function prints information about the error to stderr, then it either stops if
+ * [setBreakOnError()] had been called before or raises the exception. It is possible to alternate
+ * error processing by using [redirectError()].
+ *
+ * [CV_Error], [CV_Error_], [CV_Assert], [CV_DbgAssert]
+ *
+ * @param _code - error code (Error::Code)
+ *
+ * @param _err - error description
+ *
+ * @param _func - function name. Available only when the compiler supports getting it
+ *
+ * @param _file - source file name where the error has occurred
+ *
+ * @param _line - line number in the source file where the error has occurred
+ */
+export declare function error(_code: int, _err: any, _func: any, _file: any, _line: int): void;
+/**
+ * The function fastAtan2 calculates the full-range angle of an input 2D vector. The angle is measured
+ * in degrees and varies from 0 to 360 degrees. The accuracy is about 0.3 degrees.
+ *
+ * @param y y-coordinate of the vector.
+ *
+ * @param x x-coordinate of the vector.
+ */
+export declare function fastAtan2(y: float, x: float): float;
+/**
+ * The function deallocates the buffer allocated with fastMalloc . If NULL pointer is passed, the
+ * function does nothing. C version of the function clears the pointer *pptr* to avoid problems with
+ * double memory deallocation.
+ *
+ * @param ptr Pointer to the allocated buffer.
+ */
+export declare function fastFree(ptr: any): void;
+/**
+ * The function allocates the buffer of the specified size and returns it. When the buffer size is 16
+ * bytes or more, the returned buffer is aligned to 16 bytes.
+ *
+ * @param bufSize Allocated buffer size.
+ */
+export declare function fastMalloc(bufSize: size_t): any;
+export declare function forEach_impl(arg94: any, arg95: any, operation: any): any;
+/**
+ * Returned value is raw cmake output including version control system revision, compiler version,
+ * compiler flags, enabled modules and third party libraries, etc. Output format depends on target
+ * architecture.
+ */
+export declare function getBuildInformation(): any;
+/**
+ * Returned value is a string containing space separated list of CPU features with following markers:
+ *
+ * no markers - baseline features
+ * prefix `*` - features enabled in dispatcher
+ * suffix `?` - features enabled but not available in HW
+ *
+ * Example: `SSE SSE2 SSE3 *SSE4.1 *SSE4.2 *FP16 *AVX *AVX2 *AVX512-SKX?`
+ */
+export declare function getCPUFeaturesLine(): any;
+/**
+ * The function returns the current number of CPU ticks on some architectures (such as x86, x64,
+ * PowerPC). On other platforms the function is equivalent to getTickCount. It can also be used for
+ * very accurate time measurements, as well as for [RNG] initialization. Note that in case of multi-CPU
+ * systems a thread, from which getCPUTickCount is called, can be suspended and resumed at another CPU
+ * with its own counter. So, theoretically (and practically) the subsequent calls to the function do
+ * not necessary return the monotonously increasing values. Also, since a modern CPU varies the CPU
+ * frequency depending on the load, the number of CPU clocks spent in some code cannot be directly
+ * converted to time units. Therefore, getTickCount is generally a preferable solution for measuring
+ * execution time.
+ */
+export declare function getCPUTickCount(): int64;
+export declare function getElemSize(type: int): size_t;
+/**
+ * Returns empty string if feature is not defined
+ */
+export declare function getHardwareFeatureName(feature: int): String;
+export declare function getNumberOfCPUs(): int;
+/**
+ * Always returns 1 if OpenCV is built without threading support.
+ *
+ * The exact meaning of return value depends on the threading framework used by OpenCV library:
+ *
+ * `TBB` - The number of threads, that OpenCV will try to use for parallel regions. If there is any
+ * tbb::thread_scheduler_init in user code conflicting with OpenCV, then function returns default
+ * number of threads used by TBB library.
+ * `OpenMP` - An upper bound on the number of threads that could be used to form a new team.
+ * `Concurrency` - The number of threads, that OpenCV will try to use for parallel regions.
+ * `GCD` - Unsupported; returns the GCD thread pool limit (512) for compatibility.
+ * `C=` - The number of threads, that OpenCV will try to use for parallel regions, if before called
+ * setNumThreads with threads > 0, otherwise returns the number of logical CPUs, available for the
+ * process.
+ *
+ * [setNumThreads], [getThreadNum]
+ */
+export declare function getNumThreads(): int;
+/**
+ * The exact meaning of the return value depends on the threading framework used by OpenCV library:
+ *
+ * `TBB` - Unsupported with current 4.1 TBB release. Maybe will be supported in future.
+ * `OpenMP` - The thread number, within the current team, of the calling thread.
+ * `Concurrency` - An ID for the virtual processor that the current context is executing on (0 for
+ * master thread and unique number for others, but not necessary 1,2,3,...).
+ * `GCD` - System calling thread's ID. Never returns 0 inside parallel region.
+ * `C=` - The index of the current parallel task.
+ *
+ * [setNumThreads], [getNumThreads]
+ */
+export declare function getThreadNum(): int;
+/**
+ * The function returns the number of ticks after the certain event (for example, when the machine was
+ * turned on). It can be used to initialize [RNG] or to measure a function execution time by reading
+ * the tick count before and after the function call.
+ *
+ * [getTickFrequency], [TickMeter]
+ */
+export declare function getTickCount(): int64;
+/**
+ * The function returns the number of ticks per second. That is, the following code computes the
+ * execution time in seconds:
+ *
+ * ```cpp
+ * double t = (double)getTickCount();
+ * // do something ...
+ * t = ((double)getTickCount() - t)/getTickFrequency();
+ * ```
+ *
+ * [getTickCount], [TickMeter]
+ */
+export declare function getTickFrequency(): double;
+export declare function getVersionMajor(): int;
+export declare function getVersionMinor(): int;
+export declare function getVersionRevision(): int;
+/**
+ * For example "3.4.1-dev".
+ *
+ * getMajorVersion, getMinorVersion, getRevisionVersion
+ */
+export declare function getVersionString(): String;
+export declare function glob(pattern: String, result: any, recursive?: bool): void;
+/**
+ * proxy for hal::LU
+ */
+export declare function LU(A: any, astep: size_t, m: int, b: any, bstep: size_t, n: int): int;
+/**
+ * proxy for hal::LU
+ */
+export declare function LU(A: any, astep: size_t, m: int, b: any, bstep: size_t, n: int): int;
+export declare function normInf(arg96: any, arg97: any, a: any, n: int): any;
+export declare function normInf(arg98: any, arg99: any, a: any, b: any, n: int): any;
+export declare function normL1(arg100: any, arg101: any, a: any, n: int): any;
+export declare function normL1(arg102: any, arg103: any, a: any, b: any, n: int): any;
+export declare function normL1(a: any, b: any, n: int): float;
+export declare function normL1(a: uchar, b: uchar, n: int): uchar;
+export declare function normL2Sqr(arg104: any, arg105: any, a: any, n: int): any;
+export declare function normL2Sqr(arg106: any, arg107: any, a: any, b: any, n: int): any;
+export declare function normL2Sqr(a: any, b: any, n: int): float;
+export declare function parallel_for_(range: any, body: any, nstripes?: double): void;
+export declare function parallel_for_(range: any, functor: any, nstripes?: double): void;
+/**
+ * The function sets the new error handler, called from [cv::error()].
+ *
+ * the previous error handler
+ *
+ * @param errCallback the new error handler. If NULL, the default error handler is used.
+ *
+ * @param userdata the optional user data pointer, passed to the callback.
+ *
+ * @param prevUserdata the optional output parameter where the previous user data pointer is stored
+ */
+export declare function redirectError(errCallback: ErrorCallback, userdata?: any, prevUserdata?: any): ErrorCallback;
+/**
+ * Use this function instead of `ceil((float)a / b) * b` expressions.
+ *
+ * [divUp]
+ */
+export declare function roundUp(a: int, b: any): int;
+/**
+ * This is an overloaded member function, provided for convenience. It differs from the above function
+ * only in what argument(s) it accepts.
+ */
+export declare function roundUp(a: size_t, b: any): size_t;
+/**
+ * The function saturate_cast resembles the standard C++ cast operations, such as static_cast<T>() and
+ * others. It perform an efficient and accurate conversion from one primitive type to another (see the
+ * introduction chapter). saturate in the name means that when the input value v is out of the range of
+ * the target type, the result is not formed just by taking low bits of the input, but instead the
+ * value is clipped. For example:
+ *
+ * ```cpp
+ * uchar a = saturate_cast<uchar>(-100); // a = 0 (UCHAR_MIN)
+ * short b = saturate_cast<short>(33333.33333); // b = 32767 (SHRT_MAX)
+ * ```
+ *
+ *  Such clipping is done when the target type is unsigned char , signed char , unsigned short or
+ * signed short . For 32-bit integers, no clipping is done.
+ *
+ * When the parameter is a floating-point value and the target type is an integer (8-, 16- or 32-bit),
+ * the floating-point value is first rounded to the nearest integer and then clipped if needed (when
+ * the target type is 8- or 16-bit).
+ *
+ * This operation is used in the simplest or most complex image processing functions in OpenCV.
+ *
+ * [add], [subtract], [multiply], [divide], [Mat::convertTo]
+ *
+ * @param v Function parameter.
+ */
+export declare function saturate_cast(arg108: any, v: uchar): uchar;
+/**
+ * This is an overloaded member function, provided for convenience. It differs from the above function
+ * only in what argument(s) it accepts.
+ */
+export declare function saturate_cast(arg109: any, v: schar): schar;
+/**
+ * This is an overloaded member function, provided for convenience. It differs from the above function
+ * only in what argument(s) it accepts.
+ */
+export declare function saturate_cast(arg110: any, v: ushort): ushort;
+/**
+ * This is an overloaded member function, provided for convenience. It differs from the above function
+ * only in what argument(s) it accepts.
+ */
+export declare function saturate_cast(arg111: any, v: short): any;
+/**
+ * This is an overloaded member function, provided for convenience. It differs from the above function
+ * only in what argument(s) it accepts.
+ */
+export declare function saturate_cast(arg112: any, v: unsigned): any;
+/**
+ * This is an overloaded member function, provided for convenience. It differs from the above function
+ * only in what argument(s) it accepts.
+ */
+export declare function saturate_cast(arg113: any, v: int): any;
+/**
+ * This is an overloaded member function, provided for convenience. It differs from the above function
+ * only in what argument(s) it accepts.
+ */
+export declare function saturate_cast(arg114: any, v: float): any;
+/**
+ * This is an overloaded member function, provided for convenience. It differs from the above function
+ * only in what argument(s) it accepts.
+ */
+export declare function saturate_cast(arg115: any, v: double): any;
+/**
+ * This is an overloaded member function, provided for convenience. It differs from the above function
+ * only in what argument(s) it accepts.
+ */
+export declare function saturate_cast(arg116: any, v: int64): int64;
+/**
+ * This is an overloaded member function, provided for convenience. It differs from the above function
+ * only in what argument(s) it accepts.
+ */
+export declare function saturate_cast(arg117: any, v: uint64): uint64;
+/**
+ * This is an overloaded member function, provided for convenience. It differs from the above function
+ * only in what argument(s) it accepts.
+ */
+export declare function saturate_cast(arg118: any, v: float16_t): any;
+/**
+ * When the break-on-error mode is set, the default error handler issues a hardware exception, which
+ * can make debugging more convenient.
+ *
+ * the previous state
+ */
+export declare function setBreakOnError(flag: bool): bool;
+/**
+ * If threads == 0, OpenCV will disable threading optimizations and run all it's functions
+ * sequentially. Passing threads < 0 will reset threads number to system default. This function must be
+ * called outside of parallel region.
+ *
+ * OpenCV will try to run its functions with specified threads number, but some behaviour differs from
+ * framework:
+ *
+ * `TBB` - User-defined parallel constructions will run with the same threads number, if another is not
+ * specified. If later on user creates his own scheduler, OpenCV will use it.
+ * `OpenMP` - No special defined behaviour.
+ * `Concurrency` - If threads == 1, OpenCV will disable threading optimizations and run its functions
+ * sequentially.
+ * `GCD` - Supports only values <= 0.
+ * `C=` - No special defined behaviour.
+ *
+ * [getNumThreads], [getThreadNum]
+ *
+ * @param nthreads Number of threads used by OpenCV.
+ */
+export declare function setNumThreads(nthreads: int): void;
+/**
+ * The function can be used to dynamically turn on and off optimized dispatched code (code that uses
+ * SSE4.2, AVX/AVX2, and other instructions on the platforms that support it). It sets a global flag
+ * that is further checked by OpenCV functions. Since the flag is not checked in the inner OpenCV
+ * loops, it is only safe to call the function on the very top level in your application where you can
+ * be sure that no other OpenCV function is currently executed.
+ *
+ * By default, the optimized code is enabled unless you disable it in CMake. The current status can be
+ * retrieved using useOptimized.
+ *
+ * @param onoff The boolean flag specifying whether the optimized code should be used (onoff=true) or
+ * not (onoff=false).
+ */
+export declare function setUseOptimized(onoff: bool): void;
+export declare function tempfile(suffix?: any): String;
+export declare function testAsyncArray(argument: InputArray): AsyncArray;
+export declare function testAsyncException(): AsyncArray;
+/**
+ * The function returns true if the optimized code is enabled. Otherwise, it returns false.
+ */
+export declare function useOptimized(): bool;
+export declare const CPU_MMX: CpuFeatures;
+export declare const CPU_SSE: CpuFeatures;
+export declare const CPU_SSE2: CpuFeatures;
+export declare const CPU_SSE3: CpuFeatures;
+export declare const CPU_SSSE3: CpuFeatures;
+export declare const CPU_SSE4_1: CpuFeatures;
+export declare const CPU_SSE4_2: CpuFeatures;
+export declare const CPU_POPCNT: CpuFeatures;
+export declare const CPU_FP16: CpuFeatures;
+export declare const CPU_AVX: CpuFeatures;
+export declare const CPU_AVX2: CpuFeatures;
+export declare const CPU_FMA3: CpuFeatures;
+export declare const CPU_AVX_512F: CpuFeatures;
+export declare const CPU_AVX_512BW: CpuFeatures;
+export declare const CPU_AVX_512CD: CpuFeatures;
+export declare const CPU_AVX_512DQ: CpuFeatures;
+export declare const CPU_AVX_512ER: CpuFeatures;
+export declare const CPU_AVX_512IFMA512: CpuFeatures;
+export declare const CPU_AVX_512IFMA: CpuFeatures;
+export declare const CPU_AVX_512PF: CpuFeatures;
+export declare const CPU_AVX_512VBMI: CpuFeatures;
+export declare const CPU_AVX_512VL: CpuFeatures;
+export declare const CPU_AVX_512VBMI2: CpuFeatures;
+export declare const CPU_AVX_512VNNI: CpuFeatures;
+export declare const CPU_AVX_512BITALG: CpuFeatures;
+export declare const CPU_AVX_512VPOPCNTDQ: CpuFeatures;
+export declare const CPU_AVX_5124VNNIW: CpuFeatures;
+export declare const CPU_AVX_5124FMAPS: CpuFeatures;
+export declare const CPU_NEON: CpuFeatures;
+export declare const CPU_VSX: CpuFeatures;
+export declare const CPU_VSX3: CpuFeatures;
+export declare const CPU_AVX512_SKX: CpuFeatures;
+export declare const CPU_AVX512_COMMON: CpuFeatures;
+export declare const CPU_AVX512_KNL: CpuFeatures;
+export declare const CPU_AVX512_KNM: CpuFeatures;
+export declare const CPU_AVX512_CNL: CpuFeatures;
+export declare const CPU_AVX512_CEL: CpuFeatures;
+export declare const CPU_AVX512_ICL: CpuFeatures;
+export declare const CPU_MAX_FEATURE: CpuFeatures;
+export declare const SORT_EVERY_ROW: SortFlags;
+/**
+ * each matrix column is sorted independently; this flag and the previous one are mutually exclusive.
+ *
+ */
+export declare const SORT_EVERY_COLUMN: SortFlags;
+/**
+ * each matrix row is sorted in the ascending order.
+ *
+ */
+export declare const SORT_ASCENDING: SortFlags;
+/**
+ * each matrix row is sorted in the descending order; this flag and the previous one are also mutually
+ * exclusive.
+ *
+ */
+export declare const SORT_DESCENDING: SortFlags;
+export type CpuFeatures = any;
+export type SortFlags = any;