cv

cv

functions

blobFromImage

Result : Mat
blobFromImage ( image : Mat , scaleFactor : number = 1.0 , size : Size = Size() , mean : Vec3 = Vec3() , swapRB : boolean = true ) : Result
blobFromImageAsync ( image : Mat , scaleFactor : number = 1.0 , size : Size = Size() , mean : Vec3 = Vec3() , swapRB : boolean = true ) : Promise < Result >
blobFromImageAsync ( image : Mat , scaleFactor : number = 1.0 , size : Size = Size() , mean : Vec3 = Vec3() , swapRB : boolean = true , ...opts , callback ( err : Error , Result res )) : void

blobFromImages

Result : Mat
blobFromImages ( image : Mat [] , scaleFactor : number = 1.0 , size : Size = Size() , mean : Vec3 = Vec3() , swapRB : boolean = true ) : Result
blobFromImagesAsync ( image : Mat [] , scaleFactor : number = 1.0 , size : Size = Size() , mean : Vec3 = Vec3() , swapRB : boolean = true ) : Promise < Result >
blobFromImagesAsync ( image : Mat [] , scaleFactor : number = 1.0 , size : Size = Size() , mean : Vec3 = Vec3() , swapRB : boolean = true , ...opts , callback ( err : Error , Result res )) : void

calcHist

Result : Mat
calcHist ( img : Mat , histAxes : HistAxes [] , mask : Mat = noArray() ) : Result

calibrateCamera

Result = {
returnValue : number ,
rvecs : Vec3 [] ,
tvecs : Vec3 []
}
calibrateCamera ( objectPoints : Point3 [] , imagePoints : Point2 [] , imageSize : Size , cameraMatrix : Mat , distCoeffs : number [] , flags : int = 0 , criteria : TermCriteria = new TermCriteria(cv.TermCriteria.COUNT + cv.TermCriteria.EPS, 30; DBL_EPSILON) ) : Result
calibrateCameraAsync ( objectPoints : Point3 [] , imagePoints : Point2 [] , imageSize : Size , cameraMatrix : Mat , distCoeffs : number [] , flags : int = 0 , criteria : TermCriteria = new TermCriteria(cv.TermCriteria.COUNT + cv.TermCriteria.EPS, 30; DBL_EPSILON) ) : Promise < Result >
calibrateCameraAsync ( objectPoints : Point3 [] , imagePoints : Point2 [] , imageSize : Size , cameraMatrix : Mat , distCoeffs : number [] , flags : int = 0 , criteria : TermCriteria = new TermCriteria(cv.TermCriteria.COUNT + cv.TermCriteria.EPS, 30; DBL_EPSILON) , ...opts , callback ( err : Error , Result res )) : void

calibrateCameraExtended

Result = {
returnValue : number ,
rvecs : Vec3 [] ,
tvecs : Vec3 [] ,
stdDeviationsIntrinsics : Mat ,
stdDeviationsExtrinsics : Mat ,
perViewErrors : number []
}
calibrateCameraExtended ( objectPoints : Point3 [] , imagePoints : Point2 [] , imageSize : Size , cameraMatrix : Mat , distCoeffs : number [] , flags : int = 0 , criteria : TermCriteria = new TermCriteria(cv.TermCriteria.COUNT + cv.TermCriteria.EPS, 30; DBL_EPSILON) ) : Result
calibrateCameraExtendedAsync ( objectPoints : Point3 [] , imagePoints : Point2 [] , imageSize : Size , cameraMatrix : Mat , distCoeffs : number [] , flags : int = 0 , criteria : TermCriteria = new TermCriteria(cv.TermCriteria.COUNT + cv.TermCriteria.EPS, 30; DBL_EPSILON) ) : Promise < Result >
calibrateCameraExtendedAsync ( objectPoints : Point3 [] , imagePoints : Point2 [] , imageSize : Size , cameraMatrix : Mat , distCoeffs : number [] , flags : int = 0 , criteria : TermCriteria = new TermCriteria(cv.TermCriteria.COUNT + cv.TermCriteria.EPS, 30; DBL_EPSILON) , ...opts , callback ( err : Error , Result res )) : void

