Merge remote-tracking branch 'upstream/3.4' into merge-3.4

cmake/templates/opencv_abi.xml.in

@@ -22,6 +22,8 @@
 
 <skip_headers>
     opencv2/core/hal/intrin*
+    opencv2/core/hal/*macros.*
+    opencv2/core/hal/*.impl.*
     opencv2/core/cuda*
     opencv2/core/opencl*
     opencv2/core/private*

doc/py_tutorials/py_imgproc/py_colorspaces/py_colorspaces.markdown

@@ -5,44 +5,44 @@ Goal
 ----
 
 -   In this tutorial, you will learn how to convert images from one color-space to another, like
-    BGR \f$\leftrightarrow\f$ Gray, BGR \f$\leftrightarrow\f$ HSV etc.
--   In addition to that, we will create an application which extracts a colored object in a video
--   You will learn following functions : **cv.cvtColor()**, **cv.inRange()** etc.
+    BGR \f$\leftrightarrow\f$ Gray, BGR \f$\leftrightarrow\f$ HSV, etc.
+-   In addition to that, we will create an application to extract a colored object in a video
+-   You will learn the following functions: **cv.cvtColor()**, **cv.inRange()**, etc.
 
 Changing Color-space
 --------------------
 
 There are more than 150 color-space conversion methods available in OpenCV. But we will look into
-only two which are most widely used ones, BGR \f$\leftrightarrow\f$ Gray and BGR \f$\leftrightarrow\f$ HSV.
+only two, which are most widely used ones: BGR \f$\leftrightarrow\f$ Gray and BGR \f$\leftrightarrow\f$ HSV.
 
 For color conversion, we use the function cv.cvtColor(input_image, flag) where flag determines the
 type of conversion.
 
-For BGR \f$\rightarrow\f$ Gray conversion we use the flags cv.COLOR_BGR2GRAY. Similarly for BGR
+For BGR \f$\rightarrow\f$ Gray conversion, we use the flag cv.COLOR_BGR2GRAY. Similarly for BGR
 \f$\rightarrow\f$ HSV, we use the flag cv.COLOR_BGR2HSV. To get other flags, just run following
-commands in your Python terminal :
+commands in your Python terminal:
 @code{.py}
 >>> import cv2 as cv
 >>> flags = [i for i in dir(cv) if i.startswith('COLOR_')]
 >>> print( flags )
 @endcode
-@note For HSV, Hue range is [0,179], Saturation range is [0,255] and Value range is [0,255].
+@note For HSV, hue range is [0,179], saturation range is [0,255], and value range is [0,255].
 Different software use different scales. So if you are comparing OpenCV values with them, you need
 to normalize these ranges.
 
 Object Tracking
 ---------------
 
-Now we know how to convert BGR image to HSV, we can use this to extract a colored object. In HSV, it
-is more easier to represent a color than in BGR color-space. In our application, we will try to extract
+Now that we know how to convert a BGR image to HSV, we can use this to extract a colored object. In HSV, it
+is easier to represent a color than in BGR color-space. In our application, we will try to extract
 a blue colored object. So here is the method:
 
 -   Take each frame of the video
 -   Convert from BGR to HSV color-space
 -   We threshold the HSV image for a range of blue color
--   Now extract the blue object alone, we can do whatever on that image we want.
+-   Now extract the blue object alone, we can do whatever we want on that image.
 
-Below is the code which are commented in detail :
+Below is the code which is commented in detail:
 @code{.py}
 import cv2 as cv
 import numpy as np
@@ -80,18 +80,18 @@ Below image shows tracking of the blue object:
 
 ![image](images/frame.jpg)
 
-@note There are some noises in the image. We will see how to remove them in later chapters.
+@note There is some noise in the image. We will see how to remove it in later chapters.
 
 @note This is the simplest method in object tracking. Once you learn functions of contours, you can
-do plenty of things like find centroid of this object and use it to track the object, draw diagrams
-just by moving your hand in front of camera and many other funny stuffs.
+do plenty of things like find the centroid of an object and use it to track the object, draw diagrams
+just by moving your hand in front of a camera, and other fun stuff.
 
 How to find HSV values to track?
 --------------------------------
 
 This is a common question found in [stackoverflow.com](http://www.stackoverflow.com). It is very simple and
 you can use the same function, cv.cvtColor(). Instead of passing an image, you just pass the BGR
-values you want. For example, to find the HSV value of Green, try following commands in Python
+values you want. For example, to find the HSV value of Green, try the following commands in a Python
 terminal:
 @code{.py}
 >>> green = np.uint8([[[0,255,0 ]]])
@@ -99,7 +99,7 @@ terminal:
 >>> print( hsv_green )
 [[[ 60 255 255]]]
 @endcode
-Now you take [H-10, 100,100] and [H+10, 255, 255] as lower bound and upper bound respectively. Apart
+Now you take [H-10, 100,100] and [H+10, 255, 255] as the lower bound and upper bound respectively. Apart
 from this method, you can use any image editing tools like GIMP or any online converters to find
 these values, but don't forget to adjust the HSV ranges.
 
@@ -109,5 +109,5 @@ Additional Resources
 Exercises
 ---------
 
--#  Try to find a way to extract more than one colored objects, for eg, extract red, blue, green
-    objects simultaneously.
+-#  Try to find a way to extract more than one colored object, for example, extract red, blue, and green
+objects simultaneously.

doc/py_tutorials/py_imgproc/py_filtering/py_filtering.markdown

@@ -5,24 +5,24 @@ Goals
 -----
 
 Learn to:
-    -   Blur the images with various low pass filters
+    -   Blur images with various low pass filters
     -   Apply custom-made filters to images (2D convolution)
 
 2D Convolution ( Image Filtering )
 ----------------------------------
 
-As in one-dimensional signals, images also can be filtered with various low-pass filters(LPF),
-high-pass filters(HPF) etc. LPF helps in removing noises, blurring the images etc. HPF filters helps
-in finding edges in the images.
+As in one-dimensional signals, images also can be filtered with various low-pass filters (LPF),
+high-pass filters (HPF), etc. LPF helps in removing noise, blurring images, etc. HPF filters help
+in finding edges in images.
 
 OpenCV provides a function **cv.filter2D()** to convolve a kernel with an image. As an example, we
-will try an averaging filter on an image. A 5x5 averaging filter kernel will look like below:
+will try an averaging filter on an image. A 5x5 averaging filter kernel will look like the below:
 
 \f[K =  \frac{1}{25} \begin{bmatrix} 1 & 1 & 1 & 1 & 1  \\ 1 & 1 & 1 & 1 & 1 \\ 1 & 1 & 1 & 1 & 1 \\ 1 & 1 & 1 & 1 & 1 \\ 1 & 1 & 1 & 1 & 1 \end{bmatrix}\f]
 
-Operation is like this: keep this kernel above a pixel, add all the 25 pixels below this kernel,
-take its average and replace the central pixel with the new average value. It continues this
-operation for all the pixels in the image. Try this code and check the result:
+The operation works like this: keep this kernel above a pixel, add all the 25 pixels below this kernel,
+take the average, and replace the central pixel with the new average value. This operation is continued
+for all the pixels in the image. Try this code and check the result:
 @code{.py}
 import numpy as np
 import cv2 as cv
@@ -47,20 +47,20 @@ Image Blurring (Image Smoothing)
 --------------------------------
 
 Image blurring is achieved by convolving the image with a low-pass filter kernel. It is useful for
-removing noises. It actually removes high frequency content (eg: noise, edges) from the image. So
-edges are blurred a little bit in this operation. (Well, there are blurring techniques which doesn't
-blur the edges too). OpenCV provides mainly four types of blurring techniques.
+removing noise. It actually removes high frequency content (eg: noise, edges) from the image. So
+edges are blurred a little bit in this operation (there are also blurring techniques which don't
+blur the edges). OpenCV provides four main types of blurring techniques.
 
 ### 1. Averaging
 
-This is done by convolving image with a normalized box filter. It simply takes the average of all
-the pixels under kernel area and replace the central element. This is done by the function
+This is done by convolving an image with a normalized box filter. It simply takes the average of all
+the pixels under the kernel area and replaces the central element. This is done by the function
 **cv.blur()** or **cv.boxFilter()**. Check the docs for more details about the kernel. We should
-specify the width and height of kernel. A 3x3 normalized box filter would look like below:
+specify the width and height of the kernel. A 3x3 normalized box filter would look like the below:
 
 \f[K =  \frac{1}{9} \begin{bmatrix} 1 & 1 & 1  \\ 1 & 1 & 1 \\ 1 & 1 & 1 \end{bmatrix}\f]
 
-@note If you don't want to use normalized box filter, use **cv.boxFilter()**. Pass an argument
+@note If you don't want to use a normalized box filter, use **cv.boxFilter()**. Pass an argument
 normalize=False to the function.
 
 Check a sample demo below with a kernel of 5x5 size:
@@ -85,12 +85,12 @@ Result:
 
 ### 2. Gaussian Blurring
 
-In this, instead of box filter, gaussian kernel is used. It is done with the function,
-**cv.GaussianBlur()**. We should specify the width and height of kernel which should be positive
-and odd. We also should specify the standard deviation in X and Y direction, sigmaX and sigmaY
-respectively. If only sigmaX is specified, sigmaY is taken as same as sigmaX. If both are given as
-zeros, they are calculated from kernel size. Gaussian blurring is highly effective in removing
-gaussian noise from the image.
+In this method, instead of a box filter, a Gaussian kernel is used. It is done with the function,
+**cv.GaussianBlur()**. We should specify the width and height of the kernel which should be positive
+and odd. We also should specify the standard deviation in the X and Y directions, sigmaX and sigmaY
+respectively. If only sigmaX is specified, sigmaY is taken as the same as sigmaX. If both are given as
+zeros, they are calculated from the kernel size. Gaussian blurring is highly effective in removing
+Gaussian noise from an image.
 
 If you want, you can create a Gaussian kernel with the function, **cv.getGaussianKernel()**.
 
@@ -104,14 +104,14 @@ Result:
 
 ### 3. Median Blurring
 
-Here, the function **cv.medianBlur()** takes median of all the pixels under kernel area and central
+Here, the function **cv.medianBlur()** takes the median of all the pixels under the kernel area and the central
 element is replaced with this median value. This is highly effective against salt-and-pepper noise
-in the images. Interesting thing is that, in the above filters, central element is a newly
+in an image. Interestingly, in the above filters, the central element is a newly
 calculated value which may be a pixel value in the image or a new value. But in median blurring,
-central element is always replaced by some pixel value in the image. It reduces the noise
+the central element is always replaced by some pixel value in the image. It reduces the noise
 effectively. Its kernel size should be a positive odd integer.
 
-In this demo, I added a 50% noise to our original image and applied median blur. Check the result:
+In this demo, I added a 50% noise to our original image and applied median blurring. Check the result:
 @code{.py}
 median = cv.medianBlur(img,5)
 @endcode
@@ -122,19 +122,19 @@ Result:
 ### 4. Bilateral Filtering
 
 **cv.bilateralFilter()** is highly effective in noise removal while keeping edges sharp. But the
-operation is slower compared to other filters. We already saw that gaussian filter takes the a
-neighbourhood around the pixel and find its gaussian weighted average. This gaussian filter is a
+operation is slower compared to other filters. We already saw that a Gaussian filter takes the
+neighbourhood around the pixel and finds its Gaussian weighted average. This Gaussian filter is a
 function of space alone, that is, nearby pixels are considered while filtering. It doesn't consider
-whether pixels have almost same intensity. It doesn't consider whether pixel is an edge pixel or
+whether pixels have almost the same intensity. It doesn't consider whether a pixel is an edge pixel or
 not. So it blurs the edges also, which we don't want to do.
 
-Bilateral filter also takes a gaussian filter in space, but one more gaussian filter which is a
-function of pixel difference. Gaussian function of space make sure only nearby pixels are considered
-for blurring while gaussian function of intensity difference make sure only those pixels with
-similar intensity to central pixel is considered for blurring. So it preserves the edges since
+Bilateral filtering also takes a Gaussian filter in space, but one more Gaussian filter which is a
+function of pixel difference. The Gaussian function of space makes sure that only nearby pixels are considered
+for blurring, while the Gaussian function of intensity difference makes sure that only those pixels with
+similar intensities to the central pixel are considered for blurring. So it preserves the edges since
 pixels at edges will have large intensity variation.
 
-Below samples shows use bilateral filter (For details on arguments, visit docs).
+The below sample shows use of a bilateral filter (For details on arguments, visit docs).
 @code{.py}
 blur = cv.bilateralFilter(img,9,75,75)
 @endcode
@@ -142,7 +142,7 @@ Result:
 
 ![image](images/bilateral.jpg)
 
-See, the texture on the surface is gone, but edges are still preserved.
+See, the texture on the surface is gone, but the edges are still preserved.
 
 Additional Resources
 --------------------

doc/py_tutorials/py_imgproc/py_geometric_transformations/py_geometric_transformations.markdown

@@ -4,7 +4,7 @@ Geometric Transformations of Images {#tutorial_py_geometric_transformations}
 Goals
 -----
 
--   Learn to apply different geometric transformation to images like translation, rotation, affine
+-   Learn to apply different geometric transformations to images, like translation, rotation, affine
     transformation etc.
 -   You will see these functions: **cv.getPerspectiveTransform**
 
@@ -12,7 +12,7 @@ Transformations
 ---------------
 
 OpenCV provides two transformation functions, **cv.warpAffine** and **cv.warpPerspective**, with
-which you can have all kinds of transformations. **cv.warpAffine** takes a 2x3 transformation
+which you can perform all kinds of transformations. **cv.warpAffine** takes a 2x3 transformation
 matrix while **cv.warpPerspective** takes a 3x3 transformation matrix as input.
 
 ### Scaling
@@ -21,8 +21,8 @@ Scaling is just resizing of the image. OpenCV comes with a function **cv.resize(
 purpose. The size of the image can be specified manually, or you can specify the scaling factor.
 Different interpolation methods are used. Preferable interpolation methods are **cv.INTER_AREA**
 for shrinking and **cv.INTER_CUBIC** (slow) & **cv.INTER_LINEAR** for zooming. By default,
-interpolation method used is **cv.INTER_LINEAR** for all resizing purposes. You can resize an
-input image either of following methods:
+the interpolation method **cv.INTER_LINEAR** is used for all resizing purposes. You can resize an
+input image with either of following methods:
 @code{.py}
 import numpy as np
 import cv2 as cv
@@ -38,13 +38,13 @@ res = cv.resize(img,(2*width, 2*height), interpolation = cv.INTER_CUBIC)
 @endcode
 ### Translation
 
-Translation is the shifting of object's location. If you know the shift in (x,y) direction, let it
+Translation is the shifting of an object's location. If you know the shift in the (x,y) direction and let it
 be \f$(t_x,t_y)\f$, you can create the transformation matrix \f$\textbf{M}\f$ as follows:
 
 \f[M = \begin{bmatrix} 1 & 0 & t_x \\ 0 & 1 & t_y  \end{bmatrix}\f]
 
-You can take make it into a Numpy array of type np.float32 and pass it into **cv.warpAffine()**
-function. See below example for a shift of (100,50):
+You can take make it into a Numpy array of type np.float32 and pass it into the **cv.warpAffine()**
+function. See the below example for a shift of (100,50):
 @code{.py}
 import numpy as np
 import cv2 as cv
@@ -61,7 +61,7 @@ cv.destroyAllWindows()
 @endcode
 **warning**
 
-Third argument of the **cv.warpAffine()** function is the size of the output image, which should
+The third argument of the **cv.warpAffine()** function is the size of the output image, which should
 be in the form of **(width, height)**. Remember width = number of columns, and height = number of
 rows.
 
@@ -76,7 +76,7 @@ Rotation of an image for an angle \f$\theta\f$ is achieved by the transformation
 \f[M = \begin{bmatrix} cos\theta & -sin\theta \\ sin\theta & cos\theta   \end{bmatrix}\f]
 
 But OpenCV provides scaled rotation with adjustable center of rotation so that you can rotate at any
-location you prefer. Modified transformation matrix is given by
+location you prefer. The modified transformation matrix is given by
 
 \f[\begin{bmatrix} \alpha &  \beta & (1- \alpha )  \cdot center.x -  \beta \cdot center.y \\ - \beta &  \alpha &  \beta \cdot center.x + (1- \alpha )  \cdot center.y \end{bmatrix}\f]
 
@@ -84,7 +84,7 @@ where:
 
 \f[\begin{array}{l} \alpha =  scale \cdot \cos \theta , \\ \beta =  scale \cdot \sin \theta \end{array}\f]
 
-To find this transformation matrix, OpenCV provides a function, **cv.getRotationMatrix2D**. Check
+To find this transformation matrix, OpenCV provides a function, **cv.getRotationMatrix2D**. Check out the
 below example which rotates the image by 90 degree with respect to center without any scaling.
 @code{.py}
 img = cv.imread('messi5.jpg',0)
@@ -101,11 +101,11 @@ See the result:
 ### Affine Transformation
 
 In affine transformation, all parallel lines in the original image will still be parallel in the
-output image. To find the transformation matrix, we need three points from input image and their
-corresponding locations in output image. Then **cv.getAffineTransform** will create a 2x3 matrix
+output image. To find the transformation matrix, we need three points from the input image and their
+corresponding locations in the output image. Then **cv.getAffineTransform** will create a 2x3 matrix
 which is to be passed to **cv.warpAffine**.
 
-Check below example, and also look at the points I selected (which are marked in Green color):
+Check the below example, and also look at the points I selected (which are marked in green color):
 @code{.py}
 img = cv.imread('drawing.png')
 rows,cols,ch = img.shape
@@ -130,7 +130,7 @@ See the result:
 For perspective transformation, you need a 3x3 transformation matrix. Straight lines will remain
 straight even after the transformation. To find this transformation matrix, you need 4 points on the
 input image and corresponding points on the output image. Among these 4 points, 3 of them should not
-be collinear. Then transformation matrix can be found by the function
+be collinear. Then the transformation matrix can be found by the function
 **cv.getPerspectiveTransform**. Then apply **cv.warpPerspective** with this 3x3 transformation
 matrix.
 

doc/py_tutorials/py_imgproc/py_thresholding/py_thresholding.markdown

@@ -4,13 +4,13 @@ Image Thresholding {#tutorial_py_thresholding}
 Goal
 ----
 
--   In this tutorial, you will learn Simple thresholding, Adaptive thresholding and Otsu's thresholding.
+-   In this tutorial, you will learn simple thresholding, adaptive thresholding and Otsu's thresholding.
 -   You will learn the functions **cv.threshold** and **cv.adaptiveThreshold**.
 
 Simple Thresholding
 -------------------
 
-Here, the matter is straight forward. For every pixel, the same threshold value is applied.
+Here, the matter is straight-forward. For every pixel, the same threshold value is applied.
 If the pixel value is smaller than the threshold, it is set to 0, otherwise it is set to a maximum value.
 The function **cv.threshold** is used to apply the thresholding.
 The first argument is the source image, which **should be a grayscale image**.
@@ -65,11 +65,11 @@ Adaptive Thresholding
 
 In the previous section, we used one global value as a threshold.
 But this might not be good in all cases, e.g. if an image has different lighting conditions in different areas.
-In that case, adaptive thresholding thresholding can help.
+In that case, adaptive thresholding can help.
 Here, the algorithm determines the threshold for a pixel based on a small region around it.
 So we get different thresholds for different regions of the same image which gives better results for images with varying illumination.
 
-Additionally to the parameters described above, the method cv.adaptiveThreshold three input parameters:
+In addition to the parameters described above, the method cv.adaptiveThreshold takes three input parameters:
 
 The **adaptiveMethod** decides how the threshold value is calculated:
     -   cv.ADAPTIVE_THRESH_MEAN_C: The threshold value is the mean of the neighbourhood area minus the constant **C**.
@@ -168,8 +168,8 @@ Result:
 
 ### How does Otsu's Binarization work?
 
-This section demonstrates a Python implementation of Otsu's binarization to show how it works
-actually. If you are not interested, you can skip this.
+This section demonstrates a Python implementation of Otsu's binarization to show how it actually
+works. If you are not interested, you can skip this.
 
 Since we are working with bimodal images, Otsu's algorithm tries to find a threshold value (t) which
 minimizes the **weighted within-class variance** given by the relation:

doc/tutorials/introduction/cross_referencing/tutorial_cross_referencing.markdown

@@ -4,7 +4,7 @@ Cross referencing OpenCV from other Doxygen projects {#tutorial_cross_referencin
 Cross referencing OpenCV
 ------------------------
 
-[Doxygen](https://www.stack.nl/~dimitri/doxygen/) is a tool to generate
+[Doxygen](http://www.doxygen.nl) is a tool to generate
 documentations like the OpenCV documentation you are reading right now.
 It is used by a variety of software projects and if you happen to use it
 to generate your own documentation, and you are using OpenCV inside your
@@ -57,5 +57,5 @@ contain a `your_project.tag` file in its root directory.
 References
 ----------
 
-- [Doxygen: Linking to external documentation](https://www.stack.nl/~dimitri/doxygen/manual/external.html)
+- [Doxygen: Linking to external documentation](http://www.doxygen.nl/manual/external.html)
 - [opencv.tag](opencv.tag)

doc/tutorials/introduction/documenting_opencv/documentation_tutorial.markdown

@@ -684,12 +684,12 @@ References {#tutorial_documentation_refs}
 - [Command reference] - supported commands and their parameters
 
 <!-- invisible references list -->
-[Doxygen]: http://www.stack.nl/~dimitri/doxygen/index.html)
-[Doxygen download]: http://www.stack.nl/~dimitri/doxygen/download.html
-[Doxygen installation]: http://www.stack.nl/~dimitri/doxygen/manual/install.html
-[Documenting basics]: http://www.stack.nl/~dimitri/doxygen/manual/docblocks.html
-[Markdown support]: http://www.stack.nl/~dimitri/doxygen/manual/markdown.html
-[Formulas support]: http://www.stack.nl/~dimitri/doxygen/manual/formulas.html
+[Doxygen]: http://www.doxygen.nl
+[Doxygen download]: http://doxygen.nl/download.html
+[Doxygen installation]: http://doxygen.nl/manual/install.html
+[Documenting basics]: http://www.doxygen.nl/manual/docblocks.html
+[Markdown support]: http://www.doxygen.nl/manual/markdown.html
+[Formulas support]: http://www.doxygen.nl/manual/formulas.html
 [Supported formula commands]: http://docs.mathjax.org/en/latest/tex.html#supported-latex-commands
-[Command reference]: http://www.stack.nl/~dimitri/doxygen/manual/commands.html
+[Command reference]: http://www.doxygen.nl/manual/commands.html
 [Google Scholar]: http://scholar.google.ru/

doc/tutorials/introduction/ios_install/ios_install.markdown

@@ -9,7 +9,7 @@ Required Packages
 
 ### Getting the Cutting-edge OpenCV from Git Repository
 
-Launch GIT client and clone OpenCV repository from [here](http://github.com/opencv/opencv)
+Launch Git client and clone OpenCV repository from [GitHub](http://github.com/opencv/opencv).
 
 In MacOS it can be done using the following command in Terminal:
 
@@ -18,24 +18,48 @@ cd ~/<my_working _directory>
 git clone https://github.com/opencv/opencv.git
 @endcode
 
+If you want to install OpenCV’s extra modules, clone the opencv_contrib repository as well:
+
+@code{.bash}
+cd ~/<my_working _directory>
+git clone https://github.com/opencv/opencv_contrib.git
+@endcode
+
+
 Building OpenCV from Source, using CMake and Command Line
 ---------------------------------------------------------
 
--#  Make symbolic link for Xcode to let OpenCV build scripts find the compiler, header files etc.
+1.  Make sure the xcode command line tools are installed:
     @code{.bash}
-    cd /
-    sudo ln -s /Applications/Xcode.app/Contents/Developer Developer
+    xcode-select --install
     @endcode
 
--#  Build OpenCV framework:
+2.  Build OpenCV framework:
     @code{.bash}
     cd ~/<my_working_directory>
     python opencv/platforms/ios/build_framework.py ios
     @endcode
 
-If everything's fine, a few minutes later you will get
-\~/\<my_working_directory\>/ios/opencv2.framework. You can add this framework to your Xcode
-projects.
+3.  To install OpenCV’s extra modules, append `--contrib opencv_contrib` to the python command above. **Note:** the extra modules are not included in the iOS Pack download at [OpenCV Releases](https://opencv.org/releases/). If you want to use the extra modules (e.g. aruco), you must build OpenCV yourself and include this option:
+    @code{.bash}
+    cd ~/<my_working_directory>
+    python opencv/platforms/ios/build_framework.py ios --contrib opencv_contrib
+    @endcode
+
+4.  To exclude a specific module, append `--without <module_name>`. For example, to exclude the "optflow" module from opencv_contrib:
+    @code{.bash}
+    cd ~/<my_working_directory>
+    python opencv/platforms/ios/build_framework.py ios --contrib opencv_contrib --without optflow
+    @endcode
+
+5.  The build process can take a significant amount of time. Currently (OpenCV 3.4 and 4.1), five separate architectures are built: armv7, armv7s, and arm64 for iOS plus i386 and x86_64 for the iPhone simulator. If you want to specify the architectures to include in the framework, use the `--iphoneos_archs` and/or `--iphonesimulator_archs` options. For example, to only build arm64 for iOS and x86_64 for the simulator:
+    @code{.bash}
+    cd ~/<my_working_directory>
+    python opencv/platforms/ios/build_framework.py ios --contrib opencv_contrib --iphoneos_archs arm64 --iphonesimulator_archs x86_64
+    @endcode
+
+If everything’s fine, the build process will create
+`~/<my_working_directory>/ios/opencv2.framework`. You can add this framework to your Xcode projects.
 
 Further Reading
 ---------------

doc/tutorials/introduction/table_of_content_introduction.markdown

@@ -114,7 +114,7 @@ Additionally you can find very basic sample source code to introduce you to the
 
     _Compatibility:_ \> OpenCV 2.4.2
 
-    _Author:_ Artem Myagkov, Eduard Feicho
+    _Author:_ Artem Myagkov, Eduard Feicho, Steve Nicholson
 
     We will learn how to setup OpenCV for using it in iOS!
 

doc/tutorials/introduction/windows_install/windows_install.markdown

@@ -151,7 +151,7 @@ of them, you need to download and install them on your system.
     image file format.
 -   The OpenNI Framework contains a set of open source APIs that provide support for natural interaction with devices via methods such as voice command recognition, hand gestures, and body
     motion tracking. Prebuilt binaries can be found [here](http://structure.io/openni). The source code of [OpenNI](https://github.com/OpenNI/OpenNI) and [OpenNI2](https://github.com/OpenNI/OpenNI2) are also available on Github.
--   [Doxygen](http://www.stack.nl/~dimitri/doxygen/) is a documentation generator and is the tool that will actually create the
+-   [Doxygen](http://www.doxygen.nl) is a documentation generator and is the tool that will actually create the
     *OpenCV documentation*.
 
 Now we will describe the steps to follow for a full build (using all the above frameworks, tools and

modules/core/include/opencv2/core/bindings_utils.hpp

@@ -20,6 +20,44 @@ CV_EXPORTS_W String dumpInputOutputArray(InputOutputArray argument);
 
 CV_EXPORTS_W String dumpInputOutputArrayOfArrays(InputOutputArrayOfArrays argument);
 
+CV_WRAP static inline
+String dumpBool(bool argument)
+{
+    return (argument) ? String("Bool: True") : String("Bool: False");
+}
+
+CV_WRAP static inline
+String dumpInt(int argument)
+{
+    return cv::format("Int: %d", argument);
+}
+
+CV_WRAP static inline
+String dumpSizeT(size_t argument)
+{
+    std::ostringstream oss("size_t: ", std::ios::ate);
+    oss << argument;
+    return oss.str();
+}
+
+CV_WRAP static inline
+String dumpFloat(float argument)
+{
+    return cv::format("Float: %.2f", argument);
+}
+
+CV_WRAP static inline
+String dumpDouble(double argument)
+{
+    return cv::format("Double: %.2f", argument);
+}
+
+CV_WRAP static inline
+String dumpCString(const char* argument)
+{
+    return cv::format("String: %s", argument);
+}
+
 CV_WRAP static inline
 AsyncArray testAsyncArray(InputArray argument)
 {

modules/core/include/opencv2/core/hal/intrin.hpp

@@ -457,10 +457,6 @@ namespace CV__SIMD_NAMESPACE {
 using namespace CV__SIMD_NAMESPACE;
 #endif
 
-#ifndef CV_DOXYGEN
-CV_CPU_OPTIMIZATION_HAL_NAMESPACE_END
-#endif
-
 #ifndef CV_SIMD_64F
 #define CV_SIMD_64F 0
 #endif
@@ -469,11 +465,16 @@ CV_CPU_OPTIMIZATION_HAL_NAMESPACE_END
 #define CV_SIMD_FP16 0  //!< Defined to 1 on native support of operations with float16x8_t / float16x16_t (SIMD256) types
 #endif
 
-
 #ifndef CV_SIMD
 #define CV_SIMD 0
 #endif
 
+#include "simd_utils.impl.hpp"
+
+#ifndef CV_DOXYGEN
+CV_CPU_OPTIMIZATION_HAL_NAMESPACE_END
+#endif
+
 } // cv::
 
 //! @endcond

modules/core/include/opencv2/core/hal/simd_utils.impl.hpp

+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html
+
+// This header is not standalone. Don't include directly, use "intrin.hpp" instead.
+#ifdef OPENCV_HAL_INTRIN_HPP  // defined in intrin.hpp
+
+
+#if CV_SIMD128 || CV_SIMD128_CPP
+
+template<typename _T> struct Type2Vec128_Traits;
+#define CV_INTRIN_DEF_TYPE2VEC128_TRAITS(type_, vec_type_) \
+    template<> struct Type2Vec128_Traits<type_> \
+    { \
+        typedef vec_type_ vec_type; \
+    }
+
+CV_INTRIN_DEF_TYPE2VEC128_TRAITS(uchar, v_uint8x16);
+CV_INTRIN_DEF_TYPE2VEC128_TRAITS(schar, v_int8x16);
+CV_INTRIN_DEF_TYPE2VEC128_TRAITS(ushort, v_uint16x8);
+CV_INTRIN_DEF_TYPE2VEC128_TRAITS(short, v_int16x8);
+CV_INTRIN_DEF_TYPE2VEC128_TRAITS(unsigned, v_uint32x4);
+CV_INTRIN_DEF_TYPE2VEC128_TRAITS(int, v_int32x4);
+CV_INTRIN_DEF_TYPE2VEC128_TRAITS(float, v_float32x4);
+CV_INTRIN_DEF_TYPE2VEC128_TRAITS(uint64, v_uint64x2);
+CV_INTRIN_DEF_TYPE2VEC128_TRAITS(int64, v_int64x2);
+#if CV_SIMD128_64F
+CV_INTRIN_DEF_TYPE2VEC128_TRAITS(double, v_float64x2);
+#endif
+
+template<typename _T> static inline
+typename Type2Vec128_Traits<_T>::vec_type v_setall(const _T& a);
+
+template<> inline Type2Vec128_Traits< uchar>::vec_type v_setall< uchar>(const  uchar& a) { return v_setall_u8(a); }
+template<> inline Type2Vec128_Traits< schar>::vec_type v_setall< schar>(const  schar& a) { return v_setall_s8(a); }
+template<> inline Type2Vec128_Traits<ushort>::vec_type v_setall<ushort>(const ushort& a) { return v_setall_u16(a); }
+template<> inline Type2Vec128_Traits< short>::vec_type v_setall< short>(const  short& a) { return v_setall_s16(a); }
+template<> inline Type2Vec128_Traits<  uint>::vec_type v_setall<  uint>(const   uint& a) { return v_setall_u32(a); }
+template<> inline Type2Vec128_Traits<   int>::vec_type v_setall<   int>(const    int& a) { return v_setall_s32(a); }
+template<> inline Type2Vec128_Traits<uint64>::vec_type v_setall<uint64>(const uint64& a) { return v_setall_u64(a); }
+template<> inline Type2Vec128_Traits< int64>::vec_type v_setall< int64>(const  int64& a) { return v_setall_s64(a); }
+template<> inline Type2Vec128_Traits< float>::vec_type v_setall< float>(const  float& a) { return v_setall_f32(a); }
+#if CV_SIMD128_64F
+template<> inline Type2Vec128_Traits<double>::vec_type v_setall<double>(const double& a) { return v_setall_f64(a); }
+#endif
+
+#endif  // SIMD128
+
+
+#if CV_SIMD256
+
+template<typename _T> struct Type2Vec256_Traits;
+#define CV_INTRIN_DEF_TYPE2VEC256_TRAITS(type_, vec_type_) \
+    template<> struct Type2Vec256_Traits<type_> \
+    { \
+        typedef vec_type_ vec_type; \
+    }
+
+CV_INTRIN_DEF_TYPE2VEC256_TRAITS(uchar, v_uint8x32);
+CV_INTRIN_DEF_TYPE2VEC256_TRAITS(schar, v_int8x32);
+CV_INTRIN_DEF_TYPE2VEC256_TRAITS(ushort, v_uint16x16);
+CV_INTRIN_DEF_TYPE2VEC256_TRAITS(short, v_int16x16);
+CV_INTRIN_DEF_TYPE2VEC256_TRAITS(unsigned, v_uint32x8);
+CV_INTRIN_DEF_TYPE2VEC256_TRAITS(int, v_int32x8);
+CV_INTRIN_DEF_TYPE2VEC256_TRAITS(float, v_float32x8);
+CV_INTRIN_DEF_TYPE2VEC256_TRAITS(uint64, v_uint64x4);
+CV_INTRIN_DEF_TYPE2VEC256_TRAITS(int64, v_int64x4);
+#if CV_SIMD256_64F
+CV_INTRIN_DEF_TYPE2VEC256_TRAITS(double, v_float64x4);
+#endif
+
+template<typename _T> static inline
+typename Type2Vec256_Traits<_T>::vec_type v256_setall(const _T& a);
+
+template<> inline Type2Vec256_Traits< uchar>::vec_type v256_setall< uchar>(const  uchar& a) { return v256_setall_u8(a); }
+template<> inline Type2Vec256_Traits< schar>::vec_type v256_setall< schar>(const  schar& a) { return v256_setall_s8(a); }
+template<> inline Type2Vec256_Traits<ushort>::vec_type v256_setall<ushort>(const ushort& a) { return v256_setall_u16(a); }
+template<> inline Type2Vec256_Traits< short>::vec_type v256_setall< short>(const  short& a) { return v256_setall_s16(a); }
+template<> inline Type2Vec256_Traits<  uint>::vec_type v256_setall<  uint>(const   uint& a) { return v256_setall_u32(a); }
+template<> inline Type2Vec256_Traits<   int>::vec_type v256_setall<   int>(const    int& a) { return v256_setall_s32(a); }
+template<> inline Type2Vec256_Traits<uint64>::vec_type v256_setall<uint64>(const uint64& a) { return v256_setall_u64(a); }
+template<> inline Type2Vec256_Traits< int64>::vec_type v256_setall< int64>(const  int64& a) { return v256_setall_s64(a); }
+template<> inline Type2Vec256_Traits< float>::vec_type v256_setall< float>(const  float& a) { return v256_setall_f32(a); }
+#if CV_SIMD256_64F
+template<> inline Type2Vec256_Traits<double>::vec_type v256_setall<double>(const double& a) { return v256_setall_f64(a); }
+#endif
+
+#endif  // SIMD256
+
+
+#if CV_SIMD512
+
+template<typename _T> struct Type2Vec512_Traits;
+#define CV_INTRIN_DEF_TYPE2VEC512_TRAITS(type_, vec_type_) \
+    template<> struct Type2Vec512_Traits<type_> \
+    { \
+        typedef vec_type_ vec_type; \
+    }
+
+CV_INTRIN_DEF_TYPE2VEC512_TRAITS(uchar, v_uint8x64);
+CV_INTRIN_DEF_TYPE2VEC512_TRAITS(schar, v_int8x64);
+CV_INTRIN_DEF_TYPE2VEC512_TRAITS(ushort, v_uint16x32);
+CV_INTRIN_DEF_TYPE2VEC512_TRAITS(short, v_int16x32);
+CV_INTRIN_DEF_TYPE2VEC512_TRAITS(unsigned, v_uint32x16);
+CV_INTRIN_DEF_TYPE2VEC512_TRAITS(int, v_int32x16);
+CV_INTRIN_DEF_TYPE2VEC512_TRAITS(float, v_float32x16);
+CV_INTRIN_DEF_TYPE2VEC512_TRAITS(uint64, v_uint64x8);
+CV_INTRIN_DEF_TYPE2VEC512_TRAITS(int64, v_int64x8);
+#if CV_SIMD512_64F
+CV_INTRIN_DEF_TYPE2VEC512_TRAITS(double, v_float64x8);
+#endif
+
+template<typename _T> static inline
+typename Type2Vec512_Traits<_T>::vec_type v512_setall(const _T& a);
+
+template<> inline Type2Vec512_Traits< uchar>::vec_type v512_setall< uchar>(const  uchar& a) { return v512_setall_u8(a); }
+template<> inline Type2Vec512_Traits< schar>::vec_type v512_setall< schar>(const  schar& a) { return v512_setall_s8(a); }
+template<> inline Type2Vec512_Traits<ushort>::vec_type v512_setall<ushort>(const ushort& a) { return v512_setall_u16(a); }
+template<> inline Type2Vec512_Traits< short>::vec_type v512_setall< short>(const  short& a) { return v512_setall_s16(a); }
+template<> inline Type2Vec512_Traits<  uint>::vec_type v512_setall<  uint>(const   uint& a) { return v512_setall_u32(a); }
+template<> inline Type2Vec512_Traits<   int>::vec_type v512_setall<   int>(const    int& a) { return v512_setall_s32(a); }
+template<> inline Type2Vec512_Traits<uint64>::vec_type v512_setall<uint64>(const uint64& a) { return v512_setall_u64(a); }
+template<> inline Type2Vec512_Traits< int64>::vec_type v512_setall< int64>(const  int64& a) { return v512_setall_s64(a); }
+template<> inline Type2Vec512_Traits< float>::vec_type v512_setall< float>(const  float& a) { return v512_setall_f32(a); }
+#if CV_SIMD512_64F
+template<> inline Type2Vec512_Traits<double>::vec_type v512_setall<double>(const double& a) { return v512_setall_f64(a); }
+#endif
+
+#endif  // SIMD512
+
+
+#if CV_SIMD_WIDTH == 16
+template<typename _T> static inline
+typename Type2Vec128_Traits<_T>::vec_type vx_setall(const _T& a) { return v_setall(a); }
+#elif CV_SIMD_WIDTH == 32
+template<typename _T> static inline
+typename Type2Vec256_Traits<_T>::vec_type vx_setall(const _T& a) { return v256_setall(a); }
+#elif CV_SIMD_WIDTH == 64
+template<typename _T> static inline
+typename Type2Vec512_Traits<_T>::vec_type vx_setall(const _T& a) { return v512_setall(a); }
+#else
+#error "Build configuration error, unsupported CV_SIMD_WIDTH"
+#endif
+
+
+#endif  // OPENCV_HAL_INTRIN_HPP

modules/core/test/test_intrin_utils.hpp

@@ -336,6 +336,40 @@ template<typename R> struct TheTest
         v_float64 vf64 = v_reinterpret_as_f64(r1); out.a.clear(); v_store((double*)out.a.d, vf64); EXPECT_EQ(data.a, out.a);
 #endif
 
+#if CV_SIMD_WIDTH == 16
+        R setall_res1 = v_setall((LaneType)5);
+        R setall_res2 = v_setall<LaneType>(6);
+#elif CV_SIMD_WIDTH == 32
+        R setall_res1 = v256_setall((LaneType)5);
+        R setall_res2 = v256_setall<LaneType>(6);
+#elif CV_SIMD_WIDTH == 64
+        R setall_res1 = v512_setall((LaneType)5);
+        R setall_res2 = v512_setall<LaneType>(6);
+#else
+#error "Configuration error"
+#endif
+#if CV_SIMD_WIDTH > 0
+        Data<R> setall_res1_; v_store(setall_res1_.d, setall_res1);
+        Data<R> setall_res2_; v_store(setall_res2_.d, setall_res2);
+        for (int i = 0; i < R::nlanes; ++i)
+        {
+            SCOPED_TRACE(cv::format("i=%d", i));
+            EXPECT_EQ((LaneType)5, setall_res1_[i]);
+            EXPECT_EQ((LaneType)6, setall_res2_[i]);
+        }
+#endif
+
+        R vx_setall_res1 = vx_setall((LaneType)11);
+        R vx_setall_res2 = vx_setall<LaneType>(12);
+        Data<R> vx_setall_res1_; v_store(vx_setall_res1_.d, vx_setall_res1);
+        Data<R> vx_setall_res2_; v_store(vx_setall_res2_.d, vx_setall_res2);
+        for (int i = 0; i < R::nlanes; ++i)
+        {
+            SCOPED_TRACE(cv::format("i=%d", i));
+            EXPECT_EQ((LaneType)11, vx_setall_res1_[i]);
+            EXPECT_EQ((LaneType)12, vx_setall_res2_[i]);
+        }
+
         return *this;
     }
 

modules/dnn/src/tensorflow/tf_importer.cpp

@@ -1585,7 +1585,7 @@ void TFImporter::populateNet(Net dstNet)
                 }
             }
         }
-        else if (type == "FusedBatchNorm")
+        else if (type == "FusedBatchNorm" || type == "FusedBatchNormV3")
         {
             // op: "FusedBatchNorm"
             // input: "input"

modules/ml/src/svm.cpp

@@ -1451,7 +1451,7 @@ public:
             sortSamplesByClasses( _samples, _responses, sidx_all, class_ranges );
 
             //check that while cross-validation there were the samples from all the classes
-            if( class_ranges[class_count] <= 0 )
+            if ((int)class_ranges.size() < class_count + 1)
                 CV_Error( CV_StsBadArg, "While cross-validation one or more of the classes have "
                 "been fell out of the sample. Try to reduce <Params::k_fold>" );
 

modules/ml/test/test_ann.cpp

+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+
+#include "test_precomp.hpp"
+
+// #define GENERATE_TESTDATA
+
+namespace opencv_test { namespace {
+
+struct Activation
+{
+    int id;
+    const char * name;
+};
+void PrintTo(const Activation &a, std::ostream *os) { *os << a.name; }
+
+Activation activation_list[] =
+{
+    { ml::ANN_MLP::IDENTITY, "identity" },
+    { ml::ANN_MLP::SIGMOID_SYM, "sigmoid_sym" },
+    { ml::ANN_MLP::GAUSSIAN, "gaussian" },
+    { ml::ANN_MLP::RELU, "relu" },
+    { ml::ANN_MLP::LEAKYRELU, "leakyrelu" },
+};
+
+typedef testing::TestWithParam< Activation > ML_ANN_Params;
+
+TEST_P(ML_ANN_Params, ActivationFunction)
+{
+    const Activation &activation = GetParam();
+    const string dataname = "waveform";
+    const string data_path = findDataFile(dataname + ".data");
+    const string model_name = dataname + "_" + activation.name + ".yml";
+
+    Ptr<TrainData> tdata = TrainData::loadFromCSV(data_path, 0);
+    ASSERT_FALSE(tdata.empty());
+
+    // hack?
+    const uint64 old_state = theRNG().state;
+    theRNG().state = 1027401484159173092;
+    tdata->setTrainTestSplit(500);
+    theRNG().state = old_state;
+
+    Mat_<int> layerSizes(1, 4);
+    layerSizes(0, 0) = tdata->getNVars();
+    layerSizes(0, 1) = 100;
+    layerSizes(0, 2) = 100;
+    layerSizes(0, 3) = tdata->getResponses().cols;
+
+    Mat testSamples = tdata->getTestSamples();
+    Mat rx, ry;
+
+    {
+        Ptr<ml::ANN_MLP> x = ml::ANN_MLP::create();
+        x->setActivationFunction(activation.id);
+        x->setLayerSizes(layerSizes);
+        x->setTrainMethod(ml::ANN_MLP::RPROP, 0.01, 0.1);
+        x->setTermCriteria(TermCriteria(TermCriteria::COUNT, 300, 0.01));
+        x->train(tdata, ml::ANN_MLP::NO_OUTPUT_SCALE);
+        ASSERT_TRUE(x->isTrained());
+        x->predict(testSamples, rx);
+#ifdef GENERATE_TESTDATA
+        x->save(cvtest::TS::ptr()->get_data_path() + model_name);
+#endif
+    }
+
+    {
+        const string model_path = findDataFile(model_name);
+        Ptr<ml::ANN_MLP> y = Algorithm::load<ANN_MLP>(model_path);
+        ASSERT_TRUE(y);
+        y->predict(testSamples, ry);
+        EXPECT_MAT_NEAR(rx, ry, FLT_EPSILON);
+    }
+}
+
+INSTANTIATE_TEST_CASE_P(/**/, ML_ANN_Params, testing::ValuesIn(activation_list));
+
+//==================================================================================================
+
+CV_ENUM(ANN_MLP_METHOD, ANN_MLP::RPROP, ANN_MLP::ANNEAL)
+
+typedef tuple<ANN_MLP_METHOD, string, int> ML_ANN_METHOD_Params;
+typedef TestWithParam<ML_ANN_METHOD_Params> ML_ANN_METHOD;
+
+TEST_P(ML_ANN_METHOD, Test)
+{
+    int methodType = get<0>(GetParam());
+    string methodName = get<1>(GetParam());
+    int N = get<2>(GetParam());
+
+    String folder = string(cvtest::TS::ptr()->get_data_path());
+    String original_path = findDataFile("waveform.data");
+    string dataname = "waveform_" + methodName;
+    string weight_name = dataname + "_init_weight.yml.gz";
+    string model_name = dataname + ".yml.gz";
+    string response_name = dataname + "_response.yml.gz";
+
+    Ptr<TrainData> tdata2 = TrainData::loadFromCSV(original_path, 0);
+    ASSERT_FALSE(tdata2.empty());
+
+    Mat samples = tdata2->getSamples()(Range(0, N), Range::all());
+    Mat responses(N, 3, CV_32FC1, Scalar(0));
+    for (int i = 0; i < N; i++)
+        responses.at<float>(i, static_cast<int>(tdata2->getResponses().at<float>(i, 0))) = 1;
+
+    Ptr<TrainData> tdata = TrainData::create(samples, ml::ROW_SAMPLE, responses);
+    ASSERT_FALSE(tdata.empty());
+
+    // hack?
+    const uint64 old_state = theRNG().state;
+    theRNG().state = 0;
+    tdata->setTrainTestSplitRatio(0.8);
+    theRNG().state = old_state;
+
+    Mat testSamples = tdata->getTestSamples();
+
+    // train 1st stage
+
+    Ptr<ml::ANN_MLP> xx = ml::ANN_MLP::create();
+    Mat_<int> layerSizes(1, 4);
+    layerSizes(0, 0) = tdata->getNVars();
+    layerSizes(0, 1) = 30;
+    layerSizes(0, 2) = 30;
+    layerSizes(0, 3) = tdata->getResponses().cols;
+    xx->setLayerSizes(layerSizes);
+    xx->setActivationFunction(ml::ANN_MLP::SIGMOID_SYM);
+    xx->setTrainMethod(ml::ANN_MLP::RPROP);
+    xx->setTermCriteria(TermCriteria(TermCriteria::COUNT, 1, 0.01));
+    xx->train(tdata, ml::ANN_MLP::NO_OUTPUT_SCALE + ml::ANN_MLP::NO_INPUT_SCALE);
+#ifdef GENERATE_TESTDATA
+    {
+        FileStorage fs;
+        fs.open(cvtest::TS::ptr()->get_data_path() + weight_name, FileStorage::WRITE + FileStorage::BASE64);
+        xx->write(fs);
+    }
+#endif
+
+    // train 2nd stage
+    Mat r_gold;
+    Ptr<ml::ANN_MLP> x = ml::ANN_MLP::create();
+    {
+        const string weight_file = findDataFile(weight_name);
+        FileStorage fs;
+        fs.open(weight_file, FileStorage::READ);
+        x->read(fs.root());
+    }
+    x->setTrainMethod(methodType);
+    if (methodType == ml::ANN_MLP::ANNEAL)
+    {
+        x->setAnnealEnergyRNG(RNG(CV_BIG_INT(0xffffffff)));
+        x->setAnnealInitialT(12);
+        x->setAnnealFinalT(0.15);
+        x->setAnnealCoolingRatio(0.96);
+        x->setAnnealItePerStep(11);
+    }
+    x->setTermCriteria(TermCriteria(TermCriteria::COUNT, 100, 0.01));
+    x->train(tdata, ml::ANN_MLP::NO_OUTPUT_SCALE + ml::ANN_MLP::NO_INPUT_SCALE + ml::ANN_MLP::UPDATE_WEIGHTS);
+    ASSERT_TRUE(x->isTrained());
+#ifdef GENERATE_TESTDATA
+    x->save(cvtest::TS::ptr()->get_data_path() + model_name);
+    x->predict(testSamples, r_gold);
+    {
+        FileStorage fs_response(cvtest::TS::ptr()->get_data_path() + response_name, FileStorage::WRITE + FileStorage::BASE64);
+        fs_response << "response" << r_gold;
+    }
+#endif
+    {
+        const string response_file = findDataFile(response_name);
+        FileStorage fs_response(response_file, FileStorage::READ);
+        fs_response["response"] >> r_gold;
+    }
+    ASSERT_FALSE(r_gold.empty());
+
+    // verify
+    const string model_file = findDataFile(model_name);
+    Ptr<ml::ANN_MLP> y = Algorithm::load<ANN_MLP>(model_file);
+    ASSERT_TRUE(y);
+    Mat rx, ry;
+    for (int j = 0; j < 4; j++)
+    {
+        rx = x->getWeights(j);
+        ry = y->getWeights(j);
+        EXPECT_MAT_NEAR(rx, ry, FLT_EPSILON) << "Weights are not equal for layer: " << j;
+    }
+    x->predict(testSamples, rx);
+    y->predict(testSamples, ry);
+    EXPECT_MAT_NEAR(ry, rx, FLT_EPSILON) << "Predict are not equal to result of the saved model";
+    EXPECT_MAT_NEAR(r_gold, rx, FLT_EPSILON) << "Predict are not equal to 'gold' response";
+}
+
+INSTANTIATE_TEST_CASE_P(/*none*/, ML_ANN_METHOD,
+    testing::Values(
+        ML_ANN_METHOD_Params(ml::ANN_MLP::RPROP, "rprop", 5000),
+        ML_ANN_METHOD_Params(ml::ANN_MLP::ANNEAL, "anneal", 1000)
+        // ML_ANN_METHOD_Params(ml::ANN_MLP::BACKPROP, "backprop", 500) -----> NO BACKPROP TEST
+    )
+);
+
+}} // namespace

