opencv4nodejs

adaptiveThresholdAsync ( maxVal : number , adaptiveMethod : int , thresholdType : int , blockSize : int , C : number , callback ( err : Error , Result res )) : void

add

Result : Mat

add ( otherMat : Mat ) : Result

addWeighted

Result : Mat

addWeighted ( alpha : number , mat2 : Mat , beta : number , gamma : number , dtype : int = -1 ) : Result

addWeightedAsync ( alpha : number , mat2 : Mat , beta : number , gamma : number , dtype : int = -1 ) : Promise < Result >

addWeightedAsync ( alpha : number , mat2 : Mat , beta : number , gamma : number , dtype : int = -1 , ...opts , callback ( err : Error , Result res )) : void

and

Result : Mat

and ( otherMat : Mat ) : Result

at

Result : number

at ( row : uint , col : uint ) : Result

Result : Vec2

at ( row : uint , col : uint ) : Result

Result : Vec3

at ( row : uint , col : uint ) : Result

Result : Vec4

at ( row : uint , col : uint ) : Result

atRaw

Result : number

atRaw ( row : uint , col : uint ) : Result

Result : number []

atRaw ( row : uint , col : uint ) : Result

Result : number []

atRaw ( row : uint , col : uint ) : Result

Result : number []

atRaw ( row : uint , col : uint ) : Result

bgrToGray

Result : Mat

bgrToGray () : Result

bgrToGrayAsync () : Promise < Result >

bgrToGrayAsync ( callback ( err : Error , Result res )) : void

bilateralFilter

Result : Mat

bilateralFilter ( d : int , sigmaColor : number , sigmaSpace : number , borderType : int = BORDER_DEFAULT ) : Result

bilateralFilterAsync ( d : int , sigmaColor : number , sigmaSpace : number , borderType : int = BORDER_DEFAULT ) : Promise < Result >

bilateralFilterAsync ( d : int , sigmaColor : number , sigmaSpace : number , borderType : int = BORDER_DEFAULT , ...opts , callback ( err : Error , Result res )) : void

bitwiseAnd

Result : Mat

bitwiseAnd ( otherMat : Mat ) : Result

bitwiseNot

Result : Mat

bitwiseNot () : Result

bitwiseOr

Result : Mat

bitwiseOr ( otherMat : Mat ) : Result

bitwiseXor

Result : Mat

bitwiseXor ( otherMat : Mat ) : Result

blur

Result : Mat

blur ( kSize : Size , anchor : Point2 = new Point2(-1, -1) , borderType : uint = BORDER_CONSTANT ) : Result

blurAsync ( kSize : Size , anchor : Point2 = new Point2(-1, -1) , borderType : uint = BORDER_CONSTANT ) : Promise < Result >

blurAsync ( kSize : Size , anchor : Point2 = new Point2(-1, -1) , borderType : uint = BORDER_CONSTANT , ...opts , callback ( err : Error , Result res )) : void

boxFilter

Result : Mat

boxFilter ( ddepth : int , ksize : Size , anchor : Point2 = new Point(-1, -1) , normalize : boolean = true , borderType : int = BORDER_DEFAULT ) : Result

boxFilterAsync ( ddepth : int , ksize : Size , anchor : Point2 = new Point(-1, -1) , normalize : boolean = true , borderType : int = BORDER_DEFAULT ) : Promise < Result >

boxFilterAsync ( ddepth : int , ksize : Size , anchor : Point2 = new Point(-1, -1) , normalize : boolean = true , borderType : int = BORDER_DEFAULT , ...opts , callback ( err : Error , Result res )) : void

buildPyramid

Result : Mat []

buildPyramid ( maxLevel : int , borderType : int = BORDER_DEFAULT ) : Result

buildPyramidAsync ( maxLevel : int , borderType : int = BORDER_DEFAULT ) : Promise < Result >

buildPyramidAsync ( maxLevel : int , borderType : int = BORDER_DEFAULT , ...opts , callback ( err : Error , Result res )) : void

calibrationMatrixValues

Result = {

fovx : number ,

fovy : number ,

focalLength : number ,

principalPoint : Point2 ,

aspectRatio : number

}

calibrationMatrixValues ( imageSize : Size , apertureWidth : number , apertureHeight : number ) : Result

calibrationMatrixValuesAsync ( imageSize : Size , apertureWidth : number , apertureHeight : number ) : Promise < Result >

calibrationMatrixValuesAsync ( imageSize : Size , apertureWidth : number , apertureHeight : number , callback ( err : Error , Result res )) : void

canny

Result : Mat

canny ( threshold1 : number , threshold2 : number , apertureSize : int = 3 , L2gradient : boolean = false ) : Result

cannyAsync ( threshold1 : number , threshold2 : number , apertureSize : int = 3 , L2gradient : boolean = false ) : Promise < Result >

cannyAsync ( threshold1 : number , threshold2 : number , apertureSize : int = 3 , L2gradient : boolean = false , ...opts , callback ( err : Error , Result res )) : void

compareHist

Result : number

compareHist ( H2 : Mat , method : int ) : Result

compareHistAsync ( H2 : Mat , method : int ) : Promise < Result >

compareHistAsync ( H2 : Mat , method : int , callback ( err : Error , Result res )) : void

connectedComponents

Result : Mat

connectedComponents ( connectivity : uint = 8 , ltype : uint = CV_32S ) : Result

connectedComponentsAsync ( connectivity : uint = 8 , ltype : uint = CV_32S ) : Promise < Result >

connectedComponentsAsync ( connectivity : uint = 8 , ltype : uint = CV_32S , ...opts , callback ( err : Error , Result res )) : void

connectedComponentsWithStats

Result = {

labels : Mat ,

stats : Mat ,

centroids : Mat

}

connectedComponentsWithStats ( connectivity : uint = 8 , ltype : uint = CV_32S ) : Result

connectedComponentsWithStatsAsync ( connectivity : uint = 8 , ltype : uint = CV_32S ) : Promise < Result >

connectedComponentsWithStatsAsync ( connectivity : uint = 8 , ltype : uint = CV_32S , ...opts , callback ( err : Error , Result res )) : void

convertScaleAbs

Result : Mat

convertScaleAbs ( alpha : number , beta : number ) : Result

convertScaleAbsAsync ( alpha : number , beta : number ) : Promise < Result >