canny

Result : Mat
canny ( dx : Mat , dy : Mat , threshold1 : number , threshold2 : number , L2gradient : boolean = false ) : Result

cartToPolar

Result = {
magnitude : Mat ,
angle : Mat
}
cartToPolar ( x : Mat , y : Mat , angleInDegrees : boolean = false ) : Result
cartToPolarAsync ( x : Mat , y : Mat , angleInDegrees : boolean = false ) : Promise < Result >
cartToPolarAsync ( x : Mat , y : Mat , angleInDegrees : boolean = false , ...opts , callback ( err : Error , Result res )) : void

composeRT

Result = {
rvec3 : Vec3 ,
tvec3 : Vec3 ,
dr3dr1 : Mat ,
dr3dt1 : Mat ,
dr3dr2 : Mat ,
dr3dt2 : Mat ,
dt3dr1 : Mat ,
dt3dt1 : Mat ,
dt3dr2 : Mat ,
dt3dt2 : Mat
}
composeRT ( rvec1 : Vec3 , tvec1 : Vec3 , rvec2 : Vec3 , tvec2 : Vec3 ) : Result
composeRTAsync ( rvec1 : Vec3 , tvec1 : Vec3 , rvec2 : Vec3 , tvec2 : Vec3 ) : Promise < Result >
composeRTAsync ( rvec1 : Vec3 , tvec1 : Vec3 , rvec2 : Vec3 , tvec2 : Vec3 , callback ( err : Error , Result res )) : void

computeCorrespondEpilines

Result : Vec3 []
computeCorrespondEpilines ( points : Point2 [] , whichImage : int , F : Mat ) : Result
computeCorrespondEpilinesAsync ( points : Point2 [] , whichImage : int , F : Mat ) : Promise < Result >
computeCorrespondEpilinesAsync ( points : Point2 [] , whichImage : int , F : Mat , callback ( err : Error , Result res )) : void

createOCRHMMTransitionsTable

Result : Mat
createOCRHMMTransitionsTable ( vocabulary : string , lexicon : string []) : Result
createOCRHMMTransitionsTableAsync ( vocabulary : string , lexicon : string []) : Promise < Result >
createOCRHMMTransitionsTableAsync ( vocabulary : string , lexicon : string [] , callback ( err : Error , Result res )) : void

dangerousDisableCustomMatAllocator

Result : boolean
dangerousDisableCustomMatAllocator () : Result

dangerousEnableCustomMatAllocator

Result : boolean
dangerousEnableCustomMatAllocator () : Result

destroyAllWindows

Result : void
destroyAllWindows () : Result

destroyWindow

Result : void
destroyWindow ( winName : string ) : Result

drawDetection

Result : Rect
drawDetection ( img : Mat , inputRect : Rect , opts : DrawDetectionParams = {} ) : Result

drawKeyPoints

Result : Mat
drawKeyPoints ( img : Mat , keyPoints : KeyPoint []) : Result

drawMatches

Result : Mat
drawMatches ( img1 : Mat , img2 : Mat , keyPoints1 : KeyPoint [] , keyPoints2 : KeyPoint [] , matches : DescriptorMatch []) : Result

drawTextBox

Result : Mat
drawTextBox ( img : Mat , upperLeft : Point2 , textLines : TextLine [] , alpha : number ) : Result

estimateAffine2D

Result = {
out : Mat ,
inliers : Mat
}
estimateAffine2D ( from : Point2 [] , to : Point2 [] , method : int = cv.RANSAC , ransacReprojThreshold : number = 3.0 , maxIters : int = 2000 , confidence : number = 0.99 , refineIters : int = 10 ) : Result
estimateAffine2DAsync ( from : Point2 [] , to : Point2 [] , method : int = cv.RANSAC , ransacReprojThreshold : number = 3.0 , maxIters : int = 2000 , confidence : number = 0.99 , refineIters : int = 10 ) : Promise < Result >
estimateAffine2DAsync ( from : Point2 [] , to : Point2 [] , method : int = cv.RANSAC , ransacReprojThreshold : number = 3.0 , maxIters : int = 2000 , confidence : number = 0.99 , refineIters : int = 10 , ...opts , callback ( err : Error , Result res )) : void

