Eliminate discrepancies between signatures in documentation and OpenCV headers

All errors were found by doc/check_docs2.py

modules/contrib/doc/openfabmap.rst

@@ -9,10 +9,10 @@ FAB-MAP is an approach to appearance-based place recognition. FAB-MAP compares i
 
 openFABMAP requires training data (e.g. a collection of images from a similar but not identical environment) to construct a visual vocabulary for the visual bag-of-words model, along with a Chow-Liu tree representation of feature likelihood and for use in the Sampled new place method (see below).
 
-FabMap
+of2::FabMap
 --------------------
 
-.. ocv:class:: FabMap
+.. ocv:class:: of2::FabMap
 
 The main FabMap class performs the comparison between visual bags-of-words extracted from one or more images. The FabMap class is instantiated as one of the four inherited FabMap classes (FabMap1, FabMapLUT, FabMapFBO, FabMap2). Each inherited class performs the comparison differently based on algorithm iterations as published (see each class below for specifics). A Chow-Liu tree, detector model parameters and some option flags are common to all Fabmap variants and are supplied on class creation. Training data (visual bag-of-words) is supplied to the class if using the SAMPLED new place method. Test data (visual bag-of-words) is supplied as images to which query bag-of-words are compared against. The common flags are listed below: ::
 
@@ -149,10 +149,10 @@ The inverted index FAB-MAP as in [IJRR2010]_. This version of FAB-MAP is the fas
 
 .. [ICRA2011] A. Glover, et al., "OpenFABMAP: An Open Source Toolbox for Appearance-based Loop Closure Detection," in IEEE International Conference on Robotics and Automation, St Paul, Minnesota, 2011
 
-ImageMatch
+of2::IMatch
 --------------------
 
-.. ocv:struct:: IMatch
+.. ocv:struct:: of2::IMatch
 
 FAB-MAP comparison results are stored in a vector of IMatch structs. Each IMatch structure provides the index of the provided query bag-of-words, the index of the test bag-of-words, the raw log-likelihood of the match (independent of other comparisons), and the match probability (normalised over other comparison likelihoods).
 
@@ -180,48 +180,48 @@ FAB-MAP comparison results are stored in a vector of IMatch structs. Each IMatch
 
     };
 
-Chow-Liu Tree
+of2::ChowLiuTree
 --------------------
 
-.. ocv:class:: ChowLiuTree
+.. ocv:class:: of2::ChowLiuTree
 
 The Chow-Liu tree is a probabilistic model of the environment in terms of feature occurance and co-occurance. The Chow-Liu tree is a form of Bayesian network. FAB-MAP uses the model when calculating bag-of-words similarity by taking into account feature saliency. Training data is provided to the ChowLiuTree class in the form of bag-of-words image descriptors. The make function produces a cv::Mat that encodes the tree structure.
 
-.. ocv:function:: ChowLiuTree::ChowLiuTree()
+.. ocv:function:: of2::ChowLiuTree::ChowLiuTree()
 
-.. ocv:function:: void add(const Mat& imgDescriptor)
+.. ocv:function:: void of2::ChowLiuTree::add(const Mat& imgDescriptor)
 
     :param imgDescriptor:  bag-of-words image descriptors stored as rows in a Mat
 
-.. ocv:function:: void add(const vector<Mat>& imgDescriptors)
+.. ocv:function:: void of2::ChowLiuTree::add(const vector<Mat>& imgDescriptors)
 
     :param imgDescriptors: a vector containing multiple bag-of-words image descriptors
 
-.. ocv:function:: const vector<Mat>& getImgDescriptors() const
+.. ocv:function:: const vector<Mat>& of2::ChowLiuTree::getImgDescriptors() const
 
     Returns a vector containing multiple bag-of-words image descriptors
 
-.. ocv:function:: Mat make(double infoThreshold = 0.0)
+.. ocv:function:: Mat of2::ChowLiuTree::make(double infoThreshold = 0.0)
 
     :param infoThreshold: a threshold can be set to reduce the amount of memory used when making the Chow-Liu tree, which can occur with large vocabulary sizes. This function can fail if the threshold is set too high. If memory is an issue the value must be set by trial and error (~0.0005)
 
 
-BOWMSCTrainer
+of2::BOWMSCTrainer
 --------------------
 