modules/ml/test/test_bayes.cpp

+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+
+#include "test_precomp.hpp"
+
+namespace opencv_test { namespace {
+
+TEST(ML_NBAYES, regression_5911)
+{
+    int N=12;
+    Ptr<ml::NormalBayesClassifier> nb = cv::ml::NormalBayesClassifier::create();
+
+    // data:
+    float X_data[] = {
+        1,2,3,4,  1,2,3,4,   1,2,3,4,    1,2,3,4,
+        5,5,5,5,  5,5,5,5,   5,5,5,5,    5,5,5,5,
+        4,3,2,1,  4,3,2,1,   4,3,2,1,    4,3,2,1
+    };
+    Mat_<float> X(N, 4, X_data);
+
+    // labels:
+    int Y_data[] = { 0,0,0,0, 1,1,1,1, 2,2,2,2 };
+    Mat_<int> Y(N, 1, Y_data);
+
+    nb->train(X, ml::ROW_SAMPLE, Y);
+
+    // single prediction:
+    Mat R1,P1;
+    for (int i=0; i<N; i++)
+    {
+        Mat r,p;
+        nb->predictProb(X.row(i), r, p);
+        R1.push_back(r);
+        P1.push_back(p);
+    }
+
+    // bulk prediction (continuous memory):
+    Mat R2,P2;
+    nb->predictProb(X, R2, P2);
+
+    EXPECT_EQ(255 * R2.total(), sum(R1 == R2)[0]);
+    EXPECT_EQ(255 * P2.total(), sum(P1 == P2)[0]);
+
+    // bulk prediction, with non-continuous memory storage
+    Mat R3_(N, 1+1, CV_32S),
+        P3_(N, 3+1, CV_32F);
+    nb->predictProb(X, R3_.col(0), P3_.colRange(0,3));
+    Mat R3 = R3_.col(0).clone(),
+        P3 = P3_.colRange(0,3).clone();
+
+    EXPECT_EQ(255 * R3.total(), sum(R1 == R3)[0]);
+    EXPECT_EQ(255 * P3.total(), sum(P1 == P3)[0]);
+}
+
+}} // namespace

