vs python opencv_Python中OpenCV2. VS. CV1

OpenCV的2.4.7.版本生成了python的CV2模块，可以直接载入；

Tips1： 关于两种载入方法的区别：

import numpy as np

import cv2 as cv2

Vs.

import cv2.cv as cv

(一)：引入CV2使用：

第一种方法的cv函数使用方法几乎等同于matlab，其中可以使用的函数范围也较少；

例如：利用help(cv2)命令；

查看函数列表如下：

ANN_MLP([layerSizes[, activateFunc[, fparam1[, fparam2]]]]) ->

Algorithm__create(name) -> retval

Algorithm_getList() -> algorithms

BFMatcher([, normType[, crossCheck]]) ->

BRISK([, thresh[, octaves[, patternScale]]]) -> or BRISK(radiusList, numberList[, dMax[, dMin[, indexChange]]]) ->

BackgroundSubtractorMOG([history, nmixtures, backgroundRatio[, noiseSigma]]) ->

Boost([trainData, tflag, responses[, varIdx[, sampleIdx[, varType[, missingDataMask[, params]]]]]]) ->

CamShift(probImage, window, criteria) -> retval, window

Canny(image, threshold1, threshold2[, edges[, apertureSize[, L2gradient]]]) -> edges

CascadeClassifier([filename]) ->

DMatch() -> or DMatch(_queryIdx, _trainIdx, _distance) -> or DMatch(_queryIdx, _trainIdx, _imgIdx, _distance) ->

DTree() ->

DescriptorExtractor_create(descriptorExtractorType) -> retval

DescriptorMatcher_create(descriptorMatcherType) -> retval

EM([, nclusters[, covMatType[, termCrit]]]) ->

ERTrees() ->

FastFeatureDetector([, threshold[, nonmaxSuppression]]) ->

Feature2D_create(name) -> retval

FeatureDetector_create(detectorType) -> retval

FileNode() ->

FileStorage([source, flags[, encoding]]) ->

FlannBasedMatcher([, indexParams[, searchParams]]) ->

GBTrees([trainData, tflag, responses[, varIdx[, sampleIdx[, varType[, missingDataMask[, params]]]]]]) ->

GFTTDetector([, maxCorners[, qualityLevel[, minDistance[, blockSize[, useHarrisDetector[, k]]]]]]) ->

GaussianBlur(src, ksize, sigmaX[, dst[, sigmaY[, borderType]]]) -> dst

GridAdaptedFeatureDetector([, detector[, maxTotalKeypoints[, gridRows[, gridCols]]]]) ->

HOGDescriptor() -> or HOGDescriptor(_winSize, _blockSize, _blockStride, _cellSize, _nbins[, _derivAperture[, _winSigma[, _histogramNormType[, _L2HysThreshold[, _gammaCorrection[, _nlevels]]]]]]) -> or HOGDescriptor(filename) ->

HOGDescriptor_getDaimlerPeopleDetector() -> retval

HOGDescriptor_getDefaultPeopleDetector() -> retval

HoughCircles(image, method, dp, minDist[, circles[, param1[, param2[, minRadius[, maxRadius]]]]]) -> circles

HoughLines(image, rho, theta, threshold[, lines[, srn[, stn]]]) -> lines

HoughLinesP(image, rho, theta, threshold[, lines[, minLineLength[, maxLineGap]]]) -> lines

HuMoments(m[, hu]) -> hu

KDTree() -> or KDTree(points[, copyAndReorderPoints]) -> or KDTree(points, _labels[, copyAndReorderPoints]) -> KNearest([trainData, responses[, sampleIdx[, isRegression[, max_k]]]]) ->

KalmanFilter([dynamParams, measureParams[, controlParams[, type]]]) ->

KeyPoint([x, y, _size[, _angle[, _response[, _octave[, _class_id]]]]]) ->

LUT(src, lut[, dst[, interpolation]]) -> dst

