@techstark/opencv-js 4.8.0-release.6 → 4.8.0-release.8

package/src/types/opencv/photo_inpaint.ts

@@ -0,0 +1,37 @@
+import { double, InputArray, int, OutputArray } from "./_types";
+/*
+ * # Inpainting
+ * the inpainting algorithm
+ */
+/**
+ * The function reconstructs the selected image area from the pixel near the area boundary. The
+ * function may be used to remove dust and scratches from a scanned photo, or to remove undesirable
+ * objects from still images or video. See  for more details.
+ *
+ * An example using the inpainting technique can be found at opencv_source_code/samples/cpp/inpaint.cpp
+ * (Python) An example using the inpainting technique can be found at
+ * opencv_source_code/samples/python/inpaint.py
+ *
+ * @param src Input 8-bit, 16-bit unsigned or 32-bit float 1-channel or 8-bit 3-channel image.
+ *
+ * @param inpaintMask Inpainting mask, 8-bit 1-channel image. Non-zero pixels indicate the area that
+ * needs to be inpainted.
+ *
+ * @param dst Output image with the same size and type as src .
+ *
+ * @param inpaintRadius Radius of a circular neighborhood of each point inpainted that is considered by
+ * the algorithm.
+ *
+ * @param flags Inpainting method that could be cv::INPAINT_NS or cv::INPAINT_TELEA
+ */
+export declare function inpaint(
+  src: InputArray,
+  inpaintMask: InputArray,
+  dst: OutputArray,
+  inpaintRadius: double,
+  flags: int,
+): void;
+
+export declare const INPAINT_NS: any; // initializer: = 0
+
+export declare const INPAINT_TELEA: any; // initializer: = 1

package/src/types/opencv/softdouble.ts

@@ -0,0 +1,64 @@
+import { bool, int, int32_t, int64_t, uint32_t, uint64_t } from "./_types";
+
+export declare class softdouble {
+  public v: uint64_t;
+
+  public constructor();
+
+  public constructor(c: softdouble);
+
+  public constructor(arg159: uint32_t);
+
+  public constructor(arg160: uint64_t);
+
+  public constructor(arg161: int32_t);
+
+  public constructor(arg162: int64_t);
+
+  public constructor(a: any);
+
+  public getExp(): int;
+
+  /**
+   *   Returns a number 1 <= x < 2 with the same significand
+   */
+  public getFrac(): softdouble;
+
+  public getSign(): bool;
+
+  public isInf(): bool;
+
+  public isNaN(): bool;
+
+  public isSubnormal(): bool;
+
+  public setExp(e: int): softdouble;
+
+  /**
+   *   Constructs a copy of a number with significand taken from parameter
+   */
+  public setFrac(s: softdouble): softdouble;
+
+  public setSign(sign: bool): softdouble;
+
+  public static eps(): softdouble;
+
+  /**
+   *   Builds new value from raw binary representation
+   */
+  public static fromRaw(a: uint64_t): softdouble;
+
+  public static inf(): softdouble;
+
+  public static max(): softdouble;
+
+  public static min(): softdouble;
+
+  public static nan(): softdouble;
+
+  public static one(): softdouble;
+
+  public static pi(): softdouble;
+
+  public static zero(): softdouble;
+}

package/src/types/opencv/softfloat.ts

@@ -0,0 +1,64 @@
+import { bool, int, int32_t, int64_t, uint32_t, uint64_t } from "./_types";
+
+export declare class softfloat {
+  public v: uint32_t;
+
+  public constructor();
+
+  public constructor(c: softfloat);
+
+  public constructor(arg174: uint32_t);
+
+  public constructor(arg175: uint64_t);
+
+  public constructor(arg176: int32_t);
+
+  public constructor(arg177: int64_t);
+
+  public constructor(a: any);
+
+  public getExp(): int;
+
+  /**
+   *   Returns a number 1 <= x < 2 with the same significand
+   */
+  public getFrac(): softfloat;
+
+  public getSign(): bool;
+
+  public isInf(): bool;
+
+  public isNaN(): bool;
+
+  public isSubnormal(): bool;
+
+  public setExp(e: int): softfloat;
+
+  /**
+   *   Constructs a copy of a number with significand taken from parameter
+   */
+  public setFrac(s: softfloat): softfloat;
+
+  public setSign(sign: bool): softfloat;
+
+  public static eps(): softfloat;
+
+  /**
+   *   Builds new value from raw binary representation
+   */
+  public static fromRaw(a: uint32_t): softfloat;
+
+  public static inf(): softfloat;
+
+  public static max(): softfloat;
+
+  public static min(): softfloat;
+
+  public static nan(): softfloat;
+
+  public static one(): softfloat;
+
+  public static pi(): softfloat;
+
+  public static zero(): softfloat;
+}

