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, (object)image_points, (object)focal_length, (object)criteria, (object)rotation_matrix, (object)translation_vector) -> None :

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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( (object)arr) -> object :

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

CvTypeInfo :

firstType()
Wrapped function: cvFirstType

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

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

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

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

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

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

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

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

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

long :

getCPUTickCount()
C++ signature :...

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

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

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

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

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

int :

getErrMode()
Wrapped function: cvGetErrMode

int :

getErrStatus()
Wrapped function: cvGetErrStatus

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

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

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

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

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

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

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

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

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

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

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

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

int :

getNumThreads()
Wrapped function: cvGetNumThreads

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

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

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

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

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

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

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

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

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

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

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

int :

getThreadNum()
Wrapped function: cvGetThreadNum

long :

getTickCount()
Wrapped function: cvGetTickCount

float :

getTickFrequency()
Wrapped function: cvGetTickFrequency

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Scalar :

morphologyDefaultBorderValue()
C++ signature :...

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

int :

startWindowThread()
Wrapped function: cvStartWindowThread

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

RNG :

theRNG()
C++ signature :...

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Variables

[hide private]

ADAPTIVE_THRESH_GAUSSIAN_C = 1

ADAPTIVE_THRESH_MEAN_C = 0

AUTOTUNED = pyopencv.pyopencvext.flann_algorithm_t.AUTOTUNED

BORDER_CONSTANT = 0

BORDER_DEFAULT = 4

BORDER_ISOLATED = 16

BORDER_REFLECT = 2

BORDER_REFLECT101 = 4

BORDER_REFLECT_101 = 4

BORDER_REPLICATE = 1

BORDER_TRANSPARENT = 4

BORDER_WRAP = 3

CALIB_CB_ADAPTIVE_THRESH = 1

CALIB_CB_FILTER_QUADS = 4

CALIB_CB_NORMALIZE_IMAGE = 2

CALIB_FIX_ASPECT_RATIO = 2

CALIB_FIX_FOCAL_LENGTH = 16

CALIB_FIX_INTRINSIC = 256

CALIB_FIX_K1 = 32

CALIB_FIX_K2 = 64

CALIB_FIX_K3 = 128

CALIB_FIX_PRINCIPAL_POINT = 4

CALIB_SAME_FOCAL_LENGTH = 512

CALIB_USE_INTRINSIC_GUESS = 1

CALIB_ZERO_DISPARITY = 1024

CALIB_ZERO_TANGENT_DIST = 8

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

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

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

CHAIN_APPROX_NONE = 1

CHAIN_APPROX_SIMPLE = 2

CHAIN_APPROX_TC89_KCOS = 4

CHAIN_APPROX_TC89_L1 = 3

CMP_EQ = 0

CMP_GE = 2

CMP_GT = 1

CMP_LE = 4

CMP_LT = 3

CMP_NE = 5

COMPOSITE = pyopencv.pyopencvext.flann_algorithm_t.COMPOSITE

CV_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.
        To convert a Mat into a list, invoke one of Mat's member functions 
        to_list_of_...().
        Output argument: omitted from the function's calling sequence, and is 
        returned along with the function's return value (if any).

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

GaussianBlur(...)


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

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

HoughCircles(...)


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

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

HoughLines(...)


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

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

HoughLinesP(...)


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

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

HuMoments(...)


HuMoments( (Moments)moments) -> object :

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

LSHAdd(...)


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

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

LSHQuery(...)


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

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

LSHRemove(...)


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

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

LSHSize(...)


LSHSize( (CvLSH)lsh) -> int :

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

LUT(...)


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

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

Laplacian(...)


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

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

Mahalanobis(...)


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

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

Mahalonobis(...)


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

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

POSIT(...)


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

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

RANSACUpdateNumIters(...)


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

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

RQDecomp3x3(...)


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

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

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

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

Rodrigues(...)


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

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

SURFPoint(...)


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

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

Scharr(...)


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

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

Sobel(...)


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

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

absdiff(...)


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

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

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

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

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

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

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

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

acc(...)


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

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

accumulate(...)


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

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

accumulateProduct(...)


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

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

accumulateSquare(...)


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

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

accumulateWeighted(...)


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

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

adaptiveThreshold(...)


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

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

add(...)


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

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

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

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

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

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

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

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

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

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

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

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

addWeighted(...)


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

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

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

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

approxChains(...)


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

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

approxPolyDP(...)


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

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

arcLength(...)


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

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

asComplexd(...)


asComplexd( (Complexf)inst_Complexf) -> Complexd :

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

asComplexf(...)


asComplexf( (Complexd)inst_Complexd) -> Complexf :

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

asMat1b(...)


asMat1b( (Mat2b)inst_Mat2b) -> Mat1b :

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

asMat1b( (Mat3b)inst_Mat3b) -> Mat1b :

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

asMat1b( (Mat4b)inst_Mat4b) -> Mat1b :

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

asMat1b( (Mat1s)inst_Mat1s) -> Mat1b :

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

asMat1b( (Mat2s)inst_Mat2s) -> Mat1b :

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

asMat1b( (Mat3s)inst_Mat3s) -> Mat1b :

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

asMat1b( (Mat4s)inst_Mat4s) -> Mat1b :

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

asMat1b( (Mat1w)inst_Mat1w) -> Mat1b :

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

asMat1b( (Mat2w)inst_Mat2w) -> Mat1b :

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

asMat1b( (Mat3w)inst_Mat3w) -> Mat1b :

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

asMat1b( (Mat4w)inst_Mat4w) -> Mat1b :

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

asMat1b( (Mat1i)inst_Mat1i) -> Mat1b :

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

asMat1b( (Mat2i)inst_Mat2i) -> Mat1b :

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

asMat1b( (Mat3i)inst_Mat3i) -> Mat1b :

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

asMat1b( (Mat4i)inst_Mat4i) -> Mat1b :

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

asMat1b( (Mat1f)inst_Mat1f) -> Mat1b :

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

asMat1b( (Mat2f)inst_Mat2f) -> Mat1b :

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

asMat1b( (Mat3f)inst_Mat3f) -> Mat1b :

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

asMat1b( (Mat4f)inst_Mat4f) -> Mat1b :

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

asMat1b( (Mat1d)inst_Mat1d) -> Mat1b :

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

asMat1b( (Mat2d)inst_Mat2d) -> Mat1b :

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

asMat1b( (Mat3d)inst_Mat3d) -> Mat1b :

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

asMat1b( (Mat4d)inst_Mat4d) -> Mat1b :

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

asMat1d(...)


asMat1d( (Mat1b)inst_Mat1b) -> Mat1d :

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

asMat1d( (Mat2b)inst_Mat2b) -> Mat1d :

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

asMat1d( (Mat3b)inst_Mat3b) -> Mat1d :

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

asMat1d( (Mat4b)inst_Mat4b) -> Mat1d :

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

asMat1d( (Mat1s)inst_Mat1s) -> Mat1d :

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

asMat1d( (Mat2s)inst_Mat2s) -> Mat1d :

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

asMat1d( (Mat3s)inst_Mat3s) -> Mat1d :

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

asMat1d( (Mat4s)inst_Mat4s) -> Mat1d :

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

asMat1d( (Mat1w)inst_Mat1w) -> Mat1d :

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

asMat1d( (Mat2w)inst_Mat2w) -> Mat1d :

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

asMat1d( (Mat3w)inst_Mat3w) -> Mat1d :

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

asMat1d( (Mat4w)inst_Mat4w) -> Mat1d :

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

asMat1d( (Mat1i)inst_Mat1i) -> Mat1d :

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

asMat1d( (Mat2i)inst_Mat2i) -> Mat1d :

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

asMat1d( (Mat3i)inst_Mat3i) -> Mat1d :

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

asMat1d( (Mat4i)inst_Mat4i) -> Mat1d :

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

asMat1d( (Mat1f)inst_Mat1f) -> Mat1d :

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

asMat1d( (Mat2f)inst_Mat2f) -> Mat1d :

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

asMat1d( (Mat3f)inst_Mat3f) -> Mat1d :

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

asMat1d( (Mat4f)inst_Mat4f) -> Mat1d :

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

asMat1d( (Mat2d)inst_Mat2d) -> Mat1d :

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

asMat1d( (Mat3d)inst_Mat3d) -> Mat1d :

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

asMat1d( (Mat4d)inst_Mat4d) -> Mat1d :

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

asMat1f(...)


asMat1f( (Mat1b)inst_Mat1b) -> Mat1f :

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

asMat1f( (Mat2b)inst_Mat2b) -> Mat1f :

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

asMat1f( (Mat3b)inst_Mat3b) -> Mat1f :

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

asMat1f( (Mat4b)inst_Mat4b) -> Mat1f :

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

asMat1f( (Mat1s)inst_Mat1s) -> Mat1f :

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

asMat1f( (Mat2s)inst_Mat2s) -> Mat1f :

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

asMat1f( (Mat3s)inst_Mat3s) -> Mat1f :

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

asMat1f( (Mat4s)inst_Mat4s) -> Mat1f :

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

asMat1f( (Mat1w)inst_Mat1w) -> Mat1f :

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

asMat1f( (Mat2w)inst_Mat2w) -> Mat1f :

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

asMat1f( (Mat3w)inst_Mat3w) -> Mat1f :

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

asMat1f( (Mat4w)inst_Mat4w) -> Mat1f :

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

asMat1f( (Mat1i)inst_Mat1i) -> Mat1f :

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

asMat1f( (Mat2i)inst_Mat2i) -> Mat1f :

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

asMat1f( (Mat3i)inst_Mat3i) -> Mat1f :

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

asMat1f( (Mat4i)inst_Mat4i) -> Mat1f :

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

asMat1f( (Mat2f)inst_Mat2f) -> Mat1f :

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

asMat1f( (Mat3f)inst_Mat3f) -> Mat1f :

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

asMat1f( (Mat4f)inst_Mat4f) -> Mat1f :

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

asMat1f( (Mat1d)inst_Mat1d) -> Mat1f :

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

asMat1f( (Mat2d)inst_Mat2d) -> Mat1f :

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

asMat1f( (Mat3d)inst_Mat3d) -> Mat1f :

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

asMat1f( (Mat4d)inst_Mat4d) -> Mat1f :

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

asMat1i(...)


asMat1i( (Mat1b)inst_Mat1b) -> Mat1i :

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

asMat1i( (Mat2b)inst_Mat2b) -> Mat1i :

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

asMat1i( (Mat3b)inst_Mat3b) -> Mat1i :

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

asMat1i( (Mat4b)inst_Mat4b) -> Mat1i :

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

asMat1i( (Mat1s)inst_Mat1s) -> Mat1i :

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

asMat1i( (Mat2s)inst_Mat2s) -> Mat1i :

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

asMat1i( (Mat3s)inst_Mat3s) -> Mat1i :

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

asMat1i( (Mat4s)inst_Mat4s) -> Mat1i :

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

asMat1i( (Mat1w)inst_Mat1w) -> Mat1i :

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

asMat1i( (Mat2w)inst_Mat2w) -> Mat1i :

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

asMat1i( (Mat3w)inst_Mat3w) -> Mat1i :

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

asMat1i( (Mat4w)inst_Mat4w) -> Mat1i :

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

asMat1i( (Mat2i)inst_Mat2i) -> Mat1i :

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

asMat1i( (Mat3i)inst_Mat3i) -> Mat1i :

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

asMat1i( (Mat4i)inst_Mat4i) -> Mat1i :

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

asMat1i( (Mat1f)inst_Mat1f) -> Mat1i :

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

asMat1i( (Mat2f)inst_Mat2f) -> Mat1i :

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

asMat1i( (Mat3f)inst_Mat3f) -> Mat1i :

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

asMat1i( (Mat4f)inst_Mat4f) -> Mat1i :

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

asMat1i( (Mat1d)inst_Mat1d) -> Mat1i :

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

asMat1i( (Mat2d)inst_Mat2d) -> Mat1i :

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

asMat1i( (Mat3d)inst_Mat3d) -> Mat1i :

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

asMat1i( (Mat4d)inst_Mat4d) -> Mat1i :

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

asMat1s(...)


asMat1s( (Mat1b)inst_Mat1b) -> Mat1s :

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

asMat1s( (Mat2b)inst_Mat2b) -> Mat1s :

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

asMat1s( (Mat3b)inst_Mat3b) -> Mat1s :

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

asMat1s( (Mat4b)inst_Mat4b) -> Mat1s :

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

asMat1s( (Mat2s)inst_Mat2s) -> Mat1s :

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

asMat1s( (Mat3s)inst_Mat3s) -> Mat1s :

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

asMat1s( (Mat4s)inst_Mat4s) -> Mat1s :

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

asMat1s( (Mat1w)inst_Mat1w) -> Mat1s :

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

asMat1s( (Mat2w)inst_Mat2w) -> Mat1s :

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

asMat1s( (Mat3w)inst_Mat3w) -> Mat1s :

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

asMat1s( (Mat4w)inst_Mat4w) -> Mat1s :

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

asMat1s( (Mat1i)inst_Mat1i) -> Mat1s :

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

asMat1s( (Mat2i)inst_Mat2i) -> Mat1s :

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

asMat1s( (Mat3i)inst_Mat3i) -> Mat1s :

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

asMat1s( (Mat4i)inst_Mat4i) -> Mat1s :

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

asMat1s( (Mat1f)inst_Mat1f) -> Mat1s :

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

asMat1s( (Mat2f)inst_Mat2f) -> Mat1s :

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

asMat1s( (Mat3f)inst_Mat3f) -> Mat1s :

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

asMat1s( (Mat4f)inst_Mat4f) -> Mat1s :

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

asMat1s( (Mat1d)inst_Mat1d) -> Mat1s :

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

asMat1s( (Mat2d)inst_Mat2d) -> Mat1s :

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

asMat1s( (Mat3d)inst_Mat3d) -> Mat1s :

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

asMat1s( (Mat4d)inst_Mat4d) -> Mat1s :

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

asMat1w(...)


asMat1w( (Mat1b)inst_Mat1b) -> Mat1w :

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

asMat1w( (Mat2b)inst_Mat2b) -> Mat1w :

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

asMat1w( (Mat3b)inst_Mat3b) -> Mat1w :

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

asMat1w( (Mat4b)inst_Mat4b) -> Mat1w :

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

asMat1w( (Mat1s)inst_Mat1s) -> Mat1w :

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

asMat1w( (Mat2s)inst_Mat2s) -> Mat1w :

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

asMat1w( (Mat3s)inst_Mat3s) -> Mat1w :

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

asMat1w( (Mat4s)inst_Mat4s) -> Mat1w :

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

asMat1w( (Mat2w)inst_Mat2w) -> Mat1w :

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

asMat1w( (Mat3w)inst_Mat3w) -> Mat1w :

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

asMat1w( (Mat4w)inst_Mat4w) -> Mat1w :

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

asMat1w( (Mat1i)inst_Mat1i) -> Mat1w :

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

asMat1w( (Mat2i)inst_Mat2i) -> Mat1w :

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

asMat1w( (Mat3i)inst_Mat3i) -> Mat1w :

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

asMat1w( (Mat4i)inst_Mat4i) -> Mat1w :

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

asMat1w( (Mat1f)inst_Mat1f) -> Mat1w :

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

asMat1w( (Mat2f)inst_Mat2f) -> Mat1w :

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

asMat1w( (Mat3f)inst_Mat3f) -> Mat1w :

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

asMat1w( (Mat4f)inst_Mat4f) -> Mat1w :

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

asMat1w( (Mat1d)inst_Mat1d) -> Mat1w :

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

asMat1w( (Mat2d)inst_Mat2d) -> Mat1w :

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

asMat1w( (Mat3d)inst_Mat3d) -> Mat1w :

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

asMat1w( (Mat4d)inst_Mat4d) -> Mat1w :

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

asMat2b(...)


asMat2b( (Mat1b)inst_Mat1b) -> Mat2b :

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

asMat2b( (Mat3b)inst_Mat3b) -> Mat2b :

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

asMat2b( (Mat4b)inst_Mat4b) -> Mat2b :

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

asMat2b( (Mat1s)inst_Mat1s) -> Mat2b :

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

asMat2b( (Mat2s)inst_Mat2s) -> Mat2b :

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

asMat2b( (Mat3s)inst_Mat3s) -> Mat2b :

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

asMat2b( (Mat4s)inst_Mat4s) -> Mat2b :

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

asMat2b( (Mat1w)inst_Mat1w) -> Mat2b :

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

asMat2b( (Mat2w)inst_Mat2w) -> Mat2b :

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

asMat2b( (Mat3w)inst_Mat3w) -> Mat2b :

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

asMat2b( (Mat4w)inst_Mat4w) -> Mat2b :

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

asMat2b( (Mat1i)inst_Mat1i) -> Mat2b :

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

asMat2b( (Mat2i)inst_Mat2i) -> Mat2b :

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

asMat2b( (Mat3i)inst_Mat3i) -> Mat2b :

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

asMat2b( (Mat4i)inst_Mat4i) -> Mat2b :

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

asMat2b( (Mat1f)inst_Mat1f) -> Mat2b :

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

asMat2b( (Mat2f)inst_Mat2f) -> Mat2b :

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

asMat2b( (Mat3f)inst_Mat3f) -> Mat2b :

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

asMat2b( (Mat4f)inst_Mat4f) -> Mat2b :

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

asMat2b( (Mat1d)inst_Mat1d) -> Mat2b :

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

asMat2b( (Mat2d)inst_Mat2d) -> Mat2b :

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

asMat2b( (Mat3d)inst_Mat3d) -> Mat2b :

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

asMat2b( (Mat4d)inst_Mat4d) -> Mat2b :

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

asMat2d(...)


asMat2d( (Mat1b)inst_Mat1b) -> Mat2d :

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

asMat2d( (Mat2b)inst_Mat2b) -> Mat2d :

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

asMat2d( (Mat3b)inst_Mat3b) -> Mat2d :

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

asMat2d( (Mat4b)inst_Mat4b) -> Mat2d :

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

asMat2d( (Mat1s)inst_Mat1s) -> Mat2d :

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

asMat2d( (Mat2s)inst_Mat2s) -> Mat2d :

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

asMat2d( (Mat3s)inst_Mat3s) -> Mat2d :

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

asMat2d( (Mat4s)inst_Mat4s) -> Mat2d :

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

asMat2d( (Mat1w)inst_Mat1w) -> Mat2d :

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

asMat2d( (Mat2w)inst_Mat2w) -> Mat2d :

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

asMat2d( (Mat3w)inst_Mat3w) -> Mat2d :

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

asMat2d( (Mat4w)inst_Mat4w) -> Mat2d :

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

asMat2d( (Mat1i)inst_Mat1i) -> Mat2d :

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

asMat2d( (Mat2i)inst_Mat2i) -> Mat2d :

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

asMat2d( (Mat3i)inst_Mat3i) -> Mat2d :

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

asMat2d( (Mat4i)inst_Mat4i) -> Mat2d :

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

asMat2d( (Mat1f)inst_Mat1f) -> Mat2d :

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

asMat2d( (Mat2f)inst_Mat2f) -> Mat2d :

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

asMat2d( (Mat3f)inst_Mat3f) -> Mat2d :

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

asMat2d( (Mat4f)inst_Mat4f) -> Mat2d :

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

asMat2d( (Mat1d)inst_Mat1d) -> Mat2d :

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

asMat2d( (Mat3d)inst_Mat3d) -> Mat2d :

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

asMat2d( (Mat4d)inst_Mat4d) -> Mat2d :

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

asMat2f(...)


asMat2f( (Mat1b)inst_Mat1b) -> Mat2f :

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

asMat2f( (Mat2b)inst_Mat2b) -> Mat2f :

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

asMat2f( (Mat3b)inst_Mat3b) -> Mat2f :

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

asMat2f( (Mat4b)inst_Mat4b) -> Mat2f :

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

asMat2f( (Mat1s)inst_Mat1s) -> Mat2f :

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

asMat2f( (Mat2s)inst_Mat2s) -> Mat2f :

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

asMat2f( (Mat3s)inst_Mat3s) -> Mat2f :

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

asMat2f( (Mat4s)inst_Mat4s) -> Mat2f :

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

asMat2f( (Mat1w)inst_Mat1w) -> Mat2f :

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

asMat2f( (Mat2w)inst_Mat2w) -> Mat2f :

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

asMat2f( (Mat3w)inst_Mat3w) -> Mat2f :

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

asMat2f( (Mat4w)inst_Mat4w) -> Mat2f :

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

asMat2f( (Mat1i)inst_Mat1i) -> Mat2f :

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

asMat2f( (Mat2i)inst_Mat2i) -> Mat2f :

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

asMat2f( (Mat3i)inst_Mat3i) -> Mat2f :

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

asMat2f( (Mat4i)inst_Mat4i) -> Mat2f :

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

asMat2f( (Mat1f)inst_Mat1f) -> Mat2f :

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

asMat2f( (Mat3f)inst_Mat3f) -> Mat2f :

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

asMat2f( (Mat4f)inst_Mat4f) -> Mat2f :

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

asMat2f( (Mat1d)inst_Mat1d) -> Mat2f :

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

asMat2f( (Mat2d)inst_Mat2d) -> Mat2f :

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

asMat2f( (Mat3d)inst_Mat3d) -> Mat2f :

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

asMat2f( (Mat4d)inst_Mat4d) -> Mat2f :

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

asMat2i(...)


asMat2i( (Mat1b)inst_Mat1b) -> Mat2i :

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

asMat2i( (Mat2b)inst_Mat2b) -> Mat2i :

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

asMat2i( (Mat3b)inst_Mat3b) -> Mat2i :

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

asMat2i( (Mat4b)inst_Mat4b) -> Mat2i :

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

asMat2i( (Mat1s)inst_Mat1s) -> Mat2i :

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

asMat2i( (Mat2s)inst_Mat2s) -> Mat2i :

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

asMat2i( (Mat3s)inst_Mat3s) -> Mat2i :

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

asMat2i( (Mat4s)inst_Mat4s) -> Mat2i :

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

asMat2i( (Mat1w)inst_Mat1w) -> Mat2i :

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

asMat2i( (Mat2w)inst_Mat2w) -> Mat2i :

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

asMat2i( (Mat3w)inst_Mat3w) -> Mat2i :

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

asMat2i( (Mat4w)inst_Mat4w) -> Mat2i :

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

asMat2i( (Mat1i)inst_Mat1i) -> Mat2i :

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

asMat2i( (Mat3i)inst_Mat3i) -> Mat2i :

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

asMat2i( (Mat4i)inst_Mat4i) -> Mat2i :

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

asMat2i( (Mat1f)inst_Mat1f) -> Mat2i :

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

asMat2i( (Mat2f)inst_Mat2f) -> Mat2i :

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

asMat2i( (Mat3f)inst_Mat3f) -> Mat2i :

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

asMat2i( (Mat4f)inst_Mat4f) -> Mat2i :

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

asMat2i( (Mat1d)inst_Mat1d) -> Mat2i :

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

asMat2i( (Mat2d)inst_Mat2d) -> Mat2i :

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

asMat2i( (Mat3d)inst_Mat3d) -> Mat2i :

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

asMat2i( (Mat4d)inst_Mat4d) -> Mat2i :

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

asMat2s(...)


asMat2s( (Mat1b)inst_Mat1b) -> Mat2s :

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

asMat2s( (Mat2b)inst_Mat2b) -> Mat2s :

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

asMat2s( (Mat3b)inst_Mat3b) -> Mat2s :

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

asMat2s( (Mat4b)inst_Mat4b) -> Mat2s :

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

asMat2s( (Mat1s)inst_Mat1s) -> Mat2s :

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

asMat2s( (Mat3s)inst_Mat3s) -> Mat2s :

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

asMat2s( (Mat4s)inst_Mat4s) -> Mat2s :

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

asMat2s( (Mat1w)inst_Mat1w) -> Mat2s :

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

asMat2s( (Mat2w)inst_Mat2w) -> Mat2s :

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

asMat2s( (Mat3w)inst_Mat3w) -> Mat2s :

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

asMat2s( (Mat4w)inst_Mat4w) -> Mat2s :

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

asMat2s( (Mat1i)inst_Mat1i) -> Mat2s :

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

asMat2s( (Mat2i)inst_Mat2i) -> Mat2s :

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

asMat2s( (Mat3i)inst_Mat3i) -> Mat2s :

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

asMat2s( (Mat4i)inst_Mat4i) -> Mat2s :

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

asMat2s( (Mat1f)inst_Mat1f) -> Mat2s :

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

asMat2s( (Mat2f)inst_Mat2f) -> Mat2s :

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

asMat2s( (Mat3f)inst_Mat3f) -> Mat2s :

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

asMat2s( (Mat4f)inst_Mat4f) -> Mat2s :

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

asMat2s( (Mat1d)inst_Mat1d) -> Mat2s :

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

asMat2s( (Mat2d)inst_Mat2d) -> Mat2s :

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

asMat2s( (Mat3d)inst_Mat3d) -> Mat2s :

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

asMat2s( (Mat4d)inst_Mat4d) -> Mat2s :

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

asMat2w(...)


asMat2w( (Mat1b)inst_Mat1b) -> Mat2w :

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

asMat2w( (Mat2b)inst_Mat2b) -> Mat2w :

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

asMat2w( (Mat3b)inst_Mat3b) -> Mat2w :

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

asMat2w( (Mat4b)inst_Mat4b) -> Mat2w :

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

asMat2w( (Mat1s)inst_Mat1s) -> Mat2w :

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

asMat2w( (Mat2s)inst_Mat2s) -> Mat2w :

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

asMat2w( (Mat3s)inst_Mat3s) -> Mat2w :

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

asMat2w( (Mat4s)inst_Mat4s) -> Mat2w :

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

asMat2w( (Mat1w)inst_Mat1w) -> Mat2w :

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

asMat2w( (Mat3w)inst_Mat3w) -> Mat2w :

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

asMat2w( (Mat4w)inst_Mat4w) -> Mat2w :

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

asMat2w( (Mat1i)inst_Mat1i) -> Mat2w :

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

asMat2w( (Mat2i)inst_Mat2i) -> Mat2w :

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

asMat2w( (Mat3i)inst_Mat3i) -> Mat2w :

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

asMat2w( (Mat4i)inst_Mat4i) -> Mat2w :

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

asMat2w( (Mat1f)inst_Mat1f) -> Mat2w :

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

asMat2w( (Mat2f)inst_Mat2f) -> Mat2w :

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

asMat2w( (Mat3f)inst_Mat3f) -> Mat2w :

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

asMat2w( (Mat4f)inst_Mat4f) -> Mat2w :

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

asMat2w( (Mat1d)inst_Mat1d) -> Mat2w :

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

asMat2w( (Mat2d)inst_Mat2d) -> Mat2w :

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

asMat2w( (Mat3d)inst_Mat3d) -> Mat2w :

    C++ signature :
        cv::Mat_<cv::Vec<unsigned short, 2> > asMat2w(cv::Mat_<cv::Vec<double, 3> >)

asMat2w( (Mat4d)inst_Mat4d) -> Mat2w :

    C++ signature :
        cv::Mat_<cv::Vec<unsigned short, 2> > asMat2w(cv::Mat_<cv::Vec<double, 4> >)

asMat3b(...)


asMat3b( (Mat1b)inst_Mat1b) -> Mat3b :

    C++ signature :
        cv::Mat_<cv::Vec<unsigned char, 3> > asMat3b(cv::Mat_<unsigned char>)

asMat3b( (Mat2b)inst_Mat2b) -> Mat3b :

    C++ signature :
        cv::Mat_<cv::Vec<unsigned char, 3> > asMat3b(cv::Mat_<cv::Vec<unsigned char, 2> >)

asMat3b( (Mat4b)inst_Mat4b) -> Mat3b :

    C++ signature :
        cv::Mat_<cv::Vec<unsigned char, 3> > asMat3b(cv::Mat_<cv::Vec<unsigned char, 4> >)

asMat3b( (Mat1s)inst_Mat1s) -> Mat3b :

    C++ signature :
        cv::Mat_<cv::Vec<unsigned char, 3> > asMat3b(cv::Mat_<short>)

asMat3b( (Mat2s)inst_Mat2s) -> Mat3b :

    C++ signature :
        cv::Mat_<cv::Vec<unsigned char, 3> > asMat3b(cv::Mat_<cv::Vec<short, 2> >)

asMat3b( (Mat3s)inst_Mat3s) -> Mat3b :

    C++ signature :
        cv::Mat_<cv::Vec<unsigned char, 3> > asMat3b(cv::Mat_<cv::Vec<short, 3> >)

asMat3b( (Mat4s)inst_Mat4s) -> Mat3b :

    C++ signature :
        cv::Mat_<cv::Vec<unsigned char, 3> > asMat3b(cv::Mat_<cv::Vec<short, 4> >)

asMat3b( (Mat1w)inst_Mat1w) -> Mat3b :

    C++ signature :
        cv::Mat_<cv::Vec<unsigned char, 3> > asMat3b(cv::Mat_<unsigned short>)

asMat3b( (Mat2w)inst_Mat2w) -> Mat3b :

    C++ signature :
        cv::Mat_<cv::Vec<unsigned char, 3> > asMat3b(cv::Mat_<cv::Vec<unsigned short, 2> >)

asMat3b( (Mat3w)inst_Mat3w) -> Mat3b :

    C++ signature :
        cv::Mat_<cv::Vec<unsigned char, 3> > asMat3b(cv::Mat_<cv::Vec<unsigned short, 3> >)

asMat3b( (Mat4w)inst_Mat4w) -> Mat3b :

    C++ signature :
        cv::Mat_<cv::Vec<unsigned char, 3> > asMat3b(cv::Mat_<cv::Vec<unsigned short, 4> >)

asMat3b( (Mat1i)inst_Mat1i) -> Mat3b :

    C++ signature :
        cv::Mat_<cv::Vec<unsigned char, 3> > asMat3b(cv::Mat_<int>)

asMat3b( (Mat2i)inst_Mat2i) -> Mat3b :

    C++ signature :
        cv::Mat_<cv::Vec<unsigned char, 3> > asMat3b(cv::Mat_<cv::Vec<int, 2> >)

asMat3b( (Mat3i)inst_Mat3i) -> Mat3b :

    C++ signature :
        cv::Mat_<cv::Vec<unsigned char, 3> > asMat3b(cv::Mat_<cv::Vec<int, 3> >)

asMat3b( (Mat4i)inst_Mat4i) -> Mat3b :

    C++ signature :
        cv::Mat_<cv::Vec<unsigned char, 3> > asMat3b(cv::Mat_<cv::Vec<int, 4> >)

asMat3b( (Mat1f)inst_Mat1f) -> Mat3b :

    C++ signature :
        cv::Mat_<cv::Vec<unsigned char, 3> > asMat3b(cv::Mat_<float>)

asMat3b( (Mat2f)inst_Mat2f) -> Mat3b :

    C++ signature :
        cv::Mat_<cv::Vec<unsigned char, 3> > asMat3b(cv::Mat_<cv::Vec<float, 2> >)

asMat3b( (Mat3f)inst_Mat3f) -> Mat3b :

    C++ signature :
        cv::Mat_<cv::Vec<unsigned char, 3> > asMat3b(cv::Mat_<cv::Vec<float, 3> >)

asMat3b( (Mat4f)inst_Mat4f) -> Mat3b :

    C++ signature :
        cv::Mat_<cv::Vec<unsigned char, 3> > asMat3b(cv::Mat_<cv::Vec<float, 4> >)

asMat3b( (Mat1d)inst_Mat1d) -> Mat3b :

    C++ signature :
        cv::Mat_<cv::Vec<unsigned char, 3> > asMat3b(cv::Mat_<double>)

asMat3b( (Mat2d)inst_Mat2d) -> Mat3b :

    C++ signature :
        cv::Mat_<cv::Vec<unsigned char, 3> > asMat3b(cv::Mat_<cv::Vec<double, 2> >)

asMat3b( (Mat3d)inst_Mat3d) -> Mat3b :

    C++ signature :
        cv::Mat_<cv::Vec<unsigned char, 3> > asMat3b(cv::Mat_<cv::Vec<double, 3> >)

asMat3b( (Mat4d)inst_Mat4d) -> Mat3b :

    C++ signature :
        cv::Mat_<cv::Vec<unsigned char, 3> > asMat3b(cv::Mat_<cv::Vec<double, 4> >)

asMat3d(...)


asMat3d( (Mat1b)inst_Mat1b) -> Mat3d :

    C++ signature :
        cv::Mat_<cv::Vec<double, 3> > asMat3d(cv::Mat_<unsigned char>)

asMat3d( (Mat2b)inst_Mat2b) -> Mat3d :

    C++ signature :
        cv::Mat_<cv::Vec<double, 3> > asMat3d(cv::Mat_<cv::Vec<unsigned char, 2> >)

asMat3d( (Mat3b)inst_Mat3b) -> Mat3d :

    C++ signature :
        cv::Mat_<cv::Vec<double, 3> > asMat3d(cv::Mat_<cv::Vec<unsigned char, 3> >)

asMat3d( (Mat4b)inst_Mat4b) -> Mat3d :

    C++ signature :
        cv::Mat_<cv::Vec<double, 3> > asMat3d(cv::Mat_<cv::Vec<unsigned char, 4> >)

asMat3d( (Mat1s)inst_Mat1s) -> Mat3d :

    C++ signature :
        cv::Mat_<cv::Vec<double, 3> > asMat3d(cv::Mat_<short>)

asMat3d( (Mat2s)inst_Mat2s) -> Mat3d :

    C++ signature :
        cv::Mat_<cv::Vec<double, 3> > asMat3d(cv::Mat_<cv::Vec<short, 2> >)

asMat3d( (Mat3s)inst_Mat3s) -> Mat3d :

    C++ signature :
        cv::Mat_<cv::Vec<double, 3> > asMat3d(cv::Mat_<cv::Vec<short, 3> >)

asMat3d( (Mat4s)inst_Mat4s) -> Mat3d :

    C++ signature :
        cv::Mat_<cv::Vec<double, 3> > asMat3d(cv::Mat_<cv::Vec<short, 4> >)

asMat3d( (Mat1w)inst_Mat1w) -> Mat3d :

    C++ signature :
        cv::Mat_<cv::Vec<double, 3> > asMat3d(cv::Mat_<unsigned short>)

asMat3d( (Mat2w)inst_Mat2w) -> Mat3d :

    C++ signature :
        cv::Mat_<cv::Vec<double, 3> > asMat3d(cv::Mat_<cv::Vec<unsigned short, 2> >)

asMat3d( (Mat3w)inst_Mat3w) -> Mat3d :

    C++ signature :
        cv::Mat_<cv::Vec<double, 3> > asMat3d(cv::Mat_<cv::Vec<unsigned short, 3> >)

asMat3d( (Mat4w)inst_Mat4w) -> Mat3d :

    C++ signature :
        cv::Mat_<cv::Vec<double, 3> > asMat3d(cv::Mat_<cv::Vec<unsigned short, 4> >)

asMat3d( (Mat1i)inst_Mat1i) -> Mat3d :

    C++ signature :
        cv::Mat_<cv::Vec<double, 3> > asMat3d(cv::Mat_<int>)

asMat3d( (Mat2i)inst_Mat2i) -> Mat3d :

    C++ signature :
        cv::Mat_<cv::Vec<double, 3> > asMat3d(cv::Mat_<cv::Vec<int, 2> >)

asMat3d( (Mat3i)inst_Mat3i) -> Mat3d :

    C++ signature :
        cv::Mat_<cv::Vec<double, 3> > asMat3d(cv::Mat_<cv::Vec<int, 3> >)

asMat3d( (Mat4i)inst_Mat4i) -> Mat3d :

    C++ signature :
        cv::Mat_<cv::Vec<double, 3> > asMat3d(cv::Mat_<cv::Vec<int, 4> >)

asMat3d( (Mat1f)inst_Mat1f) -> Mat3d :

    C++ signature :
        cv::Mat_<cv::Vec<double, 3> > asMat3d(cv::Mat_<float>)

asMat3d( (Mat2f)inst_Mat2f) -> Mat3d :

    C++ signature :
        cv::Mat_<cv::Vec<double, 3> > asMat3d(cv::Mat_<cv::Vec<float, 2> >)

asMat3d( (Mat3f)inst_Mat3f) -> Mat3d :

    C++ signature :
        cv::Mat_<cv::Vec<double, 3> > asMat3d(cv::Mat_<cv::Vec<float, 3> >)