convertScaleAbsAsync ( alpha : number , beta : number , callback ( err : Error , Result res )) : void

convertTo

Result : Mat

convertTo ( type : uint , alpha : number = 1.0 , beta : number = 0.0 ) : Result

convertToAsync ( type : uint , alpha : number = 1.0 , beta : number = 0.0 ) : Promise < Result >

convertToAsync ( type : uint , alpha : number = 1.0 , beta : number = 0.0 , ...opts , callback ( err : Error , Result res )) : void

copy

Result : Mat

copy ( mask : Mat = null ) : Result

copyAsync ( mask : Mat = null ) : Promise < Result >

copyAsync ( mask : Mat = null , ...opts , callback ( err : Error , Result res )) : void

copyMakeBorder

Result : Mat

copyMakeBorder ( top : number , bottom : number , left : number , right : number , borderValue : number = BORDER_CONSTANT , value : number = 0 ) : Result

copyMakeBorderAsync ( top : number , bottom : number , left : number , right : number , borderValue : number = BORDER_CONSTANT , value : number = 0 ) : Promise < Result >

copyMakeBorderAsync ( top : number , bottom : number , left : number , right : number , borderValue : number = BORDER_CONSTANT , value : number = 0 , ...opts , callback ( err : Error , Result res )) : void

Result : Mat

copyMakeBorder ( top : number , bottom : number , left : number , right : number , borderValue : number = BORDER_CONSTANT , value : Vec2 = new cv.Vec(0, 0) ) : Result

copyMakeBorderAsync ( top : number , bottom : number , left : number , right : number , borderValue : number = BORDER_CONSTANT , value : Vec2 = new cv.Vec(0, 0) ) : Promise < Result >

copyMakeBorderAsync ( top : number , bottom : number , left : number , right : number , borderValue : number = BORDER_CONSTANT , value : Vec2 = new cv.Vec(0, 0) , ...opts , callback ( err : Error , Result res )) : void

Result : Mat

copyMakeBorder ( top : number , bottom : number , left : number , right : number , borderValue : number = BORDER_CONSTANT , value : Vec3 = new cv.Vec(0, 0, 0) ) : Result

copyMakeBorderAsync ( top : number , bottom : number , left : number , right : number , borderValue : number = BORDER_CONSTANT , value : Vec3 = new cv.Vec(0, 0, 0) ) : Promise < Result >

copyMakeBorderAsync ( top : number , bottom : number , left : number , right : number , borderValue : number = BORDER_CONSTANT , value : Vec3 = new cv.Vec(0, 0, 0) , ...opts , callback ( err : Error , Result res )) : void

Result : Mat

copyMakeBorder ( top : number , bottom : number , left : number , right : number , borderValue : number = BORDER_CONSTANT , value : Vec4 = new cv.Vec(0, 0, 0, 0) ) : Result

copyMakeBorderAsync ( top : number , bottom : number , left : number , right : number , borderValue : number = BORDER_CONSTANT , value : Vec4 = new cv.Vec(0, 0, 0, 0) ) : Promise < Result >

copyMakeBorderAsync ( top : number , bottom : number , left : number , right : number , borderValue : number = BORDER_CONSTANT , value : Vec4 = new cv.Vec(0, 0, 0, 0) , ...opts , callback ( err : Error , Result res )) : void

copyTo

Result : Mat

copyTo ( dst : Mat , mask : Mat = null ) : Result

copyToAsync ( dst : Mat , mask : Mat = null ) : Promise < Result >

copyToAsync ( dst : Mat , mask : Mat = null , ...opts , callback ( err : Error , Result res )) : void

cornerEigenValsAndVecs

Result : Mat

cornerEigenValsAndVecs ( blockSize : int , ksize : int = 3 , borderType : int = BORDER_DEFAULT ) : Result

cornerEigenValsAndVecsAsync ( blockSize : int , ksize : int = 3 , borderType : int = BORDER_DEFAULT ) : Promise < Result >

cornerEigenValsAndVecsAsync ( blockSize : int , ksize : int = 3 , borderType : int = BORDER_DEFAULT , ...opts , callback ( err : Error , Result res )) : void

cornerHarris

Result : Mat

cornerHarris ( blockSize : int , ksize : int , k : number , borderType : int = BORDER_DEFAULT ) : Result

cornerHarrisAsync ( blockSize : int , ksize : int , k : number , borderType : int = BORDER_DEFAULT ) : Promise < Result >

cornerHarrisAsync ( blockSize : int , ksize : int , k : number , borderType : int = BORDER_DEFAULT , ...opts , callback ( err : Error , Result res )) : void

cornerMinEigenVal

Result : Mat

cornerMinEigenVal ( blockSize : int , ksize : int = 3 , borderType : int = BORDER_DEFAULT ) : Result

cornerMinEigenValAsync ( blockSize : int , ksize : int = 3 , borderType : int = BORDER_DEFAULT ) : Promise < Result >

cornerMinEigenValAsync ( blockSize : int , ksize : int = 3 , borderType : int = BORDER_DEFAULT , ...opts , callback ( err : Error , Result res )) : void

cornerSubPix

Result : Point2 []

cornerSubPix ( corners : Point2 [] , winSize : Size , zeroZone : Size , criteria : TermCriteria ) : Result

cornerSubPixAsync ( corners : Point2 [] , winSize : Size , zeroZone : Size , criteria : TermCriteria ) : Promise < Result >

cornerSubPixAsync ( corners : Point2 [] , winSize : Size , zeroZone : Size , criteria : TermCriteria , callback ( err : Error , Result res )) : void

correctMatches

Result = {

newPoints1 : Point2 [] ,

newPoints2 : Point2 []

}

correctMatches ( points1 : Point2 [] , points2 : Point2 []) : Result

correctMatchesAsync ( points1 : Point2 [] , points2 : Point2 []) : Promise < Result >

correctMatchesAsync ( points1 : Point2 [] , points2 : Point2 [] , callback ( err : Error , Result res )) : void

countNonZero

Result : int

countNonZero () : Result

countNonZeroAsync () : Promise < Result >

countNonZeroAsync ( callback ( err : Error , Result res )) : void

cvtColor

Result : Mat

cvtColor ( code : uint , dstCn : uint = 0 ) : Result

cvtColorAsync ( code : uint , dstCn : uint = 0 ) : Promise < Result >