-.. ocv:class:: BOWMSCTrainer : public BOWTrainer
+.. ocv:class:: of2::BOWMSCTrainer : public of2::BOWTrainer
 
 BOWMSCTrainer is a custom clustering algorithm used to produce the feature vocabulary required to create bag-of-words representations. The algorithm is an implementation of [AVC2007]_. Arguments against using K-means for the FAB-MAP algorithm are discussed in [IJRR2010]_. The BOWMSCTrainer inherits from the cv::BOWTrainer class, overwriting the cluster function.
 
-.. ocv:function::   BOWMSCTrainer::BOWMSCTrainer(double clusterSize = 0.4)
+.. ocv:function::   of2::BOWMSCTrainer::BOWMSCTrainer(double clusterSize = 0.4)
 
     :param clusterSize: the specificity of the vocabulary produced. A smaller cluster size will instigate a larger vocabulary.
 
-.. ocv:function::  virtual Mat cluster() const
+.. ocv:function::  virtual Mat of2::BOWMSCTrainer::cluster() const
 
 Cluster using features added to the class
 
-.. ocv:function:: virtual Mat cluster(const Mat& descriptors) const
+.. ocv:function:: virtual Mat of2::BOWMSCTrainer::cluster(const Mat& descriptors) const
 
     :param descriptors: feature descriptors provided as rows of the Mat.
 

modules/core/doc/drawing_functions.rst

@@ -452,7 +452,7 @@ polylines
 -------------
 Draws several polygonal curves.
 
-.. ocv:function:: void polylines( Mat& img, const Point* const* pts, const int* npts, int ncontours, bool isClosed, const Scalar& color, int thickness=1, int lineType=8, int shift=0 )
+.. ocv:function:: void polylines( Mat& img, const Point** pts, const int* npts, int ncontours, bool isClosed, const Scalar& color, int thickness=1, int lineType=8, int shift=0 )
 
 .. ocv:function:: void polylines( InputOutputArray img, InputArrayOfArrays pts, bool isClosed, const Scalar& color, int thickness=1, int lineType=8, int shift=0 )
 

modules/core/doc/operations_on_arrays.rst

@@ -1085,7 +1085,7 @@ Calculates eigenvalues and eigenvectors of a symmetric matrix.
 
 .. ocv:function:: bool eigen(InputArray src, OutputArray eigenvalues, OutputArray eigenvectors, int lowindex=-1,int highindex=-1)
 
-.. ocv:pyfunction:: cv2.eigen(src, calculateEigenvectors[, eigenvalues[, eigenvectors]]) -> retval, eigenvalues, eigenvectors
+.. ocv:pyfunction:: cv2.eigen(src, computeEigenvectors[, eigenvalues[, eigenvectors]]) -> retval, eigenvalues, eigenvectors
 
 .. ocv:cfunction:: void cvEigenVV( CvArr* mat, CvArr* evects, CvArr* evals, double eps=0, int lowindex=-1, int highindex=-1 )
 
@@ -2283,7 +2283,7 @@ PCA constructors
         * **CV_PCA_DATA_AS_COL** indicates that the input samples are stored as matrix columns.
 
     :param maxComponents: maximum number of components that PCA should retain; by default, all the components are retained.
-    
+
     :param retainedVariance: Percentage of variance that PCA should retain. Using this parameter will let the PCA decided how many components to retain but it will always keep at least 2.
 
 The default constructor initializes an empty PCA structure. The other constructors initialize the structure and call
@@ -2297,10 +2297,12 @@ Performs Principal Component Analysis of the supplied dataset.
 
 .. ocv:function:: PCA& PCA::operator()(InputArray data, InputArray mean, int flags, int maxComponents=0)
 
-.. ocv:function:: PCA& PCA::operator()(InputArray data, InputArray mean, int flags, double retainedVariance)
+.. ocv:function:: PCA& PCA::computeVar(InputArray data, InputArray mean, int flags, double retainedVariance)
 
 .. ocv:pyfunction:: cv2.PCACompute(data[, mean[, eigenvectors[, maxComponents]]]) -> mean, eigenvectors
 
+.. ocv:pyfunction:: cv2.PCAComputeVar(data, retainedVariance[, mean[, eigenvectors]]) -> mean, eigenvectors
+
     :param data: input samples stored as the matrix rows or as the matrix columns.
 
     :param mean: optional mean value; if the matrix is empty (``noArray()``), the mean is computed from the data.
