Package pyopencv

PyOpenCV - A Python wrapper for OpenCV 2.x using Boost.Python and NumPy

Copyright (c) 2009, Minh-Tri Pham
All rights reserved.

Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:

   * Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
   * Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
   * Neither the name of pyopencv's copyright holders nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

For further inquiries, please contact Minh-Tri Pham at pmtri80@gmail.com.

Submodules

[hide private]

pyopencv.pyopencvext

Functions

[hide private]

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

boxPoints(...)
boxPoints( (RotatedRect)box, (CvPoint2D32f)pt) -> None :

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

cloneSeq(...)
cloneSeq( (CvSeq)seq [, (MemStorage)storage=<pyopencv.pyopencvext.MemStorage object at 0x0340B330>]) -> object :

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

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

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

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

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

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

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

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

contourFromContourTree(...)
contourFromContourTree( (CvContourTree)tree, (MemStorage)storage, (TermCriteria)criteria) -> object :

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

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

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

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

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

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

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

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

convexityDefects(...)
convexityDefects( (Mat)contour, (Mat)convexhull [, (MemStorage)storage=<pyopencv.pyopencvext.MemStorage object at 0x0340B370>]) -> object :

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

CvTypeInfo :

firstType()
Wrapped function: cvFirstType

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

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

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

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

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

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

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

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

long :

getCPUTickCount()
C++ signature :...

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

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

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

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

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

int :

getErrMode()
Wrapped function: cvGetErrMode

int :

getErrStatus()
Wrapped function: cvGetErrStatus

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

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

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

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

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

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

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

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

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

int :

getNumThreads()
Wrapped function: cvGetNumThreads

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

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

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

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

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

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

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

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

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

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

int :

getThreadNum()
Wrapped function: cvGetThreadNum

long :

getTickCount()
Wrapped function: cvGetTickCount

float :

getTickFrequency()
Wrapped function: cvGetTickFrequency

getTrackbarPos(...)
getTrackbarPos( (object)trackbarname, (object)winname) -> int :

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

merge(...)
merge( (vector_MatND)mv, (MatND)dst) -> None :

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

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

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

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

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

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

Scalar :

morphologyDefaultBorderValue()
C++ signature :...

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

setTrackbarPos(...)
setTrackbarPos( (object)trackbarname, (object)winname, (object)pos) -> None :

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

int :

startWindowThread()
Wrapped function: cvStartWindowThread

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

RNG :

theRNG()
Returns the default random number generator.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Variables

[hide private]

ADAPTIVE_THRESH_GAUSSIAN_C = 1

ADAPTIVE_THRESH_MEAN_C = 0

AUTOTUNED = pyopencv.pyopencvext.flann_algorithm_t.AUTOTUNED

BORDER_CONSTANT = 0

BORDER_DEFAULT = 4

BORDER_ISOLATED = 16

BORDER_REFLECT = 2

BORDER_REFLECT101 = 4

BORDER_REFLECT_101 = 4

BORDER_REPLICATE = 1

BORDER_TRANSPARENT = 4

BORDER_WRAP = 3

CALIB_CB_ADAPTIVE_THRESH = 1

CALIB_CB_FILTER_QUADS = 4

CALIB_CB_NORMALIZE_IMAGE = 2

CALIB_FIX_ASPECT_RATIO = 2

CALIB_FIX_FOCAL_LENGTH = 16

CALIB_FIX_INTRINSIC = 256

CALIB_FIX_K1 = 32

CALIB_FIX_K2 = 64

CALIB_FIX_K3 = 128

CALIB_FIX_PRINCIPAL_POINT = 4

CALIB_SAME_FOCAL_LENGTH = 512

CALIB_USE_INTRINSIC_GUESS = 1

CALIB_ZERO_DISPARITY = 1024

CALIB_ZERO_TANGENT_DIST = 8

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

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

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

CHAIN_APPROX_NONE = 1

CHAIN_APPROX_SIMPLE = 2

CHAIN_APPROX_TC89_KCOS = 4

CHAIN_APPROX_TC89_L1 = 3

CMP_EQ = 0

CMP_GE = 2

CMP_GT = 1

CMP_LE = 4

CMP_LT = 3

CMP_NE = 5

COMPOSITE = pyopencv.pyopencvext.flann_algorithm_t.COMPOSITE

CV_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.pyopencvext.CvStatus.CV_BADARG_ERR

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

CV_BADCOEF_ERR = pyopencv.pyopencvext.CvStatus.CV_BADCOEF_ERR

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

CV_BADDEPTH_ERR = pyopencv.pyopencvext.CvStatus.CV_BADDEPTH_ERR

CV_BADFACTOR_ERR = pyopencv.pyopencvext.CvStatus.CV_BADFACTOR_ERR

CV_BADFLAG_ERR = pyopencv.pyopencvext.CvStatus.CV_BADFLAG_ERR

CV_BADHEADER_ERR = pyopencv.pyopencvext.CvStatus.CV_BADHEADER_ERR

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

CV_BADPOINT_ERR = pyopencv.pyopencvext.CvStatus.CV_BADPOINT_ERR

CV_BADRANGE_ERR = pyopencv.pyopencvext.CvStatus.CV_BADRANGE_ERR

CV_BADROI_ERR = pyopencv.pyopencvext.CvStatus.CV_BADROI_ERR

CV_BADSCALE_ERR = pyopencv.pyopencvext.CvStatus.CV_BADSCALE_ERR

CV_BADSIZE_ERR = pyopencv.pyopencvext.CvStatus.CV_BADSIZE_ERR

CV_BADSTEP_ERR = pyopencv.pyopencvext.CvStatus.CV_BADSTEP_ERR

CV_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_CALIB_ETALON_CHECKERBOARD = pyopencv.pyopencvext.CvCalibEta...

CV_CALIB_ETALON_CHESSBOARD = pyopencv.pyopencvext.CvCalibEtalo...

CV_CALIB_ETALON_USER = pyopencv.pyopencvext.CvCalibEtalonType....

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.pyopencvext.CvStatus.CV_DIV_BY_Z...

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.pyopencvext.CV_FACE_ELEMENTS.CV_FA...

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

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

CV_FILLED = -1

CV_FOURCC_DEFAULT = 1448433993

CV_FOURCC_PROMPT = -1

CV_FRONT = 1

CV_GAUSSIAN = 2

CV_GAUSSIAN_5x5 = pyopencv.pyopencvext.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.pyopencvext.CvStatus.C...

CV_LEE_AUTO = pyopencv.pyopencvext.CvLeeParameters.CV_LEE_AUTO

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

CV_LEE_ERODE = pyopencv.pyopencvext.CvLeeParameters.CV_LEE_ERODE

CV_LEE_FLOAT = pyopencv.pyopencvext.CvLeeParameters.CV_LEE_FLOAT

CV_LEE_INT = pyopencv.pyopencvext.CvLeeParameters.CV_LEE_INT

CV_LEE_NON = pyopencv.pyopencvext.CvLeeParameters.CV_LEE_NON

CV_LEE_ZOOM = pyopencv.pyopencvext.CvLeeParameters.CV_LEE_ZOOM

CV_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.pyopencvext.CvNextEdgeType.CV_NE...

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

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

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

CV_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.pyopencvext.CvStatus.CV_NOTDEFINE...

CV_NOTFOUND_ERR = pyopencv.pyopencvext.CvStatus.CV_NOTFOUND_ERR

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

CV_NO_CN_CHECK = 2

CV_NO_DEPTH_CHECK = 1

CV_NO_ERR = pyopencv.pyopencvext.CvStatus.CV_NO_ERR

CV_NO_SIZE_CHECK = 4

CV_NULLPTR_ERR = pyopencv.pyopencvext.CvStatus.CV_NULLPTR_ERR

CV_OK = pyopencv.pyopencvext.CvStatus.CV_OK

CV_ORIENTED_GRAPH = 5632

CV_OUTOFMEM_ERR = pyopencv.pyopencvext.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.pyopencvext.CvNextEdgeType.CV_PR...

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

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

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

CV_PTLOC_ERROR = pyopencv.pyopencvext.CvSubdiv2DPointLocation....

CV_PTLOC_INSIDE = pyopencv.pyopencvext.CvSubdiv2DPointLocation...

CV_PTLOC_ON_EDGE = pyopencv.pyopencvext.CvSubdiv2DPointLocatio...

CV_PTLOC_OUTSIDE_RECT = pyopencv.pyopencvext.CvSubdiv2DPointLo...

CV_PTLOC_VERTEX = pyopencv.pyopencvext.CvSubdiv2DPointLocation...

CV_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.pyopencvext.CvStatus.CV_UN...

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

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

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

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

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

CV_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_WEIGHTED_ALL = pyopencv.pyopencvext.CvGraphWeightType.CV_WE...

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

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

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.pyopencvext.flann_distance_t.EUCLIDEAN

FLOODFILL_FIXED_RANGE = 65536

FLOODFILL_MASK_ONLY = 131072

FM_7POINT = 1

FM_8POINT = 2

FM_LMEDS = 4

FM_RANSAC = 8

FONT_HERSHEY_COMPLEX = 3

FONT_HERSHEY_COMPLEX_SMALL = 5

FONT_HERSHEY_DUPLEX = 2

FONT_HERSHEY_PLAIN = 1

FONT_HERSHEY_SCRIPT_COMPLEX = 7

FONT_HERSHEY_SCRIPT_SIMPLEX = 6

FONT_HERSHEY_SIMPLEX = 0

FONT_HERSHEY_TRIPLEX = 4

FONT_ITALIC = 16

GC_BGD = 0

GC_EVAL = 2

GC_FGD = 1

GC_INIT_WITH_MASK = 1

GC_INIT_WITH_RECT = 0

GC_PR_BGD = 2

GC_PR_FGD = 3

GEMM_1_T = 1

GEMM_2_T = 2

GEMM_3_T = 4

INPAINT_NS = 0

INPAINT_TELEA = 1

INTER_AREA = 3

INTER_CUBIC = 2

INTER_LANCZOS4 = 4

INTER_LINEAR = 1

INTER_MAX = 7

INTER_NEAREST = 0

KDTREE = pyopencv.pyopencvext.flann_algorithm_t.KDTREE

KERNEL_ASYMMETRICAL = 2

KERNEL_GENERAL = 0

KERNEL_INTEGER = 8

KERNEL_SMOOTH = 4

KERNEL_SYMMETRICAL = 1

KMEANS = pyopencv.pyopencvext.flann_algorithm_t.KMEANS

KMEANS_PP_CENTERS = 2

KMEANS_RANDOM_CENTERS = 0

KMEANS_USE_INITIAL_LABELS = 1

LINEAR = pyopencv.pyopencvext.flann_algorithm_t.LINEAR

LMEDS = 4

LOG_ERROR = pyopencv.pyopencvext.flann_log_level_t.LOG_ERROR

LOG_FATAL = pyopencv.pyopencvext.flann_log_level_t.LOG_FATAL

LOG_INFO = pyopencv.pyopencvext.flann_log_level_t.LOG_INFO

LOG_NONE = pyopencv.pyopencvext.flann_log_level_t.LOG_NONE

LOG_WARN = pyopencv.pyopencvext.flann_log_level_t.LOG_WARN

MAGIC_MASK = -65536

MANHATTAN = pyopencv.pyopencvext.flann_distance_t.MANHATTAN

MINKOWSKI = pyopencv.pyopencvext.flann_distance_t.MINKOWSKI

MORPH_BLACKHAT = 6

MORPH_CLOSE = 3

MORPH_CROSS = 1

MORPH_DILATE = 1

MORPH_ELLIPSE = 2

MORPH_ERODE = 0

MORPH_GRADIENT = 4

MORPH_OPEN = 2

MORPH_RECT = 0

MORPH_TOPHAT = 5

NORM_INF = 1

NORM_L1 = 2

NORM_L2 = 4

NORM_MINMAX = 32

NORM_RELATIVE = 8

NORM_TYPE_MASK = 7

OPTFLOW_FARNEBACK_GAUSSIAN = 256

OPTFLOW_USE_INITIAL_FLOW = 4

RANSAC = 8

RETR_CCOMP = 2

RETR_EXTERNAL = 0

RETR_LIST = 1

RETR_TREE = 3

SAVED = pyopencv.pyopencvext.flann_algorithm_t.SAVED

THRESH_BINARY = 0

THRESH_BINARY_INV = 1

THRESH_MASK = 7

THRESH_OTSU = 8

THRESH_TOZERO = 3

THRESH_TOZERO_INV = 4

THRESH_TRUNC = 2

TM_CCOEFF = 4

TM_CCOEFF_NORMED = 5

TM_CCORR = 2

TM_CCORR_NORMED = 3

TM_SQDIFF = 0

TM_SQDIFF_NORMED = 1

TYPE_MASK = 4095

WARP_INVERSE_MAP = 16

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

__package__ = 'pyopencv'

Function Details

[hide private]

CamShift(...)

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

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

Canny(...)

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

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

FAST(...)

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

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

GaussianBlur(...)

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

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

HoughCircles(...)

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

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

HoughLines(...)

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

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

HoughLinesP(...)

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

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

HuMoments(...)

HuMoments( (Moments)moments) -> object :

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

LSHAdd(...)

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

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

LSHQuery(...)

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

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

LSHRemove(...)

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

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

LSHSize(...)

LSHSize( (CvLSH)lsh) -> int :

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

LUT(...)

LUT( (Mat)a, (Mat)lut, (Mat)b) -> None :
    
    Performs a look-up table transform of an array.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#cv-lut

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

Laplacian(...)

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

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

Mahalanobis(...)

Mahalanobis( (Mat)v1, (Mat)v2, (Mat)icovar) -> float :
    
    Calculates the Mahalanobis distance between two vectors.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#cv-mahalanobis

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

Mahalonobis(...)

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

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

POSIT(...)

POSIT( (CvPOSITObject)posit_object, (CvPoint2D32f)image_points, (object)focal_length, (TermCriteria)criteria, (object)rotation_matrix, (object)translation_vector) -> None :
    
    Wrapped function:
        cvPOSIT
    Argument 'criteria':
        C/C++ type: ::CvTermCriteria.
        Python type: TermCriteria.

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

RANSACUpdateNumIters(...)

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

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

RQDecomp3x3(...)

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

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

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

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

Rodrigues(...)

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

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

SURFParams(...)

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

    C++ signature :
        CvSURFParams SURFParams(double [,int=0])

Scharr(...)

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

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

Sobel(...)

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

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

absdiff(...)

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

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

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

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

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

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

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

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

acc(...)

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

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

accumulate(...)

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

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

accumulateProduct(...)

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

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

accumulateSquare(...)

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

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

accumulateWeighted(...)

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

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

adaptiveThreshold(...)

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

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

add(...)

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

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

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

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

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

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

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

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

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

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

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

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

addWeighted(...)

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

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

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

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

approxChains(...)

approxChains( (CvSeq)src_seq, (MemStorage)storage [, (object)method=2 [, (object)parameter=0 [, (object)minimal_perimeter=0 [, (object)recursive=0]]]]) -> object :
    
    Wrapped function:
        cvApproxChains
    Argument 'storage':
        C/C++ type: ::CvMemStorage *.
        Python type: MemStorage.

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

approxPolyDP_float32(...)

approxPolyDP_float32( (Mat)curve, (object)epsilon, (bool)closed) -> object :
    
    Wrapped function:
        approxPolyDP
    Argument 'approxCurve':
        C/C++ type: ::std::vector< cv::Point_<float> > &.
        Python type: Mat.
        Invoke asMat() to convert a 1D Python sequence into a Mat, e.g. 
        asMat([0,1,2]) or asMat((0,1,2)).
        Output argument: omitted from the function's calling sequence, and is 
        returned along with the function's return value (if any).

    C++ signature :
        boost::python::api::object approxPolyDP_float32(cv::Mat,double,bool)

approxPolyDP_int(...)

approxPolyDP_int( (Mat)curve, (object)epsilon, (bool)closed) -> object :
    
    Wrapped function:
        approxPolyDP
    Argument 'approxCurve':
        C/C++ type: ::std::vector< cv::Point_<int> > &.
        Python type: Mat.
        Invoke asMat() to convert a 1D Python sequence into a Mat, e.g. 
        asMat([0,1,2]) or asMat((0,1,2)).
        Output argument: omitted from the function's calling sequence, and is 
        returned along with the function's return value (if any).

    C++ signature :
        boost::python::api::object approxPolyDP_int(cv::Mat,double,bool)

arcLength(...)

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

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

asComplexd(...)

asComplexd( (Complexf)inst_Complexf) -> Complexd :

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

asComplexf(...)

asComplexf( (Complexd)inst_Complexd) -> Complexf :

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

asCvMat(...)

asCvMat( (Mat)inst_Mat) -> CvMat :

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

asCvPoint(...)

asCvPoint( (Point2i)inst_Point2i) -> CvPoint :

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

asCvPoint( (Point2f)inst_Point2f) -> CvPoint :

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

asCvPoint( (Point2d)inst_Point2d) -> CvPoint :

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

asCvPoint2D32f(...)

asCvPoint2D32f( (Point2i)inst_Point2i) -> CvPoint2D32f :

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

asCvPoint2D32f( (Point2f)inst_Point2f) -> CvPoint2D32f :

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

asCvPoint2D32f( (Point2d)inst_Point2d) -> CvPoint2D32f :

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

asCvPoint3D32f(...)

asCvPoint3D32f( (Point3i)inst_Point3i) -> CvPoint3D32f :

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

asCvPoint3D32f( (Point3f)inst_Point3f) -> CvPoint3D32f :

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

asCvPoint3D32f( (Point3d)inst_Point3d) -> CvPoint3D32f :

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

asMatND(...)

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

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

asPoint(...)

asPoint2i( (Point2f)inst_Point2f) -> Point2i :

    C++ signature :
        cv::Point_<int> asPoint2i(cv::Point_<float>)

asPoint2i( (Point2d)inst_Point2d) -> Point2i :

    C++ signature :
        cv::Point_<int> asPoint2i(cv::Point_<double>)

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

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

asPoint2d(...)

asPoint2d( (Point2i)inst_Point2i) -> Point2d :

    C++ signature :
        cv::Point_<double> asPoint2d(cv::Point_<int>)

asPoint2d( (Point2f)inst_Point2f) -> Point2d :

    C++ signature :
        cv::Point_<double> asPoint2d(cv::Point_<float>)

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

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

asPoint2f(...)

asPoint2f( (Point2i)inst_Point2i) -> Point2f :

    C++ signature :
        cv::Point_<float> asPoint2f(cv::Point_<int>)

asPoint2f( (Point2d)inst_Point2d) -> Point2f :

    C++ signature :
        cv::Point_<float> asPoint2f(cv::Point_<double>)

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

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

asPoint2i(...)

asPoint2i( (Point2f)inst_Point2f) -> Point2i :

    C++ signature :
        cv::Point_<int> asPoint2i(cv::Point_<float>)

asPoint2i( (Point2d)inst_Point2d) -> Point2i :

    C++ signature :
        cv::Point_<int> asPoint2i(cv::Point_<double>)

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

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

asPoint3d(...)

asPoint3d( (Point3i)inst_Point3i) -> Point3d :

    C++ signature :
        cv::Point3_<double> asPoint3d(cv::Point3_<int>)

asPoint3d( (Point3f)inst_Point3f) -> Point3d :

    C++ signature :
        cv::Point3_<double> asPoint3d(cv::Point3_<float>)

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

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

asPoint3f(...)

asPoint3f( (Point3i)inst_Point3i) -> Point3f :

    C++ signature :
        cv::Point3_<float> asPoint3f(cv::Point3_<int>)

asPoint3f( (Point3d)inst_Point3d) -> Point3f :

    C++ signature :
        cv::Point3_<float> asPoint3f(cv::Point3_<double>)

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

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

asPoint3i(...)

asPoint3i( (Point3f)inst_Point3f) -> Point3i :

    C++ signature :
        cv::Point3_<int> asPoint3i(cv::Point3_<float>)

asPoint3i( (Point3d)inst_Point3d) -> Point3i :

    C++ signature :
        cv::Point3_<int> asPoint3i(cv::Point3_<double>)

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

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

asRange(...)

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

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

asRect(...)

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

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

asRotatedRect(...)

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

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

asScalar(...)

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

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

asSize2f(...)

asSize2f( (Size2i)inst_Size2i) -> Size2f :

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

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

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

asSize2i(...)

asSize2i( (Size2f)inst_Size2f) -> Size2i :

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

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

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

asVec2b(...)

asVec2b( (Vec2s)inst_Vec2s) -> Vec2b :

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

asVec2b( (Vec2w)inst_Vec2w) -> Vec2b :

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

asVec2b( (Vec2i)inst_Vec2i) -> Vec2b :

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

asVec2b( (Vec2f)inst_Vec2f) -> Vec2b :

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

asVec2b( (Vec2d)inst_Vec2d) -> Vec2b :

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

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

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

asVec2d(...)

asVec2d( (Vec2b)inst_Vec2b) -> Vec2d :

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

asVec2d( (Vec2s)inst_Vec2s) -> Vec2d :

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

asVec2d( (Vec2w)inst_Vec2w) -> Vec2d :

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

asVec2d( (Vec2i)inst_Vec2i) -> Vec2d :

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

asVec2d( (Vec2f)inst_Vec2f) -> Vec2d :

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

asVec2d( (Point2d)inst_Point2d) -> Vec2d :

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

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

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

asVec2f(...)

asVec2f( (Vec2b)inst_Vec2b) -> Vec2f :

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

asVec2f( (Vec2s)inst_Vec2s) -> Vec2f :

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

asVec2f( (Vec2w)inst_Vec2w) -> Vec2f :

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

asVec2f( (Vec2i)inst_Vec2i) -> Vec2f :

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

asVec2f( (Vec2d)inst_Vec2d) -> Vec2f :

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

asVec2f( (Point2f)inst_Point2f) -> Vec2f :

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

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

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

asVec2i(...)

asVec2i( (Vec2b)inst_Vec2b) -> Vec2i :

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

asVec2i( (Vec2s)inst_Vec2s) -> Vec2i :

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

asVec2i( (Vec2w)inst_Vec2w) -> Vec2i :

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

asVec2i( (Vec2f)inst_Vec2f) -> Vec2i :

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

asVec2i( (Vec2d)inst_Vec2d) -> Vec2i :

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

asVec2i( (Point2i)inst_Point2i) -> Vec2i :

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

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

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

asVec2s(...)

asVec2s( (Vec2b)inst_Vec2b) -> Vec2s :

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

asVec2s( (Vec2w)inst_Vec2w) -> Vec2s :

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

asVec2s( (Vec2i)inst_Vec2i) -> Vec2s :

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

asVec2s( (Vec2f)inst_Vec2f) -> Vec2s :

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

asVec2s( (Vec2d)inst_Vec2d) -> Vec2s :

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

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

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

asVec2w(...)

asVec2w( (Vec2b)inst_Vec2b) -> Vec2w :

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

asVec2w( (Vec2s)inst_Vec2s) -> Vec2w :

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

asVec2w( (Vec2i)inst_Vec2i) -> Vec2w :

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

asVec2w( (Vec2f)inst_Vec2f) -> Vec2w :

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

asVec2w( (Vec2d)inst_Vec2d) -> Vec2w :

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

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

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

asVec3b(...)

asVec3b( (Vec3s)inst_Vec3s) -> Vec3b :

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

asVec3b( (Vec3w)inst_Vec3w) -> Vec3b :

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

asVec3b( (Vec3i)inst_Vec3i) -> Vec3b :

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

asVec3b( (Vec3f)inst_Vec3f) -> Vec3b :

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

asVec3b( (Vec3d)inst_Vec3d) -> Vec3b :

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

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

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

asVec3d(...)

asVec3d( (Vec3b)inst_Vec3b) -> Vec3d :

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

asVec3d( (Vec3s)inst_Vec3s) -> Vec3d :

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

asVec3d( (Vec3w)inst_Vec3w) -> Vec3d :

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

asVec3d( (Vec3i)inst_Vec3i) -> Vec3d :

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

asVec3d( (Vec3f)inst_Vec3f) -> Vec3d :

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

asVec3d( (Point3d)inst_Point3d) -> Vec3d :

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

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

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

asVec3f(...)

asVec3f( (Vec3b)inst_Vec3b) -> Vec3f :

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

asVec3f( (Vec3s)inst_Vec3s) -> Vec3f :

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

asVec3f( (Vec3w)inst_Vec3w) -> Vec3f :

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

asVec3f( (Vec3i)inst_Vec3i) -> Vec3f :

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

asVec3f( (Vec3d)inst_Vec3d) -> Vec3f :

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

asVec3f( (Point3f)inst_Point3f) -> Vec3f :

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

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

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

asVec3i(...)

asVec3i( (Vec3b)inst_Vec3b) -> Vec3i :

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

asVec3i( (Vec3s)inst_Vec3s) -> Vec3i :

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

asVec3i( (Vec3w)inst_Vec3w) -> Vec3i :

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

asVec3i( (Vec3f)inst_Vec3f) -> Vec3i :

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

asVec3i( (Vec3d)inst_Vec3d) -> Vec3i :

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

asVec3i( (Point3i)inst_Point3i) -> Vec3i :

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

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

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

asVec3s(...)

asVec3s( (Vec3b)inst_Vec3b) -> Vec3s :

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

asVec3s( (Vec3w)inst_Vec3w) -> Vec3s :

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

asVec3s( (Vec3i)inst_Vec3i) -> Vec3s :

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

asVec3s( (Vec3f)inst_Vec3f) -> Vec3s :

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

asVec3s( (Vec3d)inst_Vec3d) -> Vec3s :

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

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

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

asVec3w(...)

asVec3w( (Vec3b)inst_Vec3b) -> Vec3w :

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

asVec3w( (Vec3s)inst_Vec3s) -> Vec3w :

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

asVec3w( (Vec3i)inst_Vec3i) -> Vec3w :

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

asVec3w( (Vec3f)inst_Vec3f) -> Vec3w :

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

asVec3w( (Vec3d)inst_Vec3d) -> Vec3w :

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

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

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

asVec4b(...)

asVec4b( (Vec4s)inst_Vec4s) -> Vec4b :

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

asVec4b( (Vec4w)inst_Vec4w) -> Vec4b :

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

asVec4b( (Vec4i)inst_Vec4i) -> Vec4b :

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

asVec4b( (Vec4f)inst_Vec4f) -> Vec4b :

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

asVec4b( (Vec4d)inst_Vec4d) -> Vec4b :

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

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

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

asVec4d(...)

asVec4d( (Vec4b)inst_Vec4b) -> Vec4d :

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

asVec4d( (Vec4s)inst_Vec4s) -> Vec4d :

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

asVec4d( (Vec4w)inst_Vec4w) -> Vec4d :

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

asVec4d( (Vec4i)inst_Vec4i) -> Vec4d :

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

asVec4d( (Vec4f)inst_Vec4f) -> Vec4d :

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

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

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

asVec4f(...)

asVec4f( (Vec4b)inst_Vec4b) -> Vec4f :

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

asVec4f( (Vec4s)inst_Vec4s) -> Vec4f :

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

asVec4f( (Vec4w)inst_Vec4w) -> Vec4f :

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

asVec4f( (Vec4i)inst_Vec4i) -> Vec4f :

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

asVec4f( (Vec4d)inst_Vec4d) -> Vec4f :

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

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

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

asVec4i(...)

asVec4i( (Vec4b)inst_Vec4b) -> Vec4i :

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

asVec4i( (Vec4s)inst_Vec4s) -> Vec4i :

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

asVec4i( (Vec4w)inst_Vec4w) -> Vec4i :

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

asVec4i( (Vec4f)inst_Vec4f) -> Vec4i :

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

asVec4i( (Vec4d)inst_Vec4d) -> Vec4i :

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

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

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

asVec4s(...)

asVec4s( (Vec4b)inst_Vec4b) -> Vec4s :

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