cvtColorAsync ( code : uint , dstCn : uint = 0 , ...opts , callback ( err : Error , Result res )) : void

dct

Result : Mat

dct ( flags : int = 0 ) : Result

dctAsync ( flags : int = 0 ) : Promise < Result >

dctAsync ( flags : int = 0 , ...opts , callback ( err : Error , Result res )) : void

decomposeEssentialMat

Result = {

R1 : Mat ,

R2 : Mat ,

T : Vec3

}

decomposeEssentialMat () : Result

decomposeEssentialMatAsync () : Promise < Result >

decomposeEssentialMatAsync ( callback ( err : Error , Result res )) : void

decomposeHomographyMat

Result = {

returnValue : int ,

rotations : Mat [] ,

translations : Mat [] ,

normals : Mat []

}

decomposeHomographyMat ( K : Mat ) : Result

decomposeHomographyMatAsync ( K : Mat ) : Promise < Result >

decomposeHomographyMatAsync ( K : Mat , callback ( err : Error , Result res )) : void

decomposeProjectionMatrix

Result = {

cameraMatrix : Mat ,

rotMatrix : Mat ,

transVect : Vec4 ,

rotMatrixX : Mat ,

rotMatrixY : Mat ,

rotMatrixZ : Mat ,

eulerAngles : Mat

}

decomposeProjectionMatrix () : Result

decomposeProjectionMatrixAsync () : Promise < Result >

decomposeProjectionMatrixAsync ( callback ( err : Error , Result res )) : void

determinant

Result : number

determinant () : Result

dft

Result : Mat

dft ( flags : int = 0 , nonzeroRows : int = 0 ) : Result

dftAsync ( flags : int = 0 , nonzeroRows : int = 0 ) : Promise < Result >

dftAsync ( flags : int = 0 , nonzeroRows : int = 0 , ...opts , callback ( err : Error , Result res )) : void

dilate

Result : Mat

dilate ( kernel : Mat , anchor : Point2 = new Point2(-1, -1) , iterations : uint = 1 , borderType : uint = BORDER_CONSTANT ) : Result

dilateAsync ( kernel : Mat , anchor : Point2 = new Point2(-1, -1) , iterations : uint = 1 , borderType : uint = BORDER_CONSTANT ) : Promise < Result >

dilateAsync ( kernel : Mat , anchor : Point2 = new Point2(-1, -1) , iterations : uint = 1 , borderType : uint = BORDER_CONSTANT , ...opts , callback ( err : Error , Result res )) : void

distanceTransform

Result : Mat

distanceTransform ( distanceType : uint , maskSize : uint , dstType : uint = CV_32F ) : Result

distanceTransformAsync ( distanceType : uint , maskSize : uint , dstType : uint = CV_32F ) : Promise < Result >

distanceTransformAsync ( distanceType : uint , maskSize : uint , dstType : uint = CV_32F , ...opts , callback ( err : Error , Result res )) : void

distanceTransformWithLabels

Result = {

labels : Mat ,

dist : Mat

}

distanceTransformWithLabels ( distanceType : uint , maskSize : uint , labelType : uint = DIST_LABEL_CCOMP ) : Result

distanceTransformWithLabelsAsync ( distanceType : uint , maskSize : uint , labelType : uint = DIST_LABEL_CCOMP ) : Promise < Result >

distanceTransformWithLabelsAsync ( distanceType : uint , maskSize : uint , labelType : uint = DIST_LABEL_CCOMP , ...opts , callback ( err : Error , Result res )) : void

div

Result : Mat

div ( s : number ) : Result

dot

Result : Mat

dot () : Result

drawArrowedLine

drawArrowedLine ( pt0 : Point2 , pt1 : Point2 , color : Vec3 = new cv.Vec(0, 0; 0) , thickness : int = 1 , lineType : int = LINE_8 , shift : int = 0 , tipLength : number = 0.1 ) : Result

drawChessboardCorners

drawChessboardCorners ( patternSize : Size , corners : Point2 [] , patternWasFound : boolean ) : Result

drawChessboardCornersAsync ( patternSize : Size , corners : Point2 [] , patternWasFound : boolean ) : Promise < Result >

drawChessboardCornersAsync ( patternSize : Size , corners : Point2 [] , patternWasFound : boolean , callback ( err : Error , Result res )) : void

drawCircle

drawCircle ( center : Point2 , radius : int , color : Vec3 = new Vec(0, 0; 0) , thickness : int = 1 , lineType : int = LINE_8 , shift : int = 0 ) : Result

drawContours

drawContours ( contours : Contour [] , color : Vec3 , contourIdx : int = 0 , maxLevel : int = INT_MAX , offset : Point2 = new Point2(0, 0) , lineType : uint = LINE_8 , thickness : uint = 1 , shift : uint = 0 ) : Result

drawEllipse

drawEllipse ( box : RotatedRect , color : Vec3 = new Vec(0, 0; 0) , thickness : int = 1 , lineType : int = LINE_8 ) : Result

drawEllipse ( center : Point2 , axes : Size , angle : number , startAngle : number , endAngle : number , color : Vec3 = new Vec(0, 0; 0) , thickness : int = 1 , lineType : int = LINE_8 , shift : int = 0 ) : Result

drawFillConvexPoly

drawFillConvexPoly ( pts : Point2 [] , color : Vec3 = new cv.Vec(0, 0; 0) , lineType : int = LINE_8 , shift : int = 0 ) : Result

drawFillPoly

drawFillPoly ( pts : Point2 [][] , color : Vec3 = new cv.Vec(0, 0; 0) , lineType : int = LINE_8 , shift : int = 0 , offset : Point2 = Point() ) : Result

drawLine

drawLine ( pt0 : Point2 , pt1 : Point2 , color : Vec3 = new Vec(0, 0; 0) , thickness : int = 1 , lineType : int = LINE_8 , shift : int = 0 ) : Result

drawPolylines

drawPolylines ( pts : Point2 [][] , isClosed : boolean , color : Vec3 = new cv.Vec(0, 0; 0) , thickness : int = 1 , lineType : int = LINE_8 , shift : int = 0 ) : Result

drawRectangle

drawRectangle ( pt0 : Point2 , pt1 : Point2 , color : Vec3 = new Vec(0, 0; 0) , thickness : int = 1 , lineType : int = LINE_8 , shift : int = 0 ) : Result