@@ -2312,7 +2314,7 @@ Performs Principal Component Analysis of the supplied dataset.
         * **CV_PCA_DATA_AS_COL** indicates that the input samples are stored as matrix columns.
 
     :param maxComponents: maximum number of components that PCA should retain; by default, all the components are retained.
-    
+
     :param retainedVariance: Percentage of variance that PCA should retain. Using this parameter will let the PCA decided how many components to retain but it will always keep at least 2.
 
 The operator performs PCA of the supplied dataset. It is safe to reuse the same PCA structure for multiple datasets. That is, if the  structure has been previously used with another dataset, the existing internal data is reclaimed and the new ``eigenvalues``, ``eigenvectors`` , and ``mean`` are allocated and computed.

modules/features2d/doc/feature_detection_and_description.rst

@@ -7,7 +7,9 @@ FAST
 ----
 Detects corners using the FAST algorithm
 
-.. ocv:function:: void FAST( InputArray image, vector<KeyPoint>& keypoints, int threshold, bool nonmaxSupression=true, type=FastFeatureDetector::TYPE_9_16 )
+.. ocv:function:: void FAST( InputArray image, vector<KeyPoint>& keypoints, int threshold, bool nonmaxSupression=true )
+
+.. ocv:function:: void FASTX( InputArray image, vector<KeyPoint>& keypoints, int threshold, bool nonmaxSupression, int type )
 
     :param image: grayscale image where keypoints (corners) are detected.
 

modules/gpu/doc/image_processing.rst

@@ -824,7 +824,7 @@ gpu::bilateralFilter
 --------------------
 Performs bilateral filtering of passed image
 
-.. ocv:function:: void gpu::bilateralFilter(const GpuMat& src, GpuMat& dst, int kernel_size, float sigma_color, float sigma_spatial, int borderMode, Stream& stream = Stream::Null())
+.. ocv:function:: void gpu::bilateralFilter( const GpuMat& src, GpuMat& dst, int kernel_size, float sigma_color, float sigma_spatial, int borderMode=BORDER_DEFAULT, Stream& stream=Stream::Null() )
 
     :param src: Source image. Supports only (channles != 2 && depth() != CV_8S && depth() != CV_32S && depth() != CV_64F).
 
@@ -849,7 +849,7 @@ gpu::nonLocalMeans
 -------------------
 Performs pure non local means denoising without any simplification, and thus it is not fast.
 
-.. ocv:function:: void nonLocalMeans(const GpuMat& src, GpuMat& dst, float h, int search_window = 21, int block_size = 7, int borderMode = BORDER_DEFAULT, Stream& s = Stream::Null())
+.. ocv:function:: void gpu::nonLocalMeans(const GpuMat& src, GpuMat& dst, float h, int search_window = 21, int block_size = 7, int borderMode = BORDER_DEFAULT, Stream& s = Stream::Null())
 
     :param src: Source image. Supports only CV_8UC1, CV_8UC2 and CV_8UC3.
 
@@ -868,7 +868,7 @@ Performs pure non local means denoising without any simplification, and thus it
 .. seealso::
 
     :ocv:func:`fastNlMeansDenoising`
-    
+
 gpu::FastNonLocalMeansDenoising
 -------------------------------
 .. ocv:class:: gpu::FastNonLocalMeansDenoising
@@ -877,10 +877,10 @@ gpu::FastNonLocalMeansDenoising
     {
     public:
         //! Simple method, recommended for grayscale images (though it supports multichannel images)
-        void simpleMethod(const GpuMat& src, GpuMat& dst, float h, int search_window = 21, int block_size = 7, Stream& s = Stream::Null());
+        void simpleMethod(const GpuMat& src, GpuMat& dst, float h, int search_window = 21, int block_size = 7, Stream& s = Stream::Null())
 
         //! Processes luminance and color components separatelly
-        void labMethod(const GpuMat& src, GpuMat& dst, float h_luminance, float h_color, int search_window = 21, int block_size = 7, Stream& s = Stream::Null());
+        void labMethod(const GpuMat& src, GpuMat& dst, float h_luminance, float h_color, int search_window = 21, int block_size = 7, Stream& s = Stream::Null())
     };
 
 The class implements fast approximate Non Local Means Denoising algorithm.
