Options
All
  • Public
  • Public/Protected
  • All
Menu

Module @autojs/opencv

Auto.js Pro 9 migrates opencv4nodejs to built-in module @autojs/opencv. You can use it like opencv4nodejs without npm installation.

The documentation of opencv4nodejs can be found:

  1. OpenCV 4.5.1 DocsOpenCV Mat
  2. opencv4nodejs Quick Start
  3. opencv4nodejs docs

Since the content of OpenCV itself is relatively large, it is unlikely that the documents of OpenCV will be translated and migrated here, so the OpenCV part needs to read and understand the above English documents by yourself. The following documents are generated from the content of the .d.ts file, only marking all functions, constants, class names, types and other information, without detailed comments.

example
"nodejs";

const cv = require("@autojs/opencv");
const rows = 100; // height
const cols = 100; // width
const emptyMat = new cv.Mat(rows, cols, cv.CV_8UC3);
// fill the Mat with default value
const whiteMat = new cv.Mat(rows, cols, cv.CV_8UC1, 255);
const blueMat = new cv.Mat(rows, cols, cv.CV_8UC3, [255, 0, 0]);

Index

Classes

Interfaces

Type aliases

Variables

Functions

Type aliases

DrawParams

DrawParams: { color?: Vec3; lineType?: number; thickness?: number }

Type declaration

  • Optional color?: Vec3
  • Optional lineType?: number
  • Optional thickness?: number

Variables

Const ADAPTIVE_THRESH_GAUSSIAN_C

ADAPTIVE_THRESH_GAUSSIAN_C: number

Const ADAPTIVE_THRESH_MEAN_C

ADAPTIVE_THRESH_MEAN_C: number

Const BORDER_CONSTANT

BORDER_CONSTANT: number

Const BORDER_DEFAULT

BORDER_DEFAULT: number

Const BORDER_ISOLATED

BORDER_ISOLATED: number

Const BORDER_REFLECT

BORDER_REFLECT: number

Const BORDER_REFLECT_101

BORDER_REFLECT_101: number

Const BORDER_REPLICATE

BORDER_REPLICATE: number

Const BORDER_TRANSPARENT

BORDER_TRANSPARENT: number

Const BORDER_WRAP

BORDER_WRAP: number

Const CALIB_CB_ADAPTIVE_THRESH

CALIB_CB_ADAPTIVE_THRESH: number

Const CALIB_CB_ASYMMETRIC_GRID

CALIB_CB_ASYMMETRIC_GRID: number

Const CALIB_CB_CLUSTERING

CALIB_CB_CLUSTERING: number

Const CALIB_CB_FAST_CHECK

CALIB_CB_FAST_CHECK: number

Const CALIB_CB_FILTER_QUADS

CALIB_CB_FILTER_QUADS: number

Const CALIB_CB_NORMALIZE_IMAGE

CALIB_CB_NORMALIZE_IMAGE: number

Const CALIB_CB_SYMMETRIC_GRID

CALIB_CB_SYMMETRIC_GRID: number

Const CALIB_FIX_ASPECT_RATIO

CALIB_FIX_ASPECT_RATIO: number

Const CALIB_FIX_FOCAL_LENGTH

CALIB_FIX_FOCAL_LENGTH: number

Const CALIB_FIX_INTRINSIC

CALIB_FIX_INTRINSIC: number

Const CALIB_FIX_K1

CALIB_FIX_K1: number

Const CALIB_FIX_K2

CALIB_FIX_K2: number

Const CALIB_FIX_K3

CALIB_FIX_K3: number

Const CALIB_FIX_K4

CALIB_FIX_K4: number

Const CALIB_FIX_K5

CALIB_FIX_K5: number

Const CALIB_FIX_K6

CALIB_FIX_K6: number

Const CALIB_FIX_PRINCIPAL_POINT

CALIB_FIX_PRINCIPAL_POINT: number

Const CALIB_FIX_S1_S2_S3_S4

CALIB_FIX_S1_S2_S3_S4: number

Const CALIB_FIX_TANGENT_DIST

CALIB_FIX_TANGENT_DIST: number

Const CALIB_FIX_TAUX_TAUY

CALIB_FIX_TAUX_TAUY: number

Const CALIB_RATIONAL_MODEL

CALIB_RATIONAL_MODEL: number

Const CALIB_SAME_FOCAL_LENGTH

CALIB_SAME_FOCAL_LENGTH: number

Const CALIB_THIN_PRISM_MODEL

CALIB_THIN_PRISM_MODEL: number

Const CALIB_TILTED_MODEL

CALIB_TILTED_MODEL: number

Const CALIB_USE_INTRINSIC_GUESS

CALIB_USE_INTRINSIC_GUESS: number

Const CALIB_USE_LU

CALIB_USE_LU: number

Const CALIB_USE_QR

CALIB_USE_QR: number

Const CALIB_ZERO_DISPARITY

CALIB_ZERO_DISPARITY: number

Const CALIB_ZERO_TANGENT_DIST

CALIB_ZERO_TANGENT_DIST: number

Const CAP_ANDROID

CAP_ANDROID: number

Const CAP_ANY

CAP_ANY: number

Const CAP_ARAVIS

CAP_ARAVIS: number

Const CAP_AVFOUNDATION

CAP_AVFOUNDATION: number

Const CAP_CMU1394

CAP_CMU1394: number

Const CAP_DC1394

CAP_DC1394: number

Const CAP_DSHOW

CAP_DSHOW: number

Const CAP_FFMPEG

CAP_FFMPEG: number

Const CAP_FIREWIRE

CAP_FIREWIRE: number

Const CAP_GIGANETIX

CAP_GIGANETIX: number

Const CAP_GPHOTO2

CAP_GPHOTO2: number

Const CAP_GSTREAMER

CAP_GSTREAMER: number

Const CAP_IEEE1394

CAP_IEEE1394: number

Const CAP_IMAGES

CAP_IMAGES: number

Const CAP_INTELPERC

CAP_INTELPERC: number

Const CAP_MODE_BGR

CAP_MODE_BGR: number

Const CAP_MODE_GRAY

CAP_MODE_GRAY: number

Const CAP_MODE_RGB

CAP_MODE_RGB: number

Const CAP_MODE_YUYV

CAP_MODE_YUYV: number

Const CAP_MSMF

CAP_MSMF: number

Const CAP_OPENNI

CAP_OPENNI: number

Const CAP_OPENNI2

CAP_OPENNI2: number

Const CAP_OPENNI2_ASUS

CAP_OPENNI2_ASUS: number

Const CAP_OPENNI_ASUS

CAP_OPENNI_ASUS: number

Const CAP_PROP_AUTOFOCUS

CAP_PROP_AUTOFOCUS: number

Const CAP_PROP_AUTO_EXPOSURE

CAP_PROP_AUTO_EXPOSURE: number

Const CAP_PROP_BACKLIGHT

CAP_PROP_BACKLIGHT: number

Const CAP_PROP_BRIGHTNESS

CAP_PROP_BRIGHTNESS: number

Const CAP_PROP_BUFFERSIZE

CAP_PROP_BUFFERSIZE: number

Const CAP_PROP_CONTRAST

CAP_PROP_CONTRAST: number

Const CAP_PROP_CONVERT_RGB

CAP_PROP_CONVERT_RGB: number

Const CAP_PROP_EXPOSURE

CAP_PROP_EXPOSURE: number

Const CAP_PROP_FOCUS

CAP_PROP_FOCUS: number

Const CAP_PROP_FORMAT

CAP_PROP_FORMAT: number

Const CAP_PROP_FOURCC

CAP_PROP_FOURCC: number

Const CAP_PROP_FPS

CAP_PROP_FPS: number

Const CAP_PROP_FRAME_COUNT

CAP_PROP_FRAME_COUNT: number

Const CAP_PROP_FRAME_HEIGHT

CAP_PROP_FRAME_HEIGHT: number

Const CAP_PROP_FRAME_WIDTH

CAP_PROP_FRAME_WIDTH: number

Const CAP_PROP_GAIN

CAP_PROP_GAIN: number

Const CAP_PROP_GAMMA

CAP_PROP_GAMMA: number

Const CAP_PROP_GUID

CAP_PROP_GUID: number

Const CAP_PROP_HUE

CAP_PROP_HUE: number

Const CAP_PROP_IRIS

CAP_PROP_IRIS: number

Const CAP_PROP_ISO_SPEED

CAP_PROP_ISO_SPEED: number

Const CAP_PROP_MODE

CAP_PROP_MODE: number

Const CAP_PROP_MONOCHROME

CAP_PROP_MONOCHROME: number

Const CAP_PROP_PAN

CAP_PROP_PAN: number

Const CAP_PROP_POS_AVI_RATIO

CAP_PROP_POS_AVI_RATIO: number

Const CAP_PROP_POS_FRAMES

CAP_PROP_POS_FRAMES: number

Const CAP_PROP_POS_MSEC

CAP_PROP_POS_MSEC: number

Const CAP_PROP_RECTIFICATION

CAP_PROP_RECTIFICATION: number

Const CAP_PROP_ROLL

CAP_PROP_ROLL: number

Const CAP_PROP_SATURATION

CAP_PROP_SATURATION: number

Const CAP_PROP_SETTINGS

CAP_PROP_SETTINGS: number

Const CAP_PROP_SHARPNESS

CAP_PROP_SHARPNESS: number

Const CAP_PROP_TEMPERATURE

CAP_PROP_TEMPERATURE: number

Const CAP_PROP_TILT

CAP_PROP_TILT: number

Const CAP_PROP_TRIGGER

CAP_PROP_TRIGGER: number

Const CAP_PROP_TRIGGER_DELAY

CAP_PROP_TRIGGER_DELAY: number

Const CAP_PROP_WHITE_BALANCE_BLUE_U

CAP_PROP_WHITE_BALANCE_BLUE_U: number

Const CAP_PROP_WHITE_BALANCE_RED_V

CAP_PROP_WHITE_BALANCE_RED_V: number

Const CAP_PROP_ZOOM

CAP_PROP_ZOOM: number

Const CAP_PVAPI

CAP_PVAPI: number

Const CAP_QT

CAP_QT: number

Const CAP_UNICAP

CAP_UNICAP: number

Const CAP_V4L

CAP_V4L: number

Const CAP_V4L2

CAP_V4L2: number

Const CAP_VFW

CAP_VFW: number

Const CAP_WINRT

CAP_WINRT: number

Const CAP_XIAPI

CAP_XIAPI: number

Const CC_STAT_AREA

CC_STAT_AREA: number

Const CC_STAT_HEIGHT

CC_STAT_HEIGHT: number

Const CC_STAT_LEFT

CC_STAT_LEFT: number

Const CC_STAT_MAX

CC_STAT_MAX: number

Const CC_STAT_TOP

CC_STAT_TOP: number

Const CC_STAT_WIDTH

CC_STAT_WIDTH: number

Const CHAIN_APPROX_NONE

CHAIN_APPROX_NONE: number

Const CHAIN_APPROX_SIMPLE

CHAIN_APPROX_SIMPLE: number

Const CHAIN_APPROX_TC89_KCOS

CHAIN_APPROX_TC89_KCOS: number

Const CHAIN_APPROX_TC89_L1

CHAIN_APPROX_TC89_L1: number

Const COLORMAP_AUTUMN

COLORMAP_AUTUMN: number

Const COLORMAP_BONE

COLORMAP_BONE: number

Const COLORMAP_COOL

COLORMAP_COOL: number

Const COLORMAP_HOT

COLORMAP_HOT: number

Const COLORMAP_HSV

COLORMAP_HSV: number

Const COLORMAP_JET

COLORMAP_JET: number

Const COLORMAP_OCEAN

COLORMAP_OCEAN: number

Const COLORMAP_PARULA

COLORMAP_PARULA: number

Const COLORMAP_PINK

COLORMAP_PINK: number

Const COLORMAP_RAINBOW

COLORMAP_RAINBOW: number

Const COLORMAP_SPRING

COLORMAP_SPRING: number

Const COLORMAP_SUMMER

COLORMAP_SUMMER: number

