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

package/README.md

@@ -137,6 +137,7 @@ Object.keys(cv).filter((key) => !key.includes("dynCall"));
   "stdout",
   "stderr",
   "IntVector",
+  "CharVector",
   "FloatVector",
   "DoubleVector",
   "PointVector",
@@ -157,6 +158,7 @@ Object.keys(cv).filter((key) => !key.includes("dynCall"));
   "CV_MAT_DEPTH",
   "CamShift",
   "meanShift",
+  "Tracker",
   "getBuildInformation",
   "Canny",
   "Canny1",
@@ -281,6 +283,7 @@ Object.keys(cv).filter((key) => !key.includes("dynCall"));
   "polarToCart",
   "polylines",
   "pow",
+  "projectPoints",
   "putText",
   "pyrDown",
   "pyrUp",
@@ -316,6 +319,12 @@ Object.keys(cv).filter((key) => !key.includes("dynCall"));
   "warpPerspective",
   "warpPolar",
   "watershed",
+  "drawDetectedCornersCharuco",
+  "drawDetectedDiamonds",
+  "drawDetectedMarkers",
+  "extendDictionary",
+  "generateImageMarker",
+  "getPredefinedDictionary",
   "blobFromImage",
   "readNet",
   "readNet1",
@@ -325,9 +334,13 @@ Object.keys(cv).filter((key) => !key.includes("dynCall"));
   "readNetFromDarknet1",
   "readNetFromONNX",
   "readNetFromONNX1",
+  "readNetFromTFLite",
+  "readNetFromTFLite1",
   "readNetFromTensorflow",
   "readNetFromTensorflow1",
   "readNetFromTorch",
+  "fisheye_initUndistortRectifyMap",
+  "fisheye_projectPoints",
   "AKAZE",
   "AgastFeatureDetector",
   "Algorithm",
@@ -345,6 +358,7 @@ Object.keys(cv).filter((key) => !key.includes("dynCall"));
   "FastFeatureDetector",
   "Feature2D",
   "GFTTDetector",
+  "GraphicalCodeDetector",
   "HOGDescriptor",
   "KAZE",
   "MSER",
@@ -354,10 +368,24 @@ Object.keys(cv).filter((key) => !key.includes("dynCall"));
   "MergeRobertson",
   "ORB",
   "QRCodeDetector",
+  "QRCodeDetectorAruco",
+  "QRCodeDetectorAruco_Params",
   "Tonemap",
   "TonemapDrago",
   "TonemapMantiuk",
   "TonemapReinhard",
+  "TrackerMIL",
+  "TrackerMIL_Params",
+  "aruco_ArucoDetector",
+  "aruco_Board",
+  "aruco_CharucoBoard",
+  "aruco_CharucoDetector",
+  "aruco_CharucoParameters",
+  "aruco_DetectorParameters",
+  "aruco_Dictionary",
+  "aruco_GridBoard",
+  "aruco_RefineParameters",
+  "barcode_BarcodeDetector",
   "dnn_Net",
   "segmentation_IntelligentScissorsMB",
   "CV_8UC1",
@@ -560,6 +588,15 @@ Object.keys(cv).filter((key) => !key.includes("dynCall"));
   "COLOR_BayerBG2RGBA",
   "COLOR_BayerBG2RGB_EA",
   "COLOR_BayerBG2RGB_VNG",
+  "COLOR_BayerBGGR2BGR",
+  "COLOR_BayerBGGR2BGRA",
+  "COLOR_BayerBGGR2BGR_EA",
+  "COLOR_BayerBGGR2BGR_VNG",
+  "COLOR_BayerBGGR2GRAY",
+  "COLOR_BayerBGGR2RGB",
+  "COLOR_BayerBGGR2RGBA",
+  "COLOR_BayerBGGR2RGB_EA",
+  "COLOR_BayerBGGR2RGB_VNG",
   "COLOR_BayerGB2BGR",
   "COLOR_BayerGB2BGRA",
   "COLOR_BayerGB2BGR_EA",
@@ -569,6 +606,15 @@ Object.keys(cv).filter((key) => !key.includes("dynCall"));
   "COLOR_BayerGB2RGBA",
   "COLOR_BayerGB2RGB_EA",
   "COLOR_BayerGB2RGB_VNG",