Laplacian(src, ddepth[, dst[, ksize[, scale[, delta[, borderType]]]]]) -> dst

MSER([, _delta[, _min_area[, _max_area[, _max_variation[, _min_diversity[, _max_evolution[, _area_threshold[, _min_margin[, _edge_blur_size]]]]]]]]]) ->

Mahalanobis(v1, v2, icovar) -> retval

NormalBayesClassifier([trainData, responses[, varIdx[, sampleIdx]]]) ->

ORB([, nfeatures[, scaleFactor[, nlevels[, edgeThreshold[, firstLevel[, WTA_K[, scoreType[, patchSize]]]]]]]]) ->

PCABackProject(data, mean, eigenvectors[, result]) -> result

PCACompute(data[, mean[, eigenvectors[, maxComponents]]]) -> mean, eigenvectors

PCAComputeVar(data, retainedVariance[, mean[, eigenvectors]]) -> mean, eigenvectors

PCAProject(data, mean, eigenvectors[, result]) -> result

PSNR(src1, src2) -> retval

PyramidAdaptedFeatureDetector(detector[, maxLevel]) ->

RQDecomp3x3(src[, mtxR[, mtxQ[, Qx[, Qy[, Qz]]]]]) -> retval, mtxR, mtxQ, Qx, Qy, Qz

RTrees() ->

Rodrigues(src[, dst[, jacobian]]) -> dst, jacobian

SIFT([, nfeatures[, nOctaveLayers[, contrastThreshold[, edgeThreshold[, sigma]]]]]) ->

SURF([hessianThreshold[, nOctaves[, nOctaveLayers[, extended[, upright]]]]]) ->

SVBackSubst(w, u, vt, rhs[, dst]) -> dst

SVDecomp(src[, w[, u[, vt[, flags]]]]) -> w, u, vt

SVM([trainData, responses[, varIdx[, sampleIdx[, params]]]]) ->

Scharr(src, ddepth, dx, dy[, dst[, scale[, delta[, borderType]]]]) -> dst

SimpleBlobDetector([, parameters]) ->

SimpleBlobDetector_Params() ->

Sobel(src, ddepth, dx, dy[, dst[, ksize[, scale[, delta[, borderType]]]]]) -> dst

StarDetector([, _maxSize[, _responseThreshold[, _lineThresholdProjected[, _lineThresholdBinarized[, _suppressNonmaxSize]]]]]) ->

StereoBM([preset[, ndisparities[, SADWindowSize]]]) ->

StereoSGBM([minDisparity, numDisparities, SADWindowSize[, P1[, P2[, disp12MaxDiff[, preFilterCap[, uniquenessRatio[, speckleWindowSize[, speckleRange[, fullDP]]]]]]]]]) ->

StereoVar([levels, pyrScale, nIt, minDisp, maxDisp, poly_n, poly_sigma, fi, lambda, penalization, cycle, flags]) ->

Subdiv2D([rect]) ->

VideoCapture() -> or VideoCapture(filename) -> or VideoCapture(device) ->

VideoWriter([filename, fourcc, fps, frameSize[, isColor]]) ->

absdiff(src1, src2[, dst]) -> dst

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

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

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

accumulateWeighted(src, dst, alpha[, mask]) -> None

adaptiveBilateralFilter(src, ksize, sigmaSpace[, dst[, maxSigmaColor[, anchor[, borderType]]]]) -> dst

adaptiveThreshold(src, maxValue, adaptiveMethod, thresholdType, blockSize, C[, dst]) -> dst

add(src1, src2[, dst[, mask[, dtype]]]) -> dst

addWeighted(src1, alpha, src2, beta, gamma[, dst[, dtype]]) -> dst

applyColorMap(src, colormap[, dst]) -> dst

approxPolyDP(curve, epsilon, closed[, approxCurve]) -> approxCurve

arcLength(curve, closed) -> retval