estimateAffine3D

Result = {
returnValue : int ,
out : Mat ,
inliers : Mat
}
estimateAffine3D ( src : Point3 [] , dst : Point3 [] , ransacThreshold : number = 3.0 , confidence : number = 0.99 ) : Result
estimateAffine3DAsync ( src : Point3 [] , dst : Point3 [] , ransacThreshold : number = 3.0 , confidence : number = 0.99 ) : Promise < Result >
estimateAffine3DAsync ( src : Point3 [] , dst : Point3 [] , ransacThreshold : number = 3.0 , confidence : number = 0.99 , ...opts , callback ( err : Error , Result res )) : void
Result = {
out : Mat ,
inliers : Mat
}
estimateAffine3D ( from : Point2 [] , to : Point2 [] , method : int = cv.RANSAC , ransacReprojThreshold : number = 3.0 , maxIters : int = 2000 , confidence : number = 0.99 , refineIters : int = 10 ) : Result
estimateAffine3DAsync ( from : Point2 [] , to : Point2 [] , method : int = cv.RANSAC , ransacReprojThreshold : number = 3.0 , maxIters : int = 2000 , confidence : number = 0.99 , refineIters : int = 10 ) : Promise < Result >
estimateAffine3DAsync ( from : Point2 [] , to : Point2 [] , method : int = cv.RANSAC , ransacReprojThreshold : number = 3.0 , maxIters : int = 2000 , confidence : number = 0.99 , refineIters : int = 10 , ...opts , callback ( err : Error , Result res )) : void

estimateAffinePartial2D

Result = {
out : Mat ,
inliers : Mat
}
estimateAffinePartial2D ( from : Point2 [] , to : Point2 [] , method : int = cv.RANSAC , ransacReprojThreshold : number = 3.0 , maxIters : int = 2000 , confidence : number = 0.99 , refineIters : int = 10 ) : Result
estimateAffinePartial2DAsync ( from : Point2 [] , to : Point2 [] , method : int = cv.RANSAC , ransacReprojThreshold : number = 3.0 , maxIters : int = 2000 , confidence : number = 0.99 , refineIters : int = 10 ) : Promise < Result >
estimateAffinePartial2DAsync ( from : Point2 [] , to : Point2 [] , method : int = cv.RANSAC , ransacReprojThreshold : number = 3.0 , maxIters : int = 2000 , confidence : number = 0.99 , refineIters : int = 10 , ...opts , callback ( err : Error , Result res )) : void

fastNlMeansDenoisingColored

Result : Mat
fastNlMeansDenoisingColored ( src : Mat , h : number = 3 , hColor : number = 3 , templateWindowSize : uint = 7 , searchWindowSize : uint = 21 ) : Result

findEssentialMat

Result = {
E : Mat ,
mask : Mat
}
findEssentialMat ( points1 : Point2 [] , points2 : Point2 [] , focal : number = 1.0 , pp : Point2 = new Point(0, 0) , method : int = cv.RANSAC , prob : number = 0.999 , threshold : number = 1.0 ) : Result
findEssentialMatAsync ( points1 : Point2 [] , points2 : Point2 [] , focal : number = 1.0 , pp : Point2 = new Point(0, 0) , method : int = cv.RANSAC , prob : number = 0.999 , threshold : number = 1.0 ) : Promise < Result >
findEssentialMatAsync ( points1 : Point2 [] , points2 : Point2 [] , focal : number = 1.0 , pp : Point2 = new Point(0, 0) , method : int = cv.RANSAC , prob : number = 0.999 , threshold : number = 1.0 , ...opts , callback ( err : Error , Result res )) : void

findFundamentalMat