asMat3d( (Mat4f)inst_Mat4f) -> Mat3d :

    C++ signature :
        cv::Mat_<cv::Vec<double, 3> > asMat3d(cv::Mat_<cv::Vec<float, 4> >)

asMat3d( (Mat1d)inst_Mat1d) -> Mat3d :

    C++ signature :
        cv::Mat_<cv::Vec<double, 3> > asMat3d(cv::Mat_<double>)

asMat3d( (Mat2d)inst_Mat2d) -> Mat3d :

    C++ signature :
        cv::Mat_<cv::Vec<double, 3> > asMat3d(cv::Mat_<cv::Vec<double, 2> >)

asMat3d( (Mat4d)inst_Mat4d) -> Mat3d :

    C++ signature :
        cv::Mat_<cv::Vec<double, 3> > asMat3d(cv::Mat_<cv::Vec<double, 4> >)

asMat3f(...)


asMat3f( (Mat1b)inst_Mat1b) -> Mat3f :

    C++ signature :
        cv::Mat_<cv::Vec<float, 3> > asMat3f(cv::Mat_<unsigned char>)

asMat3f( (Mat2b)inst_Mat2b) -> Mat3f :

    C++ signature :
        cv::Mat_<cv::Vec<float, 3> > asMat3f(cv::Mat_<cv::Vec<unsigned char, 2> >)

asMat3f( (Mat3b)inst_Mat3b) -> Mat3f :

    C++ signature :
        cv::Mat_<cv::Vec<float, 3> > asMat3f(cv::Mat_<cv::Vec<unsigned char, 3> >)

asMat3f( (Mat4b)inst_Mat4b) -> Mat3f :

    C++ signature :
        cv::Mat_<cv::Vec<float, 3> > asMat3f(cv::Mat_<cv::Vec<unsigned char, 4> >)

asMat3f( (Mat1s)inst_Mat1s) -> Mat3f :

    C++ signature :
        cv::Mat_<cv::Vec<float, 3> > asMat3f(cv::Mat_<short>)

asMat3f( (Mat2s)inst_Mat2s) -> Mat3f :

    C++ signature :
        cv::Mat_<cv::Vec<float, 3> > asMat3f(cv::Mat_<cv::Vec<short, 2> >)

asMat3f( (Mat3s)inst_Mat3s) -> Mat3f :

    C++ signature :
        cv::Mat_<cv::Vec<float, 3> > asMat3f(cv::Mat_<cv::Vec<short, 3> >)

asMat3f( (Mat4s)inst_Mat4s) -> Mat3f :

    C++ signature :
        cv::Mat_<cv::Vec<float, 3> > asMat3f(cv::Mat_<cv::Vec<short, 4> >)

asMat3f( (Mat1w)inst_Mat1w) -> Mat3f :

    C++ signature :
        cv::Mat_<cv::Vec<float, 3> > asMat3f(cv::Mat_<unsigned short>)

asMat3f( (Mat2w)inst_Mat2w) -> Mat3f :

    C++ signature :
        cv::Mat_<cv::Vec<float, 3> > asMat3f(cv::Mat_<cv::Vec<unsigned short, 2> >)

asMat3f( (Mat3w)inst_Mat3w) -> Mat3f :

    C++ signature :
        cv::Mat_<cv::Vec<float, 3> > asMat3f(cv::Mat_<cv::Vec<unsigned short, 3> >)

asMat3f( (Mat4w)inst_Mat4w) -> Mat3f :

    C++ signature :
        cv::Mat_<cv::Vec<float, 3> > asMat3f(cv::Mat_<cv::Vec<unsigned short, 4> >)

asMat3f( (Mat1i)inst_Mat1i) -> Mat3f :

    C++ signature :
        cv::Mat_<cv::Vec<float, 3> > asMat3f(cv::Mat_<int>)

asMat3f( (Mat2i)inst_Mat2i) -> Mat3f :

    C++ signature :
        cv::Mat_<cv::Vec<float, 3> > asMat3f(cv::Mat_<cv::Vec<int, 2> >)

asMat3f( (Mat3i)inst_Mat3i) -> Mat3f :

    C++ signature :
        cv::Mat_<cv::Vec<float, 3> > asMat3f(cv::Mat_<cv::Vec<int, 3> >)

asMat3f( (Mat4i)inst_Mat4i) -> Mat3f :

    C++ signature :
        cv::Mat_<cv::Vec<float, 3> > asMat3f(cv::Mat_<cv::Vec<int, 4> >)

asMat3f( (Mat1f)inst_Mat1f) -> Mat3f :

    C++ signature :
        cv::Mat_<cv::Vec<float, 3> > asMat3f(cv::Mat_<float>)

asMat3f( (Mat2f)inst_Mat2f) -> Mat3f :

    C++ signature :
        cv::Mat_<cv::Vec<float, 3> > asMat3f(cv::Mat_<cv::Vec<float, 2> >)

asMat3f( (Mat4f)inst_Mat4f) -> Mat3f :

    C++ signature :
        cv::Mat_<cv::Vec<float, 3> > asMat3f(cv::Mat_<cv::Vec<float, 4> >)

asMat3f( (Mat1d)inst_Mat1d) -> Mat3f :

    C++ signature :
        cv::Mat_<cv::Vec<float, 3> > asMat3f(cv::Mat_<double>)

asMat3f( (Mat2d)inst_Mat2d) -> Mat3f :

    C++ signature :
        cv::Mat_<cv::Vec<float, 3> > asMat3f(cv::Mat_<cv::Vec<double, 2> >)

asMat3f( (Mat3d)inst_Mat3d) -> Mat3f :

    C++ signature :
        cv::Mat_<cv::Vec<float, 3> > asMat3f(cv::Mat_<cv::Vec<double, 3> >)

asMat3f( (Mat4d)inst_Mat4d) -> Mat3f :

    C++ signature :
        cv::Mat_<cv::Vec<float, 3> > asMat3f(cv::Mat_<cv::Vec<double, 4> >)

asMat3i(...)


asMat3i( (Mat1b)inst_Mat1b) -> Mat3i :

    C++ signature :
        cv::Mat_<cv::Vec<int, 3> > asMat3i(cv::Mat_<unsigned char>)

asMat3i( (Mat2b)inst_Mat2b) -> Mat3i :

    C++ signature :
        cv::Mat_<cv::Vec<int, 3> > asMat3i(cv::Mat_<cv::Vec<unsigned char, 2> >)

asMat3i( (Mat3b)inst_Mat3b) -> Mat3i :

    C++ signature :
        cv::Mat_<cv::Vec<int, 3> > asMat3i(cv::Mat_<cv::Vec<unsigned char, 3> >)

asMat3i( (Mat4b)inst_Mat4b) -> Mat3i :

    C++ signature :
        cv::Mat_<cv::Vec<int, 3> > asMat3i(cv::Mat_<cv::Vec<unsigned char, 4> >)

asMat3i( (Mat1s)inst_Mat1s) -> Mat3i :

    C++ signature :
        cv::Mat_<cv::Vec<int, 3> > asMat3i(cv::Mat_<short>)

asMat3i( (Mat2s)inst_Mat2s) -> Mat3i :

    C++ signature :
        cv::Mat_<cv::Vec<int, 3> > asMat3i(cv::Mat_<cv::Vec<short, 2> >)

asMat3i( (Mat3s)inst_Mat3s) -> Mat3i :

    C++ signature :
        cv::Mat_<cv::Vec<int, 3> > asMat3i(cv::Mat_<cv::Vec<short, 3> >)

asMat3i( (Mat4s)inst_Mat4s) -> Mat3i :

    C++ signature :
        cv::Mat_<cv::Vec<int, 3> > asMat3i(cv::Mat_<cv::Vec<short, 4> >)

asMat3i( (Mat1w)inst_Mat1w) -> Mat3i :

    C++ signature :
        cv::Mat_<cv::Vec<int, 3> > asMat3i(cv::Mat_<unsigned short>)

asMat3i( (Mat2w)inst_Mat2w) -> Mat3i :

    C++ signature :
        cv::Mat_<cv::Vec<int, 3> > asMat3i(cv::Mat_<cv::Vec<unsigned short, 2> >)

asMat3i( (Mat3w)inst_Mat3w) -> Mat3i :

    C++ signature :
        cv::Mat_<cv::Vec<int, 3> > asMat3i(cv::Mat_<cv::Vec<unsigned short, 3> >)

asMat3i( (Mat4w)inst_Mat4w) -> Mat3i :

    C++ signature :
        cv::Mat_<cv::Vec<int, 3> > asMat3i(cv::Mat_<cv::Vec<unsigned short, 4> >)

asMat3i( (Mat1i)inst_Mat1i) -> Mat3i :

    C++ signature :
        cv::Mat_<cv::Vec<int, 3> > asMat3i(cv::Mat_<int>)

asMat3i( (Mat2i)inst_Mat2i) -> Mat3i :

    C++ signature :
        cv::Mat_<cv::Vec<int, 3> > asMat3i(cv::Mat_<cv::Vec<int, 2> >)

asMat3i( (Mat4i)inst_Mat4i) -> Mat3i :

    C++ signature :
        cv::Mat_<cv::Vec<int, 3> > asMat3i(cv::Mat_<cv::Vec<int, 4> >)

asMat3i( (Mat1f)inst_Mat1f) -> Mat3i :

    C++ signature :
        cv::Mat_<cv::Vec<int, 3> > asMat3i(cv::Mat_<float>)

asMat3i( (Mat2f)inst_Mat2f) -> Mat3i :

    C++ signature :
        cv::Mat_<cv::Vec<int, 3> > asMat3i(cv::Mat_<cv::Vec<float, 2> >)

asMat3i( (Mat3f)inst_Mat3f) -> Mat3i :

    C++ signature :
        cv::Mat_<cv::Vec<int, 3> > asMat3i(cv::Mat_<cv::Vec<float, 3> >)

asMat3i( (Mat4f)inst_Mat4f) -> Mat3i :

    C++ signature :
        cv::Mat_<cv::Vec<int, 3> > asMat3i(cv::Mat_<cv::Vec<float, 4> >)

asMat3i( (Mat1d)inst_Mat1d) -> Mat3i :

    C++ signature :
        cv::Mat_<cv::Vec<int, 3> > asMat3i(cv::Mat_<double>)

asMat3i( (Mat2d)inst_Mat2d) -> Mat3i :

    C++ signature :
        cv::Mat_<cv::Vec<int, 3> > asMat3i(cv::Mat_<cv::Vec<double, 2> >)

asMat3i( (Mat3d)inst_Mat3d) -> Mat3i :

    C++ signature :
        cv::Mat_<cv::Vec<int, 3> > asMat3i(cv::Mat_<cv::Vec<double, 3> >)

asMat3i( (Mat4d)inst_Mat4d) -> Mat3i :

    C++ signature :
        cv::Mat_<cv::Vec<int, 3> > asMat3i(cv::Mat_<cv::Vec<double, 4> >)

asMat3s(...)


asMat3s( (Mat1b)inst_Mat1b) -> Mat3s :

    C++ signature :
        cv::Mat_<cv::Vec<short, 3> > asMat3s(cv::Mat_<unsigned char>)

asMat3s( (Mat2b)inst_Mat2b) -> Mat3s :

    C++ signature :
        cv::Mat_<cv::Vec<short, 3> > asMat3s(cv::Mat_<cv::Vec<unsigned char, 2> >)

asMat3s( (Mat3b)inst_Mat3b) -> Mat3s :

    C++ signature :
        cv::Mat_<cv::Vec<short, 3> > asMat3s(cv::Mat_<cv::Vec<unsigned char, 3> >)

asMat3s( (Mat4b)inst_Mat4b) -> Mat3s :

    C++ signature :
        cv::Mat_<cv::Vec<short, 3> > asMat3s(cv::Mat_<cv::Vec<unsigned char, 4> >)

asMat3s( (Mat1s)inst_Mat1s) -> Mat3s :

    C++ signature :
        cv::Mat_<cv::Vec<short, 3> > asMat3s(cv::Mat_<short>)

asMat3s( (Mat2s)inst_Mat2s) -> Mat3s :

    C++ signature :
        cv::Mat_<cv::Vec<short, 3> > asMat3s(cv::Mat_<cv::Vec<short, 2> >)

asMat3s( (Mat4s)inst_Mat4s) -> Mat3s :

    C++ signature :
        cv::Mat_<cv::Vec<short, 3> > asMat3s(cv::Mat_<cv::Vec<short, 4> >)

asMat3s( (Mat1w)inst_Mat1w) -> Mat3s :

    C++ signature :
        cv::Mat_<cv::Vec<short, 3> > asMat3s(cv::Mat_<unsigned short>)

asMat3s( (Mat2w)inst_Mat2w) -> Mat3s :

    C++ signature :
        cv::Mat_<cv::Vec<short, 3> > asMat3s(cv::Mat_<cv::Vec<unsigned short, 2> >)

asMat3s( (Mat3w)inst_Mat3w) -> Mat3s :

    C++ signature :
        cv::Mat_<cv::Vec<short, 3> > asMat3s(cv::Mat_<cv::Vec<unsigned short, 3> >)

asMat3s( (Mat4w)inst_Mat4w) -> Mat3s :

    C++ signature :
        cv::Mat_<cv::Vec<short, 3> > asMat3s(cv::Mat_<cv::Vec<unsigned short, 4> >)

asMat3s( (Mat1i)inst_Mat1i) -> Mat3s :

    C++ signature :
        cv::Mat_<cv::Vec<short, 3> > asMat3s(cv::Mat_<int>)

asMat3s( (Mat2i)inst_Mat2i) -> Mat3s :

    C++ signature :
        cv::Mat_<cv::Vec<short, 3> > asMat3s(cv::Mat_<cv::Vec<int, 2> >)

asMat3s( (Mat3i)inst_Mat3i) -> Mat3s :

    C++ signature :
        cv::Mat_<cv::Vec<short, 3> > asMat3s(cv::Mat_<cv::Vec<int, 3> >)

asMat3s( (Mat4i)inst_Mat4i) -> Mat3s :

    C++ signature :
        cv::Mat_<cv::Vec<short, 3> > asMat3s(cv::Mat_<cv::Vec<int, 4> >)

asMat3s( (Mat1f)inst_Mat1f) -> Mat3s :

    C++ signature :
        cv::Mat_<cv::Vec<short, 3> > asMat3s(cv::Mat_<float>)

asMat3s( (Mat2f)inst_Mat2f) -> Mat3s :

    C++ signature :
        cv::Mat_<cv::Vec<short, 3> > asMat3s(cv::Mat_<cv::Vec<float, 2> >)

asMat3s( (Mat3f)inst_Mat3f) -> Mat3s :

    C++ signature :
        cv::Mat_<cv::Vec<short, 3> > asMat3s(cv::Mat_<cv::Vec<float, 3> >)

asMat3s( (Mat4f)inst_Mat4f) -> Mat3s :

    C++ signature :
        cv::Mat_<cv::Vec<short, 3> > asMat3s(cv::Mat_<cv::Vec<float, 4> >)

asMat3s( (Mat1d)inst_Mat1d) -> Mat3s :

    C++ signature :
        cv::Mat_<cv::Vec<short, 3> > asMat3s(cv::Mat_<double>)

asMat3s( (Mat2d)inst_Mat2d) -> Mat3s :

    C++ signature :
        cv::Mat_<cv::Vec<short, 3> > asMat3s(cv::Mat_<cv::Vec<double, 2> >)

asMat3s( (Mat3d)inst_Mat3d) -> Mat3s :

    C++ signature :
        cv::Mat_<cv::Vec<short, 3> > asMat3s(cv::Mat_<cv::Vec<double, 3> >)

asMat3s( (Mat4d)inst_Mat4d) -> Mat3s :

    C++ signature :
        cv::Mat_<cv::Vec<short, 3> > asMat3s(cv::Mat_<cv::Vec<double, 4> >)

asMat3w(...)


asMat3w( (Mat1b)inst_Mat1b) -> Mat3w :

    C++ signature :
        cv::Mat_<cv::Vec<unsigned short, 3> > asMat3w(cv::Mat_<unsigned char>)

asMat3w( (Mat2b)inst_Mat2b) -> Mat3w :

    C++ signature :
        cv::Mat_<cv::Vec<unsigned short, 3> > asMat3w(cv::Mat_<cv::Vec<unsigned char, 2> >)

asMat3w( (Mat3b)inst_Mat3b) -> Mat3w :

    C++ signature :
        cv::Mat_<cv::Vec<unsigned short, 3> > asMat3w(cv::Mat_<cv::Vec<unsigned char, 3> >)

asMat3w( (Mat4b)inst_Mat4b) -> Mat3w :

    C++ signature :
        cv::Mat_<cv::Vec<unsigned short, 3> > asMat3w(cv::Mat_<cv::Vec<unsigned char, 4> >)

asMat3w( (Mat1s)inst_Mat1s) -> Mat3w :

    C++ signature :
        cv::Mat_<cv::Vec<unsigned short, 3> > asMat3w(cv::Mat_<short>)

asMat3w( (Mat2s)inst_Mat2s) -> Mat3w :

    C++ signature :
        cv::Mat_<cv::Vec<unsigned short, 3> > asMat3w(cv::Mat_<cv::Vec<short, 2> >)

asMat3w( (Mat3s)inst_Mat3s) -> Mat3w :

    C++ signature :
        cv::Mat_<cv::Vec<unsigned short, 3> > asMat3w(cv::Mat_<cv::Vec<short, 3> >)

asMat3w( (Mat4s)inst_Mat4s) -> Mat3w :

    C++ signature :
        cv::Mat_<cv::Vec<unsigned short, 3> > asMat3w(cv::Mat_<cv::Vec<short, 4> >)

asMat3w( (Mat1w)inst_Mat1w) -> Mat3w :

    C++ signature :
        cv::Mat_<cv::Vec<unsigned short, 3> > asMat3w(cv::Mat_<unsigned short>)

asMat3w( (Mat2w)inst_Mat2w) -> Mat3w :

    C++ signature :
        cv::Mat_<cv::Vec<unsigned short, 3> > asMat3w(cv::Mat_<cv::Vec<unsigned short, 2> >)

asMat3w( (Mat4w)inst_Mat4w) -> Mat3w :

    C++ signature :
        cv::Mat_<cv::Vec<unsigned short, 3> > asMat3w(cv::Mat_<cv::Vec<unsigned short, 4> >)

asMat3w( (Mat1i)inst_Mat1i) -> Mat3w :

    C++ signature :
        cv::Mat_<cv::Vec<unsigned short, 3> > asMat3w(cv::Mat_<int>)

asMat3w( (Mat2i)inst_Mat2i) -> Mat3w :

    C++ signature :
        cv::Mat_<cv::Vec<unsigned short, 3> > asMat3w(cv::Mat_<cv::Vec<int, 2> >)

asMat3w( (Mat3i)inst_Mat3i) -> Mat3w :

    C++ signature :
        cv::Mat_<cv::Vec<unsigned short, 3> > asMat3w(cv::Mat_<cv::Vec<int, 3> >)

asMat3w( (Mat4i)inst_Mat4i) -> Mat3w :

    C++ signature :
        cv::Mat_<cv::Vec<unsigned short, 3> > asMat3w(cv::Mat_<cv::Vec<int, 4> >)

asMat3w( (Mat1f)inst_Mat1f) -> Mat3w :

    C++ signature :
        cv::Mat_<cv::Vec<unsigned short, 3> > asMat3w(cv::Mat_<float>)

asMat3w( (Mat2f)inst_Mat2f) -> Mat3w :

    C++ signature :
        cv::Mat_<cv::Vec<unsigned short, 3> > asMat3w(cv::Mat_<cv::Vec<float, 2> >)

asMat3w( (Mat3f)inst_Mat3f) -> Mat3w :

    C++ signature :
        cv::Mat_<cv::Vec<unsigned short, 3> > asMat3w(cv::Mat_<cv::Vec<float, 3> >)

asMat3w( (Mat4f)inst_Mat4f) -> Mat3w :

    C++ signature :
        cv::Mat_<cv::Vec<unsigned short, 3> > asMat3w(cv::Mat_<cv::Vec<float, 4> >)

asMat3w( (Mat1d)inst_Mat1d) -> Mat3w :

    C++ signature :
        cv::Mat_<cv::Vec<unsigned short, 3> > asMat3w(cv::Mat_<double>)

asMat3w( (Mat2d)inst_Mat2d) -> Mat3w :

    C++ signature :
        cv::Mat_<cv::Vec<unsigned short, 3> > asMat3w(cv::Mat_<cv::Vec<double, 2> >)

asMat3w( (Mat3d)inst_Mat3d) -> Mat3w :

    C++ signature :
        cv::Mat_<cv::Vec<unsigned short, 3> > asMat3w(cv::Mat_<cv::Vec<double, 3> >)

asMat3w( (Mat4d)inst_Mat4d) -> Mat3w :

    C++ signature :
        cv::Mat_<cv::Vec<unsigned short, 3> > asMat3w(cv::Mat_<cv::Vec<double, 4> >)

asMat4b(...)


asMat4b( (Mat1b)inst_Mat1b) -> Mat4b :

    C++ signature :
        cv::Mat_<cv::Vec<unsigned char, 4> > asMat4b(cv::Mat_<unsigned char>)

asMat4b( (Mat2b)inst_Mat2b) -> Mat4b :

    C++ signature :
        cv::Mat_<cv::Vec<unsigned char, 4> > asMat4b(cv::Mat_<cv::Vec<unsigned char, 2> >)

asMat4b( (Mat3b)inst_Mat3b) -> Mat4b :

    C++ signature :
        cv::Mat_<cv::Vec<unsigned char, 4> > asMat4b(cv::Mat_<cv::Vec<unsigned char, 3> >)

asMat4b( (Mat1s)inst_Mat1s) -> Mat4b :

    C++ signature :
        cv::Mat_<cv::Vec<unsigned char, 4> > asMat4b(cv::Mat_<short>)

asMat4b( (Mat2s)inst_Mat2s) -> Mat4b :

    C++ signature :
        cv::Mat_<cv::Vec<unsigned char, 4> > asMat4b(cv::Mat_<cv::Vec<short, 2> >)

asMat4b( (Mat3s)inst_Mat3s) -> Mat4b :

    C++ signature :
        cv::Mat_<cv::Vec<unsigned char, 4> > asMat4b(cv::Mat_<cv::Vec<short, 3> >)

asMat4b( (Mat4s)inst_Mat4s) -> Mat4b :

    C++ signature :
        cv::Mat_<cv::Vec<unsigned char, 4> > asMat4b(cv::Mat_<cv::Vec<short, 4> >)

asMat4b( (Mat1w)inst_Mat1w) -> Mat4b :

    C++ signature :
        cv::Mat_<cv::Vec<unsigned char, 4> > asMat4b(cv::Mat_<unsigned short>)

asMat4b( (Mat2w)inst_Mat2w) -> Mat4b :

    C++ signature :
        cv::Mat_<cv::Vec<unsigned char, 4> > asMat4b(cv::Mat_<cv::Vec<unsigned short, 2> >)

asMat4b( (Mat3w)inst_Mat3w) -> Mat4b :

    C++ signature :
        cv::Mat_<cv::Vec<unsigned char, 4> > asMat4b(cv::Mat_<cv::Vec<unsigned short, 3> >)

asMat4b( (Mat4w)inst_Mat4w) -> Mat4b :

    C++ signature :
        cv::Mat_<cv::Vec<unsigned char, 4> > asMat4b(cv::Mat_<cv::Vec<unsigned short, 4> >)

asMat4b( (Mat1i)inst_Mat1i) -> Mat4b :

    C++ signature :
        cv::Mat_<cv::Vec<unsigned char, 4> > asMat4b(cv::Mat_<int>)

asMat4b( (Mat2i)inst_Mat2i) -> Mat4b :

    C++ signature :
        cv::Mat_<cv::Vec<unsigned char, 4> > asMat4b(cv::Mat_<cv::Vec<int, 2> >)

asMat4b( (Mat3i)inst_Mat3i) -> Mat4b :

    C++ signature :
        cv::Mat_<cv::Vec<unsigned char, 4> > asMat4b(cv::Mat_<cv::Vec<int, 3> >)

asMat4b( (Mat4i)inst_Mat4i) -> Mat4b :

    C++ signature :
        cv::Mat_<cv::Vec<unsigned char, 4> > asMat4b(cv::Mat_<cv::Vec<int, 4> >)

asMat4b( (Mat1f)inst_Mat1f) -> Mat4b :

    C++ signature :
        cv::Mat_<cv::Vec<unsigned char, 4> > asMat4b(cv::Mat_<float>)

asMat4b( (Mat2f)inst_Mat2f) -> Mat4b :

    C++ signature :
        cv::Mat_<cv::Vec<unsigned char, 4> > asMat4b(cv::Mat_<cv::Vec<float, 2> >)

asMat4b( (Mat3f)inst_Mat3f) -> Mat4b :

    C++ signature :
        cv::Mat_<cv::Vec<unsigned char, 4> > asMat4b(cv::Mat_<cv::Vec<float, 3> >)

asMat4b( (Mat4f)inst_Mat4f) -> Mat4b :

    C++ signature :
        cv::Mat_<cv::Vec<unsigned char, 4> > asMat4b(cv::Mat_<cv::Vec<float, 4> >)

asMat4b( (Mat1d)inst_Mat1d) -> Mat4b :

    C++ signature :
        cv::Mat_<cv::Vec<unsigned char, 4> > asMat4b(cv::Mat_<double>)

asMat4b( (Mat2d)inst_Mat2d) -> Mat4b :

    C++ signature :
        cv::Mat_<cv::Vec<unsigned char, 4> > asMat4b(cv::Mat_<cv::Vec<double, 2> >)

asMat4b( (Mat3d)inst_Mat3d) -> Mat4b :

    C++ signature :
        cv::Mat_<cv::Vec<unsigned char, 4> > asMat4b(cv::Mat_<cv::Vec<double, 3> >)

asMat4b( (Mat4d)inst_Mat4d) -> Mat4b :

    C++ signature :
        cv::Mat_<cv::Vec<unsigned char, 4> > asMat4b(cv::Mat_<cv::Vec<double, 4> >)

asMat4d(...)


asMat4d( (Mat1b)inst_Mat1b) -> Mat4d :

    C++ signature :
        cv::Mat_<cv::Vec<double, 4> > asMat4d(cv::Mat_<unsigned char>)

asMat4d( (Mat2b)inst_Mat2b) -> Mat4d :

    C++ signature :
        cv::Mat_<cv::Vec<double, 4> > asMat4d(cv::Mat_<cv::Vec<unsigned char, 2> >)

asMat4d( (Mat3b)inst_Mat3b) -> Mat4d :

    C++ signature :
        cv::Mat_<cv::Vec<double, 4> > asMat4d(cv::Mat_<cv::Vec<unsigned char, 3> >)

asMat4d( (Mat4b)inst_Mat4b) -> Mat4d :

    C++ signature :
        cv::Mat_<cv::Vec<double, 4> > asMat4d(cv::Mat_<cv::Vec<unsigned char, 4> >)

asMat4d( (Mat1s)inst_Mat1s) -> Mat4d :

    C++ signature :
        cv::Mat_<cv::Vec<double, 4> > asMat4d(cv::Mat_<short>)

asMat4d( (Mat2s)inst_Mat2s) -> Mat4d :

    C++ signature :
        cv::Mat_<cv::Vec<double, 4> > asMat4d(cv::Mat_<cv::Vec<short, 2> >)

asMat4d( (Mat3s)inst_Mat3s) -> Mat4d :

    C++ signature :
        cv::Mat_<cv::Vec<double, 4> > asMat4d(cv::Mat_<cv::Vec<short, 3> >)

asMat4d( (Mat4s)inst_Mat4s) -> Mat4d :

    C++ signature :
        cv::Mat_<cv::Vec<double, 4> > asMat4d(cv::Mat_<cv::Vec<short, 4> >)

asMat4d( (Mat1w)inst_Mat1w) -> Mat4d :

    C++ signature :
        cv::Mat_<cv::Vec<double, 4> > asMat4d(cv::Mat_<unsigned short>)

asMat4d( (Mat2w)inst_Mat2w) -> Mat4d :

    C++ signature :
        cv::Mat_<cv::Vec<double, 4> > asMat4d(cv::Mat_<cv::Vec<unsigned short, 2> >)

asMat4d( (Mat3w)inst_Mat3w) -> Mat4d :

    C++ signature :
        cv::Mat_<cv::Vec<double, 4> > asMat4d(cv::Mat_<cv::Vec<unsigned short, 3> >)

asMat4d( (Mat4w)inst_Mat4w) -> Mat4d :

    C++ signature :
        cv::Mat_<cv::Vec<double, 4> > asMat4d(cv::Mat_<cv::Vec<unsigned short, 4> >)

asMat4d( (Mat1i)inst_Mat1i) -> Mat4d :

    C++ signature :
        cv::Mat_<cv::Vec<double, 4> > asMat4d(cv::Mat_<int>)

asMat4d( (Mat2i)inst_Mat2i) -> Mat4d :

    C++ signature :
        cv::Mat_<cv::Vec<double, 4> > asMat4d(cv::Mat_<cv::Vec<int, 2> >)

asMat4d( (Mat3i)inst_Mat3i) -> Mat4d :

    C++ signature :
        cv::Mat_<cv::Vec<double, 4> > asMat4d(cv::Mat_<cv::Vec<int, 3> >)

asMat4d( (Mat4i)inst_Mat4i) -> Mat4d :

    C++ signature :
        cv::Mat_<cv::Vec<double, 4> > asMat4d(cv::Mat_<cv::Vec<int, 4> >)

asMat4d( (Mat1f)inst_Mat1f) -> Mat4d :

    C++ signature :
        cv::Mat_<cv::Vec<double, 4> > asMat4d(cv::Mat_<float>)

asMat4d( (Mat2f)inst_Mat2f) -> Mat4d :

    C++ signature :
        cv::Mat_<cv::Vec<double, 4> > asMat4d(cv::Mat_<cv::Vec<float, 2> >)

asMat4d( (Mat3f)inst_Mat3f) -> Mat4d :

    C++ signature :
        cv::Mat_<cv::Vec<double, 4> > asMat4d(cv::Mat_<cv::Vec<float, 3> >)

asMat4d( (Mat4f)inst_Mat4f) -> Mat4d :

    C++ signature :
        cv::Mat_<cv::Vec<double, 4> > asMat4d(cv::Mat_<cv::Vec<float, 4> >)

asMat4d( (Mat1d)inst_Mat1d) -> Mat4d :

    C++ signature :
        cv::Mat_<cv::Vec<double, 4> > asMat4d(cv::Mat_<double>)

asMat4d( (Mat2d)inst_Mat2d) -> Mat4d :

    C++ signature :
        cv::Mat_<cv::Vec<double, 4> > asMat4d(cv::Mat_<cv::Vec<double, 2> >)

asMat4d( (Mat3d)inst_Mat3d) -> Mat4d :

    C++ signature :
        cv::Mat_<cv::Vec<double, 4> > asMat4d(cv::Mat_<cv::Vec<double, 3> >)

asMat4f(...)


asMat4f( (Mat1b)inst_Mat1b) -> Mat4f :

    C++ signature :
        cv::Mat_<cv::Vec<float, 4> > asMat4f(cv::Mat_<unsigned char>)

asMat4f( (Mat2b)inst_Mat2b) -> Mat4f :

    C++ signature :
        cv::Mat_<cv::Vec<float, 4> > asMat4f(cv::Mat_<cv::Vec<unsigned char, 2> >)

asMat4f( (Mat3b)inst_Mat3b) -> Mat4f :

    C++ signature :
        cv::Mat_<cv::Vec<float, 4> > asMat4f(cv::Mat_<cv::Vec<unsigned char, 3> >)

asMat4f( (Mat4b)inst_Mat4b) -> Mat4f :

    C++ signature :
        cv::Mat_<cv::Vec<float, 4> > asMat4f(cv::Mat_<cv::Vec<unsigned char, 4> >)

asMat4f( (Mat1s)inst_Mat1s) -> Mat4f :

    C++ signature :
        cv::Mat_<cv::Vec<float, 4> > asMat4f(cv::Mat_<short>)

asMat4f( (Mat2s)inst_Mat2s) -> Mat4f :

    C++ signature :
        cv::Mat_<cv::Vec<float, 4> > asMat4f(cv::Mat_<cv::Vec<short, 2> >)

asMat4f( (Mat3s)inst_Mat3s) -> Mat4f :

    C++ signature :
        cv::Mat_<cv::Vec<float, 4> > asMat4f(cv::Mat_<cv::Vec<short, 3> >)

asMat4f( (Mat4s)inst_Mat4s) -> Mat4f :

    C++ signature :
        cv::Mat_<cv::Vec<float, 4> > asMat4f(cv::Mat_<cv::Vec<short, 4> >)

asMat4f( (Mat1w)inst_Mat1w) -> Mat4f :

    C++ signature :
        cv::Mat_<cv::Vec<float, 4> > asMat4f(cv::Mat_<unsigned short>)

asMat4f( (Mat2w)inst_Mat2w) -> Mat4f :

    C++ signature :
        cv::Mat_<cv::Vec<float, 4> > asMat4f(cv::Mat_<cv::Vec<unsigned short, 2> >)

asMat4f( (Mat3w)inst_Mat3w) -> Mat4f :

    C++ signature :
        cv::Mat_<cv::Vec<float, 4> > asMat4f(cv::Mat_<cv::Vec<unsigned short, 3> >)

asMat4f( (Mat4w)inst_Mat4w) -> Mat4f :

    C++ signature :
        cv::Mat_<cv::Vec<float, 4> > asMat4f(cv::Mat_<cv::Vec<unsigned short, 4> >)

asMat4f( (Mat1i)inst_Mat1i) -> Mat4f :

    C++ signature :
        cv::Mat_<cv::Vec<float, 4> > asMat4f(cv::Mat_<int>)

asMat4f( (Mat2i)inst_Mat2i) -> Mat4f :

    C++ signature :
        cv::Mat_<cv::Vec<float, 4> > asMat4f(cv::Mat_<cv::Vec<int, 2> >)

asMat4f( (Mat3i)inst_Mat3i) -> Mat4f :

    C++ signature :
        cv::Mat_<cv::Vec<float, 4> > asMat4f(cv::Mat_<cv::Vec<int, 3> >)

asMat4f( (Mat4i)inst_Mat4i) -> Mat4f :

    C++ signature :
        cv::Mat_<cv::Vec<float, 4> > asMat4f(cv::Mat_<cv::Vec<int, 4> >)

asMat4f( (Mat1f)inst_Mat1f) -> Mat4f :

    C++ signature :
        cv::Mat_<cv::Vec<float, 4> > asMat4f(cv::Mat_<float>)

asMat4f( (Mat2f)inst_Mat2f) -> Mat4f :

    C++ signature :
        cv::Mat_<cv::Vec<float, 4> > asMat4f(cv::Mat_<cv::Vec<float, 2> >)

asMat4f( (Mat3f)inst_Mat3f) -> Mat4f :

    C++ signature :
        cv::Mat_<cv::Vec<float, 4> > asMat4f(cv::Mat_<cv::Vec<float, 3> >)

asMat4f( (Mat1d)inst_Mat1d) -> Mat4f :

    C++ signature :
        cv::Mat_<cv::Vec<float, 4> > asMat4f(cv::Mat_<double>)

asMat4f( (Mat2d)inst_Mat2d) -> Mat4f :

    C++ signature :
        cv::Mat_<cv::Vec<float, 4> > asMat4f(cv::Mat_<cv::Vec<double, 2> >)

asMat4f( (Mat3d)inst_Mat3d) -> Mat4f :

    C++ signature :
        cv::Mat_<cv::Vec<float, 4> > asMat4f(cv::Mat_<cv::Vec<double, 3> >)

asMat4f( (Mat4d)inst_Mat4d) -> Mat4f :

    C++ signature :
        cv::Mat_<cv::Vec<float, 4> > asMat4f(cv::Mat_<cv::Vec<double, 4> >)

asMat4i(...)


asMat4i( (Mat1b)inst_Mat1b) -> Mat4i :

    C++ signature :
        cv::Mat_<cv::Vec<int, 4> > asMat4i(cv::Mat_<unsigned char>)

asMat4i( (Mat2b)inst_Mat2b) -> Mat4i :

    C++ signature :
        cv::Mat_<cv::Vec<int, 4> > asMat4i(cv::Mat_<cv::Vec<unsigned char, 2> >)