batchDistance(src1, src2, dtype[, dist[, nidx[, normType[, K[, mask[, update[, crosscheck]]]]]]]) -> dist, nidx

bilateralFilter(src, d, sigmaColor, sigmaSpace[, dst[, borderType]]) -> dst

bitwise_and(src1, src2[, dst[, mask]]) -> dst

bitwise_not(src[, dst[, mask]]) -> dst

bitwise_or(src1, src2[, dst[, mask]]) -> dst

bitwise_xor(src1, src2[, dst[, mask]]) -> dst

blur(src, ksize[, dst[, anchor[, borderType]]]) -> dst

borderInterpolate(p, len, borderType) -> retval

boundingRect(points) -> retval

boxFilter(src, ddepth, ksize[, dst[, anchor[, normalize[, borderType]]]]) -> dst

buildOpticalFlowPyramid(img, winSize, maxLevel[, pyramid[, withDerivatives[, pyrBorder[, derivBorder[, tryReuseInputImage]]]]]) -> retval, pyramid

calcBackProject(images, channels, hist, ranges, scale[, dst]) -> dst

calcCovarMatrix(samples, flags[, covar[, mean[, ctype]]]) -> covar, mean

calcGlobalOrientation(orientation, mask, mhi, timestamp, duration) -> retval

calcHist(images, channels, mask, histSize, ranges[, hist[, accumulate]]) -> hist

calcMotionGradient(mhi, delta1, delta2[, mask[, orientation[, apertureSize]]]) -> mask, orientation

calcOpticalFlowFarneback(prev, next, pyr_scale, levels, winsize, iterations, poly_n, poly_sigma, flags[, flow]) -> flow

calcOpticalFlowPyrLK(prevImg, nextImg, prevPts[, nextPts[, status[, err[, winSize[, maxLevel[, criteria[, flags[, minEigThreshold]]]]]]]]) -> nextPts, status, err

calcOpticalFlowSF(from, to, flow, layers, averaging_block_size, max_flow) -> None or calcOpticalFlowSF(from, to, flow, layers, averaging_block_size, max_flow,

sigma_dist, sigma_color, postprocess_window, sigma_dist_fix, sigma_color_fix, occ_thr, upscale_averaging_radius, upscale_sigma_dist, upscale_sigma_color, speed_up_thr) -> None

calibrateCamera(objectPoints, imagePoints, imageSize[, cameraMatrix[, distCoeffs[, rvecs[, tvecs[, flags[, criteria]]]]]]) -> retval, cameraMatrix, distCoeffs, rvecs, tvecs

calibrationMatrixValues(cameraMatrix, imageSize, apertureWidth, apertureHeight) -> fovx, fovy, focalLength, principalPoint, aspectRatio

cartToPolar(x, y[, magnitude[, angle[, angleInDegrees]]]) -> magnitude, angle

chamerMatching(img, templ[, templScale[, maxMatches[, minMatchDistance[, padX[, padY[, scales[, minScale[, maxScale[, orientationWeight[, truncate]]]]]]]]]]) -> retval, results, cost

checkHardwareSupport(feature) -> retval

checkRange(a[, quiet[, minVal[, maxVal]]]) -> retval, pos

circle(img, center, radius, color[, thickness[, lineType[, shift]]]) -> None

clipLine(imgRect, pt1, pt2) -> retval, pt1, pt2

compare(src1, src2, cmpop[, dst]) -> dst

compareHist(H1, H2, method) -> retval

completeSymm(mtx[, lowerToUpper]) -> None

composeRT(rvec1, tvec1, rvec2, tvec2[, rvec3[, tvec3[, dr3dr1[, dr3dt1[, dr3dr2[, dr3dt2[, dt3dr1[, dt3dt1[, dt3dr2[, dt3dt2]]]]]]]]]]) -> rvec3, tvec3, dr3dr1, dr3dt1, dr3dr2, dr3dt2, dt3dr1, dt3dt1, dt3dr2, dt3dt2