Const COLORMAP_WINTER

COLORMAP_WINTER: number

Const COLOR_BGR2BGR555

COLOR_BGR2BGR555: number

Const COLOR_BGR2BGR565

COLOR_BGR2BGR565: number

Const COLOR_BGR2BGRA

COLOR_BGR2BGRA: number

Const COLOR_BGR2GRAY

COLOR_BGR2GRAY: number

Const COLOR_BGR2HLS

COLOR_BGR2HLS: number

Const COLOR_BGR2HLS_FULL

COLOR_BGR2HLS_FULL: number

Const COLOR_BGR2HSV

COLOR_BGR2HSV: number

Const COLOR_BGR2HSV_FULL

COLOR_BGR2HSV_FULL: number

Const COLOR_BGR2Lab

COLOR_BGR2Lab: number

Const COLOR_BGR2Luv

COLOR_BGR2Luv: number

Const COLOR_BGR2RGB

COLOR_BGR2RGB: number

Const COLOR_BGR2RGBA

COLOR_BGR2RGBA: number

Const COLOR_BGR2XYZ

COLOR_BGR2XYZ: number

Const COLOR_BGR2YCrCb

COLOR_BGR2YCrCb: number

Const COLOR_BGR2YUV

COLOR_BGR2YUV: number

Const COLOR_BGR2YUV_I420

COLOR_BGR2YUV_I420: number

Const COLOR_BGR2YUV_IYUV

COLOR_BGR2YUV_IYUV: number

Const COLOR_BGR2YUV_YV12

COLOR_BGR2YUV_YV12: number

Const COLOR_BGR5552BGR

COLOR_BGR5552BGR: number

Const COLOR_BGR5552BGRA

COLOR_BGR5552BGRA: number

Const COLOR_BGR5552GRAY

COLOR_BGR5552GRAY: number

Const COLOR_BGR5552RGB

COLOR_BGR5552RGB: number

Const COLOR_BGR5552RGBA

COLOR_BGR5552RGBA: number

Const COLOR_BGR5652BGR

COLOR_BGR5652BGR: number

Const COLOR_BGR5652BGRA

COLOR_BGR5652BGRA: number

Const COLOR_BGR5652GRAY

COLOR_BGR5652GRAY: number

Const COLOR_BGR5652RGB

COLOR_BGR5652RGB: number

Const COLOR_BGR5652RGBA

COLOR_BGR5652RGBA: number

Const COLOR_BGRA2BGR

COLOR_BGRA2BGR: number

Const COLOR_BGRA2BGR555

COLOR_BGRA2BGR555: number

Const COLOR_BGRA2BGR565

COLOR_BGRA2BGR565: number

Const COLOR_BGRA2GRAY

COLOR_BGRA2GRAY: number

Const COLOR_BGRA2RGB

COLOR_BGRA2RGB: number

Const COLOR_BGRA2RGBA

COLOR_BGRA2RGBA: number

Const COLOR_BGRA2YUV_I420

COLOR_BGRA2YUV_I420: number

Const COLOR_BGRA2YUV_IYUV

COLOR_BGRA2YUV_IYUV: number

Const COLOR_BGRA2YUV_YV12

COLOR_BGRA2YUV_YV12: number

Const COLOR_BayerBG2BGR

COLOR_BayerBG2BGR: number

Const COLOR_BayerBG2BGR_EA

COLOR_BayerBG2BGR_EA: number

Const COLOR_BayerBG2BGR_VNG

COLOR_BayerBG2BGR_VNG: number

Const COLOR_BayerBG2GRAY

COLOR_BayerBG2GRAY: number

Const COLOR_BayerBG2RGB

COLOR_BayerBG2RGB: number

Const COLOR_BayerBG2RGB_EA

COLOR_BayerBG2RGB_EA: number

Const COLOR_BayerBG2RGB_VNG

COLOR_BayerBG2RGB_VNG: number

Const COLOR_BayerGB2BGR

COLOR_BayerGB2BGR: number

Const COLOR_BayerGB2BGR_EA

COLOR_BayerGB2BGR_EA: number

Const COLOR_BayerGB2BGR_VNG

COLOR_BayerGB2BGR_VNG: number

Const COLOR_BayerGB2GRAY

COLOR_BayerGB2GRAY: number

Const COLOR_BayerGB2RGB

COLOR_BayerGB2RGB: number

Const COLOR_BayerGB2RGB_EA

COLOR_BayerGB2RGB_EA: number

Const COLOR_BayerGB2RGB_VNG

COLOR_BayerGB2RGB_VNG: number

Const COLOR_BayerGR2BGR

COLOR_BayerGR2BGR: number

Const COLOR_BayerGR2BGR_EA

COLOR_BayerGR2BGR_EA: number

Const COLOR_BayerGR2BGR_VNG

COLOR_BayerGR2BGR_VNG: number

Const COLOR_BayerGR2GRAY

COLOR_BayerGR2GRAY: number

Const COLOR_BayerGR2RGB

COLOR_BayerGR2RGB: number

Const COLOR_BayerGR2RGB_EA

COLOR_BayerGR2RGB_EA: number

Const COLOR_BayerGR2RGB_VNG

COLOR_BayerGR2RGB_VNG: number

Const COLOR_BayerRG2BGR

COLOR_BayerRG2BGR: number

Const COLOR_BayerRG2BGR_EA

COLOR_BayerRG2BGR_EA: number

Const COLOR_BayerRG2BGR_VNG

COLOR_BayerRG2BGR_VNG: number

Const COLOR_BayerRG2GRAY

COLOR_BayerRG2GRAY: number

Const COLOR_BayerRG2RGB

COLOR_BayerRG2RGB: number

Const COLOR_BayerRG2RGB_EA

COLOR_BayerRG2RGB_EA: number

Const COLOR_BayerRG2RGB_VNG

COLOR_BayerRG2RGB_VNG: number

Const COLOR_COLORCVT_MAX

COLOR_COLORCVT_MAX: number

Const COLOR_GRAY2BGR

COLOR_GRAY2BGR: number

Const COLOR_GRAY2BGR555

COLOR_GRAY2BGR555: number

Const COLOR_GRAY2BGR565

COLOR_GRAY2BGR565: number

Const COLOR_GRAY2BGRA

COLOR_GRAY2BGRA: number

Const COLOR_GRAY2RGB

COLOR_GRAY2RGB: number

Const COLOR_GRAY2RGBA

COLOR_GRAY2RGBA: number

Const COLOR_HLS2BGR

COLOR_HLS2BGR: number

Const COLOR_HLS2BGR_FULL

COLOR_HLS2BGR_FULL: number

Const COLOR_HLS2RGB

COLOR_HLS2RGB: number

Const COLOR_HLS2RGB_FULL

COLOR_HLS2RGB_FULL: number

Const COLOR_HSV2BGR

COLOR_HSV2BGR: number

Const COLOR_HSV2BGR_FULL

COLOR_HSV2BGR_FULL: number

Const COLOR_HSV2RGB

COLOR_HSV2RGB: number

Const COLOR_HSV2RGB_FULL

COLOR_HSV2RGB_FULL: number

Const COLOR_LBGR2Lab

COLOR_LBGR2Lab: number

Const COLOR_LBGR2Luv

COLOR_LBGR2Luv: number

Const COLOR_LRGB2Lab

COLOR_LRGB2Lab: number

Const COLOR_LRGB2Luv

COLOR_LRGB2Luv: number

Const COLOR_Lab2BGR

COLOR_Lab2BGR: number

Const COLOR_Lab2LBGR

COLOR_Lab2LBGR: number

Const COLOR_Lab2LRGB

COLOR_Lab2LRGB: number

Const COLOR_Lab2RGB

COLOR_Lab2RGB: number

Const COLOR_Luv2BGR

COLOR_Luv2BGR: number

Const COLOR_Luv2LBGR

COLOR_Luv2LBGR: number

Const COLOR_Luv2LRGB

COLOR_Luv2LRGB: number

Const COLOR_Luv2RGB

COLOR_Luv2RGB: number

Const COLOR_RGB2BGR

COLOR_RGB2BGR: number

Const COLOR_RGB2BGR555

COLOR_RGB2BGR555: number

Const COLOR_RGB2BGR565

COLOR_RGB2BGR565: number

Const COLOR_RGB2BGRA

COLOR_RGB2BGRA: number

Const COLOR_RGB2GRAY

COLOR_RGB2GRAY: number

Const COLOR_RGB2HLS

COLOR_RGB2HLS: number

Const COLOR_RGB2HLS_FULL

COLOR_RGB2HLS_FULL: number

Const COLOR_RGB2HSV

COLOR_RGB2HSV: number

Const COLOR_RGB2HSV_FULL

COLOR_RGB2HSV_FULL: number

Const COLOR_RGB2Lab

COLOR_RGB2Lab: number

Const COLOR_RGB2Luv

COLOR_RGB2Luv: number

Const COLOR_RGB2RGBA

COLOR_RGB2RGBA: number

Const COLOR_RGB2XYZ

COLOR_RGB2XYZ: number

Const COLOR_RGB2YCrCb

COLOR_RGB2YCrCb: number

Const COLOR_RGB2YUV

COLOR_RGB2YUV: number

Const COLOR_RGB2YUV_I420

COLOR_RGB2YUV_I420: number

Const COLOR_RGB2YUV_IYUV

COLOR_RGB2YUV_IYUV: number

Const COLOR_RGB2YUV_YV12

COLOR_RGB2YUV_YV12: number

Const COLOR_RGBA2BGR

COLOR_RGBA2BGR: number

Const COLOR_RGBA2BGR555

COLOR_RGBA2BGR555: number

Const COLOR_RGBA2BGR565

COLOR_RGBA2BGR565: number

Const COLOR_RGBA2BGRA

COLOR_RGBA2BGRA: number

Const COLOR_RGBA2GRAY

COLOR_RGBA2GRAY: number

Const COLOR_RGBA2RGB

COLOR_RGBA2RGB: number

Const COLOR_RGBA2YUV_I420

COLOR_RGBA2YUV_I420: number

Const COLOR_RGBA2YUV_IYUV

COLOR_RGBA2YUV_IYUV: number

Const COLOR_RGBA2YUV_YV12

COLOR_RGBA2YUV_YV12: number

Const COLOR_RGBA2mRGBA

COLOR_RGBA2mRGBA: number

Const COLOR_XYZ2BGR

COLOR_XYZ2BGR: number

Const COLOR_XYZ2RGB

COLOR_XYZ2RGB: number

Const COLOR_YCrCb2BGR

COLOR_YCrCb2BGR: number

Const COLOR_YCrCb2RGB

COLOR_YCrCb2RGB: number

Const COLOR_YUV2BGR

COLOR_YUV2BGR: number

Const COLOR_YUV2BGRA_I420

COLOR_YUV2BGRA_I420: number

Const COLOR_YUV2BGRA_IYUV

COLOR_YUV2BGRA_IYUV: number

Const COLOR_YUV2BGRA_NV12

COLOR_YUV2BGRA_NV12: number

Const COLOR_YUV2BGRA_NV21

COLOR_YUV2BGRA_NV21: number

Const COLOR_YUV2BGRA_UYNV

COLOR_YUV2BGRA_UYNV: number

Const COLOR_YUV2BGRA_UYVY

COLOR_YUV2BGRA_UYVY: number

Const COLOR_YUV2BGRA_Y422

COLOR_YUV2BGRA_Y422: number

Const COLOR_YUV2BGRA_YUNV

COLOR_YUV2BGRA_YUNV: number

Const COLOR_YUV2BGRA_YUY2

COLOR_YUV2BGRA_YUY2: number

Const COLOR_YUV2BGRA_YUYV

COLOR_YUV2BGRA_YUYV: number

Const COLOR_YUV2BGRA_YV12

COLOR_YUV2BGRA_YV12: number

Const COLOR_YUV2BGRA_YVYU

COLOR_YUV2BGRA_YVYU: number

Const COLOR_YUV2BGR_I420

COLOR_YUV2BGR_I420: number

Const COLOR_YUV2BGR_IYUV

