Package pyopencv

Functions

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

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

FAST(...)
FAST( (Mat)image, (object)threshold [, (bool)nonmax_supression=True]) -> object :

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

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 :

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(76, 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 :

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

bitwise_xor(...)
bitwise_xor( (MatND)a, (Scalar)s, (MatND)c [, (MatND)mask=MatND(shape=(), nchannels=1, depth=0): array(120, 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, (vector_Point2f)prev_features, (Size2i)win_size, (object)level, (TermCriteria)criteria, (object)flags) -> tuple :

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

calcCovarMatrix(...)
calcCovarMatrix( (Mat)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) -> float :

calcHist(...)
calcHist( (vector_Mat)images, (vector_int)channels, (Mat)mask, (SparseMat)hist, (vector_int)histSize, (vector_vector_float32)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)apertureSize=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)prev0, (Mat)next0, (Mat)flow0, (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, (vector_Point2f)prevPts, (vector_Point2f)nextPts, (vector_uint8)status, (vector_float32)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( (vector_vector_Point3f)objectPoints, (vector_vector_Point2f)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.cxtypes_h_ext.MemStorage object at 0x02040B70>]) -> 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.cxtypes_h_ext.MemStorage object at 0x0214AA70>]) -> 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, (vector_Point2f)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 :

CvBlobDetector :

createBlobDetectorCC()
Wrapped function: cvCreateBlobDetectorCC

CvBlobDetector :

createBlobDetectorSimple()
Wrapped function: cvCreateBlobDetectorSimple

CvBlobTracker :

createBlobTrackerCC()
Wrapped function: cvCreateBlobTrackerCC

CvBlobTracker :

createBlobTrackerCCMSPF()
Wrapped function: cvCreateBlobTrackerCCMSPF

CvBlobTracker :

createBlobTrackerMS()
Wrapped function: cvCreateBlobTrackerMS

CvBlobTracker :

createBlobTrackerMSFG()
Wrapped function: cvCreateBlobTrackerMSFG

CvBlobTracker :

createBlobTrackerMSFGS()
Wrapped function: cvCreateBlobTrackerMSFGS

CvBlobTracker :

createBlobTrackerMSPF()
Wrapped function: cvCreateBlobTrackerMSPF

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

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

CvBlobTrackAnalysis :

createModuleBlobTrackAnalysisHistP()
Wrapped function: cvCreateModuleBlobTrackAnalysisHistP

CvBlobTrackAnalysis :

createModuleBlobTrackAnalysisHistPV()
Wrapped function: cvCreateModuleBlobTrackAnalysisHistPV

CvBlobTrackAnalysis :

createModuleBlobTrackAnalysisHistPVS()
Wrapped function: cvCreateModuleBlobTrackAnalysisHistPVS

CvBlobTrackAnalysis :

createModuleBlobTrackAnalysisHistSS()
Wrapped function: cvCreateModuleBlobTrackAnalysisHistSS

CvBlobTrackAnalysis :

createModuleBlobTrackAnalysisIOR()
Wrapped function: cvCreateModuleBlobTrackAnalysisIOR

CvBlobTrackAnalysis :

createModuleBlobTrackAnalysisTrackDist()
Wrapped function: cvCreateModuleBlobTrackAnalysisTrackDist

CvBlobTrackGen :

createModuleBlobTrackGen1()
Wrapped function: cvCreateModuleBlobTrackGen1

CvBlobTrackGen :

createModuleBlobTrackGenYML()
Wrapped function: cvCreateModuleBlobTrackGenYML

CvBlobTrackPostProc :

createModuleBlobTrackPostProcKalman()
Wrapped function: cvCreateModuleBlobTrackPostProcKalman

CvBlobTrackPostProc :

createModuleBlobTrackPostProcTimeAverExp()
Wrapped function: cvCreateModuleBlobTrackPostProcTimeAverExp

CvBlobTrackPostProc :

createModuleBlobTrackPostProcTimeAverRect()
Wrapped function: cvCreateModuleBlobTrackPostProcTimeAverRect

CvBlobTrackPredictor :