computeCorrespondEpilines(points, whichImage, F[, lines]) -> lines

contourArea(contour[, oriented]) -> retval

convertMaps(map1, map2, dstmap1type[, dstmap1[, dstmap2[, nninterpolation]]]) -> dstmap1, dstmap2

convertPointsFromHomogeneous(src[, dst]) -> dst

convertPointsToHomogeneous(src[, dst]) -> dst

convertScaleAbs(src[, dst[, alpha[, beta]]]) -> dst

convexHull(points[, hull[, clockwise[, returnPoints]]]) -> hull

convexityDefects(contour, convexhull[, convexityDefects]) -> convexityDefects

copyMakeBorder(src, top, bottom, left, right, borderType[, dst[, value]]) -> dst

cornerEigenValsAndVecs(src, blockSize, ksize[, dst[, borderType]]) -> dst

cornerHarris(src, blockSize, ksize, k[, dst[, borderType]]) -> dst

cornerMinEigenVal(src, blockSize[, dst[, ksize[, borderType]]]) -> dst

cornerSubPix(image, corners, winSize, zeroZone, criteria) -> None

correctMatches(F, points1, points2[, newPoints1[, newPoints2]]) -> newPoints1, newPoints2

countNonZero(src) -> retval

createCLAHE([, clipLimit[, tileGridSize]]) -> retval

createEigenFaceRecognizer([, num_components[, threshold]]) -> retval

createFisherFaceRecognizer([, num_components[, threshold]]) -> retval

createHanningWindow(winSize, type[, dst]) -> dst

createLBPHFaceRecognizer([, radius[, neighbors[, grid_x[, grid_y[, threshold]]]]]) -> retval

createTrackbar(trackbarName, windowName, value, count, onChange) -> None

cubeRoot(val) -> retval

cvtColor(src, code[, dst[, dstCn]]) -> dst

dct(src[, dst[, flags]]) -> dst

decomposeProjectionMatrix(projMatrix[, cameraMatrix[, rotMatrix[, transVect[, rotMatrixX[, rotMatrixY[, rotMatrixZ[, eulerAngles]]]]]]]) -> cameraMatrix, rotMatrix, transVect, rotMatrixX, rotMatrixY, rotMatrixZ, eulerAngles

destroyAllWindows() -> None

destroyWindow(winname) -> None

determinant(mtx) -> retval

dft(src[, dst[, flags[, nonzeroRows]]]) -> dst

dilate(src, kernel[, dst[, anchor[, iterations[, borderType[, borderValue]]]]]) -> dst

distanceTransform(src, distanceType, maskSize[, dst]) -> dst

distanceTransformWithLabels(src, distanceType, maskSize[, dst[, labels[, labelType]]]) -> dst, labels

divide(src1, src2[, dst[, scale[, dtype]]]) -> dst or divide(scale, src2[, dst[, dtype]]) -> dst

drawChessboardCorners(image, patternSize, corners, patternWasFound) -> None

drawContours(image, contours, contourIdx, color[, thickness[, lineType[, hierarchy[, maxLevel[, offset]]]]]) -> None

drawDataMatrixCodes(image, codes, corners) -> None

drawKeypoints(image, keypoints[, outImage[, color[, flags]]]) -> outImage

eigen(src, computeEigenvectors[, eigenvalues[, eigenvectors]]) -> retval, eigenvalues, eigenvectors

ellipse(img, center, axes, angle, startAngle, endAngle, color[, thickness[, lineType[, shift]]]) -> None or ellipse(img, box, color[, thickness[, lineType]]) -> None

ellipse2Poly(center, axes, angle, arcStart, arcEnd, delta) -> pts

equalizeHist(src[, dst]) -> dst

erode(src, kernel[, dst[, anchor[, iterations[, borderType[, borderValue]]]]]) -> dst

estimateAffine3D(src, dst[, out[, inliers[, ransacThreshold[, confidence]]]]) -> retval, out, inliers