Result = {
F : Mat ,
mask : Mat
}
findFundamentalMat ( points1 : Point2 [] , points2 : Point2 [] , method : int = cv.FM_RANSAC , param1 : number = 3.0 , param2 : number = 0.99 ) : Result
findFundamentalMatAsync ( points1 : Point2 [] , points2 : Point2 [] , method : int = cv.FM_RANSAC , param1 : number = 3.0 , param2 : number = 0.99 ) : Promise < Result >
findFundamentalMatAsync ( points1 : Point2 [] , points2 : Point2 [] , method : int = cv.FM_RANSAC , param1 : number = 3.0 , param2 : number = 0.99 , ...opts , callback ( err : Error , Result res )) : void

findHomography

Result = {
returnValue : Mat ,
mask : Mat
}
findHomography ( srcPoints : Point2 [] , dstPoints : Point2 [] , method : uint = 0 , ransacReprojThreshold : number = 3 , maxIters : uint = 2000 , confidence : number = 0.995 ) : Result

fitLine

Result : number []
fitLine ( points : Point2 [] , distType : uint , param : number , reps : number , aeps : number ) : Result
Result : number []
fitLine ( points : Point3 [] , distType : uint , param : number , reps : number , aeps : number ) : Result

getAffineTransform

Result : Mat
getAffineTransform ( srcPoints : Point2 [] , dstPoints : Point2 []) : Result

getMemMetrics

Result = {
TotalAlloc : number ,
TotalKnownByJS : number ,
NumAllocations : number ,
NumDeAllocations : number
}
getMemMetrics () : Result

getPerspectiveTransform

Result : Mat
getPerspectiveTransform ( srcPoints : Point2 [] , dstPoints : Point2 []) : Result

getRotationMatrix2D

Result : Mat
getRotationMatrix2D ( center : Point2 , angle : number , scale : number = 1.0 ) : Result

getStructuringElement

Result : Mat
getStructuringElement ( shape : uint , kernelSize : Size , anchor : Point2 = new Point(-1, -1) ) : Result

getValidDisparityROI

Result : Rect
getValidDisparityROI ( roi1 : Rect [] , roi2 : Rect [] , minDisparity : int , numberOfDisparities : int , SADWindowSize : int ) : Result
getValidDisparityROIAsync ( roi1 : Rect [] , roi2 : Rect [] , minDisparity : int , numberOfDisparities : int , SADWindowSize : int ) : Promise < Result >
getValidDisparityROIAsync ( roi1 : Rect [] , roi2 : Rect [] , minDisparity : int , numberOfDisparities : int , SADWindowSize : int , callback ( err : Error , Result res )) : void

imdecode

Result : Mat
imdecode ( buffer : Buffer , flags : int = IMREAD_ANYCOLOR ) : Result
imdecodeAsync ( buffer : Buffer , flags : int = IMREAD_ANYCOLOR ) : Promise < Result >
imdecodeAsync ( buffer : Buffer , flags : int = IMREAD_ANYCOLOR , ...opts , callback ( err : Error , Result res )) : void

imencode

Result : Buffer
imencode ( fileExt : string , img : Mat , flags : int [] = [] ) : Result
imencodeAsync ( fileExt : string , img : Mat , flags : int [] = [] ) : Promise < Result >
imencodeAsync ( fileExt : string , img : Mat , flags : int [] = [] , ...opts , callback ( err : Error , Result res )) : void

imread

Result : Mat
imread ( filePath : string , flags : int = cv.IMREAD_COLOR ) : Result
imreadAsync ( filePath : string , flags : int = cv.IMREAD_COLOR ) : Promise < Result >
imreadAsync ( filePath : string , flags : int = cv.IMREAD_COLOR , ...opts , callback ( err : Error , Result res )) : void

imshow

imshow ( winName : string , img : Mat ) : Result

imshowWait

imshowWait ( winName : string , img : Mat ) : Result

imwrite

imwrite ( filePath : string , img : Mat , flags : int [] = [] ) : Result
imwriteAsync ( filePath : string , img : Mat , flags : int [] = [] ) : Promise < Result >
imwriteAsync ( filePath : string , img : Mat , flags : int [] = [] , ...opts , callback ( err : Error , Result res )) : void

initCameraMatrix2D