modules/ml/test/test_em.cpp

+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+
+#include "test_precomp.hpp"
+
+namespace opencv_test { namespace {
+
+CV_ENUM(EM_START_STEP, EM::START_AUTO_STEP, EM::START_M_STEP, EM::START_E_STEP)
+CV_ENUM(EM_COV_MAT, EM::COV_MAT_GENERIC, EM::COV_MAT_DIAGONAL, EM::COV_MAT_SPHERICAL)
+
+typedef testing::TestWithParam< tuple<EM_START_STEP, EM_COV_MAT> > ML_EM_Params;
+
+TEST_P(ML_EM_Params, accuracy)
+{
+    const int nclusters = 3;
+    const int sizesArr[] = { 500, 700, 800 };
+    const vector<int> sizes( sizesArr, sizesArr + sizeof(sizesArr) / sizeof(sizesArr[0]) );
+    const int pointsCount = sizesArr[0] + sizesArr[1] + sizesArr[2];
+    Mat means;
+    vector<Mat> covs;
+    defaultDistribs( means, covs, CV_64FC1 );
+    Mat trainData(pointsCount, 2, CV_64FC1 );
+    Mat trainLabels;
+    generateData( trainData, trainLabels, sizes, means, covs, CV_64FC1, CV_32SC1 );
+    Mat testData( pointsCount, 2, CV_64FC1 );
+    Mat testLabels;
+    generateData( testData, testLabels, sizes, means, covs, CV_64FC1, CV_32SC1 );
+    Mat probs(trainData.rows, nclusters, CV_64FC1, cv::Scalar(1));
+    Mat weights(1, nclusters, CV_64FC1, cv::Scalar(1));
+    TermCriteria termCrit(cv::TermCriteria::COUNT + cv::TermCriteria::EPS, 100, FLT_EPSILON);
+    int startStep = get<0>(GetParam());
+    int covMatType = get<1>(GetParam());
+    cv::Mat labels;
+
+    Ptr<EM> em = EM::create();
+    em->setClustersNumber(nclusters);
+    em->setCovarianceMatrixType(covMatType);
+    em->setTermCriteria(termCrit);
+    if( startStep == EM::START_AUTO_STEP )
+        em->trainEM( trainData, noArray(), labels, noArray() );
+    else if( startStep == EM::START_E_STEP )
+        em->trainE( trainData, means, covs, weights, noArray(), labels, noArray() );
+    else if( startStep == EM::START_M_STEP )
+        em->trainM( trainData, probs, noArray(), labels, noArray() );
+
+    {
+        SCOPED_TRACE("Train");
+        float err = 1000;
+        EXPECT_TRUE(calcErr( labels, trainLabels, sizes, err , false, false ));
+        EXPECT_LE(err, 0.008f);
+    }
+
+    {
+        SCOPED_TRACE("Test");
+        float err = 1000;
+        labels.create( testData.rows, 1, CV_32SC1 );
+        for( int i = 0; i < testData.rows; i++ )
+        {
+            Mat sample = testData.row(i);
+            Mat out_probs;
+            labels.at<int>(i) = static_cast<int>(em->predict2( sample, out_probs )[1]);
+        }
+        EXPECT_TRUE(calcErr( labels, testLabels, sizes, err, false, false ));
+        EXPECT_LE(err, 0.008f);
+    }
+}
+
+INSTANTIATE_TEST_CASE_P(/**/, ML_EM_Params,
+    testing::Combine(
+        testing::Values(EM::START_AUTO_STEP, EM::START_M_STEP, EM::START_E_STEP),
+        testing::Values(EM::COV_MAT_GENERIC, EM::COV_MAT_DIAGONAL, EM::COV_MAT_SPHERICAL)
+    ));
+
+//==================================================================================================
+
+TEST(ML_EM, save_load)
+{
+    const int nclusters = 2;
+    Mat_<double> samples(3, 1);
+    samples << 1., 2., 3.;
+
+    std::vector<double> firstResult;
+    string filename = cv::tempfile(".xml");
+    {
+        Mat labels;
+        Ptr<EM> em = EM::create();
+        em->setClustersNumber(nclusters);
+        em->trainEM(samples, noArray(), labels, noArray());
+        for( int i = 0; i < samples.rows; i++)
+        {
+            Vec2d res = em->predict2(samples.row(i), noArray());
+            firstResult.push_back(res[1]);
+        }
+        {
+            FileStorage fs = FileStorage(filename, FileStorage::WRITE);
+            ASSERT_NO_THROW(fs << "em" << "{");
+            ASSERT_NO_THROW(em->write(fs));
+            ASSERT_NO_THROW(fs << "}");
+        }
+    }
+    {
+        Ptr<EM> em;
+        ASSERT_NO_THROW(em = Algorithm::load<EM>(filename));
+        for( int i = 0; i < samples.rows; i++)
+        {
+            SCOPED_TRACE(i);
+            Vec2d res = em->predict2(samples.row(i), noArray());
+            EXPECT_DOUBLE_EQ(firstResult[i], res[1]);
+        }
+    }
+    remove(filename.c_str());
+}
+
+//==================================================================================================
+
+TEST(ML_EM, classification)
+{
+    // This test classifies spam by the following way:
+    // 1. estimates distributions of "spam" / "not spam"
+    // 2. predict classID using Bayes classifier for estimated distributions.
+    string dataFilename = findDataFile("spambase.data");
+    Ptr<TrainData> data = TrainData::loadFromCSV(dataFilename, 0);
+    ASSERT_FALSE(data.empty());
+
+    Mat samples = data->getSamples();
+    ASSERT_EQ(samples.cols, 57);
+    Mat responses = data->getResponses();
+
+    vector<int> trainSamplesMask(samples.rows, 0);
+    const int trainSamplesCount = (int)(0.5f * samples.rows);
+    const int testSamplesCount = samples.rows - trainSamplesCount;
+    for(int i = 0; i < trainSamplesCount; i++)
+        trainSamplesMask[i] = 1;
+    RNG &rng = cv::theRNG();
+    for(size_t i = 0; i < trainSamplesMask.size(); i++)
+    {
+        int i1 = rng(static_cast<unsigned>(trainSamplesMask.size()));
+        int i2 = rng(static_cast<unsigned>(trainSamplesMask.size()));
+        std::swap(trainSamplesMask[i1], trainSamplesMask[i2]);
+    }
+
+    Mat samples0, samples1;
+    for(int i = 0; i < samples.rows; i++)
+    {
+        if(trainSamplesMask[i])
+        {
+            Mat sample = samples.row(i);
+            int resp = (int)responses.at<float>(i);
+            if(resp == 0)
+                samples0.push_back(sample);
+            else
+                samples1.push_back(sample);
+        }
+    }
+
+    Ptr<EM> model0 = EM::create();
+    model0->setClustersNumber(3);
+    model0->trainEM(samples0, noArray(), noArray(), noArray());
+
+    Ptr<EM> model1 = EM::create();
+    model1->setClustersNumber(3);
+    model1->trainEM(samples1, noArray(), noArray(), noArray());
+
+    // confusion matrices
+    Mat_<int> trainCM(2, 2, 0);
+    Mat_<int> testCM(2, 2, 0);
+    const double lambda = 1.;
+    for(int i = 0; i < samples.rows; i++)
+    {
+        Mat sample = samples.row(i);
+        double sampleLogLikelihoods0 = model0->predict2(sample, noArray())[0];
+        double sampleLogLikelihoods1 = model1->predict2(sample, noArray())[0];
+        int classID = (sampleLogLikelihoods0 >= lambda * sampleLogLikelihoods1) ? 0 : 1;
+        int resp = (int)responses.at<float>(i);
+        EXPECT_TRUE(resp == 0 || resp == 1);
+        if(trainSamplesMask[i])
+            trainCM(resp, classID)++;
+        else
+            testCM(resp, classID)++;
+    }
+    EXPECT_LE((double)(trainCM(1,0) + trainCM(0,1)) / trainSamplesCount, 0.23);
+    EXPECT_LE((double)(testCM(1,0) + testCM(0,1)) / testSamplesCount, 0.26);
+}
+
+}} // namespace