estimateRigidTransform(src, dst, fullAffine) -> retval

exp(src[, dst]) -> dst

extractChannel(src, coi[, dst]) -> dst

fastAtan2(y, x) -> retval

fastNlMeansDenoising(src[, dst[, h[, templateWindowSize[, searchWindowSize]]]]) -> dst

fastNlMeansDenoisingColored(src[, dst[, h[, hColor[, templateWindowSize[, searchWindowSize]]]]]) -> dst

fastNlMeansDenoisingColoredMulti(srcImgs, imgToDenoiseIndex, temporalWindowSize[, dst[, h[, hColor[, templateWindowSize[, searchWindowSize]]]]]) -> dst

fastNlMeansDenoisingMulti(srcImgs, imgToDenoiseIndex, temporalWindowSize[, dst[, h[, templateWindowSize[, searchWindowSize]]]]) -> dst

fillConvexPoly(img, points, color[, lineType[, shift]]) -> None

fillPoly(img, pts, color[, lineType[, shift[, offset]]]) -> None

filter2D(src, ddepth, kernel[, dst[, anchor[, delta[, borderType]]]]) -> dst

filterSpeckles(img, newVal, maxSpeckleSize, maxDiff[, buf]) -> None

findChessboardCorners(image, patternSize[, corners[, flags]]) -> retval, corners

findCirclesGrid(image, patternSize[, centers[, flags[, blobDetector]]]) -> retval, centers

findCirclesGridDefault(image, patternSize[, centers[, flags]]) -> retval, centers

findContours(image, mode, method[, contours[, hierarchy[, offset]]]) -> contours, hierarchy

findDataMatrix(image[, corners[, dmtx]]) -> codes, corners, dmtx

findFundamentalMat(points1, points2[, method[, param1[, param2[, mask]]]]) -> retval, mask

findHomography(srcPoints, dstPoints[, method[, ransacReprojThreshold[, mask]]]) -> retval, mask

findNonZero(src[, idx]) -> idx

fitEllipse(points) -> retval

fitLine(points, distType, param, reps, aeps[, line]) -> line

flann_Index([features, params[, distType]]) ->

flip(src, flipCode[, dst]) -> dst

floodFill(image, mask, seedPoint, newVal[, loDiff[, upDiff[, flags]]]) -> retval, rect

gemm(src1, src2, alpha, src3, gamma[, dst[, flags]]) -> dst

getAffineTransform(src, dst) -> retval

getBuildInformation() -> retval

getCPUTickCount() -> retval

getDefaultNewCameraMatrix(cameraMatrix[, imgsize[, centerPrincipalPoint]]) -> retval

getDerivKernels(dx, dy, ksize[, kx[, ky[, normalize[, ktype]]]]) -> kx, ky

getGaborKernel(ksize, sigma, theta, lambd, gamma[, psi[, ktype]]) -> retval

getGaussianKernel(ksize, sigma[, ktype]) -> retval

getNumberOfCPUs() -> retval

getOptimalDFTSize(vecsize) -> retval

getOptimalNewCameraMatrix(cameraMatrix, distCoeffs, imageSize, alpha[, newImgSize[, centerPrincipalPoint]]) -> retval, validPixROI

getPerspectiveTransform(src, dst) -> retval

getRectSubPix(image, patchSize, center[, patch[, patchType]]) -> patch

getRotationMatrix2D(center, angle, scale) -> retval

getStructuringElement(shape, ksize[, anchor]) -> retval

getTextSize(text, fontFace, fontScale, thickness) -> retval, baseLine

getTickCount() -> retval

getTickFrequency() -> retval

getTrackbarPos(trackbarname, winname) -> retval

getValidDisparityROI(roi1, roi2, minDisparity, numberOfDisparities, SADWindowSize) -> retval

getWindowProperty(winname, prop_id) -> retval