createModuleBlobTrackPredictKalman()
Wrapped function: cvCreateModuleBlobTrackPredictKalman

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 [, (vector_float32)mask=vector_float32(len=0, []) [, (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, (vector_vector_Point2i)contours, (object)contourIdx, (Scalar)color [, (object)thickness=1 [, (object)lineType=8 [, (vector_Vec4i)hierarchy=vector_Vec4i(len=0, []) [, (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, (vector_Point2i)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, (vector_uint8)outliers [, (object)param1=3.0 [, (object)param2=0.98999999999999999]]) -> int :

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, (vector_Point2i)pts, (Scalar)color [, (object)lineType=8 [, (object)shift=0]]) -> None :

fillPoly(...)
fillPoly( (Mat)img, (vector_vector_Point2i)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, (vector_Point2f)corners, (Size2i)region_size) -> bool :

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( (vector_Point2f)src, (vector_Point2f)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()
C++ signature :...

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( (vector_Point2f)src, (vector_Point2f)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()
C++ signature :...

long :

getTickCount()
C++ signature :...

float :

getTickFrequency()
C++ signature :...

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( (vector_Rect)rectList, (vector_int)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 [, (vector_int)params=vector_int(len=0, [])]) -> tuple :

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

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

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

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

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

initNArrayIterator(...)
initNArrayIterator( (vector_Mat)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(42, 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) -> tuple :

minMaxLoc(...)
minMaxLoc( (SparseMat)a) -> tuple :

mixChannels(...)
mixChannels( (vector_MatND)src, (vector_MatND)dst, (vector_int)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, (vector_vector_Point2i)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(94, dtype=uint8)]) -> object :

read_SparseMat(...)
read_SparseMat( (FileNode)node [, (SparseMat)default_mat=<pyopencv.cxcore_hpp_ext.SparseMat object at 0x0216E070>]) -> 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)disparity, (Mat)_3dImage, (Mat)Q [, (bool)handleMissingValues=False]) -> 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 :

rotateHistToMode(...)
rotateHistToMode( (vector_int)in_hist, (vector_int)out_hist) -> None :

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

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

sampleLine(...)
sampleLine( (Mat)image, (Point2i)pt1, (Point2i)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)arg0) -> 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( (Point2i)pt, (object)size, (object)response) -> object :

startFindContours(...)
startFindContours( (Mat)image, (MemStorage)storage [, (object)header_size=88 [, (object)mode=1 [, (object)method=2 [, (Point2i)offset=Point2i(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.cxtypes_h_ext.CvAttrList object at 0x02040BB0>]]) -> None :

stereoCalibrate(...)
stereoCalibrate( (vector_vector_Point3f)objectPoints, (vector_vector_Point2f)imagePoints1, (vector_vector_Point2f)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]]) -> float :

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 :

bool :

useOptimized()
C++ signature :...

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.cxtypes_h_ext.CvAttrList object at 0x02040BF0>]) -> 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, (vector_KeyPoint)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.cxcore_h_ext.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.cxcore_h_ext.flann_centers_init_t....

CENTERS_KMEANSPP = pyopencv.cxcore_h_ext.flann_centers_init_t....

CENTERS_RANDOM = pyopencv.cxcore_h_ext.flann_centers_init_t.CE...

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.cxcore_h_ext.flann_algorithm_t.COMPOSITE

CV_16S = 3

CV_16SC1 = 3

CV_16SC2 = 11

CV_16SC3 = 19

CV_16SC4 = 27

CV_16U = 2

CV_16UC1 = 2

CV_16UC2 = 10

CV_16UC3 = 18

CV_16UC4 = 26

CV_32F = 5

CV_32FC1 = 5

CV_32FC2 = 13

CV_32FC3 = 21

CV_32FC4 = 29

CV_32S = 4

CV_32SC1 = 4

CV_32SC2 = 12

CV_32SC3 = 20

CV_32SC4 = 28

CV_64F = 6

CV_64FC1 = 6

CV_64FC2 = 14

CV_64FC3 = 22

CV_64FC4 = 30

CV_8S = 1

CV_8SC1 = 1

CV_8SC2 = 9

CV_8SC3 = 17

CV_8SC4 = 25

CV_8U = 0

CV_8UC1 = 0

CV_8UC2 = 8

CV_8UC3 = 16

CV_8UC4 = 24

CV_AA = 16

CV_ARRAY = 2

CV_AUTOSTEP = 2147483647

CV_BACK = 0

CV_BADARG_ERR = pyopencv.cxtypes_h_ext.CvStatus.CV_BADARG_ERR

CV_BADCHANNELS_ERR = pyopencv.cxtypes_h_ext.CvStatus.CV_BADCHA...

CV_BADCOEF_ERR = pyopencv.cxtypes_h_ext.CvStatus.CV_BADCOEF_ERR

CV_BADCONVERGENCE_ERR = pyopencv.cxtypes_h_ext.CvStatus.CV_BAD...

CV_BADDEPTH_ERR = pyopencv.cxtypes_h_ext.CvStatus.CV_BADDEPTH_ERR

CV_BADFACTOR_ERR = pyopencv.cxtypes_h_ext.CvStatus.CV_BADFACTO...

CV_BADFLAG_ERR = pyopencv.cxtypes_h_ext.CvStatus.CV_BADFLAG_ERR

CV_BADHEADER_ERR = pyopencv.cxtypes_h_ext.CvStatus.CV_BADHEADE...

CV_BADMEMBLOCK_ERR = pyopencv.cxtypes_h_ext.CvStatus.CV_BADMEM...

CV_BADPOINT_ERR = pyopencv.cxtypes_h_ext.CvStatus.CV_BADPOINT_ERR

CV_BADRANGE_ERR = pyopencv.cxtypes_h_ext.CvStatus.CV_BADRANGE_ERR

CV_BADROI_ERR = pyopencv.cxtypes_h_ext.CvStatus.CV_BADROI_ERR

CV_BADSCALE_ERR = pyopencv.cxtypes_h_ext.CvStatus.CV_BADSCALE_ERR

CV_BADSIZE_ERR = pyopencv.cxtypes_h_ext.CvStatus.CV_BADSIZE_ERR

CV_BADSTEP_ERR = pyopencv.cxtypes_h_ext.CvStatus.CV_BADSTEP_ERR

CV_BGR2BGR555 = 22

CV_BGR2BGR565 = 12

CV_BGR2BGRA = 0

CV_BGR2GRAY = 6

CV_BGR2HLS = 52

CV_BGR2HSV = 40

CV_BGR2Lab = 44

CV_BGR2Luv = 50

CV_BGR2RGB = 4

CV_BGR2RGBA = 2

CV_BGR2XYZ = 32

CV_BGR2YCrCb = 36

CV_BGR5552BGR = 24

CV_BGR5552BGRA = 28

CV_BGR5552GRAY = 31

CV_BGR5552RGB = 25

CV_BGR5552RGBA = 29

CV_BGR5652BGR = 14

CV_BGR5652BGRA = 18

CV_BGR5652GRAY = 21

CV_BGR5652RGB = 15

CV_BGR5652RGBA = 19

CV_BGRA2BGR = 1

CV_BGRA2BGR555 = 26

CV_BGRA2BGR565 = 16

CV_BGRA2GRAY = 10

CV_BGRA2RGB = 3

CV_BGRA2RGBA = 5

CV_BILATERAL = 4

CV_BLOB_MINH = 5

CV_BLOB_MINW = 5

CV_BLUR = 1

CV_BLUR_NO_SCALE = 0

CV_BadAlign = -21

CV_BadAlphaChannel = -18

CV_BadCOI = -24

CV_BadCallBack = -22

CV_BadDataPtr = -12

CV_BadDepth = -17

CV_BadImageSize = -10

CV_BadModelOrChSeq = -14

CV_BadNumChannel1U = -16

CV_BadNumChannels = -15

CV_BadOffset = -11

CV_BadOrder = -19

CV_BadOrigin = -20

CV_BadROISize = -25

CV_BadStep = -13

CV_BadTileSize = -23

CV_BayerBG2BGR = 46

CV_BayerBG2RGB = 48

CV_BayerGB2BGR = 47

CV_BayerGB2RGB = 49

CV_BayerGR2BGR = 49

CV_BayerGR2RGB = 47

CV_BayerRG2BGR = 48

CV_BayerRG2RGB = 46

CV_CALIB_CB_FAST_CHECK = 8

CV_CAP_ANY = 0

CV_CAP_CMU1394 = 300

CV_CAP_DC1394 = 300

CV_CAP_DSHOW = 700

CV_CAP_FIREWARE = 300

CV_CAP_FIREWIRE = 300

CV_CAP_IEEE1394 = 300

CV_CAP_MIL = 100

CV_CAP_PROP_BRIGHTNESS = 10

CV_CAP_PROP_CONTRAST = 11

CV_CAP_PROP_CONVERT_RGB = 16

CV_CAP_PROP_EXPOSURE = 15

CV_CAP_PROP_FORMAT = 8

CV_CAP_PROP_FOURCC = 6

CV_CAP_PROP_FPS = 5

CV_CAP_PROP_FRAME_COUNT = 7

CV_CAP_PROP_FRAME_HEIGHT = 4

CV_CAP_PROP_FRAME_WIDTH = 3

CV_CAP_PROP_GAIN = 14

CV_CAP_PROP_HUE = 13

CV_CAP_PROP_MODE = 9

CV_CAP_PROP_POS_AVI_RATIO = 2

CV_CAP_PROP_POS_FRAMES = 1

CV_CAP_PROP_POS_MSEC = 0

CV_CAP_PROP_RECTIFICATION = 18

CV_CAP_PROP_SATURATION = 12

CV_CAP_PROP_WHITE_BALANCE = 17

CV_CAP_PVAPI = 800

CV_CAP_QT = 500

CV_CAP_STEREO = 400

CV_CAP_TYZX = 400

CV_CAP_UNICAP = 600

CV_CAP_V4L = 200

CV_CAP_V4L2 = 200

CV_CAP_VFW = 200

CV_CLOCKWISE = 1

CV_CN_MAX = 64

CV_CN_SHIFT = 3

CV_COLORCVT_MAX = 100

CV_COL_SAMPLE = 0

CV_COMP_BHATTACHARYYA = 3

CV_COMP_CHISQR = 1

CV_COMP_CORREL = 0

CV_COMP_INTERSECT = 2

CV_CONTOURS_MATCH_I1 = 1

CV_CONTOURS_MATCH_I2 = 2

CV_CONTOURS_MATCH_I3 = 3

CV_CONTOUR_TREES_MATCH_I1 = 1

CV_COUNT = 0

CV_COUNTER_CLOCKWISE = 2

CV_COVAR_COLS = 16

CV_COVAR_NORMAL = 1

CV_COVAR_ROWS = 8

CV_COVAR_SCALE = 4

CV_COVAR_SCRAMBLED = 0

CV_COVAR_USE_AVG = 2

CV_CPU_AVX = 10

CV_CPU_MMX = 1

CV_CPU_NONE = 0

CV_CPU_SSE = 2

CV_CPU_SSE2 = 3

CV_CPU_SSE3 = 4

CV_CPU_SSE4_1 = 6

CV_CPU_SSE4_2 = 7

CV_CPU_SSSE3 = 5

CV_CVTIMG_FLIP = 1

CV_CVTIMG_SWAP_RB = 2

CV_DEPTH_MAX = 8

CV_DISPARITY_BIRCHFIELD = 0

CV_DIST_C = 3

CV_DIST_FAIR = 5

CV_DIST_HUBER = 7

CV_DIST_L1 = 1

CV_DIST_L12 = 4

CV_DIST_L2 = 2

CV_DIST_MASK_3 = 3

CV_DIST_MASK_5 = 5

CV_DIST_MASK_PRECISE = 0

CV_DIST_USER = -1

CV_DIST_WELSCH = 6

CV_DIV_BY_ZERO_ERR = pyopencv.cxtypes_h_ext.CvStatus.CV_DIV_BY...

CV_DOMINANT_IPAN = 1

CV_EVENT_FLAG_ALTKEY = 32

CV_EVENT_FLAG_CTRLKEY = 8

CV_EVENT_FLAG_LBUTTON = 1

CV_EVENT_FLAG_MBUTTON = 4

CV_EVENT_FLAG_RBUTTON = 2

CV_EVENT_FLAG_SHIFTKEY = 16

CV_EVENT_LBUTTONDBLCLK = 7

CV_EVENT_LBUTTONDOWN = 1

CV_EVENT_LBUTTONUP = 4

CV_EVENT_MBUTTONDBLCLK = 9

CV_EVENT_MBUTTONDOWN = 3

CV_EVENT_MBUTTONUP = 6

CV_EVENT_MOUSEMOVE = 0

CV_EVENT_RBUTTONDBLCLK = 8

CV_EVENT_RBUTTONDOWN = 2

CV_EVENT_RBUTTONUP = 5

CV_ErrModeLeaf = 0

CV_ErrModeParent = 1

CV_ErrModeSilent = 2

CV_FACE_LEFT_EYE = pyopencv.cvaux_ext.CV_FACE_ELEMENTS.CV_FACE...

CV_FACE_MOUTH = pyopencv.cvaux_ext.CV_FACE_ELEMENTS.CV_FACE_MOUTH

CV_FACE_RIGHT_EYE = pyopencv.cvaux_ext.CV_FACE_ELEMENTS.CV_FAC...

CV_FILLED = -1

CV_FOURCC_DEFAULT = 1448433993

CV_FOURCC_PROMPT = -1

CV_FRONT = 1

CV_GAUSSIAN = 2

CV_GAUSSIAN_5x5 = pyopencv.cv_h_ext.CvFilter.CV_GAUSSIAN_5x5

CV_GRAPH = 1536

CV_GRAPH_FLAG_ORIENTED = 4096

CV_GRAY2BGR = 8

CV_GRAY2BGR555 = 30

CV_GRAY2BGR565 = 20

CV_GRAY2BGRA = 9

CV_GRAY2RGB = 8

CV_GRAY2RGBA = 9

CV_HAAR_FEATURE_MAX = 3

CV_HAAR_MAGIC_VAL = 1112539136

CV_HARDWARE_MAX_FEATURE = 255

CV_HLS2BGR = 60

CV_HLS2RGB = 61

CV_HSV2BGR = 54

CV_HSV2RGB = 55

CV_HeaderIsNull = -9

CV_IDP_BIRCHFIELD_PARAM1 = 25

CV_IDP_BIRCHFIELD_PARAM2 = 5

CV_IDP_BIRCHFIELD_PARAM3 = 12

CV_IDP_BIRCHFIELD_PARAM4 = 15

CV_IDP_BIRCHFIELD_PARAM5 = 25

CV_IMWRITE_JPEG_QUALITY = 1

CV_IMWRITE_PNG_COMPRESSION = 16

CV_IMWRITE_PXM_BINARY = 32

CV_INPLACE_NOT_SUPPORTED_ERR = pyopencv.cxtypes_h_ext.CvStatus...

CV_LKFLOW_GET_MIN_EIGENVALS = 8

CV_LKFLOW_INITIAL_GUESSES = 4

CV_LKFLOW_PYR_A_READY = 1

CV_LKFLOW_PYR_B_READY = 2

CV_LOAD_IMAGE_ANYCOLOR = 4

CV_LOAD_IMAGE_ANYDEPTH = 2

CV_LOAD_IMAGE_COLOR = 1

CV_LOAD_IMAGE_GRAYSCALE = 0

CV_LOAD_IMAGE_UNCHANGED = -1

CV_LOG2 = 0.69314718056

CV_LOG2PI = 1.83787706641

CV_Lab2BGR = 56

CV_Lab2RGB = 57

CV_Luv2BGR = 58

CV_Luv2RGB = 59

CV_MAGIC_MASK = 4294901760

CV_MAJOR_VERSION = 2

CV_MATND_MAGIC_VAL = 1111687168

CV_MAT_CN_MASK = 504

CV_MAT_CONT_FLAG = 512

CV_MAT_CONT_FLAG_SHIFT = 9

CV_MAT_DEPTH_MASK = 7

CV_MAT_MAGIC_VAL = 1111621632

CV_MAT_TEMP_FLAG = 1024

CV_MAT_TEMP_FLAG_SHIFT = 10

CV_MAT_TYPE_MASK = 511

CV_MAX_ARR = 10

CV_MAX_DIM = 32

CV_MAX_DIM_HEAP = 65536

CV_MAX_SOBEL_KSIZE = 7

CV_MEDIAN = 3

CV_MINOR_VERSION = 1

CV_MOP_BLACKHAT = 6

CV_MOP_CLOSE = 3

CV_MOP_DILATE = 1

CV_MOP_ERODE = 0

CV_MOP_GRADIENT = 4

CV_MOP_OPEN = 2

CV_MOP_TOPHAT = 5

CV_MaskIsTiled = -26

CV_NEXT_AROUND_DST = pyopencv.cv_h_ext.CvNextEdgeType.CV_NEXT_...

CV_NEXT_AROUND_LEFT = pyopencv.cv_h_ext.CvNextEdgeType.CV_NEXT...

CV_NEXT_AROUND_ORG = pyopencv.cv_h_ext.CvNextEdgeType.CV_NEXT_...

CV_NEXT_AROUND_RIGHT = pyopencv.cv_h_ext.CvNextEdgeType.CV_NEX...

CV_NODE_EMPTY = 32

CV_NODE_FLOAT = 2

CV_NODE_FLOW = 8

CV_NODE_INT = 1

CV_NODE_INTEGER = 1

CV_NODE_MAP = 6

CV_NODE_NAMED = 64

CV_NODE_NONE = 0

CV_NODE_REAL = 2

CV_NODE_REF = 4

CV_NODE_SEQ = 5

CV_NODE_SEQ_SIMPLE = 256

CV_NODE_STR = 3

CV_NODE_STRING = 3

CV_NODE_TYPE_MASK = 7

CV_NODE_USER = 16

CV_NOTDEFINED_ERR = pyopencv.cxtypes_h_ext.CvStatus.CV_NOTDEFI...

CV_NOTFOUND_ERR = pyopencv.cxtypes_h_ext.CvStatus.CV_NOTFOUND_ERR

CV_NO_CN_CHECK = 2

CV_NO_DEPTH_CHECK = 1

CV_NO_ERR = pyopencv.cxtypes_h_ext.CvStatus.CV_NO_ERR

CV_NO_SIZE_CHECK = 4

CV_NULLPTR_ERR = pyopencv.cxtypes_h_ext.CvStatus.CV_NULLPTR_ERR

CV_OK = pyopencv.cxtypes_h_ext.CvStatus.CV_OK

CV_ORIENTED_GRAPH = 5632

CV_OUTOFMEM_ERR = pyopencv.cxtypes_h_ext.CvStatus.CV_OUTOFMEM_ERR

CV_PCA_DATA_AS_COL = 1

CV_PCA_DATA_AS_ROW = 0

CV_PCA_USE_AVG = 2

CV_PI = 3.14159265359

CV_POLY_APPROX_DP = 0

CV_PORTION = 1

CV_PREV_AROUND_DST = pyopencv.cv_h_ext.CvNextEdgeType.CV_PREV_...

CV_PREV_AROUND_LEFT = pyopencv.cv_h_ext.CvNextEdgeType.CV_PREV...

CV_PREV_AROUND_ORG = pyopencv.cv_h_ext.CvNextEdgeType.CV_PREV_...

CV_PREV_AROUND_RIGHT = pyopencv.cv_h_ext.CvNextEdgeType.CV_PRE...

CV_PTLOC_ERROR = pyopencv.cv_h_ext.CvSubdiv2DPointLocation.CV_...

CV_PTLOC_INSIDE = pyopencv.cv_h_ext.CvSubdiv2DPointLocation.CV...

CV_PTLOC_ON_EDGE = pyopencv.cv_h_ext.CvSubdiv2DPointLocation.C...

CV_PTLOC_OUTSIDE_RECT = pyopencv.cv_h_ext.CvSubdiv2DPointLocat...

CV_PTLOC_VERTEX = pyopencv.cv_h_ext.CvSubdiv2DPointLocation.CV...

CV_RAND_NORMAL = 1

CV_RAND_UNI = 0

CV_REDUCE_AVG = 1

CV_REDUCE_MAX = 2

CV_REDUCE_MIN = 3

CV_REDUCE_SUM = 0

CV_RGB2BGR = 4

CV_RGB2BGR555 = 23

CV_RGB2BGR565 = 13

CV_RGB2BGRA = 2

CV_RGB2GRAY = 7

CV_RGB2HLS = 53

CV_RGB2HSV = 41

CV_RGB2Lab = 45

CV_RGB2Luv = 51

CV_RGB2RGBA = 0

CV_RGB2XYZ = 33

CV_RGB2YCrCb = 37

CV_RGBA2BGR = 3

CV_RGBA2BGR555 = 27

CV_RGBA2BGR565 = 17

CV_RGBA2BGRA = 5

CV_RGBA2GRAY = 11

CV_RGBA2RGB = 1

CV_ROW_SAMPLE = 1

CV_SCHARR = -1

CV_SEQ_CHAIN = 512

CV_SEQ_CHAIN_CONTOUR = 4608

CV_SEQ_CONNECTED_COMP = 0

CV_SEQ_CONTOUR = 4620

CV_SEQ_ELTYPE_BITS = 9

CV_SEQ_ELTYPE_CODE = 0

CV_SEQ_ELTYPE_CONNECTED_COMP = 0

CV_SEQ_ELTYPE_GENERIC = 0

CV_SEQ_ELTYPE_GRAPH_EDGE = 0

CV_SEQ_ELTYPE_GRAPH_VERTEX = 0

CV_SEQ_ELTYPE_INDEX = 4

CV_SEQ_ELTYPE_MASK = 511

CV_SEQ_ELTYPE_POINT = 12

CV_SEQ_ELTYPE_POINT3D = 21

CV_SEQ_ELTYPE_PPOINT = 7

CV_SEQ_ELTYPE_PTR = 7

CV_SEQ_ELTYPE_TRIAN_ATR = 0

CV_SEQ_FLAG_CLOSED = 4096

CV_SEQ_FLAG_CONVEX = 16384

CV_SEQ_FLAG_HOLE = 32768

CV_SEQ_FLAG_SHIFT = 12

CV_SEQ_FLAG_SIMPLE = 8192

CV_SEQ_INDEX = 4

CV_SEQ_KIND_BIN_TREE = 1024

CV_SEQ_KIND_BITS = 3

CV_SEQ_KIND_CURVE = 512

CV_SEQ_KIND_GENERIC = 0

CV_SEQ_KIND_GRAPH = 1536

CV_SEQ_KIND_MASK = 3584

CV_SEQ_KIND_SUBDIV2D = 2048

CV_SEQ_MAGIC_VAL = 1117323264

CV_SEQ_POINT3D_SET = 21

CV_SEQ_POINT_SET = 12

CV_SEQ_POLYGON = 4620

CV_SEQ_POLYGON_TREE = 1024

CV_SEQ_POLYLINE = 524

CV_SEQ_SIMPLE_POLYGON = 12812

CV_SET_ELEM_FREE_FLAG = 2147483648

CV_SET_ELEM_IDX_MASK = 67108863

CV_SET_MAGIC_VAL = 1117257728

CV_SHAPE_CROSS = 1

CV_SHAPE_CUSTOM = 100

CV_SHAPE_ELLIPSE = 2

CV_SHAPE_RECT = 0

CV_SPARSE_MAT_MAGIC_VAL = 1111752704

CV_STORAGE_APPEND = 2

CV_STORAGE_MAGIC_VAL = 1116274688

CV_STORAGE_READ = 0

CV_STORAGE_WRITE = 1

CV_STORAGE_WRITE_BINARY = 1

CV_STORAGE_WRITE_TEXT = 1

CV_SUBMINOR_VERSION = 0

CV_StsAssert = -215

CV_StsAutoTrace = -8

CV_StsBackTrace = -1

CV_StsBadArg = -5

CV_StsBadFlag = -206

CV_StsBadFunc = -6

CV_StsBadMask = -208

CV_StsBadMemBlock = -214

CV_StsBadPoint = -207

CV_StsBadSize = -201

CV_StsDivByZero = -202

CV_StsError = -2

CV_StsFilterOffsetErr = -31

CV_StsFilterStructContentErr = -29

CV_StsInplaceNotSupported = -203

CV_StsInternal = -3

CV_StsKernelStructContentErr = -30

CV_StsNoConv = -7

CV_StsNoMem = -4

CV_StsNotImplemented = -213

CV_StsNullPtr = -27

CV_StsObjectNotFound = -204

CV_StsOk = 0

CV_StsOutOfRange = -211

CV_StsParseError = -212

CV_StsUnmatchedFormats = -205

CV_StsUnmatchedSizes = -209

CV_StsUnsupportedFormat = -210

CV_StsVecLengthErr = -28

CV_TEST_ERROR = 1

CV_TM_CCOEFF = 4

CV_TM_CCOEFF_NORMED = 5

CV_TM_CCORR = 2

CV_TM_CCORR_NORMED = 3

CV_TM_SQDIFF = 0

CV_TM_SQDIFF_NORMED = 1

CV_TRAIN_ERROR = 0

CV_TS_CONCENTRIC_SPHERES = 0

CV_TYPE_NAME_GRAPH = 'opencv-graph'

CV_TYPE_NAME_HAAR = 'opencv-haar-classifier'

CV_TYPE_NAME_MAT = 'opencv-matrix'

CV_TYPE_NAME_MATND = 'opencv-nd-matrix'

CV_TYPE_NAME_ML_ANN_MLP = 'opencv-ml-ann-mlp'

CV_TYPE_NAME_ML_BOOSTING = 'opencv-ml-boost-tree'

CV_TYPE_NAME_ML_CNN = 'opencv-ml-cnn'

CV_TYPE_NAME_ML_EM = 'opencv-ml-em'

CV_TYPE_NAME_ML_KNN = 'opencv-ml-knn'

CV_TYPE_NAME_ML_NBAYES = 'opencv-ml-bayesian'

CV_TYPE_NAME_ML_RTREES = 'opencv-ml-random-trees'

CV_TYPE_NAME_ML_SVM = 'opencv-ml-svm'

CV_TYPE_NAME_ML_TREE = 'opencv-ml-tree'

CV_TYPE_NAME_SEQ = 'opencv-sequence'

CV_TYPE_NAME_SEQ_TREE = 'opencv-sequence-tree'

CV_TYPE_NAME_SPARSE_MAT = 'opencv-sparse-matrix'

CV_TYZX_COLOR = 402

CV_TYZX_LEFT = 400

CV_TYZX_RIGHT = 401

CV_TYZX_Z = 403

CV_UNDEF_SC_PARAM = 12345

CV_UNMATCHED_FORMATS_ERR = pyopencv.cxtypes_h_ext.CvStatus.CV_...

CV_UNMATCHED_ROI_ERR = pyopencv.cxtypes_h_ext.CvStatus.CV_UNMA...

CV_UNSUPPORTED_CHANNELS_ERR = pyopencv.cxtypes_h_ext.CvStatus....

CV_UNSUPPORTED_COI_ERR = pyopencv.cxtypes_h_ext.CvStatus.CV_UN...

CV_UNSUPPORTED_DEPTH_ERR = pyopencv.cxtypes_h_ext.CvStatus.CV_...

CV_UNSUPPORTED_FORMAT_ERR = pyopencv.cxtypes_h_ext.CvStatus.CV...

CV_USRTYPE1 = 7

CV_VALUE = 1

CV_VAR_CATEGORICAL = 1

CV_VAR_NUMERICAL = 0

CV_VAR_ORDERED = 0

CV_VERSION = '2.1.0'

CV_WARP_FILL_OUTLIERS = 8

CV_WARP_INVERSE_MAP = 16

CV_WHOLE_ARR = Range(start=0, end=1073741823)

CV_WHOLE_SEQ = Range(start=0, end=1073741823)

CV_WHOLE_SEQ_END_INDEX = 1073741823

CV_WINDOW_AUTOSIZE = 1

CV_WINDOW_FULLSCREEN = 1

CV_WINDOW_NORMAL = 0

CV_WND_PROP_AUTOSIZE = 1

CV_WND_PROP_FULLSCREEN = 0

CV_XYZ2BGR = 34

CV_XYZ2RGB = 35

CV_YCrCb2BGR = 38

CV_YCrCb2RGB = 39

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.cxcore_h_ext.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.cxcore_h_ext.flann_algorithm_t.KDTREE

KERNEL_ASYMMETRICAL = 2

KERNEL_GENERAL = 0

KERNEL_INTEGER = 8

KERNEL_SMOOTH = 4

KERNEL_SYMMETRICAL = 1

KMEANS = pyopencv.cxcore_h_ext.flann_algorithm_t.KMEANS

KMEANS_PP_CENTERS = 2

KMEANS_RANDOM_CENTERS = 0

KMEANS_USE_INITIAL_LABELS = 1

LINEAR = pyopencv.cxcore_h_ext.flann_algorithm_t.LINEAR

LMEDS = 4

LOG_ERROR = pyopencv.cxcore_h_ext.flann_log_level_t.LOG_ERROR

LOG_FATAL = pyopencv.cxcore_h_ext.flann_log_level_t.LOG_FATAL

LOG_INFO = pyopencv.cxcore_h_ext.flann_log_level_t.LOG_INFO

LOG_NONE = pyopencv.cxcore_h_ext.flann_log_level_t.LOG_NONE

LOG_WARN = pyopencv.cxcore_h_ext.flann_log_level_t.LOG_WARN

MAGIC_MASK = -65536

MANHATTAN = pyopencv.cxcore_h_ext.flann_distance_t.MANHATTAN

MINKOWSKI = pyopencv.cxcore_h_ext.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

PROFILE_DOG = 1

PROFILE_EPANECHNIKOV = 0

PYOPENCV_VERSION = '2.1.0.wr1.1.1'

PYOPENCV_VERSION_MAJOR = '2.1.0.wr1'

PYOPENCV_VERSION_MINOR = '1'

PYOPENCV_VERSION_PATCH = '1'

RANSAC = 8

RETR_CCOMP = 2

RETR_EXTERNAL = 0

RETR_LIST = 1

RETR_TREE = 3

SAVED = pyopencv.cxcore_h_ext.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

__loader__ = <zipimporter object "M:\programming\builders\Pyth...

__package__ = 'pyopencv'

asComplexd = <functools.partial object at 0x0225CC60>

asComplexf = <functools.partial object at 0x0225CD20>

asCvMat = <functools.partial object at 0x02262210>

asCvPoint = <functools.partial object at 0x02262240>

asCvPoint2D32f = <functools.partial object at 0x0225CF90>

asCvPoint3D32f = <functools.partial object at 0x0225CF60>

asMatND = <functools.partial object at 0x022624B0>

asPoint = <functools.partial object at 0x0225C4E0>

asPoint2d = <functools.partial object at 0x0225C600>

asPoint2f = <functools.partial object at 0x0225C390>

asPoint2i = <functools.partial object at 0x0225C4E0>

asPoint3d = <functools.partial object at 0x0225C2D0>

asPoint3f = <functools.partial object at 0x0225C300>

asPoint3i = <functools.partial object at 0x0225C240>

asRange = <functools.partial object at 0x0225CC90>

asRect = <functools.partial object at 0x0225C3F0>

asRotatedRect = <functools.partial object at 0x0225CFC0>

asScalar = <functools.partial object at 0x0225C690>

asSize2f = <functools.partial object at 0x022622D0>

asSize2i = <functools.partial object at 0x022622A0>

asStepFunc = <functools.partial object at 0x0225CB70>

asVec2b = <functools.partial object at 0x0225CA20>

asVec2d = <functools.partial object at 0x0225C990>

asVec2f = <functools.partial object at 0x0225C9C0>

asVec2i = <functools.partial object at 0x0225CAB0>

asVec2s = <functools.partial object at 0x0225C8A0>

asVec2w = <functools.partial object at 0x0225C870>

asVec3b = <functools.partial object at 0x022620F0>

asVec3d = <functools.partial object at 0x022620C0>

asVec3f = <functools.partial object at 0x02262090>

asVec3i = <functools.partial object at 0x02262150>

asVec3s = <functools.partial object at 0x02262060>

asVec3w = <functools.partial object at 0x02262030>

asVec4b = <functools.partial object at 0x0225C150>

asVec4d = <functools.partial object at 0x0225C120>

asVec4f = <functools.partial object at 0x0225C0F0>

asVec4i = <functools.partial object at 0x0225C1E0>

asVec4s = <functools.partial object at 0x0225C2A0>

asVec4w = <functools.partial object at 0x0225C210>

asVec6d = <functools.partial object at 0x02262360>

asVec6f = <functools.partial object at 0x02262390>

asndarray = <functools.partial object at 0x022623F0>

asvector_CvConnectedComp = <functools.partial object at 0x0225...

asvector_CvSURFPoint = <functools.partial object at 0x02262420>

asvector_Point2d = <functools.partial object at 0x022621B0>

asvector_Point2f = <functools.partial object at 0x02262180>

asvector_Point2i = <functools.partial object at 0x022621E0>

asvector_Point3d = <functools.partial object at 0x0225C510>

asvector_Point3f = <functools.partial object at 0x0225C1B0>

asvector_Point3i = <functools.partial object at 0x0225C570>

asvector_Range = <functools.partial object at 0x0225C840>

asvector_Rect = <functools.partial object at 0x0225CD80>

asvector_RotatedRect = <functools.partial object at 0x0225CE70>

asvector_Scalar = <functools.partial object at 0x0225CA50>

asvector_Vec2b = <functools.partial object at 0x0225CE40>

asvector_Vec2d = <functools.partial object at 0x0225CDE0>

asvector_Vec2f = <functools.partial object at 0x0225CE10>

asvector_Vec2i = <functools.partial object at 0x0225CDB0>

asvector_Vec2s = <functools.partial object at 0x0225CD50>

asvector_Vec2w = <functools.partial object at 0x0225CCF0>

asvector_Vec3b = <functools.partial object at 0x0225CAE0>

asvector_Vec3d = <functools.partial object at 0x0225CA80>

asvector_Vec3f = <functools.partial object at 0x0225C540>

asvector_Vec3i = <functools.partial object at 0x0225C9F0>

asvector_Vec3s = <functools.partial object at 0x0225C930>

asvector_Vec3w = <functools.partial object at 0x0225C8D0>

asvector_Vec4b = <functools.partial object at 0x0225C4B0>

asvector_Vec4d = <functools.partial object at 0x0225C480>

asvector_Vec4f = <functools.partial object at 0x0225C450>

asvector_Vec4i = <functools.partial object at 0x0225C420>

asvector_Vec4s = <functools.partial object at 0x0225C5D0>

asvector_Vec4w = <functools.partial object at 0x0225C5A0>

asvector_Vec6d = <functools.partial object at 0x02262480>

asvector_Vec6f = <functools.partial object at 0x022624E0>

asvector_float32 = <functools.partial object at 0x02262510>

asvector_float64 = <functools.partial object at 0x0225C960>

asvector_int = <functools.partial object at 0x022623C0>

asvector_int16 = <functools.partial object at 0x0225C180>

asvector_int64 = <functools.partial object at 0x0225C3C0>

asvector_int8 = <functools.partial object at 0x0225C270>

asvector_long = <functools.partial object at 0x0225CCC0>

asvector_uint = <functools.partial object at 0x0225CF30>

asvector_uint16 = <functools.partial object at 0x02262120>

asvector_uint64 = <functools.partial object at 0x0225C900>

asvector_uint8 = <functools.partial object at 0x0225CED0>

asvector_ulong = <functools.partial object at 0x0225CF00>

asvector_vector_Point2d = <functools.partial object at 0x0225C...

asvector_vector_Point2f = <functools.partial object at 0x0225C...

asvector_vector_Point2i = <functools.partial object at 0x0225C...

asvector_vector_Point3d = <functools.partial object at 0x0225C...

asvector_vector_Point3f = <functools.partial object at 0x0225C...

asvector_vector_Point3i = <functools.partial object at 0x0225C...

asvector_vector_Vec2i = <functools.partial object at 0x0225C330>

asvector_vector_float32 = <functools.partial object at 0x02262...

asvector_vector_int = <functools.partial object at 0x0225C7E0>

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++ type: ::std::vector< cv::KeyPoint > &
        Python type: vector_KeyPoint
        Output argument: omitted from input and returned as output.
    Returns:
        keypoints

    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++ type: ::std::vector< cv::Vec<float, 3> > &
        Python type: vector_Vec3f
        Output argument: omitted from input and returned as output.
    Returns:
        circles

    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++ type: ::std::vector< cv::Vec<float, 2> > &
        Python type: vector_Vec2f
        Output argument: omitted from input and returned as output.
    Returns:
        lines

    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++ type: ::std::vector< cv::Vec<int, 4> > &
        Python type: vector_Vec4i
        Output argument: omitted from input and returned as output.
    Returns:
        lines

    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 'data':
        C++ type: ::CvMat const *.
        Python type: Mat.
    Argument 'indices':
        C++ type: ::CvMat *.
        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 'query_points':
        C++ type: ::CvMat const *.
        Python type: Mat.
    Argument 'indices':
        C++ type: ::CvMat *.
        Python type: Mat.
    Argument 'dist':
        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++ 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++ 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]]]])

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++ type: ::CvArr const *.
        Python type: Mat.
    Argument 'sum':
        C++ type: ::CvArr *.
        Python type: Mat.
    Argument 'mask':
        C++ type: ::CvArr const *.
        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(76, 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(76, 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++ 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++ type: ::std::vector< cv::Point_<float> > &
        Python type: vector_Point2f
        Output argument: omitted from input and returned as output.
    Returns:
        approxCurve

    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++ type: ::std::vector< cv::Point_<int> > &
        Python type: vector_Point2i
        Output argument: omitted from input and returned as output.
    Returns:
        approxCurve

    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)

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

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

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

bitwise_xor( (MatND)a, (MatND)b, (MatND)c [, (MatND)mask=MatND(shape=(), nchannels=1, depth=0):
array(120, 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(120, 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++ 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, (vector_Point2f)prev_features, (Size2i)win_size, (object)level, (TermCriteria)criteria, (object)flags) -> tuple :
    
    Wrapped function:
        cvCalcAffineFlowPyrLK
    Argument 'prev':
        C++ type: ::CvArr const *.
        Python type: Mat.
    Argument 'curr':
        C++ type: ::CvArr const *.
        Python type: Mat.
    Argument 'prev_pyr':
        C++ type: ::CvArr *.
        Python type: Mat.
    Argument 'curr_pyr':
        C++ type: ::CvArr *.
        Python type: Mat.
    Argument 'prev_features':
        C++ type: ::CvPoint2D32f const *.
        Python type: vector_Point2f.
    Argument 'curr_features':
        C++ type: ::CvPoint2D32f *.
        Python type: vector_Point2f.
        Output argument: omitted from input and returned as output.
    Argument 'matrices':
        C++ type: float *.
        Python type: vector_float32.
        Output argument: omitted from input and returned as output.
    Argument 'count':
        Dependent argument: omitted from input. Its value is derived from 
        argument 'prev_features'.
    Argument 'win_size':
        C++ type: ::CvSize.
        Python type: Size2i.
    Argument 'status':
        C++ type: char *.
        Python type: vector_int8.
        Output argument: omitted from input and returned as output.
    Argument 'track_error':
        C++ type: float *.
        Python type: vector_float32.
        Output argument: omitted from input and returned as output.
    Argument 'criteria':
        C++ type: ::CvTermCriteria.
        Python type: TermCriteria.
    Returns:
        (curr_features, matrices, status, track_error)

    C++ signature :
        boost::python::tuple calcAffineFlowPyrLK(cv::Mat {lvalue},cv::Mat {lvalue},cv::Mat {lvalue},cv::Mat {lvalue},std::vector<cv::Point_<float>, std::allocator<cv::Point_<float> > >,cv::Size_<int>,int,cv::TermCriteria,int)

calcBackProject(...)


calcBackProject( (vector_Mat)images, (vector_int)channels, (SparseMat)hist, (Mat)backProject, (vector_vector_float32)ranges [, (object)scale=1 [, (bool)uniform=True]]) -> None :
    
    Argument 'images':
        C++ type: ::cv::Mat const *
        Python type: vector_Mat
    Argument 'nimages':
        Dependent argument: omitted from input. Its value is derived from 
        argument 'images'.
    Argument 'channels':
        C++ type: int const *
        Python type: vector_int
    Argument 'ranges':
        C++ type: float const * *
        Python type: vector_vector_float32

    C++ signature :
        void calcBackProject(std::vector<cv::Mat, std::allocator<cv::Mat> >,std::vector<int, std::allocator<int> >,cv::SparseMat,cv::Mat {lvalue},std::vector<std::vector<float, std::allocator<float> >, std::allocator<std::vector<float, std::allocator<float> > > > [,double=1 [,bool=True]])

calcBackProject( (vector_Mat)images, (vector_int)channels, (MatND)hist, (Mat)backProject, (vector_vector_float32)ranges [, (object)scale=1 [, (bool)uniform=True]]) -> None :
    
    Argument 'images':
        C++ type: ::cv::Mat const *
        Python type: vector_Mat
    Argument 'nimages':
        Dependent argument: omitted from input. Its value is derived from 
        argument 'images'.
    Argument 'channels':
        C++ type: int const *
        Python type: vector_int
    Argument 'ranges':
        C++ type: float const * *
        Python type: vector_vector_float32

    C++ signature :
        void calcBackProject(std::vector<cv::Mat, std::allocator<cv::Mat> >,std::vector<int, std::allocator<int> >,cv::MatND,cv::Mat {lvalue},std::vector<std::vector<float, std::allocator<float> >, std::allocator<std::vector<float, std::allocator<float> > > > [,double=1 [,bool=True]])

calcCovarMatrix(...)


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

calcCovarMatrix( (Mat)samples, (object)nsamples, (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 const*,int,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++ type: ::CvArr const *.
        Python type: Mat.
    Argument 'signature2':
        C++ type: ::CvArr const *.
        Python type: Mat.
    Argument 'cost_matrix':
        C++ type: ::CvArr const *.
        Python type: Mat.
    Argument 'flow':
        C++ type: ::CvArr *.
        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) -> float :

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

calcHist(...)


calcHist( (vector_Mat)images, (vector_int)channels, (Mat)mask, (SparseMat)hist, (vector_int)histSize, (vector_vector_float32)ranges [, (bool)uniform=True [, (bool)accumulate=False]]) -> None :
    
    Argument 'images':
        C++ type: ::cv::Mat const *
        Python type: vector_Mat
    Argument 'nimages':
        Dependent argument: omitted from input. Its value is derived from 
        argument 'images'.
    Argument 'channels':
        C++ type: int const *
        Python type: vector_int
    Argument 'dims':
        Dependent argument: omitted from input. Its value is derived from 
        argument 'histSize'.
    Argument 'histSize':
        C++ type: int const *
        Python type: vector_int
    Argument 'ranges':
        C++ type: float const * *
        Python type: vector_vector_float32

    C++ signature :
        void calcHist(std::vector<cv::Mat, std::allocator<cv::Mat> >,std::vector<int, std::allocator<int> >,cv::Mat,cv::SparseMat {lvalue},std::vector<int, std::allocator<int> >,std::vector<std::vector<float, std::allocator<float> >, std::allocator<std::vector<float, std::allocator<float> > > > [,bool=True [,bool=False]])

calcHist( (vector_Mat)images, (vector_int)channels, (Mat)mask, (MatND)hist, (vector_int)histSize, (vector_vector_float32)ranges [, (bool)uniform=True [, (bool)accumulate=False]]) -> None :
    
    Argument 'images':
        C++ type: ::cv::Mat const *
        Python type: vector_Mat
    Argument 'nimages':
        Dependent argument: omitted from input. Its value is derived from 
        argument 'images'.
    Argument 'channels':
        C++ type: int const *
        Python type: vector_int
    Argument 'dims':
        Dependent argument: omitted from input. Its value is derived from 
        argument 'histSize'.
    Argument 'histSize':
        C++ type: int const *
        Python type: vector_int
    Argument 'ranges':
        C++ type: float const * *
        Python type: vector_vector_float32

    C++ signature :
        void calcHist(std::vector<cv::Mat, std::allocator<cv::Mat> >,std::vector<int, std::allocator<int> >,cv::Mat,cv::MatND {lvalue},std::vector<int, std::allocator<int> >,std::vector<std::vector<float, std::allocator<float> >, std::allocator<std::vector<float, std::allocator<float> > > > [,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)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 'prev':
        C++ type: ::CvArr const *.
        Python type: Mat.
    Argument 'curr':
        C++ type: ::CvArr const *.
        Python type: Mat.
    Argument 'block_size':
        C++ type: ::CvSize.
        Python type: Size2i.
    Argument 'shift_size':
        C++ type: ::CvSize.
        Python type: Size2i.
    Argument 'max_range':
        C++ type: ::CvSize.
        Python type: Size2i.
    Argument 'velx':
        C++ type: ::CvArr *.
        Python type: Mat.
    Argument 'vely':
        C++ type: ::CvArr *.
        Python type: Mat.

    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)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 'prev':
        C++ type: ::CvArr const *.
        Python type: Mat.
    Argument 'curr':
        C++ type: ::CvArr const *.
        Python type: Mat.
    Argument 'velx':
        C++ type: ::CvArr *.
        Python type: Mat.
    Argument 'vely':
        C++ type: ::CvArr *.
        Python type: Mat.
    Argument 'criteria':
        C++ type: ::CvTermCriteria.
        Python type: TermCriteria.

    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++ type: ::CvArr const *.
        Python type: Mat.
    Argument 'curr':
        C++ type: ::CvArr const *.
        Python type: Mat.
    Argument 'win_size':
        C++ type: ::CvSize.
        Python type: Size2i.
    Argument 'velx':
        C++ type: ::CvArr *.
        Python type: Mat.
    Argument 'vely':
        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, (vector_Point2f)prevPts, (vector_Point2f)nextPts, (vector_uint8)status, (vector_float32)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 :

    C++ signature :
        void calcOpticalFlowPyrLK(cv::Mat,cv::Mat,std::vector<cv::Point_<float>, std::allocator<cv::Point_<float> > >,std::vector<cv::Point_<float>, std::allocator<cv::Point_<float> > > {lvalue},std::vector<unsigned char, std::allocator<unsigned char> > {lvalue},std::vector<float, std::allocator<float> > {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]]]]])

calcSubdivVoronoi2D(...)


calcSubdivVoronoi2D( (CvSubdiv2D)subdiv) -> None :
    
    Wrapped function:
        cvCalcSubdivVoronoi2D

    C++ signature :
        void calcSubdivVoronoi2D(CvSubdiv2D*)

calibrateCamera(...)


calibrateCamera( (vector_vector_Point3f)objectPoints, (vector_vector_Point2f)imagePoints, (Size2i)imageSize, (Mat)cameraMatrix, (Mat)distCoeffs [, (object)flags=0]) -> tuple :
    
    Argument 'rvecs':
        C++ type: ::std::vector< cv::Mat > &
        Python type: vector_Mat
        Output argument: omitted from input and returned as output.
    Argument 'tvecs':
        C++ type: ::std::vector< cv::Mat > &
        Python type: vector_Mat
        Output argument: omitted from input and returned as output.
    Returns:
        ((float64), rvecs, tvecs)

    C++ signature :
        boost::python::tuple calibrateCamera(std::vector<std::vector<cv::Point3_<float>, std::allocator<cv::Point3_<float> > >, std::allocator<std::vector<cv::Point3_<float>, std::allocator<cv::Point3_<float> > > > >,std::vector<std::vector<cv::Point_<float>, std::allocator<cv::Point_<float> > >, std::allocator<std::vector<cv::Point_<float>, std::allocator<cv::Point_<float> > > > >,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++ type: ::IplImage *.
        Python type: Mat.
    Argument 'size':
        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++ type: int *
        Python type: int
        Output argument: omitted from input and returned as output.
    Returns:
        ((bool), idx)

    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++ type: ::cv::Point *
        Python type: Point2i
        Output argument: omitted from input and returned as output.
    Returns:
        ((bool), pt)

    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++ 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.cxtypes_h_ext.MemStorage object at 0x02040B70>]) -> object :
    
    Wrapped function:
        cvCloneSeq
    Argument 'storage':
        C++ type: ::CvMemStorage *
        Python type: MemStorage

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

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++ type: ::std::vector< cv::Vec<float, 3> > &
        Python type: vector_Vec3f
        Output argument: omitted from input and returned as output.
    Returns:
        lines

    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++ type: ::CvMat *
        Python type: Mat
    Argument 'upper_bound':
        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++ type: ::CvMemStorage *.
        Python type: MemStorage.
    Argument 'criteria':
        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++ type: ::CvArr const *
        Python type: Mat
    Argument 'dst':
        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++ type: ::std::vector< cv::Point_<float> > &
        Python type: vector_Point2f
        Output argument: omitted from input and returned as output.
    Returns:
        dst

    C++ signature :
        boost::python::api::object convertPointsHomogeneous2D(cv::Mat)