COLOR_YUV2BGR_IYUV: number

Const COLOR_YUV2BGR_NV12

COLOR_YUV2BGR_NV12: number

Const COLOR_YUV2BGR_NV21

COLOR_YUV2BGR_NV21: number

Const COLOR_YUV2BGR_UYNV

COLOR_YUV2BGR_UYNV: number

Const COLOR_YUV2BGR_UYVY

COLOR_YUV2BGR_UYVY: number

Const COLOR_YUV2BGR_Y422

COLOR_YUV2BGR_Y422: number

Const COLOR_YUV2BGR_YUNV

COLOR_YUV2BGR_YUNV: number

Const COLOR_YUV2BGR_YUY2

COLOR_YUV2BGR_YUY2: number

Const COLOR_YUV2BGR_YUYV

COLOR_YUV2BGR_YUYV: number

Const COLOR_YUV2BGR_YV12

COLOR_YUV2BGR_YV12: number

Const COLOR_YUV2BGR_YVYU

COLOR_YUV2BGR_YVYU: number

Const COLOR_YUV2GRAY_420

COLOR_YUV2GRAY_420: number

Const COLOR_YUV2GRAY_I420

COLOR_YUV2GRAY_I420: number

Const COLOR_YUV2GRAY_IYUV

COLOR_YUV2GRAY_IYUV: number

Const COLOR_YUV2GRAY_NV12

COLOR_YUV2GRAY_NV12: number

Const COLOR_YUV2GRAY_NV21

COLOR_YUV2GRAY_NV21: number

Const COLOR_YUV2GRAY_UYNV

COLOR_YUV2GRAY_UYNV: number

Const COLOR_YUV2GRAY_UYVY

COLOR_YUV2GRAY_UYVY: number

Const COLOR_YUV2GRAY_Y422

COLOR_YUV2GRAY_Y422: number

Const COLOR_YUV2GRAY_YUNV

COLOR_YUV2GRAY_YUNV: number

Const COLOR_YUV2GRAY_YUY2

COLOR_YUV2GRAY_YUY2: number

Const COLOR_YUV2GRAY_YUYV

COLOR_YUV2GRAY_YUYV: number

Const COLOR_YUV2GRAY_YV12

COLOR_YUV2GRAY_YV12: number

Const COLOR_YUV2GRAY_YVYU

COLOR_YUV2GRAY_YVYU: number

Const COLOR_YUV2RGB

COLOR_YUV2RGB: number

Const COLOR_YUV2RGBA_I420

COLOR_YUV2RGBA_I420: number

Const COLOR_YUV2RGBA_IYUV

COLOR_YUV2RGBA_IYUV: number

Const COLOR_YUV2RGBA_NV12

COLOR_YUV2RGBA_NV12: number

Const COLOR_YUV2RGBA_NV21

COLOR_YUV2RGBA_NV21: number

Const COLOR_YUV2RGBA_UYNV

COLOR_YUV2RGBA_UYNV: number

Const COLOR_YUV2RGBA_UYVY

COLOR_YUV2RGBA_UYVY: number

Const COLOR_YUV2RGBA_Y422

COLOR_YUV2RGBA_Y422: number

Const COLOR_YUV2RGBA_YUNV

COLOR_YUV2RGBA_YUNV: number

Const COLOR_YUV2RGBA_YUY2

COLOR_YUV2RGBA_YUY2: number

Const COLOR_YUV2RGBA_YUYV

COLOR_YUV2RGBA_YUYV: number

Const COLOR_YUV2RGBA_YV12

COLOR_YUV2RGBA_YV12: number

Const COLOR_YUV2RGBA_YVYU

COLOR_YUV2RGBA_YVYU: number

Const COLOR_YUV2RGB_I420

COLOR_YUV2RGB_I420: number

Const COLOR_YUV2RGB_IYUV

COLOR_YUV2RGB_IYUV: number

Const COLOR_YUV2RGB_NV12

COLOR_YUV2RGB_NV12: number

Const COLOR_YUV2RGB_NV21

COLOR_YUV2RGB_NV21: number

Const COLOR_YUV2RGB_UYNV

COLOR_YUV2RGB_UYNV: number

Const COLOR_YUV2RGB_UYVY

COLOR_YUV2RGB_UYVY: number

Const COLOR_YUV2RGB_Y422

COLOR_YUV2RGB_Y422: number

Const COLOR_YUV2RGB_YUNV

COLOR_YUV2RGB_YUNV: number

Const COLOR_YUV2RGB_YUY2

COLOR_YUV2RGB_YUY2: number

Const COLOR_YUV2RGB_YUYV

COLOR_YUV2RGB_YUYV: number

Const COLOR_YUV2RGB_YV12

COLOR_YUV2RGB_YV12: number

Const COLOR_YUV2RGB_YVYU

COLOR_YUV2RGB_YVYU: number

Const COLOR_YUV420p2BGR

COLOR_YUV420p2BGR: number

Const COLOR_YUV420p2BGRA

COLOR_YUV420p2BGRA: number

Const COLOR_YUV420p2GRAY

COLOR_YUV420p2GRAY: number

Const COLOR_YUV420p2RGB

COLOR_YUV420p2RGB: number

Const COLOR_YUV420p2RGBA

COLOR_YUV420p2RGBA: number

Const COLOR_YUV420sp2BGR

COLOR_YUV420sp2BGR: number

Const COLOR_YUV420sp2BGRA

COLOR_YUV420sp2BGRA: number

Const COLOR_YUV420sp2GRAY

COLOR_YUV420sp2GRAY: number

Const COLOR_YUV420sp2RGB

COLOR_YUV420sp2RGB: number

Const COLOR_YUV420sp2RGBA

COLOR_YUV420sp2RGBA: number

Const COLOR_mRGBA2RGBA

COLOR_mRGBA2RGBA: number

Const CV_16S

CV_16S: number

Const CV_16SC1

CV_16SC1: number

Const CV_16SC2

CV_16SC2: number

Const CV_16SC3

CV_16SC3: number

Const CV_16SC4

CV_16SC4: number

Const CV_16U

CV_16U: number

Const CV_16UC1

CV_16UC1: number

Const CV_16UC2

CV_16UC2: number

Const CV_16UC3

CV_16UC3: number

Const CV_16UC4

CV_16UC4: number

Const CV_32F

CV_32F: number

Const CV_32FC1

CV_32FC1: number

Const CV_32FC2

CV_32FC2: number

Const CV_32FC3

CV_32FC3: number

Const CV_32FC4

CV_32FC4: number

Const CV_32S

CV_32S: number

Const CV_32SC1

CV_32SC1: number

Const CV_32SC2

CV_32SC2: number

Const CV_32SC3

CV_32SC3: number

Const CV_32SC4

CV_32SC4: number

Const CV_64F

CV_64F: number

Const CV_64FC1

CV_64FC1: number

Const CV_64FC2

CV_64FC2: number

Const CV_64FC3

CV_64FC3: number

Const CV_64FC4

CV_64FC4: number

Const CV_8S

CV_8S: number

Const CV_8SC1

CV_8SC1: number

Const CV_8SC2

CV_8SC2: number

Const CV_8SC3

CV_8SC3: number

Const CV_8SC4

CV_8SC4: number

Const CV_8U

CV_8U: number

Const CV_8UC1

CV_8UC1: number

Const CV_8UC2

CV_8UC2: number

Const CV_8UC3

CV_8UC3: number

Const CV_8UC4

CV_8UC4: number

Const CV_CONTOURS_MATCH_I1

CV_CONTOURS_MATCH_I1: number

Const CV_CONTOURS_MATCH_I2

CV_CONTOURS_MATCH_I2: number

Const CV_CONTOURS_MATCH_I3

CV_CONTOURS_MATCH_I3: number

Const DCT_INVERSE

DCT_INVERSE: number

Const DCT_ROWS

DCT_ROWS: number

Const DFT_COMPLEX_OUTPUT

DFT_COMPLEX_OUTPUT: number

Const DFT_INVERSE

DFT_INVERSE: number

Const DFT_REAL_OUTPUT

DFT_REAL_OUTPUT: number

Const DFT_ROWS

DFT_ROWS: number

Const DFT_SCALE

DFT_SCALE: number

Const DIST_C

DIST_C: number

Const DIST_FAIR

DIST_FAIR: number

Const DIST_HUBER

DIST_HUBER: number

Const DIST_L1

DIST_L1: number

Const DIST_L12

DIST_L12: number

Const DIST_L2

DIST_L2: number

Const DIST_LABEL_CCOMP

DIST_LABEL_CCOMP: number

Const DIST_LABEL_PIXEL

DIST_LABEL_PIXEL: number

Const DIST_MASK_3

DIST_MASK_3: number

Const DIST_MASK_5

DIST_MASK_5: number

Const DIST_MASK_PRECISE

DIST_MASK_PRECISE: number

Const DIST_USER

DIST_USER: number

Const DIST_WELSCH

DIST_WELSCH: number

Const FILLED

FILLED: number

Const FLOODFILL_FIXED_RANGE

FLOODFILL_FIXED_RANGE: number

Const FLOODFILL_MASK_ONLY

FLOODFILL_MASK_ONLY: number

Const FM_7POINT

FM_7POINT: number

Const FM_8POINT

FM_8POINT: number

Const FM_LMEDS

FM_LMEDS: number

Const FM_RANSAC

FM_RANSAC: number

Const FONT_HERSHEY_COMPLEX

FONT_HERSHEY_COMPLEX: number

Const FONT_HERSHEY_COMPLEX_SMALL

FONT_HERSHEY_COMPLEX_SMALL: number

Const FONT_HERSHEY_DUPLEX

FONT_HERSHEY_DUPLEX: number

Const FONT_HERSHEY_PLAIN

FONT_HERSHEY_PLAIN: number

Const FONT_HERSHEY_SCRIPT_COMPLEX

FONT_HERSHEY_SCRIPT_COMPLEX: number

Const FONT_HERSHEY_SCRIPT_SIMPLEX

FONT_HERSHEY_SCRIPT_SIMPLEX: number

Const FONT_HERSHEY_SIMPLEX

FONT_HERSHEY_SIMPLEX: number

Const FONT_HERSHEY_TRIPLEX

FONT_HERSHEY_TRIPLEX: number

Const FONT_ITALIC

FONT_ITALIC: number

Const GC_BGD

GC_BGD: number

Const GC_EVAL

GC_EVAL: number

Const GC_FGD

GC_FGD: number

Const GC_INIT_WITH_MASK

GC_INIT_WITH_MASK: number

Const GC_INIT_WITH_RECT

GC_INIT_WITH_RECT: number

Const GC_PR_BGD

GC_PR_BGD: number

Const GC_PR_FGD

GC_PR_FGD: number

Const HAAR_EYE

HAAR_EYE: string

Const HAAR_EYE_TREE_EYEGLASSES

HAAR_EYE_TREE_EYEGLASSES: string

Const HAAR_FRONTALCATFACE

HAAR_FRONTALCATFACE: string

Const HAAR_FRONTALCATFACE_EXTENDED

HAAR_FRONTALCATFACE_EXTENDED: string

Const HAAR_FRONTALFACE_ALT

HAAR_FRONTALFACE_ALT: string

Const HAAR_FRONTALFACE_ALT2

HAAR_FRONTALFACE_ALT2: string

Const HAAR_FRONTALFACE_ALT_TREE

HAAR_FRONTALFACE_ALT_TREE: string

Const HAAR_FRONTALFACE_DEFAULT

HAAR_FRONTALFACE_DEFAULT: string

Const HAAR_FULLBODY

HAAR_FULLBODY: string

Const HAAR_LEFTEYE_2SPLITS

HAAR_LEFTEYE_2SPLITS: string

Const HAAR_LICENCE_PLATE_RUS_16STAGES

HAAR_LICENCE_PLATE_RUS_16STAGES: string

Const HAAR_LOWERBODY

HAAR_LOWERBODY: string

Const HAAR_PROFILEFACE

HAAR_PROFILEFACE: string

Const HAAR_RIGHTEYE_2SPLITS