+  "COLOR_BayerGBRG2BGR",
+  "COLOR_BayerGBRG2BGRA",
+  "COLOR_BayerGBRG2BGR_EA",
+  "COLOR_BayerGBRG2BGR_VNG",
+  "COLOR_BayerGBRG2GRAY",
+  "COLOR_BayerGBRG2RGB",
+  "COLOR_BayerGBRG2RGBA",
+  "COLOR_BayerGBRG2RGB_EA",
+  "COLOR_BayerGBRG2RGB_VNG",
   "COLOR_BayerGR2BGR",
   "COLOR_BayerGR2BGRA",
   "COLOR_BayerGR2BGR_EA",
@@ -578,6 +624,15 @@ Object.keys(cv).filter((key) => !key.includes("dynCall"));
   "COLOR_BayerGR2RGBA",
   "COLOR_BayerGR2RGB_EA",
   "COLOR_BayerGR2RGB_VNG",
+  "COLOR_BayerGRBG2BGR",
+  "COLOR_BayerGRBG2BGRA",
+  "COLOR_BayerGRBG2BGR_EA",
+  "COLOR_BayerGRBG2BGR_VNG",
+  "COLOR_BayerGRBG2GRAY",
+  "COLOR_BayerGRBG2RGB",
+  "COLOR_BayerGRBG2RGBA",
+  "COLOR_BayerGRBG2RGB_EA",
+  "COLOR_BayerGRBG2RGB_VNG",
   "COLOR_BayerRG2BGR",
   "COLOR_BayerRG2BGRA",
   "COLOR_BayerRG2BGR_EA",
@@ -587,6 +642,15 @@ Object.keys(cv).filter((key) => !key.includes("dynCall"));
   "COLOR_BayerRG2RGBA",
   "COLOR_BayerRG2RGB_EA",
   "COLOR_BayerRG2RGB_VNG",
+  "COLOR_BayerRGGB2BGR",
+  "COLOR_BayerRGGB2BGRA",
+  "COLOR_BayerRGGB2BGR_EA",
+  "COLOR_BayerRGGB2BGR_VNG",
+  "COLOR_BayerRGGB2GRAY",
+  "COLOR_BayerRGGB2RGB",
+  "COLOR_BayerRGGB2RGBA",
+  "COLOR_BayerRGGB2RGB_EA",
+  "COLOR_BayerRGGB2RGB_VNG",
   "COLOR_COLORCVT_MAX",
   "COLOR_GRAY2BGR",
   "COLOR_GRAY2BGR555",
@@ -729,6 +793,7 @@ Object.keys(cv).filter((key) => !key.includes("dynCall"));
   "COVAR_SCALE",
   "COVAR_SCRAMBLED",
   "COVAR_USE_AVG",
+  "COV_POLISHER",
   "CirclesGridFinderParameters_ASYMMETRIC_GRID",
   "CirclesGridFinderParameters_SYMMETRIC_GRID",
   "DCT_INVERSE",
@@ -788,6 +853,8 @@ Object.keys(cv).filter((key) => !key.includes("dynCall"));
   "FONT_HERSHEY_SIMPLEX",
   "FONT_HERSHEY_TRIPLEX",
   "FONT_ITALIC",
+  "FaceRecognizerSF_FR_COSINE",
+  "FaceRecognizerSF_FR_NORM_L2",
   "FastFeatureDetector_FAST_N",
   "FastFeatureDetector_NONMAX_SUPPRESSION",
   "FastFeatureDetector_THRESHOLD",
@@ -892,6 +959,8 @@ Object.keys(cv).filter((key) => !key.includes("dynCall"));
   "LSD_REFINE_ADV",
   "LSD_REFINE_NONE",
   "LSD_REFINE_STD",
+  "LSQ_POLISHER",
+  "MAGSAC",
   "MARKER_CROSS",
   "MARKER_DIAMOND",
   "MARKER_SQUARE",
@@ -926,6 +995,7 @@ Object.keys(cv).filter((key) => !key.includes("dynCall"));
   "NEIGH_FLANN_KNN",
   "NEIGH_FLANN_RADIUS",
   "NEIGH_GRID",
+  "NONE_POLISHER",
   "NORMAL_CLONE",
   "NORMCONV_FILTER",
   "NORM_HAMMING",