modules/ml/test/test_gbttest.cpp

-
-#include "test_precomp.hpp"
-
-#if 0
-
-using namespace std;
-
-
-class CV_GBTreesTest : public cvtest::BaseTest
-{
-public:
-    CV_GBTreesTest();
-    ~CV_GBTreesTest();
-
-protected:
-    void run(int);
-
-    int TestTrainPredict(int test_num);
-    int TestSaveLoad();
-
-    int checkPredictError(int test_num);
-    int checkLoadSave();
-
-    string model_file_name1;
-    string model_file_name2;
-
-    string* datasets;
-    string data_path;
-
-    CvMLData* data;
-    CvGBTrees* gtb;
-
-    vector<float> test_resps1;
-    vector<float> test_resps2;
-
-    int64 initSeed;
-};
-
-
-int _get_len(const CvMat* mat)
-{
-    return (mat->cols > mat->rows) ? mat->cols : mat->rows;
-}
-
-
-CV_GBTreesTest::CV_GBTreesTest()
-{
-    int64 seeds[] = { CV_BIG_INT(0x00009fff4f9c8d52),
-                      CV_BIG_INT(0x0000a17166072c7c),
-                      CV_BIG_INT(0x0201b32115cd1f9a),
-                      CV_BIG_INT(0x0513cb37abcd1234),
-                      CV_BIG_INT(0x0001a2b3c4d5f678)
-                    };
-
-    int seedCount = sizeof(seeds)/sizeof(seeds[0]);
-    cv::RNG& rng = cv::theRNG();
-    initSeed = rng.state;
-    rng.state = seeds[rng(seedCount)];
-
-    datasets = 0;
-    data = 0;
-    gtb = 0;
-}
-
-CV_GBTreesTest::~CV_GBTreesTest()
-{
-    if (data)
-        delete data;
-    delete[] datasets;
-    cv::theRNG().state = initSeed;
-}
-
-
-int CV_GBTreesTest::TestTrainPredict(int test_num)
-{
-    int code = cvtest::TS::OK;
-
-    int weak_count = 200;
-    float shrinkage = 0.1f;
-    float subsample_portion = 0.5f;
-    int max_depth = 5;
-    bool use_surrogates = false;
-    int loss_function_type = 0;
-    switch (test_num)
-    {
-        case (1) : loss_function_type = CvGBTrees::SQUARED_LOSS; break;
-        case (2) : loss_function_type = CvGBTrees::ABSOLUTE_LOSS; break;
-        case (3) : loss_function_type = CvGBTrees::HUBER_LOSS; break;
-        case (0) : loss_function_type = CvGBTrees::DEVIANCE_LOSS; break;
-        default  :
-            {
-            ts->printf( cvtest::TS::LOG, "Bad test_num value in CV_GBTreesTest::TestTrainPredict(..) function." );
-            return cvtest::TS::FAIL_BAD_ARG_CHECK;
-            }
-    }
-
-    int dataset_num = test_num == 0 ? 0 : 1;
-    if (!data)
-    {
-        data = new CvMLData();
-        data->set_delimiter(',');
-
-        if (data->read_csv(datasets[dataset_num].c_str()))
-        {
-            ts->printf( cvtest::TS::LOG, "File reading error." );
-            return cvtest::TS::FAIL_INVALID_TEST_DATA;
-        }
-
-        if (test_num == 0)
-        {
-            data->set_response_idx(57);
-            data->set_var_types("ord[0-56],cat[57]");
-        }
-        else
-        {
-            data->set_response_idx(13);
-            data->set_var_types("ord[0-2,4-13],cat[3]");
-            subsample_portion = 0.7f;
-        }
-
-        int train_sample_count = cvFloor(_get_len(data->get_responses())*0.5f);
-        CvTrainTestSplit spl( train_sample_count );
-        data->set_train_test_split( &spl );
-    }
-
-    data->mix_train_and_test_idx();
-
-
-    if (gtb) delete gtb;
-    gtb = new CvGBTrees();
-    bool tmp_code = true;
-    tmp_code = gtb->train(data, CvGBTreesParams(loss_function_type, weak_count,
-                          shrinkage, subsample_portion,
-                          max_depth, use_surrogates));
-
-    if (!tmp_code)
-    {
-        ts->printf( cvtest::TS::LOG, "Model training was failed.");
-        return cvtest::TS::FAIL_INVALID_OUTPUT;
-    }
-
-    code = checkPredictError(test_num);
-
-    return code;
-
-}
-
-
-int CV_GBTreesTest::checkPredictError(int test_num)
-{
-    if (!gtb)
-        return cvtest::TS::FAIL_GENERIC;
-
-    //float mean[] = {5.430247f, 13.5654f, 12.6569f, 13.1661f};
-    //float sigma[] = {0.4162694f, 3.21161f, 3.43297f, 3.00624f};
-    float mean[] = {5.80226f, 12.68689f, 13.49095f, 13.19628f};
-    float sigma[] = {0.4764534f, 3.166919f, 3.022405f, 2.868722f};
-
-    float current_error = gtb->calc_error(data, CV_TEST_ERROR);
-
-    if ( abs( current_error - mean[test_num]) > 6*sigma[test_num] )
-    {
-        ts->printf( cvtest::TS::LOG, "Test error is out of range:\n"
-                    "abs(%f/*curEr*/ - %f/*mean*/ > %f/*6*sigma*/",
-                    current_error, mean[test_num], 6*sigma[test_num] );
-        return cvtest::TS::FAIL_BAD_ACCURACY;
-    }
-
-    return cvtest::TS::OK;
-
-}
-
-
-int CV_GBTreesTest::TestSaveLoad()
-{
-    if (!gtb)
-        return cvtest::TS::FAIL_GENERIC;
-
-    model_file_name1 = cv::tempfile();
-    model_file_name2 = cv::tempfile();
-
-    gtb->save(model_file_name1.c_str());
-    gtb->calc_error(data, CV_TEST_ERROR, &test_resps1);
-    gtb->load(model_file_name1.c_str());
-    gtb->calc_error(data, CV_TEST_ERROR, &test_resps2);
-    gtb->save(model_file_name2.c_str());
-
-    return checkLoadSave();
-
-}
-
-
-
-int CV_GBTreesTest::checkLoadSave()
-{
-    int code = cvtest::TS::OK;
-
-    // 1. compare files
-    ifstream f1( model_file_name1.c_str() ), f2( model_file_name2.c_str() );
-    string s1, s2;
-    int lineIdx = 0;
-    CV_Assert( f1.is_open() && f2.is_open() );
-    for( ; !f1.eof() && !f2.eof(); lineIdx++ )
-    {
-        getline( f1, s1 );
-        getline( f2, s2 );
-        if( s1.compare(s2) )
-        {
-            ts->printf( cvtest::TS::LOG, "first and second saved files differ in %n-line; first %n line: %s; second %n-line: %s",
-               lineIdx, lineIdx, s1.c_str(), lineIdx, s2.c_str() );
-            code = cvtest::TS::FAIL_INVALID_OUTPUT;
-        }
-    }
-    if( !f1.eof() || !f2.eof() )
-    {
-        ts->printf( cvtest::TS::LOG, "First and second saved files differ in %n-line; first %n line: %s; second %n-line: %s",
-            lineIdx, lineIdx, s1.c_str(), lineIdx, s2.c_str() );
-        code = cvtest::TS::FAIL_INVALID_OUTPUT;
-    }
-    f1.close();
-    f2.close();
-    // delete temporary files
-    remove( model_file_name1.c_str() );
-    remove( model_file_name2.c_str() );
-
-    // 2. compare responses
-    CV_Assert( test_resps1.size() == test_resps2.size() );
-    vector<float>::const_iterator it1 = test_resps1.begin(), it2 = test_resps2.begin();
-    for( ; it1 != test_resps1.end(); ++it1, ++it2 )
-    {
-        if( fabs(*it1 - *it2) > FLT_EPSILON )
-        {
-            ts->printf( cvtest::TS::LOG, "Responses predicted before saving and after loading are different" );
-            code = cvtest::TS::FAIL_INVALID_OUTPUT;
-        }
-    }
-    return code;
-}
-
-
-
-void CV_GBTreesTest::run(int)
-{
-
-    string dataPath = string(ts->get_data_path());
-    datasets = new string[2];
-    datasets[0] = dataPath + string("spambase.data"); /*string("dataset_classification.csv");*/
-    datasets[1] = dataPath + string("housing_.data");  /*string("dataset_regression.csv");*/
-
-    int code = cvtest::TS::OK;
-
-    for (int i = 0; i < 4; i++)
-    {
-
-        int temp_code = TestTrainPredict(i);
-        if (temp_code != cvtest::TS::OK)
-        {
-            code = temp_code;
-            break;
-        }
-
-        else if (i==0)
-        {
-            temp_code = TestSaveLoad();
-            if (temp_code != cvtest::TS::OK)
-                code = temp_code;
-            delete data;
-            data = 0;
-        }
-
-        delete gtb;
-        gtb = 0;
-    }
-    delete data;
-    data = 0;
-
-    ts->set_failed_test_info( code );
-}
-
-/////////////////////////////////////////////////////////////////////////////
-//////////////////// test registration  /////////////////////////////////////
-/////////////////////////////////////////////////////////////////////////////
-
-TEST(ML_GBTrees, regression) { CV_GBTreesTest test; test.safe_run(); }
-
-#endif

