core

Mat

fields

Mat = {
rows : number ,
cols : number ,
type : number ,
channels : number ,
depth : number ,
dims : number ,
empty : boolean ,
step : number ,
elemSize : number ,
sizes : number []
}

constructors

constructor ()
constructor ( channels : Mat [])
constructor ( rows : uint , cols : uint , type : uint )
constructor ( rows : uint , cols : uint , type : uint , fillValue : number )
constructor ( rows : uint , cols : uint , type : uint , fillValue : number [])
constructor ( rows : uint , cols : uint , type : uint , fillValue : number [])
constructor ( rows : uint , cols : uint , type : uint , fillValue : number [])
constructor ( dataArray : number [][] , type : uint )
constructor ( dataArray : number [][][] , type : uint )
constructor ( dataArray : number [][][] , type : uint )
constructor ( dataArray : number [][][] , type : uint )
constructor ( data : Buffer , rows : uint , cols : uint , type : uint = CV_8U )

functions

abs

Result : Mat
abs () : Result

absdiff

Result : Mat
absdiff ( otherMat : Mat ) : Result

adaptiveThreshold

Result : Mat
adaptiveThreshold ( maxVal : number , adaptiveMethod : int , thresholdType : int , blockSize : int , C : number ) : Result
adaptiveThresholdAsync ( maxVal : number , adaptiveMethod : int , thresholdType : int , blockSize : int , C : number ) : Promise < Result >
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 >
goodFeaturesToTrackAsync ( maxCorners : number , qualityLevel : number , minDistance : number , mask : Mat = noArray() , blockSize : int = 3 , useHarrisDetector : boolean = false , harrisK : number = 0.04 , ...opts , callback ( err :