drawRectangle ( rect : Rect , color : Vec3 = new Vec(0, 0; 0) , thickness : int = 1 , lineType : int = LINE_8 , shift : int = 0 ) : Result

equalizeHist

Result : Mat

equalizeHist () : Result

equalizeHistAsync () : Promise < Result >

equalizeHistAsync ( callback ( err : Error , Result res )) : void

erode

Result : Mat

erode ( kernel : Mat , anchor : Point2 = new Point2(-1, -1) , iterations : uint = 1 , borderType : uint = BORDER_CONSTANT ) : Result

erodeAsync ( kernel : Mat , anchor : Point2 = new Point2(-1, -1) , iterations : uint = 1 , borderType : uint = BORDER_CONSTANT ) : Promise < Result >

erodeAsync ( kernel : Mat , anchor : Point2 = new Point2(-1, -1) , iterations : uint = 1 , borderType : uint = BORDER_CONSTANT , ...opts , callback ( err : Error , Result res )) : void

exp

Result : Mat

exp () : Result

filter2D

Result : Mat

filter2D ( ddepth : int , kernel : Mat , anchor : Point2 = new Point(-1, -1) , delta : number = 0 , borderType : int = BORDER_DEFAULT ) : Result

filter2DAsync ( ddepth : int , kernel : Mat , anchor : Point2 = new Point(-1, -1) , delta : number = 0 , borderType : int = BORDER_DEFAULT ) : Promise < Result >

filter2DAsync ( ddepth : int , kernel : Mat , anchor : Point2 = new Point(-1, -1) , delta : number = 0 , borderType : int = BORDER_DEFAULT , ...opts , callback ( err : Error , Result res )) : void

filterSpeckles

Result = {

newPoints1 : Point2 [] ,

newPoints2 : Point2 []

}

filterSpeckles ( newVal : number , maxSpeckleSize : int , maxDiff : number ) : Result

filterSpecklesAsync ( newVal : number , maxSpeckleSize : int , maxDiff : number ) : Promise < Result >

filterSpecklesAsync ( newVal : number , maxSpeckleSize : int , maxDiff : number , callback ( err : Error , Result res )) : void

find4QuadCornerSubpix

Result : boolean

find4QuadCornerSubpix ( corners : Point2 [] , regionSize : Size ) : Result

find4QuadCornerSubpixAsync ( corners : Point2 [] , regionSize : Size ) : Promise < Result >

find4QuadCornerSubpixAsync ( corners : Point2 [] , regionSize : Size , callback ( err : Error , Result res )) : void

findChessboardCorners

Result = {

returnValue : boolean ,

corners : Point2 []

}

findChessboardCorners ( patternSize : Size , flags : int = cv.CALIB_CB_ADAPTIVE_THRESH + cv.CALIB_CB_NORMALIZE_IMAGE ) : Result

findChessboardCornersAsync ( patternSize : Size , flags : int = cv.CALIB_CB_ADAPTIVE_THRESH + cv.CALIB_CB_NORMALIZE_IMAGE ) : Promise < Result >

findChessboardCornersAsync ( patternSize : Size , flags : int = cv.CALIB_CB_ADAPTIVE_THRESH + cv.CALIB_CB_NORMALIZE_IMAGE , ...opts , callback ( err : Error , Result res )) : void

findContours

Result : Contour []

findContours ( mode : uint , method : uint , offset : Point2 = new Point2(0, 0) ) : Result

findContoursAsync ( mode : uint , method : uint , offset : Point2 = new Point2(0, 0) ) : Promise < Result >

findContoursAsync ( mode : uint , method : uint , offset : Point2 = new Point2(0, 0) , ...opts , callback ( err : Error , Result res )) : void

findEssentialMat

Result = {

E : Mat ,

mask : Mat

}

findEssentialMat ( points1 : Point2 [] , points2 : Point2 [] , method : int = cv.RANSAC , prob : number = 0.999 , threshold : number = 1.0 ) : Result

findEssentialMatAsync ( points1 : Point2 [] , points2 : Point2 [] , method : int = cv.RANSAC , prob : number = 0.999 , threshold : number = 1.0 ) : Promise < Result >

findEssentialMatAsync ( points1 : Point2 [] , points2 : Point2 [] , method : int = cv.RANSAC , prob : number = 0.999 , threshold : number = 1.0 , ...opts , callback ( err : Error , Result res )) : void

findNonZero

Result : Point2 []

findNonZero () : Result

findNonZeroAsync () : Promise < Result >

findNonZeroAsync ( callback ( err : Error , Result res )) : void

flip

Result : Mat

flip ( flipCode : int ) : Result

flipAsync ( flipCode : int ) : Promise < Result >

flipAsync ( flipCode : int , callback ( err : Error , Result res )) : void

floodFill

Result = {

returnValue : int ,

rect : Rect

}

floodFill ( seedPoint : Point2 , newVal : number , mask : Mat = noArray() , loDiff : number = 0 , upDiff : number = 0 , flags : int = 4 ) : Result

floodFillAsync ( seedPoint : Point2 , newVal : number , mask : Mat = noArray() , loDiff : number = 0 , upDiff : number = 0 , flags : int = 4 ) : Promise < Result >

floodFillAsync ( seedPoint : Point2 , newVal : number , mask : Mat = noArray() , loDiff : number = 0 , upDiff : number = 0 , flags : int = 4 , ...opts , callback ( err : Error , Result res )) : void

Result = {

returnValue : int ,

rect : Rect

}

floodFill ( seedPoint : Point2 , newVal : Vec3 , mask : Mat = noArray() , loDiff : Vec3 = Vec3() , upDiff : Vec3 = Vec3() , flags : int = 4 ) : Result

floodFillAsync ( seedPoint : Point2 , newVal : Vec3 , mask : Mat = noArray() , loDiff : Vec3 = Vec3() , upDiff : Vec3 = Vec3() , flags : int = 4 ) : Promise < Result >

floodFillAsync ( seedPoint : Point2 , newVal : Vec3 , mask : Mat = noArray() , loDiff : Vec3 = Vec3() , upDiff : Vec3 = Vec3() , flags : int = 4 , ...opts , callback ( err : Error , Result res )) : void

gaussianBlur

Result : Mat

gaussianBlur ( kSize : Size , sigmaX : number , sigmaY : number = 0.0 , borderType : uint = BORDER_CONSTANT ) : Result