asMat4i( (Mat3b)inst_Mat3b) -> Mat4i :

    C++ signature :
        cv::Mat_<cv::Vec<int, 4> > asMat4i(cv::Mat_<cv::Vec<unsigned char, 3> >)

asMat4i( (Mat4b)inst_Mat4b) -> Mat4i :

    C++ signature :
        cv::Mat_<cv::Vec<int, 4> > asMat4i(cv::Mat_<cv::Vec<unsigned char, 4> >)

asMat4i( (Mat1s)inst_Mat1s) -> Mat4i :

    C++ signature :
        cv::Mat_<cv::Vec<int, 4> > asMat4i(cv::Mat_<short>)

asMat4i( (Mat2s)inst_Mat2s) -> Mat4i :

    C++ signature :
        cv::Mat_<cv::Vec<int, 4> > asMat4i(cv::Mat_<cv::Vec<short, 2> >)

asMat4i( (Mat3s)inst_Mat3s) -> Mat4i :

    C++ signature :
        cv::Mat_<cv::Vec<int, 4> > asMat4i(cv::Mat_<cv::Vec<short, 3> >)

asMat4i( (Mat4s)inst_Mat4s) -> Mat4i :

    C++ signature :
        cv::Mat_<cv::Vec<int, 4> > asMat4i(cv::Mat_<cv::Vec<short, 4> >)

asMat4i( (Mat1w)inst_Mat1w) -> Mat4i :

    C++ signature :
        cv::Mat_<cv::Vec<int, 4> > asMat4i(cv::Mat_<unsigned short>)

asMat4i( (Mat2w)inst_Mat2w) -> Mat4i :

    C++ signature :
        cv::Mat_<cv::Vec<int, 4> > asMat4i(cv::Mat_<cv::Vec<unsigned short, 2> >)

asMat4i( (Mat3w)inst_Mat3w) -> Mat4i :

    C++ signature :
        cv::Mat_<cv::Vec<int, 4> > asMat4i(cv::Mat_<cv::Vec<unsigned short, 3> >)

asMat4i( (Mat4w)inst_Mat4w) -> Mat4i :

    C++ signature :
        cv::Mat_<cv::Vec<int, 4> > asMat4i(cv::Mat_<cv::Vec<unsigned short, 4> >)

asMat4i( (Mat1i)inst_Mat1i) -> Mat4i :

    C++ signature :
        cv::Mat_<cv::Vec<int, 4> > asMat4i(cv::Mat_<int>)

asMat4i( (Mat2i)inst_Mat2i) -> Mat4i :

    C++ signature :
        cv::Mat_<cv::Vec<int, 4> > asMat4i(cv::Mat_<cv::Vec<int, 2> >)

asMat4i( (Mat3i)inst_Mat3i) -> Mat4i :

    C++ signature :
        cv::Mat_<cv::Vec<int, 4> > asMat4i(cv::Mat_<cv::Vec<int, 3> >)

asMat4i( (Mat1f)inst_Mat1f) -> Mat4i :

    C++ signature :
        cv::Mat_<cv::Vec<int, 4> > asMat4i(cv::Mat_<float>)

asMat4i( (Mat2f)inst_Mat2f) -> Mat4i :

    C++ signature :
        cv::Mat_<cv::Vec<int, 4> > asMat4i(cv::Mat_<cv::Vec<float, 2> >)

asMat4i( (Mat3f)inst_Mat3f) -> Mat4i :

    C++ signature :
        cv::Mat_<cv::Vec<int, 4> > asMat4i(cv::Mat_<cv::Vec<float, 3> >)

asMat4i( (Mat4f)inst_Mat4f) -> Mat4i :

    C++ signature :
        cv::Mat_<cv::Vec<int, 4> > asMat4i(cv::Mat_<cv::Vec<float, 4> >)

asMat4i( (Mat1d)inst_Mat1d) -> Mat4i :

    C++ signature :
        cv::Mat_<cv::Vec<int, 4> > asMat4i(cv::Mat_<double>)

asMat4i( (Mat2d)inst_Mat2d) -> Mat4i :

    C++ signature :
        cv::Mat_<cv::Vec<int, 4> > asMat4i(cv::Mat_<cv::Vec<double, 2> >)

asMat4i( (Mat3d)inst_Mat3d) -> Mat4i :

    C++ signature :
        cv::Mat_<cv::Vec<int, 4> > asMat4i(cv::Mat_<cv::Vec<double, 3> >)

asMat4i( (Mat4d)inst_Mat4d) -> Mat4i :

    C++ signature :
        cv::Mat_<cv::Vec<int, 4> > asMat4i(cv::Mat_<cv::Vec<double, 4> >)

asMat4s(...)


asMat4s( (Mat1b)inst_Mat1b) -> Mat4s :

    C++ signature :
        cv::Mat_<cv::Vec<short, 4> > asMat4s(cv::Mat_<unsigned char>)

asMat4s( (Mat2b)inst_Mat2b) -> Mat4s :

    C++ signature :
        cv::Mat_<cv::Vec<short, 4> > asMat4s(cv::Mat_<cv::Vec<unsigned char, 2> >)

asMat4s( (Mat3b)inst_Mat3b) -> Mat4s :

    C++ signature :
        cv::Mat_<cv::Vec<short, 4> > asMat4s(cv::Mat_<cv::Vec<unsigned char, 3> >)

asMat4s( (Mat4b)inst_Mat4b) -> Mat4s :

    C++ signature :
        cv::Mat_<cv::Vec<short, 4> > asMat4s(cv::Mat_<cv::Vec<unsigned char, 4> >)

asMat4s( (Mat1s)inst_Mat1s) -> Mat4s :

    C++ signature :
        cv::Mat_<cv::Vec<short, 4> > asMat4s(cv::Mat_<short>)

asMat4s( (Mat2s)inst_Mat2s) -> Mat4s :

    C++ signature :
        cv::Mat_<cv::Vec<short, 4> > asMat4s(cv::Mat_<cv::Vec<short, 2> >)

asMat4s( (Mat3s)inst_Mat3s) -> Mat4s :

    C++ signature :
        cv::Mat_<cv::Vec<short, 4> > asMat4s(cv::Mat_<cv::Vec<short, 3> >)

asMat4s( (Mat1w)inst_Mat1w) -> Mat4s :

    C++ signature :
        cv::Mat_<cv::Vec<short, 4> > asMat4s(cv::Mat_<unsigned short>)

asMat4s( (Mat2w)inst_Mat2w) -> Mat4s :

    C++ signature :
        cv::Mat_<cv::Vec<short, 4> > asMat4s(cv::Mat_<cv::Vec<unsigned short, 2> >)

asMat4s( (Mat3w)inst_Mat3w) -> Mat4s :

    C++ signature :
        cv::Mat_<cv::Vec<short, 4> > asMat4s(cv::Mat_<cv::Vec<unsigned short, 3> >)

asMat4s( (Mat4w)inst_Mat4w) -> Mat4s :

    C++ signature :
        cv::Mat_<cv::Vec<short, 4> > asMat4s(cv::Mat_<cv::Vec<unsigned short, 4> >)

asMat4s( (Mat1i)inst_Mat1i) -> Mat4s :

    C++ signature :
        cv::Mat_<cv::Vec<short, 4> > asMat4s(cv::Mat_<int>)

asMat4s( (Mat2i)inst_Mat2i) -> Mat4s :

    C++ signature :
        cv::Mat_<cv::Vec<short, 4> > asMat4s(cv::Mat_<cv::Vec<int, 2> >)

asMat4s( (Mat3i)inst_Mat3i) -> Mat4s :

    C++ signature :
        cv::Mat_<cv::Vec<short, 4> > asMat4s(cv::Mat_<cv::Vec<int, 3> >)

asMat4s( (Mat4i)inst_Mat4i) -> Mat4s :

    C++ signature :
        cv::Mat_<cv::Vec<short, 4> > asMat4s(cv::Mat_<cv::Vec<int, 4> >)

asMat4s( (Mat1f)inst_Mat1f) -> Mat4s :

    C++ signature :
        cv::Mat_<cv::Vec<short, 4> > asMat4s(cv::Mat_<float>)

asMat4s( (Mat2f)inst_Mat2f) -> Mat4s :

    C++ signature :
        cv::Mat_<cv::Vec<short, 4> > asMat4s(cv::Mat_<cv::Vec<float, 2> >)

asMat4s( (Mat3f)inst_Mat3f) -> Mat4s :

    C++ signature :
        cv::Mat_<cv::Vec<short, 4> > asMat4s(cv::Mat_<cv::Vec<float, 3> >)

asMat4s( (Mat4f)inst_Mat4f) -> Mat4s :

    C++ signature :
        cv::Mat_<cv::Vec<short, 4> > asMat4s(cv::Mat_<cv::Vec<float, 4> >)

asMat4s( (Mat1d)inst_Mat1d) -> Mat4s :

    C++ signature :
        cv::Mat_<cv::Vec<short, 4> > asMat4s(cv::Mat_<double>)

asMat4s( (Mat2d)inst_Mat2d) -> Mat4s :

    C++ signature :
        cv::Mat_<cv::Vec<short, 4> > asMat4s(cv::Mat_<cv::Vec<double, 2> >)

asMat4s( (Mat3d)inst_Mat3d) -> Mat4s :

    C++ signature :
        cv::Mat_<cv::Vec<short, 4> > asMat4s(cv::Mat_<cv::Vec<double, 3> >)

asMat4s( (Mat4d)inst_Mat4d) -> Mat4s :

    C++ signature :
        cv::Mat_<cv::Vec<short, 4> > asMat4s(cv::Mat_<cv::Vec<double, 4> >)

asMat4w(...)


asMat4w( (Mat1b)inst_Mat1b) -> Mat4w :

    C++ signature :
        cv::Mat_<cv::Vec<unsigned short, 4> > asMat4w(cv::Mat_<unsigned char>)

asMat4w( (Mat2b)inst_Mat2b) -> Mat4w :

    C++ signature :
        cv::Mat_<cv::Vec<unsigned short, 4> > asMat4w(cv::Mat_<cv::Vec<unsigned char, 2> >)

asMat4w( (Mat3b)inst_Mat3b) -> Mat4w :

    C++ signature :
        cv::Mat_<cv::Vec<unsigned short, 4> > asMat4w(cv::Mat_<cv::Vec<unsigned char, 3> >)

asMat4w( (Mat4b)inst_Mat4b) -> Mat4w :

    C++ signature :
        cv::Mat_<cv::Vec<unsigned short, 4> > asMat4w(cv::Mat_<cv::Vec<unsigned char, 4> >)

asMat4w( (Mat1s)inst_Mat1s) -> Mat4w :

    C++ signature :
        cv::Mat_<cv::Vec<unsigned short, 4> > asMat4w(cv::Mat_<short>)

asMat4w( (Mat2s)inst_Mat2s) -> Mat4w :

    C++ signature :
        cv::Mat_<cv::Vec<unsigned short, 4> > asMat4w(cv::Mat_<cv::Vec<short, 2> >)

asMat4w( (Mat3s)inst_Mat3s) -> Mat4w :

    C++ signature :
        cv::Mat_<cv::Vec<unsigned short, 4> > asMat4w(cv::Mat_<cv::Vec<short, 3> >)

asMat4w( (Mat4s)inst_Mat4s) -> Mat4w :

    C++ signature :
        cv::Mat_<cv::Vec<unsigned short, 4> > asMat4w(cv::Mat_<cv::Vec<short, 4> >)

asMat4w( (Mat1w)inst_Mat1w) -> Mat4w :

    C++ signature :
        cv::Mat_<cv::Vec<unsigned short, 4> > asMat4w(cv::Mat_<unsigned short>)

asMat4w( (Mat2w)inst_Mat2w) -> Mat4w :

    C++ signature :
        cv::Mat_<cv::Vec<unsigned short, 4> > asMat4w(cv::Mat_<cv::Vec<unsigned short, 2> >)

asMat4w( (Mat3w)inst_Mat3w) -> Mat4w :

    C++ signature :
        cv::Mat_<cv::Vec<unsigned short, 4> > asMat4w(cv::Mat_<cv::Vec<unsigned short, 3> >)

asMat4w( (Mat1i)inst_Mat1i) -> Mat4w :

    C++ signature :
        cv::Mat_<cv::Vec<unsigned short, 4> > asMat4w(cv::Mat_<int>)

asMat4w( (Mat2i)inst_Mat2i) -> Mat4w :

    C++ signature :
        cv::Mat_<cv::Vec<unsigned short, 4> > asMat4w(cv::Mat_<cv::Vec<int, 2> >)

asMat4w( (Mat3i)inst_Mat3i) -> Mat4w :

    C++ signature :
        cv::Mat_<cv::Vec<unsigned short, 4> > asMat4w(cv::Mat_<cv::Vec<int, 3> >)

asMat4w( (Mat4i)inst_Mat4i) -> Mat4w :

    C++ signature :
        cv::Mat_<cv::Vec<unsigned short, 4> > asMat4w(cv::Mat_<cv::Vec<int, 4> >)

asMat4w( (Mat1f)inst_Mat1f) -> Mat4w :

    C++ signature :
        cv::Mat_<cv::Vec<unsigned short, 4> > asMat4w(cv::Mat_<float>)

asMat4w( (Mat2f)inst_Mat2f) -> Mat4w :

    C++ signature :
        cv::Mat_<cv::Vec<unsigned short, 4> > asMat4w(cv::Mat_<cv::Vec<float, 2> >)

asMat4w( (Mat3f)inst_Mat3f) -> Mat4w :

    C++ signature :
        cv::Mat_<cv::Vec<unsigned short, 4> > asMat4w(cv::Mat_<cv::Vec<float, 3> >)

asMat4w( (Mat4f)inst_Mat4f) -> Mat4w :

    C++ signature :
        cv::Mat_<cv::Vec<unsigned short, 4> > asMat4w(cv::Mat_<cv::Vec<float, 4> >)

asMat4w( (Mat1d)inst_Mat1d) -> Mat4w :

    C++ signature :
        cv::Mat_<cv::Vec<unsigned short, 4> > asMat4w(cv::Mat_<double>)

asMat4w( (Mat2d)inst_Mat2d) -> Mat4w :

    C++ signature :
        cv::Mat_<cv::Vec<unsigned short, 4> > asMat4w(cv::Mat_<cv::Vec<double, 2> >)

asMat4w( (Mat3d)inst_Mat3d) -> Mat4w :

    C++ signature :
        cv::Mat_<cv::Vec<unsigned short, 4> > asMat4w(cv::Mat_<cv::Vec<double, 3> >)

asMat4w( (Mat4d)inst_Mat4d) -> Mat4w :

    C++ signature :
        cv::Mat_<cv::Vec<unsigned short, 4> > asMat4w(cv::Mat_<cv::Vec<double, 4> >)

asMatND(...)


asMatND( (object)arr) -> object :

    C++ signature :
        boost::python::api::object asMatND(boost::python::ndarray)

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( (object)arr) -> object :

    C++ signature :
        boost::python::api::object asPoint2i(boost::python::ndarray)

asPoint2d(...)


asPoint2d( (Point2i)inst_Point2i) -> Point2d :

    C++ signature :
        cv::Point_<double> asPoint2d(cv::Point_<int>)

asPoint2d( (Point2f)inst_Point2f) -> Point2d :

    C++ signature :
        cv::Point_<double> asPoint2d(cv::Point_<float>)

asPoint2d( (object)arr) -> object :

    C++ signature :
        boost::python::api::object asPoint2d(boost::python::ndarray)

asPoint2f(...)


asPoint2f( (Point2i)inst_Point2i) -> Point2f :

    C++ signature :
        cv::Point_<float> asPoint2f(cv::Point_<int>)

asPoint2f( (Point2d)inst_Point2d) -> Point2f :

    C++ signature :
        cv::Point_<float> asPoint2f(cv::Point_<double>)

asPoint2f( (object)arr) -> object :

    C++ signature :
        boost::python::api::object asPoint2f(boost::python::ndarray)

asPoint2i(...)


asPoint2i( (Point2f)inst_Point2f) -> Point2i :

    C++ signature :
        cv::Point_<int> asPoint2i(cv::Point_<float>)

asPoint2i( (Point2d)inst_Point2d) -> Point2i :

    C++ signature :
        cv::Point_<int> asPoint2i(cv::Point_<double>)

asPoint2i( (object)arr) -> object :

    C++ signature :
        boost::python::api::object asPoint2i(boost::python::ndarray)

asPoint3d(...)


asPoint3d( (Point3i)inst_Point3i) -> Point3d :

    C++ signature :
        cv::Point3_<double> asPoint3d(cv::Point3_<int>)

asPoint3d( (Point3f)inst_Point3f) -> Point3d :

    C++ signature :
        cv::Point3_<double> asPoint3d(cv::Point3_<float>)

asPoint3d( (object)arr) -> object :

    C++ signature :
        boost::python::api::object asPoint3d(boost::python::ndarray)

asPoint3f(...)


asPoint3f( (Point3i)inst_Point3i) -> Point3f :

    C++ signature :
        cv::Point3_<float> asPoint3f(cv::Point3_<int>)

asPoint3f( (Point3d)inst_Point3d) -> Point3f :

    C++ signature :
        cv::Point3_<float> asPoint3f(cv::Point3_<double>)

asPoint3f( (object)arr) -> object :

    C++ signature :
        boost::python::api::object asPoint3f(boost::python::ndarray)

asPoint3i(...)


asPoint3i( (Point3f)inst_Point3f) -> Point3i :

    C++ signature :
        cv::Point3_<int> asPoint3i(cv::Point3_<float>)

asPoint3i( (Point3d)inst_Point3d) -> Point3i :

    C++ signature :
        cv::Point3_<int> asPoint3i(cv::Point3_<double>)

asPoint3i( (object)arr) -> object :

    C++ signature :
        boost::python::api::object asPoint3i(boost::python::ndarray)

asRange(...)


asRange( (object)arr) -> object :

    C++ signature :
        boost::python::api::object asRange(boost::python::ndarray)

asRect(...)


asRect( (Rectf)inst_Rectf) -> Rect :

    C++ signature :
        cv::Rect_<int> asRect(cv::Rect_<float>)

asRect( (Rectd)inst_Rectd) -> Rect :

    C++ signature :
        cv::Rect_<int> asRect(cv::Rect_<double>)

asRect( (object)arr) -> object :

    C++ signature :
        boost::python::api::object asRect(boost::python::ndarray)

asRectd(...)


asRectd( (Rect)inst_Rect) -> Rectd :

    C++ signature :
        cv::Rect_<double> asRectd(cv::Rect_<int>)

asRectd( (Rectf)inst_Rectf) -> Rectd :

    C++ signature :
        cv::Rect_<double> asRectd(cv::Rect_<float>)

asRectd( (object)arr) -> object :

    C++ signature :
        boost::python::api::object asRectd(boost::python::ndarray)

asRectf(...)


asRectf( (Rect)inst_Rect) -> Rectf :

    C++ signature :
        cv::Rect_<float> asRectf(cv::Rect_<int>)

asRectf( (Rectd)inst_Rectd) -> Rectf :

    C++ signature :
        cv::Rect_<float> asRectf(cv::Rect_<double>)

asRectf( (object)arr) -> object :

    C++ signature :
        boost::python::api::object asRectf(boost::python::ndarray)

asRotatedRect(...)


asRotatedRect( (object)arr) -> object :

    C++ signature :
        boost::python::api::object asRotatedRect(boost::python::ndarray)

asScalar(...)


asScalar( (object)arr) -> object :

    C++ signature :
        boost::python::api::object asScalar(boost::python::ndarray)

asSize2d(...)


asSize2d( (Size2i)inst_Size2i) -> Size2d :

    C++ signature :
        cv::Size_<double> asSize2d(cv::Size_<int>)

asSize2d( (Size2f)inst_Size2f) -> Size2d :

    C++ signature :
        cv::Size_<double> asSize2d(cv::Size_<float>)

asSize2d( (object)arr) -> object :

    C++ signature :
        boost::python::api::object asSize2d(boost::python::ndarray)

asSize2f(...)


asSize2f( (Size2i)inst_Size2i) -> Size2f :

    C++ signature :
        cv::Size_<float> asSize2f(cv::Size_<int>)

asSize2f( (Size2d)inst_Size2d) -> Size2f :

    C++ signature :
        cv::Size_<float> asSize2f(cv::Size_<double>)

asSize2f( (object)arr) -> object :

    C++ signature :
        boost::python::api::object asSize2f(boost::python::ndarray)

asSize2i(...)


asSize2i( (Size2f)inst_Size2f) -> Size2i :

    C++ signature :
        cv::Size_<int> asSize2i(cv::Size_<float>)

asSize2i( (Size2d)inst_Size2d) -> Size2i :

    C++ signature :
        cv::Size_<int> asSize2i(cv::Size_<double>)

asSize2i( (object)arr) -> object :

    C++ signature :
        boost::python::api::object asSize2i(boost::python::ndarray)

asVec2b(...)


asVec2b( (Vec2s)inst_Vec2s) -> Vec2b :

    C++ signature :
        cv::Vec<unsigned char, 2> asVec2b(cv::Vec<short, 2>)

asVec2b( (Vec2w)inst_Vec2w) -> Vec2b :

    C++ signature :
        cv::Vec<unsigned char, 2> asVec2b(cv::Vec<unsigned short, 2>)

asVec2b( (Vec2i)inst_Vec2i) -> Vec2b :

    C++ signature :
        cv::Vec<unsigned char, 2> asVec2b(cv::Vec<int, 2>)

asVec2b( (Vec2f)inst_Vec2f) -> Vec2b :

    C++ signature :
        cv::Vec<unsigned char, 2> asVec2b(cv::Vec<float, 2>)

asVec2b( (Vec2d)inst_Vec2d) -> Vec2b :

    C++ signature :
        cv::Vec<unsigned char, 2> asVec2b(cv::Vec<double, 2>)

asVec2b( (object)arr) -> object :

    C++ signature :
        boost::python::api::object asVec2b(boost::python::ndarray)

asVec2d(...)


asVec2d( (Vec2b)inst_Vec2b) -> Vec2d :

    C++ signature :
        cv::Vec<double, 2> asVec2d(cv::Vec<unsigned char, 2>)

asVec2d( (Vec2s)inst_Vec2s) -> Vec2d :

    C++ signature :
        cv::Vec<double, 2> asVec2d(cv::Vec<short, 2>)

asVec2d( (Vec2w)inst_Vec2w) -> Vec2d :

    C++ signature :
        cv::Vec<double, 2> asVec2d(cv::Vec<unsigned short, 2>)

asVec2d( (Vec2i)inst_Vec2i) -> Vec2d :

    C++ signature :
        cv::Vec<double, 2> asVec2d(cv::Vec<int, 2>)

asVec2d( (Vec2f)inst_Vec2f) -> Vec2d :

    C++ signature :
        cv::Vec<double, 2> asVec2d(cv::Vec<float, 2>)

asVec2d( (object)arr) -> object :

    C++ signature :
        boost::python::api::object asVec2d(boost::python::ndarray)

asVec2f(...)


asVec2f( (Vec2b)inst_Vec2b) -> Vec2f :

    C++ signature :
        cv::Vec<float, 2> asVec2f(cv::Vec<unsigned char, 2>)

asVec2f( (Vec2s)inst_Vec2s) -> Vec2f :

    C++ signature :
        cv::Vec<float, 2> asVec2f(cv::Vec<short, 2>)

asVec2f( (Vec2w)inst_Vec2w) -> Vec2f :

    C++ signature :
        cv::Vec<float, 2> asVec2f(cv::Vec<unsigned short, 2>)

asVec2f( (Vec2i)inst_Vec2i) -> Vec2f :

    C++ signature :
        cv::Vec<float, 2> asVec2f(cv::Vec<int, 2>)

asVec2f( (Vec2d)inst_Vec2d) -> Vec2f :

    C++ signature :
        cv::Vec<float, 2> asVec2f(cv::Vec<double, 2>)

asVec2f( (object)arr) -> object :

    C++ signature :
        boost::python::api::object asVec2f(boost::python::ndarray)

asVec2i(...)


asVec2i( (Vec2b)inst_Vec2b) -> Vec2i :

    C++ signature :
        cv::Vec<int, 2> asVec2i(cv::Vec<unsigned char, 2>)

asVec2i( (Vec2s)inst_Vec2s) -> Vec2i :

    C++ signature :
        cv::Vec<int, 2> asVec2i(cv::Vec<short, 2>)

asVec2i( (Vec2w)inst_Vec2w) -> Vec2i :

    C++ signature :
        cv::Vec<int, 2> asVec2i(cv::Vec<unsigned short, 2>)

asVec2i( (Vec2f)inst_Vec2f) -> Vec2i :

    C++ signature :
        cv::Vec<int, 2> asVec2i(cv::Vec<float, 2>)

asVec2i( (Vec2d)inst_Vec2d) -> Vec2i :

    C++ signature :
        cv::Vec<int, 2> asVec2i(cv::Vec<double, 2>)

asVec2i( (object)arr) -> object :

    C++ signature :
        boost::python::api::object asVec2i(boost::python::ndarray)

asVec2s(...)


asVec2s( (Vec2b)inst_Vec2b) -> Vec2s :

    C++ signature :
        cv::Vec<short, 2> asVec2s(cv::Vec<unsigned char, 2>)

asVec2s( (Vec2w)inst_Vec2w) -> Vec2s :

    C++ signature :
        cv::Vec<short, 2> asVec2s(cv::Vec<unsigned short, 2>)

asVec2s( (Vec2i)inst_Vec2i) -> Vec2s :

    C++ signature :
        cv::Vec<short, 2> asVec2s(cv::Vec<int, 2>)

asVec2s( (Vec2f)inst_Vec2f) -> Vec2s :

    C++ signature :
        cv::Vec<short, 2> asVec2s(cv::Vec<float, 2>)

asVec2s( (Vec2d)inst_Vec2d) -> Vec2s :

    C++ signature :
        cv::Vec<short, 2> asVec2s(cv::Vec<double, 2>)

asVec2s( (object)arr) -> object :

    C++ signature :
        boost::python::api::object asVec2s(boost::python::ndarray)

asVec2w(...)


asVec2w( (Vec2b)inst_Vec2b) -> Vec2w :

    C++ signature :
        cv::Vec<unsigned short, 2> asVec2w(cv::Vec<unsigned char, 2>)

asVec2w( (Vec2s)inst_Vec2s) -> Vec2w :

    C++ signature :
        cv::Vec<unsigned short, 2> asVec2w(cv::Vec<short, 2>)

asVec2w( (Vec2i)inst_Vec2i) -> Vec2w :

    C++ signature :
        cv::Vec<unsigned short, 2> asVec2w(cv::Vec<int, 2>)

asVec2w( (Vec2f)inst_Vec2f) -> Vec2w :

    C++ signature :
        cv::Vec<unsigned short, 2> asVec2w(cv::Vec<float, 2>)

asVec2w( (Vec2d)inst_Vec2d) -> Vec2w :

    C++ signature :
        cv::Vec<unsigned short, 2> asVec2w(cv::Vec<double, 2>)

asVec2w( (object)arr) -> object :

    C++ signature :
        boost::python::api::object asVec2w(boost::python::ndarray)

asVec3b(...)


asVec3b( (Vec3s)inst_Vec3s) -> Vec3b :

    C++ signature :
        cv::Vec<unsigned char, 3> asVec3b(cv::Vec<short, 3>)

asVec3b( (Vec3w)inst_Vec3w) -> Vec3b :

    C++ signature :
        cv::Vec<unsigned char, 3> asVec3b(cv::Vec<unsigned short, 3>)

asVec3b( (Vec3i)inst_Vec3i) -> Vec3b :

    C++ signature :
        cv::Vec<unsigned char, 3> asVec3b(cv::Vec<int, 3>)

asVec3b( (Vec3f)inst_Vec3f) -> Vec3b :

    C++ signature :
        cv::Vec<unsigned char, 3> asVec3b(cv::Vec<float, 3>)

asVec3b( (Vec3d)inst_Vec3d) -> Vec3b :

    C++ signature :
        cv::Vec<unsigned char, 3> asVec3b(cv::Vec<double, 3>)

asVec3b( (object)arr) -> object :

    C++ signature :
        boost::python::api::object asVec3b(boost::python::ndarray)

asVec3d(...)


asVec3d( (Vec3b)inst_Vec3b) -> Vec3d :

    C++ signature :
        cv::Vec<double, 3> asVec3d(cv::Vec<unsigned char, 3>)

asVec3d( (Vec3s)inst_Vec3s) -> Vec3d :

    C++ signature :
        cv::Vec<double, 3> asVec3d(cv::Vec<short, 3>)

asVec3d( (Vec3w)inst_Vec3w) -> Vec3d :

    C++ signature :
        cv::Vec<double, 3> asVec3d(cv::Vec<unsigned short, 3>)

asVec3d( (Vec3i)inst_Vec3i) -> Vec3d :

    C++ signature :
        cv::Vec<double, 3> asVec3d(cv::Vec<int, 3>)

asVec3d( (Vec3f)inst_Vec3f) -> Vec3d :

    C++ signature :
        cv::Vec<double, 3> asVec3d(cv::Vec<float, 3>)

asVec3d( (object)arr) -> object :

    C++ signature :
        boost::python::api::object asVec3d(boost::python::ndarray)

asVec3f(...)


asVec3f( (Vec3b)inst_Vec3b) -> Vec3f :

    C++ signature :
        cv::Vec<float, 3> asVec3f(cv::Vec<unsigned char, 3>)

asVec3f( (Vec3s)inst_Vec3s) -> Vec3f :

    C++ signature :
        cv::Vec<float, 3> asVec3f(cv::Vec<short, 3>)

asVec3f( (Vec3w)inst_Vec3w) -> Vec3f :

    C++ signature :
        cv::Vec<float, 3> asVec3f(cv::Vec<unsigned short, 3>)

asVec3f( (Vec3i)inst_Vec3i) -> Vec3f :

    C++ signature :
        cv::Vec<float, 3> asVec3f(cv::Vec<int, 3>)

asVec3f( (Vec3d)inst_Vec3d) -> Vec3f :

    C++ signature :
        cv::Vec<float, 3> asVec3f(cv::Vec<double, 3>)

asVec3f( (object)arr) -> object :

    C++ signature :
        boost::python::api::object asVec3f(boost::python::ndarray)

asVec3i(...)


asVec3i( (Vec3b)inst_Vec3b) -> Vec3i :

    C++ signature :
        cv::Vec<int, 3> asVec3i(cv::Vec<unsigned char, 3>)

asVec3i( (Vec3s)inst_Vec3s) -> Vec3i :

    C++ signature :
        cv::Vec<int, 3> asVec3i(cv::Vec<short, 3>)

asVec3i( (Vec3w)inst_Vec3w) -> Vec3i :

    C++ signature :
        cv::Vec<int, 3> asVec3i(cv::Vec<unsigned short, 3>)

asVec3i( (Vec3f)inst_Vec3f) -> Vec3i :

    C++ signature :
        cv::Vec<int, 3> asVec3i(cv::Vec<float, 3>)

asVec3i( (Vec3d)inst_Vec3d) -> Vec3i :

    C++ signature :
        cv::Vec<int, 3> asVec3i(cv::Vec<double, 3>)

asVec3i( (object)arr) -> object :

    C++ signature :
        boost::python::api::object asVec3i(boost::python::ndarray)

asVec3s(...)


asVec3s( (Vec3b)inst_Vec3b) -> Vec3s :

    C++ signature :
        cv::Vec<short, 3> asVec3s(cv::Vec<unsigned char, 3>)

asVec3s( (Vec3w)inst_Vec3w) -> Vec3s :

    C++ signature :
        cv::Vec<short, 3> asVec3s(cv::Vec<unsigned short, 3>)

asVec3s( (Vec3i)inst_Vec3i) -> Vec3s :

    C++ signature :
        cv::Vec<short, 3> asVec3s(cv::Vec<int, 3>)

asVec3s( (Vec3f)inst_Vec3f) -> Vec3s :

    C++ signature :
        cv::Vec<short, 3> asVec3s(cv::Vec<float, 3>)

asVec3s( (Vec3d)inst_Vec3d) -> Vec3s :

    C++ signature :
        cv::Vec<short, 3> asVec3s(cv::Vec<double, 3>)

asVec3s( (object)arr) -> object :

    C++ signature :
        boost::python::api::object asVec3s(boost::python::ndarray)

asVec3w(...)


asVec3w( (Vec3b)inst_Vec3b) -> Vec3w :

    C++ signature :
        cv::Vec<unsigned short, 3> asVec3w(cv::Vec<unsigned char, 3>)

asVec3w( (Vec3s)inst_Vec3s) -> Vec3w :

    C++ signature :
        cv::Vec<unsigned short, 3> asVec3w(cv::Vec<short, 3>)

asVec3w( (Vec3i)inst_Vec3i) -> Vec3w :

    C++ signature :
        cv::Vec<unsigned short, 3> asVec3w(cv::Vec<int, 3>)

asVec3w( (Vec3f)inst_Vec3f) -> Vec3w :

    C++ signature :
        cv::Vec<unsigned short, 3> asVec3w(cv::Vec<float, 3>)

asVec3w( (Vec3d)inst_Vec3d) -> Vec3w :

    C++ signature :
        cv::Vec<unsigned short, 3> asVec3w(cv::Vec<double, 3>)

asVec3w( (object)arr) -> object :

    C++ signature :
        boost::python::api::object asVec3w(boost::python::ndarray)

asVec4b(...)


asVec4b( (Vec4s)inst_Vec4s) -> Vec4b :

    C++ signature :
        cv::Vec<unsigned char, 4> asVec4b(cv::Vec<short, 4>)

asVec4b( (Vec4w)inst_Vec4w) -> Vec4b :

    C++ signature :
        cv::Vec<unsigned char, 4> asVec4b(cv::Vec<unsigned short, 4>)

asVec4b( (Vec4i)inst_Vec4i) -> Vec4b :

    C++ signature :
        cv::Vec<unsigned char, 4> asVec4b(cv::Vec<int, 4>)

asVec4b( (Vec4f)inst_Vec4f) -> Vec4b :

    C++ signature :
        cv::Vec<unsigned char, 4> asVec4b(cv::Vec<float, 4>)

asVec4b( (Vec4d)inst_Vec4d) -> Vec4b :

    C++ signature :
        cv::Vec<unsigned char, 4> asVec4b(cv::Vec<double, 4>)

asVec4b( (object)arr) -> object :

    C++ signature :
        boost::python::api::object asVec4b(boost::python::ndarray)

asVec4d(...)


asVec4d( (Vec4b)inst_Vec4b) -> Vec4d :

    C++ signature :
        cv::Vec<double, 4> asVec4d(cv::Vec<unsigned char, 4>)

asVec4d( (Vec4s)inst_Vec4s) -> Vec4d :

    C++ signature :
        cv::Vec<double, 4> asVec4d(cv::Vec<short, 4>)

asVec4d( (Vec4w)inst_Vec4w) -> Vec4d :

    C++ signature :
        cv::Vec<double, 4> asVec4d(cv::Vec<unsigned short, 4>)

asVec4d( (Vec4i)inst_Vec4i) -> Vec4d :

    C++ signature :
        cv::Vec<double, 4> asVec4d(cv::Vec<int, 4>)

asVec4d( (Vec4f)inst_Vec4f) -> Vec4d :

    C++ signature :
        cv::Vec<double, 4> asVec4d(cv::Vec<float, 4>)

asVec4d( (object)arr) -> object :

    C++ signature :
        boost::python::api::object asVec4d(boost::python::ndarray)

asVec4f(...)


asVec4f( (Vec4b)inst_Vec4b) -> Vec4f :

    C++ signature :
        cv::Vec<float, 4> asVec4f(cv::Vec<unsigned char, 4>)

asVec4f( (Vec4s)inst_Vec4s) -> Vec4f :

    C++ signature :
        cv::Vec<float, 4> asVec4f(cv::Vec<short, 4>)

asVec4f( (Vec4w)inst_Vec4w) -> Vec4f :

    C++ signature :
        cv::Vec<float, 4> asVec4f(cv::Vec<unsigned short, 4>)

asVec4f( (Vec4i)inst_Vec4i) -> Vec4f :

    C++ signature :
        cv::Vec<float, 4> asVec4f(cv::Vec<int, 4>)

asVec4f( (Vec4d)inst_Vec4d) -> Vec4f :

    C++ signature :
        cv::Vec<float, 4> asVec4f(cv::Vec<double, 4>)

asVec4f( (object)arr) -> object :

    C++ signature :
        boost::python::api::object asVec4f(boost::python::ndarray)