modules/ml/test/test_kmeans.cpp

+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+
+#include "test_precomp.hpp"
+
+namespace opencv_test { namespace {
+
+TEST(ML_KMeans, accuracy)
+{
+    const int iters = 100;
+    int sizesArr[] = { 5000, 7000, 8000 };
+    int pointsCount = sizesArr[0]+ sizesArr[1] + sizesArr[2];
+
+    Mat data( pointsCount, 2, CV_32FC1 ), labels;
+    vector<int> sizes( sizesArr, sizesArr + sizeof(sizesArr) / sizeof(sizesArr[0]) );
+    Mat means;
+    vector<Mat> covs;
+    defaultDistribs( means, covs );
+    generateData( data, labels, sizes, means, covs, CV_32FC1, CV_32SC1 );
+    TermCriteria termCriteria( TermCriteria::COUNT, iters, 0.0);
+
+    {
+        SCOPED_TRACE("KMEANS_PP_CENTERS");
+        float err = 1000;
+        Mat bestLabels;
+        kmeans( data, 3, bestLabels, termCriteria, 0, KMEANS_PP_CENTERS, noArray() );
+        EXPECT_TRUE(calcErr( bestLabels, labels, sizes, err , false ));
+        EXPECT_LE(err, 0.01f);
+    }
+    {
+        SCOPED_TRACE("KMEANS_RANDOM_CENTERS");
+        float err = 1000;
+        Mat bestLabels;
+        kmeans( data, 3, bestLabels, termCriteria, 0, KMEANS_RANDOM_CENTERS, noArray() );
+        EXPECT_TRUE(calcErr( bestLabels, labels, sizes, err, false ));
+        EXPECT_LE(err, 0.01f);
+    }
+    {
+        SCOPED_TRACE("KMEANS_USE_INITIAL_LABELS");
+        float err = 1000;
+        Mat bestLabels;
+        labels.copyTo( bestLabels );
+        RNG &rng = cv::theRNG();
+        for( int i = 0; i < 0.5f * pointsCount; i++ )
+        bestLabels.at<int>( rng.next() % pointsCount, 0 ) = rng.next() % 3;
+        kmeans( data, 3, bestLabels, termCriteria, 0, KMEANS_USE_INITIAL_LABELS, noArray() );
+        EXPECT_TRUE(calcErr( bestLabels, labels, sizes, err, false ));
+        EXPECT_LE(err, 0.01f);
+    }
+}
+
+}} // namespace