HAAR_RIGHTEYE_2SPLITS: string

Const HAAR_RUSSIAN_PLATE_NUMBER

HAAR_RUSSIAN_PLATE_NUMBER: string

Const HAAR_SMILE

HAAR_SMILE: string

Const HAAR_UPPERBODY

HAAR_UPPERBODY: string

Const HISTCMP_BHATTACHARYYA

HISTCMP_BHATTACHARYYA: number

Const HISTCMP_CHISQR

HISTCMP_CHISQR: number

Const HISTCMP_CHISQR_ALT

HISTCMP_CHISQR_ALT: number

Const HISTCMP_CORREL

HISTCMP_CORREL: number

Const HISTCMP_HELLINGER

HISTCMP_HELLINGER: number

Const HISTCMP_INTERSECT

HISTCMP_INTERSECT: number

Const HISTCMP_KL_DIV

HISTCMP_KL_DIV: number

Const HOUGH_GRADIENT

HOUGH_GRADIENT: number

Const HOUGH_MULTI_SCALE

HOUGH_MULTI_SCALE: number

Const HOUGH_PROBABILISTIC

HOUGH_PROBABILISTIC: number

Const HOUGH_STANDARD

HOUGH_STANDARD: number

Const IMREAD_ANYCOLOR

IMREAD_ANYCOLOR: number

Const IMREAD_ANYDEPTH

IMREAD_ANYDEPTH: number

Const IMREAD_COLOR

IMREAD_COLOR: number

Const IMREAD_GRAYSCALE

IMREAD_GRAYSCALE: number

Const IMREAD_IGNORE_ORIENTATION

IMREAD_IGNORE_ORIENTATION: number

Const IMREAD_LOAD_GDAL

IMREAD_LOAD_GDAL: number

Const IMREAD_REDUCED_COLOR_2

IMREAD_REDUCED_COLOR_2: number

Const IMREAD_REDUCED_COLOR_4

IMREAD_REDUCED_COLOR_4: number

Const IMREAD_REDUCED_COLOR_8

IMREAD_REDUCED_COLOR_8: number

Const IMREAD_REDUCED_GRAYSCALE_2

IMREAD_REDUCED_GRAYSCALE_2: number

Const IMREAD_REDUCED_GRAYSCALE_4

IMREAD_REDUCED_GRAYSCALE_4: number

Const IMREAD_REDUCED_GRAYSCALE_8

IMREAD_REDUCED_GRAYSCALE_8: number

Const IMREAD_UNCHANGED

IMREAD_UNCHANGED: number

Const IMWRITE_JPEG_CHROMA_QUALITY

IMWRITE_JPEG_CHROMA_QUALITY: number

Const IMWRITE_JPEG_LUMA_QUALITY

IMWRITE_JPEG_LUMA_QUALITY: number

Const IMWRITE_JPEG_OPTIMIZE

IMWRITE_JPEG_OPTIMIZE: number

Const IMWRITE_JPEG_PROGRESSIVE

IMWRITE_JPEG_PROGRESSIVE: number

Const IMWRITE_JPEG_QUALITY

IMWRITE_JPEG_QUALITY: number

Const IMWRITE_JPEG_RST_INTERVAL

IMWRITE_JPEG_RST_INTERVAL: number

Const IMWRITE_PAM_FORMAT_BLACKANDWHITE

IMWRITE_PAM_FORMAT_BLACKANDWHITE: number

Const IMWRITE_PAM_FORMAT_GRAYSCALE

IMWRITE_PAM_FORMAT_GRAYSCALE: number

Const IMWRITE_PAM_FORMAT_GRAYSCALE_ALPHA

IMWRITE_PAM_FORMAT_GRAYSCALE_ALPHA: number

Const IMWRITE_PAM_FORMAT_NULL

IMWRITE_PAM_FORMAT_NULL: number

Const IMWRITE_PAM_FORMAT_RGB

IMWRITE_PAM_FORMAT_RGB: number

Const IMWRITE_PAM_FORMAT_RGB_ALPHA

IMWRITE_PAM_FORMAT_RGB_ALPHA: number

Const IMWRITE_PAM_TUPLETYPE

IMWRITE_PAM_TUPLETYPE: number

Const IMWRITE_PNG_BILEVEL

IMWRITE_PNG_BILEVEL: number

Const IMWRITE_PNG_COMPRESSION

IMWRITE_PNG_COMPRESSION: number

Const IMWRITE_PNG_STRATEGY

IMWRITE_PNG_STRATEGY: number

Const IMWRITE_PNG_STRATEGY_DEFAULT

IMWRITE_PNG_STRATEGY_DEFAULT: number

Const IMWRITE_PNG_STRATEGY_FILTERED

IMWRITE_PNG_STRATEGY_FILTERED: number

Const IMWRITE_PNG_STRATEGY_FIXED

IMWRITE_PNG_STRATEGY_FIXED: number

Const IMWRITE_PNG_STRATEGY_HUFFMAN_ONLY

IMWRITE_PNG_STRATEGY_HUFFMAN_ONLY: number

Const IMWRITE_PNG_STRATEGY_RLE

IMWRITE_PNG_STRATEGY_RLE: number

Const IMWRITE_PXM_BINARY

IMWRITE_PXM_BINARY: number

Const IMWRITE_WEBP_QUALITY

IMWRITE_WEBP_QUALITY: number

Const INPAINT_NS

INPAINT_NS: number

Const INPAINT_TELEA

INPAINT_TELEA: number

Const INTER_AREA

INTER_AREA: number

Const INTER_CUBIC

INTER_CUBIC: number

Const INTER_LANCZOS4

INTER_LANCZOS4: number

Const INTER_LINEAR

INTER_LINEAR: number

Const INTER_MAX

INTER_MAX: number

Const INTER_NEAREST

INTER_NEAREST: number

Const KMEANS_PP_CENTERS

KMEANS_PP_CENTERS: number

Const KMEANS_RANDOM_CENTERS

KMEANS_RANDOM_CENTERS: number

Const KMEANS_USE_INITIAL_LABELS

KMEANS_USE_INITIAL_LABELS: number

Const LBP_FRONTALCATFACE

LBP_FRONTALCATFACE: string

Const LBP_FRONTALFACE

LBP_FRONTALFACE: string

Const LBP_FRONTALFACE_IMPROVED

LBP_FRONTALFACE_IMPROVED: string

Const LBP_PROFILEFACE

LBP_PROFILEFACE: string

Const LBP_SILVERWARE

LBP_SILVERWARE: string

Const LINE_4

LINE_4: number

Const LINE_8

LINE_8: number

Const LINE_AA

LINE_AA: number

Const LMEDS

LMEDS: number

Const MIXED_CLONE

MIXED_CLONE: number

Const MONOCHROME_TRANSFER

MONOCHROME_TRANSFER: number

Const MORPH_BLACKHAT

MORPH_BLACKHAT: number

Const MORPH_CLOSE

MORPH_CLOSE: number

Const MORPH_CROSS

MORPH_CROSS: number

Const MORPH_DILATE

MORPH_DILATE: number

Const MORPH_ELLIPSE

MORPH_ELLIPSE: number

Const MORPH_ERODE

MORPH_ERODE: number

Const MORPH_GRADIENT

MORPH_GRADIENT: number

Const MORPH_HITMISS

MORPH_HITMISS: number

Const MORPH_OPEN

MORPH_OPEN: number

Const MORPH_RECT

MORPH_RECT: number

Const MORPH_TOPHAT

MORPH_TOPHAT: number

Const NORMAL_CLONE

NORMAL_CLONE: number

Const NORM_HAMMING

NORM_HAMMING: number

Const NORM_HAMMING2

NORM_HAMMING2: number

Const NORM_INF

NORM_INF: number

Const NORM_L1

NORM_L1: number

Const NORM_L2

NORM_L2: number

Const NORM_L2SQR

NORM_L2SQR: number

Const NORM_MINMAX

NORM_MINMAX: number

Const NORM_RELATIVE

NORM_RELATIVE: number

Const NORM_const_MASK

NORM_const_MASK: number

Const RANSAC

RANSAC: number

Const REGULAR

REGULAR: number

Const RETR_CCOMP

RETR_CCOMP: number

Const RETR_EXTERNAL

RETR_EXTERNAL: number

Const RETR_FLOODFILL

RETR_FLOODFILL: number

Const RETR_LIST

RETR_LIST: number

Const RETR_TREE

RETR_TREE: number

Const RHO

RHO: number

Const ROTATE_180

ROTATE_180: number

Const ROTATE_90_CLOCKWISE

ROTATE_90_CLOCKWISE: number

Const ROTATE_90_COUNTERCLOCKWISE

ROTATE_90_COUNTERCLOCKWISE: number

Const SOLVEPNP_AP3P

SOLVEPNP_AP3P: number

Const SOLVEPNP_DLS

SOLVEPNP_DLS: number

Const SOLVEPNP_EPNP

SOLVEPNP_EPNP: number

Const SOLVEPNP_ITERATIVE

SOLVEPNP_ITERATIVE: number

Const SOLVEPNP_MAX_COUNT

SOLVEPNP_MAX_COUNT: number

Const SOLVEPNP_P3P

SOLVEPNP_P3P: number

Const SOLVEPNP_UPNP

SOLVEPNP_UPNP: number

Const THRESH_BINARY

THRESH_BINARY: number

Const THRESH_BINARY_INV

THRESH_BINARY_INV: number

Const THRESH_MASK

THRESH_MASK: number

Const THRESH_OTSU

THRESH_OTSU: number

Const THRESH_TOZERO

THRESH_TOZERO: number

Const THRESH_TOZERO_INV

THRESH_TOZERO_INV: number

Const THRESH_TRIANGLE

THRESH_TRIANGLE: number

Const THRESH_TRUNC

THRESH_TRUNC: number

Const TM_CCOEFF

TM_CCOEFF: number

Const TM_CCOEFF_NORMED

TM_CCOEFF_NORMED: number

Const TM_CCORR

TM_CCORR: number

Const TM_CCORR_NORMED

TM_CCORR_NORMED: number

Const TM_SQDIFF

TM_SQDIFF: number

Const TM_SQDIFF_NORMED

TM_SQDIFF_NORMED: number

Const VIDEOWRITER_PROP_FRAMEBYTES

VIDEOWRITER_PROP_FRAMEBYTES: number

Const VIDEOWRITER_PROP_NSTRIPES

VIDEOWRITER_PROP_NSTRIPES: number

Const VIDEOWRITER_PROP_QUALITY

VIDEOWRITER_PROP_QUALITY: number

Const WARP_FILL_OUTLIERS

WARP_FILL_OUTLIERS: number

Const WARP_INVERSE_MAP

WARP_INVERSE_MAP: number

Const ml

ml: { COL_SAMPLE: number; ROW_SAMPLE: number; SVM: { C: number; CHI2: number; COEF: number; CUSTOM: number; DEGREE: number; GAMMA: number; INTER: number; LINEAR: number; NU: number; P: number; POLY: number; RBF: number; SIGMOID: number }; VAR_CATEGORICAL: number; VAR_NUMERICAL: number; VAR_ORDERED: number }

Type declaration

  • COL_SAMPLE: number
  • ROW_SAMPLE: number
  • SVM: { C: number; CHI2: number; COEF: number; CUSTOM: number; DEGREE: number; GAMMA: number; INTER: number; LINEAR: number; NU: number; P: number; POLY: number; RBF: number; SIGMOID: number }
    • C: number
    • CHI2: number
    • COEF: number
    • CUSTOM: number
    • DEGREE: number
    • GAMMA: number
    • INTER: number
    • LINEAR: number
    • NU: number
    • P: number
    • POLY: number
    • RBF: number
    • SIGMOID: number
  • VAR_CATEGORICAL: number
  • VAR_NUMERICAL: number
  • VAR_ORDERED: number

Const statModel

statModel: { COMPRESSED_INPUT: number; PREPROCESSED_INPUT: number; RAW_OUTPUT: number; UPDATE_MODEL: number }