@@ -959,6 +1029,18 @@ Object.keys(cv).filter((key) => !key.includes("dynCall"));
   "Param_UCHAR",
   "Param_UINT64",
   "Param_UNSIGNED_INT",
+  "QRCodeEncoder_CORRECT_LEVEL_H",
+  "QRCodeEncoder_CORRECT_LEVEL_L",
+  "QRCodeEncoder_CORRECT_LEVEL_M",
+  "QRCodeEncoder_CORRECT_LEVEL_Q",
+  "QRCodeEncoder_ECI_UTF8",
+  "QRCodeEncoder_MODE_ALPHANUMERIC",
+  "QRCodeEncoder_MODE_AUTO",
+  "QRCodeEncoder_MODE_BYTE",
+  "QRCodeEncoder_MODE_ECI",
+  "QRCodeEncoder_MODE_KANJI",
+  "QRCodeEncoder_MODE_NUMERIC",
+  "QRCodeEncoder_MODE_STRUCTURED_APPEND",
   "QUAT_ASSUME_NOT_UNIT",
   "QUAT_ASSUME_UNIT",
   "QuatEnum_EULER_ANGLES_MAX_VALUE",
@@ -992,6 +1074,7 @@ Object.keys(cv).filter((key) => !key.includes("dynCall"));
   "REDUCE_MAX",
   "REDUCE_MIN",
   "REDUCE_SUM",
+  "REDUCE_SUM2",
   "RETR_CCOMP",
   "RETR_EXTERNAL",
   "RETR_FLOODFILL",
@@ -1011,6 +1094,7 @@ Object.keys(cv).filter((key) => !key.includes("dynCall"));
   "SCORE_METHOD_MAGSAC",
   "SCORE_METHOD_MSAC",
   "SCORE_METHOD_RANSAC",
+  "SOLVELP_LOST",
   "SOLVELP_MULTI",
   "SOLVELP_SINGLE",
   "SOLVELP_UNBOUNDED",
@@ -1192,6 +1276,32 @@ Object.keys(cv).filter((key) => !key.includes("dynCall"));
   "StsUnmatchedSizes",
   "StsUnsupportedFormat",
   "StsVecLengthErr",
+  "CORNER_REFINE_APRILTAG",
+  "CORNER_REFINE_CONTOUR",
+  "CORNER_REFINE_NONE",
+  "CORNER_REFINE_SUBPIX",
+  "DICT_4X4_100",
+  "DICT_4X4_1000",
+  "DICT_4X4_250",
+  "DICT_4X4_50",
+  "DICT_5X5_100",
+  "DICT_5X5_1000",
+  "DICT_5X5_250",
+  "DICT_5X5_50",
+  "DICT_6X6_100",
+  "DICT_6X6_1000",
+  "DICT_6X6_250",
+  "DICT_6X6_50",
+  "DICT_7X7_100",
+  "DICT_7X7_1000",
+  "DICT_7X7_250",
+  "DICT_7X7_50",
+  "DICT_APRILTAG_16h5",
+  "DICT_APRILTAG_25h9",
+  "DICT_APRILTAG_36h10",
+  "DICT_APRILTAG_36h11",
+  "DICT_ARUCO_MIP_36h12",
+  "DICT_ARUCO_ORIGINAL",
   "TEST_CUSTOM",
   "TEST_EQ",
   "TEST_GE",
@@ -1204,21 +1314,38 @@ Object.keys(cv).filter((key) => !key.includes("dynCall"));
   "TrackerSamplerCSC_MODE_INIT_POS",
   "TrackerSamplerCSC_MODE_TRACK_NEG",
   "TrackerSamplerCSC_MODE_TRACK_POS",
+  "DNN_BACKEND_CANN",
   "DNN_BACKEND_CUDA",
   "DNN_BACKEND_DEFAULT",
   "DNN_BACKEND_HALIDE",
   "DNN_BACKEND_INFERENCE_ENGINE",
   "DNN_BACKEND_OPENCV",
+  "DNN_BACKEND_TIMVX",
   "DNN_BACKEND_VKCOM",