gaussianBlurAsync ( kSize : Size , sigmaX : number , sigmaY : number = 0.0 , borderType : uint = BORDER_CONSTANT ) : Promise < Result >

gaussianBlurAsync ( kSize : Size , sigmaX : number , sigmaY : number = 0.0 , borderType : uint = BORDER_CONSTANT , ...opts , callback ( err : Error , Result res )) : void

getData

Result : Buffer

getData () : Result

getDataAsync () : Promise < Result >

getDataAsync ( callback ( err : Error , Result res )) : void

getDataAsArray

Result : number [][]

getDataAsArray () : Result

Result : number [][][]

getDataAsArray () : Result

Result : number [][][]

getDataAsArray () : Result

Result : number [][][]

getDataAsArray () : Result

getOptimalNewCameraMatrix

Result = {

out : Mat ,

validPixROI : Rect

}

getOptimalNewCameraMatrix ( distCoeffs : number [] , imageSize : Size , alpha : number , newImageSize : Size = new Size() , centerPrincipalPoint : boolean = false ) : Result

getOptimalNewCameraMatrixAsync ( distCoeffs : number [] , imageSize : Size , alpha : number , newImageSize : Size = new Size() , centerPrincipalPoint : boolean = false ) : Promise < Result >

getOptimalNewCameraMatrixAsync ( distCoeffs : number [] , imageSize : Size , alpha : number , newImageSize : Size = new Size() , centerPrincipalPoint : boolean = false , ...opts , callback ( err : Error , Result res )) : void

getRegion

Result : Mat

getRegion ( region : Rect ) : Result

goodFeaturesToTrack

Result : Point2 []

goodFeaturesToTrack ( maxCorners : number , qualityLevel : number , minDistance : number , mask : Mat = noArray() , blockSize : int = 3 , useHarrisDetector : boolean = false , harrisK : number = 0.04 ) : Result

goodFeaturesToTrackAsync ( maxCorners : number , qualityLevel : number , minDistance : number , mask : Mat = noArray() , blockSize : int = 3 , useHarrisDetector : boolean = false , harrisK : number = 0.04 ) : Promise < Result >

Result : Point2 []

goodFeaturesToTrack ( maxCorners : number , qualityLevel : number , minDistance : number , mask : Mat = noArray() , blockSize : int = 3 , gradientSize : int = 3 , useHarrisDetector : boolean = false , harrisK : number = 0.04 ) : Result

goodFeaturesToTrackAsync ( maxCorners : number , qualityLevel : number , minDistance : number , mask : Mat = noArray() , blockSize : int = 3 , gradientSize : int = 3 , useHarrisDetector : boolean = false , harrisK : number = 0.04 ) : Promise < Result >

grabCut

grabCut ( mask : Mat , rect : Rect , bgdModel : Mat , fgdModel : Mat , iterCount : int , mode : int ) : Result

grabCutAsync ( mask : Mat , rect : Rect , bgdModel : Mat , fgdModel : Mat , iterCount : int , mode : int ) : Promise < Result >

grabCutAsync ( mask : Mat , rect : Rect , bgdModel : Mat , fgdModel : Mat , iterCount : int , mode : int , callback ( err : Error , Result res )) : void

hDiv

Result : Mat

hDiv ( otherMat : Mat ) : Result

hMul

Result : Mat

hMul ( otherMat : Mat ) : Result

houghCircles

Result : Vec3 []

houghCircles ( method : int , dp : number , minDist : number , param1 : number = 100.0 , param2 : number = 100.0 , minRadius : int = 0 , maxRadius : int = 0 ) : Result

houghCirclesAsync ( method : int , dp : number , minDist : number , param1 : number = 100.0 , param2 : number = 100.0 , minRadius : int = 0 , maxRadius : int = 0 ) : Promise < Result >

houghCirclesAsync ( method : int , dp : number , minDist : number , param1 : number = 100.0 , param2 : number = 100.0 , minRadius : int = 0 , maxRadius : int = 0 , ...opts , callback ( err : Error , Result res )) : void

houghLines

Result : Vec2 []

houghLines ( rho : number , theta : number , threshold : int , srn : number = 0.0 , stn : number = 0.0 , min_theta : number = 0.0 , max_theta : number = PI ) : Result

houghLinesAsync ( rho : number , theta : number , threshold : int , srn : number = 0.0 , stn : number = 0.0 , min_theta : number = 0.0 , max_theta : number = PI ) : Promise < Result >

houghLinesAsync ( rho : number , theta : number , threshold : int , srn : number = 0.0 , stn : number = 0.0 , min_theta : number = 0.0 , max_theta : number = PI , ...opts , callback ( err : Error , Result res )) : void

houghLinesP

Result : Vec4 []

houghLinesP ( rho : number , theta : number , threshold : int , minLineLength : number = 0.0 , maxLineGap : number = 0.0 ) : Result

houghLinesPAsync ( rho : number , theta : number , threshold : int , minLineLength : number = 0.0 , maxLineGap : number = 0.0 ) : Promise < Result >

houghLinesPAsync ( rho : number , theta : number , threshold : int , minLineLength : number = 0.0 , maxLineGap : number = 0.0 , ...opts , callback ( err : Error , Result res )) : void

idct

Result : Mat

idct ( flags : int = 0 ) : Result

idctAsync ( flags : int = 0 ) : Promise < Result >

idctAsync ( flags : int = 0 , ...opts , callback ( err : Error , Result res )) : void

idft

Result : Mat

idft ( flags : int = 0 , nonzeroRows : int = 0 ) : Result

idftAsync ( flags : int = 0 , nonzeroRows : int = 0 ) : Promise < Result >

idftAsync ( flags : int = 0 , nonzeroRows : int = 0 , ...opts , callback ( err : Error , Result res )) : void

inRange

Result : Mat

inRange ( lower : number , upper : number ) : Result

inRangeAsync ( lower : number , upper : number ) : Promise < Result >

inRangeAsync ( lower : number , upper : number , callback ( err : Error , Result res )) : void

Result : Mat

inRange ( lower : Vec3 , upper : Vec3 ) : Result

inRangeAsync ( lower : Vec3 , upper : Vec3 ) : Promise < Result >

inRangeAsync ( lower : Vec3 , upper : Vec3 , callback ( err : Error , Result res )) : void

integral

Result = {

sum : Mat ,

sqsum : Mat ,

tilted : Mat

}