goodFeaturesToTrack(image, maxCorners, qualityLevel, minDistance[, corners[, mask[, blockSize[, useHarrisDetector[, k]]]]]) -> corners

grabCut(img, mask, rect, bgdModel, fgdModel, iterCount[, mode]) -> None

groupRectangles(rectList, groupThreshold[, eps]) -> rectList, weights

hconcat(src[, dst]) -> dst

idct(src[, dst[, flags]]) -> dst

idft(src[, dst[, flags[, nonzeroRows]]]) -> dst

imdecode(buf, flags) -> retval

imencode(ext, img[, params]) -> retval, buf

imread(filename[, flags]) -> retval

imshow(winname, mat) -> None

imwrite(filename, img[, params]) -> retval

inRange(src, lowerb, upperb[, dst]) -> dst

initCameraMatrix2D(objectPoints, imagePoints, imageSize[, aspectRatio]) -> retval

initModule_nonfree() -> retval

initUndistortRectifyMap(cameraMatrix, distCoeffs, R, newCameraMatrix, size, m1type[, map1[, map2]]) -> map1, map2

initWideAngleProjMap(cameraMatrix, distCoeffs, imageSize, destImageWidth, m1type[, map1[, map2[, projType[, alpha]]]]) -> retval, map1, map2

inpaint(src, inpaintMask, inpaintRadius, flags[, dst]) -> dst

insertChannel(src, dst, coi) -> None

integral(src[, sum[, sdepth]]) -> sum

integral2(src[, sum[, sqsum[, sdepth]]]) -> sum, sqsum

integral3(src[, sum[, sqsum[, tilted[, sdepth]]]]) -> sum, sqsum, tilted

intersectConvexConvex(_p1, _p2[, _p12[, handleNested]]) -> retval, _p12

invert(src[, dst[, flags]]) -> retval, dst

invertAffineTransform(M[, iM]) -> iM

isContourConvex(contour) -> retval

kmeans(data, K, criteria, attempts, flags[, bestLabels[, centers]]) -> retval, bestLabels, centers

line(img, pt1, pt2, color[, thickness[, lineType[, shift]]]) -> None

log(src[, dst]) -> dst

magnitude(x, y[, magnitude]) -> magnitude

matMulDeriv(A, B[, dABdA[, dABdB]]) -> dABdA, dABdB

matchShapes(contour1, contour2, method, parameter) -> retval

matchTemplate(image, templ, method[, result]) -> result

max(src1, src2[, dst]) -> dst

mean(src[, mask]) -> retval

meanShift(probImage, window, criteria) -> retval, window

meanStdDev(src[, mean[, stddev[, mask]]]) -> mean, stddev

medianBlur(src, ksize[, dst]) -> dst

merge(mv[, dst]) -> dst

min(src1, src2[, dst]) -> dst

minAreaRect(points) -> retval

minEnclosingCircle(points) -> center, radius

minMaxLoc(src[, mask]) -> minVal, maxVal, minLoc, maxLoc

mixChannels(src, dst, fromTo) -> None

moments(array[, binaryImage]) -> retval

morphologyEx(src, op, kernel[, dst[, anchor[, iterations[, borderType[, borderValue]]]]]) -> dst

moveWindow(winname, x, y) -> None

mulSpectrums(a, b, flags[, c[, conjB]]) -> c

mulTransposed(src, aTa[, dst[, delta[, scale[, dtype]]]]) -> dst

multiply(src1, src2[, dst[, scale[, dtype]]]) -> dst

namedWindow(winname[, flags]) -> None

norm(src1[, normType[, mask]]) -> retval or norm(src1, src2[, normType[, mask]]) -> retval

normalize(src[, dst[, alpha[, beta[, norm_type[, dtype[, mask]]]]]]) -> dst

patchNaNs(a[, val]) -> None

perspectiveTransform(src, m[, dst]) -> dst

phase(x, y[, angle[, angleInDegrees]]) -> angle