@@ -889,52 +889,52 @@ gpu::FastNonLocalMeansDenoising::simpleMethod()
 -------------------------------------
 Perform image denoising using Non-local Means Denoising algorithm http://www.ipol.im/pub/algo/bcm_non_local_means_denoising with several computational optimizations. Noise expected to be a gaussian white noise
 
-.. ocv:function:: void gpu::FastNonLocalMeansDenoising::simpleMethod(const GpuMat& src, GpuMat& dst, float h, int search_window = 21, int block_size = 7, Stream& s = Stream::Null());
+.. ocv:function:: void gpu::FastNonLocalMeansDenoising::simpleMethod(const GpuMat& src, GpuMat& dst, float h, int search_window = 21, int block_size = 7, Stream& s = Stream::Null())
 
     :param src: Input 8-bit 1-channel, 2-channel or 3-channel image.
 
     :param dst: Output image with the same size and type as  ``src`` .
-    
+
     :param h: Parameter regulating filter strength. Big h value perfectly removes noise but also removes image details, smaller h value preserves details but also preserves some noise
 
     :param search_window: Size in pixels of the window that is used to compute weighted average for given pixel. Should be odd. Affect performance linearly: greater search_window - greater denoising time. Recommended value 21 pixels
-    
+
     :param block_size: Size in pixels of the template patch that is used to compute weights. Should be odd. Recommended value 7 pixels
-           
+
     :param stream: Stream for the asynchronous invocations.
 
-This function expected to be applied to grayscale images. For colored images look at ``FastNonLocalMeansDenoising::labMethod``. 
+This function expected to be applied to grayscale images. For colored images look at ``FastNonLocalMeansDenoising::labMethod``.
+
+.. seealso::
 
-.. seealso:: 
-    
     :ocv:func:`fastNlMeansDenoising`
 
 gpu::FastNonLocalMeansDenoising::labMethod()
 -------------------------------------
 Modification of ``FastNonLocalMeansDenoising::simpleMethod`` for color images
 
-.. ocv:function:: void gpu::FastNonLocalMeansDenoising::labMethod(const GpuMat& src, GpuMat& dst, float h_luminance, float h_color, int search_window = 21, int block_size = 7, Stream& s = Stream::Null());
+.. ocv:function:: void gpu::FastNonLocalMeansDenoising::labMethod(const GpuMat& src, GpuMat& dst, float h_luminance, float h_color, int search_window = 21, int block_size = 7, Stream& s = Stream::Null())
 
     :param src: Input 8-bit 3-channel image.
 
     :param dst: Output image with the same size and type as  ``src`` .
 
     :param h_luminance: Parameter regulating filter strength. Big h value perfectly removes noise but also removes image details, smaller h value preserves details but also preserves some noise
-    
+
     :param float: The same as h but for color components. For most images value equals 10 will be enought to remove colored noise and do not distort colors
 
     :param search_window: Size in pixels of the window that is used to compute weighted average for given pixel. Should be odd. Affect performance linearly: greater search_window - greater denoising time. Recommended value 21 pixels
-    
+
     :param block_size: Size in pixels of the template patch that is used to compute weights. Should be odd. Recommended value 7 pixels
-           
+
     :param stream: Stream for the asynchronous invocations.
-    
+
 The function converts image to CIELAB colorspace and then separately denoise L and AB components with given h parameters using ``FastNonLocalMeansDenoising::simpleMethod`` function.
 
-.. seealso:: 
+.. seealso::
 
     :ocv:func:`fastNlMeansDenoisingColored`
-    
+
 gpu::alphaComp
 -------------------
 Composites two images using alpha opacity values contained in each image.

modules/gpu/doc/object_detection.rst

@@ -271,9 +271,7 @@ gpu::CascadeClassifier_GPU::detectMultiScale
 ------------------------------------------------
 Detects objects of different sizes in the input image.
 