Type declaration

  • COMPRESSED_INPUT: number
  • PREPROCESSED_INPUT: number
  • RAW_OUTPUT: number
  • UPDATE_MODEL: number

Const termCriteria

termCriteria: { COUNT: number; EPS: number; MAX_ITER: number }

Type declaration

  • COUNT: number
  • EPS: number
  • MAX_ITER: number

Const version

version: { major: number; minor: number }

Type declaration

  • major: number
  • minor: number

Const xmodules

xmodules: { dnn: boolean; face: boolean; text: boolean; tracking: boolean; xfeatures2d: boolean; ximgproc: boolean }

Type declaration

  • dnn: boolean
  • face: boolean
  • text: boolean
  • tracking: boolean
  • xfeatures2d: boolean
  • ximgproc: boolean

Functions

NMSBoxes

  • NMSBoxes(bboxes: Rect[], scores: number[], scoreThreshold: number, nmsThreshold: number): number[]
  • Parameters

    • bboxes: Rect[]
    • scores: number[]
    • scoreThreshold: number
    • nmsThreshold: number

    Returns number[]

accumulate

  • accumulate(src: Mat, dst: Mat, mask?: Mat): void
  • Parameters

    Returns void

accumulateAsync

  • accumulateAsync(src: Mat, dst: Mat, mask?: Mat): Promise<void>
  • Parameters

    Returns Promise<void>

accumulateProduct

  • accumulateProduct(src1: Mat, src2: Mat, dst: Mat, mask?: Mat): void
  • Parameters

    Returns void

accumulateProductAsync

  • accumulateProductAsync(src1: Mat, src2: Mat, dst: Mat, mask?: Mat): Promise<void>
  • Parameters

    Returns Promise<void>

accumulateSquare

  • accumulateSquare(src: Mat, dst: Mat, mask?: Mat): void
  • Parameters

    Returns void

accumulateSquareAsync

  • accumulateSquareAsync(src: Mat, dst: Mat, mask?: Mat): Promise<void>
  • Parameters

    Returns Promise<void>

accumulateWeighted

  • accumulateWeighted(src: Mat, dst: Mat, alpha: number, mask?: Mat): void
  • Parameters

    • src: Mat
    • dst: Mat
    • alpha: number
    • Optional mask: Mat

    Returns void

accumulateWeightedAsync

  • accumulateWeightedAsync(src: Mat, dst: Mat, alpha: number, mask?: Mat): Promise<void>
  • Parameters

    • src: Mat
    • dst: Mat
    • alpha: number
    • Optional mask: Mat

    Returns Promise<void>

addWeighted

  • addWeighted(mat: Mat, alpha: number, mat2: Mat, beta: number, gamma: number, dtype?: number): Mat
  • Parameters

    • mat: Mat
    • alpha: number
    • mat2: Mat
    • beta: number
    • gamma: number
    • Optional dtype: number

    Returns Mat

addWeightedAsync

  • addWeightedAsync(mat: Mat, alpha: number, mat2: Mat, beta: number, gamma: number, dtype?: number): Promise<Mat>
  • Parameters

    • mat: Mat
    • alpha: number
    • mat2: Mat
    • beta: number
    • gamma: number
    • Optional dtype: number

    Returns Promise<Mat>

applyColorMap

  • applyColorMap(src: Mat, colormap: number | Mat): Mat
  • Parameters

    • src: Mat
    • colormap: number | Mat

    Returns Mat

blobFromImage

  • blobFromImage(image: Mat, scaleFactor?: number, size?: Size, mean?: Vec3, swapRB?: boolean, crop?: boolean, ddepth?: number): Mat
  • Parameters

    • image: Mat
    • Optional scaleFactor: number
    • Optional size: Size
    • Optional mean: Vec3
    • Optional swapRB: boolean
    • Optional crop: boolean
    • Optional ddepth: number

    Returns Mat

blobFromImageAsync

  • blobFromImageAsync(image: Mat, scaleFactor?: number, size?: Size, mean?: Vec3, swapRB?: boolean, crop?: boolean, ddepth?: number): Promise<Mat>
  • Parameters

    • image: Mat
    • Optional scaleFactor: number
    • Optional size: Size
    • Optional mean: Vec3
    • Optional swapRB: boolean
    • Optional crop: boolean
    • Optional ddepth: number

    Returns Promise<Mat>

blobFromImages

  • blobFromImages(image: Mat[], scaleFactor?: number, size?: Size, mean?: Vec3, swapRB?: boolean, crop?: boolean, ddepth?: number): Mat
  • Parameters

    • image: Mat[]
    • Optional scaleFactor: number
    • Optional size: Size
    • Optional mean: Vec3
    • Optional swapRB: boolean
    • Optional crop: boolean
    • Optional ddepth: number

    Returns Mat

blobFromImagesAsync

  • blobFromImagesAsync(image: Mat[], scaleFactor?: number, size?: Size, mean?: Vec3, swapRB?: boolean, crop?: boolean, ddepth?: number): Promise<Mat>
  • Parameters

    • image: Mat[]
    • Optional scaleFactor: number
    • Optional size: Size
    • Optional mean: Vec3
    • Optional swapRB: boolean
    • Optional crop: boolean
    • Optional ddepth: number

    Returns Promise<Mat>

blur

  • Parameters

    • mat: Mat
    • kSize: Size
    • Optional anchor: Point2
    • Optional borderType: number

    Returns Mat

blurAsync

  • blurAsync(mat: Mat, kSize: Size, anchor?: Point2, borderType?: number): Promise<Mat>
  • Parameters

    • mat: Mat
    • kSize: Size
    • Optional anchor: Point2
    • Optional borderType: number

    Returns Promise<Mat>

calcHist

  • calcHist(img: Mat, histAxes: { bins: number; channel: number; ranges: [number, number] }[], mask?: Mat): Mat
  • calcHist(img: Mat, histAxes: HistAxes[], mask?: Mat): Mat
  • deprecated

    Parameters

    • img: Mat
    • histAxes: { bins: number; channel: number; ranges: [number, number] }[]
    • Optional mask: Mat

    Returns Mat

  • Parameters

    Returns Mat

calcHistAsync

calibrateCamera

  • calibrateCamera(objectPoints: Point3[], imagePoints: Point2[], imageSize: Size, cameraMatrix: Mat, distCoeffs: number[], flags?: number, criteria?: TermCriteria): { distCoeffs: number[]; returnValue: number; rvecs: Vec3[]; tvecs: Vec3[] }
  • Parameters

    • objectPoints: Point3[]
    • imagePoints: Point2[]
    • imageSize: Size
    • cameraMatrix: Mat
    • distCoeffs: number[]
    • Optional flags: number
    • Optional criteria: TermCriteria

    Returns { distCoeffs: number[]; returnValue: number; rvecs: Vec3[]; tvecs: Vec3[] }

    • distCoeffs: number[]
    • returnValue: number
    • rvecs: Vec3[]
    • tvecs: Vec3[]

calibrateCameraAsync

  • calibrateCameraAsync(objectPoints: Point3[], imagePoints: Point2[], imageSize: Size, cameraMatrix: Mat, distCoeffs: number[], flags?: number, criteria?: TermCriteria): Promise<{ distCoeffs: number[]; returnValue: number; rvecs: Vec3[]; tvecs: Vec3[] }>
  • Parameters

    • objectPoints: Point3[]
    • imagePoints: Point2[]
    • imageSize: Size
    • cameraMatrix: Mat
    • distCoeffs: number[]
    • Optional flags: number
    • Optional criteria: TermCriteria

    Returns Promise<{ distCoeffs: number[]; returnValue: number; rvecs: Vec3[]; tvecs: Vec3[] }>

calibrateCameraExtended

  • calibrateCameraExtended(objectPoints: Point3[], imagePoints: Point2[], imageSize: Size, cameraMatrix: Mat, distCoeffs: number[], flags?: number, criteria?: TermCriteria): { distCoeffs: number[]; perViewErrors: number[]; returnValue: number; rvecs: Vec3[]; stdDeviationsExtrinsics: Mat; stdDeviationsIntrinsics: Mat; tvecs: Vec3[] }
  • Parameters

    • objectPoints: Point3[]
    • imagePoints: Point2[]
    • imageSize: Size
    • cameraMatrix: Mat
    • distCoeffs: number[]
    • Optional flags: number
    • Optional criteria: TermCriteria

    Returns { distCoeffs: number[]; perViewErrors: number[]; returnValue: number; rvecs: Vec3[]; stdDeviationsExtrinsics: Mat; stdDeviationsIntrinsics: Mat; tvecs: Vec3[] }

    • distCoeffs: number[]
    • perViewErrors: number[]
    • returnValue: number
    • rvecs: Vec3[]
    • stdDeviationsExtrinsics: Mat
    • stdDeviationsIntrinsics: Mat
    • tvecs: Vec3[]

calibrateCameraExtendedAsync

  • calibrateCameraExtendedAsync(objectPoints: Point3[], imagePoints: Point2[], imageSize: Size, cameraMatrix: Mat, distCoeffs: number[], flags?: number, criteria?: TermCriteria): Promise<{ distCoeffs: number[]; perViewErrors: number[]; returnValue: number; rvecs: Vec3[]; stdDeviationsExtrinsics: Mat; stdDeviationsIntrinsics: Mat; tvecs: Vec3[] }>
  • Parameters

    • objectPoints: Point3[]
    • imagePoints: Point2[]
    • imageSize: Size
    • cameraMatrix: Mat
    • distCoeffs: number[]
    • Optional flags: number
    • Optional criteria: TermCriteria

    Returns Promise<{ distCoeffs: number[]; perViewErrors: number[]; returnValue: number; rvecs: Vec3[]; stdDeviationsExtrinsics: Mat; stdDeviationsIntrinsics: Mat; tvecs: Vec3[] }>

canny

  • canny(dx: Mat, dy: Mat, threshold1: number, threshold2: number, L2gradient?: boolean): Mat
  • Parameters

    • dx: Mat
    • dy: Mat
    • threshold1: number
    • threshold2: number
    • Optional L2gradient: boolean

    Returns Mat

cartToPolar

  • cartToPolar(x: Mat, y: Mat, angleInDegrees?: boolean): { angle: Mat; magnitude: Mat }
  • Parameters

    • x: Mat
    • y: Mat
    • Optional angleInDegrees: boolean

    Returns { angle: Mat; magnitude: Mat }

cartToPolarAsync

  • cartToPolarAsync(x: Mat, y: Mat, angleInDegrees?: boolean): Promise<{ angle: Mat; magnitude: Mat }>
  • Parameters

    • x: Mat
    • y: Mat
    • Optional angleInDegrees: boolean

    Returns Promise<{ angle: Mat; magnitude: Mat }>

composeRT

composeRTAsync

computeCorrespondEpilines

  • computeCorrespondEpilines(points: Point2[], whichImage: number, F: Mat): Vec3[]
  • Parameters

    Returns Vec3[]

computeCorrespondEpilinesAsync

  • computeCorrespondEpilinesAsync(points: Point2[], whichImage: number, F: Mat): Promise<Vec3[]>
  • Parameters

    Returns Promise<Vec3[]>

convertScaleAbs

  • convertScaleAbs(mat: Mat, alpha: number, beta: number): Mat
  • Parameters

    • mat: Mat
    • alpha: number
    • beta: number

    Returns Mat

convertScaleAbsAsync

  • convertScaleAbsAsync(mat: Mat, alpha: number, beta: number): Promise<Mat>
  • Parameters

    • mat: Mat
    • alpha: number
    • beta: number

    Returns Promise<Mat>

countNonZero

  • countNonZero(mat: Mat): number
  • Parameters

    Returns number

countNonZeroAsync

  • countNonZeroAsync(mat: Mat): Promise<number>
  • Parameters

    Returns Promise<number>

createOCRHMMTransitionsTable

  • createOCRHMMTransitionsTable(vocabulary: string, lexicon: string[]): Mat
  • Parameters

    • vocabulary: string
    • lexicon: string[]

    Returns Mat

createOCRHMMTransitionsTableAsync

  • createOCRHMMTransitionsTableAsync(vocabulary: string, lexicon: string[]): Promise<Mat>
  • Parameters

    • vocabulary: string
    • lexicon: string[]

    Returns Promise<Mat>

