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, (CvPoint2D32f)image_points, (object)focal_length, (TermCriteria)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 :

SURFParams(...)
SURFParams( (object)hessianThreshold [, (object)extended=0]) -> CvSURFParams :

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 :

_createTrackbar(...)
_createTrackbar( (object)trackbarname, (object)winname, (object)value, (object)count [, (object)onChange=None [, (object)userdata=None]]) -> tuple :

None :

_cvDestroyAllWindows()
Destroys all of the HighGUI windows.

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

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

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

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

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

_cvReleaseLSH(...)
_cvReleaseLSH( (object)lsh) -> 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(36, dtype=uint8)]) -> None :

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

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

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

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

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

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

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

asCvMat(...)
asCvMat( (Mat)inst_Mat) -> CvMat :

asCvPoint(...)
asCvPoint( (Point2i)inst_Point2i) -> CvPoint :

asCvPoint2D32f(...)
asCvPoint2D32f( (Point2i)inst_Point2i) -> CvPoint2D32f :

asCvPoint3D32f(...)
asCvPoint3D32f( (Point3i)inst_Point3i) -> CvPoint3D32f :

asMat(...)
asMat( (CvMat)inst_CvMat) -> Mat :

asMatND(...)
asMatND( (numpy.ndarray)inst_ndarray) -> 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( (numpy.ndarray)inst_ndarray) -> object :

asRect(...)
asRect( (numpy.ndarray)inst_ndarray) -> object :

asRotatedRect(...)
asRotatedRect( (numpy.ndarray)inst_ndarray) -> object :

asScalar(...)
asScalar( (numpy.ndarray)inst_ndarray) -> object :

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 :

asvector_Point2d(...)
asvector_Point2d( (Mat)inst_Mat) -> vector_Point2d :

asvector_Point2f(...)
asvector_Point2f( (Mat)inst_Mat) -> vector_Point2f :

asvector_Point2i(...)
asvector_Point2i( (Mat)inst_Mat) -> vector_Point2i :

asvector_Point3d(...)
asvector_Point3d( (Mat)inst_Mat) -> vector_Point3d :

asvector_Point3f(...)
asvector_Point3f( (Mat)inst_Mat) -> vector_Point3f :

asvector_Point3i(...)
asvector_Point3i( (Mat)inst_Mat) -> vector_Point3i :

asvector_Range(...)
asvector_Range( (Mat)inst_Mat) -> vector_Range :

asvector_Rect(...)
asvector_Rect( (Mat)inst_Mat) -> vector_Rect :

asvector_RotatedRect(...)
asvector_RotatedRect( (Mat)inst_Mat) -> vector_RotatedRect :

asvector_Scalar(...)
asvector_Scalar( (Mat)inst_Mat) -> vector_Scalar :

asvector_Size2f(...)
asvector_Size2f( (Mat)inst_Mat) -> vector_Size2f :

asvector_Size2i(...)
asvector_Size2i( (Mat)inst_Mat) -> vector_Size2i :

asvector_Vec2b(...)
asvector_Vec2b( (Mat)inst_Mat) -> vector_Vec2b :

asvector_Vec2d(...)
asvector_Vec2d( (Mat)inst_Mat) -> vector_Vec2d :

asvector_Vec2f(...)
asvector_Vec2f( (Mat)inst_Mat) -> vector_Vec2f :

asvector_Vec2i(...)
asvector_Vec2i( (Mat)inst_Mat) -> vector_Vec2i :

asvector_Vec2s(...)
asvector_Vec2s( (Mat)inst_Mat) -> vector_Vec2s :

asvector_Vec2w(...)
asvector_Vec2w( (Mat)inst_Mat) -> vector_Vec2w :

asvector_Vec3b(...)
asvector_Vec3b( (Mat)inst_Mat) -> vector_Vec3b :

asvector_Vec3d(...)
asvector_Vec3d( (Mat)inst_Mat) -> vector_Vec3d :

asvector_Vec3f(...)
asvector_Vec3f( (Mat)inst_Mat) -> vector_Vec3f :

asvector_Vec3i(...)
asvector_Vec3i( (Mat)inst_Mat) -> vector_Vec3i :

asvector_Vec3s(...)
asvector_Vec3s( (Mat)inst_Mat) -> vector_Vec3s :

asvector_Vec3w(...)
asvector_Vec3w( (Mat)inst_Mat) -> vector_Vec3w :

asvector_Vec4b(...)
asvector_Vec4b( (Mat)inst_Mat) -> vector_Vec4b :

asvector_Vec4d(...)
asvector_Vec4d( (Mat)inst_Mat) -> vector_Vec4d :

asvector_Vec4f(...)
asvector_Vec4f( (Mat)inst_Mat) -> vector_Vec4f :

asvector_Vec4i(...)
asvector_Vec4i( (Mat)inst_Mat) -> vector_Vec4i :

asvector_Vec4s(...)
asvector_Vec4s( (Mat)inst_Mat) -> vector_Vec4s :

asvector_Vec4w(...)
asvector_Vec4w( (Mat)inst_Mat) -> vector_Vec4w :

asvector_Vec6d(...)
asvector_Vec6d( (Mat)inst_Mat) -> vector_Vec6d :

asvector_Vec6f(...)
asvector_Vec6f( (Mat)inst_Mat) -> vector_Vec6f :

asvector_float32(...)
asvector_float32( (Mat)inst_Mat) -> vector_float32 :

asvector_float64(...)
asvector_float64( (Mat)inst_Mat) -> vector_float64 :

asvector_int(...)
asvector_int( (Mat)inst_Mat) -> vector_int :

asvector_int16(...)
asvector_int16( (Mat)inst_Mat) -> vector_int16 :

asvector_int8(...)
asvector_int8( (Mat)inst_Mat) -> vector_int8 :

asvector_uint16(...)
asvector_uint16( (Mat)inst_Mat) -> vector_uint16 :

asvector_uint8(...)
asvector_uint8( (Mat)inst_Mat) -> vector_uint8 :

asvector_vector_Point2d(...)
asvector_vector_Point2d( (Mat)inst_Mat) -> vector_vector_Point2d :

asvector_vector_Point2f(...)
asvector_vector_Point2f( (Mat)inst_Mat) -> vector_vector_Point2f :

asvector_vector_Point2i(...)
asvector_vector_Point2i( (Mat)inst_Mat) -> vector_vector_Point2i :

asvector_vector_Point3d(...)
asvector_vector_Point3d( (Mat)inst_Mat) -> vector_vector_Point3d :

asvector_vector_Point3f(...)
asvector_vector_Point3f( (Mat)inst_Mat) -> vector_vector_Point3f :

asvector_vector_Point3i(...)
asvector_vector_Point3i( (Mat)inst_Mat) -> vector_vector_Point3i :

asvector_vector_Vec2i(...)
asvector_vector_Vec2i( (Mat)inst_Mat) -> vector_vector_Vec2i :

asvector_vector_float32(...)
asvector_vector_float32( (Mat)inst_Mat) -> vector_vector_float32 :

asvector_vector_int(...)
asvector_vector_int( (Mat)inst_Mat) -> vector_vector_int :

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(58, 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(82, dtype=uint8)]) -> None :

bitwise_xor(...)
bitwise_xor( (MatND)a, (Scalar)s, (MatND)c [, (MatND)mask=MatND(shape=(), nchannels=1, depth=0): array(102, 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( (RotatedRect)box, (CvPoint2D32f)pt) -> None :

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

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

calcBackProject(...)
calcBackProject( (list)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( (list)images, (Mat)channels, (Mat)mask, (SparseMat)hist, (Mat)histSize, (object)ranges [, (bool)uniform=True [, (bool)accumulate=False]]) -> None :

calcImageHomography(...)
calcImageHomography( (object)line, (CvPoint3D32f)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, (Size2i)block_size, (Size2i)shift_size, (Size2i)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, (TermCriteria)criteria) -> None :

calcOpticalFlowLK(...)
calcOpticalFlowLK( (Mat)prev, (Mat)curr, (Size2i)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, (Size2i)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( (MemStorage)storage) -> 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 [, (MemStorage)storage=<pyopencv.pyopencvext.MemStorage object at 0x0340B330>]) -> object :

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, (MemStorage)storage, (TermCriteria)criteria) -> object :

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 :

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

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

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

convexityDefects(...)
convexityDefects( (Mat)contour, (Mat)convexhull [, (MemStorage)storage=<pyopencv.pyopencvext.MemStorage object at 0x0340B370>]) -> 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( (MemStorage)parent) -> MemStorage :

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

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

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]) -> MemStorage :

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( (CvPoint3D32f)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, (MemStorage)storage) -> object :

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

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, (MemStorage)storage) -> object :

createSubdivDelaunay2D(...)
createSubdivDelaunay2D( (Rect)rect, (MemStorage)storage) -> object :

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 :

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 :

extractSURF(...)
extractSURF( (Mat)img, (Mat)mask, (Seq_CvSURFPoint)keypoints, (CvSURFParams)params [, (object)useProvidedKeyPts=0]) -> object :

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

fillConvexPoly(...)
fillConvexPoly( (Mat)img, (list)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, (MemStorage)storage [, (object)method=1 [, (object)parameter1=0 [, (object)parameter2=0 [, (object)parameter3=0 [, (object)parameter4=0]]]]]) -> object :

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 :

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( (list)src, (list)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

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 :

getOptimalNewCameraMatrix(...)
getOptimalNewCameraMatrix( (Mat)cameraMatrix, (Mat)distCoeffs, (Size2i)imageSize, (object)alpha [, (Size2i)newImgSize=Size2i(width=0, height=0)]) -> tuple :

getPerspectiveTransform(...)
getPerspectiveTransform( (list)src, (list)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 :

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

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

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( (object)trackbarname, (object)winname) -> 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( (list)arrs, (Mat)mask, (object)stubs, (CvNArrayIterator)array_iterator [, (object)flags=0]) -> object :

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

initSystem(...)
initSystem( (list)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( (object)rect1, (object)rect2) -> object :

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(238, dtype=uint8)]) -> None :

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

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

merge(...)
merge( (vector_MatND)mv, (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( (SparseMat)a) -> tuple :

mixChannels(...)
mixChannels( (vector_MatND)src, (vector_MatND)dst, (Mat)fromTo, (object)npairs) -> None :

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 :

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 [, (TermCriteria)termcrit=TermCriteria(type=3, maxCount=5, epsilon=1.0)]]) -> None :

pyrSegmentation(...)
pyrSegmentation( (Mat)src, (Mat)dst, (MemStorage)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, (Scalar)param1, (Scalar)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) -> CvPoint :

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(206, dtype=uint8)]) -> object :

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

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

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

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

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

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

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

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

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

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

read_uint8(...)
read_uint8( (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( (MemStorage)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, (CvPoint)pt1, (CvPoint)pt2, (object)buffer [, (object)connectivity=8]) -> object :

saveMemStoragePos(...)
saveMemStoragePos( (MemStorage)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, (MemStorage)storage) -> object :

segmentMotion(...)
segmentMotion( (Mat)mhi, (Mat)seg_mask, (MemStorage)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 :

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 :

setTrackbarPos(...)
setTrackbarPos( (object)trackbarname, (object)winname, (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) -> object :

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, (vector_MatND)mv) -> None :

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

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

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

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

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

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

int :

startWindowThread()
Wrapped function: cvStartWindowThread

startWriteStruct(...)
startWriteStruct( (FileStorage)fs, (str)name, (object)struct_flags [, (str)type_name=None [, (CvAttrList)attributes=<pyopencv.pyopencvext.CvAttrList object at 0x0340B3F0>]]) -> 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 :

stereoRectify(...)
stereoRectify( (Mat)cameraMatrix1, (Mat)distCoeffs1, (Mat)cameraMatrix2, (Mat)distCoeffs2, (Size2i)imageSize, (Mat)R, (Mat)T, (Mat)R1, (Mat)R2, (Mat)P1, (Mat)P2, (Mat)Q [, (object)flags=1024]) -> None :

stereoRectify2(...)
stereoRectify2( (Mat)cameraMatrix1, (Mat)distCoeffs1, (Mat)cameraMatrix2, (Mat)distCoeffs2, (Size2i)imageSize, (Mat)R, (Mat)T, (Mat)R1, (Mat)R2, (Mat)P1, (Mat)P2, (Mat)Q, (object)alpha [, (Size2i)newImageSize=Size2i(width=0, height=0) [, (object)flags=1024]]) -> tuple :

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(6, dtype=uint8)]) -> None :

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

RNG :

theRNG()
Returns the default random number generator.

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 0x0340B430>]) -> None :

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

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