phaseCorrelate(src1, src2[, window]) -> retval

phaseCorrelateRes(src1, src2, window) -> retval, response

pointPolygonTest(contour, pt, measureDist) -> retval

polarToCart(magnitude, angle[, x[, y[, angleInDegrees]]]) -> x, y

polylines(img, pts, isClosed, color[, thickness[, lineType[, shift]]]) -> None

pow(src, power[, dst]) -> dst

preCornerDetect(src, ksize[, dst[, borderType]]) -> dst

projectPoints(objectPoints, rvec, tvec, cameraMatrix, distCoeffs[, imagePoints[, jacobian[, aspectRatio]]]) -> imagePoints, jacobian

putText(img, text, org, fontFace, fontScale, color[, thickness[, lineType[, bottomLeftOrigin]]]) -> None

pyrDown(src[, dst[, dstsize[, borderType]]]) -> dst

pyrMeanShiftFiltering(src, sp, sr[, dst[, maxLevel[, termcrit]]]) -> dst

pyrUp(src[, dst[, dstsize[, borderType]]]) -> dst

randShuffle(dst[, iterFactor]) -> None

randn(dst, mean, stddev) -> None

randu(dst, low, high) -> None

rectangle(img, pt1, pt2, color[, thickness[, lineType[, shift]]]) -> None

rectify3Collinear(cameraMatrix1, distCoeffs1, cameraMatrix2, distCoeffs2, cameraMatrix3, distCoeffs3, imgpt1, imgpt3, imageSize, R12, T12, R13, T13, alpha, newImgSize, flags[, R1[, R2[, R3[, P1[, P2[, P3[, Q]]]]]]]) -> retval, R1, R2, R3, P1, P2, P3, Q, roi1, roi2

reduce(src, dim, rtype[, dst[, dtype]]) -> dst

remap(src, map1, map2, interpolation[, dst[, borderMode[, borderValue]]]) -> dst

repeat(src, ny, nx[, dst]) -> dst

reprojectImageTo3D(disparity, Q[, _3dImage[, handleMissingValues[, ddepth]]]) -> _3dImage

resize(src, dsize[, dst[, fx[, fy[, interpolation]]]]) -> dst

resizeWindow(winname, width, height) -> None

scaleAdd(src1, alpha, src2[, dst]) -> dst

segmentMotion(mhi, timestamp, segThresh[, segmask]) -> segmask, boundingRects

sepFilter2D(src, ddepth, kernelX, kernelY[, dst[, anchor[, delta[, borderType]]]]) -> dst

setIdentity(mtx[, s]) -> None

setMouseCallback(windowName, onMouse [, param]) -> None

setTrackbarPos(trackbarname, winname, pos) -> None

setUseOptimized(onoff) -> None

setWindowProperty(winname, prop_id, prop_value) -> None

solve(src1, src2[, dst[, flags]]) -> retval, dst

solveCubic(coeffs[, roots]) -> retval, roots

solvePnP(objectPoints, imagePoints, cameraMatrix, distCoeffs[, rvec[, tvec[, useExtrinsicGuess[, flags]]]]) -> retval, rvec, tvec

solvePnPRansac(objectPoints, imagePoints, cameraMatrix, distCoeffs[, rvec[, tvec[, useExtrinsicGuess[, iterationsCount[, reprojectionError[, minInliersCount[, inliers[, flags]]]]]]]]) -> rvec, tvec, inliers

solvePoly(coeffs[, roots[, maxIters]]) -> retval, roots

sort(src, flags[, dst]) -> dst

sortIdx(src, flags[, dst]) -> dst

split(m[, mv]) -> mv

sqrt(src[, dst]) -> dst

startWindowThread() -> retval

stereoCalibrate(objectPoints, imagePoints1, imagePoints2, imageSize[, cameraMatrix1[, distCoeffs1[, cameraMatrix2[, distCoeffs2[, R[, T[, E[, F[, criteria[, flags]]]]]]]]]]) -> retval, cameraMatrix1, distCoeffs1, cameraMatrix2, distCoeffs2, R, T, E, F