dangerousDisableCustomMatAllocator

  • dangerousDisableCustomMatAllocator(): boolean
  • Returns boolean

dangerousEnableCustomMatAllocator

  • dangerousEnableCustomMatAllocator(): boolean
  • Returns boolean

destroyAllWindows

  • destroyAllWindows(): void
  • Returns void

destroyWindow

  • destroyWindow(winName: string): void
  • Parameters

    • winName: string

    Returns void

drawDetection

drawKeyPoints

drawMatches

drawTextBox

  • drawTextBox(img: Mat, upperLeft: { x: number; y: number }, textLines: TextLine[], alpha: number): Mat
  • Parameters

    • img: Mat
    • upperLeft: { x: number; y: number }
      • x: number
      • y: number
    • textLines: TextLine[]
    • alpha: number

    Returns Mat

eigen

  • Parameters

    Returns Mat

eigenAsync

  • eigenAsync(mat: Mat): Promise<Mat>
  • Parameters

    Returns Promise<Mat>

estimateAffine2D

  • estimateAffine2D(from: Point2[], to: Point2[], method?: number, ransacReprojThreshold?: number, maxIters?: number, confidence?: number, refineIters?: number): { inliers: Mat; out: Mat }
  • Parameters

    • from: Point2[]
    • to: Point2[]
    • Optional method: number
    • Optional ransacReprojThreshold: number
    • Optional maxIters: number
    • Optional confidence: number
    • Optional refineIters: number

    Returns { inliers: Mat; out: Mat }

estimateAffine2DAsync

  • estimateAffine2DAsync(from: Point2[], to: Point2[], method?: number, ransacReprojThreshold?: number, maxIters?: number, confidence?: number, refineIters?: number): Promise<{ inliers: Mat; out: Mat }>
  • Parameters

    • from: Point2[]
    • to: Point2[]
    • Optional method: number
    • Optional ransacReprojThreshold: number
    • Optional maxIters: number
    • Optional confidence: number
    • Optional refineIters: number

    Returns Promise<{ inliers: Mat; out: Mat }>

estimateAffine3D

  • estimateAffine3D(src: Point3[], dst: Point3[], ransacThreshold?: number, confidence?: number): { inliers: Mat; out: Mat; returnValue: number }
  • estimateAffine3D(from: Point2[], to: Point2[], method?: number, ransacReprojThreshold?: number, maxIters?: number, confidence?: number, refineIters?: number): { inliers: Mat; out: Mat }
  • Parameters

    • src: Point3[]
    • dst: Point3[]
    • Optional ransacThreshold: number
    • Optional confidence: number

    Returns { inliers: Mat; out: Mat; returnValue: number }

    • inliers: Mat
    • out: Mat
    • returnValue: number
  • Parameters

    • from: Point2[]
    • to: Point2[]
    • Optional method: number
    • Optional ransacReprojThreshold: number
    • Optional maxIters: number
    • Optional confidence: number
    • Optional refineIters: number

    Returns { inliers: Mat; out: Mat }

estimateAffine3DAsync

  • estimateAffine3DAsync(src: Point3[], dst: Point3[], ransacThreshold?: number, confidence?: number): Promise<{ inliers: Mat; out: Mat; returnValue: number }>
  • estimateAffine3DAsync(from: Point2[], to: Point2[], method?: number, ransacReprojThreshold?: number, maxIters?: number, confidence?: number, refineIters?: number): Promise<{ inliers: Mat; out: Mat }>
  • Parameters

    • src: Point3[]
    • dst: Point3[]
    • Optional ransacThreshold: number
    • Optional confidence: number

    Returns Promise<{ inliers: Mat; out: Mat; returnValue: number }>

  • Parameters

    • from: Point2[]
    • to: Point2[]
    • Optional method: number
    • Optional ransacReprojThreshold: number
    • Optional maxIters: number
    • Optional confidence: number
    • Optional refineIters: number

    Returns Promise<{ inliers: Mat; out: Mat }>

estimateAffinePartial2D

  • estimateAffinePartial2D(from: Point2[], to: Point2[], method?: number, ransacReprojThreshold?: number, maxIters?: number, confidence?: number, refineIters?: number): { inliers: Mat; out: Mat }
  • Parameters

    • from: Point2[]
    • to: Point2[]
    • Optional method: number
    • Optional ransacReprojThreshold: number
    • Optional maxIters: number
    • Optional confidence: number
    • Optional refineIters: number

    Returns { inliers: Mat; out: Mat }

estimateAffinePartial2DAsync

  • estimateAffinePartial2DAsync(from: Point2[], to: Point2[], method?: number, ransacReprojThreshold?: number, maxIters?: number, confidence?: number, refineIters?: number): Promise<{ inliers: Mat; out: Mat }>
  • Parameters

    • from: Point2[]
    • to: Point2[]
    • Optional method: number
    • Optional ransacReprojThreshold: number
    • Optional maxIters: number
    • Optional confidence: number
    • Optional refineIters: number

    Returns Promise<{ inliers: Mat; out: Mat }>

fastNlMeansDenoisingColored

  • fastNlMeansDenoisingColored(src: Mat, h?: number, hColor?: number, templateWindowSize?: number, searchWindowSize?: number): Mat
  • Parameters

    • src: Mat
    • Optional h: number
    • Optional hColor: number
    • Optional templateWindowSize: number
    • Optional searchWindowSize: number

    Returns Mat

findEssentialMat

  • findEssentialMat(points1: Point2[], points2: Point2[], focal?: number, pp?: Point2, method?: number, prob?: number, threshold?: number): { E: Mat; mask: Mat }
  • Parameters

    • points1: Point2[]
    • points2: Point2[]
    • Optional focal: number
    • Optional pp: Point2
    • Optional method: number
    • Optional prob: number
    • Optional threshold: number

    Returns { E: Mat; mask: Mat }

findEssentialMatAsync

  • findEssentialMatAsync(points1: Point2[], points2: Point2[], focal?: number, pp?: Point2, method?: number, prob?: number, threshold?: number): Promise<{ E: Mat; mask: Mat }>
  • Parameters

    • points1: Point2[]
    • points2: Point2[]
    • Optional focal: number
    • Optional pp: Point2
    • Optional method: number
    • Optional prob: number
    • Optional threshold: number

    Returns Promise<{ E: Mat; mask: Mat }>

findFundamentalMat

  • findFundamentalMat(points1: Point2[], points2: Point2[], method?: number, param1?: number, param2?: number): { F: Mat; mask: Mat }
  • Parameters

    • points1: Point2[]
    • points2: Point2[]
    • Optional method: number
    • Optional param1: number
    • Optional param2: number

    Returns { F: Mat; mask: Mat }

findFundamentalMatAsync

  • findFundamentalMatAsync(points1: Point2[], points2: Point2[], method?: number, param1?: number, param2?: number): Promise<{ F: Mat; mask: Mat }>
  • Parameters

    • points1: Point2[]
    • points2: Point2[]
    • Optional method: number
    • Optional param1: number
    • Optional param2: number

    Returns Promise<{ F: Mat; mask: Mat }>

findHomography

  • findHomography(srcPoints: Point2[], dstPoints: Point2[], method?: number, ransacReprojThreshold?: number, maxIters?: number, confidence?: number): { homography: Mat; mask: Mat }
  • Parameters

    • srcPoints: Point2[]
    • dstPoints: Point2[]
    • Optional method: number
    • Optional ransacReprojThreshold: number
    • Optional maxIters: number
    • Optional confidence: number

    Returns { homography: Mat; mask: Mat }

findNonZero

findNonZeroAsync

  • findNonZeroAsync(mat: Mat): Promise<Point2[]>
  • Parameters

    Returns Promise<Point2[]>

fitLine

  • fitLine(points: Point2[], distType: number, param: number, reps: number, aeps: number): number[]
  • fitLine(points: Point3[], distType: number, param: number, reps: number, aeps: number): number[]
  • Parameters

    • points: Point2[]
    • distType: number
    • param: number
    • reps: number
    • aeps: number

    Returns number[]

  • Parameters

    • points: Point3[]
    • distType: number
    • param: number
    • reps: number
    • aeps: number

    Returns number[]

gaussianBlur

  • gaussianBlur(mat: Mat, kSize: Size, sigmaX: number, sigmaY?: number, borderType?: number): Mat
  • Parameters

    • mat: Mat
    • kSize: Size
    • sigmaX: number
    • Optional sigmaY: number
    • Optional borderType: number

    Returns Mat

gaussianBlurAsync

  • gaussianBlurAsync(mat: Mat, kSize: Size, sigmaX: number, sigmaY?: number, borderType?: number): Promise<Mat>
  • Parameters

    • mat: Mat
    • kSize: Size
    • sigmaX: number
    • Optional sigmaY: number
    • Optional borderType: number

    Returns Promise<Mat>

getAffineTransform

getBuildInformation

  • getBuildInformation(): string
  • Returns string

getMemMetrics

  • getMemMetrics(): { NumAllocations: number; NumDeAllocations: number; TotalAlloc: number; TotalKnownByJS: number }
  • Returns { NumAllocations: number; NumDeAllocations: number; TotalAlloc: number; TotalKnownByJS: number }

    • NumAllocations: number
    • NumDeAllocations: number
    • TotalAlloc: number
    • TotalKnownByJS: number

getNumThreads

  • getNumThreads(): number
  • Returns number

getPerspectiveTransform

getRotationMatrix2D

  • getRotationMatrix2D(center: Point2, angle: number, scale?: number): Mat
  • Parameters

    • center: Point2
    • angle: number
    • Optional scale: number

    Returns Mat

getStructuringElement

  • getStructuringElement(shape: number, kernelSize: Size, anchor?: Point2): Mat
  • Parameters

    • shape: number
    • kernelSize: Size
    • Optional anchor: Point2

    Returns Mat

getTextSize

  • getTextSize(text: string, fontFace: number, fontScale: number, thickness: number): { baseLine: number; size: Size }
  • Parameters

    • text: string
    • fontFace: number
    • fontScale: number
    • thickness: number

    Returns { baseLine: number; size: Size }

    • baseLine: number
    • size: Size

getTextSizeAsync

  • getTextSizeAsync(text: string, fontFace: number, fontScale: number, thickness: number): Promise<{ baseLine: number; size: Size }>
  • Parameters

    • text: string
    • fontFace: number
    • fontScale: number
    • thickness: number

    Returns Promise<{ baseLine: number; size: Size }>

getThreadNum

  • getThreadNum(): number
  • Returns number

getValidDisparityROI

  • getValidDisparityROI(roi1: Rect[], roi2: Rect[], minDisparity: number, numberOfDisparities: number, SADWindowSize: number): Rect
  • Parameters

    • roi1: Rect[]
    • roi2: Rect[]
    • minDisparity: number
    • numberOfDisparities: number
    • SADWindowSize: number

    Returns Rect

getValidDisparityROIAsync

  • getValidDisparityROIAsync(roi1: Rect[], roi2: Rect[], minDisparity: number, numberOfDisparities: number, SADWindowSize: number): Promise<Rect>
  • Parameters

    • roi1: Rect[]
    • roi2: Rect[]
    • minDisparity: number
    • numberOfDisparities: number
    • SADWindowSize: number

    Returns Promise<Rect>

goodFeaturesToTrack

  • goodFeaturesToTrack(mat: Mat, maxCorners: number, qualityLevel: number, minDistance: number, mask?: Mat, blockSize?: number, gradientSize?: number, useHarrisDetector?: boolean, harrisK?: number): Point2[]
  • Parameters

    • mat: Mat
    • maxCorners: number
    • qualityLevel: number
    • minDistance: number
    • Optional mask: Mat
    • Optional blockSize: number
    • Optional gradientSize: number
    • Optional useHarrisDetector: boolean
    • Optional harrisK: number

    Returns Point2[]