asVec4s( (Vec4w)inst_Vec4w) -> Vec4s :

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

asVec4s( (Vec4i)inst_Vec4i) -> Vec4s :

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

asVec4s( (Vec4f)inst_Vec4f) -> Vec4s :

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

asVec4s( (Vec4d)inst_Vec4d) -> Vec4s :

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

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

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

asVec4w(...)

asVec4w( (Vec4b)inst_Vec4b) -> Vec4w :

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

asVec4w( (Vec4s)inst_Vec4s) -> Vec4w :

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

asVec4w( (Vec4i)inst_Vec4i) -> Vec4w :

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

asVec4w( (Vec4f)inst_Vec4f) -> Vec4w :

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

asVec4w( (Vec4d)inst_Vec4d) -> Vec4w :

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

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

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

asVec6d(...)

asVec6d( (Vec6f)inst_Vec6f) -> Vec6d :

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

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

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

asVec6f(...)

asVec6f( (Vec6d)inst_Vec6d) -> Vec6f :

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

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

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

asvector_Point2d(...)

asvector_Point2d( (Mat)inst_Mat) -> vector_Point2d :

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

asvector_Point2f(...)

asvector_Point2f( (Mat)inst_Mat) -> vector_Point2f :

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

asvector_Point2i(...)

asvector_Point2i( (Mat)inst_Mat) -> vector_Point2i :

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

asvector_Point3d(...)

asvector_Point3d( (Mat)inst_Mat) -> vector_Point3d :

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

asvector_Point3f(...)

asvector_Point3f( (Mat)inst_Mat) -> vector_Point3f :

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

asvector_Point3i(...)

asvector_Point3i( (Mat)inst_Mat) -> vector_Point3i :

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

asvector_Range(...)

asvector_Range( (Mat)inst_Mat) -> vector_Range :

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

asvector_Rect(...)

asvector_Rect( (Mat)inst_Mat) -> vector_Rect :

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

asvector_RotatedRect(...)

asvector_RotatedRect( (Mat)inst_Mat) -> vector_RotatedRect :

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

asvector_Scalar(...)

asvector_Scalar( (Mat)inst_Mat) -> vector_Scalar :

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

asvector_Size2f(...)

asvector_Size2f( (Mat)inst_Mat) -> vector_Size2f :

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

asvector_Size2i(...)

asvector_Size2i( (Mat)inst_Mat) -> vector_Size2i :

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

asvector_Vec2b(...)

asvector_Vec2b( (Mat)inst_Mat) -> vector_Vec2b :

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

asvector_Vec2d(...)

asvector_Vec2d( (Mat)inst_Mat) -> vector_Vec2d :

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

asvector_Vec2f(...)

asvector_Vec2f( (Mat)inst_Mat) -> vector_Vec2f :

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

asvector_Vec2i(...)

asvector_Vec2i( (Mat)inst_Mat) -> vector_Vec2i :

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

asvector_Vec2s(...)

asvector_Vec2s( (Mat)inst_Mat) -> vector_Vec2s :

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

asvector_Vec2w(...)

asvector_Vec2w( (Mat)inst_Mat) -> vector_Vec2w :

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

asvector_Vec3b(...)

asvector_Vec3b( (Mat)inst_Mat) -> vector_Vec3b :

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

asvector_Vec3d(...)

asvector_Vec3d( (Mat)inst_Mat) -> vector_Vec3d :

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

asvector_Vec3f(...)

asvector_Vec3f( (Mat)inst_Mat) -> vector_Vec3f :

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

asvector_Vec3i(...)

asvector_Vec3i( (Mat)inst_Mat) -> vector_Vec3i :

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

asvector_Vec3s(...)

asvector_Vec3s( (Mat)inst_Mat) -> vector_Vec3s :

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

asvector_Vec3w(...)

asvector_Vec3w( (Mat)inst_Mat) -> vector_Vec3w :

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

asvector_Vec4b(...)

asvector_Vec4b( (Mat)inst_Mat) -> vector_Vec4b :

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

asvector_Vec4d(...)

asvector_Vec4d( (Mat)inst_Mat) -> vector_Vec4d :

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

asvector_Vec4f(...)

asvector_Vec4f( (Mat)inst_Mat) -> vector_Vec4f :

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

asvector_Vec4i(...)

asvector_Vec4i( (Mat)inst_Mat) -> vector_Vec4i :

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

asvector_Vec4s(...)

asvector_Vec4s( (Mat)inst_Mat) -> vector_Vec4s :

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

asvector_Vec4w(...)

asvector_Vec4w( (Mat)inst_Mat) -> vector_Vec4w :

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

asvector_Vec6d(...)

asvector_Vec6d( (Mat)inst_Mat) -> vector_Vec6d :

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

asvector_Vec6f(...)

asvector_Vec6f( (Mat)inst_Mat) -> vector_Vec6f :

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

asvector_float32(...)

asvector_float32( (Mat)inst_Mat) -> vector_float32 :

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

asvector_float64(...)

asvector_float64( (Mat)inst_Mat) -> vector_float64 :

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

asvector_int(...)

asvector_int( (Mat)inst_Mat) -> vector_int :

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

asvector_int16(...)

asvector_int16( (Mat)inst_Mat) -> vector_int16 :

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

asvector_int8(...)

asvector_int8( (Mat)inst_Mat) -> vector_int8 :

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

asvector_uint16(...)

asvector_uint16( (Mat)inst_Mat) -> vector_uint16 :

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

asvector_uint8(...)

asvector_uint8( (Mat)inst_Mat) -> vector_uint8 :

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

asvector_vector_Point2d(...)

asvector_vector_Point2d( (Mat)inst_Mat) -> vector_vector_Point2d :

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

asvector_vector_Point2f(...)

asvector_vector_Point2f( (Mat)inst_Mat) -> vector_vector_Point2f :

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

asvector_vector_Point2i(...)

asvector_vector_Point2i( (Mat)inst_Mat) -> vector_vector_Point2i :

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

asvector_vector_Point3d(...)

asvector_vector_Point3d( (Mat)inst_Mat) -> vector_vector_Point3d :

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

asvector_vector_Point3f(...)

asvector_vector_Point3f( (Mat)inst_Mat) -> vector_vector_Point3f :

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

asvector_vector_Point3i(...)

asvector_vector_Point3i( (Mat)inst_Mat) -> vector_vector_Point3i :

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

asvector_vector_Vec2i(...)

asvector_vector_Vec2i( (Mat)inst_Mat) -> vector_vector_Vec2i :

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

asvector_vector_float32(...)

asvector_vector_float32( (Mat)inst_Mat) -> vector_vector_float32 :

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

asvector_vector_int(...)

asvector_vector_int( (Mat)inst_Mat) -> vector_vector_int :

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

attrValue(...)

attrValue( (CvAttrList)attr, (str)attr_name) -> str :
    
    Wrapped function:
        cvAttrValue

    C++ signature :
        char const* attrValue(CvAttrList const*,char const*)

bilateralFilter(...)

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

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

bitwise_and(...)

bitwise_and( (MatND)a, (Scalar)s, (MatND)c [, (MatND)mask=MatND(shape=(), nchannels=1, depth=0):
array(58, dtype=uint8)]) -> None :
    
    Calculates per-element bit-wise conjunction of two arrays and an 
    array and a scalar.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#cv-bitwise-and

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

bitwise_and( (MatND)a, (MatND)b, (MatND)c [, (MatND)mask=MatND(shape=(), nchannels=1, depth=0):
array(50, dtype=uint8)]) -> None :
    
    Calculates per-element bit-wise conjunction of two arrays and an 
    array and a scalar.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#cv-bitwise-and

    C++ signature :
        void bitwise_and(cv::MatND,cv::MatND,cv::MatND {lvalue} [,cv::MatND=MatND(shape=(), nchannels=1, depth=0):
array(54, dtype=uint8)])

bitwise_and( (Mat)a, (Scalar)s, (Mat)c [, (Mat)mask=Mat()]) -> None :
    
    Calculates per-element bit-wise conjunction of two arrays and an 
    array and a scalar.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#cv-bitwise-and

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

bitwise_and( (Mat)a, (Mat)b, (Mat)c [, (Mat)mask=Mat()]) -> None :
    
    Calculates per-element bit-wise conjunction of two arrays and an 
    array and a scalar.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#cv-bitwise-and

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

bitwise_not(...)

bitwise_not( (MatND)a, (MatND)c) -> None :
    
    Inverts every bit of array.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#cv-bitwise-not

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

bitwise_not( (Mat)a, (Mat)c) -> None :
    
    Inverts every bit of array.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#cv-bitwise-not

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

bitwise_or(...)

bitwise_or( (MatND)a, (Scalar)s, (MatND)c [, (MatND)mask=MatND(shape=(), nchannels=1, depth=0):
array(82, dtype=uint8)]) -> None :
    
    Calculates per-element bit-wise disjunction of two arrays and an 
    array and a scalar.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#cv-bitwise-or

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

bitwise_or( (MatND)a, (MatND)b, (MatND)c [, (MatND)mask=MatND(shape=(), nchannels=1, depth=0):
array(74, dtype=uint8)]) -> None :
    
    Calculates per-element bit-wise disjunction of two arrays and an 
    array and a scalar.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#cv-bitwise-or

    C++ signature :
        void bitwise_or(cv::MatND,cv::MatND,cv::MatND {lvalue} [,cv::MatND=MatND(shape=(), nchannels=1, depth=0):
array(78, dtype=uint8)])

bitwise_or( (Mat)a, (Scalar)s, (Mat)c [, (Mat)mask=Mat()]) -> None :
    
    Calculates per-element bit-wise disjunction of two arrays and an 
    array and a scalar.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#cv-bitwise-or

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

bitwise_or( (Mat)a, (Mat)b, (Mat)c [, (Mat)mask=Mat()]) -> None :
    
    Calculates per-element bit-wise disjunction of two arrays and an 
    array and a scalar.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#cv-bitwise-or

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

bitwise_xor(...)

bitwise_xor( (MatND)a, (Scalar)s, (MatND)c [, (MatND)mask=MatND(shape=(), nchannels=1, depth=0):
array(102, dtype=uint8)]) -> None :
    
    Calculates per-element bit-wise 'exclusive or' operation on two 
    arrays and an array and a scalar.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#cv-bitwise-xor

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

bitwise_xor( (MatND)a, (MatND)b, (MatND)c [, (MatND)mask=MatND(shape=(), nchannels=1, depth=0):
array(94, dtype=uint8)]) -> None :
    
    Calculates per-element bit-wise 'exclusive or' operation on two 
    arrays and an array and a scalar.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#cv-bitwise-xor

    C++ signature :
        void bitwise_xor(cv::MatND,cv::MatND,cv::MatND {lvalue} [,cv::MatND=MatND(shape=(), nchannels=1, depth=0):
array(98, dtype=uint8)])

bitwise_xor( (Mat)a, (Scalar)s, (Mat)c [, (Mat)mask=Mat()]) -> None :
    
    Calculates per-element bit-wise 'exclusive or' operation on two 
    arrays and an array and a scalar.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#cv-bitwise-xor

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

bitwise_xor( (Mat)a, (Mat)b, (Mat)c [, (Mat)mask=Mat()]) -> None :
    
    Calculates per-element bit-wise 'exclusive or' operation on two 
    arrays and an array and a scalar.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#cv-bitwise-xor

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

blob(...)

blob( (object)x, (object)y, (object)w, (object)h) -> CvBlob :
    
    Wrapped function:
        cvBlob

    C++ signature :
        CvBlob blob(float,float,float,float)

blur(...)

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

    C++ signature :
        void blur(cv::Mat,cv::Mat {lvalue},cv::Size_<int> [,cv::Point_<int>=Point2i(x=-1, y=-1) [,int=4]])

borderInterpolate(...)

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

    C++ signature :
        int borderInterpolate(int,int,int)

boundingRect(...)

boundingRect( (Mat)points) -> Rect :

    C++ signature :
        cv::Rect_<int> boundingRect(cv::Mat)

boxFilter(...)

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

    C++ signature :
        void boxFilter(cv::Mat,cv::Mat {lvalue},int,cv::Size_<int> [,cv::Point_<int>=Point2i(x=-1, y=-1) [,bool=True [,int=4]]])

boxPoints(...)

boxPoints( (RotatedRect)box, (CvPoint2D32f)pt) -> None :
    
    Wrapped function:
        cvBoxPoints
    Argument 'box':
        C/C++ type: ::CvBox2D.
        Python type: RotatedRect.

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

buildPyramid(...)

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

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

calcAffineFlowPyrLK(...)

calcAffineFlowPyrLK( (Mat)prev, (Mat)curr, (Mat)prev_pyr, (Mat)curr_pyr, (list)prev_features, (Size2i)win_size, (object)level, (TermCriteria)criteria, (object)flags) -> tuple :
    
    Wrapped function:
        cvCalcAffineFlowPyrLK
    Argument 'count':
        Dependent argument: omitted from the function's calling sequence, as 
        its value is derived from argument 'prev_features'.
    Argument 'status':
        Output argument: omitted from the function's calling sequence, and is 
        returned along with the function's return value (if any).
    Argument 'prev':
        C/C++ type: ::CvArr const *.
        Python type: Mat.
    Argument 'curr':
        C/C++ type: ::CvArr const *.
        Python type: Mat.
    Argument 'track_error':
        Output argument: omitted from the function's calling sequence, and is 
        returned along with the function's return value (if any).
    Argument 'prev_pyr':
        C/C++ type: ::CvArr *.
        Python type: Mat.
    Argument 'curr_pyr':
        C/C++ type: ::CvArr *.
        Python type: Mat.
    Argument 'prev_features':
        C/C++ type: ::CvPoint2D32f const *.
        Python type: Python sequence with elements of C++ type 
        '::CvPoint2D32f'.
    Argument 'criteria':
        C/C++ type: ::CvTermCriteria.
        Python type: TermCriteria.
    Argument 'curr_features':
        Output argument: omitted from the function's calling sequence, and is 
        returned along with the function's return value (if any).
    Argument 'matrices':
        Output argument: omitted from the function's calling sequence, and is 
        returned along with the function's return value (if any).
    Argument 'win_size':
        C/C++ type: ::CvSize.
        Python type: Size2i.

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

calcBackProject(...)

calcBackProject( (list)images, (Mat)channels, (SparseMat)hist, (Mat)backProject, (object)ranges [, (object)scale=1 [, (bool)uniform=True]]) -> None :
    
    Argument 'images':
        C/C++ type: ::cv::Mat const *.
        Python type: list of Mat, e.g. [Mat(), Mat(), Mat()].
    Argument 'channels':
        C/C++ type: int const *.
        Python type: Mat.
        Invoke asMat() to convert a 1D Python sequence into a Mat, e.g. 
        asMat([0,1,2]) or asMat((0,1,2)).
    Argument 'nimages':
        Dependent argument: omitted from the function's calling sequence, as 
        its value is derived from argument 'images'.
    Argument 'ranges':
        C/C++ type: float const * *.
        Python type: list of Mat.

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

calcBackProject( (list)images, (Mat)channels, (MatND)hist, (Mat)backProject, (object)ranges [, (object)scale=1 [, (bool)uniform=True]]) -> None :
    
    Argument 'images':
        C/C++ type: ::cv::Mat const *.
        Python type: list of Mat, e.g. [Mat(), Mat(), Mat()].
    Argument 'channels':
        C/C++ type: int const *.
        Python type: Mat.
        Invoke asMat() to convert a 1D Python sequence into a Mat, e.g. 
        asMat([0,1,2]) or asMat((0,1,2)).
    Argument 'nimages':
        Dependent argument: omitted from the function's calling sequence, as 
        its value is derived from argument 'images'.
    Argument 'ranges':
        C/C++ type: float const * *.
        Python type: list of Mat.

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

calcCovarMatrix(...)

calcCovarMatrix( (list)samples, (Mat)covar, (Mat)mean, (object)flags [, (object)ctype=6]) -> None :
    
    Calculates covariation matrix of a set of vectors.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#calccovarmatrix
    Argument 'nsamples':
        Dependent argument: omitted from the function's calling sequence, as 
        its value is derived from argument 'samples'.
    Argument 'samples':
        C/C++ type: ::cv::Mat const *.
        Python type: list of Mat, e.g. [Mat(), Mat(), Mat()].

    C++ signature :
        void calcCovarMatrix(boost::python::list,cv::Mat {lvalue},cv::Mat {lvalue},int [,int=6])

calcCovarMatrix( (Mat)samples, (Mat)covar, (Mat)mean, (object)flags [, (object)ctype=6]) -> None :
    
    Calculates covariation matrix of a set of vectors.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#calccovarmatrix

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

calcEMD2(...)


calcEMD2( (Mat)signature1, (Mat)signature2, (object)distance_type [, (object)distance_func=None [, (Mat)cost_matrix=Mat() [, (Mat)flow=Mat() [, (object)lower_bound=None [, (object)userdata=None]]]]]) -> object :
    
    Wrapped function:
        cvCalcEMD2
    Argument 'signature1':
        C/C++ type: ::CvArr const *.
        Python type: Mat.
    Argument 'signature2':
        C/C++ type: ::CvArr const *.
        Python type: Mat.
    Argument 'flow':
        C/C++ type: ::CvArr *.
        Python type: Mat.
    Argument 'cost_matrix':
        C/C++ type: ::CvArr const *.
        Python type: Mat.

    C++ signature :
        boost::python::api::object calcEMD2(cv::Mat {lvalue},cv::Mat {lvalue},int [,boost::python::api::object=None [,cv::Mat=Mat() [,cv::Mat=Mat() [,float*=None [,boost::python::api::object=None]]]]])
    'distance_func' is a Python function declared as follows:
        def distance_func((int)a, (int)b, (object)userdata) -> (float)x
    where
        'a' : the address of a C array of C floats representing the first vector
        'b' : the address of a C array of C floats representing the second vector
        'userdata' : the 'userdata' parameter of cvCalcEMD2()
        'x' : the resultant distance

calcGlobalOrientation(...)

calcGlobalOrientation( (Mat)orientation, (Mat)mask, (Mat)mhi, (object)timestamp, (object)duration) -> object :
    
    Wrapped function:
        cvCalcGlobalOrientation
    Argument 'mask':
        C/C++ type: ::CvArr const *.
        Python type: Mat.
    Argument 'orientation':
        C/C++ type: ::CvArr const *.
        Python type: Mat.
    Argument 'mhi':
        C/C++ type: ::CvArr const *.
        Python type: Mat.

    C++ signature :
        boost::python::api::object calcGlobalOrientation(cv::Mat {lvalue},cv::Mat {lvalue},cv::Mat {lvalue},double,double)

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

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

calcHist(...)

calcHist( (list)images, (Mat)channels, (Mat)mask, (SparseMat)hist, (Mat)histSize, (object)ranges [, (bool)uniform=True [, (bool)accumulate=False]]) -> None :
    
    Argument 'ranges':
        C/C++ type: float const * *.
        Python type: list of Mat.
    Argument 'histSize':
        C/C++ type: int const *.
        Python type: Mat.
        Invoke asMat() to convert a 1D Python sequence into a Mat, e.g. 
        asMat([0,1,2]) or asMat((0,1,2)).
    Argument 'channels':
        C/C++ type: int const *.
        Python type: Mat.
        Invoke asMat() to convert a 1D Python sequence into a Mat, e.g. 
        asMat([0,1,2]) or asMat((0,1,2)).
    Argument 'dims':
        Dependent argument: omitted from the function's calling sequence, as 
        its value is derived from argument 'histSize'.
    Argument 'images':
        C/C++ type: ::cv::Mat const *.
        Python type: list of Mat, e.g. [Mat(), Mat(), Mat()].
    Argument 'nimages':
        Dependent argument: omitted from the function's calling sequence, as 
        its value is derived from argument 'images'.

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

calcHist( (list)images, (Mat)channels, (Mat)mask, (MatND)hist, (Mat)histSize, (object)ranges [, (bool)uniform=True [, (bool)accumulate=False]]) -> None :
    
    Argument 'ranges':
        C/C++ type: float const * *.
        Python type: list of Mat.
    Argument 'histSize':
        C/C++ type: int const *.
        Python type: Mat.
        Invoke asMat() to convert a 1D Python sequence into a Mat, e.g. 
        asMat([0,1,2]) or asMat((0,1,2)).
    Argument 'channels':
        C/C++ type: int const *.
        Python type: Mat.
        Invoke asMat() to convert a 1D Python sequence into a Mat, e.g. 
        asMat([0,1,2]) or asMat((0,1,2)).
    Argument 'dims':
        Dependent argument: omitted from the function's calling sequence, as 
        its value is derived from argument 'histSize'.
    Argument 'images':
        C/C++ type: ::cv::Mat const *.
        Python type: list of Mat, e.g. [Mat(), Mat(), Mat()].
    Argument 'nimages':
        Dependent argument: omitted from the function's calling sequence, as 
        its value is derived from argument 'images'.

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

calcImageHomography(...)

calcImageHomography( (object)line, (CvPoint3D32f)center, (object)intrinsic) -> object :
    
    Wrapped function:
        cvCalcImageHomography

    C++ signature :
        boost::python::api::object calcImageHomography(boost::python::api::object,CvPoint3D32f*,boost::python::api::object)

calcMotionGradient(...)

calcMotionGradient( (Mat)mhi, (Mat)mask, (Mat)orientation, (object)delta1, (object)delta2 [, (object)aperture_size=3]) -> None :
    
    Wrapped function:
        cvCalcMotionGradient
    Argument 'mask':
        C/C++ type: ::CvArr *.
        Python type: Mat.
    Argument 'orientation':
        C/C++ type: ::CvArr *.
        Python type: Mat.
    Argument 'mhi':
        C/C++ type: ::CvArr const *.
        Python type: Mat.

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

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

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

calcOpticalFlowBM(...)

calcOpticalFlowBM( (Mat)prev, (Mat)curr, (Size2i)block_size, (Size2i)shift_size, (Size2i)max_range, (object)use_previous, (Mat)velx, (Mat)vely) -> None :
    
    Wrapped function:
        cvCalcOpticalFlowBM
    Argument 'max_range':
        C/C++ type: ::CvSize.
        Python type: Size2i.
    Argument 'prev':
        C/C++ type: ::CvArr const *.
        Python type: Mat.
    Argument 'curr':
        C/C++ type: ::CvArr const *.
        Python type: Mat.
    Argument 'shift_size':
        C/C++ type: ::CvSize.
        Python type: Size2i.
    Argument 'vely':
        C/C++ type: ::CvArr *.
        Python type: Mat.
    Argument 'velx':
        C/C++ type: ::CvArr *.
        Python type: Mat.
    Argument 'block_size':
        C/C++ type: ::CvSize.
        Python type: Size2i.

    C++ signature :
        void calcOpticalFlowBM(cv::Mat {lvalue},cv::Mat {lvalue},cv::Size_<int>,cv::Size_<int>,cv::Size_<int>,int,cv::Mat {lvalue},cv::Mat {lvalue})

calcOpticalFlowFarneback(...)

calcOpticalFlowFarneback( (Mat)prev, (Mat)next, (Mat)flow, (object)pyr_scale, (object)levels, (object)winsize, (object)iterations, (object)poly_n, (object)poly_sigma, (object)flags) -> None :
    
    Wrapped function:
        cvCalcOpticalFlowFarneback
    Argument 'prev':
        C/C++ type: ::CvArr const *.
        Python type: Mat.
    Argument 'flow':
        C/C++ type: ::CvArr *.
        Python type: Mat.
    Argument 'next':
        C/C++ type: ::CvArr const *.
        Python type: Mat.

    C++ signature :
        void calcOpticalFlowFarneback(cv::Mat {lvalue},cv::Mat {lvalue},cv::Mat {lvalue},double,int,int,int,int,double,int)

calcOpticalFlowFarneback( (Mat)prev0, (Mat)next0, (Mat)flow0, (object)pyr_scale, (object)levels, (object)winsize, (object)iterations, (object)poly_n, (object)poly_sigma, (object)flags) -> None :

    C++ signature :
        void calcOpticalFlowFarneback(cv::Mat,cv::Mat,cv::Mat {lvalue},double,int,int,int,int,double,int)

calcOpticalFlowHS(...)

calcOpticalFlowHS( (Mat)prev, (Mat)curr, (object)use_previous, (Mat)velx, (Mat)vely, (object)lambda, (TermCriteria)criteria) -> None :
    
    Wrapped function:
        cvCalcOpticalFlowHS
    Argument 'criteria':
        C/C++ type: ::CvTermCriteria.
        Python type: TermCriteria.
    Argument 'prev':
        C/C++ type: ::CvArr const *.
        Python type: Mat.
    Argument 'curr':
        C/C++ type: ::CvArr const *.
        Python type: Mat.
    Argument 'vely':
        C/C++ type: ::CvArr *.
        Python type: Mat.
    Argument 'velx':
        C/C++ type: ::CvArr *.
        Python type: Mat.

    C++ signature :
        void calcOpticalFlowHS(cv::Mat {lvalue},cv::Mat {lvalue},int,cv::Mat {lvalue},cv::Mat {lvalue},double,cv::TermCriteria)

calcOpticalFlowLK(...)

calcOpticalFlowLK( (Mat)prev, (Mat)curr, (Size2i)win_size, (Mat)velx, (Mat)vely) -> None :
    
    Wrapped function:
        cvCalcOpticalFlowLK
    Argument 'prev':
        C/C++ type: ::CvArr const *.
        Python type: Mat.
    Argument 'curr':
        C/C++ type: ::CvArr const *.
        Python type: Mat.
    Argument 'vely':
        C/C++ type: ::CvArr *.
        Python type: Mat.
    Argument 'win_size':
        C/C++ type: ::CvSize.
        Python type: Size2i.
    Argument 'velx':
        C/C++ type: ::CvArr *.
        Python type: Mat.

    C++ signature :
        void calcOpticalFlowLK(cv::Mat {lvalue},cv::Mat {lvalue},cv::Size_<int>,cv::Mat {lvalue},cv::Mat {lvalue})

calcOpticalFlowPyrLK(...)

calcOpticalFlowPyrLK( (Mat)prevImg, (Mat)nextImg, (Mat)prevPts, (Mat)nextPts, (Mat)status, (Mat)err [, (Size2i)winSize=Size2i(width=15, height=15) [, (object)maxLevel=3 [, (TermCriteria)criteria=TermCriteria(type=3, maxCount=30, epsilon=0.01) [, (object)derivLambda=0.5 [, (object)flags=0]]]]]) -> None :
    
    Argument 'status':
        C/C++ type: ::std::vector< unsigned char > &.
        Python type: Mat.
        Invoke asMat() to convert a 1D Python sequence into a Mat, e.g. 
        asMat([0,1,2]) or asMat((0,1,2)).
    Argument 'nextPts':
        C/C++ type: ::std::vector< cv::Point_<float> > &.
        Python type: Mat.
        Invoke asMat() to convert a 1D Python sequence into a Mat, e.g. 
        asMat([0,1,2]) or asMat((0,1,2)).
    Argument 'prevPts':
        C/C++ type: ::std::vector< cv::Point_<float> > const &.
        Python type: Mat.
        Invoke asMat() to convert a 1D Python sequence into a Mat, e.g. 
        asMat([0,1,2]) or asMat((0,1,2)).
    Argument 'err':
        C/C++ type: ::std::vector< float > &.
        Python type: Mat.
        Invoke asMat() to convert a 1D Python sequence into a Mat, e.g. 
        asMat([0,1,2]) or asMat((0,1,2)).

    C++ signature :
        void calcOpticalFlowPyrLK(cv::Mat,cv::Mat,cv::Mat,cv::Mat {lvalue},cv::Mat {lvalue},cv::Mat {lvalue} [,cv::Size_<int>=Size2i(width=15, height=15) [,int=3 [,cv::TermCriteria=TermCriteria(type=3, maxCount=30, epsilon=0.01) [,double=0.5 [,int=0]]]]])