Result : Mat
initCameraMatrix2D ( objectPoints : Point3 [] , imagePoints : Point2 [] , imageSize : Size , aspectRatio : number = 1.0 ) : Result
initCameraMatrix2DAsync ( objectPoints : Point3 [] , imagePoints : Point2 [] , imageSize : Size , aspectRatio : number = 1.0 ) : Promise < Result >
initCameraMatrix2DAsync ( objectPoints : Point3 [] , imagePoints : Point2 [] , imageSize : Size , aspectRatio : number = 1.0 , ...opts , callback ( err : Error , Result res )) : void

inpaint

Result : Mat
inpaint ( src : Mat , mask : Mat , inpaintRadius : number , flags : number ) : Result
inpaintAsync ( src : Mat , mask : Mat , inpaintRadius : number , flags : number ) : Promise < Result >
inpaintAsync ( src : Mat , mask : Mat , inpaintRadius : number , flags : number , callback ( err : Error , Result res )) : void

isCustomMatAllocatorEnabled

Result : boolean
isCustomMatAllocatorEnabled () : Result

kmeans

Result = {
labels : int [] ,
centers : Point2 []
}
kmeans ( data : Point2 [] , k : int , attempts : int , termCriteria : TermCriteria , flags : int ) : Result

loadOCRHMMClassifierCNN

Result : OCRHMMClassifier
loadOCRHMMClassifierCNN ( file : string ) : Result
loadOCRHMMClassifierCNNAsync ( file : string ) : Promise < Result >
loadOCRHMMClassifierCNNAsync ( file : string , callback ( err : Error , Result res )) : void

loadOCRHMMClassifierNM

Result : OCRHMMClassifier
loadOCRHMMClassifierNM ( file : string ) : Result
loadOCRHMMClassifierNMAsync ( file : string ) : Promise < Result >
loadOCRHMMClassifierNMAsync ( file : string , callback ( err : Error , Result res )) : void

matchBruteForce

Result : DescriptorMatch []
matchBruteForce ( descriptors1 : Mat , descriptors2 : Mat ) : Result
matchBruteForceAsync ( descriptors1 : Mat , descriptors2 : Mat ) : Promise < Result >
matchBruteForceAsync ( descriptors1 : Mat , descriptors2 : Mat , callback ( err : Error , Result res )) : void

matchBruteForceHamming

Result : DescriptorMatch []
matchBruteForceHamming ( descriptors1 : Mat , descriptors2 : Mat ) : Result
matchBruteForceHammingAsync ( descriptors1 : Mat , descriptors2 : Mat ) : Promise < Result >
matchBruteForceHammingAsync ( descriptors1 : Mat , descriptors2 : Mat , callback ( err : Error , Result res )) : void

matchBruteForceHammingLut

Result : DescriptorMatch []
matchBruteForceHammingLut ( descriptors1 : Mat , descriptors2 : Mat ) : Result
matchBruteForceHammingLutAsync ( descriptors1 : Mat , descriptors2 : Mat ) : Promise < Result >
matchBruteForceHammingLutAsync ( descriptors1 : Mat , descriptors2 : Mat , callback ( err : Error , Result res )) : void

matchBruteForceL1

Result : DescriptorMatch []
matchBruteForceL1 ( descriptors1 : Mat , descriptors2 : Mat ) : Result
matchBruteForceL1Async ( descriptors1 : Mat , descriptors2 : Mat ) : Promise < Result >
matchBruteForceL1Async ( descriptors1 : Mat , descriptors2 : Mat , callback ( err : Error , Result res )) : void

matchBruteForceSL2

Result : DescriptorMatch []
matchBruteForceSL2 ( descriptors1 : Mat , descriptors2 : Mat ) : Result
matchBruteForceSL2Async ( descriptors1 : Mat , descriptors2 : Mat ) : Promise < Result >
matchBruteForceSL2Async ( descriptors1 : Mat , descriptors2 : Mat , callback ( err : Error , Result res )) : void

matchFlannBased

Result : DescriptorMatch []
matchFlannBased ( descriptors1 : Mat , descriptors2 : Mat ) : Result
matchFlannBasedAsync ( descriptors1 : Mat , descriptors2 : Mat ) : Promise < Result >
matchFlannBasedAsync ( descriptors1 : Mat , descriptors2 : Mat , callback ( err : Error , Result res )) : void