package/src/types/opencv/video_track.ts

@@ -0,0 +1,372 @@
+import {
+  bool,
+  double,
+  InputArray,
+  InputOutputArray,
+  int,
+  Mat,
+  OutputArray,
+  OutputArrayOfArrays,
+  RotatedRect,
+  Size,
+  TermCriteria,
+} from "./_types";
+/*
+ * # Object Tracking
+ *
+ */
+/**
+ * number of levels in constructed pyramid. Can be less than maxLevel.
+ *
+ * @param img 8-bit input image.
+ *
+ * @param pyramid output pyramid.
+ *
+ * @param winSize window size of optical flow algorithm. Must be not less than winSize argument of
+ * calcOpticalFlowPyrLK. It is needed to calculate required padding for pyramid levels.
+ *
+ * @param maxLevel 0-based maximal pyramid level number.
+ *
+ * @param withDerivatives set to precompute gradients for the every pyramid level. If pyramid is
+ * constructed without the gradients then calcOpticalFlowPyrLK will calculate them internally.
+ *
+ * @param pyrBorder the border mode for pyramid layers.
+ *
+ * @param derivBorder the border mode for gradients.
+ *
+ * @param tryReuseInputImage put ROI of input image into the pyramid if possible. You can pass false to
+ * force data copying.
+ */
+export declare function buildOpticalFlowPyramid(
+  img: InputArray,
+  pyramid: OutputArrayOfArrays,
+  winSize: Size,
+  maxLevel: int,
+  withDerivatives?: bool,
+  pyrBorder?: int,
+  derivBorder?: int,
+  tryReuseInputImage?: bool,
+): int;
+
+/**
+ * The function finds an optical flow for each prev pixel using the Farneback2003 algorithm so that
+ *
+ * `\\[\\texttt{prev} (y,x) \\sim \\texttt{next} ( y + \\texttt{flow} (y,x)[1], x + \\texttt{flow}
+ * (y,x)[0])\\]`
+ *
+ * An example using the optical flow algorithm described by Gunnar Farneback can be found at
+ * opencv_source_code/samples/cpp/fback.cpp
+ * (Python) An example using the optical flow algorithm described by Gunnar Farneback can be found at
+ * opencv_source_code/samples/python/opt_flow.py
+ *
+ * @param prev first 8-bit single-channel input image.
+ *
+ * @param next second input image of the same size and the same type as prev.
+ *
+ * @param flow computed flow image that has the same size as prev and type CV_32FC2.
+ *
+ * @param pyr_scale parameter, specifying the image scale (<1) to build pyramids for each image;
+ * pyr_scale=0.5 means a classical pyramid, where each next layer is twice smaller than the previous
+ * one.
+ *
+ * @param levels number of pyramid layers including the initial image; levels=1 means that no extra
+ * layers are created and only the original images are used.
+ *
+ * @param winsize averaging window size; larger values increase the algorithm robustness to image noise
+ * and give more chances for fast motion detection, but yield more blurred motion field.
+ *
+ * @param iterations number of iterations the algorithm does at each pyramid level.
+ *
+ * @param poly_n size of the pixel neighborhood used to find polynomial expansion in each pixel; larger
+ * values mean that the image will be approximated with smoother surfaces, yielding more robust
+ * algorithm and more blurred motion field, typically poly_n =5 or 7.
+ *
+ * @param poly_sigma standard deviation of the Gaussian that is used to smooth derivatives used as a
+ * basis for the polynomial expansion; for poly_n=5, you can set poly_sigma=1.1, for poly_n=7, a good
+ * value would be poly_sigma=1.5.
+ *
+ * @param flags operation flags that can be a combination of the following:
+ * OPTFLOW_USE_INITIAL_FLOW uses the input flow as an initial flow
+ * approximation.OPTFLOW_FARNEBACK_GAUSSIAN uses the Gaussian $\texttt{winsize}\times\texttt{winsize}$
+ * filter instead of a box filter of the same size for optical flow estimation; usually, this option
+ * gives z more accurate flow than with a box filter, at the cost of lower speed; normally, winsize for
+ * a Gaussian window should be set to a larger value to achieve the same level of robustness.
+ */
+export declare function calcOpticalFlowFarneback(
+  prev: InputArray,
+  next: InputArray,
+  flow: InputOutputArray,
+  pyr_scale: double,
+  levels: int,
+  winsize: int,
+  iterations: int,
+  poly_n: int,
+  poly_sigma: double,
+  flags: int,
+): void;
+
+/**
+ * The function implements a sparse iterative version of the Lucas-Kanade optical flow in pyramids. See
+ * Bouguet00 . The function is parallelized with the TBB library.
+ *
+ * An example using the Lucas-Kanade optical flow algorithm can be found at
+ * opencv_source_code/samples/cpp/lkdemo.cpp
+ * (Python) An example using the Lucas-Kanade optical flow algorithm can be found at
+ * opencv_source_code/samples/python/lk_track.py
+ * (Python) An example using the Lucas-Kanade tracker for homography matching can be found at
+ * opencv_source_code/samples/python/lk_homography.py
+ *
+ * @param prevImg first 8-bit input image or pyramid constructed by buildOpticalFlowPyramid.
+ *
+ * @param nextImg second input image or pyramid of the same size and the same type as prevImg.
+ *
+ * @param prevPts vector of 2D points for which the flow needs to be found; point coordinates must be
+ * single-precision floating-point numbers.
+ *
+ * @param nextPts output vector of 2D points (with single-precision floating-point coordinates)
+ * containing the calculated new positions of input features in the second image; when
+ * OPTFLOW_USE_INITIAL_FLOW flag is passed, the vector must have the same size as in the input.
+ *
+ * @param status output status vector (of unsigned chars); each element of the vector is set to 1 if
+ * the flow for the corresponding features has been found, otherwise, it is set to 0.
+ *
+ * @param err output vector of errors; each element of the vector is set to an error for the
+ * corresponding feature, type of the error measure can be set in flags parameter; if the flow wasn't
+ * found then the error is not defined (use the status parameter to find such cases).
+ *
+ * @param winSize size of the search window at each pyramid level.
+ *
+ * @param maxLevel 0-based maximal pyramid level number; if set to 0, pyramids are not used (single
+ * level), if set to 1, two levels are used, and so on; if pyramids are passed to input then algorithm
+ * will use as many levels as pyramids have but no more than maxLevel.
+ *
+ * @param criteria parameter, specifying the termination criteria of the iterative search algorithm
+ * (after the specified maximum number of iterations criteria.maxCount or when the search window moves
+ * by less than criteria.epsilon.
+ *
+ * @param flags operation flags:
+ * OPTFLOW_USE_INITIAL_FLOW uses initial estimations, stored in nextPts; if the flag is not set, then
+ * prevPts is copied to nextPts and is considered the initial estimate.OPTFLOW_LK_GET_MIN_EIGENVALS use
+ * minimum eigen values as an error measure (see minEigThreshold description); if the flag is not set,
+ * then L1 distance between patches around the original and a moved point, divided by number of pixels
+ * in a window, is used as a error measure.
+ *
+ * @param minEigThreshold the algorithm calculates the minimum eigen value of a 2x2 normal matrix of
+ * optical flow equations (this matrix is called a spatial gradient matrix in Bouguet00), divided by
+ * number of pixels in a window; if this value is less than minEigThreshold, then a corresponding
+ * feature is filtered out and its flow is not processed, so it allows to remove bad points and get a
+ * performance boost.
+ */
+export declare function calcOpticalFlowPyrLK(
+  prevImg: InputArray,
+  nextImg: InputArray,
+  prevPts: InputArray,
+  nextPts: InputOutputArray,
+  status: OutputArray,
+  err: OutputArray,
+  winSize?: Size,
+  maxLevel?: int,
+  criteria?: TermCriteria,
+  flags?: int,
+  minEigThreshold?: double,
+): void;
+
+/**
+ * See the OpenCV sample camshiftdemo.c that tracks colored objects.
+ *
+ * (Python) A sample explaining the camshift tracking algorithm can be found at
+ * opencv_source_code/samples/python/camshift.py
+ *
+ * @param probImage Back projection of the object histogram. See calcBackProject.
+ *
+ * @param window Initial search window.
+ *
+ * @param criteria Stop criteria for the underlying meanShift. returns (in old interfaces) Number of
+ * iterations CAMSHIFT took to converge The function implements the CAMSHIFT object tracking algorithm
+ * Bradski98 . First, it finds an object center using meanShift and then adjusts the window size and
+ * finds the optimal rotation. The function returns the rotated rectangle structure that includes the
+ * object position, size, and orientation. The next position of the search window can be obtained with
+ * RotatedRect::boundingRect()
+ */
+export declare function CamShift(
+  probImage: InputArray,
+  window: any,
+  criteria: TermCriteria,
+): RotatedRect;
+
+/**
+ * [findTransformECC]
+ *
+ * @param templateImage single-channel template image; CV_8U or CV_32F array.
+ *
+ * @param inputImage single-channel input image to be warped to provide an image similar to
+ * templateImage, same type as templateImage.
+ *
+ * @param inputMask An optional mask to indicate valid values of inputImage.
+ */
+export declare function computeECC(
+  templateImage: InputArray,
+  inputImage: InputArray,
+  inputMask?: InputArray,
+): double;
+
+/**
+ * The function finds an optimal affine transform *[A|b]* (a 2 x 3 floating-point matrix) that
+ * approximates best the affine transformation between:  In case of point sets, the problem is
+ * formulated as follows: you need to find a 2x2 matrix *A* and 2x1 vector *b* so that:
+ *
+ * `\\[[A^*|b^*] = arg \\min _{[A|b]} \\sum _i \\| \\texttt{dst}[i] - A { \\texttt{src}[i]}^T - b \\|
+ * ^2\\]` where src[i] and dst[i] are the i-th points in src and dst, respectively `$[A|b]$` can be
+ * either arbitrary (when fullAffine=true ) or have a form of `\\[\\begin{bmatrix} a_{11} & a_{12} &
+ * b_1 \\\\ -a_{12} & a_{11} & b_2 \\end{bmatrix}\\]` when fullAffine=false.
+ *
+ * [estimateAffine2D], [estimateAffinePartial2D], [getAffineTransform], [getPerspectiveTransform],
+ * [findHomography]
+ *
+ * @param src First input 2D point set stored in std::vector or Mat, or an image stored in Mat.
+ *
+ * @param dst Second input 2D point set of the same size and the same type as A, or another image.
+ *
+ * @param fullAffine If true, the function finds an optimal affine transformation with no additional
+ * restrictions (6 degrees of freedom). Otherwise, the class of transformations to choose from is
+ * limited to combinations of translation, rotation, and uniform scaling (4 degrees of freedom).
+ */
+export declare function estimateRigidTransform(
+  src: InputArray,
+  dst: InputArray,
+  fullAffine: bool,
+): Mat;
+
+/**
+ * The function estimates the optimum transformation (warpMatrix) with respect to ECC criterion (EP08),
+ * that is
+ *
+ * `\\[\\texttt{warpMatrix} = \\texttt{warpMatrix} = \\arg\\max_{W}
+ * \\texttt{ECC}(\\texttt{templateImage}(x,y),\\texttt{inputImage}(x',y'))\\]`
+ *
+ * where
+ *
+ * `\\[\\begin{bmatrix} x' \\\\ y' \\end{bmatrix} = W \\cdot \\begin{bmatrix} x \\\\ y \\\\ 1
+ * \\end{bmatrix}\\]`
+ *
+ * (the equation holds with homogeneous coordinates for homography). It returns the final enhanced
+ * correlation coefficient, that is the correlation coefficient between the template image and the
+ * final warped input image. When a `$3\\times 3$` matrix is given with motionType =0, 1 or 2, the
+ * third row is ignored.
+ *
+ * Unlike findHomography and estimateRigidTransform, the function findTransformECC implements an
+ * area-based alignment that builds on intensity similarities. In essence, the function updates the
+ * initial transformation that roughly aligns the images. If this information is missing, the identity
+ * warp (unity matrix) is used as an initialization. Note that if images undergo strong
+ * displacements/rotations, an initial transformation that roughly aligns the images is necessary
+ * (e.g., a simple euclidean/similarity transform that allows for the images showing the same image
+ * content approximately). Use inverse warping in the second image to take an image close to the first
+ * one, i.e. use the flag WARP_INVERSE_MAP with warpAffine or warpPerspective. See also the OpenCV
+ * sample image_alignment.cpp that demonstrates the use of the function. Note that the function throws
+ * an exception if algorithm does not converges.
+ *
+ * [computeECC], [estimateAffine2D], [estimateAffinePartial2D], [findHomography]
+ *
+ * @param templateImage single-channel template image; CV_8U or CV_32F array.
+ *
+ * @param inputImage single-channel input image which should be warped with the final warpMatrix in
+ * order to provide an image similar to templateImage, same type as templateImage.
+ *
+ * @param warpMatrix floating-point $2\times 3$ or $3\times 3$ mapping matrix (warp).
+ *
+ * @param motionType parameter, specifying the type of motion:
+ * MOTION_TRANSLATION sets a translational motion model; warpMatrix is $2\times 3$ with the first
+ * $2\times 2$ part being the unity matrix and the rest two parameters being estimated.MOTION_EUCLIDEAN
+ * sets a Euclidean (rigid) transformation as motion model; three parameters are estimated; warpMatrix
+ * is $2\times 3$.MOTION_AFFINE sets an affine motion model (DEFAULT); six parameters are estimated;
+ * warpMatrix is $2\times 3$.MOTION_HOMOGRAPHY sets a homography as a motion model; eight parameters
+ * are estimated;`warpMatrix` is $3\times 3$.
+ *
+ * @param criteria parameter, specifying the termination criteria of the ECC algorithm;
+ * criteria.epsilon defines the threshold of the increment in the correlation coefficient between two
+ * iterations (a negative criteria.epsilon makes criteria.maxcount the only termination criterion).
+ * Default values are shown in the declaration above.
+ *
+ * @param inputMask An optional mask to indicate valid values of inputImage.
+ *
+ * @param gaussFiltSize An optional value indicating size of gaussian blur filter; (DEFAULT: 5)
+ */
+export declare function findTransformECC(
+  templateImage: InputArray,
+  inputImage: InputArray,
+  warpMatrix: InputOutputArray,
+  motionType: int,
+  criteria: TermCriteria,
+  inputMask: InputArray,
+  gaussFiltSize: int,
+): double;
+
+/**
+ * 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 findTransformECC(
+  templateImage: InputArray,
+  inputImage: InputArray,
+  warpMatrix: InputOutputArray,
+  motionType?: int,
+  criteria?: TermCriteria,
+  inputMask?: InputArray,
+): double;
+
+/**
+ * @param probImage Back projection of the object histogram. See calcBackProject for details.
+ *
+ * @param window Initial search window.
+ *
+ * @param criteria Stop criteria for the iterative search algorithm. returns : Number of iterations
+ * CAMSHIFT took to converge. The function implements the iterative object search algorithm. It takes
+ * the input back projection of an object and the initial position. The mass center in window of the
+ * back projection image is computed and the search window center shifts to the mass center. The
+ * procedure is repeated until the specified number of iterations criteria.maxCount is done or until
+ * the window center shifts by less than criteria.epsilon. The algorithm is used inside CamShift and,
+ * unlike CamShift , the search window size or orientation do not change during the search. You can
+ * simply pass the output of calcBackProject to this function. But better results can be obtained if
+ * you pre-filter the back projection and remove the noise. For example, you can do this by retrieving
+ * connected components with findContours , throwing away contours with small area ( contourArea ), and
+ * rendering the remaining contours with drawContours.
+ */
+export declare function meanShift(
+  probImage: InputArray,
+  window: any,
+  criteria: TermCriteria,
+): int;
+
+/**
+ * The function readOpticalFlow loads a flow field from a file and returns it as a single matrix.
+ * Resulting [Mat] has a type CV_32FC2 - floating-point, 2-channel. First channel corresponds to the
+ * flow in the horizontal direction (u), second - vertical (v).
+ *
+ * @param path Path to the file to be loaded
+ */
+export declare function readOpticalFlow(path: any): Mat;
+
+/**
+ * The function stores a flow field in a file, returns true on success, false otherwise. The flow field
+ * must be a 2-channel, floating-point matrix (CV_32FC2). First channel corresponds to the flow in the
+ * horizontal direction (u), second - vertical (v).
+ *
+ * @param path Path to the file to be written
+ *
+ * @param flow Flow field to be stored
+ */
+export declare function writeOpticalFlow(path: any, flow: InputArray): bool;
+
+export declare const OPTFLOW_USE_INITIAL_FLOW: any; // initializer: = 4
+
+export declare const OPTFLOW_LK_GET_MIN_EIGENVALS: any; // initializer: = 8
+
+export declare const OPTFLOW_FARNEBACK_GAUSSIAN: any; // initializer: = 256
+
+export declare const MOTION_TRANSLATION: any; // initializer: = 0
+
+export declare const MOTION_EUCLIDEAN: any; // initializer: = 1
+
+export declare const MOTION_AFFINE: any; // initializer: = 2
+
+export declare const MOTION_HOMOGRAPHY: any; // initializer: = 3