calcOpticalFlowPyrLK( (Mat)prev, (Mat)curr, (Mat)prev_pyr, (Mat)curr_pyr, (list)prev_features, (Size2i)win_size, (object)level, (TermCriteria)criteria, (object)flags) -> tuple :
    
    Wrapped function:
        cvCalcOpticalFlowPyrLK
    Argument 'count':
        Dependent argument: omitted from the function's calling sequence, as 
        its value is derived from argument 'prev_features'.
    Argument 'status':
        Output argument: omitted from the function's calling sequence, and is 
        returned along with the function's return value (if any).
    Argument 'prev':
        C/C++ type: ::CvArr const *.
        Python type: Mat.
    Argument 'curr':
        C/C++ type: ::CvArr const *.
        Python type: Mat.
    Argument 'track_error':
        Output argument: omitted from the function's calling sequence, and is 
        returned along with the function's return value (if any).
    Argument 'prev_pyr':
        C/C++ type: ::CvArr *.
        Python type: Mat.
    Argument 'prev_features':
        C/C++ type: ::CvPoint2D32f const *.
        Python type: Python sequence with elements of C++ type 
        '::CvPoint2D32f'.
    Argument 'criteria':
        C/C++ type: ::CvTermCriteria.
        Python type: TermCriteria.
    Argument 'curr_features':
        Output argument: omitted from the function's calling sequence, and is 
        returned along with the function's return value (if any).
    Argument 'curr_pyr':
        C/C++ type: ::CvArr *.
        Python type: Mat.
    Argument 'win_size':
        C/C++ type: ::CvSize.
        Python type: Size2i.

    C++ signature :
        boost::python::tuple calcOpticalFlowPyrLK(cv::Mat {lvalue},cv::Mat {lvalue},cv::Mat {lvalue},cv::Mat {lvalue},boost::python::list,cv::Size_<int>,int,cv::TermCriteria,int)

calcSubdivVoronoi2D(...)

calcSubdivVoronoi2D( (CvSubdiv2D)subdiv) -> None :
    
    Wrapped function:
        cvCalcSubdivVoronoi2D

    C++ signature :
        void calcSubdivVoronoi2D(CvSubdiv2D*)

calibrateCamera(...)