-.. ocv:function:: int gpu::CascadeClassifier_GPU::detectMultiScale(const GpuMat& image, GpuMat& objectsBuf, double scaleFactor=1.2, int minNeighbors=4, Size minSize=Size())
-
-.. ocv:function:: int gpu::CascadeClassifier_GPU::detectMultiScale(const GpuMat& image, GpuMat& objectsBuf, Size maxObjectSize, Size minSize = Size(), double scaleFactor = 1.1, int minNeighbors = 4)
+.. ocv:function:: int gpu::CascadeClassifier_GPU::detectMultiScale( const GpuMat& image, GpuMat& objectsBuf, double scaleFactor=1.1, int minNeighbors=4, Size minSize=Size() )
 
     :param image: Matrix of type  ``CV_8U``  containing an image where objects should be detected.
 

modules/gpu/doc/per_element_operations.rst

@@ -276,8 +276,6 @@ Compares elements of two matrices.
 
 .. ocv:function:: void gpu::compare( const GpuMat& a, const GpuMat& b, GpuMat& c, int cmpop, Stream& stream=Stream::Null() )
 
-.. ocv:function:: void gpu::compare(const GpuMat& a, Scalar sc, GpuMat& c, int cmpop, Stream& stream = Stream::Null())
-
     :param a: First source matrix.
 
     :param b: Second source matrix with the same size and type as ``a`` .

modules/gpu/doc/video.rst

@@ -739,7 +739,7 @@ gpu::GMG_GPU::operator()
 ------------------------
 Updates the background model and returns the foreground mask
 
-.. ocv:function:: void gpu::GMG_GPU::operator()(const GpuMat& frame, GpuMat& fgmask, Stream& stream = Stream::Null())
+.. ocv:function:: void gpu::GMG_GPU::operator ()( const GpuMat& frame, GpuMat& fgmask, float learningRate=-1.0f, Stream& stream=Stream::Null() )
 
     :param frame: Next video frame.
 

modules/imgproc/doc/motion_analysis_and_object_tracking.rst

@@ -151,7 +151,9 @@ The function is used to detect translational shifts that occur between two image
 
 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(), double* response = 0)
+.. ocv:function:: Point2d phaseCorrelate(InputArray src1, InputArray src2, InputArray window = noArray())
+
+.. ocv:function:: Point2d phaseCorrelateRes(InputArray src1, InputArray src2, InputArray window, double* response = 0)
 
     :param src1: Source floating point array (CV_32FC1 or CV_64FC1)
     :param src2: Source floating point array (CV_32FC1 or CV_64FC1)

modules/nonfree/doc/feature_detection.rst

@@ -104,8 +104,7 @@ Detects keypoints and computes SURF descriptors for them.
 .. ocv:function:: void SURF::operator()(InputArray img, InputArray mask, vector<KeyPoint>& keypoints) const
 .. ocv:function:: void SURF::operator()(InputArray img, InputArray mask, vector<KeyPoint>& keypoints, OutputArray descriptors, bool useProvidedKeypoints=false)
 
-.. ocv:pyfunction:: cv2.SURF.detect(img, mask) -> keypoints
-.. ocv:pyfunction:: cv2.SURF.detect(img, mask[, descriptors[, useProvidedKeypoints]]) -> keypoints, descriptors
+.. ocv:pyfunction:: cv2.SURF.detect(image[, mask]) -> keypoints
 
 .. ocv:cfunction:: void cvExtractSURF( const CvArr* image, const CvArr* mask, CvSeq** keypoints, CvSeq** descriptors, CvMemStorage* storage, CvSURFParams params )
 

modules/ocl/doc/structures_and_functions.rst

@@ -13,11 +13,11 @@ ocl::getDevice
 ------------------
 Returns the list of devices
 
-.. ocv:function:: int ocl::getDevice(std::vector<Info>& oclinfo, int devicetype = CVCL_DEVICE_TYPE_GPU)
+.. ocv:function:: int ocl::getDevice( std::vector<Info> & oclinfo, int devicetype=CVCL_DEVICE_TYPE_GPU )
 
     :param oclinfo: Output vector of ``ocl::Info`` structures
-    
+
     :param devicetype: One of ``CVCL_DEVICE_TYPE_GPU``, ``CVCL_DEVICE_TYPE_CPU`` or ``CVCL_DEVICE_TYPE_DEFAULT``.
-    
+
 the function must be called before any other ``cv::ocl`` functions; it initializes ocl runtime.
 

modules/photo/doc/denoising.rst

@@ -4,40 +4,40 @@ Denoising
 .. highlight:: cpp
 
 fastNlMeansDenoising