modules/ml/test/test_knearest.cpp

+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+
+#include "test_precomp.hpp"
+
+namespace opencv_test { namespace {
+
+using cv::ml::TrainData;
+using cv::ml::EM;
+using cv::ml::KNearest;
+
+TEST(ML_KNearest, accuracy)
+{
+    int sizesArr[] = { 500, 700, 800 };
+    int pointsCount = sizesArr[0]+ sizesArr[1] + sizesArr[2];
+
+    Mat trainData( pointsCount, 2, CV_32FC1 ), trainLabels;
+    vector<int> sizes( sizesArr, sizesArr + sizeof(sizesArr) / sizeof(sizesArr[0]) );
+    Mat means;
+    vector<Mat> covs;
+    defaultDistribs( means, covs );
+    generateData( trainData, trainLabels, sizes, means, covs, CV_32FC1, CV_32FC1 );
+
+    Mat testData( pointsCount, 2, CV_32FC1 );
+    Mat testLabels;
+    generateData( testData, testLabels, sizes, means, covs, CV_32FC1, CV_32FC1 );
+
+    {
+        SCOPED_TRACE("Default");
+        Mat bestLabels;
+        float err = 1000;
+        Ptr<KNearest> knn = KNearest::create();
+        knn->train(trainData, ml::ROW_SAMPLE, trainLabels);
+        knn->findNearest(testData, 4, bestLabels);
+        EXPECT_TRUE(calcErr( bestLabels, testLabels, sizes, err, true ));
+        EXPECT_LE(err, 0.01f);
+    }
+    {
+        // TODO: broken
+#if 0
+        SCOPED_TRACE("KDTree");
+        Mat bestLabels;
+        float err = 1000;
+        Ptr<KNearest> knn = KNearest::create();
+        knn->setAlgorithmType(KNearest::KDTREE);
+        knn->train(trainData, ml::ROW_SAMPLE, trainLabels);
+        knn->findNearest(testData, 4, bestLabels);
+        EXPECT_TRUE(calcErr( bestLabels, testLabels, sizes, err, true ));
+        EXPECT_LE(err, 0.01f);
+#endif
+    }
+}
+
+TEST(ML_KNearest, regression_12347)
+{
+    Mat xTrainData = (Mat_<float>(5,2) << 1, 1.1, 1.1, 1, 2, 2, 2.1, 2, 2.1, 2.1);
+    Mat yTrainLabels = (Mat_<float>(5,1) << 1, 1, 2, 2, 2);
+    Ptr<KNearest> knn = KNearest::create();
+    knn->train(xTrainData, ml::ROW_SAMPLE, yTrainLabels);
+
+    Mat xTestData = (Mat_<float>(2,2) << 1.1, 1.1, 2, 2.2);
+    Mat zBestLabels, neighbours, dist;
+    // check output shapes:
+    int K = 16, Kexp = std::min(K, xTrainData.rows);
+    knn->findNearest(xTestData, K, zBestLabels, neighbours, dist);
+    EXPECT_EQ(xTestData.rows, zBestLabels.rows);
+    EXPECT_EQ(neighbours.cols, Kexp);
+    EXPECT_EQ(dist.cols, Kexp);
+    // see if the result is still correct:
+    K = 2;
+    knn->findNearest(xTestData, K, zBestLabels, neighbours, dist);
+    EXPECT_EQ(1, zBestLabels.at<float>(0,0));
+    EXPECT_EQ(2, zBestLabels.at<float>(1,0));
+}
+
+}} // namespace

