CoCalc -- 2015-06-17-084340-opencv.sagews

| Hosted by CoCalc | Download

import cv

help(cv)

Help on module cv:

NAME
    cv

FILE
    /usr/local/lib/python2.7/dist-packages/cv.py

FUNCTIONS
    16SC(...)
        CV_16SC(n) -> int
    
    16UC(...)
        CV_16UC(n) -> int
    
    32FC(...)
        CV_32FC(n) -> int
    
    32SC(...)
        CV_32SC(n) -> int
    
    64FC(...)
        CV_64FC(n) -> int
    
    8SC(...)
        CV_8SC(n) -> int
    
    8UC(...)
        CV_8UC(n) -> int
    
    Abs(...)
        Abs(src, dst) -> None
    
    AbsDiff(...)
        AbsDiff(src1, src2, dst) -> None
    
    AbsDiffS(...)
        AbsDiffS(src, dst, value) -> None
    
    Acc(...)
        Acc(image, sum [, mask]) -> None
    
    AdaptiveThreshold(...)
        AdaptiveThreshold(src, dst, maxValue [, adaptive_method [, thresholdType [, blockSize [, param1]]]]) -> None
    
    Add(...)
        Add(src1, src2, dst [, mask]) -> None
    
    AddS(...)
        AddS(src, value, dst [, mask]) -> None
    
    AddWeighted(...)
        AddWeighted(src1, alpha, src2, beta, gamma, dst) -> None
    
    And(...)
        And(src1, src2, dst [, mask]) -> None
    
    AndS(...)
        AndS(src, value, dst [, mask]) -> None
    
    ApproxChains(...)
        ApproxChains(src_seq, storage [, method [, parameter [, minimal_perimeter [, recursive]]]]) -> CvSeq*
    
    ApproxPoly(...)
        ApproxPoly(src_seq, storage, method [, parameter [, parameter2]]) -> None
    
    ArcLength(...)
        ArcLength(curve [, slice [, isClosed]]) -> double
    
    Avg(...)
        Avg(arr [, mask]) -> CvScalar
    
    AvgSdv(...)
        AvgSdv(arr [, mask]) -> mean,stdDev
    
    BackProjectPCA(...)
        BackProjectPCA(proj, avg, eigenvects, result) -> None
    
    BoundingRect(...)
        BoundingRect(points [, update]) -> CvRect
    
    BoxPoints(...)
        BoxPoints(box) -> points
    
    CMP(...)
        CV_CMP(a, b) -> int
    
    CV_16SC(...)
        CV_16SC(n) -> int
    
    CV_16UC(...)
        CV_16UC(n) -> int
    
    CV_32FC(...)
        CV_32FC(n) -> int
    
    CV_32SC(...)
        CV_32SC(n) -> int
    
    CV_64FC(...)
        CV_64FC(n) -> int
    
    CV_8SC(...)
        CV_8SC(n) -> int
    
    CV_8UC(...)
        CV_8UC(n) -> int
    
    CV_CMP(...)
        CV_CMP(a, b) -> int
    
    CV_FOURCC(...)
        CV_FOURCC(c1, c2, c3, c4) -> int
    
    CV_IABS(...)
        CV_IABS(a) -> int
    
    CV_IS_SEQ_CLOSED(...)
        CV_IS_SEQ_CLOSED(s) -> int
    
    CV_IS_SEQ_CONVEX(...)
        CV_IS_SEQ_CONVEX(s) -> int
    
    CV_IS_SEQ_CURVE(...)
        CV_IS_SEQ_CURVE(s) -> int
    
    CV_IS_SEQ_HOLE(...)
        CV_IS_SEQ_HOLE(s) -> int
    
    CV_IS_SEQ_INDEX(...)
        CV_IS_SEQ_INDEX(s) -> int
    
    CV_IS_SEQ_SIMPLE(...)
        CV_IS_SEQ_SIMPLE(s) -> int
    
    CV_MAKETYPE(...)
        CV_MAKETYPE(depth, cn) -> int
    
    CV_MAT_CN(...)
        CV_MAT_CN(i) -> int
    
    CV_MAT_DEPTH(...)
        CV_MAT_DEPTH(i) -> int
    
    CV_RGB(...)
        CV_RGB(red, grn, blu) -> CvScalar
    
    CV_SIGN(...)
        CV_SIGN(a) -> int
    
    CalcArrBackProject(...)
        CalcArrBackProject(image, back_project, hist) -> None
    
    CalcArrHist(...)
        CalcArrHist(image, hist [, accumulate [, mask]]) -> None
    
    CalcBackProject(...)
        CalcBackProject(image, back_project, hist) -> None
    
    CalcBackProjectPatch(...)
        CalcBackProjectPatch(images, dst, patch_size, hist, method, factor) -> None
    
    CalcCovarMatrix(...)
        CalcCovarMatrix(vects, covMat, avg, flags) -> None
    
    CalcEMD2(...)
        CalcEMD2(signature1, signature2, distance_type [, distance_func [, cost_matrix [, flow [, lower_bound [, userdata]]]]]) -> float
    
    CalcGlobalOrientation(...)
        CalcGlobalOrientation(orientation, mask, mhi, timestamp, duration) -> double
    
    CalcHist(...)
        CalcHist(image, hist [, accumulate [, mask]]) -> None
    
    CalcMotionGradient(...)
        CalcMotionGradient(mhi, mask, orientation, delta1, delta2 [, apertureSize]) -> None
    
    CalcOpticalFlowBM(...)
        CalcOpticalFlowBM(prev, curr, blockSize, shiftSize, max_range, usePrevious, velx, vely) -> None
    
    CalcOpticalFlowFarneback(...)
        CalcOpticalFlowFarneback(prev, curr, flow [, pyr_scale [, levels [, winsize [, iterations [, poly_n [, poly_sigma [, flags]]]]]]]) -> None
    
    CalcOpticalFlowHS(...)
        CalcOpticalFlowHS(prev, curr, usePrevious, velx, vely, lambda, criteria) -> None
    
    CalcOpticalFlowLK(...)
        CalcOpticalFlowLK(prev, curr, winSize, velx, vely) -> None
    
    CalcOpticalFlowPyrLK(...)
        CalcOpticalFlowPyrLK(prev, curr, prevPyr, currPyr, prevFeatures, winSize, level, criteria, flags [, guesses]) -> currFeatures,status,track_error
    
    CalcPCA(...)
        CalcPCA(data, avg, eigenvalues, eigenvectors, flags) -> None
    
    CalcProbDensity(...)
        CalcProbDensity(hist1, hist2, dst_hist [, scale]) -> None
    
    CalcSubdivVoronoi2D(...)
        CalcSubdivVoronoi2D(subdiv) -> None
    
    CalibrateCamera2(...)
        CalibrateCamera2(objectPoints, imagePoints, pointCounts, imageSize, cameraMatrix, distCoeffs, rvecs, tvecs [, flags]) -> None
    
    CalibrationMatrixValues(...)
        CalibrationMatrixValues(calibMatr, image_size [, apertureWidth [, apertureHeight]]) -> fovx,fovy,focalLength,principalPoint,pixelAspectRatio
    
    CamShift(...)
        CamShift(prob_image, window, criteria) -> int,comp,box
    
    Canny(...)
        Canny(image, edges, threshold1, threshold2 [, aperture_size]) -> None
    
    CaptureFromCAM(...)
        CaptureFromCAM(index) -> CvCapture*
    
    CaptureFromFile(...)
        CaptureFromFile(filename) -> CvCapture*
    
    CartToPolar(...)
        CartToPolar(x, y, magnitude [, angle [, angleInDegrees]]) -> None
    
    Cbrt(...)
        Cbrt(value) -> float
    
    Ceil(...)
        Ceil(value) -> int
    
    CheckArr(...)
        CheckArr(arr [, flags [, min_val [, max_val]]]) -> int
    
    CheckContourConvexity(...)
        CheckContourConvexity(contour) -> int
    
    Circle(...)
        Circle(img, center, radius, color [, thickness [, lineType [, shift]]]) -> None
    
    ClearHist(...)
        ClearHist(hist) -> None
    
    ClearND(...)
        ClearND(arr, idx) -> None
    
    ClearSeq(...)
        ClearSeq(seq) -> None
    
    ClearSubdivVoronoi2D(...)
        ClearSubdivVoronoi2D(subdiv) -> None
    
    ClipLine(...)
        ClipLine(imgSize, pt1, pt2) -> point1,point2
    
    CloneImage(...)
        CloneImage(image) -> IplImage*
    
    CloneMat(...)
        CloneMat(mat) -> CvMat*
    
    CloneMatND(...)
        CloneMatND(mat) -> CvMatND*
    
    CloneSeq(...)
        CloneSeq(seq, storage) -> None
    
    Cmp(...)
        Cmp(src1, src2, dst, cmpOp) -> None
    
    CmpS(...)
        CmpS(src, value, dst, cmpOp) -> None
    
    CompareHist(...)
        CompareHist(hist1, hist2, method) -> double
    
    ComputeCorrespondEpilines(...)
        ComputeCorrespondEpilines(points, whichImage, F, lines) -> None
    
    ContourArea(...)
        ContourArea(contour [, slice]) -> double
    
    Convert(...)
        Convert(src, dst) -> None
    
    ConvertImage(...)
        ConvertImage(src, dst [, flags]) -> None
    
    ConvertMaps(...)
        ConvertMaps(mapx, mapy, mapxy, mapalpha) -> None
    
    ConvertPointsHomogeneous(...)
        ConvertPointsHomogeneous(src, dst) -> None
    
    ConvertScale(...)
        ConvertScale(src, dst [, scale [, shift]]) -> None
    
    ConvertScaleAbs(...)
        ConvertScaleAbs(src, dst [, scale [, shift]]) -> None
    
    ConvexHull2(...)
        ConvexHull2(points, storage [, orientation [, return_points]]) -> CvSeq*
    
    ConvexityDefects(...)
        ConvexityDefects(contour, convexhull, storage) -> CvSeqOfCvConvexityDefect*
    
    Copy(...)
        Copy(src, dst [, mask]) -> None
    
    CopyMakeBorder(...)
        CopyMakeBorder(src, dst, offset, bordertype [, value]) -> None
    
    CornerEigenValsAndVecs(...)
        CornerEigenValsAndVecs(image, eigenvv, blockSize [, aperture_size]) -> None
    
    CornerHarris(...)
        CornerHarris(image, harris_dst, blockSize [, aperture_size [, k]]) -> None
    
    CornerMinEigenVal(...)
        CornerMinEigenVal(image, eigenval, blockSize [, aperture_size]) -> None
    
    CountNonZero(...)
        CountNonZero(arr) -> int
    
    CreateCameraCapture(...)
        CreateCameraCapture(index) -> CvCapture*
    
    CreateData(...)
        CreateData(arr) -> None
    
    CreateFileCapture(...)
        CreateFileCapture(filename) -> CvCapture*
    
    CreateHist(...)
        CreateHist(dims, type [, ranges [, uniform]]) -> CvHistogram
    
    CreateImage(...)
        CreateImage(size, depth, channels) -> IplImage*
    
    CreateImageHeader(...)
        CreateImageHeader(size, depth, channels) -> IplImage*
    
    CreateKalman(...)
        CreateKalman(dynam_params, measure_params [, control_params]) -> CvKalman*
    
    CreateMat(...)
        CreateMat(rows, cols, type) -> CvMat
    
    CreateMatHeader(...)
        CreateMatHeader(rows, cols, type) -> CvMat
    
    CreateMatND(...)
        CreateMatND(dims, type) -> CvMatND
    
    CreateMatNDHeader(...)
        CreateMatNDHeader(dims, type) -> CvMatND
    
    CreateMemStorage(...)
        CreateMemStorage( [, blockSize]) -> CvMemStorage
    
    CreatePOSITObject(...)
        CreatePOSITObject(points) -> CvPOSITObject*
    
    CreateStereoBMState(...)
        CreateStereoBMState( [, preset [, numberOfDisparities]]) -> CvStereoBMState*
    
    CreateStereoGCState(...)
        CreateStereoGCState(numberOfDisparities, maxIters) -> CvStereoGCState*
    
    CreateStructuringElementEx(...)
        CreateStructuringElementEx(cols, rows, anchorX, anchorY, shape [, values]) -> IplConvKernel*
    
    CreateSubdivDelaunay2D(...)
        CreateSubdivDelaunay2D(rect, storage) -> CvSubdiv2D*
    
    CreateTrackbar(...)
        CreateTrackbar(trackbarName, windowName, value, count, onChange) -> None
    
    CreateVideoWriter(...)
        CreateVideoWriter(filename, fourcc, fps, frame_size [, is_color]) -> CvVideoWriter*
    
    CrossProduct(...)
        CrossProduct(src1, src2, dst) -> None
    
    CvtColor(...)
        CvtColor(src, dst, code) -> None
    
    CvtPixToPlane(...)
        CvtPixToPlane(src, dst0, dst1, dst2, dst3) -> None
    
    CvtScale(...)
        CvtScale(src, dst [, scale [, shift]]) -> None
    
    DCT(...)
        DCT(src, dst, flags) -> None
    
    DFT(...)
        DFT(src, dst, flags [, nonzeroRows]) -> None
    
    DecodeImage(...)
        DecodeImage(buf [, iscolor]) -> IplImage*
    
    DecodeImageM(...)
        DecodeImageM(buf [, iscolor]) -> CvMat*
    
    DecomposeProjectionMatrix(...)
        DecomposeProjectionMatrix(projMatrix, cameraMatrix, rotMatrix, transVect [, rotMatrX [, rotMatrY [, rotMatrZ]]]) -> eulerAngles
    
    DestroyAllWindows(...)
        DestroyAllWindows() -> None
    
    DestroyWindow(...)
        DestroyWindow(name) -> None
    
    Det(...)
        Det(mat) -> double
    
    Dilate(...)
        Dilate(src, dst [, element [, iterations]]) -> None
    
    DistTransform(...)
        DistTransform(src, dst [, distance_type [, mask_size [, mask [, labels]]]]) -> None
    
    Div(...)
        Div(src1, src2, dst [, scale]) -> None
    
    DotProduct(...)
        DotProduct(src1, src2) -> double
    
    DrawChessboardCorners(...)
        DrawChessboardCorners(image, patternSize, corners, patternWasFound) -> None
    
    DrawContours(...)
        DrawContours(img, contour, external_color, hole_color, max_level [, thickness [, lineType [, offset]]]) -> None
    
    EigenVV(...)
        EigenVV(mat, evects, evals, eps [, lowindex [, highindex]]) -> None
    
    Ellipse(...)
        Ellipse(img, center, axes, angle, start_angle, end_angle, color [, thickness [, lineType [, shift]]]) -> None
    
    EllipseBox(...)
        EllipseBox(img, box, color [, thickness [, lineType [, shift]]]) -> None
    
    EncodeImage(...)
        EncodeImage(ext, image [, params]) -> CvMat*
    
    EqualizeHist(...)
        EqualizeHist(src, dst) -> None
    
    Erode(...)
        Erode(src, dst [, element [, iterations]]) -> None
    
    EstimateRigidTransform(...)
        EstimateRigidTransform(A, B, M, full_affine) -> None
    
    Exp(...)
        Exp(src, dst) -> None
    
    ExtractSURF(...)
        ExtractSURF(image, mask, storage, params) -> keypoints,descriptors
    
    FOURCC(...)
        CV_FOURCC(c1, c2, c3, c4) -> int
    
    FastArctan(...)
        FastArctan(y, x) -> float
    
    FillConvexPoly(...)
        FillConvexPoly(img, pn, color [, lineType [, shift]]) -> None
    
    FillPoly(...)
        FillPoly(img, polys, color [, lineType [, shift]]) -> None
    
    Filter2D(...)
        Filter2D(src, dst, kernel [, anchor]) -> None
    
    FindChessboardCorners(...)
        FindChessboardCorners(image, patternSize [, flags]) -> corners
    
    FindContours(...)
        FindContours(image, storage [, mode [, method [, offset]]]) -> CvSeq
    
    FindCornerSubPix(...)
        FindCornerSubPix(image, corners, win, zero_zone, criteria) -> corners
    
    FindDataMatrix(...)
    
    FindExtrinsicCameraParams2(...)
        FindExtrinsicCameraParams2(objectPoints, imagePoints, cameraMatrix, distCoeffs, rvec, tvec [, useExtrinsicGuess]) -> None
    
    FindFundamentalMat(...)
        FindFundamentalMat(points1, points2, fundamentalMatrix [, method [, param1 [, param2 [, status]]]]) -> int
    
    FindHomography(...)
        FindHomography(srcPoints, dstPoints, H [, method [, ransacReprojThreshold [, status]]]) -> None
    
    FindNearestPoint2D(...)
        FindNearestPoint2D(subdiv, pt) -> CvSubdiv2DPoint*
    
    FindStereoCorrespondenceBM(...)
        FindStereoCorrespondenceBM(left, right, disparity, state) -> None
    
    FindStereoCorrespondenceGC(...)
        FindStereoCorrespondenceGC(left, right, dispLeft, dispRight, state [, useDisparityGuess]) -> None
    
    FitEllipse2(...)
        FitEllipse2(points) -> CvBox2D
    
    FitLine(...)
        FitLine(points, dist_type, param, reps, aeps) -> line
    
    Flip(...)
        Flip(src [, dst [, flipMode]]) -> None
    
    FloodFill(...)
        FloodFill(image, seed_point, new_val [, lo_diff [, up_diff [, flags [, mask]]]]) -> comp
    
    Floor(...)
        Floor(value) -> int
    
    GEMM(...)
        GEMM(src1, src2, alpha, src3, beta, dst [, tABC]) -> None
    
    Get1D(...)
        Get1D(arr, idx) -> CvScalar
    
    Get2D(...)
        Get2D(arr, idx0, idx1) -> CvScalar
    
    Get3D(...)
        Get3D(arr, idx0, idx1, idx2) -> CvScalar
    
    GetAffineTransform(...)
        GetAffineTransform(src, dst, mapMatrix) -> None
    
    GetCaptureProperty(...)
        GetCaptureProperty(capture, property_id) -> double
    
    GetCentralMoment(...)
        GetCentralMoment(moments, x_order, y_order) -> double
    
    GetCol(...)
        GetCol(arr, col) -> submat
    
    GetCols(...)
        GetCols(arr, startCol, endCol) -> submat
    
    GetDiag(...)
        GetDiag(arr [, diag]) -> submat
    
    GetDims(...)
        GetDims(arr) -> dim1,dim2,...
    
    GetElemType(...)
        GetElemType(arr) -> int
    
    GetHuMoments(...)
        GetHuMoments(moments) -> hu
    
    GetImage(...)
        GetImage(arr) -> iplimage
    
    GetImageCOI(...)
        GetImageCOI(image) -> int
    
    GetImageROI(...)
        GetImageROI(image) -> CvRect
    
    GetMat(...)
        GetMat(arr [, allowND]) -> CvMat
    
    GetMinMaxHistValue(...)
        GetMinMaxHistValue(hist) -> min_value,max_value,min_idx,max_idx
    
    GetND(...)
        GetND(arr, indices) -> CvScalar
    
    GetNormalizedCentralMoment(...)
        GetNormalizedCentralMoment(moments, x_order, y_order) -> double
    
    GetOptimalDFTSize(...)
        GetOptimalDFTSize(size0) -> int
    
    GetOptimalNewCameraMatrix(...)
        GetOptimalNewCameraMatrix(cameraMatrix, distCoeffs, imageSize, alpha, newCameraMatrix [, newImageSize [, validPixROI [, centerPrincipalPoint]]]) -> None
    
    GetPerspectiveTransform(...)
        GetPerspectiveTransform(src, dst, mapMatrix) -> None
    
    GetQuadrangleSubPix(...)
        GetQuadrangleSubPix(src, dst, mapMatrix) -> None
    
    GetReal1D(...)
        GetReal1D(arr, idx0) -> double
    
    GetReal2D(...)
        GetReal2D(arr, idx0, idx1) -> double
    
    GetReal3D(...)
        GetReal3D(arr, idx0, idx1, idx2) -> double
    
    GetRealND(...)
        GetRealND(arr, idx) -> double
    
    GetRectSubPix(...)
        GetRectSubPix(src, dst, center) -> None
    
    GetRotationMatrix2D(...)
        GetRotationMatrix2D(center, angle, scale, mapMatrix) -> None
    
    GetRow(...)
        GetRow(arr, row) -> submat
    
    GetRows(...)
        GetRows(arr, startRow, endRow [, deltaRow]) -> submat
    
    GetSize(...)
        GetSize(arr) -> CvSize
    
    GetSpatialMoment(...)
        GetSpatialMoment(moments, x_order, y_order) -> double
    
    GetStarKeypoints(...)
        GetStarKeypoints(image, storage [, params]) -> CvSeqOfCvStarKeypoint*
    
    GetSubRect(...)
        GetSubRect(arr, rect) -> submat
    
    GetTextSize(...)
        GetTextSize(textString, font) -> textSize,baseline
    
    GetTickCount(...)
        GetTickCount() -> int64
    
    GetTickFrequency(...)
        GetTickFrequency() -> int64
    
    GetTrackbarPos(...)
        GetTrackbarPos(trackbarName, windowName) -> int
    
    GetWindowProperty(...)
        GetWindowProperty(name, prop_id) -> double
    
    GoodFeaturesToTrack(...)
        GoodFeaturesToTrack(image, eigImage, tempImage, cornerCount, qualityLevel, minDistance [, mask [, blockSize [, useHarris [, k]]]]) -> cornerCount
    
    GrabCut(...)
        GrabCut(image, mask, rect, bgdModel, fgdModel, iterCount, mode) -> None
    
    GrabFrame(...)
        GrabFrame(capture) -> int
    
    HOGDetectMultiScale(...)
        HOGDetectMultiScale(image, storage [, svm_classifier [, win_stride [, hit_threshold [, scale [, group_threshold [, padding [, win_size [, block_size [, block_stride [, cell_size [, nbins [, gammaCorrection]]]]]]]]]]]]) -> CvSeq*
    
    HaarDetectObjects(...)
        HaarDetectObjects(image, cascade, storage [, scale_factor [, min_neighbors [, flags [, min_size]]]]) -> CvSeqOfCvAvgComp*
    
    HoughCircles(...)
        HoughCircles(image, circle_storage, method, dp, min_dist [, param1 [, param2 [, min_radius [, max_radius]]]]) -> None
    
    HoughLines2(...)
        HoughLines2(image, storage, method, rho, theta, threshold [, param1 [, param2]]) -> CvSeq*
    
    IABS(...)
        CV_IABS(a) -> int
    
    IS_SEQ_CLOSED(...)
        CV_IS_SEQ_CLOSED(s) -> int
    
    IS_SEQ_CONVEX(...)
        CV_IS_SEQ_CONVEX(s) -> int
    
    IS_SEQ_CURVE(...)
        CV_IS_SEQ_CURVE(s) -> int
    
    IS_SEQ_HOLE(...)
        CV_IS_SEQ_HOLE(s) -> int
    
    IS_SEQ_INDEX(...)
        CV_IS_SEQ_INDEX(s) -> int
    
    IS_SEQ_SIMPLE(...)
        CV_IS_SEQ_SIMPLE(s) -> int
    
    InRange(...)
        InRange(src, lower, upper, dst) -> None
    
    InRangeS(...)
        InRangeS(src, lower, upper, dst) -> None
    
    InitFont(...)
        InitFont(fontFace, hscale, vscale [, shear [, thickness [, lineType]]]) -> font
    
    InitIntrinsicParams2D(...)
        InitIntrinsicParams2D(objectPoints, imagePoints, npoints, imageSize, cameraMatrix [, aspectRatio]) -> None
    
    InitLineIterator(...)
        InitLineIterator(image, pt1, pt2 [, connectivity [, left_to_right]]) -> line_iterator
    
    InitUndistortMap(...)
        InitUndistortMap(cameraMatrix, distCoeffs, map1, map2) -> None
    
    InitUndistortRectifyMap(...)
        InitUndistortRectifyMap(cameraMatrix, distCoeffs, R, newCameraMatrix, map1, map2) -> None
    
    Inpaint(...)
        Inpaint(src, mask, dst, inpaintRadius, flags) -> None
    
    Integral(...)
        Integral(image, sum [, sqsum [, tiltedSum]]) -> None
    
    InvSqrt(...)
        InvSqrt(value) -> float
    
    Invert(...)
        Invert(src, dst [, method]) -> double
    
    IsInf(...)
        IsInf(value) -> int
    
    IsNaN(...)
        IsNaN(value) -> int
    
    KMeans2(...)
        KMeans2(samples, nclusters, labels, termcrit [, attempts [, flags [, centers]]]) -> double
    
    KalmanCorrect(...)
        KalmanCorrect(kalman, measurement) -> ROCvMat*
    
    KalmanPredict(...)
        KalmanPredict(kalman [, control]) -> ROCvMat*
    
    LUT(...)
        LUT(src, dst, lut) -> None
    
    Laplace(...)
        Laplace(src, dst [, apertureSize]) -> None
    
    Line(...)
        Line(img, pt1, pt2, color [, thickness [, lineType [, shift]]]) -> None
    
    Load(...)
        Load(filename [, storage [, name]]) -> generic
    
    LoadImage(...)
        LoadImage(filename [, iscolor]) -> None
    
    LoadImageM(...)
        LoadImageM(filename [, iscolor]) -> None
    
    Log(...)
        Log(src, dst) -> None
    
    LogPolar(...)
        LogPolar(src, dst, center, M [, flags]) -> None
    
    MAKETYPE(...)
        CV_MAKETYPE(depth, cn) -> int
    
    MAT_CN(...)
        CV_MAT_CN(i) -> int
    
    MAT_DEPTH(...)
        CV_MAT_DEPTH(i) -> int
    
    Mahalonobis(...)
        Mahalonobis(vec1, vec2, mat) -> None
    
    MatMul(...)
        MatMul(src1, src2, dst) -> None
    
    MatMulAdd(...)
        MatMulAdd(src1, src2, src3, dst) -> None
    
    MatchShapes(...)
        MatchShapes(object1, object2, method [, parameter]) -> double
    
    MatchTemplate(...)
        MatchTemplate(image, templ, result, method) -> None
    
    Max(...)
        Max(src1, src2, dst) -> None
    
    MaxRect(...)
        MaxRect(rect1, rect2) -> CvRect
    
    MaxS(...)
        MaxS(src, value, dst) -> None
    
    MeanShift(...)
        MeanShift(prob_image, window, criteria) -> comp
    
    Merge(...)
        Merge(src0, src1, src2, src3, dst) -> None
    
    Min(...)
        Min(src1, src2, dst) -> None
    
    MinAreaRect2(...)
        MinAreaRect2(points [, storage]) -> CvBox2D
    
    MinEnclosingCircle(...)
        MinEnclosingCircle(points) -> int,center,radius
    
    MinMaxLoc(...)
        MinMaxLoc(arr [, mask]) -> minVal,maxVal,minLoc,maxLoc
    
    MinS(...)
        MinS(src, value, dst) -> None
    
    MixChannels(...)
        MixChannels(src, dst, fromTo) -> None
    
    Moments(...)
        Moments(arr [, binary]) -> moments
    
    MorphologyEx(...)
        MorphologyEx(src, dst, temp, element, operation [, iterations]) -> None
    
    MoveWindow(...)
        MoveWindow(name, x, y) -> None
    
    Mul(...)
        Mul(src1, src2, dst [, scale]) -> None
    
    MulSpectrums(...)
        MulSpectrums(src1, src2, dst, flags) -> None
    
    MulTransposed(...)
        MulTransposed(src, dst, order [, delta [, scale]]) -> None
    
    MultiplyAcc(...)
        MultiplyAcc(image1, image2, acc [, mask]) -> None
    
    NamedWindow(...)
        NamedWindow(name [, flags]) -> None
    
    Norm(...)
        Norm(arr1, arr2 [, normType [, mask]]) -> double
    
    Normalize(...)
        Normalize(src, dst [, a [, b [, norm_type [, mask]]]]) -> None
    
    NormalizeHist(...)
        NormalizeHist(hist, factor) -> None
    
    Not(...)
        Not(src, dst) -> None
    
    Or(...)
        Or(src1, src2, dst [, mask]) -> None
    
    OrS(...)
        OrS(src, value, dst [, mask]) -> None
    
    POSIT(...)
        POSIT(posit_object, imagePoints, focal_length, criteria) -> rotationMatrix,translation_vector
    
    PerspectiveTransform(...)
        PerspectiveTransform(src, dst, mat) -> None
    
    PointPolygonTest(...)
        PointPolygonTest(contour, pt, measure_dist) -> double
    
    PolarToCart(...)
        PolarToCart(magnitude, angle, x, y [, angleInDegrees]) -> None
    
    PolyLine(...)
        PolyLine(img, polys, is_closed, color [, thickness [, lineType [, shift]]]) -> None
    
    Pow(...)
        Pow(src, dst, power) -> None
    
    PreCornerDetect(...)
        PreCornerDetect(image, corners [, apertureSize]) -> None
    
    ProjectPCA(...)
        ProjectPCA(data, avg, eigenvectors, result) -> None
    
    ProjectPoints2(...)
        ProjectPoints2(objectPoints, rvec, tvec, cameraMatrix, distCoeffs, imagePoints [, dpdrot [, dpdt [, dpdf [, dpdc [, dpddist]]]]]) -> None
    
    PutText(...)
        PutText(img, text, org, font, color) -> None
    
    PyrDown(...)
        PyrDown(src, dst [, filter]) -> None
    
    PyrMeanShiftFiltering(...)
        PyrMeanShiftFiltering(src, dst, sp, sr [, max_level [, termcrit]]) -> None
    
    PyrSegmentation(...)
        PyrSegmentation(src, dst, storage, level, threshold1, threshold2) -> comp
    
    PyrUp(...)
        PyrUp(src, dst [, filter]) -> None
    
    QueryFrame(...)
        QueryFrame(capture) -> ROIplImage*
    
    QueryHistValue_1D(...)
        QueryHistValue_1D(hist, idx0) -> double
    
    QueryHistValue_2D(...)
        QueryHistValue_2D(hist, idx0, idx1) -> double
    
    QueryHistValue_3D(...)
        QueryHistValue_3D(hist, idx0, idx1, idx2) -> double
    
    QueryHistValue_nD(...)
        QueryHistValue_nD(hist, idx) -> double
    
    RGB(...)
        CV_RGB(red, grn, blu) -> CvScalar
    
    RNG(...)
        RNG( [, seed]) -> CvRNG
    
    RQDecomp3x3(...)
        RQDecomp3x3(M, R, Q [, Qx [, Qy [, Qz]]]) -> eulerAngles
    
    RandArr(...)
        RandArr(rng, arr, distType, param1, param2) -> None
    
    RandInt(...)
        RandInt(rng) -> unsigned
    
    RandReal(...)
        RandReal(rng) -> double
    
    RandShuffle(...)
        RandShuffle(mat, rng [, iter_factor]) -> None
    
    Range(...)
        Range(mat, start, end) -> None
    
    RealScalar(...)
        RealScalar(val0) -> CvScalar
    
    Rectangle(...)
        Rectangle(img, pt1, pt2, color [, thickness [, lineType [, shift]]]) -> None
    
    Reduce(...)
        Reduce(src, dst [, dim [, op]]) -> None
    
    Remap(...)
        Remap(src, dst, mapx, mapy [, flags [, fillval]]) -> None
    
    Repeat(...)
        Repeat(src, dst) -> None
    
    ReprojectImageTo3D(...)
        ReprojectImageTo3D(disparity, _3dImage, Q [, handleMissingValues]) -> None
    
    ResetImageROI(...)
        ResetImageROI(image) -> None
    
    Reshape(...)
        Reshape(arr, newCn [, newRows]) -> CvMat
    
    ReshapeMatND(...)
        ReshapeMatND(arr, newCn, newDims) -> CvMat
    
    Resize(...)
        Resize(src, dst [, interpolation]) -> None
    
    ResizeWindow(...)
        ResizeWindow(name, width, height) -> None
    
    RetrieveFrame(...)
        RetrieveFrame(capture [, index]) -> ROIplImage*
    
    Rodrigues2(...)
        Rodrigues2(src, dst [, jacobian]) -> None
    
    Round(...)
        Round(value) -> int
    
    RunningAvg(...)
        RunningAvg(image, acc, alpha [, mask]) -> None
    
    SIGN(...)
        CV_SIGN(a) -> int
    
    SVBkSb(...)
        SVBkSb(W, U, V, B, X, flags) -> None
    
    SVD(...)
        SVD(A, W [, U [, V [, flags]]]) -> None
    
    Save(...)
        Save(filename, structPtr [, name [, comment]]) -> None
    
    SaveImage(...)
        SaveImage(filename, image) -> None
    
    Scalar(...)
        Scalar(val0 [, val1 [, val2 [, val3]]]) -> CvScalar
    
    ScalarAll(...)
        ScalarAll(val0123) -> CvScalar
    
    Scale(...)
        Scale(src, dst [, scale [, shift]]) -> None
    
    ScaleAdd(...)
        ScaleAdd(src1, scale, src2, dst) -> None
    
    SegmentMotion(...)
        SegmentMotion(mhi, seg_mask, storage, timestamp, seg_thresh) -> CvSeq*
    
    SeqInvert(...)
        SeqInvert(seq) -> None
    
    SeqRemove(...)
        SeqRemove(seq, index) -> None
    
    SeqRemoveSlice(...)
        SeqRemoveSlice(seq, slice) -> None
    
    Set(...)
        Set(arr, value [, mask]) -> None
    
    Set1D(...)
        Set1D(arr, idx, value) -> None
    
    Set2D(...)
        Set2D(arr, idx0, idx1, value) -> None
    
    Set3D(...)
        Set3D(arr, idx0, idx1, idx2, value) -> None
    
    SetCaptureProperty(...)
        SetCaptureProperty(capture, property_id, value) -> int
    
    SetData(...)
        SetData(arr, data, step) -> None
    
    SetIdentity(...)
        SetIdentity(mat [, value]) -> None
    
    SetImageCOI(...)
        SetImageCOI(image, coi) -> None
    
    SetImageROI(...)
        SetImageROI(image, rect) -> None
    
    SetMouseCallback(...)
        SetMouseCallback(windowName, onMouse [, param]) -> None
    
    SetND(...)
        SetND(arr, indices, value) -> None
    
    SetReal1D(...)
        SetReal1D(arr, idx, value) -> None
    
    SetReal2D(...)
        SetReal2D(arr, idx0, idx1, value) -> None
    
    SetReal3D(...)
        SetReal3D(arr, idx0, idx1, idx2, value) -> None
    
    SetRealND(...)
        SetRealND(arr, indices, value) -> None
    
    SetTrackbarPos(...)
        SetTrackbarPos(trackbarName, windowName, pos) -> None
    
    SetWindowProperty(...)
        SetWindowProperty(name, prop_id, prop_value) -> None
    
    SetZero(...)
        SetZero(arr) -> None
    
    ShowImage(...)
        ShowImage(name, image) -> None
    
    Smooth(...)
        Smooth(src, dst [, smoothtype [, param1 [, param2 [, param3 [, param4]]]]]) -> None
    
    SnakeImage(...)
        SnakeImage(image, points, alpha, beta, gamma, win, criteria [, calc_gradient]) -> points
    
    Sobel(...)
        Sobel(src, dst, xorder, yorder [, apertureSize]) -> None
    
    Solve(...)
        Solve(A, B, X [, method]) -> None
    
    SolveCubic(...)
        SolveCubic(coeffs, roots) -> None
    
    SolvePoly(...)
        SolvePoly(coeffs, roots [, maxiter [, fig]]) -> None
    
    Sort(...)
        Sort(src, dst, idxmat [, flags]) -> None
    
    Split(...)
        Split(src, dst0, dst1, dst2, dst3) -> None
    
    Sqrt(...)
        Sqrt(value) -> float
    
    SquareAcc(...)
        SquareAcc(image, sqsum [, mask]) -> None
    
    StartWindowThread(...)
        StartWindowThread() -> None
    
    StereoCalibrate(...)
        StereoCalibrate(objectPoints, imagePoints1, imagePoints2, pointCounts, cameraMatrix1, distCoeffs1, cameraMatrix2, distCoeffs2, imageSize, R, T [, E [, F [, term_crit [, flags]]]]) -> None
    
    StereoRectify(...)
        StereoRectify(cameraMatrix1, cameraMatrix2, distCoeffs1, distCoeffs2, imageSize, R, T, R1, R2, P1, P2 [, Q [, flags [, alpha [, newImageSize]]]]) -> roi1,roi2
    
    StereoRectifyUncalibrated(...)
        StereoRectifyUncalibrated(points1, points2, F, imageSize, H1, H2 [, threshold]) -> None
    
    Sub(...)
        Sub(src1, src2, dst [, mask]) -> None
    
    SubRS(...)
        SubRS(src, value, dst [, mask]) -> None
    
    SubS(...)
        SubS(src, value, dst [, mask]) -> None
    
    Subdiv2DEdgeDst(...)
        Subdiv2DEdgeDst(edge) -> CvSubdiv2DPoint*
    
    Subdiv2DEdgeOrg(...)
        Subdiv2DEdgeOrg(edge) -> CvSubdiv2DPoint*
    
    Subdiv2DGetEdge(...)
        Subdiv2DGetEdge(edge, type) -> CvSubdiv2DEdge
    
    Subdiv2DLocate(...)
        Subdiv2DLocate(subdiv, pt) -> loc,where
    
    Subdiv2DNextEdge(...)
        Subdiv2DNextEdge(edge) -> CvSubdiv2DEdge
    
    Subdiv2DRotateEdge(...)
        Subdiv2DRotateEdge(edge, rotate) -> CvSubdiv2DEdge
    
    SubdivDelaunay2DInsert(...)
        SubdivDelaunay2DInsert(subdiv, pt) -> CvSubdiv2DPoint*
    
    Sum(...)
        Sum(arr) -> CvScalar
    
    ThreshHist(...)
        ThreshHist(hist, threshold) -> None
    
    Threshold(...)
        Threshold(src, dst, threshold, maxValue, thresholdType) -> None
    
    Trace(...)
        Trace(mat) -> CvScalar
    
    Transform(...)
        Transform(src, dst, transmat [, shiftvec]) -> None
    
    Transpose(...)
        Transpose(src, dst) -> None
    
    Undistort2(...)
        Undistort2(src, dst, cameraMatrix, distCoeffs) -> None
    
    UndistortPoints(...)
        UndistortPoints(src, dst, cameraMatrix, distCoeffs [, R [, P]]) -> None
    
    UpdateMotionHistory(...)
        UpdateMotionHistory(silhouette, mhi, timestamp, duration) -> None
    
    WaitKey(...)
        WaitKey( [, delay]) -> int
    
    WarpAffine(...)
        WarpAffine(src, dst, mapMatrix [, flags [, fillval]]) -> None
    
    WarpPerspective(...)
        WarpPerspective(src, dst, mapMatrix [, flags [, fillval]]) -> None
    
    Watershed(...)
        Watershed(image, markers) -> None
    
    WriteFrame(...)
        WriteFrame(writer, image) -> int
    
    Xor(...)
        Xor(src1, src2, dst [, mask]) -> None
    
    XorS(...)
        XorS(src, value, dst [, mask]) -> None
    
    Zero(...)
        Zero(arr) -> None
    
    fromarray(...)
        fromarray(array [, allowND]) -> CvMat
    
    mGet(...)
        mGet(mat, row, col) -> double
    
    mSet(...)
        mSet(mat, row, col, value) -> None
    
    temp_test(...)