goodFeaturesToTrackAsync

  • goodFeaturesToTrackAsync(mat: Mat, maxCorners: number, qualityLevel: number, minDistance: number, mask?: Mat, blockSize?: number, gradientSize?: number, useHarrisDetector?: boolean, harrisK?: number): Promise<Point2[]>
  • Parameters

    • mat: Mat
    • maxCorners: number
    • qualityLevel: number
    • minDistance: number
    • Optional mask: Mat
    • Optional blockSize: number
    • Optional gradientSize: number
    • Optional useHarrisDetector: boolean
    • Optional harrisK: number

    Returns Promise<Point2[]>

imdecode

  • imdecode(buffer: Buffer, flags?: number): Mat
  • Parameters

    • buffer: Buffer
    • Optional flags: number

    Returns Mat

imdecodeAsync

  • imdecodeAsync(buffer: Buffer, flags?: number): Promise<Mat>
  • Parameters

    • buffer: Buffer
    • Optional flags: number

    Returns Promise<Mat>

imencode

  • imencode(fileExt: string, img: Mat, flags?: number[]): Buffer
  • Parameters

    • fileExt: string
    • img: Mat
    • Optional flags: number[]

    Returns Buffer

imencodeAsync

  • imencodeAsync(fileExt: string, img: Mat, flags?: number[]): Promise<Buffer>
  • Parameters

    • fileExt: string
    • img: Mat
    • Optional flags: number[]

    Returns Promise<Buffer>

imread

  • imread(filePath: string, flags?: number): Mat
  • Parameters

    • filePath: string
    • Optional flags: number

    Returns Mat

imreadAsync

  • imreadAsync(filePath: string, flags?: number): Promise<Mat>
  • Parameters

    • filePath: string
    • Optional flags: number

    Returns Promise<Mat>

imshow

  • imshow(winName: string, img: Mat): void
  • Parameters

    • winName: string
    • img: Mat

    Returns void

imshowWait

  • imshowWait(winName: string, img: Mat): void
  • Parameters

    • winName: string
    • img: Mat

    Returns void

imwrite

  • imwrite(filePath: string, img: Mat, flags?: number[]): void
  • Parameters

    • filePath: string
    • img: Mat
    • Optional flags: number[]

    Returns void

imwriteAsync

  • imwriteAsync(filePath: string, img: Mat, flags?: number[]): Promise<void>
  • Parameters

    • filePath: string
    • img: Mat
    • Optional flags: number[]

    Returns Promise<void>

initCameraMatrix2D

  • initCameraMatrix2D(objectPoints: Point3[], imagePoints: Point2[], imageSize: Size, aspectRatio?: number): Mat
  • Parameters

    • objectPoints: Point3[]
    • imagePoints: Point2[]
    • imageSize: Size
    • Optional aspectRatio: number

    Returns Mat

initCameraMatrix2DAsync

  • initCameraMatrix2DAsync(objectPoints: Point3[], imagePoints: Point2[], imageSize: Size, aspectRatio?: number): Promise<Mat>
  • Parameters

    • objectPoints: Point3[]
    • imagePoints: Point2[]
    • imageSize: Size
    • Optional aspectRatio: number

    Returns Promise<Mat>

inpaint

  • inpaint(src: Mat, mask: Mat, inpaintRadius: number, flags: number): Mat
  • Parameters

    • src: Mat
    • mask: Mat
    • inpaintRadius: number
    • flags: number

    Returns Mat

inpaintAsync

  • inpaintAsync(src: Mat, mask: Mat, inpaintRadius: number, flags: number): Promise<Mat>
  • Parameters

    • src: Mat
    • mask: Mat
    • inpaintRadius: number
    • flags: number

    Returns Promise<Mat>

isCustomMatAllocatorEnabled

  • isCustomMatAllocatorEnabled(): boolean
  • Returns boolean

kmeans

  • kmeans(data: Point2[], k: number, attempts: number, termCriteria: TermCriteria, flags: number): { centers: Point2[]; labels: number[] }
  • kmeans(data: Point3[], k: number, attempts: number, termCriteria: TermCriteria, flags: number): { centers: Point3[]; labels: number[] }
  • Parameters

    Returns { centers: Point2[]; labels: number[] }

    • centers: Point2[]
    • labels: number[]
  • Parameters

    Returns { centers: Point3[]; labels: number[] }

    • centers: Point3[]
    • labels: number[]

loadOCRHMMClassifierCNN

loadOCRHMMClassifierCNNAsync

loadOCRHMMClassifierNM

loadOCRHMMClassifierNMAsync

matchBruteForce

matchBruteForceAsync

matchBruteForceHamming

matchBruteForceHammingAsync

matchBruteForceHammingLut

matchBruteForceHammingLutAsync

matchBruteForceL1

matchBruteForceL1Async

matchBruteForceSL2

matchBruteForceSL2Async

matchFlannBased

matchFlannBasedAsync

matchKnnBruteForce

matchKnnBruteForceAsync

matchKnnBruteForceHamming

matchKnnBruteForceHammingAsync

  • matchKnnBruteForceHammingAsync(descriptors1: Mat, descriptors2: Mat, k: number): Promise<DescriptorMatch[][]>

matchKnnBruteForceHammingLut

matchKnnBruteForceHammingLutAsync

  • matchKnnBruteForceHammingLutAsync(descriptors1: Mat, descriptors2: Mat, k: number): Promise<DescriptorMatch[][]>

matchKnnBruteForceL1

matchKnnBruteForceL1Async

  • matchKnnBruteForceL1Async(descriptors1: Mat, descriptors2: Mat, k: number): Promise<DescriptorMatch[][]>

matchKnnBruteForceSL2

matchKnnBruteForceSL2Async

  • matchKnnBruteForceSL2Async(descriptors1: Mat, descriptors2: Mat, k: number): Promise<DescriptorMatch[][]>

matchKnnFlannBased

matchKnnFlannBasedAsync

mean

meanAsync

  • meanAsync(mat: Mat): Promise<Vec4>
  • Parameters

    Returns Promise<Vec4>

meanStdDev

  • meanStdDev(mat: Mat, mask?: Mat): { mean: Mat; stddev: Mat }
  • Parameters

    Returns { mean: Mat; stddev: Mat }

meanStdDevAsync

  • meanStdDevAsync(mat: Mat, mask?: Mat): Promise<{ mean: Mat; stddev: Mat }>
  • Parameters

    Returns Promise<{ mean: Mat; stddev: Mat }>

medianBlur

  • medianBlur(mat: Mat, kSize: number): Mat
  • Parameters

    • mat: Mat
    • kSize: number

    Returns Mat

medianBlurAsync

  • medianBlurAsync(mat: Mat, kSize: number): Promise<Mat>
  • Parameters

    • mat: Mat
    • kSize: number

    Returns Promise<Mat>

minMaxLoc

  • minMaxLoc(mat: Mat, mask?: Mat): { maxLoc: Point2; maxVal: number; minLoc: Point2; minVal: number }
  • Parameters

    Returns { maxLoc: Point2; maxVal: number; minLoc: Point2; minVal: number }

    • maxLoc: Point2
    • maxVal: number
    • minLoc: Point2
    • minVal: number

minMaxLocAsync

  • minMaxLocAsync(mat: Mat, mask?: Mat): Promise<{ maxLoc: Point2; maxVal: number; minLoc: Point2; minVal: number }>
  • Parameters

    Returns Promise<{ maxLoc: Point2; maxVal: number; minLoc: Point2; minVal: number }>

moveWindow

  • moveWindow(winName: string, x: number, y: number): void
  • Parameters

    • winName: string
    • x: number
    • y: number

    Returns void

mulSpectrums

  • mulSpectrums(mat: Mat, mat2: Mat, dftRows?: boolean, conjB?: boolean): Mat
  • Parameters

    • mat: Mat
    • mat2: Mat
    • Optional dftRows: boolean
    • Optional conjB: boolean

    Returns Mat

mulSpectrumsAsync

  • mulSpectrumsAsync(mat: Mat, mat2: Mat, dftRows?: boolean, conjB?: boolean): Promise<Mat>
  • Parameters

    • mat: Mat
    • mat2: Mat
    • Optional dftRows: boolean
    • Optional conjB: boolean

    Returns Promise<Mat>

partition

  • partition(data: Point2[], predicate: (pt1: Point2, pt2: Point2) => boolean): { labels: number[]; numLabels: number }
  • partition(data: Point3[], predicate: (pt1: Point3, pt2: Point3) => boolean): { labels: number[]; numLabels: number }
  • partition(data: Vec2[], predicate: (vec1: Vec2, vec2: Vec2) => boolean): { labels: number[]; numLabels: number }
  • partition(data: Vec3[], predicate: (vec1: Vec3, vec2: Vec3) => boolean): { labels: number[]; numLabels: number }
  • partition(data: Vec4[], predicate: (vec1: Vec4, vec2: Vec4) => boolean): { labels: number[]; numLabels: number }
  • partition(data: Vec6[], predicate: (vec1: Vec6, vec2: Vec6) => boolean): { labels: number[]; numLabels: number }
  • partition(data: Mat[], predicate: (mat1: Mat, mat2: Mat) => boolean): { labels: number[]; numLabels: number }
  • Parameters

    Returns { labels: number[]; numLabels: number }

    • labels: number[]
    • numLabels: number
  • Parameters

    Returns { labels: number[]; numLabels: number }

    • labels: number[]
    • numLabels: number
  • Parameters

    • data: Vec2[]
    • predicate: (vec1: Vec2, vec2: Vec2) => boolean
        • Parameters

          Returns boolean

    Returns { labels: number[]; numLabels: number }

    • labels: number[]
    • numLabels: number
  • Parameters

    • data: Vec3[]
    • predicate: (vec1: Vec3, vec2: Vec3) => boolean
        • Parameters

          Returns boolean

    Returns { labels: number[]; numLabels: number }

    • labels: number[]
    • numLabels: number
  • Parameters

    • data: Vec4[]
    • predicate: (vec1: Vec4, vec2: Vec4) => boolean
        • Parameters

          Returns boolean

    Returns { labels: number[]; numLabels: number }

    • labels: number[]
    • numLabels: number
  • Parameters

    • data: Vec6[]
    • predicate: (vec1: Vec6, vec2: Vec6) => boolean
        • Parameters

          Returns boolean

    Returns { labels: number[]; numLabels: number }

    • labels: number[]
    • numLabels: number
  • Parameters

    • data: Mat[]
    • predicate: (mat1: Mat, mat2: Mat) => boolean
        • (mat1: Mat, mat2: Mat): boolean
        • Parameters

          Returns boolean

    Returns { labels: number[]; numLabels: number }

    • labels: number[]
    • numLabels: number

perspectiveTransform

  • perspectiveTransform(mat: Mat, m: Mat): Mat

perspectiveTransformAsync

  • perspectiveTransformAsync(mat: Mat, m: Mat): Promise<Mat>
  • Parameters

    Returns Promise<Mat>

plot1DHist

  • plot1DHist(hist: Mat, plotImg: Mat, color: Vec3, lineType?: number, thickness?: number, shift?: number): Mat
  • Parameters

    • hist: Mat
    • plotImg: Mat
    • color: Vec3
    • Optional lineType: number
    • Optional thickness: number
    • Optional shift: number

    Returns Mat

polarToCart

  • polarToCart(magnitude: Mat, angle: Mat, angleInDegrees?: boolean): { x: Mat; y: Mat }
  • Parameters

    • magnitude: Mat
    • angle: Mat
    • Optional angleInDegrees: boolean

    Returns { x: Mat; y: Mat }

polarToCartAsync

  • polarToCartAsync(magnitude: Mat, angle: Mat, angleInDegrees?: boolean): Promise<{ x: Mat; y: Mat }>
  • Parameters

    • magnitude: Mat
    • angle: Mat
    • Optional angleInDegrees: boolean

    Returns Promise<{ x: Mat; y: Mat }>