asVec4i(...)


asVec4i( (Vec4b)inst_Vec4b) -> Vec4i :

    C++ signature :
        cv::Vec<int, 4> asVec4i(cv::Vec<unsigned char, 4>)

asVec4i( (Vec4s)inst_Vec4s) -> Vec4i :

    C++ signature :
        cv::Vec<int, 4> asVec4i(cv::Vec<short, 4>)

asVec4i( (Vec4w)inst_Vec4w) -> Vec4i :

    C++ signature :
        cv::Vec<int, 4> asVec4i(cv::Vec<unsigned short, 4>)

asVec4i( (Vec4f)inst_Vec4f) -> Vec4i :

    C++ signature :
        cv::Vec<int, 4> asVec4i(cv::Vec<float, 4>)

asVec4i( (Vec4d)inst_Vec4d) -> Vec4i :

    C++ signature :
        cv::Vec<int, 4> asVec4i(cv::Vec<double, 4>)

asVec4i( (object)arr) -> object :

    C++ signature :
        boost::python::api::object asVec4i(boost::python::ndarray)

asVec4s(...)


asVec4s( (Vec4b)inst_Vec4b) -> Vec4s :

    C++ signature :
        cv::Vec<short, 4> asVec4s(cv::Vec<unsigned char, 4>)

asVec4s( (Vec4w)inst_Vec4w) -> Vec4s :

    C++ signature :
        cv::Vec<short, 4> asVec4s(cv::Vec<unsigned short, 4>)

asVec4s( (Vec4i)inst_Vec4i) -> Vec4s :

    C++ signature :
        cv::Vec<short, 4> asVec4s(cv::Vec<int, 4>)

asVec4s( (Vec4f)inst_Vec4f) -> Vec4s :

    C++ signature :
        cv::Vec<short, 4> asVec4s(cv::Vec<float, 4>)

asVec4s( (Vec4d)inst_Vec4d) -> Vec4s :

    C++ signature :
        cv::Vec<short, 4> asVec4s(cv::Vec<double, 4>)

asVec4s( (object)arr) -> object :

    C++ signature :
        boost::python::api::object asVec4s(boost::python::ndarray)

asVec4w(...)


asVec4w( (Vec4b)inst_Vec4b) -> Vec4w :

    C++ signature :
        cv::Vec<unsigned short, 4> asVec4w(cv::Vec<unsigned char, 4>)

asVec4w( (Vec4s)inst_Vec4s) -> Vec4w :

    C++ signature :
        cv::Vec<unsigned short, 4> asVec4w(cv::Vec<short, 4>)

asVec4w( (Vec4i)inst_Vec4i) -> Vec4w :

    C++ signature :
        cv::Vec<unsigned short, 4> asVec4w(cv::Vec<int, 4>)

asVec4w( (Vec4f)inst_Vec4f) -> Vec4w :

    C++ signature :
        cv::Vec<unsigned short, 4> asVec4w(cv::Vec<float, 4>)

asVec4w( (Vec4d)inst_Vec4d) -> Vec4w :

    C++ signature :
        cv::Vec<unsigned short, 4> asVec4w(cv::Vec<double, 4>)

asVec4w( (object)arr) -> object :

    C++ signature :
        boost::python::api::object asVec4w(boost::python::ndarray)

asVec6d(...)


asVec6d( (Vec6f)inst_Vec6f) -> Vec6d :

    C++ signature :
        cv::Vec<double, 6> asVec6d(cv::Vec<float, 6>)

asVec6d( (object)arr) -> object :

    C++ signature :
        boost::python::api::object asVec6d(boost::python::ndarray)

asVec6f(...)


asVec6f( (Vec6d)inst_Vec6d) -> Vec6f :

    C++ signature :
        cv::Vec<float, 6> asVec6f(cv::Vec<double, 6>)

asVec6f( (object)arr) -> object :

    C++ signature :
        boost::python::api::object asVec6f(boost::python::ndarray)

attrValue(...)


attrValue( (CvAttrList)attr, (str)attr_name) -> str :
    
    Wrapped function:
        cvAttrValue

    C++ signature :
        char const* attrValue(CvAttrList const*,char const*)

bilateralFilter(...)


bilateralFilter( (Mat)src, (Mat)dst, (object)d, (object)sigmaColor, (object)sigmaSpace [, (object)borderType=4]) -> None :

    C++ signature :
        void bilateralFilter(cv::Mat,cv::Mat {lvalue},int,double,double [,int=4])

bitwise_and(...)


bitwise_and( (MatND)a, (Scalar)s, (MatND)c [, (MatND)mask=MatND(shape=(), nchannels=1, depth=0):
array(0, dtype=uint8)]) -> None :
    
    Calculates per-element bit-wise conjunction of two arrays and an 
    array and a scalar.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#cv-bitwise-and

    C++ signature :
        void bitwise_and(cv::MatND,cv::Scalar_<double>,cv::MatND {lvalue} [,cv::MatND=MatND(shape=(), nchannels=1, depth=0):
array(0, dtype=uint8)])

bitwise_and( (MatND)a, (MatND)b, (MatND)c [, (MatND)mask=MatND(shape=(), nchannels=1, depth=0):
array(0, dtype=uint8)]) -> None :
    
    Calculates per-element bit-wise conjunction of two arrays and an 
    array and a scalar.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#cv-bitwise-and

    C++ signature :
        void bitwise_and(cv::MatND,cv::MatND,cv::MatND {lvalue} [,cv::MatND=MatND(shape=(), nchannels=1, depth=0):
array(0, dtype=uint8)])

bitwise_and( (Mat)a, (Scalar)s, (Mat)c [, (Mat)mask=Mat()]) -> None :
    
    Calculates per-element bit-wise conjunction of two arrays and an 
    array and a scalar.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#cv-bitwise-and

    C++ signature :
        void bitwise_and(cv::Mat,cv::Scalar_<double>,cv::Mat {lvalue} [,cv::Mat=Mat()])

bitwise_and( (Mat)a, (Mat)b, (Mat)c [, (Mat)mask=Mat()]) -> None :
    
    Calculates per-element bit-wise conjunction of two arrays and an 
    array and a scalar.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#cv-bitwise-and

    C++ signature :
        void bitwise_and(cv::Mat,cv::Mat,cv::Mat {lvalue} [,cv::Mat=Mat()])

bitwise_not(...)


bitwise_not( (MatND)a, (MatND)c) -> None :
    
    Inverts every bit of array.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#cv-bitwise-not

    C++ signature :
        void bitwise_not(cv::MatND,cv::MatND {lvalue})

bitwise_not( (Mat)a, (Mat)c) -> None :
    
    Inverts every bit of array.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#cv-bitwise-not

    C++ signature :
        void bitwise_not(cv::Mat,cv::Mat {lvalue})

bitwise_or(...)


bitwise_or( (MatND)a, (Scalar)s, (MatND)c [, (MatND)mask=MatND(shape=(), nchannels=1, depth=0):
array(0, dtype=uint8)]) -> None :
    
    Calculates per-element bit-wise disjunction of two arrays and an 
    array and a scalar.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#cv-bitwise-or

    C++ signature :
        void bitwise_or(cv::MatND,cv::Scalar_<double>,cv::MatND {lvalue} [,cv::MatND=MatND(shape=(), nchannels=1, depth=0):
array(0, dtype=uint8)])

bitwise_or( (MatND)a, (MatND)b, (MatND)c [, (MatND)mask=MatND(shape=(), nchannels=1, depth=0):
array(0, dtype=uint8)]) -> None :
    
    Calculates per-element bit-wise disjunction of two arrays and an 
    array and a scalar.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#cv-bitwise-or

    C++ signature :
        void bitwise_or(cv::MatND,cv::MatND,cv::MatND {lvalue} [,cv::MatND=MatND(shape=(), nchannels=1, depth=0):
array(0, dtype=uint8)])

bitwise_or( (Mat)a, (Scalar)s, (Mat)c [, (Mat)mask=Mat()]) -> None :
    
    Calculates per-element bit-wise disjunction of two arrays and an 
    array and a scalar.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#cv-bitwise-or

    C++ signature :
        void bitwise_or(cv::Mat,cv::Scalar_<double>,cv::Mat {lvalue} [,cv::Mat=Mat()])

bitwise_or( (Mat)a, (Mat)b, (Mat)c [, (Mat)mask=Mat()]) -> None :
    
    Calculates per-element bit-wise disjunction of two arrays and an 
    array and a scalar.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#cv-bitwise-or

    C++ signature :
        void bitwise_or(cv::Mat,cv::Mat,cv::Mat {lvalue} [,cv::Mat=Mat()])

bitwise_xor(...)


bitwise_xor( (MatND)a, (Scalar)s, (MatND)c [, (MatND)mask=MatND(shape=(), nchannels=1, depth=0):
array(0, dtype=uint8)]) -> None :
    
    Calculates per-element bit-wise 'exclusive or' operation on two 
    arrays and an array and a scalar.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#cv-bitwise-xor

    C++ signature :
        void bitwise_xor(cv::MatND,cv::Scalar_<double>,cv::MatND {lvalue} [,cv::MatND=MatND(shape=(), nchannels=1, depth=0):
array(0, dtype=uint8)])

bitwise_xor( (MatND)a, (MatND)b, (MatND)c [, (MatND)mask=MatND(shape=(), nchannels=1, depth=0):
array(0, dtype=uint8)]) -> None :
    
    Calculates per-element bit-wise 'exclusive or' operation on two 
    arrays and an array and a scalar.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#cv-bitwise-xor

    C++ signature :
        void bitwise_xor(cv::MatND,cv::MatND,cv::MatND {lvalue} [,cv::MatND=MatND(shape=(), nchannels=1, depth=0):
array(0, dtype=uint8)])

bitwise_xor( (Mat)a, (Scalar)s, (Mat)c [, (Mat)mask=Mat()]) -> None :
    
    Calculates per-element bit-wise 'exclusive or' operation on two 
    arrays and an array and a scalar.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#cv-bitwise-xor

    C++ signature :
        void bitwise_xor(cv::Mat,cv::Scalar_<double>,cv::Mat {lvalue} [,cv::Mat=Mat()])

bitwise_xor( (Mat)a, (Mat)b, (Mat)c [, (Mat)mask=Mat()]) -> None :
    
    Calculates per-element bit-wise 'exclusive or' operation on two 
    arrays and an array and a scalar.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#cv-bitwise-xor

    C++ signature :
        void bitwise_xor(cv::Mat,cv::Mat,cv::Mat {lvalue} [,cv::Mat=Mat()])

blob(...)


blob( (object)x, (object)y, (object)w, (object)h) -> CvBlob :
    
    Wrapped function:
        cvBlob

    C++ signature :
        CvBlob blob(float,float,float,float)

blur(...)


blur( (Mat)src, (Mat)dst, (Size2i)ksize [, (Point2i)anchor=Point2i(x=-1, y=-1) [, (object)borderType=4]]) -> None :

    C++ signature :
        void blur(cv::Mat,cv::Mat {lvalue},cv::Size_<int> [,cv::Point_<int>=Point2i(x=-1, y=-1) [,int=4]])

borderInterpolate(...)


borderInterpolate( (object)p, (object)len, (object)borderType) -> int :

    C++ signature :
        int borderInterpolate(int,int,int)

boundingRect(...)


boundingRect( (Mat)points) -> Rect :

    C++ signature :
        cv::Rect_<int> boundingRect(cv::Mat)

boxFilter(...)


boxFilter( (Mat)src, (Mat)dst, (object)ddepth, (Size2i)ksize [, (Point2i)anchor=Point2i(x=-1, y=-1) [, (bool)normalize=True [, (object)borderType=4]]]) -> None :

    C++ signature :
        void boxFilter(cv::Mat,cv::Mat {lvalue},int,cv::Size_<int> [,cv::Point_<int>=Point2i(x=-1, y=-1) [,bool=True [,int=4]]])

boxPoints(...)


boxPoints( (object)box, (object)pt) -> None :
    
    Wrapped function:
        cvBoxPoints

    C++ signature :
        void boxPoints(CvBox2D,CvPoint2D32f*)

buildPyramid(...)


buildPyramid( (Mat)src, (list)dst, (object)maxlevel) -> None :
    
    Argument 'dst':
        C/C++ type: ::std::vector< cv::Mat > &.
        Python type: list.
        To convert a Mat into a list, invoke one of Mat's member functions 
        to_list_of_...().

    C++ signature :
        void buildPyramid(cv::Mat,boost::python::list {lvalue},int)

calcAffineFlowPyrLK(...)


calcAffineFlowPyrLK( (Mat)prev, (Mat)curr, (Mat)prev_pyr, (Mat)curr_pyr, (Mat)prev_features, (CvSize)win_size, (object)level, (object)criteria, (object)flags) -> tuple :
    
    Wrapped function:
        cvCalcAffineFlowPyrLK
    Argument 'count':
        Dependent argument: omitted from the function's calling sequence, as 
        its value is derived from argument 'prev_features'.
    Argument 'status':
        Output argument: omitted from the function's calling sequence, and is 
        returned along with the function's return value (if any).
    Argument 'prev':
        C/C++ type: ::CvArr const *.
        Python type: Mat.
    Argument 'curr':
        C/C++ type: ::CvArr const *.
        Python type: Mat.
    Argument 'track_error':
        Output argument: omitted from the function's calling sequence, and is 
        returned along with the function's return value (if any).
    Argument 'prev_pyr':
        C/C++ type: ::CvArr *.
        Python type: Mat.
    Argument 'curr_pyr':
        C/C++ type: ::CvArr *.
        Python type: Mat.
    Argument 'prev_features':
        C/C++ type: ::CvPoint2D32f const *.
        Python type: Mat.
        Invoke asMat() to convert a 1D Python sequence into a Mat, e.g. 
        asMat([0,1,2]) or asMat((0,1,2)).
    Argument 'curr_features':
        Output argument: omitted from the function's calling sequence, and is 
        returned along with the function's return value (if any).
    Argument 'matrices':
        Output argument: omitted from the function's calling sequence, and is 
        returned along with the function's return value (if any).

    C++ signature :
        boost::python::tuple calcAffineFlowPyrLK(cv::Mat {lvalue},cv::Mat {lvalue},cv::Mat {lvalue},cv::Mat {lvalue},cv::Mat,CvSize,int,CvTermCriteria,int)

calcBackProject(...)


calcBackProject( (object)images, (Mat)channels, (SparseMat)hist, (Mat)backProject, (object)ranges [, (object)scale=1 [, (bool)uniform=True]]) -> None :
    
    Argument 'images':
        C/C++ type: ::cv::Mat const *.
        Python type: list of MatND, e.g. [MatND(), MatND(), MatND()].
    Argument 'channels':
        C/C++ type: int const *.
        Python type: Mat.
        Invoke asMat() to convert a 1D Python sequence into a Mat, e.g. 
        asMat([0,1,2]) or asMat((0,1,2)).
    Argument 'nimages':
        Dependent argument: omitted from the function's calling sequence, as 
        its value is derived from argument 'images'.
    Argument 'ranges':
        C/C++ type: float const * *.
        Python type: 2d list.
        Depending on its C++ argument type, it should be a list of Mats or a 
        list of lists.

    C++ signature :
        void calcBackProject(boost::python::sequence,cv::Mat,cv::SparseMat,cv::Mat {lvalue},boost::python::api::object [,double=1 [,bool=True]])

calcBackProject( (object)images, (Mat)channels, (MatND)hist, (Mat)backProject, (object)ranges [, (object)scale=1 [, (bool)uniform=True]]) -> None :
    
    Argument 'images':
        C/C++ type: ::cv::Mat const *.
        Python type: list of MatND, e.g. [MatND(), MatND(), MatND()].
    Argument 'channels':
        C/C++ type: int const *.
        Python type: Mat.
        Invoke asMat() to convert a 1D Python sequence into a Mat, e.g. 
        asMat([0,1,2]) or asMat((0,1,2)).
    Argument 'nimages':
        Dependent argument: omitted from the function's calling sequence, as 
        its value is derived from argument 'images'.
    Argument 'ranges':
        C/C++ type: float const * *.
        Python type: 2d list.
        Depending on its C++ argument type, it should be a list of Mats or a 
        list of lists.

    C++ signature :
        void calcBackProject(boost::python::sequence,cv::Mat,cv::MatND,cv::Mat {lvalue},boost::python::api::object [,double=1 [,bool=True]])

calcCovarMatrix(...)


calcCovarMatrix( (list)samples, (Mat)covar, (Mat)mean, (object)flags [, (object)ctype=6]) -> None :
    
    Calculates covariation matrix of a set of vectors.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#calccovarmatrix
    Argument 'nsamples':
        Dependent argument: omitted from the function's calling sequence, as 
        its value is derived from argument 'samples'.
    Argument 'samples':
        C/C++ type: ::cv::Mat const *.
        Python type: list of Mat, e.g. [Mat(), Mat(), Mat()].

    C++ signature :
        void calcCovarMatrix(boost::python::list,cv::Mat {lvalue},cv::Mat {lvalue},int [,int=6])

calcCovarMatrix( (Mat)samples, (Mat)covar, (Mat)mean, (object)flags [, (object)ctype=6]) -> None :
    
    Calculates covariation matrix of a set of vectors.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#calccovarmatrix

    C++ signature :
        void calcCovarMatrix(cv::Mat,cv::Mat {lvalue},cv::Mat {lvalue},int [,int=6])

calcEMD2(...)



calcEMD2( (Mat)signature1, (Mat)signature2, (object)distance_type [, (object)distance_func=None [, (Mat)cost_matrix=Mat() [, (Mat)flow=Mat() [, (object)lower_bound=None [, (object)userdata=None]]]]]) -> object :
    
    Wrapped function:
        cvCalcEMD2
    Argument 'signature1':
        C/C++ type: ::CvArr const *.
        Python type: Mat.
    Argument 'signature2':
        C/C++ type: ::CvArr const *.
        Python type: Mat.
    Argument 'flow':
        C/C++ type: ::CvArr *.
        Python type: Mat.
    Argument 'cost_matrix':
        C/C++ type: ::CvArr const *.
        Python type: Mat.

    C++ signature :
        boost::python::api::object calcEMD2(cv::Mat {lvalue},cv::Mat {lvalue},int [,boost::python::api::object=None [,cv::Mat=Mat() [,cv::Mat=Mat() [,float*=None [,boost::python::api::object=None]]]]])
    'distance_func' is a Python function declared as follows:
        def distance_func((int)a, (int)b, (object)userdata) -> (float)x
    where
        'a' : the address of a C array of C floats representing the first vector
        'b' : the address of a C array of C floats representing the second vector
        'userdata' : the 'userdata' parameter of cvCalcEMD2()
        'x' : the resultant distance

calcGlobalOrientation(...)


calcGlobalOrientation( (Mat)orientation, (Mat)mask, (Mat)mhi, (object)timestamp, (object)duration) -> object :
    
    Wrapped function:
        cvCalcGlobalOrientation
    Argument 'mask':
        C/C++ type: ::CvArr const *.
        Python type: Mat.
    Argument 'orientation':
        C/C++ type: ::CvArr const *.
        Python type: Mat.
    Argument 'mhi':
        C/C++ type: ::CvArr const *.
        Python type: Mat.

    C++ signature :
        boost::python::api::object calcGlobalOrientation(cv::Mat {lvalue},cv::Mat {lvalue},cv::Mat {lvalue},double,double)

calcGlobalOrientation( (Mat)orientation, (Mat)mask, (Mat)mhi, (object)timestamp, (object)duration) -> float :

    C++ signature :
        double calcGlobalOrientation(cv::Mat,cv::Mat,cv::Mat,double,double)

calcHist(...)


calcHist( (object)images, (Mat)channels, (Mat)mask, (SparseMat)hist, (Mat)histSize, (object)ranges [, (bool)uniform=True [, (bool)accumulate=False]]) -> None :
    
    Argument 'ranges':
        C/C++ type: float const * *.
        Python type: 2d list.
        Depending on its C++ argument type, it should be a list of Mats or a 
        list of lists.
    Argument 'histSize':
        C/C++ type: int const *.
        Python type: Mat.
        Invoke asMat() to convert a 1D Python sequence into a Mat, e.g. 
        asMat([0,1,2]) or asMat((0,1,2)).
    Argument 'channels':
        C/C++ type: int const *.
        Python type: Mat.
        Invoke asMat() to convert a 1D Python sequence into a Mat, e.g. 
        asMat([0,1,2]) or asMat((0,1,2)).
    Argument 'dims':
        Dependent argument: omitted from the function's calling sequence, as 
        its value is derived from argument 'histSize'.
    Argument 'images':
        C/C++ type: ::cv::Mat const *.
        Python type: list of MatND, e.g. [MatND(), MatND(), MatND()].
    Argument 'nimages':
        Dependent argument: omitted from the function's calling sequence, as 
        its value is derived from argument 'images'.

    C++ signature :
        void calcHist(boost::python::sequence,cv::Mat,cv::Mat,cv::SparseMat {lvalue},cv::Mat,boost::python::api::object [,bool=True [,bool=False]])

calcHist( (object)images, (Mat)channels, (Mat)mask, (MatND)hist, (Mat)histSize, (object)ranges [, (bool)uniform=True [, (bool)accumulate=False]]) -> None :
    
    Argument 'ranges':
        C/C++ type: float const * *.
        Python type: 2d list.
        Depending on its C++ argument type, it should be a list of Mats or a 
        list of lists.
    Argument 'histSize':
        C/C++ type: int const *.
        Python type: Mat.
        Invoke asMat() to convert a 1D Python sequence into a Mat, e.g. 
        asMat([0,1,2]) or asMat((0,1,2)).
    Argument 'channels':
        C/C++ type: int const *.
        Python type: Mat.
        Invoke asMat() to convert a 1D Python sequence into a Mat, e.g. 
        asMat([0,1,2]) or asMat((0,1,2)).
    Argument 'dims':
        Dependent argument: omitted from the function's calling sequence, as 
        its value is derived from argument 'histSize'.
    Argument 'images':
        C/C++ type: ::cv::Mat const *.
        Python type: list of MatND, e.g. [MatND(), MatND(), MatND()].
    Argument 'nimages':
        Dependent argument: omitted from the function's calling sequence, as 
        its value is derived from argument 'images'.

    C++ signature :
        void calcHist(boost::python::sequence,cv::Mat,cv::Mat,cv::MatND {lvalue},cv::Mat,boost::python::api::object [,bool=True [,bool=False]])

calcImageHomography(...)


calcImageHomography( (object)line, (object)center, (object)intrinsic) -> object :
    
    Wrapped function:
        cvCalcImageHomography

    C++ signature :
        boost::python::api::object calcImageHomography(boost::python::api::object,CvPoint3D32f*,boost::python::api::object)

calcMotionGradient(...)


calcMotionGradient( (Mat)mhi, (Mat)mask, (Mat)orientation, (object)delta1, (object)delta2 [, (object)aperture_size=3]) -> None :
    
    Wrapped function:
        cvCalcMotionGradient
    Argument 'mask':
        C/C++ type: ::CvArr *.
        Python type: Mat.
    Argument 'orientation':
        C/C++ type: ::CvArr *.
        Python type: Mat.
    Argument 'mhi':
        C/C++ type: ::CvArr const *.
        Python type: Mat.

    C++ signature :
        void calcMotionGradient(cv::Mat {lvalue},cv::Mat {lvalue},cv::Mat {lvalue},double,double [,int=3])

calcMotionGradient( (Mat)mhi, (Mat)mask, (Mat)orientation, (object)delta1, (object)delta2 [, (object)apertureSize=3]) -> None :

    C++ signature :
        void calcMotionGradient(cv::Mat,cv::Mat {lvalue},cv::Mat {lvalue},double,double [,int=3])

calcOpticalFlowBM(...)


calcOpticalFlowBM( (Mat)prev, (Mat)curr, (CvSize)block_size, (CvSize)shift_size, (CvSize)max_range, (object)use_previous, (Mat)velx, (Mat)vely) -> None :
    
    Wrapped function:
        cvCalcOpticalFlowBM
    Argument 'prev':
        C/C++ type: ::CvArr const *.
        Python type: Mat.
    Argument 'curr':
        C/C++ type: ::CvArr const *.
        Python type: Mat.
    Argument 'vely':
        C/C++ type: ::CvArr *.
        Python type: Mat.
    Argument 'velx':
        C/C++ type: ::CvArr *.
        Python type: Mat.

    C++ signature :
        void calcOpticalFlowBM(cv::Mat {lvalue},cv::Mat {lvalue},CvSize,CvSize,CvSize,int,cv::Mat {lvalue},cv::Mat {lvalue})

calcOpticalFlowFarneback(...)


calcOpticalFlowFarneback( (Mat)prev, (Mat)next, (Mat)flow, (object)pyr_scale, (object)levels, (object)winsize, (object)iterations, (object)poly_n, (object)poly_sigma, (object)flags) -> None :
    
    Wrapped function:
        cvCalcOpticalFlowFarneback
    Argument 'prev':
        C/C++ type: ::CvArr const *.
        Python type: Mat.
    Argument 'flow':
        C/C++ type: ::CvArr *.
        Python type: Mat.
    Argument 'next':
        C/C++ type: ::CvArr const *.
        Python type: Mat.

    C++ signature :
        void calcOpticalFlowFarneback(cv::Mat {lvalue},cv::Mat {lvalue},cv::Mat {lvalue},double,int,int,int,int,double,int)

calcOpticalFlowFarneback( (Mat)prev0, (Mat)next0, (Mat)flow0, (object)pyr_scale, (object)levels, (object)winsize, (object)iterations, (object)poly_n, (object)poly_sigma, (object)flags) -> None :

    C++ signature :
        void calcOpticalFlowFarneback(cv::Mat,cv::Mat,cv::Mat {lvalue},double,int,int,int,int,double,int)

calcOpticalFlowHS(...)


calcOpticalFlowHS( (Mat)prev, (Mat)curr, (object)use_previous, (Mat)velx, (Mat)vely, (object)lambda, (object)criteria) -> None :
    
    Wrapped function:
        cvCalcOpticalFlowHS
    Argument 'prev':
        C/C++ type: ::CvArr const *.
        Python type: Mat.
    Argument 'curr':
        C/C++ type: ::CvArr const *.
        Python type: Mat.
    Argument 'vely':
        C/C++ type: ::CvArr *.
        Python type: Mat.
    Argument 'velx':
        C/C++ type: ::CvArr *.
        Python type: Mat.

    C++ signature :
        void calcOpticalFlowHS(cv::Mat {lvalue},cv::Mat {lvalue},int,cv::Mat {lvalue},cv::Mat {lvalue},double,CvTermCriteria)

calcOpticalFlowLK(...)


calcOpticalFlowLK( (Mat)prev, (Mat)curr, (CvSize)win_size, (Mat)velx, (Mat)vely) -> None :
    
    Wrapped function:
        cvCalcOpticalFlowLK
    Argument 'prev':
        C/C++ type: ::CvArr const *.
        Python type: Mat.
    Argument 'curr':
        C/C++ type: ::CvArr const *.
        Python type: Mat.
    Argument 'vely':
        C/C++ type: ::CvArr *.
        Python type: Mat.
    Argument 'velx':
        C/C++ type: ::CvArr *.
        Python type: Mat.

    C++ signature :
        void calcOpticalFlowLK(cv::Mat {lvalue},cv::Mat {lvalue},CvSize,cv::Mat {lvalue},cv::Mat {lvalue})

calcOpticalFlowPyrLK(...)


calcOpticalFlowPyrLK( (Mat)prevImg, (Mat)nextImg, (Mat)prevPts, (Mat)nextPts, (Mat)status, (Mat)err [, (Size2i)winSize=Size2i(width=15, height=15) [, (object)maxLevel=3 [, (TermCriteria)criteria=TermCriteria(type=3, maxCount=30, epsilon=0.01) [, (object)derivLambda=0.5 [, (object)flags=0]]]]]) -> None :
    
    Argument 'status':
        C/C++ type: ::std::vector< unsigned char > &.
        Python type: Mat.
        Invoke asMat() to convert a 1D Python sequence into a Mat, e.g. 
        asMat([0,1,2]) or asMat((0,1,2)).
    Argument 'nextPts':
        C/C++ type: ::std::vector< cv::Point_<float> > &.
        Python type: Mat.
        Invoke asMat() to convert a 1D Python sequence into a Mat, e.g. 
        asMat([0,1,2]) or asMat((0,1,2)).
    Argument 'prevPts':
        C/C++ type: ::std::vector< cv::Point_<float> > const &.
        Python type: Mat.
        Invoke asMat() to convert a 1D Python sequence into a Mat, e.g. 
        asMat([0,1,2]) or asMat((0,1,2)).
    Argument 'err':
        C/C++ type: ::std::vector< float > &.
        Python type: Mat.
        Invoke asMat() to convert a 1D Python sequence into a Mat, e.g. 
        asMat([0,1,2]) or asMat((0,1,2)).

    C++ signature :
        void calcOpticalFlowPyrLK(cv::Mat,cv::Mat,cv::Mat,cv::Mat {lvalue},cv::Mat {lvalue},cv::Mat {lvalue} [,cv::Size_<int>=Size2i(width=15, height=15) [,int=3 [,cv::TermCriteria=TermCriteria(type=3, maxCount=30, epsilon=0.01) [,double=0.5 [,int=0]]]]])

calcOpticalFlowPyrLK( (Mat)prev, (Mat)curr, (Mat)prev_pyr, (Mat)curr_pyr, (Mat)prev_features, (CvSize)win_size, (object)level, (object)criteria, (object)flags) -> tuple :
    
    Wrapped function:
        cvCalcOpticalFlowPyrLK
    Argument 'count':
        Dependent argument: omitted from the function's calling sequence, as 
        its value is derived from argument 'prev_features'.
    Argument 'status':
        Output argument: omitted from the function's calling sequence, and is 
        returned along with the function's return value (if any).
    Argument 'prev':
        C/C++ type: ::CvArr const *.
        Python type: Mat.
    Argument 'curr':
        C/C++ type: ::CvArr const *.
        Python type: Mat.
    Argument 'track_error':
        Output argument: omitted from the function's calling sequence, and is 
        returned along with the function's return value (if any).
    Argument 'prev_pyr':
        C/C++ type: ::CvArr *.
        Python type: Mat.
    Argument 'prev_features':
        C/C++ type: ::CvPoint2D32f const *.
        Python type: Mat.
        Invoke asMat() to convert a 1D Python sequence into a Mat, e.g. 
        asMat([0,1,2]) or asMat((0,1,2)).
    Argument 'curr_features':
        Output argument: omitted from the function's calling sequence, and is 
        returned along with the function's return value (if any).
    Argument 'curr_pyr':
        C/C++ type: ::CvArr *.
        Python type: Mat.

    C++ signature :
        boost::python::tuple calcOpticalFlowPyrLK(cv::Mat {lvalue},cv::Mat {lvalue},cv::Mat {lvalue},cv::Mat {lvalue},cv::Mat,CvSize,int,CvTermCriteria,int)

calcSubdivVoronoi2D(...)


calcSubdivVoronoi2D( (CvSubdiv2D)subdiv) -> None :
    
    Wrapped function:
        cvCalcSubdivVoronoi2D

    C++ signature :
        void calcSubdivVoronoi2D(CvSubdiv2D*)

calibrateCamera(...)