write_Mat(...)
write_Mat( (FileStorage)fs, (object)name, (Mat)value) -> None :

write_MatND(...)
write_MatND( (FileStorage)fs, (object)name, (MatND)value) -> None :

write_Range(...)
write_Range( (FileStorage)fs, (object)name, (Range)r) -> None :

write_SparseMat(...)
write_SparseMat( (FileStorage)fs, (object)name, (SparseMat)value) -> None :

write_float32(...)
write_float32( (FileStorage)fs, (object)value) -> None :

write_float64(...)
write_float64( (FileStorage)fs, (object)value) -> None :

write_int(...)
write_int( (FileStorage)fs, (object)value) -> None :

write_list_of_KeyPoint(...)
write_list_of_KeyPoint( (FileStorage)fs, (object)name, (list)keypoints) -> None :

write_str(...)
write_str( (FileStorage)fs, (object)value) -> 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 of KeyPoint.
        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 :
    
    Performs a look-up table transform of an array.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#cv-lut

    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 :
    
    Calculates the Mahalanobis distance between two vectors.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#cv-mahalanobis

    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, (CvPoint2D32f)image_points, (object)focal_length, (TermCriteria)criteria, (object)rotation_matrix, (object)translation_vector) -> None :
    
    Wrapped function:
        cvPOSIT
    Argument 'criteria':
        C/C++ type: ::CvTermCriteria.
        Python type: TermCriteria.

    C++ signature :
        void POSIT(CvPOSITObject*,CvPoint2D32f*,double,cv::TermCriteria,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}])

SURFParams(...)


SURFParams( (object)hessianThreshold [, (object)extended=0]) -> CvSURFParams :
    
    Wrapped function:
        cvSURFParams

    C++ signature :
        CvSURFParams SURFParams(double [,int=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]]]])

_createTrackbar(...)


_createTrackbar( (object)trackbarname, (object)winname, (object)value, (object)count [, (object)onChange=None [, (object)userdata=None]]) -> tuple :
    
    Creates a trackbar and attaches it to the specified window.
    Wrapped function:
        createTrackbar
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/user_interface.html#cv-createtrackbar
    Argument 'onChange' 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 _createTrackbar(std::string,std::string,unsigned int,int [,boost::python::api::object=None [,boost::python::api::object=None]])

_cvDestroyAllWindows()

    Destroys all of the HighGUI windows.
    Wrapped function:
        cvDestroyAllWindows
    Reference:
        http://opencv.willowgarage.com/documentation/c/user_interface.html#convertimage#destroyallwindows

    C++ signature :
        void _cvDestroyAllWindows()

Returns: None :

_cvDestroyWindow(...)


_cvDestroyWindow( (str)name) -> None :
    
    Destroys a window.
    Wrapped function:
        cvDestroyWindow
    Reference:
        http://opencv.willowgarage.com/documentation/c/user_interface.html#convertimage#destroywindow

    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: CvConDensation.

    C++ signature :
        void _cvReleaseConDensation(CvConDensation)

_cvReleaseFeatureTree(...)


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

    C++ signature :
        void _cvReleaseFeatureTree(CvFeatureTree*)

_cvReleaseFileStorage(...)


_cvReleaseFileStorage( (object)fs) -> None :
    
    Wrapped function:
        cvReleaseFileStorage
    Argument 'fs':
        C/C++ type: ::CvFileStorage * *.
        Python type: CvFileStorage.

    C++ signature :
        void _cvReleaseFileStorage(CvFileStorage)

_cvReleaseLSH(...)


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

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

_cvReleasePOSITObject(...)


_cvReleasePOSITObject( (CvPOSITObject)posit_object) -> None :
    
    Wrapped function:
        cvReleasePOSITObject
    Argument 'posit_object':
        C/C++ type: ::CvPOSITObject * *.
        Python type: CvPOSITObject.

    C++ signature :
        void _cvReleasePOSITObject(CvPOSITObject)

_cvReleaseStereoGCState(...)


_cvReleaseStereoGCState( (CvStereoGCState)state) -> None :
    
    Wrapped function:
        cvReleaseStereoGCState
    Argument 'state':
        C/C++ type: ::CvStereoGCState * *.
        Python type: CvStereoGCState.

    C++ signature :
        void _cvReleaseStereoGCState(CvStereoGCState)

_cvSetMouseCallback(...)


_cvSetMouseCallback( (str)window_name, (object)on_mouse [, (object)param=None]) -> object :
    
    Assigns callback for mouse events.
    Wrapped function:
        cvSetMouseCallback
    Reference:
        http://opencv.willowgarage.com/documentation/c/user_interface.html#convertimage#setmousecallback
    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(36, 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(38, 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, (MemStorage)storage [, (object)method=2 [, (object)parameter=0 [, (object)minimal_perimeter=0 [, (object)recursive=0]]]]) -> object :
    
    Wrapped function:
        cvApproxChains
    Argument 'storage':
        C/C++ type: ::CvMemStorage *.
        Python type: MemStorage.

    C++ signature :
        boost::python::api::object approxChains(CvSeq*,cv::Ptr<CvMemStorage> {lvalue} [,int=2 [,double=0 [,int=0 [,int=0]]]])

approxPolyDP_float32(...)


approxPolyDP_float32( (Mat)curve, (object)epsilon, (bool)closed) -> object :
    
    Wrapped function:
        approxPolyDP
    Argument 'approxCurve':
        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 approxPolyDP_float32(cv::Mat,double,bool)

approxPolyDP_int(...)


approxPolyDP_int( (Mat)curve, (object)epsilon, (bool)closed) -> object :
    
    Wrapped function:
        approxPolyDP
    Argument 'approxCurve':
        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)).
        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 approxPolyDP_int(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>)

asCvMat(...)


asCvMat( (Mat)inst_Mat) -> CvMat :

    C++ signature :
        CvMat asCvMat(cv::Mat)

asCvPoint(...)


asCvPoint( (Point2i)inst_Point2i) -> CvPoint :

    C++ signature :
        CvPoint asCvPoint(cv::Point_<int>)

asCvPoint( (Point2f)inst_Point2f) -> CvPoint :

    C++ signature :
        CvPoint asCvPoint(cv::Point_<float>)

asCvPoint( (Point2d)inst_Point2d) -> CvPoint :

    C++ signature :
        CvPoint asCvPoint(cv::Point_<double>)

asCvPoint2D32f(...)


asCvPoint2D32f( (Point2i)inst_Point2i) -> CvPoint2D32f :

    C++ signature :
        CvPoint2D32f asCvPoint2D32f(cv::Point_<int>)

asCvPoint2D32f( (Point2f)inst_Point2f) -> CvPoint2D32f :

    C++ signature :
        CvPoint2D32f asCvPoint2D32f(cv::Point_<float>)

asCvPoint2D32f( (Point2d)inst_Point2d) -> CvPoint2D32f :

    C++ signature :
        CvPoint2D32f asCvPoint2D32f(cv::Point_<double>)

asCvPoint3D32f(...)


asCvPoint3D32f( (Point3i)inst_Point3i) -> CvPoint3D32f :

    C++ signature :
        CvPoint3D32f asCvPoint3D32f(cv::Point3_<int>)

asCvPoint3D32f( (Point3f)inst_Point3f) -> CvPoint3D32f :

    C++ signature :
        CvPoint3D32f asCvPoint3D32f(cv::Point3_<float>)

asCvPoint3D32f( (Point3d)inst_Point3d) -> CvPoint3D32f :

    C++ signature :
        CvPoint3D32f asCvPoint3D32f(cv::Point3_<double>)

asMat(...)


asMat( (CvMat)inst_CvMat) -> Mat :

    C++ signature :
        cv::Mat asMat(CvMat)

asMat( (vector_Vec4f)inst_vector_Vec4f) -> Mat :

    C++ signature :
        cv::Mat asMat(std::vector<cv::Vec<float, 4>, std::allocator<cv::Vec<float, 4> > >)

asMat( (vector_int16)inst_vector_int16) -> Mat :

    C++ signature :
        cv::Mat asMat(std::vector<short, std::allocator<short> >)

asMat( (vector_Vec4b)inst_vector_Vec4b) -> Mat :

    C++ signature :
        cv::Mat asMat(std::vector<cv::Vec<unsigned char, 4>, std::allocator<cv::Vec<unsigned char, 4> > >)

asMat( (vector_int)inst_vector_int) -> Mat :

    C++ signature :
        cv::Mat asMat(std::vector<int, std::allocator<int> >)

asMat( (vector_uint8)inst_vector_uint8) -> Mat :

    C++ signature :
        cv::Mat asMat(std::vector<unsigned char, std::allocator<unsigned char> >)

asMat( (vector_Vec4i)inst_vector_Vec4i) -> Mat :

    C++ signature :
        cv::Mat asMat(std::vector<cv::Vec<int, 4>, std::allocator<cv::Vec<int, 4> > >)

asMat( (vector_Vec4w)inst_vector_Vec4w) -> Mat :

    C++ signature :
        cv::Mat asMat(std::vector<cv::Vec<unsigned short, 4>, std::allocator<cv::Vec<unsigned short, 4> > >)

asMat( (vector_Point3i)inst_vector_Point3i) -> Mat :

    C++ signature :
        cv::Mat asMat(std::vector<cv::Point3_<int>, std::allocator<cv::Point3_<int> > >)

asMat( (vector_Point2i)inst_vector_Point2i) -> Mat :

    C++ signature :
        cv::Mat asMat(std::vector<cv::Point_<int>, std::allocator<cv::Point_<int> > >)

asMat( (vector_Vec4d)inst_vector_Vec4d) -> Mat :

    C++ signature :
        cv::Mat asMat(std::vector<cv::Vec<double, 4>, std::allocator<cv::Vec<double, 4> > >)

asMat( (vector_Vec4s)inst_vector_Vec4s) -> Mat :

    C++ signature :
        cv::Mat asMat(std::vector<cv::Vec<short, 4>, std::allocator<cv::Vec<short, 4> > >)

asMat( (vector_Vec2f)inst_vector_Vec2f) -> Mat :

    C++ signature :
        cv::Mat asMat(std::vector<cv::Vec<float, 2>, std::allocator<cv::Vec<float, 2> > >)

asMat( (vector_Range)inst_vector_Range) -> Mat :

    C++ signature :
        cv::Mat asMat(std::vector<cv::Range, std::allocator<cv::Range> >)

asMat( (vector_RotatedRect)inst_vector_RotatedRect) -> Mat :

    C++ signature :
        cv::Mat asMat(std::vector<cv::RotatedRect, std::allocator<cv::RotatedRect> >)

asMat( (vector_Size2i)inst_vector_Size2i) -> Mat :

    C++ signature :
        cv::Mat asMat(std::vector<cv::Size_<int>, std::allocator<cv::Size_<int> > >)

asMat( (vector_Point3d)inst_vector_Point3d) -> Mat :

    C++ signature :
        cv::Mat asMat(std::vector<cv::Point3_<double>, std::allocator<cv::Point3_<double> > >)

asMat( (vector_int8)inst_vector_int8) -> Mat :

    C++ signature :
        cv::Mat asMat(std::vector<char, std::allocator<char> >)

asMat( (vector_Point3f)inst_vector_Point3f) -> Mat :

    C++ signature :
        cv::Mat asMat(std::vector<cv::Point3_<float>, std::allocator<cv::Point3_<float> > >)

asMat( (vector_Point2d)inst_vector_Point2d) -> Mat :

    C++ signature :
        cv::Mat asMat(std::vector<cv::Point_<double>, std::allocator<cv::Point_<double> > >)

asMat( (vector_Vec3w)inst_vector_Vec3w) -> Mat :

    C++ signature :
        cv::Mat asMat(std::vector<cv::Vec<unsigned short, 3>, std::allocator<cv::Vec<unsigned short, 3> > >)

asMat( (vector_Vec2w)inst_vector_Vec2w) -> Mat :

    C++ signature :
        cv::Mat asMat(std::vector<cv::Vec<unsigned short, 2>, std::allocator<cv::Vec<unsigned short, 2> > >)

asMat( (vector_Vec3s)inst_vector_Vec3s) -> Mat :

    C++ signature :
        cv::Mat asMat(std::vector<cv::Vec<short, 3>, std::allocator<cv::Vec<short, 3> > >)