convertPointsHomogeneous3D(...)


convertPointsHomogeneous3D( (Mat)src) -> object :
    
    Wrapped function:
        convertPointsHomogeneous
    Argument 'dst':
        C++ type: ::std::vector< cv::Point3_<float> > &
        Python type: vector_Point3f
        Output argument: omitted from input and returned as output.
    Returns:
        dst

    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++ type: ::std::vector< int > &
        Python type: vector_int
        Output argument: omitted from input and returned as output.
    Returns:
        hull

    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++ type: ::std::vector< cv::Point_<float> > &
        Python type: vector_Point2f
        Output argument: omitted from input and returned as output.
    Returns:
        hull

    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++ type: ::std::vector< cv::Point_<int> > &
        Python type: vector_Point2i
        Output argument: omitted from input and returned as output.
    Returns:
        hull

    C++ signature :
        boost::python::api::object convexHull_int(cv::Mat [,bool=False])

convexityDefects(...)


convexityDefects( (Mat)contour, (Mat)convexhull [, (MemStorage)storage=<pyopencv.cxtypes_h_ext.MemStorage object at 0x0214AA70>]) -> object :
    
    Wrapped function:
        cvConvexityDefects
    Argument 'contour':
        C++ type: ::CvArr const *.
        Python type: Mat.
    Argument 'convexhull':
        C++ type: ::CvArr const *.
        Python type: Mat.
    Argument 'storage':
        C++ type: ::CvMemStorage *.
        Python type: MemStorage.

    C++ signature :
        boost::python::api::object convexityDefects(cv::Mat {lvalue},cv::Mat {lvalue} [,cv::Ptr<CvMemStorage>=<pyopencv.cxtypes_h_ext.MemStorage object at 0x0214AA70>])

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, (vector_Point2f)corners, (Size2i)winSize, (Size2i)zeroZone, (TermCriteria)criteria) -> None :

    C++ signature :
        void cornerSubPix(cv::Mat,std::vector<cv::Point_<float>, std::allocator<cv::Point_<float> > > {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 'F':
        C++ type: ::CvMat *.
        Python type: Mat.
    Argument 'points1':
        C++ type: ::CvMat *.
        Python type: Mat.
    Argument 'points2':
        C++ type: ::CvMat *.
        Python type: Mat.
    Argument 'new_points1':
        C++ type: ::CvMat *.
        Python type: Mat.
    Argument 'new_points2':
        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)

createBlobDetectorCC()

    Wrapped function:
        cvCreateBlobDetectorCC

    C++ signature :
        CvBlobDetector* createBlobDetectorCC()

Returns: CvBlobDetector :

createBlobDetectorSimple()

    Wrapped function:
        cvCreateBlobDetectorSimple

    C++ signature :
        CvBlobDetector* createBlobDetectorSimple()

Returns: CvBlobDetector :

createBlobTrackerCC()

    Wrapped function:
        cvCreateBlobTrackerCC

    C++ signature :
        CvBlobTracker* createBlobTrackerCC()

Returns: CvBlobTracker :

createBlobTrackerCCMSPF()

    Wrapped function:
        cvCreateBlobTrackerCCMSPF

    C++ signature :
        CvBlobTracker* createBlobTrackerCCMSPF()

Returns: CvBlobTracker :

createBlobTrackerMS()

    Wrapped function:
        cvCreateBlobTrackerMS

    C++ signature :
        CvBlobTracker* createBlobTrackerMS()

Returns: CvBlobTracker :

createBlobTrackerMSFG()

    Wrapped function:
        cvCreateBlobTrackerMSFG

    C++ signature :
        CvBlobTracker* createBlobTrackerMSFG()

Returns: CvBlobTracker :

createBlobTrackerMSFGS()

    Wrapped function:
        cvCreateBlobTrackerMSFGS

    C++ signature :
        CvBlobTracker* createBlobTrackerMSFGS()

Returns: CvBlobTracker :

createBlobTrackerMSPF()

    Wrapped function:
        cvCreateBlobTrackerMSPF

    C++ signature :
        CvBlobTracker* createBlobTrackerMSPF()

Returns: CvBlobTracker :

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)arg1) -> 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++ 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++ 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)arg1) -> MemStorage :

    C++ signature :
        cv::Ptr<CvMemStorage> createMemStorage(int)

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