integral ( sdepth : number = -1 , sqdepth : number = -1 ) : Result

integralAsync ( sdepth : number = -1 , sqdepth : number = -1 ) : Promise < Result >

integralAsync ( sdepth : number = -1 , sqdepth : number = -1 , ...opts , callback ( err : Error , Result res )) : void

laplacian

Result : Mat

laplacian ( ddepth : int , ksize : int = 1 , scale : number = 1.0 , delta : number = 0.0 , borderType : int = BORDER_DEFAULT ) : Result

laplacianAsync ( ddepth : int , ksize : int = 1 , scale : number = 1.0 , delta : number = 0.0 , borderType : int = BORDER_DEFAULT ) : Promise < Result >

laplacianAsync ( ddepth : int , ksize : int = 1 , scale : number = 1.0 , delta : number = 0.0 , borderType : int = BORDER_DEFAULT , ...opts , callback ( err : Error , Result res )) : void

log

Result : Mat

log () : Result

matchTemplate

Result : Mat

matchTemplate ( template : Mat , method : int , mask : Mat = noArray() ) : Result

matchTemplateAsync ( template : Mat , method : int , mask : Mat = noArray() ) : Promise < Result >

matchTemplateAsync ( template : Mat , method : int , mask : Mat = noArray() , ...opts , callback ( err : Error , Result res )) : void

matMulDeriv

Result = {

dABdA : Mat ,

dABdB : Mat

}

matMulDeriv ( B : Mat ) : Result

matMulDerivAsync ( B : Mat ) : Promise < Result >

matMulDerivAsync ( B : Mat , callback ( err : Error , Result res )) : void

mean

Result : Vec4

mean () : Result

meanAsync () : Promise < Result >

meanAsync ( callback ( err : Error , Result res )) : void

meanStdDev

Result = {

mean : Mat ,

stddev : Mat

}

meanStdDev ( mask : Mat = noArray() ) : Result

meanStdDevAsync ( mask : Mat = noArray() ) : Promise < Result >

meanStdDevAsync ( mask : Mat = noArray() , ...opts , callback ( err : Error , Result res )) : void

medianBlur

Result : Mat

medianBlur ( kSize : int ) : Result

medianBlurAsync ( kSize : int ) : Promise < Result >

medianBlurAsync ( kSize : int , callback ( err : Error , Result res )) : void

minMaxLoc

Result = {

minVal : number ,

maxVal : number ,

minLoc : Point2 ,

maxLoc : Point2

}

minMaxLoc ( mask : Mat = noArray() ) : Result

minMaxLocAsync ( mask : Mat = noArray() ) : Promise < Result >

minMaxLocAsync ( mask : Mat = noArray() , ...opts , callback ( err : Error , Result res )) : void

moments

Result : Moments

moments () : Result

momentsAsync () : Promise < Result >

momentsAsync ( callback ( err : Error , Result res )) : void

morphologyEx

Result : Mat

morphologyEx ( kernel : Mat , morphType : int , anchor : Point2 = new Point2(-1, -1) , iterations : uint = 1 , borderType : uint = BORDER_CONSTANT ) : Result

morphologyExAsync ( kernel : Mat , morphType : int , anchor : Point2 = new Point2(-1, -1) , iterations : uint = 1 , borderType : uint = BORDER_CONSTANT ) : Promise < Result >

morphologyExAsync ( kernel : Mat , morphType : int , anchor : Point2 = new Point2(-1, -1) , iterations : uint = 1 , borderType : uint = BORDER_CONSTANT , ...opts , callback ( err : Error , Result res )) : void

mul

Result : Mat

mul ( s : number ) : Result

mulSpectrums

Result : Mat

mulSpectrums ( mat2 : Mat , dftRows : boolean = false , conjB : boolean = false ) : Result

mulSpectrumsAsync ( mat2 : Mat , dftRows : boolean = false , conjB : boolean = false ) : Promise < Result >

mulSpectrumsAsync ( mat2 : Mat , dftRows : boolean = false , conjB : boolean = false , ...opts , callback ( err : Error , Result res )) : void

norm

Result : number

norm ( src2 : Mat , normType : uint = NORM_L2 , mask : Mat = noArray() ) : Result

Result : number

norm ( normType : uint = NORM_L2 , mask : Mat = noArray() ) : Result

normalize

Result : Mat

normalize ( alpha : number = 1.0 , beta : number = 0.0 , normType : uint = NORM_L2 , dtype : int = -1 , mask : Mat = noArray() ) : Result

or

Result : Mat

or ( otherMat : Mat ) : Result

perspectiveTransform

Result : Mat

perspectiveTransform ( m : Mat ) : Result

perspectiveTransformAsync ( m : Mat ) : Promise < Result >

perspectiveTransformAsync ( m : Mat , callback ( err : Error , Result res )) : void

popBack

Result : Mat

popBack ( numRows : number = 1 ) : Result

popBackAsync ( numRows : number = 1 ) : Promise < Result >

popBackAsync ( numRows : number = 1 , ...opts , callback ( err : Error , Result res )) : void

pop_back

Result : Mat

pop_back ( numRows : number = 1 ) : Result

pop_backAsync ( numRows : number = 1 ) : Promise < Result >

pop_backAsync ( numRows : number = 1 , ...opts , callback ( err : Error , Result res )) : void

pushBack

Result : Mat

pushBack ( mat : Mat ) : Result

pushBackAsync ( mat : Mat ) : Promise < Result >

pushBackAsync ( mat : Mat , callback ( err : Error , Result res )) : void

push_back

Result : Mat

push_back ( mat : Mat ) : Result

push_backAsync ( mat : Mat ) : Promise < Result >

push_backAsync ( mat : Mat , callback ( err : Error , Result res )) : void

putText

putText ( text : string , origin : Point2 , fontFace : int , fontScale : number , color : Vec3 = new Vec(0, 0; 0) , lineType : int = LINE_8 , thickness : int = 1 , bottomLeftOrigin : boolean = false ) : Result

pyrDown

Result : Mat

pyrDown ( size : Size = Size() , borderType : int = BORDER_DEFAULT ) : Result

pyrDownAsync ( size : Size = Size() , borderType : int = BORDER_DEFAULT ) : Promise < Result >

pyrDownAsync ( size : Size = Size() , borderType : int = BORDER_DEFAULT , ...opts , callback ( err : Error , Result res )) : void

