HoughCircles(...)
HoughCircles( (Mat)image, (object)method, (object)dp, (object)minDist [, (object)param1=100 [, (object)param2=100 [, (object)minRadius=0 [, (object)maxRadius=0]]]]) -> object :

HoughLines(...)
HoughLines( (Mat)image, (object)rho, (object)theta, (object)threshold [, (object)srn=0 [, (object)stn=0]]) -> object :

HoughLinesP(...)
HoughLinesP( (Mat)image, (object)rho, (object)theta, (object)threshold [, (object)minLineLength=0 [, (object)maxLineGap=0]]) -> object :

HuMoments(...)
HuMoments( (Moments)moments) -> object :

LSHAdd(...)
LSHAdd( (CvLSH)lsh, (Mat)data [, (Mat)indices=Mat()]) -> None :

LSHQuery(...)
LSHQuery( (CvLSH)lsh, (Mat)query_points, (Mat)indices, (Mat)dist, (object)k, (object)emax) -> None :

LSHRemove(...)
LSHRemove( (CvLSH)lsh, (Mat)indices) -> None :

LSHSize(...)
LSHSize( (CvLSH)lsh) -> int :

LUT(...)
LUT( (Mat)a, (Mat)lut, (Mat)b) -> None :

Laplacian(...)
Laplacian( (Mat)src, (Mat)dst, (object)ddepth [, (object)ksize=1 [, (object)scale=1 [, (object)delta=0 [, (object)borderType=4]]]]) -> None :

Mahalanobis(...)
Mahalanobis( (Mat)v1, (Mat)v2, (Mat)icovar) -> float :

Mahalonobis(...)
Mahalonobis( (Mat)v1, (Mat)v2, (Mat)icovar) -> float :

POSIT(...)
POSIT( (CvPOSITObject)posit_object, (object)image_points, (object)focal_length, (object)criteria, (object)rotation_matrix, (object)translation_vector) -> None :

RANSACUpdateNumIters(...)
RANSACUpdateNumIters( (object)p, (object)err_prob, (object)model_points, (object)max_iters) -> int :

RQDecomp3x3(...)
RQDecomp3x3( (Mat)M, (Mat)R, (Mat)Q, (Mat)Qx, (Mat)Qy, (Mat)Qz) -> Vec3d :

Rodrigues(...)
Rodrigues( (Mat)src, (Mat)dst [, (Mat)jacobian]) -> None :

SURFPoint(...)
SURFPoint( (Point2f)pt, (object)laplacian, (object)size [, (object)dir=0 [, (object)hessian=0]]) -> object :

Scharr(...)
Scharr( (Mat)src, (Mat)dst, (object)ddepth, (object)dx, (object)dy [, (object)scale=1 [, (object)delta=0 [, (object)borderType=4]]]) -> None :

Sobel(...)
Sobel( (Mat)src, (Mat)dst, (object)ddepth, (object)dx, (object)dy [, (object)ksize=3 [, (object)scale=1 [, (object)delta=0 [, (object)borderType=4]]]]) -> None :

_cvCreateTrackbar2(...)
_cvCreateTrackbar2( (str)trackbar_name, (str)window_name, (object)value, (object)count, (object)on_change [, (object)userdata=None]) -> tuple :

None :

_cvDestroyAllWindows()
Wrapped function: cvDestroyAllWindows

_cvDestroyWindow(...)
_cvDestroyWindow( (str)name) -> None :

_cvEndFindContours(...)
_cvEndFindContours( (object)scanner) -> CvSeq :

_cvReleaseConDensation(...)
_cvReleaseConDensation( (CvConDensation)condens) -> None :

_cvReleaseFeatureTree(...)
_cvReleaseFeatureTree( (CvFeatureTree)tr) -> None :

_cvReleaseFileStorage(...)
_cvReleaseFileStorage( (CvFileStorage)fs) -> None :

_cvReleaseLSH(...)
_cvReleaseLSH( (object)lsh) -> None :

_cvReleaseMemStorage(...)
_cvReleaseMemStorage( (CvMemStorage)storage) -> None :

_cvReleasePOSITObject(...)
_cvReleasePOSITObject( (CvPOSITObject)posit_object) -> None :

_cvReleaseStereoGCState(...)
_cvReleaseStereoGCState( (CvStereoGCState)state) -> None :

_cvSetMouseCallback(...)
_cvSetMouseCallback( (str)window_name, (object)on_mouse [, (object)param=None]) -> object :

absdiff(...)
absdiff( (MatND)a, (Scalar)s, (MatND)c) -> None :

acc(...)
acc( (Mat)image, (Mat)sum [, (Mat)mask=Mat()]) -> None :

accumulate(...)
accumulate( (Mat)src, (Mat)dst [, (Mat)mask=Mat()]) -> None :

accumulateProduct(...)
accumulateProduct( (Mat)src1, (Mat)src2, (Mat)dst [, (Mat)mask=Mat()]) -> None :

accumulateSquare(...)
accumulateSquare( (Mat)src, (Mat)dst [, (Mat)mask=Mat()]) -> None :

accumulateWeighted(...)
accumulateWeighted( (Mat)src, (Mat)dst, (object)alpha [, (Mat)mask=Mat()]) -> None :

adaptiveThreshold(...)
adaptiveThreshold( (Mat)src, (Mat)dst, (object)maxValue, (object)adaptiveMethod, (object)thresholdType, (object)blockSize, (object)C) -> None :

add(...)
add( (MatND)a, (Scalar)s, (MatND)c [, (MatND)mask=MatND(shape=(), nchannels=1, depth=0): array(24, dtype=uint8)]) -> None :

addWeighted(...)
addWeighted( (MatND)a, (object)alpha, (MatND)b, (object)beta, (object)gamma, (MatND)c) -> None :

approxChains(...)
approxChains( (CvSeq)src_seq, (CvMemStorage)storage [, (object)method=2 [, (object)parameter=0 [, (object)minimal_perimeter=0 [, (object)recursive=0]]]]) -> CvSeq :

approxPolyDP(...)
approxPolyDP( (Mat)curve, (object)epsilon, (bool)closed) -> Mat :

arcLength(...)
arcLength( (Mat)curve, (bool)closed) -> float :

asComplexd(...)
asComplexd( (Complexf)inst_Complexf) -> Complexd :

asComplexf(...)
asComplexf( (Complexd)inst_Complexd) -> Complexf :

asMat(...)
asMat( (object)arr) -> object :

asMat1b(...)
asMat1b( (Mat2b)inst_Mat2b) -> Mat1b :

asMat1d(...)
asMat1d( (Mat1b)inst_Mat1b) -> Mat1d :

asMat1f(...)
asMat1f( (Mat1b)inst_Mat1b) -> Mat1f :

asMat1i(...)
asMat1i( (Mat1b)inst_Mat1b) -> Mat1i :

asMat1s(...)
asMat1s( (Mat1b)inst_Mat1b) -> Mat1s :

asMat1w(...)
asMat1w( (Mat1b)inst_Mat1b) -> Mat1w :

asMat2b(...)
asMat2b( (Mat1b)inst_Mat1b) -> Mat2b :

asMat2d(...)
asMat2d( (Mat1b)inst_Mat1b) -> Mat2d :

asMat2f(...)
asMat2f( (Mat1b)inst_Mat1b) -> Mat2f :

asMat2i(...)
asMat2i( (Mat1b)inst_Mat1b) -> Mat2i :

asMat2s(...)
asMat2s( (Mat1b)inst_Mat1b) -> Mat2s :

asMat2w(...)
asMat2w( (Mat1b)inst_Mat1b) -> Mat2w :

asMat3b(...)
asMat3b( (Mat1b)inst_Mat1b) -> Mat3b :

asMat3d(...)
asMat3d( (Mat1b)inst_Mat1b) -> Mat3d :

asMat3f(...)
asMat3f( (Mat1b)inst_Mat1b) -> Mat3f :

asMat3i(...)
asMat3i( (Mat1b)inst_Mat1b) -> Mat3i :

asMat3s(...)
asMat3s( (Mat1b)inst_Mat1b) -> Mat3s :

asMat3w(...)
asMat3w( (Mat1b)inst_Mat1b) -> Mat3w :

asMat4b(...)
asMat4b( (Mat1b)inst_Mat1b) -> Mat4b :

asMat4d(...)
asMat4d( (Mat1b)inst_Mat1b) -> Mat4d :

asMat4f(...)
asMat4f( (Mat1b)inst_Mat1b) -> Mat4f :

asMat4i(...)
asMat4i( (Mat1b)inst_Mat1b) -> Mat4i :

asMat4s(...)
asMat4s( (Mat1b)inst_Mat1b) -> Mat4s :

asMat4w(...)
asMat4w( (Mat1b)inst_Mat1b) -> Mat4w :

asMatND(...)
asMatND( (object)arr) -> object :

asPoint2d(...)
asPoint2d( (Point2i)inst_Point2i) -> Point2d :

asPoint2f(...)
asPoint2f( (Point2i)inst_Point2i) -> Point2f :

asPoint2i(...)
asPoint2i( (Point2f)inst_Point2f) -> Point2i :

asPoint3d(...)
asPoint3d( (Point3i)inst_Point3i) -> Point3d :

asPoint3f(...)
asPoint3f( (Point3i)inst_Point3i) -> Point3f :

asPoint3i(...)
asPoint3i( (Point3f)inst_Point3f) -> Point3i :

asRange(...)
asRange( (object)arr) -> object :

asRect(...)
asRect( (Rectf)inst_Rectf) -> Rect :

asRectd(...)
asRectd( (Rect)inst_Rect) -> Rectd :

asRectf(...)
asRectf( (Rect)inst_Rect) -> Rectf :

asRotatedRect(...)
asRotatedRect( (object)arr) -> object :

asScalar(...)
asScalar( (object)arr) -> object :

asSize2d(...)
asSize2d( (Size2i)inst_Size2i) -> Size2d :

asSize2f(...)
asSize2f( (Size2i)inst_Size2i) -> Size2f :

asSize2i(...)
asSize2i( (Size2f)inst_Size2f) -> Size2i :

asVec2b(...)
asVec2b( (Vec2s)inst_Vec2s) -> Vec2b :

asVec2d(...)
asVec2d( (Vec2b)inst_Vec2b) -> Vec2d :

asVec2f(...)
asVec2f( (Vec2b)inst_Vec2b) -> Vec2f :

asVec2i(...)
asVec2i( (Vec2b)inst_Vec2b) -> Vec2i :

asVec2s(...)
asVec2s( (Vec2b)inst_Vec2b) -> Vec2s :

asVec2w(...)
asVec2w( (Vec2b)inst_Vec2b) -> Vec2w :

asVec3b(...)
asVec3b( (Vec3s)inst_Vec3s) -> Vec3b :

asVec3d(...)
asVec3d( (Vec3b)inst_Vec3b) -> Vec3d :

asVec3f(...)
asVec3f( (Vec3b)inst_Vec3b) -> Vec3f :

asVec3i(...)
asVec3i( (Vec3b)inst_Vec3b) -> Vec3i :

asVec3s(...)
asVec3s( (Vec3b)inst_Vec3b) -> Vec3s :

asVec3w(...)
asVec3w( (Vec3b)inst_Vec3b) -> Vec3w :

asVec4b(...)
asVec4b( (Vec4s)inst_Vec4s) -> Vec4b :

asVec4d(...)
asVec4d( (Vec4b)inst_Vec4b) -> Vec4d :

asVec4f(...)
asVec4f( (Vec4b)inst_Vec4b) -> Vec4f :

asVec4i(...)
asVec4i( (Vec4b)inst_Vec4b) -> Vec4i :

asVec4s(...)
asVec4s( (Vec4b)inst_Vec4b) -> Vec4s :

asVec4w(...)
asVec4w( (Vec4b)inst_Vec4b) -> Vec4w :

asVec6d(...)
asVec6d( (Vec6f)inst_Vec6f) -> Vec6d :

asVec6f(...)
asVec6f( (Vec6d)inst_Vec6d) -> Vec6f :

attrValue(...)
attrValue( (CvAttrList)attr, (str)attr_name) -> str :

bilateralFilter(...)
bilateralFilter( (Mat)src, (Mat)dst, (object)d, (object)sigmaColor, (object)sigmaSpace [, (object)borderType=4]) -> None :

bitwise_and(...)
bitwise_and( (MatND)a, (Scalar)s, (MatND)c [, (MatND)mask=MatND(shape=(), nchannels=1, depth=0): array(0, dtype=uint8)]) -> None :

bitwise_not(...)
bitwise_not( (MatND)a, (MatND)c) -> None :

bitwise_or(...)
bitwise_or( (MatND)a, (Scalar)s, (MatND)c [, (MatND)mask=MatND(shape=(), nchannels=1, depth=0): array(0, dtype=uint8)]) -> None :

bitwise_xor(...)
bitwise_xor( (MatND)a, (Scalar)s, (MatND)c [, (MatND)mask=MatND(shape=(), nchannels=1, depth=0): array(0, dtype=uint8)]) -> None :

blob(...)
blob( (object)x, (object)y, (object)w, (object)h) -> CvBlob :

blur(...)
blur( (Mat)src, (Mat)dst, (Size2i)ksize [, (Point2i)anchor=Point2i(x=-1, y=-1) [, (object)borderType=4]]) -> None :

borderInterpolate(...)
borderInterpolate( (object)p, (object)len, (object)borderType) -> int :

boundingRect(...)
boundingRect( (Mat)points) -> Rect :

boxFilter(...)
boxFilter( (Mat)src, (Mat)dst, (object)ddepth, (Size2i)ksize [, (Point2i)anchor=Point2i(x=-1, y=-1) [, (bool)normalize=True [, (object)borderType=4]]]) -> None :

boxPoints(...)
boxPoints( (object)box, (object)pt) -> None :

buildPyramid(...)
buildPyramid( (Mat)src, (list)dst, (object)maxlevel) -> None :

calcAffineFlowPyrLK(...)
calcAffineFlowPyrLK( (Mat)prev, (Mat)curr, (Mat)prev_pyr, (Mat)curr_pyr, (Mat)prev_features, (CvSize)win_size, (object)level, (object)criteria, (object)flags) -> tuple :

calcBackProject(...)
calcBackProject( (object)images, (Mat)channels, (SparseMat)hist, (Mat)backProject, (object)ranges [, (object)scale=1 [, (bool)uniform=True]]) -> None :

calcCovarMatrix(...)
calcCovarMatrix( (list)samples, (Mat)covar, (Mat)mean, (object)flags [, (object)ctype=6]) -> None :

calcEMD2(...)
calcEMD2( (Mat)signature1, (Mat)signature2, (object)distance_type [, (object)distance_func=None [, (Mat)cost_matrix=Mat() [, (Mat)flow=Mat() [, (object)lower_bound=None [, (object)userdata=None]]]]]) -> object :

calcGlobalOrientation(...)
calcGlobalOrientation( (Mat)orientation, (Mat)mask, (Mat)mhi, (object)timestamp, (object)duration) -> object :

calcHist(...)
calcHist( (object)images, (Mat)channels, (Mat)mask, (SparseMat)hist, (Mat)histSize, (object)ranges [, (bool)uniform=True [, (bool)accumulate=False]]) -> None :

calcImageHomography(...)
calcImageHomography( (object)line, (object)center, (object)intrinsic) -> object :

calcMotionGradient(...)
calcMotionGradient( (Mat)mhi, (Mat)mask, (Mat)orientation, (object)delta1, (object)delta2 [, (object)aperture_size=3]) -> None :

calcOpticalFlowBM(...)
calcOpticalFlowBM( (Mat)prev, (Mat)curr, (CvSize)block_size, (CvSize)shift_size, (CvSize)max_range, (object)use_previous, (Mat)velx, (Mat)vely) -> None :

calcOpticalFlowFarneback(...)
calcOpticalFlowFarneback( (Mat)prev, (Mat)next, (Mat)flow, (object)pyr_scale, (object)levels, (object)winsize, (object)iterations, (object)poly_n, (object)poly_sigma, (object)flags) -> None :

calcOpticalFlowHS(...)
calcOpticalFlowHS( (Mat)prev, (Mat)curr, (object)use_previous, (Mat)velx, (Mat)vely, (object)lambda, (object)criteria) -> None :

calcOpticalFlowLK(...)
calcOpticalFlowLK( (Mat)prev, (Mat)curr, (CvSize)win_size, (Mat)velx, (Mat)vely) -> None :

calcOpticalFlowPyrLK(...)
calcOpticalFlowPyrLK( (Mat)prevImg, (Mat)nextImg, (Mat)prevPts, (Mat)nextPts, (Mat)status, (Mat)err [, (Size2i)winSize=Size2i(width=15, height=15) [, (object)maxLevel=3 [, (TermCriteria)criteria=TermCriteria(type=3, maxCount=30, epsilon=0.01) [, (object)derivLambda=0.5 [, (object)flags=0]]]]]) -> None :

calcSubdivVoronoi2D(...)
calcSubdivVoronoi2D( (CvSubdiv2D)subdiv) -> None :

calibrateCamera(...)
calibrateCamera( (list)objectPoints, (list)imagePoints, (Size2i)imageSize, (Mat)cameraMatrix, (Mat)distCoeffs [, (object)flags=0]) -> tuple :

calibrationMatrixValues(...)
calibrationMatrixValues( (Mat)cameraMatrix, (Size2i)imageSize, (object)apertureWidth, (object)apertureHeight, (object)fovx, (object)fovy, (object)focalLength, (Point2d)principalPoint, (object)aspectRatio) -> None :

cartToPolar(...)
cartToPolar( (Mat)x, (Mat)y, (Mat)magnitude, (Mat)angle [, (bool)angleInDegrees=False]) -> None :

ceil(...)
ceil( (object)value) -> int :

checkChessboard(...)
checkChessboard( (Mat)src, (CvSize)size) -> object :

checkHardwareSupport(...)
checkHardwareSupport( (object)feature) -> bool :

checkRange(...)
checkRange( (MatND)a [, (bool)quiet=True [, (object)minVal=-1.7976931348623157e+308 [, (object)maxVal=1.7976931348623157e+308]]]) -> tuple :

circle(...)
circle( (Mat)img, (Point2i)center, (object)radius, (Scalar)color [, (object)thickness=1 [, (object)lineType=8 [, (object)shift=0]]]) -> None :

clearMemStorage(...)
clearMemStorage( (CvMemStorage)storage) -> None :

clearSeq(...)
clearSeq( (CvSeq)seq) -> None :

clearSet(...)
clearSet( (CvSet)set_header) -> None :

clearSubdivVoronoi2D(...)
clearSubdivVoronoi2D( (CvSubdiv2D)subdiv) -> None :

clipLine(...)
clipLine( (Rect)img_rect, (Point2i)pt1, (Point2i)pt2) -> bool :

cloneSeq(...)
cloneSeq( (CvSeq)seq [, (CvMemStorage)storage=None]) -> CvSeq :

compare(...)
compare( (MatND)a, (object)s, (MatND)c, (object)cmpop) -> None :

compareHist(...)
compareHist( (SparseMat)H1, (SparseMat)H2, (object)method) -> float :

completeSymm(...)
completeSymm( (Mat)a [, (bool)lowerToUpper=False]) -> None :

composeRT(...)
composeRT( (Mat)rvec1, (Mat)tvec1, (Mat)rvec2, (Mat)tvec2, (Mat)rvec3, (Mat)tvec3, (Mat)dr3dr1, (Mat)dr3dt1, (Mat)dr3dr2, (Mat)dr3dt2, (Mat)dt3dr1, (Mat)dt3dt1, (Mat)dt3dr2, (Mat)dt3dt2) -> None :

computeCorrespondEpilines(...)
computeCorrespondEpilines( (Mat)points1, (object)whichImage, (Mat)F) -> object :

conDensInitSampleSet(...)
conDensInitSampleSet( (CvConDensation)condens, (Mat)lower_bound, (Mat)upper_bound) -> None :

conDensUpdateByTime(...)
conDensUpdateByTime( (CvConDensation)condens) -> None :

contourArea(...)
contourArea( (Mat)contour [, (bool)oriented=False]) -> float :

contourFromContourTree(...)
contourFromContourTree( (CvContourTree)tree, (CvMemStorage)storage, (object)criteria) -> CvSeq :

convertImage(...)
convertImage( (Mat)src, (Mat)dst [, (object)flags=0]) -> None :

convertMaps(...)
convertMaps( (Mat)map1, (Mat)map2, (Mat)dstmap1, (Mat)dstmap2, (object)dstmap1type [, (bool)nninterpolation=False]) -> None :

convertPointsHomogeneous2D(...)
convertPointsHomogeneous2D( (Mat)src) -> object :

convertPointsHomogeneous3D(...)
convertPointsHomogeneous3D( (Mat)src) -> object :

convertScaleAbs(...)
convertScaleAbs( (Mat)a, (Mat)c [, (object)alpha=1 [, (object)beta=0]]) -> None :

convexHull(...)
convexHull( (Mat)points [, (bool)clockwise=False]) -> Mat :

convexHullIdx(...)
convexHullIdx( (Mat)points [, (bool)clockwise=False]) -> object :

convexityDefects(...)
convexityDefects( (Mat)contour, (Mat)convexhull [, (CvMemStorage)storage=None]) -> object :

copyMakeBorder(...)
copyMakeBorder( (Mat)src, (Mat)dst, (object)top, (object)bottom, (object)left, (object)right, (object)borderType [, (Scalar)value=Scalar([ 0.

cornerEigenValsAndVecs(...)
cornerEigenValsAndVecs( (Mat)src, (Mat)dst, (object)blockSize, (object)ksize [, (object)borderType=4]) -> None :

cornerHarris(...)
cornerHarris( (Mat)src, (Mat)dst, (object)blockSize, (object)ksize, (object)k [, (object)borderType=4]) -> None :

cornerMinEigenVal(...)
cornerMinEigenVal( (Mat)src, (Mat)dst, (object)blockSize [, (object)ksize=3 [, (object)borderType=4]]) -> None :

cornerSubPix(...)
cornerSubPix( (Mat)image, (Mat)corners, (Size2i)winSize, (Size2i)zeroZone, (TermCriteria)criteria) -> None :

correctMatches(...)
correctMatches( (Mat)F, (Mat)points1, (Mat)points2, (Mat)new_points1, (Mat)new_points2) -> None :

countNonZero(...)
countNonZero( (MatND)m) -> int :

createBoxFilter(...)
createBoxFilter( (object)srcType, (object)dstType, (Size2i)ksize [, (Point2i)anchor=Point2i(x=-1, y=-1) [, (bool)normalize=True [, (object)borderType=4]]]) -> Ptr_FilterEngine :

createChildMemStorage(...)
createChildMemStorage( (CvMemStorage)parent) -> CvMemStorage :

createConDensation(...)
createConDensation( (object)dynam_params, (object)measure_params, (object)sample_count) -> CvConDensation :

createContourTree(...)
createContourTree( (CvSeq)contour, (CvMemStorage)storage, (object)threshold) -> CvContourTree :

createDerivFilter(...)
createDerivFilter( (object)srcType, (object)dstType, (object)dx, (object)dy, (object)ksize [, (object)borderType=4]) -> Ptr_FilterEngine :

createGaussianFilter(...)
createGaussianFilter( (object)type, (Size2i)ksize, (object)sigma1 [, (object)sigma2=0 [, (object)borderType=4]]) -> Ptr_FilterEngine :

createKDTree(...)
createKDTree( (Mat)desc) -> object :

createLSH(...)
createLSH( (CvLSHOperations)ops, (object)d [, (object)L=10 [, (object)k=10 [, (object)type=6 [, (object)r=4 [, (long)seed=-1L]]]]]) -> CvLSH :

createLinearFilter(...)
createLinearFilter( (object)srcType, (object)dstType, (Mat)kernel [, (Point2i)_anchor=Point2i(x=-1, y=-1) [, (object)delta=0 [, (object)_rowBorderType=4 [, (object)_columnBorderType=-1 [, (Scalar)_borderValue=Scalar([ 0.

createMemStorage(...)
createMemStorage([ (object)block_size=0]) -> CvMemStorage :

createMemoryLSH(...)
createMemoryLSH( (object)d, (object)n [, (object)L=10 [, (object)k=10 [, (object)type=6 [, (object)r=4 [, (long)seed=-1L]]]]]) -> CvLSH :

createMorphologyFilter(...)
createMorphologyFilter( (object)op, (object)type, (Mat)kernel [, (Point2i)anchor=Point2i(x=-1, y=-1) [, (object)_rowBorderType=0 [, (object)_columnBorderType=-1 [, (Scalar)_borderValue=Scalar([ 1.79769313e+308 1.79769313e+308 1.79769313e+308 1.79769313e+308])]]]]) -> Ptr_FilterEngine :

createPOSITObject(...)
createPOSITObject( (object)points, (object)point_count) -> CvPOSITObject :

createSeparableLinearFilter(...)
createSeparableLinearFilter( (object)srcType, (object)dstType, (Mat)rowKernel, (Mat)columnKernel [, (Point2i)_anchor=Point2i(x=-1, y=-1) [, (object)delta=0 [, (object)_rowBorderType=4 [, (object)_columnBorderType=-1 [, (Scalar)_borderValue=Scalar([ 0.

createSeq(...)
createSeq( (object)seq_flags, (object)header_size, (object)elem_size, (CvMemStorage)storage) -> CvSeq :

createSeqBlock(...)
createSeqBlock( (CvSeqWriter)writer) -> None :

createSet(...)
createSet( (object)set_flags, (object)header_size, (object)elem_size, (CvMemStorage)storage) -> CvSet :

createSpillTree(...)
createSpillTree( (Mat)raw_data [, (object)naive=50 [, (object)rho=0.69999999999999996 [, (object)tau=0.10000000000000001]]]) -> object :

createStereoGCState(...)
createStereoGCState( (object)numberOfDisparities, (object)maxIters) -> CvStereoGCState :

createSubdiv2D(...)
createSubdiv2D( (object)subdiv_type, (object)header_size, (object)vtx_size, (object)quadedge_size, (CvMemStorage)storage) -> CvSubdiv2D :

createSubdivDelaunay2D(...)
createSubdivDelaunay2D( (CvRect)rect, (CvMemStorage)storage) -> CvSubdiv2D :

cubeRoot(...)
cubeRoot( (object)val) -> float :

cvtColor(...)
cvtColor( (Mat)src, (Mat)dst, (object)code [, (object)dstCn=0]) -> None :

dct(...)
dct( (Mat)src, (Mat)dst [, (object)flags=0]) -> None :

decomposeProjectionMatrix(...)
decomposeProjectionMatrix( (Mat)projMatrix, (Mat)cameraMatrix, (Mat)rotMatrix, (Mat)transVect, (Mat)rotMatrixX, (Mat)rotMatrixY, (Mat)rotMatrixZ, (Vec3d)eulerAngles) -> None :

detectedBlob(...)
detectedBlob( (object)x, (object)y, (object)w, (object)h [, (object)ID=0 [, (object)response=0.0]]) -> CvDetectedBlob :

determinant(...)
determinant( (Mat)m) -> float :

dft(...)
dft( (Mat)src, (Mat)dst [, (object)flags=0 [, (object)nonzeroRows=0]]) -> None :

dilate(...)
dilate( (Mat)src, (Mat)dst, (Mat)kernel [, (Point2i)anchor=Point2i(x=-1, y=-1) [, (object)iterations=1 [, (object)borderType=0 [, (Scalar)borderValue=Scalar([ 1.79769313e+308 1.79769313e+308 1.79769313e+308 1.79769313e+308])]]]]) -> None :

distTransform(...)
distTransform( (Mat)src, (Mat)dst [, (object)distance_type=2 [, (object)mask_size=3 [, (Mat)mask=Mat() [, (Mat)labels=Mat()]]]]) -> None :

distanceTransform(...)
distanceTransform( (Mat)src, (Mat)dst, (object)distanceType, (object)maskSize) -> None :

divide(...)
divide( (object)scale, (MatND)b, (MatND)c) -> None :

drawChessboardCorners(...)
drawChessboardCorners( (Mat)image, (Size2i)patternSize, (Mat)corners, (bool)patternWasFound) -> None :

drawContours(...)
drawContours( (Mat)image, (list)contours, (object)contourIdx, (Scalar)color [, (object)thickness=1 [, (object)lineType=8 [, (Mat)hierarchy=Mat() [, (object)maxLevel=2147483647 [, (Point2i)offset=Point2i(x=0, y=0)]]]]]) -> None :

eigen(...)
eigen( (Mat)a, (Mat)eigenvalues, (Mat)eigenvectors [, (object)lowindex=-1 [, (object)highindex=-1]]) -> bool :

ellipse(...)
ellipse( (Mat)img, (RotatedRect)box, (Scalar)color [, (object)thickness=1 [, (object)lineType=8]]) -> None :

ellipse2Poly(...)
ellipse2Poly( (Point2i)center, (Size2i)axes, (object)angle, (object)arcStart, (object)arcEnd, (object)delta, (Mat)pts) -> None :

endWriteSeq(...)
endWriteSeq( (CvSeqWriter)writer) -> CvSeq :

endWriteStruct(...)
endWriteStruct( (FileStorage)fs) -> None :

equalizeHist(...)
equalizeHist( (Mat)src, (Mat)dst) -> None :

erode(...)
erode( (Mat)src, (Mat)dst, (Mat)kernel [, (Point2i)anchor=Point2i(x=-1, y=-1) [, (object)iterations=1 [, (object)borderType=0 [, (Scalar)borderValue=Scalar([ 1.79769313e+308 1.79769313e+308 1.79769313e+308 1.79769313e+308])]]]]) -> None :

error(...)
error( (object)status, (str)func_name, (str)err_msg, (str)file_name, (object)line) -> None :

errorFromIppStatus(...)
errorFromIppStatus( (object)ipp_status) -> int :

errorStr(...)
errorStr( (object)status) -> str :

estimateAffine3D(...)
estimateAffine3D( (Mat)from, (Mat)to, (Mat)out, (Mat)outliers [, (object)param1=3.0 [, (object)param2=0.98999999999999999]]) -> object :

estimateRigidTransform(...)
estimateRigidTransform( (Mat)A, (Mat)B, (Mat)M, (object)full_affine) -> object :

exp(...)
exp( (MatND)a, (MatND)b) -> None :

fastAtan2(...)
fastAtan2( (object)y, (object)x) -> float :

fillConvexPoly(...)
fillConvexPoly( (Mat)img, (Mat)pts, (Scalar)color [, (object)lineType=8 [, (object)shift=0]]) -> None :

fillPoly(...)
fillPoly( (Mat)img, (object)pts, (Scalar)color [, (object)lineType=8 [, (object)shift=0 [, (Point2i)offset=Point2i(x=0, y=0)]]]) -> None :

filter2D(...)
filter2D( (Mat)src, (Mat)dst, (object)ddepth, (Mat)kernel [, (Point2i)anchor=Point2i(x=-1, y=-1) [, (object)delta=0 [, (object)borderType=4]]]) -> None :

filterSpeckles(...)
filterSpeckles( (Mat)img, (object)newVal, (object)maxSpeckleSize, (object)maxDiff, (Mat)buf) -> None :

find4QuadCornerSubpix(...)
find4QuadCornerSubpix( (Mat)img, (Mat)corners, (Size2i)region_size) -> object :

findChessboardCorners(...)
findChessboardCorners( (Mat)image, (Size2i)patternSize [, (object)flags=3]) -> tuple :

findContours(...)
findContours( (Mat)image, (object)mode, (object)method [, (Point2i)offset=Point2i(x=0, y=0)]) -> object :

findDominantPoints(...)
findDominantPoints( (CvSeq)contour, (CvMemStorage)storage [, (object)method=1 [, (object)parameter1=0 [, (object)parameter2=0 [, (object)parameter3=0 [, (object)parameter4=0]]]]]) -> CvSeq :

findFeatures(...)
findFeatures( (CvFeatureTree)tr, (Mat)query_points, (Mat)indices, (Mat)dist, (object)k [, (object)emax=20]) -> None :

findFeaturesBoxed(...)
findFeaturesBoxed( (CvFeatureTree)tr, (Mat)bounds_min, (Mat)bounds_max, (Mat)out_indices) -> object :

findFundamentalMat(...)
findFundamentalMat( (Mat)points1, (Mat)points2 [, (object)method=8 [, (object)param1=3.0 [, (object)param2=0.98999999999999999]]]) -> Mat :

findFundamentalMat2(...)
findFundamentalMat2( (Mat)points1, (Mat)points2 [, (object)method=8 [, (object)param1=3.0 [, (object)param2=0.98999999999999999]]]) -> tuple :

findHomography(...)
findHomography( (Mat)srcPoints, (Mat)dstPoints [, (object)method=0 [, (object)ransacReprojThreshold=0]]) -> Mat :

findHomography2(...)
findHomography2( (Mat)srcPoints, (Mat)dstPoints [, (object)method=0 [, (object)ransacReprojThreshold=0]]) -> tuple :

findNearestPoint2D(...)
findNearestPoint2D( (CvSubdiv2D)subdiv, (Point2f)pt) -> object :

findNextContour(...)
findNextContour( (CvContourScanner)scanner) -> CvSeq :

findStereoCorrespondence(...)
findStereoCorrespondence( (Mat)leftImage, (Mat)rightImage, (object)mode, (Mat)dispImage, (object)maxDisparity [, (object)param1=12345 [, (object)param2=12345 [, (object)param3=12345 [, (object)param4=12345 [, (object)param5=12345]]]]]) -> None :

findStereoCorrespondenceGC(...)
findStereoCorrespondenceGC( (Mat)left, (Mat)right, (Mat)disparityLeft, (Mat)disparityRight, (CvStereoGCState)state [, (object)useDisparityGuess=0]) -> None :

findType(...)
findType( (str)type_name) -> CvTypeInfo :

CvTypeInfo :

firstType()
Wrapped function: cvFirstType

fitEllipse(...)
fitEllipse( (Mat)points) -> RotatedRect :

fitLine(...)
fitLine( (Mat)points, (Vec6f)line, (object)distType, (object)param, (object)reps, (object)aeps) -> None :

flip(...)
flip( (Mat)a, (Mat)b, (object)flipCode) -> None :

floodFill(...)
floodFill( (Mat)image, (Mat)mask, (Point2i)seedPoint, (Scalar)newVal [, (Scalar)loDiff=Scalar([ 0.

floor(...)
floor( (object)value) -> int :

flushSeqWriter(...)
flushSeqWriter( (CvSeqWriter)writer) -> None :

fromUtf16(...)
fromUtf16( (unicode)str) -> str :

gemm(...)
gemm( (Mat)a, (Mat)b, (object)alpha, (Mat)c, (object)gamma, (Mat)d [, (object)flags=0]) -> None :

getAffineTransform(...)
getAffineTransform( (Mat)src, (Mat)dst) -> object :

long :

getCPUTickCount()
C++ signature :...

getColumnSumFilter(...)
getColumnSumFilter( (object)sumType, (object)dstType, (object)ksize [, (object)anchor=-1 [, (object)scale=1]]) -> Ptr_BaseColumnFilter :

getDefaultNewCameraMatrix(...)
getDefaultNewCameraMatrix( (Mat)cameraMatrix [, (Size2i)imgsize=Size2i(width=0, height=0) [, (bool)centerPrincipalPoint=False]]) -> Mat :

getDerivKernels(...)
getDerivKernels( (Mat)kx, (Mat)ky, (object)dx, (object)dy, (object)ksize [, (bool)normalize=False [, (object)ktype=5]]) -> None :

getElemSize(...)
getElemSize( (object)type) -> int :

getElemType(...)
getElemType( (Mat)arr) -> object :

int :

getErrMode()
Wrapped function: cvGetErrMode

int :

getErrStatus()
Wrapped function: cvGetErrStatus

getFileNode(...)
getFileNode( (FileStorage)fs, (FileNode)map, (CvStringHashNode)key [, (object)create_missing=0]) -> object :

getFileNodeByName(...)
getFileNodeByName( (CvFileStorage)fs, (FileNode)map, (str)name) -> object :

getFileNodeName(...)
getFileNodeName( (FileNode)node) -> object :

getGaussianKernel(...)
getGaussianKernel( (object)ksize, (object)sigma [, (object)ktype=6]) -> Mat :

getHashedKey(...)
getHashedKey( (FileStorage)fs, (str)name [, (object)len=-1 [, (object)create_missing=0]]) -> object :

getKernelType(...)
getKernelType( (Mat)kernel, (Point2i)anchor) -> int :

getLinearColumnFilter(...)
getLinearColumnFilter( (object)bufType, (object)dstType, (Mat)kernel, (object)anchor, (object)symmetryType [, (object)delta=0 [, (object)bits=0]]) -> Ptr_BaseColumnFilter :

getLinearFilter(...)
getLinearFilter( (object)srcType, (object)dstType, (Mat)kernel [, (Point2i)anchor=Point2i(x=-1, y=-1) [, (object)delta=0 [, (object)bits=0]]]) -> Ptr_BaseFilter :

getLinearRowFilter(...)
getLinearRowFilter( (object)srcType, (object)bufType, (Mat)kernel, (object)anchor, (object)symmetryType) -> Ptr_BaseRowFilter :

getMorphologyColumnFilter(...)
getMorphologyColumnFilter( (object)op, (object)type, (object)ksize [, (object)anchor=-1]) -> Ptr_BaseColumnFilter :

getMorphologyFilter(...)
getMorphologyFilter( (object)op, (object)type, (Mat)kernel [, (Point2i)anchor=Point2i(x=-1, y=-1)]) -> Ptr_BaseFilter :

getMorphologyRowFilter(...)
getMorphologyRowFilter( (object)op, (object)type, (object)ksize [, (object)anchor=-1]) -> Ptr_BaseRowFilter :

int :

getNumThreads()
Wrapped function: cvGetNumThreads

getOptimalDFTSize(...)
getOptimalDFTSize( (object)vecsize) -> int :

getPerspectiveTransform(...)
getPerspectiveTransform( (Mat)src, (Mat)dst) -> object :

getQuadrangleSubPix(...)
getQuadrangleSubPix( (Mat)src, (Mat)dst, (Mat)map_matrix) -> None :

getRectSubPix(...)
getRectSubPix( (Mat)image, (Size2i)patchSize, (Point2f)center, (Mat)patch [, (object)patchType=-1]) -> None :

getRootFileNode(...)
getRootFileNode( (CvFileStorage)fs [, (object)stream_index=0]) -> CvFileNode :

getRotationMatrix2D(...)
getRotationMatrix2D( (Point2f)center, (object)angle, (object)scale) -> Mat :

getRowSumFilter(...)
getRowSumFilter( (object)srcType, (object)sumType, (object)ksize [, (object)anchor=-1]) -> Ptr_BaseRowFilter :

getSeqReaderPos(...)
getSeqReaderPos( (CvSeqReader)reader) -> int :

getSetElem(...)
getSetElem( (CvSet)set_header, (object)index) -> CvSetElem :

getStructuringElement(...)
getStructuringElement( (object)shape, (Size2i)ksize [, (Point2i)anchor=Point2i(x=-1, y=-1)]) -> Mat :

getTextSize(...)
getTextSize( (object)text, (object)fontFace, (object)fontScale, (object)thickness) -> tuple :

int :

getThreadNum()
Wrapped function: cvGetThreadNum

long :

getTickCount()
Wrapped function: cvGetTickCount

float :

getTickFrequency()
Wrapped function: cvGetTickFrequency

getTrackbarPos(...)
getTrackbarPos( (str)trackbar_name, (str)window_name) -> int :

getValidDisparityROI(...)
getValidDisparityROI( (Rect)roi1, (Rect)roi2, (object)minDisparity, (object)numberOfDisparities, (object)SADWindowSize) -> Rect :

getWindowName(...)
getWindowName( (object)window_handle) -> str :

getWindowProperty(...)
getWindowProperty( (object)winname, (object)prop_id) -> float :

goodFeaturesToTrack(...)
goodFeaturesToTrack( (Mat)image, (object)maxCorners, (object)qualityLevel, (object)minDistance [, (Mat)mask=Mat() [, (object)blockSize=3 [, (bool)useHarrisDetector=False [, (object)k=0.040000000000000001]]]]) -> object :

grabCut(...)
grabCut( (Mat)img, (Mat)mask, (Rect)rect, (Mat)bgdModel, (Mat)fgdModel, (object)iterCount [, (object)mode=2]) -> None :

groupRectangles(...)
groupRectangles( (Mat)rectList, (Mat)weights, (object)groupThreshold [, (object)eps=0.20000000000000001]) -> None :

hierarchicalClustering(...)
hierarchicalClustering( (Mat)features, (Mat)centers, (KMeansIndexParams)params) -> int :

idct(...)
idct( (Mat)src, (Mat)dst [, (object)flags=0]) -> None :

idft(...)
idft( (Mat)src, (Mat)dst [, (object)flags=0 [, (object)nonzeroRows=0]]) -> None :

imdecode(...)
imdecode( (Mat)buf, (object)flags) -> Mat :

imencode(...)
imencode( (object)ext, (Mat)img [, (Mat)params=Mat()]) -> tuple :

imread(...)
imread( (object)filename [, (object)flags=1]) -> Mat :

imshow(...)
imshow( (object)winname, (Mat)mat) -> None :

imwrite(...)
imwrite( (object)filename, (Mat)img [, (Mat)params=Mat()]) -> object :

inRange(...)
inRange( (MatND)src, (Scalar)lowerb, (Scalar)upperb, (MatND)dst) -> None :

initCameraMatrix2D(...)
initCameraMatrix2D( (list)objectPoints, (list)imagePoints, (Size2i)imageSize [, (object)aspectRatio=1.0]) -> object :

initNArrayIterator(...)
initNArrayIterator( (Mat)arrs, (Mat)mask, (object)stubs, (CvNArrayIterator)array_iterator [, (object)flags=0]) -> object :

initSubdivDelaunay2D(...)
initSubdivDelaunay2D( (CvSubdiv2D)subdiv, (CvRect)rect) -> None :

initSystem(...)
initSystem( (Mat)argv) -> object :

initUndistortRectifyMap(...)
initUndistortRectifyMap( (Mat)cameraMatrix, (Mat)distCoeffs, (Mat)R, (Mat)newCameraMatrix, (Size2i)size, (object)m1type, (Mat)map1, (Mat)map2) -> None :

inpaint(...)
inpaint( (Mat)src, (Mat)inpaintMask, (Mat)dst, (object)inpaintRange, (object)flags) -> None :

integral(...)
integral( (Mat)src, (Mat)sum, (Mat)sqsum, (Mat)tilted [, (object)sdepth=-1]) -> None :

invert(...)
invert( (Mat)a, (Mat)c [, (object)flags=0]) -> float :

invertAffineTransform(...)
invertAffineTransform( (Mat)M, (Mat)iM) -> None :

isContourConvex(...)
isContourConvex( (Mat)contour) -> bool :

isInf(...)
isInf( (object)value) -> int :

isNaN(...)
isNaN( (object)value) -> int :

kmeans(...)
kmeans( (Mat)data, (object)K, (Mat)best_labels, (TermCriteria)criteria, (object)attempts, (object)flags) -> tuple :

line(...)
line( (Mat)img, (Point2i)pt1, (Point2i)pt2, (Scalar)color [, (object)thickness=1 [, (object)lineType=8 [, (object)shift=0]]]) -> None :

linearPolar(...)
linearPolar( (Mat)src, (Mat)dst, (Point2f)center, (object)maxRadius [, (object)flags=9]) -> None :

log(...)
log( (MatND)a, (MatND)b) -> None :

logPolar(...)
logPolar( (Mat)src, (Mat)dst, (Point2f)center, (object)M [, (object)flags=9]) -> None :

magnitude(...)
magnitude( (Mat)x, (Mat)y, (Mat)magnitude) -> None :

matMulDeriv(...)
matMulDeriv( (Mat)A, (Mat)B, (Mat)dABdA, (Mat)dABdB) -> None :

matchContourTrees(...)
matchContourTrees( (CvContourTree)tree1, (CvContourTree)tree2, (object)method, (object)threshold) -> float :

matchShapes(...)
matchShapes( (Mat)contour1, (Mat)contour2, (object)method, (object)parameter) -> float :

matchTemplate(...)
matchTemplate( (Mat)image, (Mat)templ, (Mat)result, (object)method) -> None :

max(...)
max( (MatND)a, (object)alpha, (MatND)c) -> None :

maxRect(...)
maxRect( (CvRect)rect1, (CvRect)rect2) -> CvRect :

mean(...)
mean( (MatND)m [, (MatND)mask]) -> Scalar :

meanShift(...)
meanShift( (Mat)probImage, (Rect)window, (TermCriteria)criteria) -> int :

meanStdDev(...)
meanStdDev( (MatND)m, (Scalar)mean, (Scalar)stddev [, (MatND)mask=MatND(shape=(), nchannels=1, depth=0): array(0, dtype=uint8)]) -> None :

medianBlur(...)
medianBlur( (Mat)src, (Mat)dst, (object)ksize) -> None :

memStorageAllocString(...)
memStorageAllocString( (CvMemStorage)storage, (str)ptr [, (object)len=-1]) -> CvString :

merge(...)
merge( (list)mvbegin, (MatND)dst) -> None :

min(...)
min( (MatND)a, (object)alpha, (MatND)c) -> None :

minAreaRect(...)
minAreaRect( (Mat)points) -> RotatedRect :

minEnclosingCircle(...)
minEnclosingCircle( (Mat)points, (Point2f)center, (object)radius) -> None :

minMaxLoc(...)
minMaxLoc( (object)a [, (object)mask=None]) -> tuple :

mixChannels(...)
mixChannels( (object)src, (object)dst, (object)fromTo) -> tuple :

moments(...)
moments( (Mat)array [, (bool)binaryImage=False]) -> Moments :

Scalar :

morphologyDefaultBorderValue()
C++ signature :...

morphologyEx(...)
morphologyEx( (Mat)src, (Mat)dst, (object)op, (Mat)kernel [, (Point2i)anchor=Point2i(x=-1, y=-1) [, (object)iterations=1 [, (object)borderType=0 [, (Scalar)borderValue=Scalar([ 1.79769313e+308 1.79769313e+308 1.79769313e+308 1.79769313e+308])]]]]) -> None :

moveWindow(...)
moveWindow( (str)name, (object)x, (object)y) -> None :

mulSpectrums(...)
mulSpectrums( (Mat)a, (Mat)b, (Mat)c, (object)flags [, (bool)conjB=False]) -> None :

mulTransposed(...)
mulTransposed( (Mat)a, (Mat)c, (bool)aTa [, (Mat)delta=Mat() [, (object)scale=1 [, (object)rtype=-1]]]) -> None :

multiply(...)
multiply( (MatND)a, (MatND)b, (MatND)c [, (object)scale=1]) -> None :

multiplyAcc(...)
multiplyAcc( (Mat)image1, (Mat)image2, (Mat)acc [, (Mat)mask=Mat()]) -> None :

namedWindow(...)
namedWindow( (object)winname [, (object)flags=1]) -> None :

nextNArraySlice(...)
nextNArraySlice( (CvNArrayIterator)array_iterator) -> int :

norm(...)
norm( (SparseMat)src, (object)normType) -> float :

normalize(...)
normalize( (SparseMat)src, (SparseMat)dst, (object)alpha, (object)normType) -> None :

openFileStorage(...)
openFileStorage( (str)filename, (CvMemStorage)memstorage, (object)flags) -> CvFileStorage :

patchBasedStdDev(...)
patchBasedStdDev( (Mat)in_image, (Size2i)patch_size, (Mat)out_image) -> None :

perspectiveTransform(...)
perspectiveTransform( (Mat)src, (Mat)dst, (Mat)m) -> None :

phase(...)
phase( (Mat)x, (Mat)y, (Mat)angle [, (bool)angleInDegrees=False]) -> None :

pointPolygonTest(...)
pointPolygonTest( (Mat)contour, (Point2f)pt, (bool)measureDist) -> float :

pointSeqFromMat(...)
pointSeqFromMat( (object)seq_kind, (Mat)mat, (CvContour)contour_header, (CvSeqBlock)block) -> object :

polarToCart(...)
polarToCart( (Mat)magnitude, (Mat)angle, (Mat)x, (Mat)y [, (bool)angleInDegrees=False]) -> None :

polylines(...)
polylines( (Mat)img, (object)pts, (bool)isClosed, (Scalar)color [, (object)thickness=1 [, (object)lineType=8 [, (object)shift=0]]]) -> None :

pow(...)
pow( (MatND)a, (object)power, (MatND)b) -> None :

preCornerDetect(...)
preCornerDetect( (Mat)src, (Mat)dst, (object)ksize [, (object)borderType=4]) -> None :

projectPoints(...)
projectPoints( (Mat)objectPoints, (Mat)rvec, (Mat)tvec, (Mat)cameraMatrix, (Mat)distCoeffs) -> object :

projectPoints2(...)
projectPoints2( (Mat)objectPoints, (Mat)rvec, (Mat)tvec, (Mat)cameraMatrix, (Mat)distCoeffs, (Mat)dpdrot, (Mat)dpdt, (Mat)dpdf, (Mat)dpdc, (Mat)dpddist [, (object)aspectRatio=0]) -> object :

putText(...)
putText( (Mat)img, (object)text, (Point2i)org, (object)fontFace, (object)fontScale, (Scalar)color [, (object)thickness=1 [, (object)linetype=8 [, (bool)bottomLeftOrigin=False]]]) -> None :

pyrDown(...)
pyrDown( (Mat)src, (Mat)dst [, (Size2i)dstsize=Size2i(width=0, height=0)]) -> None :

pyrMeanShiftFiltering(...)
pyrMeanShiftFiltering( (Mat)src, (Mat)dst, (object)sp, (object)sr [, (object)max_level=1 [, (object)termcrit=TermCriteria(type=3, maxCount=5, epsilon=1.0)]]) -> None :

pyrSegmentation(...)
pyrSegmentation( (Mat)src, (Mat)dst, (CvMemStorage)storage, (object)level, (object)threshold1, (object)threshold2) -> object :

pyrUp(...)
pyrUp( (Mat)src, (Mat)dst [, (Size2i)dstsize=Size2i(width=0, height=0)]) -> None :

randArr(...)
randArr( (RNG)rng, (Mat)arr, (object)dist_type, (object)param1, (object)param2) -> None :

randShuffle(...)
randShuffle( (Mat)dst [, (object)iterFactor=1.0 [, (RNG)rng=None]]) -> None :

randn(...)
randn( (Mat)dst, (Scalar)mean, (Scalar)stddev) -> None :

randu(...)
randu( (Mat)dst, (Scalar)low, (Scalar)high) -> None :

range_(...)
range_( (Mat)mat, (object)start, (object)end) -> object :

readChainPoint(...)
readChainPoint( (CvChainPtReader)reader) -> object :

readInt(...)
readInt( (FileNode)node [, (object)default_value=0]) -> object :

readIntByName(...)
readIntByName( (CvFileStorage)fs, (FileNode)map, (str)name [, (object)default_value=0]) -> object :

readReal(...)
readReal( (FileNode)node [, (object)default_value=0.0]) -> object :

readRealByName(...)
readRealByName( (CvFileStorage)fs, (FileNode)map, (str)name [, (object)default_value=0.0]) -> object :

readString(...)
readString( (FileNode)node [, (str)default_value=None]) -> object :

readStringByName(...)
readStringByName( (CvFileStorage)fs, (FileNode)map, (str)name [, (str)default_value=None]) -> object :

read_KeyPoints(...)
read_KeyPoints( (FileNode)node) -> object :

read_Mat(...)
read_Mat( (FileNode)node [, (Mat)default_mat=Mat()]) -> object :

read_MatND(...)
read_MatND( (FileNode)node [, (MatND)default_mat=MatND(shape=(), nchannels=1, depth=0): array(0, dtype=uint8)]) -> object :

read_SparseMat(...)
read_SparseMat( (FileNode)node [, (SparseMat)default_mat=<pyopencv.pyopencvext.SparseMat object at 0x0184F7B0>]) -> object :

read_bool(...)
read_bool( (FileNode)node, (bool)default_value) -> object :

read_double(...)
read_double( (FileNode)node, (object)default_value) -> object :

read_float(...)
read_float( (FileNode)node, (object)default_value) -> object :

read_inst(...)
read_inst( (FileNode)node, (object)default_value) -> object :

read_schar(...)
read_schar( (FileNode)node, (object)default_value) -> object :

read_short(...)
read_short( (FileNode)node, (object)default_value) -> object :

read_str(...)
read_str( (FileNode)node, (object)default_value) -> object :

read_uchar(...)
read_uchar( (FileNode)node, (object)default_value) -> object :

read_ushort(...)
read_ushort( (FileNode)node, (object)default_value) -> object :

rectangle(...)
rectangle( (Mat)img, (Rect)rec, (Scalar)color [, (object)thickness=1 [, (object)lineType=8 [, (object)shift=0]]]) -> None :

reduce(...)
reduce( (Mat)m, (Mat)dst, (object)dim, (object)rtype [, (object)dtype=-1]) -> None :

registerModule(...)
registerModule( (CvModuleInfo)module_info) -> int :

registerType(...)
registerType( (CvTypeInfo)info) -> None :

remap(...)
remap( (Mat)src, (Mat)dst, (Mat)map1, (Mat)map2, (object)interpolation [, (object)borderMode=0 [, (Scalar)borderValue=Scalar([ 0.

repeat(...)
repeat( (Mat)src, (object)ny, (object)nx) -> Mat :

reprojectImageTo3D(...)
reprojectImageTo3D( (Mat)disparityImage, (Mat)_3dImage, (Mat)Q [, (object)handleMissingValues=0]) -> None :

resize(...)
resize( (Mat)src, (Mat)dst, (Size2i)dsize [, (object)fx=0 [, (object)fy=0 [, (object)interpolation=1]]]) -> None :

resizeWindow(...)
resizeWindow( (str)name, (object)width, (object)height) -> None :

restoreMemStoragePos(...)
restoreMemStoragePos( (CvMemStorage)storage, (CvMemStoragePos)pos) -> None :

round(...)
round( (object)value) -> int :

runningAvg(...)
runningAvg( (Mat)image, (Mat)acc, (object)alpha [, (Mat)mask=Mat()]) -> None :

sampleLine(...)
sampleLine( (Mat)image, (object)pt1, (object)pt2, (object)buffer [, (object)connectivity=8]) -> object :

saveMemStoragePos(...)
saveMemStoragePos( (CvMemStorage)storage, (CvMemStoragePos)pos) -> None :

scaleAdd(...)
scaleAdd( (MatND)a, (object)alpha, (MatND)b, (MatND)c) -> None :

segmentImage(...)
segmentImage( (Mat)srcarr, (Mat)dstarr, (object)canny_threshold, (object)ffill_threshold, (CvMemStorage)storage) -> object :

segmentMotion(...)
segmentMotion( (Mat)mhi, (Mat)seg_mask, (CvMemStorage)storage, (object)timestamp, (object)seg_thresh) -> object :

sepFilter2D(...)
sepFilter2D( (Mat)src, (Mat)dst, (object)ddepth, (Mat)kernelX, (Mat)kernelY [, (Point2i)anchor=Point2i(x=-1, y=-1) [, (object)delta=0 [, (object)borderType=4]]]) -> None :

seqInsertSlice(...)
seqInsertSlice( (CvSeq)seq, (object)before_index, (Mat)from_arr) -> None :

seqInvert(...)
seqInvert( (CvSeq)seq) -> None :

seqRemove(...)
seqRemove( (CvSeq)seq, (object)index) -> None :

seqRemoveSlice(...)
seqRemoveSlice( (CvSeq)seq, (Range)slice) -> None :

seqSlice(...)
seqSlice( (CvSeq)seq, (Range)slice [, (CvMemStorage)storage=None [, (object)copy_data=0]]) -> CvSeq :

setErrMode(...)
setErrMode( (object)mode) -> int :

setErrStatus(...)
setErrStatus( (object)status) -> None :

setIdentity(...)
setIdentity( (Mat)c [, (Scalar)s=Scalar([ 1.

setNumThreads(...)
setNumThreads([ (object)threads=0]) -> None :

setRemove(...)
setRemove( (CvSet)set_header, (object)index) -> None :

setSeqBlockSize(...)
setSeqBlockSize( (CvSeq)seq, (object)delta_elems) -> None :

setSeqReaderPos(...)
setSeqReaderPos( (CvSeqReader)reader, (object)index [, (object)is_relative=0]) -> None :

setTrackbarPos(...)
setTrackbarPos( (str)trackbar_name, (str)window_name, (object)pos) -> None :

setUseOptimized(...)
setUseOptimized( (bool)arg0) -> None :

setWindowProperty(...)
setWindowProperty( (object)winname, (object)prop_id, (object)prop_value) -> None :

sliceLength(...)
sliceLength( (Range)slice, (CvSeq)seq) -> int :

smooth(...)
smooth( (Mat)src, (Mat)dst [, (object)smoothtype=2 [, (object)size1=3 [, (object)size2=0 [, (object)sigma1=0 [, (object)sigma2=0]]]]]) -> None :

snakeImage(...)
snakeImage( (Mat)image, (Mat)points, (object)alpha, (object)beta, (object)gamma, (object)coeff_usage, (Size2i)win, (TermCriteria)criteria [, (object)calc_gradient=1]) -> None :

solve(...)
solve( (Mat)a, (Mat)b, (Mat)x [, (object)flags=0]) -> bool :

solveCubic(...)
solveCubic( (Mat)coeffs, (Mat)roots) -> object :

solvePnP(...)
solvePnP( (Mat)objectPoints, (Mat)imagePoints, (Mat)cameraMatrix, (Mat)distCoeffs, (Mat)rvec, (Mat)tvec [, (bool)useExtrinsicGuess=False]) -> None :

solvePoly(...)
solvePoly( (Mat)coeffs, (Mat)roots2 [, (object)maxiter=20 [, (object)fig=100]]) -> None :

sort(...)
sort( (Mat)a, (Mat)b, (object)flags) -> None :

sortIdx(...)
sortIdx( (Mat)a, (Mat)b, (object)flags) -> None :

split(...)
split( (MatND)m, (list)mv) -> None :

sqrt(...)
sqrt( (MatND)a, (MatND)b) -> None :

squareAcc(...)
squareAcc( (Mat)image, (Mat)sqsum [, (Mat)mask=Mat()]) -> None :

starKeypoint(...)
starKeypoint( (object)pt, (object)size, (object)response) -> CvStarKeypoint :

startAppendToSeq(...)
startAppendToSeq( (CvSeq)seq, (CvSeqWriter)writer) -> None :

startFindContours(...)
startFindContours( (Mat)image, (CvMemStorage)storage [, (object)header_size=88 [, (object)mode=1 [, (object)method=2 [, (object)offset=Point2i(x=0, y=0)]]]]) -> object :

startNextStream(...)
startNextStream( (FileStorage)fs) -> None :

startReadChainPoints(...)
startReadChainPoints( (CvChain)chain, (CvChainPtReader)reader) -> None :

startReadRawData(...)
startReadRawData( (CvFileStorage)fs, (FileNode)src, (CvSeqReader)reader) -> None :

startReadSeq(...)
startReadSeq( (CvSeq)seq, (CvSeqReader)reader [, (object)reverse=0]) -> None :

int :

startWindowThread()
Wrapped function: cvStartWindowThread

startWriteSeq(...)
startWriteSeq( (object)seq_flags, (object)header_size, (object)elem_size, (CvMemStorage)storage, (CvSeqWriter)writer) -> None :

startWriteStruct(...)
startWriteStruct( (FileStorage)fs, (str)name, (object)struct_flags [, (str)type_name=None [, (CvAttrList)attributes=<pyopencv.pyopencvext.CvAttrList object at 0x0184F5B0>]]) -> None :

stereoCalibrate(...)
stereoCalibrate( (list)objectPoints, (list)imagePoints1, (list)imagePoints2, (Mat)cameraMatrix1, (Mat)distCoeffs1, (Mat)cameraMatrix2, (Mat)distCoeffs2, (Size2i)imageSize, (Mat)R, (Mat)T, (Mat)E, (Mat)F [, (TermCriteria)criteria=TermCriteria(type=3, maxCount=30, epsilon=9.9999999999999995e-07) [, (object)flags=256]]) -> object :

stereoRectifyUncalibrated(...)
stereoRectifyUncalibrated( (Mat)points1, (Mat)points2, (Mat)F, (Size2i)imgSize, (Mat)H1, (Mat)H2 [, (object)threshold=5]) -> bool :

subdiv2DEdgeDst(...)
subdiv2DEdgeDst( (object)edge) -> CvSubdiv2DPoint :

subdiv2DEdgeOrg(...)
subdiv2DEdgeOrg( (object)edge) -> CvSubdiv2DPoint :

subdiv2DGetEdge(...)
subdiv2DGetEdge( (object)edge, (CvNextEdgeType)type) -> int :

subdiv2DLocate(...)
subdiv2DLocate( (CvSubdiv2D)subdiv, (Point2f)pt, (object)edge) -> tuple :

subdiv2DNextEdge(...)
subdiv2DNextEdge( (object)edge) -> int :

subdiv2DRotateEdge(...)
subdiv2DRotateEdge( (object)edge, (object)rotate) -> int :

subdiv2DSymEdge(...)
subdiv2DSymEdge( (object)edge) -> int :

subdivDelaunay2DInsert(...)
subdivDelaunay2DInsert( (CvSubdiv2D)subdiv, (Point2f)pt) -> object :

substituteContour(...)
substituteContour( (CvContourScanner)scanner, (CvSeq)new_contour) -> None :

subtract(...)
subtract( (MatND)a, (Scalar)s, (MatND)c [, (MatND)mask=MatND(shape=(), nchannels=1, depth=0): array(0, dtype=uint8)]) -> None :

sum(...)
sum( (MatND)m) -> Scalar :

RNG :

theRNG()
C++ signature :...

threshold(...)
threshold( (Mat)src, (Mat)dst, (object)thresh, (object)maxval, (object)type) -> float :

toUtf16(...)
toUtf16( (object)str) -> unicode :

trace(...)
trace( (Mat)m) -> Scalar :

transform(...)
transform( (Mat)src, (Mat)dst, (Mat)m) -> None :

transpose(...)
transpose( (Mat)a, (Mat)b) -> None :

triangleArea(...)
triangleArea( (Point2f)a, (Point2f)b, (Point2f)c) -> object :

triangulatePoints(...)
triangulatePoints( (Mat)projMatr1, (Mat)projMatr2, (Mat)projPoints1, (Mat)projPoints2, (Mat)points4D) -> None :

typeOf(...)
typeOf( (object)struct_ptr) -> object :

undistort(...)
undistort( (Mat)src, (Mat)dst, (Mat)cameraMatrix, (Mat)distCoeffs [, (Mat)newCameraMatrix=Mat()]) -> None :

undistortPoints(...)
undistortPoints( (Mat)src, (Mat)dst, (Mat)cameraMatrix, (Mat)distCoeffs [, (Mat)R=Mat() [, (Mat)P=Mat()]]) -> None :

undistortPoints2(...)
undistortPoints2( (Mat)src, (Mat)cameraMatrix, (Mat)distCoeffs [, (Mat)R=Mat() [, (Mat)P=Mat()]]) -> object :

unregisterType(...)
unregisterType( (str)type_name) -> None :

updateMotionHistory(...)
updateMotionHistory( (Mat)silhouette, (Mat)mhi, (object)timestamp, (object)duration) -> None :

useOptimized(...)
useOptimized( (object)on_off) -> int :

validateDisparity(...)
validateDisparity( (Mat)disparity, (Mat)cost, (object)minDisparity, (object)numberOfDisparities [, (object)disp12MaxDisp=1]) -> None :

waitKey(...)
waitKey([ (object)delay=0]) -> int :

warpAffine(...)
warpAffine( (Mat)src, (Mat)dst, (Mat)M, (Size2i)dsize [, (object)flags=1 [, (object)borderMode=0 [, (Scalar)borderValue=Scalar([ 0.

warpPerspective(...)
warpPerspective( (Mat)src, (Mat)dst, (Mat)M, (Size2i)dsize [, (object)flags=1 [, (object)borderMode=0 [, (Scalar)borderValue=Scalar([ 0.

watershed(...)
watershed( (Mat)image, (Mat)markers) -> None :

write(...)
write( (FileStorage)fs, (str)name, (str)ptr [, (CvAttrList)attributes=<pyopencv.pyopencvext.CvAttrList object at 0x0184F5F0>]) -> None :

writeComment(...)
writeComment( (FileStorage)fs, (str)comment, (object)eol_comment) -> None :

writeFileNode(...)
writeFileNode( (FileStorage)fs, (str)new_node_name, (FileNode)node, (object)embed) -> None :

writeInt(...)
writeInt( (FileStorage)fs, (str)name, (object)value) -> None :

writeReal(...)
writeReal( (FileStorage)fs, (str)name, (object)value) -> None :

writeString(...)
writeString( (FileStorage)fs, (str)name, (str)str [, (object)quote=0]) -> None :

Variables

[hide private]

ADAPTIVE_THRESH_GAUSSIAN_C = 1

ADAPTIVE_THRESH_MEAN_C = 0

AUTOTUNED = pyopencv.pyopencvext.flann_algorithm_t.AUTOTUNED

BORDER_CONSTANT = 0

BORDER_DEFAULT = 4

BORDER_ISOLATED = 16

BORDER_REFLECT = 2

BORDER_REFLECT101 = 4

BORDER_REFLECT_101 = 4

BORDER_REPLICATE = 1

BORDER_TRANSPARENT = 4

BORDER_WRAP = 3

CALIB_CB_ADAPTIVE_THRESH = 1

CALIB_CB_FILTER_QUADS = 4

CALIB_CB_NORMALIZE_IMAGE = 2

CALIB_FIX_ASPECT_RATIO = 2

CALIB_FIX_FOCAL_LENGTH = 16

CALIB_FIX_INTRINSIC = 256

CALIB_FIX_K1 = 32

CALIB_FIX_K2 = 64

CALIB_FIX_K3 = 128

CALIB_FIX_PRINCIPAL_POINT = 4

CALIB_SAME_FOCAL_LENGTH = 512

CALIB_USE_INTRINSIC_GUESS = 1

CALIB_ZERO_DISPARITY = 1024

CALIB_ZERO_TANGENT_DIST = 8

CENTERS_GONZALES = pyopencv.pyopencvext.flann_centers_init_t.C...

CENTERS_KMEANSPP = pyopencv.pyopencvext.flann_centers_init_t.C...

CENTERS_RANDOM = pyopencv.pyopencvext.flann_centers_init_t.CEN...

CHAIN_APPROX_NONE = 1

CHAIN_APPROX_SIMPLE = 2

CHAIN_APPROX_TC89_KCOS = 4

CHAIN_APPROX_TC89_L1 = 3

CMP_EQ = 0

CMP_GE = 2

CMP_GT = 1

CMP_LE = 4

CMP_LT = 3

CMP_NE = 5

COMPOSITE = pyopencv.pyopencvext.flann_algorithm_t.COMPOSITE

CV_BADARG_ERR = pyopencv.pyopencvext.CvStatus.CV_BADARG_ERR

CV_BADCHANNELS_ERR = pyopencv.pyopencvext.CvStatus.CV_BADCHANN...

CV_BADCOEF_ERR = pyopencv.pyopencvext.CvStatus.CV_BADCOEF_ERR

CV_BADCONVERGENCE_ERR = pyopencv.pyopencvext.CvStatus.CV_BADCO...

CV_BADDEPTH_ERR = pyopencv.pyopencvext.CvStatus.CV_BADDEPTH_ERR

CV_BADFACTOR_ERR = pyopencv.pyopencvext.CvStatus.CV_BADFACTOR_ERR

CV_BADFLAG_ERR = pyopencv.pyopencvext.CvStatus.CV_BADFLAG_ERR

CV_BADHEADER_ERR = pyopencv.pyopencvext.CvStatus.CV_BADHEADER_ERR

CV_BADMEMBLOCK_ERR = pyopencv.pyopencvext.CvStatus.CV_BADMEMBL...

CV_BADPOINT_ERR = pyopencv.pyopencvext.CvStatus.CV_BADPOINT_ERR

CV_BADRANGE_ERR = pyopencv.pyopencvext.CvStatus.CV_BADRANGE_ERR

CV_BADROI_ERR = pyopencv.pyopencvext.CvStatus.CV_BADROI_ERR

CV_BADSCALE_ERR = pyopencv.pyopencvext.CvStatus.CV_BADSCALE_ERR

CV_BADSIZE_ERR = pyopencv.pyopencvext.CvStatus.CV_BADSIZE_ERR

CV_BADSTEP_ERR = pyopencv.pyopencvext.CvStatus.CV_BADSTEP_ERR

CV_CALIB_ETALON_CHECKERBOARD = pyopencv.pyopencvext.CvCalibEta...

CV_CALIB_ETALON_CHESSBOARD = pyopencv.pyopencvext.CvCalibEtalo...

CV_CALIB_ETALON_USER = pyopencv.pyopencvext.CvCalibEtalonType....

CV_DIV_BY_ZERO_ERR = pyopencv.pyopencvext.CvStatus.CV_DIV_BY_Z...

CV_FACE_LEFT_EYE = pyopencv.pyopencvext.CV_FACE_ELEMENTS.CV_FA...

CV_FACE_MOUTH = pyopencv.pyopencvext.CV_FACE_ELEMENTS.CV_FACE_...

CV_FACE_RIGHT_EYE = pyopencv.pyopencvext.CV_FACE_ELEMENTS.CV_F...

CV_GAUSSIAN_5x5 = pyopencv.pyopencvext.CvFilter.CV_GAUSSIAN_5x5

CV_INPLACE_NOT_SUPPORTED_ERR = pyopencv.pyopencvext.CvStatus.C...

CV_LEE_AUTO = pyopencv.pyopencvext.CvLeeParameters.CV_LEE_AUTO

CV_LEE_DOUBLE = pyopencv.pyopencvext.CvLeeParameters.CV_LEE_DO...

CV_LEE_ERODE = pyopencv.pyopencvext.CvLeeParameters.CV_LEE_ERODE

CV_LEE_FLOAT = pyopencv.pyopencvext.CvLeeParameters.CV_LEE_FLOAT

CV_LEE_INT = pyopencv.pyopencvext.CvLeeParameters.CV_LEE_INT

CV_LEE_NON = pyopencv.pyopencvext.CvLeeParameters.CV_LEE_NON

CV_LEE_ZOOM = pyopencv.pyopencvext.CvLeeParameters.CV_LEE_ZOOM

CV_NEXT_AROUND_DST = pyopencv.pyopencvext.CvNextEdgeType.CV_NE...

CV_NEXT_AROUND_LEFT = pyopencv.pyopencvext.CvNextEdgeType.CV_N...

CV_NEXT_AROUND_ORG = pyopencv.pyopencvext.CvNextEdgeType.CV_NE...

CV_NEXT_AROUND_RIGHT = pyopencv.pyopencvext.CvNextEdgeType.CV_...

CV_NOTDEFINED_ERR = pyopencv.pyopencvext.CvStatus.CV_NOTDEFINE...

CV_NOTFOUND_ERR = pyopencv.pyopencvext.CvStatus.CV_NOTFOUND_ERR

CV_NOT_WEIGHTED = pyopencv.pyopencvext.CvGraphWeightType.CV_NO...

CV_NO_ERR = pyopencv.pyopencvext.CvStatus.CV_NO_ERR

CV_NULLPTR_ERR = pyopencv.pyopencvext.CvStatus.CV_NULLPTR_ERR

CV_OK = pyopencv.pyopencvext.CvStatus.CV_OK

CV_OUTOFMEM_ERR = pyopencv.pyopencvext.CvStatus.CV_OUTOFMEM_ERR

CV_PREV_AROUND_DST = pyopencv.pyopencvext.CvNextEdgeType.CV_PR...

CV_PREV_AROUND_LEFT = pyopencv.pyopencvext.CvNextEdgeType.CV_P...

CV_PREV_AROUND_ORG = pyopencv.pyopencvext.CvNextEdgeType.CV_PR...

CV_PREV_AROUND_RIGHT = pyopencv.pyopencvext.CvNextEdgeType.CV_...

CV_PTLOC_ERROR = pyopencv.pyopencvext.CvSubdiv2DPointLocation....

CV_PTLOC_INSIDE = pyopencv.pyopencvext.CvSubdiv2DPointLocation...

CV_PTLOC_ON_EDGE = pyopencv.pyopencvext.CvSubdiv2DPointLocatio...

CV_PTLOC_OUTSIDE_RECT = pyopencv.pyopencvext.CvSubdiv2DPointLo...

CV_PTLOC_VERTEX = pyopencv.pyopencvext.CvSubdiv2DPointLocation...

CV_UNMATCHED_FORMATS_ERR = pyopencv.pyopencvext.CvStatus.CV_UN...

CV_UNMATCHED_ROI_ERR = pyopencv.pyopencvext.CvStatus.CV_UNMATC...

CV_UNSUPPORTED_CHANNELS_ERR = pyopencv.pyopencvext.CvStatus.CV...

CV_UNSUPPORTED_COI_ERR = pyopencv.pyopencvext.CvStatus.CV_UNSU...

CV_UNSUPPORTED_DEPTH_ERR = pyopencv.pyopencvext.CvStatus.CV_UN...

CV_UNSUPPORTED_FORMAT_ERR = pyopencv.pyopencvext.CvStatus.CV_U...

CV_WEIGHTED_ALL = pyopencv.pyopencvext.CvGraphWeightType.CV_WE...

CV_WEIGHTED_EDGE = pyopencv.pyopencvext.CvGraphWeightType.CV_W...

CV_WEIGHTED_VTX = pyopencv.pyopencvext.CvGraphWeightType.CV_WE...

DCT_INVERSE = 1

DCT_ROWS = 4

DECOMP_CHOLESKY = 3

DECOMP_EIG = 2

DECOMP_LU = 0

DECOMP_NORMAL = 16

DECOMP_QR = 4

DECOMP_SVD = 1

DEPTH_MASK = 7

DFT_COMPLEX_OUTPUT = 16

DFT_INVERSE = 1

DFT_REAL_OUTPUT = 32

DFT_ROWS = 4

DFT_SCALE = 2

EUCLIDEAN = pyopencv.pyopencvext.flann_distance_t.EUCLIDEAN

FLOODFILL_FIXED_RANGE = 65536

FLOODFILL_MASK_ONLY = 131072

FM_7POINT = 1

FM_8POINT = 2

FM_LMEDS = 4

FM_RANSAC = 8

FONT_HERSHEY_COMPLEX = 3

FONT_HERSHEY_COMPLEX_SMALL = 5

FONT_HERSHEY_DUPLEX = 2

FONT_HERSHEY_PLAIN = 1

FONT_HERSHEY_SCRIPT_COMPLEX = 7

FONT_HERSHEY_SCRIPT_SIMPLEX = 6

FONT_HERSHEY_SIMPLEX = 0

FONT_HERSHEY_TRIPLEX = 4

FONT_ITALIC = 16

GC_BGD = 0

GC_EVAL = 2

GC_FGD = 1

GC_INIT_WITH_MASK = 1

GC_INIT_WITH_RECT = 0

GC_PR_BGD = 2

GC_PR_FGD = 3

GEMM_1_T = 1

GEMM_2_T = 2

GEMM_3_T = 4

INPAINT_NS = 0

INPAINT_TELEA = 1

INTER_AREA = 3

INTER_CUBIC = 2

INTER_LANCZOS4 = 4

INTER_LINEAR = 1

INTER_MAX = 7

INTER_NEAREST = 0

KDTREE = pyopencv.pyopencvext.flann_algorithm_t.KDTREE

KERNEL_ASYMMETRICAL = 2

KERNEL_GENERAL = 0

KERNEL_INTEGER = 8

KERNEL_SMOOTH = 4

KERNEL_SYMMETRICAL = 1

KMEANS = pyopencv.pyopencvext.flann_algorithm_t.KMEANS

KMEANS_PP_CENTERS = 2

KMEANS_RANDOM_CENTERS = 0

KMEANS_USE_INITIAL_LABELS = 1

LINEAR = pyopencv.pyopencvext.flann_algorithm_t.LINEAR

LMEDS = 4

LOG_ERROR = pyopencv.pyopencvext.flann_log_level_t.LOG_ERROR

LOG_FATAL = pyopencv.pyopencvext.flann_log_level_t.LOG_FATAL

LOG_INFO = pyopencv.pyopencvext.flann_log_level_t.LOG_INFO

LOG_NONE = pyopencv.pyopencvext.flann_log_level_t.LOG_NONE

LOG_WARN = pyopencv.pyopencvext.flann_log_level_t.LOG_WARN

MAGIC_MASK = -65536

MANHATTAN = pyopencv.pyopencvext.flann_distance_t.MANHATTAN

MINKOWSKI = pyopencv.pyopencvext.flann_distance_t.MINKOWSKI

MORPH_BLACKHAT = 6

MORPH_CLOSE = 3

MORPH_CROSS = 1

MORPH_DILATE = 1

MORPH_ELLIPSE = 2

MORPH_ERODE = 0

MORPH_GRADIENT = 4

MORPH_OPEN = 2

MORPH_RECT = 0

MORPH_TOPHAT = 5

NORM_INF = 1

NORM_L1 = 2

NORM_L2 = 4

NORM_MINMAX = 32

NORM_RELATIVE = 8

NORM_TYPE_MASK = 7

OPTFLOW_FARNEBACK_GAUSSIAN = 256

OPTFLOW_USE_INITIAL_FLOW = 4

RANSAC = 8

RETR_CCOMP = 2

RETR_EXTERNAL = 0

RETR_LIST = 1

RETR_TREE = 3

SAVED = pyopencv.pyopencvext.flann_algorithm_t.SAVED

THRESH_BINARY = 0

THRESH_BINARY_INV = 1

THRESH_MASK = 7

THRESH_OTSU = 8

THRESH_TOZERO = 3

THRESH_TOZERO_INV = 4

THRESH_TRUNC = 2

TM_CCOEFF = 4

TM_CCOEFF_NORMED = 5

TM_CCORR = 2

TM_CCORR_NORMED = 3

TM_SQDIFF = 0

TM_SQDIFF_NORMED = 1

TYPE_MASK = 4095

WARP_INVERSE_MAP = 16

__package__ = 'pyopencv'

Function Details

[hide private]

CamShift(...)


CamShift( (Mat)probImage, (Rect)window, (TermCriteria)criteria) -> RotatedRect :

    C++ signature :
        cv::RotatedRect CamShift(cv::Mat,cv::Rect_<int> {lvalue},cv::TermCriteria)

Canny(...)


Canny( (Mat)image, (Mat)edges, (object)threshold1, (object)threshold2 [, (object)apertureSize=3 [, (bool)L2gradient=False]]) -> None :

    C++ signature :
        void Canny(cv::Mat,cv::Mat {lvalue},double,double [,int=3 [,bool=False]])

FAST(...)


FAST( (Mat)image, (object)threshold [, (bool)nonmax_supression=True]) -> object :
    
    Argument 'keypoints':
        C/C++ type: ::std::vector< cv::KeyPoint > &.
        Python type: list.
        To convert a Mat into a list, invoke one of Mat's member functions 
        to_list_of_...().
        Output argument: omitted from the function's calling sequence, and is 
        returned along with the function's return value (if any).

    C++ signature :
        boost::python::api::object FAST(cv::Mat,int [,bool=True])

GaussianBlur(...)


GaussianBlur( (Mat)src, (Mat)dst, (Size2i)ksize, (object)sigma1 [, (object)sigma2=0 [, (object)borderType=4]]) -> None :

    C++ signature :
        void GaussianBlur(cv::Mat,cv::Mat {lvalue},cv::Size_<int>,double [,double=0 [,int=4]])

HoughCircles(...)


HoughCircles( (Mat)image, (object)method, (object)dp, (object)minDist [, (object)param1=100 [, (object)param2=100 [, (object)minRadius=0 [, (object)maxRadius=0]]]]) -> object :
    
    Argument 'circles':
        C/C++ type: ::std::vector< cv::Vec<float, 3> > &.
        Python type: Mat.
        Invoke asMat() to convert a 1D Python sequence into a Mat, e.g. 
        asMat([0,1,2]) or asMat((0,1,2)).
        Output argument: omitted from the function's calling sequence, and is 
        returned along with the function's return value (if any).

    C++ signature :
        boost::python::api::object HoughCircles(cv::Mat,int,double,double [,double=100 [,double=100 [,int=0 [,int=0]]]])

HoughLines(...)


HoughLines( (Mat)image, (object)rho, (object)theta, (object)threshold [, (object)srn=0 [, (object)stn=0]]) -> object :
    
    Argument 'lines':
        C/C++ type: ::std::vector< cv::Vec<float, 2> > &.
        Python type: Mat.
        Invoke asMat() to convert a 1D Python sequence into a Mat, e.g. 
        asMat([0,1,2]) or asMat((0,1,2)).
        Output argument: omitted from the function's calling sequence, and is 
        returned along with the function's return value (if any).

    C++ signature :
        boost::python::api::object HoughLines(cv::Mat,double,double,int [,double=0 [,double=0]])

HoughLinesP(...)


HoughLinesP( (Mat)image, (object)rho, (object)theta, (object)threshold [, (object)minLineLength=0 [, (object)maxLineGap=0]]) -> object :
    
    Argument 'lines':
        C/C++ type: ::std::vector< cv::Vec<int, 4> > &.
        Python type: Mat.
        Invoke asMat() to convert a 1D Python sequence into a Mat, e.g. 
        asMat([0,1,2]) or asMat((0,1,2)).
        Output argument: omitted from the function's calling sequence, and is 
        returned along with the function's return value (if any).

    C++ signature :
        boost::python::api::object HoughLinesP(cv::Mat {lvalue},double,double,int [,double=0 [,double=0]])

HuMoments(...)


HuMoments( (Moments)moments) -> object :

    C++ signature :
        boost::python::api::object HuMoments(cv::Moments)

LSHAdd(...)


LSHAdd( (CvLSH)lsh, (Mat)data [, (Mat)indices=Mat()]) -> None :
    
    Wrapped function:
        cvLSHAdd
    Argument 'indices':
        C/C++ type: ::CvMat *.
        Python type: Mat.
    Argument 'data':
        C/C++ type: ::CvMat const *.
        Python type: Mat.

    C++ signature :
        void LSHAdd(CvLSH*,cv::Mat {lvalue} [,cv::Mat=Mat()])

LSHQuery(...)


LSHQuery( (CvLSH)lsh, (Mat)query_points, (Mat)indices, (Mat)dist, (object)k, (object)emax) -> None :
    
    Wrapped function:
        cvLSHQuery
    Argument 'indices':
        C/C++ type: ::CvMat *.
        Python type: Mat.
    Argument 'query_points':
        C/C++ type: ::CvMat const *.
        Python type: Mat.
    Argument 'dist':
        C/C++ type: ::CvMat *.
        Python type: Mat.

    C++ signature :
        void LSHQuery(CvLSH*,cv::Mat {lvalue},cv::Mat {lvalue},cv::Mat {lvalue},int,int)

LSHRemove(...)


LSHRemove( (CvLSH)lsh, (Mat)indices) -> None :
    
    Wrapped function:
        cvLSHRemove
    Argument 'indices':
        C/C++ type: ::CvMat const *.
        Python type: Mat.

    C++ signature :
        void LSHRemove(CvLSH*,cv::Mat {lvalue})

LSHSize(...)


LSHSize( (CvLSH)lsh) -> int :

    C++ signature :
        unsigned int LSHSize(CvLSH*)

LUT(...)


LUT( (Mat)a, (Mat)lut, (Mat)b) -> None :

    C++ signature :
        void LUT(cv::Mat,cv::Mat,cv::Mat {lvalue})

Laplacian(...)


Laplacian( (Mat)src, (Mat)dst, (object)ddepth [, (object)ksize=1 [, (object)scale=1 [, (object)delta=0 [, (object)borderType=4]]]]) -> None :

    C++ signature :
        void Laplacian(cv::Mat,cv::Mat {lvalue},int [,int=1 [,double=1 [,double=0 [,int=4]]]])

Mahalanobis(...)


Mahalanobis( (Mat)v1, (Mat)v2, (Mat)icovar) -> float :

    C++ signature :
        double Mahalanobis(cv::Mat,cv::Mat,cv::Mat)

Mahalonobis(...)


Mahalonobis( (Mat)v1, (Mat)v2, (Mat)icovar) -> float :

    C++ signature :
        double Mahalonobis(cv::Mat,cv::Mat,cv::Mat)

POSIT(...)


POSIT( (CvPOSITObject)posit_object, (object)image_points, (object)focal_length, (object)criteria, (object)rotation_matrix, (object)translation_vector) -> None :
    
    Wrapped function:
        cvPOSIT

    C++ signature :
        void POSIT(CvPOSITObject*,CvPoint2D32f*,double,CvTermCriteria,float*,float*)

RANSACUpdateNumIters(...)


RANSACUpdateNumIters( (object)p, (object)err_prob, (object)model_points, (object)max_iters) -> int :
    
    Wrapped function:
        cvRANSACUpdateNumIters

    C++ signature :
        int RANSACUpdateNumIters(double,double,int,int)

RQDecomp3x3(...)


RQDecomp3x3( (Mat)M, (Mat)R, (Mat)Q, (Mat)Qx, (Mat)Qy, (Mat)Qz) -> Vec3d :

    C++ signature :
        cv::Vec<double, 3> RQDecomp3x3(cv::Mat,cv::Mat {lvalue},cv::Mat {lvalue},cv::Mat {lvalue},cv::Mat {lvalue},cv::Mat {lvalue})

RQDecomp3x3( (Mat)M, (Mat)R, (Mat)Q) -> None :

    C++ signature :
        void RQDecomp3x3(cv::Mat,cv::Mat {lvalue},cv::Mat {lvalue})

Rodrigues(...)


Rodrigues( (Mat)src, (Mat)dst [, (Mat)jacobian]) -> None :

    C++ signature :
        void Rodrigues(cv::Mat,cv::Mat {lvalue} [,cv::Mat {lvalue}])

SURFPoint(...)


SURFPoint( (Point2f)pt, (object)laplacian, (object)size [, (object)dir=0 [, (object)hessian=0]]) -> object :
    
    Wrapped function:
        cvSURFPoint
    Argument 'pt':
        C/C++ type: ::CvPoint2D32f.
        Python type: Point2f.

    C++ signature :
        boost::python::api::object SURFPoint(cv::Point_<float>,int,int [,float=0 [,float=0]])

Scharr(...)


Scharr( (Mat)src, (Mat)dst, (object)ddepth, (object)dx, (object)dy [, (object)scale=1 [, (object)delta=0 [, (object)borderType=4]]]) -> None :

    C++ signature :
        void Scharr(cv::Mat,cv::Mat {lvalue},int,int,int [,double=1 [,double=0 [,int=4]]])

Sobel(...)


Sobel( (Mat)src, (Mat)dst, (object)ddepth, (object)dx, (object)dy [, (object)ksize=3 [, (object)scale=1 [, (object)delta=0 [, (object)borderType=4]]]]) -> None :

    C++ signature :
        void Sobel(cv::Mat,cv::Mat {lvalue},int,int,int [,int=3 [,double=1 [,double=0 [,int=4]]]])

_cvCreateTrackbar2(...)


_cvCreateTrackbar2( (str)trackbar_name, (str)window_name, (object)value, (object)count, (object)on_change [, (object)userdata=None]) -> tuple :
    
    Wrapped function:
        cvCreateTrackbar2
    Argument 'on_change' is a Python function that should look like below:
        def on_trackbar(pos, user_data):
            ...
    Argument 'userdata' is a Python object that is passed to function 
    on_trackbar() as 'user_data'.

    C++ signature :
        boost::python::tuple _cvCreateTrackbar2(char const*,char const*,unsigned int,int,boost::python::api::object [,boost::python::api::object=None])

_cvDestroyAllWindows()

    Wrapped function:
        cvDestroyAllWindows

    C++ signature :
        void _cvDestroyAllWindows()

Returns: None :

_cvDestroyWindow(...)


_cvDestroyWindow( (str)name) -> None :
    
    Wrapped function:
        cvDestroyWindow

    C++ signature :
        void _cvDestroyWindow(char const*)

_cvEndFindContours(...)


_cvEndFindContours( (object)scanner) -> CvSeq :
    
    Wrapped function:
        cvEndFindContours

    C++ signature :
        CvSeq* _cvEndFindContours(_CvContourScanner**)

_cvReleaseConDensation(...)


_cvReleaseConDensation( (CvConDensation)condens) -> None :
    
    Wrapped function:
        cvReleaseConDensation
    Argument 'condens':
        C/C++ type: ::CvConDensation * *.
        Python type: Python equivalence of the C/C++ type without double 
        pointer.

    C++ signature :
        void _cvReleaseConDensation(CvConDensation)

_cvReleaseFeatureTree(...)


_cvReleaseFeatureTree( (CvFeatureTree)tr) -> None :
    
    Wrapped function:
        cvReleaseFeatureTree

    C++ signature :
        void _cvReleaseFeatureTree(CvFeatureTree*)

_cvReleaseFileStorage(...)


_cvReleaseFileStorage( (CvFileStorage)fs) -> None :
    
    Wrapped function:
        cvReleaseFileStorage
    Argument 'fs':
        C/C++ type: ::CvFileStorage * *.
        Python type: Python equivalence of the C/C++ type without double 
        pointer.

    C++ signature :
        void _cvReleaseFileStorage(CvFileStorage)

_cvReleaseLSH(...)


_cvReleaseLSH( (object)lsh) -> None :
    
    Wrapped function:
        cvReleaseLSH

    C++ signature :
        void _cvReleaseLSH(CvLSH**)

_cvReleaseMemStorage(...)


_cvReleaseMemStorage( (CvMemStorage)storage) -> None :
    
    Wrapped function:
        cvReleaseMemStorage
    Argument 'storage':
        C/C++ type: ::CvMemStorage * *.
        Python type: Python equivalence of the C/C++ type without double 
        pointer.

    C++ signature :
        void _cvReleaseMemStorage(CvMemStorage)

_cvReleasePOSITObject(...)


_cvReleasePOSITObject( (CvPOSITObject)posit_object) -> None :
    
    Wrapped function:
        cvReleasePOSITObject
    Argument 'posit_object':
        C/C++ type: ::CvPOSITObject * *.
        Python type: Python equivalence of the C/C++ type without double 
        pointer.

    C++ signature :
        void _cvReleasePOSITObject(CvPOSITObject)

_cvReleaseStereoGCState(...)


_cvReleaseStereoGCState( (CvStereoGCState)state) -> None :
    
    Wrapped function:
        cvReleaseStereoGCState
    Argument 'state':
        C/C++ type: ::CvStereoGCState * *.
        Python type: Python equivalence of the C/C++ type without double 
        pointer.

    C++ signature :
        void _cvReleaseStereoGCState(CvStereoGCState)

_cvSetMouseCallback(...)


_cvSetMouseCallback( (str)window_name, (object)on_mouse [, (object)param=None]) -> object :
    
    Wrapped function:
        cvSetMouseCallback
    Argument 'on_mouse' is a Python function that should look like below:
        def on_mouse(event, x, y, flags, user_data):
            ...
    Argument 'param' is a Python object that is passed to function 
    on_mouse() as 'user_data'.

    C++ signature :
        boost::python::api::object _cvSetMouseCallback(char const*,boost::python::api::object [,boost::python::api::object=None])

absdiff(...)


absdiff( (MatND)a, (Scalar)s, (MatND)c) -> None :
    
    Computes per-element absolute difference between 2 arrays or between 
    array and a scalar.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#absdiff

    C++ signature :
        void absdiff(cv::MatND,cv::Scalar_<double>,cv::MatND {lvalue})

absdiff( (MatND)a, (MatND)b, (MatND)c) -> None :
    
    Computes per-element absolute difference between 2 arrays or between 
    array and a scalar.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#absdiff

    C++ signature :
        void absdiff(cv::MatND,cv::MatND,cv::MatND {lvalue})

absdiff( (Mat)a, (Scalar)s, (Mat)c) -> None :
    
    Computes per-element absolute difference between 2 arrays or between 
    array and a scalar.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#absdiff

    C++ signature :
        void absdiff(cv::Mat,cv::Scalar_<double>,cv::Mat {lvalue})

absdiff( (Mat)a, (Mat)b, (Mat)c) -> None :
    
    Computes per-element absolute difference between 2 arrays or between 
    array and a scalar.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#absdiff

    C++ signature :
        void absdiff(cv::Mat,cv::Mat,cv::Mat {lvalue})

acc(...)


acc( (Mat)image, (Mat)sum [, (Mat)mask=Mat()]) -> None :
    
    Wrapped function:
        cvAcc
    Argument 'image':
        C/C++ type: ::CvArr const *.
        Python type: Mat.
    Argument 'mask':
        C/C++ type: ::CvArr const *.
        Python type: Mat.
    Argument 'sum':
        C/C++ type: ::CvArr *.
        Python type: Mat.

    C++ signature :
        void acc(cv::Mat {lvalue},cv::Mat {lvalue} [,cv::Mat=Mat()])

accumulate(...)


accumulate( (Mat)src, (Mat)dst [, (Mat)mask=Mat()]) -> None :

    C++ signature :
        void accumulate(cv::Mat,cv::Mat {lvalue} [,cv::Mat=Mat()])

accumulateProduct(...)


accumulateProduct( (Mat)src1, (Mat)src2, (Mat)dst [, (Mat)mask=Mat()]) -> None :

    C++ signature :
        void accumulateProduct(cv::Mat,cv::Mat,cv::Mat {lvalue} [,cv::Mat=Mat()])

accumulateSquare(...)


accumulateSquare( (Mat)src, (Mat)dst [, (Mat)mask=Mat()]) -> None :

    C++ signature :
        void accumulateSquare(cv::Mat,cv::Mat {lvalue} [,cv::Mat=Mat()])

accumulateWeighted(...)


accumulateWeighted( (Mat)src, (Mat)dst, (object)alpha [, (Mat)mask=Mat()]) -> None :

    C++ signature :
        void accumulateWeighted(cv::Mat,cv::Mat {lvalue},double [,cv::Mat=Mat()])

adaptiveThreshold(...)


adaptiveThreshold( (Mat)src, (Mat)dst, (object)maxValue, (object)adaptiveMethod, (object)thresholdType, (object)blockSize, (object)C) -> None :

    C++ signature :
        void adaptiveThreshold(cv::Mat,cv::Mat {lvalue},double,int,int,int,double)

add(...)


add( (MatND)a, (Scalar)s, (MatND)c [, (MatND)mask=MatND(shape=(), nchannels=1, depth=0):
array(24, dtype=uint8)]) -> None :
    
    Computes the per-element sum of two arrays or an array and a scalar.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#add

    C++ signature :
        void add(cv::MatND,cv::Scalar_<double>,cv::MatND {lvalue} [,cv::MatND=MatND(shape=(), nchannels=1, depth=0):
array(24, dtype=uint8)])

add( (MatND)a, (MatND)b, (MatND)c) -> None :
    
    Computes the per-element sum of two arrays or an array and a scalar.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#add

    C++ signature :
        void add(cv::MatND,cv::MatND,cv::MatND {lvalue})

add( (MatND)a, (MatND)b, (MatND)c, (MatND)mask) -> None :
    
    Computes the per-element sum of two arrays or an array and a scalar.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#add

    C++ signature :
        void add(cv::MatND,cv::MatND,cv::MatND {lvalue},cv::MatND)

add( (Mat)a, (Scalar)s, (Mat)c [, (Mat)mask=Mat()]) -> None :
    
    Computes the per-element sum of two arrays or an array and a scalar.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#add

    C++ signature :
        void add(cv::Mat,cv::Scalar_<double>,cv::Mat {lvalue} [,cv::Mat=Mat()])

add( (Mat)a, (Mat)b, (Mat)c) -> None :
    
    Computes the per-element sum of two arrays or an array and a scalar.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#add

    C++ signature :
        void add(cv::Mat,cv::Mat,cv::Mat {lvalue})

add( (Mat)a, (Mat)b, (Mat)c, (Mat)mask) -> None :
    
    Computes the per-element sum of two arrays or an array and a scalar.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#add

    C++ signature :
        void add(cv::Mat,cv::Mat,cv::Mat {lvalue},cv::Mat)

addWeighted(...)


addWeighted( (MatND)a, (object)alpha, (MatND)b, (object)beta, (object)gamma, (MatND)c) -> None :
    
    Computes the weighted sum of two arrays.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#addweighted

    C++ signature :
        void addWeighted(cv::MatND,double,cv::MatND,double,double,cv::MatND {lvalue})

addWeighted( (Mat)a, (object)alpha, (Mat)b, (object)beta, (object)gamma, (Mat)c) -> None :
    
    Computes the weighted sum of two arrays.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#addweighted

    C++ signature :
        void addWeighted(cv::Mat,double,cv::Mat,double,double,cv::Mat {lvalue})

approxChains(...)


approxChains( (CvSeq)src_seq, (CvMemStorage)storage [, (object)method=2 [, (object)parameter=0 [, (object)minimal_perimeter=0 [, (object)recursive=0]]]]) -> CvSeq :
    
    Wrapped function:
        cvApproxChains

    C++ signature :
        CvSeq* approxChains(CvSeq*,CvMemStorage* [,int=2 [,double=0 [,int=0 [,int=0]]]])

approxPolyDP(...)


approxPolyDP( (Mat)curve, (object)epsilon, (bool)closed) -> Mat :

    C++ signature :
        cv::Mat approxPolyDP(cv::Mat,double,bool)

arcLength(...)


arcLength( (Mat)curve, (bool)closed) -> float :

    C++ signature :
        double arcLength(cv::Mat,bool)

asComplexd(...)


asComplexd( (Complexf)inst_Complexf) -> Complexd :

    C++ signature :
        cv::Complex<double> asComplexd(cv::Complex<float>)

asComplexf(...)


asComplexf( (Complexd)inst_Complexd) -> Complexf :

    C++ signature :
        cv::Complex<float> asComplexf(cv::Complex<double>)

asMat(...)


asMat( (object)arr) -> object :

    C++ signature :
        boost::python::api::object asMat(boost::python::ndarray)

asMat1b(...)


asMat1b( (Mat2b)inst_Mat2b) -> Mat1b :

    C++ signature :
        cv::Mat_<unsigned char> asMat1b(cv::Mat_<cv::Vec<unsigned char, 2> >)

asMat1b( (Mat3b)inst_Mat3b) -> Mat1b :

    C++ signature :
        cv::Mat_<unsigned char> asMat1b(cv::Mat_<cv::Vec<unsigned char, 3> >)

asMat1b( (Mat4b)inst_Mat4b) -> Mat1b :

    C++ signature :
        cv::Mat_<unsigned char> asMat1b(cv::Mat_<cv::Vec<unsigned char, 4> >)

asMat1b( (Mat1s)inst_Mat1s) -> Mat1b :

    C++ signature :
        cv::Mat_<unsigned char> asMat1b(cv::Mat_<short>)

asMat1b( (Mat2s)inst_Mat2s) -> Mat1b :

    C++ signature :
        cv::Mat_<unsigned char> asMat1b(cv::Mat_<cv::Vec<short, 2> >)

asMat1b( (Mat3s)inst_Mat3s) -> Mat1b :

    C++ signature :
        cv::Mat_<unsigned char> asMat1b(cv::Mat_<cv::Vec<short, 3> >)

asMat1b( (Mat4s)inst_Mat4s) -> Mat1b :

    C++ signature :
        cv::Mat_<unsigned char> asMat1b(cv::Mat_<cv::Vec<short, 4> >)

asMat1b( (Mat1w)inst_Mat1w) -> Mat1b :

    C++ signature :
        cv::Mat_<unsigned char> asMat1b(cv::Mat_<unsigned short>)

asMat1b( (Mat2w)inst_Mat2w) -> Mat1b :

    C++ signature :
        cv::Mat_<unsigned char> asMat1b(cv::Mat_<cv::Vec<unsigned short, 2> >)

asMat1b( (Mat3w)inst_Mat3w) -> Mat1b :

    C++ signature :
        cv::Mat_<unsigned char> asMat1b(cv::Mat_<cv::Vec<unsigned short, 3> >)

asMat1b( (Mat4w)inst_Mat4w) -> Mat1b :

    C++ signature :
        cv::Mat_<unsigned char> asMat1b(cv::Mat_<cv::Vec<unsigned short, 4> >)

asMat1b( (Mat1i)inst_Mat1i) -> Mat1b :

    C++ signature :
        cv::Mat_<unsigned char> asMat1b(cv::Mat_<int>)

asMat1b( (Mat2i)inst_Mat2i) -> Mat1b :

    C++ signature :
        cv::Mat_<unsigned char> asMat1b(cv::Mat_<cv::Vec<int, 2> >)

asMat1b( (Mat3i)inst_Mat3i) -> Mat1b :

    C++ signature :
        cv::Mat_<unsigned char> asMat1b(cv::Mat_<cv::Vec<int, 3> >)

asMat1b( (Mat4i)inst_Mat4i) -> Mat1b :

    C++ signature :
        cv::Mat_<unsigned char> asMat1b(cv::Mat_<cv::Vec<int, 4> >)

asMat1b( (Mat1f)inst_Mat1f) -> Mat1b :

    C++ signature :
        cv::Mat_<unsigned char> asMat1b(cv::Mat_<float>)

asMat1b( (Mat2f)inst_Mat2f) -> Mat1b :

    C++ signature :
        cv::Mat_<unsigned char> asMat1b(cv::Mat_<cv::Vec<float, 2> >)

asMat1b( (Mat3f)inst_Mat3f) -> Mat1b :

    C++ signature :
        cv::Mat_<unsigned char> asMat1b(cv::Mat_<cv::Vec<float, 3> >)

asMat1b( (Mat4f)inst_Mat4f) -> Mat1b :

    C++ signature :
        cv::Mat_<unsigned char> asMat1b(cv::Mat_<cv::Vec<float, 4> >)

asMat1b( (Mat1d)inst_Mat1d) -> Mat1b :

    C++ signature :
        cv::Mat_<unsigned char> asMat1b(cv::Mat_<double>)

asMat1b( (Mat2d)inst_Mat2d) -> Mat1b :

    C++ signature :
        cv::Mat_<unsigned char> asMat1b(cv::Mat_<cv::Vec<double, 2> >)

asMat1b( (Mat3d)inst_Mat3d) -> Mat1b :

    C++ signature :
        cv::Mat_<unsigned char> asMat1b(cv::Mat_<cv::Vec<double, 3> >)

asMat1b( (Mat4d)inst_Mat4d) -> Mat1b :

    C++ signature :
        cv::Mat_<unsigned char> asMat1b(cv::Mat_<cv::Vec<double, 4> >)

asMat1d(...)


asMat1d( (Mat1b)inst_Mat1b) -> Mat1d :

    C++ signature :
        cv::Mat_<double> asMat1d(cv::Mat_<unsigned char>)

asMat1d( (Mat2b)inst_Mat2b) -> Mat1d :

    C++ signature :
        cv::Mat_<double> asMat1d(cv::Mat_<cv::Vec<unsigned char, 2> >)

asMat1d( (Mat3b)inst_Mat3b) -> Mat1d :

    C++ signature :
        cv::Mat_<double> asMat1d(cv::Mat_<cv::Vec<unsigned char, 3> >)

asMat1d( (Mat4b)inst_Mat4b) -> Mat1d :

    C++ signature :
        cv::Mat_<double> asMat1d(cv::Mat_<cv::Vec<unsigned char, 4> >)

asMat1d( (Mat1s)inst_Mat1s) -> Mat1d :

    C++ signature :
        cv::Mat_<double> asMat1d(cv::Mat_<short>)

asMat1d( (Mat2s)inst_Mat2s) -> Mat1d :

    C++ signature :
        cv::Mat_<double> asMat1d(cv::Mat_<cv::Vec<short, 2> >)

asMat1d( (Mat3s)inst_Mat3s) -> Mat1d :

    C++ signature :
        cv::Mat_<double> asMat1d(cv::Mat_<cv::Vec<short, 3> >)

asMat1d( (Mat4s)inst_Mat4s) -> Mat1d :

    C++ signature :
        cv::Mat_<double> asMat1d(cv::Mat_<cv::Vec<short, 4> >)

asMat1d( (Mat1w)inst_Mat1w) -> Mat1d :

    C++ signature :
        cv::Mat_<double> asMat1d(cv::Mat_<unsigned short>)

asMat1d( (Mat2w)inst_Mat2w) -> Mat1d :

    C++ signature :
        cv::Mat_<double> asMat1d(cv::Mat_<cv::Vec<unsigned short, 2> >)

asMat1d( (Mat3w)inst_Mat3w) -> Mat1d :

    C++ signature :
        cv::Mat_<double> asMat1d(cv::Mat_<cv::Vec<unsigned short, 3> >)

asMat1d( (Mat4w)inst_Mat4w) -> Mat1d :

    C++ signature :
        cv::Mat_<double> asMat1d(cv::Mat_<cv::Vec<unsigned short, 4> >)

asMat1d( (Mat1i)inst_Mat1i) -> Mat1d :

    C++ signature :
        cv::Mat_<double> asMat1d(cv::Mat_<int>)

asMat1d( (Mat2i)inst_Mat2i) -> Mat1d :

    C++ signature :
        cv::Mat_<double> asMat1d(cv::Mat_<cv::Vec<int, 2> >)

asMat1d( (Mat3i)inst_Mat3i) -> Mat1d :

    C++ signature :
        cv::Mat_<double> asMat1d(cv::Mat_<cv::Vec<int, 3> >)

asMat1d( (Mat4i)inst_Mat4i) -> Mat1d :

    C++ signature :
        cv::Mat_<double> asMat1d(cv::Mat_<cv::Vec<int, 4> >)

asMat1d( (Mat1f)inst_Mat1f) -> Mat1d :

    C++ signature :
        cv::Mat_<double> asMat1d(cv::Mat_<float>)

asMat1d( (Mat2f)inst_Mat2f) -> Mat1d :

    C++ signature :
        cv::Mat_<double> asMat1d(cv::Mat_<cv::Vec<float, 2> >)

asMat1d( (Mat3f)inst_Mat3f) -> Mat1d :

    C++ signature :
        cv::Mat_<double> asMat1d(cv::Mat_<cv::Vec<float, 3> >)

asMat1d( (Mat4f)inst_Mat4f) -> Mat1d :

    C++ signature :
        cv::Mat_<double> asMat1d(cv::Mat_<cv::Vec<float, 4> >)

asMat1d( (Mat2d)inst_Mat2d) -> Mat1d :

    C++ signature :
        cv::Mat_<double> asMat1d(cv::Mat_<cv::Vec<double, 2> >)

asMat1d( (Mat3d)inst_Mat3d) -> Mat1d :

    C++ signature :
        cv::Mat_<double> asMat1d(cv::Mat_<cv::Vec<double, 3> >)

asMat1d( (Mat4d)inst_Mat4d) -> Mat1d :

    C++ signature :
        cv::Mat_<double> asMat1d(cv::Mat_<cv::Vec<double, 4> >)

asMat1f(...)


asMat1f( (Mat1b)inst_Mat1b) -> Mat1f :

    C++ signature :
        cv::Mat_<float> asMat1f(cv::Mat_<unsigned char>)

asMat1f( (Mat2b)inst_Mat2b) -> Mat1f :

    C++ signature :
        cv::Mat_<float> asMat1f(cv::Mat_<cv::Vec<unsigned char, 2> >)

asMat1f( (Mat3b)inst_Mat3b) -> Mat1f :

    C++ signature :
        cv::Mat_<float> asMat1f(cv::Mat_<cv::Vec<unsigned char, 3> >)

asMat1f( (Mat4b)inst_Mat4b) -> Mat1f :

    C++ signature :
        cv::Mat_<float> asMat1f(cv::Mat_<cv::Vec<unsigned char, 4> >)

asMat1f( (Mat1s)inst_Mat1s) -> Mat1f :

    C++ signature :
        cv::Mat_<float> asMat1f(cv::Mat_<short>)

asMat1f( (Mat2s)inst_Mat2s) -> Mat1f :

    C++ signature :
        cv::Mat_<float> asMat1f(cv::Mat_<cv::Vec<short, 2> >)

asMat1f( (Mat3s)inst_Mat3s) -> Mat1f :

    C++ signature :
        cv::Mat_<float> asMat1f(cv::Mat_<cv::Vec<short, 3> >)

asMat1f( (Mat4s)inst_Mat4s) -> Mat1f :

    C++ signature :
        cv::Mat_<float> asMat1f(cv::Mat_<cv::Vec<short, 4> >)

asMat1f( (Mat1w)inst_Mat1w) -> Mat1f :

    C++ signature :
        cv::Mat_<float> asMat1f(cv::Mat_<unsigned short>)

asMat1f( (Mat2w)inst_Mat2w) -> Mat1f :

    C++ signature :
        cv::Mat_<float> asMat1f(cv::Mat_<cv::Vec<unsigned short, 2> >)

asMat1f( (Mat3w)inst_Mat3w) -> Mat1f :

    C++ signature :
        cv::Mat_<float> asMat1f(cv::Mat_<cv::Vec<unsigned short, 3> >)

asMat1f( (Mat4w)inst_Mat4w) -> Mat1f :

    C++ signature :
        cv::Mat_<float> asMat1f(cv::Mat_<cv::Vec<unsigned short, 4> >)

asMat1f( (Mat1i)inst_Mat1i) -> Mat1f :

    C++ signature :
        cv::Mat_<float> asMat1f(cv::Mat_<int>)

asMat1f( (Mat2i)inst_Mat2i) -> Mat1f :

    C++ signature :
        cv::Mat_<float> asMat1f(cv::Mat_<cv::Vec<int, 2> >)

asMat1f( (Mat3i)inst_Mat3i) -> Mat1f :

    C++ signature :
        cv::Mat_<float> asMat1f(cv::Mat_<cv::Vec<int, 3> >)

asMat1f( (Mat4i)inst_Mat4i) -> Mat1f :

    C++ signature :
        cv::Mat_<float> asMat1f(cv::Mat_<cv::Vec<int, 4> >)

asMat1f( (Mat2f)inst_Mat2f) -> Mat1f :

    C++ signature :
        cv::Mat_<float> asMat1f(cv::Mat_<cv::Vec<float, 2> >)

asMat1f( (Mat3f)inst_Mat3f) -> Mat1f :

    C++ signature :
        cv::Mat_<float> asMat1f(cv::Mat_<cv::Vec<float, 3> >)

asMat1f( (Mat4f)inst_Mat4f) -> Mat1f :

    C++ signature :
        cv::Mat_<float> asMat1f(cv::Mat_<cv::Vec<float, 4> >)

asMat1f( (Mat1d)inst_Mat1d) -> Mat1f :

    C++ signature :
        cv::Mat_<float> asMat1f(cv::Mat_<double>)

asMat1f( (Mat2d)inst_Mat2d) -> Mat1f :

    C++ signature :
        cv::Mat_<float> asMat1f(cv::Mat_<cv::Vec<double, 2> >)

asMat1f( (Mat3d)inst_Mat3d) -> Mat1f :

    C++ signature :
        cv::Mat_<float> asMat1f(cv::Mat_<cv::Vec<double, 3> >)

asMat1f( (Mat4d)inst_Mat4d) -> Mat1f :

    C++ signature :
        cv::Mat_<float> asMat1f(cv::Mat_<cv::Vec<double, 4> >)

asMat1i(...)


asMat1i( (Mat1b)inst_Mat1b) -> Mat1i :

    C++ signature :
        cv::Mat_<int> asMat1i(cv::Mat_<unsigned char>)

asMat1i( (Mat2b)inst_Mat2b) -> Mat1i :

    C++ signature :
        cv::Mat_<int> asMat1i(cv::Mat_<cv::Vec<unsigned char, 2> >)

asMat1i( (Mat3b)inst_Mat3b) -> Mat1i :

    C++ signature :
        cv::Mat_<int> asMat1i(cv::Mat_<cv::Vec<unsigned char, 3> >)

asMat1i( (Mat4b)inst_Mat4b) -> Mat1i :

    C++ signature :
        cv::Mat_<int> asMat1i(cv::Mat_<cv::Vec<unsigned char, 4> >)

asMat1i( (Mat1s)inst_Mat1s) -> Mat1i :

    C++ signature :
        cv::Mat_<int> asMat1i(cv::Mat_<short>)

asMat1i( (Mat2s)inst_Mat2s) -> Mat1i :

    C++ signature :
        cv::Mat_<int> asMat1i(cv::Mat_<cv::Vec<short, 2> >)

asMat1i( (Mat3s)inst_Mat3s) -> Mat1i :

    C++ signature :
        cv::Mat_<int> asMat1i(cv::Mat_<cv::Vec<short, 3> >)

asMat1i( (Mat4s)inst_Mat4s) -> Mat1i :

    C++ signature :
        cv::Mat_<int> asMat1i(cv::Mat_<cv::Vec<short, 4> >)

asMat1i( (Mat1w)inst_Mat1w) -> Mat1i :

    C++ signature :
        cv::Mat_<int> asMat1i(cv::Mat_<unsigned short>)

asMat1i( (Mat2w)inst_Mat2w) -> Mat1i :

    C++ signature :
        cv::Mat_<int> asMat1i(cv::Mat_<cv::Vec<unsigned short, 2> >)

asMat1i( (Mat3w)inst_Mat3w) -> Mat1i :

    C++ signature :
        cv::Mat_<int> asMat1i(cv::Mat_<cv::Vec<unsigned short, 3> >)

asMat1i( (Mat4w)inst_Mat4w) -> Mat1i :

    C++ signature :
        cv::Mat_<int> asMat1i(cv::Mat_<cv::Vec<unsigned short, 4> >)

asMat1i( (Mat2i)inst_Mat2i) -> Mat1i :

    C++ signature :
        cv::Mat_<int> asMat1i(cv::Mat_<cv::Vec<int, 2> >)

asMat1i( (Mat3i)inst_Mat3i) -> Mat1i :

    C++ signature :
        cv::Mat_<int> asMat1i(cv::Mat_<cv::Vec<int, 3> >)

asMat1i( (Mat4i)inst_Mat4i) -> Mat1i :

    C++ signature :
        cv::Mat_<int> asMat1i(cv::Mat_<cv::Vec<int, 4> >)

asMat1i( (Mat1f)inst_Mat1f) -> Mat1i :

    C++ signature :
        cv::Mat_<int> asMat1i(cv::Mat_<float>)

asMat1i( (Mat2f)inst_Mat2f) -> Mat1i :

    C++ signature :
        cv::Mat_<int> asMat1i(cv::Mat_<cv::Vec<float, 2> >)

asMat1i( (Mat3f)inst_Mat3f) -> Mat1i :

    C++ signature :
        cv::Mat_<int> asMat1i(cv::Mat_<cv::Vec<float, 3> >)

asMat1i( (Mat4f)inst_Mat4f) -> Mat1i :

    C++ signature :
        cv::Mat_<int> asMat1i(cv::Mat_<cv::Vec<float, 4> >)

asMat1i( (Mat1d)inst_Mat1d) -> Mat1i :

    C++ signature :
        cv::Mat_<int> asMat1i(cv::Mat_<double>)

asMat1i( (Mat2d)inst_Mat2d) -> Mat1i :

    C++ signature :
        cv::Mat_<int> asMat1i(cv::Mat_<cv::Vec<double, 2> >)

asMat1i( (Mat3d)inst_Mat3d) -> Mat1i :

    C++ signature :
        cv::Mat_<int> asMat1i(cv::Mat_<cv::Vec<double, 3> >)

asMat1i( (Mat4d)inst_Mat4d) -> Mat1i :

    C++ signature :
        cv::Mat_<int> asMat1i(cv::Mat_<cv::Vec<double, 4> >)

asMat1s(...)


asMat1s( (Mat1b)inst_Mat1b) -> Mat1s :

    C++ signature :
        cv::Mat_<short> asMat1s(cv::Mat_<unsigned char>)

asMat1s( (Mat2b)inst_Mat2b) -> Mat1s :

    C++ signature :
        cv::Mat_<short> asMat1s(cv::Mat_<cv::Vec<unsigned char, 2> >)

asMat1s( (Mat3b)inst_Mat3b) -> Mat1s :

    C++ signature :
        cv::Mat_<short> asMat1s(cv::Mat_<cv::Vec<unsigned char, 3> >)

asMat1s( (Mat4b)inst_Mat4b) -> Mat1s :

    C++ signature :
        cv::Mat_<short> asMat1s(cv::Mat_<cv::Vec<unsigned char, 4> >)

asMat1s( (Mat2s)inst_Mat2s) -> Mat1s :

    C++ signature :
        cv::Mat_<short> asMat1s(cv::Mat_<cv::Vec<short, 2> >)

asMat1s( (Mat3s)inst_Mat3s) -> Mat1s :

    C++ signature :
        cv::Mat_<short> asMat1s(cv::Mat_<cv::Vec<short, 3> >)

asMat1s( (Mat4s)inst_Mat4s) -> Mat1s :

    C++ signature :
        cv::Mat_<short> asMat1s(cv::Mat_<cv::Vec<short, 4> >)

asMat1s( (Mat1w)inst_Mat1w) -> Mat1s :

    C++ signature :
        cv::Mat_<short> asMat1s(cv::Mat_<unsigned short>)

asMat1s( (Mat2w)inst_Mat2w) -> Mat1s :

    C++ signature :
        cv::Mat_<short> asMat1s(cv::Mat_<cv::Vec<unsigned short, 2> >)

asMat1s( (Mat3w)inst_Mat3w) -> Mat1s :

    C++ signature :
        cv::Mat_<short> asMat1s(cv::Mat_<cv::Vec<unsigned short, 3> >)

asMat1s( (Mat4w)inst_Mat4w) -> Mat1s :

    C++ signature :
        cv::Mat_<short> asMat1s(cv::Mat_<cv::Vec<unsigned short, 4> >)

asMat1s( (Mat1i)inst_Mat1i) -> Mat1s :

    C++ signature :
        cv::Mat_<short> asMat1s(cv::Mat_<int>)

asMat1s( (Mat2i)inst_Mat2i) -> Mat1s :

    C++ signature :
        cv::Mat_<short> asMat1s(cv::Mat_<cv::Vec<int, 2> >)

asMat1s( (Mat3i)inst_Mat3i) -> Mat1s :

    C++ signature :
        cv::Mat_<short> asMat1s(cv::Mat_<cv::Vec<int, 3> >)

asMat1s( (Mat4i)inst_Mat4i) -> Mat1s :

    C++ signature :
        cv::Mat_<short> asMat1s(cv::Mat_<cv::Vec<int, 4> >)

asMat1s( (Mat1f)inst_Mat1f) -> Mat1s :

    C++ signature :
        cv::Mat_<short> asMat1s(cv::Mat_<float>)

asMat1s( (Mat2f)inst_Mat2f) -> Mat1s :

    C++ signature :
        cv::Mat_<short> asMat1s(cv::Mat_<cv::Vec<float, 2> >)

asMat1s( (Mat3f)inst_Mat3f) -> Mat1s :

    C++ signature :
        cv::Mat_<short> asMat1s(cv::Mat_<cv::Vec<float, 3> >)

asMat1s( (Mat4f)inst_Mat4f) -> Mat1s :

    C++ signature :
        cv::Mat_<short> asMat1s(cv::Mat_<cv::Vec<float, 4> >)

asMat1s( (Mat1d)inst_Mat1d) -> Mat1s :

    C++ signature :
        cv::Mat_<short> asMat1s(cv::Mat_<double>)

asMat1s( (Mat2d)inst_Mat2d) -> Mat1s :

    C++ signature :
        cv::Mat_<short> asMat1s(cv::Mat_<cv::Vec<double, 2> >)

asMat1s( (Mat3d)inst_Mat3d) -> Mat1s :

    C++ signature :
        cv::Mat_<short> asMat1s(cv::Mat_<cv::Vec<double, 3> >)

asMat1s( (Mat4d)inst_Mat4d) -> Mat1s :

    C++ signature :
        cv::Mat_<short> asMat1s(cv::Mat_<cv::Vec<double, 4> >)

asMat1w(...)


asMat1w( (Mat1b)inst_Mat1b) -> Mat1w :

    C++ signature :
        cv::Mat_<unsigned short> asMat1w(cv::Mat_<unsigned char>)

asMat1w( (Mat2b)inst_Mat2b) -> Mat1w :

    C++ signature :
        cv::Mat_<unsigned short> asMat1w(cv::Mat_<cv::Vec<unsigned char, 2> >)

asMat1w( (Mat3b)inst_Mat3b) -> Mat1w :

    C++ signature :
        cv::Mat_<unsigned short> asMat1w(cv::Mat_<cv::Vec<unsigned char, 3> >)

asMat1w( (Mat4b)inst_Mat4b) -> Mat1w :

    C++ signature :
        cv::Mat_<unsigned short> asMat1w(cv::Mat_<cv::Vec<unsigned char, 4> >)

asMat1w( (Mat1s)inst_Mat1s) -> Mat1w :

    C++ signature :
        cv::Mat_<unsigned short> asMat1w(cv::Mat_<short>)

asMat1w( (Mat2s)inst_Mat2s) -> Mat1w :

    C++ signature :
        cv::Mat_<unsigned short> asMat1w(cv::Mat_<cv::Vec<short, 2> >)

asMat1w( (Mat3s)inst_Mat3s) -> Mat1w :

    C++ signature :
        cv::Mat_<unsigned short> asMat1w(cv::Mat_<cv::Vec<short, 3> >)

asMat1w( (Mat4s)inst_Mat4s) -> Mat1w :

    C++ signature :
        cv::Mat_<unsigned short> asMat1w(cv::Mat_<cv::Vec<short, 4> >)

asMat1w( (Mat2w)inst_Mat2w) -> Mat1w :

    C++ signature :
        cv::Mat_<unsigned short> asMat1w(cv::Mat_<cv::Vec<unsigned short, 2> >)

asMat1w( (Mat3w)inst_Mat3w) -> Mat1w :

    C++ signature :
        cv::Mat_<unsigned short> asMat1w(cv::Mat_<cv::Vec<unsigned short, 3> >)

asMat1w( (Mat4w)inst_Mat4w) -> Mat1w :

    C++ signature :
        cv::Mat_<unsigned short> asMat1w(cv::Mat_<cv::Vec<unsigned short, 4> >)

asMat1w( (Mat1i)inst_Mat1i) -> Mat1w :

    C++ signature :
        cv::Mat_<unsigned short> asMat1w(cv::Mat_<int>)

asMat1w( (Mat2i)inst_Mat2i) -> Mat1w :

    C++ signature :
        cv::Mat_<unsigned short> asMat1w(cv::Mat_<cv::Vec<int, 2> >)

asMat1w( (Mat3i)inst_Mat3i) -> Mat1w :

    C++ signature :
        cv::Mat_<unsigned short> asMat1w(cv::Mat_<cv::Vec<int, 3> >)

asMat1w( (Mat4i)inst_Mat4i) -> Mat1w :

    C++ signature :
        cv::Mat_<unsigned short> asMat1w(cv::Mat_<cv::Vec<int, 4> >)

asMat1w( (Mat1f)inst_Mat1f) -> Mat1w :

    C++ signature :
        cv::Mat_<unsigned short> asMat1w(cv::Mat_<float>)

asMat1w( (Mat2f)inst_Mat2f) -> Mat1w :

    C++ signature :
        cv::Mat_<unsigned short> asMat1w(cv::Mat_<cv::Vec<float, 2> >)

asMat1w( (Mat3f)inst_Mat3f) -> Mat1w :

    C++ signature :
        cv::Mat_<unsigned short> asMat1w(cv::Mat_<cv::Vec<float, 3> >)

asMat1w( (Mat4f)inst_Mat4f) -> Mat1w :

    C++ signature :
        cv::Mat_<unsigned short> asMat1w(cv::Mat_<cv::Vec<float, 4> >)

asMat1w( (Mat1d)inst_Mat1d) -> Mat1w :

    C++ signature :
        cv::Mat_<unsigned short> asMat1w(cv::Mat_<double>)

asMat1w( (Mat2d)inst_Mat2d) -> Mat1w :

    C++ signature :
        cv::Mat_<unsigned short> asMat1w(cv::Mat_<cv::Vec<double, 2> >)

asMat1w( (Mat3d)inst_Mat3d) -> Mat1w :

    C++ signature :
        cv::Mat_<unsigned short> asMat1w(cv::Mat_<cv::Vec<double, 3> >)

asMat1w( (Mat4d)inst_Mat4d) -> Mat1w :

    C++ signature :
        cv::Mat_<unsigned short> asMat1w(cv::Mat_<cv::Vec<double, 4> >)

asMat2b(...)


asMat2b( (Mat1b)inst_Mat1b) -> Mat2b :

    C++ signature :
        cv::Mat_<cv::Vec<unsigned char, 2> > asMat2b(cv::Mat_<unsigned char>)

asMat2b( (Mat3b)inst_Mat3b) -> Mat2b :

    C++ signature :
        cv::Mat_<cv::Vec<unsigned char, 2> > asMat2b(cv::Mat_<cv::Vec<unsigned char, 3> >)

asMat2b( (Mat4b)inst_Mat4b) -> Mat2b :

    C++ signature :
        cv::Mat_<cv::Vec<unsigned char, 2> > asMat2b(cv::Mat_<cv::Vec<unsigned char, 4> >)

asMat2b( (Mat1s)inst_Mat1s) -> Mat2b :

    C++ signature :
        cv::Mat_<cv::Vec<unsigned char, 2> > asMat2b(cv::Mat_<short>)

asMat2b( (Mat2s)inst_Mat2s) -> Mat2b :

    C++ signature :
        cv::Mat_<cv::Vec<unsigned char, 2> > asMat2b(cv::Mat_<cv::Vec<short, 2> >)

asMat2b( (Mat3s)inst_Mat3s) -> Mat2b :

    C++ signature :
        cv::Mat_<cv::Vec<unsigned char, 2> > asMat2b(cv::Mat_<cv::Vec<short, 3> >)

asMat2b( (Mat4s)inst_Mat4s) -> Mat2b :

    C++ signature :
        cv::Mat_<cv::Vec<unsigned char, 2> > asMat2b(cv::Mat_<cv::Vec<short, 4> >)

asMat2b( (Mat1w)inst_Mat1w) -> Mat2b :

    C++ signature :
        cv::Mat_<cv::Vec<unsigned char, 2> > asMat2b(cv::Mat_<unsigned short>)

asMat2b( (Mat2w)inst_Mat2w) -> Mat2b :

    C++ signature :
        cv::Mat_<cv::Vec<unsigned char, 2> > asMat2b(cv::Mat_<cv::Vec<unsigned short, 2> >)

asMat2b( (Mat3w)inst_Mat3w) -> Mat2b :

    C++ signature :
        cv::Mat_<cv::Vec<unsigned char, 2> > asMat2b(cv::Mat_<cv::Vec<unsigned short, 3> >)

asMat2b( (Mat4w)inst_Mat4w) -> Mat2b :

    C++ signature :
        cv::Mat_<cv::Vec<unsigned char, 2> > asMat2b(cv::Mat_<cv::Vec<unsigned short, 4> >)

asMat2b( (Mat1i)inst_Mat1i) -> Mat2b :

    C++ signature :
        cv::Mat_<cv::Vec<unsigned char, 2> > asMat2b(cv::Mat_<int>)

asMat2b( (Mat2i)inst_Mat2i) -> Mat2b :

    C++ signature :
        cv::Mat_<cv::Vec<unsigned char, 2> > asMat2b(cv::Mat_<cv::Vec<int, 2> >)

asMat2b( (Mat3i)inst_Mat3i) -> Mat2b :

    C++ signature :
        cv::Mat_<cv::Vec<unsigned char, 2> > asMat2b(cv::Mat_<cv::Vec<int, 3> >)

asMat2b( (Mat4i)inst_Mat4i) -> Mat2b :

    C++ signature :
        cv::Mat_<cv::Vec<unsigned char, 2> > asMat2b(cv::Mat_<cv::Vec<int, 4> >)

asMat2b( (Mat1f)inst_Mat1f) -> Mat2b :

    C++ signature :
        cv::Mat_<cv::Vec<unsigned char, 2> > asMat2b(cv::Mat_<float>)

asMat2b( (Mat2f)inst_Mat2f) -> Mat2b :

    C++ signature :
        cv::Mat_<cv::Vec<unsigned char, 2> > asMat2b(cv::Mat_<cv::Vec<float, 2> >)

asMat2b( (Mat3f)inst_Mat3f) -> Mat2b :

    C++ signature :
        cv::Mat_<cv::Vec<unsigned char, 2> > asMat2b(cv::Mat_<cv::Vec<float, 3> >)

asMat2b( (Mat4f)inst_Mat4f) -> Mat2b :

    C++ signature :
        cv::Mat_<cv::Vec<unsigned char, 2> > asMat2b(cv::Mat_<cv::Vec<float, 4> >)

asMat2b( (Mat1d)inst_Mat1d) -> Mat2b :

    C++ signature :
        cv::Mat_<cv::Vec<unsigned char, 2> > asMat2b(cv::Mat_<double>)

asMat2b( (Mat2d)inst_Mat2d) -> Mat2b :

    C++ signature :
        cv::Mat_<cv::Vec<unsigned char, 2> > asMat2b(cv::Mat_<cv::Vec<double, 2> >)

asMat2b( (Mat3d)inst_Mat3d) -> Mat2b :

    C++ signature :
        cv::Mat_<cv::Vec<unsigned char, 2> > asMat2b(cv::Mat_<cv::Vec<double, 3> >)

asMat2b( (Mat4d)inst_Mat4d) -> Mat2b :

    C++ signature :
        cv::Mat_<cv::Vec<unsigned char, 2> > asMat2b(cv::Mat_<cv::Vec<double, 4> >)

asMat2d(...)


asMat2d( (Mat1b)inst_Mat1b) -> Mat2d :

    C++ signature :
        cv::Mat_<cv::Vec<double, 2> > asMat2d(cv::Mat_<unsigned char>)

asMat2d( (Mat2b)inst_Mat2b) -> Mat2d :

    C++ signature :
        cv::Mat_<cv::Vec<double, 2> > asMat2d(cv::Mat_<cv::Vec<unsigned char, 2> >)

asMat2d( (Mat3b)inst_Mat3b) -> Mat2d :

    C++ signature :
        cv::Mat_<cv::Vec<double, 2> > asMat2d(cv::Mat_<cv::Vec<unsigned char, 3> >)

asMat2d( (Mat4b)inst_Mat4b) -> Mat2d :

    C++ signature :
        cv::Mat_<cv::Vec<double, 2> > asMat2d(cv::Mat_<cv::Vec<unsigned char, 4> >)

asMat2d( (Mat1s)inst_Mat1s) -> Mat2d :

    C++ signature :
        cv::Mat_<cv::Vec<double, 2> > asMat2d(cv::Mat_<short>)

asMat2d( (Mat2s)inst_Mat2s) -> Mat2d :

    C++ signature :
        cv::Mat_<cv::Vec<double, 2> > asMat2d(cv::Mat_<cv::Vec<short, 2> >)

asMat2d( (Mat3s)inst_Mat3s) -> Mat2d :

    C++ signature :
        cv::Mat_<cv::Vec<double, 2> > asMat2d(cv::Mat_<cv::Vec<short, 3> >)

asMat2d( (Mat4s)inst_Mat4s) -> Mat2d :

    C++ signature :
        cv::Mat_<cv::Vec<double, 2> > asMat2d(cv::Mat_<cv::Vec<short, 4> >)

asMat2d( (Mat1w)inst_Mat1w) -> Mat2d :

    C++ signature :
        cv::Mat_<cv::Vec<double, 2> > asMat2d(cv::Mat_<unsigned short>)

asMat2d( (Mat2w)inst_Mat2w) -> Mat2d :

    C++ signature :
        cv::Mat_<cv::Vec<double, 2> > asMat2d(cv::Mat_<cv::Vec<unsigned short, 2> >)

asMat2d( (Mat3w)inst_Mat3w) -> Mat2d :

    C++ signature :
        cv::Mat_<cv::Vec<double, 2> > asMat2d(cv::Mat_<cv::Vec<unsigned short, 3> >)

asMat2d( (Mat4w)inst_Mat4w) -> Mat2d :

    C++ signature :
        cv::Mat_<cv::Vec<double, 2> > asMat2d(cv::Mat_<cv::Vec<unsigned short, 4> >)

asMat2d( (Mat1i)inst_Mat1i) -> Mat2d :

    C++ signature :
        cv::Mat_<cv::Vec<double, 2> > asMat2d(cv::Mat_<int>)

asMat2d( (Mat2i)inst_Mat2i) -> Mat2d :

    C++ signature :
        cv::Mat_<cv::Vec<double, 2> > asMat2d(cv::Mat_<cv::Vec<int, 2> >)

asMat2d( (Mat3i)inst_Mat3i) -> Mat2d :

    C++ signature :
        cv::Mat_<cv::Vec<double, 2> > asMat2d(cv::Mat_<cv::Vec<int, 3> >)

asMat2d( (Mat4i)inst_Mat4i) -> Mat2d :

    C++ signature :
        cv::Mat_<cv::Vec<double, 2> > asMat2d(cv::Mat_<cv::Vec<int, 4> >)

asMat2d( (Mat1f)inst_Mat1f) -> Mat2d :

    C++ signature :
        cv::Mat_<cv::Vec<double, 2> > asMat2d(cv::Mat_<float>)

asMat2d( (Mat2f)inst_Mat2f) -> Mat2d :

    C++ signature :
        cv::Mat_<cv::Vec<double, 2> > asMat2d(cv::Mat_<cv::Vec<float, 2> >)

asMat2d( (Mat3f)inst_Mat3f) -> Mat2d :

    C++ signature :
        cv::Mat_<cv::Vec<double, 2> > asMat2d(cv::Mat_<cv::Vec<float, 3> >)

asMat2d( (Mat4f)inst_Mat4f) -> Mat2d :

    C++ signature :
        cv::Mat_<cv::Vec<double, 2> > asMat2d(cv::Mat_<cv::Vec<float, 4> >)

asMat2d( (Mat1d)inst_Mat1d) -> Mat2d :

    C++ signature :
        cv::Mat_<cv::Vec<double, 2> > asMat2d(cv::Mat_<double>)

asMat2d( (Mat3d)inst_Mat3d) -> Mat2d :

    C++ signature :
        cv::Mat_<cv::Vec<double, 2> > asMat2d(cv::Mat_<cv::Vec<double, 3> >)

asMat2d( (Mat4d)inst_Mat4d) -> Mat2d :

    C++ signature :
        cv::Mat_<cv::Vec<double, 2> > asMat2d(cv::Mat_<cv::Vec<double, 4> >)

asMat2f(...)


asMat2f( (Mat1b)inst_Mat1b) -> Mat2f :

    C++ signature :
        cv::Mat_<cv::Vec<float, 2> > asMat2f(cv::Mat_<unsigned char>)

asMat2f( (Mat2b)inst_Mat2b) -> Mat2f :

    C++ signature :
        cv::Mat_<cv::Vec<float, 2> > asMat2f(cv::Mat_<cv::Vec<unsigned char, 2> >)

asMat2f( (Mat3b)inst_Mat3b) -> Mat2f :

    C++ signature :
        cv::Mat_<cv::Vec<float, 2> > asMat2f(cv::Mat_<cv::Vec<unsigned char, 3> >)

asMat2f( (Mat4b)inst_Mat4b) -> Mat2f :

    C++ signature :
        cv::Mat_<cv::Vec<float, 2> > asMat2f(cv::Mat_<cv::Vec<unsigned char, 4> >)

asMat2f( (Mat1s)inst_Mat1s) -> Mat2f :

    C++ signature :
        cv::Mat_<cv::Vec<float, 2> > asMat2f(cv::Mat_<short>)

asMat2f( (Mat2s)inst_Mat2s) -> Mat2f :

    C++ signature :
        cv::Mat_<cv::Vec<float, 2> > asMat2f(cv::Mat_<cv::Vec<short, 2> >)

asMat2f( (Mat3s)inst_Mat3s) -> Mat2f :

    C++ signature :
        cv::Mat_<cv::Vec<float, 2> > asMat2f(cv::Mat_<cv::Vec<short, 3> >)

asMat2f( (Mat4s)inst_Mat4s) -> Mat2f :

    C++ signature :
        cv::Mat_<cv::Vec<float, 2> > asMat2f(cv::Mat_<cv::Vec<short, 4> >)

asMat2f( (Mat1w)inst_Mat1w) -> Mat2f :

    C++ signature :
        cv::Mat_<cv::Vec<float, 2> > asMat2f(cv::Mat_<unsigned short>)

asMat2f( (Mat2w)inst_Mat2w) -> Mat2f :

    C++ signature :
        cv::Mat_<cv::Vec<float, 2> > asMat2f(cv::Mat_<cv::Vec<unsigned short, 2> >)

asMat2f( (Mat3w)inst_Mat3w) -> Mat2f :

    C++ signature :
        cv::Mat_<cv::Vec<float, 2> > asMat2f(cv::Mat_<cv::Vec<unsigned short, 3> >)

asMat2f( (Mat4w)inst_Mat4w) -> Mat2f :

    C++ signature :
        cv::Mat_<cv::Vec<float, 2> > asMat2f(cv::Mat_<cv::Vec<unsigned short, 4> >)

asMat2f( (Mat1i)inst_Mat1i) -> Mat2f :

    C++ signature :
        cv::Mat_<cv::Vec<float, 2> > asMat2f(cv::Mat_<int>)

asMat2f( (Mat2i)inst_Mat2i) -> Mat2f :

    C++ signature :
        cv::Mat_<cv::Vec<float, 2> > asMat2f(cv::Mat_<cv::Vec<int, 2> >)

asMat2f( (Mat3i)inst_Mat3i) -> Mat2f :

    C++ signature :
        cv::Mat_<cv::Vec<float, 2> > asMat2f(cv::Mat_<cv::Vec<int, 3> >)

asMat2f( (Mat4i)inst_Mat4i) -> Mat2f :

    C++ signature :
        cv::Mat_<cv::Vec<float, 2> > asMat2f(cv::Mat_<cv::Vec<int, 4> >)

asMat2f( (Mat1f)inst_Mat1f) -> Mat2f :

    C++ signature :
        cv::Mat_<cv::Vec<float, 2> > asMat2f(cv::Mat_<float>)

asMat2f( (Mat3f)inst_Mat3f) -> Mat2f :

    C++ signature :
        cv::Mat_<cv::Vec<float, 2> > asMat2f(cv::Mat_<cv::Vec<float, 3> >)

asMat2f( (Mat4f)inst_Mat4f) -> Mat2f :

    C++ signature :
        cv::Mat_<cv::Vec<float, 2> > asMat2f(cv::Mat_<cv::Vec<float, 4> >)

asMat2f( (Mat1d)inst_Mat1d) -> Mat2f :

    C++ signature :
        cv::Mat_<cv::Vec<float, 2> > asMat2f(cv::Mat_<double>)

asMat2f( (Mat2d)inst_Mat2d) -> Mat2f :

    C++ signature :
        cv::Mat_<cv::Vec<float, 2> > asMat2f(cv::Mat_<cv::Vec<double, 2> >)

asMat2f( (Mat3d)inst_Mat3d) -> Mat2f :

    C++ signature :
        cv::Mat_<cv::Vec<float, 2> > asMat2f(cv::Mat_<cv::Vec<double, 3> >)

asMat2f( (Mat4d)inst_Mat4d) -> Mat2f :

    C++ signature :
        cv::Mat_<cv::Vec<float, 2> > asMat2f(cv::Mat_<cv::Vec<double, 4> >)

asMat2i(...)


asMat2i( (Mat1b)inst_Mat1b) -> Mat2i :

    C++ signature :
        cv::Mat_<cv::Vec<int, 2> > asMat2i(cv::Mat_<unsigned char>)

asMat2i( (Mat2b)inst_Mat2b) -> Mat2i :

    C++ signature :
        cv::Mat_<cv::Vec<int, 2> > asMat2i(cv::Mat_<cv::Vec<unsigned char, 2> >)

asMat2i( (Mat3b)inst_Mat3b) -> Mat2i :

    C++ signature :
        cv::Mat_<cv::Vec<int, 2> > asMat2i(cv::Mat_<cv::Vec<unsigned char, 3> >)

asMat2i( (Mat4b)inst_Mat4b) -> Mat2i :

    C++ signature :
        cv::Mat_<cv::Vec<int, 2> > asMat2i(cv::Mat_<cv::Vec<unsigned char, 4> >)

asMat2i( (Mat1s)inst_Mat1s) -> Mat2i :

    C++ signature :
        cv::Mat_<cv::Vec<int, 2> > asMat2i(cv::Mat_<short>)

asMat2i( (Mat2s)inst_Mat2s) -> Mat2i :

    C++ signature :
        cv::Mat_<cv::Vec<int, 2> > asMat2i(cv::Mat_<cv::Vec<short, 2> >)

asMat2i( (Mat3s)inst_Mat3s) -> Mat2i :

    C++ signature :
        cv::Mat_<cv::Vec<int, 2> > asMat2i(cv::Mat_<cv::Vec<short, 3> >)

asMat2i( (Mat4s)inst_Mat4s) -> Mat2i :

    C++ signature :
        cv::Mat_<cv::Vec<int, 2> > asMat2i(cv::Mat_<cv::Vec<short, 4> >)

asMat2i( (Mat1w)inst_Mat1w) -> Mat2i :

    C++ signature :
        cv::Mat_<cv::Vec<int, 2> > asMat2i(cv::Mat_<unsigned short>)

asMat2i( (Mat2w)inst_Mat2w) -> Mat2i :

    C++ signature :
        cv::Mat_<cv::Vec<int, 2> > asMat2i(cv::Mat_<cv::Vec<unsigned short, 2> >)

asMat2i( (Mat3w)inst_Mat3w) -> Mat2i :

    C++ signature :
        cv::Mat_<cv::Vec<int, 2> > asMat2i(cv::Mat_<cv::Vec<unsigned short, 3> >)

asMat2i( (Mat4w)inst_Mat4w) -> Mat2i :

    C++ signature :
        cv::Mat_<cv::Vec<int, 2> > asMat2i(cv::Mat_<cv::Vec<unsigned short, 4> >)

asMat2i( (Mat1i)inst_Mat1i) -> Mat2i :

    C++ signature :
        cv::Mat_<cv::Vec<int, 2> > asMat2i(cv::Mat_<int>)

asMat2i( (Mat3i)inst_Mat3i) -> Mat2i :

    C++ signature :
        cv::Mat_<cv::Vec<int, 2> > asMat2i(cv::Mat_<cv::Vec<int, 3> >)

asMat2i( (Mat4i)inst_Mat4i) -> Mat2i :

    C++ signature :
        cv::Mat_<cv::Vec<int, 2> > asMat2i(cv::Mat_<cv::Vec<int, 4> >)

asMat2i( (Mat1f)inst_Mat1f) -> Mat2i :

    C++ signature :
        cv::Mat_<cv::Vec<int, 2> > asMat2i(cv::Mat_<float>)

asMat2i( (Mat2f)inst_Mat2f) -> Mat2i :

    C++ signature :
        cv::Mat_<cv::Vec<int, 2> > asMat2i(cv::Mat_<cv::Vec<float, 2> >)

asMat2i( (Mat3f)inst_Mat3f) -> Mat2i :

    C++ signature :
        cv::Mat_<cv::Vec<int, 2> > asMat2i(cv::Mat_<cv::Vec<float, 3> >)

asMat2i( (Mat4f)inst_Mat4f) -> Mat2i :

    C++ signature :
        cv::Mat_<cv::Vec<int, 2> > asMat2i(cv::Mat_<cv::Vec<float, 4> >)

asMat2i( (Mat1d)inst_Mat1d) -> Mat2i :

    C++ signature :
        cv::Mat_<cv::Vec<int, 2> > asMat2i(cv::Mat_<double>)

asMat2i( (Mat2d)inst_Mat2d) -> Mat2i :

    C++ signature :
        cv::Mat_<cv::Vec<int, 2> > asMat2i(cv::Mat_<cv::Vec<double, 2> >)

asMat2i( (Mat3d)inst_Mat3d) -> Mat2i :

    C++ signature :
        cv::Mat_<cv::Vec<int, 2> > asMat2i(cv::Mat_<cv::Vec<double, 3> >)

asMat2i( (Mat4d)inst_Mat4d) -> Mat2i :

    C++ signature :
        cv::Mat_<cv::Vec<int, 2> > asMat2i(cv::Mat_<cv::Vec<double, 4> >)

asMat2s(...)


asMat2s( (Mat1b)inst_Mat1b) -> Mat2s :

    C++ signature :
        cv::Mat_<cv::Vec<short, 2> > asMat2s(cv::Mat_<unsigned char>)

asMat2s( (Mat2b)inst_Mat2b) -> Mat2s :

    C++ signature :
        cv::Mat_<cv::Vec<short, 2> > asMat2s(cv::Mat_<cv::Vec<unsigned char, 2> >)

asMat2s( (Mat3b)inst_Mat3b) -> Mat2s :

    C++ signature :
        cv::Mat_<cv::Vec<short, 2> > asMat2s(cv::Mat_<cv::Vec<unsigned char, 3> >)

asMat2s( (Mat4b)inst_Mat4b) -> Mat2s :

    C++ signature :
        cv::Mat_<cv::Vec<short, 2> > asMat2s(cv::Mat_<cv::Vec<unsigned char, 4> >)

asMat2s( (Mat1s)inst_Mat1s) -> Mat2s :

    C++ signature :
        cv::Mat_<cv::Vec<short, 2> > asMat2s(cv::Mat_<short>)

asMat2s( (Mat3s)inst_Mat3s) -> Mat2s :

    C++ signature :
        cv::Mat_<cv::Vec<short, 2> > asMat2s(cv::Mat_<cv::Vec<short, 3> >)

asMat2s( (Mat4s)inst_Mat4s) -> Mat2s :

    C++ signature :
        cv::Mat_<cv::Vec<short, 2> > asMat2s(cv::Mat_<cv::Vec<short, 4> >)

asMat2s( (Mat1w)inst_Mat1w) -> Mat2s :

    C++ signature :
        cv::Mat_<cv::Vec<short, 2> > asMat2s(cv::Mat_<unsigned short>)

asMat2s( (Mat2w)inst_Mat2w) -> Mat2s :

    C++ signature :
        cv::Mat_<cv::Vec<short, 2> > asMat2s(cv::Mat_<cv::Vec<unsigned short, 2> >)

asMat2s( (Mat3w)inst_Mat3w) -> Mat2s :

    C++ signature :
        cv::Mat_<cv::Vec<short, 2> > asMat2s(cv::Mat_<cv::Vec<unsigned short, 3> >)

asMat2s( (Mat4w)inst_Mat4w) -> Mat2s :

    C++ signature :
        cv::Mat_<cv::Vec<short, 2> > asMat2s(cv::Mat_<cv::Vec<unsigned short, 4> >)

asMat2s( (Mat1i)inst_Mat1i) -> Mat2s :

    C++ signature :
        cv::Mat_<cv::Vec<short, 2> > asMat2s(cv::Mat_<int>)

asMat2s( (Mat2i)inst_Mat2i) -> Mat2s :

    C++ signature :
        cv::Mat_<cv::Vec<short, 2> > asMat2s(cv::Mat_<cv::Vec<int, 2> >)

asMat2s( (Mat3i)inst_Mat3i) -> Mat2s :

    C++ signature :
        cv::Mat_<cv::Vec<short, 2> > asMat2s(cv::Mat_<cv::Vec<int, 3> >)

asMat2s( (Mat4i)inst_Mat4i) -> Mat2s :

    C++ signature :
        cv::Mat_<cv::Vec<short, 2> > asMat2s(cv::Mat_<cv::Vec<int, 4> >)

asMat2s( (Mat1f)inst_Mat1f) -> Mat2s :

    C++ signature :
        cv::Mat_<cv::Vec<short, 2> > asMat2s(cv::Mat_<float>)

asMat2s( (Mat2f)inst_Mat2f) -> Mat2s :

    C++ signature :
        cv::Mat_<cv::Vec<short, 2> > asMat2s(cv::Mat_<cv::Vec<float, 2> >)

asMat2s( (Mat3f)inst_Mat3f) -> Mat2s :

    C++ signature :
        cv::Mat_<cv::Vec<short, 2> > asMat2s(cv::Mat_<cv::Vec<float, 3> >)

asMat2s( (Mat4f)inst_Mat4f) -> Mat2s :

    C++ signature :
        cv::Mat_<cv::Vec<short, 2> > asMat2s(cv::Mat_<cv::Vec<float, 4> >)

asMat2s( (Mat1d)inst_Mat1d) -> Mat2s :

    C++ signature :
        cv::Mat_<cv::Vec<short, 2> > asMat2s(cv::Mat_<double>)

asMat2s( (Mat2d)inst_Mat2d) -> Mat2s :

    C++ signature :
        cv::Mat_<cv::Vec<short, 2> > asMat2s(cv::Mat_<cv::Vec<double, 2> >)

asMat2s( (Mat3d)inst_Mat3d) -> Mat2s :

    C++ signature :
        cv::Mat_<cv::Vec<short, 2> > asMat2s(cv::Mat_<cv::Vec<double, 3> >)

asMat2s( (Mat4d)inst_Mat4d) -> Mat2s :

    C++ signature :
        cv::Mat_<cv::Vec<short, 2> > asMat2s(cv::Mat_<cv::Vec<double, 4> >)

asMat2w(...)


asMat2w( (Mat1b)inst_Mat1b) -> Mat2w :

    C++ signature :
        cv::Mat_<cv::Vec<unsigned short, 2> > asMat2w(cv::Mat_<unsigned char>)

asMat2w( (Mat2b)inst_Mat2b) -> Mat2w :

    C++ signature :
        cv::Mat_<cv::Vec<unsigned short, 2> > asMat2w(cv::Mat_<cv::Vec<unsigned char, 2> >)

asMat2w( (Mat3b)inst_Mat3b) -> Mat2w :

    C++ signature :
        cv::Mat_<cv::Vec<unsigned short, 2> > asMat2w(cv::Mat_<cv::Vec<unsigned char, 3> >)

asMat2w( (Mat4b)inst_Mat4b) -> Mat2w :

    C++ signature :
        cv::Mat_<cv::Vec<unsigned short, 2> > asMat2w(cv::Mat_<cv::Vec<unsigned char, 4> >)

asMat2w( (Mat1s)inst_Mat1s) -> Mat2w :

    C++ signature :
        cv::Mat_<cv::Vec<unsigned short, 2> > asMat2w(cv::Mat_<short>)

asMat2w( (Mat2s)inst_Mat2s) -> Mat2w :

    C++ signature :
        cv::Mat_<cv::Vec<unsigned short, 2> > asMat2w(cv::Mat_<cv::Vec<short, 2> >)

asMat2w( (Mat3s)inst_Mat3s) -> Mat2w :

    C++ signature :
        cv::Mat_<cv::Vec<unsigned short, 2> > asMat2w(cv::Mat_<cv::Vec<short, 3> >)

asMat2w( (Mat4s)inst_Mat4s) -> Mat2w :

    C++ signature :
        cv::Mat_<cv::Vec<unsigned short, 2> > asMat2w(cv::Mat_<cv::Vec<short, 4> >)

asMat2w( (Mat1w)inst_Mat1w) -> Mat2w :

    C++ signature :
        cv::Mat_<cv::Vec<unsigned short, 2> > asMat2w(cv::Mat_<unsigned short>)

asMat2w( (Mat3w)inst_Mat3w) -> Mat2w :

    C++ signature :
        cv::Mat_<cv::Vec<unsigned short, 2> > asMat2w(cv::Mat_<cv::Vec<unsigned short, 3> >)

asMat2w( (Mat4w)inst_Mat4w) -> Mat2w :

    C++ signature :
        cv::Mat_<cv::Vec<unsigned short, 2> > asMat2w(cv::Mat_<cv::Vec<unsigned short, 4> >)

asMat2w( (Mat1i)inst_Mat1i) -> Mat2w :

    C++ signature :
        cv::Mat_<cv::Vec<unsigned short, 2> > asMat2w(cv::Mat_<int>)

asMat2w( (Mat2i)inst_Mat2i) -> Mat2w :

    C++ signature :
        cv::Mat_<cv::Vec<unsigned short, 2> > asMat2w(cv::Mat_<cv::Vec<int, 2> >)

asMat2w( (Mat3i)inst_Mat3i) -> Mat2w :

    C++ signature :
        cv::Mat_<cv::Vec<unsigned short, 2> > asMat2w(cv::Mat_<cv::Vec<int, 3> >)

asMat2w( (Mat4i)inst_Mat4i) -> Mat2w :

    C++ signature :
        cv::Mat_<cv::Vec<unsigned short, 2> > asMat2w(cv::Mat_<cv::Vec<int, 4> >)

asMat2w( (Mat1f)inst_Mat1f) -> Mat2w :

    C++ signature :
        cv::Mat_<cv::Vec<unsigned short, 2> > asMat2w(cv::Mat_<float>)

asMat2w( (Mat2f)inst_Mat2f) -> Mat2w :

    C++ signature :
        cv::Mat_<cv::Vec<unsigned short, 2> > asMat2w(cv::Mat_<cv::Vec<float, 2> >)

asMat2w( (Mat3f)inst_Mat3f) -> Mat2w :

    C++ signature :
        cv::Mat_<cv::Vec<unsigned short, 2> > asMat2w(cv::Mat_<cv::Vec<float, 3> >)

asMat2w( (Mat4f)inst_Mat4f) -> Mat2w :

    C++ signature :
        cv::Mat_<cv::Vec<unsigned short, 2> > asMat2w(cv::Mat_<cv::Vec<float, 4> >)

asMat2w( (Mat1d)inst_Mat1d) -> Mat2w :

    C++ signature :
        cv::Mat_<cv::Vec<unsigned short, 2> > asMat2w(cv::Mat_<double>)

asMat2w( (Mat2d)inst_Mat2d) -> Mat2w :

    C++ signature :
        cv::Mat_<cv::Vec<unsigned short, 2> > asMat2w(cv::Mat_<cv::Vec<double, 2> >)

asMat2w( (Mat3d)inst_Mat3d) -> Mat2w :

    C++ signature :
        cv::Mat_<cv::Vec<unsigned short, 2> > asMat2w(cv::Mat_<cv::Vec<double, 3> >)

asMat2w( (Mat4d)inst_Mat4d) -> Mat2w :

    C++ signature :
        cv::Mat_<cv::Vec<unsigned short, 2> > asMat2w(cv::Mat_<cv::Vec<double, 4> >)

asMat3b(...)


asMat3b( (Mat1b)inst_Mat1b) -> Mat3b :

    C++ signature :
        cv::Mat_<cv::Vec<unsigned char, 3> > asMat3b(cv::Mat_<unsigned char>)

asMat3b( (Mat2b)inst_Mat2b) -> Mat3b :

    C++ signature :
        cv::Mat_<cv::Vec<unsigned char, 3> > asMat3b(cv::Mat_<cv::Vec<unsigned char, 2> >)

asMat3b( (Mat4b)inst_Mat4b) -> Mat3b :

    C++ signature :
        cv::Mat_<cv::Vec<unsigned char, 3> > asMat3b(cv::Mat_<cv::Vec<unsigned char, 4> >)

asMat3b( (Mat1s)inst_Mat1s) -> Mat3b :

    C++ signature :
        cv::Mat_<cv::Vec<unsigned char, 3> > asMat3b(cv::Mat_<short>)

asMat3b( (Mat2s)inst_Mat2s) -> Mat3b :

    C++ signature :
        cv::Mat_<cv::Vec<unsigned char, 3> > asMat3b(cv::Mat_<cv::Vec<short, 2> >)

asMat3b( (Mat3s)inst_Mat3s) -> Mat3b :

    C++ signature :
        cv::Mat_<cv::Vec<unsigned char, 3> > asMat3b(cv::Mat_<cv::Vec<short, 3> >)

asMat3b( (Mat4s)inst_Mat4s) -> Mat3b :

    C++ signature :
        cv::Mat_<cv::Vec<unsigned char, 3> > asMat3b(cv::Mat_<cv::Vec<short, 4> >)

asMat3b( (Mat1w)inst_Mat1w) -> Mat3b :

    C++ signature :
        cv::Mat_<cv::Vec<unsigned char, 3> > asMat3b(cv::Mat_<unsigned short>)

asMat3b( (Mat2w)inst_Mat2w) -> Mat3b :

    C++ signature :
        cv::Mat_<cv::Vec<unsigned char, 3> > asMat3b(cv::Mat_<cv::Vec<unsigned short, 2> >)

asMat3b( (Mat3w)inst_Mat3w) -> Mat3b :

    C++ signature :
        cv::Mat_<cv::Vec<unsigned char, 3> > asMat3b(cv::Mat_<cv::Vec<unsigned short, 3> >)

asMat3b( (Mat4w)inst_Mat4w) -> Mat3b :

    C++ signature :
        cv::Mat_<cv::Vec<unsigned char, 3> > asMat3b(cv::Mat_<cv::Vec<unsigned short, 4> >)

asMat3b( (Mat1i)inst_Mat1i) -> Mat3b :

    C++ signature :
        cv::Mat_<cv::Vec<unsigned char, 3> > asMat3b(cv::Mat_<int>)

asMat3b( (Mat2i)inst_Mat2i) -> Mat3b :

    C++ signature :
        cv::Mat_<cv::Vec<unsigned char, 3> > asMat3b(cv::Mat_<cv::Vec<int, 2> >)

asMat3b( (Mat3i)inst_Mat3i) -> Mat3b :

    C++ signature :
        cv::Mat_<cv::Vec<unsigned char, 3> > asMat3b(cv::Mat_<cv::Vec<int, 3> >)

asMat3b( (Mat4i)inst_Mat4i) -> Mat3b :

    C++ signature :
        cv::Mat_<cv::Vec<unsigned char, 3> > asMat3b(cv::Mat_<cv::Vec<int, 4> >)

asMat3b( (Mat1f)inst_Mat1f) -> Mat3b :

    C++ signature :
        cv::Mat_<cv::Vec<unsigned char, 3> > asMat3b(cv::Mat_<float>)

asMat3b( (Mat2f)inst_Mat2f) -> Mat3b :

    C++ signature :
        cv::Mat_<cv::Vec<unsigned char, 3> > asMat3b(cv::Mat_<cv::Vec<float, 2> >)

asMat3b( (Mat3f)inst_Mat3f) -> Mat3b :

    C++ signature :
        cv::Mat_<cv::Vec<unsigned char, 3> > asMat3b(cv::Mat_<cv::Vec<float, 3> >)

asMat3b( (Mat4f)inst_Mat4f) -> Mat3b :

    C++ signature :
        cv::Mat_<cv::Vec<unsigned char, 3> > asMat3b(cv::Mat_<cv::Vec<float, 4> >)

asMat3b( (Mat1d)inst_Mat1d) -> Mat3b :

    C++ signature :
        cv::Mat_<cv::Vec<unsigned char, 3> > asMat3b(cv::Mat_<double>)

asMat3b( (Mat2d)inst_Mat2d) -> Mat3b :

    C++ signature :
        cv::Mat_<cv::Vec<unsigned char, 3> > asMat3b(cv::Mat_<cv::Vec<double, 2> >)

asMat3b( (Mat3d)inst_Mat3d) -> Mat3b :

    C++ signature :
        cv::Mat_<cv::Vec<unsigned char, 3> > asMat3b(cv::Mat_<cv::Vec<double, 3> >)

asMat3b( (Mat4d)inst_Mat4d) -> Mat3b :

    C++ signature :
        cv::Mat_<cv::Vec<unsigned char, 3> > asMat3b(cv::Mat_<cv::Vec<double, 4> >)

asMat3d(...)


asMat3d( (Mat1b)inst_Mat1b) -> Mat3d :

    C++ signature :
        cv::Mat_<cv::Vec<double, 3> > asMat3d(cv::Mat_<unsigned char>)

asMat3d( (Mat2b)inst_Mat2b) -> Mat3d :

    C++ signature :
        cv::Mat_<cv::Vec<double, 3> > asMat3d(cv::Mat_<cv::Vec<unsigned char, 2> >)

asMat3d( (Mat3b)inst_Mat3b) -> Mat3d :

    C++ signature :
        cv::Mat_<cv::Vec<double, 3> > asMat3d(cv::Mat_<cv::Vec<unsigned char, 3> >)

asMat3d( (Mat4b)inst_Mat4b) -> Mat3d :

    C++ signature :
        cv::Mat_<cv::Vec<double, 3> > asMat3d(cv::Mat_<cv::Vec<unsigned char, 4> >)

asMat3d( (Mat1s)inst_Mat1s) -> Mat3d :

    C++ signature :
        cv::Mat_<cv::Vec<double, 3> > asMat3d(cv::Mat_<short>)

asMat3d( (Mat2s)inst_Mat2s) -> Mat3d :

    C++ signature :
        cv::Mat_<cv::Vec<double, 3> > asMat3d(cv::Mat_<cv::Vec<short, 2> >)

asMat3d( (Mat3s)inst_Mat3s) -> Mat3d :

    C++ signature :
        cv::Mat_<cv::Vec<double, 3> > asMat3d(cv::Mat_<cv::Vec<short, 3> >)

asMat3d( (Mat4s)inst_Mat4s) -> Mat3d :

    C++ signature :
        cv::Mat_<cv::Vec<double, 3> > asMat3d(cv::Mat_<cv::Vec<short, 4> >)

asMat3d( (Mat1w)inst_Mat1w) -> Mat3d :

    C++ signature :
        cv::Mat_<cv::Vec<double, 3> > asMat3d(cv::Mat_<unsigned short>)

asMat3d( (Mat2w)inst_Mat2w) -> Mat3d :

    C++ signature :
        cv::Mat_<cv::Vec<double, 3> > asMat3d(cv::Mat_<cv::Vec<unsigned short, 2> >)

asMat3d( (Mat3w)inst_Mat3w) -> Mat3d :

    C++ signature :
        cv::Mat_<cv::Vec<double, 3> > asMat3d(cv::Mat_<cv::Vec<unsigned short, 3> >)

asMat3d( (Mat4w)inst_Mat4w) -> Mat3d :

    C++ signature :
        cv::Mat_<cv::Vec<double, 3> > asMat3d(cv::Mat_<cv::Vec<unsigned short, 4> >)

asMat3d( (Mat1i)inst_Mat1i) -> Mat3d :

    C++ signature :
        cv::Mat_<cv::Vec<double, 3> > asMat3d(cv::Mat_<int>)

asMat3d( (Mat2i)inst_Mat2i) -> Mat3d :

    C++ signature :
        cv::Mat_<cv::Vec<double, 3> > asMat3d(cv::Mat_<cv::Vec<int, 2> >)

asMat3d( (Mat3i)inst_Mat3i) -> Mat3d :

    C++ signature :
        cv::Mat_<cv::Vec<double, 3> > asMat3d(cv::Mat_<cv::Vec<int, 3> >)

asMat3d( (Mat4i)inst_Mat4i) -> Mat3d :

    C++ signature :
        cv::Mat_<cv::Vec<double, 3> > asMat3d(cv::Mat_<cv::Vec<int, 4> >)

asMat3d( (Mat1f)inst_Mat1f) -> Mat3d :

    C++ signature :
        cv::Mat_<cv::Vec<double, 3> > asMat3d(cv::Mat_<float>)

asMat3d( (Mat2f)inst_Mat2f) -> Mat3d :

    C++ signature :
        cv::Mat_<cv::Vec<double, 3> > asMat3d(cv::Mat_<cv::Vec<float, 2> >)

asMat3d( (Mat3f)inst_Mat3f) -> Mat3d :

    C++ signature :
        cv::Mat_<cv::Vec<double, 3> > asMat3d(cv::Mat_<cv::Vec<float, 3> >)

asMat3d( (Mat4f)inst_Mat4f) -> Mat3d :

    C++ signature :
        cv::Mat_<cv::Vec<double, 3> > asMat3d(cv::Mat_<cv::Vec<float, 4> >)

asMat3d( (Mat1d)inst_Mat1d) -> Mat3d :

    C++ signature :
        cv::Mat_<cv::Vec<double, 3> > asMat3d(cv::Mat_<double>)

asMat3d( (Mat2d)inst_Mat2d) -> Mat3d :

    C++ signature :
        cv::Mat_<cv::Vec<double, 3> > asMat3d(cv::Mat_<cv::Vec<double, 2> >)

asMat3d( (Mat4d)inst_Mat4d) -> Mat3d :

    C++ signature :
        cv::Mat_<cv::Vec<double, 3> > asMat3d(cv::Mat_<cv::Vec<double, 4> >)

asMat3f(...)


asMat3f( (Mat1b)inst_Mat1b) -> Mat3f :

    C++ signature :
        cv::Mat_<cv::Vec<float, 3> > asMat3f(cv::Mat_<unsigned char>)

asMat3f( (Mat2b)inst_Mat2b) -> Mat3f :

    C++ signature :
        cv::Mat_<cv::Vec<float, 3> > asMat3f(cv::Mat_<cv::Vec<unsigned char, 2> >)

asMat3f( (Mat3b)inst_Mat3b) -> Mat3f :

    C++ signature :
        cv::Mat_<cv::Vec<float, 3> > asMat3f(cv::Mat_<cv::Vec<unsigned char, 3> >)

asMat3f( (Mat4b)inst_Mat4b) -> Mat3f :

    C++ signature :
        cv::Mat_<cv::Vec<float, 3> > asMat3f(cv::Mat_<cv::Vec<unsigned char, 4> >)

asMat3f( (Mat1s)inst_Mat1s) -> Mat3f :

    C++ signature :
        cv::Mat_<cv::Vec<float, 3> > asMat3f(cv::Mat_<short>)

asMat3f( (Mat2s)inst_Mat2s) -> Mat3f :

    C++ signature :
        cv::Mat_<cv::Vec<float, 3> > asMat3f(cv::Mat_<cv::Vec<short, 2> >)

asMat3f( (Mat3s)inst_Mat3s) -> Mat3f :

    C++ signature :
        cv::Mat_<cv::Vec<float, 3> > asMat3f(cv::Mat_<cv::Vec<short, 3> >)

asMat3f( (Mat4s)inst_Mat4s) -> Mat3f :

    C++ signature :
        cv::Mat_<cv::Vec<float, 3> > asMat3f(cv::Mat_<cv::Vec<short, 4> >)

asMat3f( (Mat1w)inst_Mat1w) -> Mat3f :

    C++ signature :
        cv::Mat_<cv::Vec<float, 3> > asMat3f(cv::Mat_<unsigned short>)

asMat3f( (Mat2w)inst_Mat2w) -> Mat3f :

    C++ signature :
        cv::Mat_<cv::Vec<float, 3> > asMat3f(cv::Mat_<cv::Vec<unsigned short, 2> >)

asMat3f( (Mat3w)inst_Mat3w) -> Mat3f :

    C++ signature :
        cv::Mat_<cv::Vec<float, 3> > asMat3f(cv::Mat_<cv::Vec<unsigned short, 3> >)

asMat3f( (Mat4w)inst_Mat4w) -> Mat3f :

    C++ signature :
        cv::Mat_<cv::Vec<float, 3> > asMat3f(cv::Mat_<cv::Vec<unsigned short, 4> >)

asMat3f( (Mat1i)inst_Mat1i) -> Mat3f :

    C++ signature :
        cv::Mat_<cv::Vec<float, 3> > asMat3f(cv::Mat_<int>)

asMat3f( (Mat2i)inst_Mat2i) -> Mat3f :

    C++ signature :
        cv::Mat_<cv::Vec<float, 3> > asMat3f(cv::Mat_<cv::Vec<int, 2> >)

asMat3f( (Mat3i)inst_Mat3i) -> Mat3f :

    C++ signature :
        cv::Mat_<cv::Vec<float, 3> > asMat3f(cv::Mat_<cv::Vec<int, 3> >)

asMat3f( (Mat4i)inst_Mat4i) -> Mat3f :

    C++ signature :
        cv::Mat_<cv::Vec<float, 3> > asMat3f(cv::Mat_<cv::Vec<int, 4> >)

asMat3f( (Mat1f)inst_Mat1f) -> Mat3f :

    C++ signature :
        cv::Mat_<cv::Vec<float, 3> > asMat3f(cv::Mat_<float>)

asMat3f( (Mat2f)inst_Mat2f) -> Mat3f :

    C++ signature :
        cv::Mat_<cv::Vec<float, 3> > asMat3f(cv::Mat_<cv::Vec<float, 2> >)

asMat3f( (Mat4f)inst_Mat4f) -> Mat3f :

    C++ signature :
        cv::Mat_<cv::Vec<float, 3> > asMat3f(cv::Mat_<cv::Vec<float, 4> >)

asMat3f( (Mat1d)inst_Mat1d) -> Mat3f :

    C++ signature :
        cv::Mat_<cv::Vec<float, 3> > asMat3f(cv::Mat_<double>)

asMat3f( (Mat2d)inst_Mat2d) -> Mat3f :

    C++ signature :
        cv::Mat_<cv::Vec<float, 3> > asMat3f(cv::Mat_<cv::Vec<double, 2> >)

asMat3f( (Mat3d)inst_Mat3d) -> Mat3f :

    C++ signature :
        cv::Mat_<cv::Vec<float, 3> > asMat3f(cv::Mat_<cv::Vec<double, 3> >)

asMat3f( (Mat4d)inst_Mat4d) -> Mat3f :

    C++ signature :
        cv::Mat_<cv::Vec<float, 3> > asMat3f(cv::Mat_<cv::Vec<double, 4> >)

asMat3i(...)


asMat3i( (Mat1b)inst_Mat1b) -> Mat3i :

    C++ signature :
        cv::Mat_<cv::Vec<int, 3> > asMat3i(cv::Mat_<unsigned char>)

asMat3i( (Mat2b)inst_Mat2b) -> Mat3i :

    C++ signature :
        cv::Mat_<cv::Vec<int, 3> > asMat3i(cv::Mat_<cv::Vec<unsigned char, 2> >)

asMat3i( (Mat3b)inst_Mat3b) -> Mat3i :

    C++ signature :
        cv::Mat_<cv::Vec<int, 3> > asMat3i(cv::Mat_<cv::Vec<unsigned char, 3> >)

asMat3i( (Mat4b)inst_Mat4b) -> Mat3i :

    C++ signature :
        cv::Mat_<cv::Vec<int, 3> > asMat3i(cv::Mat_<cv::Vec<unsigned char, 4> >)

asMat3i( (Mat1s)inst_Mat1s) -> Mat3i :

    C++ signature :
        cv::Mat_<cv::Vec<int, 3> > asMat3i(cv::Mat_<short>)

asMat3i( (Mat2s)inst_Mat2s) -> Mat3i :

    C++ signature :
        cv::Mat_<cv::Vec<int, 3> > asMat3i(cv::Mat_<cv::Vec<short, 2> >)

asMat3i( (Mat3s)inst_Mat3s) -> Mat3i :

    C++ signature :
        cv::Mat_<cv::Vec<int, 3> > asMat3i(cv::Mat_<cv::Vec<short, 3> >)

asMat3i( (Mat4s)inst_Mat4s) -> Mat3i :

    C++ signature :
        cv::Mat_<cv::Vec<int, 3> > asMat3i(cv::Mat_<cv::Vec<short, 4> >)

asMat3i( (Mat1w)inst_Mat1w) -> Mat3i :

    C++ signature :
        cv::Mat_<cv::Vec<int, 3> > asMat3i(cv::Mat_<unsigned short>)

asMat3i( (Mat2w)inst_Mat2w) -> Mat3i :

    C++ signature :
        cv::Mat_<cv::Vec<int, 3> > asMat3i(cv::Mat_<cv::Vec<unsigned short, 2> >)

asMat3i( (Mat3w)inst_Mat3w) -> Mat3i :

    C++ signature :
        cv::Mat_<cv::Vec<int, 3> > asMat3i(cv::Mat_<cv::Vec<unsigned short, 3> >)

asMat3i( (Mat4w)inst_Mat4w) -> Mat3i :

    C++ signature :
        cv::Mat_<cv::Vec<int, 3> > asMat3i(cv::Mat_<cv::Vec<unsigned short, 4> >)

asMat3i( (Mat1i)inst_Mat1i) -> Mat3i :

    C++ signature :
        cv::Mat_<cv::Vec<int, 3> > asMat3i(cv::Mat_<int>)

asMat3i( (Mat2i)inst_Mat2i) -> Mat3i :

    C++ signature :
        cv::Mat_<cv::Vec<int, 3> > asMat3i(cv::Mat_<cv::Vec<int, 2> >)

asMat3i( (Mat4i)inst_Mat4i) -> Mat3i :

    C++ signature :
        cv::Mat_<cv::Vec<int, 3> > asMat3i(cv::Mat_<cv::Vec<int, 4> >)

asMat3i( (Mat1f)inst_Mat1f) -> Mat3i :

    C++ signature :
        cv::Mat_<cv::Vec<int, 3> > asMat3i(cv::Mat_<float>)

asMat3i( (Mat2f)inst_Mat2f) -> Mat3i :

    C++ signature :
        cv::Mat_<cv::Vec<int, 3> > asMat3i(cv::Mat_<cv::Vec<float, 2> >)

asMat3i( (Mat3f)inst_Mat3f) -> Mat3i :

    C++ signature :
        cv::Mat_<cv::Vec<int, 3> > asMat3i(cv::Mat_<cv::Vec<float, 3> >)

asMat3i( (Mat4f)inst_Mat4f) -> Mat3i :

    C++ signature :
        cv::Mat_<cv::Vec<int, 3> > asMat3i(cv::Mat_<cv::Vec<float, 4> >)

asMat3i( (Mat1d)inst_Mat1d) -> Mat3i :

    C++ signature :
        cv::Mat_<cv::Vec<int, 3> > asMat3i(cv::Mat_<double>)

asMat3i( (Mat2d)inst_Mat2d) -> Mat3i :

    C++ signature :
        cv::Mat_<cv::Vec<int, 3> > asMat3i(cv::Mat_<cv::Vec<double, 2> >)

asMat3i( (Mat3d)inst_Mat3d) -> Mat3i :

    C++ signature :
        cv::Mat_<cv::Vec<int, 3> > asMat3i(cv::Mat_<cv::Vec<double, 3> >)

asMat3i( (Mat4d)inst_Mat4d) -> Mat3i :

    C++ signature :
        cv::Mat_<cv::Vec<int, 3> > asMat3i(cv::Mat_<cv::Vec<double, 4> >)

asMat3s(...)


asMat3s( (Mat1b)inst_Mat1b) -> Mat3s :

    C++ signature :
        cv::Mat_<cv::Vec<short, 3> > asMat3s(cv::Mat_<unsigned char>)

asMat3s( (Mat2b)inst_Mat2b) -> Mat3s :

    C++ signature :
        cv::Mat_<cv::Vec<short, 3> > asMat3s(cv::Mat_<cv::Vec<unsigned char, 2> >)

asMat3s( (Mat3b)inst_Mat3b) -> Mat3s :

    C++ signature :
        cv::Mat_<cv::Vec<short, 3> > asMat3s(cv::Mat_<cv::Vec<unsigned char, 3> >)

asMat3s( (Mat4b)inst_Mat4b) -> Mat3s :

    C++ signature :
        cv::Mat_<cv::Vec<short, 3> > asMat3s(cv::Mat_<cv::Vec<unsigned char, 4> >)

asMat3s( (Mat1s)inst_Mat1s) -> Mat3s :

    C++ signature :
        cv::Mat_<cv::Vec<short, 3> > asMat3s(cv::Mat_<short>)

asMat3s( (Mat2s)inst_Mat2s) -> Mat3s :

    C++ signature :
        cv::Mat_<cv::Vec<short, 3> > asMat3s(cv::Mat_<cv::Vec<short, 2> >)

asMat3s( (Mat4s)inst_Mat4s) -> Mat3s :

    C++ signature :
        cv::Mat_<cv::Vec<short, 3> > asMat3s(cv::Mat_<cv::Vec<short, 4> >)

asMat3s( (Mat1w)inst_Mat1w) -> Mat3s :

    C++ signature :
        cv::Mat_<cv::Vec<short, 3> > asMat3s(cv::Mat_<unsigned short>)

asMat3s( (Mat2w)inst_Mat2w) -> Mat3s :

    C++ signature :
        cv::Mat_<cv::Vec<short, 3> > asMat3s(cv::Mat_<cv::Vec<unsigned short, 2> >)

asMat3s( (Mat3w)inst_Mat3w) -> Mat3s :

    C++ signature :
        cv::Mat_<cv::Vec<short, 3> > asMat3s(cv::Mat_<cv::Vec<unsigned short, 3> >)

asMat3s( (Mat4w)inst_Mat4w) -> Mat3s :

    C++ signature :
        cv::Mat_<cv::Vec<short, 3> > asMat3s(cv::Mat_<cv::Vec<unsigned short, 4> >)

asMat3s( (Mat1i)inst_Mat1i) -> Mat3s :

    C++ signature :
        cv::Mat_<cv::Vec<short, 3> > asMat3s(cv::Mat_<int>)

asMat3s( (Mat2i)inst_Mat2i) -> Mat3s :

    C++ signature :
        cv::Mat_<cv::Vec<short, 3> > asMat3s(cv::Mat_<cv::Vec<int, 2> >)

asMat3s( (Mat3i)inst_Mat3i) -> Mat3s :

    C++ signature :
        cv::Mat_<cv::Vec<short, 3> > asMat3s(cv::Mat_<cv::Vec<int, 3> >)

asMat3s( (Mat4i)inst_Mat4i) -> Mat3s :

    C++ signature :
        cv::Mat_<cv::Vec<short, 3> > asMat3s(cv::Mat_<cv::Vec<int, 4> >)

asMat3s( (Mat1f)inst_Mat1f) -> Mat3s :

    C++ signature :
        cv::Mat_<cv::Vec<short, 3> > asMat3s(cv::Mat_<float>)

asMat3s( (Mat2f)inst_Mat2f) -> Mat3s :

    C++ signature :
        cv::Mat_<cv::Vec<short, 3> > asMat3s(cv::Mat_<cv::Vec<float, 2> >)

asMat3s( (Mat3f)inst_Mat3f) -> Mat3s :

    C++ signature :
        cv::Mat_<cv::Vec<short, 3> > asMat3s(cv::Mat_<cv::Vec<float, 3> >)

asMat3s( (Mat4f)inst_Mat4f) -> Mat3s :

    C++ signature :
        cv::Mat_<cv::Vec<short, 3> > asMat3s(cv::Mat_<cv::Vec<float, 4> >)

asMat3s( (Mat1d)inst_Mat1d) -> Mat3s :

    C++ signature :
        cv::Mat_<cv::Vec<short, 3> > asMat3s(cv::Mat_<double>)

asMat3s( (Mat2d)inst_Mat2d) -> Mat3s :

    C++ signature :
        cv::Mat_<cv::Vec<short, 3> > asMat3s(cv::Mat_<cv::Vec<double, 2> >)

asMat3s( (Mat3d)inst_Mat3d) -> Mat3s :

    C++ signature :
        cv::Mat_<cv::Vec<short, 3> > asMat3s(cv::Mat_<cv::Vec<double, 3> >)

asMat3s( (Mat4d)inst_Mat4d) -> Mat3s :

    C++ signature :
        cv::Mat_<cv::Vec<short, 3> > asMat3s(cv::Mat_<cv::Vec<double, 4> >)

asMat3w(...)


asMat3w( (Mat1b)inst_Mat1b) -> Mat3w :

    C++ signature :
        cv::Mat_<cv::Vec<unsigned short, 3> > asMat3w(cv::Mat_<unsigned char>)

asMat3w( (Mat2b)inst_Mat2b) -> Mat3w :

    C++ signature :
        cv::Mat_<cv::Vec<unsigned short, 3> > asMat3w(cv::Mat_<cv::Vec<unsigned char, 2> >)

asMat3w( (Mat3b)inst_Mat3b) -> Mat3w :

    C++ signature :
        cv::Mat_<cv::Vec<unsigned short, 3> > asMat3w(cv::Mat_<cv::Vec<unsigned char, 3> >)

asMat3w( (Mat4b)inst_Mat4b) -> Mat3w :

    C++ signature :
        cv::Mat_<cv::Vec<unsigned short, 3> > asMat3w(cv::Mat_<cv::Vec<unsigned char, 4> >)

asMat3w( (Mat1s)inst_Mat1s) -> Mat3w :

    C++ signature :
        cv::Mat_<cv::Vec<unsigned short, 3> > asMat3w(cv::Mat_<short>)

asMat3w( (Mat2s)inst_Mat2s) -> Mat3w :

    C++ signature :
        cv::Mat_<cv::Vec<unsigned short, 3> > asMat3w(cv::Mat_<cv::Vec<short, 2> >)

asMat3w( (Mat3s)inst_Mat3s) -> Mat3w :

    C++ signature :
        cv::Mat_<cv::Vec<unsigned short, 3> > asMat3w(cv::Mat_<cv::Vec<short, 3> >)

asMat3w( (Mat4s)inst_Mat4s) -> Mat3w :

    C++ signature :
        cv::Mat_<cv::Vec<unsigned short, 3> > asMat3w(cv::Mat_<cv::Vec<short, 4> >)

asMat3w( (Mat1w)inst_Mat1w) -> Mat3w :

    C++ signature :
        cv::Mat_<cv::Vec<unsigned short, 3> > asMat3w(cv::Mat_<unsigned short>)

asMat3w( (Mat2w)inst_Mat2w) -> Mat3w :

    C++ signature :
        cv::Mat_<cv::Vec<unsigned short, 3> > asMat3w(cv::Mat_<cv::Vec<unsigned short, 2> >)

asMat3w( (Mat4w)inst_Mat4w) -> Mat3w :

    C++ signature :
        cv::Mat_<cv::Vec<unsigned short, 3> > asMat3w(cv::Mat_<cv::Vec<unsigned short, 4> >)

asMat3w( (Mat1i)inst_Mat1i) -> Mat3w :

    C++ signature :
        cv::Mat_<cv::Vec<unsigned short, 3> > asMat3w(cv::Mat_<int>)

asMat3w( (Mat2i)inst_Mat2i) -> Mat3w :

    C++ signature :
        cv::Mat_<cv::Vec<unsigned short, 3> > asMat3w(cv::Mat_<cv::Vec<int, 2> >)

asMat3w( (Mat3i)inst_Mat3i) -> Mat3w :

    C++ signature :
        cv::Mat_<cv::Vec<unsigned short, 3> > asMat3w(cv::Mat_<cv::Vec<int, 3> >)

asMat3w( (Mat4i)inst_Mat4i) -> Mat3w :

    C++ signature :
        cv::Mat_<cv::Vec<unsigned short, 3> > asMat3w(cv::Mat_<cv::Vec<int, 4> >)

asMat3w( (Mat1f)inst_Mat1f) -> Mat3w :

    C++ signature :
        cv::Mat_<cv::Vec<unsigned short, 3> > asMat3w(cv::Mat_<float>)

asMat3w( (Mat2f)inst_Mat2f) -> Mat3w :

    C++ signature :
        cv::Mat_<cv::Vec<unsigned short, 3> > asMat3w(cv::Mat_<cv::Vec<float, 2> >)

asMat3w( (Mat3f)inst_Mat3f) -> Mat3w :

    C++ signature :
        cv::Mat_<cv::Vec<unsigned short, 3> > asMat3w(cv::Mat_<cv::Vec<float, 3> >)

asMat3w( (Mat4f)inst_Mat4f) -> Mat3w :

    C++ signature :
        cv::Mat_<cv::Vec<unsigned short, 3> > asMat3w(cv::Mat_<cv::Vec<float, 4> >)

asMat3w( (Mat1d)inst_Mat1d) -> Mat3w :

    C++ signature :
        cv::Mat_<cv::Vec<unsigned short, 3> > asMat3w(cv::Mat_<double>)

asMat3w( (Mat2d)inst_Mat2d) -> Mat3w :

    C++ signature :
        cv::Mat_<cv::Vec<unsigned short, 3> > asMat3w(cv::Mat_<cv::Vec<double, 2> >)

asMat3w( (Mat3d)inst_Mat3d) -> Mat3w :

    C++ signature :
        cv::Mat_<cv::Vec<unsigned short, 3> > asMat3w(cv::Mat_<cv::Vec<double, 3> >)

asMat3w( (Mat4d)inst_Mat4d) -> Mat3w :

    C++ signature :
        cv::Mat_<cv::Vec<unsigned short, 3> > asMat3w(cv::Mat_<cv::Vec<double, 4> >)

asMat4b(...)


asMat4b( (Mat1b)inst_Mat1b) -> Mat4b :

    C++ signature :
        cv::Mat_<cv::Vec<unsigned char, 4> > asMat4b(cv::Mat_<unsigned char>)

asMat4b( (Mat2b)inst_Mat2b) -> Mat4b :

    C++ signature :
        cv::Mat_<cv::Vec<unsigned char, 4> > asMat4b(cv::Mat_<cv::Vec<unsigned char, 2> >)

asMat4b( (Mat3b)inst_Mat3b) -> Mat4b :

    C++ signature :
        cv::Mat_<cv::Vec<unsigned char, 4> > asMat4b(cv::Mat_<cv::Vec<unsigned char, 3> >)

asMat4b( (Mat1s)inst_Mat1s) -> Mat4b :

    C++ signature :
        cv::Mat_<cv::Vec<unsigned char, 4> > asMat4b(cv::Mat_<short>)

asMat4b( (Mat2s)inst_Mat2s) -> Mat4b :

    C++ signature :
        cv::Mat_<cv::Vec<unsigned char, 4> > asMat4b(cv::Mat_<cv::Vec<short, 2> >)

asMat4b( (Mat3s)inst_Mat3s) -> Mat4b :

    C++ signature :
        cv::Mat_<cv::Vec<unsigned char, 4> > asMat4b(cv::Mat_<cv::Vec<short, 3> >)

asMat4b( (Mat4s)inst_Mat4s) -> Mat4b :

    C++ signature :
        cv::Mat_<cv::Vec<unsigned char, 4> > asMat4b(cv::Mat_<cv::Vec<short, 4> >)

asMat4b( (Mat1w)inst_Mat1w) -> Mat4b :

    C++ signature :
        cv::Mat_<cv::Vec<unsigned char, 4> > asMat4b(cv::Mat_<unsigned short>)

asMat4b( (Mat2w)inst_Mat2w) -> Mat4b :

    C++ signature :
        cv::Mat_<cv::Vec<unsigned char, 4> > asMat4b(cv::Mat_<cv::Vec<unsigned short, 2> >)

asMat4b( (Mat3w)inst_Mat3w) -> Mat4b :

    C++ signature :
        cv::Mat_<cv::Vec<unsigned char, 4> > asMat4b(cv::Mat_<cv::Vec<unsigned short, 3> >)

asMat4b( (Mat4w)inst_Mat4w) -> Mat4b :

    C++ signature :
        cv::Mat_<cv::Vec<unsigned char, 4> > asMat4b(cv::Mat_<cv::Vec<unsigned short, 4> >)

asMat4b( (Mat1i)inst_Mat1i) -> Mat4b :

    C++ signature :
        cv::Mat_<cv::Vec<unsigned char, 4> > asMat4b(cv::Mat_<int>)

asMat4b( (Mat2i)inst_Mat2i) -> Mat4b :

    C++ signature :
        cv::Mat_<cv::Vec<unsigned char, 4> > asMat4b(cv::Mat_<cv::Vec<int, 2> >)

asMat4b( (Mat3i)inst_Mat3i) -> Mat4b :

    C++ signature :
        cv::Mat_<cv::Vec<unsigned char, 4> > asMat4b(cv::Mat_<cv::Vec<int, 3> >)

asMat4b( (Mat4i)inst_Mat4i) -> Mat4b :

    C++ signature :
        cv::Mat_<cv::Vec<unsigned char, 4> > asMat4b(cv::Mat_<cv::Vec<int, 4> >)

asMat4b( (Mat1f)inst_Mat1f) -> Mat4b :

    C++ signature :
        cv::Mat_<cv::Vec<unsigned char, 4> > asMat4b(cv::Mat_<float>)

asMat4b( (Mat2f)inst_Mat2f) -> Mat4b :

    C++ signature :
        cv::Mat_<cv::Vec<unsigned char, 4> > asMat4b(cv::Mat_<cv::Vec<float, 2> >)

asMat4b( (Mat3f)inst_Mat3f) -> Mat4b :

    C++ signature :
        cv::Mat_<cv::Vec<unsigned char, 4> > asMat4b(cv::Mat_<cv::Vec<float, 3> >)

asMat4b( (Mat4f)inst_Mat4f) -> Mat4b :

    C++ signature :
        cv::Mat_<cv::Vec<unsigned char, 4> > asMat4b(cv::Mat_<cv::Vec<float, 4> >)

asMat4b( (Mat1d)inst_Mat1d) -> Mat4b :

    C++ signature :
        cv::Mat_<cv::Vec<unsigned char, 4> > asMat4b(cv::Mat_<double>)

asMat4b( (Mat2d)inst_Mat2d) -> Mat4b :

    C++ signature :
        cv::Mat_<cv::Vec<unsigned char, 4> > asMat4b(cv::Mat_<cv::Vec<double, 2> >)

asMat4b( (Mat3d)inst_Mat3d) -> Mat4b :

    C++ signature :
        cv::Mat_<cv::Vec<unsigned char, 4> > asMat4b(cv::Mat_<cv::Vec<double, 3> >)

asMat4b( (Mat4d)inst_Mat4d) -> Mat4b :

    C++ signature :
        cv::Mat_<cv::Vec<unsigned char, 4> > asMat4b(cv::Mat_<cv::Vec<double, 4> >)

asMat4d(...)


asMat4d( (Mat1b)inst_Mat1b) -> Mat4d :

    C++ signature :
        cv::Mat_<cv::Vec<double, 4> > asMat4d(cv::Mat_<unsigned char>)

asMat4d( (Mat2b)inst_Mat2b) -> Mat4d :

    C++ signature :
        cv::Mat_<cv::Vec<double, 4> > asMat4d(cv::Mat_<cv::Vec<unsigned char, 2> >)

asMat4d( (Mat3b)inst_Mat3b) -> Mat4d :

    C++ signature :
        cv::Mat_<cv::Vec<double, 4> > asMat4d(cv::Mat_<cv::Vec<unsigned char, 3> >)

asMat4d( (Mat4b)inst_Mat4b) -> Mat4d :

    C++ signature :
        cv::Mat_<cv::Vec<double, 4> > asMat4d(cv::Mat_<cv::Vec<unsigned char, 4> >)

asMat4d( (Mat1s)inst_Mat1s) -> Mat4d :

    C++ signature :
        cv::Mat_<cv::Vec<double, 4> > asMat4d(cv::Mat_<short>)

asMat4d( (Mat2s)inst_Mat2s) -> Mat4d :

    C++ signature :
        cv::Mat_<cv::Vec<double, 4> > asMat4d(cv::Mat_<cv::Vec<short, 2> >)

asMat4d( (Mat3s)inst_Mat3s) -> Mat4d :

    C++ signature :
        cv::Mat_<cv::Vec<double, 4> > asMat4d(cv::Mat_<cv::Vec<short, 3> >)

asMat4d( (Mat4s)inst_Mat4s) -> Mat4d :

    C++ signature :
        cv::Mat_<cv::Vec<double, 4> > asMat4d(cv::Mat_<cv::Vec<short, 4> >)

asMat4d( (Mat1w)inst_Mat1w) -> Mat4d :

    C++ signature :
        cv::Mat_<cv::Vec<double, 4> > asMat4d(cv::Mat_<unsigned short>)

asMat4d( (Mat2w)inst_Mat2w) -> Mat4d :

    C++ signature :
        cv::Mat_<cv::Vec<double, 4> > asMat4d(cv::Mat_<cv::Vec<unsigned short, 2> >)

asMat4d( (Mat3w)inst_Mat3w) -> Mat4d :

    C++ signature :
        cv::Mat_<cv::Vec<double, 4> > asMat4d(cv::Mat_<cv::Vec<unsigned short, 3> >)

asMat4d( (Mat4w)inst_Mat4w) -> Mat4d :

    C++ signature :
        cv::Mat_<cv::Vec<double, 4> > asMat4d(cv::Mat_<cv::Vec<unsigned short, 4> >)

asMat4d( (Mat1i)inst_Mat1i) -> Mat4d :

    C++ signature :
        cv::Mat_<cv::Vec<double, 4> > asMat4d(cv::Mat_<int>)

asMat4d( (Mat2i)inst_Mat2i) -> Mat4d :

    C++ signature :
        cv::Mat_<cv::Vec<double, 4> > asMat4d(cv::Mat_<cv::Vec<int, 2> >)

asMat4d( (Mat3i)inst_Mat3i) -> Mat4d :

    C++ signature :
        cv::Mat_<cv::Vec<double, 4> > asMat4d(cv::Mat_<cv::Vec<int, 3> >)

asMat4d( (Mat4i)inst_Mat4i) -> Mat4d :

    C++ signature :
        cv::Mat_<cv::Vec<double, 4> > asMat4d(cv::Mat_<cv::Vec<int, 4> >)

asMat4d( (Mat1f)inst_Mat1f) -> Mat4d :

    C++ signature :
        cv::Mat_<cv::Vec<double, 4> > asMat4d(cv::Mat_<float>)

asMat4d( (Mat2f)inst_Mat2f) -> Mat4d :

    C++ signature :
        cv::Mat_<cv::Vec<double, 4> > asMat4d(cv::Mat_<cv::Vec<float, 2> >)

asMat4d( (Mat3f)inst_Mat3f) -> Mat4d :

    C++ signature :
        cv::Mat_<cv::Vec<double, 4> > asMat4d(cv::Mat_<cv::Vec<float, 3> >)

asMat4d( (Mat4f)inst_Mat4f) -> Mat4d :

    C++ signature :
        cv::Mat_<cv::Vec<double, 4> > asMat4d(cv::Mat_<cv::Vec<float, 4> >)

asMat4d( (Mat1d)inst_Mat1d) -> Mat4d :

    C++ signature :
        cv::Mat_<cv::Vec<double, 4> > asMat4d(cv::Mat_<double>)

asMat4d( (Mat2d)inst_Mat2d) -> Mat4d :

    C++ signature :
        cv::Mat_<cv::Vec<double, 4> > asMat4d(cv::Mat_<cv::Vec<double, 2> >)

asMat4d( (Mat3d)inst_Mat3d) -> Mat4d :

    C++ signature :
        cv::Mat_<cv::Vec<double, 4> > asMat4d(cv::Mat_<cv::Vec<double, 3> >)

asMat4f(...)


asMat4f( (Mat1b)inst_Mat1b) -> Mat4f :

    C++ signature :
        cv::Mat_<cv::Vec<float, 4> > asMat4f(cv::Mat_<unsigned char>)

asMat4f( (Mat2b)inst_Mat2b) -> Mat4f :

    C++ signature :
        cv::Mat_<cv::Vec<float, 4> > asMat4f(cv::Mat_<cv::Vec<unsigned char, 2> >)

asMat4f( (Mat3b)inst_Mat3b) -> Mat4f :

    C++ signature :
        cv::Mat_<cv::Vec<float, 4> > asMat4f(cv::Mat_<cv::Vec<unsigned char, 3> >)

asMat4f( (Mat4b)inst_Mat4b) -> Mat4f :

    C++ signature :
        cv::Mat_<cv::Vec<float, 4> > asMat4f(cv::Mat_<cv::Vec<unsigned char, 4> >)

asMat4f( (Mat1s)inst_Mat1s) -> Mat4f :

    C++ signature :
        cv::Mat_<cv::Vec<float, 4> > asMat4f(cv::Mat_<short>)

asMat4f( (Mat2s)inst_Mat2s) -> Mat4f :

    C++ signature :
        cv::Mat_<cv::Vec<float, 4> > asMat4f(cv::Mat_<cv::Vec<short, 2> >)

asMat4f( (Mat3s)inst_Mat3s) -> Mat4f :

    C++ signature :
        cv::Mat_<cv::Vec<float, 4> > asMat4f(cv::Mat_<cv::Vec<short, 3> >)

asMat4f( (Mat4s)inst_Mat4s) -> Mat4f :

    C++ signature :
        cv::Mat_<cv::Vec<float, 4> > asMat4f(cv::Mat_<cv::Vec<short, 4> >)

asMat4f( (Mat1w)inst_Mat1w) -> Mat4f :

    C++ signature :
        cv::Mat_<cv::Vec<float, 4> > asMat4f(cv::Mat_<unsigned short>)

asMat4f( (Mat2w)inst_Mat2w) -> Mat4f :

    C++ signature :
        cv::Mat_<cv::Vec<float, 4> > asMat4f(cv::Mat_<cv::Vec<unsigned short, 2> >)

asMat4f( (Mat3w)inst_Mat3w) -> Mat4f :

    C++ signature :
        cv::Mat_<cv::Vec<float, 4> > asMat4f(cv::Mat_<cv::Vec<unsigned short, 3> >)

asMat4f( (Mat4w)inst_Mat4w) -> Mat4f :

    C++ signature :
        cv::Mat_<cv::Vec<float, 4> > asMat4f(cv::Mat_<cv::Vec<unsigned short, 4> >)

asMat4f( (Mat1i)inst_Mat1i) -> Mat4f :

    C++ signature :
        cv::Mat_<cv::Vec<float, 4> > asMat4f(cv::Mat_<int>)

asMat4f( (Mat2i)inst_Mat2i) -> Mat4f :

    C++ signature :
        cv::Mat_<cv::Vec<float, 4> > asMat4f(cv::Mat_<cv::Vec<int, 2> >)

asMat4f( (Mat3i)inst_Mat3i) -> Mat4f :

    C++ signature :
        cv::Mat_<cv::Vec<float, 4> > asMat4f(cv::Mat_<cv::Vec<int, 3> >)

asMat4f( (Mat4i)inst_Mat4i) -> Mat4f :

    C++ signature :
        cv::Mat_<cv::Vec<float, 4> > asMat4f(cv::Mat_<cv::Vec<int, 4> >)

asMat4f( (Mat1f)inst_Mat1f) -> Mat4f :

    C++ signature :
        cv::Mat_<cv::Vec<float, 4> > asMat4f(cv::Mat_<float>)

asMat4f( (Mat2f)inst_Mat2f) -> Mat4f :

    C++ signature :
        cv::Mat_<cv::Vec<float, 4> > asMat4f(cv::Mat_<cv::Vec<float, 2> >)

asMat4f( (Mat3f)inst_Mat3f) -> Mat4f :

    C++ signature :
        cv::Mat_<cv::Vec<float, 4> > asMat4f(cv::Mat_<cv::Vec<float, 3> >)

asMat4f( (Mat1d)inst_Mat1d) -> Mat4f :

    C++ signature :
        cv::Mat_<cv::Vec<float, 4> > asMat4f(cv::Mat_<double>)

asMat4f( (Mat2d)inst_Mat2d) -> Mat4f :

    C++ signature :
        cv::Mat_<cv::Vec<float, 4> > asMat4f(cv::Mat_<cv::Vec<double, 2> >)

asMat4f( (Mat3d)inst_Mat3d) -> Mat4f :

    C++ signature :
        cv::Mat_<cv::Vec<float, 4> > asMat4f(cv::Mat_<cv::Vec<double, 3> >)

asMat4f( (Mat4d)inst_Mat4d) -> Mat4f :

    C++ signature :
        cv::Mat_<cv::Vec<float, 4> > asMat4f(cv::Mat_<cv::Vec<double, 4> >)

asMat4i(...)


asMat4i( (Mat1b)inst_Mat1b) -> Mat4i :

    C++ signature :
        cv::Mat_<cv::Vec<int, 4> > asMat4i(cv::Mat_<unsigned char>)

asMat4i( (Mat2b)inst_Mat2b) -> Mat4i :

    C++ signature :
        cv::Mat_<cv::Vec<int, 4> > asMat4i(cv::Mat_<cv::Vec<unsigned char, 2> >)

asMat4i( (Mat3b)inst_Mat3b) -> Mat4i :

    C++ signature :
        cv::Mat_<cv::Vec<int, 4> > asMat4i(cv::Mat_<cv::Vec<unsigned char, 3> >)

asMat4i( (Mat4b)inst_Mat4b) -> Mat4i :

    C++ signature :
        cv::Mat_<cv::Vec<int, 4> > asMat4i(cv::Mat_<cv::Vec<unsigned char, 4> >)

asMat4i( (Mat1s)inst_Mat1s) -> Mat4i :

    C++ signature :
        cv::Mat_<cv::Vec<int, 4> > asMat4i(cv::Mat_<short>)

asMat4i( (Mat2s)inst_Mat2s) -> Mat4i :

    C++ signature :
        cv::Mat_<cv::Vec<int, 4> > asMat4i(cv::Mat_<cv::Vec<short, 2> >)

asMat4i( (Mat3s)inst_Mat3s) -> Mat4i :

    C++ signature :
        cv::Mat_<cv::Vec<int, 4> > asMat4i(cv::Mat_<cv::Vec<short, 3> >)

asMat4i( (Mat4s)inst_Mat4s) -> Mat4i :

    C++ signature :
        cv::Mat_<cv::Vec<int, 4> > asMat4i(cv::Mat_<cv::Vec<short, 4> >)

asMat4i( (Mat1w)inst_Mat1w) -> Mat4i :

    C++ signature :
        cv::Mat_<cv::Vec<int, 4> > asMat4i(cv::Mat_<unsigned short>)

asMat4i( (Mat2w)inst_Mat2w) -> Mat4i :

    C++ signature :
        cv::Mat_<cv::Vec<int, 4> > asMat4i(cv::Mat_<cv::Vec<unsigned short, 2> >)

asMat4i( (Mat3w)inst_Mat3w) -> Mat4i :

    C++ signature :
        cv::Mat_<cv::Vec<int, 4> > asMat4i(cv::Mat_<cv::Vec<unsigned short, 3> >)

asMat4i( (Mat4w)inst_Mat4w) -> Mat4i :

    C++ signature :
        cv::Mat_<cv::Vec<int, 4> > asMat4i(cv::Mat_<cv::Vec<unsigned short, 4> >)

asMat4i( (Mat1i)inst_Mat1i) -> Mat4i :

    C++ signature :
        cv::Mat_<cv::Vec<int, 4> > asMat4i(cv::Mat_<int>)

asMat4i( (Mat2i)inst_Mat2i) -> Mat4i :

    C++ signature :
        cv::Mat_<cv::Vec<int, 4> > asMat4i(cv::Mat_<cv::Vec<int, 2> >)

asMat4i( (Mat3i)inst_Mat3i) -> Mat4i :

    C++ signature :
        cv::Mat_<cv::Vec<int, 4> > asMat4i(cv::Mat_<cv::Vec<int, 3> >)

asMat4i( (Mat1f)inst_Mat1f) -> Mat4i :

    C++ signature :
        cv::Mat_<cv::Vec<int, 4> > asMat4i(cv::Mat_<float>)

asMat4i( (Mat2f)inst_Mat2f) -> Mat4i :

    C++ signature :
        cv::Mat_<cv::Vec<int, 4> > asMat4i(cv::Mat_<cv::Vec<float, 2> >)

asMat4i( (Mat3f)inst_Mat3f) -> Mat4i :

    C++ signature :
        cv::Mat_<cv::Vec<int, 4> > asMat4i(cv::Mat_<cv::Vec<float, 3> >)

asMat4i( (Mat4f)inst_Mat4f) -> Mat4i :

    C++ signature :
        cv::Mat_<cv::Vec<int, 4> > asMat4i(cv::Mat_<cv::Vec<float, 4> >)

asMat4i( (Mat1d)inst_Mat1d) -> Mat4i :

    C++ signature :
        cv::Mat_<cv::Vec<int, 4> > asMat4i(cv::Mat_<double>)

asMat4i( (Mat2d)inst_Mat2d) -> Mat4i :

    C++ signature :
        cv::Mat_<cv::Vec<int, 4> > asMat4i(cv::Mat_<cv::Vec<double, 2> >)

asMat4i( (Mat3d)inst_Mat3d) -> Mat4i :

    C++ signature :
        cv::Mat_<cv::Vec<int, 4> > asMat4i(cv::Mat_<cv::Vec<double, 3> >)

asMat4i( (Mat4d)inst_Mat4d) -> Mat4i :

    C++ signature :
        cv::Mat_<cv::Vec<int, 4> > asMat4i(cv::Mat_<cv::Vec<double, 4> >)

asMat4s(...)


asMat4s( (Mat1b)inst_Mat1b) -> Mat4s :

    C++ signature :
        cv::Mat_<cv::Vec<short, 4> > asMat4s(cv::Mat_<unsigned char>)

asMat4s( (Mat2b)inst_Mat2b) -> Mat4s :

    C++ signature :
        cv::Mat_<cv::Vec<short, 4> > asMat4s(cv::Mat_<cv::Vec<unsigned char, 2> >)

asMat4s( (Mat3b)inst_Mat3b) -> Mat4s :

    C++ signature :
        cv::Mat_<cv::Vec<short, 4> > asMat4s(cv::Mat_<cv::Vec<unsigned char, 3> >)

asMat4s( (Mat4b)inst_Mat4b) -> Mat4s :

    C++ signature :
        cv::Mat_<cv::Vec<short, 4> > asMat4s(cv::Mat_<cv::Vec<unsigned char, 4> >)

asMat4s( (Mat1s)inst_Mat1s) -> Mat4s :

    C++ signature :
        cv::Mat_<cv::Vec<short, 4> > asMat4s(cv::Mat_<short>)

asMat4s( (Mat2s)inst_Mat2s) -> Mat4s :

    C++ signature :
        cv::Mat_<cv::Vec<short, 4> > asMat4s(cv::Mat_<cv::Vec<short, 2> >)

asMat4s( (Mat3s)inst_Mat3s) -> Mat4s :

    C++ signature :
        cv::Mat_<cv::Vec<short, 4> > asMat4s(cv::Mat_<cv::Vec<short, 3> >)

asMat4s( (Mat1w)inst_Mat1w) -> Mat4s :

    C++ signature :
        cv::Mat_<cv::Vec<short, 4> > asMat4s(cv::Mat_<unsigned short>)

asMat4s( (Mat2w)inst_Mat2w) -> Mat4s :

    C++ signature :
        cv::Mat_<cv::Vec<short, 4> > asMat4s(cv::Mat_<cv::Vec<unsigned short, 2> >)

asMat4s( (Mat3w)inst_Mat3w) -> Mat4s :

    C++ signature :
        cv::Mat_<cv::Vec<short, 4> > asMat4s(cv::Mat_<cv::Vec<unsigned short, 3> >)

asMat4s( (Mat4w)inst_Mat4w) -> Mat4s :

    C++ signature :
        cv::Mat_<cv::Vec<short, 4> > asMat4s(cv::Mat_<cv::Vec<unsigned short, 4> >)

asMat4s( (Mat1i)inst_Mat1i) -> Mat4s :

    C++ signature :
        cv::Mat_<cv::Vec<short, 4> > asMat4s(cv::Mat_<int>)

asMat4s( (Mat2i)inst_Mat2i) -> Mat4s :

    C++ signature :
        cv::Mat_<cv::Vec<short, 4> > asMat4s(cv::Mat_<cv::Vec<int, 2> >)

asMat4s( (Mat3i)inst_Mat3i) -> Mat4s :

    C++ signature :
        cv::Mat_<cv::Vec<short, 4> > asMat4s(cv::Mat_<cv::Vec<int, 3> >)

asMat4s( (Mat4i)inst_Mat4i) -> Mat4s :

    C++ signature :
        cv::Mat_<cv::Vec<short, 4> > asMat4s(cv::Mat_<cv::Vec<int, 4> >)

asMat4s( (Mat1f)inst_Mat1f) -> Mat4s :

    C++ signature :
        cv::Mat_<cv::Vec<short, 4> > asMat4s(cv::Mat_<float>)

asMat4s( (Mat2f)inst_Mat2f) -> Mat4s :

    C++ signature :
        cv::Mat_<cv::Vec<short, 4> > asMat4s(cv::Mat_<cv::Vec<float, 2> >)

asMat4s( (Mat3f)inst_Mat3f) -> Mat4s :

    C++ signature :
        cv::Mat_<cv::Vec<short, 4> > asMat4s(cv::Mat_<cv::Vec<float, 3> >)

asMat4s( (Mat4f)inst_Mat4f) -> Mat4s :

    C++ signature :
        cv::Mat_<cv::Vec<short, 4> > asMat4s(cv::Mat_<cv::Vec<float, 4> >)

asMat4s( (Mat1d)inst_Mat1d) -> Mat4s :

    C++ signature :
        cv::Mat_<cv::Vec<short, 4> > asMat4s(cv::Mat_<double>)

asMat4s( (Mat2d)inst_Mat2d) -> Mat4s :

    C++ signature :
        cv::Mat_<cv::Vec<short, 4> > asMat4s(cv::Mat_<cv::Vec<double, 2> >)

asMat4s( (Mat3d)inst_Mat3d) -> Mat4s :

    C++ signature :
        cv::Mat_<cv::Vec<short, 4> > asMat4s(cv::Mat_<cv::Vec<double, 3> >)

asMat4s( (Mat4d)inst_Mat4d) -> Mat4s :

    C++ signature :
        cv::Mat_<cv::Vec<short, 4> > asMat4s(cv::Mat_<cv::Vec<double, 4> >)

asMat4w(...)


asMat4w( (Mat1b)inst_Mat1b) -> Mat4w :

    C++ signature :
        cv::Mat_<cv::Vec<unsigned short, 4> > asMat4w(cv::Mat_<unsigned char>)

asMat4w( (Mat2b)inst_Mat2b) -> Mat4w :

    C++ signature :
        cv::Mat_<cv::Vec<unsigned short, 4> > asMat4w(cv::Mat_<cv::Vec<unsigned char, 2> >)

asMat4w( (Mat3b)inst_Mat3b) -> Mat4w :

    C++ signature :
        cv::Mat_<cv::Vec<unsigned short, 4> > asMat4w(cv::Mat_<cv::Vec<unsigned char, 3> >)

asMat4w( (Mat4b)inst_Mat4b) -> Mat4w :

    C++ signature :
        cv::Mat_<cv::Vec<unsigned short, 4> > asMat4w(cv::Mat_<cv::Vec<unsigned char, 4> >)

asMat4w( (Mat1s)inst_Mat1s) -> Mat4w :

    C++ signature :
        cv::Mat_<cv::Vec<unsigned short, 4> > asMat4w(cv::Mat_<short>)

asMat4w( (Mat2s)inst_Mat2s) -> Mat4w :

    C++ signature :
        cv::Mat_<cv::Vec<unsigned short, 4> > asMat4w(cv::Mat_<cv::Vec<short, 2> >)

asMat4w( (Mat3s)inst_Mat3s) -> Mat4w :

    C++ signature :
        cv::Mat_<cv::Vec<unsigned short, 4> > asMat4w(cv::Mat_<cv::Vec<short, 3> >)

asMat4w( (Mat4s)inst_Mat4s) -> Mat4w :

    C++ signature :
        cv::Mat_<cv::Vec<unsigned short, 4> > asMat4w(cv::Mat_<cv::Vec<short, 4> >)

asMat4w( (Mat1w)inst_Mat1w) -> Mat4w :

    C++ signature :
        cv::Mat_<cv::Vec<unsigned short, 4> > asMat4w(cv::Mat_<unsigned short>)

asMat4w( (Mat2w)inst_Mat2w) -> Mat4w :

    C++ signature :
        cv::Mat_<cv::Vec<unsigned short, 4> > asMat4w(cv::Mat_<cv::Vec<unsigned short, 2> >)

asMat4w( (Mat3w)inst_Mat3w) -> Mat4w :

    C++ signature :
        cv::Mat_<cv::Vec<unsigned short, 4> > asMat4w(cv::Mat_<cv::Vec<unsigned short, 3> >)

asMat4w( (Mat1i)inst_Mat1i) -> Mat4w :

    C++ signature :
        cv::Mat_<cv::Vec<unsigned short, 4> > asMat4w(cv::Mat_<int>)

asMat4w( (Mat2i)inst_Mat2i) -> Mat4w :

    C++ signature :
        cv::Mat_<cv::Vec<unsigned short, 4> > asMat4w(cv::Mat_<cv::Vec<int, 2> >)

asMat4w( (Mat3i)inst_Mat3i) -> Mat4w :

    C++ signature :
        cv::Mat_<cv::Vec<unsigned short, 4> > asMat4w(cv::Mat_<cv::Vec<int, 3> >)

asMat4w( (Mat4i)inst_Mat4i) -> Mat4w :

    C++ signature :
        cv::Mat_<cv::Vec<unsigned short, 4> > asMat4w(cv::Mat_<cv::Vec<int, 4> >)

asMat4w( (Mat1f)inst_Mat1f) -> Mat4w :

    C++ signature :
        cv::Mat_<cv::Vec<unsigned short, 4> > asMat4w(cv::Mat_<float>)

asMat4w( (Mat2f)inst_Mat2f) -> Mat4w :

    C++ signature :
        cv::Mat_<cv::Vec<unsigned short, 4> > asMat4w(cv::Mat_<cv::Vec<float, 2> >)

asMat4w( (Mat3f)inst_Mat3f) -> Mat4w :

    C++ signature :
        cv::Mat_<cv::Vec<unsigned short, 4> > asMat4w(cv::Mat_<cv::Vec<float, 3> >)

asMat4w( (Mat4f)inst_Mat4f) -> Mat4w :

    C++ signature :
        cv::Mat_<cv::Vec<unsigned short, 4> > asMat4w(cv::Mat_<cv::Vec<float, 4> >)

asMat4w( (Mat1d)inst_Mat1d) -> Mat4w :

    C++ signature :
        cv::Mat_<cv::Vec<unsigned short, 4> > asMat4w(cv::Mat_<double>)

asMat4w( (Mat2d)inst_Mat2d) -> Mat4w :

    C++ signature :
        cv::Mat_<cv::Vec<unsigned short, 4> > asMat4w(cv::Mat_<cv::Vec<double, 2> >)

asMat4w( (Mat3d)inst_Mat3d) -> Mat4w :

    C++ signature :
        cv::Mat_<cv::Vec<unsigned short, 4> > asMat4w(cv::Mat_<cv::Vec<double, 3> >)

asMat4w( (Mat4d)inst_Mat4d) -> Mat4w :

    C++ signature :
        cv::Mat_<cv::Vec<unsigned short, 4> > asMat4w(cv::Mat_<cv::Vec<double, 4> >)

asMatND(...)


asMatND( (object)arr) -> object :

    C++ signature :
        boost::python::api::object asMatND(boost::python::ndarray)

asPoint2d(...)


asPoint2d( (Point2i)inst_Point2i) -> Point2d :

    C++ signature :
        cv::Point_<double> asPoint2d(cv::Point_<int>)

asPoint2d( (Point2f)inst_Point2f) -> Point2d :

    C++ signature :
        cv::Point_<double> asPoint2d(cv::Point_<float>)

asPoint2d( (object)arr) -> object :

    C++ signature :
        boost::python::api::object asPoint2d(boost::python::ndarray)

asPoint2f(...)


asPoint2f( (Point2i)inst_Point2i) -> Point2f :

    C++ signature :
        cv::Point_<float> asPoint2f(cv::Point_<int>)

asPoint2f( (Point2d)inst_Point2d) -> Point2f :

    C++ signature :
        cv::Point_<float> asPoint2f(cv::Point_<double>)

asPoint2f( (object)arr) -> object :

    C++ signature :
        boost::python::api::object asPoint2f(boost::python::ndarray)

asPoint2i(...)


asPoint2i( (Point2f)inst_Point2f) -> Point2i :

    C++ signature :
        cv::Point_<int> asPoint2i(cv::Point_<float>)

asPoint2i( (Point2d)inst_Point2d) -> Point2i :

    C++ signature :
        cv::Point_<int> asPoint2i(cv::Point_<double>)

asPoint2i( (object)arr) -> object :

    C++ signature :
        boost::python::api::object asPoint2i(boost::python::ndarray)

asPoint3d(...)


asPoint3d( (Point3i)inst_Point3i) -> Point3d :

    C++ signature :
        cv::Point3_<double> asPoint3d(cv::Point3_<int>)

asPoint3d( (Point3f)inst_Point3f) -> Point3d :

    C++ signature :
        cv::Point3_<double> asPoint3d(cv::Point3_<float>)

asPoint3d( (object)arr) -> object :

    C++ signature :
        boost::python::api::object asPoint3d(boost::python::ndarray)

asPoint3f(...)


asPoint3f( (Point3i)inst_Point3i) -> Point3f :

    C++ signature :
        cv::Point3_<float> asPoint3f(cv::Point3_<int>)

asPoint3f( (Point3d)inst_Point3d) -> Point3f :

    C++ signature :
        cv::Point3_<float> asPoint3f(cv::Point3_<double>)

asPoint3f( (object)arr) -> object :

    C++ signature :
        boost::python::api::object asPoint3f(boost::python::ndarray)

asPoint3i(...)


asPoint3i( (Point3f)inst_Point3f) -> Point3i :

    C++ signature :
        cv::Point3_<int> asPoint3i(cv::Point3_<float>)

asPoint3i( (Point3d)inst_Point3d) -> Point3i :

    C++ signature :
        cv::Point3_<int> asPoint3i(cv::Point3_<double>)

asPoint3i( (object)arr) -> object :

    C++ signature :
        boost::python::api::object asPoint3i(boost::python::ndarray)

asRange(...)


asRange( (object)arr) -> object :

    C++ signature :
        boost::python::api::object asRange(boost::python::ndarray)

asRect(...)


asRect( (Rectf)inst_Rectf) -> Rect :

    C++ signature :
        cv::Rect_<int> asRect(cv::Rect_<float>)

asRect( (Rectd)inst_Rectd) -> Rect :

    C++ signature :
        cv::Rect_<int> asRect(cv::Rect_<double>)

asRect( (object)arr) -> object :

    C++ signature :
        boost::python::api::object asRect(boost::python::ndarray)

asRectd(...)


asRectd( (Rect)inst_Rect) -> Rectd :

    C++ signature :
        cv::Rect_<double> asRectd(cv::Rect_<int>)

asRectd( (Rectf)inst_Rectf) -> Rectd :

    C++ signature :
        cv::Rect_<double> asRectd(cv::Rect_<float>)

asRectd( (object)arr) -> object :

    C++ signature :
        boost::python::api::object asRectd(boost::python::ndarray)

asRectf(...)


asRectf( (Rect)inst_Rect) -> Rectf :

    C++ signature :
        cv::Rect_<float> asRectf(cv::Rect_<int>)

asRectf( (Rectd)inst_Rectd) -> Rectf :

    C++ signature :
        cv::Rect_<float> asRectf(cv::Rect_<double>)

asRectf( (object)arr) -> object :

    C++ signature :
        boost::python::api::object asRectf(boost::python::ndarray)

asRotatedRect(...)


asRotatedRect( (object)arr) -> object :

    C++ signature :
        boost::python::api::object asRotatedRect(boost::python::ndarray)

asScalar(...)


asScalar( (object)arr) -> object :

    C++ signature :
        boost::python::api::object asScalar(boost::python::ndarray)

asSize2d(...)


asSize2d( (Size2i)inst_Size2i) -> Size2d :

    C++ signature :
        cv::Size_<double> asSize2d(cv::Size_<int>)

asSize2d( (Size2f)inst_Size2f) -> Size2d :

    C++ signature :
        cv::Size_<double> asSize2d(cv::Size_<float>)

asSize2d( (object)arr) -> object :

    C++ signature :
        boost::python::api::object asSize2d(boost::python::ndarray)

asSize2f(...)


asSize2f( (Size2i)inst_Size2i) -> Size2f :

    C++ signature :
        cv::Size_<float> asSize2f(cv::Size_<int>)

asSize2f( (Size2d)inst_Size2d) -> Size2f :

    C++ signature :
        cv::Size_<float> asSize2f(cv::Size_<double>)

asSize2f( (object)arr) -> object :

    C++ signature :
        boost::python::api::object asSize2f(boost::python::ndarray)

asSize2i(...)


asSize2i( (Size2f)inst_Size2f) -> Size2i :

    C++ signature :
        cv::Size_<int> asSize2i(cv::Size_<float>)

asSize2i( (Size2d)inst_Size2d) -> Size2i :

    C++ signature :
        cv::Size_<int> asSize2i(cv::Size_<double>)

asSize2i( (object)arr) -> object :

    C++ signature :
        boost::python::api::object asSize2i(boost::python::ndarray)

asVec2b(...)


asVec2b( (Vec2s)inst_Vec2s) -> Vec2b :

    C++ signature :
        cv::Vec<unsigned char, 2> asVec2b(cv::Vec<short, 2>)

asVec2b( (Vec2w)inst_Vec2w) -> Vec2b :

    C++ signature :
        cv::Vec<unsigned char, 2> asVec2b(cv::Vec<unsigned short, 2>)

asVec2b( (Vec2i)inst_Vec2i) -> Vec2b :

    C++ signature :
        cv::Vec<unsigned char, 2> asVec2b(cv::Vec<int, 2>)

asVec2b( (Vec2f)inst_Vec2f) -> Vec2b :

    C++ signature :
        cv::Vec<unsigned char, 2> asVec2b(cv::Vec<float, 2>)

asVec2b( (Vec2d)inst_Vec2d) -> Vec2b :

    C++ signature :
        cv::Vec<unsigned char, 2> asVec2b(cv::Vec<double, 2>)

asVec2b( (object)arr) -> object :

    C++ signature :
        boost::python::api::object asVec2b(boost::python::ndarray)

asVec2d(...)


asVec2d( (Vec2b)inst_Vec2b) -> Vec2d :

    C++ signature :
        cv::Vec<double, 2> asVec2d(cv::Vec<unsigned char, 2>)

asVec2d( (Vec2s)inst_Vec2s) -> Vec2d :

    C++ signature :
        cv::Vec<double, 2> asVec2d(cv::Vec<short, 2>)

asVec2d( (Vec2w)inst_Vec2w) -> Vec2d :

    C++ signature :
        cv::Vec<double, 2> asVec2d(cv::Vec<unsigned short, 2>)

asVec2d( (Vec2i)inst_Vec2i) -> Vec2d :

    C++ signature :
        cv::Vec<double, 2> asVec2d(cv::Vec<int, 2>)

asVec2d( (Vec2f)inst_Vec2f) -> Vec2d :

    C++ signature :
        cv::Vec<double, 2> asVec2d(cv::Vec<float, 2>)

asVec2d( (object)arr) -> object :

    C++ signature :
        boost::python::api::object asVec2d(boost::python::ndarray)

asVec2f(...)


asVec2f( (Vec2b)inst_Vec2b) -> Vec2f :

    C++ signature :
        cv::Vec<float, 2> asVec2f(cv::Vec<unsigned char, 2>)

asVec2f( (Vec2s)inst_Vec2s) -> Vec2f :

    C++ signature :
        cv::Vec<float, 2> asVec2f(cv::Vec<short, 2>)

asVec2f( (Vec2w)inst_Vec2w) -> Vec2f :

    C++ signature :
        cv::Vec<float, 2> asVec2f(cv::Vec<unsigned short, 2>)

asVec2f( (Vec2i)inst_Vec2i) -> Vec2f :

    C++ signature :
        cv::Vec<float, 2> asVec2f(cv::Vec<int, 2>)

asVec2f( (Vec2d)inst_Vec2d) -> Vec2f :

    C++ signature :
        cv::Vec<float, 2> asVec2f(cv::Vec<double, 2>)

asVec2f( (object)arr) -> object :

    C++ signature :
        boost::python::api::object asVec2f(boost::python::ndarray)

asVec2i(...)


asVec2i( (Vec2b)inst_Vec2b) -> Vec2i :

    C++ signature :
        cv::Vec<int, 2> asVec2i(cv::Vec<unsigned char, 2>)

asVec2i( (Vec2s)inst_Vec2s) -> Vec2i :

    C++ signature :
        cv::Vec<int, 2> asVec2i(cv::Vec<short, 2>)

asVec2i( (Vec2w)inst_Vec2w) -> Vec2i :

    C++ signature :
        cv::Vec<int, 2> asVec2i(cv::Vec<unsigned short, 2>)

asVec2i( (Vec2f)inst_Vec2f) -> Vec2i :

    C++ signature :
        cv::Vec<int, 2> asVec2i(cv::Vec<float, 2>)

asVec2i( (Vec2d)inst_Vec2d) -> Vec2i :

    C++ signature :
        cv::Vec<int, 2> asVec2i(cv::Vec<double, 2>)

asVec2i( (object)arr) -> object :

    C++ signature :
        boost::python::api::object asVec2i(boost::python::ndarray)

asVec2s(...)


asVec2s( (Vec2b)inst_Vec2b) -> Vec2s :

    C++ signature :
        cv::Vec<short, 2> asVec2s(cv::Vec<unsigned char, 2>)

asVec2s( (Vec2w)inst_Vec2w) -> Vec2s :

    C++ signature :
        cv::Vec<short, 2> asVec2s(cv::Vec<unsigned short, 2>)

asVec2s( (Vec2i)inst_Vec2i) -> Vec2s :

    C++ signature :
        cv::Vec<short, 2> asVec2s(cv::Vec<int, 2>)

asVec2s( (Vec2f)inst_Vec2f) -> Vec2s :

    C++ signature :
        cv::Vec<short, 2> asVec2s(cv::Vec<float, 2>)

asVec2s( (Vec2d)inst_Vec2d) -> Vec2s :

    C++ signature :
        cv::Vec<short, 2> asVec2s(cv::Vec<double, 2>)

asVec2s( (object)arr) -> object :

    C++ signature :
        boost::python::api::object asVec2s(boost::python::ndarray)

asVec2w(...)


asVec2w( (Vec2b)inst_Vec2b) -> Vec2w :

    C++ signature :
        cv::Vec<unsigned short, 2> asVec2w(cv::Vec<unsigned char, 2>)

asVec2w( (Vec2s)inst_Vec2s) -> Vec2w :

    C++ signature :
        cv::Vec<unsigned short, 2> asVec2w(cv::Vec<short, 2>)

asVec2w( (Vec2i)inst_Vec2i) -> Vec2w :

    C++ signature :
        cv::Vec<unsigned short, 2> asVec2w(cv::Vec<int, 2>)

asVec2w( (Vec2f)inst_Vec2f) -> Vec2w :

    C++ signature :
        cv::Vec<unsigned short, 2> asVec2w(cv::Vec<float, 2>)

asVec2w( (Vec2d)inst_Vec2d) -> Vec2w :

    C++ signature :
        cv::Vec<unsigned short, 2> asVec2w(cv::Vec<double, 2>)

asVec2w( (object)arr) -> object :

    C++ signature :
        boost::python::api::object asVec2w(boost::python::ndarray)

asVec3b(...)


asVec3b( (Vec3s)inst_Vec3s) -> Vec3b :

    C++ signature :
        cv::Vec<unsigned char, 3> asVec3b(cv::Vec<short, 3>)

asVec3b( (Vec3w)inst_Vec3w) -> Vec3b :

    C++ signature :
        cv::Vec<unsigned char, 3> asVec3b(cv::Vec<unsigned short, 3>)

asVec3b( (Vec3i)inst_Vec3i) -> Vec3b :

    C++ signature :
        cv::Vec<unsigned char, 3> asVec3b(cv::Vec<int, 3>)

asVec3b( (Vec3f)inst_Vec3f) -> Vec3b :

    C++ signature :
        cv::Vec<unsigned char, 3> asVec3b(cv::Vec<float, 3>)

asVec3b( (Vec3d)inst_Vec3d) -> Vec3b :

    C++ signature :
        cv::Vec<unsigned char, 3> asVec3b(cv::Vec<double, 3>)

asVec3b( (object)arr) -> object :

    C++ signature :
        boost::python::api::object asVec3b(boost::python::ndarray)

asVec3d(...)


asVec3d( (Vec3b)inst_Vec3b) -> Vec3d :

    C++ signature :
        cv::Vec<double, 3> asVec3d(cv::Vec<unsigned char, 3>)

asVec3d( (Vec3s)inst_Vec3s) -> Vec3d :

    C++ signature :
        cv::Vec<double, 3> asVec3d(cv::Vec<short, 3>)

asVec3d( (Vec3w)inst_Vec3w) -> Vec3d :

    C++ signature :
        cv::Vec<double, 3> asVec3d(cv::Vec<unsigned short, 3>)

asVec3d( (Vec3i)inst_Vec3i) -> Vec3d :

    C++ signature :
        cv::Vec<double, 3> asVec3d(cv::Vec<int, 3>)

asVec3d( (Vec3f)inst_Vec3f) -> Vec3d :

    C++ signature :
        cv::Vec<double, 3> asVec3d(cv::Vec<float, 3>)

asVec3d( (object)arr) -> object :

    C++ signature :
        boost::python::api::object asVec3d(boost::python::ndarray)

asVec3f(...)


asVec3f( (Vec3b)inst_Vec3b) -> Vec3f :

    C++ signature :
        cv::Vec<float, 3> asVec3f(cv::Vec<unsigned char, 3>)

asVec3f( (Vec3s)inst_Vec3s) -> Vec3f :

    C++ signature :
        cv::Vec<float, 3> asVec3f(cv::Vec<short, 3>)

asVec3f( (Vec3w)inst_Vec3w) -> Vec3f :

    C++ signature :
        cv::Vec<float, 3> asVec3f(cv::Vec<unsigned short, 3>)

asVec3f( (Vec3i)inst_Vec3i) -> Vec3f :

    C++ signature :
        cv::Vec<float, 3> asVec3f(cv::Vec<int, 3>)

asVec3f( (Vec3d)inst_Vec3d) -> Vec3f :

    C++ signature :
        cv::Vec<float, 3> asVec3f(cv::Vec<double, 3>)

asVec3f( (object)arr) -> object :

    C++ signature :
        boost::python::api::object asVec3f(boost::python::ndarray)

asVec3i(...)


asVec3i( (Vec3b)inst_Vec3b) -> Vec3i :

    C++ signature :
        cv::Vec<int, 3> asVec3i(cv::Vec<unsigned char, 3>)

asVec3i( (Vec3s)inst_Vec3s) -> Vec3i :

    C++ signature :
        cv::Vec<int, 3> asVec3i(cv::Vec<short, 3>)

asVec3i( (Vec3w)inst_Vec3w) -> Vec3i :

    C++ signature :
        cv::Vec<int, 3> asVec3i(cv::Vec<unsigned short, 3>)

asVec3i( (Vec3f)inst_Vec3f) -> Vec3i :

    C++ signature :
        cv::Vec<int, 3> asVec3i(cv::Vec<float, 3>)

asVec3i( (Vec3d)inst_Vec3d) -> Vec3i :

    C++ signature :
        cv::Vec<int, 3> asVec3i(cv::Vec<double, 3>)

asVec3i( (object)arr) -> object :

    C++ signature :
        boost::python::api::object asVec3i(boost::python::ndarray)

asVec3s(...)


asVec3s( (Vec3b)inst_Vec3b) -> Vec3s :

    C++ signature :
        cv::Vec<short, 3> asVec3s(cv::Vec<unsigned char, 3>)

asVec3s( (Vec3w)inst_Vec3w) -> Vec3s :

    C++ signature :
        cv::Vec<short, 3> asVec3s(cv::Vec<unsigned short, 3>)

asVec3s( (Vec3i)inst_Vec3i) -> Vec3s :

    C++ signature :
        cv::Vec<short, 3> asVec3s(cv::Vec<int, 3>)

asVec3s( (Vec3f)inst_Vec3f) -> Vec3s :

    C++ signature :
        cv::Vec<short, 3> asVec3s(cv::Vec<float, 3>)

asVec3s( (Vec3d)inst_Vec3d) -> Vec3s :

    C++ signature :
        cv::Vec<short, 3> asVec3s(cv::Vec<double, 3>)

asVec3s( (object)arr) -> object :

    C++ signature :
        boost::python::api::object asVec3s(boost::python::ndarray)

asVec3w(...)


asVec3w( (Vec3b)inst_Vec3b) -> Vec3w :

    C++ signature :
        cv::Vec<unsigned short, 3> asVec3w(cv::Vec<unsigned char, 3>)

asVec3w( (Vec3s)inst_Vec3s) -> Vec3w :

    C++ signature :
        cv::Vec<unsigned short, 3> asVec3w(cv::Vec<short, 3>)

asVec3w( (Vec3i)inst_Vec3i) -> Vec3w :

    C++ signature :
        cv::Vec<unsigned short, 3> asVec3w(cv::Vec<int, 3>)

asVec3w( (Vec3f)inst_Vec3f) -> Vec3w :

    C++ signature :
        cv::Vec<unsigned short, 3> asVec3w(cv::Vec<float, 3>)

asVec3w( (Vec3d)inst_Vec3d) -> Vec3w :

    C++ signature :
        cv::Vec<unsigned short, 3> asVec3w(cv::Vec<double, 3>)

asVec3w( (object)arr) -> object :

    C++ signature :
        boost::python::api::object asVec3w(boost::python::ndarray)

asVec4b(...)


asVec4b( (Vec4s)inst_Vec4s) -> Vec4b :

    C++ signature :
        cv::Vec<unsigned char, 4> asVec4b(cv::Vec<short, 4>)

asVec4b( (Vec4w)inst_Vec4w) -> Vec4b :

    C++ signature :
        cv::Vec<unsigned char, 4> asVec4b(cv::Vec<unsigned short, 4>)

asVec4b( (Vec4i)inst_Vec4i) -> Vec4b :

    C++ signature :
        cv::Vec<unsigned char, 4> asVec4b(cv::Vec<int, 4>)

asVec4b( (Vec4f)inst_Vec4f) -> Vec4b :

    C++ signature :
        cv::Vec<unsigned char, 4> asVec4b(cv::Vec<float, 4>)

asVec4b( (Vec4d)inst_Vec4d) -> Vec4b :

    C++ signature :
        cv::Vec<unsigned char, 4> asVec4b(cv::Vec<double, 4>)

asVec4b( (object)arr) -> object :

    C++ signature :
        boost::python::api::object asVec4b(boost::python::ndarray)

asVec4d(...)


asVec4d( (Vec4b)inst_Vec4b) -> Vec4d :

    C++ signature :
        cv::Vec<double, 4> asVec4d(cv::Vec<unsigned char, 4>)

asVec4d( (Vec4s)inst_Vec4s) -> Vec4d :

    C++ signature :
        cv::Vec<double, 4> asVec4d(cv::Vec<short, 4>)

asVec4d( (Vec4w)inst_Vec4w) -> Vec4d :

    C++ signature :
        cv::Vec<double, 4> asVec4d(cv::Vec<unsigned short, 4>)

asVec4d( (Vec4i)inst_Vec4i) -> Vec4d :

    C++ signature :
        cv::Vec<double, 4> asVec4d(cv::Vec<int, 4>)

asVec4d( (Vec4f)inst_Vec4f) -> Vec4d :

    C++ signature :
        cv::Vec<double, 4> asVec4d(cv::Vec<float, 4>)

asVec4d( (object)arr) -> object :

    C++ signature :
        boost::python::api::object asVec4d(boost::python::ndarray)

asVec4f(...)


asVec4f( (Vec4b)inst_Vec4b) -> Vec4f :

    C++ signature :
        cv::Vec<float, 4> asVec4f(cv::Vec<unsigned char, 4>)

asVec4f( (Vec4s)inst_Vec4s) -> Vec4f :

    C++ signature :
        cv::Vec<float, 4> asVec4f(cv::Vec<short, 4>)

asVec4f( (Vec4w)inst_Vec4w) -> Vec4f :

    C++ signature :
        cv::Vec<float, 4> asVec4f(cv::Vec<unsigned short, 4>)

asVec4f( (Vec4i)inst_Vec4i) -> Vec4f :

    C++ signature :
        cv::Vec<float, 4> asVec4f(cv::Vec<int, 4>)

asVec4f( (Vec4d)inst_Vec4d) -> Vec4f :

    C++ signature :
        cv::Vec<float, 4> asVec4f(cv::Vec<double, 4>)

asVec4f( (object)arr) -> object :

    C++ signature :
        boost::python::api::object asVec4f(boost::python::ndarray)

asVec4i(...)


asVec4i( (Vec4b)inst_Vec4b) -> Vec4i :

    C++ signature :
        cv::Vec<int, 4> asVec4i(cv::Vec<unsigned char, 4>)

asVec4i( (Vec4s)inst_Vec4s) -> Vec4i :

    C++ signature :
        cv::Vec<int, 4> asVec4i(cv::Vec<short, 4>)

asVec4i( (Vec4w)inst_Vec4w) -> Vec4i :

    C++ signature :
        cv::Vec<int, 4> asVec4i(cv::Vec<unsigned short, 4>)

asVec4i( (Vec4f)inst_Vec4f) -> Vec4i :

    C++ signature :
        cv::Vec<int, 4> asVec4i(cv::Vec<float, 4>)

asVec4i( (Vec4d)inst_Vec4d) -> Vec4i :

    C++ signature :
        cv::Vec<int, 4> asVec4i(cv::Vec<double, 4>)

asVec4i( (object)arr) -> object :

    C++ signature :
        boost::python::api::object asVec4i(boost::python::ndarray)

asVec4s(...)


asVec4s( (Vec4b)inst_Vec4b) -> Vec4s :

    C++ signature :
        cv::Vec<short, 4> asVec4s(cv::Vec<unsigned char, 4>)

asVec4s( (Vec4w)inst_Vec4w) -> Vec4s :

    C++ signature :
        cv::Vec<short, 4> asVec4s(cv::Vec<unsigned short, 4>)

asVec4s( (Vec4i)inst_Vec4i) -> Vec4s :

    C++ signature :
        cv::Vec<short, 4> asVec4s(cv::Vec<int, 4>)

asVec4s( (Vec4f)inst_Vec4f) -> Vec4s :

    C++ signature :
        cv::Vec<short, 4> asVec4s(cv::Vec<float, 4>)

asVec4s( (Vec4d)inst_Vec4d) -> Vec4s :

    C++ signature :
        cv::Vec<short, 4> asVec4s(cv::Vec<double, 4>)

asVec4s( (object)arr) -> object :

    C++ signature :
        boost::python::api::object asVec4s(boost::python::ndarray)

asVec4w(...)


asVec4w( (Vec4b)inst_Vec4b) -> Vec4w :

    C++ signature :
        cv::Vec<unsigned short, 4> asVec4w(cv::Vec<unsigned char, 4>)

asVec4w( (Vec4s)inst_Vec4s) -> Vec4w :

    C++ signature :
        cv::Vec<unsigned short, 4> asVec4w(cv::Vec<short, 4>)

asVec4w( (Vec4i)inst_Vec4i) -> Vec4w :

    C++ signature :
        cv::Vec<unsigned short, 4> asVec4w(cv::Vec<int, 4>)

asVec4w( (Vec4f)inst_Vec4f) -> Vec4w :

    C++ signature :
        cv::Vec<unsigned short, 4> asVec4w(cv::Vec<float, 4>)

asVec4w( (Vec4d)inst_Vec4d) -> Vec4w :

    C++ signature :
        cv::Vec<unsigned short, 4> asVec4w(cv::Vec<double, 4>)

asVec4w( (object)arr) -> object :

    C++ signature :
        boost::python::api::object asVec4w(boost::python::ndarray)

asVec6d(...)


asVec6d( (Vec6f)inst_Vec6f) -> Vec6d :

    C++ signature :
        cv::Vec<double, 6> asVec6d(cv::Vec<float, 6>)

asVec6d( (object)arr) -> object :

    C++ signature :
        boost::python::api::object asVec6d(boost::python::ndarray)

asVec6f(...)


asVec6f( (Vec6d)inst_Vec6d) -> Vec6f :

    C++ signature :
        cv::Vec<float, 6> asVec6f(cv::Vec<double, 6>)

asVec6f( (object)arr) -> object :

    C++ signature :
        boost::python::api::object asVec6f(boost::python::ndarray)

attrValue(...)


attrValue( (CvAttrList)attr, (str)attr_name) -> str :
    
    Wrapped function:
        cvAttrValue

    C++ signature :
        char const* attrValue(CvAttrList const*,char const*)

bilateralFilter(...)


bilateralFilter( (Mat)src, (Mat)dst, (object)d, (object)sigmaColor, (object)sigmaSpace [, (object)borderType=4]) -> None :

    C++ signature :
        void bilateralFilter(cv::Mat,cv::Mat {lvalue},int,double,double [,int=4])

bitwise_and(...)


bitwise_and( (MatND)a, (Scalar)s, (MatND)c [, (MatND)mask=MatND(shape=(), nchannels=1, depth=0):
array(0, dtype=uint8)]) -> None :
    
    Calculates per-element bit-wise conjunction of two arrays and an 
    array and a scalar.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#cv-bitwise-and

    C++ signature :
        void bitwise_and(cv::MatND,cv::Scalar_<double>,cv::MatND {lvalue} [,cv::MatND=MatND(shape=(), nchannels=1, depth=0):
array(0, dtype=uint8)])

bitwise_and( (MatND)a, (MatND)b, (MatND)c [, (MatND)mask=MatND(shape=(), nchannels=1, depth=0):
array(0, dtype=uint8)]) -> None :
    
    Calculates per-element bit-wise conjunction of two arrays and an 
    array and a scalar.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#cv-bitwise-and

    C++ signature :
        void bitwise_and(cv::MatND,cv::MatND,cv::MatND {lvalue} [,cv::MatND=MatND(shape=(), nchannels=1, depth=0):
array(0, dtype=uint8)])

bitwise_and( (Mat)a, (Scalar)s, (Mat)c [, (Mat)mask=Mat()]) -> None :
    
    Calculates per-element bit-wise conjunction of two arrays and an 
    array and a scalar.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#cv-bitwise-and

    C++ signature :
        void bitwise_and(cv::Mat,cv::Scalar_<double>,cv::Mat {lvalue} [,cv::Mat=Mat()])

bitwise_and( (Mat)a, (Mat)b, (Mat)c [, (Mat)mask=Mat()]) -> None :
    
    Calculates per-element bit-wise conjunction of two arrays and an 
    array and a scalar.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#cv-bitwise-and

    C++ signature :
        void bitwise_and(cv::Mat,cv::Mat,cv::Mat {lvalue} [,cv::Mat=Mat()])

bitwise_not(...)


bitwise_not( (MatND)a, (MatND)c) -> None :
    
    Inverts every bit of array.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#cv-bitwise-not

    C++ signature :
        void bitwise_not(cv::MatND,cv::MatND {lvalue})

bitwise_not( (Mat)a, (Mat)c) -> None :
    
    Inverts every bit of array.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#cv-bitwise-not

    C++ signature :
        void bitwise_not(cv::Mat,cv::Mat {lvalue})

bitwise_or(...)


bitwise_or( (MatND)a, (Scalar)s, (MatND)c [, (MatND)mask=MatND(shape=(), nchannels=1, depth=0):
array(0, dtype=uint8)]) -> None :
    
    Calculates per-element bit-wise disjunction of two arrays and an 
    array and a scalar.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#cv-bitwise-or

    C++ signature :
        void bitwise_or(cv::MatND,cv::Scalar_<double>,cv::MatND {lvalue} [,cv::MatND=MatND(shape=(), nchannels=1, depth=0):
array(0, dtype=uint8)])

bitwise_or( (MatND)a, (MatND)b, (MatND)c [, (MatND)mask=MatND(shape=(), nchannels=1, depth=0):
array(0, dtype=uint8)]) -> None :
    
    Calculates per-element bit-wise disjunction of two arrays and an 
    array and a scalar.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#cv-bitwise-or

    C++ signature :
        void bitwise_or(cv::MatND,cv::MatND,cv::MatND {lvalue} [,cv::MatND=MatND(shape=(), nchannels=1, depth=0):
array(0, dtype=uint8)])

bitwise_or( (Mat)a, (Scalar)s, (Mat)c [, (Mat)mask=Mat()]) -> None :
    
    Calculates per-element bit-wise disjunction of two arrays and an 
    array and a scalar.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#cv-bitwise-or

    C++ signature :
        void bitwise_or(cv::Mat,cv::Scalar_<double>,cv::Mat {lvalue} [,cv::Mat=Mat()])

bitwise_or( (Mat)a, (Mat)b, (Mat)c [, (Mat)mask=Mat()]) -> None :
    
    Calculates per-element bit-wise disjunction of two arrays and an 
    array and a scalar.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#cv-bitwise-or

    C++ signature :
        void bitwise_or(cv::Mat,cv::Mat,cv::Mat {lvalue} [,cv::Mat=Mat()])

bitwise_xor(...)


bitwise_xor( (MatND)a, (Scalar)s, (MatND)c [, (MatND)mask=MatND(shape=(), nchannels=1, depth=0):
array(0, dtype=uint8)]) -> None :
    
    Calculates per-element bit-wise 'exclusive or' operation on two 
    arrays and an array and a scalar.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#cv-bitwise-xor

    C++ signature :
        void bitwise_xor(cv::MatND,cv::Scalar_<double>,cv::MatND {lvalue} [,cv::MatND=MatND(shape=(), nchannels=1, depth=0):
array(0, dtype=uint8)])

bitwise_xor( (MatND)a, (MatND)b, (MatND)c [, (MatND)mask=MatND(shape=(), nchannels=1, depth=0):
array(0, dtype=uint8)]) -> None :
    
    Calculates per-element bit-wise 'exclusive or' operation on two 
    arrays and an array and a scalar.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#cv-bitwise-xor

    C++ signature :
        void bitwise_xor(cv::MatND,cv::MatND,cv::MatND {lvalue} [,cv::MatND=MatND(shape=(), nchannels=1, depth=0):
array(0, dtype=uint8)])

bitwise_xor( (Mat)a, (Scalar)s, (Mat)c [, (Mat)mask=Mat()]) -> None :
    
    Calculates per-element bit-wise 'exclusive or' operation on two 
    arrays and an array and a scalar.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#cv-bitwise-xor

    C++ signature :
        void bitwise_xor(cv::Mat,cv::Scalar_<double>,cv::Mat {lvalue} [,cv::Mat=Mat()])

bitwise_xor( (Mat)a, (Mat)b, (Mat)c [, (Mat)mask=Mat()]) -> None :
    
    Calculates per-element bit-wise 'exclusive or' operation on two 
    arrays and an array and a scalar.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#cv-bitwise-xor

    C++ signature :
        void bitwise_xor(cv::Mat,cv::Mat,cv::Mat {lvalue} [,cv::Mat=Mat()])

blob(...)


blob( (object)x, (object)y, (object)w, (object)h) -> CvBlob :
    
    Wrapped function:
        cvBlob

    C++ signature :
        CvBlob blob(float,float,float,float)

blur(...)


blur( (Mat)src, (Mat)dst, (Size2i)ksize [, (Point2i)anchor=Point2i(x=-1, y=-1) [, (object)borderType=4]]) -> None :

    C++ signature :
        void blur(cv::Mat,cv::Mat {lvalue},cv::Size_<int> [,cv::Point_<int>=Point2i(x=-1, y=-1) [,int=4]])

borderInterpolate(...)


borderInterpolate( (object)p, (object)len, (object)borderType) -> int :

    C++ signature :
        int borderInterpolate(int,int,int)

boundingRect(...)


boundingRect( (Mat)points) -> Rect :

    C++ signature :
        cv::Rect_<int> boundingRect(cv::Mat)

boxFilter(...)


boxFilter( (Mat)src, (Mat)dst, (object)ddepth, (Size2i)ksize [, (Point2i)anchor=Point2i(x=-1, y=-1) [, (bool)normalize=True [, (object)borderType=4]]]) -> None :

    C++ signature :
        void boxFilter(cv::Mat,cv::Mat {lvalue},int,cv::Size_<int> [,cv::Point_<int>=Point2i(x=-1, y=-1) [,bool=True [,int=4]]])

boxPoints(...)


boxPoints( (object)box, (object)pt) -> None :
    
    Wrapped function:
        cvBoxPoints

    C++ signature :
        void boxPoints(CvBox2D,CvPoint2D32f*)

buildPyramid(...)


buildPyramid( (Mat)src, (list)dst, (object)maxlevel) -> None :
    
    Argument 'dst':
        C/C++ type: ::std::vector< cv::Mat > &.
        Python type: list.
        To convert a Mat into a list, invoke one of Mat's member functions 
        to_list_of_...().

    C++ signature :
        void buildPyramid(cv::Mat,boost::python::list {lvalue},int)

calcAffineFlowPyrLK(...)


calcAffineFlowPyrLK( (Mat)prev, (Mat)curr, (Mat)prev_pyr, (Mat)curr_pyr, (Mat)prev_features, (CvSize)win_size, (object)level, (object)criteria, (object)flags) -> tuple :
    
    Wrapped function:
        cvCalcAffineFlowPyrLK
    Argument 'count':
        Dependent argument: omitted from the function's calling sequence, as 
        its value is derived from argument 'prev_features'.
    Argument 'status':
        Output argument: omitted from the function's calling sequence, and is 
        returned along with the function's return value (if any).
    Argument 'prev':
        C/C++ type: ::CvArr const *.
        Python type: Mat.
    Argument 'curr':
        C/C++ type: ::CvArr const *.
        Python type: Mat.
    Argument 'track_error':
        Output argument: omitted from the function's calling sequence, and is 
        returned along with the function's return value (if any).
    Argument 'prev_pyr':
        C/C++ type: ::CvArr *.
        Python type: Mat.
    Argument 'curr_pyr':
        C/C++ type: ::CvArr *.
        Python type: Mat.
    Argument 'prev_features':
        C/C++ type: ::CvPoint2D32f const *.
        Python type: Mat.
        Invoke asMat() to convert a 1D Python sequence into a Mat, e.g. 
        asMat([0,1,2]) or asMat((0,1,2)).
    Argument 'curr_features':
        Output argument: omitted from the function's calling sequence, and is 
        returned along with the function's return value (if any).
    Argument 'matrices':
        Output argument: omitted from the function's calling sequence, and is 
        returned along with the function's return value (if any).

    C++ signature :
        boost::python::tuple calcAffineFlowPyrLK(cv::Mat {lvalue},cv::Mat {lvalue},cv::Mat {lvalue},cv::Mat {lvalue},cv::Mat,CvSize,int,CvTermCriteria,int)

calcBackProject(...)


calcBackProject( (object)images, (Mat)channels, (SparseMat)hist, (Mat)backProject, (object)ranges [, (object)scale=1 [, (bool)uniform=True]]) -> None :
    
    Argument 'images':
        C/C++ type: ::cv::Mat const *.
        Python type: list of MatND, e.g. [MatND(), MatND(), MatND()].
    Argument 'channels':
        C/C++ type: int const *.
        Python type: Mat.
        Invoke asMat() to convert a 1D Python sequence into a Mat, e.g. 
        asMat([0,1,2]) or asMat((0,1,2)).
    Argument 'nimages':
        Dependent argument: omitted from the function's calling sequence, as 
        its value is derived from argument 'images'.
    Argument 'ranges':
        C/C++ type: float const * *.
        Python type: 2d list.
        Depending on its C++ argument type, it should be a list of Mats or a 
        list of lists.

    C++ signature :
        void calcBackProject(boost::python::sequence,cv::Mat,cv::SparseMat,cv::Mat {lvalue},boost::python::api::object [,double=1 [,bool=True]])

calcBackProject( (object)images, (Mat)channels, (MatND)hist, (Mat)backProject, (object)ranges [, (object)scale=1 [, (bool)uniform=True]]) -> None :
    
    Argument 'images':
        C/C++ type: ::cv::Mat const *.
        Python type: list of MatND, e.g. [MatND(), MatND(), MatND()].
    Argument 'channels':
        C/C++ type: int const *.
        Python type: Mat.
        Invoke asMat() to convert a 1D Python sequence into a Mat, e.g. 
        asMat([0,1,2]) or asMat((0,1,2)).
    Argument 'nimages':
        Dependent argument: omitted from the function's calling sequence, as 
        its value is derived from argument 'images'.
    Argument 'ranges':
        C/C++ type: float const * *.
        Python type: 2d list.
        Depending on its C++ argument type, it should be a list of Mats or a 
        list of lists.

    C++ signature :
        void calcBackProject(boost::python::sequence,cv::Mat,cv::MatND,cv::Mat {lvalue},boost::python::api::object [,double=1 [,bool=True]])

calcCovarMatrix(...)


calcCovarMatrix( (list)samples, (Mat)covar, (Mat)mean, (object)flags [, (object)ctype=6]) -> None :
    
    Calculates covariation matrix of a set of vectors.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#calccovarmatrix
    Argument 'nsamples':
        Dependent argument: omitted from the function's calling sequence, as 
        its value is derived from argument 'samples'.
    Argument 'samples':
        C/C++ type: ::cv::Mat const *.
        Python type: list of Mat, e.g. [Mat(), Mat(), Mat()].

    C++ signature :
        void calcCovarMatrix(boost::python::list,cv::Mat {lvalue},cv::Mat {lvalue},int [,int=6])

calcCovarMatrix( (Mat)samples, (Mat)covar, (Mat)mean, (object)flags [, (object)ctype=6]) -> None :
    
    Calculates covariation matrix of a set of vectors.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#calccovarmatrix

    C++ signature :
        void calcCovarMatrix(cv::Mat,cv::Mat {lvalue},cv::Mat {lvalue},int [,int=6])

calcEMD2(...)



calcEMD2( (Mat)signature1, (Mat)signature2, (object)distance_type [, (object)distance_func=None [, (Mat)cost_matrix=Mat() [, (Mat)flow=Mat() [, (object)lower_bound=None [, (object)userdata=None]]]]]) -> object :
    
    Wrapped function:
        cvCalcEMD2
    Argument 'signature1':
        C/C++ type: ::CvArr const *.
        Python type: Mat.
    Argument 'signature2':
        C/C++ type: ::CvArr const *.
        Python type: Mat.
    Argument 'flow':
        C/C++ type: ::CvArr *.
        Python type: Mat.
    Argument 'cost_matrix':
        C/C++ type: ::CvArr const *.
        Python type: Mat.

    C++ signature :
        boost::python::api::object calcEMD2(cv::Mat {lvalue},cv::Mat {lvalue},int [,boost::python::api::object=None [,cv::Mat=Mat() [,cv::Mat=Mat() [,float*=None [,boost::python::api::object=None]]]]])
    'distance_func' is a Python function declared as follows:
        def distance_func((int)a, (int)b, (object)userdata) -> (float)x
    where
        'a' : the address of a C array of C floats representing the first vector
        'b' : the address of a C array of C floats representing the second vector
        'userdata' : the 'userdata' parameter of cvCalcEMD2()
        'x' : the resultant distance

calcGlobalOrientation(...)


calcGlobalOrientation( (Mat)orientation, (Mat)mask, (Mat)mhi, (object)timestamp, (object)duration) -> object :
    
    Wrapped function:
        cvCalcGlobalOrientation
    Argument 'mask':
        C/C++ type: ::CvArr const *.
        Python type: Mat.
    Argument 'orientation':
        C/C++ type: ::CvArr const *.
        Python type: Mat.
    Argument 'mhi':
        C/C++ type: ::CvArr const *.
        Python type: Mat.

    C++ signature :
        boost::python::api::object calcGlobalOrientation(cv::Mat {lvalue},cv::Mat {lvalue},cv::Mat {lvalue},double,double)

calcGlobalOrientation( (Mat)orientation, (Mat)mask, (Mat)mhi, (object)timestamp, (object)duration) -> float :

    C++ signature :
        double calcGlobalOrientation(cv::Mat,cv::Mat,cv::Mat,double,double)

calcHist(...)


calcHist( (object)images, (Mat)channels, (Mat)mask, (SparseMat)hist, (Mat)histSize, (object)ranges [, (bool)uniform=True [, (bool)accumulate=False]]) -> None :
    
    Argument 'ranges':
        C/C++ type: float const * *.
        Python type: 2d list.
        Depending on its C++ argument type, it should be a list of Mats or a 
        list of lists.
    Argument 'histSize':
        C/C++ type: int const *.
        Python type: Mat.
        Invoke asMat() to convert a 1D Python sequence into a Mat, e.g. 
        asMat([0,1,2]) or asMat((0,1,2)).
    Argument 'channels':
        C/C++ type: int const *.
        Python type: Mat.
        Invoke asMat() to convert a 1D Python sequence into a Mat, e.g. 
        asMat([0,1,2]) or asMat((0,1,2)).
    Argument 'dims':
        Dependent argument: omitted from the function's calling sequence, as 
        its value is derived from argument 'histSize'.
    Argument 'images':
        C/C++ type: ::cv::Mat const *.
        Python type: list of MatND, e.g. [MatND(), MatND(), MatND()].
    Argument 'nimages':
        Dependent argument: omitted from the function's calling sequence, as 
        its value is derived from argument 'images'.

    C++ signature :
        void calcHist(boost::python::sequence,cv::Mat,cv::Mat,cv::SparseMat {lvalue},cv::Mat,boost::python::api::object [,bool=True [,bool=False]])

calcHist( (object)images, (Mat)channels, (Mat)mask, (MatND)hist, (Mat)histSize, (object)ranges [, (bool)uniform=True [, (bool)accumulate=False]]) -> None :
    
    Argument 'ranges':
        C/C++ type: float const * *.
        Python type: 2d list.
        Depending on its C++ argument type, it should be a list of Mats or a 
        list of lists.
    Argument 'histSize':
        C/C++ type: int const *.
        Python type: Mat.
        Invoke asMat() to convert a 1D Python sequence into a Mat, e.g. 
        asMat([0,1,2]) or asMat((0,1,2)).
    Argument 'channels':
        C/C++ type: int const *.
        Python type: Mat.
        Invoke asMat() to convert a 1D Python sequence into a Mat, e.g. 
        asMat([0,1,2]) or asMat((0,1,2)).
    Argument 'dims':
        Dependent argument: omitted from the function's calling sequence, as 
        its value is derived from argument 'histSize'.
    Argument 'images':
        C/C++ type: ::cv::Mat const *.
        Python type: list of MatND, e.g. [MatND(), MatND(), MatND()].
    Argument 'nimages':
        Dependent argument: omitted from the function's calling sequence, as 
        its value is derived from argument 'images'.

    C++ signature :
        void calcHist(boost::python::sequence,cv::Mat,cv::Mat,cv::MatND {lvalue},cv::Mat,boost::python::api::object [,bool=True [,bool=False]])

calcImageHomography(...)


calcImageHomography( (object)line, (object)center, (object)intrinsic) -> object :
    
    Wrapped function:
        cvCalcImageHomography

    C++ signature :
        boost::python::api::object calcImageHomography(boost::python::api::object,CvPoint3D32f*,boost::python::api::object)

calcMotionGradient(...)


calcMotionGradient( (Mat)mhi, (Mat)mask, (Mat)orientation, (object)delta1, (object)delta2 [, (object)aperture_size=3]) -> None :
    
    Wrapped function:
        cvCalcMotionGradient
    Argument 'mask':
        C/C++ type: ::CvArr *.
        Python type: Mat.
    Argument 'orientation':
        C/C++ type: ::CvArr *.
        Python type: Mat.
    Argument 'mhi':
        C/C++ type: ::CvArr const *.
        Python type: Mat.

    C++ signature :
        void calcMotionGradient(cv::Mat {lvalue},cv::Mat {lvalue},cv::Mat {lvalue},double,double [,int=3])

calcMotionGradient( (Mat)mhi, (Mat)mask, (Mat)orientation, (object)delta1, (object)delta2 [, (object)apertureSize=3]) -> None :

    C++ signature :
        void calcMotionGradient(cv::Mat,cv::Mat {lvalue},cv::Mat {lvalue},double,double [,int=3])

calcOpticalFlowBM(...)


calcOpticalFlowBM( (Mat)prev, (Mat)curr, (CvSize)block_size, (CvSize)shift_size, (CvSize)max_range, (object)use_previous, (Mat)velx, (Mat)vely) -> None :
    
    Wrapped function:
        cvCalcOpticalFlowBM
    Argument 'prev':
        C/C++ type: ::CvArr const *.
        Python type: Mat.
    Argument 'curr':
        C/C++ type: ::CvArr const *.
        Python type: Mat.
    Argument 'vely':
        C/C++ type: ::CvArr *.
        Python type: Mat.
    Argument 'velx':
        C/C++ type: ::CvArr *.
        Python type: Mat.

    C++ signature :
        void calcOpticalFlowBM(cv::Mat {lvalue},cv::Mat {lvalue},CvSize,CvSize,CvSize,int,cv::Mat {lvalue},cv::Mat {lvalue})

calcOpticalFlowFarneback(...)


calcOpticalFlowFarneback( (Mat)prev, (Mat)next, (Mat)flow, (object)pyr_scale, (object)levels, (object)winsize, (object)iterations, (object)poly_n, (object)poly_sigma, (object)flags) -> None :
    
    Wrapped function:
        cvCalcOpticalFlowFarneback
    Argument 'prev':
        C/C++ type: ::CvArr const *.
        Python type: Mat.
    Argument 'flow':
        C/C++ type: ::CvArr *.
        Python type: Mat.
    Argument 'next':
        C/C++ type: ::CvArr const *.
        Python type: Mat.

    C++ signature :
        void calcOpticalFlowFarneback(cv::Mat {lvalue},cv::Mat {lvalue},cv::Mat {lvalue},double,int,int,int,int,double,int)

calcOpticalFlowFarneback( (Mat)prev0, (Mat)next0, (Mat)flow0, (object)pyr_scale, (object)levels, (object)winsize, (object)iterations, (object)poly_n, (object)poly_sigma, (object)flags) -> None :

    C++ signature :
        void calcOpticalFlowFarneback(cv::Mat,cv::Mat,cv::Mat {lvalue},double,int,int,int,int,double,int)

calcOpticalFlowHS(...)


calcOpticalFlowHS( (Mat)prev, (Mat)curr, (object)use_previous, (Mat)velx, (Mat)vely, (object)lambda, (object)criteria) -> None :
    
    Wrapped function:
        cvCalcOpticalFlowHS
    Argument 'prev':
        C/C++ type: ::CvArr const *.
        Python type: Mat.
    Argument 'curr':
        C/C++ type: ::CvArr const *.
        Python type: Mat.
    Argument 'vely':
        C/C++ type: ::CvArr *.
        Python type: Mat.
    Argument 'velx':
        C/C++ type: ::CvArr *.
        Python type: Mat.

    C++ signature :
        void calcOpticalFlowHS(cv::Mat {lvalue},cv::Mat {lvalue},int,cv::Mat {lvalue},cv::Mat {lvalue},double,CvTermCriteria)

calcOpticalFlowLK(...)


calcOpticalFlowLK( (Mat)prev, (Mat)curr, (CvSize)win_size, (Mat)velx, (Mat)vely) -> None :
    
    Wrapped function:
        cvCalcOpticalFlowLK
    Argument 'prev':
        C/C++ type: ::CvArr const *.
        Python type: Mat.
    Argument 'curr':
        C/C++ type: ::CvArr const *.
        Python type: Mat.
    Argument 'vely':
        C/C++ type: ::CvArr *.
        Python type: Mat.
    Argument 'velx':
        C/C++ type: ::CvArr *.
        Python type: Mat.

    C++ signature :
        void calcOpticalFlowLK(cv::Mat {lvalue},cv::Mat {lvalue},CvSize,cv::Mat {lvalue},cv::Mat {lvalue})

calcOpticalFlowPyrLK(...)


calcOpticalFlowPyrLK( (Mat)prevImg, (Mat)nextImg, (Mat)prevPts, (Mat)nextPts, (Mat)status, (Mat)err [, (Size2i)winSize=Size2i(width=15, height=15) [, (object)maxLevel=3 [, (TermCriteria)criteria=TermCriteria(type=3, maxCount=30, epsilon=0.01) [, (object)derivLambda=0.5 [, (object)flags=0]]]]]) -> None :
    
    Argument 'status':
        C/C++ type: ::std::vector< unsigned char > &.
        Python type: Mat.
        Invoke asMat() to convert a 1D Python sequence into a Mat, e.g. 
        asMat([0,1,2]) or asMat((0,1,2)).
    Argument 'nextPts':
        C/C++ type: ::std::vector< cv::Point_<float> > &.
        Python type: Mat.
        Invoke asMat() to convert a 1D Python sequence into a Mat, e.g. 
        asMat([0,1,2]) or asMat((0,1,2)).
    Argument 'prevPts':
        C/C++ type: ::std::vector< cv::Point_<float> > const &.
        Python type: Mat.
        Invoke asMat() to convert a 1D Python sequence into a Mat, e.g. 
        asMat([0,1,2]) or asMat((0,1,2)).
    Argument 'err':
        C/C++ type: ::std::vector< float > &.
        Python type: Mat.
        Invoke asMat() to convert a 1D Python sequence into a Mat, e.g. 
        asMat([0,1,2]) or asMat((0,1,2)).

    C++ signature :
        void calcOpticalFlowPyrLK(cv::Mat,cv::Mat,cv::Mat,cv::Mat {lvalue},cv::Mat {lvalue},cv::Mat {lvalue} [,cv::Size_<int>=Size2i(width=15, height=15) [,int=3 [,cv::TermCriteria=TermCriteria(type=3, maxCount=30, epsilon=0.01) [,double=0.5 [,int=0]]]]])

calcOpticalFlowPyrLK( (Mat)prev, (Mat)curr, (Mat)prev_pyr, (Mat)curr_pyr, (Mat)prev_features, (CvSize)win_size, (object)level, (object)criteria, (object)flags) -> tuple :
    
    Wrapped function:
        cvCalcOpticalFlowPyrLK
    Argument 'count':
        Dependent argument: omitted from the function's calling sequence, as 
        its value is derived from argument 'prev_features'.
    Argument 'status':
        Output argument: omitted from the function's calling sequence, and is 
        returned along with the function's return value (if any).
    Argument 'prev':
        C/C++ type: ::CvArr const *.
        Python type: Mat.
    Argument 'curr':
        C/C++ type: ::CvArr const *.
        Python type: Mat.
    Argument 'track_error':
        Output argument: omitted from the function's calling sequence, and is 
        returned along with the function's return value (if any).
    Argument 'prev_pyr':
        C/C++ type: ::CvArr *.
        Python type: Mat.
    Argument 'prev_features':
        C/C++ type: ::CvPoint2D32f const *.
        Python type: Mat.
        Invoke asMat() to convert a 1D Python sequence into a Mat, e.g. 
        asMat([0,1,2]) or asMat((0,1,2)).
    Argument 'curr_features':
        Output argument: omitted from the function's calling sequence, and is 
        returned along with the function's return value (if any).
    Argument 'curr_pyr':
        C/C++ type: ::CvArr *.
        Python type: Mat.

    C++ signature :
        boost::python::tuple calcOpticalFlowPyrLK(cv::Mat {lvalue},cv::Mat {lvalue},cv::Mat {lvalue},cv::Mat {lvalue},cv::Mat,CvSize,int,CvTermCriteria,int)

calcSubdivVoronoi2D(...)


calcSubdivVoronoi2D( (CvSubdiv2D)subdiv) -> None :
    
    Wrapped function:
        cvCalcSubdivVoronoi2D

    C++ signature :
        void calcSubdivVoronoi2D(CvSubdiv2D*)

calibrateCamera(...)


calibrateCamera( (list)objectPoints, (list)imagePoints, (Size2i)imageSize, (Mat)cameraMatrix, (Mat)distCoeffs [, (object)flags=0]) -> tuple :
    
    Argument 'tvecs':
        C/C++ type: ::std::vector< cv::Mat > &.
        Python type: list.
        To convert a Mat into a list, invoke one of Mat's member functions 
        to_list_of_...().
        Output argument: omitted from the function's calling sequence, and is 
        returned along with the function's return value (if any).
    Argument 'objectPoints':
        C/C++ type: ::std::vector< std::vector< cv::Point3_<float> > > const 
        &.
        Python type: list of Mat, e.g. [Mat(), Mat(), Mat()].
        Invoke asMat() to convert every 1D Python sequence into a Mat, e.g. 
        [asMat([0,1,2]), asMat((0,1,2)].
    Argument 'rvecs':
        C/C++ type: ::std::vector< cv::Mat > &.
        Python type: list.
        To convert a Mat into a list, invoke one of Mat's member functions 
        to_list_of_...().
        Output argument: omitted from the function's calling sequence, and is 
        returned along with the function's return value (if any).
    Argument 'imagePoints':
        C/C++ type: ::std::vector< std::vector< cv::Point_<float> > > const &.
        Python type: list of Mat, e.g. [Mat(), Mat(), Mat()].
        Invoke asMat() to convert every 1D Python sequence into a Mat, e.g. 
        [asMat([0,1,2]), asMat((0,1,2)].

    C++ signature :
        boost::python::tuple calibrateCamera(boost::python::list,boost::python::list,cv::Size_<int>,cv::Mat {lvalue},cv::Mat {lvalue} [,int=0])

calibrationMatrixValues(...)


calibrationMatrixValues( (Mat)cameraMatrix, (Size2i)imageSize, (object)apertureWidth, (object)apertureHeight, (object)fovx, (object)fovy, (object)focalLength, (Point2d)principalPoint, (object)aspectRatio) -> None :

    C++ signature :
        void calibrationMatrixValues(cv::Mat,cv::Size_<int>,double,double,double {lvalue},double {lvalue},double {lvalue},cv::Point_<double> {lvalue},double {lvalue})

cartToPolar(...)


cartToPolar( (Mat)x, (Mat)y, (Mat)magnitude, (Mat)angle [, (bool)angleInDegrees=False]) -> None :
    
    Calculates the magnitude and angle of 2d vectors.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#carttopolar

    C++ signature :
        void cartToPolar(cv::Mat,cv::Mat,cv::Mat {lvalue},cv::Mat {lvalue} [,bool=False])

ceil(...)


ceil( (object)value) -> int :
    
    Wrapped function:
        cvCeil

    C++ signature :
        int ceil(double)

checkChessboard(...)


checkChessboard( (Mat)src, (CvSize)size) -> object :
    
    Wrapped function:
        cvCheckChessboard
    Argument 'src':
        C/C++ type: ::IplImage *.
        Python type: Mat.

    C++ signature :
        boost::python::api::object checkChessboard(cv::Mat {lvalue},CvSize)

checkHardwareSupport(...)


checkHardwareSupport( (object)feature) -> bool :

    C++ signature :
        bool checkHardwareSupport(int)

checkRange(...)


checkRange( (MatND)a [, (bool)quiet=True [, (object)minVal=-1.7976931348623157e+308 [, (object)maxVal=1.7976931348623157e+308]]]) -> tuple :
    
    Checks every element of an input array for invalid values.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#checkrange
    Argument 'idx':
        C/C++ type: int *.
        Python type: Python equivalence of the C/C++ type without pointer.
        Output argument: omitted from the function's calling sequence, and is 
        returned along with the function's return value (if any).

    C++ signature :
        boost::python::tuple checkRange(cv::MatND [,bool=True [,double=-1.7976931348623157e+308 [,double=1.7976931348623157e+308]]])

checkRange( (Mat)a [, (bool)quiet=True [, (object)minVal=-1.7976931348623157e+308 [, (object)maxVal=1.7976931348623157e+308]]]) -> tuple :
    
    Checks every element of an input array for invalid values.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#checkrange
    Argument 'pt':
        C/C++ type: ::cv::Point *.
        Python type: Python equivalence of the C/C++ type without pointer.
        Output argument: omitted from the function's calling sequence, and is 
        returned along with the function's return value (if any).

    C++ signature :
        boost::python::tuple checkRange(cv::Mat [,bool=True [,double=-1.7976931348623157e+308 [,double=1.7976931348623157e+308]]])

circle(...)


circle( (Mat)img, (Point2i)center, (object)radius, (Scalar)color [, (object)thickness=1 [, (object)lineType=8 [, (object)shift=0]]]) -> None :

    C++ signature :
        void circle(cv::Mat {lvalue},cv::Point_<int>,int,cv::Scalar_<double> [,int=1 [,int=8 [,int=0]]])

clearMemStorage(...)


clearMemStorage( (CvMemStorage)storage) -> None :
    
    Wrapped function:
        cvClearMemStorage

    C++ signature :
        void clearMemStorage(CvMemStorage*)

clearSeq(...)


clearSeq( (CvSeq)seq) -> None :
    
    Wrapped function:
        cvClearSeq

    C++ signature :
        void clearSeq(CvSeq*)

clearSet(...)


clearSet( (CvSet)set_header) -> None :
    
    Wrapped function:
        cvClearSet

    C++ signature :
        void clearSet(CvSet*)

clearSubdivVoronoi2D(...)


clearSubdivVoronoi2D( (CvSubdiv2D)subdiv) -> None :
    
    Wrapped function:
        cvClearSubdivVoronoi2D

    C++ signature :
        void clearSubdivVoronoi2D(CvSubdiv2D*)

clipLine(...)


clipLine( (Rect)img_rect, (Point2i)pt1, (Point2i)pt2) -> bool :

    C++ signature :
        bool clipLine(cv::Rect_<int>,cv::Point_<int> {lvalue},cv::Point_<int> {lvalue})

clipLine( (Size2i)imgSize, (Point2i)pt1, (Point2i)pt2) -> bool :

    C++ signature :
        bool clipLine(cv::Size_<int>,cv::Point_<int> {lvalue},cv::Point_<int> {lvalue})

cloneSeq(...)


cloneSeq( (CvSeq)seq [, (CvMemStorage)storage=None]) -> CvSeq :
    
    Wrapped function:
        cvCloneSeq

    C++ signature :
        CvSeq* cloneSeq(CvSeq const* [,CvMemStorage*=None])

compare(...)


compare( (MatND)a, (object)s, (MatND)c, (object)cmpop) -> None :
    
    Performs per-element comparison of two arrays or an array and scalar 
    value.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#compare

    C++ signature :
        void compare(cv::MatND,double,cv::MatND {lvalue},int)

compare( (MatND)a, (MatND)b, (MatND)c, (object)cmpop) -> None :
    
    Performs per-element comparison of two arrays or an array and scalar 
    value.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#compare

    C++ signature :
        void compare(cv::MatND,cv::MatND,cv::MatND {lvalue},int)

compare( (Mat)a, (object)s, (Mat)c, (object)cmpop) -> None :
    
    Performs per-element comparison of two arrays or an array and scalar 
    value.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#compare

    C++ signature :
        void compare(cv::Mat,double,cv::Mat {lvalue},int)

compare( (Mat)a, (Mat)b, (Mat)c, (object)cmpop) -> None :
    
    Performs per-element comparison of two arrays or an array and scalar 
    value.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#compare

    C++ signature :
        void compare(cv::Mat,cv::Mat,cv::Mat {lvalue},int)

compareHist(...)


compareHist( (SparseMat)H1, (SparseMat)H2, (object)method) -> float :

    C++ signature :
        double compareHist(cv::SparseMat,cv::SparseMat,int)

compareHist( (MatND)H1, (MatND)H2, (object)method) -> float :

    C++ signature :
        double compareHist(cv::MatND,cv::MatND,int)

completeSymm(...)


completeSymm( (Mat)a [, (bool)lowerToUpper=False]) -> None :
    
    Copies the lower or the upper half of a square matrix to another half.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#completesymm

    C++ signature :
        void completeSymm(cv::Mat {lvalue} [,bool=False])

composeRT(...)


composeRT( (Mat)rvec1, (Mat)tvec1, (Mat)rvec2, (Mat)tvec2, (Mat)rvec3, (Mat)tvec3, (Mat)dr3dr1, (Mat)dr3dt1, (Mat)dr3dr2, (Mat)dr3dt2, (Mat)dt3dr1, (Mat)dt3dt1, (Mat)dt3dr2, (Mat)dt3dt2) -> None :

    C++ signature :
        void composeRT(cv::Mat,cv::Mat,cv::Mat,cv::Mat,cv::Mat {lvalue},cv::Mat {lvalue},cv::Mat {lvalue},cv::Mat {lvalue},cv::Mat {lvalue},cv::Mat {lvalue},cv::Mat {lvalue},cv::Mat {lvalue},cv::Mat {lvalue},cv::Mat {lvalue})

composeRT( (Mat)rvec1, (Mat)tvec1, (Mat)rvec2, (Mat)tvec2, (Mat)rvec3, (Mat)tvec3) -> None :

    C++ signature :
        void composeRT(cv::Mat,cv::Mat,cv::Mat,cv::Mat,cv::Mat {lvalue},cv::Mat {lvalue})

computeCorrespondEpilines(...)


computeCorrespondEpilines( (Mat)points1, (object)whichImage, (Mat)F) -> object :
    
    Argument 'lines':
        C/C++ type: ::std::vector< cv::Vec<float, 3> > &.
        Python type: Mat.
        Invoke asMat() to convert a 1D Python sequence into a Mat, e.g. 
        asMat([0,1,2]) or asMat((0,1,2)).
        Output argument: omitted from the function's calling sequence, and is 
        returned along with the function's return value (if any).

    C++ signature :
        boost::python::api::object computeCorrespondEpilines(cv::Mat,int,cv::Mat)

conDensInitSampleSet(...)


conDensInitSampleSet( (CvConDensation)condens, (Mat)lower_bound, (Mat)upper_bound) -> None :
    
    Wrapped function:
        cvConDensInitSampleSet
    Argument 'lower_bound':
        C/C++ type: ::CvMat *.
        Python type: Mat.
    Argument 'upper_bound':
        C/C++ type: ::CvMat *.
        Python type: Mat.

    C++ signature :
        void conDensInitSampleSet(CvConDensation*,cv::Mat {lvalue},cv::Mat {lvalue})

conDensUpdateByTime(...)


conDensUpdateByTime( (CvConDensation)condens) -> None :
    
    Wrapped function:
        cvConDensUpdateByTime

    C++ signature :
        void conDensUpdateByTime(CvConDensation*)

contourArea(...)


contourArea( (Mat)contour [, (bool)oriented=False]) -> float :

    C++ signature :
        double contourArea(cv::Mat [,bool=False])

contourFromContourTree(...)


contourFromContourTree( (CvContourTree)tree, (CvMemStorage)storage, (object)criteria) -> CvSeq :
    
    Wrapped function:
        cvContourFromContourTree

    C++ signature :
        CvSeq* contourFromContourTree(CvContourTree const*,CvMemStorage*,CvTermCriteria)

convertImage(...)


convertImage( (Mat)src, (Mat)dst [, (object)flags=0]) -> None :
    
    Wrapped function:
        cvConvertImage
    Argument 'src':
        C/C++ type: ::CvArr const *.
        Python type: Mat.
    Argument 'dst':
        C/C++ type: ::CvArr *.
        Python type: Mat.

    C++ signature :
        void convertImage(cv::Mat {lvalue},cv::Mat {lvalue} [,int=0])

convertMaps(...)


convertMaps( (Mat)map1, (Mat)map2, (Mat)dstmap1, (Mat)dstmap2, (object)dstmap1type [, (bool)nninterpolation=False]) -> None :

    C++ signature :
        void convertMaps(cv::Mat,cv::Mat,cv::Mat {lvalue},cv::Mat {lvalue},int [,bool=False])

convertPointsHomogeneous2D(...)


convertPointsHomogeneous2D( (Mat)src) -> object :
    
    Wrapped function:
        convertPointsHomogeneous
    Argument 'dst':
        C/C++ type: ::std::vector< cv::Point_<float> > &.
        Python type: Mat.
        Invoke asMat() to convert a 1D Python sequence into a Mat, e.g. 
        asMat([0,1,2]) or asMat((0,1,2)).
        Output argument: omitted from the function's calling sequence, and is 
        returned along with the function's return value (if any).

    C++ signature :
        boost::python::api::object convertPointsHomogeneous2D(cv::Mat)

convertPointsHomogeneous3D(...)


convertPointsHomogeneous3D( (Mat)src) -> object :
    
    Wrapped function:
        convertPointsHomogeneous
    Argument 'dst':
        C/C++ type: ::std::vector< cv::Point3_<float> > &.
        Python type: Mat.
        Invoke asMat() to convert a 1D Python sequence into a Mat, e.g. 
        asMat([0,1,2]) or asMat((0,1,2)).
        Output argument: omitted from the function's calling sequence, and is 
        returned along with the function's return value (if any).

    C++ signature :
        boost::python::api::object convertPointsHomogeneous3D(cv::Mat)

convertScaleAbs(...)


convertScaleAbs( (Mat)a, (Mat)c [, (object)alpha=1 [, (object)beta=0]]) -> None :
    
    Scales, computes absolute values and converts the result to 8-bit.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#convertscaleabs

    C++ signature :
        void convertScaleAbs(cv::Mat,cv::Mat {lvalue} [,double=1 [,double=0]])

convexHull(...)


convexHull( (Mat)points [, (bool)clockwise=False]) -> Mat :

    C++ signature :
        cv::Mat convexHull(cv::Mat [,bool=False])

convexHullIdx(...)


convexHullIdx( (Mat)points [, (bool)clockwise=False]) -> object :
    
    Wrapped function:
        convexHull
    Argument 'hull':
        C/C++ type: ::std::vector< int > &.
        Python type: Mat.
        Invoke asMat() to convert a 1D Python sequence into a Mat, e.g. 
        asMat([0,1,2]) or asMat((0,1,2)).
        Output argument: omitted from the function's calling sequence, and is 
        returned along with the function's return value (if any).

    C++ signature :
        boost::python::api::object convexHullIdx(cv::Mat [,bool=False])

convexityDefects(...)


convexityDefects( (Mat)contour, (Mat)convexhull [, (CvMemStorage)storage=None]) -> object :
    
    Wrapped function:
        cvConvexityDefects
    Argument 'contour':
        C/C++ type: ::CvArr const *.
        Python type: Mat.
    Argument 'convexhull':
        C/C++ type: ::CvArr const *.
        Python type: Mat.

    C++ signature :
        boost::python::api::object convexityDefects(cv::Mat {lvalue},cv::Mat {lvalue} [,CvMemStorage*=None])

copyMakeBorder(...)


copyMakeBorder( (Mat)src, (Mat)dst, (object)top, (object)bottom, (object)left, (object)right, (object)borderType [, (Scalar)value=Scalar([ 0.  0.  0.  0.])]) -> None :

    C++ signature :
        void copyMakeBorder(cv::Mat,cv::Mat {lvalue},int,int,int,int,int [,cv::Scalar_<double>=Scalar([ 0.  0.  0.  0.])])

cornerEigenValsAndVecs(...)


cornerEigenValsAndVecs( (Mat)src, (Mat)dst, (object)blockSize, (object)ksize [, (object)borderType=4]) -> None :

    C++ signature :
        void cornerEigenValsAndVecs(cv::Mat,cv::Mat {lvalue},int,int [,int=4])

cornerHarris(...)


cornerHarris( (Mat)src, (Mat)dst, (object)blockSize, (object)ksize, (object)k [, (object)borderType=4]) -> None :

    C++ signature :
        void cornerHarris(cv::Mat,cv::Mat {lvalue},int,int,double [,int=4])

cornerMinEigenVal(...)


cornerMinEigenVal( (Mat)src, (Mat)dst, (object)blockSize [, (object)ksize=3 [, (object)borderType=4]]) -> None :

    C++ signature :
        void cornerMinEigenVal(cv::Mat,cv::Mat {lvalue},int [,int=3 [,int=4]])

cornerSubPix(...)


cornerSubPix( (Mat)image, (Mat)corners, (Size2i)winSize, (Size2i)zeroZone, (TermCriteria)criteria) -> None :
    
    Argument 'corners':
        C/C++ type: ::std::vector< cv::Point_<float> > &.
        Python type: Mat.
        Invoke asMat() to convert a 1D Python sequence into a Mat, e.g. 
        asMat([0,1,2]) or asMat((0,1,2)).

    C++ signature :
        void cornerSubPix(cv::Mat,cv::Mat {lvalue},cv::Size_<int>,cv::Size_<int>,cv::TermCriteria)

correctMatches(...)


correctMatches( (Mat)F, (Mat)points1, (Mat)points2, (Mat)new_points1, (Mat)new_points2) -> None :
    
    Wrapped function:
        cvCorrectMatches
    Argument 'points1':
        C/C++ type: ::CvMat *.
        Python type: Mat.
    Argument 'points2':
        C/C++ type: ::CvMat *.
        Python type: Mat.
    Argument 'new_points2':
        C/C++ type: ::CvMat *.
        Python type: Mat.
    Argument 'new_points1':
        C/C++ type: ::CvMat *.
        Python type: Mat.
    Argument 'F':
        C/C++ type: ::CvMat *.
        Python type: Mat.

    C++ signature :
        void correctMatches(cv::Mat {lvalue},cv::Mat {lvalue},cv::Mat {lvalue},cv::Mat {lvalue},cv::Mat {lvalue})

countNonZero(...)


countNonZero( (MatND)m) -> int :
    
    Counts non-zero array elements.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#countnonzero

    C++ signature :
        int countNonZero(cv::MatND)

countNonZero( (Mat)m) -> int :
    
    Counts non-zero array elements.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#countnonzero

    C++ signature :
        int countNonZero(cv::Mat)

createBoxFilter(...)


createBoxFilter( (object)srcType, (object)dstType, (Size2i)ksize [, (Point2i)anchor=Point2i(x=-1, y=-1) [, (bool)normalize=True [, (object)borderType=4]]]) -> Ptr_FilterEngine :

    C++ signature :
        cv::Ptr<cv::FilterEngine> createBoxFilter(int,int,cv::Size_<int> [,cv::Point_<int>=Point2i(x=-1, y=-1) [,bool=True [,int=4]]])

createChildMemStorage(...)


createChildMemStorage( (CvMemStorage)parent) -> CvMemStorage :
    
    Wrapped function:
        cvCreateChildMemStorage

    C++ signature :
        CvMemStorage* createChildMemStorage(CvMemStorage*)

createConDensation(...)


createConDensation( (object)dynam_params, (object)measure_params, (object)sample_count) -> CvConDensation :
    
    Wrapped function:
        cvCreateConDensation

    C++ signature :
        CvConDensation* createConDensation(int,int,int)

createContourTree(...)


createContourTree( (CvSeq)contour, (CvMemStorage)storage, (object)threshold) -> CvContourTree :
    
    Wrapped function:
        cvCreateContourTree

    C++ signature :
        CvContourTree* createContourTree(CvSeq const*,CvMemStorage*,double)

createDerivFilter(...)


createDerivFilter( (object)srcType, (object)dstType, (object)dx, (object)dy, (object)ksize [, (object)borderType=4]) -> Ptr_FilterEngine :

    C++ signature :
        cv::Ptr<cv::FilterEngine> createDerivFilter(int,int,int,int,int [,int=4])

createGaussianFilter(...)


createGaussianFilter( (object)type, (Size2i)ksize, (object)sigma1 [, (object)sigma2=0 [, (object)borderType=4]]) -> Ptr_FilterEngine :

    C++ signature :
        cv::Ptr<cv::FilterEngine> createGaussianFilter(int,cv::Size_<int>,double [,double=0 [,int=4]])

createKDTree(...)


createKDTree( (Mat)desc) -> object :
    
    Wrapped function:
        cvCreateKDTree
    Argument 'desc':
        C/C++ type: ::CvMat *.
        Python type: Mat.

    C++ signature :
        boost::python::api::object createKDTree(cv::Mat {lvalue})

createLSH(...)


createLSH( (CvLSHOperations)ops, (object)d [, (object)L=10 [, (object)k=10 [, (object)type=6 [, (object)r=4 [, (long)seed=-1L]]]]]) -> CvLSH :
    
    Wrapped function:
        cvCreateLSH

    C++ signature :
        CvLSH* createLSH(CvLSHOperations*,int [,int=10 [,int=10 [,int=6 [,double=4 [,long long=-1L]]]]])

createLinearFilter(...)


createLinearFilter( (object)srcType, (object)dstType, (Mat)kernel [, (Point2i)_anchor=Point2i(x=-1, y=-1) [, (object)delta=0 [, (object)_rowBorderType=4 [, (object)_columnBorderType=-1 [, (Scalar)_borderValue=Scalar([ 0.  0.  0.  0.])]]]]]) -> Ptr_FilterEngine :

    C++ signature :
        cv::Ptr<cv::FilterEngine> createLinearFilter(int,int,cv::Mat [,cv::Point_<int>=Point2i(x=-1, y=-1) [,double=0 [,int=4 [,int=-1 [,cv::Scalar_<double>=Scalar([ 0.  0.  0.  0.])]]]]])

createMemStorage(...)


createMemStorage([  (object)block_size=0]) -> CvMemStorage :
    
    Wrapped function:
        cvCreateMemStorage

    C++ signature :
        CvMemStorage* createMemStorage([ int=0])

createMemoryLSH(...)


createMemoryLSH( (object)d, (object)n [, (object)L=10 [, (object)k=10 [, (object)type=6 [, (object)r=4 [, (long)seed=-1L]]]]]) -> CvLSH :
    
    Wrapped function:
        cvCreateMemoryLSH

    C++ signature :
        CvLSH* createMemoryLSH(int,int [,int=10 [,int=10 [,int=6 [,double=4 [,long long=-1L]]]]])

createMorphologyFilter(...)


createMorphologyFilter( (object)op, (object)type, (Mat)kernel [, (Point2i)anchor=Point2i(x=-1, y=-1) [, (object)_rowBorderType=0 [, (object)_columnBorderType=-1 [, (Scalar)_borderValue=Scalar([  1.79769313e+308   1.79769313e+308   1.79769313e+308   1.79769313e+308])]]]]) -> Ptr_FilterEngine :

    C++ signature :
        cv::Ptr<cv::FilterEngine> createMorphologyFilter(int,int,cv::Mat [,cv::Point_<int>=Point2i(x=-1, y=-1) [,int=0 [,int=-1 [,cv::Scalar_<double>=Scalar([  1.79769313e+308   1.79769313e+308   1.79769313e+308   1.79769313e+308])]]]])

createPOSITObject(...)


createPOSITObject( (object)points, (object)point_count) -> CvPOSITObject :
    
    Wrapped function:
        cvCreatePOSITObject

    C++ signature :
        CvPOSITObject* createPOSITObject(CvPoint3D32f*,int)

createSeparableLinearFilter(...)


createSeparableLinearFilter( (object)srcType, (object)dstType, (Mat)rowKernel, (Mat)columnKernel [, (Point2i)_anchor=Point2i(x=-1, y=-1) [, (object)delta=0 [, (object)_rowBorderType=4 [, (object)_columnBorderType=-1 [, (Scalar)_borderValue=Scalar([ 0.  0.  0.  0.])]]]]]) -> Ptr_FilterEngine :

    C++ signature :
        cv::Ptr<cv::FilterEngine> createSeparableLinearFilter(int,int,cv::Mat,cv::Mat [,cv::Point_<int>=Point2i(x=-1, y=-1) [,double=0 [,int=4 [,int=-1 [,cv::Scalar_<double>=Scalar([ 0.  0.  0.  0.])]]]]])

createSeq(...)


createSeq( (object)seq_flags, (object)header_size, (object)elem_size, (CvMemStorage)storage) -> CvSeq :
    
    Wrapped function:
        cvCreateSeq

    C++ signature :
        CvSeq* createSeq(int,int,int,CvMemStorage*)

createSeqBlock(...)


createSeqBlock( (CvSeqWriter)writer) -> None :
    
    Wrapped function:
        cvCreateSeqBlock

    C++ signature :
        void createSeqBlock(CvSeqWriter*)

createSet(...)


createSet( (object)set_flags, (object)header_size, (object)elem_size, (CvMemStorage)storage) -> CvSet :
    
    Wrapped function:
        cvCreateSet

    C++ signature :
        CvSet* createSet(int,int,int,CvMemStorage*)

createSpillTree(...)


createSpillTree( (Mat)raw_data [, (object)naive=50 [, (object)rho=0.69999999999999996 [, (object)tau=0.10000000000000001]]]) -> object :
    
    Wrapped function:
        cvCreateSpillTree
    Argument 'raw_data':
        C/C++ type: ::CvMat const *.
        Python type: Mat.

    C++ signature :
        boost::python::api::object createSpillTree(cv::Mat {lvalue} [,int=50 [,double=0.69999999999999996 [,double=0.10000000000000001]]])

createStereoGCState(...)


createStereoGCState( (object)numberOfDisparities, (object)maxIters) -> CvStereoGCState :
    
    Wrapped function:
        cvCreateStereoGCState

    C++ signature :
        CvStereoGCState* createStereoGCState(int,int)

createSubdiv2D(...)


createSubdiv2D( (object)subdiv_type, (object)header_size, (object)vtx_size, (object)quadedge_size, (CvMemStorage)storage) -> CvSubdiv2D :
    
    Wrapped function:
        cvCreateSubdiv2D

    C++ signature :
        CvSubdiv2D* createSubdiv2D(int,int,int,int,CvMemStorage*)

createSubdivDelaunay2D(...)


createSubdivDelaunay2D( (CvRect)rect, (CvMemStorage)storage) -> CvSubdiv2D :
    
    Wrapped function:
        cvCreateSubdivDelaunay2D

    C++ signature :
        CvSubdiv2D* createSubdivDelaunay2D(CvRect,CvMemStorage*)

cubeRoot(...)


cubeRoot( (object)val) -> float :

    C++ signature :
        float cubeRoot(float)

cvtColor(...)


cvtColor( (Mat)src, (Mat)dst, (object)code [, (object)dstCn=0]) -> None :

    C++ signature :
        void cvtColor(cv::Mat,cv::Mat {lvalue},int [,int=0])

dct(...)


dct( (Mat)src, (Mat)dst [, (object)flags=0]) -> None :

    C++ signature :
        void dct(cv::Mat,cv::Mat {lvalue} [,int=0])

decomposeProjectionMatrix(...)


decomposeProjectionMatrix( (Mat)projMatrix, (Mat)cameraMatrix, (Mat)rotMatrix, (Mat)transVect, (Mat)rotMatrixX, (Mat)rotMatrixY, (Mat)rotMatrixZ, (Vec3d)eulerAngles) -> None :

    C++ signature :
        void decomposeProjectionMatrix(cv::Mat,cv::Mat {lvalue},cv::Mat {lvalue},cv::Mat {lvalue},cv::Mat {lvalue},cv::Mat {lvalue},cv::Mat {lvalue},cv::Vec<double, 3> {lvalue})

decomposeProjectionMatrix( (Mat)projMatrix, (Mat)cameraMatrix, (Mat)rotMatrix, (Mat)transVect) -> None :

    C++ signature :
        void decomposeProjectionMatrix(cv::Mat,cv::Mat {lvalue},cv::Mat {lvalue},cv::Mat {lvalue})

detectedBlob(...)


detectedBlob( (object)x, (object)y, (object)w, (object)h [, (object)ID=0 [, (object)response=0.0]]) -> CvDetectedBlob :
    
    Wrapped function:
        cvDetectedBlob

    C++ signature :
        CvDetectedBlob detectedBlob(float,float,float,float [,int=0 [,float=0.0]])

determinant(...)


determinant( (Mat)m) -> float :

    C++ signature :
        double determinant(cv::Mat)

dft(...)


dft( (Mat)src, (Mat)dst [, (object)flags=0 [, (object)nonzeroRows=0]]) -> None :

    C++ signature :
        void dft(cv::Mat,cv::Mat {lvalue} [,int=0 [,int=0]])

dilate(...)


dilate( (Mat)src, (Mat)dst, (Mat)kernel [, (Point2i)anchor=Point2i(x=-1, y=-1) [, (object)iterations=1 [, (object)borderType=0 [, (Scalar)borderValue=Scalar([  1.79769313e+308   1.79769313e+308   1.79769313e+308   1.79769313e+308])]]]]) -> None :

    C++ signature :
        void dilate(cv::Mat,cv::Mat {lvalue},cv::Mat [,cv::Point_<int>=Point2i(x=-1, y=-1) [,int=1 [,int=0 [,cv::Scalar_<double>=Scalar([  1.79769313e+308   1.79769313e+308   1.79769313e+308   1.79769313e+308])]]]])

distTransform(...)


distTransform( (Mat)src, (Mat)dst [, (object)distance_type=2 [, (object)mask_size=3 [, (Mat)mask=Mat() [, (Mat)labels=Mat()]]]]) -> None :
    
    Wrapped function:
        cvDistTransform
    Argument 'src':
        C/C++ type: ::CvArr const *.
        Python type: Mat.
    Argument 'dst':
        C/C++ type: ::CvArr *.
        Python type: Mat.
    Argument 'labels':
        C/C++ type: ::CvArr *.
        Python type: Mat.
    Argument 'mask':
        C/C++ type: float const *.
        Python type: Mat.
        Invoke asMat() to convert a 1D Python sequence into a Mat, e.g. 
        asMat([0,1,2]) or asMat((0,1,2)).

    C++ signature :
        void distTransform(cv::Mat {lvalue},cv::Mat {lvalue} [,int=2 [,int=3 [,cv::Mat=Mat() [,cv::Mat=Mat()]]]])

distanceTransform(...)


distanceTransform( (Mat)src, (Mat)dst, (object)distanceType, (object)maskSize) -> None :

    C++ signature :
        void distanceTransform(cv::Mat,cv::Mat {lvalue},int,int)

distanceTransform( (Mat)src, (Mat)dst, (Mat)labels, (object)distanceType, (object)maskSize) -> None :

    C++ signature :
        void distanceTransform(cv::Mat,cv::Mat {lvalue},cv::Mat {lvalue},int,int)

divide(...)


divide( (object)scale, (MatND)b, (MatND)c) -> None :

    C++ signature :
        void divide(double,cv::MatND,cv::MatND {lvalue})

divide( (MatND)a, (MatND)b, (MatND)c [, (object)scale=1]) -> None :

    C++ signature :
        void divide(cv::MatND,cv::MatND,cv::MatND {lvalue} [,double=1])

divide( (object)scale, (Mat)b, (Mat)c) -> None :

    C++ signature :
        void divide(double,cv::Mat,cv::Mat {lvalue})

divide( (Mat)a, (Mat)b, (Mat)c [, (object)scale=1]) -> None :

    C++ signature :
        void divide(cv::Mat,cv::Mat,cv::Mat {lvalue} [,double=1])

drawChessboardCorners(...)


drawChessboardCorners( (Mat)image, (Size2i)patternSize, (Mat)corners, (bool)patternWasFound) -> None :

    C++ signature :
        void drawChessboardCorners(cv::Mat {lvalue},cv::Size_<int>,cv::Mat,bool)

drawContours(...)


drawContours( (Mat)image, (list)contours, (object)contourIdx, (Scalar)color [, (object)thickness=1 [, (object)lineType=8 [, (Mat)hierarchy=Mat() [, (object)maxLevel=2147483647 [, (Point2i)offset=Point2i(x=0, y=0)]]]]]) -> None :
    
    Argument 'hierarchy':
        C/C++ type: ::std::vector< cv::Vec<int, 4> > const &.
        Python type: Mat.
        Invoke asMat() to convert a 1D Python sequence into a Mat, e.g. 
        asMat([0,1,2]) or asMat((0,1,2)).
    Argument 'contours':
        C/C++ type: ::std::vector< std::vector< cv::Point_<int> > > const &.
        Python type: list of Mat, e.g. [Mat(), Mat(), Mat()].
        Invoke asMat() to convert every 1D Python sequence into a Mat, e.g. 
        [asMat([0,1,2]), asMat((0,1,2)].

    C++ signature :
        void drawContours(cv::Mat {lvalue},boost::python::list,int,cv::Scalar_<double> [,int=1 [,int=8 [,cv::Mat=Mat() [,int=2147483647 [,cv::Point_<int>=Point2i(x=0, y=0)]]]]])

eigen(...)


eigen( (Mat)a, (Mat)eigenvalues, (Mat)eigenvectors [, (object)lowindex=-1 [, (object)highindex=-1]]) -> bool :

    C++ signature :
        bool eigen(cv::Mat,cv::Mat {lvalue},cv::Mat {lvalue} [,int=-1 [,int=-1]])

eigen( (Mat)a, (Mat)eigenvalues [, (object)lowindex=-1 [, (object)highindex=-1]]) -> bool :

    C++ signature :
        bool eigen(cv::Mat,cv::Mat {lvalue} [,int=-1 [,int=-1]])

ellipse(...)


ellipse( (Mat)img, (RotatedRect)box, (Scalar)color [, (object)thickness=1 [, (object)lineType=8]]) -> None :

    C++ signature :
        void ellipse(cv::Mat {lvalue},cv::RotatedRect,cv::Scalar_<double> [,int=1 [,int=8]])

ellipse( (Mat)img, (Point2i)center, (Size2i)axes, (object)angle, (object)startAngle, (object)endAngle, (Scalar)color [, (object)thickness=1 [, (object)lineType=8 [, (object)shift=0]]]) -> None :

    C++ signature :
        void ellipse(cv::Mat {lvalue},cv::Point_<int>,cv::Size_<int>,double,double,double,cv::Scalar_<double> [,int=1 [,int=8 [,int=0]]])

ellipse2Poly(...)


ellipse2Poly( (Point2i)center, (Size2i)axes, (object)angle, (object)arcStart, (object)arcEnd, (object)delta, (Mat)pts) -> None :
    
    Argument 'pts':
        C/C++ type: ::std::vector< cv::Point_<int> > &.
        Python type: Mat.
        Invoke asMat() to convert a 1D Python sequence into a Mat, e.g. 
        asMat([0,1,2]) or asMat((0,1,2)).

    C++ signature :
        void ellipse2Poly(cv::Point_<int>,cv::Size_<int>,int,int,int,int,cv::Mat {lvalue})

endWriteSeq(...)


endWriteSeq( (CvSeqWriter)writer) -> CvSeq :
    
    Wrapped function:
        cvEndWriteSeq

    C++ signature :
        CvSeq* endWriteSeq(CvSeqWriter*)

endWriteStruct(...)


endWriteStruct( (FileStorage)fs) -> None :
    
    Wrapped function:
        cvEndWriteStruct
    Argument 'fs':
        C/C++ type: ::CvFileStorage *.
        Python type: FileStorage.

    C++ signature :
        void endWriteStruct(cv::FileStorage {lvalue})

equalizeHist(...)


equalizeHist( (Mat)src, (Mat)dst) -> None :

    C++ signature :
        void equalizeHist(cv::Mat,cv::Mat {lvalue})

erode(...)


erode( (Mat)src, (Mat)dst, (Mat)kernel [, (Point2i)anchor=Point2i(x=-1, y=-1) [, (object)iterations=1 [, (object)borderType=0 [, (Scalar)borderValue=Scalar([  1.79769313e+308   1.79769313e+308   1.79769313e+308   1.79769313e+308])]]]]) -> None :

    C++ signature :
        void erode(cv::Mat,cv::Mat {lvalue},cv::Mat [,cv::Point_<int>=Point2i(x=-1, y=-1) [,int=1 [,int=0 [,cv::Scalar_<double>=Scalar([  1.79769313e+308   1.79769313e+308   1.79769313e+308   1.79769313e+308])]]]])

error(...)


error( (object)status, (str)func_name, (str)err_msg, (str)file_name, (object)line) -> None :
    
    Wrapped function:
        cvError

    C++ signature :
        void error(int,char const*,char const*,char const*,int)

errorFromIppStatus(...)


errorFromIppStatus( (object)ipp_status) -> int :
    
    Wrapped function:
        cvErrorFromIppStatus

    C++ signature :
        int errorFromIppStatus(int)

errorStr(...)


errorStr( (object)status) -> str :
    
    Wrapped function:
        cvErrorStr

    C++ signature :
        char const* errorStr(int)

estimateAffine3D(...)


estimateAffine3D( (Mat)from, (Mat)to, (Mat)out, (Mat)outliers [, (object)param1=3.0 [, (object)param2=0.98999999999999999]]) -> object :
    
    Argument 'outliers':
        C/C++ type: ::std::vector< unsigned char > &.
        Python type: Mat.
        Invoke asMat() to convert a 1D Python sequence into a Mat, e.g. 
        asMat([0,1,2]) or asMat((0,1,2)).

    C++ signature :
        boost::python::api::object estimateAffine3D(cv::Mat,cv::Mat,cv::Mat {lvalue},cv::Mat {lvalue} [,double=3.0 [,double=0.98999999999999999]])

estimateRigidTransform(...)


estimateRigidTransform( (Mat)A, (Mat)B, (Mat)M, (object)full_affine) -> object :
    
    Wrapped function:
        cvEstimateRigidTransform
    Argument 'A':
        C/C++ type: ::CvArr const *.
        Python type: Mat.
    Argument 'B':
        C/C++ type: ::CvArr const *.
        Python type: Mat.
    Argument 'M':
        C/C++ type: ::CvMat *.
        Python type: Mat.

    C++ signature :
        boost::python::api::object estimateRigidTransform(cv::Mat {lvalue},cv::Mat {lvalue},cv::Mat {lvalue},int)

exp(...)


exp( (MatND)a, (MatND)b) -> None :

    C++ signature :
        void exp(cv::MatND,cv::MatND {lvalue})

exp( (Mat)a, (Mat)b) -> None :

    C++ signature :
        void exp(cv::Mat,cv::Mat {lvalue})

fastAtan2(...)


fastAtan2( (object)y, (object)x) -> float :

    C++ signature :
        float fastAtan2(float,float)

fillConvexPoly(...)


fillConvexPoly( (Mat)img, (Mat)pts, (Scalar)color [, (object)lineType=8 [, (object)shift=0]]) -> None :
    
    Argument 'npts':
        Dependent argument: omitted from the function's calling sequence, as 
        its value is derived from argument 'pts'.
    Argument 'pts':
        C/C++ type: ::cv::Point const *.
        Python type: Mat.
        Invoke asMat() to convert a 1D Python sequence into a Mat, e.g. 
        asMat([0,1,2]) or asMat((0,1,2)).

    C++ signature :
        void fillConvexPoly(cv::Mat {lvalue},cv::Mat,cv::Scalar_<double> [,int=8 [,int=0]])

fillPoly(...)


fillPoly( (Mat)img, (object)pts, (Scalar)color [, (object)lineType=8 [, (object)shift=0 [, (Point2i)offset=Point2i(x=0, y=0)]]]) -> None :
    
    Argument 'npts':
        Dependent argument: omitted from the function's calling sequence, as 
        its value is derived from argument 'pts'.
    Argument 'ncontours':
        Dependent argument: omitted from the function's calling sequence, as 
        its value is derived from argument 'pts'.
    Argument 'pts':
        C/C++ type: ::cv::Point const * *.
        Python type: 2d list.
        Depending on its C++ argument type, it should be a list of Mats or a 
        list of lists.

    C++ signature :
        void fillPoly(cv::Mat {lvalue},boost::python::api::object,cv::Scalar_<double> [,int=8 [,int=0 [,cv::Point_<int>=Point2i(x=0, y=0)]]])

filter2D(...)


filter2D( (Mat)src, (Mat)dst, (object)ddepth, (Mat)kernel [, (Point2i)anchor=Point2i(x=-1, y=-1) [, (object)delta=0 [, (object)borderType=4]]]) -> None :

    C++ signature :
        void filter2D(cv::Mat,cv::Mat {lvalue},int,cv::Mat [,cv::Point_<int>=Point2i(x=-1, y=-1) [,double=0 [,int=4]]])

filterSpeckles(...)


filterSpeckles( (Mat)img, (object)newVal, (object)maxSpeckleSize, (object)maxDiff, (Mat)buf) -> None :

    C++ signature :
        void filterSpeckles(cv::Mat {lvalue},double,int,double,cv::Mat {lvalue})

find4QuadCornerSubpix(...)


find4QuadCornerSubpix( (Mat)img, (Mat)corners, (Size2i)region_size) -> object :
    
    Argument 'corners':
        C/C++ type: ::std::vector< cv::Point_<float> > &.
        Python type: Mat.
        Invoke asMat() to convert a 1D Python sequence into a Mat, e.g. 
        asMat([0,1,2]) or asMat((0,1,2)).

    C++ signature :
        boost::python::api::object find4QuadCornerSubpix(cv::Mat,cv::Mat {lvalue},cv::Size_<int>)

findChessboardCorners(...)


findChessboardCorners( (Mat)image, (Size2i)patternSize [, (object)flags=3]) -> tuple :
    
    Argument 'corners':
        C/C++ type: ::std::vector< cv::Point_<float> > &.
        Python type: Mat.
        Invoke asMat() to convert a 1D Python sequence into a Mat, e.g. 
        asMat([0,1,2]) or asMat((0,1,2)).
        Output argument: omitted from the function's calling sequence, and is 
        returned along with the function's return value (if any).

    C++ signature :
        boost::python::tuple findChessboardCorners(cv::Mat,cv::Size_<int> [,int=3])

findContours(...)


findContours( (Mat)image, (object)mode, (object)method [, (Point2i)offset=Point2i(x=0, y=0)]) -> object :
    
    Argument 'contours':
        C/C++ type: ::std::vector< std::vector< cv::Point_<int> > > &.
        Python type: list of Mat, e.g. [Mat(), Mat(), Mat()].
        Invoke asMat() to convert every 1D Python sequence into a Mat, e.g. 
        [asMat([0,1,2]), asMat((0,1,2)].
        Output argument: omitted from the function's calling sequence, and is 
        returned along with the function's return value (if any).

    C++ signature :
        boost::python::api::object findContours(cv::Mat {lvalue},int,int [,cv::Point_<int>=Point2i(x=0, y=0)])

findContours( (Mat)image, (object)mode, (object)method [, (Point2i)offset=Point2i(x=0, y=0)]) -> tuple :
    
    Argument 'hierarchy':
        C/C++ type: ::std::vector< cv::Vec<int, 4> > &.
        Python type: Mat.
        Invoke asMat() to convert a 1D Python sequence into a Mat, e.g. 
        asMat([0,1,2]) or asMat((0,1,2)).
        Output argument: omitted from the function's calling sequence, and is 
        returned along with the function's return value (if any).
    Argument 'contours':
        C/C++ type: ::std::vector< std::vector< cv::Point_<int> > > &.
        Python type: list of Mat, e.g. [Mat(), Mat(), Mat()].
        Invoke asMat() to convert every 1D Python sequence into a Mat, e.g. 
        [asMat([0,1,2]), asMat((0,1,2)].
        Output argument: omitted from the function's calling sequence, and is 
        returned along with the function's return value (if any).

    C++ signature :
        boost::python::tuple findContours(cv::Mat {lvalue},int,int [,cv::Point_<int>=Point2i(x=0, y=0)])

findDominantPoints(...)


findDominantPoints( (CvSeq)contour, (CvMemStorage)storage [, (object)method=1 [, (object)parameter1=0 [, (object)parameter2=0 [, (object)parameter3=0 [, (object)parameter4=0]]]]]) -> CvSeq :
    
    Wrapped function:
        cvFindDominantPoints

    C++ signature :
        CvSeq* findDominantPoints(CvSeq*,CvMemStorage* [,int=1 [,double=0 [,double=0 [,double=0 [,double=0]]]]])

findFeatures(...)


findFeatures( (CvFeatureTree)tr, (Mat)query_points, (Mat)indices, (Mat)dist, (object)k [, (object)emax=20]) -> None :
    
    Wrapped function:
        cvFindFeatures
    Argument 'indices':
        C/C++ type: ::CvMat *.
        Python type: Mat.
    Argument 'query_points':
        C/C++ type: ::CvMat const *.
        Python type: Mat.
    Argument 'dist':
        C/C++ type: ::CvMat *.
        Python type: Mat.

    C++ signature :
        void findFeatures(CvFeatureTree*,cv::Mat {lvalue},cv::Mat {lvalue},cv::Mat {lvalue},int [,int=20])

findFeaturesBoxed(...)


findFeaturesBoxed( (CvFeatureTree)tr, (Mat)bounds_min, (Mat)bounds_max, (Mat)out_indices) -> object :
    
    Wrapped function:
        cvFindFeaturesBoxed
    Argument 'bounds_min':
        C/C++ type: ::CvMat *.
        Python type: Mat.
    Argument 'out_indices':
        C/C++ type: ::CvMat *.
        Python type: Mat.
    Argument 'bounds_max':
        C/C++ type: ::CvMat *.
        Python type: Mat.

    C++ signature :
        boost::python::api::object findFeaturesBoxed(CvFeatureTree*,cv::Mat {lvalue},cv::Mat {lvalue},cv::Mat {lvalue})

findFundamentalMat(...)


findFundamentalMat( (Mat)points1, (Mat)points2 [, (object)method=8 [, (object)param1=3.0 [, (object)param2=0.98999999999999999]]]) -> Mat :

    C++ signature :
        cv::Mat findFundamentalMat(cv::Mat,cv::Mat [,int=8 [,double=3.0 [,double=0.98999999999999999]]])

findFundamentalMat2(...)


findFundamentalMat2( (Mat)points1, (Mat)points2 [, (object)method=8 [, (object)param1=3.0 [, (object)param2=0.98999999999999999]]]) -> tuple :
    
    Wrapped function:
        findFundamentalMat
    Argument 'mask':
        C/C++ type: ::std::vector< unsigned char > &.
        Python type: Mat.
        Invoke asMat() to convert a 1D Python sequence into a Mat, e.g. 
        asMat([0,1,2]) or asMat((0,1,2)).
        Output argument: omitted from the function's calling sequence, and is 
        returned along with the function's return value (if any).

    C++ signature :
        boost::python::tuple findFundamentalMat2(cv::Mat,cv::Mat [,int=8 [,double=3.0 [,double=0.98999999999999999]]])

findHomography(...)


findHomography( (Mat)srcPoints, (Mat)dstPoints [, (object)method=0 [, (object)ransacReprojThreshold=0]]) -> Mat :

    C++ signature :
        cv::Mat findHomography(cv::Mat,cv::Mat [,int=0 [,double=0]])

findHomography2(...)


findHomography2( (Mat)srcPoints, (Mat)dstPoints [, (object)method=0 [, (object)ransacReprojThreshold=0]]) -> tuple :
    
    Wrapped function:
        findHomography
    Argument 'mask':
        C/C++ type: ::std::vector< unsigned char > &.
        Python type: Mat.
        Invoke asMat() to convert a 1D Python sequence into a Mat, e.g. 
        asMat([0,1,2]) or asMat((0,1,2)).
        Output argument: omitted from the function's calling sequence, and is 
        returned along with the function's return value (if any).

    C++ signature :
        boost::python::tuple findHomography2(cv::Mat,cv::Mat [,int=0 [,double=0]])

findNearestPoint2D(...)


findNearestPoint2D( (CvSubdiv2D)subdiv, (Point2f)pt) -> object :
    
    Wrapped function:
        cvFindNearestPoint2D
    Argument 'pt':
        C/C++ type: ::CvPoint2D32f.
        Python type: Point2f.

    C++ signature :
        boost::python::api::object findNearestPoint2D(CvSubdiv2D*,cv::Point_<float>)

findNextContour(...)


findNextContour( (CvContourScanner)scanner) -> CvSeq :
    
    Wrapped function:
        cvFindNextContour

    C++ signature :
        CvSeq* findNextContour(_CvContourScanner*)

findStereoCorrespondence(...)


findStereoCorrespondence( (Mat)leftImage, (Mat)rightImage, (object)mode, (Mat)dispImage, (object)maxDisparity [, (object)param1=12345 [, (object)param2=12345 [, (object)param3=12345 [, (object)param4=12345 [, (object)param5=12345]]]]]) -> None :
    
    Wrapped function:
        cvFindStereoCorrespondence
    Argument 'dispImage':
        C/C++ type: ::CvArr *.
        Python type: Mat.
    Argument 'leftImage':
        C/C++ type: ::CvArr const *.
        Python type: Mat.
    Argument 'rightImage':
        C/C++ type: ::CvArr const *.
        Python type: Mat.

    C++ signature :
        void findStereoCorrespondence(cv::Mat {lvalue},cv::Mat {lvalue},int,cv::Mat {lvalue},int [,double=12345 [,double=12345 [,double=12345 [,double=12345 [,double=12345]]]]])

findStereoCorrespondenceGC(...)


findStereoCorrespondenceGC( (Mat)left, (Mat)right, (Mat)disparityLeft, (Mat)disparityRight, (CvStereoGCState)state [, (object)useDisparityGuess=0]) -> None :
    
    Wrapped function:
        cvFindStereoCorrespondenceGC
    Argument 'disparityLeft':
        C/C++ type: ::CvArr *.
        Python type: Mat.
    Argument 'right':
        C/C++ type: ::CvArr const *.
        Python type: Mat.
    Argument 'disparityRight':
        C/C++ type: ::CvArr *.
        Python type: Mat.
    Argument 'left':
        C/C++ type: ::CvArr const *.
        Python type: Mat.

    C++ signature :
        void findStereoCorrespondenceGC(cv::Mat {lvalue},cv::Mat {lvalue},cv::Mat {lvalue},cv::Mat {lvalue},CvStereoGCState* [,int=0])

findType(...)


findType( (str)type_name) -> CvTypeInfo :
    
    Wrapped function:
        cvFindType

    C++ signature :
        CvTypeInfo* findType(char const*)

firstType()

    Wrapped function:
        cvFirstType

    C++ signature :
        CvTypeInfo* firstType()

Returns: CvTypeInfo :

fitEllipse(...)


fitEllipse( (Mat)points) -> RotatedRect :

    C++ signature :
        cv::RotatedRect fitEllipse(cv::Mat)

fitLine(...)


fitLine( (Mat)points, (Vec6f)line, (object)distType, (object)param, (object)reps, (object)aeps) -> None :

    C++ signature :
        void fitLine(cv::Mat,cv::Vec<float, 6> {lvalue},int,double,double,double)

fitLine( (Mat)points, (Vec4f)line, (object)distType, (object)param, (object)reps, (object)aeps) -> None :

    C++ signature :
        void fitLine(cv::Mat,cv::Vec<float, 4> {lvalue},int,double,double,double)

flip(...)


flip( (Mat)a, (Mat)b, (object)flipCode) -> None :

    C++ signature :
        void flip(cv::Mat,cv::Mat {lvalue},int)

floodFill(...)


floodFill( (Mat)image, (Mat)mask, (Point2i)seedPoint, (Scalar)newVal [, (Scalar)loDiff=Scalar([ 0.  0.  0.  0.]) [, (Scalar)upDiff=Scalar([ 0.  0.  0.  0.]) [, (object)flags=4]]]) -> tuple :
    
    Argument 'rect':
        C/C++ type: ::cv::Rect *.
        Python type: Python equivalence of the C/C++ type without pointer.
        Output argument: omitted from the function's calling sequence, and is 
        returned along with the function's return value (if any).

    C++ signature :
        boost::python::tuple floodFill(cv::Mat {lvalue},cv::Mat {lvalue},cv::Point_<int>,cv::Scalar_<double> [,cv::Scalar_<double>=Scalar([ 0.  0.  0.  0.]) [,cv::Scalar_<double>=Scalar([ 0.  0.  0.  0.]) [,int=4]]])

floodFill( (Mat)image, (Point2i)seedPoint, (Scalar)newVal [, (Scalar)loDiff=Scalar([ 0.  0.  0.  0.]) [, (Scalar)upDiff=Scalar([ 0.  0.  0.  0.]) [, (object)flags=4]]]) -> tuple :
    
    Argument 'rect':
        C/C++ type: ::cv::Rect *.
        Python type: Python equivalence of the C/C++ type without pointer.
        Output argument: omitted from the function's calling sequence, and is 
        returned along with the function's return value (if any).

    C++ signature :
        boost::python::tuple floodFill(cv::Mat {lvalue},cv::Point_<int>,cv::Scalar_<double> [,cv::Scalar_<double>=Scalar([ 0.  0.  0.  0.]) [,cv::Scalar_<double>=Scalar([ 0.  0.  0.  0.]) [,int=4]]])

floor(...)


floor( (object)value) -> int :
    
    Wrapped function:
        cvFloor

    C++ signature :
        int floor(double)

flushSeqWriter(...)


flushSeqWriter( (CvSeqWriter)writer) -> None :
    
    Wrapped function:
        cvFlushSeqWriter

    C++ signature :
        void flushSeqWriter(CvSeqWriter*)

fromUtf16(...)


fromUtf16( (unicode)str) -> str :

    C++ signature :
        std::string fromUtf16(std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t> >)

gemm(...)


gemm( (Mat)a, (Mat)b, (object)alpha, (Mat)c, (object)gamma, (Mat)d [, (object)flags=0]) -> None :

    C++ signature :
        void gemm(cv::Mat,cv::Mat,double,cv::Mat,double,cv::Mat {lvalue} [,int=0])

getAffineTransform(...)


getAffineTransform( (Mat)src, (Mat)dst) -> object :
    
    Argument 'src':
        C/C++ type: ::cv::Point2f const *.
        Python type: Mat.
        Invoke asMat() to convert a 1D Python sequence into a Mat, e.g. 
        asMat([0,1,2]) or asMat((0,1,2)).
    Argument 'dst':
        C/C++ type: ::cv::Point2f const *.
        Python type: Mat.
        Invoke asMat() to convert a 1D Python sequence into a Mat, e.g. 
        asMat([0,1,2]) or asMat((0,1,2)).

    C++ signature :
        boost::python::api::object getAffineTransform(cv::Mat,cv::Mat)

getCPUTickCount()

    C++ signature :
        long long getCPUTickCount()

Returns: long :

getColumnSumFilter(...)


getColumnSumFilter( (object)sumType, (object)dstType, (object)ksize [, (object)anchor=-1 [, (object)scale=1]]) -> Ptr_BaseColumnFilter :

    C++ signature :
        cv::Ptr<cv::BaseColumnFilter> getColumnSumFilter(int,int,int [,int=-1 [,double=1]])

getDefaultNewCameraMatrix(...)


getDefaultNewCameraMatrix( (Mat)cameraMatrix [, (Size2i)imgsize=Size2i(width=0, height=0) [, (bool)centerPrincipalPoint=False]]) -> Mat :

    C++ signature :
        cv::Mat getDefaultNewCameraMatrix(cv::Mat [,cv::Size_<int>=Size2i(width=0, height=0) [,bool=False]])

getDerivKernels(...)


getDerivKernels( (Mat)kx, (Mat)ky, (object)dx, (object)dy, (object)ksize [, (bool)normalize=False [, (object)ktype=5]]) -> None :

    C++ signature :
        void getDerivKernels(cv::Mat {lvalue},cv::Mat {lvalue},int,int,int [,bool=False [,int=5]])

getElemSize(...)


getElemSize( (object)type) -> int :

    C++ signature :
        unsigned int getElemSize(int)

getElemType(...)


getElemType( (Mat)arr) -> object :
    
    Wrapped function:
        cvGetElemType
    Argument 'arr':
        C/C++ type: ::CvArr const *.
        Python type: Mat.

    C++ signature :
        boost::python::api::object getElemType(cv::Mat {lvalue})

getErrMode()

    Wrapped function:
        cvGetErrMode

    C++ signature :
        int getErrMode()

Returns: int :

getErrStatus()

    Wrapped function:
        cvGetErrStatus

    C++ signature :
        int getErrStatus()

Returns: int :

getFileNode(...)


getFileNode( (FileStorage)fs, (FileNode)map, (CvStringHashNode)key [, (object)create_missing=0]) -> object :
    
    Wrapped function:
        cvGetFileNode
    Argument 'map':
        C/C++ type: ::CvFileNode *.
        Python type: FileNode.
    Argument 'fs':
        C/C++ type: ::CvFileStorage *.
        Python type: FileStorage.

    C++ signature :
        boost::python::api::object getFileNode(cv::FileStorage {lvalue},cv::FileNode {lvalue},CvStringHashNode const* [,int=0])

getFileNodeByName(...)


getFileNodeByName( (CvFileStorage)fs, (FileNode)map, (str)name) -> object :
    
    Wrapped function:
        cvGetFileNodeByName
    Argument 'map':
        C/C++ type: ::CvFileNode const *.
        Python type: FileNode.

    C++ signature :
        boost::python::api::object getFileNodeByName(CvFileStorage const*,cv::FileNode,char const*)

getFileNodeName(...)


getFileNodeName( (FileNode)node) -> object :
    
    Wrapped function:
        cvGetFileNodeName
    Argument 'node':
        C/C++ type: ::CvFileNode const *.
        Python type: FileNode.

    C++ signature :
        boost::python::api::object getFileNodeName(cv::FileNode)

getGaussianKernel(...)


getGaussianKernel( (object)ksize, (object)sigma [, (object)ktype=6]) -> Mat :

    C++ signature :
        cv::Mat getGaussianKernel(int,double [,int=6])

getHashedKey(...)


getHashedKey( (FileStorage)fs, (str)name [, (object)len=-1 [, (object)create_missing=0]]) -> object :
    
    Wrapped function:
        cvGetHashedKey
    Argument 'fs':
        C/C++ type: ::CvFileStorage *.
        Python type: FileStorage.

    C++ signature :
        boost::python::api::object getHashedKey(cv::FileStorage {lvalue},char const* [,int=-1 [,int=0]])

getKernelType(...)


getKernelType( (Mat)kernel, (Point2i)anchor) -> int :

    C++ signature :
        int getKernelType(cv::Mat,cv::Point_<int>)

getLinearColumnFilter(...)


getLinearColumnFilter( (object)bufType, (object)dstType, (Mat)kernel, (object)anchor, (object)symmetryType [, (object)delta=0 [, (object)bits=0]]) -> Ptr_BaseColumnFilter :

    C++ signature :
        cv::Ptr<cv::BaseColumnFilter> getLinearColumnFilter(int,int,cv::Mat,int,int [,double=0 [,int=0]])

getLinearFilter(...)


getLinearFilter( (object)srcType, (object)dstType, (Mat)kernel [, (Point2i)anchor=Point2i(x=-1, y=-1) [, (object)delta=0 [, (object)bits=0]]]) -> Ptr_BaseFilter :

    C++ signature :
        cv::Ptr<cv::BaseFilter> getLinearFilter(int,int,cv::Mat [,cv::Point_<int>=Point2i(x=-1, y=-1) [,double=0 [,int=0]]])

getLinearRowFilter(...)


getLinearRowFilter( (object)srcType, (object)bufType, (Mat)kernel, (object)anchor, (object)symmetryType) -> Ptr_BaseRowFilter :

    C++ signature :
        cv::Ptr<cv::BaseRowFilter> getLinearRowFilter(int,int,cv::Mat,int,int)

getMorphologyColumnFilter(...)


getMorphologyColumnFilter( (object)op, (object)type, (object)ksize [, (object)anchor=-1]) -> Ptr_BaseColumnFilter :

    C++ signature :
        cv::Ptr<cv::BaseColumnFilter> getMorphologyColumnFilter(int,int,int [,int=-1])

getMorphologyFilter(...)


getMorphologyFilter( (object)op, (object)type, (Mat)kernel [, (Point2i)anchor=Point2i(x=-1, y=-1)]) -> Ptr_BaseFilter :

    C++ signature :
        cv::Ptr<cv::BaseFilter> getMorphologyFilter(int,int,cv::Mat [,cv::Point_<int>=Point2i(x=-1, y=-1)])

getMorphologyRowFilter(...)


getMorphologyRowFilter( (object)op, (object)type, (object)ksize [, (object)anchor=-1]) -> Ptr_BaseRowFilter :

    C++ signature :
        cv::Ptr<cv::BaseRowFilter> getMorphologyRowFilter(int,int,int [,int=-1])

getNumThreads()

    Wrapped function:
        cvGetNumThreads

    C++ signature :
        int getNumThreads()

getNumThreads() -> int :

    C++ signature :
        int getNumThreads()

Returns: int :

getOptimalDFTSize(...)


getOptimalDFTSize( (object)vecsize) -> int :

    C++ signature :
        int getOptimalDFTSize(int)

getPerspectiveTransform(...)


getPerspectiveTransform( (Mat)src, (Mat)dst) -> object :
    
    Argument 'src':
        C/C++ type: ::cv::Point2f const *.
        Python type: Mat.
        Invoke asMat() to convert a 1D Python sequence into a Mat, e.g. 
        asMat([0,1,2]) or asMat((0,1,2)).
    Argument 'dst':
        C/C++ type: ::cv::Point2f const *.
        Python type: Mat.
        Invoke asMat() to convert a 1D Python sequence into a Mat, e.g. 
        asMat([0,1,2]) or asMat((0,1,2)).

    C++ signature :
        boost::python::api::object getPerspectiveTransform(cv::Mat,cv::Mat)

getQuadrangleSubPix(...)


getQuadrangleSubPix( (Mat)src, (Mat)dst, (Mat)map_matrix) -> None :
    
    Wrapped function:
        cvGetQuadrangleSubPix
    Argument 'map_matrix':
        C/C++ type: ::CvMat const *.
        Python type: Mat.
    Argument 'src':
        C/C++ type: ::CvArr const *.
        Python type: Mat.
    Argument 'dst':
        C/C++ type: ::CvArr *.
        Python type: Mat.

    C++ signature :
        void getQuadrangleSubPix(cv::Mat {lvalue},cv::Mat {lvalue},cv::Mat {lvalue})

getRectSubPix(...)


getRectSubPix( (Mat)image, (Size2i)patchSize, (Point2f)center, (Mat)patch [, (object)patchType=-1]) -> None :

    C++ signature :
        void getRectSubPix(cv::Mat,cv::Size_<int>,cv::Point_<float>,cv::Mat {lvalue} [,int=-1])

getRootFileNode(...)


getRootFileNode( (CvFileStorage)fs [, (object)stream_index=0]) -> CvFileNode :
    
    Wrapped function:
        cvGetRootFileNode

    C++ signature :
        CvFileNode* getRootFileNode(CvFileStorage const* [,int=0])

getRotationMatrix2D(...)


getRotationMatrix2D( (Point2f)center, (object)angle, (object)scale) -> Mat :

    C++ signature :
        cv::Mat getRotationMatrix2D(cv::Point_<float>,double,double)

getRowSumFilter(...)


getRowSumFilter( (object)srcType, (object)sumType, (object)ksize [, (object)anchor=-1]) -> Ptr_BaseRowFilter :

    C++ signature :
        cv::Ptr<cv::BaseRowFilter> getRowSumFilter(int,int,int [,int=-1])

getSeqReaderPos(...)


getSeqReaderPos( (CvSeqReader)reader) -> int :
    
    Wrapped function:
        cvGetSeqReaderPos

    C++ signature :
        int getSeqReaderPos(CvSeqReader*)

getSetElem(...)


getSetElem( (CvSet)set_header, (object)index) -> CvSetElem :
    
    Wrapped function:
        cvGetSetElem

    C++ signature :
        CvSetElem* getSetElem(CvSet const*,int)

getStructuringElement(...)


getStructuringElement( (object)shape, (Size2i)ksize [, (Point2i)anchor=Point2i(x=-1, y=-1)]) -> Mat :

    C++ signature :
        cv::Mat getStructuringElement(int,cv::Size_<int> [,cv::Point_<int>=Point2i(x=-1, y=-1)])

getTextSize(...)


getTextSize( (object)text, (object)fontFace, (object)fontScale, (object)thickness) -> tuple :
    
    Argument 'baseLine':
        C/C++ type: int *.
        Python type: Python equivalence of the C/C++ type without pointer.
        Output argument: omitted from the function's calling sequence, and is 
        returned along with the function's return value (if any).

    C++ signature :
        boost::python::tuple getTextSize(std::string,int,double,int)

getThreadNum()

    Wrapped function:
        cvGetThreadNum

    C++ signature :
        int getThreadNum()

getThreadNum() -> int :

    C++ signature :
        int getThreadNum()

Returns: int :

getTickCount()

    Wrapped function:
        cvGetTickCount

    C++ signature :
        long long getTickCount()

getTickCount() -> long :

    C++ signature :
        long long getTickCount()

Returns: long :

getTickFrequency()

    Wrapped function:
        cvGetTickFrequency

    C++ signature :
        double getTickFrequency()

getTickFrequency() -> float :

    C++ signature :
        double getTickFrequency()

Returns: float :

getTrackbarPos(...)


getTrackbarPos( (str)trackbar_name, (str)window_name) -> int :
    
    Wrapped function:
        cvGetTrackbarPos

    C++ signature :
        int getTrackbarPos(char const*,char const*)

getValidDisparityROI(...)


getValidDisparityROI( (Rect)roi1, (Rect)roi2, (object)minDisparity, (object)numberOfDisparities, (object)SADWindowSize) -> Rect :

    C++ signature :
        cv::Rect_<int> getValidDisparityROI(cv::Rect_<int>,cv::Rect_<int>,int,int,int)

getWindowName(...)


getWindowName( (object)window_handle) -> str :
    
    Wrapped function:
        cvGetWindowName

    C++ signature :
        char const* getWindowName(void*)

getWindowProperty(...)


getWindowProperty( (object)winname, (object)prop_id) -> float :

    C++ signature :
        double getWindowProperty(std::string,int)

goodFeaturesToTrack(...)


goodFeaturesToTrack( (Mat)image, (object)maxCorners, (object)qualityLevel, (object)minDistance [, (Mat)mask=Mat() [, (object)blockSize=3 [, (bool)useHarrisDetector=False [, (object)k=0.040000000000000001]]]]) -> object :
    
    Argument 'corners':
        C/C++ type: ::std::vector< cv::Point_<float> > &.
        Python type: Mat.
        Invoke asMat() to convert a 1D Python sequence into a Mat, e.g. 
        asMat([0,1,2]) or asMat((0,1,2)).
        Output argument: omitted from the function's calling sequence, and is 
        returned along with the function's return value (if any).

    C++ signature :
        boost::python::api::object goodFeaturesToTrack(cv::Mat,int,double,double [,cv::Mat=Mat() [,int=3 [,bool=False [,double=0.040000000000000001]]]])

grabCut(...)


grabCut( (Mat)img, (Mat)mask, (Rect)rect, (Mat)bgdModel, (Mat)fgdModel, (object)iterCount [, (object)mode=2]) -> None :

    C++ signature :
        void grabCut(cv::Mat,cv::Mat {lvalue},cv::Rect_<int>,cv::Mat {lvalue},cv::Mat {lvalue},int [,int=2])

groupRectangles(...)


groupRectangles( (Mat)rectList, (Mat)weights, (object)groupThreshold [, (object)eps=0.20000000000000001]) -> None :
    
    Argument 'weights':
        C/C++ type: ::std::vector< int > &.
        Python type: Mat.
        Invoke asMat() to convert a 1D Python sequence into a Mat, e.g. 
        asMat([0,1,2]) or asMat((0,1,2)).
    Argument 'rectList':
        C/C++ type: ::std::vector< cv::Rect_<int> > &.
        Python type: Mat.
        Invoke asMat() to convert a 1D Python sequence into a Mat, e.g. 
        asMat([0,1,2]) or asMat((0,1,2)).

    C++ signature :
        void groupRectangles(cv::Mat {lvalue},cv::Mat {lvalue},int [,double=0.20000000000000001])

groupRectangles( (Mat)rectList, (object)groupThreshold [, (object)eps=0.20000000000000001]) -> None :
    
    Argument 'rectList':
        C/C++ type: ::std::vector< cv::Rect_<int> > &.
        Python type: Mat.
        Invoke asMat() to convert a 1D Python sequence into a Mat, e.g. 
        asMat([0,1,2]) or asMat((0,1,2)).

    C++ signature :
        void groupRectangles(cv::Mat {lvalue},int [,double=0.20000000000000001])

hierarchicalClustering(...)


hierarchicalClustering( (Mat)features, (Mat)centers, (KMeansIndexParams)params) -> int :

    C++ signature :
        int hierarchicalClustering(cv::Mat,cv::Mat {lvalue},cv::flann::KMeansIndexParams)

idct(...)


idct( (Mat)src, (Mat)dst [, (object)flags=0]) -> None :

    C++ signature :
        void idct(cv::Mat,cv::Mat {lvalue} [,int=0])

idft(...)


idft( (Mat)src, (Mat)dst [, (object)flags=0 [, (object)nonzeroRows=0]]) -> None :

    C++ signature :
        void idft(cv::Mat,cv::Mat {lvalue} [,int=0 [,int=0]])

imdecode(...)


imdecode( (Mat)buf, (object)flags) -> Mat :

    C++ signature :
        cv::Mat imdecode(cv::Mat,int)

imencode(...)


imencode( (object)ext, (Mat)img [, (Mat)params=Mat()]) -> tuple :
    
    Argument 'params':
        C/C++ type: ::std::vector< int > const &.
        Python type: Mat.
        Invoke asMat() to convert a 1D Python sequence into a Mat, e.g. 
        asMat([0,1,2]) or asMat((0,1,2)).
    Argument 'buf':
        C/C++ type: ::std::vector< unsigned char > &.
        Python type: Mat.
        Invoke asMat() to convert a 1D Python sequence into a Mat, e.g. 
        asMat([0,1,2]) or asMat((0,1,2)).
        Output argument: omitted from the function's calling sequence, and is 
        returned along with the function's return value (if any).

    C++ signature :
        boost::python::tuple imencode(std::string,cv::Mat [,cv::Mat=Mat()])

imread(...)


imread( (object)filename [, (object)flags=1]) -> Mat :

    C++ signature :
        cv::Mat imread(std::string [,int=1])

imshow(...)


imshow( (object)winname, (Mat)mat) -> None :

    C++ signature :
        void imshow(std::string,cv::Mat)

imwrite(...)


imwrite( (object)filename, (Mat)img [, (Mat)params=Mat()]) -> object :
    
    Argument 'params':
        C/C++ type: ::std::vector< int > const &.
        Python type: Mat.
        Invoke asMat() to convert a 1D Python sequence into a Mat, e.g. 
        asMat([0,1,2]) or asMat((0,1,2)).

    C++ signature :
        boost::python::api::object imwrite(std::string,cv::Mat [,cv::Mat=Mat()])

inRange(...)


inRange( (MatND)src, (Scalar)lowerb, (Scalar)upperb, (MatND)dst) -> None :

    C++ signature :
        void inRange(cv::MatND,cv::Scalar_<double>,cv::Scalar_<double>,cv::MatND {lvalue})

inRange( (MatND)src, (MatND)lowerb, (MatND)upperb, (MatND)dst) -> None :

    C++ signature :
        void inRange(cv::MatND,cv::MatND,cv::MatND,cv::MatND {lvalue})

inRange( (Mat)src, (Scalar)lowerb, (Scalar)upperb, (Mat)dst) -> None :

    C++ signature :
        void inRange(cv::Mat,cv::Scalar_<double>,cv::Scalar_<double>,cv::Mat {lvalue})

inRange( (Mat)src, (Mat)lowerb, (Mat)upperb, (Mat)dst) -> None :

    C++ signature :
        void inRange(cv::Mat,cv::Mat,cv::Mat,cv::Mat {lvalue})

initCameraMatrix2D(...)


initCameraMatrix2D( (list)objectPoints, (list)imagePoints, (Size2i)imageSize [, (object)aspectRatio=1.0]) -> object :
    
    Argument 'objectPoints':
        C/C++ type: ::std::vector< std::vector< cv::Point3_<float> > > const 
        &.
        Python type: list of Mat, e.g. [Mat(), Mat(), Mat()].
        Invoke asMat() to convert every 1D Python sequence into a Mat, e.g. 
        [asMat([0,1,2]), asMat((0,1,2)].
    Argument 'imagePoints':
        C/C++ type: ::std::vector< std::vector< cv::Point_<float> > > const &.
        Python type: list of Mat, e.g. [Mat(), Mat(), Mat()].
        Invoke asMat() to convert every 1D Python sequence into a Mat, e.g. 
        [asMat([0,1,2]), asMat((0,1,2)].

    C++ signature :
        boost::python::api::object initCameraMatrix2D(boost::python::list,boost::python::list,cv::Size_<int> [,double=1.0])

initNArrayIterator(...)


initNArrayIterator( (Mat)arrs, (Mat)mask, (object)stubs, (CvNArrayIterator)array_iterator [, (object)flags=0]) -> object :
    
    Wrapped function:
        cvInitNArrayIterator
    Argument 'count':
        Dependent argument: omitted from the function's calling sequence, as 
        its value is derived from argument 'arrs'.
    Argument 'mask':
        C/C++ type: ::CvArr const *.
        Python type: Mat.
    Argument 'arrs':
        C/C++ type: ::CvArr * *.
        Python type: Mat.
        Invoke asMat() to convert a 1D Python sequence into a Mat, e.g. 
        asMat([0,1,2]) or asMat((0,1,2)).

    C++ signature :
        boost::python::api::object initNArrayIterator(cv::Mat,cv::Mat {lvalue},CvMatND*,CvNArrayIterator* [,int=0])

initSubdivDelaunay2D(...)


initSubdivDelaunay2D( (CvSubdiv2D)subdiv, (CvRect)rect) -> None :
    
    Wrapped function:
        cvInitSubdivDelaunay2D

    C++ signature :
        void initSubdivDelaunay2D(CvSubdiv2D*,CvRect)

initSystem(...)


initSystem( (Mat)argv) -> object :
    
    Wrapped function:
        cvInitSystem
    Argument 'argc':
        Dependent argument: omitted from the function's calling sequence, as 
        its value is derived from argument 'argv'.
    Argument 'argv':
        C/C++ type: char * *.
        Python type: Mat.
        Invoke asMat() to convert a 1D Python sequence into a Mat, e.g. 
        asMat([0,1,2]) or asMat((0,1,2)).

    C++ signature :
        boost::python::api::object initSystem(cv::Mat)

initUndistortRectifyMap(...)


initUndistortRectifyMap( (Mat)cameraMatrix, (Mat)distCoeffs, (Mat)R, (Mat)newCameraMatrix, (Size2i)size, (object)m1type, (Mat)map1, (Mat)map2) -> None :

    C++ signature :
        void initUndistortRectifyMap(cv::Mat,cv::Mat,cv::Mat,cv::Mat,cv::Size_<int>,int,cv::Mat {lvalue},cv::Mat {lvalue})

inpaint(...)


inpaint( (Mat)src, (Mat)inpaintMask, (Mat)dst, (object)inpaintRange, (object)flags) -> None :

    C++ signature :
        void inpaint(cv::Mat,cv::Mat,cv::Mat {lvalue},double,int)

integral(...)


integral( (Mat)src, (Mat)sum, (Mat)sqsum, (Mat)tilted [, (object)sdepth=-1]) -> None :

    C++ signature :
        void integral(cv::Mat,cv::Mat {lvalue},cv::Mat {lvalue},cv::Mat {lvalue} [,int=-1])

integral( (Mat)src, (Mat)sum, (Mat)sqsum [, (object)sdepth=-1]) -> None :

    C++ signature :
        void integral(cv::Mat,cv::Mat {lvalue},cv::Mat {lvalue} [,int=-1])

integral( (Mat)src, (Mat)sum [, (object)sdepth=-1]) -> None :

    C++ signature :
        void integral(cv::Mat,cv::Mat {lvalue} [,int=-1])

invert(...)


invert( (Mat)a, (Mat)c [, (object)flags=0]) -> float :

    C++ signature :
        double invert(cv::Mat,cv::Mat {lvalue} [,int=0])

invertAffineTransform(...)


invertAffineTransform( (Mat)M, (Mat)iM) -> None :

    C++ signature :
        void invertAffineTransform(cv::Mat,cv::Mat {lvalue})

isContourConvex(...)


isContourConvex( (Mat)contour) -> bool :

    C++ signature :
        bool isContourConvex(cv::Mat)

isInf(...)


isInf( (object)value) -> int :
    
    Wrapped function:
        cvIsInf

    C++ signature :
        int isInf(double)

isNaN(...)


isNaN( (object)value) -> int :
    
    Wrapped function:
        cvIsNaN

    C++ signature :
        int isNaN(double)

kmeans(...)


kmeans( (Mat)data, (object)K, (Mat)best_labels, (TermCriteria)criteria, (object)attempts, (object)flags) -> tuple :
    
    Argument 'centers':
        C/C++ type: ::cv::Mat *.
        Python type: Python equivalence of the C/C++ type without pointer.
        Output argument: omitted from the function's calling sequence, and is 
        returned along with the function's return value (if any).

    C++ signature :
        boost::python::tuple kmeans(cv::Mat,int,cv::Mat {lvalue},cv::TermCriteria,int,int)

line(...)


line( (Mat)img, (Point2i)pt1, (Point2i)pt2, (Scalar)color [, (object)thickness=1 [, (object)lineType=8 [, (object)shift=0]]]) -> None :

    C++ signature :
        void line(cv::Mat {lvalue},cv::Point_<int>,cv::Point_<int>,cv::Scalar_<double> [,int=1 [,int=8 [,int=0]]])

linearPolar(...)


linearPolar( (Mat)src, (Mat)dst, (Point2f)center, (object)maxRadius [, (object)flags=9]) -> None :
    
    Wrapped function:
        cvLinearPolar
    Argument 'src':
        C/C++ type: ::CvArr const *.
        Python type: Mat.
    Argument 'dst':
        C/C++ type: ::CvArr *.
        Python type: Mat.
    Argument 'center':
        C/C++ type: ::CvPoint2D32f.
        Python type: Point2f.

    C++ signature :
        void linearPolar(cv::Mat {lvalue},cv::Mat {lvalue},cv::Point_<float>,double [,int=9])

log(...)


log( (MatND)a, (MatND)b) -> None :

    C++ signature :
        void log(cv::MatND,cv::MatND {lvalue})

log( (Mat)a, (Mat)b) -> None :

    C++ signature :
        void log(cv::Mat,cv::Mat {lvalue})

logPolar(...)


logPolar( (Mat)src, (Mat)dst, (Point2f)center, (object)M [, (object)flags=9]) -> None :
    
    Wrapped function:
        cvLogPolar
    Argument 'src':
        C/C++ type: ::CvArr const *.
        Python type: Mat.
    Argument 'dst':
        C/C++ type: ::CvArr *.
        Python type: Mat.
    Argument 'center':
        C/C++ type: ::CvPoint2D32f.
        Python type: Point2f.

    C++ signature :
        void logPolar(cv::Mat {lvalue},cv::Mat {lvalue},cv::Point_<float>,double [,int=9])

magnitude(...)


magnitude( (Mat)x, (Mat)y, (Mat)magnitude) -> None :

    C++ signature :
        void magnitude(cv::Mat,cv::Mat,cv::Mat {lvalue})

matMulDeriv(...)


matMulDeriv( (Mat)A, (Mat)B, (Mat)dABdA, (Mat)dABdB) -> None :

    C++ signature :
        void matMulDeriv(cv::Mat,cv::Mat,cv::Mat {lvalue},cv::Mat {lvalue})

matchContourTrees(...)


matchContourTrees( (CvContourTree)tree1, (CvContourTree)tree2, (object)method, (object)threshold) -> float :
    
    Wrapped function:
        cvMatchContourTrees

    C++ signature :
        double matchContourTrees(CvContourTree const*,CvContourTree const*,int,double)

matchShapes(...)


matchShapes( (Mat)contour1, (Mat)contour2, (object)method, (object)parameter) -> float :

    C++ signature :
        double matchShapes(cv::Mat,cv::Mat,int,double)

matchTemplate(...)


matchTemplate( (Mat)image, (Mat)templ, (Mat)result, (object)method) -> None :

    C++ signature :
        void matchTemplate(cv::Mat,cv::Mat,cv::Mat {lvalue},int)

max(...)


max( (MatND)a, (object)alpha, (MatND)c) -> None :

    C++ signature :
        void max(cv::MatND,double,cv::MatND {lvalue})

max( (MatND)a, (MatND)b, (MatND)c) -> None :

    C++ signature :
        void max(cv::MatND,cv::MatND,cv::MatND {lvalue})

max( (Mat)a, (object)alpha, (Mat)c) -> None :

    C++ signature :
        void max(cv::Mat,double,cv::Mat {lvalue})

max( (Mat)a, (Mat)b, (Mat)c) -> None :

    C++ signature :
        void max(cv::Mat,cv::Mat,cv::Mat {lvalue})

maxRect(...)


maxRect( (CvRect)rect1, (CvRect)rect2) -> CvRect :
    
    Wrapped function:
        cvMaxRect

    C++ signature :
        CvRect maxRect(CvRect const*,CvRect const*)

mean(...)


mean( (MatND)m [, (MatND)mask]) -> Scalar :

    C++ signature :
        cv::Scalar_<double> mean(cv::MatND [,cv::MatND])

mean( (Mat)m [, (Mat)mask]) -> Scalar :

    C++ signature :
        cv::Scalar_<double> mean(cv::Mat [,cv::Mat])

meanShift(...)


meanShift( (Mat)probImage, (Rect)window, (TermCriteria)criteria) -> int :

    C++ signature :
        int meanShift(cv::Mat,cv::Rect_<int> {lvalue},cv::TermCriteria)

meanStdDev(...)


meanStdDev( (MatND)m, (Scalar)mean, (Scalar)stddev [, (MatND)mask=MatND(shape=(), nchannels=1, depth=0):
array(0, dtype=uint8)]) -> None :

    C++ signature :
        void meanStdDev(cv::MatND,cv::Scalar_<double> {lvalue},cv::Scalar_<double> {lvalue} [,cv::MatND=MatND(shape=(), nchannels=1, depth=0):
array(0, dtype=uint8)])

meanStdDev( (Mat)m, (Scalar)mean, (Scalar)stddev [, (Mat)mask=Mat()]) -> None :

    C++ signature :
        void meanStdDev(cv::Mat,cv::Scalar_<double> {lvalue},cv::Scalar_<double> {lvalue} [,cv::Mat=Mat()])

medianBlur(...)


medianBlur( (Mat)src, (Mat)dst, (object)ksize) -> None :

    C++ signature :
        void medianBlur(cv::Mat,cv::Mat {lvalue},int)

memStorageAllocString(...)


memStorageAllocString( (CvMemStorage)storage, (str)ptr [, (object)len=-1]) -> CvString :
    
    Wrapped function:
        cvMemStorageAllocString

    C++ signature :
        CvString memStorageAllocString(CvMemStorage*,char const* [,int=-1])

merge(...)


merge( (list)mvbegin, (MatND)dst) -> None :
    
    Argument 'count':
        Dependent argument: omitted from the function's calling sequence, as 
        its value is derived from argument 'mvbegin'.
    Argument 'mvbegin':
        C/C++ type: ::cv::MatND const *.
        Python type: list of Mat, e.g. [Mat(), Mat(), Mat()].

    C++ signature :
        void merge(boost::python::list,cv::MatND {lvalue})

merge( (list)mv, (Mat)dst) -> None :
    
    Argument 'count':
        Dependent argument: omitted from the function's calling sequence, as 
        its value is derived from argument 'mv'.
    Argument 'mv':
        C/C++ type: ::cv::Mat const *.
        Python type: list of Mat, e.g. [Mat(), Mat(), Mat()].

    C++ signature :
        void merge(boost::python::list,cv::Mat {lvalue})

min(...)


min( (MatND)a, (object)alpha, (MatND)c) -> None :

    C++ signature :
        void min(cv::MatND,double,cv::MatND {lvalue})

min( (MatND)a, (MatND)b, (MatND)c) -> None :

    C++ signature :
        void min(cv::MatND,cv::MatND,cv::MatND {lvalue})

min( (Mat)a, (object)alpha, (Mat)c) -> None :

    C++ signature :
        void min(cv::Mat,double,cv::Mat {lvalue})

min( (Mat)a, (Mat)b, (Mat)c) -> None :

    C++ signature :
        void min(cv::Mat,cv::Mat,cv::Mat {lvalue})

minAreaRect(...)


minAreaRect( (Mat)points) -> RotatedRect :

    C++ signature :
        cv::RotatedRect minAreaRect(cv::Mat)

minEnclosingCircle(...)


minEnclosingCircle( (Mat)points, (Point2f)center, (object)radius) -> None :

    C++ signature :
        void minEnclosingCircle(cv::Mat,cv::Point_<float> {lvalue},float {lvalue})

minMaxLoc(...)


minMaxLoc( (object)a [, (object)mask=None]) -> tuple :

    C++ signature :
        boost::python::tuple minMaxLoc(boost::python::api::object [,boost::python::api::object=None])

mixChannels(...)


mixChannels( (object)src, (object)dst, (object)fromTo) -> tuple :

    C++ signature :
        boost::python::sequence mixChannels(boost::python::sequence,boost::python::sequence {lvalue},boost::python::ndarray)

moments(...)


moments( (Mat)array [, (bool)binaryImage=False]) -> Moments :

    C++ signature :
        cv::Moments moments(cv::Mat [,bool=False])

morphologyDefaultBorderValue()

    C++ signature :
        cv::Scalar_<double> morphologyDefaultBorderValue()

Returns: Scalar :

morphologyEx(...)


morphologyEx( (Mat)src, (Mat)dst, (object)op, (Mat)kernel [, (Point2i)anchor=Point2i(x=-1, y=-1) [, (object)iterations=1 [, (object)borderType=0 [, (Scalar)borderValue=Scalar([  1.79769313e+308   1.79769313e+308   1.79769313e+308   1.79769313e+308])]]]]) -> None :

    C++ signature :
        void morphologyEx(cv::Mat,cv::Mat {lvalue},int,cv::Mat [,cv::Point_<int>=Point2i(x=-1, y=-1) [,int=1 [,int=0 [,cv::Scalar_<double>=Scalar([  1.79769313e+308   1.79769313e+308   1.79769313e+308   1.79769313e+308])]]]])

moveWindow(...)


moveWindow( (str)name, (object)x, (object)y) -> None :
    
    Wrapped function:
        cvMoveWindow

    C++ signature :
        void moveWindow(char const*,int,int)

mulSpectrums(...)


mulSpectrums( (Mat)a, (Mat)b, (Mat)c, (object)flags [, (bool)conjB=False]) -> None :

    C++ signature :
        void mulSpectrums(cv::Mat,cv::Mat,cv::Mat {lvalue},int [,bool=False])

mulTransposed(...)


mulTransposed( (Mat)a, (Mat)c, (bool)aTa [, (Mat)delta=Mat() [, (object)scale=1 [, (object)rtype=-1]]]) -> None :

    C++ signature :
        void mulTransposed(cv::Mat,cv::Mat {lvalue},bool [,cv::Mat=Mat() [,double=1 [,int=-1]]])

multiply(...)


multiply( (MatND)a, (MatND)b, (MatND)c [, (object)scale=1]) -> None :

    C++ signature :
        void multiply(cv::MatND,cv::MatND,cv::MatND {lvalue} [,double=1])

multiply( (Mat)a, (Mat)b, (Mat)c [, (object)scale=1]) -> None :

    C++ signature :
        void multiply(cv::Mat,cv::Mat,cv::Mat {lvalue} [,double=1])

multiplyAcc(...)


multiplyAcc( (Mat)image1, (Mat)image2, (Mat)acc [, (Mat)mask=Mat()]) -> None :
    
    Wrapped function:
        cvMultiplyAcc
    Argument 'acc':
        C/C++ type: ::CvArr *.
        Python type: Mat.
    Argument 'image2':
        C/C++ type: ::CvArr const *.
        Python type: Mat.
    Argument 'image1':
        C/C++ type: ::CvArr const *.
        Python type: Mat.
    Argument 'mask':
        C/C++ type: ::CvArr const *.
        Python type: Mat.

    C++ signature :
        void multiplyAcc(cv::Mat {lvalue},cv::Mat {lvalue},cv::Mat {lvalue} [,cv::Mat=Mat()])

namedWindow(...)


namedWindow( (object)winname [, (object)flags=1]) -> None :

    C++ signature :
        void namedWindow(std::string [,int=1])

nextNArraySlice(...)


nextNArraySlice( (CvNArrayIterator)array_iterator) -> int :
    
    Wrapped function:
        cvNextNArraySlice

    C++ signature :
        int nextNArraySlice(CvNArrayIterator*)

norm(...)


norm( (SparseMat)src, (object)normType) -> float :

    C++ signature :
        double norm(cv::SparseMat,int)

norm( (MatND)a, (MatND)b [, (object)normType=4 [, (MatND)mask=MatND(shape=(), nchannels=1, depth=0):
array(0, dtype=uint8)]]) -> float :

    C++ signature :
        double norm(cv::MatND,cv::MatND [,int=4 [,cv::MatND=MatND(shape=(), nchannels=1, depth=0):
array(0, dtype=uint8)]])

norm( (MatND)a [, (object)normType=4 [, (MatND)mask=MatND(shape=(), nchannels=1, depth=0):
array(0, dtype=uint8)]]) -> float :

    C++ signature :
        double norm(cv::MatND [,int=4 [,cv::MatND=MatND(shape=(), nchannels=1, depth=0):
array(0, dtype=uint8)]])

norm( (Mat)a, (Mat)b, (object)normType, (Mat)mask) -> float :

    C++ signature :
        double norm(cv::Mat,cv::Mat,int,cv::Mat)

norm( (Mat)a, (object)normType, (Mat)mask) -> float :

    C++ signature :
        double norm(cv::Mat,int,cv::Mat)

norm( (Mat)a, (Mat)b [, (object)normType=4]) -> float :

    C++ signature :
        double norm(cv::Mat,cv::Mat [,int=4])

norm( (Mat)a [, (object)normType=4]) -> float :

    C++ signature :
        double norm(cv::Mat [,int=4])

normalize(...)


normalize( (SparseMat)src, (SparseMat)dst, (object)alpha, (object)normType) -> None :

    C++ signature :
        void normalize(cv::SparseMat,cv::SparseMat {lvalue},double,int)

normalize( (MatND)a, (MatND)b [, (object)alpha=1 [, (object)beta=0 [, (object)norm_type=4 [, (object)rtype=-1 [, (MatND)mask=MatND(shape=(), nchannels=1, depth=0):
array(0, dtype=uint8)]]]]]) -> None :

    C++ signature :
        void normalize(cv::MatND,cv::MatND {lvalue} [,double=1 [,double=0 [,int=4 [,int=-1 [,cv::MatND=MatND(shape=(), nchannels=1, depth=0):
array(0, dtype=uint8)]]]]])

normalize( (Mat)a, (Mat)b [, (object)alpha=1 [, (object)beta=0 [, (object)norm_type=4 [, (object)rtype=-1 [, (Mat)mask=Mat()]]]]]) -> None :

    C++ signature :
        void normalize(cv::Mat,cv::Mat {lvalue} [,double=1 [,double=0 [,int=4 [,int=-1 [,cv::Mat=Mat()]]]]])

openFileStorage(...)


openFileStorage( (str)filename, (CvMemStorage)memstorage, (object)flags) -> CvFileStorage :
    
    Wrapped function:
        cvOpenFileStorage

    C++ signature :
        CvFileStorage* openFileStorage(char const*,CvMemStorage*,int)

patchBasedStdDev(...)


patchBasedStdDev( (Mat)in_image, (Size2i)patch_size, (Mat)out_image) -> None :

    C++ signature :
        void patchBasedStdDev(cv::Mat,cv::Size_<int>,cv::Mat {lvalue})

perspectiveTransform(...)


perspectiveTransform( (Mat)src, (Mat)dst, (Mat)m) -> None :

    C++ signature :
        void perspectiveTransform(cv::Mat,cv::Mat {lvalue},cv::Mat)

phase(...)


phase( (Mat)x, (Mat)y, (Mat)angle [, (bool)angleInDegrees=False]) -> None :

    C++ signature :
        void phase(cv::Mat,cv::Mat,cv::Mat {lvalue} [,bool=False])

pointPolygonTest(...)


pointPolygonTest( (Mat)contour, (Point2f)pt, (bool)measureDist) -> float :

    C++ signature :
        double pointPolygonTest(cv::Mat,cv::Point_<float>,bool)

pointSeqFromMat(...)


pointSeqFromMat( (object)seq_kind, (Mat)mat, (CvContour)contour_header, (CvSeqBlock)block) -> object :
    
    Wrapped function:
        cvPointSeqFromMat
    Argument 'mat':
        C/C++ type: ::CvArr const *.
        Python type: Mat.

    C++ signature :
        boost::python::api::object pointSeqFromMat(int,cv::Mat {lvalue},CvContour*,CvSeqBlock*)

polarToCart(...)


polarToCart( (Mat)magnitude, (Mat)angle, (Mat)x, (Mat)y [, (bool)angleInDegrees=False]) -> None :

    C++ signature :
        void polarToCart(cv::Mat,cv::Mat,cv::Mat {lvalue},cv::Mat {lvalue} [,bool=False])

polylines(...)


polylines( (Mat)img, (object)pts, (bool)isClosed, (Scalar)color [, (object)thickness=1 [, (object)lineType=8 [, (object)shift=0]]]) -> None :
    
    Argument 'npts':
        Dependent argument: omitted from the function's calling sequence, as 
        its value is derived from argument 'pts'.
    Argument 'ncontours':
        Dependent argument: omitted from the function's calling sequence, as 
        its value is derived from argument 'pts'.
    Argument 'pts':
        C/C++ type: ::cv::Point const * *.
        Python type: 2d list.
        Depending on its C++ argument type, it should be a list of Mats or a 
        list of lists.

    C++ signature :
        void polylines(cv::Mat {lvalue},boost::python::api::object,bool,cv::Scalar_<double> [,int=1 [,int=8 [,int=0]]])

pow(...)


pow( (MatND)a, (object)power, (MatND)b) -> None :

    C++ signature :
        void pow(cv::MatND,double,cv::MatND {lvalue})

pow( (Mat)a, (object)power, (Mat)b) -> None :

    C++ signature :
        void pow(cv::Mat,double,cv::Mat {lvalue})

preCornerDetect(...)


preCornerDetect( (Mat)src, (Mat)dst, (object)ksize [, (object)borderType=4]) -> None :

    C++ signature :
        void preCornerDetect(cv::Mat,cv::Mat {lvalue},int [,int=4])

projectPoints(...)


projectPoints( (Mat)objectPoints, (Mat)rvec, (Mat)tvec, (Mat)cameraMatrix, (Mat)distCoeffs) -> object :
    
    Argument 'imagePoints':
        C/C++ type: ::std::vector< cv::Point_<float> > &.
        Python type: Mat.
        Invoke asMat() to convert a 1D Python sequence into a Mat, e.g. 
        asMat([0,1,2]) or asMat((0,1,2)).
        Output argument: omitted from the function's calling sequence, and is 
        returned along with the function's return value (if any).

    C++ signature :
        boost::python::api::object projectPoints(cv::Mat,cv::Mat,cv::Mat,cv::Mat,cv::Mat)

projectPoints2(...)


projectPoints2( (Mat)objectPoints, (Mat)rvec, (Mat)tvec, (Mat)cameraMatrix, (Mat)distCoeffs, (Mat)dpdrot, (Mat)dpdt, (Mat)dpdf, (Mat)dpdc, (Mat)dpddist [, (object)aspectRatio=0]) -> object :
    
    Wrapped function:
        projectPoints
    Argument 'imagePoints':
        C/C++ type: ::std::vector< cv::Point_<float> > &.
        Python type: Mat.
        Invoke asMat() to convert a 1D Python sequence into a Mat, e.g. 
        asMat([0,1,2]) or asMat((0,1,2)).
        Output argument: omitted from the function's calling sequence, and is 
        returned along with the function's return value (if any).

    C++ signature :
        boost::python::api::object projectPoints2(cv::Mat,cv::Mat,cv::Mat,cv::Mat,cv::Mat,cv::Mat {lvalue},cv::Mat {lvalue},cv::Mat {lvalue},cv::Mat {lvalue},cv::Mat {lvalue} [,double=0])

putText(...)


putText( (Mat)img, (object)text, (Point2i)org, (object)fontFace, (object)fontScale, (Scalar)color [, (object)thickness=1 [, (object)linetype=8 [, (bool)bottomLeftOrigin=False]]]) -> None :

    C++ signature :
        void putText(cv::Mat {lvalue},std::string,cv::Point_<int>,int,double,cv::Scalar_<double> [,int=1 [,int=8 [,bool=False]]])

pyrDown(...)


pyrDown( (Mat)src, (Mat)dst [, (Size2i)dstsize=Size2i(width=0, height=0)]) -> None :

    C++ signature :
        void pyrDown(cv::Mat,cv::Mat {lvalue} [,cv::Size_<int>=Size2i(width=0, height=0)])

pyrMeanShiftFiltering(...)


pyrMeanShiftFiltering( (Mat)src, (Mat)dst, (object)sp, (object)sr [, (object)max_level=1 [, (object)termcrit=TermCriteria(type=3, maxCount=5, epsilon=1.0)]]) -> None :
    
    Wrapped function:
        cvPyrMeanShiftFiltering
    Argument 'src':
        C/C++ type: ::CvArr const *.
        Python type: Mat.
    Argument 'dst':
        C/C++ type: ::CvArr *.
        Python type: Mat.

    C++ signature :
        void pyrMeanShiftFiltering(cv::Mat {lvalue},cv::Mat {lvalue},double,double [,int=1 [,CvTermCriteria=TermCriteria(type=3, maxCount=5, epsilon=1.0)]])

pyrSegmentation(...)


pyrSegmentation( (Mat)src, (Mat)dst, (CvMemStorage)storage, (object)level, (object)threshold1, (object)threshold2) -> object :
    
    Wrapped function:
        cvPyrSegmentation
    Argument 'comp':
        C/C++ type: ::CvSeq * *.
        Python type: Python equivalence of the C/C++ type without pointer.
        Output argument: omitted from the function's calling sequence, and is 
        returned along with the function's return value (if any).
    Argument 'dst':
        C/C++ type: ::IplImage *.
        Python type: Mat.
    Argument 'src':
        C/C++ type: ::IplImage *.
        Python type: Mat.

    C++ signature :
        boost::python::api::object pyrSegmentation(cv::Mat {lvalue},cv::Mat {lvalue},CvMemStorage*,int,double,double)

pyrUp(...)


pyrUp( (Mat)src, (Mat)dst [, (Size2i)dstsize=Size2i(width=0, height=0)]) -> None :

    C++ signature :
        void pyrUp(cv::Mat,cv::Mat {lvalue} [,cv::Size_<int>=Size2i(width=0, height=0)])

randArr(...)


randArr( (RNG)rng, (Mat)arr, (object)dist_type, (object)param1, (object)param2) -> None :
    
    Wrapped function:
        cvRandArr
    Argument 'arr':
        C/C++ type: ::CvArr *.
        Python type: Mat.
    Argument 'rng':
        C/C++ type: ::CvRNG *.
        Python type: RNG.

    C++ signature :
        void randArr(cv::RNG {lvalue},cv::Mat {lvalue},int,CvScalar,CvScalar)

randShuffle(...)


randShuffle( (Mat)dst [, (object)iterFactor=1.0 [, (RNG)rng=None]]) -> None :

    C++ signature :
        void randShuffle(cv::Mat {lvalue} [,double=1.0 [,cv::RNG*=None]])

randn(...)


randn( (Mat)dst, (Scalar)mean, (Scalar)stddev) -> None :

    C++ signature :
        void randn(cv::Mat {lvalue},cv::Scalar_<double>,cv::Scalar_<double>)

randu(...)


randu( (Mat)dst, (Scalar)low, (Scalar)high) -> None :

    C++ signature :
        void randu(cv::Mat {lvalue},cv::Scalar_<double>,cv::Scalar_<double>)

range_(...)


range_( (Mat)mat, (object)start, (object)end) -> object :
    
    Wrapped function:
        cvRange
    Argument 'mat':
        C/C++ type: ::CvArr *.
        Python type: Mat.

    C++ signature :
        boost::python::api::object range_(cv::Mat {lvalue},double,double)

readChainPoint(...)


readChainPoint( (CvChainPtReader)reader) -> object :
    
    Wrapped function:
        cvReadChainPoint

    C++ signature :
        CvPoint readChainPoint(CvChainPtReader*)

readInt(...)


readInt( (FileNode)node [, (object)default_value=0]) -> object :
    
    Wrapped function:
        cvReadInt
    Argument 'node':
        C/C++ type: ::CvFileNode const *.
        Python type: FileNode.

    C++ signature :
        boost::python::api::object readInt(cv::FileNode [,int=0])

readIntByName(...)


readIntByName( (CvFileStorage)fs, (FileNode)map, (str)name [, (object)default_value=0]) -> object :
    
    Wrapped function:
        cvReadIntByName
    Argument 'map':
        C/C++ type: ::CvFileNode const *.
        Python type: FileNode.

    C++ signature :
        boost::python::api::object readIntByName(CvFileStorage const*,cv::FileNode,char const* [,int=0])

readReal(...)


readReal( (FileNode)node [, (object)default_value=0.0]) -> object :
    
    Wrapped function:
        cvReadReal
    Argument 'node':
        C/C++ type: ::CvFileNode const *.
        Python type: FileNode.

    C++ signature :
        boost::python::api::object readReal(cv::FileNode [,double=0.0])

readRealByName(...)


readRealByName( (CvFileStorage)fs, (FileNode)map, (str)name [, (object)default_value=0.0]) -> object :
    
    Wrapped function:
        cvReadRealByName
    Argument 'map':
        C/C++ type: ::CvFileNode const *.
        Python type: FileNode.

    C++ signature :
        boost::python::api::object readRealByName(CvFileStorage const*,cv::FileNode,char const* [,double=0.0])

readString(...)


readString( (FileNode)node [, (str)default_value=None]) -> object :
    
    Wrapped function:
        cvReadString
    Argument 'node':
        C/C++ type: ::CvFileNode const *.
        Python type: FileNode.

    C++ signature :
        boost::python::api::object readString(cv::FileNode [,char const*=None])

readStringByName(...)


readStringByName( (CvFileStorage)fs, (FileNode)map, (str)name [, (str)default_value=None]) -> object :
    
    Wrapped function:
        cvReadStringByName
    Argument 'map':
        C/C++ type: ::CvFileNode const *.
        Python type: FileNode.

    C++ signature :
        boost::python::api::object readStringByName(CvFileStorage const*,cv::FileNode,char const* [,char const*=None])

read_KeyPoints(...)


read_KeyPoints( (FileNode)node) -> object :
    
    Wrapped function:
        read
    Argument 'keypoints':
        C/C++ type: ::std::vector< cv::KeyPoint > &.
        Python type: list.
        To convert a Mat into a list, invoke one of Mat's member functions 
        to_list_of_...().
        Output argument: omitted from the function's calling sequence, and is 
        returned along with the function's return value (if any).

    C++ signature :
        boost::python::api::object read_KeyPoints(cv::FileNode)

read_Mat(...)


read_Mat( (FileNode)node [, (Mat)default_mat=Mat()]) -> object :
    
    Wrapped function:
        read

    C++ signature :
        boost::python::api::object read_Mat(cv::FileNode [,cv::Mat=Mat()])

read_MatND(...)


read_MatND( (FileNode)node [, (MatND)default_mat=MatND(shape=(), nchannels=1, depth=0):
array(0, dtype=uint8)]) -> object :
    
    Wrapped function:
        read

    C++ signature :
        boost::python::api::object read_MatND(cv::FileNode [,cv::MatND=MatND(shape=(), nchannels=1, depth=0):
array(0, dtype=uint8)])

read_SparseMat(...)


read_SparseMat( (FileNode)node [, (SparseMat)default_mat=<pyopencv.pyopencvext.SparseMat object at 0x0184F7B0>]) -> object :
    
    Wrapped function:
        read

    C++ signature :
        boost::python::api::object read_SparseMat(cv::FileNode [,cv::SparseMat=<pyopencv.pyopencvext.SparseMat object at 0x0184F7B0>])

read_bool(...)


read_bool( (FileNode)node, (bool)default_value) -> object :
    
    Wrapped function:
        read

    C++ signature :
        boost::python::api::object read_bool(cv::FileNode,bool)

read_double(...)


read_double( (FileNode)node, (object)default_value) -> object :
    
    Wrapped function:
        read

    C++ signature :
        boost::python::api::object read_double(cv::FileNode,double)

read_float(...)


read_float( (FileNode)node, (object)default_value) -> object :
    
    Wrapped function:
        read

    C++ signature :
        boost::python::api::object read_float(cv::FileNode,float)

read_inst(...)


read_inst( (FileNode)node, (object)default_value) -> object :
    
    Wrapped function:
        read

    C++ signature :
        boost::python::api::object read_inst(cv::FileNode,int)

read_schar(...)


read_schar( (FileNode)node, (object)default_value) -> object :
    
    Wrapped function:
        read

    C++ signature :
        boost::python::api::object read_schar(cv::FileNode,signed char)

read_short(...)


read_short( (FileNode)node, (object)default_value) -> object :
    
    Wrapped function:
        read

    C++ signature :
        boost::python::api::object read_short(cv::FileNode,short)

read_str(...)


read_str( (FileNode)node, (object)default_value) -> object :
    
    Wrapped function:
        read

    C++ signature :
        boost::python::api::object read_str(cv::FileNode,std::string)

read_uchar(...)


read_uchar( (FileNode)node, (object)default_value) -> object :
    
    Wrapped function:
        read

    C++ signature :
        boost::python::api::object read_uchar(cv::FileNode,unsigned char)

read_ushort(...)


read_ushort( (FileNode)node, (object)default_value) -> object :
    
    Wrapped function:
        read

    C++ signature :
        boost::python::api::object read_ushort(cv::FileNode,unsigned short)

rectangle(...)


rectangle( (Mat)img, (Rect)rec, (Scalar)color [, (object)thickness=1 [, (object)lineType=8 [, (object)shift=0]]]) -> None :

    C++ signature :
        void rectangle(cv::Mat {lvalue},cv::Rect_<int>,cv::Scalar_<double> [,int=1 [,int=8 [,int=0]]])

rectangle( (Mat)img, (Point2i)pt1, (Point2i)pt2, (Scalar)color [, (object)thickness=1 [, (object)lineType=8 [, (object)shift=0]]]) -> None :

    C++ signature :
        void rectangle(cv::Mat {lvalue},cv::Point_<int>,cv::Point_<int>,cv::Scalar_<double> [,int=1 [,int=8 [,int=0]]])

reduce(...)


reduce( (Mat)m, (Mat)dst, (object)dim, (object)rtype [, (object)dtype=-1]) -> None :

    C++ signature :
        void reduce(cv::Mat,cv::Mat {lvalue},int,int [,int=-1])

registerModule(...)


registerModule( (CvModuleInfo)module_info) -> int :
    
    Wrapped function:
        cvRegisterModule

    C++ signature :
        int registerModule(CvModuleInfo const*)

registerType(...)


registerType( (CvTypeInfo)info) -> None :
    
    Wrapped function:
        cvRegisterType

    C++ signature :
        void registerType(CvTypeInfo const*)

remap(...)


remap( (Mat)src, (Mat)dst, (Mat)map1, (Mat)map2, (object)interpolation [, (object)borderMode=0 [, (Scalar)borderValue=Scalar([ 0.  0.  0.  0.])]]) -> None :

    C++ signature :
        void remap(cv::Mat,cv::Mat {lvalue},cv::Mat,cv::Mat,int [,int=0 [,cv::Scalar_<double>=Scalar([ 0.  0.  0.  0.])]])

repeat(...)


repeat( (Mat)src, (object)ny, (object)nx) -> Mat :

    C++ signature :
        cv::Mat repeat(cv::Mat,int,int)

repeat( (Mat)a, (object)ny, (object)nx, (Mat)b) -> None :

    C++ signature :
        void repeat(cv::Mat,int,int,cv::Mat {lvalue})

reprojectImageTo3D(...)


reprojectImageTo3D( (Mat)disparityImage, (Mat)_3dImage, (Mat)Q [, (object)handleMissingValues=0]) -> None :
    
    Wrapped function:
        cvReprojectImageTo3D
    Argument 'Q':
        C/C++ type: ::CvMat const *.
        Python type: Mat.
    Argument 'disparityImage':
        C/C++ type: ::CvArr const *.
        Python type: Mat.
    Argument '_3dImage':
        C/C++ type: ::CvArr *.
        Python type: Mat.

    C++ signature :
        void reprojectImageTo3D(cv::Mat {lvalue},cv::Mat {lvalue},cv::Mat {lvalue} [,int=0])

reprojectImageTo3D( (Mat)disparity, (Mat)_3dImage, (Mat)Q [, (bool)handleMissingValues=False]) -> None :

    C++ signature :
        void reprojectImageTo3D(cv::Mat,cv::Mat {lvalue},cv::Mat [,bool=False])

resize(...)


resize( (Mat)src, (Mat)dst, (Size2i)dsize [, (object)fx=0 [, (object)fy=0 [, (object)interpolation=1]]]) -> None :

    C++ signature :
        void resize(cv::Mat,cv::Mat {lvalue},cv::Size_<int> [,double=0 [,double=0 [,int=1]]])

resizeWindow(...)


resizeWindow( (str)name, (object)width, (object)height) -> None :
    
    Wrapped function:
        cvResizeWindow

    C++ signature :
        void resizeWindow(char const*,int,int)

restoreMemStoragePos(...)


restoreMemStoragePos( (CvMemStorage)storage, (CvMemStoragePos)pos) -> None :
    
    Wrapped function:
        cvRestoreMemStoragePos

    C++ signature :
        void restoreMemStoragePos(CvMemStorage*,CvMemStoragePos*)

round(...)


round( (object)value) -> int :
    
    Wrapped function:
        cvRound

    C++ signature :
        int round(double)

runningAvg(...)


runningAvg( (Mat)image, (Mat)acc, (object)alpha [, (Mat)mask=Mat()]) -> None :
    
    Wrapped function:
        cvRunningAvg
    Argument 'acc':
        C/C++ type: ::CvArr *.
        Python type: Mat.
    Argument 'image':
        C/C++ type: ::CvArr const *.
        Python type: Mat.
    Argument 'mask':
        C/C++ type: ::CvArr const *.
        Python type: Mat.

    C++ signature :
        void runningAvg(cv::Mat {lvalue},cv::Mat {lvalue},double [,cv::Mat=Mat()])

sampleLine(...)


sampleLine( (Mat)image, (object)pt1, (object)pt2, (object)buffer [, (object)connectivity=8]) -> object :
    
    Wrapped function:
        cvSampleLine
    Argument 'image':
        C/C++ type: ::CvArr const *.
        Python type: Mat.

    C++ signature :
        boost::python::api::object sampleLine(cv::Mat {lvalue},CvPoint,CvPoint,void* [,int=8])

saveMemStoragePos(...)


saveMemStoragePos( (CvMemStorage)storage, (CvMemStoragePos)pos) -> None :
    
    Wrapped function:
        cvSaveMemStoragePos

    C++ signature :
        void saveMemStoragePos(CvMemStorage const*,CvMemStoragePos*)

scaleAdd(...)


scaleAdd( (MatND)a, (object)alpha, (MatND)b, (MatND)c) -> None :

    C++ signature :
        void scaleAdd(cv::MatND,double,cv::MatND,cv::MatND {lvalue})

scaleAdd( (Mat)a, (object)alpha, (Mat)b, (Mat)c) -> None :

    C++ signature :
        void scaleAdd(cv::Mat,double,cv::Mat,cv::Mat {lvalue})

segmentImage(...)


segmentImage( (Mat)srcarr, (Mat)dstarr, (object)canny_threshold, (object)ffill_threshold, (CvMemStorage)storage) -> object :
    
    Wrapped function:
        cvSegmentImage
    Argument 'dstarr':
        C/C++ type: ::CvArr *.
        Python type: Mat.
    Argument 'srcarr':
        C/C++ type: ::CvArr const *.
        Python type: Mat.

    C++ signature :
        boost::python::api::object segmentImage(cv::Mat {lvalue},cv::Mat {lvalue},double,double,CvMemStorage*)

segmentMotion(...)


segmentMotion( (Mat)mhi, (Mat)seg_mask, (CvMemStorage)storage, (object)timestamp, (object)seg_thresh) -> object :
    
    Wrapped function:
        cvSegmentMotion
    Argument 'seg_mask':
        C/C++ type: ::CvArr *.
        Python type: Mat.
    Argument 'mhi':
        C/C++ type: ::CvArr const *.
        Python type: Mat.

    C++ signature :
        boost::python::api::object segmentMotion(cv::Mat {lvalue},cv::Mat {lvalue},CvMemStorage*,double,double)

sepFilter2D(...)


sepFilter2D( (Mat)src, (Mat)dst, (object)ddepth, (Mat)kernelX, (Mat)kernelY [, (Point2i)anchor=Point2i(x=-1, y=-1) [, (object)delta=0 [, (object)borderType=4]]]) -> None :

    C++ signature :
        void sepFilter2D(cv::Mat,cv::Mat {lvalue},int,cv::Mat,cv::Mat [,cv::Point_<int>=Point2i(x=-1, y=-1) [,double=0 [,int=4]]])

seqInsertSlice(...)


seqInsertSlice( (CvSeq)seq, (object)before_index, (Mat)from_arr) -> None :
    
    Wrapped function:
        cvSeqInsertSlice
    Argument 'from_arr':
        C/C++ type: ::CvArr const *.
        Python type: Mat.

    C++ signature :
        void seqInsertSlice(CvSeq*,int,cv::Mat {lvalue})

seqInvert(...)


seqInvert( (CvSeq)seq) -> None :
    
    Wrapped function:
        cvSeqInvert

    C++ signature :
        void seqInvert(CvSeq*)

seqRemove(...)


seqRemove( (CvSeq)seq, (object)index) -> None :
    
    Wrapped function:
        cvSeqRemove

    C++ signature :
        void seqRemove(CvSeq*,int)

seqRemoveSlice(...)


seqRemoveSlice( (CvSeq)seq, (Range)slice) -> None :
    
    Wrapped function:
        cvSeqRemoveSlice

    C++ signature :
        void seqRemoveSlice(CvSeq*,CvSlice)

seqSlice(...)


seqSlice( (CvSeq)seq, (Range)slice [, (CvMemStorage)storage=None [, (object)copy_data=0]]) -> CvSeq :
    
    Wrapped function:
        cvSeqSlice

    C++ signature :
        CvSeq* seqSlice(CvSeq const*,CvSlice [,CvMemStorage*=None [,int=0]])

setErrMode(...)


setErrMode( (object)mode) -> int :
    
    Wrapped function:
        cvSetErrMode

    C++ signature :
        int setErrMode(int)

setErrStatus(...)


setErrStatus( (object)status) -> None :
    
    Wrapped function:
        cvSetErrStatus

    C++ signature :
        void setErrStatus(int)

setIdentity(...)


setIdentity( (Mat)c [, (Scalar)s=Scalar([ 1.  0.  0.  0.])]) -> None :

    C++ signature :
        void setIdentity(cv::Mat {lvalue} [,cv::Scalar_<double>=Scalar([ 1.  0.  0.  0.])])

setNumThreads(...)


setNumThreads([  (object)threads=0]) -> None :
    
    Wrapped function:
        cvSetNumThreads

    C++ signature :
        void setNumThreads([ int=0])

setNumThreads( (object)arg0) -> None :

    C++ signature :
        void setNumThreads(int)

setRemove(...)


setRemove( (CvSet)set_header, (object)index) -> None :
    
    Wrapped function:
        cvSetRemove

    C++ signature :
        void setRemove(CvSet*,int)

setSeqBlockSize(...)


setSeqBlockSize( (CvSeq)seq, (object)delta_elems) -> None :
    
    Wrapped function:
        cvSetSeqBlockSize

    C++ signature :
        void setSeqBlockSize(CvSeq*,int)

setSeqReaderPos(...)


setSeqReaderPos( (CvSeqReader)reader, (object)index [, (object)is_relative=0]) -> None :
    
    Wrapped function:
        cvSetSeqReaderPos

    C++ signature :
        void setSeqReaderPos(CvSeqReader*,int [,int=0])

setTrackbarPos(...)


setTrackbarPos( (str)trackbar_name, (str)window_name, (object)pos) -> None :
    
    Wrapped function:
        cvSetTrackbarPos

    C++ signature :
        void setTrackbarPos(char const*,char const*,int)

setUseOptimized(...)


setUseOptimized( (bool)arg0) -> None :

    C++ signature :
        void setUseOptimized(bool)

setWindowProperty(...)


setWindowProperty( (object)winname, (object)prop_id, (object)prop_value) -> None :

    C++ signature :
        void setWindowProperty(std::string,int,double)

sliceLength(...)


sliceLength( (Range)slice, (CvSeq)seq) -> int :
    
    Wrapped function:
        cvSliceLength

    C++ signature :
        int sliceLength(CvSlice,CvSeq const*)

smooth(...)


smooth( (Mat)src, (Mat)dst [, (object)smoothtype=2 [, (object)size1=3 [, (object)size2=0 [, (object)sigma1=0 [, (object)sigma2=0]]]]]) -> None :
    
    Wrapped function:
        cvSmooth
    Argument 'src':
        C/C++ type: ::CvArr const *.
        Python type: Mat.
    Argument 'dst':
        C/C++ type: ::CvArr *.
        Python type: Mat.

    C++ signature :
        void smooth(cv::Mat {lvalue},cv::Mat {lvalue} [,int=2 [,int=3 [,int=0 [,double=0 [,double=0]]]]])

snakeImage(...)


snakeImage( (Mat)image, (Mat)points, (object)alpha, (object)beta, (object)gamma, (object)coeff_usage, (Size2i)win, (TermCriteria)criteria [, (object)calc_gradient=1]) -> None :

    C++ signature :
        void snakeImage(cv::Mat,cv::Mat,boost::python::api::object,boost::python::api::object,boost::python::api::object,int,cv::Size_<int>,cv::TermCriteria [,int=1])

solve(...)


solve( (Mat)a, (Mat)b, (Mat)x [, (object)flags=0]) -> bool :

    C++ signature :
        bool solve(cv::Mat,cv::Mat,cv::Mat {lvalue} [,int=0])

solveCubic(...)


solveCubic( (Mat)coeffs, (Mat)roots) -> object :
    
    Wrapped function:
        cvSolveCubic
    Argument 'coeffs':
        C/C++ type: ::CvMat const *.
        Python type: Mat.
    Argument 'roots':
        C/C++ type: ::CvMat *.
        Python type: Mat.

    C++ signature :
        boost::python::api::object solveCubic(cv::Mat {lvalue},cv::Mat {lvalue})

solvePnP(...)


solvePnP( (Mat)objectPoints, (Mat)imagePoints, (Mat)cameraMatrix, (Mat)distCoeffs, (Mat)rvec, (Mat)tvec [, (bool)useExtrinsicGuess=False]) -> None :

    C++ signature :
        void solvePnP(cv::Mat,cv::Mat,cv::Mat,cv::Mat,cv::Mat {lvalue},cv::Mat {lvalue} [,bool=False])

solvePoly(...)


solvePoly( (Mat)coeffs, (Mat)roots2 [, (object)maxiter=20 [, (object)fig=100]]) -> None :
    
    Wrapped function:
        cvSolvePoly
    Argument 'coeffs':
        C/C++ type: ::CvMat const *.
        Python type: Mat.
    Argument 'roots2':
        C/C++ type: ::CvMat *.
        Python type: Mat.

    C++ signature :
        void solvePoly(cv::Mat {lvalue},cv::Mat {lvalue} [,int=20 [,int=100]])

sort(...)


sort( (Mat)a, (Mat)b, (object)flags) -> None :

    C++ signature :
        void sort(cv::Mat,cv::Mat {lvalue},int)

sortIdx(...)


sortIdx( (Mat)a, (Mat)b, (object)flags) -> None :

    C++ signature :
        void sortIdx(cv::Mat,cv::Mat {lvalue},int)

split(...)


split( (MatND)m, (list)mv) -> None :
    
    Argument 'mv':
        C/C++ type: ::cv::MatND *.
        Python type: list of Mat, e.g. [Mat(), Mat(), Mat()].

    C++ signature :
        void split(cv::MatND,boost::python::list)

split( (Mat)m, (list)mvbegin) -> None :
    
    Argument 'mvbegin':
        C/C++ type: ::cv::Mat *.
        Python type: list of Mat, e.g. [Mat(), Mat(), Mat()].

    C++ signature :
        void split(cv::Mat,boost::python::list)

sqrt(...)


sqrt( (MatND)a, (MatND)b) -> None :

    C++ signature :
        void sqrt(cv::MatND,cv::MatND {lvalue})

sqrt( (Mat)a, (Mat)b) -> None :

    C++ signature :
        void sqrt(cv::Mat,cv::Mat {lvalue})

squareAcc(...)


squareAcc( (Mat)image, (Mat)sqsum [, (Mat)mask=Mat()]) -> None :
    
    Wrapped function:
        cvSquareAcc
    Argument 'mask':
        C/C++ type: ::CvArr const *.
        Python type: Mat.
    Argument 'image':
        C/C++ type: ::CvArr const *.
        Python type: Mat.
    Argument 'sqsum':
        C/C++ type: ::CvArr *.
        Python type: Mat.

    C++ signature :
        void squareAcc(cv::Mat {lvalue},cv::Mat {lvalue} [,cv::Mat=Mat()])

starKeypoint(...)


starKeypoint( (object)pt, (object)size, (object)response) -> CvStarKeypoint :
    
    Wrapped function:
        cvStarKeypoint

    C++ signature :
        CvStarKeypoint starKeypoint(CvPoint,int,float)

startAppendToSeq(...)


startAppendToSeq( (CvSeq)seq, (CvSeqWriter)writer) -> None :
    
    Wrapped function:
        cvStartAppendToSeq

    C++ signature :
        void startAppendToSeq(CvSeq*,CvSeqWriter*)

startFindContours(...)


startFindContours( (Mat)image, (CvMemStorage)storage [, (object)header_size=88 [, (object)mode=1 [, (object)method=2 [, (object)offset=Point2i(x=0, y=0)]]]]) -> object :
    
    Wrapped function:
        cvStartFindContours
    Argument 'image':
        C/C++ type: ::CvArr *.
        Python type: Mat.

    C++ signature :
        boost::python::api::object startFindContours(cv::Mat {lvalue},CvMemStorage* [,int=88 [,int=1 [,int=2 [,CvPoint=Point2i(x=0, y=0)]]]])

startNextStream(...)


startNextStream( (FileStorage)fs) -> None :
    
    Wrapped function:
        cvStartNextStream
    Argument 'fs':
        C/C++ type: ::CvFileStorage *.
        Python type: FileStorage.

    C++ signature :
        void startNextStream(cv::FileStorage {lvalue})

startReadChainPoints(...)


startReadChainPoints( (CvChain)chain, (CvChainPtReader)reader) -> None :
    
    Wrapped function:
        cvStartReadChainPoints

    C++ signature :
        void startReadChainPoints(CvChain*,CvChainPtReader*)

startReadRawData(...)


startReadRawData( (CvFileStorage)fs, (FileNode)src, (CvSeqReader)reader) -> None :
    
    Wrapped function:
        cvStartReadRawData
    Argument 'src':
        C/C++ type: ::CvFileNode const *.
        Python type: FileNode.

    C++ signature :
        void startReadRawData(CvFileStorage const*,cv::FileNode,CvSeqReader*)

startReadSeq(...)


startReadSeq( (CvSeq)seq, (CvSeqReader)reader [, (object)reverse=0]) -> None :
    
    Wrapped function:
        cvStartReadSeq

    C++ signature :
        void startReadSeq(CvSeq const*,CvSeqReader* [,int=0])

startWindowThread()

    Wrapped function:
        cvStartWindowThread

    C++ signature :
        int startWindowThread()

Returns: int :

startWriteSeq(...)


startWriteSeq( (object)seq_flags, (object)header_size, (object)elem_size, (CvMemStorage)storage, (CvSeqWriter)writer) -> None :
    
    Wrapped function:
        cvStartWriteSeq

    C++ signature :
        void startWriteSeq(int,int,int,CvMemStorage*,CvSeqWriter*)

startWriteStruct(...)


startWriteStruct( (FileStorage)fs, (str)name, (object)struct_flags [, (str)type_name=None [, (CvAttrList)attributes=<pyopencv.pyopencvext.CvAttrList object at 0x0184F5B0>]]) -> None :
    
    Wrapped function:
        cvStartWriteStruct
    Argument 'fs':
        C/C++ type: ::CvFileStorage *.
        Python type: FileStorage.

    C++ signature :
        void startWriteStruct(cv::FileStorage {lvalue},char const*,int [,char const*=None [,CvAttrList=<pyopencv.pyopencvext.CvAttrList object at 0x0184F5B0>]])

stereoCalibrate(...)


stereoCalibrate( (list)objectPoints, (list)imagePoints1, (list)imagePoints2, (Mat)cameraMatrix1, (Mat)distCoeffs1, (Mat)cameraMatrix2, (Mat)distCoeffs2, (Size2i)imageSize, (Mat)R, (Mat)T, (Mat)E, (Mat)F [, (TermCriteria)criteria=TermCriteria(type=3, maxCount=30, epsilon=9.9999999999999995e-07) [, (object)flags=256]]) -> object :
    
    Argument 'objectPoints':
        C/C++ type: ::std::vector< std::vector< cv::Point3_<float> > > const 
        &.
        Python type: list of Mat, e.g. [Mat(), Mat(), Mat()].
        Invoke asMat() to convert every 1D Python sequence into a Mat, e.g. 
        [asMat([0,1,2]), asMat((0,1,2)].
    Argument 'imagePoints2':
        C/C++ type: ::std::vector< std::vector< cv::Point_<float> > > const &.
        Python type: list of Mat, e.g. [Mat(), Mat(), Mat()].
        Invoke asMat() to convert every 1D Python sequence into a Mat, e.g. 
        [asMat([0,1,2]), asMat((0,1,2)].
    Argument 'imagePoints1':
        C/C++ type: ::std::vector< std::vector< cv::Point_<float> > > const &.
        Python type: list of Mat, e.g. [Mat(), Mat(), Mat()].
        Invoke asMat() to convert every 1D Python sequence into a Mat, e.g. 
        [asMat([0,1,2]), asMat((0,1,2)].

    C++ signature :
        boost::python::api::object stereoCalibrate(boost::python::list,boost::python::list,boost::python::list,cv::Mat {lvalue},cv::Mat {lvalue},cv::Mat {lvalue},cv::Mat {lvalue},cv::Size_<int>,cv::Mat {lvalue},cv::Mat {lvalue},cv::Mat {lvalue},cv::Mat {lvalue} [,cv::TermCriteria=TermCriteria(type=3, maxCount=30, epsilon=9.9999999999999995e-07) [,int=256]])

stereoRectifyUncalibrated(...)


stereoRectifyUncalibrated( (Mat)points1, (Mat)points2, (Mat)F, (Size2i)imgSize, (Mat)H1, (Mat)H2 [, (object)threshold=5]) -> bool :

    C++ signature :
        bool stereoRectifyUncalibrated(cv::Mat,cv::Mat,cv::Mat,cv::Size_<int>,cv::Mat {lvalue},cv::Mat {lvalue} [,double=5])

subdiv2DEdgeDst(...)


subdiv2DEdgeDst( (object)edge) -> CvSubdiv2DPoint :
    
    Wrapped function:
        cvSubdiv2DEdgeDst

    C++ signature :
        CvSubdiv2DPoint* subdiv2DEdgeDst(unsigned int)

subdiv2DEdgeOrg(...)


subdiv2DEdgeOrg( (object)edge) -> CvSubdiv2DPoint :
    
    Wrapped function:
        cvSubdiv2DEdgeOrg

    C++ signature :
        CvSubdiv2DPoint* subdiv2DEdgeOrg(unsigned int)

subdiv2DGetEdge(...)


subdiv2DGetEdge( (object)edge, (CvNextEdgeType)type) -> int :
    
    Wrapped function:
        cvSubdiv2DGetEdge

    C++ signature :
        unsigned int subdiv2DGetEdge(unsigned int,CvNextEdgeType)

subdiv2DLocate(...)


subdiv2DLocate( (CvSubdiv2D)subdiv, (Point2f)pt, (object)edge) -> tuple :
    
    Wrapped function:
        cvSubdiv2DLocate
    Argument 'vertex':
        C/C++ type: ::CvSubdiv2DPoint * *.
        Python type: Python equivalence of the C/C++ type without pointer.
        Output argument: omitted from the function's calling sequence, and is 
        returned along with the function's return value (if any).
    Argument 'pt':
        C/C++ type: ::CvPoint2D32f.
        Python type: Point2f.

    C++ signature :
        boost::python::tuple subdiv2DLocate(CvSubdiv2D*,cv::Point_<float>,unsigned int*)

subdiv2DNextEdge(...)


subdiv2DNextEdge( (object)edge) -> int :
    
    Wrapped function:
        cvSubdiv2DNextEdge

    C++ signature :
        unsigned int subdiv2DNextEdge(unsigned int)

subdiv2DRotateEdge(...)


subdiv2DRotateEdge( (object)edge, (object)rotate) -> int :
    
    Wrapped function:
        cvSubdiv2DRotateEdge

    C++ signature :
        unsigned int subdiv2DRotateEdge(unsigned int,int)

subdiv2DSymEdge(...)


subdiv2DSymEdge( (object)edge) -> int :
    
    Wrapped function:
        cvSubdiv2DSymEdge

    C++ signature :
        unsigned int subdiv2DSymEdge(unsigned int)

subdivDelaunay2DInsert(...)


subdivDelaunay2DInsert( (CvSubdiv2D)subdiv, (Point2f)pt) -> object :
    
    Wrapped function:
        cvSubdivDelaunay2DInsert
    Argument 'pt':
        C/C++ type: ::CvPoint2D32f.
        Python type: Point2f.

    C++ signature :
        boost::python::api::object subdivDelaunay2DInsert(CvSubdiv2D*,cv::Point_<float>)

substituteContour(...)


substituteContour( (CvContourScanner)scanner, (CvSeq)new_contour) -> None :
    
    Wrapped function:
        cvSubstituteContour

    C++ signature :
        void substituteContour(_CvContourScanner*,CvSeq*)

subtract(...)


subtract( (MatND)a, (Scalar)s, (MatND)c [, (MatND)mask=MatND(shape=(), nchannels=1, depth=0):
array(0, dtype=uint8)]) -> None :

    C++ signature :
        void subtract(cv::MatND,cv::Scalar_<double>,cv::MatND {lvalue} [,cv::MatND=MatND(shape=(), nchannels=1, depth=0):
array(0, dtype=uint8)])

subtract( (Scalar)s, (MatND)a, (MatND)c [, (MatND)mask=MatND(shape=(), nchannels=1, depth=0):
array(0, dtype=uint8)]) -> None :

    C++ signature :
        void subtract(cv::Scalar_<double>,cv::MatND,cv::MatND {lvalue} [,cv::MatND=MatND(shape=(), nchannels=1, depth=0):
array(0, dtype=uint8)])

subtract( (MatND)a, (MatND)b, (MatND)c) -> None :

    C++ signature :
        void subtract(cv::MatND,cv::MatND,cv::MatND {lvalue})

subtract( (MatND)a, (MatND)b, (MatND)c, (MatND)mask) -> None :

    C++ signature :
        void subtract(cv::MatND,cv::MatND,cv::MatND {lvalue},cv::MatND)

subtract( (Scalar)s, (Mat)a, (Mat)c [, (Mat)mask=Mat()]) -> None :

    C++ signature :
        void subtract(cv::Scalar_<double>,cv::Mat,cv::Mat {lvalue} [,cv::Mat=Mat()])

subtract( (Mat)a, (Scalar)s, (Mat)c [, (Mat)mask=Mat()]) -> None :

    C++ signature :
        void subtract(cv::Mat,cv::Scalar_<double>,cv::Mat {lvalue} [,cv::Mat=Mat()])

subtract( (Mat)a, (Mat)b, (Mat)c) -> None :

    C++ signature :
        void subtract(cv::Mat,cv::Mat,cv::Mat {lvalue})

subtract( (Mat)a, (Mat)b, (Mat)c, (Mat)mask) -> None :

    C++ signature :
        void subtract(cv::Mat,cv::Mat,cv::Mat {lvalue},cv::Mat)

sum(...)


sum( (MatND)m) -> Scalar :

    C++ signature :
        cv::Scalar_<double> sum(cv::MatND)

sum( (Mat)m) -> Scalar :

    C++ signature :
        cv::Scalar_<double> sum(cv::Mat)

theRNG()

    C++ signature :
        cv::RNG {lvalue} theRNG()

Returns: RNG :

threshold(...)


threshold( (Mat)src, (Mat)dst, (object)thresh, (object)maxval, (object)type) -> float :

    C++ signature :
        double threshold(cv::Mat,cv::Mat {lvalue},double,double,int)

toUtf16(...)


toUtf16( (object)str) -> unicode :

    C++ signature :
        std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t> > toUtf16(std::string)

trace(...)


trace( (Mat)m) -> Scalar :

    C++ signature :
        cv::Scalar_<double> trace(cv::Mat)

transform(...)


transform( (Mat)src, (Mat)dst, (Mat)m) -> None :

    C++ signature :
        void transform(cv::Mat,cv::Mat {lvalue},cv::Mat)

transpose(...)


transpose( (Mat)a, (Mat)b) -> None :

    C++ signature :
        void transpose(cv::Mat,cv::Mat {lvalue})

triangleArea(...)


triangleArea( (Point2f)a, (Point2f)b, (Point2f)c) -> object :
    
    Wrapped function:
        cvTriangleArea
    Argument 'a':
        C/C++ type: ::CvPoint2D32f.
        Python type: Point2f.
    Argument 'c':
        C/C++ type: ::CvPoint2D32f.
        Python type: Point2f.
    Argument 'b':
        C/C++ type: ::CvPoint2D32f.
        Python type: Point2f.

    C++ signature :
        boost::python::api::object triangleArea(cv::Point_<float>,cv::Point_<float>,cv::Point_<float>)

triangulatePoints(...)


triangulatePoints( (Mat)projMatr1, (Mat)projMatr2, (Mat)projPoints1, (Mat)projPoints2, (Mat)points4D) -> None :
    
    Wrapped function:
        cvTriangulatePoints
    Argument 'projPoints2':
        C/C++ type: ::CvMat *.
        Python type: Mat.
    Argument 'projPoints1':
        C/C++ type: ::CvMat *.
        Python type: Mat.
    Argument 'projMatr2':
        C/C++ type: ::CvMat *.
        Python type: Mat.
    Argument 'points4D':
        C/C++ type: ::CvMat *.
        Python type: Mat.
    Argument 'projMatr1':
        C/C++ type: ::CvMat *.
        Python type: Mat.

    C++ signature :
        void triangulatePoints(cv::Mat {lvalue},cv::Mat {lvalue},cv::Mat {lvalue},cv::Mat {lvalue},cv::Mat {lvalue})

typeOf(...)


typeOf( (object)struct_ptr) -> object :
    
    Wrapped function:
        cvTypeOf

    C++ signature :
        boost::python::api::object typeOf(void*)

undistort(...)


undistort( (Mat)src, (Mat)dst, (Mat)cameraMatrix, (Mat)distCoeffs [, (Mat)newCameraMatrix=Mat()]) -> None :

    C++ signature :
        void undistort(cv::Mat,cv::Mat {lvalue},cv::Mat,cv::Mat [,cv::Mat=Mat()])

undistortPoints(...)


undistortPoints( (Mat)src, (Mat)dst, (Mat)cameraMatrix, (Mat)distCoeffs [, (Mat)R=Mat() [, (Mat)P=Mat()]]) -> None :

    C++ signature :
        void undistortPoints(cv::Mat,cv::Mat {lvalue},cv::Mat,cv::Mat [,cv::Mat=Mat() [,cv::Mat=Mat()]])

undistortPoints2(...)


undistortPoints2( (Mat)src, (Mat)cameraMatrix, (Mat)distCoeffs [, (Mat)R=Mat() [, (Mat)P=Mat()]]) -> object :
    
    Wrapped function:
        undistortPoints
    Argument 'dst':
        C/C++ type: ::std::vector< cv::Point_<float> > &.
        Python type: Mat.
        Invoke asMat() to convert a 1D Python sequence into a Mat, e.g. 
        asMat([0,1,2]) or asMat((0,1,2)).
        Output argument: omitted from the function's calling sequence, and is 
        returned along with the function's return value (if any).

    C++ signature :
        boost::python::api::object undistortPoints2(cv::Mat,cv::Mat,cv::Mat [,cv::Mat=Mat() [,cv::Mat=Mat()]])

unregisterType(...)


unregisterType( (str)type_name) -> None :
    
    Wrapped function:
        cvUnregisterType

    C++ signature :
        void unregisterType(char const*)

updateMotionHistory(...)


updateMotionHistory( (Mat)silhouette, (Mat)mhi, (object)timestamp, (object)duration) -> None :
    
    Wrapped function:
        cvUpdateMotionHistory
    Argument 'silhouette':
        C/C++ type: ::CvArr const *.
        Python type: Mat.
    Argument 'mhi':
        C/C++ type: ::CvArr *.
        Python type: Mat.

    C++ signature :
        void updateMotionHistory(cv::Mat {lvalue},cv::Mat {lvalue},double,double)

updateMotionHistory( (Mat)silhouette, (Mat)mhi, (object)timestamp, (object)duration) -> None :

    C++ signature :
        void updateMotionHistory(cv::Mat,cv::Mat {lvalue},double,double)

useOptimized(...)


useOptimized( (object)on_off) -> int :
    
    Wrapped function:
        cvUseOptimized

    C++ signature :
        int useOptimized(int)

useOptimized() -> bool :

    C++ signature :
        bool useOptimized()

validateDisparity(...)


validateDisparity( (Mat)disparity, (Mat)cost, (object)minDisparity, (object)numberOfDisparities [, (object)disp12MaxDisp=1]) -> None :

    C++ signature :
        void validateDisparity(cv::Mat {lvalue},cv::Mat,int,int [,int=1])

waitKey(...)


waitKey([  (object)delay=0]) -> int :

    C++ signature :
        int waitKey([ int=0])

warpAffine(...)


warpAffine( (Mat)src, (Mat)dst, (Mat)M, (Size2i)dsize [, (object)flags=1 [, (object)borderMode=0 [, (Scalar)borderValue=Scalar([ 0.  0.  0.  0.])]]]) -> None :

    C++ signature :
        void warpAffine(cv::Mat,cv::Mat {lvalue},cv::Mat,cv::Size_<int> [,int=1 [,int=0 [,cv::Scalar_<double>=Scalar([ 0.  0.  0.  0.])]]])

warpPerspective(...)


warpPerspective( (Mat)src, (Mat)dst, (Mat)M, (Size2i)dsize [, (object)flags=1 [, (object)borderMode=0 [, (Scalar)borderValue=Scalar([ 0.  0.  0.  0.])]]]) -> None :

    C++ signature :
        void warpPerspective(cv::Mat,cv::Mat {lvalue},cv::Mat,cv::Size_<int> [,int=1 [,int=0 [,cv::Scalar_<double>=Scalar([ 0.  0.  0.  0.])]]])

watershed(...)


watershed( (Mat)image, (Mat)markers) -> None :

    C++ signature :
        void watershed(cv::Mat,cv::Mat {lvalue})

write(...)


write( (FileStorage)fs, (str)name, (str)ptr [, (CvAttrList)attributes=<pyopencv.pyopencvext.CvAttrList object at 0x0184F5F0>]) -> None :
    
    Wrapped function:
        cvWrite
    Argument 'fs':
        C/C++ type: ::CvFileStorage *.
        Python type: FileStorage.
    Argument 'ptr':
        C/C++ type: void const *.
        Python type: string.

    C++ signature :
        void write(cv::FileStorage {lvalue},char const*,char const* [,CvAttrList=<pyopencv.pyopencvext.CvAttrList object at 0x0184F5F0>])

write( (FileStorage)fs, (object)name, (list)keypoints) -> None :
    
    Argument 'keypoints':
        C/C++ type: ::std::vector< cv::KeyPoint > const &.
        Python type: list.
        To convert a Mat into a list, invoke one of Mat's member functions 
        to_list_of_...().

    C++ signature :
        void write(cv::FileStorage {lvalue},std::string,boost::python::list)

write( (FileStorage)fs, (object)name, (SparseMat)value) -> None :

    C++ signature :
        void write(cv::FileStorage {lvalue},std::string,cv::SparseMat)

write( (FileStorage)fs, (object)name, (MatND)value) -> None :

    C++ signature :
        void write(cv::FileStorage {lvalue},std::string,cv::MatND)

write( (FileStorage)fs, (object)name, (Mat)value) -> None :

    C++ signature :
        void write(cv::FileStorage {lvalue},std::string,cv::Mat)

write( (FileStorage)fs, (object)name, (Range)r) -> None :

    C++ signature :
        void write(cv::FileStorage {lvalue},std::string,cv::Range)

write( (FileStorage)fs, (Range)r) -> None :

    C++ signature :
        void write(cv::FileStorage {lvalue},cv::Range)

write( (FileStorage)fs, (object)value) -> None :

    C++ signature :
        void write(cv::FileStorage {lvalue},int)

write( (FileStorage)fs, (object)value) -> None :

    C++ signature :
        void write(cv::FileStorage {lvalue},std::string)

write( (FileStorage)fs, (object)value) -> None :

    C++ signature :
        void write(cv::FileStorage {lvalue},double)

write( (FileStorage)fs, (object)value) -> None :

    C++ signature :
        void write(cv::FileStorage {lvalue},float)

write( (FileStorage)fs, (object)name, (object)value) -> None :

    C++ signature :
        void write(cv::FileStorage {lvalue},std::string,std::string)

write( (FileStorage)fs, (object)name, (object)value) -> None :

    C++ signature :
        void write(cv::FileStorage {lvalue},std::string,double)

write( (FileStorage)fs, (object)name, (object)value) -> None :

    C++ signature :
        void write(cv::FileStorage {lvalue},std::string,float)

write( (FileStorage)fs, (object)name, (object)value) -> None :

    C++ signature :
        void write(cv::FileStorage {lvalue},std::string,int)

writeComment(...)


writeComment( (FileStorage)fs, (str)comment, (object)eol_comment) -> None :
    
    Wrapped function:
        cvWriteComment
    Argument 'fs':
        C/C++ type: ::CvFileStorage *.
        Python type: FileStorage.

    C++ signature :
        void writeComment(cv::FileStorage {lvalue},char const*,int)

writeFileNode(...)


writeFileNode( (FileStorage)fs, (str)new_node_name, (FileNode)node, (object)embed) -> None :
    
    Wrapped function:
        cvWriteFileNode
    Argument 'node':
        C/C++ type: ::CvFileNode const *.
        Python type: FileNode.
    Argument 'fs':
        C/C++ type: ::CvFileStorage *.
        Python type: FileStorage.

    C++ signature :
        void writeFileNode(cv::FileStorage {lvalue},char const*,cv::FileNode,int)

writeInt(...)


writeInt( (FileStorage)fs, (str)name, (object)value) -> None :
    
    Wrapped function:
        cvWriteInt
    Argument 'fs':
        C/C++ type: ::CvFileStorage *.
        Python type: FileStorage.

    C++ signature :
        void writeInt(cv::FileStorage {lvalue},char const*,int)

writeReal(...)


writeReal( (FileStorage)fs, (str)name, (object)value) -> None :
    
    Wrapped function:
        cvWriteReal
    Argument 'fs':
        C/C++ type: ::CvFileStorage *.
        Python type: FileStorage.

    C++ signature :
        void writeReal(cv::FileStorage {lvalue},char const*,double)

writeString(...)


writeString( (FileStorage)fs, (str)name, (str)str [, (object)quote=0]) -> None :
    
    Wrapped function:
        cvWriteString
    Argument 'fs':
        C/C++ type: ::CvFileStorage *.
        Python type: FileStorage.

    C++ signature :
        void writeString(cv::FileStorage {lvalue},char const*,char const* [,int=0])

Variables Details

[hide private]

CENTERS_GONZALES

Value:

pyopencv.pyopencvext.flann_centers_init_t.CENTERS_GONZALES

CENTERS_KMEANSPP

Value:

pyopencv.pyopencvext.flann_centers_init_t.CENTERS_KMEANSPP

CENTERS_RANDOM

Value:

pyopencv.pyopencvext.flann_centers_init_t.CENTERS_RANDOM

CV_BADCHANNELS_ERR

Value:

pyopencv.pyopencvext.CvStatus.CV_BADCHANNELS_ERR

CV_BADCONVERGENCE_ERR

Value:

pyopencv.pyopencvext.CvStatus.CV_BADCONVERGENCE_ERR

CV_BADMEMBLOCK_ERR

Value:

pyopencv.pyopencvext.CvStatus.CV_BADMEMBLOCK_ERR

CV_CALIB_ETALON_CHECKERBOARD

Value:

pyopencv.pyopencvext.CvCalibEtalonType.CV_CALIB_ETALON_CHECKERBOARD

CV_CALIB_ETALON_CHESSBOARD

Value:

pyopencv.pyopencvext.CvCalibEtalonType.CV_CALIB_ETALON_CHESSBOARD

CV_CALIB_ETALON_USER

Value:

pyopencv.pyopencvext.CvCalibEtalonType.CV_CALIB_ETALON_USER

CV_DIV_BY_ZERO_ERR

Value:

pyopencv.pyopencvext.CvStatus.CV_DIV_BY_ZERO_ERR

CV_FACE_LEFT_EYE

Value:

pyopencv.pyopencvext.CV_FACE_ELEMENTS.CV_FACE_LEFT_EYE

CV_FACE_MOUTH

Value:

pyopencv.pyopencvext.CV_FACE_ELEMENTS.CV_FACE_MOUTH

CV_FACE_RIGHT_EYE

Value:

pyopencv.pyopencvext.CV_FACE_ELEMENTS.CV_FACE_RIGHT_EYE

CV_INPLACE_NOT_SUPPORTED_ERR

Value:

pyopencv.pyopencvext.CvStatus.CV_INPLACE_NOT_SUPPORTED_ERR

CV_LEE_DOUBLE

Value:

pyopencv.pyopencvext.CvLeeParameters.CV_LEE_DOUBLE

CV_NEXT_AROUND_DST

Value:

pyopencv.pyopencvext.CvNextEdgeType.CV_NEXT_AROUND_DST

CV_NEXT_AROUND_LEFT

Value:

pyopencv.pyopencvext.CvNextEdgeType.CV_NEXT_AROUND_LEFT

CV_NEXT_AROUND_ORG

Value:

pyopencv.pyopencvext.CvNextEdgeType.CV_NEXT_AROUND_ORG

CV_NEXT_AROUND_RIGHT

Value:

pyopencv.pyopencvext.CvNextEdgeType.CV_NEXT_AROUND_RIGHT

CV_NOTDEFINED_ERR

Value:

pyopencv.pyopencvext.CvStatus.CV_NOTDEFINED_ERR

CV_NOT_WEIGHTED

Value:

pyopencv.pyopencvext.CvGraphWeightType.CV_NOT_WEIGHTED

CV_PREV_AROUND_DST

Value:

pyopencv.pyopencvext.CvNextEdgeType.CV_PREV_AROUND_DST

CV_PREV_AROUND_LEFT

Value:

pyopencv.pyopencvext.CvNextEdgeType.CV_PREV_AROUND_LEFT

CV_PREV_AROUND_ORG

Value:

pyopencv.pyopencvext.CvNextEdgeType.CV_PREV_AROUND_ORG

CV_PREV_AROUND_RIGHT

Value:

pyopencv.pyopencvext.CvNextEdgeType.CV_PREV_AROUND_RIGHT

CV_PTLOC_ERROR

Value:

pyopencv.pyopencvext.CvSubdiv2DPointLocation.CV_PTLOC_ERROR

CV_PTLOC_INSIDE

Value:

pyopencv.pyopencvext.CvSubdiv2DPointLocation.CV_PTLOC_INSIDE

CV_PTLOC_ON_EDGE

Value:

pyopencv.pyopencvext.CvSubdiv2DPointLocation.CV_PTLOC_ON_EDGE

CV_PTLOC_OUTSIDE_RECT

Value:

pyopencv.pyopencvext.CvSubdiv2DPointLocation.CV_PTLOC_OUTSIDE_RECT

CV_PTLOC_VERTEX

Value:

pyopencv.pyopencvext.CvSubdiv2DPointLocation.CV_PTLOC_VERTEX

CV_UNMATCHED_FORMATS_ERR

Value:

pyopencv.pyopencvext.CvStatus.CV_UNMATCHED_FORMATS_ERR

CV_UNMATCHED_ROI_ERR

Value:

pyopencv.pyopencvext.CvStatus.CV_UNMATCHED_ROI_ERR

CV_UNSUPPORTED_CHANNELS_ERR

Value:

pyopencv.pyopencvext.CvStatus.CV_UNSUPPORTED_CHANNELS_ERR

CV_UNSUPPORTED_COI_ERR

Value:

pyopencv.pyopencvext.CvStatus.CV_UNSUPPORTED_COI_ERR

CV_UNSUPPORTED_DEPTH_ERR

Value:

pyopencv.pyopencvext.CvStatus.CV_UNSUPPORTED_DEPTH_ERR

CV_UNSUPPORTED_FORMAT_ERR

Value:

pyopencv.pyopencvext.CvStatus.CV_UNSUPPORTED_FORMAT_ERR

CV_WEIGHTED_ALL

Value:

pyopencv.pyopencvext.CvGraphWeightType.CV_WEIGHTED_ALL

CV_WEIGHTED_EDGE

Value:

pyopencv.pyopencvext.CvGraphWeightType.CV_WEIGHTED_EDGE

CV_WEIGHTED_VTX

Value:

pyopencv.pyopencvext.CvGraphWeightType.CV_WEIGHTED_VTX