asMat( (vector_Vec2s)inst_vector_Vec2s) -> Mat :

    C++ signature :
        cv::Mat asMat(std::vector<cv::Vec<short, 2>, std::allocator<cv::Vec<short, 2> > >)

asMat( (vector_float64)inst_vector_float64) -> Mat :

    C++ signature :
        cv::Mat asMat(std::vector<double, std::allocator<double> >)

asMat( (vector_Size2f)inst_vector_Size2f) -> Mat :

    C++ signature :
        cv::Mat asMat(std::vector<cv::Size_<float>, std::allocator<cv::Size_<float> > >)

asMat( (vector_Scalar)inst_vector_Scalar) -> Mat :

    C++ signature :
        cv::Mat asMat(std::vector<cv::Scalar_<double>, std::allocator<cv::Scalar_<double> > >)

asMat( (vector_Point2f)inst_vector_Point2f) -> Mat :

    C++ signature :
        cv::Mat asMat(std::vector<cv::Point_<float>, std::allocator<cv::Point_<float> > >)

asMat( (vector_Vec3f)inst_vector_Vec3f) -> Mat :

    C++ signature :
        cv::Mat asMat(std::vector<cv::Vec<float, 3>, std::allocator<cv::Vec<float, 3> > >)

asMat( (vector_Vec2d)inst_vector_Vec2d) -> Mat :

    C++ signature :
        cv::Mat asMat(std::vector<cv::Vec<double, 2>, std::allocator<cv::Vec<double, 2> > >)

asMat( (vector_Vec3d)inst_vector_Vec3d) -> Mat :

    C++ signature :
        cv::Mat asMat(std::vector<cv::Vec<double, 3>, std::allocator<cv::Vec<double, 3> > >)

asMat( (vector_uint16)inst_vector_uint16) -> Mat :

    C++ signature :
        cv::Mat asMat(std::vector<unsigned short, std::allocator<unsigned short> >)

asMat( (vector_Vec3b)inst_vector_Vec3b) -> Mat :

    C++ signature :
        cv::Mat asMat(std::vector<cv::Vec<unsigned char, 3>, std::allocator<cv::Vec<unsigned char, 3> > >)

asMat( (vector_Rect)inst_vector_Rect) -> Mat :

    C++ signature :
        cv::Mat asMat(std::vector<cv::Rect_<int>, std::allocator<cv::Rect_<int> > >)

asMat( (vector_Vec2b)inst_vector_Vec2b) -> Mat :

    C++ signature :
        cv::Mat asMat(std::vector<cv::Vec<unsigned char, 2>, std::allocator<cv::Vec<unsigned char, 2> > >)

asMat( (vector_Vec6f)inst_vector_Vec6f) -> Mat :

    C++ signature :
        cv::Mat asMat(std::vector<cv::Vec<float, 6>, std::allocator<cv::Vec<float, 6> > >)

asMat( (vector_Vec2i)inst_vector_Vec2i) -> Mat :

    C++ signature :
        cv::Mat asMat(std::vector<cv::Vec<int, 2>, std::allocator<cv::Vec<int, 2> > >)

asMat( (vector_Vec6d)inst_vector_Vec6d) -> Mat :

    C++ signature :
        cv::Mat asMat(std::vector<cv::Vec<double, 6>, std::allocator<cv::Vec<double, 6> > >)

asMat( (vector_float32)inst_vector_float32) -> Mat :

    C++ signature :
        cv::Mat asMat(std::vector<float, std::allocator<float> >)

asMat( (vector_Vec3i)inst_vector_Vec3i) -> Mat :

    C++ signature :
        cv::Mat asMat(std::vector<cv::Vec<int, 3>, std::allocator<cv::Vec<int, 3> > >)

asMat( (numpy.ndarray)inst_ndarray) -> object :

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

asMatND(...)