createModuleBlobTrackAnalysisHistP()

    Wrapped function:
        cvCreateModuleBlobTrackAnalysisHistP

    C++ signature :
        CvBlobTrackAnalysis* createModuleBlobTrackAnalysisHistP()

Returns: CvBlobTrackAnalysis :

createModuleBlobTrackAnalysisHistPV()

    Wrapped function:
        cvCreateModuleBlobTrackAnalysisHistPV

    C++ signature :
        CvBlobTrackAnalysis* createModuleBlobTrackAnalysisHistPV()

Returns: CvBlobTrackAnalysis :

createModuleBlobTrackAnalysisHistPVS()

    Wrapped function:
        cvCreateModuleBlobTrackAnalysisHistPVS

    C++ signature :
        CvBlobTrackAnalysis* createModuleBlobTrackAnalysisHistPVS()

Returns: CvBlobTrackAnalysis :

createModuleBlobTrackAnalysisHistSS()

    Wrapped function:
        cvCreateModuleBlobTrackAnalysisHistSS

    C++ signature :
        CvBlobTrackAnalysis* createModuleBlobTrackAnalysisHistSS()

Returns: CvBlobTrackAnalysis :

createModuleBlobTrackAnalysisIOR()

    Wrapped function:
        cvCreateModuleBlobTrackAnalysisIOR

    C++ signature :
        CvBlobTrackAnalysis* createModuleBlobTrackAnalysisIOR()