+  "DNN_BACKEND_WEBNN",
+  "DNN_LAYOUT_NCDHW",
+  "DNN_LAYOUT_NCHW",
+  "DNN_LAYOUT_ND",
+  "DNN_LAYOUT_NDHWC",
+  "DNN_LAYOUT_NHWC",
+  "DNN_LAYOUT_PLANAR",
+  "DNN_LAYOUT_UNKNOWN",
+  "DNN_PMODE_CROP_CENTER",
+  "DNN_PMODE_LETTERBOX",
+  "DNN_PMODE_NULL",
   "DNN_TARGET_CPU",
+  "DNN_TARGET_CPU_FP16",
   "DNN_TARGET_CUDA",
   "DNN_TARGET_CUDA_FP16",
   "DNN_TARGET_FPGA",
   "DNN_TARGET_HDDL",
   "DNN_TARGET_MYRIAD",
+  "DNN_TARGET_NPU",
   "DNN_TARGET_OPENCL",
   "DNN_TARGET_OPENCL_FP16",
   "DNN_TARGET_VULKAN",
+  "SoftNMSMethod_SOFTNMS_GAUSSIAN",
+  "SoftNMSMethod_SOFTNMS_LINEAR",
   "CALIB_CHECK_COND",
   "CALIB_FIX_SKEW",
   "CALIB_RECOMPUTE_EXTRINSIC",

package/dist/src/index.d.ts

@@ -0,0 +1 @@
+export * from "./types/opencv";

package/dist/src/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./types/opencv"), exports);
+//# sourceMappingURL=index.js.map

package/dist/src/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,iDAA+B"}

package/dist/src/types/_cv.d.ts

@@ -0,0 +1,7 @@
+import { FS } from "./emscripten";
+import { CV } from "./opencv";
+declare global {
+    var cv: CV & {
+        FS: FS;
+    };
+}

package/dist/src/types/_cv.js

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

package/dist/src/types/_cv.js.map

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

package/dist/src/types/emscripten.d.ts

