:param imagePoints: Vector of vectors of the projections of the calibration pattern points. In the old interface all the per-view vectors are concatenated.
- :param npoints: The integer vector of point counters for each view.
+ :param pointCounts: The integer vector of point counters for each view.
:param imageSize: Image size in pixels used to initialize the principal point.
.. ocv:pyfunction:: cv2.reprojectImageTo3D(disparity, Q[, _3dImage[, handleMissingValues[, ddepth]]]) -> _3dImage
.. ocv:cfunction:: void cvReprojectImageTo3D( const CvArr* disparity, CvArr* _3dImage, const CvMat* Q, int handleMissingValues=0)
+
.. ocv:pyoldfunction:: cv.ReprojectImageTo3D(disparity, _3dImage, Q, handleMissingValues=0) -> None
:param disparity: Input single-channel 8-bit unsigned, 16-bit signed, 32-bit signed or 32-bit floating-point disparity image.
:param vtx: Optional input argument used to initialize the added vertex (only user-defined fields beyond ``sizeof(CvGraphVtx)`` are copied)
- :param inserted_vertex: Optional output argument. If not ``NULL`` , the address of the new vertex is written here.
+ :param inserted_vtx: Optional output argument. If not ``NULL`` , the address of the new vertex is written here.
The function adds a vertex to the graph and returns the vertex index.
:param graph: Graph
- :param vtx_idx: Index of the removed vertex
+ :param index: Index of the removed vertex
The function removes a vertex from a graph
together with all the edges incident to it. The function reports an error
One and only one of the two above flags must be specified
- :param CV_NODE_FLOW: the optional flag that makes sense only for YAML streams. It means that the structure is written as a flow (not as a block), which is more compact. It is recommended to use this flag for structures or arrays whose elements are all scalars.
+ * **CV_NODE_FLOW** the optional flag that makes sense only for YAML streams. It means that the structure is written as a flow (not as a block), which is more compact. It is recommended to use this flag for structures or arrays whose elements are all scalars.
:param typeName: Optional parameter - the object type name. In
case of XML it is written as a ``type_id`` attribute of the
:param fs: Destination file storage
- :param new_file_node: New name of the file node in the destination file storage. To keep the existing name, use :ocv:cfunc:`cvGetFileNodeName`
+ :param new_node_name: New name of the file node in the destination file storage. To keep the existing name, use :ocv:cfunc:`cvGetFileNodeName`
:param node: The written node
----
Computes the inverse Discrete Fourier Transform of a 1D or 2D array.
-.. ocv:function:: void idft(InputArray src, OutputArray dst, int flags=0, int outputRows=0)
+.. ocv:function:: void idft(InputArray src, OutputArray dst, int flags=0, int nonzeroRows=0)
.. ocv:pyfunction:: cv2.idft(src[, dst[, flags[, nonzeroRows]]]) -> dst
------
Finds the inverse or pseudo-inverse of a matrix.
-.. ocv:function:: double invert(InputArray src, OutputArray dst, int method=DECOMP_LU)
+.. ocv:function:: double invert(InputArray src, OutputArray dst, int flags=DECOMP_LU)
.. ocv:pyfunction:: cv2.invert(src[, dst[, flags]]) -> retval, dst
-.. ocv:cfunction:: double cvInvert(const CvArr* src, CvArr* dst, int method=CV_LU)
-.. ocv:pyoldfunction:: cv.Invert(src, dst, method=CV_LU)-> double
+.. ocv:cfunction:: double cvInvert(const CvArr* src, CvArr* dst, int flags=CV_LU)
+
+.. ocv:pyoldfunction:: cv.Invert(src, dst, flags=CV_LU)-> double
:param src: Source floating-point ``M x N`` matrix.
:param y: Floating-point array of y-coordinates of the vectors. It must have the same size as ``x`` .
- :param dst: Destination array of the same size and type as ``x`` .
+ :param magnitude: Destination array of the same size and type as ``x`` .
The function ``magnitude`` calculates the magnitude of 2D vectors formed from the corresponding elements of ``x`` and ``y`` arrays:
.. ocv:function:: SVD::SVD( InputArray A, int flags=0 )
- :param src: Decomposed matrix.
+ :param A: Decomposed matrix.
:param flags: Operation flags.
.. ocv:cfunction:: CvScalar cvTrace(const CvArr* mat)
.. ocv:pyoldfunction:: cv.Trace(mat)-> CvScalar
- :param mtx: Source matrix.
+ :param mat: Source matrix.
The function ``trace`` returns the sum of the diagonal elements of the matrix ``mtx`` .
error
----------
+-----
Signals an error and raises an exception.
.. ocv:function:: void error( const Exception& exc )
-.. ocv:cfunction:: int cvError( int status, const char* funcName, const char* errMsg, const char* filename, int line )
+.. ocv:cfunction:: int cvError( int status, const char* funcName, const char* err_msg, const char* filename, int line )
:param exc: Exception to throw.
- :param code: Error code. Normally, it is a negative value. The list of pre-defined error codes can be found in ``cxerror.h`` .
+ :param status: Error code. Normally, it is a negative value. The list of pre-defined error codes can be found in ``cxerror.h`` .
- :param msg: Text of the error message.
+ :param err_msg: Text of the error message.
:param args: ``printf`` -like formatted error message in parentheses.
:param keypoints2: Keypoints from the second source image.
- :param matches: Matches from the first image to the second one, which means that ``keypoints1[i]`` has a corresponding point in ``keypoints2[matches[i]]`` .
+ :param matches1to2: Matches from the first image to the second one, which means that ``keypoints1[i]`` has a corresponding point in ``keypoints2[matches[i]]`` .
:param outImg: Output image. Its content depends on the ``flags`` value defining what is drawn in the output image. See possible ``flags`` bit values below.
:param file_name: Name of the file where randomized tree data is stored.
- :param is: Output stream associated with the file where randomized tree data is stored.
+ :param os: Output stream associated with the file where randomized tree data is stored.
.. ocv:function:: Ptr<FilterEngine_GPU> gpu::createMorphologyFilter_GPU(int op, int type, const Mat& kernel, const Point& anchor = Point(-1,-1), int iterations = 1)
-.. ocv:function:: Ptr<BaseFilter_GPU> getMorphologyFilter_GPU(int op, int type, const Mat& kernel, const Size& ksize, Point anchor=Point(-1,-1))
+.. ocv:function:: Ptr<BaseFilter_GPU> gpu::getMorphologyFilter_GPU(int op, int type, const Mat& kernel, const Size& ksize, Point anchor=Point(-1,-1))
:param op: Morphology operation id. Only ``MORPH_ERODE`` and ``MORPH_DILATE`` are supported.
:param kernel: 2D 8-bit structuring element for the morphological operation.
- :param size: Size of a horizontal or vertical structuring element used for separable morphological operations.
+ :param ksize: Size of a horizontal or vertical structuring element used for separable morphological operations.
:param anchor: Anchor position within the structuring element. Negative values mean that the anchor is at the center.
:param ddepth: Destination image depth. ``CV_8U`` , ``CV_16S`` , ``CV_32S`` , and ``CV_32F`` are supported.
- :param xorder: Order of the derivative x.
+ :param dx: Order of the derivative x.
- :param yorder: Order of the derivative y.
+ :param dy: Order of the derivative y.
:param scale: Optional scale factor for the computed derivative values. By default, no scaling is applied. See :ocv:func:`getDerivKernels` for details.
.. ocv:function:: void gpu::cornerMinEigenVal(const GpuMat& src, GpuMat& dst, int blockSize, int ksize, int borderType=BORDER_REFLECT101)
+.. ocv:function:: void gpu::cornerMinEigenVal(const GpuMat& src, GpuMat& dst, GpuMat& Dx, GpuMat& Dy, int blockSize, int ksize, int borderType=BORDER_REFLECT101)
+
+.. ocv:function:: void gpu::cornerMinEigenVal(const GpuMat& src, GpuMat& dst, GpuMat& Dx, GpuMat& Dy, GpuMat& buf, int blockSize, int ksize, int borderType=BORDER_REFLECT101, Stream& stream = Stream::Null())
+
:param src: Source image. Only ``CV_8UC1`` and ``CV_32FC1`` images are supported for now.
:param dst: Destination image containing cornerness values. The size is the same. The type is ``CV_32FC1`` .
:param ksize: Aperture parameter for the Sobel operator.
- :param k: Harris detector free parameter.
-
:param borderType: Pixel extrapolation method. Only ``BORDER_REFLECT101`` and ``BORDER_REPLICATE`` are supported for now.
.. seealso:: :ocv:func:`cornerMinEigenVal`
.. ocv:function:: void gpu::swapChannels(GpuMat& image, const int dstOrder[4], Stream& stream = Stream::Null())
- :param src: Source image. Supports only ``CV_8UC4`` type.
+ :param image: Source image. Supports only ``CV_8UC4`` type.
:param dstOrder: Integer array describing how channel values are permutated. The n-th entry of the array contains the number of the channel that is stored in the n-th channel of the output image. E.g. Given an RGBA image, aDstOrder = [3,2,1,0] converts this to ABGR channel order.
:param thresh: Threshold value.
- :param maxVal: Maximum value to use with ``THRESH_BINARY`` and ``THRESH_BINARY_INV`` threshold types.
+ :param maxval: Maximum value to use with ``THRESH_BINARY`` and ``THRESH_BINARY_INV`` threshold types.
- :param thresholdType: Threshold type. For details, see :ocv:func:`threshold` . The ``THRESH_OTSU`` threshold type is not supported.
+ :param type: Threshold type. For details, see :ocv:func:`threshold` . The ``THRESH_OTSU`` threshold type is not supported.
:param stream: Stream for the asynchronous version.
:param edges: Output edge map. It has the same size and type as ``image`` .
- :param threshold1: First threshold for the hysteresis procedure.
+ :param low_thresh: First threshold for the hysteresis procedure.
- :param threshold2: Second threshold for the hysteresis procedure.
+ :param high_thresh: Second threshold for the hysteresis procedure.
- :param apertureSize: Aperture size for the :ocv:func:`Sobel` operator.
+ :param apperture_size: Aperture size for the :ocv:func:`Sobel` operator.
:param L2gradient: Flag indicating whether a more accurate :math:`L_2` norm :math:`=\sqrt{(dI/dx)^2 + (dI/dy)^2}` should be used to compute the image gradient magnitude ( ``L2gradient=true`` ), or a faster default :math:`L_1` norm :math:`=|dI/dx|+|dI/dy|` is enough ( ``L2gradient=false`` ).
:param maxVal: Pointer to the returned maximum value. Use ``NULL`` if not required.
- :param minValLoc: Pointer to the returned minimum location. Use ``NULL`` if not required.
+ :param minLoc: Pointer to the returned minimum location. Use ``NULL`` if not required.
- :param maxValLoc: Pointer to the returned maximum location. Use ``NULL`` if not required.
+ :param maxLoc: Pointer to the returned maximum location. Use ``NULL`` if not required.
:param mask: Optional mask to select a sub-matrix.
:param win_sigma: Gaussian smoothing window parameter.
- :param threshold_L2Hys: L2-Hys normalization method shrinkage.
+ :param threshold_L2hys: L2-Hys normalization method shrinkage.
:param gamma_correction: Flag to specify whether the gamma correction preprocessing is required or not.
:param image: Matrix of type ``CV_8U`` containing an image where objects should be detected.
- :param objects: Buffer to store detected objects (rectangles). If it is empty, it is allocated with the default size. If not empty, the function searches not more than N objects, where ``N = sizeof(objectsBufer's data)/sizeof(cv::Rect)``.
+ :param objectsBuf: Buffer to store detected objects (rectangles). If it is empty, it is allocated with the default size. If not empty, the function searches not more than N objects, where ``N = sizeof(objectsBufer's data)/sizeof(cv::Rect)``.
:param scaleFactor: Value to specify how much the image size is reduced at each image scale.
:param angle: Destionation matrix of angles ( ``CV_32FC1`` ).
- :param angleInDegress: Flag for angles that must be evaluated in degress.
+ :param angleInDegrees: Flag for angles that must be evaluated in degress.
:param stream: Stream for the asynchronous version.
:param angle: Destionation matrix of angles ( ``CV_32FC1`` ).
- :param angleInDegress: Flag for angles that must be evaluated in degress.
+ :param angleInDegrees: Flag for angles that must be evaluated in degress.
:param stream: Stream for the asynchronous version.
:param y: Destination matrix of imaginary components ( ``CV_32FC1`` ).
- :param angleInDegress: Flag that indicates angles in degress.
+ :param angleInDegrees: Flag that indicates angles in degress.
:param stream: Stream for the asynchronous version.
:param apertureSize: Aperture parameter for the :ocv:func:`Sobel` operator.
- :param boderType: Pixel extrapolation method. See :ocv:func:`borderInterpolate` .
+ :param borderType: Pixel extrapolation method. See :ocv:func:`borderInterpolate` .
For every pixel
:math:`p` , the function ``cornerEigenValsAndVecs`` considers a ``blockSize`` :math:`\times` ``blockSize`` neigborhood
:param k: Harris detector free parameter. See the formula below.
- :param boderType: Pixel extrapolation method. See :ocv:func:`borderInterpolate` .
+ :param borderType: Pixel extrapolation method. See :ocv:func:`borderInterpolate` .
The function runs the Harris edge detector on the image. Similarly to
:ocv:func:`cornerMinEigenVal` and
.. ocv:pyfunction:: cv2.cornerMinEigenVal(src, blockSize[, dst[, ksize[, borderType]]]) -> dst
.. ocv:cfunction:: void cvCornerMinEigenVal( const CvArr* image, CvArr* eigenval, int blockSize, int apertureSize=3 )
+
.. ocv:pyoldfunction:: cv.CornerMinEigenVal(image, eigenval, blockSize, apertureSize=3)-> None
:param src: Input single-channel 8-bit or floating-point image.
:param apertureSize: Aperture parameter for the :ocv:func:`Sobel` operator.
- :param boderType: Pixel extrapolation method. See :ocv:func:`borderInterpolate` .
+ :param borderType: Pixel extrapolation method. See :ocv:func:`borderInterpolate` .
The function is similar to
:ocv:func:`cornerEigenValsAndVecs` but it calculates and stores only the minimal eigenvalue of the covariance matrix of derivatives, that is,
getDefaultNewCameraMatrix
------------------------------
+-------------------------
Returns the default new camera matrix.
-.. ocv:function:: Mat getDefaultNewCameraMatrix(InputArray cameraMatrix, Size imgSize=Size(), bool centerPrincipalPoint=false )
+.. ocv:function:: Mat getDefaultNewCameraMatrix(InputArray cameraMatrix, Size imgsize=Size(), bool centerPrincipalPoint=false )
.. ocv:pyfunction:: cv2.getDefaultNewCameraMatrix(cameraMatrix[, imgsize[, centerPrincipalPoint]]) -> retval
:param cameraMatrix: Input camera matrix.
- :param imageSize: Camera view image size in pixels.
+ :param imgsize: Camera view image size in pixels.
:param centerPrincipalPoint: Location of the principal point in the new camera matrix. The parameter indicates whether this location should be at the image center or not.
--------------
Returns a pointer to the histogram bin.
-.. ocv:cfunction:: float cvGetHistValue_1D(hist, idx0)
+.. ocv:cfunction:: float cvGetHistValue_1D(CvHistogram hist, int idx0)
-.. ocv:cfunction:: float cvGetHistValue_2D(hist, idx0, idx1)
+.. ocv:cfunction:: float cvGetHistValue_2D(CvHistogram hist, int idx0, int idx1)
-.. ocv:cfunction:: float cvGetHistValue_3D(hist, idx0, idx1, idx2)
+.. ocv:cfunction:: float cvGetHistValue_3D(CvHistogram hist, int idx0, int idx1, int idx2)
-.. ocv:cfunction:: float cvGetHistValue_nD(hist, idx)
+.. ocv:cfunction:: float cvGetHistValue_nD(CvHistogram hist, int idx)
:param hist: Histogram.
phaseCorrelate
--------------------------------
+--------------
The function is used to detect translational shifts that occur between two images. The operation takes advantage of the Fourier shift theorem for detecting the translational shift in the frequency domain. It can be used for fast image registration as well as motion esitimation. For more information please see http://en.wikipedia.org/wiki/Phase\_correlation .
-Calculates the cross-power spectrum of two supplied source arrays. The arrays are padded if needed with ``getOptimalDFTSize`` .
+Calculates the cross-power spectrum of two supplied source arrays. The arrays are padded if needed with :ocv:func:`getOptimalDFTSize`.
.. ocv:function:: Point2d phaseCorrelate(InputArray src1, InputArray src2, InputArray window = noArray())
:param src1: Source floating point array (CV_32FC1 or CV_64FC1)
:param src2: Source floating point array (CV_32FC1 or CV_64FC1)
:param window: Floating point array with windowing coefficients to reduce edge effects (optional).
- :param result: Detected phase shift (sub-pixel) between the two arrays.
+
+Return value: detected phase shift (sub-pixel) between the two arrays.
The function performs the following equations
----------------
Finds contours in a binary image.
-.. ocv:function:: void findContours( InputOutputArray image, OutputArrayOfArrays contours, OutputArray hierarchy, int mode, int method, Point offset=Point())
+.. ocv:function:: void findContours( InputOutputArray image, OutputArrayOfArrays contours, OutputArray hierarchy, int mode, int method, Point offset=Point())
.. ocv:function:: void findContours( InputOutputArray image, OutputArrayOfArrays contours, int mode, int method, Point offset=Point())
.. ocv:cfunction:: int cvFindContours( CvArr* image, CvMemStorage* storage, CvSeq** firstContour, int headerSize=sizeof(CvContour), int mode=CV_RETR_LIST, int method=CV_CHAIN_APPROX_SIMPLE, CvPoint offset=cvPoint(0, 0) )
+
.. ocv:pyoldfunction:: cv.FindContours(image, storage, mode=CV_RETR_LIST, method=CV_CHAIN_APPROX_SIMPLE, offset=(0, 0)) -> cvseq
:param image: Source, an 8-bit single-channel image. Non-zero pixels are treated as 1's. Zero pixels remain 0's, so the image is treated as ``binary`` . You can use :ocv:func:`compare` , :ocv:func:`inRange` , :ocv:func:`threshold` , :ocv:func:`adaptiveThreshold` , :ocv:func:`Canny` , and others to create a binary image out of a grayscale or color one. The function modifies the ``image`` while extracting the contours.
:param contours: Detected contours. Each contour is stored as a vector of points.
- :param hiararchy: Optional output vector containing information about the image topology. It has as many elements as the number of contours. For each contour ``contours[i]`` , the elements ``hierarchy[i][0]`` , ``hiearchy[i][1]`` , ``hiearchy[i][2]`` , and ``hiearchy[i][3]`` are set to 0-based indices in ``contours`` of the next and previous contours at the same hierarchical level: the first child contour and the parent contour, respectively. If for a contour ``i`` there are no next, previous, parent, or nested contours, the corresponding elements of ``hierarchy[i]`` will be negative.
+ :param hierarchy: Optional output vector containing information about the image topology. It has as many elements as the number of contours. For each contour ``contours[i]`` , the elements ``hierarchy[i][0]`` , ``hiearchy[i][1]`` , ``hiearchy[i][2]`` , and ``hiearchy[i][3]`` are set to 0-based indices in ``contours`` of the next and previous contours at the same hierarchical level: the first child contour and the parent contour, respectively. If for a contour ``i`` there are no next, previous, parent, or nested contours, the corresponding elements of ``hierarchy[i]`` will be negative.
:param mode: Contour retrieval mode.
.. ocv:pyfunction:: cv2.contourArea(contour[, oriented]) -> retval
.. ocv:cfunction:: double cvContourArea( const CvArr* contour, CvSlice slice=CV_WHOLE_SEQ )
+
.. ocv:pyoldfunction:: cv.ContourArea(contour, slice=CV_WHOLE_SEQ)-> double
:param contour: Input vector of 2D points (contour vertices), stored in ``std::vector`` or ``Mat``.
- :param orientation: Oriented area flag. If it is true, the function returns a signed area value, depending on the contour orientation (clockwise or counter-clockwise). Using this feature you can determine orientation of a contour by taking the sign of an area. By default, the parameter is ``false``, which means that the absolute value is returned.
+
+ :param oriented: Oriented area flag. If it is true, the function returns a signed area value, depending on the contour orientation (clockwise or counter-clockwise). Using this feature you can determine orientation of a contour by taking the sign of an area. By default, the parameter is ``false``, which means that the absolute value is returned.
The function computes a contour area. Similarly to
:ocv:func:`moments` , the area is computed using the Green formula. Thus, the returned area and the number of non-zero pixels, if you draw the contour using
import os, sys, re, string, glob
-allmodules = ["core", "flann", "imgproc", "ml", "highgui", "video", "features2d", "calib3d", "objdetect", "legacy", "contrib", "gpu", "androidcamera", "haartraining", "java", "python", "stitching", "traincascade", "ts", "photo"]
+allmodules = ["core", "flann", "imgproc", "ml", "highgui", "video", "features2d", "calib3d", "objdetect", "legacy", "contrib", "gpu", "androidcamera", "java", "python", "stitching", "ts", "photo", "nonfree", "videostab"]
verbose = False
show_warnings = True
show_errors = True
********************************
-photo. Computational Photography
+legacy. Deprecated stuff
********************************
.. highlight:: cpp
.. toctree::
:maxdepth: 2
-
- inpainting
.. ocv:function:: float CvDTree::calc_error( CvMLData* trainData, int type, std::vector<float> *resp = 0 )
- :param data: Data for the decision tree.
+ :param trainData: Data for the decision tree.
:param type: Type of error. Possible values are:
in the same position in the ``sample`` vector. If there are no missing values\r
in the feature vector, an empty matrix can be passed instead of the missing mask.\r
\r
- :param weak_responses: Matrix used to obtain predictions of all the trees.\r
+ :param weakResponses: Matrix used to obtain predictions of all the trees.\r
The matrix has :math:`K` rows,\r
where :math:`K` is the count of output classes (1 for the regression case).\r
The matrix has as many columns as the ``slice`` length.\r
:param activateFunc: Parameter specifying the activation function for each neuron: one of ``CvANN_MLP::IDENTITY``, ``CvANN_MLP::SIGMOID_SYM``, and ``CvANN_MLP::GAUSSIAN``.
- :param fparam1/fparam2: Free parameters of the activation function, :math:`\alpha` and :math:`\beta`, respectively. See the formulas in the introduction section.
+ :param fparam1: Free parameter of the activation function, :math:`\alpha`. See the formulas in the introduction section.
+
+ :param fparam2: Free parameter of the activation function, :math:`\beta`. See the formulas in the introduction section.
The method creates an MLP network with the specified topology and assigns the same activation function to all the neurons.
.. ocv:function:: float CvRTrees::get_proximity( const CvMat* sample1, const CvMat* sample2, const CvMat* missing1 = 0, const CvMat* missing2 = 0 ) const
- :param sample_1: The first sample.
+ :param sample1: The first sample.
- :param sample_2: The second sample.
+ :param sample2: The second sample.
:param missing1: Optional missing measurement mask of the first sample.
.. ocv:pyfunction:: cv2.SVM.predict(sample[, returnDFVal]) -> retval
- :param sample(s): Input sample(s) for prediction.
+ :param sample: Input sample for prediction.
+
+ :param samples: Input samples for prediction.
:param returnDFVal: Specifies a type of the return value. If ``true`` and the problem is 2-class classification then the method returns the decision function value that is signed distance to the margin, else the function returns a class label (classification) or estimated function value (regression).
-----------------
Calculates the optical flow for two images by using the block matching method.
-.. ocv::cfunction:: void cvCalcOpticalFlowBM( const CvArr* prev, const CvArr* curr, CvSize blockSize, CvSize shiftSize, CvSize maxRange, int usePrevious, CvArr* velx, CvArr* vely )
+.. ocv:cfunction:: void cvCalcOpticalFlowBM( const CvArr* prev, const CvArr* curr, CvSize blockSize, CvSize shiftSize, CvSize maxRange, int usePrevious, CvArr* velx, CvArr* vely )
.. ocv:pyoldfunction:: cv.CalcOpticalFlowBM(prev, curr, blockSize, shiftSize, maxRange, usePrevious, velx, vely)-> None
-----------------
Calculates the optical flow for two images using Horn-Schunck algorithm.
-.. ocv::cfunction:: void cvCalcOpticalFlowHS( const CvArr* prev, const CvArr* curr, int usePrevious, CvArr* velx, CvArr* vely, double lambda, CvTermCriteria criteria )
+.. ocv:cfunction:: void cvCalcOpticalFlowHS(const CvArr* prev, const CvArr* curr, int usePrevious, CvArr* velx, CvArr* vely, double lambda, CvTermCriteria criteria)
.. ocv:pyoldfunction:: cv.CalcOpticalFlowHS(prev, curr, usePrevious, velx, vely, lambda, criteria)-> None
.. ocv:pyfunction:: cv2.KalmanFilter.correct(measurement) -> retval
.. ocv:cfunction:: const CvMat* cvKalmanCorrect( CvKalman* kalman, const CvMat* measurement )
+
.. ocv:pyoldfunction:: cv.KalmanCorrect(kalman, measurement) -> cvmat
- :param control: The measured system parameters
+ :param measurement: The measured system parameters
BackgroundSubtractor
projects / profile / ivi / opencv.git / commitdiff