calibrateCamera( (list)objectPoints, (list)imagePoints, (Size2i)imageSize, (Mat)cameraMatrix, (Mat)distCoeffs [, (object)flags=0]) -> tuple :
    
    Argument 'tvecs':
        C/C++ type: ::std::vector< cv::Mat > &.
        Python type: list of Mat, e.g. [Mat(), Mat(), Mat()].
        Output argument: omitted from the function's calling sequence, and is 
        returned along with the function's return value (if any).
    Argument 'objectPoints':
        C/C++ type: ::std::vector< std::vector< cv::Point3_<float> > > const 
        &.
        Python type: list of Mat, e.g. [Mat(), Mat(), Mat()].
        Invoke asMat() to convert every 1D Python sequence into a Mat, e.g. 
        [asMat([0,1,2]), asMat((0,1,2)].
    Argument 'rvecs':
        C/C++ type: ::std::vector< cv::Mat > &.
        Python type: list of Mat, e.g. [Mat(), Mat(), Mat()].
        Output argument: omitted from the function's calling sequence, and is 
        returned along with the function's return value (if any).
    Argument 'imagePoints':
        C/C++ type: ::std::vector< std::vector< cv::Point_<float> > > const &.
        Python type: list of Mat, e.g. [Mat(), Mat(), Mat()].
        Invoke asMat() to convert every 1D Python sequence into a Mat, e.g. 
        [asMat([0,1,2]), asMat((0,1,2)].

    C++ signature :
        boost::python::tuple calibrateCamera(boost::python::list,boost::python::list,cv::Size_<int>,cv::Mat {lvalue},cv::Mat {lvalue} [,int=0])

calibrationMatrixValues(...)

calibrationMatrixValues( (Mat)cameraMatrix, (Size2i)imageSize, (object)apertureWidth, (object)apertureHeight, (object)fovx, (object)fovy, (object)focalLength, (Point2d)principalPoint, (object)aspectRatio) -> None :

    C++ signature :
        void calibrationMatrixValues(cv::Mat,cv::Size_<int>,double,double,double {lvalue},double {lvalue},double {lvalue},cv::Point_<double> {lvalue},double {lvalue})

cartToPolar(...)

cartToPolar( (Mat)x, (Mat)y, (Mat)magnitude, (Mat)angle [, (bool)angleInDegrees=False]) -> None :
    
    Calculates the magnitude and angle of 2d vectors.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#carttopolar

    C++ signature :
        void cartToPolar(cv::Mat,cv::Mat,cv::Mat {lvalue},cv::Mat {lvalue} [,bool=False])

ceil(...)

ceil( (object)value) -> int :
    
    Wrapped function:
        cvCeil

    C++ signature :
        int ceil(double)

checkChessboard(...)

checkChessboard( (Mat)src, (Size2i)size) -> object :
    
    Wrapped function:
        cvCheckChessboard
    Argument 'src':
        C/C++ type: ::IplImage *.
        Python type: Mat.
    Argument 'size':
        C/C++ type: ::CvSize.
        Python type: Size2i.

    C++ signature :
        boost::python::api::object checkChessboard(cv::Mat {lvalue},cv::Size_<int>)

checkHardwareSupport(...)

checkHardwareSupport( (object)feature) -> bool :

    C++ signature :
        bool checkHardwareSupport(int)

checkRange(...)

checkRange( (MatND)a [, (bool)quiet=True [, (object)minVal=-1.7976931348623157e+308 [, (object)maxVal=1.7976931348623157e+308]]]) -> tuple :
    
    Checks every element of an input array for invalid values.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#checkrange
    Argument 'idx':
        C/C++ type: int *.
        Python type: Python equivalence of the C/C++ type without pointer.
        Output argument: omitted from the function's calling sequence, and is 
        returned along with the function's return value (if any).

    C++ signature :
        boost::python::tuple checkRange(cv::MatND [,bool=True [,double=-1.7976931348623157e+308 [,double=1.7976931348623157e+308]]])

checkRange( (Mat)a [, (bool)quiet=True [, (object)minVal=-1.7976931348623157e+308 [, (object)maxVal=1.7976931348623157e+308]]]) -> tuple :
    
    Checks every element of an input array for invalid values.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#checkrange
    Argument 'pt':
        C/C++ type: ::cv::Point *.
        Python type: Python equivalence of the C/C++ type without pointer.
        Output argument: omitted from the function's calling sequence, and is 
        returned along with the function's return value (if any).

    C++ signature :
        boost::python::tuple checkRange(cv::Mat [,bool=True [,double=-1.7976931348623157e+308 [,double=1.7976931348623157e+308]]])

circle(...)

circle( (Mat)img, (Point2i)center, (object)radius, (Scalar)color [, (object)thickness=1 [, (object)lineType=8 [, (object)shift=0]]]) -> None :
    
    Draws a circle.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/drawing_functions.html#cv-circle

    C++ signature :
        void circle(cv::Mat {lvalue},cv::Point_<int>,int,cv::Scalar_<double> [,int=1 [,int=8 [,int=0]]])

clearMemStorage(...)

clearMemStorage( (MemStorage)storage) -> None :
    
    Wrapped function:
        cvClearMemStorage
    Argument 'storage':
        C/C++ type: ::CvMemStorage *.
        Python type: MemStorage.

    C++ signature :
        void clearMemStorage(cv::Ptr<CvMemStorage> {lvalue})

clearSet(...)

clearSet( (CvSet)set_header) -> None :
    
    Wrapped function:
        cvClearSet

    C++ signature :
        void clearSet(CvSet*)

clearSubdivVoronoi2D(...)

clearSubdivVoronoi2D( (CvSubdiv2D)subdiv) -> None :
    
    Wrapped function:
        cvClearSubdivVoronoi2D

    C++ signature :
        void clearSubdivVoronoi2D(CvSubdiv2D*)

clipLine(...)

clipLine( (Rect)img_rect, (Point2i)pt1, (Point2i)pt2) -> bool :
    
    Clips the line against the image rectangle.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/drawing_functions.html#cv-clipline

    C++ signature :
        bool clipLine(cv::Rect_<int>,cv::Point_<int> {lvalue},cv::Point_<int> {lvalue})

clipLine( (Size2i)imgSize, (Point2i)pt1, (Point2i)pt2) -> bool :
    
    Clips the line against the image rectangle.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/drawing_functions.html#cv-clipline

    C++ signature :
        bool clipLine(cv::Size_<int>,cv::Point_<int> {lvalue},cv::Point_<int> {lvalue})

cloneSeq(...)

cloneSeq( (CvSeq)seq [, (MemStorage)storage=<pyopencv.pyopencvext.MemStorage object at 0x0340B330>]) -> object :
    
    Wrapped function:
        cvCloneSeq
    Argument 'storage':
        C/C++ type: ::CvMemStorage *.
        Python type: MemStorage.

    C++ signature :
        boost::python::api::object cloneSeq(CvSeq const* [,cv::Ptr<CvMemStorage>=<pyopencv.pyopencvext.MemStorage object at 0x0340B330>])

compare(...)

compare( (MatND)a, (object)s, (MatND)c, (object)cmpop) -> None :
    
    Performs per-element comparison of two arrays or an array and scalar 
    value.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#compare

    C++ signature :
        void compare(cv::MatND,double,cv::MatND {lvalue},int)

compare( (MatND)a, (MatND)b, (MatND)c, (object)cmpop) -> None :
    
    Performs per-element comparison of two arrays or an array and scalar 
    value.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#compare

    C++ signature :
        void compare(cv::MatND,cv::MatND,cv::MatND {lvalue},int)

compare( (Mat)a, (object)s, (Mat)c, (object)cmpop) -> None :
    
    Performs per-element comparison of two arrays or an array and scalar 
    value.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#compare

    C++ signature :
        void compare(cv::Mat,double,cv::Mat {lvalue},int)

compare( (Mat)a, (Mat)b, (Mat)c, (object)cmpop) -> None :
    
    Performs per-element comparison of two arrays or an array and scalar 
    value.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#compare

    C++ signature :
        void compare(cv::Mat,cv::Mat,cv::Mat {lvalue},int)

compareHist(...)

compareHist( (SparseMat)H1, (SparseMat)H2, (object)method) -> float :

    C++ signature :
        double compareHist(cv::SparseMat,cv::SparseMat,int)

compareHist( (MatND)H1, (MatND)H2, (object)method) -> float :

    C++ signature :
        double compareHist(cv::MatND,cv::MatND,int)

completeSymm(...)

completeSymm( (Mat)a [, (bool)lowerToUpper=False]) -> None :
    
    Copies the lower or the upper half of a square matrix to another half.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#completesymm

    C++ signature :
        void completeSymm(cv::Mat {lvalue} [,bool=False])

composeRT(...)

composeRT( (Mat)rvec1, (Mat)tvec1, (Mat)rvec2, (Mat)tvec2, (Mat)rvec3, (Mat)tvec3, (Mat)dr3dr1, (Mat)dr3dt1, (Mat)dr3dr2, (Mat)dr3dt2, (Mat)dt3dr1, (Mat)dt3dt1, (Mat)dt3dr2, (Mat)dt3dt2) -> None :

    C++ signature :
        void composeRT(cv::Mat,cv::Mat,cv::Mat,cv::Mat,cv::Mat {lvalue},cv::Mat {lvalue},cv::Mat {lvalue},cv::Mat {lvalue},cv::Mat {lvalue},cv::Mat {lvalue},cv::Mat {lvalue},cv::Mat {lvalue},cv::Mat {lvalue},cv::Mat {lvalue})

composeRT( (Mat)rvec1, (Mat)tvec1, (Mat)rvec2, (Mat)tvec2, (Mat)rvec3, (Mat)tvec3) -> None :

    C++ signature :
        void composeRT(cv::Mat,cv::Mat,cv::Mat,cv::Mat,cv::Mat {lvalue},cv::Mat {lvalue})

computeCorrespondEpilines(...)

computeCorrespondEpilines( (Mat)points1, (object)whichImage, (Mat)F) -> object :
    
    Argument 'lines':
        C/C++ type: ::std::vector< cv::Vec<float, 3> > &.
        Python type: Mat.
        Invoke asMat() to convert a 1D Python sequence into a Mat, e.g. 
        asMat([0,1,2]) or asMat((0,1,2)).
        Output argument: omitted from the function's calling sequence, and is 
        returned along with the function's return value (if any).

    C++ signature :
        boost::python::api::object computeCorrespondEpilines(cv::Mat,int,cv::Mat)

conDensInitSampleSet(...)

conDensInitSampleSet( (CvConDensation)condens, (Mat)lower_bound, (Mat)upper_bound) -> None :
    
    Wrapped function:
        cvConDensInitSampleSet
    Argument 'lower_bound':
        C/C++ type: ::CvMat *.
        Python type: Mat.
    Argument 'upper_bound':
        C/C++ type: ::CvMat *.
        Python type: Mat.

    C++ signature :
        void conDensInitSampleSet(CvConDensation*,cv::Mat {lvalue},cv::Mat {lvalue})

conDensUpdateByTime(...)

conDensUpdateByTime( (CvConDensation)condens) -> None :
    
    Wrapped function:
        cvConDensUpdateByTime

    C++ signature :
        void conDensUpdateByTime(CvConDensation*)

contourArea(...)

contourArea( (Mat)contour [, (bool)oriented=False]) -> float :

    C++ signature :
        double contourArea(cv::Mat [,bool=False])

contourFromContourTree(...)

contourFromContourTree( (CvContourTree)tree, (MemStorage)storage, (TermCriteria)criteria) -> object :
    
    Wrapped function:
        cvContourFromContourTree
    Argument 'storage':
        C/C++ type: ::CvMemStorage *.
        Python type: MemStorage.
    Argument 'criteria':
        C/C++ type: ::CvTermCriteria.
        Python type: TermCriteria.

    C++ signature :
        boost::python::api::object contourFromContourTree(CvContourTree const*,cv::Ptr<CvMemStorage> {lvalue},cv::TermCriteria)

convertImage(...)

convertImage( (Mat)src, (Mat)dst [, (object)flags=0]) -> None :
    
    Converts one image to another with an optional vertical flip.
    Wrapped function:
        cvConvertImage
    Reference:
        http://opencv.willowgarage.com/documentation/c/user_interface.html#convertimage#convertimage
    Argument 'src':
        C/C++ type: ::CvArr const *.
        Python type: Mat.
    Argument 'dst':
        C/C++ type: ::CvArr *.
        Python type: Mat.

    C++ signature :
        void convertImage(cv::Mat {lvalue},cv::Mat {lvalue} [,int=0])

convertMaps(...)

convertMaps( (Mat)map1, (Mat)map2, (Mat)dstmap1, (Mat)dstmap2, (object)dstmap1type [, (bool)nninterpolation=False]) -> None :

    C++ signature :
        void convertMaps(cv::Mat,cv::Mat,cv::Mat {lvalue},cv::Mat {lvalue},int [,bool=False])

convertPointsHomogeneous2D(...)

convertPointsHomogeneous2D( (Mat)src) -> object :
    
    Wrapped function:
        convertPointsHomogeneous
    Argument 'dst':
        C/C++ type: ::std::vector< cv::Point_<float> > &.
        Python type: Mat.
        Invoke asMat() to convert a 1D Python sequence into a Mat, e.g. 
        asMat([0,1,2]) or asMat((0,1,2)).
        Output argument: omitted from the function's calling sequence, and is 
        returned along with the function's return value (if any).

    C++ signature :
        boost::python::api::object convertPointsHomogeneous2D(cv::Mat)

convertPointsHomogeneous3D(...)

convertPointsHomogeneous3D( (Mat)src) -> object :
    
    Wrapped function:
        convertPointsHomogeneous
    Argument 'dst':
        C/C++ type: ::std::vector< cv::Point3_<float> > &.
        Python type: Mat.
        Invoke asMat() to convert a 1D Python sequence into a Mat, e.g. 
        asMat([0,1,2]) or asMat((0,1,2)).
        Output argument: omitted from the function's calling sequence, and is 
        returned along with the function's return value (if any).

    C++ signature :
        boost::python::api::object convertPointsHomogeneous3D(cv::Mat)

convertScaleAbs(...)

convertScaleAbs( (Mat)a, (Mat)c [, (object)alpha=1 [, (object)beta=0]]) -> None :
    
    Scales, computes absolute values and converts the result to 8-bit.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#convertscaleabs

    C++ signature :
        void convertScaleAbs(cv::Mat,cv::Mat {lvalue} [,double=1 [,double=0]])

convexHullIdx(...)

convexHullIdx( (Mat)points [, (bool)clockwise=False]) -> object :
    
    Wrapped function:
        convexHull
    Argument 'hull':
        C/C++ type: ::std::vector< int > &.
        Python type: Mat.
        Invoke asMat() to convert a 1D Python sequence into a Mat, e.g. 
        asMat([0,1,2]) or asMat((0,1,2)).
        Output argument: omitted from the function's calling sequence, and is 
        returned along with the function's return value (if any).

    C++ signature :
        boost::python::api::object convexHullIdx(cv::Mat [,bool=False])

convexHull_float32(...)

convexHull_float32( (Mat)points [, (bool)clockwise=False]) -> object :
    
    Wrapped function:
        convexHull
    Argument 'hull':
        C/C++ type: ::std::vector< cv::Point_<float> > &.
        Python type: Mat.
        Invoke asMat() to convert a 1D Python sequence into a Mat, e.g. 
        asMat([0,1,2]) or asMat((0,1,2)).
        Output argument: omitted from the function's calling sequence, and is 
        returned along with the function's return value (if any).

    C++ signature :
        boost::python::api::object convexHull_float32(cv::Mat [,bool=False])

convexHull_int(...)

convexHull_int( (Mat)points [, (bool)clockwise=False]) -> object :
    
    Wrapped function:
        convexHull
    Argument 'hull':
        C/C++ type: ::std::vector< cv::Point_<int> > &.
        Python type: Mat.
        Invoke asMat() to convert a 1D Python sequence into a Mat, e.g. 
        asMat([0,1,2]) or asMat((0,1,2)).
        Output argument: omitted from the function's calling sequence, and is 
        returned along with the function's return value (if any).

    C++ signature :
        boost::python::api::object convexHull_int(cv::Mat [,bool=False])

convexityDefects(...)

convexityDefects( (Mat)contour, (Mat)convexhull [, (MemStorage)storage=<pyopencv.pyopencvext.MemStorage object at 0x0340B370>]) -> object :
    
    Wrapped function:
        cvConvexityDefects
    Argument 'storage':
        C/C++ type: ::CvMemStorage *.
        Python type: MemStorage.
    Argument 'contour':
        C/C++ type: ::CvArr const *.
        Python type: Mat.
    Argument 'convexhull':
        C/C++ type: ::CvArr const *.
        Python type: Mat.

    C++ signature :
        boost::python::api::object convexityDefects(cv::Mat {lvalue},cv::Mat {lvalue} [,cv::Ptr<CvMemStorage>=<pyopencv.pyopencvext.MemStorage object at 0x0340B370>])

copyMakeBorder(...)

copyMakeBorder( (Mat)src, (Mat)dst, (object)top, (object)bottom, (object)left, (object)right, (object)borderType [, (Scalar)value=Scalar([ 0.  0.  0.  0.])]) -> None :

    C++ signature :
        void copyMakeBorder(cv::Mat,cv::Mat {lvalue},int,int,int,int,int [,cv::Scalar_<double>=Scalar([ 0.  0.  0.  0.])])

cornerEigenValsAndVecs(...)

cornerEigenValsAndVecs( (Mat)src, (Mat)dst, (object)blockSize, (object)ksize [, (object)borderType=4]) -> None :

    C++ signature :
        void cornerEigenValsAndVecs(cv::Mat,cv::Mat {lvalue},int,int [,int=4])

cornerHarris(...)

cornerHarris( (Mat)src, (Mat)dst, (object)blockSize, (object)ksize, (object)k [, (object)borderType=4]) -> None :

    C++ signature :
        void cornerHarris(cv::Mat,cv::Mat {lvalue},int,int,double [,int=4])

cornerMinEigenVal(...)

cornerMinEigenVal( (Mat)src, (Mat)dst, (object)blockSize [, (object)ksize=3 [, (object)borderType=4]]) -> None :

    C++ signature :
        void cornerMinEigenVal(cv::Mat,cv::Mat {lvalue},int [,int=3 [,int=4]])

cornerSubPix(...)

cornerSubPix( (Mat)image, (Mat)corners, (Size2i)winSize, (Size2i)zeroZone, (TermCriteria)criteria) -> None :
    
    Argument 'corners':
        C/C++ type: ::std::vector< cv::Point_<float> > &.
        Python type: Mat.
        Invoke asMat() to convert a 1D Python sequence into a Mat, e.g. 
        asMat([0,1,2]) or asMat((0,1,2)).

    C++ signature :
        void cornerSubPix(cv::Mat,cv::Mat {lvalue},cv::Size_<int>,cv::Size_<int>,cv::TermCriteria)

correctMatches(...)

correctMatches( (Mat)F, (Mat)points1, (Mat)points2, (Mat)new_points1, (Mat)new_points2) -> None :
    
    Wrapped function:
        cvCorrectMatches
    Argument 'points1':
        C/C++ type: ::CvMat *.
        Python type: Mat.
    Argument 'points2':
        C/C++ type: ::CvMat *.
        Python type: Mat.
    Argument 'new_points2':
        C/C++ type: ::CvMat *.
        Python type: Mat.
    Argument 'new_points1':
        C/C++ type: ::CvMat *.
        Python type: Mat.
    Argument 'F':
        C/C++ type: ::CvMat *.
        Python type: Mat.

    C++ signature :
        void correctMatches(cv::Mat {lvalue},cv::Mat {lvalue},cv::Mat {lvalue},cv::Mat {lvalue},cv::Mat {lvalue})

countNonZero(...)

countNonZero( (MatND)m) -> int :
    
    Counts non-zero array elements.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#countnonzero

    C++ signature :
        int countNonZero(cv::MatND)

countNonZero( (Mat)m) -> int :
    
    Counts non-zero array elements.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#countnonzero

    C++ signature :
        int countNonZero(cv::Mat)

createBoxFilter(...)

createBoxFilter( (object)srcType, (object)dstType, (Size2i)ksize [, (Point2i)anchor=Point2i(x=-1, y=-1) [, (bool)normalize=True [, (object)borderType=4]]]) -> Ptr_FilterEngine :

    C++ signature :
        cv::Ptr<cv::FilterEngine> createBoxFilter(int,int,cv::Size_<int> [,cv::Point_<int>=Point2i(x=-1, y=-1) [,bool=True [,int=4]]])

createChildMemStorage(...)

createChildMemStorage( (MemStorage)parent) -> MemStorage :

    C++ signature :
        cv::Ptr<CvMemStorage> createChildMemStorage(cv::Ptr<CvMemStorage> {lvalue})

createConDensation(...)

createConDensation( (object)dynam_params, (object)measure_params, (object)sample_count) -> CvConDensation :
    
    Wrapped function:
        cvCreateConDensation

    C++ signature :
        CvConDensation* createConDensation(int,int,int)

createContourTree(...)

createContourTree( (CvSeq)contour, (MemStorage)storage, (object)threshold) -> object :
    
    Wrapped function:
        cvCreateContourTree
    Argument 'storage':
        C/C++ type: ::CvMemStorage *.
        Python type: MemStorage.

    C++ signature :
        boost::python::api::object createContourTree(CvSeq const*,cv::Ptr<CvMemStorage> {lvalue},double)

createDerivFilter(...)

createDerivFilter( (object)srcType, (object)dstType, (object)dx, (object)dy, (object)ksize [, (object)borderType=4]) -> Ptr_FilterEngine :

    C++ signature :
        cv::Ptr<cv::FilterEngine> createDerivFilter(int,int,int,int,int [,int=4])

createGaussianFilter(...)

createGaussianFilter( (object)type, (Size2i)ksize, (object)sigma1 [, (object)sigma2=0 [, (object)borderType=4]]) -> Ptr_FilterEngine :

    C++ signature :
        cv::Ptr<cv::FilterEngine> createGaussianFilter(int,cv::Size_<int>,double [,double=0 [,int=4]])

createKDTree(...)

createKDTree( (Mat)desc) -> object :
    
    Wrapped function:
        cvCreateKDTree
    Argument 'desc':
        C/C++ type: ::CvMat *.
        Python type: Mat.

    C++ signature :
        boost::python::api::object createKDTree(cv::Mat {lvalue})

createLSH(...)

createLSH( (CvLSHOperations)ops, (object)d [, (object)L=10 [, (object)k=10 [, (object)type=6 [, (object)r=4 [, (long)seed=-1L]]]]]) -> CvLSH :
    
    Wrapped function:
        cvCreateLSH

    C++ signature :
        CvLSH* createLSH(CvLSHOperations*,int [,int=10 [,int=10 [,int=6 [,double=4 [,long long=-1L]]]]])

createLinearFilter(...)

createLinearFilter( (object)srcType, (object)dstType, (Mat)kernel [, (Point2i)_anchor=Point2i(x=-1, y=-1) [, (object)delta=0 [, (object)_rowBorderType=4 [, (object)_columnBorderType=-1 [, (Scalar)_borderValue=Scalar([ 0.  0.  0.  0.])]]]]]) -> Ptr_FilterEngine :

    C++ signature :
        cv::Ptr<cv::FilterEngine> createLinearFilter(int,int,cv::Mat [,cv::Point_<int>=Point2i(x=-1, y=-1) [,double=0 [,int=4 [,int=-1 [,cv::Scalar_<double>=Scalar([ 0.  0.  0.  0.])]]]]])

createMemStorage(...)

createMemStorage([  (object)block_size=0]) -> MemStorage :

    C++ signature :
        cv::Ptr<CvMemStorage> createMemStorage([ int=0])

createMemoryLSH(...)

createMemoryLSH( (object)d, (object)n [, (object)L=10 [, (object)k=10 [, (object)type=6 [, (object)r=4 [, (long)seed=-1L]]]]]) -> CvLSH :
    
    Wrapped function:
        cvCreateMemoryLSH

    C++ signature :
        CvLSH* createMemoryLSH(int,int [,int=10 [,int=10 [,int=6 [,double=4 [,long long=-1L]]]]])

createMorphologyFilter(...)

createMorphologyFilter( (object)op, (object)type, (Mat)kernel [, (Point2i)anchor=Point2i(x=-1, y=-1) [, (object)_rowBorderType=0 [, (object)_columnBorderType=-1 [, (Scalar)_borderValue=Scalar([  1.79769313e+308   1.79769313e+308   1.79769313e+308   1.79769313e+308])]]]]) -> Ptr_FilterEngine :

    C++ signature :
        cv::Ptr<cv::FilterEngine> createMorphologyFilter(int,int,cv::Mat [,cv::Point_<int>=Point2i(x=-1, y=-1) [,int=0 [,int=-1 [,cv::Scalar_<double>=Scalar([  1.79769313e+308   1.79769313e+308   1.79769313e+308   1.79769313e+308])]]]])

createPOSITObject(...)

createPOSITObject( (CvPoint3D32f)points, (object)point_count) -> CvPOSITObject :
    
    Wrapped function:
        cvCreatePOSITObject

    C++ signature :
        CvPOSITObject* createPOSITObject(CvPoint3D32f*,int)

createSeparableLinearFilter(...)

createSeparableLinearFilter( (object)srcType, (object)dstType, (Mat)rowKernel, (Mat)columnKernel [, (Point2i)_anchor=Point2i(x=-1, y=-1) [, (object)delta=0 [, (object)_rowBorderType=4 [, (object)_columnBorderType=-1 [, (Scalar)_borderValue=Scalar([ 0.  0.  0.  0.])]]]]]) -> Ptr_FilterEngine :

    C++ signature :
        cv::Ptr<cv::FilterEngine> createSeparableLinearFilter(int,int,cv::Mat,cv::Mat [,cv::Point_<int>=Point2i(x=-1, y=-1) [,double=0 [,int=4 [,int=-1 [,cv::Scalar_<double>=Scalar([ 0.  0.  0.  0.])]]]]])

createSeq(...)

createSeq( (object)seq_flags, (object)header_size, (object)elem_size, (MemStorage)storage) -> object :
    
    Wrapped function:
        cvCreateSeq
    Argument 'storage':
        C/C++ type: ::CvMemStorage *.
        Python type: MemStorage.

    C++ signature :
        boost::python::api::object createSeq(int,int,int,cv::Ptr<CvMemStorage> {lvalue})

createSet(...)

createSet( (object)set_flags, (object)header_size, (object)elem_size, (MemStorage)storage) -> object :
    
    Wrapped function:
        cvCreateSet
    Argument 'storage':
        C/C++ type: ::CvMemStorage *.
        Python type: MemStorage.

    C++ signature :
        boost::python::api::object createSet(int,int,int,cv::Ptr<CvMemStorage> {lvalue})

createSpillTree(...)

createSpillTree( (Mat)raw_data [, (object)naive=50 [, (object)rho=0.69999999999999996 [, (object)tau=0.10000000000000001]]]) -> object :
    
    Wrapped function:
        cvCreateSpillTree
    Argument 'raw_data':
        C/C++ type: ::CvMat const *.
        Python type: Mat.

    C++ signature :
        boost::python::api::object createSpillTree(cv::Mat {lvalue} [,int=50 [,double=0.69999999999999996 [,double=0.10000000000000001]]])

createStereoGCState(...)

createStereoGCState( (object)numberOfDisparities, (object)maxIters) -> CvStereoGCState :
    
    Wrapped function:
        cvCreateStereoGCState

    C++ signature :
        CvStereoGCState* createStereoGCState(int,int)

createSubdiv2D(...)

createSubdiv2D( (object)subdiv_type, (object)header_size, (object)vtx_size, (object)quadedge_size, (MemStorage)storage) -> object :
    
    Wrapped function:
        cvCreateSubdiv2D
    Argument 'storage':
        C/C++ type: ::CvMemStorage *.
        Python type: MemStorage.

    C++ signature :
        boost::python::api::object createSubdiv2D(int,int,int,int,cv::Ptr<CvMemStorage> {lvalue})

createSubdivDelaunay2D(...)

createSubdivDelaunay2D( (Rect)rect, (MemStorage)storage) -> object :
    
    Wrapped function:
        cvCreateSubdivDelaunay2D
    Argument 'storage':
        C/C++ type: ::CvMemStorage *.
        Python type: MemStorage.
    Argument 'rect':
        C/C++ type: ::CvRect.
        Python type: Rect.

    C++ signature :
        boost::python::api::object createSubdivDelaunay2D(cv::Rect_<int>,cv::Ptr<CvMemStorage> {lvalue})

cubeRoot(...)

cubeRoot( (object)val) -> float :
    
    Computes cube root of the argument.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#cv-cuberoot

    C++ signature :
        float cubeRoot(float)

cvtColor(...)

cvtColor( (Mat)src, (Mat)dst, (object)code [, (object)dstCn=0]) -> None :

    C++ signature :
        void cvtColor(cv::Mat,cv::Mat {lvalue},int [,int=0])

dct(...)

dct( (Mat)src, (Mat)dst [, (object)flags=0]) -> None :
    
    Performs a forward or inverse discrete cosine transform of 1D or 2D 
    array.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#cv-dct

    C++ signature :
        void dct(cv::Mat,cv::Mat {lvalue} [,int=0])

decomposeProjectionMatrix(...)

decomposeProjectionMatrix( (Mat)projMatrix, (Mat)cameraMatrix, (Mat)rotMatrix, (Mat)transVect, (Mat)rotMatrixX, (Mat)rotMatrixY, (Mat)rotMatrixZ, (Vec3d)eulerAngles) -> None :

    C++ signature :
        void decomposeProjectionMatrix(cv::Mat,cv::Mat {lvalue},cv::Mat {lvalue},cv::Mat {lvalue},cv::Mat {lvalue},cv::Mat {lvalue},cv::Mat {lvalue},cv::Vec<double, 3> {lvalue})

decomposeProjectionMatrix( (Mat)projMatrix, (Mat)cameraMatrix, (Mat)rotMatrix, (Mat)transVect) -> None :

    C++ signature :
        void decomposeProjectionMatrix(cv::Mat,cv::Mat {lvalue},cv::Mat {lvalue},cv::Mat {lvalue})

detectedBlob(...)

detectedBlob( (object)x, (object)y, (object)w, (object)h [, (object)ID=0 [, (object)response=0.0]]) -> CvDetectedBlob :
    
    Wrapped function:
        cvDetectedBlob

    C++ signature :
        CvDetectedBlob detectedBlob(float,float,float,float [,int=0 [,float=0.0]])

determinant(...)

determinant( (Mat)m) -> float :
    
    Returns determinant of a square floating-point matrix.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#cv-determinant

    C++ signature :
        double determinant(cv::Mat)

dft(...)

dft( (Mat)src, (Mat)dst [, (object)flags=0 [, (object)nonzeroRows=0]]) -> None :
    
    Performs a forward or inverse Discrete Fourier transform of 1D or 2D 
    floating-point array.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#cv-dft

    C++ signature :
        void dft(cv::Mat,cv::Mat {lvalue} [,int=0 [,int=0]])

dilate(...)

dilate( (Mat)src, (Mat)dst, (Mat)kernel [, (Point2i)anchor=Point2i(x=-1, y=-1) [, (object)iterations=1 [, (object)borderType=0 [, (Scalar)borderValue=Scalar([  1.79769313e+308   1.79769313e+308   1.79769313e+308   1.79769313e+308])]]]]) -> None :

    C++ signature :
        void dilate(cv::Mat,cv::Mat {lvalue},cv::Mat [,cv::Point_<int>=Point2i(x=-1, y=-1) [,int=1 [,int=0 [,cv::Scalar_<double>=Scalar([  1.79769313e+308   1.79769313e+308   1.79769313e+308   1.79769313e+308])]]]])

distTransform(...)

distTransform( (Mat)src, (Mat)dst [, (object)distance_type=2 [, (object)mask_size=3 [, (Mat)mask=Mat() [, (Mat)labels=Mat()]]]]) -> None :
    
    Wrapped function:
        cvDistTransform
    Argument 'src':
        C/C++ type: ::CvArr const *.
        Python type: Mat.
    Argument 'dst':
        C/C++ type: ::CvArr *.
        Python type: Mat.
    Argument 'labels':
        C/C++ type: ::CvArr *.
        Python type: Mat.
    Argument 'mask':
        C/C++ type: float const *.
        Python type: Mat.
        Invoke asMat() to convert a 1D Python sequence into a Mat, e.g. 
        asMat([0,1,2]) or asMat((0,1,2)).

    C++ signature :
        void distTransform(cv::Mat {lvalue},cv::Mat {lvalue} [,int=2 [,int=3 [,cv::Mat=Mat() [,cv::Mat=Mat()]]]])

distanceTransform(...)

distanceTransform( (Mat)src, (Mat)dst, (object)distanceType, (object)maskSize) -> None :

    C++ signature :
        void distanceTransform(cv::Mat,cv::Mat {lvalue},int,int)

distanceTransform( (Mat)src, (Mat)dst, (Mat)labels, (object)distanceType, (object)maskSize) -> None :

    C++ signature :
        void distanceTransform(cv::Mat,cv::Mat {lvalue},cv::Mat {lvalue},int,int)

divide(...)

divide( (object)scale, (MatND)b, (MatND)c) -> None :
    
    Performs per-element division of two arrays or a scalar by an array.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#cv-divide

    C++ signature :
        void divide(double,cv::MatND,cv::MatND {lvalue})

divide( (MatND)a, (MatND)b, (MatND)c [, (object)scale=1]) -> None :
    
    Performs per-element division of two arrays or a scalar by an array.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#cv-divide

    C++ signature :
        void divide(cv::MatND,cv::MatND,cv::MatND {lvalue} [,double=1])

divide( (object)scale, (Mat)b, (Mat)c) -> None :
    
    Performs per-element division of two arrays or a scalar by an array.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#cv-divide

    C++ signature :
        void divide(double,cv::Mat,cv::Mat {lvalue})

divide( (Mat)a, (Mat)b, (Mat)c [, (object)scale=1]) -> None :
    
    Performs per-element division of two arrays or a scalar by an array.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#cv-divide

    C++ signature :
        void divide(cv::Mat,cv::Mat,cv::Mat {lvalue} [,double=1])

drawChessboardCorners(...)

drawChessboardCorners( (Mat)image, (Size2i)patternSize, (Mat)corners, (bool)patternWasFound) -> None :

    C++ signature :
        void drawChessboardCorners(cv::Mat {lvalue},cv::Size_<int>,cv::Mat,bool)

drawContours(...)

drawContours( (Mat)image, (list)contours, (object)contourIdx, (Scalar)color [, (object)thickness=1 [, (object)lineType=8 [, (Mat)hierarchy=Mat() [, (object)maxLevel=2147483647 [, (Point2i)offset=Point2i(x=0, y=0)]]]]]) -> None :
    
    Argument 'hierarchy':
        C/C++ type: ::std::vector< cv::Vec<int, 4> > const &.
        Python type: Mat.
        Invoke asMat() to convert a 1D Python sequence into a Mat, e.g. 
        asMat([0,1,2]) or asMat((0,1,2)).
    Argument 'contours':
        C/C++ type: ::std::vector< std::vector< cv::Point_<int> > > const &.
        Python type: list of Mat, e.g. [Mat(), Mat(), Mat()].
        Invoke asMat() to convert every 1D Python sequence into a Mat, e.g. 
        [asMat([0,1,2]), asMat((0,1,2)].

    C++ signature :
        void drawContours(cv::Mat {lvalue},boost::python::list,int,cv::Scalar_<double> [,int=1 [,int=8 [,cv::Mat=Mat() [,int=2147483647 [,cv::Point_<int>=Point2i(x=0, y=0)]]]]])

eigen(...)

eigen( (Mat)a, (Mat)eigenvalues, (Mat)eigenvectors [, (object)lowindex=-1 [, (object)highindex=-1]]) -> bool :
    
    Computes eigenvalues and eigenvectors of a symmetric matrix.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#cv-eigen

    C++ signature :
        bool eigen(cv::Mat,cv::Mat {lvalue},cv::Mat {lvalue} [,int=-1 [,int=-1]])

eigen( (Mat)a, (Mat)eigenvalues [, (object)lowindex=-1 [, (object)highindex=-1]]) -> bool :
    
    Computes eigenvalues and eigenvectors of a symmetric matrix.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#cv-eigen

    C++ signature :
        bool eigen(cv::Mat,cv::Mat {lvalue} [,int=-1 [,int=-1]])

ellipse(...)

ellipse( (Mat)img, (RotatedRect)box, (Scalar)color [, (object)thickness=1 [, (object)lineType=8]]) -> None :

    C++ signature :
        void ellipse(cv::Mat {lvalue},cv::RotatedRect,cv::Scalar_<double> [,int=1 [,int=8]])

ellipse( (Mat)img, (Point2i)center, (Size2i)axes, (object)angle, (object)startAngle, (object)endAngle, (Scalar)color [, (object)thickness=1 [, (object)lineType=8 [, (object)shift=0]]]) -> None :

    C++ signature :
        void ellipse(cv::Mat {lvalue},cv::Point_<int>,cv::Size_<int>,double,double,double,cv::Scalar_<double> [,int=1 [,int=8 [,int=0]]])

ellipse2Poly(...)

ellipse2Poly( (Point2i)center, (Size2i)axes, (object)angle, (object)arcStart, (object)arcEnd, (object)delta, (Mat)pts) -> None :
    
    Approximates an elliptic arc with a polyline.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/drawing_functions.html#cv-ellipse2poly
    Argument 'pts':
        C/C++ type: ::std::vector< cv::Point_<int> > &.
        Python type: Mat.
        Invoke asMat() to convert a 1D Python sequence into a Mat, e.g. 
        asMat([0,1,2]) or asMat((0,1,2)).

    C++ signature :
        void ellipse2Poly(cv::Point_<int>,cv::Size_<int>,int,int,int,int,cv::Mat {lvalue})

endWriteStruct(...)

endWriteStruct( (FileStorage)fs) -> None :
    
    Wrapped function:
        cvEndWriteStruct
    Argument 'fs':
        C/C++ type: ::CvFileStorage *.
        Python type: FileStorage.

    C++ signature :
        void endWriteStruct(cv::FileStorage {lvalue})

equalizeHist(...)

equalizeHist( (Mat)src, (Mat)dst) -> None :

    C++ signature :
        void equalizeHist(cv::Mat,cv::Mat {lvalue})

erode(...)

erode( (Mat)src, (Mat)dst, (Mat)kernel [, (Point2i)anchor=Point2i(x=-1, y=-1) [, (object)iterations=1 [, (object)borderType=0 [, (Scalar)borderValue=Scalar([  1.79769313e+308   1.79769313e+308   1.79769313e+308   1.79769313e+308])]]]]) -> None :

    C++ signature :
        void erode(cv::Mat,cv::Mat {lvalue},cv::Mat [,cv::Point_<int>=Point2i(x=-1, y=-1) [,int=1 [,int=0 [,cv::Scalar_<double>=Scalar([  1.79769313e+308   1.79769313e+308   1.79769313e+308   1.79769313e+308])]]]])

error(...)

error( (object)status, (str)func_name, (str)err_msg, (str)file_name, (object)line) -> None :
    
    Wrapped function:
        cvError

    C++ signature :
        void error(int,char const*,char const*,char const*,int)

errorFromIppStatus(...)

errorFromIppStatus( (object)ipp_status) -> int :
    
    Wrapped function:
        cvErrorFromIppStatus

    C++ signature :
        int errorFromIppStatus(int)

errorStr(...)

errorStr( (object)status) -> str :
    
    Wrapped function:
        cvErrorStr

    C++ signature :
        char const* errorStr(int)

estimateAffine3D(...)

estimateAffine3D( (Mat)from, (Mat)to, (Mat)out, (Mat)outliers [, (object)param1=3.0 [, (object)param2=0.98999999999999999]]) -> object :
    
    Argument 'outliers':
        C/C++ type: ::std::vector< unsigned char > &.
        Python type: Mat.
        Invoke asMat() to convert a 1D Python sequence into a Mat, e.g. 
        asMat([0,1,2]) or asMat((0,1,2)).

    C++ signature :
        boost::python::api::object estimateAffine3D(cv::Mat,cv::Mat,cv::Mat {lvalue},cv::Mat {lvalue} [,double=3.0 [,double=0.98999999999999999]])

estimateRigidTransform(...)

estimateRigidTransform( (Mat)A, (Mat)B, (Mat)M, (object)full_affine) -> object :
    
    Wrapped function:
        cvEstimateRigidTransform
    Argument 'A':
        C/C++ type: ::CvArr const *.
        Python type: Mat.
    Argument 'B':
        C/C++ type: ::CvArr const *.
        Python type: Mat.
    Argument 'M':
        C/C++ type: ::CvMat *.
        Python type: Mat.

    C++ signature :
        boost::python::api::object estimateRigidTransform(cv::Mat {lvalue},cv::Mat {lvalue},cv::Mat {lvalue},int)

exp(...)

exp( (MatND)a, (MatND)b) -> None :
    
    Calculates the exponent of every array element.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#cv-exp

    C++ signature :
        void exp(cv::MatND,cv::MatND {lvalue})

exp( (Mat)a, (Mat)b) -> None :
    
    Calculates the exponent of every array element.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#cv-exp

    C++ signature :
        void exp(cv::Mat,cv::Mat {lvalue})

extractSURF(...)

extractSURF( (Mat)img, (Mat)mask, (Seq_CvSURFPoint)keypoints, (CvSURFParams)params [, (object)useProvidedKeyPts=0]) -> object :
    
    Wrapped function:
        cvExtractSURF
    Argument 'descriptors':
        C/C++ type: ::CvSeq * *.
        Python type: vector_float32.
        Output argument: omitted from the function's calling sequence, and is 
        returned along with the function's return value (if any).
    Argument 'mask':
        C/C++ type: ::CvArr const *.
        Python type: Mat.
    Argument 'storage':
        Dependent argument: omitted from the function's calling sequence, as 
        its value is derived from argument 'keypoints'.
    Argument 'keypoints':
        C/C++ type: ::CvSeq * *.
        Python type: Seq_CvSURFPoint.
    Argument 'img':
        C/C++ type: ::CvArr const *.
        Python type: Mat.

    C++ signature :
        boost::python::api::object extractSURF(cv::Mat {lvalue},cv::Mat {lvalue},cv::Seq<CvSURFPoint> {lvalue},CvSURFParams [,int=0])

fastAtan2(...)

fastAtan2( (object)y, (object)x) -> float :
    
    Calculates the angle of a 2D vector in degrees.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#cv-fastatan2

    C++ signature :
        float fastAtan2(float,float)

fillConvexPoly(...)

fillConvexPoly( (Mat)img, (list)pts, (Scalar)color [, (object)lineType=8 [, (object)shift=0]]) -> None :
    
    Fills a convex polygon.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/drawing_functions.html#cv-fillconvexpoly
    Argument 'npts':
        Dependent argument: omitted from the function's calling sequence, as 
        its value is derived from argument 'pts'.
    Argument 'pts':
        C/C++ type: ::cv::Point const *.
        Python type: Python sequence with elements of C++ type '::cv::Point_< 
        int >'.

    C++ signature :
        void fillConvexPoly(cv::Mat {lvalue},boost::python::list,cv::Scalar_<double> [,int=8 [,int=0]])

fillPoly(...)

fillPoly( (Mat)img, (object)pts, (Scalar)color [, (object)lineType=8 [, (object)shift=0 [, (Point2i)offset=Point2i(x=0, y=0)]]]) -> None :
    
    Fills the area bounded by one or more polygons.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/drawing_functions.html#cv-fillpoly
    Argument 'npts':
        Dependent argument: omitted from the function's calling sequence, as 
        its value is derived from argument 'pts'.
    Argument 'ncontours':
        Dependent argument: omitted from the function's calling sequence, as 
        its value is derived from argument 'pts'.
    Argument 'pts':
        C/C++ type: ::cv::Point const * *.
        Python type: list of Mat.

    C++ signature :
        void fillPoly(cv::Mat {lvalue},boost::python::api::object,cv::Scalar_<double> [,int=8 [,int=0 [,cv::Point_<int>=Point2i(x=0, y=0)]]])

filter2D(...)

filter2D( (Mat)src, (Mat)dst, (object)ddepth, (Mat)kernel [, (Point2i)anchor=Point2i(x=-1, y=-1) [, (object)delta=0 [, (object)borderType=4]]]) -> None :

    C++ signature :
        void filter2D(cv::Mat,cv::Mat {lvalue},int,cv::Mat [,cv::Point_<int>=Point2i(x=-1, y=-1) [,double=0 [,int=4]]])

filterSpeckles(...)

filterSpeckles( (Mat)img, (object)newVal, (object)maxSpeckleSize, (object)maxDiff, (Mat)buf) -> None :

    C++ signature :
        void filterSpeckles(cv::Mat {lvalue},double,int,double,cv::Mat {lvalue})

find4QuadCornerSubpix(...)

find4QuadCornerSubpix( (Mat)img, (Mat)corners, (Size2i)region_size) -> object :
    
    Argument 'corners':
        C/C++ type: ::std::vector< cv::Point_<float> > &.
        Python type: Mat.
        Invoke asMat() to convert a 1D Python sequence into a Mat, e.g. 
        asMat([0,1,2]) or asMat((0,1,2)).

    C++ signature :
        boost::python::api::object find4QuadCornerSubpix(cv::Mat,cv::Mat {lvalue},cv::Size_<int>)

findChessboardCorners(...)

findChessboardCorners( (Mat)image, (Size2i)patternSize [, (object)flags=3]) -> tuple :
    
    Argument 'corners':
        C/C++ type: ::std::vector< cv::Point_<float> > &.
        Python type: Mat.
        Invoke asMat() to convert a 1D Python sequence into a Mat, e.g. 
        asMat([0,1,2]) or asMat((0,1,2)).
        Output argument: omitted from the function's calling sequence, and is 
        returned along with the function's return value (if any).

    C++ signature :
        boost::python::tuple findChessboardCorners(cv::Mat,cv::Size_<int> [,int=3])

findContours(...)

findContours( (Mat)image, (object)mode, (object)method [, (Point2i)offset=Point2i(x=0, y=0)]) -> object :
    
    Argument 'contours':
        C/C++ type: ::std::vector< std::vector< cv::Point_<int> > > &.
        Python type: list of Mat, e.g. [Mat(), Mat(), Mat()].
        Invoke asMat() to convert every 1D Python sequence into a Mat, e.g. 
        [asMat([0,1,2]), asMat((0,1,2)].
        Output argument: omitted from the function's calling sequence, and is 
        returned along with the function's return value (if any).

    C++ signature :
        boost::python::api::object findContours(cv::Mat {lvalue},int,int [,cv::Point_<int>=Point2i(x=0, y=0)])

findContours( (Mat)image, (object)mode, (object)method [, (Point2i)offset=Point2i(x=0, y=0)]) -> tuple :
    
    Argument 'hierarchy':
        C/C++ type: ::std::vector< cv::Vec<int, 4> > &.
        Python type: Mat.
        Invoke asMat() to convert a 1D Python sequence into a Mat, e.g. 
        asMat([0,1,2]) or asMat((0,1,2)).
        Output argument: omitted from the function's calling sequence, and is 
        returned along with the function's return value (if any).
    Argument 'contours':
        C/C++ type: ::std::vector< std::vector< cv::Point_<int> > > &.
        Python type: list of Mat, e.g. [Mat(), Mat(), Mat()].
        Invoke asMat() to convert every 1D Python sequence into a Mat, e.g. 
        [asMat([0,1,2]), asMat((0,1,2)].
        Output argument: omitted from the function's calling sequence, and is 
        returned along with the function's return value (if any).

    C++ signature :
        boost::python::tuple findContours(cv::Mat {lvalue},int,int [,cv::Point_<int>=Point2i(x=0, y=0)])

findDominantPoints(...)

findDominantPoints( (CvSeq)contour, (MemStorage)storage [, (object)method=1 [, (object)parameter1=0 [, (object)parameter2=0 [, (object)parameter3=0 [, (object)parameter4=0]]]]]) -> object :
    
    Wrapped function:
        cvFindDominantPoints
    Argument 'storage':
        C/C++ type: ::CvMemStorage *.
        Python type: MemStorage.

    C++ signature :
        boost::python::api::object findDominantPoints(CvSeq*,cv::Ptr<CvMemStorage> {lvalue} [,int=1 [,double=0 [,double=0 [,double=0 [,double=0]]]]])

findFeatures(...)

findFeatures( (CvFeatureTree)tr, (Mat)query_points, (Mat)indices, (Mat)dist, (object)k [, (object)emax=20]) -> None :
    
    Wrapped function:
        cvFindFeatures
    Argument 'indices':
        C/C++ type: ::CvMat *.
        Python type: Mat.
    Argument 'query_points':
        C/C++ type: ::CvMat const *.
        Python type: Mat.
    Argument 'dist':
        C/C++ type: ::CvMat *.
        Python type: Mat.

    C++ signature :
        void findFeatures(CvFeatureTree*,cv::Mat {lvalue},cv::Mat {lvalue},cv::Mat {lvalue},int [,int=20])

findFeaturesBoxed(...)

findFeaturesBoxed( (CvFeatureTree)tr, (Mat)bounds_min, (Mat)bounds_max, (Mat)out_indices) -> object :
    
    Wrapped function:
        cvFindFeaturesBoxed
    Argument 'bounds_min':
        C/C++ type: ::CvMat *.
        Python type: Mat.
    Argument 'out_indices':
        C/C++ type: ::CvMat *.
        Python type: Mat.
    Argument 'bounds_max':
        C/C++ type: ::CvMat *.
        Python type: Mat.

    C++ signature :
        boost::python::api::object findFeaturesBoxed(CvFeatureTree*,cv::Mat {lvalue},cv::Mat {lvalue},cv::Mat {lvalue})

findFundamentalMat(...)

findFundamentalMat( (Mat)points1, (Mat)points2 [, (object)method=8 [, (object)param1=3.0 [, (object)param2=0.98999999999999999]]]) -> Mat :

    C++ signature :
        cv::Mat findFundamentalMat(cv::Mat,cv::Mat [,int=8 [,double=3.0 [,double=0.98999999999999999]]])

findFundamentalMat2(...)

findFundamentalMat2( (Mat)points1, (Mat)points2 [, (object)method=8 [, (object)param1=3.0 [, (object)param2=0.98999999999999999]]]) -> tuple :
    
    Wrapped function:
        findFundamentalMat
    Argument 'mask':
        C/C++ type: ::std::vector< unsigned char > &.
        Python type: Mat.
        Invoke asMat() to convert a 1D Python sequence into a Mat, e.g. 
        asMat([0,1,2]) or asMat((0,1,2)).
        Output argument: omitted from the function's calling sequence, and is 
        returned along with the function's return value (if any).

    C++ signature :
        boost::python::tuple findFundamentalMat2(cv::Mat,cv::Mat [,int=8 [,double=3.0 [,double=0.98999999999999999]]])

findHomography(...)

findHomography( (Mat)srcPoints, (Mat)dstPoints [, (object)method=0 [, (object)ransacReprojThreshold=0]]) -> Mat :

    C++ signature :
        cv::Mat findHomography(cv::Mat,cv::Mat [,int=0 [,double=0]])

findHomography2(...)

findHomography2( (Mat)srcPoints, (Mat)dstPoints [, (object)method=0 [, (object)ransacReprojThreshold=0]]) -> tuple :
    
    Wrapped function:
        findHomography
    Argument 'mask':
        C/C++ type: ::std::vector< unsigned char > &.
        Python type: Mat.
        Invoke asMat() to convert a 1D Python sequence into a Mat, e.g. 
        asMat([0,1,2]) or asMat((0,1,2)).
        Output argument: omitted from the function's calling sequence, and is 
        returned along with the function's return value (if any).

    C++ signature :
        boost::python::tuple findHomography2(cv::Mat,cv::Mat [,int=0 [,double=0]])

findNearestPoint2D(...)

findNearestPoint2D( (CvSubdiv2D)subdiv, (Point2f)pt) -> object :
    
    Wrapped function:
        cvFindNearestPoint2D
    Argument 'pt':
        C/C++ type: ::CvPoint2D32f.
        Python type: Point2f.

    C++ signature :
        boost::python::api::object findNearestPoint2D(CvSubdiv2D*,cv::Point_<float>)

findNextContour(...)

findNextContour( (CvContourScanner)scanner) -> CvSeq :
    
    Wrapped function:
        cvFindNextContour

    C++ signature :
        CvSeq* findNextContour(_CvContourScanner*)

findStereoCorrespondence(...)

findStereoCorrespondence( (Mat)leftImage, (Mat)rightImage, (object)mode, (Mat)dispImage, (object)maxDisparity [, (object)param1=12345 [, (object)param2=12345 [, (object)param3=12345 [, (object)param4=12345 [, (object)param5=12345]]]]]) -> None :
    
    Wrapped function:
        cvFindStereoCorrespondence
    Argument 'dispImage':
        C/C++ type: ::CvArr *.
        Python type: Mat.
    Argument 'leftImage':
        C/C++ type: ::CvArr const *.
        Python type: Mat.
    Argument 'rightImage':
        C/C++ type: ::CvArr const *.
        Python type: Mat.

    C++ signature :
        void findStereoCorrespondence(cv::Mat {lvalue},cv::Mat {lvalue},int,cv::Mat {lvalue},int [,double=12345 [,double=12345 [,double=12345 [,double=12345 [,double=12345]]]]])

findStereoCorrespondenceGC(...)

findStereoCorrespondenceGC( (Mat)left, (Mat)right, (Mat)disparityLeft, (Mat)disparityRight, (CvStereoGCState)state [, (object)useDisparityGuess=0]) -> None :
    
    Wrapped function:
        cvFindStereoCorrespondenceGC
    Argument 'disparityLeft':
        C/C++ type: ::CvArr *.
        Python type: Mat.
    Argument 'right':
        C/C++ type: ::CvArr const *.
        Python type: Mat.
    Argument 'disparityRight':
        C/C++ type: ::CvArr *.
        Python type: Mat.
    Argument 'left':
        C/C++ type: ::CvArr const *.
        Python type: Mat.

    C++ signature :
        void findStereoCorrespondenceGC(cv::Mat {lvalue},cv::Mat {lvalue},cv::Mat {lvalue},cv::Mat {lvalue},CvStereoGCState* [,int=0])

findType(...)

findType( (str)type_name) -> CvTypeInfo :
    
    Wrapped function:
        cvFindType

    C++ signature :
        CvTypeInfo* findType(char const*)

firstType()

    Wrapped function:
        cvFirstType

    C++ signature :
        CvTypeInfo* firstType()

Returns: CvTypeInfo :

fitEllipse(...)

fitEllipse( (Mat)points) -> RotatedRect :

    C++ signature :
        cv::RotatedRect fitEllipse(cv::Mat)

fitLine(...)

fitLine( (Mat)points, (Vec6f)line, (object)distType, (object)param, (object)reps, (object)aeps) -> None :

    C++ signature :
        void fitLine(cv::Mat,cv::Vec<float, 6> {lvalue},int,double,double,double)

fitLine( (Mat)points, (Vec4f)line, (object)distType, (object)param, (object)reps, (object)aeps) -> None :

    C++ signature :
        void fitLine(cv::Mat,cv::Vec<float, 4> {lvalue},int,double,double,double)

flip(...)

flip( (Mat)a, (Mat)b, (object)flipCode) -> None :
    
    Flips a 2D array around vertical, horizontal or both axes.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#cv-flip

    C++ signature :
        void flip(cv::Mat,cv::Mat {lvalue},int)

floodFill(...)

floodFill( (Mat)image, (Mat)mask, (Point2i)seedPoint, (Scalar)newVal [, (Scalar)loDiff=Scalar([ 0.  0.  0.  0.]) [, (Scalar)upDiff=Scalar([ 0.  0.  0.  0.]) [, (object)flags=4]]]) -> tuple :
    
    Argument 'rect':
        C/C++ type: ::cv::Rect *.
        Python type: Python equivalence of the C/C++ type without pointer.
        Output argument: omitted from the function's calling sequence, and is 
        returned along with the function's return value (if any).

    C++ signature :
        boost::python::tuple floodFill(cv::Mat {lvalue},cv::Mat {lvalue},cv::Point_<int>,cv::Scalar_<double> [,cv::Scalar_<double>=Scalar([ 0.  0.  0.  0.]) [,cv::Scalar_<double>=Scalar([ 0.  0.  0.  0.]) [,int=4]]])

floodFill( (Mat)image, (Point2i)seedPoint, (Scalar)newVal [, (Scalar)loDiff=Scalar([ 0.  0.  0.  0.]) [, (Scalar)upDiff=Scalar([ 0.  0.  0.  0.]) [, (object)flags=4]]]) -> tuple :
    
    Argument 'rect':
        C/C++ type: ::cv::Rect *.
        Python type: Python equivalence of the C/C++ type without pointer.
        Output argument: omitted from the function's calling sequence, and is 
        returned along with the function's return value (if any).

    C++ signature :
        boost::python::tuple floodFill(cv::Mat {lvalue},cv::Point_<int>,cv::Scalar_<double> [,cv::Scalar_<double>=Scalar([ 0.  0.  0.  0.]) [,cv::Scalar_<double>=Scalar([ 0.  0.  0.  0.]) [,int=4]]])

floor(...)

floor( (object)value) -> int :
    
    Wrapped function:
        cvFloor

    C++ signature :
        int floor(double)

fromUtf16(...)

fromUtf16( (unicode)str) -> str :

    C++ signature :
        std::string fromUtf16(std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t> >)

gemm(...)

gemm( (Mat)a, (Mat)b, (object)alpha, (Mat)c, (object)gamma, (Mat)d [, (object)flags=0]) -> None :
    
    Performs generalized matrix multiplication.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#cv-gemm

    C++ signature :
        void gemm(cv::Mat,cv::Mat,double,cv::Mat,double,cv::Mat {lvalue} [,int=0])

getAffineTransform(...)

getAffineTransform( (list)src, (list)dst) -> object :
    
    Argument 'src':
        C/C++ type: ::cv::Point2f const *.
        Python type: Python sequence with elements of C++ type '::cv::Point_< 
        float >'.
    Argument 'dst':
        C/C++ type: ::cv::Point2f const *.
        Python type: Python sequence with elements of C++ type '::cv::Point_< 
        float >'.

    C++ signature :
        boost::python::api::object getAffineTransform(boost::python::list,boost::python::list)

getCPUTickCount()

    C++ signature :
        long long getCPUTickCount()

Returns: long :

getColumnSumFilter(...)

getColumnSumFilter( (object)sumType, (object)dstType, (object)ksize [, (object)anchor=-1 [, (object)scale=1]]) -> Ptr_BaseColumnFilter :

    C++ signature :
        cv::Ptr<cv::BaseColumnFilter> getColumnSumFilter(int,int,int [,int=-1 [,double=1]])

getDefaultNewCameraMatrix(...)

getDefaultNewCameraMatrix( (Mat)cameraMatrix [, (Size2i)imgsize=Size2i(width=0, height=0) [, (bool)centerPrincipalPoint=False]]) -> Mat :

    C++ signature :
        cv::Mat getDefaultNewCameraMatrix(cv::Mat [,cv::Size_<int>=Size2i(width=0, height=0) [,bool=False]])

getDerivKernels(...)

getDerivKernels( (Mat)kx, (Mat)ky, (object)dx, (object)dy, (object)ksize [, (bool)normalize=False [, (object)ktype=5]]) -> None :

    C++ signature :
        void getDerivKernels(cv::Mat {lvalue},cv::Mat {lvalue},int,int,int [,bool=False [,int=5]])

getElemSize(...)

getElemSize( (object)type) -> int :

    C++ signature :
        unsigned int getElemSize(int)

getElemType(...)

getElemType( (Mat)arr) -> object :
    
    Wrapped function:
        cvGetElemType
    Argument 'arr':
        C/C++ type: ::CvArr const *.
        Python type: Mat.

    C++ signature :
        boost::python::api::object getElemType(cv::Mat {lvalue})

getErrMode()

    Wrapped function:
        cvGetErrMode

    C++ signature :
        int getErrMode()

Returns: int :

getErrStatus()

    Wrapped function:
        cvGetErrStatus

    C++ signature :
        int getErrStatus()

Returns: int :

getGaussianKernel(...)

getGaussianKernel( (object)ksize, (object)sigma [, (object)ktype=6]) -> Mat :

    C++ signature :
        cv::Mat getGaussianKernel(int,double [,int=6])

getHashedKey(...)

getHashedKey( (FileStorage)fs, (str)name [, (object)len=-1 [, (object)create_missing=0]]) -> object :
    
    Wrapped function:
        cvGetHashedKey
    Argument 'fs':
        C/C++ type: ::CvFileStorage *.
        Python type: FileStorage.

    C++ signature :
        boost::python::api::object getHashedKey(cv::FileStorage {lvalue},char const* [,int=-1 [,int=0]])

getKernelType(...)

getKernelType( (Mat)kernel, (Point2i)anchor) -> int :

    C++ signature :
        int getKernelType(cv::Mat,cv::Point_<int>)

getLinearColumnFilter(...)

getLinearColumnFilter( (object)bufType, (object)dstType, (Mat)kernel, (object)anchor, (object)symmetryType [, (object)delta=0 [, (object)bits=0]]) -> Ptr_BaseColumnFilter :

    C++ signature :
        cv::Ptr<cv::BaseColumnFilter> getLinearColumnFilter(int,int,cv::Mat,int,int [,double=0 [,int=0]])

getLinearFilter(...)

getLinearFilter( (object)srcType, (object)dstType, (Mat)kernel [, (Point2i)anchor=Point2i(x=-1, y=-1) [, (object)delta=0 [, (object)bits=0]]]) -> Ptr_BaseFilter :

    C++ signature :
        cv::Ptr<cv::BaseFilter> getLinearFilter(int,int,cv::Mat [,cv::Point_<int>=Point2i(x=-1, y=-1) [,double=0 [,int=0]]])

getLinearRowFilter(...)

getLinearRowFilter( (object)srcType, (object)bufType, (Mat)kernel, (object)anchor, (object)symmetryType) -> Ptr_BaseRowFilter :

    C++ signature :
        cv::Ptr<cv::BaseRowFilter> getLinearRowFilter(int,int,cv::Mat,int,int)

getMorphologyColumnFilter(...)

getMorphologyColumnFilter( (object)op, (object)type, (object)ksize [, (object)anchor=-1]) -> Ptr_BaseColumnFilter :

    C++ signature :
        cv::Ptr<cv::BaseColumnFilter> getMorphologyColumnFilter(int,int,int [,int=-1])

getMorphologyFilter(...)

getMorphologyFilter( (object)op, (object)type, (Mat)kernel [, (Point2i)anchor=Point2i(x=-1, y=-1)]) -> Ptr_BaseFilter :

    C++ signature :
        cv::Ptr<cv::BaseFilter> getMorphologyFilter(int,int,cv::Mat [,cv::Point_<int>=Point2i(x=-1, y=-1)])

getMorphologyRowFilter(...)

getMorphologyRowFilter( (object)op, (object)type, (object)ksize [, (object)anchor=-1]) -> Ptr_BaseRowFilter :

    C++ signature :
        cv::Ptr<cv::BaseRowFilter> getMorphologyRowFilter(int,int,int [,int=-1])

getNumThreads()

    Wrapped function:
        cvGetNumThreads

    C++ signature :
        int getNumThreads()

getNumThreads() -> int :

    C++ signature :
        int getNumThreads()

Returns: int :

getOptimalDFTSize(...)

getOptimalDFTSize( (object)vecsize) -> int :
    
    Returns optimal DFT size for a given vector size.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#cv-getoptimaldftsize

    C++ signature :
        int getOptimalDFTSize(int)

getOptimalNewCameraMatrix(...)

getOptimalNewCameraMatrix( (Mat)cameraMatrix, (Mat)distCoeffs, (Size2i)imageSize, (object)alpha [, (Size2i)newImgSize=Size2i(width=0, height=0)]) -> tuple :
    
    Argument 'validPixROI':
        C/C++ type: ::cv::Rect *.
        Python type: Python equivalence of the C/C++ type without pointer.
        Output argument: omitted from the function's calling sequence, and is 
        returned along with the function's return value (if any).

    C++ signature :
        boost::python::tuple getOptimalNewCameraMatrix(cv::Mat,cv::Mat,cv::Size_<int>,double [,cv::Size_<int>=Size2i(width=0, height=0)])

getPerspectiveTransform(...)

getPerspectiveTransform( (list)src, (list)dst) -> object :
    
    Argument 'src':
        C/C++ type: ::cv::Point2f const *.
        Python type: Python sequence with elements of C++ type '::cv::Point_< 
        float >'.
    Argument 'dst':
        C/C++ type: ::cv::Point2f const *.
        Python type: Python sequence with elements of C++ type '::cv::Point_< 
        float >'.

    C++ signature :
        boost::python::api::object getPerspectiveTransform(boost::python::list,boost::python::list)

getQuadrangleSubPix(...)

getQuadrangleSubPix( (Mat)src, (Mat)dst, (Mat)map_matrix) -> None :
    
    Wrapped function:
        cvGetQuadrangleSubPix
    Argument 'map_matrix':
        C/C++ type: ::CvMat const *.
        Python type: Mat.
    Argument 'src':
        C/C++ type: ::CvArr const *.
        Python type: Mat.
    Argument 'dst':
        C/C++ type: ::CvArr *.
        Python type: Mat.

    C++ signature :
        void getQuadrangleSubPix(cv::Mat {lvalue},cv::Mat {lvalue},cv::Mat {lvalue})

getRectSubPix(...)

getRectSubPix( (Mat)image, (Size2i)patchSize, (Point2f)center, (Mat)patch [, (object)patchType=-1]) -> None :

    C++ signature :
        void getRectSubPix(cv::Mat,cv::Size_<int>,cv::Point_<float>,cv::Mat {lvalue} [,int=-1])

getRotationMatrix2D(...)

getRotationMatrix2D( (Point2f)center, (object)angle, (object)scale) -> Mat :

    C++ signature :
        cv::Mat getRotationMatrix2D(cv::Point_<float>,double,double)

getRowSumFilter(...)

getRowSumFilter( (object)srcType, (object)sumType, (object)ksize [, (object)anchor=-1]) -> Ptr_BaseRowFilter :

    C++ signature :
        cv::Ptr<cv::BaseRowFilter> getRowSumFilter(int,int,int [,int=-1])

getSetElem(...)

getSetElem( (CvSet)set_header, (object)index) -> CvSetElem :
    
    Wrapped function:
        cvGetSetElem

    C++ signature :
        CvSetElem* getSetElem(CvSet const*,int)

getStructuringElement(...)

getStructuringElement( (object)shape, (Size2i)ksize [, (Point2i)anchor=Point2i(x=-1, y=-1)]) -> Mat :

    C++ signature :
        cv::Mat getStructuringElement(int,cv::Size_<int> [,cv::Point_<int>=Point2i(x=-1, y=-1)])

getTextSize(...)

getTextSize( (object)text, (object)fontFace, (object)fontScale, (object)thickness) -> tuple :
    
    Calculates the width and height of a text string.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/drawing_functions.html#cv-gettextsize
    Argument 'baseLine':
        C/C++ type: int *.
        Python type: Python equivalence of the C/C++ type without pointer.
        Output argument: omitted from the function's calling sequence, and is 
        returned along with the function's return value (if any).

    C++ signature :
        boost::python::tuple getTextSize(std::string,int,double,int)

getThreadNum()

    Wrapped function:
        cvGetThreadNum

    C++ signature :
        int getThreadNum()

getThreadNum() -> int :

    C++ signature :
        int getThreadNum()

Returns: int :

getTickCount()

    Wrapped function:
        cvGetTickCount

    C++ signature :
        long long getTickCount()

getTickCount() -> long :

    C++ signature :
        long long getTickCount()

Returns: long :

getTickFrequency()

    Wrapped function:
        cvGetTickFrequency

    C++ signature :
        double getTickFrequency()

getTickFrequency() -> float :

    C++ signature :
        double getTickFrequency()

Returns: float :

getTrackbarPos(...)

getTrackbarPos( (object)trackbarname, (object)winname) -> int :
    
    Returns the trackbar position.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/user_interface.html#cv-gettrackbarpos

    C++ signature :
        int getTrackbarPos(std::string,std::string)

getValidDisparityROI(...)

getValidDisparityROI( (Rect)roi1, (Rect)roi2, (object)minDisparity, (object)numberOfDisparities, (object)SADWindowSize) -> Rect :

    C++ signature :
        cv::Rect_<int> getValidDisparityROI(cv::Rect_<int>,cv::Rect_<int>,int,int,int)

getWindowName(...)

getWindowName( (object)window_handle) -> str :
    
    Gets the window's name by its handle.
    Wrapped function:
        cvGetWindowName
    Reference:
        http://opencv.willowgarage.com/documentation/c/user_interface.html#convertimage#getwindowname

    C++ signature :
        char const* getWindowName(void*)

getWindowProperty(...)

getWindowProperty( (object)winname, (object)prop_id) -> float :

    C++ signature :
        double getWindowProperty(std::string,int)

goodFeaturesToTrack(...)

goodFeaturesToTrack( (Mat)image, (object)maxCorners, (object)qualityLevel, (object)minDistance [, (Mat)mask=Mat() [, (object)blockSize=3 [, (bool)useHarrisDetector=False [, (object)k=0.040000000000000001]]]]) -> object :
    
    Argument 'corners':
        C/C++ type: ::std::vector< cv::Point_<float> > &.
        Python type: Mat.
        Invoke asMat() to convert a 1D Python sequence into a Mat, e.g. 
        asMat([0,1,2]) or asMat((0,1,2)).
        Output argument: omitted from the function's calling sequence, and is 
        returned along with the function's return value (if any).

    C++ signature :
        boost::python::api::object goodFeaturesToTrack(cv::Mat,int,double,double [,cv::Mat=Mat() [,int=3 [,bool=False [,double=0.040000000000000001]]]])

grabCut(...)

grabCut( (Mat)img, (Mat)mask, (Rect)rect, (Mat)bgdModel, (Mat)fgdModel, (object)iterCount [, (object)mode=2]) -> None :

    C++ signature :
        void grabCut(cv::Mat,cv::Mat {lvalue},cv::Rect_<int>,cv::Mat {lvalue},cv::Mat {lvalue},int [,int=2])

groupRectangles(...)

groupRectangles( (Mat)rectList, (Mat)weights, (object)groupThreshold [, (object)eps=0.20000000000000001]) -> None :
    
    Argument 'weights':
        C/C++ type: ::std::vector< int > &.
        Python type: Mat.
        Invoke asMat() to convert a 1D Python sequence into a Mat, e.g. 
        asMat([0,1,2]) or asMat((0,1,2)).
    Argument 'rectList':
        C/C++ type: ::std::vector< cv::Rect_<int> > &.
        Python type: Mat.
        Invoke asMat() to convert a 1D Python sequence into a Mat, e.g. 
        asMat([0,1,2]) or asMat((0,1,2)).

    C++ signature :
        void groupRectangles(cv::Mat {lvalue},cv::Mat {lvalue},int [,double=0.20000000000000001])

groupRectangles( (Mat)rectList, (object)groupThreshold [, (object)eps=0.20000000000000001]) -> None :
    
    Argument 'rectList':
        C/C++ type: ::std::vector< cv::Rect_<int> > &.
        Python type: Mat.
        Invoke asMat() to convert a 1D Python sequence into a Mat, e.g. 
        asMat([0,1,2]) or asMat((0,1,2)).

    C++ signature :
        void groupRectangles(cv::Mat {lvalue},int [,double=0.20000000000000001])

hierarchicalClustering(...)

hierarchicalClustering( (Mat)features, (Mat)centers, (KMeansIndexParams)params) -> int :

    C++ signature :
        int hierarchicalClustering(cv::Mat,cv::Mat {lvalue},cv::flann::KMeansIndexParams)

idct(...)

idct( (Mat)src, (Mat)dst [, (object)flags=0]) -> None :
    
    Computes inverse Discrete Cosine Transform of a 1D or 2D array.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#cv-idct

    C++ signature :
        void idct(cv::Mat,cv::Mat {lvalue} [,int=0])

idft(...)

idft( (Mat)src, (Mat)dst [, (object)flags=0 [, (object)nonzeroRows=0]]) -> None :
    
    Computes inverse Discrete Fourier Transform of a 1D or 2D array.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#cv-idft

    C++ signature :
        void idft(cv::Mat,cv::Mat {lvalue} [,int=0 [,int=0]])

imdecode(...)

imdecode( (Mat)buf, (object)flags) -> Mat :
    
    Reads an image from a buffer in memory.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/reading_and_writing_images_and_video.html#cv-imdecode

    C++ signature :
        cv::Mat imdecode(cv::Mat,int)

imencode(...)

imencode( (object)ext, (Mat)img [, (Mat)params=Mat()]) -> tuple :
    
    Encode an image into a memory buffer.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/reading_and_writing_images_and_video.html#cv-imencode
    Argument 'params':
        C/C++ type: ::std::vector< int > const &.
        Python type: Mat.
        Invoke asMat() to convert a 1D Python sequence into a Mat, e.g. 
        asMat([0,1,2]) or asMat((0,1,2)).
    Argument 'buf':
        C/C++ type: ::std::vector< unsigned char > &.
        Python type: Mat.
        Invoke asMat() to convert a 1D Python sequence into a Mat, e.g. 
        asMat([0,1,2]) or asMat((0,1,2)).
        Output argument: omitted from the function's calling sequence, and is 
        returned along with the function's return value (if any).

    C++ signature :
        boost::python::tuple imencode(std::string,cv::Mat [,cv::Mat=Mat()])

imread(...)

imread( (object)filename [, (object)flags=1]) -> Mat :
    
    Loads an image from a file.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/reading_and_writing_images_and_video.html#cv-imread

    C++ signature :
        cv::Mat imread(std::string [,int=1])

imshow(...)

imshow( (object)winname, (Mat)mat) -> None :
    
    Displays the image in the specified window.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/user_interface.html#cv-imshow

    C++ signature :
        void imshow(std::string,cv::Mat)

imwrite(...)

imwrite( (object)filename, (Mat)img [, (Mat)params=Mat()]) -> object :
    
    Saves an image to a specified file.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/reading_and_writing_images_and_video.html#cv-imwrite
    Argument 'params':
        C/C++ type: ::std::vector< int > const &.
        Python type: Mat.
        Invoke asMat() to convert a 1D Python sequence into a Mat, e.g. 
        asMat([0,1,2]) or asMat((0,1,2)).

    C++ signature :
        boost::python::api::object imwrite(std::string,cv::Mat [,cv::Mat=Mat()])

inRange(...)

inRange( (MatND)src, (Scalar)lowerb, (Scalar)upperb, (MatND)dst) -> None :
    
    Checks if array elements lie between the elements of two other arrays.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#cv-inrange

    C++ signature :
        void inRange(cv::MatND,cv::Scalar_<double>,cv::Scalar_<double>,cv::MatND {lvalue})

inRange( (MatND)src, (MatND)lowerb, (MatND)upperb, (MatND)dst) -> None :
    
    Checks if array elements lie between the elements of two other arrays.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#cv-inrange

    C++ signature :
        void inRange(cv::MatND,cv::MatND,cv::MatND,cv::MatND {lvalue})

inRange( (Mat)src, (Scalar)lowerb, (Scalar)upperb, (Mat)dst) -> None :
    
    Checks if array elements lie between the elements of two other arrays.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#cv-inrange

    C++ signature :
        void inRange(cv::Mat,cv::Scalar_<double>,cv::Scalar_<double>,cv::Mat {lvalue})

inRange( (Mat)src, (Mat)lowerb, (Mat)upperb, (Mat)dst) -> None :
    
    Checks if array elements lie between the elements of two other arrays.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#cv-inrange

    C++ signature :
        void inRange(cv::Mat,cv::Mat,cv::Mat,cv::Mat {lvalue})

initCameraMatrix2D(...)

initCameraMatrix2D( (list)objectPoints, (list)imagePoints, (Size2i)imageSize [, (object)aspectRatio=1.0]) -> object :
    
    Argument 'objectPoints':
        C/C++ type: ::std::vector< std::vector< cv::Point3_<float> > > const 
        &.
        Python type: list of Mat, e.g. [Mat(), Mat(), Mat()].
        Invoke asMat() to convert every 1D Python sequence into a Mat, e.g. 
        [asMat([0,1,2]), asMat((0,1,2)].
    Argument 'imagePoints':
        C/C++ type: ::std::vector< std::vector< cv::Point_<float> > > const &.
        Python type: list of Mat, e.g. [Mat(), Mat(), Mat()].
        Invoke asMat() to convert every 1D Python sequence into a Mat, e.g. 
        [asMat([0,1,2]), asMat((0,1,2)].

    C++ signature :
        boost::python::api::object initCameraMatrix2D(boost::python::list,boost::python::list,cv::Size_<int> [,double=1.0])

initNArrayIterator(...)

initNArrayIterator( (list)arrs, (Mat)mask, (object)stubs, (CvNArrayIterator)array_iterator [, (object)flags=0]) -> object :
    
    Wrapped function:
        cvInitNArrayIterator
    Argument 'count':
        Dependent argument: omitted from the function's calling sequence, as 
        its value is derived from argument 'arrs'.
    Argument 'mask':
        C/C++ type: ::CvArr const *.
        Python type: Mat.
    Argument 'arrs':
        C/C++ type: ::CvArr * *.
        Python type: Python sequence with elements of C++ type 'void *'.

    C++ signature :
        boost::python::api::object initNArrayIterator(boost::python::list,cv::Mat {lvalue},CvMatND*,CvNArrayIterator* [,int=0])

initSubdivDelaunay2D(...)

initSubdivDelaunay2D( (CvSubdiv2D)subdiv, (Rect)rect) -> None :
    
    Wrapped function:
        cvInitSubdivDelaunay2D
    Argument 'rect':
        C/C++ type: ::CvRect.
        Python type: Rect.

    C++ signature :
        void initSubdivDelaunay2D(CvSubdiv2D*,cv::Rect_<int>)

initSystem(...)

initSystem( (list)argv) -> object :
    
    Initializes HighGUI.
    Wrapped function:
        cvInitSystem
    Reference:
        http://opencv.willowgarage.com/documentation/c/user_interface.html#convertimage#initsystem
    Argument 'argc':
        Dependent argument: omitted from the function's calling sequence, as 
        its value is derived from argument 'argv'.
    Argument 'argv':
        C/C++ type: char * *.
        Python type: list of strings.

    C++ signature :
        boost::python::api::object initSystem(boost::python::list)

initUndistortRectifyMap(...)

initUndistortRectifyMap( (Mat)cameraMatrix, (Mat)distCoeffs, (Mat)R, (Mat)newCameraMatrix, (Size2i)size, (object)m1type, (Mat)map1, (Mat)map2) -> None :

    C++ signature :
        void initUndistortRectifyMap(cv::Mat,cv::Mat,cv::Mat,cv::Mat,cv::Size_<int>,int,cv::Mat {lvalue},cv::Mat {lvalue})

inpaint(...)

inpaint( (Mat)src, (Mat)inpaintMask, (Mat)dst, (object)inpaintRange, (object)flags) -> None :

    C++ signature :
        void inpaint(cv::Mat,cv::Mat,cv::Mat {lvalue},double,int)

integral(...)

integral( (Mat)src, (Mat)sum, (Mat)sqsum, (Mat)tilted [, (object)sdepth=-1]) -> None :

    C++ signature :
        void integral(cv::Mat,cv::Mat {lvalue},cv::Mat {lvalue},cv::Mat {lvalue} [,int=-1])

integral( (Mat)src, (Mat)sum, (Mat)sqsum [, (object)sdepth=-1]) -> None :

    C++ signature :
        void integral(cv::Mat,cv::Mat {lvalue},cv::Mat {lvalue} [,int=-1])

integral( (Mat)src, (Mat)sum [, (object)sdepth=-1]) -> None :

    C++ signature :
        void integral(cv::Mat,cv::Mat {lvalue} [,int=-1])

invert(...)

invert( (Mat)a, (Mat)c [, (object)flags=0]) -> float :
    
    Finds the inverse or pseudo-inverse of a matrix.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#cv-invert

    C++ signature :
        double invert(cv::Mat,cv::Mat {lvalue} [,int=0])

invertAffineTransform(...)

invertAffineTransform( (Mat)M, (Mat)iM) -> None :

    C++ signature :
        void invertAffineTransform(cv::Mat,cv::Mat {lvalue})

isContourConvex(...)

isContourConvex( (Mat)contour) -> bool :

    C++ signature :
        bool isContourConvex(cv::Mat)

isInf(...)

isInf( (object)value) -> int :
    
    Wrapped function:
        cvIsInf

    C++ signature :
        int isInf(double)

isNaN(...)

isNaN( (object)value) -> int :
    
    Wrapped function:
        cvIsNaN

    C++ signature :
        int isNaN(double)

kmeans(...)

kmeans( (Mat)data, (object)K, (Mat)best_labels, (TermCriteria)criteria, (object)attempts, (object)flags) -> tuple :
    
    Argument 'centers':
        C/C++ type: ::cv::Mat *.
        Python type: Python equivalence of the C/C++ type without pointer.
        Output argument: omitted from the function's calling sequence, and is 
        returned along with the function's return value (if any).

    C++ signature :
        boost::python::tuple kmeans(cv::Mat,int,cv::Mat {lvalue},cv::TermCriteria,int,int)

line(...)

line( (Mat)img, (Point2i)pt1, (Point2i)pt2, (Scalar)color [, (object)thickness=1 [, (object)lineType=8 [, (object)shift=0]]]) -> None :
    
    Draws a line segment connecting two points.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/drawing_functions.html#cv-line

    C++ signature :
        void line(cv::Mat {lvalue},cv::Point_<int>,cv::Point_<int>,cv::Scalar_<double> [,int=1 [,int=8 [,int=0]]])

linearPolar(...)

linearPolar( (Mat)src, (Mat)dst, (Point2f)center, (object)maxRadius [, (object)flags=9]) -> None :
    
    Wrapped function:
        cvLinearPolar
    Argument 'src':
        C/C++ type: ::CvArr const *.
        Python type: Mat.
    Argument 'dst':
        C/C++ type: ::CvArr *.
        Python type: Mat.
    Argument 'center':
        C/C++ type: ::CvPoint2D32f.
        Python type: Point2f.

    C++ signature :
        void linearPolar(cv::Mat {lvalue},cv::Mat {lvalue},cv::Point_<float>,double [,int=9])

log(...)

log( (MatND)a, (MatND)b) -> None :
    
    Calculates the natural logarithm of every array element.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#cv-log

    C++ signature :
        void log(cv::MatND,cv::MatND {lvalue})

log( (Mat)a, (Mat)b) -> None :
    
    Calculates the natural logarithm of every array element.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#cv-log

    C++ signature :
        void log(cv::Mat,cv::Mat {lvalue})

logPolar(...)

logPolar( (Mat)src, (Mat)dst, (Point2f)center, (object)M [, (object)flags=9]) -> None :
    
    Wrapped function:
        cvLogPolar
    Argument 'src':
        C/C++ type: ::CvArr const *.
        Python type: Mat.
    Argument 'dst':
        C/C++ type: ::CvArr *.
        Python type: Mat.
    Argument 'center':
        C/C++ type: ::CvPoint2D32f.
        Python type: Point2f.

    C++ signature :
        void logPolar(cv::Mat {lvalue},cv::Mat {lvalue},cv::Point_<float>,double [,int=9])

magnitude(...)

magnitude( (Mat)x, (Mat)y, (Mat)magnitude) -> None :
    
    Calculates magnitude of 2D vectors.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#cv-magnitude

    C++ signature :
        void magnitude(cv::Mat,cv::Mat,cv::Mat {lvalue})

matMulDeriv(...)

matMulDeriv( (Mat)A, (Mat)B, (Mat)dABdA, (Mat)dABdB) -> None :

    C++ signature :
        void matMulDeriv(cv::Mat,cv::Mat,cv::Mat {lvalue},cv::Mat {lvalue})

matchContourTrees(...)

matchContourTrees( (CvContourTree)tree1, (CvContourTree)tree2, (object)method, (object)threshold) -> float :
    
    Wrapped function:
        cvMatchContourTrees

    C++ signature :
        double matchContourTrees(CvContourTree const*,CvContourTree const*,int,double)

matchShapes(...)

matchShapes( (Mat)contour1, (Mat)contour2, (object)method, (object)parameter) -> float :

    C++ signature :
        double matchShapes(cv::Mat,cv::Mat,int,double)

matchTemplate(...)

matchTemplate( (Mat)image, (Mat)templ, (Mat)result, (object)method) -> None :

    C++ signature :
        void matchTemplate(cv::Mat,cv::Mat,cv::Mat {lvalue},int)

max(...)

max( (MatND)a, (object)alpha, (MatND)c) -> None :
    
    Calculates per-element maximum of two arrays or array and a scalar.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#cv-max

    C++ signature :
        void max(cv::MatND,double,cv::MatND {lvalue})

max( (MatND)a, (MatND)b, (MatND)c) -> None :
    
    Calculates per-element maximum of two arrays or array and a scalar.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#cv-max

    C++ signature :
        void max(cv::MatND,cv::MatND,cv::MatND {lvalue})

max( (Mat)a, (object)alpha, (Mat)c) -> None :
    
    Calculates per-element maximum of two arrays or array and a scalar.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#cv-max

    C++ signature :
        void max(cv::Mat,double,cv::Mat {lvalue})

max( (Mat)a, (Mat)b, (Mat)c) -> None :
    
    Calculates per-element maximum of two arrays or array and a scalar.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#cv-max

    C++ signature :
        void max(cv::Mat,cv::Mat,cv::Mat {lvalue})

maxRect(...)

maxRect( (object)rect1, (object)rect2) -> object :
    
    Wrapped function:
        cvMaxRect

    C++ signature :
        CvRect maxRect(CvRect const*,CvRect const*)

mean(...)

mean( (MatND)m [, (MatND)mask]) -> Scalar :
    
    Calculates average (mean) of array elements.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#cv-mean

    C++ signature :
        cv::Scalar_<double> mean(cv::MatND [,cv::MatND])

mean( (Mat)m [, (Mat)mask]) -> Scalar :
    
    Calculates average (mean) of array elements.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#cv-mean

    C++ signature :
        cv::Scalar_<double> mean(cv::Mat [,cv::Mat])

meanShift(...)

meanShift( (Mat)probImage, (Rect)window, (TermCriteria)criteria) -> int :

    C++ signature :
        int meanShift(cv::Mat,cv::Rect_<int> {lvalue},cv::TermCriteria)

meanStdDev(...)

meanStdDev( (MatND)m, (Scalar)mean, (Scalar)stddev [, (MatND)mask=MatND(shape=(), nchannels=1, depth=0):
array(238, dtype=uint8)]) -> None :
    
    Calculates mean and standard deviation of array elements.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#cv-meanstddev

    C++ signature :
        void meanStdDev(cv::MatND,cv::Scalar_<double> {lvalue},cv::Scalar_<double> {lvalue} [,cv::MatND=MatND(shape=(), nchannels=1, depth=0):
array(242, dtype=uint8)])

meanStdDev( (Mat)m, (Scalar)mean, (Scalar)stddev [, (Mat)mask=Mat()]) -> None :
    
    Calculates mean and standard deviation of array elements.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#cv-meanstddev

    C++ signature :
        void meanStdDev(cv::Mat,cv::Scalar_<double> {lvalue},cv::Scalar_<double> {lvalue} [,cv::Mat=Mat()])

medianBlur(...)

medianBlur( (Mat)src, (Mat)dst, (object)ksize) -> None :

    C++ signature :
        void medianBlur(cv::Mat,cv::Mat {lvalue},int)

memStorageAllocString(...)

memStorageAllocString( (MemStorage)storage, (str)ptr [, (object)len=-1]) -> object :
    
    Wrapped function:
        cvMemStorageAllocString
    Argument 'storage':
        C/C++ type: ::CvMemStorage *.
        Python type: MemStorage.

    C++ signature :
        boost::python::api::object memStorageAllocString(cv::Ptr<CvMemStorage> {lvalue},char const* [,int=-1])

merge(...)

merge( (vector_MatND)mv, (MatND)dst) -> None :
    
    Composes a multi-channel array from several single-channel arrays.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#cv-merge

    C++ signature :
        void merge(std::vector<cv::MatND, std::allocator<cv::MatND> >,cv::MatND {lvalue})

merge( (vector_Mat)mv, (Mat)dst) -> None :
    
    Composes a multi-channel array from several single-channel arrays.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#cv-merge

    C++ signature :
        void merge(std::vector<cv::Mat, std::allocator<cv::Mat> >,cv::Mat {lvalue})

min(...)

min( (MatND)a, (object)alpha, (MatND)c) -> None :
    
    Calculates per-element minimum of two arrays or array and a scalar.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#cv-min

    C++ signature :
        void min(cv::MatND,double,cv::MatND {lvalue})

min( (MatND)a, (MatND)b, (MatND)c) -> None :
    
    Calculates per-element minimum of two arrays or array and a scalar.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#cv-min

    C++ signature :
        void min(cv::MatND,cv::MatND,cv::MatND {lvalue})

min( (Mat)a, (object)alpha, (Mat)c) -> None :
    
    Calculates per-element minimum of two arrays or array and a scalar.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#cv-min

    C++ signature :
        void min(cv::Mat,double,cv::Mat {lvalue})

min( (Mat)a, (Mat)b, (Mat)c) -> None :
    
    Calculates per-element minimum of two arrays or array and a scalar.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#cv-min

    C++ signature :
        void min(cv::Mat,cv::Mat,cv::Mat {lvalue})

minAreaRect(...)

minAreaRect( (Mat)points) -> RotatedRect :

    C++ signature :
        cv::RotatedRect minAreaRect(cv::Mat)

minEnclosingCircle(...)

minEnclosingCircle( (Mat)points, (Point2f)center, (object)radius) -> None :

    C++ signature :
        void minEnclosingCircle(cv::Mat,cv::Point_<float> {lvalue},float {lvalue})

minMaxLoc(...)

minMaxLoc( (SparseMat)a) -> tuple :
    
    Finds global minimum and maximum in a whole array or sub-array.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#cv-minmaxloc
    Argument 'maxVal':
        C/C++ type: double *.
        Python type: Python equivalence of the C/C++ type without pointer.
        Output argument: omitted from the function's calling sequence, and is 
        returned along with the function's return value (if any).
    Argument 'minIdx':
        C/C++ type: int *.
        Python type: Python equivalence of the C/C++ type without pointer.
        Output argument: omitted from the function's calling sequence, and is 
        returned along with the function's return value (if any).
    Argument 'maxIdx':
        C/C++ type: int *.
        Python type: Python equivalence of the C/C++ type without pointer.
        Output argument: omitted from the function's calling sequence, and is 
        returned along with the function's return value (if any).
    Argument 'minVal':
        C/C++ type: double *.
        Python type: Python equivalence of the C/C++ type without pointer.
        Output argument: omitted from the function's calling sequence, and is 
        returned along with the function's return value (if any).

    C++ signature :
        boost::python::tuple minMaxLoc(cv::SparseMat)

minMaxLoc( (MatND)a [, (MatND)mask=MatND(shape=(), nchannels=1, depth=0):
array(22, dtype=uint8)]) -> tuple :
    
    Finds global minimum and maximum in a whole array or sub-array.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#cv-minmaxloc
    Argument 'maxVal':
        C/C++ type: double *.
        Python type: Python equivalence of the C/C++ type without pointer.
        Output argument: omitted from the function's calling sequence, and is 
        returned along with the function's return value (if any).
    Argument 'minIdx':
        C/C++ type: int *.
        Python type: Python equivalence of the C/C++ type without pointer.
        Output argument: omitted from the function's calling sequence, and is 
        returned along with the function's return value (if any).
    Argument 'maxIdx':
        C/C++ type: int *.
        Python type: Python equivalence of the C/C++ type without pointer.
        Output argument: omitted from the function's calling sequence, and is 
        returned along with the function's return value (if any).
    Argument 'minVal':
        C/C++ type: double *.
        Python type: Python equivalence of the C/C++ type without pointer.
        Output argument: omitted from the function's calling sequence, and is 
        returned along with the function's return value (if any).

    C++ signature :
        boost::python::tuple minMaxLoc(cv::MatND [,cv::MatND=MatND(shape=(), nchannels=1, depth=0):
array(26, dtype=uint8)])

minMaxLoc( (Mat)a [, (Mat)mask=Mat()]) -> tuple :
    
    Finds global minimum and maximum in a whole array or sub-array.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#cv-minmaxloc
    Argument 'minLoc':
        C/C++ type: ::cv::Point *.
        Python type: Python equivalence of the C/C++ type without pointer.
        Output argument: omitted from the function's calling sequence, and is 
        returned along with the function's return value (if any).
    Argument 'maxVal':
        C/C++ type: double *.
        Python type: Python equivalence of the C/C++ type without pointer.
        Output argument: omitted from the function's calling sequence, and is 
        returned along with the function's return value (if any).
    Argument 'maxLoc':
        C/C++ type: ::cv::Point *.
        Python type: Python equivalence of the C/C++ type without pointer.
        Output argument: omitted from the function's calling sequence, and is 
        returned along with the function's return value (if any).
    Argument 'minVal':
        C/C++ type: double *.
        Python type: Python equivalence of the C/C++ type without pointer.
        Output argument: omitted from the function's calling sequence, and is 
        returned along with the function's return value (if any).

    C++ signature :
        boost::python::tuple minMaxLoc(cv::Mat [,cv::Mat=Mat()])

mixChannels(...)

mixChannels( (vector_MatND)src, (vector_MatND)dst, (Mat)fromTo, (object)npairs) -> None :
    
    Copies specified channels from input arrays to the specified channels 
    of output arrays.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#cv-mixchannels
    Argument 'fromTo':
        C/C++ type: int const *.
        Python type: Mat.
        Invoke asMat() to convert a 1D Python sequence into a Mat, e.g. 
        asMat([0,1,2]) or asMat((0,1,2)).

    C++ signature :
        void mixChannels(std::vector<cv::MatND, std::allocator<cv::MatND> >,std::vector<cv::MatND, std::allocator<cv::MatND> > {lvalue},cv::Mat,int)

mixChannels( (vector_Mat)src, (vector_Mat)dst, (Mat)fromTo, (object)npairs) -> None :
    
    Copies specified channels from input arrays to the specified channels 
    of output arrays.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#cv-mixchannels
    Argument 'fromTo':
        C/C++ type: int const *.
        Python type: Mat.
        Invoke asMat() to convert a 1D Python sequence into a Mat, e.g. 
        asMat([0,1,2]) or asMat((0,1,2)).

    C++ signature :
        void mixChannels(std::vector<cv::Mat, std::allocator<cv::Mat> >,std::vector<cv::Mat, std::allocator<cv::Mat> > {lvalue},cv::Mat,int)

moments(...)

moments( (Mat)array [, (bool)binaryImage=False]) -> Moments :

    C++ signature :
        cv::Moments moments(cv::Mat [,bool=False])

morphologyDefaultBorderValue()

    C++ signature :
        cv::Scalar_<double> morphologyDefaultBorderValue()

Returns: Scalar :

morphologyEx(...)

morphologyEx( (Mat)src, (Mat)dst, (object)op, (Mat)kernel [, (Point2i)anchor=Point2i(x=-1, y=-1) [, (object)iterations=1 [, (object)borderType=0 [, (Scalar)borderValue=Scalar([  1.79769313e+308   1.79769313e+308   1.79769313e+308   1.79769313e+308])]]]]) -> None :

    C++ signature :
        void morphologyEx(cv::Mat,cv::Mat {lvalue},int,cv::Mat [,cv::Point_<int>=Point2i(x=-1, y=-1) [,int=1 [,int=0 [,cv::Scalar_<double>=Scalar([  1.79769313e+308   1.79769313e+308   1.79769313e+308   1.79769313e+308])]]]])

moveWindow(...)

moveWindow( (str)name, (object)x, (object)y) -> None :
    
    Sets the position of the window.
    Wrapped function:
        cvMoveWindow
    Reference:
        http://opencv.willowgarage.com/documentation/c/user_interface.html#convertimage#movewindow

    C++ signature :
        void moveWindow(char const*,int,int)

mulSpectrums(...)

mulSpectrums( (Mat)a, (Mat)b, (Mat)c, (object)flags [, (bool)conjB=False]) -> None :
    
    Performs per-element multiplication of two Fourier spectrums.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#cv-mulspectrums

    C++ signature :
        void mulSpectrums(cv::Mat,cv::Mat,cv::Mat {lvalue},int [,bool=False])

mulTransposed(...)

mulTransposed( (Mat)a, (Mat)c, (bool)aTa [, (Mat)delta=Mat() [, (object)scale=1 [, (object)rtype=-1]]]) -> None :
    
    Calculates the product of a matrix and its transposition.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#cv-multransposed

    C++ signature :
        void mulTransposed(cv::Mat,cv::Mat {lvalue},bool [,cv::Mat=Mat() [,double=1 [,int=-1]]])

multiply(...)

multiply( (MatND)a, (MatND)b, (MatND)c [, (object)scale=1]) -> None :
    
    Calculates the per-element scaled product of two arrays.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#cv-multiply

    C++ signature :
        void multiply(cv::MatND,cv::MatND,cv::MatND {lvalue} [,double=1])

multiply( (Mat)a, (Mat)b, (Mat)c [, (object)scale=1]) -> None :
    
    Calculates the per-element scaled product of two arrays.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#cv-multiply

    C++ signature :
        void multiply(cv::Mat,cv::Mat,cv::Mat {lvalue} [,double=1])

multiplyAcc(...)

multiplyAcc( (Mat)image1, (Mat)image2, (Mat)acc [, (Mat)mask=Mat()]) -> None :
    
    Wrapped function:
        cvMultiplyAcc
    Argument 'acc':
        C/C++ type: ::CvArr *.
        Python type: Mat.
    Argument 'image2':
        C/C++ type: ::CvArr const *.
        Python type: Mat.
    Argument 'image1':
        C/C++ type: ::CvArr const *.
        Python type: Mat.
    Argument 'mask':
        C/C++ type: ::CvArr const *.
        Python type: Mat.

    C++ signature :
        void multiplyAcc(cv::Mat {lvalue},cv::Mat {lvalue},cv::Mat {lvalue} [,cv::Mat=Mat()])

namedWindow(...)

namedWindow( (object)winname [, (object)flags=1]) -> None :
    
    Creates a window.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/user_interface.html#cv-namedwindow

    C++ signature :
        void namedWindow(std::string [,int=1])

nextNArraySlice(...)

nextNArraySlice( (CvNArrayIterator)array_iterator) -> int :
    
    Wrapped function:
        cvNextNArraySlice

    C++ signature :
        int nextNArraySlice(CvNArrayIterator*)

norm(...)

norm( (SparseMat)src, (object)normType) -> float :
    
    Calculates absolute array norm, absolute difference norm, or relative 
    difference norm.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#cv-norm

    C++ signature :
        double norm(cv::SparseMat,int)

norm( (MatND)a, (MatND)b [, (object)normType=4 [, (MatND)mask=MatND(shape=(), nchannels=1, depth=0):
array(90, dtype=uint8)]]) -> float :
    
    Calculates absolute array norm, absolute difference norm, or relative 
    difference norm.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#cv-norm

    C++ signature :
        double norm(cv::MatND,cv::MatND [,int=4 [,cv::MatND=MatND(shape=(), nchannels=1, depth=0):
array(94, dtype=uint8)]])

norm( (MatND)a [, (object)normType=4 [, (MatND)mask=MatND(shape=(), nchannels=1, depth=0):
array(82, dtype=uint8)]]) -> float :
    
    Calculates absolute array norm, absolute difference norm, or relative 
    difference norm.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#cv-norm

    C++ signature :
        double norm(cv::MatND [,int=4 [,cv::MatND=MatND(shape=(), nchannels=1, depth=0):
array(86, dtype=uint8)]])

norm( (Mat)a, (Mat)b, (object)normType, (Mat)mask) -> float :
    
    Calculates absolute array norm, absolute difference norm, or relative 
    difference norm.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#cv-norm

    C++ signature :
        double norm(cv::Mat,cv::Mat,int,cv::Mat)

norm( (Mat)a, (object)normType, (Mat)mask) -> float :
    
    Calculates absolute array norm, absolute difference norm, or relative 
    difference norm.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#cv-norm

    C++ signature :
        double norm(cv::Mat,int,cv::Mat)

norm( (Mat)a, (Mat)b [, (object)normType=4]) -> float :
    
    Calculates absolute array norm, absolute difference norm, or relative 
    difference norm.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#cv-norm

    C++ signature :
        double norm(cv::Mat,cv::Mat [,int=4])

norm( (Mat)a [, (object)normType=4]) -> float :
    
    Calculates absolute array norm, absolute difference norm, or relative 
    difference norm.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#cv-norm

    C++ signature :
        double norm(cv::Mat [,int=4])

normalize(...)

normalize( (SparseMat)src, (SparseMat)dst, (object)alpha, (object)normType) -> None :
    
    Normalizes array's norm or the range.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#cv-normalize

    C++ signature :
        void normalize(cv::SparseMat,cv::SparseMat {lvalue},double,int)

normalize( (MatND)a, (MatND)b [, (object)alpha=1 [, (object)beta=0 [, (object)norm_type=4 [, (object)rtype=-1 [, (MatND)mask=MatND(shape=(), nchannels=1, depth=0):
array(102, dtype=uint8)]]]]]) -> None :
    
    Normalizes array's norm or the range.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#cv-normalize

    C++ signature :
        void normalize(cv::MatND,cv::MatND {lvalue} [,double=1 [,double=0 [,int=4 [,int=-1 [,cv::MatND=MatND(shape=(), nchannels=1, depth=0):
array(106, dtype=uint8)]]]]])

normalize( (Mat)a, (Mat)b [, (object)alpha=1 [, (object)beta=0 [, (object)norm_type=4 [, (object)rtype=-1 [, (Mat)mask=Mat()]]]]]) -> None :
    
    Normalizes array's norm or the range.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#cv-normalize

    C++ signature :
        void normalize(cv::Mat,cv::Mat {lvalue} [,double=1 [,double=0 [,int=4 [,int=-1 [,cv::Mat=Mat()]]]]])

patchBasedStdDev(...)

patchBasedStdDev( (Mat)in_image, (Size2i)patch_size, (Mat)out_image) -> None :

    C++ signature :
        void patchBasedStdDev(cv::Mat,cv::Size_<int>,cv::Mat {lvalue})

perspectiveTransform(...)

perspectiveTransform( (Mat)src, (Mat)dst, (Mat)m) -> None :
    
    Performs perspective matrix transformation of vectors.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#cv-perspectivetransform

    C++ signature :
        void perspectiveTransform(cv::Mat,cv::Mat {lvalue},cv::Mat)

phase(...)

phase( (Mat)x, (Mat)y, (Mat)angle [, (bool)angleInDegrees=False]) -> None :
    
    Calculates the rotation angle of 2d vectors.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#cv-phase

    C++ signature :
        void phase(cv::Mat,cv::Mat,cv::Mat {lvalue} [,bool=False])

pointPolygonTest(...)

pointPolygonTest( (Mat)contour, (Point2f)pt, (bool)measureDist) -> float :

    C++ signature :
        double pointPolygonTest(cv::Mat,cv::Point_<float>,bool)

pointSeqFromMat(...)

pointSeqFromMat( (object)seq_kind, (Mat)mat, (CvContour)contour_header, (CvSeqBlock)block) -> object :
    
    Wrapped function:
        cvPointSeqFromMat
    Argument 'mat':
        C/C++ type: ::CvArr const *.
        Python type: Mat.

    C++ signature :
        boost::python::api::object pointSeqFromMat(int,cv::Mat {lvalue},CvContour*,CvSeqBlock*)

polarToCart(...)

polarToCart( (Mat)magnitude, (Mat)angle, (Mat)x, (Mat)y [, (bool)angleInDegrees=False]) -> None :
    
    Computes x and y coordinates of 2D vectors from their magnitude and 
    angle.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#cv-polartocart

    C++ signature :
        void polarToCart(cv::Mat,cv::Mat,cv::Mat {lvalue},cv::Mat {lvalue} [,bool=False])

polylines(...)

polylines( (Mat)img, (object)pts, (bool)isClosed, (Scalar)color [, (object)thickness=1 [, (object)lineType=8 [, (object)shift=0]]]) -> None :
    
    Draws several polygonal curves.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/drawing_functions.html#cv-polylines
    Argument 'npts':
        Dependent argument: omitted from the function's calling sequence, as 
        its value is derived from argument 'pts'.
    Argument 'ncontours':
        Dependent argument: omitted from the function's calling sequence, as 
        its value is derived from argument 'pts'.
    Argument 'pts':
        C/C++ type: ::cv::Point const * *.
        Python type: list of Mat.

    C++ signature :
        void polylines(cv::Mat {lvalue},boost::python::api::object,bool,cv::Scalar_<double> [,int=1 [,int=8 [,int=0]]])

pow(...)

pow( (MatND)a, (object)power, (MatND)b) -> None :
    
    Raises every array element to a power.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#cv-pow

    C++ signature :
        void pow(cv::MatND,double,cv::MatND {lvalue})

pow( (Mat)a, (object)power, (Mat)b) -> None :
    
    Raises every array element to a power.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#cv-pow

    C++ signature :
        void pow(cv::Mat,double,cv::Mat {lvalue})

preCornerDetect(...)

preCornerDetect( (Mat)src, (Mat)dst, (object)ksize [, (object)borderType=4]) -> None :

    C++ signature :
        void preCornerDetect(cv::Mat,cv::Mat {lvalue},int [,int=4])

projectPoints(...)

projectPoints( (Mat)objectPoints, (Mat)rvec, (Mat)tvec, (Mat)cameraMatrix, (Mat)distCoeffs) -> object :
    
    Argument 'imagePoints':
        C/C++ type: ::std::vector< cv::Point_<float> > &.
        Python type: Mat.
        Invoke asMat() to convert a 1D Python sequence into a Mat, e.g. 
        asMat([0,1,2]) or asMat((0,1,2)).
        Output argument: omitted from the function's calling sequence, and is 
        returned along with the function's return value (if any).

    C++ signature :
        boost::python::api::object projectPoints(cv::Mat,cv::Mat,cv::Mat,cv::Mat,cv::Mat)

projectPoints2(...)

projectPoints2( (Mat)objectPoints, (Mat)rvec, (Mat)tvec, (Mat)cameraMatrix, (Mat)distCoeffs, (Mat)dpdrot, (Mat)dpdt, (Mat)dpdf, (Mat)dpdc, (Mat)dpddist [, (object)aspectRatio=0]) -> object :
    
    Wrapped function:
        projectPoints
    Argument 'imagePoints':
        C/C++ type: ::std::vector< cv::Point_<float> > &.
        Python type: Mat.
        Invoke asMat() to convert a 1D Python sequence into a Mat, e.g. 
        asMat([0,1,2]) or asMat((0,1,2)).
        Output argument: omitted from the function's calling sequence, and is 
        returned along with the function's return value (if any).

    C++ signature :
        boost::python::api::object projectPoints2(cv::Mat,cv::Mat,cv::Mat,cv::Mat,cv::Mat,cv::Mat {lvalue},cv::Mat {lvalue},cv::Mat {lvalue},cv::Mat {lvalue},cv::Mat {lvalue} [,double=0])

putText(...)

putText( (Mat)img, (object)text, (Point2i)org, (object)fontFace, (object)fontScale, (Scalar)color [, (object)thickness=1 [, (object)linetype=8 [, (bool)bottomLeftOrigin=False]]]) -> None :
    
    Draws a text string.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/drawing_functions.html#cv-puttext

    C++ signature :
        void putText(cv::Mat {lvalue},std::string,cv::Point_<int>,int,double,cv::Scalar_<double> [,int=1 [,int=8 [,bool=False]]])

pyrDown(...)

pyrDown( (Mat)src, (Mat)dst [, (Size2i)dstsize=Size2i(width=0, height=0)]) -> None :

    C++ signature :
        void pyrDown(cv::Mat,cv::Mat {lvalue} [,cv::Size_<int>=Size2i(width=0, height=0)])

pyrMeanShiftFiltering(...)

pyrMeanShiftFiltering( (Mat)src, (Mat)dst, (object)sp, (object)sr [, (object)max_level=1 [, (TermCriteria)termcrit=TermCriteria(type=3, maxCount=5, epsilon=1.0)]]) -> None :
    
    Wrapped function:
        cvPyrMeanShiftFiltering
    Argument 'src':
        C/C++ type: ::CvArr const *.
        Python type: Mat.
    Argument 'dst':
        C/C++ type: ::CvArr *.
        Python type: Mat.
    Argument 'termcrit':
        C/C++ type: ::CvTermCriteria.
        Python type: TermCriteria.

    C++ signature :
        void pyrMeanShiftFiltering(cv::Mat {lvalue},cv::Mat {lvalue},double,double [,int=1 [,cv::TermCriteria=TermCriteria(type=3, maxCount=5, epsilon=1.0)]])

pyrSegmentation(...)

pyrSegmentation( (Mat)src, (Mat)dst, (MemStorage)storage, (object)level, (object)threshold1, (object)threshold2) -> object :
    
    Wrapped function:
        cvPyrSegmentation
    Argument 'comp':
        C/C++ type: ::CvSeq * *.
        Python type: Python equivalence of the C/C++ type without pointer.
        Output argument: omitted from the function's calling sequence, and is 
        returned along with the function's return value (if any).
    Argument 'dst':
        C/C++ type: ::IplImage *.
        Python type: Mat.
    Argument 'storage':
        C/C++ type: ::CvMemStorage *.
        Python type: MemStorage.
    Argument 'src':
        C/C++ type: ::IplImage *.
        Python type: Mat.

    C++ signature :
        boost::python::api::object pyrSegmentation(cv::Mat {lvalue},cv::Mat {lvalue},cv::Ptr<CvMemStorage> {lvalue},int,double,double)

pyrUp(...)

pyrUp( (Mat)src, (Mat)dst [, (Size2i)dstsize=Size2i(width=0, height=0)]) -> None :

    C++ signature :
        void pyrUp(cv::Mat,cv::Mat {lvalue} [,cv::Size_<int>=Size2i(width=0, height=0)])

randArr(...)

randArr( (RNG)rng, (Mat)arr, (object)dist_type, (Scalar)param1, (Scalar)param2) -> None :
    
    Wrapped function:
        cvRandArr
    Argument 'arr':
        C/C++ type: ::CvArr *.
        Python type: Mat.
    Argument 'rng':
        C/C++ type: ::CvRNG *.
        Python type: RNG.
    Argument 'param2':
        C/C++ type: ::CvScalar.
        Python type: Scalar.
    Argument 'param1':
        C/C++ type: ::CvScalar.
        Python type: Scalar.

    C++ signature :
        void randArr(cv::RNG {lvalue},cv::Mat {lvalue},int,cv::Scalar_<double>,cv::Scalar_<double>)

randShuffle(...)

randShuffle( (Mat)dst [, (object)iterFactor=1.0 [, (RNG)rng=None]]) -> None :
    
    Shuffles the array elements randomly.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#cv-randshuffle

    C++ signature :
        void randShuffle(cv::Mat {lvalue} [,double=1.0 [,cv::RNG*=None]])

randn(...)

randn( (Mat)dst, (Scalar)mean, (Scalar)stddev) -> None :
    
    Fills array with normally distributed random numbers.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#cv-randn

    C++ signature :
        void randn(cv::Mat {lvalue},cv::Scalar_<double>,cv::Scalar_<double>)

randu(...)

randu( (Mat)dst, (Scalar)low, (Scalar)high) -> None :
    
    Generates a single uniformly-distributed random number or array of 
    random numbers.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#cv-randu

    C++ signature :
        void randu(cv::Mat {lvalue},cv::Scalar_<double>,cv::Scalar_<double>)

range_(...)

range_( (Mat)mat, (object)start, (object)end) -> object :
    
    Wrapped function:
        cvRange
    Argument 'mat':
        C/C++ type: ::CvArr *.
        Python type: Mat.

    C++ signature :
        boost::python::api::object range_(cv::Mat {lvalue},double,double)

readChainPoint(...)

readChainPoint( (CvChainPtReader)reader) -> CvPoint :
    
    Wrapped function:
        cvReadChainPoint

    C++ signature :
        CvPoint readChainPoint(CvChainPtReader*)

read_Mat(...)

read_Mat( (FileNode)node [, (Mat)default_mat=Mat()]) -> object :
    
    Wrapped function:
        read
    Argument 'mat':
        Output argument: omitted from the function's calling sequence, and is 
        returned along with the function's return value (if any).

    C++ signature :
        boost::python::api::object read_Mat(cv::FileNode [,cv::Mat=Mat()])

read_MatND(...)

read_MatND( (FileNode)node [, (MatND)default_mat=MatND(shape=(), nchannels=1, depth=0):
array(206, dtype=uint8)]) -> object :
    
    Wrapped function:
        read
    Argument 'mat':
        Output argument: omitted from the function's calling sequence, and is 
        returned along with the function's return value (if any).

    C++ signature :
        boost::python::api::object read_MatND(cv::FileNode [,cv::MatND=MatND(shape=(), nchannels=1, depth=0):
array(210, dtype=uint8)])

read_SparseMat(...)

read_SparseMat( (FileNode)node [, (SparseMat)default_mat=<pyopencv.pyopencvext.SparseMat object at 0x0340B630>]) -> object :
    
    Wrapped function:
        read
    Argument 'mat':
        Output argument: omitted from the function's calling sequence, and is 
        returned along with the function's return value (if any).

    C++ signature :
        boost::python::api::object read_SparseMat(cv::FileNode [,cv::SparseMat=<pyopencv.pyopencvext.SparseMat object at 0x0340B630>])

read_bool(...)

read_bool( (FileNode)node, (bool)default_value) -> object :
    
    Wrapped function:
        read
    Argument 'value':
        Output argument: omitted from the function's calling sequence, and is 
        returned along with the function's return value (if any).

    C++ signature :
        boost::python::api::object read_bool(cv::FileNode,bool)

read_float32(...)

read_float32( (FileNode)node, (object)default_value) -> object :
    
    Wrapped function:
        read
    Argument 'value':
        Output argument: omitted from the function's calling sequence, and is 
        returned along with the function's return value (if any).

    C++ signature :
        boost::python::api::object read_float32(cv::FileNode,float)

read_float64(...)

read_float64( (FileNode)node, (object)default_value) -> object :
    
    Wrapped function:
        read
    Argument 'value':
        Output argument: omitted from the function's calling sequence, and is 
        returned along with the function's return value (if any).

    C++ signature :
        boost::python::api::object read_float64(cv::FileNode,double)

read_int(...)

read_int( (FileNode)node, (object)default_value) -> object :
    
    Wrapped function:
        read
    Argument 'value':
        Output argument: omitted from the function's calling sequence, and is 
        returned along with the function's return value (if any).

    C++ signature :
        boost::python::api::object read_int(cv::FileNode,int)

read_int16(...)

read_int16( (FileNode)node, (object)default_value) -> object :
    
    Wrapped function:
        read
    Argument 'value':
        Output argument: omitted from the function's calling sequence, and is 
        returned along with the function's return value (if any).

    C++ signature :
        boost::python::api::object read_int16(cv::FileNode,short)

read_int8(...)

read_int8( (FileNode)node, (object)default_value) -> object :
    
    Wrapped function:
        read
    Argument 'value':
        Output argument: omitted from the function's calling sequence, and is 
        returned along with the function's return value (if any).

    C++ signature :
        boost::python::api::object read_int8(cv::FileNode,signed char)

read_list_of_KeyPoint(...)

read_list_of_KeyPoint( (FileNode)node) -> object :
    
    Wrapped function:
        read
    Argument 'keypoints':
        C/C++ type: ::std::vector< cv::KeyPoint > &.
        Python type: list of KeyPoint.
        To convert a Mat into a list, invoke one of Mat's member functions 
        to_list_of_...().
        Output argument: omitted from the function's calling sequence, and is 
        returned along with the function's return value (if any).

    C++ signature :
        boost::python::api::object read_list_of_KeyPoint(cv::FileNode)

read_str(...)

read_str( (FileNode)node, (object)default_value) -> object :
    
    Wrapped function:
        read
    Argument 'value':
        Output argument: omitted from the function's calling sequence, and is 
        returned along with the function's return value (if any).

    C++ signature :
        boost::python::api::object read_str(cv::FileNode,std::string)

read_uint16(...)

read_uint16( (FileNode)node, (object)default_value) -> object :
    
    Wrapped function:
        read
    Argument 'value':
        Output argument: omitted from the function's calling sequence, and is 
        returned along with the function's return value (if any).

    C++ signature :
        boost::python::api::object read_uint16(cv::FileNode,unsigned short)

read_uint8(...)

read_uint8( (FileNode)node, (object)default_value) -> object :
    
    Wrapped function:
        read
    Argument 'value':
        Output argument: omitted from the function's calling sequence, and is 
        returned along with the function's return value (if any).

    C++ signature :
        boost::python::api::object read_uint8(cv::FileNode,unsigned char)

rectangle(...)

rectangle( (Mat)img, (Rect)rec, (Scalar)color [, (object)thickness=1 [, (object)lineType=8 [, (object)shift=0]]]) -> None :
    
    Draws a simple, thick, or filled up-right rectangle.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/drawing_functions.html#cv-rectangle

    C++ signature :
        void rectangle(cv::Mat {lvalue},cv::Rect_<int>,cv::Scalar_<double> [,int=1 [,int=8 [,int=0]]])

rectangle( (Mat)img, (Point2i)pt1, (Point2i)pt2, (Scalar)color [, (object)thickness=1 [, (object)lineType=8 [, (object)shift=0]]]) -> None :
    
    Draws a simple, thick, or filled up-right rectangle.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/drawing_functions.html#cv-rectangle

    C++ signature :
        void rectangle(cv::Mat {lvalue},cv::Point_<int>,cv::Point_<int>,cv::Scalar_<double> [,int=1 [,int=8 [,int=0]]])

reduce(...)

reduce( (Mat)m, (Mat)dst, (object)dim, (object)rtype [, (object)dtype=-1]) -> None :
    
    Reduces a matrix to a vector.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#cv-reduce

    C++ signature :
        void reduce(cv::Mat,cv::Mat {lvalue},int,int [,int=-1])

registerModule(...)

registerModule( (CvModuleInfo)module_info) -> int :
    
    Wrapped function:
        cvRegisterModule

    C++ signature :
        int registerModule(CvModuleInfo const*)

registerType(...)

registerType( (CvTypeInfo)info) -> None :
    
    Wrapped function:
        cvRegisterType

    C++ signature :
        void registerType(CvTypeInfo const*)

remap(...)

remap( (Mat)src, (Mat)dst, (Mat)map1, (Mat)map2, (object)interpolation [, (object)borderMode=0 [, (Scalar)borderValue=Scalar([ 0.  0.  0.  0.])]]) -> None :

    C++ signature :
        void remap(cv::Mat,cv::Mat {lvalue},cv::Mat,cv::Mat,int [,int=0 [,cv::Scalar_<double>=Scalar([ 0.  0.  0.  0.])]])

repeat(...)

repeat( (Mat)src, (object)ny, (object)nx) -> Mat :
    
    Fill the destination array with repeated copies of the source array.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#cv-repeat

    C++ signature :
        cv::Mat repeat(cv::Mat,int,int)

repeat( (Mat)a, (object)ny, (object)nx, (Mat)b) -> None :
    
    Fill the destination array with repeated copies of the source array.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#cv-repeat

    C++ signature :
        void repeat(cv::Mat,int,int,cv::Mat {lvalue})

reprojectImageTo3D(...)

reprojectImageTo3D( (Mat)disparityImage, (Mat)_3dImage, (Mat)Q [, (object)handleMissingValues=0]) -> None :
    
    Wrapped function:
        cvReprojectImageTo3D
    Argument 'Q':
        C/C++ type: ::CvMat const *.
        Python type: Mat.
    Argument 'disparityImage':
        C/C++ type: ::CvArr const *.
        Python type: Mat.
    Argument '_3dImage':
        C/C++ type: ::CvArr *.
        Python type: Mat.

    C++ signature :
        void reprojectImageTo3D(cv::Mat {lvalue},cv::Mat {lvalue},cv::Mat {lvalue} [,int=0])

reprojectImageTo3D( (Mat)disparity, (Mat)_3dImage, (Mat)Q [, (bool)handleMissingValues=False]) -> None :

    C++ signature :
        void reprojectImageTo3D(cv::Mat,cv::Mat {lvalue},cv::Mat [,bool=False])

resize(...)

resize( (Mat)src, (Mat)dst, (Size2i)dsize [, (object)fx=0 [, (object)fy=0 [, (object)interpolation=1]]]) -> None :

    C++ signature :
        void resize(cv::Mat,cv::Mat {lvalue},cv::Size_<int> [,double=0 [,double=0 [,int=1]]])

resizeWindow(...)

resizeWindow( (str)name, (object)width, (object)height) -> None :
    
    Sets the window size.
    Wrapped function:
        cvResizeWindow
    Reference:
        http://opencv.willowgarage.com/documentation/c/user_interface.html#convertimage#resizewindow

    C++ signature :
        void resizeWindow(char const*,int,int)

restoreMemStoragePos(...)

restoreMemStoragePos( (MemStorage)storage, (CvMemStoragePos)pos) -> None :
    
    Wrapped function:
        cvRestoreMemStoragePos
    Argument 'storage':
        C/C++ type: ::CvMemStorage *.
        Python type: MemStorage.

    C++ signature :
        void restoreMemStoragePos(cv::Ptr<CvMemStorage> {lvalue},CvMemStoragePos*)

round(...)

round( (object)value) -> int :
    
    Wrapped function:
        cvRound

    C++ signature :
        int round(double)

runningAvg(...)

runningAvg( (Mat)image, (Mat)acc, (object)alpha [, (Mat)mask=Mat()]) -> None :
    
    Wrapped function:
        cvRunningAvg
    Argument 'acc':
        C/C++ type: ::CvArr *.
        Python type: Mat.
    Argument 'image':
        C/C++ type: ::CvArr const *.
        Python type: Mat.
    Argument 'mask':
        C/C++ type: ::CvArr const *.
        Python type: Mat.

    C++ signature :
        void runningAvg(cv::Mat {lvalue},cv::Mat {lvalue},double [,cv::Mat=Mat()])

sampleLine(...)

sampleLine( (Mat)image, (CvPoint)pt1, (CvPoint)pt2, (object)buffer [, (object)connectivity=8]) -> object :
    
    Wrapped function:
        cvSampleLine
    Argument 'image':
        C/C++ type: ::CvArr const *.
        Python type: Mat.

    C++ signature :
        boost::python::api::object sampleLine(cv::Mat {lvalue},CvPoint,CvPoint,void* [,int=8])

saveMemStoragePos(...)

saveMemStoragePos( (MemStorage)storage, (CvMemStoragePos)pos) -> None :
    
    Wrapped function:
        cvSaveMemStoragePos
    Argument 'storage':
        C/C++ type: ::CvMemStorage const *.
        Python type: MemStorage.

    C++ signature :
        void saveMemStoragePos(cv::Ptr<CvMemStorage> {lvalue},CvMemStoragePos*)

scaleAdd(...)

scaleAdd( (MatND)a, (object)alpha, (MatND)b, (MatND)c) -> None :
    
    Calculates the sum of a scaled array and another array.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#cv-scaleadd

    C++ signature :
        void scaleAdd(cv::MatND,double,cv::MatND,cv::MatND {lvalue})

scaleAdd( (Mat)a, (object)alpha, (Mat)b, (Mat)c) -> None :
    
    Calculates the sum of a scaled array and another array.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#cv-scaleadd

    C++ signature :
        void scaleAdd(cv::Mat,double,cv::Mat,cv::Mat {lvalue})

segmentImage(...)

segmentImage( (Mat)srcarr, (Mat)dstarr, (object)canny_threshold, (object)ffill_threshold, (MemStorage)storage) -> object :
    
    Wrapped function:
        cvSegmentImage
    Argument 'dstarr':
        C/C++ type: ::CvArr *.
        Python type: Mat.
    Argument 'srcarr':
        C/C++ type: ::CvArr const *.
        Python type: Mat.
    Argument 'storage':
        C/C++ type: ::CvMemStorage *.
        Python type: MemStorage.

    C++ signature :
        boost::python::api::object segmentImage(cv::Mat {lvalue},cv::Mat {lvalue},double,double,cv::Ptr<CvMemStorage> {lvalue})

segmentMotion(...)

segmentMotion( (Mat)mhi, (Mat)seg_mask, (MemStorage)storage, (object)timestamp, (object)seg_thresh) -> object :
    
    Wrapped function:
        cvSegmentMotion
    Argument 'storage':
        C/C++ type: ::CvMemStorage *.
        Python type: MemStorage.
    Argument 'seg_mask':
        C/C++ type: ::CvArr *.
        Python type: Mat.
    Argument 'mhi':
        C/C++ type: ::CvArr const *.
        Python type: Mat.

    C++ signature :
        boost::python::api::object segmentMotion(cv::Mat {lvalue},cv::Mat {lvalue},cv::Ptr<CvMemStorage> {lvalue},double,double)

sepFilter2D(...)

sepFilter2D( (Mat)src, (Mat)dst, (object)ddepth, (Mat)kernelX, (Mat)kernelY [, (Point2i)anchor=Point2i(x=-1, y=-1) [, (object)delta=0 [, (object)borderType=4]]]) -> None :

    C++ signature :
        void sepFilter2D(cv::Mat,cv::Mat {lvalue},int,cv::Mat,cv::Mat [,cv::Point_<int>=Point2i(x=-1, y=-1) [,double=0 [,int=4]]])

setErrMode(...)

setErrMode( (object)mode) -> int :
    
    Wrapped function:
        cvSetErrMode

    C++ signature :
        int setErrMode(int)

setErrStatus(...)

setErrStatus( (object)status) -> None :
    
    Wrapped function:
        cvSetErrStatus

    C++ signature :
        void setErrStatus(int)

setIdentity(...)

setIdentity( (Mat)c [, (Scalar)s=Scalar([ 1.  0.  0.  0.])]) -> None :
    
    Initializes a scaled identity matrix.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#cv-setidentity

    C++ signature :
        void setIdentity(cv::Mat {lvalue} [,cv::Scalar_<double>=Scalar([ 1.  0.  0.  0.])])

setNumThreads(...)

setNumThreads([  (object)threads=0]) -> None :
    
    Wrapped function:
        cvSetNumThreads

    C++ signature :
        void setNumThreads([ int=0])

setNumThreads( (object)arg0) -> None :

    C++ signature :
        void setNumThreads(int)

setRemove(...)

setRemove( (CvSet)set_header, (object)index) -> None :
    
    Wrapped function:
        cvSetRemove

    C++ signature :
        void setRemove(CvSet*,int)

setSeqBlockSize(...)

setSeqBlockSize( (CvSeq)seq, (object)delta_elems) -> None :
    
    Wrapped function:
        cvSetSeqBlockSize

    C++ signature :
        void setSeqBlockSize(CvSeq*,int)

setTrackbarPos(...)

setTrackbarPos( (object)trackbarname, (object)winname, (object)pos) -> None :
    
    Sets the trackbar position.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/user_interface.html#cv-settrackbarpos

    C++ signature :
        void setTrackbarPos(std::string,std::string,int)

setUseOptimized(...)

setUseOptimized( (bool)arg0) -> None :

    C++ signature :
        void setUseOptimized(bool)

setWindowProperty(...)

setWindowProperty( (object)winname, (object)prop_id, (object)prop_value) -> None :

    C++ signature :
        void setWindowProperty(std::string,int,double)

sliceLength(...)

sliceLength( (Range)slice, (CvSeq)seq) -> object :
    
    Wrapped function:
        cvSliceLength
    Argument 'slice':
        C/C++ type: ::CvSlice.
        Python type: Range.

    C++ signature :
        boost::python::api::object sliceLength(cv::Range,CvSeq const*)

smooth(...)

smooth( (Mat)src, (Mat)dst [, (object)smoothtype=2 [, (object)size1=3 [, (object)size2=0 [, (object)sigma1=0 [, (object)sigma2=0]]]]]) -> None :
    
    Wrapped function:
        cvSmooth
    Argument 'src':
        C/C++ type: ::CvArr const *.
        Python type: Mat.
    Argument 'dst':
        C/C++ type: ::CvArr *.
        Python type: Mat.

    C++ signature :
        void smooth(cv::Mat {lvalue},cv::Mat {lvalue} [,int=2 [,int=3 [,int=0 [,double=0 [,double=0]]]]])

snakeImage(...)

snakeImage( (Mat)image, (Mat)points, (object)alpha, (object)beta, (object)gamma, (object)coeff_usage, (Size2i)win, (TermCriteria)criteria [, (object)calc_gradient=1]) -> None :

    C++ signature :
        void snakeImage(cv::Mat,cv::Mat,boost::python::api::object,boost::python::api::object,boost::python::api::object,int,cv::Size_<int>,cv::TermCriteria [,int=1])

solve(...)

solve( (Mat)a, (Mat)b, (Mat)x [, (object)flags=0]) -> bool :
    
    Solves one or more linear systems or least-squares problems.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#cv-solve

    C++ signature :
        bool solve(cv::Mat,cv::Mat,cv::Mat {lvalue} [,int=0])

solveCubic(...)

solveCubic( (Mat)coeffs, (Mat)roots) -> object :
    
    Wrapped function:
        cvSolveCubic
    Argument 'coeffs':
        C/C++ type: ::CvMat const *.
        Python type: Mat.
    Argument 'roots':
        C/C++ type: ::CvMat *.
        Python type: Mat.

    C++ signature :
        boost::python::api::object solveCubic(cv::Mat {lvalue},cv::Mat {lvalue})

solvePnP(...)

solvePnP( (Mat)objectPoints, (Mat)imagePoints, (Mat)cameraMatrix, (Mat)distCoeffs, (Mat)rvec, (Mat)tvec [, (bool)useExtrinsicGuess=False]) -> None :

    C++ signature :
        void solvePnP(cv::Mat,cv::Mat,cv::Mat,cv::Mat,cv::Mat {lvalue},cv::Mat {lvalue} [,bool=False])

solvePoly(...)

solvePoly( (Mat)coeffs, (Mat)roots2 [, (object)maxiter=20 [, (object)fig=100]]) -> None :
    
    Wrapped function:
        cvSolvePoly
    Argument 'coeffs':
        C/C++ type: ::CvMat const *.
        Python type: Mat.
    Argument 'roots2':
        C/C++ type: ::CvMat *.
        Python type: Mat.

    C++ signature :
        void solvePoly(cv::Mat {lvalue},cv::Mat {lvalue} [,int=20 [,int=100]])

sort(...)

sort( (Mat)a, (Mat)b, (object)flags) -> None :
    
    Sorts each row or each column of a matrix.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#cv-sort

    C++ signature :
        void sort(cv::Mat,cv::Mat {lvalue},int)

sortIdx(...)

sortIdx( (Mat)a, (Mat)b, (object)flags) -> None :
    
    Sorts each row or each column of a matrix.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#cv-sortIdx

    C++ signature :
        void sortIdx(cv::Mat,cv::Mat {lvalue},int)

split(...)

split( (MatND)m, (vector_MatND)mv) -> None :
    
    Divides multi-channel array into several single-channel arrays.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#cv-split

    C++ signature :
        void split(cv::MatND,std::vector<cv::MatND, std::allocator<cv::MatND> > {lvalue})

split( (Mat)m, (vector_Mat)mv) -> None :
    
    Divides multi-channel array into several single-channel arrays.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#cv-split

    C++ signature :
        void split(cv::Mat,std::vector<cv::Mat, std::allocator<cv::Mat> > {lvalue})

sqrt(...)

sqrt( (MatND)a, (MatND)b) -> None :
    
    Calculates square root of array elements.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#cv-sqrt

    C++ signature :
        void sqrt(cv::MatND,cv::MatND {lvalue})

sqrt( (Mat)a, (Mat)b) -> None :
    
    Calculates square root of array elements.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#cv-sqrt

    C++ signature :
        void sqrt(cv::Mat,cv::Mat {lvalue})

squareAcc(...)

squareAcc( (Mat)image, (Mat)sqsum [, (Mat)mask=Mat()]) -> None :
    
    Wrapped function:
        cvSquareAcc
    Argument 'mask':
        C/C++ type: ::CvArr const *.
        Python type: Mat.
    Argument 'image':
        C/C++ type: ::CvArr const *.
        Python type: Mat.
    Argument 'sqsum':
        C/C++ type: ::CvArr *.
        Python type: Mat.

    C++ signature :
        void squareAcc(cv::Mat {lvalue},cv::Mat {lvalue} [,cv::Mat=Mat()])

starKeypoint(...)

starKeypoint( (CvPoint)pt, (object)size, (object)response) -> CvStarKeypoint :
    
    Wrapped function:
        cvStarKeypoint

    C++ signature :
        CvStarKeypoint starKeypoint(CvPoint,int,float)

startFindContours(...)

startFindContours( (Mat)image, (MemStorage)storage [, (object)header_size=88 [, (object)mode=1 [, (object)method=2 [, (CvPoint)offset=CvPoint(x=0, y=0)]]]]) -> object :
    
    Wrapped function:
        cvStartFindContours
    Argument 'image':
        C/C++ type: ::CvArr *.
        Python type: Mat.
    Argument 'storage':
        C/C++ type: ::CvMemStorage *.
        Python type: MemStorage.

    C++ signature :
        boost::python::api::object startFindContours(cv::Mat {lvalue},cv::Ptr<CvMemStorage> {lvalue} [,int=88 [,int=1 [,int=2 [,CvPoint=CvPoint(x=0, y=0)]]]])

startNextStream(...)

startNextStream( (FileStorage)fs) -> None :
    
    Wrapped function:
        cvStartNextStream
    Argument 'fs':
        C/C++ type: ::CvFileStorage *.
        Python type: FileStorage.

    C++ signature :
        void startNextStream(cv::FileStorage {lvalue})

startReadChainPoints(...)

startReadChainPoints( (CvChain)chain, (CvChainPtReader)reader) -> None :
    
    Wrapped function:
        cvStartReadChainPoints

    C++ signature :
        void startReadChainPoints(CvChain*,CvChainPtReader*)

startWindowThread()

    Wrapped function:
        cvStartWindowThread

    C++ signature :
        int startWindowThread()

Returns: int :

startWriteStruct(...)

startWriteStruct( (FileStorage)fs, (str)name, (object)struct_flags [, (str)type_name=None [, (CvAttrList)attributes=<pyopencv.pyopencvext.CvAttrList object at 0x0340B3F0>]]) -> None :
    
    Wrapped function:
        cvStartWriteStruct
    Argument 'fs':
        C/C++ type: ::CvFileStorage *.
        Python type: FileStorage.

    C++ signature :
        void startWriteStruct(cv::FileStorage {lvalue},char const*,int [,char const*=None [,CvAttrList=<pyopencv.pyopencvext.CvAttrList object at 0x0340B3F0>]])

stereoCalibrate(...)

stereoCalibrate( (list)objectPoints, (list)imagePoints1, (list)imagePoints2, (Mat)cameraMatrix1, (Mat)distCoeffs1, (Mat)cameraMatrix2, (Mat)distCoeffs2, (Size2i)imageSize, (Mat)R, (Mat)T, (Mat)E, (Mat)F [, (TermCriteria)criteria=TermCriteria(type=3, maxCount=30, epsilon=9.9999999999999995e-07) [, (object)flags=256]]) -> object :
    
    Argument 'objectPoints':
        C/C++ type: ::std::vector< std::vector< cv::Point3_<float> > > const 
        &.
        Python type: list of Mat, e.g. [Mat(), Mat(), Mat()].
        Invoke asMat() to convert every 1D Python sequence into a Mat, e.g. 
        [asMat([0,1,2]), asMat((0,1,2)].
    Argument 'imagePoints2':
        C/C++ type: ::std::vector< std::vector< cv::Point_<float> > > const &.
        Python type: list of Mat, e.g. [Mat(), Mat(), Mat()].
        Invoke asMat() to convert every 1D Python sequence into a Mat, e.g. 
        [asMat([0,1,2]), asMat((0,1,2)].
    Argument 'imagePoints1':
        C/C++ type: ::std::vector< std::vector< cv::Point_<float> > > const &.
        Python type: list of Mat, e.g. [Mat(), Mat(), Mat()].
        Invoke asMat() to convert every 1D Python sequence into a Mat, e.g. 
        [asMat([0,1,2]), asMat((0,1,2)].

    C++ signature :
        boost::python::api::object stereoCalibrate(boost::python::list,boost::python::list,boost::python::list,cv::Mat {lvalue},cv::Mat {lvalue},cv::Mat {lvalue},cv::Mat {lvalue},cv::Size_<int>,cv::Mat {lvalue},cv::Mat {lvalue},cv::Mat {lvalue},cv::Mat {lvalue} [,cv::TermCriteria=TermCriteria(type=3, maxCount=30, epsilon=9.9999999999999995e-07) [,int=256]])

stereoRectify(...)

stereoRectify( (Mat)cameraMatrix1, (Mat)distCoeffs1, (Mat)cameraMatrix2, (Mat)distCoeffs2, (Size2i)imageSize, (Mat)R, (Mat)T, (Mat)R1, (Mat)R2, (Mat)P1, (Mat)P2, (Mat)Q [, (object)flags=1024]) -> None :

    C++ signature :
        void stereoRectify(cv::Mat,cv::Mat,cv::Mat,cv::Mat,cv::Size_<int>,cv::Mat,cv::Mat,cv::Mat {lvalue},cv::Mat {lvalue},cv::Mat {lvalue},cv::Mat {lvalue},cv::Mat {lvalue} [,int=1024])

stereoRectify2(...)

stereoRectify2( (Mat)cameraMatrix1, (Mat)distCoeffs1, (Mat)cameraMatrix2, (Mat)distCoeffs2, (Size2i)imageSize, (Mat)R, (Mat)T, (Mat)R1, (Mat)R2, (Mat)P1, (Mat)P2, (Mat)Q, (object)alpha [, (Size2i)newImageSize=Size2i(width=0, height=0) [, (object)flags=1024]]) -> tuple :
    
    Wrapped function:
        stereoRectify
    Argument 'validPixROI2':
        C/C++ type: ::cv::Rect *.
        Python type: Python equivalence of the C/C++ type without pointer.
        Output argument: omitted from the function's calling sequence, and is 
        returned along with the function's return value (if any).
    Argument 'validPixROI1':
        C/C++ type: ::cv::Rect *.
        Python type: Python equivalence of the C/C++ type without pointer.
        Output argument: omitted from the function's calling sequence, and is 
        returned along with the function's return value (if any).

    C++ signature :
        boost::python::tuple stereoRectify2(cv::Mat,cv::Mat,cv::Mat,cv::Mat,cv::Size_<int>,cv::Mat,cv::Mat,cv::Mat {lvalue},cv::Mat {lvalue},cv::Mat {lvalue},cv::Mat {lvalue},cv::Mat {lvalue},double [,cv::Size_<int>=Size2i(width=0, height=0) [,int=1024]])

stereoRectifyUncalibrated(...)

stereoRectifyUncalibrated( (Mat)points1, (Mat)points2, (Mat)F, (Size2i)imgSize, (Mat)H1, (Mat)H2 [, (object)threshold=5]) -> bool :

    C++ signature :
        bool stereoRectifyUncalibrated(cv::Mat,cv::Mat,cv::Mat,cv::Size_<int>,cv::Mat {lvalue},cv::Mat {lvalue} [,double=5])

subdiv2DEdgeDst(...)

subdiv2DEdgeDst( (object)edge) -> CvSubdiv2DPoint :
    
    Wrapped function:
        cvSubdiv2DEdgeDst

    C++ signature :
        CvSubdiv2DPoint* subdiv2DEdgeDst(unsigned int)

subdiv2DEdgeOrg(...)

subdiv2DEdgeOrg( (object)edge) -> CvSubdiv2DPoint :
    
    Wrapped function:
        cvSubdiv2DEdgeOrg

    C++ signature :
        CvSubdiv2DPoint* subdiv2DEdgeOrg(unsigned int)

subdiv2DGetEdge(...)

subdiv2DGetEdge( (object)edge, (CvNextEdgeType)type) -> int :
    
    Wrapped function:
        cvSubdiv2DGetEdge

    C++ signature :
        unsigned int subdiv2DGetEdge(unsigned int,CvNextEdgeType)

subdiv2DLocate(...)

subdiv2DLocate( (CvSubdiv2D)subdiv, (Point2f)pt, (object)edge) -> tuple :
    
    Wrapped function:
        cvSubdiv2DLocate
    Argument 'vertex':
        C/C++ type: ::CvSubdiv2DPoint * *.
        Python type: Python equivalence of the C/C++ type without pointer.
        Output argument: omitted from the function's calling sequence, and is 
        returned along with the function's return value (if any).
    Argument 'pt':
        C/C++ type: ::CvPoint2D32f.
        Python type: Point2f.

    C++ signature :
        boost::python::tuple subdiv2DLocate(CvSubdiv2D*,cv::Point_<float>,unsigned int*)

subdiv2DNextEdge(...)

subdiv2DNextEdge( (object)edge) -> int :
    
    Wrapped function:
        cvSubdiv2DNextEdge

    C++ signature :
        unsigned int subdiv2DNextEdge(unsigned int)

subdiv2DRotateEdge(...)

subdiv2DRotateEdge( (object)edge, (object)rotate) -> int :
    
    Wrapped function:
        cvSubdiv2DRotateEdge

    C++ signature :
        unsigned int subdiv2DRotateEdge(unsigned int,int)

subdiv2DSymEdge(...)

subdiv2DSymEdge( (object)edge) -> int :
    
    Wrapped function:
        cvSubdiv2DSymEdge

    C++ signature :
        unsigned int subdiv2DSymEdge(unsigned int)

subdivDelaunay2DInsert(...)

subdivDelaunay2DInsert( (CvSubdiv2D)subdiv, (Point2f)pt) -> object :
    
    Wrapped function:
        cvSubdivDelaunay2DInsert
    Argument 'pt':
        C/C++ type: ::CvPoint2D32f.
        Python type: Point2f.

    C++ signature :
        boost::python::api::object subdivDelaunay2DInsert(CvSubdiv2D*,cv::Point_<float>)

substituteContour(...)

substituteContour( (CvContourScanner)scanner, (CvSeq)new_contour) -> None :
    
    Wrapped function:
        cvSubstituteContour

    C++ signature :
        void substituteContour(_CvContourScanner*,CvSeq*)

subtract(...)

subtract( (MatND)a, (Scalar)s, (MatND)c [, (MatND)mask=MatND(shape=(), nchannels=1, depth=0):
array(6, dtype=uint8)]) -> None :
    
    Calculates per-element difference between two arrays or array and a 
    scalar.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#cv-subtract

    C++ signature :
        void subtract(cv::MatND,cv::Scalar_<double>,cv::MatND {lvalue} [,cv::MatND=MatND(shape=(), nchannels=1, depth=0):
array(10, dtype=uint8)])

subtract( (Scalar)s, (MatND)a, (MatND)c [, (MatND)mask=MatND(shape=(), nchannels=1, depth=0):
array(250, dtype=uint8)]) -> None :
    
    Calculates per-element difference between two arrays or array and a 
    scalar.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#cv-subtract

    C++ signature :
        void subtract(cv::Scalar_<double>,cv::MatND,cv::MatND {lvalue} [,cv::MatND=MatND(shape=(), nchannels=1, depth=0):
array(255, dtype=uint8)])

subtract( (MatND)a, (MatND)b, (MatND)c) -> None :
    
    Calculates per-element difference between two arrays or array and a 
    scalar.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#cv-subtract

    C++ signature :
        void subtract(cv::MatND,cv::MatND,cv::MatND {lvalue})

subtract( (MatND)a, (MatND)b, (MatND)c, (MatND)mask) -> None :
    
    Calculates per-element difference between two arrays or array and a 
    scalar.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#cv-subtract

    C++ signature :
        void subtract(cv::MatND,cv::MatND,cv::MatND {lvalue},cv::MatND)

subtract( (Scalar)s, (Mat)a, (Mat)c [, (Mat)mask=Mat()]) -> None :
    
    Calculates per-element difference between two arrays or array and a 
    scalar.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#cv-subtract

    C++ signature :
        void subtract(cv::Scalar_<double>,cv::Mat,cv::Mat {lvalue} [,cv::Mat=Mat()])

subtract( (Mat)a, (Scalar)s, (Mat)c [, (Mat)mask=Mat()]) -> None :
    
    Calculates per-element difference between two arrays or array and a 
    scalar.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#cv-subtract

    C++ signature :
        void subtract(cv::Mat,cv::Scalar_<double>,cv::Mat {lvalue} [,cv::Mat=Mat()])

subtract( (Mat)a, (Mat)b, (Mat)c) -> None :
    
    Calculates per-element difference between two arrays or array and a 
    scalar.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#cv-subtract

    C++ signature :
        void subtract(cv::Mat,cv::Mat,cv::Mat {lvalue})

subtract( (Mat)a, (Mat)b, (Mat)c, (Mat)mask) -> None :
    
    Calculates per-element difference between two arrays or array and a 
    scalar.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#cv-subtract

    C++ signature :
        void subtract(cv::Mat,cv::Mat,cv::Mat {lvalue},cv::Mat)

sum(...)

sum( (MatND)m) -> Scalar :
    
    Calculates sum of array elements.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#cv-sum

    C++ signature :
        cv::Scalar_<double> sum(cv::MatND)

sum( (Mat)m) -> Scalar :
    
    Calculates sum of array elements.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#cv-sum

    C++ signature :
        cv::Scalar_<double> sum(cv::Mat)

theRNG()

    Returns the default random number generator.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#cv-therng

    C++ signature :
        cv::RNG {lvalue} theRNG()

Returns: RNG :

threshold(...)

threshold( (Mat)src, (Mat)dst, (object)thresh, (object)maxval, (object)type) -> float :

    C++ signature :
        double threshold(cv::Mat,cv::Mat {lvalue},double,double,int)

toUtf16(...)

toUtf16( (object)str) -> unicode :

    C++ signature :
        std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t> > toUtf16(std::string)

trace(...)

trace( (Mat)m) -> Scalar :
    
    Returns the trace of a matrix.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#cv-trace

    C++ signature :
        cv::Scalar_<double> trace(cv::Mat)

transform(...)

transform( (Mat)src, (Mat)dst, (Mat)m) -> None :
    
    Performs matrix transformation of every array element.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#cv-transform

    C++ signature :
        void transform(cv::Mat,cv::Mat {lvalue},cv::Mat)

transpose(...)

transpose( (Mat)a, (Mat)b) -> None :
    
    Transposes a matrix.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#cv-transpose

    C++ signature :
        void transpose(cv::Mat,cv::Mat {lvalue})

triangleArea(...)

triangleArea( (Point2f)a, (Point2f)b, (Point2f)c) -> object :
    
    Wrapped function:
        cvTriangleArea
    Argument 'a':
        C/C++ type: ::CvPoint2D32f.
        Python type: Point2f.
    Argument 'c':
        C/C++ type: ::CvPoint2D32f.
        Python type: Point2f.
    Argument 'b':
        C/C++ type: ::CvPoint2D32f.
        Python type: Point2f.

    C++ signature :
        boost::python::api::object triangleArea(cv::Point_<float>,cv::Point_<float>,cv::Point_<float>)

triangulatePoints(...)

triangulatePoints( (Mat)projMatr1, (Mat)projMatr2, (Mat)projPoints1, (Mat)projPoints2, (Mat)points4D) -> None :
    
    Wrapped function:
        cvTriangulatePoints
    Argument 'projPoints2':
        C/C++ type: ::CvMat *.
        Python type: Mat.
    Argument 'projPoints1':
        C/C++ type: ::CvMat *.
        Python type: Mat.
    Argument 'projMatr2':
        C/C++ type: ::CvMat *.
        Python type: Mat.
    Argument 'points4D':
        C/C++ type: ::CvMat *.
        Python type: Mat.
    Argument 'projMatr1':
        C/C++ type: ::CvMat *.
        Python type: Mat.

    C++ signature :
        void triangulatePoints(cv::Mat {lvalue},cv::Mat {lvalue},cv::Mat {lvalue},cv::Mat {lvalue},cv::Mat {lvalue})

typeOf(...)

typeOf( (object)struct_ptr) -> object :
    
    Wrapped function:
        cvTypeOf

    C++ signature :
        boost::python::api::object typeOf(void*)

undistort(...)

undistort( (Mat)src, (Mat)dst, (Mat)cameraMatrix, (Mat)distCoeffs [, (Mat)newCameraMatrix=Mat()]) -> None :

    C++ signature :
        void undistort(cv::Mat,cv::Mat {lvalue},cv::Mat,cv::Mat [,cv::Mat=Mat()])

undistortPoints(...)

undistortPoints( (Mat)src, (Mat)dst, (Mat)cameraMatrix, (Mat)distCoeffs [, (Mat)R=Mat() [, (Mat)P=Mat()]]) -> None :

    C++ signature :
        void undistortPoints(cv::Mat,cv::Mat {lvalue},cv::Mat,cv::Mat [,cv::Mat=Mat() [,cv::Mat=Mat()]])

undistortPoints2(...)

undistortPoints2( (Mat)src, (Mat)cameraMatrix, (Mat)distCoeffs [, (Mat)R=Mat() [, (Mat)P=Mat()]]) -> object :
    
    Wrapped function:
        undistortPoints
    Argument 'dst':
        C/C++ type: ::std::vector< cv::Point_<float> > &.
        Python type: Mat.
        Invoke asMat() to convert a 1D Python sequence into a Mat, e.g. 
        asMat([0,1,2]) or asMat((0,1,2)).
        Output argument: omitted from the function's calling sequence, and is 
        returned along with the function's return value (if any).

    C++ signature :
        boost::python::api::object undistortPoints2(cv::Mat,cv::Mat,cv::Mat [,cv::Mat=Mat() [,cv::Mat=Mat()]])

unregisterType(...)

unregisterType( (str)type_name) -> None :
    
    Wrapped function:
        cvUnregisterType

    C++ signature :
        void unregisterType(char const*)

updateMotionHistory(...)

updateMotionHistory( (Mat)silhouette, (Mat)mhi, (object)timestamp, (object)duration) -> None :
    
    Wrapped function:
        cvUpdateMotionHistory
    Argument 'silhouette':
        C/C++ type: ::CvArr const *.
        Python type: Mat.
    Argument 'mhi':
        C/C++ type: ::CvArr *.
        Python type: Mat.

    C++ signature :
        void updateMotionHistory(cv::Mat {lvalue},cv::Mat {lvalue},double,double)

updateMotionHistory( (Mat)silhouette, (Mat)mhi, (object)timestamp, (object)duration) -> None :

    C++ signature :
        void updateMotionHistory(cv::Mat,cv::Mat {lvalue},double,double)

useOptimized(...)

useOptimized( (object)on_off) -> int :
    
    Wrapped function:
        cvUseOptimized

    C++ signature :
        int useOptimized(int)

useOptimized() -> bool :

    C++ signature :
        bool useOptimized()

validateDisparity(...)

validateDisparity( (Mat)disparity, (Mat)cost, (object)minDisparity, (object)numberOfDisparities [, (object)disp12MaxDisp=1]) -> None :

    C++ signature :
        void validateDisparity(cv::Mat {lvalue},cv::Mat,int,int [,int=1])

waitKey(...)

waitKey([  (object)delay=0]) -> int :
    
    Waits for a pressed key.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/user_interface.html#cv-waitkey

    C++ signature :
        int waitKey([ int=0])

warpAffine(...)

warpAffine( (Mat)src, (Mat)dst, (Mat)M, (Size2i)dsize [, (object)flags=1 [, (object)borderMode=0 [, (Scalar)borderValue=Scalar([ 0.  0.  0.  0.])]]]) -> None :

    C++ signature :
        void warpAffine(cv::Mat,cv::Mat {lvalue},cv::Mat,cv::Size_<int> [,int=1 [,int=0 [,cv::Scalar_<double>=Scalar([ 0.  0.  0.  0.])]]])

warpPerspective(...)

warpPerspective( (Mat)src, (Mat)dst, (Mat)M, (Size2i)dsize [, (object)flags=1 [, (object)borderMode=0 [, (Scalar)borderValue=Scalar([ 0.  0.  0.  0.])]]]) -> None :

    C++ signature :
        void warpPerspective(cv::Mat,cv::Mat {lvalue},cv::Mat,cv::Size_<int> [,int=1 [,int=0 [,cv::Scalar_<double>=Scalar([ 0.  0.  0.  0.])]]])

watershed(...)

watershed( (Mat)image, (Mat)markers) -> None :

    C++ signature :
        void watershed(cv::Mat,cv::Mat {lvalue})

write(...)

write( (FileStorage)fs, (str)name, (str)ptr [, (CvAttrList)attributes=<pyopencv.pyopencvext.CvAttrList object at 0x0340B430>]) -> None :
    
    Wrapped function:
        cvWrite
    Argument 'fs':
        C/C++ type: ::CvFileStorage *.
        Python type: FileStorage.
    Argument 'ptr':
        C/C++ type: void const *.
        Python type: string.

    C++ signature :
        void write(cv::FileStorage {lvalue},char const*,char const* [,CvAttrList=<pyopencv.pyopencvext.CvAttrList object at 0x0340B430>])

writeComment(...)

writeComment( (FileStorage)fs, (str)comment, (object)eol_comment) -> None :
    
    Wrapped function:
        cvWriteComment
    Argument 'fs':
        C/C++ type: ::CvFileStorage *.
        Python type: FileStorage.

    C++ signature :
        void writeComment(cv::FileStorage {lvalue},char const*,int)

writeFileNode(...)

writeFileNode( (FileStorage)fs, (str)new_node_name, (FileNode)node, (object)embed) -> None :
    
    Wrapped function:
        cvWriteFileNode
    Argument 'node':
        C/C++ type: ::CvFileNode const *.
        Python type: FileNode.
    Argument 'fs':
        C/C++ type: ::CvFileStorage *.
        Python type: FileStorage.

    C++ signature :
        void writeFileNode(cv::FileStorage {lvalue},char const*,cv::FileNode,int)

write_Mat(...)

write_Mat( (FileStorage)fs, (object)name, (Mat)value) -> None :
    
    Wrapped function:
        write

    C++ signature :
        void write_Mat(cv::FileStorage {lvalue},std::string,cv::Mat)

write_MatND(...)

write_MatND( (FileStorage)fs, (object)name, (MatND)value) -> None :
    
    Wrapped function:
        write

    C++ signature :
        void write_MatND(cv::FileStorage {lvalue},std::string,cv::MatND)

write_Range(...)

write_Range( (FileStorage)fs, (object)name, (Range)r) -> None :
    
    Wrapped function:
        write

    C++ signature :
        void write_Range(cv::FileStorage {lvalue},std::string,cv::Range)

write_Range( (FileStorage)fs, (Range)r) -> None :
    
    Wrapped function:
        write

    C++ signature :
        void write_Range(cv::FileStorage {lvalue},cv::Range)

write_SparseMat(...)

write_SparseMat( (FileStorage)fs, (object)name, (SparseMat)value) -> None :
    
    Wrapped function:
        write

    C++ signature :
        void write_SparseMat(cv::FileStorage {lvalue},std::string,cv::SparseMat)

write_float32(...)

write_float32( (FileStorage)fs, (object)value) -> None :
    
    Wrapped function:
        write

    C++ signature :
        void write_float32(cv::FileStorage {lvalue},float)

write_float32( (FileStorage)fs, (object)name, (object)value) -> None :
    
    Wrapped function:
        write

    C++ signature :
        void write_float32(cv::FileStorage {lvalue},std::string,float)

write_float64(...)

write_float64( (FileStorage)fs, (object)value) -> None :
    
    Wrapped function:
        write

    C++ signature :
        void write_float64(cv::FileStorage {lvalue},double)

write_float64( (FileStorage)fs, (object)name, (object)value) -> None :
    
    Wrapped function:
        write

    C++ signature :
        void write_float64(cv::FileStorage {lvalue},std::string,double)

write_int(...)

write_int( (FileStorage)fs, (object)value) -> None :
    
    Wrapped function:
        write

    C++ signature :
        void write_int(cv::FileStorage {lvalue},int)

write_int( (FileStorage)fs, (object)name, (object)value) -> None :
    
    Wrapped function:
        write

    C++ signature :
        void write_int(cv::FileStorage {lvalue},std::string,int)

write_list_of_KeyPoint(...)

write_list_of_KeyPoint( (FileStorage)fs, (object)name, (list)keypoints) -> None :
    
    Wrapped function:
        write
    Argument 'keypoints':
        C/C++ type: ::std::vector< cv::KeyPoint > const &.
        Python type: list of KeyPoint.
        To convert a Mat into a list, invoke one of Mat's member functions 
        to_list_of_...().

    C++ signature :
        void write_list_of_KeyPoint(cv::FileStorage {lvalue},std::string,boost::python::list)

write_str(...)

write_str( (FileStorage)fs, (object)value) -> None :
    
    Wrapped function:
        write

    C++ signature :
        void write_str(cv::FileStorage {lvalue},std::string)

write_str( (FileStorage)fs, (object)name, (object)value) -> None :
    
    Wrapped function:
        write

    C++ signature :
        void write_str(cv::FileStorage {lvalue},std::string,std::string)

Variables Details

[hide private]

CENTERS_GONZALES

Value:

pyopencv.pyopencvext.flann_centers_init_t.CENTERS_GONZALES

CENTERS_KMEANSPP

Value:

pyopencv.pyopencvext.flann_centers_init_t.CENTERS_KMEANSPP

CENTERS_RANDOM

Value:

pyopencv.pyopencvext.flann_centers_init_t.CENTERS_RANDOM

CV_BADCHANNELS_ERR

Value:

pyopencv.pyopencvext.CvStatus.CV_BADCHANNELS_ERR

CV_BADCONVERGENCE_ERR

Value:

pyopencv.pyopencvext.CvStatus.CV_BADCONVERGENCE_ERR

CV_BADMEMBLOCK_ERR

Value:

pyopencv.pyopencvext.CvStatus.CV_BADMEMBLOCK_ERR

CV_CALIB_ETALON_CHECKERBOARD

Value:

pyopencv.pyopencvext.CvCalibEtalonType.CV_CALIB_ETALON_CHECKERBOARD

CV_CALIB_ETALON_CHESSBOARD

Value:

pyopencv.pyopencvext.CvCalibEtalonType.CV_CALIB_ETALON_CHESSBOARD

CV_CALIB_ETALON_USER

Value:

pyopencv.pyopencvext.CvCalibEtalonType.CV_CALIB_ETALON_USER

CV_DIV_BY_ZERO_ERR

Value:

pyopencv.pyopencvext.CvStatus.CV_DIV_BY_ZERO_ERR

CV_FACE_LEFT_EYE

Value:

pyopencv.pyopencvext.CV_FACE_ELEMENTS.CV_FACE_LEFT_EYE

CV_FACE_MOUTH

Value:

pyopencv.pyopencvext.CV_FACE_ELEMENTS.CV_FACE_MOUTH

CV_FACE_RIGHT_EYE

Value:

pyopencv.pyopencvext.CV_FACE_ELEMENTS.CV_FACE_RIGHT_EYE

CV_INPLACE_NOT_SUPPORTED_ERR

Value:

pyopencv.pyopencvext.CvStatus.CV_INPLACE_NOT_SUPPORTED_ERR

CV_LEE_DOUBLE

Value:

pyopencv.pyopencvext.CvLeeParameters.CV_LEE_DOUBLE

CV_NEXT_AROUND_DST

Value:

pyopencv.pyopencvext.CvNextEdgeType.CV_NEXT_AROUND_DST

CV_NEXT_AROUND_LEFT

Value:

pyopencv.pyopencvext.CvNextEdgeType.CV_NEXT_AROUND_LEFT

CV_NEXT_AROUND_ORG

Value:

pyopencv.pyopencvext.CvNextEdgeType.CV_NEXT_AROUND_ORG

CV_NEXT_AROUND_RIGHT

Value:

pyopencv.pyopencvext.CvNextEdgeType.CV_NEXT_AROUND_RIGHT

CV_NOTDEFINED_ERR

Value:

pyopencv.pyopencvext.CvStatus.CV_NOTDEFINED_ERR

CV_NOT_WEIGHTED

Value:

pyopencv.pyopencvext.CvGraphWeightType.CV_NOT_WEIGHTED

CV_PREV_AROUND_DST

Value:

pyopencv.pyopencvext.CvNextEdgeType.CV_PREV_AROUND_DST

CV_PREV_AROUND_LEFT

Value:

pyopencv.pyopencvext.CvNextEdgeType.CV_PREV_AROUND_LEFT

CV_PREV_AROUND_ORG

Value:

pyopencv.pyopencvext.CvNextEdgeType.CV_PREV_AROUND_ORG

CV_PREV_AROUND_RIGHT

Value:

pyopencv.pyopencvext.CvNextEdgeType.CV_PREV_AROUND_RIGHT

CV_PTLOC_ERROR

Value:

pyopencv.pyopencvext.CvSubdiv2DPointLocation.CV_PTLOC_ERROR

CV_PTLOC_INSIDE

Value:

pyopencv.pyopencvext.CvSubdiv2DPointLocation.CV_PTLOC_INSIDE

CV_PTLOC_ON_EDGE

Value:

pyopencv.pyopencvext.CvSubdiv2DPointLocation.CV_PTLOC_ON_EDGE

CV_PTLOC_OUTSIDE_RECT

Value:

pyopencv.pyopencvext.CvSubdiv2DPointLocation.CV_PTLOC_OUTSIDE_RECT

CV_PTLOC_VERTEX

Value:

pyopencv.pyopencvext.CvSubdiv2DPointLocation.CV_PTLOC_VERTEX

CV_UNMATCHED_FORMATS_ERR

Value:

pyopencv.pyopencvext.CvStatus.CV_UNMATCHED_FORMATS_ERR

CV_UNMATCHED_ROI_ERR

Value:

pyopencv.pyopencvext.CvStatus.CV_UNMATCHED_ROI_ERR

CV_UNSUPPORTED_CHANNELS_ERR

Value:

pyopencv.pyopencvext.CvStatus.CV_UNSUPPORTED_CHANNELS_ERR

CV_UNSUPPORTED_COI_ERR

Value:

pyopencv.pyopencvext.CvStatus.CV_UNSUPPORTED_COI_ERR

CV_UNSUPPORTED_DEPTH_ERR

Value:

pyopencv.pyopencvext.CvStatus.CV_UNSUPPORTED_DEPTH_ERR

CV_UNSUPPORTED_FORMAT_ERR

Value:

pyopencv.pyopencvext.CvStatus.CV_UNSUPPORTED_FORMAT_ERR

CV_WEIGHTED_ALL

Value:

pyopencv.pyopencvext.CvGraphWeightType.CV_WEIGHTED_ALL

CV_WEIGHTED_EDGE

Value:

pyopencv.pyopencvext.CvGraphWeightType.CV_WEIGHTED_EDGE

CV_WEIGHTED_VTX

Value:

pyopencv.pyopencvext.CvGraphWeightType.CV_WEIGHTED_VTX

loader

Value:

<zipimporter object "M:\programming\builders\Python26\lib\site-package
s\pyopencv-2.1.0.wr1.0.2-py2.6-win32.egg">