pyrUp

Result : Mat

pyrUp ( size : Size = Size() , borderType : int = BORDER_DEFAULT ) : Result

pyrUpAsync ( size : Size = Size() , borderType : int = BORDER_DEFAULT ) : Promise < Result >

pyrUpAsync ( size : Size = Size() , borderType : int = BORDER_DEFAULT , ...opts , callback ( err : Error , Result res )) : void

recoverPose

Result = {

returnValue : int ,

R : Mat ,

T : Vec3

}

recoverPose ( E : Mat , points1 : Point2 [] , points2 : Point2 [] , mask : Mat = noArray() ) : Result

recoverPoseAsync ( E : Mat , points1 : Point2 [] , points2 : Point2 [] , mask : Mat = noArray() ) : Promise < Result >

recoverPoseAsync ( E : Mat , points1 : Point2 [] , points2 : Point2 [] , mask : Mat = noArray() , ...opts , callback ( err : Error , Result res )) : void

rectify3Collinear

Result = {

returnValue : number ,

R1 : Mat ,

R2 : Mat ,

R3 : Mat ,

P1 : Mat ,

P2 : Mat ,

P3 : Mat ,

Q : Mat ,

roi1 : Rect ,

roi2 : Rect

}

rectify3Collinear ( distCoeffs1 : number [] , cameraMatrix2 : Mat , distCoeffs2 : number [] , cameraMatrix3 : Mat , distCoeffs3 : number [] , imageSize : Size , R12 : Mat , T12 : Vec3 , R13 : Mat , T13 : Vec3 , alpha : number , newImageSize : Size , flags : int ) : Result

rectify3CollinearAsync ( distCoeffs1 : number [] , cameraMatrix2 : Mat , distCoeffs2 : number [] , cameraMatrix3 : Mat , distCoeffs3 : number [] , imageSize : Size , R12 : Mat , T12 : Vec3 , R13 : Mat , T13 : Vec3 , alpha : number , newImageSize : Size , flags : int ) : Promise < Result >

reprojectImageTo3D

Result : Mat

reprojectImageTo3D ( Q : Mat , handleMissingValues : boolean = false , ddepth : int = -1 ) : Result

reprojectImageTo3DAsync ( Q : Mat , handleMissingValues : boolean = false , ddepth : int = -1 ) : Promise < Result >

reprojectImageTo3DAsync ( Q : Mat , handleMissingValues : boolean = false , ddepth : int = -1 , ...opts , callback ( err : Error , Result res )) : void

rescale

Result : Mat

rescale ( factor : number ) : Result

rescaleAsync ( factor : number ) : Promise < Result >

rescaleAsync ( factor : number , callback ( err : Error , Result res )) : void

resize

Result : Mat

resize ( rows : uint , cols : uint , fx : number = 0 , fy : number = 0 , interpolation : int = INTER_LINEAR ) : Result

resizeAsync ( rows : uint , cols : uint , fx : number = 0 , fy : number = 0 , interpolation : int = INTER_LINEAR ) : Promise < Result >

resizeAsync ( rows : uint , cols : uint , fx : number = 0 , fy : number = 0 , interpolation : int = INTER_LINEAR , ...opts , callback ( err : Error , Result res )) : void

Result : Mat

resize ( dsize : Size , fx : number = 0 , fy : number = 0 , interpolation : int = INTER_LINEAR ) : Result

resizeAsync ( dsize : Size , fx : number = 0 , fy : number = 0 , interpolation : int = INTER_LINEAR ) : Promise < Result >

resizeAsync ( dsize : Size , fx : number = 0 , fy : number = 0 , interpolation : int = INTER_LINEAR , ...opts , callback ( err : Error , Result res )) : void

resizeToMax

Result : Mat

resizeToMax ( maxRowsOrCols : uint ) : Result

resizeToMaxAsync ( maxRowsOrCols : uint ) : Promise < Result >

resizeToMaxAsync ( maxRowsOrCols : uint , callback ( err : Error , Result res )) : void

rodrigues

Result = {

dst : Mat ,

jacobian : Mat

}

rodrigues () : Result

rodriguesAsync () : Promise < Result >

rodriguesAsync ( callback ( err : Error , Result res )) : void

rotate

Result : Mat

rotate ( rotateCode : int ) : Result

rotateAsync ( rotateCode : int ) : Promise < Result >

rotateAsync ( rotateCode : int , callback ( err : Error , Result res )) : void

rqDecomp3x3

Result = {

returnValue : Vec3 ,

mtxR : Mat ,

mtxQ : Mat ,

Qx : Mat ,

Qy : Mat ,

Qz : Mat

}

rqDecomp3x3 () : Result

rqDecomp3x3Async () : Promise < Result >

rqDecomp3x3Async ( callback ( err : Error , Result res )) : void

scharr

Result : Mat

scharr ( ddepth : int , dx : int , dy : int , scale : number = 1.0 , delta : number = 0.0 , borderType : int = BORDER_DEFAULT ) : Result

scharrAsync ( ddepth : int , dx : int , dy : int , scale : number = 1.0 , delta : number = 0.0 , borderType : int = BORDER_DEFAULT ) : Promise < Result >

scharrAsync ( ddepth : int , dx : int , dy : int , scale : number = 1.0 , delta : number = 0.0 , borderType : int = BORDER_DEFAULT , ...opts , callback ( err : Error , Result res )) : void

sepFilter2D

Result : Mat

sepFilter2D ( ddepth : int , kernelX : Mat , kernelY : Mat , anchor : Point2 = new Point(-1, -1) , delta : number = 0 , borderType : int = BORDER_DEFAULT ) : Result

sepFilter2DAsync ( ddepth : int , kernelX : Mat , kernelY : Mat , anchor : Point2 = new Point(-1, -1) , delta : number = 0 , borderType : int = BORDER_DEFAULT ) : Promise < Result >

sepFilter2DAsync ( ddepth : int , kernelX : Mat , kernelY : Mat , anchor : Point2 = new Point(-1, -1) , delta : number = 0 , borderType : int = BORDER_DEFAULT , ...opts , callback ( err : Error , Result res )) : void

set

set ( row : uint , col : uint , value : number ) : Result

set ( row : uint , col : uint , value : number []) : Result

set ( row : uint , col : uint , value : Vec2 ) : Result

set ( row : uint , col : uint , value : Vec3 ) : Result