asMatND( (numpy.ndarray)inst_ndarray) -> object :

    C++ signature :
        boost::python::api::object asMatND(sdcpp::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( (numpy.ndarray)inst_ndarray) -> object :

    C++ signature :
        boost::python::api::object asPoint2d(sdcpp::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( (numpy.ndarray)inst_ndarray) -> object :

    C++ signature :
        boost::python::api::object asPoint2f(sdcpp::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( (numpy.ndarray)inst_ndarray) -> object :

    C++ signature :
        boost::python::api::object asPoint2i(sdcpp::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( (numpy.ndarray)inst_ndarray) -> object :

    C++ signature :
        boost::python::api::object asPoint3d(sdcpp::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( (numpy.ndarray)inst_ndarray) -> object :

    C++ signature :
        boost::python::api::object asPoint3f(sdcpp::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( (numpy.ndarray)inst_ndarray) -> object :

    C++ signature :
        boost::python::api::object asPoint3i(sdcpp::ndarray)

asRange(...)


asRange( (numpy.ndarray)inst_ndarray) -> object :

    C++ signature :
        boost::python::api::object asRange(sdcpp::ndarray)

asRect(...)


asRect( (numpy.ndarray)inst_ndarray) -> object :

    C++ signature :
        boost::python::api::object asRect(sdcpp::ndarray)

asRotatedRect(...)


asRotatedRect( (numpy.ndarray)inst_ndarray) -> object :

    C++ signature :
        boost::python::api::object asRotatedRect(sdcpp::ndarray)

asScalar(...)


asScalar( (numpy.ndarray)inst_ndarray) -> object :

    C++ signature :
        boost::python::api::object asScalar(sdcpp::ndarray)

asSize2f(...)


asSize2f( (Size2i)inst_Size2i) -> Size2f :

    C++ signature :
        cv::Size_<float> asSize2f(cv::Size_<int>)

asSize2f( (numpy.ndarray)inst_ndarray) -> object :

    C++ signature :
        boost::python::api::object asSize2f(sdcpp::ndarray)

asSize2i(...)


asSize2i( (Size2f)inst_Size2f) -> Size2i :

    C++ signature :
        cv::Size_<int> asSize2i(cv::Size_<float>)

asSize2i( (numpy.ndarray)inst_ndarray) -> object :

    C++ signature :
        boost::python::api::object asSize2i(sdcpp::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( (numpy.ndarray)inst_ndarray) -> object :

    C++ signature :
        boost::python::api::object asVec2b(sdcpp::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( (Point2d)inst_Point2d) -> Vec2d :

    C++ signature :
        cv::Vec<double, 2> asVec2d(cv::Point_<double>)

asVec2d( (numpy.ndarray)inst_ndarray) -> object :

    C++ signature :
        boost::python::api::object asVec2d(sdcpp::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( (Point2f)inst_Point2f) -> Vec2f :

    C++ signature :
        cv::Vec<float, 2> asVec2f(cv::Point_<float>)

asVec2f( (numpy.ndarray)inst_ndarray) -> object :

    C++ signature :
        boost::python::api::object asVec2f(sdcpp::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( (Point2i)inst_Point2i) -> Vec2i :

    C++ signature :
        cv::Vec<int, 2> asVec2i(cv::Point_<int>)

asVec2i( (numpy.ndarray)inst_ndarray) -> object :

    C++ signature :
        boost::python::api::object asVec2i(sdcpp::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( (numpy.ndarray)inst_ndarray) -> object :

    C++ signature :
        boost::python::api::object asVec2s(sdcpp::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( (numpy.ndarray)inst_ndarray) -> object :

    C++ signature :
        boost::python::api::object asVec2w(sdcpp::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( (numpy.ndarray)inst_ndarray) -> object :

    C++ signature :
        boost::python::api::object asVec3b(sdcpp::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( (Point3d)inst_Point3d) -> Vec3d :

    C++ signature :
        cv::Vec<double, 3> asVec3d(cv::Point3_<double>)

asVec3d( (numpy.ndarray)inst_ndarray) -> object :

    C++ signature :
        boost::python::api::object asVec3d(sdcpp::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( (Point3f)inst_Point3f) -> Vec3f :

    C++ signature :
        cv::Vec<float, 3> asVec3f(cv::Point3_<float>)

asVec3f( (numpy.ndarray)inst_ndarray) -> object :

    C++ signature :
        boost::python::api::object asVec3f(sdcpp::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( (Point3i)inst_Point3i) -> Vec3i :

    C++ signature :
        cv::Vec<int, 3> asVec3i(cv::Point3_<int>)

asVec3i( (numpy.ndarray)inst_ndarray) -> object :

    C++ signature :
        boost::python::api::object asVec3i(sdcpp::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( (numpy.ndarray)inst_ndarray) -> object :

    C++ signature :
        boost::python::api::object asVec3s(sdcpp::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( (numpy.ndarray)inst_ndarray) -> object :

    C++ signature :
        boost::python::api::object asVec3w(sdcpp::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( (numpy.ndarray)inst_ndarray) -> object :

    C++ signature :
        boost::python::api::object asVec4b(sdcpp::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( (numpy.ndarray)inst_ndarray) -> object :

    C++ signature :
        boost::python::api::object asVec4d(sdcpp::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( (numpy.ndarray)inst_ndarray) -> object :

    C++ signature :
        boost::python::api::object asVec4f(sdcpp::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( (numpy.ndarray)inst_ndarray) -> object :

    C++ signature :
        boost::python::api::object asVec4i(sdcpp::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( (numpy.ndarray)inst_ndarray) -> object :

    C++ signature :
        boost::python::api::object asVec4s(sdcpp::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( (numpy.ndarray)inst_ndarray) -> object :

    C++ signature :
        boost::python::api::object asVec4w(sdcpp::ndarray)

asVec6d(...)


asVec6d( (Vec6f)inst_Vec6f) -> Vec6d :

    C++ signature :
        cv::Vec<double, 6> asVec6d(cv::Vec<float, 6>)

asVec6d( (numpy.ndarray)inst_ndarray) -> object :

    C++ signature :
        boost::python::api::object asVec6d(sdcpp::ndarray)

asVec6f(...)


asVec6f( (Vec6d)inst_Vec6d) -> Vec6f :

    C++ signature :
        cv::Vec<float, 6> asVec6f(cv::Vec<double, 6>)

asVec6f( (numpy.ndarray)inst_ndarray) -> object :

    C++ signature :
        boost::python::api::object asVec6f(sdcpp::ndarray)

asvector_Point2d(...)


asvector_Point2d( (Mat)inst_Mat) -> vector_Point2d :

    C++ signature :
        std::vector<cv::Point_<double>, std::allocator<cv::Point_<double> > > asvector_Point2d(cv::Mat)

asvector_Point2f(...)


asvector_Point2f( (Mat)inst_Mat) -> vector_Point2f :

    C++ signature :
        std::vector<cv::Point_<float>, std::allocator<cv::Point_<float> > > asvector_Point2f(cv::Mat)

asvector_Point2i(...)


asvector_Point2i( (Mat)inst_Mat) -> vector_Point2i :

    C++ signature :
        std::vector<cv::Point_<int>, std::allocator<cv::Point_<int> > > asvector_Point2i(cv::Mat)

asvector_Point3d(...)


asvector_Point3d( (Mat)inst_Mat) -> vector_Point3d :

    C++ signature :
        std::vector<cv::Point3_<double>, std::allocator<cv::Point3_<double> > > asvector_Point3d(cv::Mat)

asvector_Point3f(...)


asvector_Point3f( (Mat)inst_Mat) -> vector_Point3f :

    C++ signature :
        std::vector<cv::Point3_<float>, std::allocator<cv::Point3_<float> > > asvector_Point3f(cv::Mat)

asvector_Point3i(...)


asvector_Point3i( (Mat)inst_Mat) -> vector_Point3i :

    C++ signature :
        std::vector<cv::Point3_<int>, std::allocator<cv::Point3_<int> > > asvector_Point3i(cv::Mat)

asvector_Range(...)


asvector_Range( (Mat)inst_Mat) -> vector_Range :

    C++ signature :
        std::vector<cv::Range, std::allocator<cv::Range> > asvector_Range(cv::Mat)

asvector_Rect(...)


asvector_Rect( (Mat)inst_Mat) -> vector_Rect :

    C++ signature :
        std::vector<cv::Rect_<int>, std::allocator<cv::Rect_<int> > > asvector_Rect(cv::Mat)

asvector_RotatedRect(...)


asvector_RotatedRect( (Mat)inst_Mat) -> vector_RotatedRect :

    C++ signature :
        std::vector<cv::RotatedRect, std::allocator<cv::RotatedRect> > asvector_RotatedRect(cv::Mat)

asvector_Scalar(...)


asvector_Scalar( (Mat)inst_Mat) -> vector_Scalar :

    C++ signature :
        std::vector<cv::Scalar_<double>, std::allocator<cv::Scalar_<double> > > asvector_Scalar(cv::Mat)

asvector_Size2f(...)


asvector_Size2f( (Mat)inst_Mat) -> vector_Size2f :

    C++ signature :
        std::vector<cv::Size_<float>, std::allocator<cv::Size_<float> > > asvector_Size2f(cv::Mat)

asvector_Size2i(...)


asvector_Size2i( (Mat)inst_Mat) -> vector_Size2i :

    C++ signature :
        std::vector<cv::Size_<int>, std::allocator<cv::Size_<int> > > asvector_Size2i(cv::Mat)

asvector_Vec2b(...)


asvector_Vec2b( (Mat)inst_Mat) -> vector_Vec2b :

    C++ signature :
        std::vector<cv::Vec<unsigned char, 2>, std::allocator<cv::Vec<unsigned char, 2> > > asvector_Vec2b(cv::Mat)

asvector_Vec2d(...)


asvector_Vec2d( (Mat)inst_Mat) -> vector_Vec2d :

    C++ signature :
        std::vector<cv::Vec<double, 2>, std::allocator<cv::Vec<double, 2> > > asvector_Vec2d(cv::Mat)

asvector_Vec2f(...)


asvector_Vec2f( (Mat)inst_Mat) -> vector_Vec2f :

    C++ signature :
        std::vector<cv::Vec<float, 2>, std::allocator<cv::Vec<float, 2> > > asvector_Vec2f(cv::Mat)

asvector_Vec2i(...)


asvector_Vec2i( (Mat)inst_Mat) -> vector_Vec2i :

    C++ signature :
        std::vector<cv::Vec<int, 2>, std::allocator<cv::Vec<int, 2> > > asvector_Vec2i(cv::Mat)

asvector_Vec2s(...)


asvector_Vec2s( (Mat)inst_Mat) -> vector_Vec2s :

    C++ signature :
        std::vector<cv::Vec<short, 2>, std::allocator<cv::Vec<short, 2> > > asvector_Vec2s(cv::Mat)

asvector_Vec2w(...)


asvector_Vec2w( (Mat)inst_Mat) -> vector_Vec2w :

    C++ signature :
        std::vector<cv::Vec<unsigned short, 2>, std::allocator<cv::Vec<unsigned short, 2> > > asvector_Vec2w(cv::Mat)

asvector_Vec3b(...)


asvector_Vec3b( (Mat)inst_Mat) -> vector_Vec3b :

    C++ signature :
        std::vector<cv::Vec<unsigned char, 3>, std::allocator<cv::Vec<unsigned char, 3> > > asvector_Vec3b(cv::Mat)

asvector_Vec3d(...)


asvector_Vec3d( (Mat)inst_Mat) -> vector_Vec3d :

    C++ signature :
        std::vector<cv::Vec<double, 3>, std::allocator<cv::Vec<double, 3> > > asvector_Vec3d(cv::Mat)

asvector_Vec3f(...)


asvector_Vec3f( (Mat)inst_Mat) -> vector_Vec3f :

    C++ signature :
        std::vector<cv::Vec<float, 3>, std::allocator<cv::Vec<float, 3> > > asvector_Vec3f(cv::Mat)

asvector_Vec3i(...)


asvector_Vec3i( (Mat)inst_Mat) -> vector_Vec3i :

    C++ signature :
        std::vector<cv::Vec<int, 3>, std::allocator<cv::Vec<int, 3> > > asvector_Vec3i(cv::Mat)

asvector_Vec3s(...)


asvector_Vec3s( (Mat)inst_Mat) -> vector_Vec3s :

    C++ signature :
        std::vector<cv::Vec<short, 3>, std::allocator<cv::Vec<short, 3> > > asvector_Vec3s(cv::Mat)

asvector_Vec3w(...)


asvector_Vec3w( (Mat)inst_Mat) -> vector_Vec3w :

    C++ signature :
        std::vector<cv::Vec<unsigned short, 3>, std::allocator<cv::Vec<unsigned short, 3> > > asvector_Vec3w(cv::Mat)

asvector_Vec4b(...)


asvector_Vec4b( (Mat)inst_Mat) -> vector_Vec4b :

    C++ signature :
        std::vector<cv::Vec<unsigned char, 4>, std::allocator<cv::Vec<unsigned char, 4> > > asvector_Vec4b(cv::Mat)

asvector_Vec4d(...)


asvector_Vec4d( (Mat)inst_Mat) -> vector_Vec4d :

    C++ signature :
        std::vector<cv::Vec<double, 4>, std::allocator<cv::Vec<double, 4> > > asvector_Vec4d(cv::Mat)

asvector_Vec4f(...)


asvector_Vec4f( (Mat)inst_Mat) -> vector_Vec4f :

    C++ signature :
        std::vector<cv::Vec<float, 4>, std::allocator<cv::Vec<float, 4> > > asvector_Vec4f(cv::Mat)

asvector_Vec4i(...)


asvector_Vec4i( (Mat)inst_Mat) -> vector_Vec4i :

    C++ signature :
        std::vector<cv::Vec<int, 4>, std::allocator<cv::Vec<int, 4> > > asvector_Vec4i(cv::Mat)

asvector_Vec4s(...)


asvector_Vec4s( (Mat)inst_Mat) -> vector_Vec4s :

    C++ signature :
        std::vector<cv::Vec<short, 4>, std::allocator<cv::Vec<short, 4> > > asvector_Vec4s(cv::Mat)

asvector_Vec4w(...)


asvector_Vec4w( (Mat)inst_Mat) -> vector_Vec4w :

    C++ signature :
        std::vector<cv::Vec<unsigned short, 4>, std::allocator<cv::Vec<unsigned short, 4> > > asvector_Vec4w(cv::Mat)

asvector_Vec6d(...)


asvector_Vec6d( (Mat)inst_Mat) -> vector_Vec6d :

    C++ signature :
        std::vector<cv::Vec<double, 6>, std::allocator<cv::Vec<double, 6> > > asvector_Vec6d(cv::Mat)

asvector_Vec6f(...)


asvector_Vec6f( (Mat)inst_Mat) -> vector_Vec6f :

    C++ signature :
        std::vector<cv::Vec<float, 6>, std::allocator<cv::Vec<float, 6> > > asvector_Vec6f(cv::Mat)

asvector_float32(...)


asvector_float32( (Mat)inst_Mat) -> vector_float32 :

    C++ signature :
        std::vector<float, std::allocator<float> > asvector_float32(cv::Mat)

asvector_float64(...)


asvector_float64( (Mat)inst_Mat) -> vector_float64 :

    C++ signature :
        std::vector<double, std::allocator<double> > asvector_float64(cv::Mat)

asvector_int(...)


asvector_int( (Mat)inst_Mat) -> vector_int :

    C++ signature :
        std::vector<int, std::allocator<int> > asvector_int(cv::Mat)

asvector_int16(...)


asvector_int16( (Mat)inst_Mat) -> vector_int16 :

    C++ signature :
        std::vector<short, std::allocator<short> > asvector_int16(cv::Mat)

asvector_int8(...)


asvector_int8( (Mat)inst_Mat) -> vector_int8 :

    C++ signature :
        std::vector<char, std::allocator<char> > asvector_int8(cv::Mat)

asvector_uint16(...)


asvector_uint16( (Mat)inst_Mat) -> vector_uint16 :

    C++ signature :
        std::vector<unsigned short, std::allocator<unsigned short> > asvector_uint16(cv::Mat)

asvector_uint8(...)


asvector_uint8( (Mat)inst_Mat) -> vector_uint8 :

    C++ signature :
        std::vector<unsigned char, std::allocator<unsigned char> > asvector_uint8(cv::Mat)

asvector_vector_Point2d(...)


asvector_vector_Point2d( (Mat)inst_Mat) -> vector_vector_Point2d :

    C++ signature :
        std::vector<std::vector<cv::Point_<double>, std::allocator<cv::Point_<double> > >, std::allocator<std::vector<cv::Point_<double>, std::allocator<cv::Point_<double> > > > > asvector_vector_Point2d(cv::Mat)

asvector_vector_Point2f(...)


asvector_vector_Point2f( (Mat)inst_Mat) -> vector_vector_Point2f :

    C++ signature :
        std::vector<std::vector<cv::Point_<float>, std::allocator<cv::Point_<float> > >, std::allocator<std::vector<cv::Point_<float>, std::allocator<cv::Point_<float> > > > > asvector_vector_Point2f(cv::Mat)

asvector_vector_Point2i(...)


asvector_vector_Point2i( (Mat)inst_Mat) -> vector_vector_Point2i :

    C++ signature :
        std::vector<std::vector<cv::Point_<int>, std::allocator<cv::Point_<int> > >, std::allocator<std::vector<cv::Point_<int>, std::allocator<cv::Point_<int> > > > > asvector_vector_Point2i(cv::Mat)

asvector_vector_Point3d(...)


asvector_vector_Point3d( (Mat)inst_Mat) -> vector_vector_Point3d :

    C++ signature :
        std::vector<std::vector<cv::Point3_<double>, std::allocator<cv::Point3_<double> > >, std::allocator<std::vector<cv::Point3_<double>, std::allocator<cv::Point3_<double> > > > > asvector_vector_Point3d(cv::Mat)

asvector_vector_Point3f(...)


asvector_vector_Point3f( (Mat)inst_Mat) -> vector_vector_Point3f :

    C++ signature :
        std::vector<std::vector<cv::Point3_<float>, std::allocator<cv::Point3_<float> > >, std::allocator<std::vector<cv::Point3_<float>, std::allocator<cv::Point3_<float> > > > > asvector_vector_Point3f(cv::Mat)

asvector_vector_Point3i(...)


asvector_vector_Point3i( (Mat)inst_Mat) -> vector_vector_Point3i :

    C++ signature :
        std::vector<std::vector<cv::Point3_<int>, std::allocator<cv::Point3_<int> > >, std::allocator<std::vector<cv::Point3_<int>, std::allocator<cv::Point3_<int> > > > > asvector_vector_Point3i(cv::Mat)

asvector_vector_Vec2i(...)


asvector_vector_Vec2i( (Mat)inst_Mat) -> vector_vector_Vec2i :

    C++ signature :
        std::vector<std::vector<cv::Vec<int, 2>, std::allocator<cv::Vec<int, 2> > >, std::allocator<std::vector<cv::Vec<int, 2>, std::allocator<cv::Vec<int, 2> > > > > asvector_vector_Vec2i(cv::Mat)

asvector_vector_float32(...)


asvector_vector_float32( (Mat)inst_Mat) -> vector_vector_float32 :

    C++ signature :
        std::vector<std::vector<float, std::allocator<float> >, std::allocator<std::vector<float, std::allocator<float> > > > asvector_vector_float32(cv::Mat)

asvector_vector_int(...)


asvector_vector_int( (Mat)inst_Mat) -> vector_vector_int :

    C++ signature :
        std::vector<std::vector<int, std::allocator<int> >, std::allocator<std::vector<int, std::allocator<int> > > > asvector_vector_int(cv::Mat)

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(58, 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(62, dtype=uint8)])

bitwise_and( (MatND)a, (MatND)b, (MatND)c [, (MatND)mask=MatND(shape=(), nchannels=1, depth=0):
array(50, 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(54, 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(82, 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(86, dtype=uint8)])

bitwise_or( (MatND)a, (MatND)b, (MatND)c [, (MatND)mask=MatND(shape=(), nchannels=1, depth=0):
array(74, 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(78, 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(102, 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(106, dtype=uint8)])

bitwise_xor( (MatND)a, (MatND)b, (MatND)c [, (MatND)mask=MatND(shape=(), nchannels=1, depth=0):
array(94, 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(98, 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( (RotatedRect)box, (CvPoint2D32f)pt) -> None :
    
    Wrapped function:
        cvBoxPoints
    Argument 'box':
        C/C++ type: ::CvBox2D.
        Python type: RotatedRect.

    C++ signature :
        void boxPoints(cv::RotatedRect,CvPoint2D32f*)

buildPyramid(...)


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

    C++ signature :
        void buildPyramid(cv::Mat,std::vector<cv::Mat, std::allocator<cv::Mat> > {lvalue},int)

calcAffineFlowPyrLK(...)


calcAffineFlowPyrLK( (Mat)prev, (Mat)curr, (Mat)prev_pyr, (Mat)curr_pyr, (list)prev_features, (Size2i)win_size, (object)level, (TermCriteria)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: Python sequence with elements of C++ type 
        '::CvPoint2D32f'.
    Argument 'criteria':
        C/C++ type: ::CvTermCriteria.
        Python type: TermCriteria.
    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).
    Argument 'win_size':
        C/C++ type: ::CvSize.
        Python type: Size2i.

    C++ signature :
        boost::python::tuple calcAffineFlowPyrLK(cv::Mat {lvalue},cv::Mat {lvalue},cv::Mat {lvalue},cv::Mat {lvalue},boost::python::list,cv::Size_<int>,int,cv::TermCriteria,int)

calcBackProject(...)


calcBackProject( (list)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 Mat, e.g. [Mat(), Mat(), Mat()].
    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: list of Mat.

    C++ signature :
        void calcBackProject(sdcpp::sequence,cv::Mat,cv::SparseMat,cv::Mat {lvalue},boost::python::api::object [,double=1 [,bool=True]])

calcBackProject( (list)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 Mat, e.g. [Mat(), Mat(), Mat()].
    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: list of Mat.

    C++ signature :
        void calcBackProject(sdcpp::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( (list)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: list of Mat.
    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 Mat, e.g. [Mat(), Mat(), Mat()].
    Argument 'nimages':
        Dependent argument: omitted from the function's calling sequence, as 
        its value is derived from argument 'images'.

    C++ signature :
        void calcHist(sdcpp::sequence,cv::Mat,cv::Mat,cv::SparseMat {lvalue},cv::Mat,boost::python::api::object [,bool=True [,bool=False]])

calcHist( (list)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: list of Mat.
    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 Mat, e.g. [Mat(), Mat(), Mat()].
    Argument 'nimages':
        Dependent argument: omitted from the function's calling sequence, as 
        its value is derived from argument 'images'.

    C++ signature :
        void calcHist(sdcpp::sequence,cv::Mat,cv::Mat,cv::MatND {lvalue},cv::Mat,boost::python::api::object [,bool=True [,bool=False]])

calcImageHomography(...)


calcImageHomography( (object)line, (CvPoint3D32f)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, (Size2i)block_size, (Size2i)shift_size, (Size2i)max_range, (object)use_previous, (Mat)velx, (Mat)vely) -> None :
    
    Wrapped function:
        cvCalcOpticalFlowBM
    Argument 'max_range':
        C/C++ type: ::CvSize.
        Python type: Size2i.
    Argument 'prev':
        C/C++ type: ::CvArr const *.
        Python type: Mat.
    Argument 'curr':
        C/C++ type: ::CvArr const *.
        Python type: Mat.
    Argument 'shift_size':
        C/C++ type: ::CvSize.
        Python type: Size2i.
    Argument 'vely':
        C/C++ type: ::CvArr *.
        Python type: Mat.
    Argument 'velx':
        C/C++ type: ::CvArr *.
        Python type: Mat.
    Argument 'block_size':
        C/C++ type: ::CvSize.
        Python type: Size2i.

    C++ signature :
        void calcOpticalFlowBM(cv::Mat {lvalue},cv::Mat {lvalue},cv::Size_<int>,cv::Size_<int>,cv::Size_<int>,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, (TermCriteria)criteria) -> None :
    
    Wrapped function:
        cvCalcOpticalFlowHS
    Argument 'criteria':
        C/C++ type: ::CvTermCriteria.
        Python type: TermCriteria.
    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,cv::TermCriteria)

calcOpticalFlowLK(...)


calcOpticalFlowLK( (Mat)prev, (Mat)curr, (Size2i)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 'win_size':
        C/C++ type: ::CvSize.
        Python type: Size2i.
    Argument 'velx':
        C/C++ type: ::CvArr *.
        Python type: Mat.

    C++ signature :
        void calcOpticalFlowLK(cv::Mat {lvalue},cv::Mat {lvalue},cv::Size_<int>,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, (list)prev_features, (Size2i)win_size, (object)level, (TermCriteria)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: Python sequence with elements of C++ type 
        '::CvPoint2D32f'.
    Argument 'criteria':
        C/C++ type: ::CvTermCriteria.
        Python type: TermCriteria.
    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.
    Argument 'win_size':
        C/C++ type: ::CvSize.
        Python type: Size2i.

    C++ signature :
        boost::python::tuple calcOpticalFlowPyrLK(cv::Mat {lvalue},cv::Mat {lvalue},cv::Mat {lvalue},cv::Mat {lvalue},boost::python::list,cv::Size_<int>,int,cv::TermCriteria,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 of Mat, e.g. [Mat(), Mat(), Mat()].
        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 of Mat, e.g. [Mat(), Mat(), Mat()].
        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, (Size2i)size) -> object :
    
    Wrapped function:
        cvCheckChessboard
    Argument 'src':
        C/C++ type: ::IplImage *.
        Python type: Mat.
    Argument 'size':
        C/C++ type: ::CvSize.
        Python type: Size2i.

    C++ signature :
        boost::python::api::object checkChessboard(cv::Mat {lvalue},cv::Size_<int>)

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 :
    
    Draws a circle.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/drawing_functions.html#cv-circle

    C++ signature :
        void circle(cv::Mat {lvalue},cv::Point_<int>,int,cv::Scalar_<double> [,int=1 [,int=8 [,int=0]]])

clearMemStorage(...)


clearMemStorage( (MemStorage)storage) -> None :
    
    Wrapped function:
        cvClearMemStorage
    Argument 'storage':
        C/C++ type: ::CvMemStorage *.
        Python type: MemStorage.

    C++ signature :
        void clearMemStorage(cv::Ptr<CvMemStorage> {lvalue})

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 :
    
    Clips the line against the image rectangle.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/drawing_functions.html#cv-clipline

    C++ signature :
        bool clipLine(cv::Rect_<int>,cv::Point_<int> {lvalue},cv::Point_<int> {lvalue})

clipLine( (Size2i)imgSize, (Point2i)pt1, (Point2i)pt2) -> bool :
    
    Clips the line against the image rectangle.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/drawing_functions.html#cv-clipline

    C++ signature :
        bool clipLine(cv::Size_<int>,cv::Point_<int> {lvalue},cv::Point_<int> {lvalue})

cloneSeq(...)


cloneSeq( (CvSeq)seq [, (MemStorage)storage=<pyopencv.pyopencvext.MemStorage object at 0x0340B330>]) -> object :
    
    Wrapped function:
        cvCloneSeq
    Argument 'storage':
        C/C++ type: ::CvMemStorage *.
        Python type: MemStorage.

    C++ signature :
        boost::python::api::object cloneSeq(CvSeq const* [,cv::Ptr<CvMemStorage>=<pyopencv.pyopencvext.MemStorage object at 0x0340B330>])

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, (MemStorage)storage, (TermCriteria)criteria) -> object :
    
    Wrapped function:
        cvContourFromContourTree
    Argument 'storage':
        C/C++ type: ::CvMemStorage *.
        Python type: MemStorage.
    Argument 'criteria':
        C/C++ type: ::CvTermCriteria.
        Python type: TermCriteria.

    C++ signature :
        boost::python::api::object contourFromContourTree(CvContourTree const*,cv::Ptr<CvMemStorage> {lvalue},cv::TermCriteria)

convertImage(...)


convertImage( (Mat)src, (Mat)dst [, (object)flags=0]) -> None :
    
    Converts one image to another with an optional vertical flip.
    Wrapped function:
        cvConvertImage
    Reference:
        http://opencv.willowgarage.com/documentation/c/user_interface.html#convertimage#convertimage
    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]])

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])

convexHull_float32(...)


convexHull_float32( (Mat)points [, (bool)clockwise=False]) -> object :
    
    Wrapped function:
        convexHull
    Argument 'hull':
        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 convexHull_float32(cv::Mat [,bool=False])

convexHull_int(...)


convexHull_int( (Mat)points [, (bool)clockwise=False]) -> object :
    
    Wrapped function:
        convexHull
    Argument 'hull':
        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)).
        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 convexHull_int(cv::Mat [,bool=False])

convexityDefects(...)


convexityDefects( (Mat)contour, (Mat)convexhull [, (MemStorage)storage=<pyopencv.pyopencvext.MemStorage object at 0x0340B370>]) -> object :
    
    Wrapped function:
        cvConvexityDefects
    Argument 'storage':
        C/C++ type: ::CvMemStorage *.
        Python type: MemStorage.
    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} [,cv::Ptr<CvMemStorage>=<pyopencv.pyopencvext.MemStorage object at 0x0340B370>])

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( (MemStorage)parent) -> MemStorage :

    C++ signature :
        cv::Ptr<CvMemStorage> createChildMemStorage(cv::Ptr<CvMemStorage> {lvalue})

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, (MemStorage)storage, (object)threshold) -> object :
    
    Wrapped function:
        cvCreateContourTree
    Argument 'storage':
        C/C++ type: ::CvMemStorage *.
        Python type: MemStorage.

    C++ signature :
        boost::python::api::object createContourTree(CvSeq const*,cv::Ptr<CvMemStorage> {lvalue},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]) -> MemStorage :

    C++ signature :
        cv::Ptr<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( (CvPoint3D32f)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, (MemStorage)storage) -> object :
    
    Wrapped function:
        cvCreateSeq
    Argument 'storage':
        C/C++ type: ::CvMemStorage *.
        Python type: MemStorage.

    C++ signature :
        boost::python::api::object createSeq(int,int,int,cv::Ptr<CvMemStorage> {lvalue})

createSet(...)


createSet( (object)set_flags, (object)header_size, (object)elem_size, (MemStorage)storage) -> object :
    
    Wrapped function:
        cvCreateSet
    Argument 'storage':
        C/C++ type: ::CvMemStorage *.
        Python type: MemStorage.

    C++ signature :
        boost::python::api::object createSet(int,int,int,cv::Ptr<CvMemStorage> {lvalue})

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, (MemStorage)storage) -> object :
    
    Wrapped function:
        cvCreateSubdiv2D
    Argument 'storage':
        C/C++ type: ::CvMemStorage *.
        Python type: MemStorage.

    C++ signature :
        boost::python::api::object createSubdiv2D(int,int,int,int,cv::Ptr<CvMemStorage> {lvalue})

createSubdivDelaunay2D(...)


createSubdivDelaunay2D( (Rect)rect, (MemStorage)storage) -> object :
    
    Wrapped function:
        cvCreateSubdivDelaunay2D
    Argument 'storage':
        C/C++ type: ::CvMemStorage *.
        Python type: MemStorage.
    Argument 'rect':
        C/C++ type: ::CvRect.
        Python type: Rect.

    C++ signature :
        boost::python::api::object createSubdivDelaunay2D(cv::Rect_<int>,cv::Ptr<CvMemStorage> {lvalue})

cubeRoot(...)


cubeRoot( (object)val) -> float :
    
    Computes cube root of the argument.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#cv-cuberoot

    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 :
    
    Performs a forward or inverse discrete cosine transform of 1D or 2D 
    array.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#cv-dct

    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 :
    
    Returns determinant of a square floating-point matrix.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#cv-determinant

    C++ signature :
        double determinant(cv::Mat)

dft(...)


dft( (Mat)src, (Mat)dst [, (object)flags=0 [, (object)nonzeroRows=0]]) -> None :
    
    Performs a forward or inverse Discrete Fourier transform of 1D or 2D 
    floating-point array.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#cv-dft

    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 :
    
    Performs per-element division of two arrays or a scalar by an array.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#cv-divide

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

divide( (MatND)a, (MatND)b, (MatND)c [, (object)scale=1]) -> None :
    
    Performs per-element division of two arrays or a scalar by an array.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#cv-divide

    C++ signature :
        void divide(cv::MatND,cv::MatND,cv::MatND {lvalue} [,double=1])

divide( (object)scale, (Mat)b, (Mat)c) -> None :
    
    Performs per-element division of two arrays or a scalar by an array.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#cv-divide

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

divide( (Mat)a, (Mat)b, (Mat)c [, (object)scale=1]) -> None :
    
    Performs per-element division of two arrays or a scalar by an array.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#cv-divide

    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 :
    
    Computes eigenvalues and eigenvectors of a symmetric matrix.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#cv-eigen

    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 :
    
    Computes eigenvalues and eigenvectors of a symmetric matrix.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#cv-eigen

    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 :
    
    Approximates an elliptic arc with a polyline.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/drawing_functions.html#cv-ellipse2poly
    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})

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 :
    
    Calculates the exponent of every array element.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#cv-exp

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

exp( (Mat)a, (Mat)b) -> None :
    
    Calculates the exponent of every array element.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#cv-exp

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

extractSURF(...)


extractSURF( (Mat)img, (Mat)mask, (Seq_CvSURFPoint)keypoints, (CvSURFParams)params [, (object)useProvidedKeyPts=0]) -> object :
    
    Wrapped function:
        cvExtractSURF
    Argument 'descriptors':
        C/C++ type: ::CvSeq * *.
        Python type: vector_float32.
        Output argument: omitted from the function's calling sequence, and is 
        returned along with the function's return value (if any).
    Argument 'mask':
        C/C++ type: ::CvArr const *.
        Python type: Mat.
    Argument 'storage':
        Dependent argument: omitted from the function's calling sequence, as 
        its value is derived from argument 'keypoints'.
    Argument 'keypoints':
        C/C++ type: ::CvSeq * *.
        Python type: Seq_CvSURFPoint.
    Argument 'img':
        C/C++ type: ::CvArr const *.
        Python type: Mat.

    C++ signature :
        boost::python::api::object extractSURF(cv::Mat {lvalue},cv::Mat {lvalue},cv::Seq<CvSURFPoint> {lvalue},CvSURFParams [,int=0])

fastAtan2(...)


fastAtan2( (object)y, (object)x) -> float :
    
    Calculates the angle of a 2D vector in degrees.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#cv-fastatan2

    C++ signature :
        float fastAtan2(float,float)

fillConvexPoly(...)


fillConvexPoly( (Mat)img, (list)pts, (Scalar)color [, (object)lineType=8 [, (object)shift=0]]) -> None :
    
    Fills a convex polygon.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/drawing_functions.html#cv-fillconvexpoly
    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: Python sequence with elements of C++ type '::cv::Point_< 
        int >'.

    C++ signature :
        void fillConvexPoly(cv::Mat {lvalue},boost::python::list,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 :
    
    Fills the area bounded by one or more polygons.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/drawing_functions.html#cv-fillpoly
    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: list of Mat.

    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, (MemStorage)storage [, (object)method=1 [, (object)parameter1=0 [, (object)parameter2=0 [, (object)parameter3=0 [, (object)parameter4=0]]]]]) -> object :
    
    Wrapped function:
        cvFindDominantPoints
    Argument 'storage':
        C/C++ type: ::CvMemStorage *.
        Python type: MemStorage.

    C++ signature :
        boost::python::api::object findDominantPoints(CvSeq*,cv::Ptr<CvMemStorage> {lvalue} [,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 :
    
    Flips a 2D array around vertical, horizontal or both axes.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#cv-flip

    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)

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 :
    
    Performs generalized matrix multiplication.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#cv-gemm

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

getAffineTransform(...)


getAffineTransform( (list)src, (list)dst) -> object :
    
    Argument 'src':
        C/C++ type: ::cv::Point2f const *.
        Python type: Python sequence with elements of C++ type '::cv::Point_< 
        float >'.
    Argument 'dst':
        C/C++ type: ::cv::Point2f const *.
        Python type: Python sequence with elements of C++ type '::cv::Point_< 
        float >'.

    C++ signature :
        boost::python::api::object getAffineTransform(boost::python::list,boost::python::list)

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 :

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 :
    
    Returns optimal DFT size for a given vector size.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#cv-getoptimaldftsize

    C++ signature :
        int getOptimalDFTSize(int)

getOptimalNewCameraMatrix(...)


getOptimalNewCameraMatrix( (Mat)cameraMatrix, (Mat)distCoeffs, (Size2i)imageSize, (object)alpha [, (Size2i)newImgSize=Size2i(width=0, height=0)]) -> tuple :
    
    Argument 'validPixROI':
        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 getOptimalNewCameraMatrix(cv::Mat,cv::Mat,cv::Size_<int>,double [,cv::Size_<int>=Size2i(width=0, height=0)])

getPerspectiveTransform(...)


getPerspectiveTransform( (list)src, (list)dst) -> object :
    
    Argument 'src':
        C/C++ type: ::cv::Point2f const *.
        Python type: Python sequence with elements of C++ type '::cv::Point_< 
        float >'.
    Argument 'dst':
        C/C++ type: ::cv::Point2f const *.
        Python type: Python sequence with elements of C++ type '::cv::Point_< 
        float >'.

    C++ signature :
        boost::python::api::object getPerspectiveTransform(boost::python::list,boost::python::list)

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])

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])

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 :
    
    Calculates the width and height of a text string.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/drawing_functions.html#cv-gettextsize
    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( (object)trackbarname, (object)winname) -> int :
    
    Returns the trackbar position.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/user_interface.html#cv-gettrackbarpos

    C++ signature :
        int getTrackbarPos(std::string,std::string)

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 :
    
    Gets the window's name by its handle.
    Wrapped function:
        cvGetWindowName
    Reference:
        http://opencv.willowgarage.com/documentation/c/user_interface.html#convertimage#getwindowname

    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 :
    
    Computes inverse Discrete Cosine Transform of a 1D or 2D array.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#cv-idct

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

idft(...)


idft( (Mat)src, (Mat)dst [, (object)flags=0 [, (object)nonzeroRows=0]]) -> None :
    
    Computes inverse Discrete Fourier Transform of a 1D or 2D array.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#cv-idft

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

imdecode(...)


imdecode( (Mat)buf, (object)flags) -> Mat :
    
    Reads an image from a buffer in memory.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/reading_and_writing_images_and_video.html#cv-imdecode

    C++ signature :
        cv::Mat imdecode(cv::Mat,int)

imencode(...)


imencode( (object)ext, (Mat)img [, (Mat)params=Mat()]) -> tuple :
    
    Encode an image into a memory buffer.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/reading_and_writing_images_and_video.html#cv-imencode
    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 :
    
    Loads an image from a file.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/reading_and_writing_images_and_video.html#cv-imread

    C++ signature :
        cv::Mat imread(std::string [,int=1])

imshow(...)


imshow( (object)winname, (Mat)mat) -> None :
    
    Displays the image in the specified window.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/user_interface.html#cv-imshow

    C++ signature :
        void imshow(std::string,cv::Mat)

imwrite(...)


imwrite( (object)filename, (Mat)img [, (Mat)params=Mat()]) -> object :
    
    Saves an image to a specified file.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/reading_and_writing_images_and_video.html#cv-imwrite
    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 :
    
    Checks if array elements lie between the elements of two other arrays.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#cv-inrange

    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 :
    
    Checks if array elements lie between the elements of two other arrays.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#cv-inrange

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

inRange( (Mat)src, (Scalar)lowerb, (Scalar)upperb, (Mat)dst) -> None :
    
    Checks if array elements lie between the elements of two other arrays.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#cv-inrange

    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 :
    
    Checks if array elements lie between the elements of two other arrays.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#cv-inrange

    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( (list)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: Python sequence with elements of C++ type 'void *'.

    C++ signature :
        boost::python::api::object initNArrayIterator(boost::python::list,cv::Mat {lvalue},CvMatND*,CvNArrayIterator* [,int=0])

initSubdivDelaunay2D(...)


initSubdivDelaunay2D( (CvSubdiv2D)subdiv, (Rect)rect) -> None :
    
    Wrapped function:
        cvInitSubdivDelaunay2D
    Argument 'rect':
        C/C++ type: ::CvRect.
        Python type: Rect.

    C++ signature :
        void initSubdivDelaunay2D(CvSubdiv2D*,cv::Rect_<int>)

initSystem(...)


initSystem( (list)argv) -> object :
    
    Initializes HighGUI.
    Wrapped function:
        cvInitSystem
    Reference:
        http://opencv.willowgarage.com/documentation/c/user_interface.html#convertimage#initsystem
    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: list of strings.

    C++ signature :
        boost::python::api::object initSystem(boost::python::list)

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 :
    
    Finds the inverse or pseudo-inverse of a matrix.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#cv-invert

    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 :
    
    Draws a line segment connecting two points.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/drawing_functions.html#cv-line

    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 :
    
    Calculates the natural logarithm of every array element.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#cv-log

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

log( (Mat)a, (Mat)b) -> None :
    
    Calculates the natural logarithm of every array element.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#cv-log

    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 :
    
    Calculates magnitude of 2D vectors.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#cv-magnitude

    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 :
    
    Calculates per-element maximum of two arrays or array and a scalar.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#cv-max

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

max( (MatND)a, (MatND)b, (MatND)c) -> None :
    
    Calculates per-element maximum of two arrays or array and a scalar.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#cv-max

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

max( (Mat)a, (object)alpha, (Mat)c) -> None :
    
    Calculates per-element maximum of two arrays or array and a scalar.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#cv-max

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

max( (Mat)a, (Mat)b, (Mat)c) -> None :
    
    Calculates per-element maximum of two arrays or array and a scalar.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#cv-max

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

maxRect(...)


maxRect( (object)rect1, (object)rect2) -> object :
    
    Wrapped function:
        cvMaxRect

    C++ signature :
        CvRect maxRect(CvRect const*,CvRect const*)

mean(...)


mean( (MatND)m [, (MatND)mask]) -> Scalar :
    
    Calculates average (mean) of array elements.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#cv-mean

    C++ signature :
        cv::Scalar_<double> mean(cv::MatND [,cv::MatND])

mean( (Mat)m [, (Mat)mask]) -> Scalar :
    
    Calculates average (mean) of array elements.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#cv-mean

    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(238, dtype=uint8)]) -> None :
    
    Calculates mean and standard deviation of array elements.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#cv-meanstddev

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

meanStdDev( (Mat)m, (Scalar)mean, (Scalar)stddev [, (Mat)mask=Mat()]) -> None :
    
    Calculates mean and standard deviation of array elements.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#cv-meanstddev

    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( (MemStorage)storage, (str)ptr [, (object)len=-1]) -> object :
    
    Wrapped function:
        cvMemStorageAllocString
    Argument 'storage':
        C/C++ type: ::CvMemStorage *.
        Python type: MemStorage.

    C++ signature :
        boost::python::api::object memStorageAllocString(cv::Ptr<CvMemStorage> {lvalue},char const* [,int=-1])

merge(...)


merge( (vector_MatND)mv, (MatND)dst) -> None :
    
    Composes a multi-channel array from several single-channel arrays.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#cv-merge

    C++ signature :
        void merge(std::vector<cv::MatND, std::allocator<cv::MatND> >,cv::MatND {lvalue})

merge( (vector_Mat)mv, (Mat)dst) -> None :
    
    Composes a multi-channel array from several single-channel arrays.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#cv-merge

    C++ signature :
        void merge(std::vector<cv::Mat, std::allocator<cv::Mat> >,cv::Mat {lvalue})

min(...)


min( (MatND)a, (object)alpha, (MatND)c) -> None :
    
    Calculates per-element minimum of two arrays or array and a scalar.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#cv-min

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

min( (MatND)a, (MatND)b, (MatND)c) -> None :
    
    Calculates per-element minimum of two arrays or array and a scalar.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#cv-min

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

min( (Mat)a, (object)alpha, (Mat)c) -> None :
    
    Calculates per-element minimum of two arrays or array and a scalar.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#cv-min

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

min( (Mat)a, (Mat)b, (Mat)c) -> None :
    
    Calculates per-element minimum of two arrays or array and a scalar.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#cv-min

    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( (SparseMat)a) -> tuple :
    
    Finds global minimum and maximum in a whole array or sub-array.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#cv-minmaxloc
    Argument 'maxVal':
        C/C++ type: double *.
        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 'minIdx':
        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).
    Argument 'maxIdx':
        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).
    Argument 'minVal':
        C/C++ type: double *.
        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 minMaxLoc(cv::SparseMat)

minMaxLoc( (MatND)a [, (MatND)mask=MatND(shape=(), nchannels=1, depth=0):
array(22, dtype=uint8)]) -> tuple :
    
    Finds global minimum and maximum in a whole array or sub-array.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#cv-minmaxloc
    Argument 'maxVal':
        C/C++ type: double *.
        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 'minIdx':
        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).
    Argument 'maxIdx':
        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).
    Argument 'minVal':
        C/C++ type: double *.
        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 minMaxLoc(cv::MatND [,cv::MatND=MatND(shape=(), nchannels=1, depth=0):
array(26, dtype=uint8)])

minMaxLoc( (Mat)a [, (Mat)mask=Mat()]) -> tuple :
    
    Finds global minimum and maximum in a whole array or sub-array.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#cv-minmaxloc
    Argument 'minLoc':
        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).
    Argument 'maxVal':
        C/C++ type: double *.
        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 'maxLoc':
        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).
    Argument 'minVal':
        C/C++ type: double *.
        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 minMaxLoc(cv::Mat [,cv::Mat=Mat()])

mixChannels(...)


mixChannels( (vector_MatND)src, (vector_MatND)dst, (Mat)fromTo, (object)npairs) -> None :
    
    Copies specified channels from input arrays to the specified channels 
    of output arrays.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#cv-mixchannels
    Argument 'fromTo':
        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)).

    C++ signature :
        void mixChannels(std::vector<cv::MatND, std::allocator<cv::MatND> >,std::vector<cv::MatND, std::allocator<cv::MatND> > {lvalue},cv::Mat,int)

mixChannels( (vector_Mat)src, (vector_Mat)dst, (Mat)fromTo, (object)npairs) -> None :
    
    Copies specified channels from input arrays to the specified channels 
    of output arrays.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#cv-mixchannels
    Argument 'fromTo':
        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)).

    C++ signature :
        void mixChannels(std::vector<cv::Mat, std::allocator<cv::Mat> >,std::vector<cv::Mat, std::allocator<cv::Mat> > {lvalue},cv::Mat,int)

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 :
    
    Sets the position of the window.
    Wrapped function:
        cvMoveWindow
    Reference:
        http://opencv.willowgarage.com/documentation/c/user_interface.html#convertimage#movewindow

    C++ signature :
        void moveWindow(char const*,int,int)

mulSpectrums(...)


mulSpectrums( (Mat)a, (Mat)b, (Mat)c, (object)flags [, (bool)conjB=False]) -> None :
    
    Performs per-element multiplication of two Fourier spectrums.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#cv-mulspectrums

    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 :
    
    Calculates the product of a matrix and its transposition.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#cv-multransposed

    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 :
    
    Calculates the per-element scaled product of two arrays.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#cv-multiply

    C++ signature :
        void multiply(cv::MatND,cv::MatND,cv::MatND {lvalue} [,double=1])

multiply( (Mat)a, (Mat)b, (Mat)c [, (object)scale=1]) -> None :
    
    Calculates the per-element scaled product of two arrays.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#cv-multiply

    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 :
    
    Creates a window.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/user_interface.html#cv-namedwindow

    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 :
    
    Calculates absolute array norm, absolute difference norm, or relative 
    difference norm.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#cv-norm

    C++ signature :
        double norm(cv::SparseMat,int)

norm( (MatND)a, (MatND)b [, (object)normType=4 [, (MatND)mask=MatND(shape=(), nchannels=1, depth=0):
array(90, dtype=uint8)]]) -> float :
    
    Calculates absolute array norm, absolute difference norm, or relative 
    difference norm.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#cv-norm

    C++ signature :
        double norm(cv::MatND,cv::MatND [,int=4 [,cv::MatND=MatND(shape=(), nchannels=1, depth=0):
array(94, dtype=uint8)]])

norm( (MatND)a [, (object)normType=4 [, (MatND)mask=MatND(shape=(), nchannels=1, depth=0):
array(82, dtype=uint8)]]) -> float :
    
    Calculates absolute array norm, absolute difference norm, or relative 
    difference norm.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#cv-norm

    C++ signature :
        double norm(cv::MatND [,int=4 [,cv::MatND=MatND(shape=(), nchannels=1, depth=0):
array(86, dtype=uint8)]])

norm( (Mat)a, (Mat)b, (object)normType, (Mat)mask) -> float :
    
    Calculates absolute array norm, absolute difference norm, or relative 
    difference norm.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#cv-norm

    C++ signature :
        double norm(cv::Mat,cv::Mat,int,cv::Mat)

norm( (Mat)a, (object)normType, (Mat)mask) -> float :
    
    Calculates absolute array norm, absolute difference norm, or relative 
    difference norm.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#cv-norm

    C++ signature :
        double norm(cv::Mat,int,cv::Mat)

norm( (Mat)a, (Mat)b [, (object)normType=4]) -> float :
    
    Calculates absolute array norm, absolute difference norm, or relative 
    difference norm.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#cv-norm

    C++ signature :
        double norm(cv::Mat,cv::Mat [,int=4])

norm( (Mat)a [, (object)normType=4]) -> float :
    
    Calculates absolute array norm, absolute difference norm, or relative 
    difference norm.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#cv-norm

    C++ signature :
        double norm(cv::Mat [,int=4])

normalize(...)


normalize( (SparseMat)src, (SparseMat)dst, (object)alpha, (object)normType) -> None :
    
    Normalizes array's norm or the range.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#cv-normalize

    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(102, dtype=uint8)]]]]]) -> None :
    
    Normalizes array's norm or the range.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#cv-normalize

    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(106, dtype=uint8)]]]]])