Returns: CvBlobTrackAnalysis :

createModuleBlobTrackAnalysisTrackDist()

    Wrapped function:
        cvCreateModuleBlobTrackAnalysisTrackDist

    C++ signature :
        CvBlobTrackAnalysis* createModuleBlobTrackAnalysisTrackDist()

Returns: CvBlobTrackAnalysis :

createModuleBlobTrackGen1()

    Wrapped function:
        cvCreateModuleBlobTrackGen1

    C++ signature :
        CvBlobTrackGen* createModuleBlobTrackGen1()

Returns: CvBlobTrackGen :

createModuleBlobTrackGenYML()

    Wrapped function:
        cvCreateModuleBlobTrackGenYML

    C++ signature :
        CvBlobTrackGen* createModuleBlobTrackGenYML()

Returns: CvBlobTrackGen :

createModuleBlobTrackPostProcKalman()

    Wrapped function:
        cvCreateModuleBlobTrackPostProcKalman

    C++ signature :
        CvBlobTrackPostProc* createModuleBlobTrackPostProcKalman()

Returns: CvBlobTrackPostProc :

createModuleBlobTrackPostProcTimeAverExp()

    Wrapped function:
        cvCreateModuleBlobTrackPostProcTimeAverExp

    C++ signature :
        CvBlobTrackPostProc* createModuleBlobTrackPostProcTimeAverExp()