set ( row : uint , col : uint , value : Vec4 ) : Result

sobel

Result : Mat

sobel ( ddepth : int , dx : int , dy : int , ksize : int = 3 , scale : number = 1.0 , delta : number = 0.0 , borderType : int = BORDER_DEFAULT ) : Result

sobelAsync ( ddepth : int , dx : int , dy : int , ksize : int = 3 , scale : number = 1.0 , delta : number = 0.0 , borderType : int = BORDER_DEFAULT ) : Promise < Result >

sobelAsync ( ddepth : int , dx : int , dy : int , ksize : int = 3 , scale : number = 1.0 , delta : number = 0.0 , borderType : int = BORDER_DEFAULT , ...opts , callback ( err : Error , Result res )) : void

split

Result : Mat []

split () : Result

splitAsync () : Promise < Result >

splitAsync ( callback ( err : Error , Result res )) : void

splitChannels

Result : Mat []

splitChannels () : Result

splitChannelsAsync () : Promise < Result >

splitChannelsAsync ( callback ( err : Error , Result res )) : void

sqrBoxFilter

Result : Mat

sqrBoxFilter ( ddepth : int , ksize : Size , anchor : Point2 = new Point(-1, -1) , normalize : boolean = true , borderType : int = BORDER_DEFAULT ) : Result

sqrBoxFilterAsync ( ddepth : int , ksize : Size , anchor : Point2 = new Point(-1, -1) , normalize : boolean = true , borderType : int = BORDER_DEFAULT ) : Promise < Result >

sqrBoxFilterAsync ( ddepth : int , ksize : Size , anchor : Point2 = new Point(-1, -1) , normalize : boolean = true , borderType : int = BORDER_DEFAULT , ...opts , callback ( err : Error , Result res )) : void

sqrt

Result : Mat

sqrt () : Result

stereoRectify

Result = {

R1 : Mat ,

R2 : Mat ,

P1 : Mat ,

P2 : Mat ,

Q : Mat ,

roi1 : Rect ,

roi2 : Rect

}

stereoRectify ( distCoeffs1 : number [] , cameraMatrix2 : Mat , distCoeffs2 : number [] , imageSize : Size , R : Mat , T : Vec3 , flags : int = cv.CALIB_ZERO_DISPARITY , alpha : number = -1 , newImageSize : Size = new Size() ) : Result

stereoRectifyAsync ( distCoeffs1 : number [] , cameraMatrix2 : Mat , distCoeffs2 : number [] , imageSize : Size , R : Mat , T : Vec3 , flags : int = cv.CALIB_ZERO_DISPARITY , alpha : number = -1 , newImageSize : Size = new Size() ) : Promise < Result >

sub

Result : Mat

sub ( otherMat : Mat ) : Result

sum

Result : number

sum () : Result

sumAsync () : Promise < Result >

sumAsync ( callback ( err : Error , Result res )) : void

Result : Vec2

sum () : Result

sumAsync () : Promise < Result >

sumAsync ( callback ( err : Error , Result res )) : void

Result : Vec3

sum () : Result

sumAsync () : Promise < Result >

sumAsync ( callback ( err : Error , Result res )) : void

Result : Vec4

sum () : Result

sumAsync () : Promise < Result >

sumAsync ( callback ( err : Error , Result res )) : void

threshold

Result : Mat

threshold ( thresh : number , maxVal : number , type : uint ) : Result

thresholdAsync ( thresh : number , maxVal : number , type : uint ) : Promise < Result >

thresholdAsync ( thresh : number , maxVal : number , type : uint , callback ( err : Error , Result res )) : void

transform

Result : Mat

transform ( m : Mat ) : Result

transformAsync ( m : Mat ) : Promise < Result >

transformAsync ( m : Mat , callback ( err : Error , Result res )) : void

transpose

Result : Mat

transpose () : Result

triangulatePoints

Result : Mat

triangulatePoints ( projPoints1 : Point2 [] , projPoints2 : Point2 []) : Result

triangulatePointsAsync ( projPoints1 : Point2 [] , projPoints2 : Point2 []) : Promise < Result >

triangulatePointsAsync ( projPoints1 : Point2 [] , projPoints2 : Point2 [] , callback ( err : Error , Result res )) : void

validateDisparity

validateDisparity ( cost : Mat , minDisparity : int , numberOfDisparities : int , disp12MaxDisp : int = 1 ) : Result

validateDisparityAsync ( cost : Mat , minDisparity : int , numberOfDisparities : int , disp12MaxDisp : int = 1 ) : Promise < Result >

validateDisparityAsync ( cost : Mat , minDisparity : int , numberOfDisparities : int , disp12MaxDisp : int = 1 , ...opts , callback ( err : Error , Result res )) : void

warpAffine

Result : Mat

warpAffine ( transforMationMatrix : Mat , size : Size = new Size(this.cols, this.rows) , flags : uint = INTER_LINEAR , borderMode : uint = BORDER_CONSTANT ) : Result

warpAffineAsync ( transforMationMatrix : Mat , size : Size = new Size(this.cols, this.rows) , flags : uint = INTER_LINEAR , borderMode : uint = BORDER_CONSTANT ) : Promise < Result >

warpAffineAsync ( transforMationMatrix : Mat , size : Size = new Size(this.cols, this.rows) , flags : uint = INTER_LINEAR , borderMode : uint = BORDER_CONSTANT , ...opts , callback ( err : Error , Result res )) : void

warpPerspective

Result : Mat

warpPerspective ( transforMationMatrix : Mat , size : Size = new Size(this.cols, this.rows) , flags : uint = INTER_LINEAR , borderMode : uint = BORDER_CONSTANT ) : Result

warpPerspectiveAsync ( transforMationMatrix : Mat , size : Size = new Size(this.cols, this.rows) , flags : uint = INTER_LINEAR , borderMode : uint = BORDER_CONSTANT ) : Promise < Result >

warpPerspectiveAsync ( transforMationMatrix : Mat , size : Size = new Size(this.cols, this.rows) , flags : uint = INTER_LINEAR , borderMode : uint = BORDER_CONSTANT , ...opts , callback ( err : Error , Result res )) : void

watershed

Result : Mat

watershed ( markers : Mat ) : Result

watershedAsync ( markers : Mat ) : Promise < Result >

watershedAsync ( markers : Mat , callback ( err : Error , Result res )) : void