normalize( (Mat)a, (Mat)b [, (object)alpha=1 [, (object)beta=0 [, (object)norm_type=4 [, (object)rtype=-1 [, (Mat)mask=Mat()]]]]]) -> None :
    
    Normalizes array's norm or the range.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#cv-normalize

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

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 :
    
    Performs perspective matrix transformation of vectors.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#cv-perspectivetransform

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

phase(...)


phase( (Mat)x, (Mat)y, (Mat)angle [, (bool)angleInDegrees=False]) -> None :
    
    Calculates the rotation angle of 2d vectors.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#cv-phase

    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 :
    
    Computes x and y coordinates of 2D vectors from their magnitude and 
    angle.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#cv-polartocart

    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 :
    
    Draws several polygonal curves.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/drawing_functions.html#cv-polylines
    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: list of Mat.

    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 :
    
    Raises every array element to a power.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#cv-pow

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

pow( (Mat)a, (object)power, (Mat)b) -> None :
    
    Raises every array element to a power.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#cv-pow

    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 :
    
    Draws a text string.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/drawing_functions.html#cv-puttext

    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 [, (TermCriteria)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.
    Argument 'termcrit':
        C/C++ type: ::CvTermCriteria.
        Python type: TermCriteria.

    C++ signature :
        void pyrMeanShiftFiltering(cv::Mat {lvalue},cv::Mat {lvalue},double,double [,int=1 [,cv::TermCriteria=TermCriteria(type=3, maxCount=5, epsilon=1.0)]])

pyrSegmentation(...)


pyrSegmentation( (Mat)src, (Mat)dst, (MemStorage)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 'storage':
        C/C++ type: ::CvMemStorage *.
        Python type: MemStorage.
    Argument 'src':
        C/C++ type: ::IplImage *.
        Python type: Mat.

    C++ signature :
        boost::python::api::object pyrSegmentation(cv::Mat {lvalue},cv::Mat {lvalue},cv::Ptr<CvMemStorage> {lvalue},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, (Scalar)param1, (Scalar)param2) -> None :
    
    Wrapped function:
        cvRandArr
    Argument 'arr':
        C/C++ type: ::CvArr *.
        Python type: Mat.
    Argument 'rng':
        C/C++ type: ::CvRNG *.
        Python type: RNG.
    Argument 'param2':
        C/C++ type: ::CvScalar.
        Python type: Scalar.
    Argument 'param1':
        C/C++ type: ::CvScalar.
        Python type: Scalar.

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

randShuffle(...)


randShuffle( (Mat)dst [, (object)iterFactor=1.0 [, (RNG)rng=None]]) -> None :
    
    Shuffles the array elements randomly.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#cv-randshuffle

    C++ signature :
        void randShuffle(cv::Mat {lvalue} [,double=1.0 [,cv::RNG*=None]])

randn(...)


randn( (Mat)dst, (Scalar)mean, (Scalar)stddev) -> None :
    
    Fills array with normally distributed random numbers.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#cv-randn

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

randu(...)


randu( (Mat)dst, (Scalar)low, (Scalar)high) -> None :
    
    Generates a single uniformly-distributed random number or array of 
    random numbers.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#cv-randu

    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) -> CvPoint :
    
    Wrapped function:
        cvReadChainPoint

    C++ signature :
        CvPoint readChainPoint(CvChainPtReader*)

read_Mat(...)


read_Mat( (FileNode)node [, (Mat)default_mat=Mat()]) -> object :
    
    Wrapped function:
        read
    Argument 'mat':
        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_Mat(cv::FileNode [,cv::Mat=Mat()])

read_MatND(...)


read_MatND( (FileNode)node [, (MatND)default_mat=MatND(shape=(), nchannels=1, depth=0):
array(206, dtype=uint8)]) -> object :
    
    Wrapped function:
        read
    Argument 'mat':
        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_MatND(cv::FileNode [,cv::MatND=MatND(shape=(), nchannels=1, depth=0):
array(210, dtype=uint8)])

read_SparseMat(...)


read_SparseMat( (FileNode)node [, (SparseMat)default_mat=<pyopencv.pyopencvext.SparseMat object at 0x0340B630>]) -> object :
    
    Wrapped function:
        read
    Argument 'mat':
        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_SparseMat(cv::FileNode [,cv::SparseMat=<pyopencv.pyopencvext.SparseMat object at 0x0340B630>])

read_bool(...)


read_bool( (FileNode)node, (bool)default_value) -> object :
    
    Wrapped function:
        read
    Argument 'value':
        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_bool(cv::FileNode,bool)

read_float32(...)


read_float32( (FileNode)node, (object)default_value) -> object :
    
    Wrapped function:
        read
    Argument 'value':
        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_float32(cv::FileNode,float)

read_float64(...)


read_float64( (FileNode)node, (object)default_value) -> object :
    
    Wrapped function:
        read
    Argument 'value':
        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_float64(cv::FileNode,double)

read_int(...)


read_int( (FileNode)node, (object)default_value) -> object :
    
    Wrapped function:
        read
    Argument 'value':
        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_int(cv::FileNode,int)

read_int16(...)


read_int16( (FileNode)node, (object)default_value) -> object :
    
    Wrapped function:
        read
    Argument 'value':
        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_int16(cv::FileNode,short)

read_int8(...)


read_int8( (FileNode)node, (object)default_value) -> object :
    
    Wrapped function:
        read
    Argument 'value':
        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_int8(cv::FileNode,signed char)

read_list_of_KeyPoint(...)


read_list_of_KeyPoint( (FileNode)node) -> object :
    
    Wrapped function:
        read
    Argument 'keypoints':
        C/C++ type: ::std::vector< cv::KeyPoint > &.
        Python type: list of KeyPoint.
        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_list_of_KeyPoint(cv::FileNode)

read_str(...)


read_str( (FileNode)node, (object)default_value) -> object :
    
    Wrapped function:
        read
    Argument 'value':
        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_str(cv::FileNode,std::string)

read_uint16(...)


read_uint16( (FileNode)node, (object)default_value) -> object :
    
    Wrapped function:
        read
    Argument 'value':
        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_uint16(cv::FileNode,unsigned short)

read_uint8(...)


read_uint8( (FileNode)node, (object)default_value) -> object :
    
    Wrapped function:
        read
    Argument 'value':
        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_uint8(cv::FileNode,unsigned char)

rectangle(...)


rectangle( (Mat)img, (Rect)rec, (Scalar)color [, (object)thickness=1 [, (object)lineType=8 [, (object)shift=0]]]) -> None :
    
    Draws a simple, thick, or filled up-right rectangle.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/drawing_functions.html#cv-rectangle

    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 :
    
    Draws a simple, thick, or filled up-right rectangle.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/drawing_functions.html#cv-rectangle

    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 :
    
    Reduces a matrix to a vector.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#cv-reduce

    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 :
    
    Fill the destination array with repeated copies of the source array.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#cv-repeat

    C++ signature :
        cv::Mat repeat(cv::Mat,int,int)

repeat( (Mat)a, (object)ny, (object)nx, (Mat)b) -> None :
    
    Fill the destination array with repeated copies of the source array.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#cv-repeat

    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 :
    
    Sets the window size.
    Wrapped function:
        cvResizeWindow
    Reference:
        http://opencv.willowgarage.com/documentation/c/user_interface.html#convertimage#resizewindow

    C++ signature :
        void resizeWindow(char const*,int,int)

restoreMemStoragePos(...)


restoreMemStoragePos( (MemStorage)storage, (CvMemStoragePos)pos) -> None :
    
    Wrapped function:
        cvRestoreMemStoragePos
    Argument 'storage':
        C/C++ type: ::CvMemStorage *.
        Python type: MemStorage.

    C++ signature :
        void restoreMemStoragePos(cv::Ptr<CvMemStorage> {lvalue},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, (CvPoint)pt1, (CvPoint)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( (MemStorage)storage, (CvMemStoragePos)pos) -> None :
    
    Wrapped function:
        cvSaveMemStoragePos
    Argument 'storage':
        C/C++ type: ::CvMemStorage const *.
        Python type: MemStorage.

    C++ signature :
        void saveMemStoragePos(cv::Ptr<CvMemStorage> {lvalue},CvMemStoragePos*)

scaleAdd(...)


scaleAdd( (MatND)a, (object)alpha, (MatND)b, (MatND)c) -> None :
    
    Calculates the sum of a scaled array and another array.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#cv-scaleadd

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

scaleAdd( (Mat)a, (object)alpha, (Mat)b, (Mat)c) -> None :
    
    Calculates the sum of a scaled array and another array.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#cv-scaleadd

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

segmentImage(...)


segmentImage( (Mat)srcarr, (Mat)dstarr, (object)canny_threshold, (object)ffill_threshold, (MemStorage)storage) -> object :
    
    Wrapped function:
        cvSegmentImage
    Argument 'dstarr':
        C/C++ type: ::CvArr *.
        Python type: Mat.
    Argument 'srcarr':
        C/C++ type: ::CvArr const *.
        Python type: Mat.
    Argument 'storage':
        C/C++ type: ::CvMemStorage *.
        Python type: MemStorage.

    C++ signature :
        boost::python::api::object segmentImage(cv::Mat {lvalue},cv::Mat {lvalue},double,double,cv::Ptr<CvMemStorage> {lvalue})

segmentMotion(...)


segmentMotion( (Mat)mhi, (Mat)seg_mask, (MemStorage)storage, (object)timestamp, (object)seg_thresh) -> object :
    
    Wrapped function:
        cvSegmentMotion
    Argument 'storage':
        C/C++ type: ::CvMemStorage *.
        Python type: MemStorage.
    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},cv::Ptr<CvMemStorage> {lvalue},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]]])

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 :
    
    Initializes a scaled identity matrix.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#cv-setidentity

    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)