Returns: CvBlobTrackPostProc :

createModuleBlobTrackPostProcTimeAverRect()

    Wrapped function:
        cvCreateModuleBlobTrackPostProcTimeAverRect

    C++ signature :
        CvBlobTrackPostProc* createModuleBlobTrackPostProcTimeAverRect()

Returns: CvBlobTrackPostProc :

createModuleBlobTrackPredictKalman()

    Wrapped function:
        cvCreateModuleBlobTrackPredictKalman

    C++ signature :
        CvBlobTrackPredictor* createModuleBlobTrackPredictKalman()

Returns: CvBlobTrackPredictor :

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++ 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++ 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++ 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++ 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 'rect':
        C++ type: ::CvRect.
        Python type: Rect.
    Argument 'storage':
        C++ type: ::CvMemStorage *.
        Python type: MemStorage.

    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 [, (vector_float32)mask=vector_float32(len=0, []) [, (Mat)labels=Mat()]]]) -> None :
    
    Wrapped function:
        cvDistTransform
    Argument 'src':
        C++ type: ::CvArr const *.
        Python type: Mat.
    Argument 'dst':
        C++ type: ::CvArr *.
        Python type: Mat.
    Argument 'mask_size':
        Dependent argument: omitted from input. Its value is derived from 
        argument 'mask'.
    Argument 'mask':
        C++ type: float const *.
        Python type: vector_float32.
    Argument 'labels':
        C++ type: ::CvArr *.
        Python type: Mat.

    C++ signature :
        void distTransform(cv::Mat {lvalue},cv::Mat {lvalue} [,int=2 [,std::vector<float, std::allocator<float> >=vector_float32(len=0, []) [,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, (vector_vector_Point2i)contours, (object)contourIdx, (Scalar)color [, (object)thickness=1 [, (object)lineType=8 [, (vector_Vec4i)hierarchy=vector_Vec4i(len=0, []) [, (object)maxLevel=2147483647 [, (Point2i)offset=Point2i(x=0, y=0)]]]]]) -> None :

    C++ signature :
        void drawContours(cv::Mat {lvalue},std::vector<std::vector<cv::Point_<int>, std::allocator<cv::Point_<int> > >, std::allocator<std::vector<cv::Point_<int>, std::allocator<cv::Point_<int> > > > >,int,cv::Scalar_<double> [,int=1 [,int=8 [,std::vector<cv::Vec<int, 4>, std::allocator<cv::Vec<int, 4> > >=vector_Vec4i(len=0, []) [,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, (vector_Point2i)pts) -> None :
    
    Approximates an elliptic arc with a polyline.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/drawing_functions.html#cv-ellipse2poly

    C++ signature :
        void ellipse2Poly(cv::Point_<int>,cv::Size_<int>,int,int,int,int,std::vector<cv::Point_<int>, std::allocator<cv::Point_<int> > > {lvalue})

endWriteStruct(...)


endWriteStruct( (FileStorage)fs) -> None :
    
    Wrapped function:
        cvEndWriteStruct
    Argument 'fs':
        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, (vector_uint8)outliers [, (object)param1=3.0 [, (object)param2=0.98999999999999999]]) -> int :

    C++ signature :
        int estimateAffine3D(cv::Mat,cv::Mat,cv::Mat {lvalue},std::vector<unsigned char, std::allocator<unsigned char> > {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++ type: ::CvArr const *.
        Python type: Mat.
    Argument 'B':
        C++ type: ::CvArr const *.
        Python type: Mat.
    Argument 'M':
        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 'img':
        C++ type: ::CvArr const *.
        Python type: Mat.
    Argument 'mask':
        C++ type: ::CvArr const *.
        Python type: Mat.
    Argument 'keypoints':
        C++ type: ::CvSeq * *.
        Python type: Seq_CvSURFPoint.
    Argument 'descriptors':
        C++ type: ::CvSeq * *.
        Python type: vector_float32.
        Output argument: omitted from input and returned as output.
    Argument 'storage':
        Dependent argument: omitted from input. Its value is derived from 
        argument 'keypoints'.
    Returns:
        descriptors

    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, (vector_Point2i)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 'pts':
        C++ type: ::cv::Point const *
        Python type: vector_Point2i
    Argument 'npts':
        Dependent argument: omitted from input. Its value is derived from 
        argument 'pts'.

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

fillPoly(...)


fillPoly( (Mat)img, (vector_vector_Point2i)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 'pts':
        C++ type: ::cv::Point const * *
        Python type: vector_vector_Point2i
    Argument 'npts':
        Dependent argument: omitted from input. Its value is derived from 
        argument 'pts'.
    Argument 'ncontours':
        Dependent argument: omitted from input. Its value is derived from 
        argument 'pts'.

    C++ signature :
        void fillPoly(cv::Mat {lvalue},std::vector<std::vector<cv::Point_<int>, std::allocator<cv::Point_<int> > >, std::allocator<std::vector<cv::Point_<int>, std::allocator<cv::Point_<int> > > > >,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, (vector_Point2f)corners, (Size2i)region_size) -> bool :

    C++ signature :
        bool find4QuadCornerSubpix(cv::Mat,std::vector<cv::Point_<float>, std::allocator<cv::Point_<float> > > {lvalue},cv::Size_<int>)

findChessboardCorners(...)


findChessboardCorners( (Mat)image, (Size2i)patternSize [, (object)flags=3]) -> tuple :
    
    Argument 'corners':
        C++ type: ::std::vector< cv::Point_<float> > &
        Python type: vector_Point2f
        Output argument: omitted from input and returned as output.
    Returns:
        ((bool), corners)

    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++ type: ::std::vector< std::vector< cv::Point_<int> > > &
        Python type: vector_vector_Point2i
        Output argument: omitted from input and returned as output.
    Returns:
        contours

    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 'contours':
        C++ type: ::std::vector< std::vector< cv::Point_<int> > > &
        Python type: vector_vector_Point2i
        Output argument: omitted from input and returned as output.
    Argument 'hierarchy':
        C++ type: ::std::vector< cv::Vec<int, 4> > &
        Python type: vector_Vec4i
        Output argument: omitted from input and returned as output.
    Returns:
        (contours, hierarchy)

    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++ 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 'query_points':
        C++ type: ::CvMat const *.
        Python type: Mat.
    Argument 'indices':
        C++ type: ::CvMat *.
        Python type: Mat.
    Argument 'dist':
        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++ type: ::CvMat *.
        Python type: Mat.
    Argument 'bounds_max':
        C++ type: ::CvMat *.
        Python type: Mat.
    Argument 'out_indices':
        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++ type: ::std::vector< unsigned char > &
        Python type: vector_uint8
        Output argument: omitted from input and returned as output.
    Returns:
        ((Mat), mask)

    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++ type: ::std::vector< unsigned char > &
        Python type: vector_uint8
        Output argument: omitted from input and returned as output.
    Returns:
        ((Mat), mask)

    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++ 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 'leftImage':
        C++ type: ::CvArr const *
        Python type: Mat
    Argument 'rightImage':
        C++ type: ::CvArr const *
        Python type: Mat
    Argument 'dispImage':
        C++ type: ::CvArr *
        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 'left':
        C++ type: ::CvArr const *.
        Python type: Mat.
    Argument 'right':
        C++ type: ::CvArr const *.
        Python type: Mat.
    Argument 'disparityLeft':
        C++ type: ::CvArr *.
        Python type: Mat.
    Argument 'disparityRight':
        C++ type: ::CvArr *.
        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++ type: ::cv::Rect *
        Python type: Rect
        Output argument: omitted from input and returned as output.
    Returns:
        ((int), rect)

    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++ type: ::cv::Rect *
        Python type: Rect
        Output argument: omitted from input and returned as output.
    Returns:
        ((int), rect)

    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( (vector_Point2f)src, (vector_Point2f)dst) -> object :
    
    Argument 'src':
        C++ type: ::cv::Point2f const *
        Python type: vector_Point2f
    Argument 'dst':
        C++ type: ::cv::Point2f const *
        Python type: vector_Point2f

    C++ signature :
        boost::python::api::object getAffineTransform(std::vector<cv::Point_<float>, std::allocator<cv::Point_<float> > >,std::vector<cv::Point_<float>, std::allocator<cv::Point_<float> > >)

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++ 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++ 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()

    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++ type: ::cv::Rect *
        Python type: Rect
        Output argument: omitted from input and returned as output.
    Returns:
        ((Mat), validPixROI)

    C++ signature :
        boost::python::tuple getOptimalNewCameraMatrix(cv::Mat,cv::Mat,cv::Size_<int>,double [,cv::Size_<int>=Size2i(width=0, height=0)])

getPerspectiveTransform(...)


getPerspectiveTransform( (vector_Point2f)src, (vector_Point2f)dst) -> object :
    
    Argument 'src':
        C++ type: ::cv::Point2f const *
        Python type: vector_Point2f
    Argument 'dst':
        C++ type: ::cv::Point2f const *
        Python type: vector_Point2f

    C++ signature :
        boost::python::api::object getPerspectiveTransform(std::vector<cv::Point_<float>, std::allocator<cv::Point_<float> > >,std::vector<cv::Point_<float>, std::allocator<cv::Point_<float> > >)

getQuadrangleSubPix(...)


getQuadrangleSubPix( (Mat)src, (Mat)dst, (Mat)map_matrix) -> None :
    
    Wrapped function:
        cvGetQuadrangleSubPix
    Argument 'src':
        C++ type: ::CvArr const *.
        Python type: Mat.
    Argument 'dst':
        C++ type: ::CvArr *.
        Python type: Mat.
    Argument 'map_matrix':
        C++ type: ::CvMat const *.
        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++ type: int *
        Python type: int
        Output argument: omitted from input and returned as output.
    Returns:
        (((C++)cv::Size), baseLine)

    C++ signature :
        boost::python::tuple getTextSize(std::string,int,double,int)

getThreadNum()

    C++ signature :
        int getThreadNum()

Returns: int :

getTickCount()

    C++ signature :
        long long getTickCount()

Returns: long :

getTickFrequency()

    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++ type: ::std::vector< cv::Point_<float> > &
        Python type: vector_Point2f
        Output argument: omitted from input and returned as output.
    Returns:
        corners

    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( (vector_Rect)rectList, (vector_int)weights, (object)groupThreshold [, (object)eps=0.20000000000000001]) -> None :

    C++ signature :
        void groupRectangles(std::vector<cv::Rect_<int>, std::allocator<cv::Rect_<int> > > {lvalue},std::vector<int, std::allocator<int> > {lvalue},int [,double=0.20000000000000001])

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

    C++ signature :
        void groupRectangles(std::vector<cv::Rect_<int>, std::allocator<cv::Rect_<int> > > {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 [, (vector_int)params=vector_int(len=0, [])]) -> 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 'buf':
        C++ type: ::std::vector< unsigned char > &
        Python type: vector_uint8
        Output argument: omitted from input and returned as output.
    Returns:
        ((bool), buf)

    C++ signature :
        boost::python::tuple imencode(std::string,cv::Mat [,std::vector<int, std::allocator<int> >=vector_int(len=0, [])])

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 [, (vector_int)params=vector_int(len=0, [])]) -> bool :
    
    Saves an image to a specified file.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/reading_and_writing_images_and_video.html#cv-imwrite

    C++ signature :
        bool imwrite(std::string,cv::Mat [,std::vector<int, std::allocator<int> >=vector_int(len=0, [])])

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( (vector_vector_Point3f)objectPoints, (vector_vector_Point2f)imagePoints, (Size2i)imageSize [, (object)aspectRatio=1.0]) -> Mat :

    C++ signature :
        cv::Mat initCameraMatrix2D(std::vector<std::vector<cv::Point3_<float>, std::allocator<cv::Point3_<float> > >, std::allocator<std::vector<cv::Point3_<float>, std::allocator<cv::Point3_<float> > > > >,std::vector<std::vector<cv::Point_<float>, std::allocator<cv::Point_<float> > >, std::allocator<std::vector<cv::Point_<float>, std::allocator<cv::Point_<float> > > > >,cv::Size_<int> [,double=1.0])

initNArrayIterator(...)


initNArrayIterator( (vector_Mat)arrs, (Mat)mask, (object)stubs, (CvNArrayIterator)array_iterator [, (object)flags=0]) -> object :
    
    Wrapped function:
        cvInitNArrayIterator
    Argument 'count':
        Dependent argument: omitted from input. Its value is derived from 
        argument 'arrs'.
    Argument 'arrs':
        C++ type: ::CvArr * *
        Python type: (C++)std::vector<cv::Mat>
    Argument 'mask':
        C++ type: ::CvArr const *
        Python type: Mat

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

initSubdivDelaunay2D(...)


initSubdivDelaunay2D( (CvSubdiv2D)subdiv, (Rect)rect) -> None :
    
    Wrapped function:
        cvInitSubdivDelaunay2D
    Argument 'rect':
        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 input. Its value is derived from 
        argument 'argv'.
    Argument 'argv':
        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++ type: ::cv::Mat *
        Python type: Mat
        Output argument: omitted from input and returned as output.
    Returns:
        ((float64), centers)

    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++ type: ::CvArr const *.
        Python type: Mat.
    Argument 'dst':
        C++ type: ::CvArr *.
        Python type: Mat.
    Argument 'center':
        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++ type: ::CvArr const *.
        Python type: Mat.
    Argument 'dst':
        C++ type: ::CvArr *.
        Python type: Mat.
    Argument 'center':
        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(42, 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(42, 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++ 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) -> tuple :
    
    Argument 'center':
        C++ type: ::cv::Point2f &
        Python type: Point2f
        Output argument: omitted from input and returned as output.
    Argument 'radius':
        C++ type: float &
        Python type: float32
        Output argument: omitted from input and returned as output.
    Returns:
        (center, radius)

    C++ signature :
        boost::python::tuple minEnclosingCircle(cv::Mat)

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 'minVal':
        C++ type: double *
        Python type: float64
        Output argument: omitted from input and returned as output.
    Argument 'maxVal':
        C++ type: double *
        Python type: float64
        Output argument: omitted from input and returned as output.
    Argument 'minIdx':
        C++ type: int *
        Python type: int
        Output argument: omitted from input and returned as output.
    Argument 'maxIdx':
        C++ type: int *
        Python type: int
        Output argument: omitted from input and returned as output.
    Returns:
        (minVal, maxVal, minIdx, maxIdx)

    C++ signature :
        boost::python::tuple minMaxLoc(cv::SparseMat)

minMaxLoc( (MatND)a [, (MatND)mask=MatND(shape=(), nchannels=1, depth=0):
array(70, 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 'minVal':
        C++ type: double *
        Python type: float64
        Output argument: omitted from input and returned as output.
    Argument 'maxVal':
        C++ type: double *
        Python type: float64
        Output argument: omitted from input and returned as output.
    Argument 'minIdx':
        C++ type: int *
        Python type: int
        Output argument: omitted from input and returned as output.
    Argument 'maxIdx':
        C++ type: int *
        Python type: int
        Output argument: omitted from input and returned as output.
    Returns:
        (minVal, maxVal, minIdx, maxIdx)

    C++ signature :
        boost::python::tuple minMaxLoc(cv::MatND [,cv::MatND=MatND(shape=(), nchannels=1, depth=0):
array(70, 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 'minVal':
        C++ type: double *
        Python type: float64
        Output argument: omitted from input and returned as output.
    Argument 'maxVal':
        C++ type: double *
        Python type: float64
        Output argument: omitted from input and returned as output.
    Argument 'minLoc':
        C++ type: ::cv::Point *
        Python type: Point2i
        Output argument: omitted from input and returned as output.
    Argument 'maxLoc':
        C++ type: ::cv::Point *
        Python type: Point2i
        Output argument: omitted from input and returned as output.
    Returns:
        (minVal, maxVal, minLoc, maxLoc)

    C++ signature :
        boost::python::tuple minMaxLoc(cv::Mat [,cv::Mat=Mat()])

mixChannels(...)


mixChannels( (vector_MatND)src, (vector_MatND)dst, (vector_int)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++ type: int const *
        Python type: vector_int

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

mixChannels( (vector_Mat)src, (vector_Mat)dst, (vector_int)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++ type: int const *
        Python type: vector_int

    C++ signature :
        void mixChannels(std::vector<cv::Mat, std::allocator<cv::Mat> >,std::vector<cv::Mat, std::allocator<cv::Mat> > {lvalue},std::vector<int, std::allocator<int> >,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 'image1':
        C++ type: ::CvArr const *.
        Python type: Mat.
    Argument 'image2':
        C++ type: ::CvArr const *.
        Python type: Mat.
    Argument 'acc':
        C++ type: ::CvArr *.
        Python type: Mat.
    Argument 'mask':
        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(118, 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(118, dtype=uint8)]])

norm( (MatND)a [, (object)normType=4 [, (MatND)mask=MatND(shape=(), nchannels=1, depth=0):
array(118, 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(118, 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(122, 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(122, 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++ 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, (vector_vector_Point2i)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 'pts':
        C++ type: ::cv::Point const * *
        Python type: vector_vector_Point2i
    Argument 'npts':
        Dependent argument: omitted from input. Its value is derived from 
        argument 'pts'.
    Argument 'ncontours':
        Dependent argument: omitted from input. Its value is derived from 
        argument 'pts'.

    C++ signature :
        void polylines(cv::Mat {lvalue},std::vector<std::vector<cv::Point_<int>, std::allocator<cv::Point_<int> > >, std::allocator<std::vector<cv::Point_<int>, std::allocator<cv::Point_<int> > > > >,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++ type: ::std::vector< cv::Point_<float> > &
        Python type: vector_Point2f
        Output argument: omitted from input and returned as output.
    Returns:
        imagePoints

    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++ type: ::std::vector< cv::Point_<float> > &
        Python type: vector_Point2f
        Output argument: omitted from input and returned as output.
    Returns:
        imagePoints

    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++ type: ::CvArr const *.
        Python type: Mat.
    Argument 'dst':
        C++ type: ::CvArr *.
        Python type: Mat.
    Argument 'termcrit':
        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 'src':
        C++ type: ::IplImage *.
        Python type: Mat.
    Argument 'dst':
        C++ type: ::IplImage *.
        Python type: Mat.
    Argument 'storage':
        C++ type: ::CvMemStorage *.
        Python type: MemStorage.
    Argument 'comp':
        C++ type: ::CvSeq * *.
        Python type: (C++)CvSeq *.
        Output argument: omitted from input and returned as output.
    Returns:
        comp

    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 'rng':
        C++ type: ::CvRNG *
        Python type: RNG
    Argument 'arr':
        C++ type: ::CvArr *
        Python type: Mat
    Argument 'param1':
        C++ type: ::CvScalar
        Python type: Scalar
    Argument 'param2':
        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++ 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 input and returned as output.
    Returns:
        mat

    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(94, dtype=uint8)]) -> object :
    
    Wrapped function:
        read
    Argument 'mat':
        Output argument: omitted from input and returned as output.
    Returns:
        mat

    C++ signature :
        boost::python::api::object read_MatND(cv::FileNode [,cv::MatND=MatND(shape=(), nchannels=1, depth=0):
array(94, dtype=uint8)])

read_SparseMat(...)


read_SparseMat( (FileNode)node [, (SparseMat)default_mat=<pyopencv.cxcore_hpp_ext.SparseMat object at 0x0216E070>]) -> object :
    
    Wrapped function:
        read
    Argument 'mat':
        Output argument: omitted from input and returned as output.
    Returns:
        mat

    C++ signature :
        boost::python::api::object read_SparseMat(cv::FileNode [,cv::SparseMat=<pyopencv.cxcore_hpp_ext.SparseMat object at 0x0216E070>])

read_bool(...)


read_bool( (FileNode)node, (bool)default_value) -> object :
    
    Wrapped function:
        read
    Argument 'value':
        Output argument: omitted from input and returned as output.
    Returns:
        value

    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 input and returned as output.
    Returns:
        value

    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 input and returned as output.
    Returns:
        value

    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 input and returned as output.
    Returns:
        value

    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 input and returned as output.
    Returns:
        value

    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 input and returned as output.
    Returns:
        value

    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++ type: ::std::vector< cv::KeyPoint > &
        Python type: vector_KeyPoint
        Output argument: omitted from input and returned as output.
    Returns:
        keypoints

    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 input and returned as output.
    Returns:
        value

    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 input and returned as output.
    Returns:
        value

    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 input and returned as output.
    Returns:
        value

    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)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++ type: ::CvMemStorage *
        Python type: MemStorage

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

rotateHistToMode(...)


rotateHistToMode( (vector_int)in_hist, (vector_int)out_hist) -> None :

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

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 'image':
        C++ type: ::CvArr const *.
        Python type: Mat.
    Argument 'acc':
        C++ type: ::CvArr *.
        Python type: Mat.
    Argument 'mask':
        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, (Point2i)pt1, (Point2i)pt2, (object)buffer [, (object)connectivity=8]) -> object :
    
    Wrapped function:
        cvSampleLine
    Argument 'image':
        C++ type: ::CvArr const *.
        Python type: Mat.
    Argument 'pt1':
        C++ type: ::CvPoint.
        Python type: Point2i.
    Argument 'pt2':
        C++ type: ::CvPoint.
        Python type: Point2i.

    C++ signature :
        boost::python::api::object sampleLine(cv::Mat {lvalue},cv::Point_<int>,cv::Point_<int>,void* [,int=8])

saveMemStoragePos(...)


saveMemStoragePos( (MemStorage)storage, (CvMemStoragePos)pos) -> None :
    
    Wrapped function:
        cvSaveMemStoragePos
    Argument 'storage':
        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 'srcarr':
        C++ type: ::CvArr const *
        Python type: Mat
    Argument 'dstarr':
        C++ type: ::CvArr *
        Python type: Mat
    Argument 'storage':
        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 'mhi':
        C++ type: ::CvArr const *.
        Python type: Mat.
    Argument 'seg_mask':
        C++ type: ::CvArr *.
        Python type: Mat.
    Argument 'storage':
        C++ type: ::CvMemStorage *.
        Python type: MemStorage.

    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)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++ 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++ type: ::CvArr const *.
        Python type: Mat.
    Argument 'dst':
        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++ type: ::CvMat const *
        Python type: Mat
    Argument 'roots':
        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++ type: ::CvMat const *
        Python type: Mat
    Argument 'roots2':
        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 'image':
        C++ type: ::CvArr const *.
        Python type: Mat.
    Argument 'sqsum':
        C++ type: ::CvArr *.
        Python type: Mat.
    Argument 'mask':
        C++ type: ::CvArr const *.
        Python type: Mat.

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

starKeypoint(...)


starKeypoint( (Point2i)pt, (object)size, (object)response) -> object :
    
    Wrapped function:
        cvStarKeypoint
    Argument 'pt':
        C++ type: ::CvPoint.
        Python type: Point2i.

    C++ signature :
        boost::python::api::object starKeypoint(cv::Point_<int>,int,float)

startFindContours(...)


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

    C++ signature :
        boost::python::api::object startFindContours(cv::Mat {lvalue},cv::Ptr<CvMemStorage> {lvalue} [,int=88 [,int=1 [,int=2 [,cv::Point_<int>=Point2i(x=0, y=0)]]]])

startNextStream(...)


startNextStream( (FileStorage)fs) -> None :
    
    Wrapped function:
        cvStartNextStream
    Argument 'fs':
        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.cxtypes_h_ext.CvAttrList object at 0x02040BB0>]]) -> None :
    
    Wrapped function:
        cvStartWriteStruct
    Argument 'fs':
        C++ type: ::CvFileStorage *
        Python type: FileStorage

    C++ signature :
        void startWriteStruct(cv::FileStorage {lvalue},char const*,int [,char const*=None [,CvAttrList=<pyopencv.cxtypes_h_ext.CvAttrList object at 0x02040BB0>]])

stereoCalibrate(...)


stereoCalibrate( (vector_vector_Point3f)objectPoints, (vector_vector_Point2f)imagePoints1, (vector_vector_Point2f)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]]) -> float :

    C++ signature :
        double stereoCalibrate(std::vector<std::vector<cv::Point3_<float>, std::allocator<cv::Point3_<float> > >, std::allocator<std::vector<cv::Point3_<float>, std::allocator<cv::Point3_<float> > > > >,std::vector<std::vector<cv::Point_<float>, std::allocator<cv::Point_<float> > >, std::allocator<std::vector<cv::Point_<float>, std::allocator<cv::Point_<float> > > > >,std::vector<std::vector<cv::Point_<float>, std::allocator<cv::Point_<float> > >, std::allocator<std::vector<cv::Point_<float>, std::allocator<cv::Point_<float> > > > >,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 'validPixROI1':
        C++ type: ::cv::Rect *
        Python type: Rect
        Output argument: omitted from input and returned as output.
    Argument 'validPixROI2':
        C++ type: ::cv::Rect *
        Python type: Rect
        Output argument: omitted from input and returned as output.
    Returns:
        (validPixROI1, validPixROI2)

    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 'pt':
        C++ type: ::CvPoint2D32f.
        Python type: Point2f.
    Argument 'vertex':
        C++ type: ::CvSubdiv2DPoint * *.
        Python type: (C++)CvSubdiv2DPoint *.
        Output argument: omitted from input and returned as output.
    Returns:
        (((C++)CvSubdiv2DPointLocation), vertex)

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

subtract( (Scalar)s, (MatND)a, (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::Scalar_<double>,cv::MatND,cv::MatND {lvalue} [,cv::MatND=MatND(shape=(), nchannels=1, depth=0):
array(6, 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++ type: ::CvPoint2D32f.
        Python type: Point2f.
    Argument 'b':
        C++ type: ::CvPoint2D32f.
        Python type: Point2f.
    Argument '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 'projMatr1':
        C++ type: ::CvMat *.
        Python type: Mat.
    Argument 'projMatr2':
        C++ type: ::CvMat *.
        Python type: Mat.
    Argument 'projPoints1':
        C++ type: ::CvMat *.
        Python type: Mat.
    Argument 'projPoints2':
        C++ type: ::CvMat *.
        Python type: Mat.
    Argument 'points4D':
        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++ type: ::std::vector< cv::Point_<float> > &
        Python type: vector_Point2f
        Output argument: omitted from input and returned as output.
    Returns:
        dst

    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 :

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

useOptimized()

    C++ signature :
        bool useOptimized()

Returns: bool :

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.cxtypes_h_ext.CvAttrList object at 0x02040BF0>]) -> None :
    
    Wrapped function:
        cvWrite
    Argument 'fs':
        C++ type: ::CvFileStorage *
        Python type: FileStorage
    Argument 'ptr':
        C++ type: void const *
        Python type: string

    C++ signature :
        void write(cv::FileStorage {lvalue},char const*,char const* [,CvAttrList=<pyopencv.cxtypes_h_ext.CvAttrList object at 0x02040BF0>])

writeComment(...)


writeComment( (FileStorage)fs, (str)comment, (object)eol_comment) -> None :
    
    Wrapped function:
        cvWriteComment
    Argument 'fs':
        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 'fs':
        C++ type: ::CvFileStorage *
        Python type: FileStorage
    Argument 'node':
        C++ type: ::CvFileNode const *
        Python type: FileNode

    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, (vector_KeyPoint)keypoints) -> None :
    
    Wrapped function:
        write

    C++ signature :
        void write_list_of_KeyPoint(cv::FileStorage {lvalue},std::string,std::vector<cv::KeyPoint, std::allocator<cv::KeyPoint> >)

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.cxcore_h_ext.flann_centers_init_t.CENTERS_GONZALES

CENTERS_KMEANSPP

Value:

pyopencv.cxcore_h_ext.flann_centers_init_t.CENTERS_KMEANSPP

CENTERS_RANDOM

Value:

pyopencv.cxcore_h_ext.flann_centers_init_t.CENTERS_RANDOM

CV_BADCHANNELS_ERR

Value:

pyopencv.cxtypes_h_ext.CvStatus.CV_BADCHANNELS_ERR

CV_BADCONVERGENCE_ERR

Value:

pyopencv.cxtypes_h_ext.CvStatus.CV_BADCONVERGENCE_ERR

CV_BADFACTOR_ERR

Value:

pyopencv.cxtypes_h_ext.CvStatus.CV_BADFACTOR_ERR

CV_BADHEADER_ERR

Value:

pyopencv.cxtypes_h_ext.CvStatus.CV_BADHEADER_ERR

CV_BADMEMBLOCK_ERR

Value:

pyopencv.cxtypes_h_ext.CvStatus.CV_BADMEMBLOCK_ERR

CV_DIV_BY_ZERO_ERR

Value:

pyopencv.cxtypes_h_ext.CvStatus.CV_DIV_BY_ZERO_ERR

CV_FACE_LEFT_EYE

Value:

pyopencv.cvaux_ext.CV_FACE_ELEMENTS.CV_FACE_LEFT_EYE

CV_FACE_RIGHT_EYE

Value:

pyopencv.cvaux_ext.CV_FACE_ELEMENTS.CV_FACE_RIGHT_EYE

CV_INPLACE_NOT_SUPPORTED_ERR

Value:

pyopencv.cxtypes_h_ext.CvStatus.CV_INPLACE_NOT_SUPPORTED_ERR

CV_NEXT_AROUND_DST

Value:

pyopencv.cv_h_ext.CvNextEdgeType.CV_NEXT_AROUND_DST

CV_NEXT_AROUND_LEFT

Value:

pyopencv.cv_h_ext.CvNextEdgeType.CV_NEXT_AROUND_LEFT

CV_NEXT_AROUND_ORG

Value:

pyopencv.cv_h_ext.CvNextEdgeType.CV_NEXT_AROUND_ORG

CV_NEXT_AROUND_RIGHT

Value:

pyopencv.cv_h_ext.CvNextEdgeType.CV_NEXT_AROUND_RIGHT

CV_NOTDEFINED_ERR

Value:

pyopencv.cxtypes_h_ext.CvStatus.CV_NOTDEFINED_ERR

CV_PREV_AROUND_DST

Value:

pyopencv.cv_h_ext.CvNextEdgeType.CV_PREV_AROUND_DST

CV_PREV_AROUND_LEFT

Value:

pyopencv.cv_h_ext.CvNextEdgeType.CV_PREV_AROUND_LEFT

CV_PREV_AROUND_ORG

Value:

pyopencv.cv_h_ext.CvNextEdgeType.CV_PREV_AROUND_ORG

CV_PREV_AROUND_RIGHT

Value:

pyopencv.cv_h_ext.CvNextEdgeType.CV_PREV_AROUND_RIGHT

CV_PTLOC_ERROR

Value:

pyopencv.cv_h_ext.CvSubdiv2DPointLocation.CV_PTLOC_ERROR

CV_PTLOC_INSIDE

Value:

pyopencv.cv_h_ext.CvSubdiv2DPointLocation.CV_PTLOC_INSIDE

CV_PTLOC_ON_EDGE

Value:

pyopencv.cv_h_ext.CvSubdiv2DPointLocation.CV_PTLOC_ON_EDGE

CV_PTLOC_OUTSIDE_RECT

Value:

pyopencv.cv_h_ext.CvSubdiv2DPointLocation.CV_PTLOC_OUTSIDE_RECT

CV_PTLOC_VERTEX

Value:

pyopencv.cv_h_ext.CvSubdiv2DPointLocation.CV_PTLOC_VERTEX

CV_UNMATCHED_FORMATS_ERR

Value:

pyopencv.cxtypes_h_ext.CvStatus.CV_UNMATCHED_FORMATS_ERR

CV_UNMATCHED_ROI_ERR

Value:

pyopencv.cxtypes_h_ext.CvStatus.CV_UNMATCHED_ROI_ERR

CV_UNSUPPORTED_CHANNELS_ERR

Value:

pyopencv.cxtypes_h_ext.CvStatus.CV_UNSUPPORTED_CHANNELS_ERR

CV_UNSUPPORTED_COI_ERR

Value:

pyopencv.cxtypes_h_ext.CvStatus.CV_UNSUPPORTED_COI_ERR

CV_UNSUPPORTED_DEPTH_ERR

Value:

pyopencv.cxtypes_h_ext.CvStatus.CV_UNSUPPORTED_DEPTH_ERR

CV_UNSUPPORTED_FORMAT_ERR

Value:

pyopencv.cxtypes_h_ext.CvStatus.CV_UNSUPPORTED_FORMAT_ERR

loader

Value:

<zipimporter object "M:\programming\builders\Python26\lib\site-package
s\pyopencv-2.1.0.wr1.1.1-py2.6-win32.egg">

asvector_CvConnectedComp

Value:

<functools.partial object at 0x0225C630>

asvector_vector_Point2d

Value:

<functools.partial object at 0x0225CBA0>

asvector_vector_Point2f

Value:

<functools.partial object at 0x0225CC00>

asvector_vector_Point2i

Value:

<functools.partial object at 0x0225CB10>

asvector_vector_Point3d

Value:

<functools.partial object at 0x0225C780>

asvector_vector_Point3f

Value:

<functools.partial object at 0x0225C720>

asvector_vector_Point3i

Value:

<functools.partial object at 0x0225C6C0>

asvector_vector_float32

Value:

<functools.partial object at 0x02262300>