matchKnnBruteForce

Result : DescriptorMatch [][]
matchKnnBruteForce ( descriptors1 : Mat , descriptors2 : Mat , k : int ) : Result
matchKnnBruteForceAsync ( descriptors1 : Mat , descriptors2 : Mat , k : int ) : Promise < Result >
matchKnnBruteForceAsync ( descriptors1 : Mat , descriptors2 : Mat , k : int , callback ( err : Error , Result res )) : void

matchKnnBruteForceHamming

Result : DescriptorMatch [][]
matchKnnBruteForceHamming ( descriptors1 : Mat , descriptors2 : Mat , k : int ) : Result
matchKnnBruteForceHammingAsync ( descriptors1 : Mat , descriptors2 : Mat , k : int ) : Promise < Result >
matchKnnBruteForceHammingAsync ( descriptors1 : Mat , descriptors2 : Mat , k : int , callback ( err : Error , Result res )) : void

matchKnnBruteForceHammingLut

Result : DescriptorMatch [][]
matchKnnBruteForceHammingLut ( descriptors1 : Mat , descriptors2 : Mat , k : int ) : Result
matchKnnBruteForceHammingLutAsync ( descriptors1 : Mat , descriptors2 : Mat , k : int ) : Promise < Result >
matchKnnBruteForceHammingLutAsync ( descriptors1 : Mat , descriptors2 : Mat , k : int , callback ( err : Error , Result res )) : void

matchKnnBruteForceL1

Result : DescriptorMatch [][]
matchKnnBruteForceL1 ( descriptors1 : Mat , descriptors2 : Mat , k : int ) : Result
matchKnnBruteForceL1Async ( descriptors1 : Mat , descriptors2 : Mat , k : int ) : Promise < Result >
matchKnnBruteForceL1Async ( descriptors1 : Mat , descriptors2 : Mat , k : int , callback ( err : Error , Result res )) : void

matchKnnBruteForceSL2

Result : DescriptorMatch [][]
matchKnnBruteForceSL2 ( descriptors1 : Mat , descriptors2 : Mat , k : int ) : Result
matchKnnBruteForceSL2Async ( descriptors1 : Mat , descriptors2 : Mat , k : int ) : Promise < Result >
matchKnnBruteForceSL2Async ( descriptors1 : Mat , descriptors2 : Mat , k : int , callback ( err : Error , Result res )) : void

matchKnnFlannBased

Result : DescriptorMatch [][]
matchKnnFlannBased ( descriptors1 : Mat , descriptors2 : Mat , k : int ) : Result
matchKnnFlannBasedAsync ( descriptors1 : Mat , descriptors2 : Mat , k : int ) : Promise < Result >
matchKnnFlannBasedAsync ( descriptors1 : Mat , descriptors2 : Mat , k : int , callback ( err : Error , Result res )) : void

Methods

partition

Result = {
labels : int [] ,
numLabels : int
}
partition ( data : Point2 [] , predicate : func ) : Result
Result = {
labels : int [] ,
numLabels : int
}
partition ( data : Point3 [] , predicate : func ) : Result
Result = {
labels : int [] ,
numLabels : int
}
partition ( data : Vec2 [] , predicate : func ) : Result
Result = {
labels : int [] ,
numLabels : int
}
partition ( data : Vec3 [] , predicate : func ) : Result
Result = {
labels : int [] ,
numLabels : int
}
partition ( data : Vec4 [] , predicate : func ) : Result
Result = {
labels : int [] ,
numLabels : int
}
partition ( data : Mat [] , predicate : func ) : Result

plot1DHist

Result : Mat
plot1DHist ( hist : Mat , plotImg : Mat , color : Vec3 , lineType : uint = LINE_8 , thickness : uint = 1 , shift : uint = 0 ) : Result

polarToCart

Result = {
x : Mat ,
y : Mat
}
polarToCart ( magnitude : Mat , angle : Mat , angleInDegrees : boolean = false ) : Result
polarToCartAsync ( magnitude : Mat , angle : Mat , angleInDegrees : boolean = false ) : Promise < Result >
polarToCartAsync ( magnitude : Mat , angle : Mat , angleInDegrees : boolean = false , ...opts , callback ( err : Error , Result res )) : void