setTrackbarPos(...)


setTrackbarPos( (object)trackbarname, (object)winname, (object)pos) -> None :
    
    Sets the trackbar position.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/user_interface.html#cv-settrackbarpos

    C++ signature :
        void setTrackbarPos(std::string,std::string,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) -> object :
    
    Wrapped function:
        cvSliceLength
    Argument 'slice':
        C/C++ type: ::CvSlice.
        Python type: Range.

    C++ signature :
        boost::python::api::object sliceLength(cv::Range,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 :
    
    Solves one or more linear systems or least-squares problems.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#cv-solve

    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 :
    
    Sorts each row or each column of a matrix.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#cv-sort

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

sortIdx(...)


sortIdx( (Mat)a, (Mat)b, (object)flags) -> None :
    
    Sorts each row or each column of a matrix.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#cv-sortIdx

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

split(...)


split( (MatND)m, (vector_MatND)mv) -> None :
    
    Divides multi-channel array into several single-channel arrays.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#cv-split

    C++ signature :
        void split(cv::MatND,std::vector<cv::MatND, std::allocator<cv::MatND> > {lvalue})

split( (Mat)m, (vector_Mat)mv) -> None :
    
    Divides multi-channel array into several single-channel arrays.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#cv-split

    C++ signature :
        void split(cv::Mat,std::vector<cv::Mat, std::allocator<cv::Mat> > {lvalue})

sqrt(...)


sqrt( (MatND)a, (MatND)b) -> None :
    
    Calculates square root of array elements.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#cv-sqrt

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

sqrt( (Mat)a, (Mat)b) -> None :
    
    Calculates square root of array elements.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#cv-sqrt

    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( (CvPoint)pt, (object)size, (object)response) -> CvStarKeypoint :
    
    Wrapped function:
        cvStarKeypoint

    C++ signature :
        CvStarKeypoint starKeypoint(CvPoint,int,float)

startFindContours(...)


startFindContours( (Mat)image, (MemStorage)storage [, (object)header_size=88 [, (object)mode=1 [, (object)method=2 [, (CvPoint)offset=CvPoint(x=0, y=0)]]]]) -> object :
    
    Wrapped function:
        cvStartFindContours
    Argument 'image':
        C/C++ type: ::CvArr *.
        Python type: Mat.
    Argument 'storage':
        C/C++ type: ::CvMemStorage *.
        Python type: MemStorage.

    C++ signature :
        boost::python::api::object startFindContours(cv::Mat {lvalue},cv::Ptr<CvMemStorage> {lvalue} [,int=88 [,int=1 [,int=2 [,CvPoint=CvPoint(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*)

startWindowThread()

    Wrapped function:
        cvStartWindowThread

    C++ signature :
        int startWindowThread()

Returns: int :

startWriteStruct(...)


startWriteStruct( (FileStorage)fs, (str)name, (object)struct_flags [, (str)type_name=None [, (CvAttrList)attributes=<pyopencv.pyopencvext.CvAttrList object at 0x0340B3F0>]]) -> 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 0x0340B3F0>]])

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]])