@@ -0,0 +1,166 @@
+interface Lookup {
+    path: string;
+    node: FSNode;
+}
+interface FSStream {
+}
+interface FSNode {
+}
+export interface FS {
+    lookupPath(path: string, opts: any): Lookup;
+    getPath(node: FSNode): string;
+    isFile(mode: number): boolean;
+    isDir(mode: number): boolean;
+    isLink(mode: number): boolean;
+    isChrdev(mode: number): boolean;
+    isBlkdev(mode: number): boolean;
+    isFIFO(mode: number): boolean;
+    isSocket(mode: number): boolean;
+    major(dev: number): number;
+    minor(dev: number): number;
+    makedev(ma: number, mi: number): number;
+    registerDevice(dev: number, ops: any): void;
+    syncfs(populate: boolean, callback: (e: any) => any): void;
+    syncfs(callback: (e: any) => any, populate?: boolean): void;
+    mount(type: any, opts: any, mountpoint: string): any;
+    unmount(mountpoint: string): void;
+    mkdir(path: string, mode?: number): any;
+    mkdev(path: string, mode?: number, dev?: number): any;
+    symlink(oldpath: string, newpath: string): any;
+    rename(old_path: string, new_path: string): void;
+    rmdir(path: string): void;
+    readdir(path: string): string[];
+    unlink(path: string): void;
+    readlink(path: string): string;
+    stat(path: string, dontFollow?: boolean): any;
+    lstat(path: string): any;
+    chmod(path: string, mode: number, dontFollow?: boolean): void;
+    lchmod(path: string, mode: number): void;
+    fchmod(fd: number, mode: number): void;
+    chown(path: string, uid: number, gid: number, dontFollow?: boolean): void;
+    lchown(path: string, uid: number, gid: number): void;
+    fchown(fd: number, uid: number, gid: number): void;
+    truncate(path: string, len: number): void;
+    ftruncate(fd: number, len: number): void;
+    utime(path: string, atime: number, mtime: number): void;
+    open(path: string, flags: string, mode?: number, fd_start?: number, fd_end?: number): FSStream;
+    close(stream: FSStream): void;
+    llseek(stream: FSStream, offset: number, whence: number): any;
+    read(stream: FSStream, buffer: ArrayBufferView, offset: number, length: number, position?: number): number;
+    write(stream: FSStream, buffer: ArrayBufferView, offset: number, length: number, position?: number, canOwn?: boolean): number;
+    allocate(stream: FSStream, offset: number, length: number): void;
+    mmap(stream: FSStream, buffer: ArrayBufferView, offset: number, length: number, position: number, prot: number, flags: number): any;
+    ioctl(stream: FSStream, cmd: any, arg: any): any;
+    readFile(path: string, opts?: {
+        encoding: string;
+        flags: string;
+    }): ArrayBufferView;
+    writeFile(path: string, data: ArrayBufferView, opts?: {
+        encoding: string;
+        flags: string;
+    }): void;
+    writeFile(path: string, data: string, opts?: {
+        encoding: string;
+        flags: string;
+    }): void;
+    analyzePath(p: string): any;
+    cwd(): string;
+    chdir(path: string): void;
+    init(input: () => number, output: (c: number) => any, error: (c: number) => any): void;
+    createLazyFile(parent: string, name: string, url: string, canRead: boolean, canWrite: boolean): FSNode;
+    createLazyFile(parent: FSNode, name: string, url: string, canRead: boolean, canWrite: boolean): FSNode;
+    createPreloadedFile(parent: string, name: string, url: string, canRead: boolean, canWrite: boolean, onload?: () => void, onerror?: () => void, dontCreateFile?: boolean, canOwn?: boolean): void;
+    createPreloadedFile(parent: FSNode, name: string, url: string, canRead: boolean, canWrite: boolean, onload?: () => void, onerror?: () => void, dontCreateFile?: boolean, canOwn?: boolean): void;
+    createDataFile(parent: string, name: string, data: ArrayBufferView, canRead: boolean, canWrite: boolean, canOwn: boolean): void;
+}
+export interface EmscriptenModule {
+    print(str: string): void;
+    printErr(str: string): void;
+    arguments: string[];
+    environment: EnvironmentType;
+    preInit: Array<{
+        (): void;
+    }>;
+    preRun: Array<{
+        (): void;
+    }>;
+    postRun: Array<{
+        (): void;
+    }>;
+    onAbort: {
+        (what: any): void;
+    };
+    onRuntimeInitialized: {
+        (): void;
+    };
+    preinitializedWebGLContext: WebGLRenderingContext;
+    noInitialRun: boolean;
+    noExitRuntime: boolean;
+    logReadFiles: boolean;
+    filePackagePrefixURL: string;
+    wasmBinary: ArrayBuffer;
+    destroy(object: object): void;
+    getPreloadedPackage(remotePackageName: string, remotePackageSize: number): ArrayBuffer;
+    instantiateWasm(imports: WebAssemblyImports, successCallback: (module: WebAssemblyModule) => void): WebAssemblyExports;
+    locateFile(url: string): string;
+    onCustomMessage(event: MessageEvent): void;
+    Runtime: any;
+    ccall(ident: string, returnType: ValueType | null, argTypes: ValueType[], args: TypeCompatibleWithC[], opts?: CCallOpts): any;
+    cwrap(ident: string, returnType: ValueType | null, argTypes: ValueType[], opts?: CCallOpts): (...args: any[]) => any;
+    setValue(ptr: number, value: any, type: string, noSafe?: boolean): void;
+    getValue(ptr: number, type: string, noSafe?: boolean): number;
+    ALLOC_NORMAL: number;
+    ALLOC_STACK: number;
+    ALLOC_STATIC: number;
+    ALLOC_DYNAMIC: number;
+    ALLOC_NONE: number;
+    allocate(slab: any, types: string | string[], allocator: number, ptr: number): number;
+    HEAP: Int32Array;
+    IHEAP: Int32Array;
+    FHEAP: Float64Array;
+    HEAP8: Int8Array;
+    HEAP16: Int16Array;
+    HEAP32: Int32Array;
+    HEAPU8: Uint8Array;
+    HEAPU16: Uint16Array;
+    HEAPU32: Uint32Array;
+    HEAPF32: Float32Array;
+    HEAPF64: Float64Array;
+    TOTAL_STACK: number;
+    TOTAL_MEMORY: number;
+    FAST_MEMORY: number;
+    addOnPreRun(cb: () => any): void;
+    addOnInit(cb: () => any): void;
+    addOnPreMain(cb: () => any): void;
+    addOnExit(cb: () => any): void;
+    addOnPostRun(cb: () => any): void;
+    intArrayFromString(stringy: string, dontAddNull?: boolean, length?: number): number[];
+    intArrayToString(array: number[]): string;
+    writeStringToMemory(str: string, buffer: number, dontAddNull: boolean): void;
+    writeArrayToMemory(array: number[], buffer: number): void;
+    writeAsciiToMemory(str: string, buffer: number, dontAddNull: boolean): void;
+    addRunDependency(id: any): void;
+    removeRunDependency(id: any): void;
+    preloadedImages: any;
+    preloadedAudios: any;
+    _malloc(size: number): number;
+    _free(ptr: number): void;
+}
+type EnvironmentType = "WEB" | "NODE" | "SHELL" | "WORKER";
+type ValueType = "number" | "string" | "array" | "boolean";
+type TypeCompatibleWithC = number | string | any[] | boolean;
+type WebAssemblyImports = Array<{
+    name: string;
+    kind: string;
+}>;
+type WebAssemblyExports = Array<{
+    module: string;
+    name: string;
+    kind: string;
+}>;
+interface CCallOpts {
+    async?: boolean;
+}
+interface WebAssemblyModule {
+}
+export {};