------------
+--------------------
 Perform image denoising using Non-local Means Denoising algorithm http://www.ipol.im/pub/algo/bcm_non_local_means_denoising/
 with several computational optimizations. Noise expected to be a gaussian white noise
 
-.. ocv:function:: void fastNlMeansDenoising( Mat& src, Mat& dst, int templateWindowSize, int searchWindowSize, int h )
+.. ocv:function:: void fastNlMeansDenoising( InputArray src, OutputArray dst, float h=3, int templateWindowSize=7, int searchWindowSize=21 )
 
     :param src: Input 8-bit 1-channel, 2-channel or 3-channel image.
 
     :param dst: Output image with the same size and type as  ``src`` .
 
     :param templateWindowSize: Size in pixels of the template patch that is used to compute weights. Should be odd. Recommended value 7 pixels
-    
+
     :param searchWindowSize: Size in pixels of the window that is used to compute weighted average for given pixel. Should be odd. Affect performance linearly: greater searchWindowsSize - greater denoising time. Recommended value 21 pixels
-    
+
     :param h: Parameter regulating filter strength. Big h value perfectly removes noise but also removes image details, smaller h value preserves details but also preserves some noise
 
 This function expected to be applied to grayscale images. For colored images look at ``fastNlMeansDenoisingColored``.
-Advanced usage of this functions can be manual denoising of colored image in different colorspaces. 
+Advanced usage of this functions can be manual denoising of colored image in different colorspaces.
 Such approach is used in ``fastNlMeansDenoisingColored`` by converting image to CIELAB colorspace and then separately denoise L and AB components with different h parameter.
 
 fastNlMeansDenoisingColored
------------
+---------------------------
 Modification of ``fastNlMeansDenoising`` function for colored images
 
-.. ocv:function:: void fastNlMeansDenoisingColored( Mat& src, Mat& dst, int templateWindowSize, int searchWindowSize, int h, int hForColorComponents )
+.. ocv:function:: void fastNlMeansDenoisingColored( InputArray src, OutputArray dst, float h=3, float hColor=3, int templateWindowSize=7, int searchWindowSize=21 )
 
     :param src: Input 8-bit 3-channel image.
 
     :param dst: Output image with the same size and type as  ``src`` .
 
     :param templateWindowSize: Size in pixels of the template patch that is used to compute weights. Should be odd. Recommended value 7 pixels
-    
+
     :param searchWindowSize: Size in pixels of the window that is used to compute weighted average for given pixel. Should be odd. Affect performance linearly: greater searchWindowsSize - greater denoising time. Recommended value 21 pixels
-    
+
     :param h: Parameter regulating filter strength for luminance component. Bigger h value perfectly removes noise but also removes image details, smaller h value preserves details but also preserves some noise
 
     :param hForColorComponents: The same as h but for color components. For most images value equals 10 will be enought to remove colored noise and do not distort colors
@@ -45,11 +45,11 @@ Modification of ``fastNlMeansDenoising`` function for colored images
 The function converts image to CIELAB colorspace and then separately denoise L and AB components with given h parameters using ``fastNlMeansDenoising`` function.
 
 fastNlMeansDenoisingMulti
------------
+-------------------------
 Modification of ``fastNlMeansDenoising`` function for images sequence where consequtive images have been captured in small period of time. For example video. This version of the function is for grayscale images or for manual manipulation with colorspaces.
 For more details see http://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.131.6394
 
-.. ocv:function:: void fastNlMeansDenoisingMulti( const std::vector<Mat>& srcImgs, int imgToDenoiseIndex, int temporalWindowSize, Mat& dst, int templateWindowSize, int searchWindowSize, int h)
+.. ocv:function:: void fastNlMeansDenoisingMulti( InputArrayOfArrays srcImgs, OutputArray dst, int imgToDenoiseIndex, int temporalWindowSize, float h=3, int templateWindowSize=7, int searchWindowSize=21 )
 
     :param srcImgs: Input 8-bit 1-channel, 2-channel or 3-channel images sequence. All images should have the same type and size.
 
@@ -60,16 +60,16 @@ For more details see http://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.131
     :param dst: Output image with the same size and type as ``srcImgs`` images.
 
     :param templateWindowSize: Size in pixels of the template patch that is used to compute weights. Should be odd. Recommended value 7 pixels