calibrateCamera( (list)objectPoints, (list)imagePoints, (Size2i)imageSize, (Mat)cameraMatrix, (Mat)distCoeffs [, (object)flags=0]) -> tuple :
    
    Argument 'tvecs':
        C/C++ type: ::std::vector< cv::Mat > &.
        Python type: list.
        To convert a Mat into a list, invoke one of Mat's member functions 
        to_list_of_...().
        Output argument: omitted from the function's calling sequence, and is 
        returned along with the function's return value (if any).
    Argument 'objectPoints':
        C/C++ type: ::std::vector< std::vector< cv::Point3_<float> > > const 
        &.
        Python type: list of Mat, e.g. [Mat(), Mat(), Mat()].
        Invoke asMat() to convert every 1D Python sequence into a Mat, e.g. 
        [asMat([0,1,2]), asMat((0,1,2)].
    Argument 'rvecs':
        C/C++ type: ::std::vector< cv::Mat > &.
        Python type: list.
        To convert a Mat into a list, invoke one of Mat's member functions 
        to_list_of_...().
        Output argument: omitted from the function's calling sequence, and is 
        returned along with the function's return value (if any).
    Argument 'imagePoints':
        C/C++ type: ::std::vector< std::vector< cv::Point_<float> > > const &.
        Python type: list of Mat, e.g. [Mat(), Mat(), Mat()].
        Invoke asMat() to convert every 1D Python sequence into a Mat, e.g. 
        [asMat([0,1,2]), asMat((0,1,2)].

    C++ signature :
        boost::python::tuple calibrateCamera(boost::python::list,boost::python::list,cv::Size_<int>,cv::Mat {lvalue},cv::Mat {lvalue} [,int=0])

calibrationMatrixValues(...)


calibrationMatrixValues( (Mat)cameraMatrix, (Size2i)imageSize, (object)apertureWidth, (object)apertureHeight, (object)fovx, (object)fovy, (object)focalLength, (Point2d)principalPoint, (object)aspectRatio) -> None :

    C++ signature :
        void calibrationMatrixValues(cv::Mat,cv::Size_<int>,double,double,double {lvalue},double {lvalue},double {lvalue},cv::Point_<double> {lvalue},double {lvalue})

cartToPolar(...)


cartToPolar( (Mat)x, (Mat)y, (Mat)magnitude, (Mat)angle [, (bool)angleInDegrees=False]) -> None :
    
    Calculates the magnitude and angle of 2d vectors.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#carttopolar

    C++ signature :
        void cartToPolar(cv::Mat,cv::Mat,cv::Mat {lvalue},cv::Mat {lvalue} [,bool=False])

ceil(...)


ceil( (object)value) -> int :
    
    Wrapped function:
        cvCeil

    C++ signature :
        int ceil(double)

checkChessboard(...)


checkChessboard( (Mat)src, (CvSize)size) -> object :
    
    Wrapped function:
        cvCheckChessboard
    Argument 'src':
        C/C++ type: ::IplImage *.
        Python type: Mat.

    C++ signature :
        boost::python::api::object checkChessboard(cv::Mat {lvalue},CvSize)

checkHardwareSupport(...)


checkHardwareSupport( (object)feature) -> bool :

    C++ signature :
        bool checkHardwareSupport(int)

checkRange(...)


checkRange( (MatND)a [, (bool)quiet=True [, (object)minVal=-1.7976931348623157e+308 [, (object)maxVal=1.7976931348623157e+308]]]) -> tuple :
    
    Checks every element of an input array for invalid values.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#checkrange
    Argument 'idx':
        C/C++ type: int *.
        Python type: Python equivalence of the C/C++ type without pointer.
        Output argument: omitted from the function's calling sequence, and is 
        returned along with the function's return value (if any).

    C++ signature :
        boost::python::tuple checkRange(cv::MatND [,bool=True [,double=-1.7976931348623157e+308 [,double=1.7976931348623157e+308]]])

checkRange( (Mat)a [, (bool)quiet=True [, (object)minVal=-1.7976931348623157e+308 [, (object)maxVal=1.7976931348623157e+308]]]) -> tuple :
    
    Checks every element of an input array for invalid values.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#checkrange
    Argument 'pt':
        C/C++ type: ::cv::Point *.
        Python type: Python equivalence of the C/C++ type without pointer.
        Output argument: omitted from the function's calling sequence, and is 
        returned along with the function's return value (if any).

    C++ signature :
        boost::python::tuple checkRange(cv::Mat [,bool=True [,double=-1.7976931348623157e+308 [,double=1.7976931348623157e+308]]])

circle(...)


circle( (Mat)img, (Point2i)center, (object)radius, (Scalar)color [, (object)thickness=1 [, (object)lineType=8 [, (object)shift=0]]]) -> None :

    C++ signature :
        void circle(cv::Mat {lvalue},cv::Point_<int>,int,cv::Scalar_<double> [,int=1 [,int=8 [,int=0]]])

clearMemStorage(...)


clearMemStorage( (CvMemStorage)storage) -> None :
    
    Wrapped function:
        cvClearMemStorage

    C++ signature :
        void clearMemStorage(CvMemStorage*)

clearSeq(...)


clearSeq( (CvSeq)seq) -> None :
    
    Wrapped function:
        cvClearSeq

    C++ signature :
        void clearSeq(CvSeq*)

clearSet(...)


clearSet( (CvSet)set_header) -> None :
    
    Wrapped function:
        cvClearSet

    C++ signature :
        void clearSet(CvSet*)

clearSubdivVoronoi2D(...)


clearSubdivVoronoi2D( (CvSubdiv2D)subdiv) -> None :
    
    Wrapped function:
        cvClearSubdivVoronoi2D

    C++ signature :
        void clearSubdivVoronoi2D(CvSubdiv2D*)

clipLine(...)


clipLine( (Rect)img_rect, (Point2i)pt1, (Point2i)pt2) -> bool :

    C++ signature :
        bool clipLine(cv::Rect_<int>,cv::Point_<int> {lvalue},cv::Point_<int> {lvalue})

clipLine( (Size2i)imgSize, (Point2i)pt1, (Point2i)pt2) -> bool :

    C++ signature :
        bool clipLine(cv::Size_<int>,cv::Point_<int> {lvalue},cv::Point_<int> {lvalue})

cloneSeq(...)


cloneSeq( (CvSeq)seq [, (CvMemStorage)storage=None]) -> CvSeq :
    
    Wrapped function:
        cvCloneSeq

    C++ signature :
        CvSeq* cloneSeq(CvSeq const* [,CvMemStorage*=None])

compare(...)


compare( (MatND)a, (object)s, (MatND)c, (object)cmpop) -> None :
    
    Performs per-element comparison of two arrays or an array and scalar 
    value.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#compare

    C++ signature :
        void compare(cv::MatND,double,cv::MatND {lvalue},int)

compare( (MatND)a, (MatND)b, (MatND)c, (object)cmpop) -> None :
    
    Performs per-element comparison of two arrays or an array and scalar 
    value.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#compare

    C++ signature :
        void compare(cv::MatND,cv::MatND,cv::MatND {lvalue},int)

compare( (Mat)a, (object)s, (Mat)c, (object)cmpop) -> None :
    
    Performs per-element comparison of two arrays or an array and scalar 
    value.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#compare

    C++ signature :
        void compare(cv::Mat,double,cv::Mat {lvalue},int)

compare( (Mat)a, (Mat)b, (Mat)c, (object)cmpop) -> None :
    
    Performs per-element comparison of two arrays or an array and scalar 
    value.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#compare

    C++ signature :
        void compare(cv::Mat,cv::Mat,cv::Mat {lvalue},int)

compareHist(...)


compareHist( (SparseMat)H1, (SparseMat)H2, (object)method) -> float :

    C++ signature :
        double compareHist(cv::SparseMat,cv::SparseMat,int)

compareHist( (MatND)H1, (MatND)H2, (object)method) -> float :

    C++ signature :
        double compareHist(cv::MatND,cv::MatND,int)

completeSymm(...)


completeSymm( (Mat)a [, (bool)lowerToUpper=False]) -> None :
    
    Copies the lower or the upper half of a square matrix to another half.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#completesymm

    C++ signature :
        void completeSymm(cv::Mat {lvalue} [,bool=False])

composeRT(...)


composeRT( (Mat)rvec1, (Mat)tvec1, (Mat)rvec2, (Mat)tvec2, (Mat)rvec3, (Mat)tvec3, (Mat)dr3dr1, (Mat)dr3dt1, (Mat)dr3dr2, (Mat)dr3dt2, (Mat)dt3dr1, (Mat)dt3dt1, (Mat)dt3dr2, (Mat)dt3dt2) -> None :

    C++ signature :
        void composeRT(cv::Mat,cv::Mat,cv::Mat,cv::Mat,cv::Mat {lvalue},cv::Mat {lvalue},cv::Mat {lvalue},cv::Mat {lvalue},cv::Mat {lvalue},cv::Mat {lvalue},cv::Mat {lvalue},cv::Mat {lvalue},cv::Mat {lvalue},cv::Mat {lvalue})

composeRT( (Mat)rvec1, (Mat)tvec1, (Mat)rvec2, (Mat)tvec2, (Mat)rvec3, (Mat)tvec3) -> None :

    C++ signature :
        void composeRT(cv::Mat,cv::Mat,cv::Mat,cv::Mat,cv::Mat {lvalue},cv::Mat {lvalue})

computeCorrespondEpilines(...)


computeCorrespondEpilines( (Mat)points1, (object)whichImage, (Mat)F) -> object :
    
    Argument 'lines':
        C/C++ type: ::std::vector< cv::Vec<float, 3> > &.
        Python type: Mat.
        Invoke asMat() to convert a 1D Python sequence into a Mat, e.g. 
        asMat([0,1,2]) or asMat((0,1,2)).
        Output argument: omitted from the function's calling sequence, and is 
        returned along with the function's return value (if any).

    C++ signature :
        boost::python::api::object computeCorrespondEpilines(cv::Mat,int,cv::Mat)

conDensInitSampleSet(...)


conDensInitSampleSet( (CvConDensation)condens, (Mat)lower_bound, (Mat)upper_bound) -> None :
    
    Wrapped function:
        cvConDensInitSampleSet
    Argument 'lower_bound':
        C/C++ type: ::CvMat *.
        Python type: Mat.
    Argument 'upper_bound':
        C/C++ type: ::CvMat *.
        Python type: Mat.

    C++ signature :
        void conDensInitSampleSet(CvConDensation*,cv::Mat {lvalue},cv::Mat {lvalue})

conDensUpdateByTime(...)


conDensUpdateByTime( (CvConDensation)condens) -> None :
    
    Wrapped function:
        cvConDensUpdateByTime

    C++ signature :
        void conDensUpdateByTime(CvConDensation*)

contourArea(...)


contourArea( (Mat)contour [, (bool)oriented=False]) -> float :

    C++ signature :
        double contourArea(cv::Mat [,bool=False])

contourFromContourTree(...)


contourFromContourTree( (CvContourTree)tree, (CvMemStorage)storage, (object)criteria) -> CvSeq :
    
    Wrapped function:
        cvContourFromContourTree

    C++ signature :
        CvSeq* contourFromContourTree(CvContourTree const*,CvMemStorage*,CvTermCriteria)

convertImage(...)


convertImage( (Mat)src, (Mat)dst [, (object)flags=0]) -> None :
    
    Wrapped function:
        cvConvertImage
    Argument 'src':
        C/C++ type: ::CvArr const *.
        Python type: Mat.
    Argument 'dst':
        C/C++ type: ::CvArr *.
        Python type: Mat.

    C++ signature :
        void convertImage(cv::Mat {lvalue},cv::Mat {lvalue} [,int=0])

convertMaps(...)


convertMaps( (Mat)map1, (Mat)map2, (Mat)dstmap1, (Mat)dstmap2, (object)dstmap1type [, (bool)nninterpolation=False]) -> None :

    C++ signature :
        void convertMaps(cv::Mat,cv::Mat,cv::Mat {lvalue},cv::Mat {lvalue},int [,bool=False])

convertPointsHomogeneous2D(...)


convertPointsHomogeneous2D( (Mat)src) -> object :
    
    Wrapped function:
        convertPointsHomogeneous
    Argument 'dst':
        C/C++ type: ::std::vector< cv::Point_<float> > &.
        Python type: Mat.
        Invoke asMat() to convert a 1D Python sequence into a Mat, e.g. 
        asMat([0,1,2]) or asMat((0,1,2)).
        Output argument: omitted from the function's calling sequence, and is 
        returned along with the function's return value (if any).

    C++ signature :
        boost::python::api::object convertPointsHomogeneous2D(cv::Mat)

convertPointsHomogeneous3D(...)


convertPointsHomogeneous3D( (Mat)src) -> object :
    
    Wrapped function:
        convertPointsHomogeneous
    Argument 'dst':
        C/C++ type: ::std::vector< cv::Point3_<float> > &.
        Python type: Mat.
        Invoke asMat() to convert a 1D Python sequence into a Mat, e.g. 
        asMat([0,1,2]) or asMat((0,1,2)).
        Output argument: omitted from the function's calling sequence, and is 
        returned along with the function's return value (if any).

    C++ signature :
        boost::python::api::object convertPointsHomogeneous3D(cv::Mat)

convertScaleAbs(...)


convertScaleAbs( (Mat)a, (Mat)c [, (object)alpha=1 [, (object)beta=0]]) -> None :
    
    Scales, computes absolute values and converts the result to 8-bit.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#convertscaleabs

    C++ signature :
        void convertScaleAbs(cv::Mat,cv::Mat {lvalue} [,double=1 [,double=0]])

convexHull(...)


convexHull( (Mat)points [, (bool)clockwise=False]) -> Mat :

    C++ signature :
        cv::Mat convexHull(cv::Mat [,bool=False])

convexHullIdx(...)


convexHullIdx( (Mat)points [, (bool)clockwise=False]) -> object :
    
    Wrapped function:
        convexHull
    Argument 'hull':
        C/C++ type: ::std::vector< int > &.
        Python type: Mat.
        Invoke asMat() to convert a 1D Python sequence into a Mat, e.g. 
        asMat([0,1,2]) or asMat((0,1,2)).
        Output argument: omitted from the function's calling sequence, and is 
        returned along with the function's return value (if any).

    C++ signature :
        boost::python::api::object convexHullIdx(cv::Mat [,bool=False])

convexityDefects(...)


convexityDefects( (Mat)contour, (Mat)convexhull [, (CvMemStorage)storage=None]) -> object :
    
    Wrapped function:
        cvConvexityDefects
    Argument 'contour':
        C/C++ type: ::CvArr const *.
        Python type: Mat.
    Argument 'convexhull':
        C/C++ type: ::CvArr const *.
        Python type: Mat.

    C++ signature :
        boost::python::api::object convexityDefects(cv::Mat {lvalue},cv::Mat {lvalue} [,CvMemStorage*=None])

copyMakeBorder(...)


copyMakeBorder( (Mat)src, (Mat)dst, (object)top, (object)bottom, (object)left, (object)right, (object)borderType [, (Scalar)value=Scalar([ 0.  0.  0.  0.])]) -> None :

    C++ signature :
        void copyMakeBorder(cv::Mat,cv::Mat {lvalue},int,int,int,int,int [,cv::Scalar_<double>=Scalar([ 0.  0.  0.  0.])])

cornerEigenValsAndVecs(...)


cornerEigenValsAndVecs( (Mat)src, (Mat)dst, (object)blockSize, (object)ksize [, (object)borderType=4]) -> None :

    C++ signature :
        void cornerEigenValsAndVecs(cv::Mat,cv::Mat {lvalue},int,int [,int=4])

cornerHarris(...)


cornerHarris( (Mat)src, (Mat)dst, (object)blockSize, (object)ksize, (object)k [, (object)borderType=4]) -> None :

    C++ signature :
        void cornerHarris(cv::Mat,cv::Mat {lvalue},int,int,double [,int=4])

cornerMinEigenVal(...)


cornerMinEigenVal( (Mat)src, (Mat)dst, (object)blockSize [, (object)ksize=3 [, (object)borderType=4]]) -> None :

    C++ signature :
        void cornerMinEigenVal(cv::Mat,cv::Mat {lvalue},int [,int=3 [,int=4]])

cornerSubPix(...)


cornerSubPix( (Mat)image, (Mat)corners, (Size2i)winSize, (Size2i)zeroZone, (TermCriteria)criteria) -> None :
    
    Argument 'corners':
        C/C++ type: ::std::vector< cv::Point_<float> > &.
        Python type: Mat.
        Invoke asMat() to convert a 1D Python sequence into a Mat, e.g. 
        asMat([0,1,2]) or asMat((0,1,2)).

    C++ signature :
        void cornerSubPix(cv::Mat,cv::Mat {lvalue},cv::Size_<int>,cv::Size_<int>,cv::TermCriteria)

correctMatches(...)


correctMatches( (Mat)F, (Mat)points1, (Mat)points2, (Mat)new_points1, (Mat)new_points2) -> None :
    
    Wrapped function:
        cvCorrectMatches
    Argument 'points1':
        C/C++ type: ::CvMat *.
        Python type: Mat.
    Argument 'points2':
        C/C++ type: ::CvMat *.
        Python type: Mat.
    Argument 'new_points2':
        C/C++ type: ::CvMat *.
        Python type: Mat.
    Argument 'new_points1':
        C/C++ type: ::CvMat *.
        Python type: Mat.
    Argument 'F':
        C/C++ type: ::CvMat *.
        Python type: Mat.

    C++ signature :
        void correctMatches(cv::Mat {lvalue},cv::Mat {lvalue},cv::Mat {lvalue},cv::Mat {lvalue},cv::Mat {lvalue})

countNonZero(...)


countNonZero( (MatND)m) -> int :
    
    Counts non-zero array elements.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#countnonzero

    C++ signature :
        int countNonZero(cv::MatND)

countNonZero( (Mat)m) -> int :
    
    Counts non-zero array elements.
    Reference:
        http://opencv.willowgarage.com/documentation/cpp/operations_on_arrays.html#countnonzero

    C++ signature :
        int countNonZero(cv::Mat)

createBoxFilter(...)


createBoxFilter( (object)srcType, (object)dstType, (Size2i)ksize [, (Point2i)anchor=Point2i(x=-1, y=-1) [, (bool)normalize=True [, (object)borderType=4]]]) -> Ptr_FilterEngine :

    C++ signature :
        cv::Ptr<cv::FilterEngine> createBoxFilter(int,int,cv::Size_<int> [,cv::Point_<int>=Point2i(x=-1, y=-1) [,bool=True [,int=4]]])

createChildMemStorage(...)


createChildMemStorage( (CvMemStorage)parent) -> CvMemStorage :
    
    Wrapped function:
        cvCreateChildMemStorage

    C++ signature :
        CvMemStorage* createChildMemStorage(CvMemStorage*)

createConDensation(...)


createConDensation( (object)dynam_params, (object)measure_params, (object)sample_count) -> CvConDensation :
    
    Wrapped function:
        cvCreateConDensation

    C++ signature :
        CvConDensation* createConDensation(int,int,int)

createContourTree(...)


createContourTree( (CvSeq)contour, (CvMemStorage)storage, (object)threshold) -> CvContourTree :
    
    Wrapped function:
        cvCreateContourTree

    C++ signature :
        CvContourTree* createContourTree(CvSeq const*,CvMemStorage*,double)

createDerivFilter(...)


createDerivFilter( (object)srcType, (object)dstType, (object)dx, (object)dy, (object)ksize [, (object)borderType=4]) -> Ptr_FilterEngine :

    C++ signature :
        cv::Ptr<cv::FilterEngine> createDerivFilter(int,int,int,int,int [,int=4])

createGaussianFilter(...)


createGaussianFilter( (object)type, (Size2i)ksize, (object)sigma1 [, (object)sigma2=0 [, (object)borderType=4]]) -> Ptr_FilterEngine :

    C++ signature :
        cv::Ptr<cv::FilterEngine> createGaussianFilter(int,cv::Size_<int>,double [,double=0 [,int=4]])

createKDTree(...)


createKDTree( (Mat)desc) -> object :
    
    Wrapped function:
        cvCreateKDTree
    Argument 'desc':
        C/C++ type: ::CvMat *.
        Python type: Mat.

    C++ signature :
        boost::python::api::object createKDTree(cv::Mat {lvalue})

createLSH(...)


createLSH( (CvLSHOperations)ops, (object)d [, (object)L=10 [, (object)k=10 [, (object)type=6 [, (object)r=4 [, (long)seed=-1L]]]]]) -> CvLSH :
    
    Wrapped function:
        cvCreateLSH

    C++ signature :
        CvLSH* createLSH(CvLSHOperations*,int [,int=10 [,int=10 [,int=6 [,double=4 [,long long=-1L]]]]])

createLinearFilter(...)


createLinearFilter( (object)srcType, (object)dstType, (Mat)kernel [, (Point2i)_anchor=Point2i(x=-1, y=-1) [, (object)delta=0 [, (object)_rowBorderType=4 [, (object)_columnBorderType=-1 [, (Scalar)_borderValue=Scalar([ 0.  0.  0.  0.])]]]]]) -> Ptr_FilterEngine :

    C++ signature :
        cv::Ptr<cv::FilterEngine> createLinearFilter(int,int,cv::Mat [,cv::Point_<int>=Point2i(x=-1, y=-1) [,double=0 [,int=4 [,int=-1 [,cv::Scalar_<double>=Scalar([ 0.  0.  0.  0.])]]]]])

createMemStorage(...)


createMemStorage([  (object)block_size=0]) -> CvMemStorage :
    
    Wrapped function:
        cvCreateMemStorage

    C++ signature :
        CvMemStorage* createMemStorage([ int=0])

createMemoryLSH(...)


createMemoryLSH( (object)d, (object)n [, (object)L=10 [, (object)k=10 [, (object)type=6 [, (object)r=4 [, (long)seed=-1L]]]]]) -> CvLSH :
    
    Wrapped function:
        cvCreateMemoryLSH

    C++ signature :
        CvLSH* createMemoryLSH(int,int [,int=10 [,int=10 [,int=6 [,double=4 [,long long=-1L]]]]])

createMorphologyFilter(...)


createMorphologyFilter( (object)op, (object)type, (Mat)kernel [, (Point2i)anchor=Point2i(x=-1, y=-1) [, (object)_rowBorderType=0 [, (object)_columnBorderType=-1 [, (Scalar)_borderValue=Scalar([  1.79769313e+308   1.79769313e+308   1.79769313e+308   1.79769313e+308])]]]]) -> Ptr_FilterEngine :

    C++ signature :
        cv::Ptr<cv::FilterEngine> createMorphologyFilter(int,int,cv::Mat [,cv::Point_<int>=Point2i(x=-1, y=-1) [,int=0 [,int=-1 [,cv::Scalar_<double>=Scalar([  1.79769313e+308   1.79769313e+308   1.79769313e+308   1.79769313e+308])]]]])

createPOSITObject(...)


createPOSITObject( (object)points, (object)point_count) -> CvPOSITObject :
    
    Wrapped function:
        cvCreatePOSITObject

    C++ signature :
        CvPOSITObject* createPOSITObject(CvPoint3D32f*,int)

createSeparableLinearFilter(...)


createSeparableLinearFilter( (object)srcType, (object)dstType, (Mat)rowKernel, (Mat)columnKernel [, (Point2i)_anchor=Point2i(x=-1, y=-1) [, (object)delta=0 [, (object)_rowBorderType=4 [, (object)_columnBorderType=-1 [, (Scalar)_borderValue=Scalar([ 0.  0.  0.  0.])]]]]]) -> Ptr_FilterEngine :

    C++ signature :
        cv::Ptr<cv::FilterEngine> createSeparableLinearFilter(int,int,cv::Mat,cv::Mat [,cv::Point_<int>=Point2i(x=-1, y=-1) [,double=0 [,int=4 [,int=-1 [,cv::Scalar_<double>=Scalar([ 0.  0.  0.  0.])]]]]])

createSeq(...)


createSeq( (object)seq_flags, (object)header_size, (object)elem_size, (CvMemStorage)storage) -> CvSeq :
    
    Wrapped function:
        cvCreateSeq

    C++ signature :
        CvSeq* createSeq(int,int,int,CvMemStorage*)

createSeqBlock(...)


createSeqBlock( (CvSeqWriter)writer) -> None :
    
    Wrapped function:
        cvCreateSeqBlock

    C++ signature :
        void createSeqBlock(CvSeqWriter*)

createSet(...)


createSet( (object)set_flags, (object)header_size, (object)elem_size, (CvMemStorage)storage) -> CvSet :
    
    Wrapped function:
        cvCreateSet

    C++ signature :
        CvSet* createSet(int,int,int,CvMemStorage*)

createSpillTree(...)


createSpillTree( (Mat)raw_data [, (object)naive=50 [, (object)rho=0.69999999999999996 [, (object)tau=0.10000000000000001]]]) -> object :
    
    Wrapped function:
        cvCreateSpillTree
    Argument 'raw_data':
        C/C++ type: ::CvMat const *.
        Python type: Mat.

    C++ signature :
        boost::python::api::object createSpillTree(cv::Mat {lvalue} [,int=50 [,double=0.69999999999999996 [,double=0.10000000000000001]]])

createStereoGCState(...)


createStereoGCState( (object)numberOfDisparities, (object)maxIters) -> CvStereoGCState :
    
    Wrapped function:
        cvCreateStereoGCState

    C++ signature :
        CvStereoGCState* createStereoGCState(int,int)

createSubdiv2D(...)


createSubdiv2D( (object)subdiv_type, (object)header_size, (object)vtx_size, (object)quadedge_size, (CvMemStorage)storage) -> CvSubdiv2D :
    
    Wrapped function:
        cvCreateSubdiv2D

    C++ signature :
        CvSubdiv2D* createSubdiv2D(int,int,int,int,CvMemStorage*)

createSubdivDelaunay2D(...)


createSubdivDelaunay2D( (CvRect)rect, (CvMemStorage)storage) -> CvSubdiv2D :
    
    Wrapped function:
        cvCreateSubdivDelaunay2D

    C++ signature :
        CvSubdiv2D* createSubdivDelaunay2D(CvRect,CvMemStorage*)

cubeRoot(...)


cubeRoot( (object)val) -> float :

    C++ signature :
        float cubeRoot(float)

cvtColor(...)


cvtColor( (Mat)src, (Mat)dst, (object)code [, (object)dstCn=0]) -> None :

    C++ signature :
        void cvtColor(cv::Mat,cv::Mat {lvalue},int [,int=0])

dct(...)


dct( (Mat)src, (Mat)dst [, (object)flags=0]) -> None :

    C++ signature :
        void dct(cv::Mat,cv::Mat {lvalue} [,int=0])

decomposeProjectionMatrix(...)


decomposeProjectionMatrix( (Mat)projMatrix, (Mat)cameraMatrix, (Mat)rotMatrix, (Mat)transVect, (Mat)rotMatrixX, (Mat)rotMatrixY, (Mat)rotMatrixZ, (Vec3d)eulerAngles) -> None :

    C++ signature :
        void decomposeProjectionMatrix(cv::Mat,cv::Mat {lvalue},cv::Mat {lvalue},cv::Mat {lvalue},cv::Mat {lvalue},cv::Mat {lvalue},cv::Mat {lvalue},cv::Vec<double, 3> {lvalue})

decomposeProjectionMatrix( (Mat)projMatrix, (Mat)cameraMatrix, (Mat)rotMatrix, (Mat)transVect) -> None :

    C++ signature :
        void decomposeProjectionMatrix(cv::Mat,cv::Mat {lvalue},cv::Mat {lvalue},cv::Mat {lvalue})

detectedBlob(...)


detectedBlob( (object)x, (object)y, (object)w, (object)h [, (object)ID=0 [, (object)response=0.0]]) -> CvDetectedBlob :
    
    Wrapped function:
        cvDetectedBlob

    C++ signature :
        CvDetectedBlob detectedBlob(float,float,float,float [,int=0 [,float=0.0]])

determinant(...)


determinant( (Mat)m) -> float :

    C++ signature :
        double determinant(cv::Mat)

dft(...)


dft( (Mat)src, (Mat)dst [, (object)flags=0 [, (object)nonzeroRows=0]]) -> None :

    C++ signature :
        void dft(cv::Mat,cv::Mat {lvalue} [,int=0 [,int=0]])

dilate(...)


dilate( (Mat)src, (Mat)dst, (Mat)kernel [, (Point2i)anchor=Point2i(x=-1, y=-1) [, (object)iterations=1 [, (object)borderType=0 [, (Scalar)borderValue=Scalar([  1.79769313e+308   1.79769313e+308   1.79769313e+308   1.79769313e+308])]]]]) -> None :

    C++ signature :
        void dilate(cv::Mat,cv::Mat {lvalue},cv::Mat [,cv::Point_<int>=Point2i(x=-1, y=-1) [,int=1 [,int=0 [,cv::Scalar_<double>=Scalar([  1.79769313e+308   1.79769313e+308   1.79769313e+308   1.79769313e+308])]]]])

distTransform(...)


distTransform( (Mat)src, (Mat)dst [, (object)distance_type=2 [, (object)mask_size=3 [, (Mat)mask=Mat() [, (Mat)labels=Mat()]]]]) -> None :
    
    Wrapped function:
        cvDistTransform
    Argument 'src':
        C/C++ type: ::CvArr const *.
        Python type: Mat.
    Argument 'dst':
        C/C++ type: ::CvArr *.
        Python type: Mat.
    Argument 'labels':
        C/C++ type: ::CvArr *.
        Python type: Mat.
    Argument 'mask':
        C/C++ type: float const *.
        Python type: Mat.
        Invoke asMat() to convert a 1D Python sequence into a Mat, e.g. 
        asMat([0,1,2]) or asMat((0,1,2)).

    C++ signature :
        void distTransform(cv::Mat {lvalue},cv::Mat {lvalue} [,int=2 [,int=3 [,cv::Mat=Mat() [,cv::Mat=Mat()]]]])

distanceTransform(...)


distanceTransform( (Mat)src, (Mat)dst, (object)distanceType, (object)maskSize) -> None :

    C++ signature :
        void distanceTransform(cv::Mat,cv::Mat {lvalue},int,int)

distanceTransform( (Mat)src, (Mat)dst, (Mat)labels, (object)distanceType, (object)maskSize) -> None :

    C++ signature :
        void distanceTransform(cv::Mat,cv::Mat {lvalue},cv::Mat {lvalue},int,int)

divide(...)


divide( (object)scale, (MatND)b, (MatND)c) -> None :

    C++ signature :
        void divide(double,cv::MatND,cv::MatND {lvalue})

divide( (MatND)a, (MatND)b, (MatND)c [, (object)scale=1]) -> None :

    C++ signature :
        void divide(cv::MatND,cv::MatND,cv::MatND {lvalue} [,double=1])

divide( (object)scale, (Mat)b, (Mat)c) -> None :

    C++ signature :
        void divide(double,cv::Mat,cv::Mat {lvalue})

divide( (Mat)a, (Mat)b, (Mat)c [, (object)scale=1]) -> None :

    C++ signature :
        void divide(cv::Mat,cv::Mat,cv::Mat {lvalue} [,double=1])

drawChessboardCorners(...)


drawChessboardCorners( (Mat)image, (Size2i)patternSize, (Mat)corners, (bool)patternWasFound) -> None :

    C++ signature :
        void drawChessboardCorners(cv::Mat {lvalue},cv::Size_<int>,cv::Mat,bool)

drawContours(...)


drawContours( (Mat)image, (list)contours, (object)contourIdx, (Scalar)color [, (object)thickness=1 [, (object)lineType=8 [, (Mat)hierarchy=Mat() [, (object)maxLevel=2147483647 [, (Point2i)offset=Point2i(x=0, y=0)]]]]]) -> None :
    
    Argument 'hierarchy':
        C/C++ type: ::std::vector< cv::Vec<int, 4> > const &.
        Python type: Mat.
        Invoke asMat() to convert a 1D Python sequence into a Mat, e.g. 
        asMat([0,1,2]) or asMat((0,1,2)).
    Argument 'contours':
        C/C++ type: ::std::vector< std::vector< cv::Point_<int> > > const &.
        Python type: list of Mat, e.g. [Mat(), Mat(), Mat()].
        Invoke asMat() to convert every 1D Python sequence into a Mat, e.g. 
        [asMat([0,1,2]), asMat((0,1,2)].

    C++ signature :
        void drawContours(cv::Mat {lvalue},boost::python::list,int,cv::Scalar_<double> [,int=1 [,int=8 [,cv::Mat=Mat() [,int=2147483647 [,cv::Point_<int>=Point2i(x=0, y=0)]]]]])

eigen(...)


eigen( (Mat)a, (Mat)eigenvalues, (Mat)eigenvectors [, (object)lowindex=-1 [, (object)highindex=-1]]) -> bool :

    C++ signature :
        bool eigen(cv::Mat,cv::Mat {lvalue},cv::Mat {lvalue} [,int=-1 [,int=-1]])

eigen( (Mat)a, (Mat)eigenvalues [, (object)lowindex=-1 [, (object)highindex=-1]]) -> bool :

    C++ signature :
        bool eigen(cv::Mat,cv::Mat {lvalue} [,int=-1 [,int=-1]])

ellipse(...)


ellipse( (Mat)img, (RotatedRect)box, (Scalar)color [, (object)thickness=1 [, (object)lineType=8]]) -> None :

    C++ signature :
        void ellipse(cv::Mat {lvalue},cv::RotatedRect,cv::Scalar_<double> [,int=1 [,int=8]])

ellipse( (Mat)img, (Point2i)center, (Size2i)axes, (object)angle, (object)startAngle, (object)endAngle, (Scalar)color [, (object)thickness=1 [, (object)lineType=8 [, (object)shift=0]]]) -> None :

    C++ signature :
        void ellipse(cv::Mat {lvalue},cv::Point_<int>,cv::Size_<int>,double,double,double,cv::Scalar_<double> [,int=1 [,int=8 [,int=0]]])

ellipse2Poly(...)


ellipse2Poly( (Point2i)center, (Size2i)axes, (object)angle, (object)arcStart, (object)arcEnd, (object)delta, (Mat)pts) -> None :
    
    Argument 'pts':
        C/C++ type: ::std::vector< cv::Point_<int> > &.
        Python type: Mat.
        Invoke asMat() to convert a 1D Python sequence into a Mat, e.g. 
        asMat([0,1,2]) or asMat((0,1,2)).

    C++ signature :
        void ellipse2Poly(cv::Point_<int>,cv::Size_<int>,int,int,int,int,cv::Mat {lvalue})

endWriteSeq(...)


endWriteSeq( (CvSeqWriter)writer) -> CvSeq :
    
    Wrapped function:
        cvEndWriteSeq

    C++ signature :
        CvSeq* endWriteSeq(CvSeqWriter*)

endWriteStruct(...)


endWriteStruct( (FileStorage)fs) -> None :
    
    Wrapped function:
        cvEndWriteStruct
    Argument 'fs':
        C/C++ type: ::CvFileStorage *.
        Python type: FileStorage.

    C++ signature :
        void endWriteStruct(cv::FileStorage {lvalue})

equalizeHist(...)


equalizeHist( (Mat)src, (Mat)dst) -> None :

    C++ signature :
        void equalizeHist(cv::Mat,cv::Mat {lvalue})

erode(...)


erode( (Mat)src, (Mat)dst, (Mat)kernel [, (Point2i)anchor=Point2i(x=-1, y=-1) [, (object)iterations=1 [, (object)borderType=0 [, (Scalar)borderValue=Scalar([  1.79769313e+308   1.79769313e+308   1.79769313e+308   1.79769313e+308])]]]]) -> None :

    C++ signature :
        void erode(cv::Mat,cv::Mat {lvalue},cv::Mat [,cv::Point_<int>=Point2i(x=-1, y=-1) [,int=1 [,int=0 [,cv::Scalar_<double>=Scalar([  1.79769313e+308   1.79769313e+308   1.79769313e+308   1.79769313e+308])]]]])

error(...)


error( (object)status, (str)func_name, (str)err_msg, (str)file_name, (object)line) -> None :
    
    Wrapped function:
        cvError

    C++ signature :
        void error(int,char const*,char const*,char const*,int)

errorFromIppStatus(...)


errorFromIppStatus( (object)ipp_status) -> int :
    
    Wrapped function:
        cvErrorFromIppStatus

    C++ signature :
        int errorFromIppStatus(int)

errorStr(...)


errorStr( (object)status) -> str :
    
    Wrapped function:
        cvErrorStr

    C++ signature :
        char const* errorStr(int)

estimateAffine3D(...)


estimateAffine3D( (Mat)from, (Mat)to, (Mat)out, (Mat)outliers [, (object)param1=3.0 [, (object)param2=0.98999999999999999]]) -> object :
    
    Argument 'outliers':
        C/C++ type: ::std::vector< unsigned char > &.
        Python type: Mat.
        Invoke asMat() to convert a 1D Python sequence into a Mat, e.g. 
        asMat([0,1,2]) or asMat((0,1,2)).

    C++ signature :
        boost::python::api::object estimateAffine3D(cv::Mat,cv::Mat,cv::Mat {lvalue},cv::Mat {lvalue} [,double=3.0 [,double=0.98999999999999999]])

estimateRigidTransform(...)


estimateRigidTransform( (Mat)A, (Mat)B, (Mat)M, (object)full_affine) -> object :
    
    Wrapped function:
        cvEstimateRigidTransform
    Argument 'A':
        C/C++ type: ::CvArr const *.
        Python type: Mat.
    Argument 'B':
        C/C++ type: ::CvArr const *.
        Python type: Mat.
    Argument 'M':
        C/C++ type: ::CvMat *.
        Python type: Mat.

    C++ signature :
        boost::python::api::object estimateRigidTransform(cv::Mat {lvalue},cv::Mat {lvalue},cv::Mat {lvalue},int)

exp(...)


exp( (MatND)a, (MatND)b) -> None :

    C++ signature :
        void exp(cv::MatND,cv::MatND {lvalue})

exp( (Mat)a, (Mat)b) -> None :

    C++ signature :
        void exp(cv::Mat,cv::Mat {lvalue})

fastAtan2(...)


fastAtan2( (object)y, (object)x) -> float :

    C++ signature :
        float fastAtan2(float,float)

fillConvexPoly(...)


fillConvexPoly( (Mat)img, (Mat)pts, (Scalar)color [, (object)lineType=8 [, (object)shift=0]]) -> None :
    
    Argument 'npts':
        Dependent argument: omitted from the function's calling sequence, as 
        its value is derived from argument 'pts'.
    Argument 'pts':
        C/C++ type: ::cv::Point const *.
        Python type: Mat.
        Invoke asMat() to convert a 1D Python sequence into a Mat, e.g. 
        asMat([0,1,2]) or asMat((0,1,2)).

    C++ signature :
        void fillConvexPoly(cv::Mat {lvalue},cv::Mat,cv::Scalar_<double> [,int=8 [,int=0]])

fillPoly(...)


fillPoly( (Mat)img, (object)pts, (Scalar)color [, (object)lineType=8 [, (object)shift=0 [, (Point2i)offset=Point2i(x=0, y=0)]]]) -> None :
    
    Argument 'npts':
        Dependent argument: omitted from the function's calling sequence, as 
        its value is derived from argument 'pts'.
    Argument 'ncontours':
        Dependent argument: omitted from the function's calling sequence, as 
        its value is derived from argument 'pts'.
    Argument 'pts':
        C/C++ type: ::cv::Point const * *.
        Python type: 2d list.
        Depending on its C++ argument type, it should be a list of Mats or a 
        list of lists.

    C++ signature :
        void fillPoly(cv::Mat {lvalue},boost::python::api::object,cv::Scalar_<double> [,int=8 [,int=0 [,cv::Point_<int>=Point2i(x=0, y=0)]]])

filter2D(...)


filter2D( (Mat)src, (Mat)dst, (object)ddepth, (Mat)kernel [, (Point2i)anchor=Point2i(x=-1, y=-1) [, (object)delta=0 [, (object)borderType=4]]]) -> None :

    C++ signature :
        void filter2D(cv::Mat,cv::Mat {lvalue},int,cv::Mat [,cv::Point_<int>=Point2i(x=-1, y=-1) [,double=0 [,int=4]]])

filterSpeckles(...)


filterSpeckles( (Mat)img, (object)newVal, (object)maxSpeckleSize, (object)maxDiff, (Mat)buf) -> None :

    C++ signature :
        void filterSpeckles(cv::Mat {lvalue},double,int,double,cv::Mat {lvalue})

find4QuadCornerSubpix(...)


find4QuadCornerSubpix( (Mat)img, (Mat)corners, (Size2i)region_size) -> object :
    
    Argument 'corners':
        C/C++ type: ::std::vector< cv::Point_<float> > &.
        Python type: Mat.
        Invoke asMat() to convert a 1D Python sequence into a Mat, e.g. 
        asMat([0,1,2]) or asMat((0,1,2)).

    C++ signature :
        boost::python::api::object find4QuadCornerSubpix(cv::Mat,cv::Mat {lvalue},cv::Size_<int>)

findChessboardCorners(...)


findChessboardCorners( (Mat)image, (Size2i)patternSize [, (object)flags=3]) -> tuple :
    
    Argument 'corners':
        C/C++ type: ::std::vector< cv::Point_<float> > &.
        Python type: Mat.
        Invoke asMat() to convert a 1D Python sequence into a Mat, e.g. 
        asMat([0,1,2]) or asMat((0,1,2)).
        Output argument: omitted from the function's calling sequence, and is 
        returned along with the function's return value (if any).

    C++ signature :
        boost::python::tuple findChessboardCorners(cv::Mat,cv::Size_<int> [,int=3])

findContours(...)


findContours( (Mat)image, (object)mode, (object)method [, (Point2i)offset=Point2i(x=0, y=0)]) -> object :
    
    Argument 'contours':
        C/C++ type: ::std::vector< std::vector< cv::Point_<int> > > &.
        Python type: list of Mat, e.g. [Mat(), Mat(), Mat()].
        Invoke asMat() to convert every 1D Python sequence into a Mat, e.g. 
        [asMat([0,1,2]), asMat((0,1,2)].
        Output argument: omitted from the function's calling sequence, and is 
        returned along with the function's return value (if any).

    C++ signature :
        boost::python::api::object findContours(cv::Mat {lvalue},int,int [,cv::Point_<int>=Point2i(x=0, y=0)])

findContours( (Mat)image, (object)mode, (object)method [, (Point2i)offset=Point2i(x=0, y=0)]) -> tuple :
    
    Argument 'hierarchy':
        C/C++ type: ::std::vector< cv::Vec<int, 4> > &.
        Python type: Mat.
        Invoke asMat() to convert a 1D Python sequence into a Mat, e.g. 
        asMat([0,1,2]) or asMat((0,1,2)).
        Output argument: omitted from the function's calling sequence, and is 
        returned along with the function's return value (if any).
    Argument 'contours':
        C/C++ type: ::std::vector< std::vector< cv::Point_<int> > > &.
        Python type: list of Mat, e.g. [Mat(), Mat(), Mat()].
        Invoke asMat() to convert every 1D Python sequence into a Mat, e.g. 
        [asMat([0,1,2]), asMat((0,1,2)].
        Output argument: omitted from the function's calling sequence, and is 
        returned along with the function's return value (if any).

    C++ signature :
        boost::python::tuple findContours(cv::Mat {lvalue},int,int [,cv::Point_<int>=Point2i(x=0, y=0)])

findDominantPoints(...)


findDominantPoints( (CvSeq)contour, (CvMemStorage)storage [, (object)method=1 [, (object)parameter1=0 [, (object)parameter2=0 [, (object)parameter3=0 [, (object)parameter4=0]]]]]) -> CvSeq :
    
    Wrapped function:
        cvFindDominantPoints

    C++ signature :
        CvSeq* findDominantPoints(CvSeq*,CvMemStorage* [,int=1 [,double=0 [,double=0 [,double=0 [,double=0]]]]])

findFeatures(...)


findFeatures( (CvFeatureTree)tr, (Mat)query_points, (Mat)indices, (Mat)dist, (object)k [, (object)emax=20]) -> None :
    
    Wrapped function:
        cvFindFeatures
    Argument 'indices':
        C/C++ type: ::CvMat *.
        Python type: Mat.
    Argument 'query_points':
        C/C++ type: ::CvMat const *.
        Python type: Mat.
    Argument 'dist':
        C/C++ type: ::CvMat *.
        Python type: Mat.

    C++ signature :
        void findFeatures(CvFeatureTree*,cv::Mat {lvalue},cv::Mat {lvalue},cv::Mat {lvalue},int [,int=20])

findFeaturesBoxed(...)


findFeaturesBoxed( (CvFeatureTree)tr, (Mat)bounds_min, (Mat)bounds_max, (Mat)out_indices) -> object :
    
    Wrapped function:
        cvFindFeaturesBoxed
    Argument 'bounds_min':
        C/C++ type: ::CvMat *.
        Python type: Mat.
    Argument 'out_indices':
        C/C++ type: ::CvMat *.
        Python type: Mat.
    Argument 'bounds_max':
        C/C++ type: ::CvMat *.
        Python type: Mat.

    C++ signature :
        boost::python::api::object findFeaturesBoxed(CvFeatureTree*,cv::Mat {lvalue},cv::Mat {lvalue},cv::Mat {lvalue})

findFundamentalMat(...)


findFundamentalMat( (Mat)points1, (Mat)points2 [, (object)method=8 [, (object)param1=3.0 [, (object)param2=0.98999999999999999]]]) -> Mat :

    C++ signature :
        cv::Mat findFundamentalMat(cv::Mat,cv::Mat [,int=8 [,double=3.0 [,double=0.98999999999999999]]])

findFundamentalMat2(...)


findFundamentalMat2( (Mat)points1, (Mat)points2 [, (object)method=8 [, (object)param1=3.0 [, (object)param2=0.98999999999999999]]]) -> tuple :
    
    Wrapped function:
        findFundamentalMat
    Argument 'mask':
        C/C++ type: ::std::vector< unsigned char > &.
        Python type: Mat.
        Invoke asMat() to convert a 1D Python sequence into a Mat, e.g. 
        asMat([0,1,2]) or asMat((0,1,2)).
        Output argument: omitted from the function's calling sequence, and is 
        returned along with the function's return value (if any).

    C++ signature :
        boost::python::tuple findFundamentalMat2(cv::Mat,cv::Mat [,int=8 [,double=3.0 [,double=0.98999999999999999]]])

findHomography(...)


findHomography( (Mat)srcPoints, (Mat)dstPoints [, (object)method=0 [, (object)ransacReprojThreshold=0]]) -> Mat :

    C++ signature :
        cv::Mat findHomography(cv::Mat,cv::Mat [,int=0 [,double=0]])

findHomography2(...)


findHomography2( (Mat)srcPoints, (Mat)dstPoints [, (object)method=0 [, (object)ransacReprojThreshold=0]]) -> tuple :
    
    Wrapped function:
        findHomography
    Argument 'mask':
        C/C++ type: ::std::vector< unsigned char > &.
        Python type: Mat.
        Invoke asMat() to convert a 1D Python sequence into a Mat, e.g. 
        asMat([0,1,2]) or asMat((0,1,2)).
        Output argument: omitted from the function's calling sequence, and is 
        returned along with the function's return value (if any).

    C++ signature :
        boost::python::tuple findHomography2(cv::Mat,cv::Mat [,int=0 [,double=0]])

findNearestPoint2D(...)


findNearestPoint2D( (CvSubdiv2D)subdiv, (Point2f)pt) -> object :
    
    Wrapped function:
        cvFindNearestPoint2D
    Argument 'pt':
        C/C++ type: ::CvPoint2D32f.
        Python type: Point2f.

    C++ signature :
        boost::python::api::object findNearestPoint2D(CvSubdiv2D*,cv::Point_<float>)

findNextContour(...)


findNextContour( (CvContourScanner)scanner) -> CvSeq :
    
    Wrapped function:
        cvFindNextContour

    C++ signature :
        CvSeq* findNextContour(_CvContourScanner*)

findStereoCorrespondence(...)


findStereoCorrespondence( (Mat)leftImage, (Mat)rightImage, (object)mode, (Mat)dispImage, (object)maxDisparity [, (object)param1=12345 [, (object)param2=12345 [, (object)param3=12345 [, (object)param4=12345 [, (object)param5=12345]]]]]) -> None :
    
    Wrapped function:
        cvFindStereoCorrespondence
    Argument 'dispImage':
        C/C++ type: ::CvArr *.
        Python type: Mat.
    Argument 'leftImage':
        C/C++ type: ::CvArr const *.
        Python type: Mat.
    Argument 'rightImage':
        C/C++ type: ::CvArr const *.
        Python type: Mat.

    C++ signature :
        void findStereoCorrespondence(cv::Mat {lvalue},cv::Mat {lvalue},int,cv::Mat {lvalue},int [,double=12345 [,double=12345 [,double=12345 [,double=12345 [,double=12345]]]]])

findStereoCorrespondenceGC(...)


findStereoCorrespondenceGC( (Mat)left, (Mat)right, (Mat)disparityLeft, (Mat)disparityRight, (CvStereoGCState)state [, (object)useDisparityGuess=0]) -> None :
    
    Wrapped function:
        cvFindStereoCorrespondenceGC
    Argument 'disparityLeft':
        C/C++ type: ::CvArr *.
        Python type: Mat.
    Argument 'right':
        C/C++ type: ::CvArr const *.
        Python type: Mat.
    Argument 'disparityRight':
        C/C++ type: ::CvArr *.
        Python type: Mat.
    Argument 'left':
        C/C++ type: ::CvArr const *.
        Python type: Mat.

    C++ signature :
        void findStereoCorrespondenceGC(cv::Mat {lvalue},cv::Mat {lvalue},cv::Mat {lvalue},cv::Mat {lvalue},CvStereoGCState* [,int=0])

findType(...)


findType( (str)type_name) -> CvTypeInfo :
    
    Wrapped function:
        cvFindType

    C++ signature :
        CvTypeInfo* findType(char const*)

firstType()

    Wrapped function:
        cvFirstType

    C++ signature :
        CvTypeInfo* firstType()

Returns: CvTypeInfo :

fitEllipse(...)


fitEllipse( (Mat)points) -> RotatedRect :

    C++ signature :
        cv::RotatedRect fitEllipse(cv::Mat)

fitLine(...)


fitLine( (Mat)points, (Vec6f)line, (object)distType, (object)param, (object)reps, (object)aeps) -> None :

    C++ signature :
        void fitLine(cv::Mat,cv::Vec<float, 6> {lvalue},int,double,double,double)

fitLine( (Mat)points, (Vec4f)line, (object)distType, (object)param, (object)reps, (object)aeps) -> None :

    C++ signature :
        void fitLine(cv::Mat,cv::Vec<float, 4> {lvalue},int,double,double,double)

flip(...)


flip( (Mat)a, (Mat)b, (object)flipCode) -> None :

    C++ signature :
        void flip(cv::Mat,cv::Mat {lvalue},int)

floodFill(...)


floodFill( (Mat)image, (Mat)mask, (Point2i)seedPoint, (Scalar)newVal [, (Scalar)loDiff=Scalar([ 0.  0.  0.  0.]) [, (Scalar)upDiff=Scalar([ 0.  0.  0.  0.]) [, (object)flags=4]]]) -> tuple :
    
    Argument 'rect':
        C/C++ type: ::cv::Rect *.
        Python type: Python equivalence of the C/C++ type without pointer.
        Output argument: omitted from the function's calling sequence, and is 
        returned along with the function's return value (if any).

    C++ signature :
        boost::python::tuple floodFill(cv::Mat {lvalue},cv::Mat {lvalue},cv::Point_<int>,cv::Scalar_<double> [,cv::Scalar_<double>=Scalar([ 0.  0.  0.  0.]) [,cv::Scalar_<double>=Scalar([ 0.  0.  0.  0.]) [,int=4]]])

floodFill( (Mat)image, (Point2i)seedPoint, (Scalar)newVal [, (Scalar)loDiff=Scalar([ 0.  0.  0.  0.]) [, (Scalar)upDiff=Scalar([ 0.  0.  0.  0.]) [, (object)flags=4]]]) -> tuple :
    
    Argument 'rect':
        C/C++ type: ::cv::Rect *.
        Python type: Python equivalence of the C/C++ type without pointer.
        Output argument: omitted from the function's calling sequence, and is 
        returned along with the function's return value (if any).

    C++ signature :
        boost::python::tuple floodFill(cv::Mat {lvalue},cv::Point_<int>,cv::Scalar_<double> [,cv::Scalar_<double>=Scalar([ 0.  0.  0.  0.]) [,cv::Scalar_<double>=Scalar([ 0.  0.  0.  0.]) [,int=4]]])

floor(...)


floor( (object)value) -> int :
    
    Wrapped function:
        cvFloor

    C++ signature :
        int floor(double)

flushSeqWriter(...)


flushSeqWriter( (CvSeqWriter)writer) -> None :
    
    Wrapped function:
        cvFlushSeqWriter

    C++ signature :
        void flushSeqWriter(CvSeqWriter*)

fromUtf16(...)


fromUtf16( (unicode)str) -> str :

    C++ signature :
        std::string fromUtf16(std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t> >)

gemm(...)


gemm( (Mat)a, (Mat)b, (object)alpha, (Mat)c, (object)gamma, (Mat)d [, (object)flags=0]) -> None :

    C++ signature :
        void gemm(cv::Mat,cv::Mat,double,cv::Mat,double,cv::Mat {lvalue} [,int=0])

getAffineTransform(...)


getAffineTransform( (Mat)src, (Mat)dst) -> object :
    
    Argument 'src':
        C/C++ type: ::cv::Point2f const *.
        Python type: Mat.
        Invoke asMat() to convert a 1D Python sequence into a Mat, e.g. 
        asMat([0,1,2]) or asMat((0,1,2)).
    Argument 'dst':
        C/C++ type: ::cv::Point2f const *.
        Python type: Mat.
        Invoke asMat() to convert a 1D Python sequence into a Mat, e.g. 
        asMat([0,1,2]) or asMat((0,1,2)).

    C++ signature :
        boost::python::api::object getAffineTransform(cv::Mat,cv::Mat)

getCPUTickCount()

    C++ signature :
        long long getCPUTickCount()

Returns: long :

getColumnSumFilter(...)


getColumnSumFilter( (object)sumType, (object)dstType, (object)ksize [, (object)anchor=-1 [, (object)scale=1]]) -> Ptr_BaseColumnFilter :

    C++ signature :
        cv::Ptr<cv::BaseColumnFilter> getColumnSumFilter(int,int,int [,int=-1 [,double=1]])

getDefaultNewCameraMatrix(...)


getDefaultNewCameraMatrix( (Mat)cameraMatrix [, (Size2i)imgsize=Size2i(width=0, height=0) [, (bool)centerPrincipalPoint=False]]) -> Mat :

    C++ signature :
        cv::Mat getDefaultNewCameraMatrix(cv::Mat [,cv::Size_<int>=Size2i(width=0, height=0) [,bool=False]])

getDerivKernels(...)


getDerivKernels( (Mat)kx, (Mat)ky, (object)dx, (object)dy, (object)ksize [, (bool)normalize=False [, (object)ktype=5]]) -> None :

    C++ signature :
        void getDerivKernels(cv::Mat {lvalue},cv::Mat {lvalue},int,int,int [,bool=False [,int=5]])

getElemSize(...)


getElemSize( (object)type) -> int :

    C++ signature :
        unsigned int getElemSize(int)

getElemType(...)


getElemType( (Mat)arr) -> object :
    
    Wrapped function:
        cvGetElemType
    Argument 'arr':
        C/C++ type: ::CvArr const *.
        Python type: Mat.

    C++ signature :
        boost::python::api::object getElemType(cv::Mat {lvalue})

getErrMode()

    Wrapped function:
        cvGetErrMode

    C++ signature :
        int getErrMode()

Returns: int :

getErrStatus()

    Wrapped function:
        cvGetErrStatus

    C++ signature :
        int getErrStatus()

Returns: int :

getFileNode(...)


getFileNode( (FileStorage)fs, (FileNode)map, (CvStringHashNode)key [, (object)create_missing=0]) -> object :
    
    Wrapped function:
        cvGetFileNode
    Argument 'map':
        C/C++ type: ::CvFileNode *.
        Python type: FileNode.
    Argument 'fs':
        C/C++ type: ::CvFileStorage *.
        Python type: FileStorage.

    C++ signature :
        boost::python::api::object getFileNode(cv::FileStorage {lvalue},cv::FileNode {lvalue},CvStringHashNode const* [,int=0])

getFileNodeByName(...)


getFileNodeByName( (CvFileStorage)fs, (FileNode)map, (str)name) -> object :
    
    Wrapped function:
        cvGetFileNodeByName
    Argument 'map':
        C/C++ type: ::CvFileNode const *.
        Python type: FileNode.

    C++ signature :
        boost::python::api::object getFileNodeByName(CvFileStorage const*,cv::FileNode,char const*)

getFileNodeName(...)


getFileNodeName( (FileNode)node) -> object :
    
    Wrapped function:
        cvGetFileNodeName
    Argument 'node':
        C/C++ type: ::CvFileNode const *.
        Python type: FileNode.

    C++ signature :
        boost::python::api::object getFileNodeName(cv::FileNode)

getGaussianKernel(...)


getGaussianKernel( (object)ksize, (object)sigma [, (object)ktype=6]) -> Mat :

    C++ signature :
        cv::Mat getGaussianKernel(int,double [,int=6])

getHashedKey(...)


getHashedKey( (FileStorage)fs, (str)name [, (object)len=-1 [, (object)create_missing=0]]) -> object :
    
    Wrapped function:
        cvGetHashedKey
    Argument 'fs':
        C/C++ type: ::CvFileStorage *.
        Python type: FileStorage.

    C++ signature :
        boost::python::api::object getHashedKey(cv::FileStorage {lvalue},char const* [,int=-1 [,int=0]])

getKernelType(...)


getKernelType( (Mat)kernel, (Point2i)anchor) -> int :

    C++ signature :
        int getKernelType(cv::Mat,cv::Point_<int>)

getLinearColumnFilter(...)


getLinearColumnFilter( (object)bufType, (object)dstType, (Mat)kernel, (object)anchor, (object)symmetryType [, (object)delta=0 [, (object)bits=0]]) -> Ptr_BaseColumnFilter :

    C++ signature :
        cv::Ptr<cv::BaseColumnFilter> getLinearColumnFilter(int,int,cv::Mat,int,int [,double=0 [,int=0]])

getLinearFilter(...)


getLinearFilter( (object)srcType, (object)dstType, (Mat)kernel [, (Point2i)anchor=Point2i(x=-1, y=-1) [, (object)delta=0 [, (object)bits=0]]]) -> Ptr_BaseFilter :

    C++ signature :
        cv::Ptr<cv::BaseFilter> getLinearFilter(int,int,cv::Mat [,cv::Point_<int>=Point2i(x=-1, y=-1) [,double=0 [,int=0]]])

getLinearRowFilter(...)


getLinearRowFilter( (object)srcType, (object)bufType, (Mat)kernel, (object)anchor, (object)symmetryType) -> Ptr_BaseRowFilter :

    C++ signature :
        cv::Ptr<cv::BaseRowFilter> getLinearRowFilter(int,int,cv::Mat,int,int)

getMorphologyColumnFilter(...)


getMorphologyColumnFilter( (object)op, (object)type, (object)ksize [, (object)anchor=-1]) -> Ptr_BaseColumnFilter :

    C++ signature :
        cv::Ptr<cv::BaseColumnFilter> getMorphologyColumnFilter(int,int,int [,int=-1])

getMorphologyFilter(...)


getMorphologyFilter( (object)op, (object)type, (Mat)kernel [, (Point2i)anchor=Point2i(x=-1, y=-1)]) -> Ptr_BaseFilter :

    C++ signature :
        cv::Ptr<cv::BaseFilter> getMorphologyFilter(int,int,cv::Mat [,cv::Point_<int>=Point2i(x=-1, y=-1)])

getMorphologyRowFilter(...)


getMorphologyRowFilter( (object)op, (object)type, (object)ksize [, (object)anchor=-1]) -> Ptr_BaseRowFilter :

    C++ signature :
        cv::Ptr<cv::BaseRowFilter> getMorphologyRowFilter(int,int,int [,int=-1])

getNumThreads()

    Wrapped function:
        cvGetNumThreads

    C++ signature :
        int getNumThreads()

getNumThreads() -> int :

    C++ signature :
        int getNumThreads()

Returns: int :

getOptimalDFTSize(...)


getOptimalDFTSize( (object)vecsize) -> int :

    C++ signature :
        int getOptimalDFTSize(int)

getPerspectiveTransform(...)


getPerspectiveTransform( (Mat)src, (Mat)dst) -> object :
    
    Argument 'src':
        C/C++ type: ::cv::Point2f const *.
        Python type: Mat.
        Invoke asMat() to convert a 1D Python sequence into a Mat, e.g. 
        asMat([0,1,2]) or asMat((0,1,2)).
    Argument 'dst':
        C/C++ type: ::cv::Point2f const *.
        Python type: Mat.
        Invoke asMat() to convert a 1D Python sequence into a Mat, e.g. 
        asMat([0,1,2]) or asMat((0,1,2)).

    C++ signature :
        boost::python::api::object getPerspectiveTransform(cv::Mat,cv::Mat)

getQuadrangleSubPix(...)


getQuadrangleSubPix( (Mat)src, (Mat)dst, (Mat)map_matrix) -> None :
    
    Wrapped function:
        cvGetQuadrangleSubPix
    Argument 'map_matrix':
        C/C++ type: ::CvMat const *.
        Python type: Mat.
    Argument 'src':
        C/C++ type: ::CvArr const *.
        Python type: Mat.
    Argument 'dst':
        C/C++ type: ::CvArr *.
        Python type: Mat.

    C++ signature :
        void getQuadrangleSubPix(cv::Mat {lvalue},cv::Mat {lvalue},cv::Mat {lvalue})

getRectSubPix(...)


getRectSubPix( (Mat)image, (Size2i)patchSize, (Point2f)center, (Mat)patch [, (object)patchType=-1]) -> None :

    C++ signature :
        void getRectSubPix(cv::Mat,cv::Size_<int>,cv::Point_<float>,cv::Mat {lvalue} [,int=-1])

getRootFileNode(...)


getRootFileNode( (CvFileStorage)fs [, (object)stream_index=0]) -> CvFileNode :
    
    Wrapped function:
        cvGetRootFileNode

    C++ signature :
        CvFileNode* getRootFileNode(CvFileStorage const* [,int=0])

getRotationMatrix2D(...)


getRotationMatrix2D( (Point2f)center, (object)angle, (object)scale) -> Mat :

    C++ signature :
        cv::Mat getRotationMatrix2D(cv::Point_<float>,double,double)

getRowSumFilter(...)


getRowSumFilter( (object)srcType, (object)sumType, (object)ksize [, (object)anchor=-1]) -> Ptr_BaseRowFilter :

    C++ signature :
        cv::Ptr<cv::BaseRowFilter> getRowSumFilter(int,int,int [,int=-1])

getSeqReaderPos(...)


getSeqReaderPos( (CvSeqReader)reader) -> int :
    
    Wrapped function:
        cvGetSeqReaderPos

    C++ signature :
        int getSeqReaderPos(CvSeqReader*)

getSetElem(...)


getSetElem( (CvSet)set_header, (object)index) -> CvSetElem :
    
    Wrapped function:
        cvGetSetElem

    C++ signature :
        CvSetElem* getSetElem(CvSet const*,int)

getStructuringElement(...)


getStructuringElement( (object)shape, (Size2i)ksize [, (Point2i)anchor=Point2i(x=-1, y=-1)]) -> Mat :

    C++ signature :
        cv::Mat getStructuringElement(int,cv::Size_<int> [,cv::Point_<int>=Point2i(x=-1, y=-1)])

getTextSize(...)


getTextSize( (object)text, (object)fontFace, (object)fontScale, (object)thickness) -> tuple :
    
    Argument 'baseLine':
        C/C++ type: int *.
        Python type: Python equivalence of the C/C++ type without pointer.
        Output argument: omitted from the function's calling sequence, and is 
        returned along with the function's return value (if any).

    C++ signature :
        boost::python::tuple getTextSize(std::string,int,double,int)

getThreadNum()

    Wrapped function:
        cvGetThreadNum

    C++ signature :
        int getThreadNum()

getThreadNum() -> int :

    C++ signature :
        int getThreadNum()

Returns: int :

getTickCount()

    Wrapped function:
        cvGetTickCount

    C++ signature :
        long long getTickCount()

getTickCount() -> long :

    C++ signature :
        long long getTickCount()

Returns: long :

getTickFrequency()

    Wrapped function:
        cvGetTickFrequency

    C++ signature :
        double getTickFrequency()

getTickFrequency() -> float :

    C++ signature :
        double getTickFrequency()

Returns: float :

getTrackbarPos(...)


getTrackbarPos( (str)trackbar_name, (str)window_name) -> int :
    
    Wrapped function:
        cvGetTrackbarPos

    C++ signature :
        int getTrackbarPos(char const*,char const*)

getValidDisparityROI(...)


getValidDisparityROI( (Rect)roi1, (Rect)roi2, (object)minDisparity, (object)numberOfDisparities, (object)SADWindowSize) -> Rect :

    C++ signature :
        cv::Rect_<int> getValidDisparityROI(cv::Rect_<int>,cv::Rect_<int>,int,int,int)

getWindowName(...)


getWindowName( (object)window_handle) -> str :
    
    Wrapped function:
        cvGetWindowName

    C++ signature :
        char const* getWindowName(void*)

getWindowProperty(...)


getWindowProperty( (object)winname, (object)prop_id) -> float :

    C++ signature :
        double getWindowProperty(std::string,int)

goodFeaturesToTrack(...)


goodFeaturesToTrack( (Mat)image, (object)maxCorners, (object)qualityLevel, (object)minDistance [, (Mat)mask=Mat() [, (object)blockSize=3 [, (bool)useHarrisDetector=False [, (object)k=0.040000000000000001]]]]) -> object :
    
    Argument 'corners':
        C/C++ type: ::std::vector< cv::Point_<float> > &.
        Python type: Mat.
        Invoke asMat() to convert a 1D Python sequence into a Mat, e.g. 
        asMat([0,1,2]) or asMat((0,1,2)).
        Output argument: omitted from the function's calling sequence, and is 
        returned along with the function's return value (if any).

    C++ signature :
        boost::python::api::object goodFeaturesToTrack(cv::Mat,int,double,double [,cv::Mat=Mat() [,int=3 [,bool=False [,double=0.040000000000000001]]]])

grabCut(...)


grabCut( (Mat)img, (Mat)mask, (Rect)rect, (Mat)bgdModel, (Mat)fgdModel, (object)iterCount [, (object)mode=2]) -> None :

    C++ signature :
        void grabCut(cv::Mat,cv::Mat {lvalue},cv::Rect_<int>,cv::Mat {lvalue},cv::Mat {lvalue},int [,int=2])

groupRectangles(...)


groupRectangles( (Mat)rectList, (Mat)weights, (object)groupThreshold [, (object)eps=0.20000000000000001]) -> None :
    
    Argument 'weights':
        C/C++ type: ::std::vector< int > &.
        Python type: Mat.
        Invoke asMat() to convert a 1D Python sequence into a Mat, e.g. 
        asMat([0,1,2]) or asMat((0,1,2)).
    Argument 'rectList':
        C/C++ type: ::std::vector< cv::Rect_<int> > &.
        Python type: Mat.
        Invoke asMat() to convert a 1D Python sequence into a Mat, e.g. 
        asMat([0,1,2]) or asMat((0,1,2)).

    C++ signature :
        void groupRectangles(cv::Mat {lvalue},cv::Mat {lvalue},int [,double=0.20000000000000001])

groupRectangles( (Mat)rectList, (object)groupThreshold [, (object)eps=0.20000000000000001]) -> None :
    
    Argument 'rectList':
        C/C++ type: ::std::vector< cv::Rect_<int> > &.
        Python type: Mat.
        Invoke asMat() to convert a 1D Python sequence into a Mat, e.g. 
        asMat([0,1,2]) or asMat((0,1,2)).

    C++ signature :
        void groupRectangles(cv::Mat {lvalue},int [,double=0.20000000000000001])

hierarchicalClustering(...)


hierarchicalClustering( (Mat)features, (Mat)centers, (KMeansIndexParams)params) -> int :

    C++ signature :
        int hierarchicalClustering(cv::Mat,cv::Mat {lvalue},cv::flann::KMeansIndexParams)

idct(...)


idct( (Mat)src, (Mat)dst [, (object)flags=0]) -> None :

    C++ signature :
        void idct(cv::Mat,cv::Mat {lvalue} [,int=0])

idft(...)


idft( (Mat)src, (Mat)dst [, (object)flags=0 [, (object)nonzeroRows=0]]) -> None :

    C++ signature :
        void idft(cv::Mat,cv::Mat {lvalue} [,int=0 [,int=0]])

imdecode(...)


imdecode( (Mat)buf, (object)flags) -> Mat :

    C++ signature :
        cv::Mat imdecode(cv::Mat,int)

imencode(...)


imencode( (object)ext, (Mat)img [, (Mat)params=Mat()]) -> tuple :
    
    Argument 'params':
        C/C++ type: ::std::vector< int > const &.
        Python type: Mat.
        Invoke asMat() to convert a 1D Python sequence into a Mat, e.g. 
        asMat([0,1,2]) or asMat((0,1,2)).
    Argument 'buf':
        C/C++ type: ::std::vector< unsigned char > &.
        Python type: Mat.
        Invoke asMat() to convert a 1D Python sequence into a Mat, e.g. 
        asMat([0,1,2]) or asMat((0,1,2)).
        Output argument: omitted from the function's calling sequence, and is 
        returned along with the function's return value (if any).

    C++ signature :
        boost::python::tuple imencode(std::string,cv::Mat [,cv::Mat=Mat()])

imread(...)


imread( (object)filename [, (object)flags=1]) -> Mat :

    C++ signature :
        cv::Mat imread(std::string [,int=1])

imshow(...)


imshow( (object)winname, (Mat)mat) -> None :

    C++ signature :
        void imshow(std::string,cv::Mat)

imwrite(...)


imwrite( (object)filename, (Mat)img [, (Mat)params=Mat()]) -> object :
    
    Argument 'params':
        C/C++ type: ::std::vector< int > const &.
        Python type: Mat.
        Invoke asMat() to convert a 1D Python sequence into a Mat, e.g. 
        asMat([0,1,2]) or asMat((0,1,2)).

    C++ signature :
        boost::python::api::object imwrite(std::string,cv::Mat [,cv::Mat=Mat()])

inRange(...)


inRange( (MatND)src, (Scalar)lowerb, (Scalar)upperb, (MatND)dst) -> None :

    C++ signature :
        void inRange(cv::MatND,cv::Scalar_<double>,cv::Scalar_<double>,cv::MatND {lvalue})

inRange( (MatND)src, (MatND)lowerb, (MatND)upperb, (MatND)dst) -> None :

    C++ signature :
        void inRange(cv::MatND,cv::MatND,cv::MatND,cv::MatND {lvalue})

inRange( (Mat)src, (Scalar)lowerb, (Scalar)upperb, (Mat)dst) -> None :

    C++ signature :
        void inRange(cv::Mat,cv::Scalar_<double>,cv::Scalar_<double>,cv::Mat {lvalue})

inRange( (Mat)src, (Mat)lowerb, (Mat)upperb, (Mat)dst) -> None :

    C++ signature :
        void inRange(cv::Mat,cv::Mat,cv::Mat,cv::Mat {lvalue})

initCameraMatrix2D(...)


initCameraMatrix2D( (list)objectPoints, (list)imagePoints, (Size2i)imageSize [, (object)aspectRatio=1.0]) -> object :
    
    Argument 'objectPoints':
        C/C++ type: ::std::vector< std::vector< cv::Point3_<float> > > const 
        &.
        Python type: list of Mat, e.g. [Mat(), Mat(), Mat()].
        Invoke asMat() to convert every 1D Python sequence into a Mat, e.g. 
        [asMat([0,1,2]), asMat((0,1,2)].
    Argument 'imagePoints':
        C/C++ type: ::std::vector< std::vector< cv::Point_<float> > > const &.
        Python type: list of Mat, e.g. [Mat(), Mat(), Mat()].
        Invoke asMat() to convert every 1D Python sequence into a Mat, e.g. 
        [asMat([0,1,2]), asMat((0,1,2)].

    C++ signature :
        boost::python::api::object initCameraMatrix2D(boost::python::list,boost::python::list,cv::Size_<int> [,double=1.0])

initNArrayIterator(...)


initNArrayIterator( (Mat)arrs, (Mat)mask, (object)stubs, (CvNArrayIterator)array_iterator [, (object)flags=0]) -> object :
    
    Wrapped function:
        cvInitNArrayIterator
    Argument 'count':
        Dependent argument: omitted from the function's calling sequence, as 
        its value is derived from argument 'arrs'.
    Argument 'mask':
        C/C++ type: ::CvArr const *.
        Python type: Mat.
    Argument 'arrs':
        C/C++ type: ::CvArr * *.
        Python type: Mat.
        Invoke asMat() to convert a 1D Python sequence into a Mat, e.g. 
        asMat([0,1,2]) or asMat((0,1,2)).

    C++ signature :
        boost::python::api::object initNArrayIterator(cv::Mat,cv::Mat {lvalue},CvMatND*,CvNArrayIterator* [,int=0])

initSubdivDelaunay2D(...)


initSubdivDelaunay2D( (CvSubdiv2D)subdiv, (CvRect)rect) -> None :
    
    Wrapped function:
        cvInitSubdivDelaunay2D

    C++ signature :
        void initSubdivDelaunay2D(CvSubdiv2D*,CvRect)

initSystem(...)


initSystem( (Mat)argv) -> object :
    
    Wrapped function:
        cvInitSystem
    Argument 'argc':
        Dependent argument: omitted from the function's calling sequence, as 
        its value is derived from argument 'argv'.
    Argument 'argv':
        C/C++ type: char * *.
        Python type: Mat.
        Invoke asMat() to convert a 1D Python sequence into a Mat, e.g. 
        asMat([0,1,2]) or asMat((0,1,2)).

    C++ signature :
        boost::python::api::object initSystem(cv::Mat)

initUndistortRectifyMap(...)


initUndistortRectifyMap( (Mat)cameraMatrix, (Mat)distCoeffs, (Mat)R, (Mat)newCameraMatrix, (Size2i)size, (object)m1type, (Mat)map1, (Mat)map2) -> None :

    C++ signature :
        void initUndistortRectifyMap(cv::Mat,cv::Mat,cv::Mat,cv::Mat,cv::Size_<int>,int,cv::Mat {lvalue},cv::Mat {lvalue})

inpaint(...)


inpaint( (Mat)src, (Mat)inpaintMask, (Mat)dst, (object)inpaintRange, (object)flags) -> None :

    C++ signature :
        void inpaint(cv::Mat,cv::Mat,cv::Mat {lvalue},double,int)

integral(...)


integral( (Mat)src, (Mat)sum, (Mat)sqsum, (Mat)tilted [, (object)sdepth=-1]) -> None :

    C++ signature :
        void integral(cv::Mat,cv::Mat {lvalue},cv::Mat {lvalue},cv::Mat {lvalue} [,int=-1])

integral( (Mat)src, (Mat)sum, (Mat)sqsum [, (object)sdepth=-1]) -> None :

    C++ signature :
        void integral(cv::Mat,cv::Mat {lvalue},cv::Mat {lvalue} [,int=-1])

integral( (Mat)src, (Mat)sum [, (object)sdepth=-1]) -> None :

    C++ signature :
        void integral(cv::Mat,cv::Mat {lvalue} [,int=-1])

invert(...)


invert( (Mat)a, (Mat)c [, (object)flags=0]) -> float :

    C++ signature :
        double invert(cv::Mat,cv::Mat {lvalue} [,int=0])

invertAffineTransform(...)


invertAffineTransform( (Mat)M, (Mat)iM) -> None :

    C++ signature :
        void invertAffineTransform(cv::Mat,cv::Mat {lvalue})

isContourConvex(...)


isContourConvex( (Mat)contour) -> bool :

    C++ signature :
        bool isContourConvex(cv::Mat)

isInf(...)


isInf( (object)value) -> int :
    
    Wrapped function:
        cvIsInf

    C++ signature :
        int isInf(double)

isNaN(...)


isNaN( (object)value) -> int :
    
    Wrapped function:
        cvIsNaN

    C++ signature :
        int isNaN(double)

kmeans(...)


kmeans( (Mat)data, (object)K, (Mat)best_labels, (TermCriteria)criteria, (object)attempts, (object)flags) -> tuple :
    
    Argument 'centers':
        C/C++ type: ::cv::Mat *.
        Python type: Python equivalence of the C/C++ type without pointer.
        Output argument: omitted from the function's calling sequence, and is 
        returned along with the function's return value (if any).

    C++ signature :
        boost::python::tuple kmeans(cv::Mat,int,cv::Mat {lvalue},cv::TermCriteria,int,int)

line(...)


line( (Mat)img, (Point2i)pt1, (Point2i)pt2, (Scalar)color [, (object)thickness=1 [, (object)lineType=8 [, (object)shift=0]]]) -> None :

    C++ signature :
        void line(cv::Mat {lvalue},cv::Point_<int>,cv::Point_<int>,cv::Scalar_<double> [,int=1 [,int=8 [,int=0]]])

linearPolar(...)


linearPolar( (Mat)src, (Mat)dst, (Point2f)center, (object)maxRadius [, (object)flags=9]) -> None :
    
    Wrapped function:
        cvLinearPolar
    Argument 'src':
        C/C++ type: ::CvArr const *.
        Python type: Mat.
    Argument 'dst':
        C/C++ type: ::CvArr *.
        Python type: Mat.
    Argument 'center':
        C/C++ type: ::CvPoint2D32f.
        Python type: Point2f.

    C++ signature :
        void linearPolar(cv::Mat {lvalue},cv::Mat {lvalue},cv::Point_<float>,double [,int=9])

log(...)


log( (MatND)a, (MatND)b) -> None :

    C++ signature :
        void log(cv::MatND,cv::MatND {lvalue})

log( (Mat)a, (Mat)b) -> None :

    C++ signature :
        void log(cv::Mat,cv::Mat {lvalue})

logPolar(...)


logPolar( (Mat)src, (Mat)dst, (Point2f)center, (object)M [, (object)flags=9]) -> None :
    
    Wrapped function:
        cvLogPolar
    Argument 'src':
        C/C++ type: ::CvArr const *.
        Python type: Mat.
    Argument 'dst':
        C/C++ type: ::CvArr *.
        Python type: Mat.
    Argument 'center':
        C/C++ type: ::CvPoint2D32f.
        Python type: Point2f.

    C++ signature :
        void logPolar(cv::Mat {lvalue},cv::Mat {lvalue},cv::Point_<float>,double [,int=9])

magnitude(...)


magnitude( (Mat)x, (Mat)y, (Mat)magnitude) -> None :

    C++ signature :
        void magnitude(cv::Mat,cv::Mat,cv::Mat {lvalue})

matMulDeriv(...)


matMulDeriv( (Mat)A, (Mat)B, (Mat)dABdA, (Mat)dABdB) -> None :

    C++ signature :
        void matMulDeriv(cv::Mat,cv::Mat,cv::Mat {lvalue},cv::Mat {lvalue})

matchContourTrees(...)


matchContourTrees( (CvContourTree)tree1, (CvContourTree)tree2, (object)method, (object)threshold) -> float :
    
    Wrapped function:
        cvMatchContourTrees

    C++ signature :
        double matchContourTrees(CvContourTree const*,CvContourTree const*,int,double)

matchShapes(...)


matchShapes( (Mat)contour1, (Mat)contour2, (object)method, (object)parameter) -> float :

    C++ signature :
        double matchShapes(cv::Mat,cv::Mat,int,double)

matchTemplate(...)


matchTemplate( (Mat)image, (Mat)templ, (Mat)result, (object)method) -> None :

    C++ signature :
        void matchTemplate(cv::Mat,cv::Mat,cv::Mat {lvalue},int)

max(...)


max( (MatND)a, (object)alpha, (MatND)c) -> None :

    C++ signature :
        void max(cv::MatND,double,cv::MatND {lvalue})

max( (MatND)a, (MatND)b, (MatND)c) -> None :

    C++ signature :
        void max(cv::MatND,cv::MatND,cv::MatND {lvalue})

max( (Mat)a, (object)alpha, (Mat)c) -> None :

    C++ signature :
        void max(cv::Mat,double,cv::Mat {lvalue})

max( (Mat)a, (Mat)b, (Mat)c) -> None :

    C++ signature :
        void max(cv::Mat,cv::Mat,cv::Mat {lvalue})

maxRect(...)


maxRect( (CvRect)rect1, (CvRect)rect2) -> CvRect :
    
    Wrapped function:
        cvMaxRect

    C++ signature :
        CvRect maxRect(CvRect const*,CvRect const*)

mean(...)


mean( (MatND)m [, (MatND)mask]) -> Scalar :

    C++ signature :
        cv::Scalar_<double> mean(cv::MatND [,cv::MatND])

mean( (Mat)m [, (Mat)mask]) -> Scalar :

    C++ signature :
        cv::Scalar_<double> mean(cv::Mat [,cv::Mat])

meanShift(...)


meanShift( (Mat)probImage, (Rect)window, (TermCriteria)criteria) -> int :

    C++ signature :
        int meanShift(cv::Mat,cv::Rect_<int> {lvalue},cv::TermCriteria)

meanStdDev(...)


meanStdDev( (MatND)m, (Scalar)mean, (Scalar)stddev [, (MatND)mask=MatND(shape=(), nchannels=1, depth=0):
array(0, dtype=uint8)]) -> None :

    C++ signature :
        void meanStdDev(cv::MatND,cv::Scalar_<double> {lvalue},cv::Scalar_<double> {lvalue} [,cv::MatND=MatND(shape=(), nchannels=1, depth=0):
array(0, dtype=uint8)])

meanStdDev( (Mat)m, (Scalar)mean, (Scalar)stddev [, (Mat)mask=Mat()]) -> None :

    C++ signature :
        void meanStdDev(cv::Mat,cv::Scalar_<double> {lvalue},cv::Scalar_<double> {lvalue} [,cv::Mat=Mat()])

medianBlur(...)


medianBlur( (Mat)src, (Mat)dst, (object)ksize) -> None :

    C++ signature :
        void medianBlur(cv::Mat,cv::Mat {lvalue},int)

memStorageAllocString(...)


memStorageAllocString( (CvMemStorage)storage, (str)ptr [, (object)len=-1]) -> CvString :
    
    Wrapped function:
        cvMemStorageAllocString

    C++ signature :
        CvString memStorageAllocString(CvMemStorage*,char const* [,int=-1])

merge(...)


merge( (list)mvbegin, (MatND)dst) -> None :
    
    Argument 'count':
        Dependent argument: omitted from the function's calling sequence, as 
        its value is derived from argument 'mvbegin'.
    Argument 'mvbegin':
        C/C++ type: ::cv::MatND const *.
        Python type: list of Mat, e.g. [Mat(), Mat(), Mat()].

    C++ signature :
        void merge(boost::python::list,cv::MatND {lvalue})

merge( (list)mv, (Mat)dst) -> None :
    
    Argument 'count':
        Dependent argument: omitted from the function's calling sequence, as 
        its value is derived from argument 'mv'.
    Argument 'mv':
        C/C++ type: ::cv::Mat const *.
        Python type: list of Mat, e.g. [Mat(), Mat(), Mat()].

    C++ signature :
        void merge(boost::python::list,cv::Mat {lvalue})

min(...)


min( (MatND)a, (object)alpha, (MatND)c) -> None :

    C++ signature :
        void min(cv::MatND,double,cv::MatND {lvalue})

min( (MatND)a, (MatND)b, (MatND)c) -> None :

    C++ signature :
        void min(cv::MatND,cv::MatND,cv::MatND {lvalue})

min( (Mat)a, (object)alpha, (Mat)c) -> None :

    C++ signature :
        void min(cv::Mat,double,cv::Mat {lvalue})

min( (Mat)a, (Mat)b, (Mat)c) -> None :

    C++ signature :
        void min(cv::Mat,cv::Mat,cv::Mat {lvalue})

minAreaRect(...)


minAreaRect( (Mat)points) -> RotatedRect :

    C++ signature :
        cv::RotatedRect minAreaRect(cv::Mat)

minEnclosingCircle(...)


minEnclosingCircle( (Mat)points, (Point2f)center, (object)radius) -> None :

    C++ signature :
        void minEnclosingCircle(cv::Mat,cv::Point_<float> {lvalue},float {lvalue})

minMaxLoc(...)


minMaxLoc( (object)a [, (object)mask=None]) -> tuple :

    C++ signature :
        boost::python::tuple minMaxLoc(boost::python::api::object [,boost::python::api::object=None])

mixChannels(...)


mixChannels( (object)src, (object)dst, (object)fromTo) -> tuple :

    C++ signature :
        boost::python::sequence mixChannels(boost::python::sequence,boost::python::sequence {lvalue},boost::python::ndarray)

moments(...)


moments( (Mat)array [, (bool)binaryImage=False]) -> Moments :

    C++ signature :
        cv::Moments moments(cv::Mat [,bool=False])

morphologyDefaultBorderValue()

    C++ signature :
        cv::Scalar_<double> morphologyDefaultBorderValue()

Returns: Scalar :

morphologyEx(...)


morphologyEx( (Mat)src, (Mat)dst, (object)op, (Mat)kernel [, (Point2i)anchor=Point2i(x=-1, y=-1) [, (object)iterations=1 [, (object)borderType=0 [, (Scalar)borderValue=Scalar([  1.79769313e+308   1.79769313e+308   1.79769313e+308   1.79769313e+308])]]]]) -> None :

    C++ signature :
        void morphologyEx(cv::Mat,cv::Mat {lvalue},int,cv::Mat [,cv::Point_<int>=Point2i(x=-1, y=-1) [,int=1 [,int=0 [,cv::Scalar_<double>=Scalar([  1.79769313e+308   1.79769313e+308   1.79769313e+308   1.79769313e+308])]]]])

moveWindow(...)


moveWindow( (str)name, (object)x, (object)y) -> None :
    
    Wrapped function:
        cvMoveWindow

    C++ signature :
        void moveWindow(char const*,int,int)

mulSpectrums(...)


mulSpectrums( (Mat)a, (Mat)b, (Mat)c, (object)flags [, (bool)conjB=False]) -> None :

    C++ signature :
        void mulSpectrums(cv::Mat,cv::Mat,cv::Mat {lvalue},int [,bool=False])

mulTransposed(...)


mulTransposed( (Mat)a, (Mat)c, (bool)aTa [, (Mat)delta=Mat() [, (object)scale=1 [, (object)rtype=-1]]]) -> None :

    C++ signature :
        void mulTransposed(cv::Mat,cv::Mat {lvalue},bool [,cv::Mat=Mat() [,double=1 [,int=-1]]])

multiply(...)


multiply( (MatND)a, (MatND)b, (MatND)c [, (object)scale=1]) -> None :

    C++ signature :
        void multiply(cv::MatND,cv::MatND,cv::MatND {lvalue} [,double=1])

multiply( (Mat)a, (Mat)b, (Mat)c [, (object)scale=1]) -> None :

    C++ signature :
        void multiply(cv::Mat,cv::Mat,cv::Mat {lvalue} [,double=1])

multiplyAcc(...)


multiplyAcc( (Mat)image1, (Mat)image2, (Mat)acc [, (Mat)mask=Mat()]) -> None :
    
    Wrapped function:
        cvMultiplyAcc
    Argument 'acc':
        C/C++ type: ::CvArr *.
        Python type: Mat.
    Argument 'image2':
        C/C++ type: ::CvArr const *.
        Python type: Mat.
    Argument 'image1':
        C/C++ type: ::CvArr const *.
        Python type: Mat.
    Argument 'mask':
        C/C++ type: ::CvArr const *.
        Python type: Mat.

    C++ signature :
        void multiplyAcc(cv::Mat {lvalue},cv::Mat {lvalue},cv::Mat {lvalue} [,cv::Mat=Mat()])

namedWindow(...)


namedWindow( (object)winname [, (object)flags=1]) -> None :

    C++ signature :
        void namedWindow(std::string [,int=1])

nextNArraySlice(...)


nextNArraySlice( (CvNArrayIterator)array_iterator) -> int :
    
    Wrapped function:
        cvNextNArraySlice

    C++ signature :
        int nextNArraySlice(CvNArrayIterator*)

norm(...)


norm( (SparseMat)src, (object)normType) -> float :

    C++ signature :
        double norm(cv::SparseMat,int)

norm( (MatND)a, (MatND)b [, (object)normType=4 [, (MatND)mask=MatND(shape=(), nchannels=1, depth=0):
array(0, dtype=uint8)]]) -> float :

    C++ signature :
        double norm(cv::MatND,cv::MatND [,int=4 [,cv::MatND=MatND(shape=(), nchannels=1, depth=0):
array(0, dtype=uint8)]])

norm( (MatND)a [, (object)normType=4 [, (MatND)mask=MatND(shape=(), nchannels=1, depth=0):
array(0, dtype=uint8)]]) -> float :

    C++ signature :
        double norm(cv::MatND [,int=4 [,cv::MatND=MatND(shape=(), nchannels=1, depth=0):
array(0, dtype=uint8)]])

norm( (Mat)a, (Mat)b, (object)normType, (Mat)mask) -> float :

    C++ signature :
        double norm(cv::Mat,cv::Mat,int,cv::Mat)

norm( (Mat)a, (object)normType, (Mat)mask) -> float :

    C++ signature :
        double norm(cv::Mat,int,cv::Mat)

norm( (Mat)a, (Mat)b [, (object)normType=4]) -> float :

    C++ signature :
        double norm(cv::Mat,cv::Mat [,int=4])

norm( (Mat)a [, (object)normType=4]) -> float :

    C++ signature :
        double norm(cv::Mat [,int=4])

normalize(...)


normalize( (SparseMat)src, (SparseMat)dst, (object)alpha, (object)normType) -> None :

    C++ signature :
        void normalize(cv::SparseMat,cv::SparseMat {lvalue},double,int)

normalize( (MatND)a, (MatND)b [, (object)alpha=1 [, (object)beta=0 [, (object)norm_type=4 [, (object)rtype=-1 [, (MatND)mask=MatND(shape=(), nchannels=1, depth=0):
array(0, dtype=uint8)]]]]]) -> None :

    C++ signature :
        void normalize(cv::MatND,cv::MatND {lvalue} [,double=1 [,double=0 [,int=4 [,int=-1 [,cv::MatND=MatND(shape=(), nchannels=1, depth=0):
array(0, dtype=uint8)]]]]])

normalize( (Mat)a, (Mat)b [, (object)alpha=1 [, (object)beta=0 [, (object)norm_type=4 [, (object)rtype=-1 [, (Mat)mask=Mat()]]]]]) -> None :

    C++ signature :
        void normalize(cv::Mat,cv::Mat {lvalue} [,double=1 [,double=0 [,int=4 [,int=-1 [,cv::Mat=Mat()]]]]])

openFileStorage(...)


openFileStorage( (str)filename, (CvMemStorage)memstorage, (object)flags) -> CvFileStorage :
    
    Wrapped function:
        cvOpenFileStorage

    C++ signature :
        CvFileStorage* openFileStorage(char const*,CvMemStorage*,int)

patchBasedStdDev(...)


patchBasedStdDev( (Mat)in_image, (Size2i)patch_size, (Mat)out_image) -> None :

    C++ signature :
        void patchBasedStdDev(cv::Mat,cv::Size_<int>,cv::Mat {lvalue})

perspectiveTransform(...)


perspectiveTransform( (Mat)src, (Mat)dst, (Mat)m) -> None :

    C++ signature :
        void perspectiveTransform(cv::Mat,cv::Mat {lvalue},cv::Mat)

phase(...)


phase( (Mat)x, (Mat)y, (Mat)angle [, (bool)angleInDegrees=False]) -> None :

    C++ signature :
        void phase(cv::Mat,cv::Mat,cv::Mat {lvalue} [,bool=False])

pointPolygonTest(...)


pointPolygonTest( (Mat)contour, (Point2f)pt, (bool)measureDist) -> float :

    C++ signature :
        double pointPolygonTest(cv::Mat,cv::Point_<float>,bool)

pointSeqFromMat(...)


pointSeqFromMat( (object)seq_kind, (Mat)mat, (CvContour)contour_header, (CvSeqBlock)block) -> object :
    
    Wrapped function:
        cvPointSeqFromMat
    Argument 'mat':
        C/C++ type: ::CvArr const *.
        Python type: Mat.

    C++ signature :
        boost::python::api::object pointSeqFromMat(int,cv::Mat {lvalue},CvContour*,CvSeqBlock*)

polarToCart(...)


polarToCart( (Mat)magnitude, (Mat)angle, (Mat)x, (Mat)y [, (bool)angleInDegrees=False]) -> None :

    C++ signature :
        void polarToCart(cv::Mat,cv::Mat,cv::Mat {lvalue},cv::Mat {lvalue} [,bool=False])

polylines(...)


polylines( (Mat)img, (object)pts, (bool)isClosed, (Scalar)color [, (object)thickness=1 [, (object)lineType=8 [, (object)shift=0]]]) -> None :
    
    Argument 'npts':
        Dependent argument: omitted from the function's calling sequence, as 
        its value is derived from argument 'pts'.
    Argument 'ncontours':
        Dependent argument: omitted from the function's calling sequence, as 
        its value is derived from argument 'pts'.
    Argument 'pts':
        C/C++ type: ::cv::Point const * *.
        Python type: 2d list.
        Depending on its C++ argument type, it should be a list of Mats or a 
        list of lists.

    C++ signature :
        void polylines(cv::Mat {lvalue},boost::python::api::object,bool,cv::Scalar_<double> [,int=1 [,int=8 [,int=0]]])

pow(...)


pow( (MatND)a, (object)power, (MatND)b) -> None :

    C++ signature :
        void pow(cv::MatND,double,cv::MatND {lvalue})

pow( (Mat)a, (object)power, (Mat)b) -> None :

    C++ signature :
        void pow(cv::Mat,double,cv::Mat {lvalue})

preCornerDetect(...)


preCornerDetect( (Mat)src, (Mat)dst, (object)ksize [, (object)borderType=4]) -> None :

    C++ signature :
        void preCornerDetect(cv::Mat,cv::Mat {lvalue},int [,int=4])

projectPoints(...)


projectPoints( (Mat)objectPoints, (Mat)rvec, (Mat)tvec, (Mat)cameraMatrix, (Mat)distCoeffs) -> object :
    
    Argument 'imagePoints':
        C/C++ type: ::std::vector< cv::Point_<float> > &.
        Python type: Mat.
        Invoke asMat() to convert a 1D Python sequence into a Mat, e.g. 
        asMat([0,1,2]) or asMat((0,1,2)).
        Output argument: omitted from the function's calling sequence, and is 
        returned along with the function's return value (if any).

    C++ signature :
        boost::python::api::object projectPoints(cv::Mat,cv::Mat,cv::Mat,cv::Mat,cv::Mat)

projectPoints2(...)


projectPoints2( (Mat)objectPoints, (Mat)rvec, (Mat)tvec, (Mat)cameraMatrix, (Mat)distCoeffs, (Mat)dpdrot, (Mat)dpdt, (Mat)dpdf, (Mat)dpdc, (Mat)dpddist [, (object)aspectRatio=0]) -> object :
    
    Wrapped function:
        projectPoints
    Argument 'imagePoints':
        C/C++ type: ::std::vector< cv::Point_<float> > &.
        Python type: Mat.
        Invoke asMat() to convert a 1D Python sequence into a Mat, e.g. 
        asMat([0,1,2]) or asMat((0,1,2)).
        Output argument: omitted from the function's calling sequence, and is 
        returned along with the function's return value (if any).

    C++ signature :
        boost::python::api::object projectPoints2(cv::Mat,cv::Mat,cv::Mat,cv::Mat,cv::Mat,cv::Mat {lvalue},cv::Mat {lvalue},cv::Mat {lvalue},cv::Mat {lvalue},cv::Mat {lvalue} [,double=0])

putText(...)


putText( (Mat)img, (object)text, (Point2i)org, (object)fontFace, (object)fontScale, (Scalar)color [, (object)thickness=1 [, (object)linetype=8 [, (bool)bottomLeftOrigin=False]]]) -> None :

    C++ signature :
        void putText(cv::Mat {lvalue},std::string,cv::Point_<int>,int,double,cv::Scalar_<double> [,int=1 [,int=8 [,bool=False]]])

pyrDown(...)


pyrDown( (Mat)src, (Mat)dst [, (Size2i)dstsize=Size2i(width=0, height=0)]) -> None :

    C++ signature :
        void pyrDown(cv::Mat,cv::Mat {lvalue} [,cv::Size_<int>=Size2i(width=0, height=0)])

pyrMeanShiftFiltering(...)


pyrMeanShiftFiltering( (Mat)src, (Mat)dst, (object)sp, (object)sr [, (object)max_level=1 [, (object)termcrit=TermCriteria(type=3, maxCount=5, epsilon=1.0)]]) -> None :
    
    Wrapped function:
        cvPyrMeanShiftFiltering
    Argument 'src':
        C/C++ type: ::CvArr const *.
        Python type: Mat.
    Argument 'dst':
        C/C++ type: ::CvArr *.
        Python type: Mat.

    C++ signature :
        void pyrMeanShiftFiltering(cv::Mat {lvalue},cv::Mat {lvalue},double,double [,int=1 [,CvTermCriteria=TermCriteria(type=3, maxCount=5, epsilon=1.0)]])

pyrSegmentation(...)


pyrSegmentation( (Mat)src, (Mat)dst, (CvMemStorage)storage, (object)level, (object)threshold1, (object)threshold2) -> object :
    
    Wrapped function:
        cvPyrSegmentation
    Argument 'comp':
        C/C++ type: ::CvSeq * *.
        Python type: Python equivalence of the C/C++ type without pointer.
        Output argument: omitted from the function's calling sequence, and is 
        returned along with the function's return value (if any).
    Argument 'dst':
        C/C++ type: ::IplImage *.
        Python type: Mat.
    Argument 'src':
        C/C++ type: ::IplImage *.
        Python type: Mat.

    C++ signature :
        boost::python::api::object pyrSegmentation(cv::Mat {lvalue},cv::Mat {lvalue},CvMemStorage*,int,double,double)

pyrUp(...)


pyrUp( (Mat)src, (Mat)dst [, (Size2i)dstsize=Size2i(width=0, height=0)]) -> None :

    C++ signature :
        void pyrUp(cv::Mat,cv::Mat {lvalue} [,cv::Size_<int>=Size2i(width=0, height=0)])

randArr(...)


randArr( (RNG)rng, (Mat)arr, (object)dist_type, (object)param1, (object)param2) -> None :
    
    Wrapped function:
        cvRandArr
    Argument 'arr':
        C/C++ type: ::CvArr *.
        Python type: Mat.
    Argument 'rng':
        C/C++ type: ::CvRNG *.
        Python type: RNG.

    C++ signature :
        void randArr(cv::RNG {lvalue},cv::Mat {lvalue},int,CvScalar,CvScalar)

randShuffle(...)


randShuffle( (Mat)dst [, (object)iterFactor=1.0 [, (RNG)rng=None]]) -> None :

    C++ signature :
        void randShuffle(cv::Mat {lvalue} [,double=1.0 [,cv::RNG*=None]])

randn(...)


randn( (Mat)dst, (Scalar)mean, (Scalar)stddev) -> None :

    C++ signature :
        void randn(cv::Mat {lvalue},cv::Scalar_<double>,cv::Scalar_<double>)

randu(...)


randu( (Mat)dst, (Scalar)low, (Scalar)high) -> None :

    C++ signature :
        void randu(cv::Mat {lvalue},cv::Scalar_<double>,cv::Scalar_<double>)

range_(...)


range_( (Mat)mat, (object)start, (object)end) -> object :
    
    Wrapped function:
        cvRange
    Argument 'mat':
        C/C++ type: ::CvArr *.
        Python type: Mat.

    C++ signature :
        boost::python::api::object range_(cv::Mat {lvalue},double,double)

readChainPoint(...)


readChainPoint( (CvChainPtReader)reader) -> object :
    
    Wrapped function:
        cvReadChainPoint

    C++ signature :
        CvPoint readChainPoint(CvChainPtReader*)

readInt(...)


readInt( (FileNode)node [, (object)default_value=0]) -> object :
    
    Wrapped function:
        cvReadInt
    Argument 'node':
        C/C++ type: ::CvFileNode const *.
        Python type: FileNode.

    C++ signature :
        boost::python::api::object readInt(cv::FileNode [,int=0])

readIntByName(...)


readIntByName( (CvFileStorage)fs, (FileNode)map, (str)name [, (object)default_value=0]) -> object :
    
    Wrapped function:
        cvReadIntByName
    Argument 'map':
        C/C++ type: ::CvFileNode const *.
        Python type: FileNode.

    C++ signature :
        boost::python::api::object readIntByName(CvFileStorage const*,cv::FileNode,char const* [,int=0])

readReal(...)


readReal( (FileNode)node [, (object)default_value=0.0]) -> object :
    
    Wrapped function:
        cvReadReal
    Argument 'node':
        C/C++ type: ::CvFileNode const *.
        Python type: FileNode.

    C++ signature :
        boost::python::api::object readReal(cv::FileNode [,double=0.0])

readRealByName(...)


readRealByName( (CvFileStorage)fs, (FileNode)map, (str)name [, (object)default_value=0.0]) -> object :
    
    Wrapped function:
        cvReadRealByName
    Argument 'map':
        C/C++ type: ::CvFileNode const *.
        Python type: FileNode.

    C++ signature :
        boost::python::api::object readRealByName(CvFileStorage const*,cv::FileNode,char const* [,double=0.0])

readString(...)


readString( (FileNode)node [, (str)default_value=None]) -> object :
    
    Wrapped function:
        cvReadString
    Argument 'node':
        C/C++ type: ::CvFileNode const *.
        Python type: FileNode.

    C++ signature :
        boost::python::api::object readString(cv::FileNode [,char const*=None])

readStringByName(...)


readStringByName( (CvFileStorage)fs, (FileNode)map, (str)name [, (str)default_value=None]) -> object :
    
    Wrapped function:
        cvReadStringByName
    Argument 'map':
        C/C++ type: ::CvFileNode const *.
        Python type: FileNode.

    C++ signature :
        boost::python::api::object readStringByName(CvFileStorage const*,cv::FileNode,char const* [,char const*=None])

read_KeyPoints(...)


read_KeyPoints( (FileNode)node) -> object :
    
    Wrapped function:
        read
    Argument 'keypoints':
        C/C++ type: ::std::vector< cv::KeyPoint > &.
        Python type: list.
        To convert a Mat into a list, invoke one of Mat's member functions 
        to_list_of_...().
        Output argument: omitted from the function's calling sequence, and is 
        returned along with the function's return value (if any).

    C++ signature :
        boost::python::api::object read_KeyPoints(cv::FileNode)

read_Mat(...)


read_Mat( (FileNode)node [, (Mat)default_mat=Mat()]) -> object :
    
    Wrapped function:
        read

    C++ signature :
        boost::python::api::object read_Mat(cv::FileNode [,cv::Mat=Mat()])

read_MatND(...)


read_MatND( (FileNode)node [, (MatND)default_mat=MatND(shape=(), nchannels=1, depth=0):
array(0, dtype=uint8)]) -> object :
    
    Wrapped function:
        read

    C++ signature :
        boost::python::api::object read_MatND(cv::FileNode [,cv::MatND=MatND(shape=(), nchannels=1, depth=0):
array(0, dtype=uint8)])

read_SparseMat(...)


read_SparseMat( (FileNode)node [, (SparseMat)default_mat=<pyopencv.pyopencvext.SparseMat object at 0x0184F7B0>]) -> object :
    
    Wrapped function:
        read

    C++ signature :
        boost::python::api::object read_SparseMat(cv::FileNode [,cv::SparseMat=<pyopencv.pyopencvext.SparseMat object at 0x0184F7B0>])

read_bool(...)


read_bool( (FileNode)node, (bool)default_value) -> object :
    
    Wrapped function:
        read

    C++ signature :
        boost::python::api::object read_bool(cv::FileNode,bool)

read_double(...)


read_double( (FileNode)node, (object)default_value) -> object :
    
    Wrapped function:
        read

    C++ signature :
        boost::python::api::object read_double(cv::FileNode,double)

read_float(...)


read_float( (FileNode)node, (object)default_value) -> object :
    
    Wrapped function:
        read

    C++ signature :
        boost::python::api::object read_float(cv::FileNode,float)

read_inst(...)


read_inst( (FileNode)node, (object)default_value) -> object :
    
    Wrapped function:
        read

    C++ signature :
        boost::python::api::object read_inst(cv::FileNode,int)

read_schar(...)


read_schar( (FileNode)node, (object)default_value) -> object :
    
    Wrapped function:
        read

    C++ signature :
        boost::python::api::object read_schar(cv::FileNode,signed char)

read_short(...)


read_short( (FileNode)node, (object)default_value) -> object :
    
    Wrapped function:
        read

    C++ signature :
        boost::python::api::object read_short(cv::FileNode,short)

read_str(...)


read_str( (FileNode)node, (object)default_value) -> object :
    
    Wrapped function:
        read

    C++ signature :
        boost::python::api::object read_str(cv::FileNode,std::string)

read_uchar(...)


read_uchar( (FileNode)node, (object)default_value) -> object :
    
    Wrapped function:
        read

    C++ signature :
        boost::python::api::object read_uchar(cv::FileNode,unsigned char)

read_ushort(...)


read_ushort( (FileNode)node, (object)default_value) -> object :
    
    Wrapped function:
        read

    C++ signature :
        boost::python::api::object read_ushort(cv::FileNode,unsigned short)

rectangle(...)


rectangle( (Mat)img, (Rect)rec, (Scalar)color [, (object)thickness=1 [, (object)lineType=8 [, (object)shift=0]]]) -> None :

    C++ signature :
        void rectangle(cv::Mat {lvalue},cv::Rect_<int>,cv::Scalar_<double> [,int=1 [,int=8 [,int=0]]])

rectangle( (Mat)img, (Point2i)pt1, (Point2i)pt2, (Scalar)color [, (object)thickness=1 [, (object)lineType=8 [, (object)shift=0]]]) -> None :

    C++ signature :
        void rectangle(cv::Mat {lvalue},cv::Point_<int>,cv::Point_<int>,cv::Scalar_<double> [,int=1 [,int=8 [,int=0]]])

reduce(...)


reduce( (Mat)m, (Mat)dst, (object)dim, (object)rtype [, (object)dtype=-1]) -> None :

    C++ signature :
        void reduce(cv::Mat,cv::Mat {lvalue},int,int [,int=-1])

registerModule(...)


registerModule( (CvModuleInfo)module_info) -> int :
    
    Wrapped function:
        cvRegisterModule

    C++ signature :
        int registerModule(CvModuleInfo const*)

registerType(...)


registerType( (CvTypeInfo)info) -> None :
    
    Wrapped function:
        cvRegisterType

    C++ signature :
        void registerType(CvTypeInfo const*)

remap(...)


remap( (Mat)src, (Mat)dst, (Mat)map1, (Mat)map2, (object)interpolation [, (object)borderMode=0 [, (Scalar)borderValue=Scalar([ 0.  0.  0.  0.])]]) -> None :

    C++ signature :
        void remap(cv::Mat,cv::Mat {lvalue},cv::Mat,cv::Mat,int [,int=0 [,cv::Scalar_<double>=Scalar([ 0.  0.  0.  0.])]])

repeat(...)


repeat( (Mat)src, (object)ny, (object)nx) -> Mat :

    C++ signature :
        cv::Mat repeat(cv::Mat,int,int)

repeat( (Mat)a, (object)ny, (object)nx, (Mat)b) -> None :

    C++ signature :
        void repeat(cv::Mat,int,int,cv::Mat {lvalue})

reprojectImageTo3D(...)


reprojectImageTo3D( (Mat)disparityImage, (Mat)_3dImage, (Mat)Q [, (object)handleMissingValues=0]) -> None :
    
    Wrapped function:
        cvReprojectImageTo3D
    Argument 'Q':
        C/C++ type: ::CvMat const *.
        Python type: Mat.
    Argument 'disparityImage':
        C/C++ type: ::CvArr const *.
        Python type: Mat.
    Argument '_3dImage':
        C/C++ type: ::CvArr *.
        Python type: Mat.

    C++ signature :
        void reprojectImageTo3D(cv::Mat {lvalue},cv::Mat {lvalue},cv::Mat {lvalue} [,int=0])

reprojectImageTo3D( (Mat)disparity, (Mat)_3dImage, (Mat)Q [, (bool)handleMissingValues=False]) -> None :

    C++ signature :
        void reprojectImageTo3D(cv::Mat,cv::Mat {lvalue},cv::Mat [,bool=False])

resize(...)


resize( (Mat)src, (Mat)dst, (Size2i)dsize [, (object)fx=0 [, (object)fy=0 [, (object)interpolation=1]]]) -> None :

    C++ signature :
        void resize(cv::Mat,cv::Mat {lvalue},cv::Size_<int> [,double=0 [,double=0 [,int=1]]])

resizeWindow(...)


resizeWindow( (str)name, (object)width, (object)height) -> None :
    
    Wrapped function:
        cvResizeWindow

    C++ signature :
        void resizeWindow(char const*,int,int)

restoreMemStoragePos(...)


restoreMemStoragePos( (CvMemStorage)storage, (CvMemStoragePos)pos) -> None :
    
    Wrapped function:
        cvRestoreMemStoragePos

    C++ signature :
        void restoreMemStoragePos(CvMemStorage*,CvMemStoragePos*)

round(...)


round( (object)value) -> int :
    
    Wrapped function:
        cvRound

    C++ signature :
        int round(double)

runningAvg(...)


runningAvg( (Mat)image, (Mat)acc, (object)alpha [, (Mat)mask=Mat()]) -> None :
    
    Wrapped function:
        cvRunningAvg
    Argument 'acc':
        C/C++ type: ::CvArr *.
        Python type: Mat.
    Argument 'image':
        C/C++ type: ::CvArr const *.
        Python type: Mat.
    Argument 'mask':
        C/C++ type: ::CvArr const *.
        Python type: Mat.

    C++ signature :
        void runningAvg(cv::Mat {lvalue},cv::Mat {lvalue},double [,cv::Mat=Mat()])

sampleLine(...)


sampleLine( (Mat)image, (object)pt1, (object)pt2, (object)buffer [, (object)connectivity=8]) -> object :
    
    Wrapped function:
        cvSampleLine
    Argument 'image':
        C/C++ type: ::CvArr const *.
        Python type: Mat.

    C++ signature :
        boost::python::api::object sampleLine(cv::Mat {lvalue},CvPoint,CvPoint,void* [,int=8])

saveMemStoragePos(...)


saveMemStoragePos( (CvMemStorage)storage, (CvMemStoragePos)pos) -> None :
    
    Wrapped function:
        cvSaveMemStoragePos

    C++ signature :
        void saveMemStoragePos(CvMemStorage const*,CvMemStoragePos*)

scaleAdd(...)


scaleAdd( (MatND)a, (object)alpha, (MatND)b, (MatND)c) -> None :

    C++ signature :
        void scaleAdd(cv::MatND,double,cv::MatND,cv::MatND {lvalue})

scaleAdd( (Mat)a, (object)alpha, (Mat)b, (Mat)c) -> None :

    C++ signature :
        void scaleAdd(cv::Mat,double,cv::Mat,cv::Mat {lvalue})

segmentImage(...)


segmentImage( (Mat)srcarr, (Mat)dstarr, (object)canny_threshold, (object)ffill_threshold, (CvMemStorage)storage) -> object :
    
    Wrapped function:
        cvSegmentImage
    Argument 'dstarr':
        C/C++ type: ::CvArr *.
        Python type: Mat.
    Argument 'srcarr':
        C/C++ type: ::CvArr const *.
        Python type: Mat.

    C++ signature :
        boost::python::api::object segmentImage(cv::Mat {lvalue},cv::Mat {lvalue},double,double,CvMemStorage*)

segmentMotion(...)


segmentMotion( (Mat)mhi, (Mat)seg_mask, (CvMemStorage)storage, (object)timestamp, (object)seg_thresh) -> object :
    
    Wrapped function:
        cvSegmentMotion
    Argument 'seg_mask':
        C/C++ type: ::CvArr *.
        Python type: Mat.
    Argument 'mhi':
        C/C++ type: ::CvArr const *.
        Python type: Mat.

    C++ signature :
        boost::python::api::object segmentMotion(cv::Mat {lvalue},cv::Mat {lvalue},CvMemStorage*,double,double)

sepFilter2D(...)


sepFilter2D( (Mat)src, (Mat)dst, (object)ddepth, (Mat)kernelX, (Mat)kernelY [, (Point2i)anchor=Point2i(x=-1, y=-1) [, (object)delta=0 [, (object)borderType=4]]]) -> None :

    C++ signature :
        void sepFilter2D(cv::Mat,cv::Mat {lvalue},int,cv::Mat,cv::Mat [,cv::Point_<int>=Point2i(x=-1, y=-1) [,double=0 [,int=4]]])

seqInsertSlice(...)


seqInsertSlice( (CvSeq)seq, (object)before_index, (Mat)from_arr) -> None :
    
    Wrapped function:
        cvSeqInsertSlice
    Argument 'from_arr':
        C/C++ type: ::CvArr const *.
        Python type: Mat.

    C++ signature :
        void seqInsertSlice(CvSeq*,int,cv::Mat {lvalue})

seqInvert(...)


seqInvert( (CvSeq)seq) -> None :
    
    Wrapped function:
        cvSeqInvert

    C++ signature :
        void seqInvert(CvSeq*)

seqRemove(...)


seqRemove( (CvSeq)seq, (object)index) -> None :
    
    Wrapped function:
        cvSeqRemove

    C++ signature :
        void seqRemove(CvSeq*,int)

seqRemoveSlice(...)


seqRemoveSlice( (CvSeq)seq, (Range)slice) -> None :
    
    Wrapped function:
        cvSeqRemoveSlice

    C++ signature :
        void seqRemoveSlice(CvSeq*,CvSlice)

seqSlice(...)


seqSlice( (CvSeq)seq, (Range)slice [, (CvMemStorage)storage=None [, (object)copy_data=0]]) -> CvSeq :
    
    Wrapped function:
        cvSeqSlice

    C++ signature :
        CvSeq* seqSlice(CvSeq const*,CvSlice [,CvMemStorage*=None [,int=0]])

setErrMode(...)


setErrMode( (object)mode) -> int :
    
    Wrapped function:
        cvSetErrMode

    C++ signature :
        int setErrMode(int)

setErrStatus(...)


setErrStatus( (object)status) -> None :
    
    Wrapped function:
        cvSetErrStatus

    C++ signature :
        void setErrStatus(int)

setIdentity(...)


setIdentity( (Mat)c [, (Scalar)s=Scalar([ 1.  0.  0.  0.])]) -> None :

    C++ signature :
        void setIdentity(cv::Mat {lvalue} [,cv::Scalar_<double>=Scalar([ 1.  0.  0.  0.])])

setNumThreads(...)


setNumThreads([  (object)threads=0]) -> None :
    
    Wrapped function:
        cvSetNumThreads

    C++ signature :
        void setNumThreads([ int=0])

setNumThreads( (object)arg0) -> None :

    C++ signature :
        void setNumThreads(int)

setRemove(...)


setRemove( (CvSet)set_header, (object)index) -> None :
    
    Wrapped function:
        cvSetRemove

    C++ signature :
        void setRemove(CvSet*,int)

setSeqBlockSize(...)


setSeqBlockSize( (CvSeq)seq, (object)delta_elems) -> None :
    
    Wrapped function:
        cvSetSeqBlockSize

    C++ signature :
        void setSeqBlockSize(CvSeq*,int)

setSeqReaderPos(...)


setSeqReaderPos( (CvSeqReader)reader, (object)index [, (object)is_relative=0]) -> None :
    
    Wrapped function:
        cvSetSeqReaderPos

    C++ signature :
        void setSeqReaderPos(CvSeqReader*,int [,int=0])

setTrackbarPos(...)


setTrackbarPos( (str)trackbar_name, (str)window_name, (object)pos) -> None :
    
    Wrapped function:
        cvSetTrackbarPos

    C++ signature :
        void setTrackbarPos(char const*,char const*,int)

setUseOptimized(...)


setUseOptimized( (bool)arg0) -> None :

    C++ signature :
        void setUseOptimized(bool)

setWindowProperty(...)


setWindowProperty( (object)winname, (object)prop_id, (object)prop_value) -> None :

    C++ signature :
        void setWindowProperty(std::string,int,double)

sliceLength(...)


sliceLength( (Range)slice, (CvSeq)seq) -> int :
    
    Wrapped function:
        cvSliceLength

    C++ signature :
        int sliceLength(CvSlice,CvSeq const*)

smooth(...)


smooth( (Mat)src, (Mat)dst [, (object)smoothtype=2 [, (object)size1=3 [, (object)size2=0 [, (object)sigma1=0 [, (object)sigma2=0]]]]]) -> None :
    
    Wrapped function:
        cvSmooth
    Argument 'src':
        C/C++ type: ::CvArr const *.
        Python type: Mat.
    Argument 'dst':
        C/C++ type: ::CvArr *.
        Python type: Mat.

    C++ signature :
        void smooth(cv::Mat {lvalue},cv::Mat {lvalue} [,int=2 [,int=3 [,int=0 [,double=0 [,double=0]]]]])

snakeImage(...)


snakeImage( (Mat)image, (Mat)points, (object)alpha, (object)beta, (object)gamma, (object)coeff_usage, (Size2i)win, (TermCriteria)criteria [, (object)calc_gradient=1]) -> None :

    C++ signature :
        void snakeImage(cv::Mat,cv::Mat,boost::python::api::object,boost::python::api::object,boost::python::api::object,int,cv::Size_<int>,cv::TermCriteria [,int=1])

solve(...)


solve( (Mat)a, (Mat)b, (Mat)x [, (object)flags=0]) -> bool :

    C++ signature :
        bool solve(cv::Mat,cv::Mat,cv::Mat {lvalue} [,int=0])

solveCubic(...)


solveCubic( (Mat)coeffs, (Mat)roots) -> object :
    
    Wrapped function:
        cvSolveCubic
    Argument 'coeffs':
        C/C++ type: ::CvMat const *.
        Python type: Mat.
    Argument 'roots':
        C/C++ type: ::CvMat *.
        Python type: Mat.

    C++ signature :
        boost::python::api::object solveCubic(cv::Mat {lvalue},cv::Mat {lvalue})

solvePnP(...)


solvePnP( (Mat)objectPoints, (Mat)imagePoints, (Mat)cameraMatrix, (Mat)distCoeffs, (Mat)rvec, (Mat)tvec [, (bool)useExtrinsicGuess=False]) -> None :

    C++ signature :
        void solvePnP(cv::Mat,cv::Mat,cv::Mat,cv::Mat,cv::Mat {lvalue},cv::Mat {lvalue} [,bool=False])

solvePoly(...)


solvePoly( (Mat)coeffs, (Mat)roots2 [, (object)maxiter=20 [, (object)fig=100]]) -> None :
    
    Wrapped function:
        cvSolvePoly
    Argument 'coeffs':
        C/C++ type: ::CvMat const *.
        Python type: Mat.
    Argument 'roots2':
        C/C++ type: ::CvMat *.
        Python type: Mat.

    C++ signature :
        void solvePoly(cv::Mat {lvalue},cv::Mat {lvalue} [,int=20 [,int=100]])

sort(...)


sort( (Mat)a, (Mat)b, (object)flags) -> None :

    C++ signature :
        void sort(cv::Mat,cv::Mat {lvalue},int)

sortIdx(...)


sortIdx( (Mat)a, (Mat)b, (object)flags) -> None :

    C++ signature :
        void sortIdx(cv::Mat,cv::Mat {lvalue},int)

split(...)


split( (MatND)m, (list)mv) -> None :
    
    Argument 'mv':
        C/C++ type: ::cv::MatND *.
        Python type: list of Mat, e.g. [Mat(), Mat(), Mat()].

    C++ signature :
        void split(cv::MatND,boost::python::list)

split( (Mat)m, (list)mvbegin) -> None :
    
    Argument 'mvbegin':
        C/C++ type: ::cv::Mat *.
        Python type: list of Mat, e.g. [Mat(), Mat(), Mat()].

    C++ signature :
        void split(cv::Mat,boost::python::list)

sqrt(...)


sqrt( (MatND)a, (MatND)b) -> None :

    C++ signature :
        void sqrt(cv::MatND,cv::MatND {lvalue})

sqrt( (Mat)a, (Mat)b) -> None :

    C++ signature :
        void sqrt(cv::Mat,cv::Mat {lvalue})

squareAcc(...)


squareAcc( (Mat)image, (Mat)sqsum [, (Mat)mask=Mat()]) -> None :
    
    Wrapped function:
        cvSquareAcc
    Argument 'mask':
        C/C++ type: ::CvArr const *.
        Python type: Mat.
    Argument 'image':
        C/C++ type: ::CvArr const *.
        Python type: Mat.
    Argument 'sqsum':
        C/C++ type: ::CvArr *.
        Python type: Mat.

    C++ signature :
        void squareAcc(cv::Mat {lvalue},cv::Mat {lvalue} [,cv::Mat=Mat()])

starKeypoint(...)


starKeypoint( (object)pt, (object)size, (object)response) -> CvStarKeypoint :
    
    Wrapped function:
        cvStarKeypoint

    C++ signature :
        CvStarKeypoint starKeypoint(CvPoint,int,float)

startAppendToSeq(...)


startAppendToSeq( (CvSeq)seq, (CvSeqWriter)writer) -> None :
    
    Wrapped function:
        cvStartAppendToSeq

    C++ signature :
        void startAppendToSeq(CvSeq*,CvSeqWriter*)

startFindContours(...)


startFindContours( (Mat)image, (CvMemStorage)storage [, (object)header_size=88 [, (object)mode=1 [, (object)method=2 [, (object)offset=Point2i(x=0, y=0)]]]]) -> object :
    
    Wrapped function:
        cvStartFindContours
    Argument 'image':
        C/C++ type: ::CvArr *.
        Python type: Mat.

    C++ signature :
        boost::python::api::object startFindContours(cv::Mat {lvalue},CvMemStorage* [,int=88 [,int=1 [,int=2 [,CvPoint=Point2i(x=0, y=0)]]]])

startNextStream(...)


startNextStream( (FileStorage)fs) -> None :
    
    Wrapped function:
        cvStartNextStream
    Argument 'fs':
        C/C++ type: ::CvFileStorage *.
        Python type: FileStorage.

    C++ signature :
        void startNextStream(cv::FileStorage {lvalue})

startReadChainPoints(...)


startReadChainPoints( (CvChain)chain, (CvChainPtReader)reader) -> None :
    
    Wrapped function:
        cvStartReadChainPoints

    C++ signature :
        void startReadChainPoints(CvChain*,CvChainPtReader*)

startReadRawData(...)


startReadRawData( (CvFileStorage)fs, (FileNode)src, (CvSeqReader)reader) -> None :
    
    Wrapped function:
        cvStartReadRawData
    Argument 'src':
        C/C++ type: ::CvFileNode const *.
        Python type: FileNode.

    C++ signature :
        void startReadRawData(CvFileStorage const*,cv::FileNode,CvSeqReader*)

startReadSeq(...)


startReadSeq( (CvSeq)seq, (CvSeqReader)reader [, (object)reverse=0]) -> None :
    
    Wrapped function:
        cvStartReadSeq

    C++ signature :
        void startReadSeq(CvSeq const*,CvSeqReader* [,int=0])

startWindowThread()

    Wrapped function:
        cvStartWindowThread

    C++ signature :
        int startWindowThread()

Returns: int :

startWriteSeq(...)


startWriteSeq( (object)seq_flags, (object)header_size, (object)elem_size, (CvMemStorage)storage, (CvSeqWriter)writer) -> None :
    
    Wrapped function:
        cvStartWriteSeq

    C++ signature :
        void startWriteSeq(int,int,int,CvMemStorage*,CvSeqWriter*)

startWriteStruct(...)


startWriteStruct( (FileStorage)fs, (str)name, (object)struct_flags [, (str)type_name=None [, (CvAttrList)attributes=<pyopencv.pyopencvext.CvAttrList object at 0x0184F5B0>]]) -> None :
    
    Wrapped function:
        cvStartWriteStruct
    Argument 'fs':
        C/C++ type: ::CvFileStorage *.
        Python type: FileStorage.

    C++ signature :
        void startWriteStruct(cv::FileStorage {lvalue},char const*,int [,char const*=None [,CvAttrList=<pyopencv.pyopencvext.CvAttrList object at 0x0184F5B0>]])

stereoCalibrate(...)


stereoCalibrate( (list)objectPoints, (list)imagePoints1, (list)imagePoints2, (Mat)cameraMatrix1, (Mat)distCoeffs1, (Mat)cameraMatrix2, (Mat)distCoeffs2, (Size2i)imageSize, (Mat)R, (Mat)T, (Mat)E, (Mat)F [, (TermCriteria)criteria=TermCriteria(type=3, maxCount=30, epsilon=9.9999999999999995e-07) [, (object)flags=256]]) -> object :
    
    Argument 'objectPoints':
        C/C++ type: ::std::vector< std::vector< cv::Point3_<float> > > const 
        &.
        Python type: list of Mat, e.g. [Mat(), Mat(), Mat()].
        Invoke asMat() to convert every 1D Python sequence into a Mat, e.g. 
        [asMat([0,1,2]), asMat((0,1,2)].
    Argument 'imagePoints2':
        C/C++ type: ::std::vector< std::vector< cv::Point_<float> > > const &.
        Python type: list of Mat, e.g. [Mat(), Mat(), Mat()].
        Invoke asMat() to convert every 1D Python sequence into a Mat, e.g. 
        [asMat([0,1,2]), asMat((0,1,2)].
    Argument 'imagePoints1':
        C/C++ type: ::std::vector< std::vector< cv::Point_<float> > > const &.
        Python type: list of Mat, e.g. [Mat(), Mat(), Mat()].
        Invoke asMat() to convert every 1D Python sequence into a Mat, e.g. 
        [asMat([0,1,2]), asMat((0,1,2)].

    C++ signature :
        boost::python::api::object stereoCalibrate(boost::python::list,boost::python::list,boost::python::list,cv::Mat {lvalue},cv::Mat {lvalue},cv::Mat {lvalue},cv::Mat {lvalue},cv::Size_<int>,cv::Mat {lvalue},cv::Mat {lvalue},cv::Mat {lvalue},cv::Mat {lvalue} [,cv::TermCriteria=TermCriteria(type=3, maxCount=30, epsilon=9.9999999999999995e-07) [,int=256]])

stereoRectifyUncalibrated(...)


stereoRectifyUncalibrated( (Mat)points1, (Mat)points2, (Mat)F, (Size2i)imgSize, (Mat)H1, (Mat)H2 [, (object)threshold=5]) -> bool :

    C++ signature :
        bool stereoRectifyUncalibrated(cv::Mat,cv::Mat,cv::Mat,cv::Size_<int>,cv::Mat {lvalue},cv::Mat {lvalue} [,double=5])

subdiv2DEdgeDst(...)


subdiv2DEdgeDst( (object)edge) -> CvSubdiv2DPoint :
    
    Wrapped function:
        cvSubdiv2DEdgeDst

    C++ signature :
        CvSubdiv2DPoint* subdiv2DEdgeDst(unsigned int)

subdiv2DEdgeOrg(...)


subdiv2DEdgeOrg( (object)edge) -> CvSubdiv2DPoint :
    
    Wrapped function:
        cvSubdiv2DEdgeOrg

    C++ signature :
        CvSubdiv2DPoint* subdiv2DEdgeOrg(unsigned int)

subdiv2DGetEdge(...)


subdiv2DGetEdge( (object)edge, (CvNextEdgeType)type) -> int :
    
    Wrapped function:
        cvSubdiv2DGetEdge

    C++ signature :
        unsigned int subdiv2DGetEdge(unsigned int,CvNextEdgeType)

subdiv2DLocate(...)


subdiv2DLocate( (CvSubdiv2D)subdiv, (Point2f)pt, (object)edge) -> tuple :
    
    Wrapped function:
        cvSubdiv2DLocate
    Argument 'vertex':
        C/C++ type: ::CvSubdiv2DPoint * *.
        Python type: Python equivalence of the C/C++ type without pointer.
        Output argument: omitted from the function's calling sequence, and is 
        returned along with the function's return value (if any).
    Argument 'pt':
        C/C++ type: ::CvPoint2D32f.
        Python type: Point2f.

    C++ signature :
        boost::python::tuple subdiv2DLocate(CvSubdiv2D*,cv::Point_<float>,unsigned int*)

subdiv2DNextEdge(...)


subdiv2DNextEdge( (object)edge) -> int :
    
    Wrapped function:
        cvSubdiv2DNextEdge

    C++ signature :
        unsigned int subdiv2DNextEdge(unsigned int)

subdiv2DRotateEdge(...)


subdiv2DRotateEdge( (object)edge, (object)rotate) -> int :
    
    Wrapped function:
        cvSubdiv2DRotateEdge

    C++ signature :
        unsigned int subdiv2DRotateEdge(unsigned int,int)

subdiv2DSymEdge(...)


subdiv2DSymEdge( (object)edge) -> int :
    
    Wrapped function:
        cvSubdiv2DSymEdge

    C++ signature :
        unsigned int subdiv2DSymEdge(unsigned int)

subdivDelaunay2DInsert(...)


subdivDelaunay2DInsert( (CvSubdiv2D)subdiv, (Point2f)pt) -> object :
    
    Wrapped function:
        cvSubdivDelaunay2DInsert
    Argument 'pt':
        C/C++ type: ::CvPoint2D32f.
        Python type: Point2f.

    C++ signature :
        boost::python::api::object subdivDelaunay2DInsert(CvSubdiv2D*,cv::Point_<float>)

substituteContour(...)


substituteContour( (CvContourScanner)scanner, (CvSeq)new_contour) -> None :
    
    Wrapped function:
        cvSubstituteContour

    C++ signature :
        void substituteContour(_CvContourScanner*,CvSeq*)

subtract(...)


subtract( (MatND)a, (Scalar)s, (MatND)c [, (MatND)mask=MatND(shape=(), nchannels=1, depth=0):
array(0, dtype=uint8)]) -> None :

    C++ signature :
        void subtract(cv::MatND,cv::Scalar_<double>,cv::MatND {lvalue} [,cv::MatND=MatND(shape=(), nchannels=1, depth=0):
array(0, dtype=uint8)])

subtract( (Scalar)s, (MatND)a, (MatND)c [, (MatND)mask=MatND(shape=(), nchannels=1, depth=0):
array(0, dtype=uint8)]) -> None :

    C++ signature :
        void subtract(cv::Scalar_<double>,cv::MatND,cv::MatND {lvalue} [,cv::MatND=MatND(shape=(), nchannels=1, depth=0):
array(0, dtype=uint8)])

subtract( (MatND)a, (MatND)b, (MatND)c) -> None :

    C++ signature :
        void subtract(cv::MatND,cv::MatND,cv::MatND {lvalue})

subtract( (MatND)a, (MatND)b, (MatND)c, (MatND)mask) -> None :

    C++ signature :
        void subtract(cv::MatND,cv::MatND,cv::MatND {lvalue},cv::MatND)

subtract( (Scalar)s, (Mat)a, (Mat)c [, (Mat)mask=Mat()]) -> None :

    C++ signature :
        void subtract(cv::Scalar_<double>,cv::Mat,cv::Mat {lvalue} [,cv::Mat=Mat()])

subtract( (Mat)a, (Scalar)s, (Mat)c [, (Mat)mask=Mat()]) -> None :

    C++ signature :
        void subtract(cv::Mat,cv::Scalar_<double>,cv::Mat {lvalue} [,cv::Mat=Mat()])

subtract( (Mat)a, (Mat)b, (Mat)c) -> None :

    C++ signature :
        void subtract(cv::Mat,cv::Mat,cv::Mat {lvalue})

subtract( (Mat)a, (Mat)b, (Mat)c, (Mat)mask) -> None :

    C++ signature :
        void subtract(cv::Mat,cv::Mat,cv::Mat {lvalue},cv::Mat)

sum(...)


sum( (MatND)m) -> Scalar :

    C++ signature :
        cv::Scalar_<double> sum(cv::MatND)

sum( (Mat)m) -> Scalar :

    C++ signature :
        cv::Scalar_<double> sum(cv::Mat)

theRNG()

    C++ signature :
        cv::RNG {lvalue} theRNG()

Returns: RNG :

threshold(...)


threshold( (Mat)src, (Mat)dst, (object)thresh, (object)maxval, (object)type) -> float :

    C++ signature :
        double threshold(cv::Mat,cv::Mat {lvalue},double,double,int)

toUtf16(...)


toUtf16( (object)str) -> unicode :

    C++ signature :
        std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t> > toUtf16(std::string)

trace(...)


trace( (Mat)m) -> Scalar :

    C++ signature :
        cv::Scalar_<double> trace(cv::Mat)

transform(...)


transform( (Mat)src, (Mat)dst, (Mat)m) -> None :

    C++ signature :
        void transform(cv::Mat,cv::Mat {lvalue},cv::Mat)

transpose(...)


transpose( (Mat)a, (Mat)b) -> None :

    C++ signature :
        void transpose(cv::Mat,cv::Mat {lvalue})

triangleArea(...)


triangleArea( (Point2f)a, (Point2f)b, (Point2f)c) -> object :
    
    Wrapped function:
        cvTriangleArea
    Argument 'a':
        C/C++ type: ::CvPoint2D32f.
        Python type: Point2f.
    Argument 'c':
        C/C++ type: ::CvPoint2D32f.
        Python type: Point2f.
    Argument 'b':
        C/C++ type: ::CvPoint2D32f.
        Python type: Point2f.

    C++ signature :
        boost::python::api::object triangleArea(cv::Point_<float>,cv::Point_<float>,cv::Point_<float>)

triangulatePoints(...)


triangulatePoints( (Mat)projMatr1, (Mat)projMatr2, (Mat)projPoints1, (Mat)projPoints2, (Mat)points4D) -> None :
    
    Wrapped function:
        cvTriangulatePoints
    Argument 'projPoints2':
        C/C++ type: ::CvMat *.
        Python type: Mat.
    Argument 'projPoints1':
        C/C++ type: ::CvMat *.
        Python type: Mat.
    Argument 'projMatr2':
        C/C++ type: ::CvMat *.
        Python type: Mat.
    Argument 'points4D':
        C/C++ type: ::CvMat *.
        Python type: Mat.
    Argument 'projMatr1':
        C/C++ type: ::CvMat *.
        Python type: Mat.

    C++ signature :
        void triangulatePoints(cv::Mat {lvalue},cv::Mat {lvalue},cv::Mat {lvalue},cv::Mat {lvalue},cv::Mat {lvalue})

typeOf(...)


typeOf( (object)struct_ptr) -> object :
    
    Wrapped function:
        cvTypeOf

    C++ signature :
        boost::python::api::object typeOf(void*)

undistort(...)


undistort( (Mat)src, (Mat)dst, (Mat)cameraMatrix, (Mat)distCoeffs [, (Mat)newCameraMatrix=Mat()]) -> None :

    C++ signature :
        void undistort(cv::Mat,cv::Mat {lvalue},cv::Mat,cv::Mat [,cv::Mat=Mat()])

undistortPoints(...)


undistortPoints( (Mat)src, (Mat)dst, (Mat)cameraMatrix, (Mat)distCoeffs [, (Mat)R=Mat() [, (Mat)P=Mat()]]) -> None :

    C++ signature :
        void undistortPoints(cv::Mat,cv::Mat {lvalue},cv::Mat,cv::Mat [,cv::Mat=Mat() [,cv::Mat=Mat()]])

undistortPoints2(...)


undistortPoints2( (Mat)src, (Mat)cameraMatrix, (Mat)distCoeffs [, (Mat)R=Mat() [, (Mat)P=Mat()]]) -> object :
    
    Wrapped function:
        undistortPoints
    Argument 'dst':
        C/C++ type: ::std::vector< cv::Point_<float> > &.
        Python type: Mat.
        Invoke asMat() to convert a 1D Python sequence into a Mat, e.g. 
        asMat([0,1,2]) or asMat((0,1,2)).
        Output argument: omitted from the function's calling sequence, and is 
        returned along with the function's return value (if any).

    C++ signature :
        boost::python::api::object undistortPoints2(cv::Mat,cv::Mat,cv::Mat [,cv::Mat=Mat() [,cv::Mat=Mat()]])

unregisterType(...)


unregisterType( (str)type_name) -> None :
    
    Wrapped function:
        cvUnregisterType

    C++ signature :
        void unregisterType(char const*)

updateMotionHistory(...)


updateMotionHistory( (Mat)silhouette, (Mat)mhi, (object)timestamp, (object)duration) -> None :
    
    Wrapped function:
        cvUpdateMotionHistory
    Argument 'silhouette':
        C/C++ type: ::CvArr const *.
        Python type: Mat.
    Argument 'mhi':
        C/C++ type: ::CvArr *.
        Python type: Mat.

    C++ signature :
        void updateMotionHistory(cv::Mat {lvalue},cv::Mat {lvalue},double,double)

updateMotionHistory( (Mat)silhouette, (Mat)mhi, (object)timestamp, (object)duration) -> None :

    C++ signature :
        void updateMotionHistory(cv::Mat,cv::Mat {lvalue},double,double)

useOptimized(...)


useOptimized( (object)on_off) -> int :
    
    Wrapped function:
        cvUseOptimized

    C++ signature :
        int useOptimized(int)

useOptimized() -> bool :

    C++ signature :
        bool useOptimized()

validateDisparity(...)


validateDisparity( (Mat)disparity, (Mat)cost, (object)minDisparity, (object)numberOfDisparities [, (object)disp12MaxDisp=1]) -> None :

    C++ signature :
        void validateDisparity(cv::Mat {lvalue},cv::Mat,int,int [,int=1])

waitKey(...)


waitKey([  (object)delay=0]) -> int :

    C++ signature :
        int waitKey([ int=0])

warpAffine(...)


warpAffine( (Mat)src, (Mat)dst, (Mat)M, (Size2i)dsize [, (object)flags=1 [, (object)borderMode=0 [, (Scalar)borderValue=Scalar([ 0.  0.  0.  0.])]]]) -> None :

    C++ signature :
        void warpAffine(cv::Mat,cv::Mat {lvalue},cv::Mat,cv::Size_<int> [,int=1 [,int=0 [,cv::Scalar_<double>=Scalar([ 0.  0.  0.  0.])]]])

warpPerspective(...)


warpPerspective( (Mat)src, (Mat)dst, (Mat)M, (Size2i)dsize [, (object)flags=1 [, (object)borderMode=0 [, (Scalar)borderValue=Scalar([ 0.  0.  0.  0.])]]]) -> None :

    C++ signature :
        void warpPerspective(cv::Mat,cv::Mat {lvalue},cv::Mat,cv::Size_<int> [,int=1 [,int=0 [,cv::Scalar_<double>=Scalar([ 0.  0.  0.  0.])]]])

watershed(...)


watershed( (Mat)image, (Mat)markers) -> None :

    C++ signature :
        void watershed(cv::Mat,cv::Mat {lvalue})

write(...)


write( (FileStorage)fs, (str)name, (str)ptr [, (CvAttrList)attributes=<pyopencv.pyopencvext.CvAttrList object at 0x0184F5F0>]) -> None :
    
    Wrapped function:
        cvWrite
    Argument 'fs':
        C/C++ type: ::CvFileStorage *.
        Python type: FileStorage.
    Argument 'ptr':
        C/C++ type: void const *.
        Python type: string.

    C++ signature :
        void write(cv::FileStorage {lvalue},char const*,char const* [,CvAttrList=<pyopencv.pyopencvext.CvAttrList object at 0x0184F5F0>])

write( (FileStorage)fs, (object)name, (list)keypoints) -> None :
    
    Argument 'keypoints':
        C/C++ type: ::std::vector< cv::KeyPoint > const &.
        Python type: list.
        To convert a Mat into a list, invoke one of Mat's member functions 
        to_list_of_...().

    C++ signature :
        void write(cv::FileStorage {lvalue},std::string,boost::python::list)

write( (FileStorage)fs, (object)name, (SparseMat)value) -> None :

    C++ signature :
        void write(cv::FileStorage {lvalue},std::string,cv::SparseMat)

write( (FileStorage)fs, (object)name, (MatND)value) -> None :

    C++ signature :
        void write(cv::FileStorage {lvalue},std::string,cv::MatND)

write( (FileStorage)fs, (object)name, (Mat)value) -> None :

    C++ signature :
        void write(cv::FileStorage {lvalue},std::string,cv::Mat)

write( (FileStorage)fs, (object)name, (Range)r) -> None :

    C++ signature :
        void write(cv::FileStorage {lvalue},std::string,cv::Range)

write( (FileStorage)fs, (Range)r) -> None :

    C++ signature :
        void write(cv::FileStorage {lvalue},cv::Range)

write( (FileStorage)fs, (object)value) -> None :

    C++ signature :
        void write(cv::FileStorage {lvalue},int)

write( (FileStorage)fs, (object)value) -> None :

    C++ signature :
        void write(cv::FileStorage {lvalue},std::string)

write( (FileStorage)fs, (object)value) -> None :

    C++ signature :
        void write(cv::FileStorage {lvalue},double)

write( (FileStorage)fs, (object)value) -> None :

    C++ signature :
        void write(cv::FileStorage {lvalue},float)

write( (FileStorage)fs, (object)name, (object)value) -> None :

    C++ signature :
        void write(cv::FileStorage {lvalue},std::string,std::string)

write( (FileStorage)fs, (object)name, (object)value) -> None :

    C++ signature :
        void write(cv::FileStorage {lvalue},std::string,double)

write( (FileStorage)fs, (object)name, (object)value) -> None :

    C++ signature :
        void write(cv::FileStorage {lvalue},std::string,float)

write( (FileStorage)fs, (object)name, (object)value) -> None :

    C++ signature :
        void write(cv::FileStorage {lvalue},std::string,int)

writeComment(...)


writeComment( (FileStorage)fs, (str)comment, (object)eol_comment) -> None :
    
    Wrapped function:
        cvWriteComment
    Argument 'fs':
        C/C++ type: ::CvFileStorage *.
        Python type: FileStorage.

    C++ signature :
        void writeComment(cv::FileStorage {lvalue},char const*,int)

writeFileNode(...)


writeFileNode( (FileStorage)fs, (str)new_node_name, (FileNode)node, (object)embed) -> None :
    
    Wrapped function:
        cvWriteFileNode
    Argument 'node':
        C/C++ type: ::CvFileNode const *.
        Python type: FileNode.
    Argument 'fs':
        C/C++ type: ::CvFileStorage *.
        Python type: FileStorage.

    C++ signature :
        void writeFileNode(cv::FileStorage {lvalue},char const*,cv::FileNode,int)

writeInt(...)


writeInt( (FileStorage)fs, (str)name, (object)value) -> None :
    
    Wrapped function:
        cvWriteInt
    Argument 'fs':
        C/C++ type: ::CvFileStorage *.
        Python type: FileStorage.

    C++ signature :
        void writeInt(cv::FileStorage {lvalue},char const*,int)

writeReal(...)


writeReal( (FileStorage)fs, (str)name, (object)value) -> None :
    
    Wrapped function:
        cvWriteReal
    Argument 'fs':
        C/C++ type: ::CvFileStorage *.
        Python type: FileStorage.

    C++ signature :
        void writeReal(cv::FileStorage {lvalue},char const*,double)

writeString(...)


writeString( (FileStorage)fs, (str)name, (str)str [, (object)quote=0]) -> None :
    
    Wrapped function:
        cvWriteString
    Argument 'fs':
        C/C++ type: ::CvFileStorage *.
        Python type: FileStorage.

    C++ signature :
        void writeString(cv::FileStorage {lvalue},char const*,char const* [,int=0])

Variables Details

[hide private]

CENTERS_GONZALES

Value:

pyopencv.pyopencvext.flann_centers_init_t.CENTERS_GONZALES

CENTERS_KMEANSPP

Value:

pyopencv.pyopencvext.flann_centers_init_t.CENTERS_KMEANSPP

CENTERS_RANDOM

Value:

pyopencv.pyopencvext.flann_centers_init_t.CENTERS_RANDOM

CV_BADCHANNELS_ERR

Value:

pyopencv.pyopencvext.CvStatus.CV_BADCHANNELS_ERR

CV_BADCONVERGENCE_ERR

Value:

pyopencv.pyopencvext.CvStatus.CV_BADCONVERGENCE_ERR

CV_BADMEMBLOCK_ERR

Value:

pyopencv.pyopencvext.CvStatus.CV_BADMEMBLOCK_ERR

CV_CALIB_ETALON_CHECKERBOARD

Value:

pyopencv.pyopencvext.CvCalibEtalonType.CV_CALIB_ETALON_CHECKERBOARD

CV_CALIB_ETALON_CHESSBOARD

Value:

pyopencv.pyopencvext.CvCalibEtalonType.CV_CALIB_ETALON_CHESSBOARD

CV_CALIB_ETALON_USER

Value:

pyopencv.pyopencvext.CvCalibEtalonType.CV_CALIB_ETALON_USER

CV_DIV_BY_ZERO_ERR

Value:

pyopencv.pyopencvext.CvStatus.CV_DIV_BY_ZERO_ERR

CV_FACE_LEFT_EYE

Value:

pyopencv.pyopencvext.CV_FACE_ELEMENTS.CV_FACE_LEFT_EYE

CV_FACE_MOUTH

Value:

pyopencv.pyopencvext.CV_FACE_ELEMENTS.CV_FACE_MOUTH

CV_FACE_RIGHT_EYE

Value:

pyopencv.pyopencvext.CV_FACE_ELEMENTS.CV_FACE_RIGHT_EYE

CV_INPLACE_NOT_SUPPORTED_ERR

Value:

pyopencv.pyopencvext.CvStatus.CV_INPLACE_NOT_SUPPORTED_ERR

CV_LEE_DOUBLE

Value:

pyopencv.pyopencvext.CvLeeParameters.CV_LEE_DOUBLE

CV_NEXT_AROUND_DST

Value:

pyopencv.pyopencvext.CvNextEdgeType.CV_NEXT_AROUND_DST

CV_NEXT_AROUND_LEFT

Value:

pyopencv.pyopencvext.CvNextEdgeType.CV_NEXT_AROUND_LEFT

CV_NEXT_AROUND_ORG

Value:

pyopencv.pyopencvext.CvNextEdgeType.CV_NEXT_AROUND_ORG

CV_NEXT_AROUND_RIGHT

Value:

pyopencv.pyopencvext.CvNextEdgeType.CV_NEXT_AROUND_RIGHT

CV_NOTDEFINED_ERR

Value:

pyopencv.pyopencvext.CvStatus.CV_NOTDEFINED_ERR

CV_NOT_WEIGHTED

Value:

pyopencv.pyopencvext.CvGraphWeightType.CV_NOT_WEIGHTED

CV_PREV_AROUND_DST

Value:

pyopencv.pyopencvext.CvNextEdgeType.CV_PREV_AROUND_DST

CV_PREV_AROUND_LEFT

Value:

pyopencv.pyopencvext.CvNextEdgeType.CV_PREV_AROUND_LEFT

CV_PREV_AROUND_ORG

Value:

pyopencv.pyopencvext.CvNextEdgeType.CV_PREV_AROUND_ORG

CV_PREV_AROUND_RIGHT

Value:

pyopencv.pyopencvext.CvNextEdgeType.CV_PREV_AROUND_RIGHT

CV_PTLOC_ERROR

Value:

pyopencv.pyopencvext.CvSubdiv2DPointLocation.CV_PTLOC_ERROR

CV_PTLOC_INSIDE

Value:

pyopencv.pyopencvext.CvSubdiv2DPointLocation.CV_PTLOC_INSIDE

CV_PTLOC_ON_EDGE

Value:

pyopencv.pyopencvext.CvSubdiv2DPointLocation.CV_PTLOC_ON_EDGE

CV_PTLOC_OUTSIDE_RECT

Value:

pyopencv.pyopencvext.CvSubdiv2DPointLocation.CV_PTLOC_OUTSIDE_RECT

CV_PTLOC_VERTEX

Value:

pyopencv.pyopencvext.CvSubdiv2DPointLocation.CV_PTLOC_VERTEX

CV_UNMATCHED_FORMATS_ERR

Value:

pyopencv.pyopencvext.CvStatus.CV_UNMATCHED_FORMATS_ERR

CV_UNMATCHED_ROI_ERR

Value:

pyopencv.pyopencvext.CvStatus.CV_UNMATCHED_ROI_ERR

CV_UNSUPPORTED_CHANNELS_ERR

Value:

pyopencv.pyopencvext.CvStatus.CV_UNSUPPORTED_CHANNELS_ERR

CV_UNSUPPORTED_COI_ERR

Value:

pyopencv.pyopencvext.CvStatus.CV_UNSUPPORTED_COI_ERR

CV_UNSUPPORTED_DEPTH_ERR

Value:

pyopencv.pyopencvext.CvStatus.CV_UNSUPPORTED_DEPTH_ERR

CV_UNSUPPORTED_FORMAT_ERR

Value:

pyopencv.pyopencvext.CvStatus.CV_UNSUPPORTED_FORMAT_ERR

CV_WEIGHTED_ALL

Value:

pyopencv.pyopencvext.CvGraphWeightType.CV_WEIGHTED_ALL

CV_WEIGHTED_EDGE

Value:

pyopencv.pyopencvext.CvGraphWeightType.CV_WEIGHTED_EDGE

CV_WEIGHTED_VTX

Value:

pyopencv.pyopencvext.CvGraphWeightType.CV_WEIGHTED_VTX

loader

Value:

<zipimporter object "M:\programming\builders\Python26\lib\site-package
s\pyopencv-2.1.0.wr1.0.0.dev_r711-py2.6-win32.egg">