projectPoints

Result = {
imagePoints : Point2 [] ,
jacobian : Mat
}
projectPoints ( objectPoints : Point3 [] , imagePoints : Point2 [] , rvec : Vec3 , tvec : Vec3 , cameraMatrix : Mat , distCoeffs : number [] , aspectRatio : number = 0 ) : Result
projectPointsAsync ( objectPoints : Point3 [] , imagePoints : Point2 [] , rvec : Vec3 , tvec : Vec3 , cameraMatrix : Mat , distCoeffs : number [] , aspectRatio : number = 0 ) : Promise < Result >
projectPointsAsync ( objectPoints : Point3 [] , imagePoints : Point2 [] , rvec : Vec3 , tvec : Vec3 , cameraMatrix : Mat , distCoeffs : number [] , aspectRatio : number = 0 , ...opts , callback ( err : Error , Result res )) : void

readNetFromCaffe

Result : Net
readNetFromCaffe ( prototxt : string , modelPath : string = '' ) : Result
readNetFromCaffeAsync ( prototxt : string , modelPath : string = '' ) : Promise < Result >
readNetFromCaffeAsync ( prototxt : string , modelPath : string = '' , ...opts , callback ( err : Error , Result res )) : void

readNetFromTensorflow

Result : Net
readNetFromTensorflow ( modelPath : string ) : Result
readNetFromTensorflowAsync ( modelPath : string ) : Promise < Result >
readNetFromTensorflowAsync ( modelPath : string , callback ( err : Error , Result res )) : void

recoverPose

Result = {
returnValue : int ,
R : Mat ,
T : Vec3
}
recoverPose ( E : Mat , points1 : Point2 [] , points2 : Point2 [] , focal : number = 1.0 , pp : Point2 = new Point(0, 0) , mask : Mat = noArray() ) : Result
recoverPoseAsync ( E : Mat , points1 : Point2 [] , points2 : Point2 [] , focal : number = 1.0 , pp : Point2 = new Point(0, 0) , mask : Mat = noArray() ) : Promise < Result >
recoverPoseAsync ( E : Mat , points1 : Point2 [] , points2 : Point2 [] , focal : number = 1.0 , pp : Point2 = new Point(0, 0) , mask : Mat = noArray() , ...opts , callback ( err : Error , Result res )) : void

sampsonDistance

Result : number
sampsonDistance ( pt1 : Vec2 , pt2 : Vec2 , F : Mat ) : Result
sampsonDistanceAsync ( pt1 : Vec2 , pt2 : Vec2 , F : Mat ) : Promise < Result >
sampsonDistanceAsync ( pt1 : Vec2 , pt2 : Vec2 , F : Mat , callback ( err : Error , Result res )) : void

solveP3P

Result = {
returnValue : boolean ,
rvecs : Mat [] ,
tvecs : Mat []
}
solveP3P ( objectPoints : Point3 [] , imagePoints : Point2 [] , cameraMatrix : Mat , distCoeffs : number [] , flags : int = cv.SOLVEPNP_P3P ) : Result
solveP3PAsync ( objectPoints : Point3 [] , imagePoints : Point2 [] , cameraMatrix : Mat , distCoeffs : number [] , flags : int = cv.SOLVEPNP_P3P ) : Promise < Result >
solveP3PAsync ( objectPoints : Point3 [] , imagePoints : Point2 [] , cameraMatrix : Mat , distCoeffs : number [] , flags : int = cv.SOLVEPNP_P3P , ...opts , callback ( err : Error , Result res )) : void

solvePnP