stereoRectify(...)


stereoRectify( (Mat)cameraMatrix1, (Mat)distCoeffs1, (Mat)cameraMatrix2, (Mat)distCoeffs2, (Size2i)imageSize, (Mat)R, (Mat)T, (Mat)R1, (Mat)R2, (Mat)P1, (Mat)P2, (Mat)Q [, (object)flags=1024]) -> None :

    C++ signature :
        void stereoRectify(cv::Mat,cv::Mat,cv::Mat,cv::Mat,cv::Size_<int>,cv::Mat,cv::Mat,cv::Mat {lvalue},cv::Mat {lvalue},cv::Mat {lvalue},cv::Mat {lvalue},cv::Mat {lvalue} [,int=1024])

stereoRectify2(...)


stereoRectify2( (Mat)cameraMatrix1, (Mat)distCoeffs1, (Mat)cameraMatrix2, (Mat)distCoeffs2, (Size2i)imageSize, (Mat)R, (Mat)T, (Mat)R1, (Mat)R2, (Mat)P1, (Mat)P2, (Mat)Q, (object)alpha [, (Size2i)newImageSize=Size2i(width=0, height=0) [, (object)flags=1024]]) -> tuple :
    
    Wrapped function:
        stereoRectify
    Argument 'validPixROI2':
        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).
    Argument 'validPixROI1':
        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 stereoRectify2(cv::Mat,cv::Mat,cv::Mat,cv::Mat,cv::Size_<int>,cv::Mat,cv::Mat,cv::Mat {lvalue},cv::Mat {lvalue},cv::Mat {lvalue},cv::Mat {lvalue},cv::Mat {lvalue},double [,cv::Size_<int>=Size2i(width=0, height=0) [,int=1024]])

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(6, dtype=uint8)]) -> None :
    
    Calculates per-element difference between two arrays or array and a 
    scalar.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#cv-subtract

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