modules/ml/test/test_lr.cpp

-///////////////////////////////////////////////////////////////////////////////////////
-// IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
-
-//  By downloading, copying, installing or using the software you agree to this license.
-//  If you do not agree to this license, do not download, install,
-//  copy or use the software.
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
 
 // This is a implementation of the Logistic Regression algorithm in C++ in OpenCV.
 
@@ -11,92 +8,16 @@
 // Rahul Kavi rahulkavi[at]live[at]com
 //
 
-// contains a subset of data from the popular Iris Dataset (taken from "http://archive.ics.uci.edu/ml/datasets/Iris")
-
-// # You are free to use, change, or redistribute the code in any way you wish for
-// # non-commercial purposes, but please maintain the name of the original author.
-// # This code comes with no warranty of any kind.
-
-// #
-// # You are free to use, change, or redistribute the code in any way you wish for
-// # non-commercial purposes, but please maintain the name of the original author.
-// # This code comes with no warranty of any kind.
-
-// # Logistic Regression ALGORITHM
-
-
-//                           License Agreement
-//                For Open Source Computer Vision Library
-
-// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
-// Copyright (C) 2008-2011, Willow Garage Inc., all rights reserved.
-// Third party copyrights are property of their respective owners.
-
-// Redistribution and use in source and binary forms, with or without modification,
-// are permitted provided that the following conditions are met:
-
-//   * Redistributions of source code must retain the above copyright notice,
-//     this list of conditions and the following disclaimer.
-
-//   * Redistributions in binary form must reproduce the above copyright notice,
-//     this list of conditions and the following disclaimer in the documentation
-//     and/or other materials provided with the distribution.
-
-//   * The name of the copyright holders may not be used to endorse or promote products
-//     derived from this software without specific prior written permission.
-
-// This software is provided by the copyright holders and contributors "as is" and
-// any express or implied warranties, including, but not limited to, the implied
-// warranties of merchantability and fitness for a particular purpose are disclaimed.
-// In no event shall the Intel Corporation or contributors be liable for any direct,
-// indirect, incidental, special, exemplary, or consequential damages
-// (including, but not limited to, procurement of substitute goods or services;
-// loss of use, data, or profits; or business interruption) however caused
-// and on any theory of liability, whether in contract, strict liability,
-// or tort (including negligence or otherwise) arising in any way out of
-// the use of this software, even if advised of the possibility of such damage.
-
 #include "test_precomp.hpp"
 
 namespace opencv_test { namespace {
 
-bool calculateError( const Mat& _p_labels, const Mat& _o_labels, float& error)
-{
-    CV_TRACE_FUNCTION();
-    error = 0.0f;
-    float accuracy = 0.0f;
-    Mat _p_labels_temp;
-    Mat _o_labels_temp;
-    _p_labels.convertTo(_p_labels_temp, CV_32S);
-    _o_labels.convertTo(_o_labels_temp, CV_32S);
-
-    CV_Assert(_p_labels_temp.total() == _o_labels_temp.total());
-    CV_Assert(_p_labels_temp.rows == _o_labels_temp.rows);
-
-    accuracy = (float)countNonZero(_p_labels_temp == _o_labels_temp)/_p_labels_temp.rows;
-    error = 1 - accuracy;
-    return true;
-}
-
-//--------------------------------------------------------------------------------------------
-
-class CV_LRTest : public cvtest::BaseTest
-{
-public:
-    CV_LRTest() {}
-protected:
-    virtual void run( int start_from );
-};
-
-void CV_LRTest::run( int /*start_from*/ )
+TEST(ML_LR, accuracy)
 {
-    CV_TRACE_FUNCTION();
-    // initialize variables from the popular Iris Dataset
-    string dataFileName = ts->get_data_path() + "iris.data";
+    std::string dataFileName = findDataFile("iris.data");
     Ptr<TrainData> tdata = TrainData::loadFromCSV(dataFileName, 0);
-    ASSERT_FALSE(tdata.empty()) << "Could not find test data file : " << dataFileName;
+    ASSERT_FALSE(tdata.empty());
 
-    // run LR classifier train classifier
     Ptr<LogisticRegression> p = LogisticRegression::create();
     p->setLearningRate(1.0);
     p->setIterations(10001);
@@ -105,121 +26,54 @@ void CV_LRTest::run( int /*start_from*/ )
     p->setMiniBatchSize(10);
     p->train(tdata);
 
-    // predict using the same data
     Mat responses;
     p->predict(tdata->getSamples(), responses);
 
-    // calculate error
-    int test_code = cvtest::TS::OK;
-    float error = 0.0f;
-    if(!calculateError(responses, tdata->getResponses(), error))
-    {
-        ts->printf(cvtest::TS::LOG, "Bad prediction labels\n" );
-        test_code = cvtest::TS::FAIL_INVALID_OUTPUT;
-    }
-    else if(error > 0.05f)
-    {
-        ts->printf(cvtest::TS::LOG, "Bad accuracy of (%f)\n", error);
-        test_code = cvtest::TS::FAIL_BAD_ACCURACY;
-    }
-
-    {
-        FileStorage s("debug.xml", FileStorage::WRITE);
-        s << "original" << tdata->getResponses();
-        s << "predicted1" << responses;
-        s << "learnt" << p->get_learnt_thetas();
-        s << "error" << error;
-        s.release();
-    }
-    ts->set_failed_test_info(test_code);
+    float error = 1000;
+    EXPECT_TRUE(calculateError(responses, tdata->getResponses(), error));
+    EXPECT_LE(error, 0.05f);
 }
 
-//--------------------------------------------------------------------------------------------
-class CV_LRTest_SaveLoad : public cvtest::BaseTest
-{
-public:
-    CV_LRTest_SaveLoad(){}
-protected:
-    virtual void run(int start_from);
-};
-
+//==================================================================================================
 
-void CV_LRTest_SaveLoad::run( int /*start_from*/ )
+TEST(ML_LR, save_load)
 {
-    CV_TRACE_FUNCTION();
-    int code = cvtest::TS::OK;
-
-    // initialize variables from the popular Iris Dataset
-    string dataFileName = ts->get_data_path() + "iris.data";
+    string dataFileName = findDataFile("iris.data");
     Ptr<TrainData> tdata = TrainData::loadFromCSV(dataFileName, 0);
-    ASSERT_FALSE(tdata.empty()) << "Could not find test data file : " << dataFileName;
-
+    ASSERT_FALSE(tdata.empty());
     Mat responses1, responses2;
     Mat learnt_mat1, learnt_mat2;
-
-    // train and save the classifier
     String filename = tempfile(".xml");
-    try
     {
-        // run LR classifier train classifier
         Ptr<LogisticRegression> lr1 = LogisticRegression::create();
         lr1->setLearningRate(1.0);
         lr1->setIterations(10001);
         lr1->setRegularization(LogisticRegression::REG_L2);
         lr1->setTrainMethod(LogisticRegression::BATCH);
         lr1->setMiniBatchSize(10);
-        lr1->train(tdata);
-        lr1->predict(tdata->getSamples(), responses1);
+        ASSERT_NO_THROW(lr1->train(tdata));
+        ASSERT_NO_THROW(lr1->predict(tdata->getSamples(), responses1));
+        ASSERT_NO_THROW(lr1->save(filename));
         learnt_mat1 = lr1->get_learnt_thetas();
-        lr1->save(filename);
     }
-    catch(...)
-    {
-        ts->printf(cvtest::TS::LOG, "Crash in write method.\n" );
-        ts->set_failed_test_info(cvtest::TS::FAIL_EXCEPTION);
-    }
-
-    // and load to another
-    try
     {
-        Ptr<LogisticRegression> lr2 = Algorithm::load<LogisticRegression>(filename);
-        lr2->predict(tdata->getSamples(), responses2);
+        Ptr<LogisticRegression> lr2;
+        ASSERT_NO_THROW(lr2 = Algorithm::load<LogisticRegression>(filename));
+        ASSERT_NO_THROW(lr2->predict(tdata->getSamples(), responses2));
         learnt_mat2 = lr2->get_learnt_thetas();
     }
-    catch(...)
-    {
-        ts->printf(cvtest::TS::LOG, "Crash in write method.\n" );
-        ts->set_failed_test_info(cvtest::TS::FAIL_EXCEPTION);
-    }
-
-    CV_Assert(responses1.rows == responses2.rows);
+    // compare difference in prediction outputs and stored inputs
+    EXPECT_MAT_NEAR(responses1, responses2, 0.f);
 
-    // compare difference in learnt matrices before and after loading from disk
     Mat comp_learnt_mats;
     comp_learnt_mats = (learnt_mat1 == learnt_mat2);
     comp_learnt_mats = comp_learnt_mats.reshape(1, comp_learnt_mats.rows*comp_learnt_mats.cols);
     comp_learnt_mats.convertTo(comp_learnt_mats, CV_32S);
     comp_learnt_mats = comp_learnt_mats/255;
-
-    // compare difference in prediction outputs and stored inputs
     // check if there is any difference between computed learnt mat and retrieved mat
-
-    float errorCount = 0.0;
-    errorCount += 1 - (float)countNonZero(responses1 == responses2)/responses1.rows;
-    errorCount += 1 - (float)sum(comp_learnt_mats)[0]/comp_learnt_mats.rows;
-
-    if(errorCount>0)
-    {
-        ts->printf( cvtest::TS::LOG, "Different prediction results before writing and after reading (errorCount=%d).\n", errorCount );
-        code = cvtest::TS::FAIL_BAD_ACCURACY;
-    }
+    EXPECT_EQ(comp_learnt_mats.rows, sum(comp_learnt_mats)[0]);
 
     remove( filename.c_str() );
-
-    ts->set_failed_test_info( code );
 }
 
-TEST(ML_LR, accuracy) { CV_LRTest test; test.safe_run(); }
-TEST(ML_LR, save_load) { CV_LRTest_SaveLoad test; test.safe_run(); }
-
 }} // namespace

modules/ml/test/test_precomp.hpp

@@ -2,10 +2,15 @@
 #define __OPENCV_TEST_PRECOMP_HPP__
 
 #include "opencv2/ts.hpp"
+#include <opencv2/ts/cuda_test.hpp> // EXPECT_MAT_NEAR
 #include "opencv2/ml.hpp"
 #include "opencv2/core/core_c.h"
 