-    
+
     :param searchWindowSize: Size in pixels of the window that is used to compute weighted average for given pixel. Should be odd. Affect performance linearly: greater searchWindowsSize - greater denoising time. Recommended value 21 pixels
-    
+
     :param h: Parameter regulating filter strength for luminance component. Bigger h value perfectly removes noise but also removes image details, smaller h value preserves details but also preserves some noise
 
 fastNlMeansDenoisingColoredMulti
------------
+--------------------------------
 Modification of ``fastNlMeansDenoisingMulti`` function for colored images sequences
 
-.. ocv:function:: void fastNlMeansDenoisingColoredMulti( const std::vector<Mat>& srcImgs, int imgToDenoiseIndex, int temporalWindowSize, Mat& dst, int templateWindowSize, int searchWindowSize, int h, int hForColorComponents)
+.. ocv:function:: void fastNlMeansDenoisingColoredMulti( InputArrayOfArrays srcImgs, OutputArray dst, int imgToDenoiseIndex, int temporalWindowSize, float h=3, float hColor=3, int templateWindowSize=7, int searchWindowSize=21 )
 
     :param srcImgs: Input 8-bit 3-channel images sequence. All images should have the same type and size.
 
@@ -80,9 +80,9 @@ Modification of ``fastNlMeansDenoisingMulti`` function for colored images sequen
     :param dst: Output image with the same size and type as ``srcImgs`` images.
 
     :param templateWindowSize: Size in pixels of the template patch that is used to compute weights. Should be odd. Recommended value 7 pixels
-    
+
     :param searchWindowSize: Size in pixels of the window that is used to compute weighted average for given pixel. Should be odd. Affect performance linearly: greater searchWindowsSize - greater denoising time. Recommended value 21 pixels
-    
+
     :param h: Parameter regulating filter strength for luminance component. Bigger h value perfectly removes noise but also removes image details, smaller h value preserves details but also preserves some noise.
 
     :param hForColorComponents: The same as h but for color components.

modules/video/doc/motion_analysis_and_object_tracking.rst

@@ -598,16 +598,16 @@ See :ocv:func:`BackgroundSubtractor::getBackgroundImage`.
 
 
 calcOpticalFlowSF
------------
+-----------------
 Calculate an optical flow using "SimpleFlow" algorithm.
 
-.. ocv:function:: void calcOpticalFlowSF( Mat& prev, Mat& next, Mat& flowX, Mat& flowY, int layers, int averaging_block_size, int max_flow)
+.. ocv:function:: void calcOpticalFlowSF( Mat& from, Mat& to, Mat& flow, int layers, int averaging_block_size, int max_flow )
 
-.. ocv:function:: void calcOpticalFlowSF( Mat& prev, Mat& next, Mat& flowX, Mat& flowY, int layers, int averaging_block_size, int max_flow, double sigma_dist, double sigma_color, int postprocess_window, double sigma_dist_fix, double sigma_color_fix, double occ_thr, int upscale_averaging_radiud, double upscale_sigma_dist, double upscale_sigma_color, double speed_up_thr)
+.. ocv:function:: void calcOpticalFlowSF( Mat& from, Mat& to, Mat& flow, int layers, int averaging_block_size, int max_flow, double sigma_dist, double sigma_color, int postprocess_window, double sigma_dist_fix, double sigma_color_fix, double occ_thr, int upscale_averaging_radius, double upscale_sigma_dist, double upscale_sigma_color, double speed_up_thr )
 
     :param prev: First 8-bit 3-channel image.
 
-    :param next: Second 8-bit 3-channel image 
+    :param next: Second 8-bit 3-channel image
 
     :param flowX: X-coordinate of estimated flow
 
@@ -639,7 +639,7 @@ Calculate an optical flow using "SimpleFlow" algorithm.
 
     :param speed_up_thr: threshold to detect point with irregular flow - where flow should be recalculated after upscale
 
-See [Tao2012]_. And site of project - http://graphics.berkeley.edu/papers/Tao-SAN-2012-05/. 
+See [Tao2012]_. And site of project - http://graphics.berkeley.edu/papers/Tao-SAN-2012-05/.
 
 .. [Bouguet00] Jean-Yves Bouguet. Pyramidal Implementation of the Lucas Kanade Feature Tracker.