DATA
    CV_16S = 3
    CV_16SC1 = 3
    CV_16SC2 = 11
    CV_16SC3 = 19
    CV_16SC4 = 27
    CV_16U = 2
    CV_16UC1 = 2
    CV_16UC2 = 10
    CV_16UC3 = 18
    CV_16UC4 = 26
    CV_32F = 5
    CV_32FC1 = 5
    CV_32FC2 = 13
    CV_32FC3 = 21
    CV_32FC4 = 29
    CV_32S = 4
    CV_32SC1 = 4
    CV_32SC2 = 12
    CV_32SC3 = 20
    CV_32SC4 = 28
    CV_64F = 6
    CV_64FC1 = 6
    CV_64FC2 = 14
    CV_64FC3 = 22
    CV_64FC4 = 30
    CV_8S = 1
    CV_8SC1 = 1
    CV_8SC2 = 9
    CV_8SC3 = 17
    CV_8SC4 = 25
    CV_8U = 0
    CV_8UC1 = 0
    CV_8UC2 = 8
    CV_8UC3 = 16
    CV_8UC4 = 24
    CV_AA = 16
    CV_ADAPTIVE_THRESH_GAUSSIAN_C = 1
    CV_ADAPTIVE_THRESH_MEAN_C = 0
    CV_AUTOSTEP = 2147483647
    CV_BACK = 0
    CV_BGR2BGR555 = 22
    CV_BGR2BGR565 = 12
    CV_BGR2BGRA = 0
    CV_BGR2GRAY = 6
    CV_BGR2HLS = 52
    CV_BGR2HSV = 40
    CV_BGR2Lab = 44
    CV_BGR2Luv = 50
    CV_BGR2RGB = 4
    CV_BGR2RGBA = 2
    CV_BGR2XYZ = 32
    CV_BGR2YCrCb = 36
    CV_BGR5552BGR = 24
    CV_BGR5552BGRA = 28
    CV_BGR5552GRAY = 31
    CV_BGR5552RGB = 25
    CV_BGR5552RGBA = 29
    CV_BGR5652BGR = 14
    CV_BGR5652BGRA = 18
    CV_BGR5652GRAY = 21
    CV_BGR5652RGB = 15
    CV_BGR5652RGBA = 19
    CV_BGRA2BGR = 1
    CV_BGRA2BGR555 = 26
    CV_BGRA2BGR565 = 16
    CV_BGRA2GRAY = 10
    CV_BGRA2RGB = 3
    CV_BGRA2RGBA = 5
    CV_BILATERAL = 4
    CV_BLUR = 1
    CV_BLUR_NO_SCALE = 0
    CV_BayerBG2BGR = 46
    CV_BayerBG2BGR_VNG = 62
    CV_BayerBG2RGB = 48
    CV_BayerGB2BGR = 47
    CV_BayerGB2BGR_VNG = 63
    CV_BayerGB2RGB = 49
    CV_BayerGR2BGR = 49
    CV_BayerGR2BGR_VNG = 65
    CV_BayerGR2RGB = 47
    CV_BayerRG2BGR = 48
    CV_BayerRG2BGR_VNG = 64
    CV_BayerRG2RGB = 46
    CV_C = 1
    CV_CALIB_CB_ADAPTIVE_THRESH = 1
    CV_CALIB_CB_FILTER_QUADS = 4
    CV_CALIB_CB_NORMALIZE_IMAGE = 2
    CV_CALIB_FIX_ASPECT_RATIO = 2
    CV_CALIB_FIX_FOCAL_LENGTH = 16
    CV_CALIB_FIX_INTRINSIC = 256
    CV_CALIB_FIX_K1 = 32
    CV_CALIB_FIX_K2 = 64
    CV_CALIB_FIX_K3 = 128
    CV_CALIB_FIX_PRINCIPAL_POINT = 4
    CV_CALIB_SAME_FOCAL_LENGTH = 512
    CV_CALIB_USE_INTRINSIC_GUESS = 1
    CV_CALIB_ZERO_DISPARITY = 1024
    CV_CALIB_ZERO_TANGENT_DIST = 8
    CV_CANNY_L2_GRADIENT = -2147483648
    CV_CAP_OPENNI = 900
    CV_CAP_OPENNI_BGR_IMAGE = 5
    CV_CAP_OPENNI_DEPTH_GENERATOR = -2147483648
    CV_CAP_OPENNI_DEPTH_GENERATOR_BASELINE = -2147483546
    CV_CAP_OPENNI_DEPTH_GENERATOR_FOCAL_LENGTH = -2147483545
    CV_CAP_OPENNI_DEPTH_GENERATOR_REGISTRATION = -2147483544
    CV_CAP_OPENNI_DEPTH_MAP = 0
    CV_CAP_OPENNI_DISPARITY_MAP = 2
    CV_CAP_OPENNI_DISPARITY_MAP_32F = 3
    CV_CAP_OPENNI_GRAY_IMAGE = 6
    CV_CAP_OPENNI_IMAGE_GENERATOR = 1073741824
    CV_CAP_OPENNI_IMAGE_GENERATOR_OUTPUT_MODE = 1073741924
    CV_CAP_OPENNI_POINT_CLOUD_MAP = 1
    CV_CAP_OPENNI_SXGA_15HZ = 1
    CV_CAP_OPENNI_VALID_DEPTH_MASK = 4
    CV_CAP_OPENNI_VGA_30HZ = 0
    CV_CAP_PROP_BRIGHTNESS = 10
    CV_CAP_PROP_CONTRAST = 11
    CV_CAP_PROP_CONVERT_RGB = 16
    CV_CAP_PROP_EXPOSURE = 15
    CV_CAP_PROP_FORMAT = 8
    CV_CAP_PROP_FOURCC = 6
    CV_CAP_PROP_FPS = 5
    CV_CAP_PROP_FRAME_COUNT = 7
    CV_CAP_PROP_FRAME_HEIGHT = 4
    CV_CAP_PROP_FRAME_WIDTH = 3
    CV_CAP_PROP_GAIN = 14
    CV_CAP_PROP_HUE = 13
    CV_CAP_PROP_MODE = 9
    CV_CAP_PROP_OPENNI_BASELINE = 102
    CV_CAP_PROP_OPENNI_FOCAL_LENGTH = 103
    CV_CAP_PROP_OPENNI_FRAME_MAX_DEPTH = 101
    CV_CAP_PROP_OPENNI_OUTPUT_MODE = 100
    CV_CAP_PROP_OPENNI_REGISTRATION = 104
    CV_CAP_PROP_POS_AVI_RATIO = 2
    CV_CAP_PROP_POS_FRAMES = 1
    CV_CAP_PROP_POS_MSEC = 0
    CV_CAP_PROP_RECTIFICATION = 18
    CV_CAP_PROP_SATURATION = 12
    CV_CHAIN_APPROX_NONE = 1
    CV_CHAIN_APPROX_SIMPLE = 2
    CV_CHAIN_APPROX_TC89_KCOS = 4
    CV_CHAIN_APPROX_TC89_L1 = 3
    CV_CHAIN_CODE = 0
    CV_CHECK_QUIET = 2
    CV_CHECK_RANGE = 1
    CV_CHOLESKY = 3
    CV_CLOCKWISE = 1
    CV_CMP_EQ = 0
    CV_CMP_GE = 2
    CV_CMP_GT = 1
    CV_CMP_LE = 4
    CV_CMP_LT = 3
    CV_CMP_NE = 5
    CV_CN_MAX = 512
    CV_CN_SHIFT = 3
    CV_COLORCVT_MAX = 135
    CV_COMP_BHATTACHARYYA = 3
    CV_COMP_CHISQR = 1
    CV_COMP_CORREL = 0
    CV_COMP_INTERSECT = 2
    CV_CONTOURS_MATCH_I1 = 1
    CV_CONTOURS_MATCH_I2 = 2
    CV_CONTOURS_MATCH_I3 = 3
    CV_COUNTER_CLOCKWISE = 2
    CV_COVAR_COLS = 16
    CV_COVAR_NORMAL = 1
    CV_COVAR_ROWS = 8
    CV_COVAR_SCALE = 4
    CV_COVAR_SCRAMBLED = 0
    CV_COVAR_USE_AVG = 2
    CV_CVTIMG_FLIP = 1
    CV_CVTIMG_SWAP_RB = 2
    CV_DIFF = 16
    CV_DIFF_C = 17
    CV_DIFF_L1 = 18
    CV_DIFF_L2 = 20
    CV_DIST_C = 3
    CV_DIST_FAIR = 5
    CV_DIST_HUBER = 7
    CV_DIST_L1 = 1
    CV_DIST_L12 = 4
    CV_DIST_L2 = 2
    CV_DIST_MASK_3 = 3
    CV_DIST_MASK_5 = 5
    CV_DIST_MASK_PRECISE = 0
    CV_DIST_USER = -1
    CV_DIST_WELSCH = 6
    CV_DXT_FORWARD = 0
    CV_DXT_INVERSE = 1
    CV_DXT_INVERSE_SCALE = 3
    CV_DXT_INV_SCALE = 3
    CV_DXT_MUL_CONJ = 8
    CV_DXT_ROWS = 4
    CV_DXT_SCALE = 2
    CV_EVENT_FLAG_ALTKEY = 32
    CV_EVENT_FLAG_CTRLKEY = 8
    CV_EVENT_FLAG_LBUTTON = 1
    CV_EVENT_FLAG_MBUTTON = 4
    CV_EVENT_FLAG_RBUTTON = 2
    CV_EVENT_FLAG_SHIFTKEY = 16
    CV_EVENT_LBUTTONDBLCLK = 7
    CV_EVENT_LBUTTONDOWN = 1
    CV_EVENT_LBUTTONUP = 4
    CV_EVENT_MBUTTONDBLCLK = 9
    CV_EVENT_MBUTTONDOWN = 3
    CV_EVENT_MBUTTONUP = 6
    CV_EVENT_MOUSEMOVE = 0
    CV_EVENT_RBUTTONDBLCLK = 8
    CV_EVENT_RBUTTONDOWN = 2
    CV_EVENT_RBUTTONUP = 5
    CV_ErrModeLeaf = 0
    CV_ErrModeParent = 1
    CV_ErrModeSilent = 2
    CV_FILLED = -1
    CV_FLOODFILL_FIXED_RANGE = 65536
    CV_FLOODFILL_MASK_ONLY = 131072
    CV_FM_7POINT = 1
    CV_FM_8POINT = 2
    CV_FM_LMEDS = 4
    CV_FM_LMEDS_ONLY = 4
    CV_FM_RANSAC = 8
    CV_FM_RANSAC_ONLY = 8
    CV_FONT_HERSHEY_COMPLEX = 3
    CV_FONT_HERSHEY_COMPLEX_SMALL = 5
    CV_FONT_HERSHEY_DUPLEX = 2
    CV_FONT_HERSHEY_PLAIN = 1
    CV_FONT_HERSHEY_SCRIPT_COMPLEX = 7
    CV_FONT_HERSHEY_SCRIPT_SIMPLEX = 6
    CV_FONT_HERSHEY_SIMPLEX = 0
    CV_FONT_HERSHEY_TRIPLEX = 4
    CV_FONT_ITALIC = 16
    CV_FONT_VECTOR0 = 0
    CV_FRONT = 1
    CV_GAUSSIAN = 2
    CV_GAUSSIAN_5x5 = 7
    CV_GEMM_A_T = 1
    CV_GEMM_B_T = 2
    CV_GEMM_C_T = 4
    CV_GRAPH_ALL_ITEMS = -1
    CV_GRAPH_ANY_EDGE = 30
    CV_GRAPH_BACKTRACKING = 64
    CV_GRAPH_BACK_EDGE = 4
    CV_GRAPH_CROSS_EDGE = 16
    CV_GRAPH_FORWARD_EDGE = 8
    CV_GRAPH_FORWARD_EDGE_FLAG = 268435456
    CV_GRAPH_ITEM_VISITED_FLAG = 1073741824
    CV_GRAPH_NEW_TREE = 32
    CV_GRAPH_OVER = -1
    CV_GRAPH_SEARCH_TREE_NODE_FLAG = 536870912
    CV_GRAPH_TREE_EDGE = 2
    CV_GRAPH_VERTEX = 1
    CV_GRAY2BGR = 8
    CV_GRAY2BGR555 = 30
    CV_GRAY2BGR565 = 20
    CV_GRAY2BGRA = 9
    CV_GRAY2RGB = 8
    CV_GRAY2RGBA = 9
    CV_HAAR_DO_CANNY_PRUNING = 1
    CV_HAAR_DO_ROUGH_SEARCH = 8
    CV_HAAR_FEATURE_MAX = 3
    CV_HAAR_FIND_BIGGEST_OBJECT = 4
    CV_HAAR_MAGIC_VAL = 1112539136
    CV_HAAR_SCALE_IMAGE = 2
    CV_HIST_ARRAY = 0
    CV_HIST_SPARSE = 1
    CV_HLS2BGR = 60
    CV_HLS2RGB = 61
    CV_HOUGH_GRADIENT = 3
    CV_HOUGH_MULTI_SCALE = 2
    CV_HOUGH_PROBABILISTIC = 1
    CV_HOUGH_STANDARD = 0
    CV_HSV2BGR = 54
    CV_HSV2RGB = 55
    CV_IMWRITE_JPEG_QUALITY = 1
    CV_IMWRITE_PNG_COMPRESSION = 16
    CV_IMWRITE_PXM_BINARY = 32
    CV_INPAINT_NS = 0
    CV_INPAINT_TELEA = 1
    CV_INTER_AREA = 3
    CV_INTER_CUBIC = 2
    CV_INTER_LINEAR = 1
    CV_INTER_NN = 0
    CV_KMEANS_USE_INITIAL_LABELS = 1
    CV_L1 = 2
    CV_L2 = 4
    CV_LINK_RUNS = 5
    CV_LKFLOW_GET_MIN_EIGENVALS = 8
    CV_LKFLOW_INITIAL_GUESSES = 4
    CV_LKFLOW_PYR_A_READY = 1
    CV_LKFLOW_PYR_B_READY = 2
    CV_LMEDS = 4
    CV_LOAD_IMAGE_COLOR = 1
    CV_LOAD_IMAGE_GRAYSCALE = 0
    CV_LOAD_IMAGE_UNCHANGED = -1
    CV_LU = 0
    CV_Lab2BGR = 56
    CV_Lab2RGB = 57
    CV_Luv2BGR = 58
    CV_Luv2RGB = 59
    CV_MAX_ARR = 10
    CV_MAX_DIM = 32
    CV_MAX_SOBEL_KSIZE = 7
    CV_MEDIAN = 3
    CV_MINMAX = 32
    CV_MOP_BLACKHAT = 6
    CV_MOP_CLOSE = 3
    CV_MOP_GRADIENT = 4
    CV_MOP_OPEN = 2
    CV_MOP_TOPHAT = 5
    CV_NEXT_AROUND_DST = 34
    CV_NEXT_AROUND_LEFT = 19
    CV_NEXT_AROUND_ORG = 0
    CV_NEXT_AROUND_RIGHT = 49
    CV_NORMAL = 16
    CV_NORM_MASK = 7
    CV_NO_CN_CHECK = 2
    CV_NO_DEPTH_CHECK = 1
    CV_NO_SIZE_CHECK = 4
    CV_PCA_DATA_AS_COL = 1
    CV_PCA_DATA_AS_ROW = 0
    CV_PCA_USE_AVG = 2
    CV_PI = 3.141592653589793
    CV_POLY_APPROX_DP = 0
    CV_PREV_AROUND_DST = 51
    CV_PREV_AROUND_LEFT = 32
    CV_PREV_AROUND_ORG = 17
    CV_PREV_AROUND_RIGHT = 2
    CV_PTLOC_INSIDE = 0
    CV_PTLOC_ON_EDGE = 2
    CV_PTLOC_OUTSIDE_RECT = -1
    CV_PTLOC_VERTEX = 1
    CV_QR = 4
    CV_RAND_NORMAL = 1
    CV_RAND_UNI = 0
    CV_RANSAC = 8
    CV_REDUCE_AVG = 1
    CV_REDUCE_MAX = 2
    CV_REDUCE_MIN = 3
    CV_REDUCE_SUM = 0
    CV_RELATIVE = 8
    CV_RELATIVE_C = 9
    CV_RELATIVE_L1 = 10
    CV_RELATIVE_L2 = 12
    CV_RETR_CCOMP = 2
    CV_RETR_EXTERNAL = 0
    CV_RETR_LIST = 1
    CV_RETR_TREE = 3
    CV_RGB2BGR = 4
    CV_RGB2BGR555 = 23
    CV_RGB2BGR565 = 13
    CV_RGB2BGRA = 2
    CV_RGB2GRAY = 7
    CV_RGB2HLS = 53
    CV_RGB2HSV = 41
    CV_RGB2Lab = 45
    CV_RGB2Luv = 51
    CV_RGB2RGBA = 0
    CV_RGB2XYZ = 33
    CV_RGB2YCrCb = 37
    CV_RGBA2BGR = 3
    CV_RGBA2BGR555 = 27
    CV_RGBA2BGR565 = 17
    CV_RGBA2BGRA = 5
    CV_RGBA2GRAY = 11
    CV_RGBA2RGB = 1
    CV_SCHARR = -1
    CV_SHAPE_CROSS = 1
    CV_SHAPE_CUSTOM = 100
    CV_SHAPE_ELLIPSE = 2
    CV_SHAPE_RECT = 0
    CV_SORT_ASCENDING = 0
    CV_SORT_DESCENDING = 16
    CV_SORT_EVERY_COLUMN = 1
    CV_SORT_EVERY_ROW = 0
    CV_STEREO_BM_BASIC = 0
    CV_STEREO_BM_FISH_EYE = 1
    CV_STEREO_BM_NARROW = 2
    CV_STEREO_BM_NORMALIZED_RESPONSE = 0
    CV_STEREO_GC_OCCLUDED = 32767
    CV_SUBDIV2D_VIRTUAL_POINT_FLAG = 1073741824
    CV_SVD = 1
    CV_SVD_MODIFY_A = 1
    CV_SVD_SYM = 2
    CV_SVD_U_T = 2
    CV_SVD_V_T = 4
    CV_TERMCRIT_EPS = 2
    CV_TERMCRIT_ITER = 1
    CV_TERMCRIT_NUMBER = 1
    CV_THRESH_BINARY = 0
    CV_THRESH_BINARY_INV = 1
    CV_THRESH_MASK = 7
    CV_THRESH_OTSU = 8
    CV_THRESH_TOZERO = 3
    CV_THRESH_TOZERO_INV = 4
    CV_THRESH_TRUNC = 2
    CV_TM_CCOEFF = 4
    CV_TM_CCOEFF_NORMED = 5
    CV_TM_CCORR = 2
    CV_TM_CCORR_NORMED = 3
    CV_TM_SQDIFF = 0
    CV_TM_SQDIFF_NORMED = 1
    CV_WARP_FILL_OUTLIERS = 8
    CV_WARP_INVERSE_MAP = 16
    CV_WINDOW_AUTOSIZE = 1
    CV_WINDOW_FULLSCREEN = 1
    CV_WINDOW_NORMAL = 0
    CV_XYZ2BGR = 34
    CV_XYZ2RGB = 35
    CV_YCrCb2BGR = 38
    CV_YCrCb2RGB = 39
    GC_BGD = 0
    GC_EVAL = 2
    GC_FGD = 1
    GC_INIT_WITH_MASK = 1
    GC_INIT_WITH_RECT = 0
    GC_PR_BGD = 2
    GC_PR_FGD = 3
    HG_AUTOSIZE = 1
    IPL_DEPTH_16S = 2147483664L
    IPL_DEPTH_16U = 16L
    IPL_DEPTH_32F = 32L
    IPL_DEPTH_32S = 2147483680L
    IPL_DEPTH_64F = 64L
    IPL_DEPTH_8S = 2147483656L
    IPL_DEPTH_8U = 8L
    IPL_ORIGIN_BL = 1
    IPL_ORIGIN_TL = 0