package/dist/src/types/emscripten.js

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

package/dist/src/types/emscripten.js.map

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

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

@@ -0,0 +1,183 @@
+import { float_type, int, Mat, Mat3, Mat4, Vec3 } from "./_types";
+/**
+ * It represents a 4x4 homogeneous transformation matrix `$T$`
+ *
+ * `\\[T = \\begin{bmatrix} R & t\\\\ 0 & 1\\\\ \\end{bmatrix} \\]`
+ *
+ * where `$R$` is a 3x3 rotation matrix and `$t$` is a 3x1 translation vector.
+ *
+ * You can specify `$R$` either by a 3x3 rotation matrix or by a 3x1 rotation vector, which is
+ * converted to a 3x3 rotation matrix by the Rodrigues formula.
+ *
+ * To construct a matrix `$T$` representing first rotation around the axis `$r$` with rotation angle
+ * `$|r|$` in radian (right hand rule) and then translation by the vector `$t$`, you can use
+ *
+ * ```cpp
+ * cv::Vec3f r, t;
+ * cv::Affine3f T(r, t);
+ * ```
+ *
+ * If you already have the rotation matrix `$R$`, then you can use
+ *
+ * ```cpp
+ * cv::Matx33f R;
+ * cv::Affine3f T(R, t);
+ * ```
+ *
+ * To extract the rotation matrix `$R$` from `$T$`, use
+ *
+ * ```cpp
+ * cv::Matx33f R = T.rotation();
+ * ```
+ *
+ * To extract the translation vector `$t$` from `$T$`, use
+ *
+ * ```cpp
+ * cv::Vec3f t = T.translation();
+ * ```
+ *
+ * To extract the rotation vector `$r$` from `$T$`, use
+ *
+ * ```cpp
+ * cv::Vec3f r = T.rvec();
+ * ```
+ *
+ * Note that since the mapping from rotation vectors to rotation matrices is many to one. The returned
+ * rotation vector is not necessarily the one you used before to set the matrix.
+ *
+ * If you have two transformations `$T = T_1 * T_2$`, use
+ *
+ * ```cpp
+ * cv::Affine3f T, T1, T2;
+ * T = T2.concatenate(T1);
+ * ```
+ *
+ * To get the inverse transform of `$T$`, use
+ *
+ * ```cpp
+ * cv::Affine3f T, T_inv;
+ * T_inv = T.inv();
+ * ```
+ *
+ * Source:
+ * [opencv2/core/affine.hpp](https://github.com/opencv/opencv/tree/master/modules/core/include/opencv2/core/affine.hpp#L129).
+ *
+ */
+export declare class Affine3 {
+    matrix: Mat4;
+    constructor();
+    constructor(affine: Mat4);
+    /**
+     *   The resulting 4x4 matrix is
+     *
+     *   `\\[ \\begin{bmatrix} R & t\\\\ 0 & 1\\\\ \\end{bmatrix} \\]`
+     *
+     * @param R 3x3 rotation matrix.
+     *
+     * @param t 3x1 translation vector.
+     */
+    constructor(R: Mat3, t?: Vec3);
+    /**
+     *   Rodrigues vector.
+     *
+     *   The last row of the current matrix is set to [0,0,0,1].
+     *
+     * @param rvec 3x1 rotation vector. Its direction indicates the rotation axis and its length
+     * indicates the rotation angle in radian (using right hand rule).
+     *
+     * @param t 3x1 translation vector.
+     */
+    constructor(rvec: Vec3, t?: Vec3);
+    /**
+     *   Combines all constructors above. Supports 4x4, 3x4, 3x3, 1x3, 3x1 sizes of data matrix.
+     *
+     *   The last row of the current matrix is set to [0,0,0,1] when data is not 4x4.
+     *
+     * @param data 1-channel matrix. when it is 4x4, it is copied to the current matrix and t is not
+     * used. When it is 3x4, it is copied to the upper part 3x4 of the current matrix and t is not used.
+     * When it is 3x3, it is copied to the upper left 3x3 part of the current matrix. When it is 3x1 or
+     * 1x3, it is treated as a rotation vector and the Rodrigues formula is used to compute a 3x3 rotation
+     * matrix.
+     *
+     * @param t 3x1 translation vector. It is used only when data is neither 4x4 nor 3x4.
+     */
+    constructor(data: Mat, t?: Vec3);
+    constructor(vals: float_type);
+    cast(arg401: any): Affine3;
+    concatenate(affine: Affine3): Affine3;
+    /**
+     *   the inverse of the current matrix.
+     */
+    inv(method?: int): Affine3;
+    /**
+     *   Copy the 3x3 matrix L to the upper left part of the current matrix
+     *
+     *   It sets the upper left 3x3 part of the matrix. The remaining part is unaffected.
+     *
+     * @param L 3x3 matrix.
+     */
+    linear(L: Mat3): Mat3;
+    /**
+     *   the upper left 3x3 part
+     */
+    linear(): Mat3;
+    rotate(R: Mat3): Affine3;
+    rotate(rvec: Vec3): Affine3;
+    /**
+     *   Rotation matrix.
+     *
+     *   Copy the rotation matrix to the upper left 3x3 part of the current matrix. The remaining elements
+     * of the current matrix are not changed.
+     *
+     * @param R 3x3 rotation matrix.
+     */
+    rotation(R: Mat3): Mat3;
+    /**
+     *   Rodrigues vector.
+     *
+     *   It sets the upper left 3x3 part of the matrix. The remaining part is unaffected.
+     *
+     * @param rvec 3x1 rotation vector. The direction indicates the rotation axis and its length
+     * indicates the rotation angle in radian (using the right thumb convention).
+     */
+    rotation(rvec: Vec3): Vec3;
+    /**
+     *   Combines rotation methods above. Supports 3x3, 1x3, 3x1 sizes of data matrix.
+     *
+     *   It sets the upper left 3x3 part of the matrix. The remaining part is unaffected.
+     *
+     * @param data 1-channel matrix. When it is a 3x3 matrix, it sets the upper left 3x3 part of the
+     * current matrix. When it is a 1x3 or 3x1 matrix, it is used as a rotation vector. The Rodrigues
+     * formula is used to compute the rotation matrix and sets the upper left 3x3 part of the current
+     * matrix.
+     */
+    rotation(data: Mat): Mat;
+    /**
+     *   the upper left 3x3 part
+     */
+    rotation(): Mat3;
+    /**
+     *   Rodrigues vector.
+     *
+     *   a vector representing the upper left 3x3 rotation matrix of the current matrix.
+     *
+     *   Since the mapping between rotation vectors and rotation matrices is many to one, this function
+     * returns only one rotation vector that represents the current rotation matrix, which is not
+     * necessarily the same one set by `[rotation(const Vec3& rvec)]`.
+     */
+    rvec(): Vec3;
+    translate(t: Vec3): Affine3;
+    /**
+     *   Copy t to the first three elements of the last column of the current matrix
+     *
+     *   It sets the upper right 3x1 part of the matrix. The remaining part is unaffected.
+     *
+     * @param t 3x1 translation vector.
+     */
+    translation(t: Vec3): Vec3;
+    /**
+     *   the upper right 3x1 part
+     */
+    translation(): Vec3;
+    static Identity(): Affine3;
+}

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

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

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

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