+#include <fstream>
+using std::ifstream;
+
 namespace opencv_test {
+
 using namespace cv::ml;
 
 #define CV_NBAYES   "nbayes"
@@ -19,8 +24,6 @@ using namespace cv::ml;
 #define CV_ERTREES  "ertrees"
 #define CV_SVMSGD   "svmsgd"
 
-enum { CV_TRAIN_ERROR=0, CV_TEST_ERROR=1 };
-
 using cv::Ptr;
 using cv::ml::StatModel;
 using cv::ml::TrainData;
@@ -34,58 +37,14 @@ using cv::ml::Boost;
 using cv::ml::RTrees;
 using cv::ml::SVMSGD;
 
-class CV_MLBaseTest : public cvtest::BaseTest
-{
-public:
-    CV_MLBaseTest( const char* _modelName );
-    virtual ~CV_MLBaseTest();
-protected:
-    virtual int read_params( const cv::FileStorage& fs );
-    virtual void run( int startFrom );
-    virtual int prepare_test_case( int testCaseIdx );
-    virtual std::string& get_validation_filename();
-    virtual int run_test_case( int testCaseIdx ) = 0;
-    virtual int validate_test_results( int testCaseIdx ) = 0;
-
-    int train( int testCaseIdx );
-    float get_test_error( int testCaseIdx, std::vector<float> *resp = 0 );
-    void save( const char* filename );
-    void load( const char* filename );
-
-    Ptr<TrainData> data;
-    std::string modelName, validationFN;
-    std::vector<std::string> dataSetNames;
-    cv::FileStorage validationFS;
-
-    Ptr<StatModel> model;
-
-    std::map<int, int> cls_map;
-
-    int64 initSeed;
-};
-
-class CV_AMLTest : public CV_MLBaseTest
-{
-public:
-    CV_AMLTest( const char* _modelName );
-    virtual ~CV_AMLTest() {}
-protected:
-    virtual int run_test_case( int testCaseIdx );
-    virtual int validate_test_results( int testCaseIdx );
-};
-
-class CV_SLMLTest : public CV_MLBaseTest
-{
-public:
-    CV_SLMLTest( const char* _modelName );
-    virtual ~CV_SLMLTest() {}
-protected:
-    virtual int run_test_case( int testCaseIdx );
-    virtual int validate_test_results( int testCaseIdx );
+void defaultDistribs( Mat& means, vector<Mat>& covs, int type=CV_32FC1 );
+void generateData( Mat& data, Mat& labels, const vector<int>& sizes, const Mat& _means, const vector<Mat>& covs, int dataType, int labelType );
+int maxIdx( const vector<int>& count );
+bool getLabelsMap( const Mat& labels, const vector<int>& sizes, vector<int>& labelsMap, bool checkClusterUniq=true );
+bool calcErr( const Mat& labels, const Mat& origLabels, const vector<int>& sizes, float& err, bool labelsEquivalent = true, bool checkClusterUniq=true );
 
-    std::vector<float> test_resps1, test_resps2; // predicted responses for test data
-    std::string fname1, fname2;
-};
+// used in LR test
+bool calculateError( const Mat& _p_labels, const Mat& _o_labels, float& error);
 
 } // namespace
 

modules/ml/test/test_rtrees.cpp

+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+
+#include "test_precomp.hpp"
+
+namespace opencv_test { namespace {
+
+TEST(ML_RTrees, getVotes)
+{
+    int n = 12;
+    int count, i;
+    int label_size = 3;
+    int predicted_class = 0;
+    int max_votes = -1;
+    int val;
+    // RTrees for classification
+    Ptr<ml::RTrees> rt = cv::ml::RTrees::create();
+
+    //data
+    Mat data(n, 4, CV_32F);
+    randu(data, 0, 10);
+
+    //labels
+    Mat labels = (Mat_<int>(n,1) << 0,0,0,0, 1,1,1,1, 2,2,2,2);
+
+    rt->train(data, ml::ROW_SAMPLE, labels);
+
+    //run function
+    Mat test(1, 4, CV_32F);
+    Mat result;
+    randu(test, 0, 10);
+    rt->getVotes(test, result, 0);
+
+    //count vote amount and find highest vote
+    count = 0;
+    const int* result_row = result.ptr<int>(1);
+    for( i = 0; i < label_size; i++ )
+    {
+        val = result_row[i];
+        //predicted_class = max_votes < val? i;
+        if( max_votes < val )
+        {
+            max_votes = val;
+            predicted_class = i;
+        }
+        count += val;
+    }
+
+    EXPECT_EQ(count, (int)rt->getRoots().size());
+    EXPECT_EQ(result.at<float>(0, predicted_class), rt->predict(test));
+}
+
+}} // namespace

modules/ml/test/test_utils.cpp

+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+#include "test_precomp.hpp"
+
+namespace opencv_test {
+
+void defaultDistribs( Mat& means, vector<Mat>& covs, int type)
+{
+    float mp0[] = {0.0f, 0.0f}, cp0[] = {0.67f, 0.0f, 0.0f, 0.67f};
+    float mp1[] = {5.0f, 0.0f}, cp1[] = {1.0f, 0.0f, 0.0f, 1.0f};
+    float mp2[] = {1.0f, 5.0f}, cp2[] = {1.0f, 0.0f, 0.0f, 1.0f};
+    means.create(3, 2, type);
+    Mat m0( 1, 2, CV_32FC1, mp0 ), c0( 2, 2, CV_32FC1, cp0 );
+    Mat m1( 1, 2, CV_32FC1, mp1 ), c1( 2, 2, CV_32FC1, cp1 );
+    Mat m2( 1, 2, CV_32FC1, mp2 ), c2( 2, 2, CV_32FC1, cp2 );
+    means.resize(3), covs.resize(3);
+
+    Mat mr0 = means.row(0);
+    m0.convertTo(mr0, type);
+    c0.convertTo(covs[0], type);
+
+    Mat mr1 = means.row(1);
+    m1.convertTo(mr1, type);
+    c1.convertTo(covs[1], type);
+
+    Mat mr2 = means.row(2);
+    m2.convertTo(mr2, type);
+    c2.convertTo(covs[2], type);
+}
+
+// generate points sets by normal distributions
+void generateData( Mat& data, Mat& labels, const vector<int>& sizes, const Mat& _means, const vector<Mat>& covs, int dataType, int labelType )
+{
+    vector<int>::const_iterator sit = sizes.begin();
+    int total = 0;
+    for( ; sit != sizes.end(); ++sit )
+        total += *sit;
+    CV_Assert( _means.rows == (int)sizes.size() && covs.size() == sizes.size() );
+    CV_Assert( !data.empty() && data.rows == total );
+    CV_Assert( data.type() == dataType );
+
+    labels.create( data.rows, 1, labelType );
+
+    randn( data, Scalar::all(-1.0), Scalar::all(1.0) );
+    vector<Mat> means(sizes.size());
+    for(int i = 0; i < _means.rows; i++)
+        means[i] = _means.row(i);
+    vector<Mat>::const_iterator mit = means.begin(), cit = covs.begin();
+    int bi, ei = 0;
+    sit = sizes.begin();
+    for( int p = 0, l = 0; sit != sizes.end(); ++sit, ++mit, ++cit, l++ )
+    {
+        bi = ei;
+        ei = bi + *sit;
+        CV_Assert( mit->rows == 1 && mit->cols == data.cols );
+        CV_Assert( cit->rows == data.cols && cit->cols == data.cols );
+        for( int i = bi; i < ei; i++, p++ )
+        {
+            Mat r = data.row(i);
+            r =  r * (*cit) + *mit;
+            if( labelType == CV_32FC1 )
+                labels.at<float>(p, 0) = (float)l;
+            else if( labelType == CV_32SC1 )
+                labels.at<int>(p, 0) = l;
+            else
+            {
+                CV_DbgAssert(0);
+            }
+        }
+    }
+}
+
+int maxIdx( const vector<int>& count )
+{
+    int idx = -1;
+    int maxVal = -1;
+    vector<int>::const_iterator it = count.begin();
+    for( int i = 0; it != count.end(); ++it, i++ )
+    {
+        if( *it > maxVal)
+        {
+            maxVal = *it;
+            idx = i;
+        }
+    }
+    CV_Assert( idx >= 0);
+    return idx;
+}
+
+bool getLabelsMap( const Mat& labels, const vector<int>& sizes, vector<int>& labelsMap, bool checkClusterUniq)
+{
+    size_t total = 0, nclusters = sizes.size();
+    for(size_t i = 0; i < sizes.size(); i++)
+        total += sizes[i];
+
+    CV_Assert( !labels.empty() );
+    CV_Assert( labels.total() == total && (labels.cols == 1 || labels.rows == 1));
+    CV_Assert( labels.type() == CV_32SC1 || labels.type() == CV_32FC1 );
+
+    bool isFlt = labels.type() == CV_32FC1;
+
+    labelsMap.resize(nclusters);
+
+    vector<bool> buzy(nclusters, false);
+    int startIndex = 0;
+    for( size_t clusterIndex = 0; clusterIndex < sizes.size(); clusterIndex++ )
+    {
+        vector<int> count( nclusters, 0 );
+        for( int i = startIndex; i < startIndex + sizes[clusterIndex]; i++)
+        {
+            int lbl = isFlt ? (int)labels.at<float>(i) : labels.at<int>(i);
+            CV_Assert(lbl < (int)nclusters);
+            count[lbl]++;
+            CV_Assert(count[lbl] < (int)total);
+        }
+        startIndex += sizes[clusterIndex];
+
+        int cls = maxIdx( count );
+        CV_Assert( !checkClusterUniq || !buzy[cls] );
+
+        labelsMap[clusterIndex] = cls;
+
+        buzy[cls] = true;
+    }
+
+    if(checkClusterUniq)
+    {
+        for(size_t i = 0; i < buzy.size(); i++)
+            if(!buzy[i])
+                return false;
+    }
+
+    return true;
+}
+
+bool calcErr( const Mat& labels, const Mat& origLabels, const vector<int>& sizes, float& err, bool labelsEquivalent, bool checkClusterUniq)
+{
+    err = 0;
+    CV_Assert( !labels.empty() && !origLabels.empty() );
+    CV_Assert( labels.rows == 1 || labels.cols == 1 );
+    CV_Assert( origLabels.rows == 1 || origLabels.cols == 1 );
+    CV_Assert( labels.total() == origLabels.total() );
+    CV_Assert( labels.type() == CV_32SC1 || labels.type() == CV_32FC1 );
+    CV_Assert( origLabels.type() == labels.type() );
+
+    vector<int> labelsMap;
+    bool isFlt = labels.type() == CV_32FC1;
+    if( !labelsEquivalent )
+    {
+        if( !getLabelsMap( labels, sizes, labelsMap, checkClusterUniq ) )
+            return false;
+
+        for( int i = 0; i < labels.rows; i++ )
+            if( isFlt )
+                err += labels.at<float>(i) != labelsMap[(int)origLabels.at<float>(i)] ? 1.f : 0.f;
+            else
+                err += labels.at<int>(i) != labelsMap[origLabels.at<int>(i)] ? 1.f : 0.f;
+    }
+    else
+    {
+        for( int i = 0; i < labels.rows; i++ )
+            if( isFlt )
+                err += labels.at<float>(i) != origLabels.at<float>(i) ? 1.f : 0.f;
+            else
+                err += labels.at<int>(i) != origLabels.at<int>(i) ? 1.f : 0.f;
+    }
+    err /= (float)labels.rows;
+    return true;
+}
+
+bool calculateError( const Mat& _p_labels, const Mat& _o_labels, float& error)
+{
+    error = 0.0f;
+    float accuracy = 0.0f;
+    Mat _p_labels_temp;
+    Mat _o_labels_temp;
+    _p_labels.convertTo(_p_labels_temp, CV_32S);
+    _o_labels.convertTo(_o_labels_temp, CV_32S);
+
+    CV_Assert(_p_labels_temp.total() == _o_labels_temp.total());
+    CV_Assert(_p_labels_temp.rows == _o_labels_temp.rows);
+
+    accuracy = (float)countNonZero(_p_labels_temp == _o_labels_temp)/_p_labels_temp.rows;
+    error = 1 - accuracy;
+    return true;
+}
+
+} // namespace

modules/ts/include/opencv2/ts.hpp

@@ -180,12 +180,21 @@ using testing::tuple_size;
 using testing::tuple_element;
 
 
-class SkipTestException: public cv::Exception
+namespace details {
+class SkipTestExceptionBase: public cv::Exception
+{
+public:
+    SkipTestExceptionBase(bool handlingTags);
+    SkipTestExceptionBase(const cv::String& message, bool handlingTags);
+};
+}
+
+class SkipTestException: public details::SkipTestExceptionBase
 {
 public:
     int dummy; // workaround for MacOSX Xcode 7.3 bug (don't make class "empty")
-    SkipTestException() : dummy(0) {}
-    SkipTestException(const cv::String& message) : dummy(0) { this->msg = message; }
+    SkipTestException() : details::SkipTestExceptionBase(false), dummy(0) {}
+    SkipTestException(const cv::String& message) : details::SkipTestExceptionBase(message, false), dummy(0) { }
 };
 
 /** Apply tag to the current test