Result = {
returnValue : boolean ,
rvec : Vec3 ,
tvec : Vec3
}
solvePnP ( objectPoints : Point3 [] , imagePoints : Point2 [] , cameraMatrix : Mat , distCoeffs : number [] , useExtrinsicGuess : boolean = false , flags : int = cv.SOLVEPNP_ITERATIVE ) : Result
solvePnPAsync ( objectPoints : Point3 [] , imagePoints : Point2 [] , cameraMatrix : Mat , distCoeffs : number [] , useExtrinsicGuess : boolean = false , flags : int = cv.SOLVEPNP_ITERATIVE ) : Promise < Result >
solvePnPAsync ( objectPoints : Point3 [] , imagePoints : Point2 [] , cameraMatrix : Mat , distCoeffs : number [] , useExtrinsicGuess : boolean = false , flags : int = cv.SOLVEPNP_ITERATIVE , ...opts , callback ( err : Error , Result res )) : void
Result = {
returnValue : boolean ,
rvec : Vec3 ,
tvec : Vec3 ,
inliers : int []
}
solvePnP ( objectPoints : Point3 [] , imagePoints : Point2 [] , cameraMatrix : Mat , distCoeffs : number [] , useExtrinsicGuess : boolean = false , iterationsCount : int = 100 , reprojectionError : number = 8.0 , confidence : number = 0.99 , flags : int = cv.SOLVEPNP_ITERATIVE ) : Result
solvePnPAsync ( objectPoints : Point3 [] , imagePoints : Point2 [] , cameraMatrix : Mat , distCoeffs : number [] , useExtrinsicGuess : boolean = false , iterationsCount : int = 100 , reprojectionError : number = 8.0 , confidence : number = 0.99 , flags : int = cv.SOLVEPNP_ITERATIVE ) : Promise < Result >
solvePnPAsync ( objectPoints : Point3 [] , imagePoints : Point2 [] , cameraMatrix : Mat , distCoeffs : number [] , useExtrinsicGuess : boolean = false , iterationsCount : int = 100 , reprojectionError : number = 8.0 , confidence : number = 0.99 , flags : int = cv.SOLVEPNP_ITERATIVE , ...opts , callback ( err : Error , Result res )) : void

solvePnPRansac

stereoCalibrate

Result = {
returnValue : number ,
R : Mat ,
T : Vec3 [] ,
E : Mat ,
F : Mat
}
stereoCalibrate ( objectPoints : Point3 [] , imagePoints1 : Point2 [] , imagePoints2 : Point2 [] , cameraMatrix1 : Mat , distCoeffs1 : number [] , cameraMatrix2 : Mat , distCoeffs2 : number [] , imageSize : Size , flags : int = cv.CALIB_FIX_INTRINSIC , criteria : TermCriteria = new TermCriteria(cv.TermCriteria.COUNT + cv.TermCriteria.EPS, 30; 1e-6) ) : Result
stereoCalibrateAsync ( objectPoints : Point3 [] , imagePoints1 : Point2 [] , imagePoints2 : Point2 [] , cameraMatrix1 : Mat , distCoeffs1 : number [] , cameraMatrix2 : Mat , distCoeffs2 : number [] , imageSize : Size , flags : int = cv.CALIB_FIX_INTRINSIC , criteria : TermCriteria = new TermCriteria(cv.TermCriteria.COUNT + cv.TermCriteria.EPS, 30; 1e-6) ) : Promise < Result >
stereoCalibrateAsync ( objectPoints : Point3 [] , imagePoints1 : Point2 [] , imagePoints2 : Point2 [] , cameraMatrix1 : Mat , distCoeffs1 : number [] , cameraMatrix2 : Mat , distCoeffs2 : number [] , imageSize : Size , flags : int = cv.CALIB_FIX_INTRINSIC , criteria : TermCriteria = new TermCriteria(cv.TermCriteria.COUNT + cv.TermCriteria.EPS, 30; 1e-6) , ...opts , callback ( err : Error , Result res )) : void

stereoRectifyUncalibrated

Result = {
returnValue : boolean ,
H1 : Mat ,
H2 : Mat
}
stereoRectifyUncalibrated ( points1 : Point2 [] , points2 : Point2 [] , F : Mat , imageSize : Size , threshold : number = 5.0 ) : Result
stereoRectifyUncalibratedAsync ( points1 : Point2 [] , points2 : Point2 [] , F : Mat , imageSize : Size , threshold : number = 5.0 ) : Promise <