Untitled.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import cv2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on module cv2:\n",
      "\n",
      "NAME\n",
      "    cv2\n",
      "\n",
      "FILE\n",
      "    /Users/haiweisu/anaconda/lib/python2.7/site-packages/cv2.so\n",
      "\n",
      "SUBMODULES\n",
      "    cv\n",
      "\n",
      "CLASSES\n",
      "    exceptions.Exception(exceptions.BaseException)\n",
      "        error\n",
      "    \n",
      "    class error(exceptions.Exception)\n",
      "     |  Method resolution order:\n",
      "     |      error\n",
      "     |      exceptions.Exception\n",
      "     |      exceptions.BaseException\n",
      "     |      __builtin__.object\n",
      "     |  \n",
      "     |  Data descriptors defined here:\n",
      "     |  \n",
      "     |  __weakref__\n",
      "     |      list of weak references to the object (if defined)\n",
      "     |  \n",
      "     |  ----------------------------------------------------------------------\n",
      "     |  Methods inherited from exceptions.Exception:\n",
      "     |  \n",
      "     |  __init__(...)\n",
      "     |      x.__init__(...) initializes x; see help(type(x)) for signature\n",
      "     |  \n",
      "     |  ----------------------------------------------------------------------\n",
      "     |  Data and other attributes inherited from exceptions.Exception:\n",
      "     |  \n",
      "     |  __new__ = <built-in method __new__ of type object>\n",
      "     |      T.__new__(S, ...) -> a new object with type S, a subtype of T\n",
      "     |  \n",
      "     |  ----------------------------------------------------------------------\n",
      "     |  Methods inherited from exceptions.BaseException:\n",
      "     |  \n",
      "     |  __delattr__(...)\n",
      "     |      x.__delattr__('name') <==> del x.name\n",
      "     |  \n",
      "     |  __getattribute__(...)\n",
      "     |      x.__getattribute__('name') <==> x.name\n",
      "     |  \n",
      "     |  __getitem__(...)\n",
      "     |      x.__getitem__(y) <==> x[y]\n",
      "     |  \n",
      "     |  __getslice__(...)\n",
      "     |      x.__getslice__(i, j) <==> x[i:j]\n",
      "     |      \n",
      "     |      Use of negative indices is not supported.\n",
      "     |  \n",
      "     |  __reduce__(...)\n",
      "     |  \n",
      "     |  __repr__(...)\n",
      "     |      x.__repr__() <==> repr(x)\n",
      "     |  \n",
      "     |  __setattr__(...)\n",
      "     |      x.__setattr__('name', value) <==> x.name = value\n",
      "     |  \n",
      "     |  __setstate__(...)\n",
      "     |  \n",
      "     |  __str__(...)\n",
      "     |      x.__str__() <==> str(x)\n",
      "     |  \n",
      "     |  __unicode__(...)\n",
      "     |  \n",
      "     |  ----------------------------------------------------------------------\n",
      "     |  Data descriptors inherited from exceptions.BaseException:\n",
      "     |  \n",
      "     |  __dict__\n",
      "     |  \n",
      "     |  args\n",
      "     |  \n",
      "     |  message\n",
      "\n",
      "FUNCTIONS\n",
      "    ANN_MLP(...)\n",
      "        ANN_MLP([layerSizes[, activateFunc[, fparam1[, fparam2]]]]) -> <ANN_MLP object>\n",
      "    \n",
      "    Algorithm__create(...)\n",
      "        Algorithm__create(name) -> retval\n",
      "    \n",
      "    Algorithm_getList(...)\n",
      "        Algorithm_getList() -> algorithms\n",
      "    \n",
      "    BFMatcher(...)\n",
      "        BFMatcher([, normType[, crossCheck]]) -> <BFMatcher object>\n",
      "    \n",
      "    BRISK(...)\n",
      "        BRISK([, thresh[, octaves[, patternScale]]]) -> <BRISK object>  or  BRISK(radiusList, numberList[, dMax[, dMin[, indexChange]]]) -> <BRISK object>\n",
      "    \n",
      "    BackgroundSubtractorMOG(...)\n",
      "        BackgroundSubtractorMOG([history, nmixtures, backgroundRatio[, noiseSigma]]) -> <BackgroundSubtractorMOG object>\n",
      "    \n",
      "    BackgroundSubtractorMOG2(...)\n",
      "        BackgroundSubtractorMOG2([history, varThreshold[, bShadowDetection]]) -> <BackgroundSubtractorMOG2 object>\n",
      "    \n",
      "    Boost(...)\n",
      "        Boost([trainData, tflag, responses[, varIdx[, sampleIdx[, varType[, missingDataMask[, params]]]]]]) -> <Boost object>\n",
      "    \n",
      "    CamShift(...)\n",
      "        CamShift(probImage, window, criteria) -> retval, window\n",
      "    \n",
      "    Canny(...)\n",
      "        Canny(image, threshold1, threshold2[, edges[, apertureSize[, L2gradient]]]) -> edges\n",
      "    \n",
      "    CascadeClassifier(...)\n",
      "        CascadeClassifier([filename]) -> <CascadeClassifier object>\n",
      "    \n",
      "    DMatch(...)\n",
      "        DMatch() -> <DMatch object>  or  DMatch(_queryIdx, _trainIdx, _distance) -> <DMatch object>  or  DMatch(_queryIdx, _trainIdx, _imgIdx, _distance) -> <DMatch object>\n",
      "    \n",
      "    DTree(...)\n",
      "        DTree() -> <DTree object>\n",
      "    \n",
      "    DescriptorExtractor_create(...)\n",
      "        DescriptorExtractor_create(descriptorExtractorType) -> retval\n",
      "    \n",
      "    DescriptorMatcher_create(...)\n",
      "        DescriptorMatcher_create(descriptorMatcherType) -> retval\n",
      "    \n",
      "    EM(...)\n",
      "        EM([, nclusters[, covMatType[, termCrit]]]) -> <EM object>\n",
      "    \n",
      "    ERTrees(...)\n",
      "        ERTrees() -> <ERTrees object>\n",
      "    \n",
      "    FastFeatureDetector(...)\n",
      "        FastFeatureDetector([, threshold[, nonmaxSuppression]]) -> <FastFeatureDetector object>\n",
      "    \n",
      "    Feature2D_create(...)\n",
      "        Feature2D_create(name) -> retval\n",
      "    \n",
      "    FeatureDetector_create(...)\n",
      "        FeatureDetector_create(detectorType) -> retval\n",
      "    \n",
      "    FileNode(...)\n",
      "        FileNode() -> <FileNode object>\n",
      "    \n",
      "    FileStorage(...)\n",
      "        FileStorage([source, flags[, encoding]]) -> <FileStorage object>\n",
      "    \n",
      "    FlannBasedMatcher(...)\n",
      "        FlannBasedMatcher([, indexParams[, searchParams]]) -> <FlannBasedMatcher object>\n",
      "    \n",
      "    GBTrees(...)\n",
      "        GBTrees([trainData, tflag, responses[, varIdx[, sampleIdx[, varType[, missingDataMask[, params]]]]]]) -> <GBTrees object>\n",
      "    \n",
      "    GFTTDetector(...)\n",
      "        GFTTDetector([, maxCorners[, qualityLevel[, minDistance[, blockSize[, useHarrisDetector[, k]]]]]]) -> <GFTTDetector object>\n",
      "    \n",
      "    GaussianBlur(...)\n",
      "        GaussianBlur(src, ksize, sigmaX[, dst[, sigmaY[, borderType]]]) -> dst\n",
      "    \n",
      "    GridAdaptedFeatureDetector(...)\n",
      "        GridAdaptedFeatureDetector([, detector[, maxTotalKeypoints[, gridRows[, gridCols]]]]) -> <GridAdaptedFeatureDetector object>\n",
      "    \n",
      "    HOGDescriptor(...)\n",
      "        HOGDescriptor() -> <HOGDescriptor object>  or  HOGDescriptor(_winSize, _blockSize, _blockStride, _cellSize, _nbins[, _derivAperture[, _winSigma[, _histogramNormType[, _L2HysThreshold[, _gammaCorrection[, _nlevels]]]]]]) -> <HOGDescriptor object>  or  HOGDescriptor(filename) -> <HOGDescriptor object>\n",
      "    \n",
      "    HOGDescriptor_getDaimlerPeopleDetector(...)\n",
      "        HOGDescriptor_getDaimlerPeopleDetector() -> retval\n",
      "    \n",
      "    HOGDescriptor_getDefaultPeopleDetector(...)\n",
      "        HOGDescriptor_getDefaultPeopleDetector() -> retval\n",
      "    \n",
      "    HoughCircles(...)\n",
      "        HoughCircles(image, method, dp, minDist[, circles[, param1[, param2[, minRadius[, maxRadius]]]]]) -> circles\n",
      "    \n",
      "    HoughLines(...)\n",
      "        HoughLines(image, rho, theta, threshold[, lines[, srn[, stn]]]) -> lines\n",
      "    \n",
      "    HoughLinesP(...)\n",
      "        HoughLinesP(image, rho, theta, threshold[, lines[, minLineLength[, maxLineGap]]]) -> lines\n",
      "    \n",
      "    HuMoments(...)\n",
      "        HuMoments(m[, hu]) -> hu\n",
      "    \n",
      "    KDTree(...)\n",
      "        KDTree() -> <KDTree object>  or  KDTree(points[, copyAndReorderPoints]) -> <KDTree object>  or  KDTree(points, _labels[, copyAndReorderPoints]) -> <KDTree object>\n",
      "    \n",
      "    KNearest(...)\n",
      "        KNearest([trainData, responses[, sampleIdx[, isRegression[, max_k]]]]) -> <KNearest object>\n",
      "    \n",
      "    KalmanFilter(...)\n",
      "        KalmanFilter([dynamParams, measureParams[, controlParams[, type]]]) -> <KalmanFilter object>\n",
      "    \n",
      "    KeyPoint(...)\n",
      "        KeyPoint([x, y, _size[, _angle[, _response[, _octave[, _class_id]]]]]) -> <KeyPoint object>\n",
      "    \n",
      "    LUT(...)\n",
      "        LUT(src, lut[, dst[, interpolation]]) -> dst\n",
      "    \n",
      "    Laplacian(...)\n",
      "        Laplacian(src, ddepth[, dst[, ksize[, scale[, delta[, borderType]]]]]) -> dst\n",
      "    \n",
      "    MSER(...)\n",
      "        MSER([, _delta[, _min_area[, _max_area[, _max_variation[, _min_diversity[, _max_evolution[, _area_threshold[, _min_margin[, _edge_blur_size]]]]]]]]]) -> <MSER object>\n",
      "    \n",
      "    Mahalanobis(...)\n",
      "        Mahalanobis(v1, v2, icovar) -> retval\n",
      "    \n",
      "    NormalBayesClassifier(...)\n",
      "        NormalBayesClassifier([trainData, responses[, varIdx[, sampleIdx]]]) -> <NormalBayesClassifier object>\n",
      "    \n",
      "    ORB(...)\n",
      "        ORB([, nfeatures[, scaleFactor[, nlevels[, edgeThreshold[, firstLevel[, WTA_K[, scoreType[, patchSize]]]]]]]]) -> <ORB object>\n",
      "    \n",
      "    PCABackProject(...)\n",
      "        PCABackProject(data, mean, eigenvectors[, result]) -> result\n",
      "    \n",
      "    PCACompute(...)\n",
      "        PCACompute(data[, mean[, eigenvectors[, maxComponents]]]) -> mean, eigenvectors\n",
      "    \n",
      "    PCAComputeVar(...)\n",
      "        PCAComputeVar(data, retainedVariance[, mean[, eigenvectors]]) -> mean, eigenvectors\n",
      "    \n",
      "    PCAProject(...)\n",
      "        PCAProject(data, mean, eigenvectors[, result]) -> result\n",
      "    \n",
      "    PSNR(...)\n",
      "        PSNR(src1, src2) -> retval\n",
      "    \n",
      "    PyramidAdaptedFeatureDetector(...)\n",
      "        PyramidAdaptedFeatureDetector(detector[, maxLevel]) -> <PyramidAdaptedFeatureDetector object>\n",
      "    \n",
      "    RQDecomp3x3(...)\n",
      "        RQDecomp3x3(src[, mtxR[, mtxQ[, Qx[, Qy[, Qz]]]]]) -> retval, mtxR, mtxQ, Qx, Qy, Qz\n",
      "    \n",
      "    RTrees(...)\n",
      "        RTrees() -> <RTrees object>\n",
      "    \n",
      "    Rodrigues(...)\n",
      "        Rodrigues(src[, dst[, jacobian]]) -> dst, jacobian\n",
      "    \n",
      "    SIFT(...)\n",
      "        SIFT([, nfeatures[, nOctaveLayers[, contrastThreshold[, edgeThreshold[, sigma]]]]]) -> <SIFT object>\n",
      "    \n",
      "    SURF(...)\n",
      "        SURF([hessianThreshold[, nOctaves[, nOctaveLayers[, extended[, upright]]]]]) -> <SURF object>\n",
      "    \n",
      "    SVBackSubst(...)\n",
      "        SVBackSubst(w, u, vt, rhs[, dst]) -> dst\n",
      "    \n",
      "    SVDecomp(...)\n",
      "        SVDecomp(src[, w[, u[, vt[, flags]]]]) -> w, u, vt\n",
      "    \n",
      "    SVM(...)\n",
      "        SVM([trainData, responses[, varIdx[, sampleIdx[, params]]]]) -> <SVM object>\n",
      "    \n",
      "    Scharr(...)\n",
      "        Scharr(src, ddepth, dx, dy[, dst[, scale[, delta[, borderType]]]]) -> dst\n",
      "    \n",
      "    SimpleBlobDetector(...)\n",
      "        SimpleBlobDetector([, parameters]) -> <SimpleBlobDetector object>\n",
      "    \n",
      "    SimpleBlobDetector_Params(...)\n",
      "        SimpleBlobDetector_Params() -> <SimpleBlobDetector_Params object>\n",
      "    \n",
      "    Sobel(...)\n",
      "        Sobel(src, ddepth, dx, dy[, dst[, ksize[, scale[, delta[, borderType]]]]]) -> dst\n",
      "    \n",
      "    StarDetector(...)\n",
      "        StarDetector([, _maxSize[, _responseThreshold[, _lineThresholdProjected[, _lineThresholdBinarized[, _suppressNonmaxSize]]]]]) -> <StarDetector object>\n",
      "    \n",
      "    StereoBM(...)\n",
      "        StereoBM([preset[, ndisparities[, SADWindowSize]]]) -> <StereoBM object>\n",
      "    \n",
      "    StereoSGBM(...)\n",
      "        StereoSGBM([minDisparity, numDisparities, SADWindowSize[, P1[, P2[, disp12MaxDiff[, preFilterCap[, uniquenessRatio[, speckleWindowSize[, speckleRange[, fullDP]]]]]]]]]) -> <StereoSGBM object>\n",
      "    \n",
      "    StereoVar(...)\n",
      "        StereoVar([levels, pyrScale, nIt, minDisp, maxDisp, poly_n, poly_sigma, fi, lambda, penalization, cycle, flags]) -> <StereoVar object>\n",
      "    \n",
      "    Subdiv2D(...)\n",
      "        Subdiv2D([rect]) -> <Subdiv2D object>\n",
      "    \n",
      "    VideoCapture(...)\n",
      "        VideoCapture() -> <VideoCapture object>  or  VideoCapture(filename) -> <VideoCapture object>  or  VideoCapture(device) -> <VideoCapture object>\n",
      "    \n",
      "    VideoWriter(...)\n",
      "        VideoWriter([filename, fourcc, fps, frameSize[, isColor]]) -> <VideoWriter object>\n",
      "    \n",
      "    absdiff(...)\n",
      "        absdiff(src1, src2[, dst]) -> dst\n",
      "    \n",
      "    accumulate(...)\n",
      "        accumulate(src, dst[, mask]) -> None\n",
      "    \n",
      "    accumulateProduct(...)\n",
      "        accumulateProduct(src1, src2, dst[, mask]) -> None\n",
      "    \n",
      "    accumulateSquare(...)\n",
      "        accumulateSquare(src, dst[, mask]) -> None\n",
      "    \n",
      "    accumulateWeighted(...)\n",
      "        accumulateWeighted(src, dst, alpha[, mask]) -> None\n",
      "    \n",
      "    adaptiveBilateralFilter(...)\n",
      "        adaptiveBilateralFilter(src, ksize, sigmaSpace[, dst[, maxSigmaColor[, anchor[, borderType]]]]) -> dst\n",
      "    \n",
      "    adaptiveThreshold(...)\n",
      "        adaptiveThreshold(src, maxValue, adaptiveMethod, thresholdType, blockSize, C[, dst]) -> dst\n",
      "    \n",
      "    add(...)\n",
      "        add(src1, src2[, dst[, mask[, dtype]]]) -> dst\n",
      "    \n",
      "    addWeighted(...)\n",
      "        addWeighted(src1, alpha, src2, beta, gamma[, dst[, dtype]]) -> dst\n",
      "    \n",
      "    applyColorMap(...)\n",
      "        applyColorMap(src, colormap[, dst]) -> dst\n",
      "    \n",
      "    approxPolyDP(...)\n",
      "        approxPolyDP(curve, epsilon, closed[, approxCurve]) -> approxCurve\n",
      "    \n",
      "    arcLength(...)\n",
      "        arcLength(curve, closed) -> retval\n",
      "    \n",
      "    batchDistance(...)\n",
      "        batchDistance(src1, src2, dtype[, dist[, nidx[, normType[, K[, mask[, update[, crosscheck]]]]]]]) -> dist, nidx\n",
      "    \n",
      "    bilateralFilter(...)\n",
      "        bilateralFilter(src, d, sigmaColor, sigmaSpace[, dst[, borderType]]) -> dst\n",
      "    \n",
      "    bitwise_and(...)\n",
      "        bitwise_and(src1, src2[, dst[, mask]]) -> dst\n",
      "    \n",
      "    bitwise_not(...)\n",
      "        bitwise_not(src[, dst[, mask]]) -> dst\n",
      "    \n",
      "    bitwise_or(...)\n",
      "        bitwise_or(src1, src2[, dst[, mask]]) -> dst\n",
      "    \n",
      "    bitwise_xor(...)\n",
      "        bitwise_xor(src1, src2[, dst[, mask]]) -> dst\n",
      "    \n",
      "    blur(...)\n",
      "        blur(src, ksize[, dst[, anchor[, borderType]]]) -> dst\n",
      "    \n",
      "    borderInterpolate(...)\n",
      "        borderInterpolate(p, len, borderType) -> retval\n",
      "    \n",
      "    boundingRect(...)\n",
      "        boundingRect(points) -> retval\n",
      "    \n",
      "    boxFilter(...)\n",
      "        boxFilter(src, ddepth, ksize[, dst[, anchor[, normalize[, borderType]]]]) -> dst\n",
      "    \n",
      "    buildOpticalFlowPyramid(...)\n",
      "        buildOpticalFlowPyramid(img, winSize, maxLevel[, pyramid[, withDerivatives[, pyrBorder[, derivBorder[, tryReuseInputImage]]]]]) -> retval, pyramid\n",
      "    \n",
      "    calcBackProject(...)\n",
      "        calcBackProject(images, channels, hist, ranges, scale[, dst]) -> dst\n",
      "    \n",
      "    calcCovarMatrix(...)\n",
      "        calcCovarMatrix(samples, flags[, covar[, mean[, ctype]]]) -> covar, mean\n",
      "    \n",
      "    calcGlobalOrientation(...)\n",
      "        calcGlobalOrientation(orientation, mask, mhi, timestamp, duration) -> retval\n",
      "    \n",
      "    calcHist(...)\n",
      "        calcHist(images, channels, mask, histSize, ranges[, hist[, accumulate]]) -> hist\n",
      "    \n",
      "    calcMotionGradient(...)\n",
      "        calcMotionGradient(mhi, delta1, delta2[, mask[, orientation[, apertureSize]]]) -> mask, orientation\n",
      "    \n",
      "    calcOpticalFlowFarneback(...)\n",
      "        calcOpticalFlowFarneback(prev, next, pyr_scale, levels, winsize, iterations, poly_n, poly_sigma, flags[, flow]) -> flow\n",
      "    \n",
      "    calcOpticalFlowPyrLK(...)\n",
      "        calcOpticalFlowPyrLK(prevImg, nextImg, prevPts[, nextPts[, status[, err[, winSize[, maxLevel[, criteria[, flags[, minEigThreshold]]]]]]]]) -> nextPts, status, err\n",
      "    \n",
      "    calcOpticalFlowSF(...)\n",
      "        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\n",
      "    \n",
      "    calibrateCamera(...)\n",
      "        calibrateCamera(objectPoints, imagePoints, imageSize[, cameraMatrix[, distCoeffs[, rvecs[, tvecs[, flags[, criteria]]]]]]) -> retval, cameraMatrix, distCoeffs, rvecs, tvecs\n",
      "    \n",
      "    calibrationMatrixValues(...)\n",
      "        calibrationMatrixValues(cameraMatrix, imageSize, apertureWidth, apertureHeight) -> fovx, fovy, focalLength, principalPoint, aspectRatio\n",
      "    \n",
      "    cartToPolar(...)\n",
      "        cartToPolar(x, y[, magnitude[, angle[, angleInDegrees]]]) -> magnitude, angle\n",
      "    \n",
      "    chamerMatching(...)\n",
      "        chamerMatching(img, templ[, templScale[, maxMatches[, minMatchDistance[, padX[, padY[, scales[, minScale[, maxScale[, orientationWeight[, truncate]]]]]]]]]]) -> retval, results, cost\n",
      "    \n",
      "    checkHardwareSupport(...)\n",
      "        checkHardwareSupport(feature) -> retval\n",
      "    \n",
      "    checkRange(...)\n",
      "        checkRange(a[, quiet[, minVal[, maxVal]]]) -> retval, pos\n",
      "    \n",
      "    circle(...)\n",
      "        circle(img, center, radius, color[, thickness[, lineType[, shift]]]) -> None\n",
      "    \n",
      "    clipLine(...)\n",
      "        clipLine(imgRect, pt1, pt2) -> retval, pt1, pt2\n",
      "    \n",
      "    compare(...)\n",
      "        compare(src1, src2, cmpop[, dst]) -> dst\n",
      "    \n",
      "    compareHist(...)\n",
      "        compareHist(H1, H2, method) -> retval\n",
      "    \n",
      "    completeSymm(...)\n",
      "        completeSymm(mtx[, lowerToUpper]) -> None\n",
      "    \n",
      "    composeRT(...)\n",
      "        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\n",
      "    \n",
      "    computeCorrespondEpilines(...)\n",
      "        computeCorrespondEpilines(points, whichImage, F[, lines]) -> lines\n",
      "    \n",
      "    contourArea(...)\n",
      "        contourArea(contour[, oriented]) -> retval\n",
      "    \n",
      "    convertMaps(...)\n",
      "        convertMaps(map1, map2, dstmap1type[, dstmap1[, dstmap2[, nninterpolation]]]) -> dstmap1, dstmap2\n",
      "    \n",
      "    convertPointsFromHomogeneous(...)\n",
      "        convertPointsFromHomogeneous(src[, dst]) -> dst\n",
      "    \n",
      "    convertPointsToHomogeneous(...)\n",
      "        convertPointsToHomogeneous(src[, dst]) -> dst\n",
      "    \n",
      "    convertScaleAbs(...)\n",
      "        convertScaleAbs(src[, dst[, alpha[, beta]]]) -> dst\n",
      "    \n",
      "    convexHull(...)\n",
      "        convexHull(points[, hull[, clockwise[, returnPoints]]]) -> hull\n",
      "    \n",
      "    convexityDefects(...)\n",
      "        convexityDefects(contour, convexhull[, convexityDefects]) -> convexityDefects\n",
      "    \n",
      "    copyMakeBorder(...)\n",
      "        copyMakeBorder(src, top, bottom, left, right, borderType[, dst[, value]]) -> dst\n",
      "    \n",
      "    cornerEigenValsAndVecs(...)\n",
      "        cornerEigenValsAndVecs(src, blockSize, ksize[, dst[, borderType]]) -> dst\n",
      "    \n",
      "    cornerHarris(...)\n",
      "        cornerHarris(src, blockSize, ksize, k[, dst[, borderType]]) -> dst\n",
      "    \n",
      "    cornerMinEigenVal(...)\n",
      "        cornerMinEigenVal(src, blockSize[, dst[, ksize[, borderType]]]) -> dst\n",
      "    \n",
      "    cornerSubPix(...)\n",
      "        cornerSubPix(image, corners, winSize, zeroZone, criteria) -> None\n",
      "    \n",
      "    correctMatches(...)\n",
      "        correctMatches(F, points1, points2[, newPoints1[, newPoints2]]) -> newPoints1, newPoints2\n",
      "    \n",
      "    countNonZero(...)\n",
      "        countNonZero(src) -> retval\n",
      "    \n",
      "    createCLAHE(...)\n",
      "        createCLAHE([, clipLimit[, tileGridSize]]) -> retval\n",
      "    \n",
      "    createEigenFaceRecognizer(...)\n",
      "        createEigenFaceRecognizer([, num_components[, threshold]]) -> retval\n",
      "    \n",
      "    createFisherFaceRecognizer(...)\n",
      "        createFisherFaceRecognizer([, num_components[, threshold]]) -> retval\n",
      "    \n",
      "    createHanningWindow(...)\n",
      "        createHanningWindow(winSize, type[, dst]) -> dst\n",
      "    \n",
      "    createLBPHFaceRecognizer(...)\n",
      "        createLBPHFaceRecognizer([, radius[, neighbors[, grid_x[, grid_y[, threshold]]]]]) -> retval\n",
      "    \n",
      "    createTrackbar(...)\n",
      "        createTrackbar(trackbarName, windowName, value, count, onChange) -> None\n",
      "    \n",
      "    cubeRoot(...)\n",
      "        cubeRoot(val) -> retval\n",
      "    \n",
      "    cvtColor(...)\n",
      "        cvtColor(src, code[, dst[, dstCn]]) -> dst\n",
      "    \n",
      "    dct(...)\n",
      "        dct(src[, dst[, flags]]) -> dst\n",
      "    \n",
      "    decomposeProjectionMatrix(...)\n",
      "        decomposeProjectionMatrix(projMatrix[, cameraMatrix[, rotMatrix[, transVect[, rotMatrixX[, rotMatrixY[, rotMatrixZ[, eulerAngles]]]]]]]) -> cameraMatrix, rotMatrix, transVect, rotMatrixX, rotMatrixY, rotMatrixZ, eulerAngles\n",
      "    \n",
      "    destroyAllWindows(...)\n",
      "        destroyAllWindows() -> None\n",
      "    \n",
      "    destroyWindow(...)\n",
      "        destroyWindow(winname) -> None\n",
      "    \n",
      "    determinant(...)\n",
      "        determinant(mtx) -> retval\n",
      "    \n",
      "    dft(...)\n",
      "        dft(src[, dst[, flags[, nonzeroRows]]]) -> dst\n",
      "    \n",
      "    dilate(...)\n",
      "        dilate(src, kernel[, dst[, anchor[, iterations[, borderType[, borderValue]]]]]) -> dst\n",
      "    \n",
      "    distanceTransform(...)\n",
      "        distanceTransform(src, distanceType, maskSize[, dst]) -> dst\n",
      "    \n",
      "    distanceTransformWithLabels(...)\n",
      "        distanceTransformWithLabels(src, distanceType, maskSize[, dst[, labels[, labelType]]]) -> dst, labels\n",
      "    \n",
      "    divide(...)\n",
      "        divide(src1, src2[, dst[, scale[, dtype]]]) -> dst  or  divide(scale, src2[, dst[, dtype]]) -> dst\n",
      "    \n",
      "    drawChessboardCorners(...)\n",
      "        drawChessboardCorners(image, patternSize, corners, patternWasFound) -> None\n",
      "    \n",
      "    drawContours(...)\n",
      "        drawContours(image, contours, contourIdx, color[, thickness[, lineType[, hierarchy[, maxLevel[, offset]]]]]) -> None\n",
      "    \n",
      "    drawDataMatrixCodes(...)\n",
      "        drawDataMatrixCodes(image, codes, corners) -> None\n",
      "    \n",
      "    drawKeypoints(...)\n",
      "        drawKeypoints(image, keypoints[, outImage[, color[, flags]]]) -> outImage\n",
      "    \n",
      "    eigen(...)\n",
      "        eigen(src, computeEigenvectors[, eigenvalues[, eigenvectors]]) -> retval, eigenvalues, eigenvectors\n",
      "    \n",
      "    ellipse(...)\n",
      "        ellipse(img, center, axes, angle, startAngle, endAngle, color[, thickness[, lineType[, shift]]]) -> None  or  ellipse(img, box, color[, thickness[, lineType]]) -> None\n",
      "    \n",
      "    ellipse2Poly(...)\n",
      "        ellipse2Poly(center, axes, angle, arcStart, arcEnd, delta) -> pts\n",
      "    \n",
      "    equalizeHist(...)\n",
      "        equalizeHist(src[, dst]) -> dst\n",
      "    \n",
      "    erode(...)\n",
      "        erode(src, kernel[, dst[, anchor[, iterations[, borderType[, borderValue]]]]]) -> dst\n",
      "    \n",
      "    estimateAffine3D(...)\n",
      "        estimateAffine3D(src, dst[, out[, inliers[, ransacThreshold[, confidence]]]]) -> retval, out, inliers\n",
      "    \n",
      "    estimateRigidTransform(...)\n",
      "        estimateRigidTransform(src, dst, fullAffine) -> retval\n",
      "    \n",
      "    exp(...)\n",
      "        exp(src[, dst]) -> dst\n",
      "    \n",
      "    extractChannel(...)\n",
      "        extractChannel(src, coi[, dst]) -> dst\n",
      "    \n",
      "    fastAtan2(...)\n",
      "        fastAtan2(y, x) -> retval\n",
      "    \n",
      "    fastNlMeansDenoising(...)\n",
      "        fastNlMeansDenoising(src[, dst[, h[, templateWindowSize[, searchWindowSize]]]]) -> dst\n",
      "    \n",
      "    fastNlMeansDenoisingColored(...)\n",
      "        fastNlMeansDenoisingColored(src[, dst[, h[, hColor[, templateWindowSize[, searchWindowSize]]]]]) -> dst\n",
      "    \n",
      "    fastNlMeansDenoisingColoredMulti(...)\n",
      "        fastNlMeansDenoisingColoredMulti(srcImgs, imgToDenoiseIndex, temporalWindowSize[, dst[, h[, hColor[, templateWindowSize[, searchWindowSize]]]]]) -> dst\n",
      "    \n",
      "    fastNlMeansDenoisingMulti(...)\n",
      "        fastNlMeansDenoisingMulti(srcImgs, imgToDenoiseIndex, temporalWindowSize[, dst[, h[, templateWindowSize[, searchWindowSize]]]]) -> dst\n",
      "    \n",
      "    fillConvexPoly(...)\n",
      "        fillConvexPoly(img, points, color[, lineType[, shift]]) -> None\n",
      "    \n",
      "    fillPoly(...)\n",
      "        fillPoly(img, pts, color[, lineType[, shift[, offset]]]) -> None\n",
      "    \n",
      "    filter2D(...)\n",
      "        filter2D(src, ddepth, kernel[, dst[, anchor[, delta[, borderType]]]]) -> dst\n",
      "    \n",
      "    filterSpeckles(...)\n",
      "        filterSpeckles(img, newVal, maxSpeckleSize, maxDiff[, buf]) -> None\n",
      "    \n",
      "    findChessboardCorners(...)\n",
      "        findChessboardCorners(image, patternSize[, corners[, flags]]) -> retval, corners\n",
      "    \n",
      "    findCirclesGrid(...)\n",
      "        findCirclesGrid(image, patternSize[, centers[, flags[, blobDetector]]]) -> retval, centers\n",
      "    \n",
      "    findCirclesGridDefault(...)\n",
      "        findCirclesGridDefault(image, patternSize[, centers[, flags]]) -> retval, centers\n",
      "    \n",
      "    findContours(...)\n",
      "        findContours(image, mode, method[, contours[, hierarchy[, offset]]]) -> contours, hierarchy\n",
      "    \n",
      "    findDataMatrix(...)\n",
      "        findDataMatrix(image[, corners[, dmtx]]) -> codes, corners, dmtx\n",
      "    \n",
      "    findFundamentalMat(...)\n",
      "        findFundamentalMat(points1, points2[, method[, param1[, param2[, mask]]]]) -> retval, mask\n",
      "    \n",
      "    findHomography(...)\n",
      "        findHomography(srcPoints, dstPoints[, method[, ransacReprojThreshold[, mask]]]) -> retval, mask\n",
      "    \n",
      "    findNonZero(...)\n",
      "        findNonZero(src[, idx]) -> idx\n",
      "    \n",
      "    fitEllipse(...)\n",
      "        fitEllipse(points) -> retval\n",
      "    \n",
      "    fitLine(...)\n",
      "        fitLine(points, distType, param, reps, aeps[, line]) -> line\n",
      "    \n",
      "    flann_Index(...)\n",
      "        flann_Index([features, params[, distType]]) -> <flann_Index object>\n",
      "    \n",
      "    flip(...)\n",
      "        flip(src, flipCode[, dst]) -> dst\n",
      "    \n",
      "    floodFill(...)\n",
      "        floodFill(image, mask, seedPoint, newVal[, loDiff[, upDiff[, flags]]]) -> retval, rect\n",
      "    \n",
      "    gemm(...)\n",
      "        gemm(src1, src2, alpha, src3, gamma[, dst[, flags]]) -> dst\n",
      "    \n",
      "    getAffineTransform(...)\n",
      "        getAffineTransform(src, dst) -> retval\n",
      "    \n",
      "    getBuildInformation(...)\n",
      "        getBuildInformation() -> retval\n",
      "    \n",
      "    getCPUTickCount(...)\n",
      "        getCPUTickCount() -> retval\n",
      "    \n",
      "    getDefaultNewCameraMatrix(...)\n",
      "        getDefaultNewCameraMatrix(cameraMatrix[, imgsize[, centerPrincipalPoint]]) -> retval\n",
      "    \n",
      "    getDerivKernels(...)\n",
      "        getDerivKernels(dx, dy, ksize[, kx[, ky[, normalize[, ktype]]]]) -> kx, ky\n",
      "    \n",
      "    getGaborKernel(...)\n",
      "        getGaborKernel(ksize, sigma, theta, lambd, gamma[, psi[, ktype]]) -> retval\n",
      "    \n",
      "    getGaussianKernel(...)\n",
      "        getGaussianKernel(ksize, sigma[, ktype]) -> retval\n",
      "    \n",
      "    getNumberOfCPUs(...)\n",
      "        getNumberOfCPUs() -> retval\n",
      "    \n",
      "    getOptimalDFTSize(...)\n",
      "        getOptimalDFTSize(vecsize) -> retval\n",
      "    \n",
      "    getOptimalNewCameraMatrix(...)\n",
      "        getOptimalNewCameraMatrix(cameraMatrix, distCoeffs, imageSize, alpha[, newImgSize[, centerPrincipalPoint]]) -> retval, validPixROI\n",
      "    \n",
      "    getPerspectiveTransform(...)\n",
      "        getPerspectiveTransform(src, dst) -> retval\n",
      "    \n",
      "    getRectSubPix(...)\n",
      "        getRectSubPix(image, patchSize, center[, patch[, patchType]]) -> patch\n",
      "    \n",
      "    getRotationMatrix2D(...)\n",
      "        getRotationMatrix2D(center, angle, scale) -> retval\n",
      "    \n",
      "    getStructuringElement(...)\n",
      "        getStructuringElement(shape, ksize[, anchor]) -> retval\n",
      "    \n",
      "    getTextSize(...)\n",
      "        getTextSize(text, fontFace, fontScale, thickness) -> retval, baseLine\n",
      "    \n",
      "    getTickCount(...)\n",
      "        getTickCount() -> retval\n",
      "    \n",
      "    getTickFrequency(...)\n",
      "        getTickFrequency() -> retval\n",
      "    \n",
      "    getTrackbarPos(...)\n",
      "        getTrackbarPos(trackbarname, winname) -> retval\n",
      "    \n",
      "    getValidDisparityROI(...)\n",
      "        getValidDisparityROI(roi1, roi2, minDisparity, numberOfDisparities, SADWindowSize) -> retval\n",
      "    \n",
      "    getWindowProperty(...)\n",
      "        getWindowProperty(winname, prop_id) -> retval\n",
      "    \n",
      "    goodFeaturesToTrack(...)\n",
      "        goodFeaturesToTrack(image, maxCorners, qualityLevel, minDistance[, corners[, mask[, blockSize[, useHarrisDetector[, k]]]]]) -> corners\n",
      "    \n",
      "    grabCut(...)\n",
      "        grabCut(img, mask, rect, bgdModel, fgdModel, iterCount[, mode]) -> None\n",
      "    \n",
      "    groupRectangles(...)\n",
      "        groupRectangles(rectList, groupThreshold[, eps]) -> rectList, weights\n",
      "    \n",
      "    hconcat(...)\n",
      "        hconcat(src[, dst]) -> dst\n",
      "    \n",
      "    idct(...)\n",
      "        idct(src[, dst[, flags]]) -> dst\n",
      "    \n",
      "    idft(...)\n",
      "        idft(src[, dst[, flags[, nonzeroRows]]]) -> dst\n",
      "    \n",
      "    imdecode(...)\n",
      "        imdecode(buf, flags) -> retval\n",
      "    \n",
      "    imencode(...)\n",
      "        imencode(ext, img[, params]) -> retval, buf\n",
      "    \n",
      "    imread(...)\n",
      "        imread(filename[, flags]) -> retval\n",
      "    \n",
      "    imshow(...)\n",
      "        imshow(winname, mat) -> None\n",
      "    \n",
      "    imwrite(...)\n",
      "        imwrite(filename, img[, params]) -> retval\n",
      "    \n",
      "    inRange(...)\n",
      "        inRange(src, lowerb, upperb[, dst]) -> dst\n",
      "    \n",
      "    initCameraMatrix2D(...)\n",
      "        initCameraMatrix2D(objectPoints, imagePoints, imageSize[, aspectRatio]) -> retval\n",
      "    \n",
      "    initModule_nonfree(...)\n",
      "        initModule_nonfree() -> retval\n",
      "    \n",
      "    initUndistortRectifyMap(...)\n",
      "        initUndistortRectifyMap(cameraMatrix, distCoeffs, R, newCameraMatrix, size, m1type[, map1[, map2]]) -> map1, map2\n",
      "    \n",
      "    initWideAngleProjMap(...)\n",
      "        initWideAngleProjMap(cameraMatrix, distCoeffs, imageSize, destImageWidth, m1type[, map1[, map2[, projType[, alpha]]]]) -> retval, map1, map2\n",
      "    \n",
      "    inpaint(...)\n",
      "        inpaint(src, inpaintMask, inpaintRadius, flags[, dst]) -> dst\n",
      "    \n",
      "    insertChannel(...)\n",
      "        insertChannel(src, dst, coi) -> None\n",
      "    \n",
      "    integral(...)\n",
      "        integral(src[, sum[, sdepth]]) -> sum\n",
      "    \n",
      "    integral2(...)\n",
      "        integral2(src[, sum[, sqsum[, sdepth]]]) -> sum, sqsum\n",
      "    \n",
      "    integral3(...)\n",
      "        integral3(src[, sum[, sqsum[, tilted[, sdepth]]]]) -> sum, sqsum, tilted\n",
      "    \n",
      "    intersectConvexConvex(...)\n",
      "        intersectConvexConvex(_p1, _p2[, _p12[, handleNested]]) -> retval, _p12\n",
      "    \n",
      "    invert(...)\n",
      "        invert(src[, dst[, flags]]) -> retval, dst\n",
      "    \n",
      "    invertAffineTransform(...)\n",
      "        invertAffineTransform(M[, iM]) -> iM\n",
      "    \n",
      "    isContourConvex(...)\n",
      "        isContourConvex(contour) -> retval\n",
      "    \n",
      "    kmeans(...)\n",
      "        kmeans(data, K, criteria, attempts, flags[, bestLabels[, centers]]) -> retval, bestLabels, centers\n",
      "    \n",
      "    line(...)\n",
      "        line(img, pt1, pt2, color[, thickness[, lineType[, shift]]]) -> None\n",
      "    \n",
      "    log(...)\n",
      "        log(src[, dst]) -> dst\n",
      "    \n",
      "    magnitude(...)\n",
      "        magnitude(x, y[, magnitude]) -> magnitude\n",
      "    \n",
      "    matMulDeriv(...)\n",
      "        matMulDeriv(A, B[, dABdA[, dABdB]]) -> dABdA, dABdB\n",
      "    \n",
      "    matchShapes(...)\n",
      "        matchShapes(contour1, contour2, method, parameter) -> retval\n",
      "    \n",
      "    matchTemplate(...)\n",
      "        matchTemplate(image, templ, method[, result]) -> result\n",
      "    \n",
      "    max(...)\n",
      "        max(src1, src2[, dst]) -> dst\n",
      "    \n",
      "    mean(...)\n",
      "        mean(src[, mask]) -> retval\n",
      "    \n",
      "    meanShift(...)\n",
      "        meanShift(probImage, window, criteria) -> retval, window\n",
      "    \n",
      "    meanStdDev(...)\n",
      "        meanStdDev(src[, mean[, stddev[, mask]]]) -> mean, stddev\n",
      "    \n",
      "    medianBlur(...)\n",
      "        medianBlur(src, ksize[, dst]) -> dst\n",
      "    \n",
      "    merge(...)\n",
      "        merge(mv[, dst]) -> dst\n",
      "    \n",
      "    min(...)\n",
      "        min(src1, src2[, dst]) -> dst\n",
      "    \n",
      "    minAreaRect(...)\n",
      "        minAreaRect(points) -> retval\n",
      "    \n",
      "    minEnclosingCircle(...)\n",
      "        minEnclosingCircle(points) -> center, radius\n",
      "    \n",
      "    minMaxLoc(...)\n",
      "        minMaxLoc(src[, mask]) -> minVal, maxVal, minLoc, maxLoc\n",
      "    \n",
      "    mixChannels(...)\n",
      "        mixChannels(src, dst, fromTo) -> None\n",
      "    \n",
      "    moments(...)\n",
      "        moments(array[, binaryImage]) -> retval\n",
      "    \n",
      "    morphologyEx(...)\n",
      "        morphologyEx(src, op, kernel[, dst[, anchor[, iterations[, borderType[, borderValue]]]]]) -> dst\n",
      "    \n",
      "    moveWindow(...)\n",
      "        moveWindow(winname, x, y) -> None\n",
      "    \n",
      "    mulSpectrums(...)\n",
      "        mulSpectrums(a, b, flags[, c[, conjB]]) -> c\n",
      "    \n",
      "    mulTransposed(...)\n",
      "        mulTransposed(src, aTa[, dst[, delta[, scale[, dtype]]]]) -> dst\n",
      "    \n",
      "    multiply(...)\n",
      "        multiply(src1, src2[, dst[, scale[, dtype]]]) -> dst\n",
      "    \n",
      "    namedWindow(...)\n",
      "        namedWindow(winname[, flags]) -> None\n",
      "    \n",
      "    norm(...)\n",
      "        norm(src1[, normType[, mask]]) -> retval  or  norm(src1, src2[, normType[, mask]]) -> retval\n",
      "    \n",
      "    normalize(...)\n",
      "        normalize(src[, dst[, alpha[, beta[, norm_type[, dtype[, mask]]]]]]) -> dst\n",
      "    \n",
      "    patchNaNs(...)\n",
      "        patchNaNs(a[, val]) -> None\n",
      "    \n",
      "    perspectiveTransform(...)\n",
      "        perspectiveTransform(src, m[, dst]) -> dst\n",
      "    \n",
      "    phase(...)\n",
      "        phase(x, y[, angle[, angleInDegrees]]) -> angle\n",
      "    \n",
      "    phaseCorrelate(...)\n",
      "        phaseCorrelate(src1, src2[, window]) -> retval\n",
      "    \n",
      "    phaseCorrelateRes(...)\n",
      "        phaseCorrelateRes(src1, src2, window) -> retval, response\n",
      "    \n",
      "    pointPolygonTest(...)\n",
      "        pointPolygonTest(contour, pt, measureDist) -> retval\n",
      "    \n",
      "    polarToCart(...)\n",
      "        polarToCart(magnitude, angle[, x[, y[, angleInDegrees]]]) -> x, y\n",
      "    \n",
      "    polylines(...)\n",
      "        polylines(img, pts, isClosed, color[, thickness[, lineType[, shift]]]) -> None\n",
      "    \n",
      "    pow(...)\n",
      "        pow(src, power[, dst]) -> dst\n",
      "    \n",
      "    preCornerDetect(...)\n",
      "        preCornerDetect(src, ksize[, dst[, borderType]]) -> dst\n",
      "    \n",
      "    projectPoints(...)\n",
      "        projectPoints(objectPoints, rvec, tvec, cameraMatrix, distCoeffs[, imagePoints[, jacobian[, aspectRatio]]]) -> imagePoints, jacobian\n",
      "    \n",
      "    putText(...)\n",
      "        putText(img, text, org, fontFace, fontScale, color[, thickness[, lineType[, bottomLeftOrigin]]]) -> None\n",
      "    \n",
      "    pyrDown(...)\n",
      "        pyrDown(src[, dst[, dstsize[, borderType]]]) -> dst\n",
      "    \n",
      "    pyrMeanShiftFiltering(...)\n",
      "        pyrMeanShiftFiltering(src, sp, sr[, dst[, maxLevel[, termcrit]]]) -> dst\n",
      "    \n",
      "    pyrUp(...)\n",
      "        pyrUp(src[, dst[, dstsize[, borderType]]]) -> dst\n",
      "    \n",
      "    randShuffle(...)\n",
      "        randShuffle(dst[, iterFactor]) -> None\n",
      "    \n",
      "    randn(...)\n",
      "        randn(dst, mean, stddev) -> None\n",
      "    \n",
      "    randu(...)\n",
      "        randu(dst, low, high) -> None\n",
      "    \n",
      "    rectangle(...)\n",
      "        rectangle(img, pt1, pt2, color[, thickness[, lineType[, shift]]]) -> None\n",
      "    \n",
      "    rectify3Collinear(...)\n",
      "        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\n",
      "    \n",
      "    reduce(...)\n",
      "        reduce(src, dim, rtype[, dst[, dtype]]) -> dst\n",
      "    \n",
      "    remap(...)\n",
      "        remap(src, map1, map2, interpolation[, dst[, borderMode[, borderValue]]]) -> dst\n",
      "    \n",
      "    repeat(...)\n",
      "        repeat(src, ny, nx[, dst]) -> dst\n",
      "    \n",
      "    reprojectImageTo3D(...)\n",
      "        reprojectImageTo3D(disparity, Q[, _3dImage[, handleMissingValues[, ddepth]]]) -> _3dImage\n",
      "    \n",
      "    resize(...)\n",
      "        resize(src, dsize[, dst[, fx[, fy[, interpolation]]]]) -> dst\n",
      "    \n",
      "    resizeWindow(...)\n",
      "        resizeWindow(winname, width, height) -> None\n",
      "    \n",
      "    scaleAdd(...)\n",
      "        scaleAdd(src1, alpha, src2[, dst]) -> dst\n",
      "    \n",
      "    segmentMotion(...)\n",
      "        segmentMotion(mhi, timestamp, segThresh[, segmask]) -> segmask, boundingRects\n",
      "    \n",
      "    sepFilter2D(...)\n",
      "        sepFilter2D(src, ddepth, kernelX, kernelY[, dst[, anchor[, delta[, borderType]]]]) -> dst\n",
      "    \n",
      "    setIdentity(...)\n",
      "        setIdentity(mtx[, s]) -> None\n",
      "    \n",
      "    setMouseCallback(...)\n",
      "        setMouseCallback(windowName, onMouse [, param]) -> None\n",
      "    \n",
      "    setTrackbarPos(...)\n",
      "        setTrackbarPos(trackbarname, winname, pos) -> None\n",
      "    \n",
      "    setUseOptimized(...)\n",
      "        setUseOptimized(onoff) -> None\n",
      "    \n",
      "    setWindowProperty(...)\n",
      "        setWindowProperty(winname, prop_id, prop_value) -> None\n",
      "    \n",
      "    solve(...)\n",
      "        solve(src1, src2[, dst[, flags]]) -> retval, dst\n",
      "    \n",
      "    solveCubic(...)\n",
      "        solveCubic(coeffs[, roots]) -> retval, roots\n",
      "    \n",
      "    solvePnP(...)\n",
      "        solvePnP(objectPoints, imagePoints, cameraMatrix, distCoeffs[, rvec[, tvec[, useExtrinsicGuess[, flags]]]]) -> retval, rvec, tvec\n",
      "    \n",
      "    solvePnPRansac(...)\n",
      "        solvePnPRansac(objectPoints, imagePoints, cameraMatrix, distCoeffs[, rvec[, tvec[, useExtrinsicGuess[, iterationsCount[, reprojectionError[, minInliersCount[, inliers[, flags]]]]]]]]) -> rvec, tvec, inliers\n",
      "    \n",
      "    solvePoly(...)\n",
      "        solvePoly(coeffs[, roots[, maxIters]]) -> retval, roots\n",
      "    \n",
      "    sort(...)\n",
      "        sort(src, flags[, dst]) -> dst\n",
      "    \n",
      "    sortIdx(...)\n",
      "        sortIdx(src, flags[, dst]) -> dst\n",
      "    \n",
      "    split(...)\n",
      "        split(m[, mv]) -> mv\n",
      "    \n",
      "    sqrt(...)\n",
      "        sqrt(src[, dst]) -> dst\n",
      "    \n",
      "    startWindowThread(...)\n",
      "        startWindowThread() -> retval\n",
      "    \n",
      "    stereoCalibrate(...)\n",
      "        stereoCalibrate(objectPoints, imagePoints1, imagePoints2, imageSize[, cameraMatrix1[, distCoeffs1[, cameraMatrix2[, distCoeffs2[, R[, T[, E[, F[, criteria[, flags]]]]]]]]]]) -> retval, cameraMatrix1, distCoeffs1, cameraMatrix2, distCoeffs2, R, T, E, F\n",
      "    \n",
      "    stereoRectify(...)\n",
      "        stereoRectify(cameraMatrix1, distCoeffs1, cameraMatrix2, distCoeffs2, imageSize, R, T[, R1[, R2[, P1[, P2[, Q[, flags[, alpha[, newImageSize]]]]]]]]) -> R1, R2, P1, P2, Q, validPixROI1, validPixROI2\n",
      "    \n",
      "    stereoRectifyUncalibrated(...)\n",
      "        stereoRectifyUncalibrated(points1, points2, F, imgSize[, H1[, H2[, threshold]]]) -> retval, H1, H2\n",
      "    \n",
      "    subtract(...)\n",
      "        subtract(src1, src2[, dst[, mask[, dtype]]]) -> dst\n",
      "    \n",
      "    sumElems(...)\n",
      "        sumElems(src) -> retval\n",
      "    \n",
      "    threshold(...)\n",
      "        threshold(src, thresh, maxval, type[, dst]) -> retval, dst\n",
      "    \n",
      "    trace(...)\n",
      "        trace(mtx) -> retval\n",
      "    \n",
      "    transform(...)\n",
      "        transform(src, m[, dst]) -> dst\n",
      "    \n",
      "    transpose(...)\n",
      "        transpose(src[, dst]) -> dst\n",
      "    \n",
      "    triangulatePoints(...)\n",
      "        triangulatePoints(projMatr1, projMatr2, projPoints1, projPoints2[, points4D]) -> points4D\n",
      "    \n",
      "    undistort(...)\n",
      "        undistort(src, cameraMatrix, distCoeffs[, dst[, newCameraMatrix]]) -> dst\n",
      "    \n",
      "    undistortPoints(...)\n",
      "        undistortPoints(src, cameraMatrix, distCoeffs[, dst[, R[, P]]]) -> dst\n",
      "    \n",
      "    updateMotionHistory(...)\n",
      "        updateMotionHistory(silhouette, mhi, timestamp, duration) -> None\n",
      "    \n",
      "    useOptimized(...)\n",
      "        useOptimized() -> retval\n",
      "    \n",
      "    validateDisparity(...)\n",
      "        validateDisparity(disparity, cost, minDisparity, numberOfDisparities[, disp12MaxDisp]) -> None\n",
      "    \n",
      "    vconcat(...)\n",
      "        vconcat(src[, dst]) -> dst\n",
      "    \n",
      "    waitKey(...)\n",
      "        waitKey([, delay]) -> retval\n",
      "    \n",
      "    warpAffine(...)\n",
      "        warpAffine(src, M, dsize[, dst[, flags[, borderMode[, borderValue]]]]) -> dst\n",
      "    \n",
      "    warpPerspective(...)\n",
      "        warpPerspective(src, M, dsize[, dst[, flags[, borderMode[, borderValue]]]]) -> dst\n",
      "    \n",
      "    watershed(...)\n",
      "        watershed(image, markers) -> None\n",
      "\n",
      "DATA\n",
      "    ADAPTIVE_SKIN_DETECTOR_MORPHING_METHOD_ERODE = 1L\n",
      "    ADAPTIVE_SKIN_DETECTOR_MORPHING_METHOD_ERODE_DILATE = 3L\n",
      "    ADAPTIVE_SKIN_DETECTOR_MORPHING_METHOD_ERODE_ERODE = 2L\n",
      "    ADAPTIVE_SKIN_DETECTOR_MORPHING_METHOD_NONE = 0L\n",
      "    ADAPTIVE_THRESH_GAUSSIAN_C = 1L\n",
      "    ADAPTIVE_THRESH_MEAN_C = 0L\n",
      "    ANN_MLP_GAUSSIAN = 2L\n",
      "    ANN_MLP_IDENTITY = 0L\n",
      "    ANN_MLP_NO_INPUT_SCALE = 2L\n",
      "    ANN_MLP_NO_OUTPUT_SCALE = 4L\n",
      "    ANN_MLP_SIGMOID_SYM = 1L\n",
      "    ANN_MLP_TRAIN_PARAMS_BACKPROP = 0L\n",
      "    ANN_MLP_TRAIN_PARAMS_RPROP = 1L\n",
      "    ANN_MLP_UPDATE_WEIGHTS = 1L\n",
      "    BOOST_DEFAULT = 0L\n",
      "    BOOST_DISCRETE = 0L\n",
      "    BOOST_GENTLE = 3L\n",
      "    BOOST_GINI = 1L\n",
      "    BOOST_LOGIT = 2L\n",
      "    BOOST_MISCLASS = 3L\n",
      "    BOOST_REAL = 1L\n",
      "    BOOST_SQERR = 4L\n",
      "    BORDER_CONSTANT = 0L\n",
      "    BORDER_DEFAULT = 4L\n",
      "    BORDER_ISOLATED = 16L\n",
      "    BORDER_REFLECT = 2L\n",
      "    BORDER_REFLECT101 = 4L\n",
      "    BORDER_REFLECT_101 = 4L\n",
      "    BORDER_REPLICATE = 1L\n",
      "    BORDER_TRANSPARENT = 5L\n",
      "    BORDER_WRAP = 3L\n",
      "    CALIB_CB_ADAPTIVE_THRESH = 1L\n",
      "    CALIB_CB_ASYMMETRIC_GRID = 2L\n",
      "    CALIB_CB_CLUSTERING = 4L\n",
      "    CALIB_CB_FAST_CHECK = 8L\n",
      "    CALIB_CB_FILTER_QUADS = 4L\n",
      "    CALIB_CB_NORMALIZE_IMAGE = 2L\n",
      "    CALIB_CB_SYMMETRIC_GRID = 1L\n",
      "    CALIB_FIX_ASPECT_RATIO = 2L\n",
      "    CALIB_FIX_FOCAL_LENGTH = 16L\n",
      "    CALIB_FIX_INTRINSIC = 256L\n",
      "    CALIB_FIX_K1 = 32L\n",
      "    CALIB_FIX_K2 = 64L\n",
      "    CALIB_FIX_K3 = 128L\n",
      "    CALIB_FIX_K4 = 2048L\n",
      "    CALIB_FIX_K5 = 4096L\n",
      "    CALIB_FIX_K6 = 8192L\n",
      "    CALIB_FIX_PRINCIPAL_POINT = 4L\n",
      "    CALIB_RATIONAL_MODEL = 16384L\n",
      "    CALIB_SAME_FOCAL_LENGTH = 512L\n",
      "    CALIB_USE_INTRINSIC_GUESS = 1L\n",
      "    CALIB_ZERO_DISPARITY = 1024L\n",
      "    CALIB_ZERO_TANGENT_DIST = 8L\n",
      "    CASCADE_DO_CANNY_PRUNING = 1L\n",
      "    CASCADE_DO_ROUGH_SEARCH = 8L\n",
      "    CASCADE_FIND_BIGGEST_OBJECT = 4L\n",
      "    CASCADE_SCALE_IMAGE = 2L\n",
      "    CHAIN_APPROX_NONE = 1L\n",
      "    CHAIN_APPROX_SIMPLE = 2L\n",
      "    CHAIN_APPROX_TC89_KCOS = 4L\n",
      "    CHAIN_APPROX_TC89_L1 = 3L\n",
      "    CMP_EQ = 0L\n",
      "    CMP_GE = 2L\n",
      "    CMP_GT = 1L\n",
      "    CMP_LE = 4L\n",
      "    CMP_LT = 3L\n",
      "    CMP_NE = 5L\n",
      "    COLORMAP_AUTUMN = 0L\n",
      "    COLORMAP_BONE = 1L\n",
      "    COLORMAP_COOL = 8L\n",
      "    COLORMAP_HOT = 11L\n",
      "    COLORMAP_HSV = 9L\n",
      "    COLORMAP_JET = 2L\n",
      "    COLORMAP_OCEAN = 5L\n",
      "    COLORMAP_PINK = 10L\n",
      "    COLORMAP_RAINBOW = 4L\n",
      "    COLORMAP_SPRING = 7L\n",
      "    COLORMAP_SUMMER = 6L\n",
      "    COLORMAP_WINTER = 3L\n",
      "    COLOR_BAYER_BG2BGR = 46L\n",
      "    COLOR_BAYER_BG2BGR_VNG = 62L\n",
      "    COLOR_BAYER_BG2GRAY = 86L\n",
      "    COLOR_BAYER_BG2RGB = 48L\n",
      "    COLOR_BAYER_BG2RGB_VNG = 64L\n",
      "    COLOR_BAYER_GB2BGR = 47L\n",
      "    COLOR_BAYER_GB2BGR_VNG = 63L\n",
      "    COLOR_BAYER_GB2GRAY = 87L\n",
      "    COLOR_BAYER_GB2RGB = 49L\n",
      "    COLOR_BAYER_GB2RGB_VNG = 65L\n",
      "    COLOR_BAYER_GR2BGR = 49L\n",
      "    COLOR_BAYER_GR2BGR_VNG = 65L\n",
      "    COLOR_BAYER_GR2GRAY = 89L\n",
      "    COLOR_BAYER_GR2RGB = 47L\n",
      "    COLOR_BAYER_GR2RGB_VNG = 63L\n",
      "    COLOR_BAYER_RG2BGR = 48L\n",
      "    COLOR_BAYER_RG2BGR_VNG = 64L\n",
      "    COLOR_BAYER_RG2GRAY = 88L\n",
      "    COLOR_BAYER_RG2RGB = 46L\n",
      "    COLOR_BAYER_RG2RGB_VNG = 62L\n",
      "    COLOR_BGR2BGR555 = 22L\n",
      "    COLOR_BGR2BGR565 = 12L\n",
      "    COLOR_BGR2BGRA = 0L\n",
      "    COLOR_BGR2GRAY = 6L\n",
      "    COLOR_BGR2HLS = 52L\n",
      "    COLOR_BGR2HLS_FULL = 68L\n",
      "    COLOR_BGR2HSV = 40L\n",
      "    COLOR_BGR2HSV_FULL = 66L\n",
      "    COLOR_BGR2LAB = 44L\n",
      "    COLOR_BGR2LUV = 50L\n",
      "    COLOR_BGR2RGB = 4L\n",
      "    COLOR_BGR2RGBA = 2L\n",
      "    COLOR_BGR2XYZ = 32L\n",
      "    COLOR_BGR2YCR_CB = 36L\n",
      "    COLOR_BGR2YUV = 82L\n",
      "    COLOR_BGR2YUV_I420 = 128L\n",
      "    COLOR_BGR2YUV_IYUV = 128L\n",
      "    COLOR_BGR2YUV_YV12 = 132L\n",
      "    COLOR_BGR5552BGR = 24L\n",
      "    COLOR_BGR5552BGRA = 28L\n",
      "    COLOR_BGR5552GRAY = 31L\n",
      "    COLOR_BGR5552RGB = 25L\n",
      "    COLOR_BGR5552RGBA = 29L\n",
      "    COLOR_BGR5652BGR = 14L\n",
      "    COLOR_BGR5652BGRA = 18L\n",
      "    COLOR_BGR5652GRAY = 21L\n",
      "    COLOR_BGR5652RGB = 15L\n",
      "    COLOR_BGR5652RGBA = 19L\n",
      "    COLOR_BGRA2BGR = 1L\n",
      "    COLOR_BGRA2BGR555 = 26L\n",
      "    COLOR_BGRA2BGR565 = 16L\n",
      "    COLOR_BGRA2GRAY = 10L\n",
      "    COLOR_BGRA2RGB = 3L\n",
      "    COLOR_BGRA2RGBA = 5L\n",
      "    COLOR_BGRA2YUV_I420 = 130L\n",
      "    COLOR_BGRA2YUV_IYUV = 130L\n",
      "    COLOR_BGRA2YUV_YV12 = 134L\n",
      "    COLOR_COLORCVT_MAX = 135L\n",
      "    COLOR_GRAY2BGR = 8L\n",
      "    COLOR_GRAY2BGR555 = 30L\n",
      "    COLOR_GRAY2BGR565 = 20L\n",
      "    COLOR_GRAY2BGRA = 9L\n",
      "    COLOR_GRAY2RGB = 8L\n",
      "    COLOR_GRAY2RGBA = 9L\n",
      "    COLOR_HLS2BGR = 60L\n",
      "    COLOR_HLS2BGR_FULL = 72L\n",
      "    COLOR_HLS2RGB = 61L\n",
      "    COLOR_HLS2RGB_FULL = 73L\n",
      "    COLOR_HSV2BGR = 54L\n",
      "    COLOR_HSV2BGR_FULL = 70L\n",
      "    COLOR_HSV2RGB = 55L\n",
      "    COLOR_HSV2RGB_FULL = 71L\n",
      "    COLOR_LAB2BGR = 56L\n",
      "    COLOR_LAB2LBGR = 78L\n",
      "    COLOR_LAB2LRGB = 79L\n",
      "    COLOR_LAB2RGB = 57L\n",
      "    COLOR_LBGR2LAB = 74L\n",
      "    COLOR_LBGR2LUV = 76L\n",
      "    COLOR_LRGB2LAB = 75L\n",
      "    COLOR_LRGB2LUV = 77L\n",
      "    COLOR_LUV2BGR = 58L\n",
      "    COLOR_LUV2LBGR = 80L\n",
      "    COLOR_LUV2LRGB = 81L\n",
      "    COLOR_LUV2RGB = 59L\n",
      "    COLOR_M_RGBA2RGBA = 126L\n",
      "    COLOR_RGB2BGR = 4L\n",
      "    COLOR_RGB2BGR555 = 23L\n",
      "    COLOR_RGB2BGR565 = 13L\n",
      "    COLOR_RGB2BGRA = 2L\n",
      "    COLOR_RGB2GRAY = 7L\n",
      "    COLOR_RGB2HLS = 53L\n",
      "    COLOR_RGB2HLS_FULL = 69L\n",
      "    COLOR_RGB2HSV = 41L\n",
      "    COLOR_RGB2HSV_FULL = 67L\n",
      "    COLOR_RGB2LAB = 45L\n",
      "    COLOR_RGB2LUV = 51L\n",
      "    COLOR_RGB2RGBA = 0L\n",
      "    COLOR_RGB2XYZ = 33L\n",
      "    COLOR_RGB2YCR_CB = 37L\n",
      "    COLOR_RGB2YUV = 83L\n",
      "    COLOR_RGB2YUV_I420 = 127L\n",
      "    COLOR_RGB2YUV_IYUV = 127L\n",
      "    COLOR_RGB2YUV_YV12 = 131L\n",
      "    COLOR_RGBA2BGR = 3L\n",
      "    COLOR_RGBA2BGR555 = 27L\n",
      "    COLOR_RGBA2BGR565 = 17L\n",
      "    COLOR_RGBA2BGRA = 5L\n",
      "    COLOR_RGBA2GRAY = 11L\n",
      "    COLOR_RGBA2M_RGBA = 125L\n",
      "    COLOR_RGBA2RGB = 1L\n",
      "    COLOR_RGBA2YUV_I420 = 129L\n",
      "    COLOR_RGBA2YUV_IYUV = 129L\n",
      "    COLOR_RGBA2YUV_YV12 = 133L\n",
      "    COLOR_XYZ2BGR = 34L\n",
      "    COLOR_XYZ2RGB = 35L\n",
      "    COLOR_YCR_CB2BGR = 38L\n",
      "    COLOR_YCR_CB2RGB = 39L\n",
      "    COLOR_YUV2BGR = 84L\n",
      "    COLOR_YUV2BGRA_I420 = 105L\n",
      "    COLOR_YUV2BGRA_IYUV = 105L\n",
      "    COLOR_YUV2BGRA_NV12 = 95L\n",
      "    COLOR_YUV2BGRA_NV21 = 97L\n",
      "    COLOR_YUV2BGRA_UYNV = 112L\n",
      "    COLOR_YUV2BGRA_UYVY = 112L\n",
      "    COLOR_YUV2BGRA_Y422 = 112L\n",
      "    COLOR_YUV2BGRA_YUNV = 120L\n",
      "    COLOR_YUV2BGRA_YUY2 = 120L\n",
      "    COLOR_YUV2BGRA_YUYV = 120L\n",
      "    COLOR_YUV2BGRA_YV12 = 103L\n",
      "    COLOR_YUV2BGRA_YVYU = 122L\n",
      "    COLOR_YUV2BGR_I420 = 101L\n",
      "    COLOR_YUV2BGR_IYUV = 101L\n",
      "    COLOR_YUV2BGR_NV12 = 91L\n",
      "    COLOR_YUV2BGR_NV21 = 93L\n",
      "    COLOR_YUV2BGR_UYNV = 108L\n",
      "    COLOR_YUV2BGR_UYVY = 108L\n",
      "    COLOR_YUV2BGR_Y422 = 108L\n",
      "    COLOR_YUV2BGR_YUNV = 116L\n",
      "    COLOR_YUV2BGR_YUY2 = 116L\n",
      "    COLOR_YUV2BGR_YUYV = 116L\n",
      "    COLOR_YUV2BGR_YV12 = 99L\n",
      "    COLOR_YUV2BGR_YVYU = 118L\n",
      "    COLOR_YUV2GRAY_420 = 106L\n",
      "    COLOR_YUV2GRAY_I420 = 106L\n",
      "    COLOR_YUV2GRAY_IYUV = 106L\n",
      "    COLOR_YUV2GRAY_NV12 = 106L\n",
      "    COLOR_YUV2GRAY_NV21 = 106L\n",
      "    COLOR_YUV2GRAY_UYNV = 123L\n",
      "    COLOR_YUV2GRAY_UYVY = 123L\n",
      "    COLOR_YUV2GRAY_Y422 = 123L\n",
      "    COLOR_YUV2GRAY_YUNV = 124L\n",
      "    COLOR_YUV2GRAY_YUY2 = 124L\n",
      "    COLOR_YUV2GRAY_YUYV = 124L\n",
      "    COLOR_YUV2GRAY_YV12 = 106L\n",
      "    COLOR_YUV2GRAY_YVYU = 124L\n",
      "    COLOR_YUV2RGB = 85L\n",
      "    COLOR_YUV2RGBA_I420 = 104L\n",
      "    COLOR_YUV2RGBA_IYUV = 104L\n",
      "    COLOR_YUV2RGBA_NV12 = 94L\n",
      "    COLOR_YUV2RGBA_NV21 = 96L\n",
      "    COLOR_YUV2RGBA_UYNV = 111L\n",
      "    COLOR_YUV2RGBA_UYVY = 111L\n",
      "    COLOR_YUV2RGBA_Y422 = 111L\n",
      "    COLOR_YUV2RGBA_YUNV = 119L\n",
      "    COLOR_YUV2RGBA_YUY2 = 119L\n",
      "    COLOR_YUV2RGBA_YUYV = 119L\n",
      "    COLOR_YUV2RGBA_YV12 = 102L\n",
      "    COLOR_YUV2RGBA_YVYU = 121L\n",
      "    COLOR_YUV2RGB_I420 = 100L\n",
      "    COLOR_YUV2RGB_IYUV = 100L\n",
      "    COLOR_YUV2RGB_NV12 = 90L\n",
      "    COLOR_YUV2RGB_NV21 = 92L\n",
      "    COLOR_YUV2RGB_UYNV = 107L\n",
      "    COLOR_YUV2RGB_UYVY = 107L\n",
      "    COLOR_YUV2RGB_Y422 = 107L\n",
      "    COLOR_YUV2RGB_YUNV = 115L\n",
      "    COLOR_YUV2RGB_YUY2 = 115L\n",
      "    COLOR_YUV2RGB_YUYV = 115L\n",
      "    COLOR_YUV2RGB_YV12 = 98L\n",
      "    COLOR_YUV2RGB_YVYU = 117L\n",
      "    COLOR_YUV420P2BGR = 99L\n",
      "    COLOR_YUV420P2BGRA = 103L\n",
      "    COLOR_YUV420P2GRAY = 106L\n",
      "    COLOR_YUV420P2RGB = 98L\n",
      "    COLOR_YUV420P2RGBA = 102L\n",
      "    COLOR_YUV420SP2BGR = 93L\n",
      "    COLOR_YUV420SP2BGRA = 97L\n",
      "    COLOR_YUV420SP2GRAY = 106L\n",
      "    COLOR_YUV420SP2RGB = 92L\n",
      "    COLOR_YUV420SP2RGBA = 96L\n",
      "    COVAR_COLS = 16L\n",
      "    COVAR_NORMAL = 1L\n",
      "    COVAR_ROWS = 8L\n",
      "    COVAR_SCALE = 4L\n",
      "    COVAR_SCRAMBLED = 0L\n",
      "    COVAR_USE_AVG = 2L\n",
      "    CV_16S = 3\n",
      "    CV_16SC1 = 3\n",
      "    CV_16SC2 = 11\n",
      "    CV_16SC3 = 19\n",
      "    CV_16SC4 = 27\n",
      "    CV_16U = 2\n",
      "    CV_16UC1 = 2\n",
      "    CV_16UC2 = 10\n",
      "    CV_16UC3 = 18\n",
      "    CV_16UC4 = 26\n",
      "    CV_32F = 5\n",
      "    CV_32FC1 = 5\n",
      "    CV_32FC2 = 13\n",
      "    CV_32FC3 = 21\n",
      "    CV_32FC4 = 29\n",
      "    CV_32S = 4\n",
      "    CV_32SC1 = 4\n",
      "    CV_32SC2 = 12\n",
      "    CV_32SC3 = 20\n",
      "    CV_32SC4 = 28\n",
      "    CV_64F = 6\n",
      "    CV_64FC1 = 6\n",
      "    CV_64FC2 = 14\n",
      "    CV_64FC3 = 22\n",
      "    CV_64FC4 = 30\n",
      "    CV_8S = 1\n",
      "    CV_8SC1 = 1\n",
      "    CV_8SC2 = 9\n",
      "    CV_8SC3 = 17\n",
      "    CV_8SC4 = 25\n",
      "    CV_8U = 0\n",
      "    CV_8UC1 = 0\n",
      "    CV_8UC2 = 8\n",
      "    CV_8UC3 = 16\n",
      "    CV_8UC4 = 24\n",
      "    CV_AA = 16\n",
      "    CV_EPNP = 1L\n",
      "    CV_HIST_ARRAY = 0\n",
      "    CV_HIST_SPARSE = 1\n",
      "    CV_ITERATIVE = 0L\n",
      "    CV_LOAD_IMAGE_COLOR = 1\n",
      "    CV_LOAD_IMAGE_GRAYSCALE = 0\n",
      "    CV_LOAD_IMAGE_UNCHANGED = -1\n",
      "    CV_NEXT_AROUND_DST = 34\n",
      "    CV_NEXT_AROUND_LEFT = 19\n",
      "    CV_NEXT_AROUND_ORG = 0\n",
      "    CV_NEXT_AROUND_RIGHT = 49\n",
      "    CV_P3P = 2L\n",
      "    CV_PREV_AROUND_DST = 51\n",
      "    CV_PREV_AROUND_LEFT = 32\n",
      "    CV_PREV_AROUND_ORG = 17\n",
      "    CV_PREV_AROUND_RIGHT = 2\n",
      "    CV_PTLOC_INSIDE = 0\n",
      "    CV_PTLOC_ON_EDGE = 2\n",
      "    CV_PTLOC_OUTSIDE_RECT = -1\n",
      "    CV_PTLOC_VERTEX = 1\n",
      "    CV_ROW_SAMPLE = 1\n",
      "    CV_VAR_CATEGORICAL = 1\n",
      "    CV_VAR_NUMERICAL = 0\n",
      "    CV_VAR_ORDERED = 0\n",
      "    CV_WINDOW_AUTOSIZE = 1\n",
      "    DCT_INVERSE = 1L\n",
      "    DCT_ROWS = 4L\n",
      "    DECOMP_CHOLESKY = 3L\n",
      "    DECOMP_EIG = 2L\n",
      "    DECOMP_LU = 0L\n",
      "    DECOMP_NORMAL = 16L\n",
      "    DECOMP_QR = 4L\n",
      "    DECOMP_SVD = 1L\n",
      "    DEPTH_MASK = 7L\n",
      "    DEPTH_MASK_16S = 8L\n",
      "    DEPTH_MASK_16U = 4L\n",
      "    DEPTH_MASK_32F = 32L\n",
      "    DEPTH_MASK_32S = 16L\n",
      "    DEPTH_MASK_64F = 64L\n",
      "    DEPTH_MASK_8S = 2L\n",
      "    DEPTH_MASK_8U = 1L\n",
      "    DEPTH_MASK_ALL = 127L\n",
      "    DEPTH_MASK_ALL_BUT_8S = 125L\n",
      "    DEPTH_MASK_FLT = 96L\n",
      "    DFT_COMPLEX_OUTPUT = 16L\n",
      "    DFT_INVERSE = 1L\n",
      "    DFT_REAL_OUTPUT = 32L\n",
      "    DFT_ROWS = 4L\n",
      "    DFT_SCALE = 2L\n",
      "    DIST_LABEL_CCOMP = 0L\n",
      "    DIST_LABEL_PIXEL = 1L\n",
      "    DRAW_MATCHES_FLAGS_DEFAULT = 0L\n",
      "    DRAW_MATCHES_FLAGS_DRAW_OVER_OUTIMG = 1L\n",
      "    DRAW_MATCHES_FLAGS_DRAW_RICH_KEYPOINTS = 4L\n",
      "    DRAW_MATCHES_FLAGS_NOT_DRAW_SINGLE_POINTS = 2L\n",
      "    EM_COV_MAT_DEFAULT = 1L\n",
      "    EM_COV_MAT_DIAGONAL = 1L\n",
      "    EM_COV_MAT_GENERIC = 2L\n",
      "    EM_COV_MAT_SPHERICAL = 0L\n",
      "    EM_DEFAULT_MAX_ITERS = 100L\n",
      "    EM_DEFAULT_NCLUSTERS = 5L\n",
      "    EM_START_AUTO_STEP = 0L\n",
      "    EM_START_E_STEP = 1L\n",
      "    EM_START_M_STEP = 2L\n",
      "    EPNP = 1L\n",
      "    EVENT_FLAG_ALTKEY = 32L\n",
      "    EVENT_FLAG_CTRLKEY = 8L\n",
      "    EVENT_FLAG_LBUTTON = 1L\n",
      "    EVENT_FLAG_MBUTTON = 4L\n",
      "    EVENT_FLAG_RBUTTON = 2L\n",
      "    EVENT_FLAG_SHIFTKEY = 16L\n",
      "    EVENT_LBUTTONDBLCLK = 7L\n",
      "    EVENT_LBUTTONDOWN = 1L\n",
      "    EVENT_LBUTTONUP = 4L\n",
      "    EVENT_MBUTTONDBLCLK = 9L\n",
      "    EVENT_MBUTTONDOWN = 3L\n",
      "    EVENT_MBUTTONUP = 6L\n",
      "    EVENT_MOUSEMOVE = 0L\n",
      "    EVENT_RBUTTONDBLCLK = 8L\n",
      "    EVENT_RBUTTONDOWN = 2L\n",
      "    EVENT_RBUTTONUP = 5L\n",
      "    FAST_FEATURE_DETECTOR_TYPE_5_8 = 0L\n",
      "    FAST_FEATURE_DETECTOR_TYPE_7_12 = 1L\n",
      "    FAST_FEATURE_DETECTOR_TYPE_9_16 = 2L\n",
      "    FEATURE_EVALUATOR_HAAR = 0L\n",
      "    FEATURE_EVALUATOR_HOG = 2L\n",
      "    FEATURE_EVALUATOR_LBP = 1L\n",
      "    FILE_NODE_EMPTY = 32L\n",
      "    FILE_NODE_FLOAT = 2L\n",
      "    FILE_NODE_FLOW = 8L\n",
      "    FILE_NODE_INT = 1L\n",
      "    FILE_NODE_MAP = 6L\n",
      "    FILE_NODE_NAMED = 64L\n",
      "    FILE_NODE_NONE = 0L\n",
      "    FILE_NODE_REAL = 2L\n",
      "    FILE_NODE_REF = 4L\n",
      "    FILE_NODE_SEQ = 5L\n",
      "    FILE_NODE_STR = 3L\n",
      "    FILE_NODE_STRING = 3L\n",
      "    FILE_NODE_TYPE_MASK = 7L\n",
      "    FILE_NODE_USER = 16L\n",
      "    FILE_STORAGE_APPEND = 2L\n",
      "    FILE_STORAGE_FORMAT_AUTO = 0L\n",
      "    FILE_STORAGE_FORMAT_MASK = 56L\n",
      "    FILE_STORAGE_FORMAT_XML = 8L\n",
      "    FILE_STORAGE_FORMAT_YAML = 16L\n",
      "    FILE_STORAGE_INSIDE_MAP = 4L\n",
      "    FILE_STORAGE_MEMORY = 4L\n",
      "    FILE_STORAGE_NAME_EXPECTED = 2L\n",
      "    FILE_STORAGE_READ = 0L\n",
      "    FILE_STORAGE_UNDEFINED = 0L\n",
      "    FILE_STORAGE_VALUE_EXPECTED = 1L\n",
      "    FILE_STORAGE_WRITE = 1L\n",
      "    FLOODFILL_FIXED_RANGE = 65536L\n",
      "    FLOODFILL_MASK_ONLY = 131072L\n",
      "    FM_7POINT = 1L\n",
      "    FM_8POINT = 2L\n",
      "    FM_LMEDS = 4L\n",
      "    FM_RANSAC = 8L\n",
      "    FONT_HERSHEY_COMPLEX = 3L\n",
      "    FONT_HERSHEY_COMPLEX_SMALL = 5L\n",
      "    FONT_HERSHEY_DUPLEX = 2L\n",
      "    FONT_HERSHEY_PLAIN = 1L\n",
      "    FONT_HERSHEY_SCRIPT_COMPLEX = 7L\n",
      "    FONT_HERSHEY_SCRIPT_SIMPLEX = 6L\n",
      "    FONT_HERSHEY_SIMPLEX = 0L\n",
      "    FONT_HERSHEY_TRIPLEX = 4L\n",
      "    FONT_ITALIC = 16L\n",
      "    FREAK_NB_ORIENPAIRS = 45L\n",
      "    FREAK_NB_PAIRS = 512L\n",
      "    FREAK_NB_SCALES = 64L\n",
      "    FUZZY_MEAN_SHIFT_TRACKER_MIN_KERNEL_MASS = 1000L\n",
      "    FUZZY_MEAN_SHIFT_TRACKER_RM_EDGE_DENSITY_FUZZY = 1L\n",
      "    FUZZY_MEAN_SHIFT_TRACKER_RM_EDGE_DENSITY_LINEAR = 0L\n",
      "    FUZZY_MEAN_SHIFT_TRACKER_RM_INNER_DENSITY = 2L\n",
      "    FUZZY_MEAN_SHIFT_TRACKER_TS_DISABLED = 10L\n",
      "    FUZZY_MEAN_SHIFT_TRACKER_TS_NONE = 0L\n",
      "    FUZZY_MEAN_SHIFT_TRACKER_TS_SEARCHING = 1L\n",
      "    FUZZY_MEAN_SHIFT_TRACKER_TS_SET_WINDOW = 3L\n",
      "    FUZZY_MEAN_SHIFT_TRACKER_TS_TRACKING = 2L\n",
      "    GBTREES_ABSOLUTE_LOSS = 1L\n",
      "    GBTREES_DEVIANCE_LOSS = 4L\n",
      "    GBTREES_HUBER_LOSS = 3L\n",
      "    GBTREES_SQUARED_LOSS = 0L\n",
      "    GC_BGD = 0L\n",
      "    GC_EVAL = 2L\n",
      "    GC_FGD = 1L\n",
      "    GC_INIT_WITH_MASK = 1L\n",
      "    GC_INIT_WITH_RECT = 0L\n",
      "    GC_PR_BGD = 2L\n",
      "    GC_PR_FGD = 3L\n",
      "    GEMM_1_T = 1L\n",
      "    GEMM_2_T = 2L\n",
      "    GEMM_3_T = 4L\n",
      "    GHT_POSITION = 0L\n",
      "    GHT_ROTATION = 2L\n",
      "    GHT_SCALE = 1L\n",
      "    HAMMING_NORM_TYPE = 6L\n",
      "    HOGDESCRIPTOR_DEFAULT_NLEVELS = 64L\n",
      "    HOGDESCRIPTOR_L2HYS = 0L\n",
      "    IMREAD_ANYCOLOR = 4L\n",
      "    IMREAD_ANYDEPTH = 2L\n",
      "    IMREAD_COLOR = 1L\n",
      "    IMREAD_GRAYSCALE = 0L\n",
      "    IMREAD_UNCHANGED = -1L\n",
      "    IMWRITE_JPEG_QUALITY = 1L\n",
      "    IMWRITE_PNG_BILEVEL = 18L\n",
      "    IMWRITE_PNG_COMPRESSION = 16L\n",
      "    IMWRITE_PNG_STRATEGY = 17L\n",
      "    IMWRITE_PNG_STRATEGY_DEFAULT = 0L\n",
      "    IMWRITE_PNG_STRATEGY_FILTERED = 1L\n",
      "    IMWRITE_PNG_STRATEGY_FIXED = 4L\n",
      "    IMWRITE_PNG_STRATEGY_HUFFMAN_ONLY = 2L\n",
      "    IMWRITE_PNG_STRATEGY_RLE = 3L\n",
      "    IMWRITE_PXM_BINARY = 32L\n",
      "    INPAINT_NS = 0L\n",
      "    INPAINT_TELEA = 1L\n",
      "    INTER_AREA = 3L\n",
      "    INTER_BITS = 5L\n",
      "    INTER_BITS2 = 10L\n",
      "    INTER_CUBIC = 2L\n",
      "    INTER_LANCZOS4 = 4L\n",
      "    INTER_LINEAR = 1L\n",
      "    INTER_MAX = 7L\n",
      "    INTER_NEAREST = 0L\n",
      "    INTER_TAB_SIZE = 32L\n",
      "    INTER_TAB_SIZE2 = 1024L\n",
      "    IPL_DEPTH_16S = 2147483664L\n",
      "    IPL_DEPTH_16U = 16L\n",
      "    IPL_DEPTH_32F = 32L\n",
      "    IPL_DEPTH_32S = 2147483680L\n",
      "    IPL_DEPTH_64F = 64L\n",
      "    IPL_DEPTH_8S = 2147483656L\n",
      "    IPL_DEPTH_8U = 8L\n",
      "    ITERATIVE = 0L\n",
      "    KERNEL_ASYMMETRICAL = 2L\n",
      "    KERNEL_GENERAL = 0L\n",
      "    KERNEL_INTEGER = 8L\n",
      "    KERNEL_SMOOTH = 4L\n",
      "    KERNEL_SYMMETRICAL = 1L\n",
      "    KMEANS_PP_CENTERS = 2L\n",
      "    KMEANS_RANDOM_CENTERS = 0L\n",
      "    KMEANS_USE_INITIAL_LABELS = 1L\n",
      "    LEV_MARQ_CALC_J = 2L\n",
      "    LEV_MARQ_CHECK_ERR = 3L\n",
      "    LEV_MARQ_DONE = 0L\n",
      "    LEV_MARQ_STARTED = 1L\n",
      "    LMEDS = 4L\n",
      "    MAGIC_MASK = 4294901760L\n",
      "    MAT_AUTO_STEP = 0L\n",
      "    MAT_CONTINUOUS_FLAG = 16384L\n",
      "    MAT_MAGIC_VAL = 1124007936L\n",
      "    MAT_SUBMATRIX_FLAG = 32768L\n",
      "    MORPH_BLACKHAT = 6L\n",
      "    MORPH_CLOSE = 3L\n",
      "    MORPH_CROSS = 1L\n",
      "    MORPH_DILATE = 1L\n",
      "    MORPH_ELLIPSE = 2L\n",
      "    MORPH_ERODE = 0L\n",
      "    MORPH_GRADIENT = 4L\n",
      "    MORPH_OPEN = 2L\n",
      "    MORPH_RECT = 0L\n",
      "    MORPH_TOPHAT = 5L\n",
      "    NORM_HAMMING = 6L\n",
      "    NORM_HAMMING2 = 7L\n",
      "    NORM_INF = 1L\n",
      "    NORM_L1 = 2L\n",
      "    NORM_L2 = 4L\n",
      "    NORM_L2SQR = 5L\n",
      "    NORM_MINMAX = 32L\n",
      "    NORM_RELATIVE = 8L\n",
      "    NORM_TYPE_MASK = 7L\n",
      "    OPTFLOW_FARNEBACK_GAUSSIAN = 256L\n",
      "    OPTFLOW_LK_GET_MIN_EIGENVALS = 8L\n",
      "    OPTFLOW_USE_INITIAL_FLOW = 4L\n",
      "    ORB_FAST_SCORE = 1L\n",
      "    ORB_HARRIS_SCORE = 0L\n",
      "    ORB_K_BYTES = 32L\n",
      "    P3P = 2L\n",
      "    PARAM_ALGORITHM = 6L\n",
      "    PARAM_BOOLEAN = 1L\n",
      "    PARAM_FLOAT = 7L\n",
      "    PARAM_GRID_SVM_C = 0L\n",
      "    PARAM_GRID_SVM_COEF = 4L\n",
      "    PARAM_GRID_SVM_DEGREE = 5L\n",
      "    PARAM_GRID_SVM_GAMMA = 1L\n",
      "    PARAM_GRID_SVM_NU = 3L\n",
      "    PARAM_GRID_SVM_P = 2L\n",
      "    PARAM_INT = 0L\n",
      "    PARAM_MAT = 4L\n",
      "    PARAM_MAT_VECTOR = 5L\n",
      "    PARAM_REAL = 2L\n",
      "    PARAM_SHORT = 10L\n",
      "    PARAM_STRING = 3L\n",
      "    PARAM_UCHAR = 11L\n",
      "    PARAM_UINT64 = 9L\n",
      "    PARAM_UNSIGNED_INT = 8L\n",
      "    PROJ_SPHERICAL_EQRECT = 1L\n",
      "    PROJ_SPHERICAL_ORTHO = 0L\n",
      "    RANSAC = 8L\n",
      "    RETR_CCOMP = 2L\n",
      "    RETR_EXTERNAL = 0L\n",
      "    RETR_FLOODFILL = 4L\n",
      "    RETR_LIST = 1L\n",
      "    RETR_TREE = 3L\n",
      "    RIGID_BODY_MOTION = 4L\n",
      "    RNG_NORMAL = 1L\n",
      "    RNG_UNIFORM = 0L\n",
      "    ROTATION = 1L\n",
      "    SELF_SIM_DESCRIPTOR_DEFAULT_LARGE_SIZE = 41L\n",
      "    SELF_SIM_DESCRIPTOR_DEFAULT_NUM_ANGLES = 20L\n",
      "    SELF_SIM_DESCRIPTOR_DEFAULT_NUM_DISTANCE_BUCKETS = 7L\n",
      "    SELF_SIM_DESCRIPTOR_DEFAULT_SMALL_SIZE = 5L\n",
      "    SELF_SIM_DESCRIPTOR_DEFAULT_START_DISTANCE_BUCKET = 3L\n",
      "    SORT_ASCENDING = 0L\n",
      "    SORT_DESCENDING = 16L\n",
      "    SORT_EVERY_COLUMN = 1L\n",
      "    SORT_EVERY_ROW = 0L\n",
      "    SPARSE_MAT_HASH_BIT = 2147483648L\n",
      "    SPARSE_MAT_HASH_SCALE = 1540483477L\n",
      "    SPARSE_MAT_MAGIC_VAL = 1123876864L\n",
      "    SPARSE_MAT_MAX_DIM = 32L\n",
      "    STEREO_BM_BASIC_PRESET = 0L\n",
      "    STEREO_BM_FISH_EYE_PRESET = 1L\n",
      "    STEREO_BM_NARROW_PRESET = 2L\n",
      "    STEREO_BM_PREFILTER_NORMALIZED_RESPONSE = 0L\n",
      "    STEREO_BM_PREFILTER_XSOBEL = 1L\n",
      "    STEREO_SGBM_DISP_SCALE = 16L\n",
      "    STEREO_SGBM_DISP_SHIFT = 4L\n",
      "    STEREO_VAR_CYCLE_O = 0L\n",
      "    STEREO_VAR_CYCLE_V = 1L\n",
      "    STEREO_VAR_PENALIZATION_CHARBONNIER = 1L\n",
      "    STEREO_VAR_PENALIZATION_PERONA_MALIK = 2L\n",
      "    STEREO_VAR_PENALIZATION_TICHONOV = 0L\n",
      "    STEREO_VAR_USE_AUTO_PARAMS = 8L\n",
      "    STEREO_VAR_USE_EQUALIZE_HIST = 2L\n",
      "    STEREO_VAR_USE_INITIAL_DISPARITY = 1L\n",
      "    STEREO_VAR_USE_MEDIAN_FILTERING = 16L\n",
      "    STEREO_VAR_USE_SMART_ID = 4L\n",
      "    SUBDIV2D_NEXT_AROUND_DST = 34L\n",
      "    SUBDIV2D_NEXT_AROUND_LEFT = 19L\n",
      "    SUBDIV2D_NEXT_AROUND_ORG = 0L\n",
      "    SUBDIV2D_NEXT_AROUND_RIGHT = 49L\n",
      "    SUBDIV2D_PREV_AROUND_DST = 51L\n",
      "    SUBDIV2D_PREV_AROUND_LEFT = 32L\n",
      "    SUBDIV2D_PREV_AROUND_ORG = 17L\n",
      "    SUBDIV2D_PREV_AROUND_RIGHT = 2L\n",
      "    SUBDIV2D_PTLOC_ERROR = -2L\n",
      "    SUBDIV2D_PTLOC_INSIDE = 0L\n",
      "    SUBDIV2D_PTLOC_ON_EDGE = 2L\n",
      "    SUBDIV2D_PTLOC_OUTSIDE_RECT = -1L\n",
      "    SUBDIV2D_PTLOC_VERTEX = 1L\n",
      "    SVD_FULL_UV = 4L\n",
      "    SVD_MODIFY_A = 1L\n",
      "    SVD_NO_UV = 2L\n",
      "    SVM_C = 0L\n",
      "    SVM_COEF = 4L\n",
      "    SVM_C_SVC = 100L\n",
      "    SVM_DEGREE = 5L\n",
      "    SVM_EPS_SVR = 103L\n",
      "    SVM_GAMMA = 1L\n",
      "    SVM_LINEAR = 0L\n",
      "    SVM_NU = 3L\n",
      "    SVM_NU_SVC = 101L\n",
      "    SVM_NU_SVR = 104L\n",
      "    SVM_ONE_CLASS = 102L\n",
      "    SVM_P = 2L\n",
      "    SVM_POLY = 1L\n",
      "    SVM_RBF = 2L\n",
      "    SVM_SIGMOID = 3L\n",
      "    TERM_CRITERIA_COUNT = 1L\n",
      "    TERM_CRITERIA_EPS = 2L\n",
      "    TERM_CRITERIA_MAX_ITER = 1L\n",
      "    THRESH_BINARY = 0L\n",
      "    THRESH_BINARY_INV = 1L\n",
      "    THRESH_MASK = 7L\n",
      "    THRESH_OTSU = 8L\n",
      "    THRESH_TOZERO = 3L\n",
      "    THRESH_TOZERO_INV = 4L\n",
      "    THRESH_TRUNC = 2L\n",
      "    TM_CCOEFF = 4L\n",
      "    TM_CCOEFF_NORMED = 5L\n",
      "    TM_CCORR = 2L\n",
      "    TM_CCORR_NORMED = 3L\n",
      "    TM_SQDIFF = 0L\n",
      "    TM_SQDIFF_NORMED = 1L\n",
      "    TRANSLATION = 2L\n",
      "    TYPE_MASK = 4095L\n",
      "    WARP_INVERSE_MAP = 16L\n",
      "    WINDOW_AUTOSIZE = 1L\n",
      "    WINDOW_NORMAL = 0L\n",
      "    WINDOW_OPENGL = 4096L\n",
      "    WND_PROP_ASPECT_RATIO = 2L\n",
      "    WND_PROP_AUTOSIZE = 1L\n",
      "    WND_PROP_FULLSCREEN = 0L\n",
      "    WND_PROP_OPENGL = 3L\n",
      "    __version__ = '2.4.8'\n",
      "\n",
      "VERSION\n",
      "    2.4.8\n",
      "\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(cv2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 2",
   "language": "python",
   "name": "python2"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.11"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}