projectPoints

  • projectPoints(objectPoints: Point3[], imagePoints: Point2[], rvec: Vec3, tvec: Vec3, cameraMatrix: Mat, distCoeffs: number[], aspectRatio?: number): { imagePoints: Point2[]; jacobian: Mat }
  • Parameters

    • objectPoints: Point3[]
    • imagePoints: Point2[]
    • rvec: Vec3
    • tvec: Vec3
    • cameraMatrix: Mat
    • distCoeffs: number[]
    • Optional aspectRatio: number

    Returns { imagePoints: Point2[]; jacobian: Mat }

projectPointsAsync

  • projectPointsAsync(objectPoints: Point3[], imagePoints: Point2[], rvec: Vec3, tvec: Vec3, cameraMatrix: Mat, distCoeffs: number[], aspectRatio?: number): Promise<{ imagePoints: Point2[]; jacobian: Mat }>
  • Parameters

    • objectPoints: Point3[]
    • imagePoints: Point2[]
    • rvec: Vec3
    • tvec: Vec3
    • cameraMatrix: Mat
    • distCoeffs: number[]
    • Optional aspectRatio: number

    Returns Promise<{ imagePoints: Point2[]; jacobian: Mat }>

readNetFromCaffe

  • readNetFromCaffe(prototxt: string, modelPath?: string): Net
  • Parameters

    • prototxt: string
    • Optional modelPath: string

    Returns Net

readNetFromCaffeAsync

  • readNetFromCaffeAsync(prototxt: string, modelPath?: string): Promise<Net>
  • Parameters

    • prototxt: string
    • Optional modelPath: string

    Returns Promise<Net>

readNetFromTensorflow

  • readNetFromTensorflow(modelPath: string): Net
  • Parameters

    • modelPath: string

    Returns Net

readNetFromTensorflowAsync

  • readNetFromTensorflowAsync(modelPath: string): Promise<Net>
  • Parameters

    • modelPath: string

    Returns Promise<Net>

recoverPose

  • Parameters

    Returns { R: Mat; T: Vec3; returnValue: number }

    • R: Mat
    • T: Vec3
    • returnValue: number

recoverPoseAsync

  • recoverPoseAsync(E: Mat, points1: Point2[], points2: Point2[], focal?: number, pp?: Point2, mask?: Mat): Promise<{ R: Mat; T: Vec3; returnValue: number }>
  • Parameters

    Returns Promise<{ R: Mat; T: Vec3; returnValue: number }>

reduce

  • reduce(mat: Mat, dim: number, rtype: number, dtype?: number): Mat
  • Parameters

    • mat: Mat
    • dim: number
    • rtype: number
    • Optional dtype: number

    Returns Mat

reduceAsync

  • reduceAsync(mat: Mat, dim: number, rtype: number, dtype?: number): Promise<Mat>
  • Parameters

    • mat: Mat
    • dim: number
    • rtype: number
    • Optional dtype: number

    Returns Promise<Mat>

sampsonDistance

  • sampsonDistance(pt1: Vec2, pt2: Vec2, F: Mat): number

sampsonDistanceAsync

  • sampsonDistanceAsync(pt1: Vec2, pt2: Vec2, F: Mat): Promise<number>
  • Parameters

    Returns Promise<number>

seamlessClone

seamlessCloneAsync

  • seamlessCloneAsync(src: Mat, dst: Mat, mask: Mat, p: Point2, flags: number): Promise<Mat>

setNumThreads

  • setNumThreads(nthreads: number): void
  • Parameters

    • nthreads: number

    Returns void

solve

  • solve(mat: Mat, mat2: Mat, flags?: number): Mat
  • Parameters

    • mat: Mat
    • mat2: Mat
    • Optional flags: number

    Returns Mat

solveAsync

  • solveAsync(mat: Mat, mat2: Mat, flags?: number): Promise<Mat>
  • Parameters

    • mat: Mat
    • mat2: Mat
    • Optional flags: number

    Returns Promise<Mat>

solveP3P

  • solveP3P(objectPoints: Point3[], imagePoints: Point2[], cameraMatrix: Mat, distCoeffs: number[], flags?: number): { returnValue: boolean; rvecs: Mat[]; tvecs: Mat[] }
  • Parameters

    • objectPoints: Point3[]
    • imagePoints: Point2[]
    • cameraMatrix: Mat
    • distCoeffs: number[]
    • Optional flags: number

    Returns { returnValue: boolean; rvecs: Mat[]; tvecs: Mat[] }

    • returnValue: boolean
    • rvecs: Mat[]
    • tvecs: Mat[]

solveP3PAsync

  • solveP3PAsync(objectPoints: Point3[], imagePoints: Point2[], cameraMatrix: Mat, distCoeffs: number[], flags?: number): Promise<{ returnValue: boolean; rvecs: Mat[]; tvecs: Mat[] }>
  • Parameters

    • objectPoints: Point3[]
    • imagePoints: Point2[]
    • cameraMatrix: Mat
    • distCoeffs: number[]
    • Optional flags: number

    Returns Promise<{ returnValue: boolean; rvecs: Mat[]; tvecs: Mat[] }>

solvePnP

  • solvePnP(objectPoints: Point3[], imagePoints: Point2[], cameraMatrix: Mat, distCoeffs: number[], useExtrinsicGuess?: boolean, flags?: number): { returnValue: boolean; rvec: Vec3; tvec: Vec3 }
  • solvePnP(objectPoints: Point3[], imagePoints: Point2[], cameraMatrix: Mat, distCoeffs: number[], useExtrinsicGuess?: boolean, iterationsCount?: number, reprojectionError?: number, confidence?: number, flags?: number): { inliers: number[]; returnValue: boolean; rvec: Vec3; tvec: Vec3 }
  • Parameters

    • objectPoints: Point3[]
    • imagePoints: Point2[]
    • cameraMatrix: Mat
    • distCoeffs: number[]
    • Optional useExtrinsicGuess: boolean
    • Optional flags: number

    Returns { returnValue: boolean; rvec: Vec3; tvec: Vec3 }

    • returnValue: boolean
    • rvec: Vec3
    • tvec: Vec3
  • Parameters

    • objectPoints: Point3[]
    • imagePoints: Point2[]
    • cameraMatrix: Mat
    • distCoeffs: number[]
    • Optional useExtrinsicGuess: boolean
    • Optional iterationsCount: number
    • Optional reprojectionError: number
    • Optional confidence: number
    • Optional flags: number

    Returns { inliers: number[]; returnValue: boolean; rvec: Vec3; tvec: Vec3 }

    • inliers: number[]
    • returnValue: boolean
    • rvec: Vec3
    • tvec: Vec3

solvePnPAsync

  • solvePnPAsync(objectPoints: Point3[], imagePoints: Point2[], cameraMatrix: Mat, distCoeffs: number[], useExtrinsicGuess?: boolean, flags?: number): Promise<{ returnValue: boolean; rvec: Vec3; tvec: Vec3 }>
  • solvePnPAsync(objectPoints: Point3[], imagePoints: Point2[], cameraMatrix: Mat, distCoeffs: number[], useExtrinsicGuess?: boolean, iterationsCount?: number, reprojectionError?: number, confidence?: number, flags?: number): Promise<{ inliers: number[]; returnValue: boolean; rvec: Vec3; tvec: Vec3 }>
  • Parameters

    • objectPoints: Point3[]
    • imagePoints: Point2[]
    • cameraMatrix: Mat
    • distCoeffs: number[]
    • Optional useExtrinsicGuess: boolean
    • Optional flags: number

    Returns Promise<{ returnValue: boolean; rvec: Vec3; tvec: Vec3 }>

  • Parameters

    • objectPoints: Point3[]
    • imagePoints: Point2[]
    • cameraMatrix: Mat
    • distCoeffs: number[]
    • Optional useExtrinsicGuess: boolean
    • Optional iterationsCount: number
    • Optional reprojectionError: number
    • Optional confidence: number
    • Optional flags: number

    Returns Promise<{ inliers: number[]; returnValue: boolean; rvec: Vec3; tvec: Vec3 }>

split

  • Parameters

    Returns Mat[]

splitAsync

  • splitAsync(mat: Mat): Promise<Mat[]>
  • Parameters

    Returns Promise<Mat[]>

stereoCalibrate

  • stereoCalibrate(objectPoints: Point3[], imagePoints1: Point2[], imagePoints2: Point2[], cameraMatrix1: Mat, distCoeffs1: number[], cameraMatrix2: Mat, distCoeffs2: number[], imageSize: Size, flags?: number, criteria?: TermCriteria): { E: Mat; F: Mat; R: Mat; T: Vec3[]; distCoeffs1: number[]; distCoeffs2: number[]; returnValue: number }
  • Parameters

    • objectPoints: Point3[]
    • imagePoints1: Point2[]
    • imagePoints2: Point2[]
    • cameraMatrix1: Mat
    • distCoeffs1: number[]
    • cameraMatrix2: Mat
    • distCoeffs2: number[]
    • imageSize: Size
    • Optional flags: number
    • Optional criteria: TermCriteria

    Returns { E: Mat; F: Mat; R: Mat; T: Vec3[]; distCoeffs1: number[]; distCoeffs2: number[]; returnValue: number }

    • E: Mat
    • F: Mat
    • R: Mat
    • T: Vec3[]
    • distCoeffs1: number[]
    • distCoeffs2: number[]
    • returnValue: number

stereoCalibrateAsync

  • stereoCalibrateAsync(objectPoints: Point3[], imagePoints1: Point2[], imagePoints2: Point2[], cameraMatrix1: Mat, distCoeffs1: number[], cameraMatrix2: Mat, distCoeffs2: number[], imageSize: Size, flags?: number, criteria?: TermCriteria): Promise<{ E: Mat; F: Mat; R: Mat; T: Vec3[]; distCoeffs1: number[]; distCoeffs2: number[]; returnValue: number }>
  • Parameters

    • objectPoints: Point3[]
    • imagePoints1: Point2[]
    • imagePoints2: Point2[]
    • cameraMatrix1: Mat
    • distCoeffs1: number[]
    • cameraMatrix2: Mat
    • distCoeffs2: number[]
    • imageSize: Size
    • Optional flags: number
    • Optional criteria: TermCriteria

    Returns Promise<{ E: Mat; F: Mat; R: Mat; T: Vec3[]; distCoeffs1: number[]; distCoeffs2: number[]; returnValue: number }>

stereoRectifyUncalibrated

  • stereoRectifyUncalibrated(points1: Point2[], points2: Point2[], F: Mat, imageSize: Size, threshold?: number): { H1: Mat; H2: Mat; returnValue: boolean }
  • Parameters

    Returns { H1: Mat; H2: Mat; returnValue: boolean }

    • H1: Mat
    • H2: Mat
    • returnValue: boolean

stereoRectifyUncalibratedAsync

  • stereoRectifyUncalibratedAsync(points1: Point2[], points2: Point2[], F: Mat, imageSize: Size, threshold?: number): Promise<{ H1: Mat; H2: Mat; returnValue: boolean }>
  • Parameters

    Returns Promise<{ H1: Mat; H2: Mat; returnValue: boolean }>

sum

  • Parameters

    Returns number

  • Parameters

    Returns Vec2

  • Parameters

    Returns Vec3

  • Parameters

    Returns Vec4

sumAsync

  • sumAsync(mat: Mat): Promise<number>
  • sumAsync(mat: Mat): Promise<Vec2>
  • sumAsync(mat: Mat): Promise<Vec3>
  • sumAsync(mat: Mat): Promise<Vec4>
  • Parameters

    Returns Promise<number>

  • Parameters

    Returns Promise<Vec2>

  • Parameters

    Returns Promise<Vec3>

  • Parameters

    Returns Promise<Vec4>

transform

transformAsync

  • transformAsync(mat: Mat, m: Mat): Promise<Mat>
  • Parameters

    Returns Promise<Mat>

undistortPoints

undistortPointsAsync

  • undistortPointsAsync(srcPoints: Point2[], cameraMatrix: Mat, distCoeffs: Mat): Promise<Point2[]>
  • Parameters

    Returns Promise<Point2[]>

waitKey

  • waitKey(delay?: number): number
  • Parameters

    • Optional delay: number

    Returns number

waitKeyEx

  • waitKeyEx(delay?: number): number
  • Parameters

    • Optional delay: number

    Returns number