stereoRectify(cameraMatrix1, distCoeffs1, cameraMatrix2, distCoeffs2, imageSize, R, T[, R1[, R2[, P1[, P2[, Q[, flags[, alpha[, newImageSize]]]]]]]]) -> R1, R2, P1, P2, Q, validPixROI1, validPixROI2

stereoRectifyUncalibrated(points1, points2, F, imgSize[, H1[, H2[, threshold]]]) -> retval, H1, H2

subtract(src1, src2[, dst[, mask[, dtype]]]) -> dst

sumElems(src) -> retval

threshold(src, thresh, maxval, type[, dst]) -> retval, dst

trace(mtx) -> retval

transform(src, m[, dst]) -> dst

transpose(src[, dst]) -> dst

triangulatePoints(projMatr1, projMatr2, projPoints1, projPoints2[, points4D]) -> points4D

undistort(src, cameraMatrix, distCoeffs[, dst[, newCameraMatrix]]) -> dst

undistortPoints(src, cameraMatrix, distCoeffs[, dst[, R[, P]]]) -> dst

updateMotionHistory(silhouette, mhi, timestamp, duration) -> None

useOptimized() -> retval

validateDisparity(disparity, cost, minDisparity, numberOfDisparities[, disp12MaxDisp]) -> None

vconcat(src[, dst]) -> dst

waitKey([, delay]) -> retval

warpAffine(src, M, dsize[, dst[, flags[, borderMode[, borderValue]]]]) -> dst

warpPerspective(src, M, dsize[, dst[, flags[, borderMode[, borderValue]]]]) -> dst

watershed(image, markers) -> None

总结：

对于CV2的使用，其主要类型是mat型，可以直接下标索引：如 Image [idxY] [idxX] = 65552

其中有一个疑惑的问题是：

对于resize的使用，  Image  =cv.resize(image,(w,h))    此句函数的使用会 导致：自动把Image 转化为3通道；这直接让我没有办法使用cv2了。

(二)：引入Cv的使用方法：

引入cv2.cv 后，使用cv便可以找到几乎在cv2refman里面的所有函数了，此处不再列出，举个例子说明。

path ="D:/Develope/EclipseWorks/SLICSeg/Recog/ViewX_2.094395 ViewY_0.000000 ViewZ_6.141592.pcd_comb.pcd_label.txtNo_SLIC.png"

Image = cv.LoadImageM(path,2) # 原始图像载入，参数为1 会转化为 三通道，8bit

cv.ShowImage("name", Image)

cv.WaitKey(0)ImageHeight= Image.height #Image.shape[0] #Iplimage 没有shape属性！

ImageWidth = Image.width

cv.Size = (Image.width, Image.height)

cv.Size = cv.GetSize(Image)

ImagePatch = cv.CreateImage(cv.Size,16, 1)

cv.Copy(Image, ImagePatch)#copy大小必须一致！

cv.SetImageROI(ImagePatch,(0,0,Image.width/2,Image.height/2))

path ="Patch2/"+ "path_"+ “76”+"_" + "S_posX" +"_Image.png"

cv.SaveImage(path,ImagePatch)

cv.ShowImage("name", ImagePatch)

cv.WaitKey(0)

ImagePatch = cv.CreateImage((320,240), 16, 1)

cv.Resize(Image, ImagePatch, cv.CV_INTER_LINEAR)

rows = Image.height

cols = Image.width

Mat = cv.CreateMat(rows, cols, cv.CV_16UC1)

cv.Convert(Image, Mat)

Image[24,25] =0 #对于单通道图像

ImagePatch = cv.CreateImage(cv.Size,8, 3)

ImagePatch[24,25][2] =255#对于三通道图像

至此，基本语法讲解告一段落！