subtract( (Scalar)s, (MatND)a, (MatND)c [, (MatND)mask=MatND(shape=(), nchannels=1, depth=0):
array(250, dtype=uint8)]) -> None :
    
    Calculates per-element difference between two arrays or array and a 
    scalar.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#cv-subtract

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

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

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

subtract( (MatND)a, (MatND)b, (MatND)c, (MatND)mask) -> None :
    
    Calculates per-element difference between two arrays or array and a 
    scalar.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#cv-subtract

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

subtract( (Scalar)s, (Mat)a, (Mat)c [, (Mat)mask=Mat()]) -> None :
    
    Calculates per-element difference between two arrays or array and a 
    scalar.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#cv-subtract

    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 :
    
    Calculates per-element difference between two arrays or array and a 
    scalar.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#cv-subtract

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

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

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

subtract( (Mat)a, (Mat)b, (Mat)c, (Mat)mask) -> None :
    
    Calculates per-element difference between two arrays or array and a 
    scalar.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#cv-subtract

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

sum(...)


sum( (MatND)m) -> Scalar :
    
    Calculates sum of array elements.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#cv-sum

    C++ signature :
        cv::Scalar_<double> sum(cv::MatND)

sum( (Mat)m) -> Scalar :
    
    Calculates sum of array elements.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#cv-sum

    C++ signature :
        cv::Scalar_<double> sum(cv::Mat)

theRNG()

    Returns the default random number generator.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#cv-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 :
    
    Returns the trace of a matrix.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#cv-trace

    C++ signature :
        cv::Scalar_<double> trace(cv::Mat)

transform(...)


transform( (Mat)src, (Mat)dst, (Mat)m) -> None :
    
    Performs matrix transformation of every array element.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#cv-transform

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

transpose(...)


transpose( (Mat)a, (Mat)b) -> None :
    
    Transposes a matrix.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#cv-transpose

    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 :
    
    Waits for a pressed key.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/user_interface.html#cv-waitkey

    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 0x0340B430>]) -> 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 0x0340B430>])

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)

write_Mat(...)


write_Mat( (FileStorage)fs, (object)name, (Mat)value) -> None :
    
    Wrapped function:
        write

    C++ signature :
        void write_Mat(cv::FileStorage {lvalue},std::string,cv::Mat)

write_MatND(...)


write_MatND( (FileStorage)fs, (object)name, (MatND)value) -> None :
    
    Wrapped function:
        write

    C++ signature :
        void write_MatND(cv::FileStorage {lvalue},std::string,cv::MatND)

write_Range(...)


write_Range( (FileStorage)fs, (object)name, (Range)r) -> None :
    
    Wrapped function:
        write

    C++ signature :
        void write_Range(cv::FileStorage {lvalue},std::string,cv::Range)

write_Range( (FileStorage)fs, (Range)r) -> None :
    
    Wrapped function:
        write

    C++ signature :
        void write_Range(cv::FileStorage {lvalue},cv::Range)

write_SparseMat(...)


write_SparseMat( (FileStorage)fs, (object)name, (SparseMat)value) -> None :
    
    Wrapped function:
        write

    C++ signature :
        void write_SparseMat(cv::FileStorage {lvalue},std::string,cv::SparseMat)

write_float32(...)


write_float32( (FileStorage)fs, (object)value) -> None :
    
    Wrapped function:
        write

    C++ signature :
        void write_float32(cv::FileStorage {lvalue},float)

write_float32( (FileStorage)fs, (object)name, (object)value) -> None :
    
    Wrapped function:
        write

    C++ signature :
        void write_float32(cv::FileStorage {lvalue},std::string,float)

write_float64(...)


write_float64( (FileStorage)fs, (object)value) -> None :
    
    Wrapped function:
        write

    C++ signature :
        void write_float64(cv::FileStorage {lvalue},double)

write_float64( (FileStorage)fs, (object)name, (object)value) -> None :
    
    Wrapped function:
        write

    C++ signature :
        void write_float64(cv::FileStorage {lvalue},std::string,double)

write_int(...)


write_int( (FileStorage)fs, (object)value) -> None :
    
    Wrapped function:
        write

    C++ signature :
        void write_int(cv::FileStorage {lvalue},int)

write_int( (FileStorage)fs, (object)name, (object)value) -> None :
    
    Wrapped function:
        write

    C++ signature :
        void write_int(cv::FileStorage {lvalue},std::string,int)

write_list_of_KeyPoint(...)


write_list_of_KeyPoint( (FileStorage)fs, (object)name, (list)keypoints) -> None :
    
    Wrapped function:
        write
    Argument 'keypoints':
        C/C++ type: ::std::vector< cv::KeyPoint > const &.
        Python type: list of KeyPoint.
        To convert a Mat into a list, invoke one of Mat's member functions 
        to_list_of_...().

    C++ signature :
        void write_list_of_KeyPoint(cv::FileStorage {lvalue},std::string,boost::python::list)

write_str(...)


write_str( (FileStorage)fs, (object)value) -> None :
    
    Wrapped function:
        write

    C++ signature :
        void write_str(cv::FileStorage {lvalue},std::string)

write_str( (FileStorage)fs, (object)name, (object)value) -> None :
    
    Wrapped function:
        write

    C++ signature :
        void write_str(cv::FileStorage {lvalue},std::string,std::string)

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