react-native-executorch 0.4.7 → 0.5.1-rc.0

package/third-party/include/opencv2/core.hpp

@@ -0,0 +1,3699 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  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.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2000-2015, Intel Corporation, all rights reserved.
+// Copyright (C) 2009-2011, Willow Garage Inc., all rights reserved.
+// Copyright (C) 2015, OpenCV Foundation, all rights reserved.
+// Copyright (C) 2015, Itseez 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:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's 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.
+//
+//M*/
+
+#ifndef OPENCV_CORE_HPP
+#define OPENCV_CORE_HPP
+
+#ifndef __cplusplus
+#error core.hpp header must be compiled as C++
+#endif
+
+#include "opencv2/core/base.hpp"
+#include "opencv2/core/cvdef.h"
+#include "opencv2/core/cvstd.hpp"
+#include "opencv2/core/mat.hpp"
+#include "opencv2/core/matx.hpp"
+#include "opencv2/core/persistence.hpp"
+#include "opencv2/core/traits.hpp"
+#include "opencv2/core/types.hpp"
+
+/**
+@defgroup core Core functionality
+
+The Core module is the backbone of OpenCV, offering fundamental data structures,
+matrix operations, and utility functions that other modules depend on. It’s
+essential for handling image data, performing mathematical computations, and
+managing memory efficiently within the OpenCV ecosystem.
+
+@{
+    @defgroup core_basic Basic structures
+    @defgroup core_array Operations on arrays
+    @defgroup core_async Asynchronous API
+    @defgroup core_xml XML/YAML/JSON Persistence
+    @defgroup core_cluster Clustering
+    @defgroup core_utils Utility and system functions and macros
+    @{
+        @defgroup core_logging Logging facilities
+        @defgroup core_utils_sse SSE utilities
+        @defgroup core_utils_neon NEON utilities
+        @defgroup core_utils_vsx VSX utilities
+        @defgroup core_utils_softfloat Softfloat support
+        @defgroup core_utils_samples Utility functions for OpenCV samples
+    @}
+    @defgroup core_opengl OpenGL interoperability
+    @defgroup core_optim Optimization Algorithms
+    @defgroup core_directx DirectX interoperability
+    @defgroup core_eigen Eigen support
+    @defgroup core_opencl OpenCL support
+    @defgroup core_va_intel Intel VA-API/OpenCL (CL-VA) interoperability
+    @defgroup core_hal Hardware Acceleration Layer
+    @{
+        @defgroup core_hal_functions Functions
+        @defgroup core_hal_interface Interface
+        @defgroup core_hal_intrin Universal intrinsics
+        @{
+            @defgroup core_hal_intrin_impl Private implementation helpers
+        @}
+        @defgroup core_lowlevel_api Low-level API for external libraries /
+plugins
+    @}
+    @defgroup core_parallel Parallel Processing
+    @{
+        @defgroup core_parallel_backend Parallel backends API
+    @}
+    @defgroup core_quaternion Quaternion
+@}
+ */
+
+namespace cv {
+
+//! @addtogroup core_utils
+//! @{
+
+/*! @brief Class passed to an error.
+
+This class encapsulates all or almost all necessary
+information about the error happened in the program. The exception is
+usually constructed and thrown implicitly via CV_Error and CV_Error_ macros.
+@see error
+ */
+class CV_EXPORTS Exception : public std::exception {
+public:
+  /*!
+   Default constructor
+   */
+  Exception();
+  /*!
+   Full constructor. Normally the constructor is not called explicitly.
+   Instead, the macros CV_Error(), CV_Error_() and CV_Assert() are used.
+  */
+  Exception(int _code, const String &_err, const String &_func,
+            const String &_file, int _line);
+  virtual ~Exception() CV_NOEXCEPT;
+
+  /*!
+   \return the error description and the context as a text string.
+  */
+  virtual const char *what() const CV_NOEXCEPT CV_OVERRIDE;
+  void formatMessage();
+
+  String msg; ///< the formatted error message
+
+  int code;    ///< error code @see CVStatus
+  String err;  ///< error description
+  String func; ///< function name. Available only when the compiler supports
+               ///< getting it
+  String file; ///< source file name where the error has occurred
+  int line;    ///< line number in the source file where the error has occurred
+};
+
+/*! @brief Signals an error and raises the exception.
+
+By default the function prints information about the error to stderr,
+then it either stops if cv::setBreakOnError() had been called before or raises
+the exception. It is possible to alternate error processing by using
+#redirectError().
+@param exc the exception raisen.
+@deprecated drop this version
+ */
+CV_EXPORTS CV_NORETURN void error(const Exception &exc);
+
+enum SortFlags {
+  SORT_EVERY_ROW = 0,    //!< each matrix row is sorted independently
+  SORT_EVERY_COLUMN = 1, //!< each matrix column is sorted
+                         //!< independently; this flag and the previous one are
+                         //!< mutually exclusive.
+  SORT_ASCENDING = 0,    //!< each matrix row is sorted in the ascending
+                         //!< order.
+  SORT_DESCENDING = 16   //!< each matrix row is sorted in the
+                       //!< descending order; this flag and the previous one are
+                       //!< also mutually exclusive.
+};
+
+//! @} core_utils
+
+//! @addtogroup core_array
+//! @{
+
+//! Covariation flags
+enum CovarFlags {
+  /** The output covariance matrix is calculated as:
+     \f[\texttt{scale}   \cdot  [  \texttt{vects}  [0]-  \texttt{mean}  ,
+     \texttt{vects}  [1]-  \texttt{mean}  ,...]^T  \cdot  [ \texttt{vects}  [0]-
+     \texttt{mean}  , \texttt{vects}  [1]- \texttt{mean}  ,...],\f] The
+     covariance matrix will be nsamples x nsamples. Such an unusual covariance
+     matrix is used for fast PCA of a set of very large vectors (see, for
+     example, the EigenFaces technique for face recognition). Eigenvalues of
+     this "scrambled" matrix match the eigenvalues of the true covariance
+     matrix. The "true" eigenvectors can be easily calculated from the
+     eigenvectors of the "scrambled" covariance matrix. */
+  COVAR_SCRAMBLED = 0,
+  /**The output covariance matrix is calculated as:
+      \f[\texttt{scale}   \cdot  [  \texttt{vects}  [0]-  \texttt{mean}  ,
+     \texttt{vects}  [1]-  \texttt{mean}  ,...]  \cdot  [ \texttt{vects}  [0]-
+     \texttt{mean}  , \texttt{vects}  [1]- \texttt{mean}  ,...]^T,\f] covar will
+     be a square matrix of the same size as the total number of elements in each
+     input vector. One and only one of #COVAR_SCRAMBLED and #COVAR_NORMAL must
+     be specified.*/
+  COVAR_NORMAL = 1,
+  /** If the flag is specified, the function does not calculate mean from
+      the input vectors but, instead, uses the passed mean vector. This is
+     useful if mean has been pre-calculated or known in advance, or if the
+     covariance matrix is calculated by parts. In this case, mean is not a mean
+     vector of the input sub-set of vectors but rather the mean vector of the
+     whole set.*/
+  COVAR_USE_AVG = 2,
+  /** If the flag is specified, the covariance matrix is scaled. In the
+      "normal" mode, scale is 1./nsamples . In the "scrambled" mode, scale is
+     the reciprocal of the total number of elements in each input vector. By
+     default (if the flag is not specified), the covariance matrix is not scaled
+     ( scale=1 ).*/
+  COVAR_SCALE = 4,
+  /** If the flag is
+      specified, all the input vectors are stored as rows of the samples matrix.
+     mean should be a single-row vector in this case.*/
+  COVAR_ROWS = 8,
+  /** If the flag is
+      specified, all the input vectors are stored as columns of the samples
+     matrix. mean should be a single-column vector in this case.*/
+  COVAR_COLS = 16
+};
+
+enum ReduceTypes {
+  REDUCE_SUM = 0, //!< the output is the sum of all rows/columns of the matrix.
+  REDUCE_AVG =
+      1, //!< the output is the mean vector of all rows/columns of the matrix.
+  REDUCE_MAX = 2, //!< the output is the maximum (column/row-wise) of all
+                  //!< rows/columns of the matrix.
+  REDUCE_MIN = 3, //!< the output is the minimum (column/row-wise) of all
+                  //!< rows/columns of the matrix.
+  REDUCE_SUM2 =
+      4 //!< the output is the sum of all squared rows/columns of the matrix.
+};
+
+/** @brief Swaps two matrices
+ */
+CV_EXPORTS void swap(Mat &a, Mat &b);
+
+/** @brief Computes the source location of an extrapolated pixel.
+
+The function computes and returns the coordinate of a donor pixel corresponding
+to the specified extrapolated pixel when using the specified extrapolation
+border mode. For example, if you use cv::BORDER_WRAP mode in the horizontal
+direction, cv::BORDER_REFLECT_101 in the vertical direction and want to compute
+value of the "virtual" pixel Point(-5, 100) in a floating-point image img, it
+looks like:
+@code{.cpp}
+    float val = img.at<float>(borderInterpolate(100, img.rows,
+cv::BORDER_REFLECT_101), borderInterpolate(-5, img.cols, cv::BORDER_WRAP));
+@endcode
+Normally, the function is not called directly. It is used inside filtering
+functions and also in copyMakeBorder.
+@param p 0-based coordinate of the extrapolated pixel along one of the axes,
+likely \<0 or \>= len
+@param len Length of the array along the corresponding axis.
+@param borderType Border type, one of the #BorderTypes, except for
+#BORDER_TRANSPARENT and #BORDER_ISOLATED. When borderType==#BORDER_CONSTANT, the
+function always returns -1, regardless of p and len.
+
+@sa copyMakeBorder
+*/
+CV_EXPORTS_W int borderInterpolate(int p, int len, int borderType);
+
+/** @example samples/cpp/tutorial_code/ImgTrans/copyMakeBorder_demo.cpp
+An example using copyMakeBorder function.
+Check @ref tutorial_copyMakeBorder "the corresponding tutorial" for more details
+*/
+
+/** @brief Forms a border around an image.
+
+The function copies the source image into the middle of the destination image.
+The areas to the left, to the right, above and below the copied source image
+will be filled with extrapolated pixels. This is not what filtering functions
+based on it do (they extrapolate pixels on-fly), but what other more complex
+functions, including your own, may do to simplify image boundary handling.
+
+The function supports the mode when src is already in the middle of dst . In
+this case, the function does not copy src itself but simply constructs the
+border, for example:
+
+@code{.cpp}
+    // let border be the same in all directions
+    int border=2;
+    // constructs a larger image to fit both the image and the border
+    Mat gray_buf(rgb.rows + border*2, rgb.cols + border*2, rgb.depth());
+    // select the middle part of it w/o copying data
+    Mat gray(gray_canvas, Rect(border, border, rgb.cols, rgb.rows));
+    // convert image from RGB to grayscale
+    cvtColor(rgb, gray, COLOR_RGB2GRAY);
+    // form a border in-place
+    copyMakeBorder(gray, gray_buf, border, border,
+                   border, border, BORDER_REPLICATE);
+    // now do some custom filtering ...
+    ...
+@endcode
+@note When the source image is a part (ROI) of a bigger image, the function will
+try to use the pixels outside of the ROI to form a border. To disable this
+feature and always do extrapolation, as if src was not a ROI, use borderType |
+#BORDER_ISOLATED.
+
+@param src Source image.
+@param dst Destination image of the same type as src and the size
+Size(src.cols+left+right, src.rows+top+bottom) .
+@param top the top pixels
+@param bottom the bottom pixels
+@param left the left pixels
+@param right Parameter specifying how many pixels in each direction from the
+source image rectangle to extrapolate. For example, top=1, bottom=1, left=1,
+right=1 mean that 1 pixel-wide border needs to be built.
+@param borderType Border type. See borderInterpolate for details.
+@param value Border value if borderType==BORDER_CONSTANT .
+
+@sa  borderInterpolate
+*/
+CV_EXPORTS_W void copyMakeBorder(InputArray src, OutputArray dst, int top,
+                                 int bottom, int left, int right,
+                                 int borderType,
+                                 const Scalar &value = Scalar());
+
+/** @brief Calculates the per-element sum of two arrays or an array and a
+scalar.
+
+The function add calculates:
+- Sum of two arrays when both input arrays have the same size and the same
+number of channels:
+\f[\texttt{dst}(I) =  \texttt{saturate} ( \texttt{src1}(I) +  \texttt{src2}(I))
+\quad \texttt{if mask}(I) \ne0\f]
+- Sum of an array and a scalar when src2 is constructed from Scalar or has the
+same number of elements as `src1.channels()`:
+\f[\texttt{dst}(I) =  \texttt{saturate} ( \texttt{src1}(I) +  \texttt{src2} )
+\quad \texttt{if mask}(I) \ne0\f]
+- Sum of a scalar and an array when src1 is constructed from Scalar or has the
+same number of elements as `src2.channels()`:
+\f[\texttt{dst}(I) =  \texttt{saturate} ( \texttt{src1} +  \texttt{src2}(I) )
+\quad \texttt{if mask}(I) \ne0\f] where `I` is a multi-dimensional index of
+array elements. In case of multi-channel arrays, each channel is processed
+independently.
+
+The first function in the list above can be replaced with matrix expressions:
+@code{.cpp}
+    dst = src1 + src2;
+    dst += src1; // equivalent to add(dst, src1, dst);
+@endcode
+The input arrays and the output array can all have the same or different depths.
+For example, you can add a 16-bit unsigned array to a 8-bit signed array and
+store the sum as a 32-bit floating-point array. Depth of the output array is
+determined by the dtype parameter. In the second and third cases above, as well
+as in the first case, when src1.depth() == src2.depth(), dtype can be set to the
+default -1. In this case, the output array will have the same depth as the input
+array, be it src1, src2 or both.
+@note Saturation is not applied when the output array has the depth CV_32S. You
+may even get result of an incorrect sign in the case of overflow.
+@note (Python) Be careful to difference behaviour between src1/src2 are single
+number and they are tuple/array. `add(src,X)` means `add(src,(X,X,X,X))`.
+`add(src,(X,))` means `add(src,(X,0,0,0))`.
+@param src1 first input array or a scalar.
+@param src2 second input array or a scalar.
+@param dst output array that has the same size and number of channels as the
+input array(s); the depth is defined by dtype or src1/src2.
+@param mask optional operation mask - 8-bit single channel array, that specifies
+elements of the output array to be changed.
+@param dtype optional depth of the output array (see the discussion below).
+@sa subtract, addWeighted, scaleAdd, Mat::convertTo
+*/
+CV_EXPORTS_W void add(InputArray src1, InputArray src2, OutputArray dst,
+                      InputArray mask = noArray(), int dtype = -1);
+
+/** @brief Calculates the per-element difference between two arrays or array and
+a scalar.
+
+The function subtract calculates:
+- Difference between two arrays, when both input arrays have the same size and
+the same number of channels:
+    \f[\texttt{dst}(I) =  \texttt{saturate} ( \texttt{src1}(I) -
+\texttt{src2}(I)) \quad \texttt{if mask}(I) \ne0\f]
+- Difference between an array and a scalar, when src2 is constructed from Scalar
+or has the same number of elements as `src1.channels()`:
+    \f[\texttt{dst}(I) =  \texttt{saturate} ( \texttt{src1}(I) -  \texttt{src2}
+) \quad \texttt{if mask}(I) \ne0\f]
+- Difference between a scalar and an array, when src1 is constructed from Scalar
+or has the same number of elements as `src2.channels()`:
+    \f[\texttt{dst}(I) =  \texttt{saturate} ( \texttt{src1} -  \texttt{src2}(I)
+) \quad \texttt{if mask}(I) \ne0\f]
+- The reverse difference between a scalar and an array in the case of `SubRS`:
+    \f[\texttt{dst}(I) =  \texttt{saturate} ( \texttt{src2} -  \texttt{src1}(I)
+) \quad \texttt{if mask}(I) \ne0\f] where I is a multi-dimensional index of
+array elements. In case of multi-channel arrays, each channel is processed
+independently.
+
+The first function in the list above can be replaced with matrix expressions:
+@code{.cpp}
+    dst = src1 - src2;
+    dst -= src1; // equivalent to subtract(dst, src1, dst);
+@endcode
+The input arrays and the output array can all have the same or different depths.
+For example, you can subtract to 8-bit unsigned arrays and store the difference
+in a 16-bit signed array. Depth of the output array is determined by dtype
+parameter. In the second and third cases above, as well as in the first case,
+when src1.depth() == src2.depth(), dtype can be set to the default -1. In this
+case the output array will have the same depth as the input array, be it src1,
+src2 or both.
+@note Saturation is not applied when the output array has the depth CV_32S. You
+may even get result of an incorrect sign in the case of overflow.
+@note (Python) Be careful to difference behaviour between src1/src2 are single
+number and they are tuple/array. `subtract(src,X)` means
+`subtract(src,(X,X,X,X))`. `subtract(src,(X,))` means `subtract(src,(X,0,0,0))`.
+@param src1 first input array or a scalar.
+@param src2 second input array or a scalar.
+@param dst output array of the same size and the same number of channels as the
+input array.
+@param mask optional operation mask; this is an 8-bit single channel array that
+specifies elements of the output array to be changed.
+@param dtype optional depth of the output array
+@sa  add, addWeighted, scaleAdd, Mat::convertTo
+  */
+CV_EXPORTS_W void subtract(InputArray src1, InputArray src2, OutputArray dst,
+                           InputArray mask = noArray(), int dtype = -1);
+
+/** @brief Calculates the per-element scaled product of two arrays.
+
+The function multiply calculates the per-element product of two arrays:
+
+\f[\texttt{dst} (I)= \texttt{saturate} ( \texttt{scale} \cdot \texttt{src1} (I)
+\cdot \texttt{src2} (I))\f]
+
+There is also a @ref MatrixExpressions -friendly variant of the first function.
+See Mat::mul .
+
+For a not-per-element matrix product, see gemm .
+
+@note Saturation is not applied when the output array has the depth
+CV_32S. You may even get result of an incorrect sign in the case of
+overflow.
+@note (Python) Be careful to difference behaviour between src1/src2 are single
+number and they are tuple/array. `multiply(src,X)` means
+`multiply(src,(X,X,X,X))`. `multiply(src,(X,))` means `multiply(src,(X,0,0,0))`.
+@param src1 first input array.
+@param src2 second input array of the same size and the same type as src1.
+@param dst output array of the same size and type as src1.
+@param scale optional scale factor.
+@param dtype optional depth of the output array
+@sa add, subtract, divide, scaleAdd, addWeighted, accumulate, accumulateProduct,
+accumulateSquare, Mat::convertTo
+*/
+CV_EXPORTS_W void multiply(InputArray src1, InputArray src2, OutputArray dst,
+                           double scale = 1, int dtype = -1);
+
+/** @brief Performs per-element division of two arrays or a scalar by an array.
+
+The function cv::divide divides one array by another:
+\f[\texttt{dst(I) = saturate(src1(I)*scale/src2(I))}\f]
+or a scalar by an array when there is no src1 :
+\f[\texttt{dst(I) = saturate(scale/src2(I))}\f]
+
+Different channels of multi-channel arrays are processed independently.
+
+For integer types when src2(I) is zero, dst(I) will also be zero.
+
+@note In case of floating point data there is no special defined behavior for
+zero src2(I) values. Regular floating-point division is used. Expect correct
+IEEE-754 behaviour for floating-point data (with NaN, Inf result values).
+
+@note Saturation is not applied when the output array has the depth CV_32S. You
+may even get result of an incorrect sign in the case of overflow.
+@note (Python) Be careful to difference behaviour between src1/src2 are single
+number and they are tuple/array. `divide(src,X)` means `divide(src,(X,X,X,X))`.
+`divide(src,(X,))` means `divide(src,(X,0,0,0))`.
+@param src1 first input array.
+@param src2 second input array of the same size and type as src1.
+@param scale scalar factor.
+@param dst output array of the same size and type as src2.
+@param dtype optional depth of the output array; if -1, dst will have depth
+src2.depth(), but in case of an array-by-array division, you can only pass -1
+when src1.depth()==src2.depth().
+@sa  multiply, add, subtract
+*/
+CV_EXPORTS_W void divide(InputArray src1, InputArray src2, OutputArray dst,
+                         double scale = 1, int dtype = -1);
+
+/** @overload */
+CV_EXPORTS_W void divide(double scale, InputArray src2, OutputArray dst,
+                         int dtype = -1);
+
+/** @brief Calculates the sum of a scaled array and another array.
+
+The function scaleAdd is one of the classical primitive linear algebra
+operations, known as DAXPY or SAXPY in
+[BLAS](http://en.wikipedia.org/wiki/Basic_Linear_Algebra_Subprograms). It
+calculates the sum of a scaled array and another array:
+\f[\texttt{dst} (I)= \texttt{scale} \cdot \texttt{src1} (I) +  \texttt{src2}
+(I)\f] The function can also be emulated with a matrix expression, for example:
+@code{.cpp}
+    Mat A(3, 3, CV_64F);
+    ...
+    A.row(0) = A.row(1)*2 + A.row(2);
+@endcode
+@param src1 first input array.
+@param alpha scale factor for the first array.
+@param src2 second input array of the same size and type as src1.
+@param dst output array of the same size and type as src1.
+@sa add, addWeighted, subtract, Mat::dot, Mat::convertTo
+*/
+CV_EXPORTS_W void scaleAdd(InputArray src1, double alpha, InputArray src2,
+                           OutputArray dst);
+
+/** @brief Calculates the weighted sum of two arrays.
+
+The function addWeighted calculates the weighted sum of two arrays as follows:
+\f[\texttt{dst} (I)= \texttt{saturate} ( \texttt{src1} (I)* \texttt{alpha} +
+\texttt{src2} (I)* \texttt{beta} +  \texttt{gamma} )\f] where I is a
+multi-dimensional index of array elements. In case of multi-channel arrays, each
+channel is processed independently.
+The function can be replaced with a matrix expression:
+@code{.cpp}
+    dst = src1*alpha + src2*beta + gamma;
+@endcode
+@note Saturation is not applied when the output array has the depth CV_32S. You
+may even get result of an incorrect sign in the case of overflow.
+@param src1 first input array.
+@param alpha weight of the first array elements.
+@param src2 second input array of the same size and channel number as src1.
+@param beta weight of the second array elements.
+@param gamma scalar added to each sum.
+@param dst output array that has the same size and number of channels as the
+input arrays.
+@param dtype optional depth of the output array; when both input arrays have the
+same depth, dtype can be set to -1, which will be equivalent to src1.depth().
+@sa  add, subtract, scaleAdd, Mat::convertTo
+*/
+CV_EXPORTS_W void addWeighted(InputArray src1, double alpha, InputArray src2,
+                              double beta, double gamma, OutputArray dst,
+                              int dtype = -1);
+
+/** @brief Scales, calculates absolute values, and converts the result to 8-bit.
+
+On each element of the input array, the function convertScaleAbs
+performs three operations sequentially: scaling, taking an absolute
+value, conversion to an unsigned 8-bit type:
+\f[\texttt{dst} (I)= \texttt{saturate\_cast<uchar>} (| \texttt{src} (I)*
+\texttt{alpha} +  \texttt{beta} |)\f] In case of multi-channel arrays, the
+function processes each channel independently. When the output is not 8-bit, the
+operation can be emulated by calling the Mat::convertTo method (or by using
+matrix expressions) and then by calculating an absolute value of the result. For
+example:
+@code{.cpp}
+    Mat_<float> A(30,30);
+    randu(A, Scalar(-100), Scalar(100));
+    Mat_<float> B = A*5 + 3;
+    B = abs(B);
+    // Mat_<float> B = abs(A*5+3) will also do the job,
+    // but it will allocate a temporary matrix
+@endcode
+@param src input array.
+@param dst output array.
+@param alpha optional scale factor.
+@param beta optional delta added to the scaled values.
+@sa  Mat::convertTo, cv::abs(const Mat&)
+*/
+CV_EXPORTS_W void convertScaleAbs(InputArray src, OutputArray dst,
+                                  double alpha = 1, double beta = 0);
+
+/** @brief Converts an array to half precision floating number.
+
+This function converts FP32 (single precision floating point) from/to FP16 (half
+precision floating point). CV_16S format is used to represent FP16 data. There
+are two use modes (src -> dst): CV_32F -> CV_16S and CV_16S -> CV_32F. The input
+array has to have type of CV_32F or CV_16S to represent the bit depth. If the
+input array is neither of them, the function will raise an error. The format of
+half precision floating point is defined in IEEE 754-2008.
+
+@param src input array.
+@param dst output array.
+
+@deprecated Use Mat::convertTo with CV_16F instead.
+*/
+CV_EXPORTS_W void convertFp16(InputArray src, OutputArray dst);
+
+/** @example
+samples/cpp/tutorial_code/core/how_to_scan_images/how_to_scan_images.cpp Check
+@ref tutorial_how_to_scan_images "the corresponding tutorial" for more details
+*/
+
+/** @brief Performs a look-up table transform of an array.
+
+The function LUT fills the output array with values from the look-up table.
+Indices of the entries are taken from the input array. That is, the function
+processes each element of src as follows:
+\f[\texttt{dst} (I)  \leftarrow \texttt{lut(src(I) + d)}\f]
+where
+\f[d =  \fork{0}{if \(\texttt{src}\) has depth \(\texttt{CV_8U}\)}{128}{if
+\(\texttt{src}\) has depth \(\texttt{CV_8S}\)}\f]
+@param src input array of 8-bit elements.
+@param lut look-up table of 256 elements; in case of multi-channel input array,
+the table should either have a single channel (in this case the same table is
+used for all channels) or the same number of channels as in the input array.
+@param dst output array of the same size and number of channels as src, and the
+same depth as lut.
+@sa  convertScaleAbs, Mat::convertTo
+*/
+CV_EXPORTS_W void LUT(InputArray src, InputArray lut, OutputArray dst);
+
+/** @brief Calculates the sum of array elements.
+
+The function cv::sum calculates and returns the sum of array elements,
+independently for each channel.
+@param src input array that must have from 1 to 4 channels.
+@sa  countNonZero, mean, meanStdDev, norm, minMaxLoc, reduce
+*/
+CV_EXPORTS_AS(sumElems) Scalar sum(InputArray src);
+
+/** @brief Checks for the presence of at least one non-zero array element.
+
+The function returns whether there are non-zero elements in src
+
+The function do not work with multi-channel arrays. If you need to check
+non-zero array elements across all the channels, use Mat::reshape first to
+reinterpret the array as single-channel. Or you may extract the particular
+channel using either extractImageCOI, or mixChannels, or split.
+
+@note
+- If the location of non-zero array elements is important, @ref findNonZero is
+helpful.
+- If the count of non-zero array elements is important, @ref countNonZero is
+helpful.
+@param src single-channel array.
+@sa  mean, meanStdDev, norm, minMaxLoc, calcCovarMatrix
+@sa  findNonZero, countNonZero
+*/
+CV_EXPORTS_W bool hasNonZero(InputArray src);
+
+/** @brief Counts non-zero array elements.
+
+The function returns the number of non-zero elements in src :
+\f[\sum _{I: \; \texttt{src} (I) \ne0 } 1\f]
+
+The function do not work with multi-channel arrays. If you need to count
+non-zero array elements across all the channels, use Mat::reshape first to
+reinterpret the array as single-channel. Or you may extract the particular
+channel using either extractImageCOI, or mixChannels, or split.
+
+@note
+- If only whether there are non-zero elements is important, @ref hasNonZero is
+helpful.
+- If the location of non-zero array elements is important, @ref findNonZero is
+helpful.
+@param src single-channel array.
+@sa  mean, meanStdDev, norm, minMaxLoc, calcCovarMatrix
+@sa  findNonZero, hasNonZero
+*/
+CV_EXPORTS_W int countNonZero(InputArray src);
+
+/** @brief Returns the list of locations of non-zero pixels
+
+Given a binary matrix (likely returned from an operation such
+as threshold(), compare(), >, ==, etc, return all of
+the non-zero indices as a cv::Mat or std::vector<cv::Point> (x,y)
+For example:
+@code{.cpp}
+    cv::Mat binaryImage; // input, binary image
+    cv::Mat locations;   // output, locations of non-zero pixels
+    cv::findNonZero(binaryImage, locations);
+
+    // access pixel coordinates
+    Point pnt = locations.at<Point>(i);
+@endcode
+or
+@code{.cpp}
+    cv::Mat binaryImage; // input, binary image
+    vector<Point> locations;   // output, locations of non-zero pixels
+    cv::findNonZero(binaryImage, locations);
+
+    // access pixel coordinates
+    Point pnt = locations[i];
+@endcode
+
+The function do not work with multi-channel arrays. If you need to find non-zero
+elements across all the channels, use Mat::reshape first to reinterpret the
+array as single-channel. Or you may extract the particular channel using either
+extractImageCOI, or mixChannels, or split.
+
+@note
+- If only count of non-zero array elements is important, @ref countNonZero is
+helpful.
+- If only whether there are non-zero elements is important, @ref hasNonZero is
+helpful.
+@param src single-channel array
+@param idx the output array, type of cv::Mat or std::vector<Point>,
+corresponding to non-zero indices in the input
+@sa  countNonZero, hasNonZero
+*/
+CV_EXPORTS_W void findNonZero(InputArray src, OutputArray idx);
+
+/** @brief Calculates an average (mean) of array elements.
+
+The function cv::mean calculates the mean value M of array elements,
+independently for each channel, and return it:
+\f[\begin{array}{l} N =  \sum _{I: \; \texttt{mask} (I) \ne 0} 1 \\ M_c =  \left
+( \sum _{I: \; \texttt{mask} (I) \ne 0}{ \texttt{mtx} (I)_c} \right )/N
+\end{array}\f] When all the mask elements are 0's, the function returns
+Scalar::all(0)
+@param src input array that should have from 1 to 4 channels so that the result
+can be stored in Scalar_ .
+@param mask optional operation mask.
+@sa  countNonZero, meanStdDev, norm, minMaxLoc
+*/
+CV_EXPORTS_W Scalar mean(InputArray src, InputArray mask = noArray());
+
+/** Calculates a mean and standard deviation of array elements.
+
+The function cv::meanStdDev calculates the mean and the standard deviation M
+of array elements independently for each channel and returns it via the
+output parameters:
+\f[\begin{array}{l} N =  \sum _{I, \texttt{mask} (I)  \ne 0} 1 \\ \texttt{mean}
+_c =  \frac{\sum_{ I: \; \texttt{mask}(I) \ne 0} \texttt{src} (I)_c}{N}
+\\ \texttt{stddev} _c =  \sqrt{\frac{\sum_{ I: \; \texttt{mask}(I) \ne 0} \left
+( \texttt{src} (I)_c -  \texttt{mean} _c \right )^2}{N}} \end{array}\f] When all
+the mask elements are 0's, the function returns mean=stddev=Scalar::all(0).
+@note The calculated standard deviation is only the diagonal of the
+complete normalized covariance matrix. If the full matrix is needed, you
+can reshape the multi-channel array M x N to the single-channel array
+M\*N x mtx.channels() (only possible when the matrix is continuous) and
+then pass the matrix to calcCovarMatrix .
+@param src input array that should have from 1 to 4 channels so that the results
+can be stored in Scalar_ 's.
+@param mean output parameter: calculated mean value.
+@param stddev output parameter: calculated standard deviation.
+@param mask optional operation mask.
+@sa  countNonZero, mean, norm, minMaxLoc, calcCovarMatrix
+*/
+CV_EXPORTS_W void meanStdDev(InputArray src, OutputArray mean,
+                             OutputArray stddev, InputArray mask = noArray());
+
+/** @brief Calculates the  absolute norm of an array.
+
+This version of #norm calculates the absolute norm of src1. The type of norm to
+calculate is specified using #NormTypes.
+
+As example for one array consider the function \f$r(x)= \begin{pmatrix} x \\ 1-x
+\end{pmatrix}, x \in [-1;1]\f$. The \f$ L_{1}, L_{2} \f$ and \f$ L_{\infty} \f$
+norm for the sample value \f$r(-1) = \begin{pmatrix} -1 \\ 2 \end{pmatrix}\f$ is
+calculated as follows
+\f{align*}
+    \| r(-1) \|_{L_1} &= |-1| + |2| = 3 \\
+    \| r(-1) \|_{L_2} &= \sqrt{(-1)^{2} + (2)^{2}} = \sqrt{5} \\
+    \| r(-1) \|_{L_\infty} &= \max(|-1|,|2|) = 2
+\f}
+and for \f$r(0.5) = \begin{pmatrix} 0.5 \\ 0.5 \end{pmatrix}\f$ the calculation
+is
+\f{align*}
+    \| r(0.5) \|_{L_1} &= |0.5| + |0.5| = 1 \\
+    \| r(0.5) \|_{L_2} &= \sqrt{(0.5)^{2} + (0.5)^{2}} = \sqrt{0.5} \\
+    \| r(0.5) \|_{L_\infty} &= \max(|0.5|,|0.5|) = 0.5.
+\f}
+The following graphic shows all values for the three norm functions \f$\| r(x)
+\|_{L_1}, \| r(x) \|_{L_2}\f$ and \f$\| r(x) \|_{L_\infty}\f$. It is notable
+that the \f$ L_{1} \f$ norm forms the upper and the \f$ L_{\infty} \f$ norm
+forms the lower border for the example function \f$ r(x) \f$.
+![Graphs for the different norm functions from the above
+example](pics/NormTypes_OneArray_1-2-INF.png)
+
+When the mask parameter is specified and it is not empty, the norm is
+
+If normType is not specified, #NORM_L2 is used.
+calculated only over the region specified by the mask.
+
+Multi-channel input arrays are treated as single-channel arrays, that is,
+the results for all channels are combined.
+
+Hamming norms can only be calculated with CV_8U depth arrays.
+
+@param src1 first input array.
+@param normType type of the norm (see #NormTypes).
+@param mask optional operation mask; it must have the same size as src1 and
+CV_8UC1 type.
+*/
+CV_EXPORTS_W double norm(InputArray src1, int normType = NORM_L2,
+                         InputArray mask = noArray());
+
+/** @brief Calculates an absolute difference norm or a relative difference norm.
+
+This version of cv::norm calculates the absolute difference norm
+or the relative difference norm of arrays src1 and src2.
+The type of norm to calculate is specified using #NormTypes.
+
+@param src1 first input array.
+@param src2 second input array of the same size and the same type as src1.
+@param normType type of the norm (see #NormTypes).
+@param mask optional operation mask; it must have the same size as src1 and
+CV_8UC1 type.
+*/
+CV_EXPORTS_W double norm(InputArray src1, InputArray src2,
+                         int normType = NORM_L2, InputArray mask = noArray());
+/** @overload
+@param src first input array.
+@param normType type of the norm (see #NormTypes).
+*/
+CV_EXPORTS double norm(const SparseMat &src, int normType);
+
+/** @brief Computes the Peak Signal-to-Noise Ratio (PSNR) image quality metric.
+
+This function calculates the Peak Signal-to-Noise Ratio (PSNR) image quality
+metric in decibels (dB), between two input arrays src1 and src2. The arrays must
+have the same type.
+
+The PSNR is calculated as follows:
+
+\f[
+\texttt{PSNR} = 10 \cdot \log_{10}{\left( \frac{R^2}{MSE} \right) }
+\f]
+
+where R is the maximum integer value of depth (e.g. 255 in the case of CV_8U
+data) and MSE is the mean squared error between the two arrays.
+
+@param src1 first input array.
+@param src2 second input array of the same size as src1.
+@param R the maximum pixel value (255 by default)
+
+  */
+CV_EXPORTS_W double PSNR(InputArray src1, InputArray src2, double R = 255.);
+
+/** @brief naive nearest neighbor finder
+
+see http://en.wikipedia.org/wiki/Nearest_neighbor_search
+@todo document
+  */
+CV_EXPORTS_W void batchDistance(InputArray src1, InputArray src2,
+                                OutputArray dist, int dtype, OutputArray nidx,
+                                int normType = NORM_L2, int K = 0,
+                                InputArray mask = noArray(), int update = 0,
+                                bool crosscheck = false);
+
+/** @brief Normalizes the norm or value range of an array.
+
+The function cv::normalize normalizes scale and shift the input array elements
+so that
+\f[\| \texttt{dst} \| _{L_p}= \texttt{alpha}\f]
+(where p=Inf, 1 or 2) when normType=NORM_INF, NORM_L1, or NORM_L2, respectively;
+or so that
+\f[\min _I  \texttt{dst} (I)= \texttt{alpha} , \, \, \max _I  \texttt{dst} (I)=
+\texttt{beta}\f]
+
+when normType=NORM_MINMAX (for dense arrays only). The optional mask specifies a
+sub-array to be normalized. This means that the norm or min-n-max are calculated
+over the sub-array, and then this sub-array is modified to be normalized. If you
+want to only use the mask to calculate the norm or min-max but modify the whole
+array, you can use norm and Mat::convertTo.
+
+In case of sparse matrices, only the non-zero values are analyzed and
+transformed. Because of this, the range transformation for sparse matrices is
+not allowed since it can shift the zero level.
+
+Possible usage with some positive example data:
+@code{.cpp}
+    vector<double> positiveData = { 2.0, 8.0, 10.0 };
+    vector<double> normalizedData_l1, normalizedData_l2, normalizedData_inf,
+normalizedData_minmax;
+
+    // Norm to probability (total count)
+    // sum(numbers) = 20.0
+    // 2.0      0.1     (2.0/20.0)
+    // 8.0      0.4     (8.0/20.0)
+    // 10.0     0.5     (10.0/20.0)
+    normalize(positiveData, normalizedData_l1, 1.0, 0.0, NORM_L1);
+
+    // Norm to unit vector: ||positiveData|| = 1.0
+    // 2.0      0.15
+    // 8.0      0.62
+    // 10.0     0.77
+    normalize(positiveData, normalizedData_l2, 1.0, 0.0, NORM_L2);
+
+    // Norm to max element
+    // 2.0      0.2     (2.0/10.0)
+    // 8.0      0.8     (8.0/10.0)
+    // 10.0     1.0     (10.0/10.0)
+    normalize(positiveData, normalizedData_inf, 1.0, 0.0, NORM_INF);
+
+    // Norm to range [0.0;1.0]
+    // 2.0      0.0     (shift to left border)
+    // 8.0      0.75    (6.0/8.0)
+    // 10.0     1.0     (shift to right border)
+    normalize(positiveData, normalizedData_minmax, 1.0, 0.0, NORM_MINMAX);
+@endcode
+
+@param src input array.
+@param dst output array of the same size as src .
+@param alpha norm value to normalize to or the lower range boundary in case of
+the range normalization.
+@param beta upper range boundary in case of the range normalization; it is not
+used for the norm normalization.
+@param norm_type normalization type (see cv::NormTypes).
+@param dtype when negative, the output array has the same type as src;
+otherwise, it has the same number of channels as src and the depth
+=CV_MAT_DEPTH(dtype).
+@param mask optional operation mask.
+@sa norm, Mat::convertTo, SparseMat::convertTo
+*/
+CV_EXPORTS_W void normalize(InputArray src, InputOutputArray dst,
+                            double alpha = 1, double beta = 0,
+                            int norm_type = NORM_L2, int dtype = -1,
+                            InputArray mask = noArray());
+
+/** @overload
+@param src input array.
+@param dst output array of the same size as src .
+@param alpha norm value to normalize to or the lower range boundary in case of
+the range normalization.
+@param normType normalization type (see cv::NormTypes).
+*/
+CV_EXPORTS void normalize(const SparseMat &src, SparseMat &dst, double alpha,
+                          int normType);
+
+/** @brief Finds the global minimum and maximum in an array.
+
+The function cv::minMaxLoc finds the minimum and maximum element values and
+their positions. The extrema are searched across the whole array or, if mask is
+not an empty array, in the specified array region.
+
+In C++, if the input is multi-channel, you should omit the minLoc, maxLoc, and
+mask arguments (i.e. leave them as NULL, NULL, and noArray() respectively).
+These arguments are not supported for multi-channel input arrays. If working
+with multi-channel input and you need the minLoc, maxLoc, or mask arguments,
+then use Mat::reshape first to reinterpret the array as single-channel.
+Alternatively, you can extract the particular channel using either
+extractImageCOI, mixChannels, or split.
+
+In Python, multi-channel input is not supported at all due to a limitation in
+the binding generation process (there is no way to set minLoc and maxLoc to
+NULL). A workaround is to operate on each channel individually or to use NumPy
+to achieve the same functionality.
+
+@param src input single-channel array.
+@param minVal pointer to the returned minimum value; NULL is used if not
+required.
+@param maxVal pointer to the returned maximum value; NULL is used if not
+required.
+@param minLoc pointer to the returned minimum location (in 2D case); NULL is
+used if not required.
+@param maxLoc pointer to the returned maximum location (in 2D case); NULL is
+used if not required.
+@param mask optional mask used to select a sub-array.
+@sa max, min, reduceArgMin, reduceArgMax, compare, inRange, extractImageCOI,
+mixChannels, split, Mat::reshape
+*/
+CV_EXPORTS_W void minMaxLoc(InputArray src, CV_OUT double *minVal,
+                            CV_OUT double *maxVal = 0, CV_OUT Point *minLoc = 0,
+                            CV_OUT Point *maxLoc = 0,
+                            InputArray mask = noArray());
+
+/**
+ * @brief Finds indices of min elements along provided axis
+ *
+ * @note
+ *      - If input or output array is not continuous, this function will create
+ * an internal copy.
+ *      - NaN handling is left unspecified, see patchNaNs().
+ *      - The returned index is always in bounds of input matrix.
+ *
+ * @param src input single-channel array.
+ * @param dst output array of type CV_32SC1 with the same dimensionality as src,
+ * except for axis being reduced - it should be set to 1.
+ * @param lastIndex whether to get the index of first or last occurrence of min.
+ * @param axis axis to reduce along.
+ * @sa reduceArgMax, minMaxLoc, min, max, compare, reduce
+ */
+CV_EXPORTS_W void reduceArgMin(InputArray src, OutputArray dst, int axis,
+                               bool lastIndex = false);
+
+/**
+ * @brief Finds indices of max elements along provided axis
+ *
+ * @note
+ *      - If input or output array is not continuous, this function will create
+ * an internal copy.
+ *      - NaN handling is left unspecified, see patchNaNs().
+ *      - The returned index is always in bounds of input matrix.
+ *
+ * @param src input single-channel array.
+ * @param dst output array of type CV_32SC1 with the same dimensionality as src,
+ * except for axis being reduced - it should be set to 1.
+ * @param lastIndex whether to get the index of first or last occurrence of max.
+ * @param axis axis to reduce along.
+ * @sa reduceArgMin, minMaxLoc, min, max, compare, reduce
+ */
+CV_EXPORTS_W void reduceArgMax(InputArray src, OutputArray dst, int axis,
+                               bool lastIndex = false);
+
+/** @brief Finds the global minimum and maximum in an array
+
+The function cv::minMaxIdx finds the minimum and maximum element values and
+their positions. The extremums are searched across the whole array or, if mask
+is not an empty array, in the specified array region. In case of a sparse
+matrix, the minimum is found among non-zero elements only. Multi-channel input
+is supported without mask and extremums indexes (should be nullptr).
+@note When minIdx is not NULL, it must have at least 2 elements (as well as
+maxIdx), even if src is a single-row or single-column matrix. In OpenCV
+(following MATLAB) each array has at least 2 dimensions, i.e. single-column
+matrix is Mx1 matrix (and therefore minIdx/maxIdx will be (i1,0)/(i2,0)) and
+single-row matrix is 1xN matrix (and therefore minIdx/maxIdx will be
+(0,j1)/(0,j2)).
+@param src input single-channel array.
+@param minVal pointer to the returned minimum value; NULL is used if not
+required.
+@param maxVal pointer to the returned maximum value; NULL is used if not
+required.
+@param minIdx pointer to the returned minimum location (in nD case); NULL is
+used if not required; Otherwise, it must point to an array of src.dims elements,
+the coordinates of the minimum element in each dimension are stored there
+sequentially.
+@param maxIdx pointer to the returned maximum location (in nD case). NULL is
+used if not required.
+@param mask specified array region
+*/
+CV_EXPORTS void minMaxIdx(InputArray src, double *minVal, double *maxVal = 0,
+                          int *minIdx = 0, int *maxIdx = 0,
+                          InputArray mask = noArray());
+
+/** @overload
+@param a input single-channel array.
+@param minVal pointer to the returned minimum value; NULL is used if not
+required.
+@param maxVal pointer to the returned maximum value; NULL is used if not
+required.
+@param minIdx pointer to the returned minimum location (in nD case); NULL is
+used if not required; Otherwise, it must point to an array of src.dims elements,
+the coordinates of the minimum element in each dimension are stored there
+sequentially.
+@param maxIdx pointer to the returned maximum location (in nD case). NULL is
+used if not required.
+*/
+CV_EXPORTS void minMaxLoc(const SparseMat &a, double *minVal, double *maxVal,
+                          int *minIdx = 0, int *maxIdx = 0);
+
+/** @brief Reduces a matrix to a vector.
+
+The function #reduce reduces the matrix to a vector by treating the matrix
+rows/columns as a set of 1D vectors and performing the specified operation on
+the vectors until a single row/column is obtained. For example, the function can
+be used to compute horizontal and vertical projections of a raster image. In
+case of #REDUCE_MAX and #REDUCE_MIN, the output image should have the same type
+as the source one. In case of #REDUCE_SUM, #REDUCE_SUM2 and #REDUCE_AVG, the
+output may have a larger element bit-depth to preserve accuracy. And
+multi-channel arrays are also supported in these two reduction modes.
+
+The following code demonstrates its usage for a single channel matrix.
+@snippet snippets/core_reduce.cpp example
+
+And the following code demonstrates its usage for a two-channel matrix.
+@snippet snippets/core_reduce.cpp example2
+
+@param src input 2D matrix.
+@param dst output vector. Its size and type is defined by dim and dtype
+parameters.
+@param dim dimension index along which the matrix is reduced. 0 means that the
+matrix is reduced to a single row. 1 means that the matrix is reduced to a
+single column.
+@param rtype reduction operation that could be one of #ReduceTypes
+@param dtype when negative, the output vector will have the same type as the
+input matrix, otherwise, its type will be CV_MAKE_TYPE(CV_MAT_DEPTH(dtype),
+src.channels()).
+@sa repeat, reduceArgMin, reduceArgMax
+*/
+CV_EXPORTS_W void reduce(InputArray src, OutputArray dst, int dim, int rtype,
+                         int dtype = -1);
+
+/** @brief Creates one multi-channel array out of several single-channel ones.
+
+The function cv::merge merges several arrays to make a single multi-channel
+array. That is, each element of the output array will be a concatenation of the
+elements of the input arrays, where elements of i-th input array are treated as
+mv[i].channels()-element vectors.
+
+The function cv::split does the reverse operation. If you need to shuffle
+channels in some other advanced way, use cv::mixChannels.
+
+The following example shows how to merge 3 single channel matrices into a single
+3-channel matrix.
+@snippet snippets/core_merge.cpp example
+
+@param mv input array of matrices to be merged; all the matrices in mv must have
+the same size and the same depth.
+@param count number of input matrices when mv is a plain C array; it must be
+greater than zero.
+@param dst output array of the same size and the same depth as mv[0]; The number
+of channels will be equal to the parameter count.
+@sa  mixChannels, split, Mat::reshape
+*/
+CV_EXPORTS void merge(const Mat *mv, size_t count, OutputArray dst);
+
+/** @overload
+@param mv input vector of matrices to be merged; all the matrices in mv must
+have the same size and the same depth.
+@param dst output array of the same size and the same depth as mv[0]; The number
+of channels will be the total number of channels in the matrix array.
+  */
+CV_EXPORTS_W void merge(InputArrayOfArrays mv, OutputArray dst);
+
+/** @brief Divides a multi-channel array into several single-channel arrays.
+
+The function cv::split splits a multi-channel array into separate single-channel
+arrays:
+\f[\texttt{mv} [c](I) =  \texttt{src} (I)_c\f]
+If you need to extract a single channel or do some other sophisticated channel
+permutation, use mixChannels.
+
+The following example demonstrates how to split a 3-channel matrix into 3 single
+channel matrices.
+@snippet snippets/core_split.cpp example
+
+@param src input multi-channel array.
+@param mvbegin output array; the number of arrays must match src.channels(); the
+arrays themselves are reallocated, if needed.
+@sa merge, mixChannels, cvtColor
+*/
+CV_EXPORTS void split(const Mat &src, Mat *mvbegin);
+
+/** @overload
+@param m input multi-channel array.
+@param mv output vector of arrays; the arrays themselves are reallocated, if
+needed.
+*/
+CV_EXPORTS_W void split(InputArray m, OutputArrayOfArrays mv);
+
+/** @brief Copies specified channels from input arrays to the specified channels
+of output arrays.
+
+The function cv::mixChannels provides an advanced mechanism for shuffling image
+channels.
+
+cv::split,cv::merge,cv::extractChannel,cv::insertChannel and some forms of
+cv::cvtColor are partial cases of cv::mixChannels.
+
+In the example below, the code splits a 4-channel BGRA image into a 3-channel
+BGR (with B and R channels swapped) and a separate alpha-channel image:
+@code{.cpp}
+    Mat bgra( 100, 100, CV_8UC4, Scalar(255,0,0,255) );
+    Mat bgr( bgra.rows, bgra.cols, CV_8UC3 );
+    Mat alpha( bgra.rows, bgra.cols, CV_8UC1 );
+
+    // forming an array of matrices is a quite efficient operation,
+    // because the matrix data is not copied, only the headers
+    Mat out[] = { bgr, alpha };
+    // bgra[0] -> bgr[2], bgra[1] -> bgr[1],
+    // bgra[2] -> bgr[0], bgra[3] -> alpha[0]
+    int from_to[] = { 0,2, 1,1, 2,0, 3,3 };
+    mixChannels( &bgra, 1, out, 2, from_to, 4 );
+@endcode
+@note Unlike many other new-style C++ functions in OpenCV (see the introduction
+section and Mat::create ), cv::mixChannels requires the output arrays to be
+pre-allocated before calling the function.
+@param src input array or vector of matrices; all of the matrices must have the
+same size and the same depth.
+@param nsrcs number of matrices in `src`.
+@param dst output array or vector of matrices; all the matrices **must be
+allocated**; their size and depth must be the same as in `src[0]`.
+@param ndsts number of matrices in `dst`.
+@param fromTo array of index pairs specifying which channels are copied and
+where; fromTo[k\*2] is a 0-based index of the input channel in src,
+fromTo[k\*2+1] is an index of the output channel in dst; the continuous channel
+numbering is used: the first input image channels are indexed from 0 to
+src[0].channels()-1, the second input image channels are indexed from
+src[0].channels() to src[0].channels() + src[1].channels()-1, and so on, the
+same scheme is used for the output image channels; as a special case, when
+fromTo[k\*2] is negative, the corresponding output channel is filled with zero .
+@param npairs number of index pairs in `fromTo`.
+@sa split, merge, extractChannel, insertChannel, cvtColor
+*/
+CV_EXPORTS void mixChannels(const Mat *src, size_t nsrcs, Mat *dst,
+                            size_t ndsts, const int *fromTo, size_t npairs);
+
+/** @overload
+@param src input array or vector of matrices; all of the matrices must have the
+same size and the same depth.
+@param dst output array or vector of matrices; all the matrices **must be
+allocated**; their size and depth must be the same as in src[0].
+@param fromTo array of index pairs specifying which channels are copied and
+where; fromTo[k\*2] is a 0-based index of the input channel in src,
+fromTo[k\*2+1] is an index of the output channel in dst; the continuous channel
+numbering is used: the first input image channels are indexed from 0 to
+src[0].channels()-1, the second input image channels are indexed from
+src[0].channels() to src[0].channels() + src[1].channels()-1, and so on, the
+same scheme is used for the output image channels; as a special case, when
+fromTo[k\*2] is negative, the corresponding output channel is filled with zero .
+@param npairs number of index pairs in fromTo.
+*/
+CV_EXPORTS void mixChannels(InputArrayOfArrays src,
+                            InputOutputArrayOfArrays dst, const int *fromTo,
+                            size_t npairs);
+
+/** @overload
+@param src input array or vector of matrices; all of the matrices must have the
+same size and the same depth.
+@param dst output array or vector of matrices; all the matrices **must be
+allocated**; their size and depth must be the same as in src[0].
+@param fromTo array of index pairs specifying which channels are copied and
+where; fromTo[k\*2] is a 0-based index of the input channel in src,
+fromTo[k\*2+1] is an index of the output channel in dst; the continuous channel
+numbering is used: the first input image channels are indexed from 0 to
+src[0].channels()-1, the second input image channels are indexed from
+src[0].channels() to src[0].channels() + src[1].channels()-1, and so on, the
+same scheme is used for the output image channels; as a special case, when
+fromTo[k\*2] is negative, the corresponding output channel is filled with zero .
+*/
+CV_EXPORTS_W void mixChannels(InputArrayOfArrays src,
+                              InputOutputArrayOfArrays dst,
+                              const std::vector<int> &fromTo);
+
+/** @brief Extracts a single channel from src (coi is 0-based index)
+@param src input array
+@param dst output array
+@param coi index of channel to extract
+@sa mixChannels, split
+*/
+CV_EXPORTS_W void extractChannel(InputArray src, OutputArray dst, int coi);
+
+/** @brief Inserts a single channel to dst (coi is 0-based index)
+@param src input array
+@param dst output array
+@param coi index of channel for insertion
+@sa mixChannels, merge
+*/
+CV_EXPORTS_W void insertChannel(InputArray src, InputOutputArray dst, int coi);
+
+/** @brief Flips a 2D array around vertical, horizontal, or both axes.
+
+The function cv::flip flips the array in one of three different ways (row
+and column indices are 0-based):
+\f[\texttt{dst} _{ij} =
+\left\{
+\begin{array}{l l}
+\texttt{src} _{\texttt{src.rows}-i-1,j} & if\;  \texttt{flipCode} = 0 \\
+\texttt{src} _{i, \texttt{src.cols} -j-1} & if\;  \texttt{flipCode} > 0 \\
+\texttt{src} _{ \texttt{src.rows} -i-1, \texttt{src.cols} -j-1} & if\;
+\texttt{flipCode} < 0 \\
+\end{array}
+\right.\f]
+The example scenarios of using the function are the following:
+*   Vertical flipping of the image (flipCode == 0) to switch between
+    top-left and bottom-left image origin. This is a typical operation
+    in video processing on Microsoft Windows\* OS.
+*   Horizontal flipping of the image with the subsequent horizontal
+    shift and absolute difference calculation to check for a
+    vertical-axis symmetry (flipCode \> 0).
+*   Simultaneous horizontal and vertical flipping of the image with
+    the subsequent shift and absolute difference calculation to check
+    for a central symmetry (flipCode \< 0).
+*   Reversing the order of point arrays (flipCode \> 0 or
+    flipCode == 0).
+@param src input array.
+@param dst output array of the same size and type as src.
+@param flipCode a flag to specify how to flip the array; 0 means
+flipping around the x-axis and positive value (for example, 1) means
+flipping around y-axis. Negative value (for example, -1) means flipping
+around both axes.
+@sa transpose, repeat, completeSymm
+*/
+CV_EXPORTS_W void flip(InputArray src, OutputArray dst, int flipCode);
+
+/** @brief Flips a n-dimensional at given axis
+ *  @param src input array
+ *  @param dst output array that has the same shape of src
+ *  @param axis axis that performs a flip on. 0 <= axis < src.dims.
+ */
+CV_EXPORTS_W void flipND(InputArray src, OutputArray dst, int axis);
+
+/** @brief Broadcast the given Mat to the given shape.
+ * @param src input array
+ * @param shape target shape. Should be a list of CV_32S numbers. Note that
+ * negative values are not supported.
+ * @param dst output array that has the given shape
+ */
+CV_EXPORTS_W void broadcast(InputArray src, InputArray shape, OutputArray dst);
+
+enum RotateFlags {
+  ROTATE_90_CLOCKWISE = 0,        //!< Rotate 90 degrees clockwise
+  ROTATE_180 = 1,                 //!< Rotate 180 degrees clockwise
+  ROTATE_90_COUNTERCLOCKWISE = 2, //!< Rotate 270 degrees clockwise
+};
+/** @brief Rotates a 2D array in multiples of 90 degrees.
+The function cv::rotate rotates the array in one of three different ways:
+*   Rotate by 90 degrees clockwise (rotateCode = ROTATE_90_CLOCKWISE).
+*   Rotate by 180 degrees clockwise (rotateCode = ROTATE_180).
+*   Rotate by 270 degrees clockwise (rotateCode = ROTATE_90_COUNTERCLOCKWISE).
+@param src input array.
+@param dst output array of the same type as src.  The size is the same with
+ROTATE_180, and the rows and cols are switched for ROTATE_90_CLOCKWISE and
+ROTATE_90_COUNTERCLOCKWISE.
+@param rotateCode an enum to specify how to rotate the array; see the enum
+#RotateFlags
+@sa transpose, repeat, completeSymm, flip, RotateFlags
+*/
+CV_EXPORTS_W void rotate(InputArray src, OutputArray dst, int rotateCode);
+
+/** @brief Fills the output array with repeated copies of the input array.
+
+The function cv::repeat duplicates the input array one or more times along each
+of the two axes:
+\f[\texttt{dst} _{ij}= \texttt{src} _{i\mod src.rows, \; j\mod src.cols }\f]
+The second variant of the function is more convenient to use with @ref
+MatrixExpressions.
+@param src input array to replicate.
+@param ny Flag to specify how many times the `src` is repeated along the
+vertical axis.
+@param nx Flag to specify how many times the `src` is repeated along the
+horizontal axis.
+@param dst output array of the same type as `src`.
+@sa cv::reduce
+*/
+CV_EXPORTS_W void repeat(InputArray src, int ny, int nx, OutputArray dst);
+
+/** @overload
+@param src input array to replicate.
+@param ny Flag to specify how many times the `src` is repeated along the
+vertical axis.
+@param nx Flag to specify how many times the `src` is repeated along the
+horizontal axis.
+  */
+CV_EXPORTS Mat repeat(const Mat &src, int ny, int nx);
+
+/** @brief Applies horizontal concatenation to given matrices.
+
+The function horizontally concatenates two or more cv::Mat matrices (with the
+same number of rows).
+@code{.cpp}
+    cv::Mat matArray[] = { cv::Mat(4, 1, CV_8UC1, cv::Scalar(1)),
+                           cv::Mat(4, 1, CV_8UC1, cv::Scalar(2)),
+                           cv::Mat(4, 1, CV_8UC1, cv::Scalar(3)),};
+
+    cv::Mat out;
+    cv::hconcat( matArray, 3, out );
+    //out:
+    //[1, 2, 3;
+    // 1, 2, 3;
+    // 1, 2, 3;
+    // 1, 2, 3]
+@endcode
+@param src input array or vector of matrices. all of the matrices must have the
+same number of rows and the same depth.
+@param nsrc number of matrices in src.
+@param dst output array. It has the same number of rows and depth as the src,
+and the sum of cols of the src.
+@sa cv::vconcat(const Mat*, size_t, OutputArray), @sa
+cv::vconcat(InputArrayOfArrays, OutputArray) and @sa cv::vconcat(InputArray,
+InputArray, OutputArray)
+*/
+CV_EXPORTS void hconcat(const Mat *src, size_t nsrc, OutputArray dst);
+/** @overload
+ @code{.cpp}
+    cv::Mat_<float> A = (cv::Mat_<float>(3, 2) << 1, 4,
+                                                  2, 5,
+                                                  3, 6);
+    cv::Mat_<float> B = (cv::Mat_<float>(3, 2) << 7, 10,
+                                                  8, 11,
+                                                  9, 12);
+
+    cv::Mat C;
+    cv::hconcat(A, B, C);
+    //C:
+    //[1, 4, 7, 10;
+    // 2, 5, 8, 11;
+    // 3, 6, 9, 12]
+ @endcode
+ @param src1 first input array to be considered for horizontal concatenation.
+ @param src2 second input array to be considered for horizontal concatenation.
+ @param dst output array. It has the same number of rows and depth as the src1
+ and src2, and the sum of cols of the src1 and src2.
+ */
+CV_EXPORTS void hconcat(InputArray src1, InputArray src2, OutputArray dst);
+/** @overload
+ @code{.cpp}
+    std::vector<cv::Mat> matrices = { cv::Mat(4, 1, CV_8UC1, cv::Scalar(1)),
+                                      cv::Mat(4, 1, CV_8UC1, cv::Scalar(2)),
+                                      cv::Mat(4, 1, CV_8UC1, cv::Scalar(3)),};
+
+    cv::Mat out;
+    cv::hconcat( matrices, out );
+    //out:
+    //[1, 2, 3;
+    // 1, 2, 3;
+    // 1, 2, 3;
+    // 1, 2, 3]
+ @endcode
+ @param src input array or vector of matrices. all of the matrices must have the
+same number of rows and the same depth.
+ @param dst output array. It has the same number of rows and depth as the src,
+and the sum of cols of the src. same depth.
+ */
+CV_EXPORTS_W void hconcat(InputArrayOfArrays src, OutputArray dst);
+
+/** @brief Applies vertical concatenation to given matrices.
+
+The function vertically concatenates two or more cv::Mat matrices (with the same
+number of cols).
+@code{.cpp}
+    cv::Mat matArray[] = { cv::Mat(1, 4, CV_8UC1, cv::Scalar(1)),
+                           cv::Mat(1, 4, CV_8UC1, cv::Scalar(2)),
+                           cv::Mat(1, 4, CV_8UC1, cv::Scalar(3)),};
+
+    cv::Mat out;
+    cv::vconcat( matArray, 3, out );
+    //out:
+    //[1,   1,   1,   1;
+    // 2,   2,   2,   2;
+    // 3,   3,   3,   3]
+@endcode
+@param src input array or vector of matrices. all of the matrices must have the
+same number of cols and the same depth.
+@param nsrc number of matrices in src.
+@param dst output array. It has the same number of cols and depth as the src,
+and the sum of rows of the src.
+@sa cv::hconcat(const Mat*, size_t, OutputArray), @sa
+cv::hconcat(InputArrayOfArrays, OutputArray) and @sa cv::hconcat(InputArray,
+InputArray, OutputArray)
+*/
+CV_EXPORTS void vconcat(const Mat *src, size_t nsrc, OutputArray dst);
+/** @overload
+ @code{.cpp}
+    cv::Mat_<float> A = (cv::Mat_<float>(3, 2) << 1, 7,
+                                                  2, 8,
+                                                  3, 9);
+    cv::Mat_<float> B = (cv::Mat_<float>(3, 2) << 4, 10,
+                                                  5, 11,
+                                                  6, 12);
+
+    cv::Mat C;
+    cv::vconcat(A, B, C);
+    //C:
+    //[1, 7;
+    // 2, 8;
+    // 3, 9;
+    // 4, 10;
+    // 5, 11;
+    // 6, 12]
+ @endcode
+ @param src1 first input array to be considered for vertical concatenation.
+ @param src2 second input array to be considered for vertical concatenation.
+ @param dst output array. It has the same number of cols and depth as the src1
+ and src2, and the sum of rows of the src1 and src2.
+ */
+CV_EXPORTS void vconcat(InputArray src1, InputArray src2, OutputArray dst);
+/** @overload
+ @code{.cpp}
+    std::vector<cv::Mat> matrices = { cv::Mat(1, 4, CV_8UC1, cv::Scalar(1)),
+                                      cv::Mat(1, 4, CV_8UC1, cv::Scalar(2)),
+                                      cv::Mat(1, 4, CV_8UC1, cv::Scalar(3)),};
+
+    cv::Mat out;
+    cv::vconcat( matrices, out );
+    //out:
+    //[1,   1,   1,   1;
+    // 2,   2,   2,   2;
+    // 3,   3,   3,   3]
+ @endcode
+ @param src input array or vector of matrices. all of the matrices must have the
+same number of cols and the same depth
+ @param dst output array. It has the same number of cols and depth as the src,
+and the sum of rows of the src. same depth.
+ */
+CV_EXPORTS_W void vconcat(InputArrayOfArrays src, OutputArray dst);
+
+/** @brief computes bitwise conjunction of the two arrays (dst = src1 & src2)
+Calculates the per-element bit-wise conjunction of two arrays or an
+array and a scalar.
+
+The function cv::bitwise_and calculates the per-element bit-wise logical
+conjunction for:
+*   Two arrays when src1 and src2 have the same size:
+    \f[\texttt{dst} (I) =  \texttt{src1} (I)  \wedge \texttt{src2} (I) \quad
+\texttt{if mask} (I) \ne0\f]
+*   An array and a scalar when src2 is constructed from Scalar or has
+    the same number of elements as `src1.channels()`:
+    \f[\texttt{dst} (I) =  \texttt{src1} (I)  \wedge \texttt{src2} \quad
+\texttt{if mask} (I) \ne0\f]
+*   A scalar and an array when src1 is constructed from Scalar or has
+    the same number of elements as `src2.channels()`:
+    \f[\texttt{dst} (I) =  \texttt{src1}  \wedge \texttt{src2} (I) \quad
+\texttt{if mask} (I) \ne0\f] In case of floating-point arrays, their
+machine-specific bit representations (usually IEEE754-compliant) are used for
+the operation. In case of multi-channel arrays, each channel is processed
+independently. In the second and third cases above, the scalar is first
+converted to the array type.
+@param src1 first input array or a scalar.
+@param src2 second input array or a scalar.
+@param dst output array that has the same size and type as the input
+arrays.
+@param mask optional operation mask, 8-bit single channel array, that
+specifies elements of the output array to be changed.
+*/
+CV_EXPORTS_W void bitwise_and(InputArray src1, InputArray src2, OutputArray dst,
+                              InputArray mask = noArray());
+
+/** @brief Calculates the per-element bit-wise disjunction of two arrays or an
+array and a scalar.
+
+The function cv::bitwise_or calculates the per-element bit-wise logical
+disjunction for:
+*   Two arrays when src1 and src2 have the same size:
+    \f[\texttt{dst} (I) =  \texttt{src1} (I)  \vee \texttt{src2} (I) \quad
+\texttt{if mask} (I) \ne0\f]
+*   An array and a scalar when src2 is constructed from Scalar or has
+    the same number of elements as `src1.channels()`:
+    \f[\texttt{dst} (I) =  \texttt{src1} (I)  \vee \texttt{src2} \quad
+\texttt{if mask} (I) \ne0\f]
+*   A scalar and an array when src1 is constructed from Scalar or has
+    the same number of elements as `src2.channels()`:
+    \f[\texttt{dst} (I) =  \texttt{src1}  \vee \texttt{src2} (I) \quad
+\texttt{if mask} (I) \ne0\f] In case of floating-point arrays, their
+machine-specific bit representations (usually IEEE754-compliant) are used for
+the operation. In case of multi-channel arrays, each channel is processed
+independently. In the second and third cases above, the scalar is first
+converted to the array type.
+@param src1 first input array or a scalar.
+@param src2 second input array or a scalar.
+@param dst output array that has the same size and type as the input
+arrays.
+@param mask optional operation mask, 8-bit single channel array, that
+specifies elements of the output array to be changed.
+*/
+CV_EXPORTS_W void bitwise_or(InputArray src1, InputArray src2, OutputArray dst,
+                             InputArray mask = noArray());
+
+/** @brief Calculates the per-element bit-wise "exclusive or" operation on two
+arrays or an array and a scalar.
+
+The function cv::bitwise_xor calculates the per-element bit-wise logical
+"exclusive-or" operation for:
+*   Two arrays when src1 and src2 have the same size:
+    \f[\texttt{dst} (I) =  \texttt{src1} (I)  \oplus \texttt{src2} (I) \quad
+\texttt{if mask} (I) \ne0\f]
+*   An array and a scalar when src2 is constructed from Scalar or has
+    the same number of elements as `src1.channels()`:
+    \f[\texttt{dst} (I) =  \texttt{src1} (I)  \oplus \texttt{src2} \quad
+\texttt{if mask} (I) \ne0\f]
+*   A scalar and an array when src1 is constructed from Scalar or has
+    the same number of elements as `src2.channels()`:
+    \f[\texttt{dst} (I) =  \texttt{src1}  \oplus \texttt{src2} (I) \quad
+\texttt{if mask} (I) \ne0\f] In case of floating-point arrays, their
+machine-specific bit representations (usually IEEE754-compliant) are used for
+the operation. In case of multi-channel arrays, each channel is processed
+independently. In the 2nd and 3rd cases above, the scalar is first
+converted to the array type.
+@param src1 first input array or a scalar.
+@param src2 second input array or a scalar.
+@param dst output array that has the same size and type as the input
+arrays.
+@param mask optional operation mask, 8-bit single channel array, that
+specifies elements of the output array to be changed.
+*/
+CV_EXPORTS_W void bitwise_xor(InputArray src1, InputArray src2, OutputArray dst,
+                              InputArray mask = noArray());
+
+/** @brief  Inverts every bit of an array.
+
+The function cv::bitwise_not calculates per-element bit-wise inversion of the
+input array:
+\f[\texttt{dst} (I) =  \neg \texttt{src} (I)\f]
+In case of a floating-point input array, its machine-specific bit
+representation (usually IEEE754-compliant) is used for the operation. In
+case of multi-channel arrays, each channel is processed independently.
+@param src input array.
+@param dst output array that has the same size and type as the input
+array.
+@param mask optional operation mask, 8-bit single channel array, that
+specifies elements of the output array to be changed.
+*/
+CV_EXPORTS_W void bitwise_not(InputArray src, OutputArray dst,
+                              InputArray mask = noArray());
+
+/** @brief Calculates the per-element absolute difference between two arrays or
+between an array and a scalar.
+
+The function cv::absdiff calculates:
+*   Absolute difference between two arrays when they have the same
+    size and type:
+    \f[\texttt{dst}(I) =  \texttt{saturate} (| \texttt{src1}(I) -
+\texttt{src2}(I)|)\f]
+*   Absolute difference between an array and a scalar when the second
+    array is constructed from Scalar or has as many elements as the
+    number of channels in `src1`:
+    \f[\texttt{dst}(I) =  \texttt{saturate} (| \texttt{src1}(I) -  \texttt{src2}
+|)\f]
+*   Absolute difference between a scalar and an array when the first
+    array is constructed from Scalar or has as many elements as the
+    number of channels in `src2`:
+    \f[\texttt{dst}(I) =  \texttt{saturate} (| \texttt{src1} -  \texttt{src2}(I)
+|)\f] where I is a multi-dimensional index of array elements. In case of
+    multi-channel arrays, each channel is processed independently.
+@note Saturation is not applied when the arrays have the depth CV_32S.
+You may even get a negative value in the case of overflow.
+@note (Python) Be careful to difference behaviour between src1/src2 are single
+number and they are tuple/array. `absdiff(src,X)` means
+`absdiff(src,(X,X,X,X))`. `absdiff(src,(X,))` means `absdiff(src,(X,0,0,0))`.
+@param src1 first input array or a scalar.
+@param src2 second input array or a scalar.
+@param dst output array that has the same size and type as input arrays.
+@sa cv::abs(const Mat&)
+*/
+CV_EXPORTS_W void absdiff(InputArray src1, InputArray src2, OutputArray dst);
+
+/** @brief  This is an overloaded member function, provided for convenience
+(python) Copies the matrix to another one. When the operation mask is specified,
+if the Mat::create call shown above reallocates the matrix, the newly allocated
+matrix is initialized with all zeros before copying the data.
+@param src source matrix.
+@param dst Destination matrix. If it does not have a proper size or type before
+the operation, it is reallocated.
+@param mask Operation mask of the same size as \*this. Its non-zero elements
+indicate which matrix elements need to be copied. The mask has to be of type
+CV_8U and can have 1 or multiple channels.
+*/
+
+void CV_EXPORTS_W copyTo(InputArray src, OutputArray dst, InputArray mask);
+/** @brief  Checks if array elements lie between the elements of two other
+arrays.
+
+The function checks the range as follows:
+-   For every element of a single-channel input array:
+    \f[\texttt{dst} (I)= \texttt{lowerb} (I)_0  \leq \texttt{src} (I)_0 \leq
+\texttt{upperb} (I)_0\f]
+-   For two-channel arrays:
+    \f[\texttt{dst} (I)= \texttt{lowerb} (I)_0  \leq \texttt{src} (I)_0 \leq
+\texttt{upperb} (I)_0  \land \texttt{lowerb} (I)_1  \leq \texttt{src} (I)_1 \leq
+\texttt{upperb} (I)_1\f]
+-   and so forth.
+
+That is, dst (I) is set to 255 (all 1 -bits) if src (I) is within the
+specified 1D, 2D, 3D, ... box and 0 otherwise.
+
+When the lower and/or upper boundary parameters are scalars, the indexes
+(I) at lowerb and upperb in the above formulas should be omitted.
+@param src first input array.
+@param lowerb inclusive lower boundary array or a scalar.
+@param upperb inclusive upper boundary array or a scalar.
+@param dst output array of the same size as src and CV_8U type.
+*/
+CV_EXPORTS_W void inRange(InputArray src, InputArray lowerb, InputArray upperb,
+                          OutputArray dst);
+
+/** @brief Performs the per-element comparison of two arrays or an array and
+scalar value.
+
+The function compares:
+*   Elements of two arrays when src1 and src2 have the same size:
+    \f[\texttt{dst} (I) =  \texttt{src1} (I)  \,\texttt{cmpop}\, \texttt{src2}
+(I)\f]
+*   Elements of src1 with a scalar src2 when src2 is constructed from
+    Scalar or has a single element:
+    \f[\texttt{dst} (I) =  \texttt{src1}(I) \,\texttt{cmpop}\,  \texttt{src2}\f]
+*   src1 with elements of src2 when src1 is constructed from Scalar or
+    has a single element:
+    \f[\texttt{dst} (I) =  \texttt{src1}  \,\texttt{cmpop}\, \texttt{src2}
+(I)\f] When the comparison result is true, the corresponding element of output
+array is set to 255. The comparison operations can be replaced with the
+equivalent matrix expressions:
+@code{.cpp}
+    Mat dst1 = src1 >= src2;
+    Mat dst2 = src1 < 8;
+    ...
+@endcode
+@param src1 first input array or a scalar; when it is an array, it must have a
+single channel.
+@param src2 second input array or a scalar; when it is an array, it must have a
+single channel.
+@param dst output array of type ref CV_8U that has the same size and the same
+number of channels as the input arrays.
+@param cmpop a flag, that specifies correspondence between the arrays
+(cv::CmpTypes)
+@sa checkRange, min, max, threshold
+*/
+CV_EXPORTS_W void compare(InputArray src1, InputArray src2, OutputArray dst,
+                          int cmpop);
+
+/** @brief Calculates per-element minimum of two arrays or an array and a
+scalar.
+
+The function cv::min calculates the per-element minimum of two arrays:
+\f[\texttt{dst} (I)= \min ( \texttt{src1} (I), \texttt{src2} (I))\f]
+or array and a scalar:
+\f[\texttt{dst} (I)= \min ( \texttt{src1} (I), \texttt{value} )\f]
+@param src1 first input array.
+@param src2 second input array of the same size and type as src1.
+@param dst output array of the same size and type as src1.
+@sa max, compare, inRange, minMaxLoc
+*/
+CV_EXPORTS_W void min(InputArray src1, InputArray src2, OutputArray dst);
+/** @overload
+needed to avoid conflicts with const _Tp& std::min(const _Tp&, const _Tp&,
+_Compare)
+*/
+CV_EXPORTS void min(const Mat &src1, const Mat &src2, Mat &dst);
+
+/** @brief Calculates per-element maximum of two arrays or an array and a
+scalar.
+
+The function cv::max calculates the per-element maximum of two arrays:
+\f[\texttt{dst} (I)= \max ( \texttt{src1} (I), \texttt{src2} (I))\f]
+or array and a scalar:
+\f[\texttt{dst} (I)= \max ( \texttt{src1} (I), \texttt{value} )\f]
+@param src1 first input array.
+@param src2 second input array of the same size and type as src1 .
+@param dst output array of the same size and type as src1.
+@sa  min, compare, inRange, minMaxLoc, @ref MatrixExpressions
+*/
+CV_EXPORTS_W void max(InputArray src1, InputArray src2, OutputArray dst);
+/** @overload
+needed to avoid conflicts with const _Tp& std::min(const _Tp&, const _Tp&,
+_Compare)
+*/
+CV_EXPORTS void max(const Mat &src1, const Mat &src2, Mat &dst);
+
+/** @brief Calculates a square root of array elements.
+
+The function cv::sqrt calculates a square root of each input array element.
+In case of multi-channel arrays, each channel is processed
+independently. The accuracy is approximately the same as of the built-in
+std::sqrt .
+@param src input floating-point array.
+@param dst output array of the same size and type as src.
+*/
+CV_EXPORTS_W void sqrt(InputArray src, OutputArray dst);
+
+/** @brief Raises every array element to a power.
+
+The function cv::pow raises every element of the input array to power :
+\f[\texttt{dst} (I) =  \fork{\texttt{src}(I)^{power}}{if \(\texttt{power}\) is
+integer}{|\texttt{src}(I)|^{power}}{otherwise}\f]
+
+So, for a non-integer power exponent, the absolute values of input array
+elements are used. However, it is possible to get true values for
+negative values using some extra operations. In the example below,
+computing the 5th root of array src shows:
+@code{.cpp}
+    Mat mask = src < 0;
+    pow(src, 1./5, dst);
+    subtract(Scalar::all(0), dst, dst, mask);
+@endcode
+For some values of power, such as integer values, 0.5 and -0.5,
+specialized faster algorithms are used.
+
+Special values (NaN, Inf) are not handled.
+@param src input array.
+@param power exponent of power.
+@param dst output array of the same size and type as src.
+@sa sqrt, exp, log, cartToPolar, polarToCart
+*/
+CV_EXPORTS_W void pow(InputArray src, double power, OutputArray dst);
+
+/** @brief Calculates the exponent of every array element.
+
+The function cv::exp calculates the exponent of every element of the input
+array:
+\f[\texttt{dst} [I] = e^{ src(I) }\f]
+
+The maximum relative error is about 7e-6 for single-precision input and
+less than 1e-10 for double-precision input. Currently, the function
+converts denormalized values to zeros on output. Special values (NaN,
+Inf) are not handled.
+@param src input array.
+@param dst output array of the same size and type as src.
+@sa log, cartToPolar, polarToCart, phase, pow, sqrt, magnitude
+*/
+CV_EXPORTS_W void exp(InputArray src, OutputArray dst);
+
+/** @brief Calculates the natural logarithm of every array element.
+
+The function cv::log calculates the natural logarithm of every element of the
+input array:
+\f[\texttt{dst} (I) =  \log (\texttt{src}(I)) \f]
+
+Output on zero, negative and special (NaN, Inf) values is undefined.
+
+@param src input array.
+@param dst output array of the same size and type as src .
+@sa exp, cartToPolar, polarToCart, phase, pow, sqrt, magnitude
+*/
+CV_EXPORTS_W void log(InputArray src, OutputArray dst);
+
+/** @brief Calculates x and y coordinates of 2D vectors from their magnitude and
+angle.
+
+The function cv::polarToCart calculates the Cartesian coordinates of each 2D
+vector represented by the corresponding elements of magnitude and angle:
+\f[\begin{array}{l} \texttt{x} (I) =  \texttt{magnitude} (I) \cos (
+\texttt{angle} (I)) \\ \texttt{y} (I) =  \texttt{magnitude} (I) \sin (
+\texttt{angle} (I)) \\ \end{array}\f]
+
+The relative accuracy of the estimated coordinates is about 1e-6.
+@param magnitude input floating-point array of magnitudes of 2D vectors;
+it can be an empty matrix (=Mat()), in this case, the function assumes
+that all the magnitudes are =1; if it is not empty, it must have the
+same size and type as angle.
+@param angle input floating-point array of angles of 2D vectors.
+@param x output array of x-coordinates of 2D vectors; it has the same
+size and type as angle.
+@param y output array of y-coordinates of 2D vectors; it has the same
+size and type as angle.
+@param angleInDegrees when true, the input angles are measured in
+degrees, otherwise, they are measured in radians.
+@sa cartToPolar, magnitude, phase, exp, log, pow, sqrt
+*/
+CV_EXPORTS_W void polarToCart(InputArray magnitude, InputArray angle,
+                              OutputArray x, OutputArray y,
+                              bool angleInDegrees = false);
+
+/** @brief Calculates the magnitude and angle of 2D vectors.
+
+The function cv::cartToPolar calculates either the magnitude, angle, or both
+for every 2D vector (x(I),y(I)):
+\f[\begin{array}{l} \texttt{magnitude} (I)=
+\sqrt{\texttt{x}(I)^2+\texttt{y}(I)^2} , \\ \texttt{angle} (I)= \texttt{atan2} (
+\texttt{y} (I), \texttt{x} (I))[ \cdot180 / \pi ] \end{array}\f]
+
+The angles are calculated with accuracy about 0.3 degrees. For the point
+(0,0), the angle is set to 0.
+@param x array of x-coordinates; this must be a single-precision or
+double-precision floating-point array.
+@param y array of y-coordinates, that must have the same size and same type as
+x.
+@param magnitude output array of magnitudes of the same size and type as x.
+@param angle output array of angles that has the same size and type as
+x; the angles are measured in radians (from 0 to 2\*Pi) or in degrees (0 to 360
+degrees).
+@param angleInDegrees a flag, indicating whether the angles are measured
+in radians (which is by default), or in degrees.
+@sa Sobel, Scharr
+*/
+CV_EXPORTS_W void cartToPolar(InputArray x, InputArray y, OutputArray magnitude,
+                              OutputArray angle, bool angleInDegrees = false);
+
+/** @brief Calculates the rotation angle of 2D vectors.
+
+The function cv::phase calculates the rotation angle of each 2D vector that
+is formed from the corresponding elements of x and y :
+\f[\texttt{angle} (I) =  \texttt{atan2} ( \texttt{y} (I), \texttt{x} (I))\f]
+
+The angle estimation accuracy is about 0.3 degrees. When x(I)=y(I)=0 ,
+the corresponding angle(I) is set to 0.
+@param x input floating-point array of x-coordinates of 2D vectors.
+@param y input array of y-coordinates of 2D vectors; it must have the
+same size and the same type as x.
+@param angle output array of vector angles; it has the same size and
+same type as x .
+@param angleInDegrees when true, the function calculates the angle in
+degrees, otherwise, they are measured in radians.
+*/
+CV_EXPORTS_W void phase(InputArray x, InputArray y, OutputArray angle,
+                        bool angleInDegrees = false);
+
+/** @brief Calculates the magnitude of 2D vectors.
+
+The function cv::magnitude calculates the magnitude of 2D vectors formed
+from the corresponding elements of x and y arrays:
+\f[\texttt{dst} (I) =  \sqrt{\texttt{x}(I)^2 + \texttt{y}(I)^2}\f]
+@param x floating-point array of x-coordinates of the vectors.
+@param y floating-point array of y-coordinates of the vectors; it must
+have the same size as x.
+@param magnitude output array of the same size and type as x.
+@sa cartToPolar, polarToCart, phase, sqrt
+*/
+CV_EXPORTS_W void magnitude(InputArray x, InputArray y, OutputArray magnitude);
+
+/** @brief Checks every element of an input array for invalid values.
+
+The function cv::checkRange checks that every array element is neither NaN nor
+infinite. When minVal \> -DBL_MAX and maxVal \< DBL_MAX, the function also
+checks that each value is between minVal and maxVal. In case of multi-channel
+arrays, each channel is processed independently. If some values are out of
+range, position of the first outlier is stored in pos (when pos != NULL). Then,
+the function either returns false (when quiet=true) or throws an exception.
+@param a input array.
+@param quiet a flag, indicating whether the functions quietly return false when
+the array elements are out of range or they throw an exception.
+@param pos optional output parameter, when not NULL, must be a pointer to array
+of src.dims elements.
+@param minVal inclusive lower boundary of valid values range.
+@param maxVal exclusive upper boundary of valid values range.
+*/
+CV_EXPORTS_W bool checkRange(InputArray a, bool quiet = true,
+                             CV_OUT Point *pos = 0, double minVal = -DBL_MAX,
+                             double maxVal = DBL_MAX);
+
+/** @brief Replaces NaNs by given number
+@param a input/output matrix (CV_32F type).
+@param val value to convert the NaNs
+*/
+CV_EXPORTS_W void patchNaNs(InputOutputArray a, double val = 0);
+
+/** @brief Performs generalized matrix multiplication.
+
+The function cv::gemm performs generalized matrix multiplication similar to the
+gemm functions in BLAS level 3. For example,
+`gemm(src1, src2, alpha, src3, beta, dst, GEMM_1_T + GEMM_3_T)`
+corresponds to
+\f[\texttt{dst} =  \texttt{alpha} \cdot \texttt{src1} ^T  \cdot \texttt{src2} +
+\texttt{beta} \cdot \texttt{src3} ^T\f]
+
+In case of complex (two-channel) data, performed a complex matrix
+multiplication.
+
+The function can be replaced with a matrix expression. For example, the
+above call can be replaced with:
+@code{.cpp}
+    dst = alpha*src1.t()*src2 + beta*src3.t();
+@endcode
+@param src1 first multiplied input matrix that could be real(CV_32FC1,
+CV_64FC1) or complex(CV_32FC2, CV_64FC2).
+@param src2 second multiplied input matrix of the same type as src1.
+@param alpha weight of the matrix product.
+@param src3 third optional delta matrix added to the matrix product; it
+should have the same type as src1 and src2.
+@param beta weight of src3.
+@param dst output matrix; it has the proper size and the same type as
+input matrices.
+@param flags operation flags (cv::GemmFlags)
+@sa mulTransposed, transform
+*/
+CV_EXPORTS_W void gemm(InputArray src1, InputArray src2, double alpha,
+                       InputArray src3, double beta, OutputArray dst,
+                       int flags = 0);
+
+/** @brief Calculates the product of a matrix and its transposition.
+
+The function cv::mulTransposed calculates the product of src and its
+transposition:
+\f[\texttt{dst} = \texttt{scale} ( \texttt{src} - \texttt{delta} )^T (
+\texttt{src} - \texttt{delta} )\f] if aTa=true, and
+\f[\texttt{dst} = \texttt{scale} ( \texttt{src} - \texttt{delta} ) (
+\texttt{src} - \texttt{delta} )^T\f] otherwise. The function is used to
+calculate the covariance matrix. With zero delta, it can be used as a faster
+substitute for general matrix product A\*B when B=A'
+@param src input single-channel matrix. Note that unlike gemm, the
+function can multiply not only floating-point matrices.
+@param dst output square matrix.
+@param aTa Flag specifying the multiplication ordering. See the
+description below.
+@param delta Optional delta matrix subtracted from src before the
+multiplication. When the matrix is empty ( delta=noArray() ), it is
+assumed to be zero, that is, nothing is subtracted. If it has the same
+size as src, it is simply subtracted. Otherwise, it is "repeated" (see
+repeat ) to cover the full src and then subtracted. Type of the delta
+matrix, when it is not empty, must be the same as the type of created
+output matrix. See the dtype parameter description below.
+@param scale Optional scale factor for the matrix product.
+@param dtype Optional type of the output matrix. When it is negative,
+the output matrix will have the same type as src . Otherwise, it will be
+type=CV_MAT_DEPTH(dtype) that should be either CV_32F or CV_64F .
+@sa calcCovarMatrix, gemm, repeat, reduce
+*/
+CV_EXPORTS_W void mulTransposed(InputArray src, OutputArray dst, bool aTa,
+                                InputArray delta = noArray(), double scale = 1,
+                                int dtype = -1);
+
+/** @brief Transposes a matrix.
+
+The function cv::transpose transposes the matrix src :
+\f[\texttt{dst} (i,j) =  \texttt{src} (j,i)\f]
+@note No complex conjugation is done in case of a complex matrix. It
+should be done separately if needed.
+@param src input array.
+@param dst output array of the same type as src.
+*/
+CV_EXPORTS_W void transpose(InputArray src, OutputArray dst);
+
+/** @brief Transpose for n-dimensional matrices.
+ *
+ * @note Input should be continuous single-channel matrix.
+ * @param src input array.
+ * @param order a permutation of [0,1,..,N-1] where N is the number of axes of
+ * src. The i'th axis of dst will correspond to the axis numbered order[i] of
+ * the input.
+ * @param dst output array of the same type as src.
+ */
+CV_EXPORTS_W void transposeND(InputArray src, const std::vector<int> &order,
+                              OutputArray dst);
+
+/** @brief Performs the matrix transformation of every array element.
+
+The function cv::transform performs the matrix transformation of every
+element of the array src and stores the results in dst :
+\f[\texttt{dst} (I) =  \texttt{m} \cdot \texttt{src} (I)\f]
+(when m.cols=src.channels() ), or
+\f[\texttt{dst} (I) =  \texttt{m} \cdot [ \texttt{src} (I); 1]\f]
+(when m.cols=src.channels()+1 )
+
+Every element of the N -channel array src is interpreted as N -element
+vector that is transformed using the M x N or M x (N+1) matrix m to
+M-element vector - the corresponding element of the output array dst .
+
+The function may be used for geometrical transformation of
+N -dimensional points, arbitrary linear color space transformation (such
+as various kinds of RGB to YUV transforms), shuffling the image
+channels, and so forth.
+@param src input array that must have as many channels (1 to 4) as
+m.cols or m.cols-1.
+@param dst output array of the same size and depth as src; it has as
+many channels as m.rows.
+@param m transformation 2x2 or 2x3 floating-point matrix.
+@sa perspectiveTransform, getAffineTransform, estimateAffine2D, warpAffine,
+warpPerspective
+*/
+CV_EXPORTS_W void transform(InputArray src, OutputArray dst, InputArray m);
+
+/** @brief Performs the perspective matrix transformation of vectors.
+
+The function cv::perspectiveTransform transforms every element of src by
+treating it as a 2D or 3D vector, in the following way:
+\f[(x, y, z)  \rightarrow (x'/w, y'/w, z'/w)\f]
+where
+\f[(x', y', z', w') =  \texttt{mat} \cdot \begin{bmatrix} x & y & z & 1
+\end{bmatrix}\f] and
+\f[w =  \fork{w'}{if \(w' \ne 0\)}{\infty}{otherwise}\f]
+
+Here a 3D vector transformation is shown. In case of a 2D vector
+transformation, the z component is omitted.
+
+@note The function transforms a sparse set of 2D or 3D vectors. If you
+want to transform an image using perspective transformation, use
+warpPerspective . If you have an inverse problem, that is, you want to
+compute the most probable perspective transformation out of several
+pairs of corresponding points, you can use getPerspectiveTransform or
+findHomography .
+@param src input two-channel or three-channel floating-point array; each
+element is a 2D/3D vector to be transformed.
+@param dst output array of the same size and type as src.
+@param m 3x3 or 4x4 floating-point transformation matrix.
+@sa  transform, warpPerspective, getPerspectiveTransform, findHomography
+*/
+CV_EXPORTS_W void perspectiveTransform(InputArray src, OutputArray dst,
+                                       InputArray m);
+
+/** @brief Copies the lower or the upper half of a square matrix to its another
+half.
+
+The function cv::completeSymm copies the lower or the upper half of a square
+matrix to its another half. The matrix diagonal remains unchanged:
+ - \f$\texttt{m}_{ij}=\texttt{m}_{ji}\f$ for \f$i > j\f$ if
+    lowerToUpper=false
+ - \f$\texttt{m}_{ij}=\texttt{m}_{ji}\f$ for \f$i < j\f$ if
+    lowerToUpper=true
+
+@param m input-output floating-point square matrix.
+@param lowerToUpper operation flag; if true, the lower half is copied to
+the upper half. Otherwise, the upper half is copied to the lower half.
+@sa flip, transpose
+*/
+CV_EXPORTS_W void completeSymm(InputOutputArray m, bool lowerToUpper = false);
+
+/** @brief Initializes a scaled identity matrix.
+
+The function cv::setIdentity initializes a scaled identity matrix:
+\f[\texttt{mtx} (i,j)= \fork{\texttt{value}}{ if \(i=j\)}{0}{otherwise}\f]
+
+The function can also be emulated using the matrix initializers and the
+matrix expressions:
+@code
+    Mat A = Mat::eye(4, 3, CV_32F)*5;
+    // A will be set to [[5, 0, 0], [0, 5, 0], [0, 0, 5], [0, 0, 0]]
+@endcode
+@param mtx matrix to initialize (not necessarily square).
+@param s value to assign to diagonal elements.
+@sa Mat::zeros, Mat::ones, Mat::setTo, Mat::operator=
+*/
+CV_EXPORTS_W void setIdentity(InputOutputArray mtx,
+                              const Scalar &s = Scalar(1));
+
+/** @brief Returns the determinant of a square floating-point matrix.
+
+The function cv::determinant calculates and returns the determinant of the
+specified matrix. For small matrices ( mtx.cols=mtx.rows\<=3 ), the
+direct method is used. For larger matrices, the function uses LU
+factorization with partial pivoting.
+
+For symmetric positively-determined matrices, it is also possible to use
+eigen decomposition to calculate the determinant.
+@param mtx input matrix that must have CV_32FC1 or CV_64FC1 type and
+square size.
+@sa trace, invert, solve, eigen, @ref MatrixExpressions
+*/
+CV_EXPORTS_W double determinant(InputArray mtx);
+
+/** @brief Returns the trace of a matrix.
+
+The function cv::trace returns the sum of the diagonal elements of the
+matrix mtx .
+\f[\mathrm{tr} ( \texttt{mtx} ) =  \sum _i  \texttt{mtx} (i,i)\f]
+@param mtx input matrix.
+*/
+CV_EXPORTS_W Scalar trace(InputArray mtx);
+
+/** @brief Finds the inverse or pseudo-inverse of a matrix.
+
+The function cv::invert inverts the matrix src and stores the result in dst
+. When the matrix src is singular or non-square, the function calculates
+the pseudo-inverse matrix (the dst matrix) so that norm(src\*dst - I) is
+minimal, where I is an identity matrix.
+
+In case of the #DECOMP_LU method, the function returns non-zero value if
+the inverse has been successfully calculated and 0 if src is singular.
+
+In case of the #DECOMP_SVD method, the function returns the inverse
+condition number of src (the ratio of the smallest singular value to the
+largest singular value) and 0 if src is singular. The SVD method
+calculates a pseudo-inverse matrix if src is singular.
+
+Similarly to #DECOMP_LU, the method #DECOMP_CHOLESKY works only with
+non-singular square matrices that should also be symmetrical and
+positively defined. In this case, the function stores the inverted
+matrix in dst and returns non-zero. Otherwise, it returns 0.
+
+@param src input floating-point M x N matrix.
+@param dst output matrix of N x M size and the same type as src.
+@param flags inversion method (cv::DecompTypes)
+@sa solve, SVD
+*/
+CV_EXPORTS_W double invert(InputArray src, OutputArray dst,
+                           int flags = DECOMP_LU);
+
+/** @brief Solves one or more linear systems or least-squares problems.
+
+The function cv::solve solves a linear system or least-squares problem (the
+latter is possible with SVD or QR methods, or by specifying the flag
+#DECOMP_NORMAL ):
+\f[\texttt{dst} =  \arg \min _X \| \texttt{src1} \cdot \texttt{X} -
+\texttt{src2} \|\f]
+
+If #DECOMP_LU or #DECOMP_CHOLESKY method is used, the function returns 1
+if src1 (or \f$\texttt{src1}^T\texttt{src1}\f$ ) is non-singular. Otherwise,
+it returns 0. In the latter case, dst is not valid. Other methods find a
+pseudo-solution in case of a singular left-hand side part.
+
+@note If you want to find a unity-norm solution of an under-defined
+singular system \f$\texttt{src1}\cdot\texttt{dst}=0\f$ , the function solve
+will not do the work. Use SVD::solveZ instead.
+
+@param src1 input matrix on the left-hand side of the system.
+@param src2 input matrix on the right-hand side of the system.
+@param dst output solution.
+@param flags solution (matrix inversion) method (#DecompTypes)
+@sa invert, SVD, eigen
+*/
+CV_EXPORTS_W bool solve(InputArray src1, InputArray src2, OutputArray dst,
+                        int flags = DECOMP_LU);
+
+/** @brief Sorts each row or each column of a matrix.
+
+The function cv::sort sorts each matrix row or each matrix column in
+ascending or descending order. So you should pass two operation flags to
+get desired behaviour. If you want to sort matrix rows or columns
+lexicographically, you can use STL std::sort generic function with the
+proper comparison predicate.
+
+@param src input single-channel array.
+@param dst output array of the same size and type as src.
+@param flags operation flags, a combination of #SortFlags
+@sa sortIdx, randShuffle
+*/
+CV_EXPORTS_W void sort(InputArray src, OutputArray dst, int flags);
+
+/** @brief Sorts each row or each column of a matrix.
+
+The function cv::sortIdx sorts each matrix row or each matrix column in the
+ascending or descending order. So you should pass two operation flags to
+get desired behaviour. Instead of reordering the elements themselves, it
+stores the indices of sorted elements in the output array. For example:
+@code
+    Mat A = Mat::eye(3,3,CV_32F), B;
+    sortIdx(A, B, SORT_EVERY_ROW + SORT_ASCENDING);
+    // B will probably contain
+    // (because of equal elements in A some permutations are possible):
+    // [[1, 2, 0], [0, 2, 1], [0, 1, 2]]
+@endcode
+@param src input single-channel array.
+@param dst output integer array of the same size as src.
+@param flags operation flags that could be a combination of cv::SortFlags
+@sa sort, randShuffle
+*/
+CV_EXPORTS_W void sortIdx(InputArray src, OutputArray dst, int flags);
+
+/** @brief Finds the real roots of a cubic equation.
+
+The function solveCubic finds the real roots of a cubic equation:
+-   if coeffs is a 4-element vector:
+\f[\texttt{coeffs} [0] x^3 +  \texttt{coeffs} [1] x^2 +  \texttt{coeffs} [2] x +
+\texttt{coeffs} [3] = 0\f]
+-   if coeffs is a 3-element vector:
+\f[x^3 +  \texttt{coeffs} [0] x^2 +  \texttt{coeffs} [1] x +  \texttt{coeffs}
+[2] = 0\f]
+
+The roots are stored in the roots array.
+@param coeffs equation coefficients, an array of 3 or 4 elements.
+@param roots output array of real roots that has 1 or 3 elements.
+@return number of real roots. It can be 0, 1 or 2.
+*/
+CV_EXPORTS_W int solveCubic(InputArray coeffs, OutputArray roots);
+
+/** @brief Finds the real or complex roots of a polynomial equation.
+
+The function cv::solvePoly finds real and complex roots of a polynomial
+equation:
+\f[\texttt{coeffs} [n] x^{n} +  \texttt{coeffs} [n-1] x^{n-1} + ... +
+\texttt{coeffs} [1] x +  \texttt{coeffs} [0] = 0\f]
+@param coeffs array of polynomial coefficients.
+@param roots output (complex) array of roots.
+@param maxIters maximum number of iterations the algorithm does.
+*/
+CV_EXPORTS_W double solvePoly(InputArray coeffs, OutputArray roots,
+                              int maxIters = 300);
+
+/** @brief Calculates eigenvalues and eigenvectors of a symmetric matrix.
+
+The function cv::eigen calculates just eigenvalues, or eigenvalues and
+eigenvectors of the symmetric matrix src:
+@code
+    src*eigenvectors.row(i).t() =
+eigenvalues.at<srcType>(i)*eigenvectors.row(i).t()
+@endcode
+
+@note Use cv::eigenNonSymmetric for calculation of real eigenvalues and
+eigenvectors of non-symmetric matrix.
+
+@param src input matrix that must have CV_32FC1 or CV_64FC1 type, square size
+and be symmetrical (src ^T^ == src).
+@param eigenvalues output vector of eigenvalues of the same type as src; the
+eigenvalues are stored in the descending order.
+@param eigenvectors output matrix of eigenvectors; it has the same size and type
+as src; the eigenvectors are stored as subsequent matrix rows, in the same order
+as the corresponding eigenvalues.
+@sa eigenNonSymmetric, completeSymm, PCA
+*/
+CV_EXPORTS_W bool eigen(InputArray src, OutputArray eigenvalues,
+                        OutputArray eigenvectors = noArray());
+
+/** @brief Calculates eigenvalues and eigenvectors of a non-symmetric matrix
+(real eigenvalues only).
+
+@note Assumes real eigenvalues.
+
+The function calculates eigenvalues and eigenvectors (optional) of the square
+matrix src:
+@code
+    src*eigenvectors.row(i).t() =
+eigenvalues.at<srcType>(i)*eigenvectors.row(i).t()
+@endcode
+
+@param src input matrix (CV_32FC1 or CV_64FC1 type).
+@param eigenvalues output vector of eigenvalues (type is the same type as src).
+@param eigenvectors output matrix of eigenvectors (type is the same type as
+src). The eigenvectors are stored as subsequent matrix rows, in the same order
+as the corresponding eigenvalues.
+@sa eigen
+*/
+CV_EXPORTS_W void eigenNonSymmetric(InputArray src, OutputArray eigenvalues,
+                                    OutputArray eigenvectors);
+
+/** @brief Calculates the covariance matrix of a set of vectors.
+
+The function cv::calcCovarMatrix calculates the covariance matrix and,
+optionally, the mean vector of the set of input vectors.
+@param samples samples stored as separate matrices
+@param nsamples number of samples
+@param covar output covariance matrix of the type ctype and square size.
+@param mean input or output (depending on the flags) array as the average value
+of the input vectors.
+@param flags operation flags as a combination of #CovarFlags
+@param ctype type of the matrixl; it equals 'CV_64F' by default.
+@sa PCA, mulTransposed, Mahalanobis
+@todo InputArrayOfArrays
+*/
+CV_EXPORTS void calcCovarMatrix(const Mat *samples, int nsamples, Mat &covar,
+                                Mat &mean, int flags, int ctype = CV_64F);
+
+/** @overload
+@note use #COVAR_ROWS or #COVAR_COLS flag
+@param samples samples stored as rows/columns of a single matrix.
+@param covar output covariance matrix of the type ctype and square size.
+@param mean input or output (depending on the flags) array as the average value
+of the input vectors.
+@param flags operation flags as a combination of #CovarFlags
+@param ctype type of the matrixl; it equals 'CV_64F' by default.
+*/
+CV_EXPORTS_W void calcCovarMatrix(InputArray samples, OutputArray covar,
+                                  InputOutputArray mean, int flags,
+                                  int ctype = CV_64F);
+
+/** wrap PCA::operator() */
+CV_EXPORTS_W void PCACompute(InputArray data, InputOutputArray mean,
+                             OutputArray eigenvectors, int maxComponents = 0);
+
+/** wrap PCA::operator() and add eigenvalues output parameter */
+CV_EXPORTS_AS(PCACompute2)
+void PCACompute(InputArray data, InputOutputArray mean,
+                OutputArray eigenvectors, OutputArray eigenvalues,
+                int maxComponents = 0);
+
+/** wrap PCA::operator() */
+CV_EXPORTS_W void PCACompute(InputArray data, InputOutputArray mean,
+                             OutputArray eigenvectors, double retainedVariance);
+
+/** wrap PCA::operator() and add eigenvalues output parameter */
+CV_EXPORTS_AS(PCACompute2)
+void PCACompute(InputArray data, InputOutputArray mean,
+                OutputArray eigenvectors, OutputArray eigenvalues,
+                double retainedVariance);
+
+/** wrap PCA::project */
+CV_EXPORTS_W void PCAProject(InputArray data, InputArray mean,
+                             InputArray eigenvectors, OutputArray result);
+
+/** wrap PCA::backProject */
+CV_EXPORTS_W void PCABackProject(InputArray data, InputArray mean,
+                                 InputArray eigenvectors, OutputArray result);
+
+/** wrap SVD::compute */
+CV_EXPORTS_W void SVDecomp(InputArray src, OutputArray w, OutputArray u,
+                           OutputArray vt, int flags = 0);
+
+/** wrap SVD::backSubst */
+CV_EXPORTS_W void SVBackSubst(InputArray w, InputArray u, InputArray vt,
+                              InputArray rhs, OutputArray dst);
+
+/** @brief Calculates the Mahalanobis distance between two vectors.
+
+The function cv::Mahalanobis calculates and returns the weighted distance
+between two vectors:
+\f[d( \texttt{vec1} , \texttt{vec2} )=
+\sqrt{\sum_{i,j}{\texttt{icovar(i,j)}\cdot(\texttt{vec1}(I)-\texttt{vec2}(I))\cdot(\texttt{vec1(j)}-\texttt{vec2(j)})}
+}\f] The covariance matrix may be calculated using the #calcCovarMatrix function
+and then inverted using the invert function (preferably using the #DECOMP_SVD
+method, as the most accurate).
+@param v1 first 1D input vector.
+@param v2 second 1D input vector.
+@param icovar inverse covariance matrix.
+*/
+CV_EXPORTS_W double Mahalanobis(InputArray v1, InputArray v2,
+                                InputArray icovar);
+
+/** @brief Performs a forward or inverse Discrete Fourier transform of a 1D or
+2D floating-point array.
+
+The function cv::dft performs one of the following:
+-   Forward the Fourier transform of a 1D vector of N elements:
+    \f[Y = F^{(N)}  \cdot X,\f]
+    where \f$F^{(N)}_{jk}=\exp(-2\pi i j k/N)\f$ and \f$i=\sqrt{-1}\f$
+-   Inverse the Fourier transform of a 1D vector of N elements:
+    \f[\begin{array}{l} X'=  \left (F^{(N)} \right )^{-1}  \cdot Y =  \left
+(F^{(N)} \right )^*  \cdot y  \\ X = (1/N)  \cdot X, \end{array}\f] where
+\f$F^*=\left(\textrm{Re}(F^{(N)})-\textrm{Im}(F^{(N)})\right)^T\f$
+-   Forward the 2D Fourier transform of a M x N matrix:
+    \f[Y = F^{(M)}  \cdot X  \cdot F^{(N)}\f]
+-   Inverse the 2D Fourier transform of a M x N matrix:
+    \f[\begin{array}{l} X'=  \left (F^{(M)} \right )^*  \cdot Y  \cdot \left
+(F^{(N)} \right )^* \\ X =  \frac{1}{M \cdot N} \cdot X' \end{array}\f]
+
+In case of real (single-channel) data, the output spectrum of the forward
+Fourier transform or input spectrum of the inverse Fourier transform can be
+represented in a packed format called *CCS* (complex-conjugate-symmetrical). It
+was borrowed from IPL (Intel\* Image Processing Library). Here is how 2D *CCS*
+spectrum looks:
+\f[\begin{bmatrix} Re Y_{0,0} & Re Y_{0,1} & Im Y_{0,1} & Re Y_{0,2} & Im
+Y_{0,2} &  \cdots & Re Y_{0,N/2-1} & Im Y_{0,N/2-1} & Re Y_{0,N/2}  \\ Re
+Y_{1,0} & Re Y_{1,1} & Im Y_{1,1} & Re Y_{1,2} & Im Y_{1,2} &  \cdots & Re
+Y_{1,N/2-1} & Im Y_{1,N/2-1} & Re Y_{1,N/2}  \\ Im Y_{1,0} & Re Y_{2,1} & Im
+Y_{2,1} & Re Y_{2,2} & Im Y_{2,2} &  \cdots & Re Y_{2,N/2-1} & Im Y_{2,N/2-1} &
+Im Y_{1,N/2}  \\ \hdotsfor{9} \\ Re Y_{M/2-1,0} &  Re Y_{M-3,1}  & Im Y_{M-3,1}
+&  \hdotsfor{3} & Re Y_{M-3,N/2-1} & Im Y_{M-3,N/2-1}& Re Y_{M/2-1,N/2}  \\ Im
+Y_{M/2-1,0} &  Re Y_{M-2,1}  & Im Y_{M-2,1} &  \hdotsfor{3} & Re Y_{M-2,N/2-1} &
+Im Y_{M-2,N/2-1}& Im Y_{M/2-1,N/2}  \\ Re Y_{M/2,0}  &  Re Y_{M-1,1} &  Im
+Y_{M-1,1} &  \hdotsfor{3} & Re Y_{M-1,N/2-1} & Im Y_{M-1,N/2-1}& Re Y_{M/2,N/2}
+\end{bmatrix}\f]
+
+In case of 1D transform of a real vector, the output looks like the first row of
+the matrix above.
+
+So, the function chooses an operation mode depending on the flags and size of
+the input array:
+-   If #DFT_ROWS is set or the input array has a single row or single column,
+the function performs a 1D forward or inverse transform of each row of a matrix
+when #DFT_ROWS is set. Otherwise, it performs a 2D transform.
+-   If the input array is real and #DFT_INVERSE is not set, the function
+performs a forward 1D or 2D transform:
+    -   When #DFT_COMPLEX_OUTPUT is set, the output is a complex matrix of the
+same size as input.
+    -   When #DFT_COMPLEX_OUTPUT is not set, the output is a real matrix of the
+same size as input. In case of 2D transform, it uses the packed format as shown
+above. In case of a single 1D transform, it looks like the first row of the
+matrix above. In case of multiple 1D transforms (when using the #DFT_ROWS flag),
+each row of the output matrix looks like the first row of the matrix above.
+-   If the input array is complex and either #DFT_INVERSE or #DFT_REAL_OUTPUT
+are not set, the output is a complex array of the same size as input. The
+function performs a forward or inverse 1D or 2D transform of the whole input
+array or each row of the input array independently, depending on the flags
+DFT_INVERSE and DFT_ROWS.
+-   When #DFT_INVERSE is set and the input array is real, or it is complex but
+#DFT_REAL_OUTPUT is set, the output is a real array of the same size as input.
+The function performs a 1D or 2D inverse transformation of the whole input array
+or each individual row, depending on the flags #DFT_INVERSE and #DFT_ROWS.
+
+If #DFT_SCALE is set, the scaling is done after the transformation.
+
+Unlike dct, the function supports arrays of arbitrary size. But only those
+arrays are processed efficiently, whose sizes can be factorized in a product of
+small prime numbers (2, 3, and 5 in the current implementation). Such an
+efficient DFT size can be calculated using the getOptimalDFTSize method.
+
+The sample below illustrates how to calculate a DFT-based convolution of two 2D
+real arrays:
+@code
+    void convolveDFT(InputArray A, InputArray B, OutputArray C)
+    {
+        // reallocate the output array if needed
+        C.create(abs(A.rows - B.rows)+1, abs(A.cols - B.cols)+1, A.type());
+        Size dftSize;
+        // calculate the size of DFT transform
+        dftSize.width = getOptimalDFTSize(A.cols + B.cols - 1);
+        dftSize.height = getOptimalDFTSize(A.rows + B.rows - 1);
+
+        // allocate temporary buffers and initialize them with 0's
+        Mat tempA(dftSize, A.type(), Scalar::all(0));
+        Mat tempB(dftSize, B.type(), Scalar::all(0));
+
+        // copy A and B to the top-left corners of tempA and tempB, respectively
+        Mat roiA(tempA, Rect(0,0,A.cols,A.rows));
+        A.copyTo(roiA);
+        Mat roiB(tempB, Rect(0,0,B.cols,B.rows));
+        B.copyTo(roiB);
+
+        // now transform the padded A & B in-place;
+        // use "nonzeroRows" hint for faster processing
+        dft(tempA, tempA, 0, A.rows);
+        dft(tempB, tempB, 0, B.rows);
+
+        // multiply the spectrums;
+        // the function handles packed spectrum representations well
+        mulSpectrums(tempA, tempB, tempA);
+
+        // transform the product back from the frequency domain.
+        // Even though all the result rows will be non-zero,
+        // you need only the first C.rows of them, and thus you
+        // pass nonzeroRows == C.rows
+        dft(tempA, tempA, DFT_INVERSE + DFT_SCALE, C.rows);
+
+        // now copy the result back to C.
+        tempA(Rect(0, 0, C.cols, C.rows)).copyTo(C);
+
+        // all the temporary buffers will be deallocated automatically
+    }
+@endcode
+To optimize this sample, consider the following approaches:
+-   Since nonzeroRows != 0 is passed to the forward transform calls and since A
+and B are copied to the top-left corners of tempA and tempB, respectively, it is
+not necessary to clear the whole tempA and tempB. It is only necessary to clear
+the tempA.cols - A.cols ( tempB.cols - B.cols) rightmost columns of the
+matrices.
+-   This DFT-based convolution does not have to be applied to the whole big
+arrays, especially if B is significantly smaller than A or vice versa. Instead,
+you can calculate convolution by parts. To do this, you need to split the output
+array C into multiple tiles. For each tile, estimate which parts of A and B are
+required to calculate convolution in this tile. If the tiles in C are too small,
+the speed will decrease a lot because of repeated work. In the ultimate case,
+when each tile in C is a single pixel, the algorithm becomes equivalent to the
+naive convolution algorithm. If the tiles are too big, the temporary arrays
+tempA and tempB become too big and there is also a slowdown because of bad cache
+locality. So, there is an optimal tile size somewhere in the middle.
+-   If different tiles in C can be calculated in parallel and, thus, the
+convolution is done by parts, the loop can be threaded.
+
+All of the above improvements have been implemented in #matchTemplate and
+#filter2D . Therefore, by using them, you can get the performance even better
+than with the above theoretically optimal implementation. Though, those two
+functions actually calculate cross-correlation, not convolution, so you need to
+"flip" the second convolution operand B vertically and horizontally using flip .
+@note
+-   An example using the discrete fourier transform can be found at
+    opencv_source_code/samples/cpp/dft.cpp
+-   (Python) An example using the dft functionality to perform Wiener
+deconvolution can be found at opencv_source/samples/python/deconvolution.py
+-   (Python) An example rearranging the quadrants of a Fourier image can be
+found at opencv_source/samples/python/dft.py
+@param src input array that could be real or complex.
+@param dst output array whose size and type depends on the flags .
+@param flags transformation flags, representing a combination of the #DftFlags
+@param nonzeroRows when the parameter is not zero, the function assumes that
+only the first nonzeroRows rows of the input array (#DFT_INVERSE is not set) or
+only the first nonzeroRows of the output array (#DFT_INVERSE is set) contain
+non-zeros, thus, the function can handle the rest of the rows more efficiently
+and save some time; this technique is very useful for calculating array
+cross-correlation or convolution using DFT.
+@sa dct, getOptimalDFTSize, mulSpectrums, filter2D, matchTemplate, flip,
+cartToPolar, magnitude, phase
+*/
+CV_EXPORTS_W void dft(InputArray src, OutputArray dst, int flags = 0,
+                      int nonzeroRows = 0);
+
+/** @brief Calculates the inverse Discrete Fourier Transform of a 1D or 2D
+array.
+
+idft(src, dst, flags) is equivalent to dft(src, dst, flags | #DFT_INVERSE) .
+@note None of dft and idft scales the result by default. So, you should pass
+#DFT_SCALE to one of dft or idft explicitly to make these transforms mutually
+inverse.
+@sa dft, dct, idct, mulSpectrums, getOptimalDFTSize
+@param src input floating-point real or complex array.
+@param dst output array whose size and type depend on the flags.
+@param flags operation flags (see dft and #DftFlags).
+@param nonzeroRows number of dst rows to process; the rest of the rows have
+undefined content (see the convolution sample in dft description.
+*/
+CV_EXPORTS_W void idft(InputArray src, OutputArray dst, int flags = 0,
+                       int nonzeroRows = 0);
+
+/** @brief Performs a forward or inverse discrete Cosine transform of 1D or 2D
+array.
+
+The function cv::dct performs a forward or inverse discrete Cosine transform
+(DCT) of a 1D or 2D floating-point array:
+-   Forward Cosine transform of a 1D vector of N elements:
+    \f[Y = C^{(N)}  \cdot X\f]
+    where
+    \f[C^{(N)}_{jk}= \sqrt{\alpha_j/N} \cos \left ( \frac{\pi(2k+1)j}{2N} \right
+)\f] and
+    \f$\alpha_0=1\f$, \f$\alpha_j=2\f$ for *j \> 0*.
+-   Inverse Cosine transform of a 1D vector of N elements:
+    \f[X =  \left (C^{(N)} \right )^{-1}  \cdot Y =  \left (C^{(N)} \right )^T
+\cdot Y\f] (since \f$C^{(N)}\f$ is an orthogonal matrix, \f$C^{(N)} \cdot
+\left(C^{(N)}\right)^T = I\f$ )
+-   Forward 2D Cosine transform of M x N matrix:
+    \f[Y = C^{(N)}  \cdot X  \cdot \left (C^{(N)} \right )^T\f]
+-   Inverse 2D Cosine transform of M x N matrix:
+    \f[X =  \left (C^{(N)} \right )^T  \cdot X  \cdot C^{(N)}\f]
+
+The function chooses the mode of operation by looking at the flags and size of
+the input array:
+-   If (flags & #DCT_INVERSE) == 0, the function does a forward 1D or 2D
+transform. Otherwise, it is an inverse 1D or 2D transform.
+-   If (flags & #DCT_ROWS) != 0, the function performs a 1D transform of each
+row.
+-   If the array is a single column or a single row, the function performs a 1D
+transform.
+-   If none of the above is true, the function performs a 2D transform.
+
+@note Currently dct supports even-size arrays (2, 4, 6 ...). For data analysis
+and approximation, you can pad the array when necessary. Also, the function
+performance depends very much, and not monotonically, on the array size (see
+getOptimalDFTSize ). In the current implementation DCT of a vector of size N is
+calculated via DFT of a vector of size N/2 . Thus, the optimal DCT size N1 \>= N
+can be calculated as:
+@code
+    size_t getOptimalDCTSize(size_t N) { return 2*getOptimalDFTSize((N+1)/2); }
+    N1 = getOptimalDCTSize(N);
+@endcode
+@param src input floating-point array.
+@param dst output array of the same size and type as src .
+@param flags transformation flags as a combination of cv::DftFlags (DCT_*)
+@sa dft, getOptimalDFTSize, idct
+*/
+CV_EXPORTS_W void dct(InputArray src, OutputArray dst, int flags = 0);
+
+/** @brief Calculates the inverse Discrete Cosine Transform of a 1D or 2D array.
+
+idct(src, dst, flags) is equivalent to dct(src, dst, flags | DCT_INVERSE).
+@param src input floating-point single-channel array.
+@param dst output array of the same size and type as src.
+@param flags operation flags.
+@sa  dct, dft, idft, getOptimalDFTSize
+*/
+CV_EXPORTS_W void idct(InputArray src, OutputArray dst, int flags = 0);
+
+/** @brief Performs the per-element multiplication of two Fourier spectrums.
+
+The function cv::mulSpectrums performs the per-element multiplication of the two
+CCS-packed or complex matrices that are results of a real or complex Fourier
+transform.
+
+The function, together with dft and idft, may be used to calculate convolution
+(pass conjB=false ) or correlation (pass conjB=true ) of two arrays rapidly.
+When the arrays are complex, they are simply multiplied (per element) with an
+optional conjugation of the second-array elements. When the arrays are real,
+they are assumed to be CCS-packed (see dft for details).
+@param a first input array.
+@param b second input array of the same size and type as src1 .
+@param c output array of the same size and type as src1 .
+@param flags operation flags; currently, the only supported flag is
+cv::DFT_ROWS, which indicates that each row of src1 and src2 is an independent
+1D Fourier spectrum. If you do not want to use this flag, then simply add a `0`
+as value.
+@param conjB optional flag that conjugates the second input array before the
+multiplication (true) or not (false).
+*/
+CV_EXPORTS_W void mulSpectrums(InputArray a, InputArray b, OutputArray c,
+                               int flags, bool conjB = false);
+
+/** @brief Returns the optimal DFT size for a given vector size.
+
+DFT performance is not a monotonic function of a vector size. Therefore, when
+you calculate convolution of two arrays or perform the spectral analysis of an
+array, it usually makes sense to pad the input data with zeros to get a bit
+larger array that can be transformed much faster than the original one. Arrays
+whose size is a power-of-two (2, 4, 8, 16, 32, ...) are the fastest to process.
+Though, the arrays whose size is a product of 2's, 3's, and 5's (for example,
+300 = 5\*5\*3\*2\*2) are also processed quite efficiently.
+
+The function cv::getOptimalDFTSize returns the minimum number N that is greater
+than or equal to vecsize so that the DFT of a vector of size N can be processed
+efficiently. In the current implementation N = 2 ^p^ \* 3 ^q^ \* 5 ^r^ for some
+integer p, q, r.
+
+The function returns a negative number if vecsize is too large (very close to
+INT_MAX ).
+
+While the function cannot be used directly to estimate the optimal vector size
+for DCT transform (since the current DCT implementation supports only even-size
+vectors), it can be easily processed as getOptimalDFTSize((vecsize+1)/2)\*2.
+@param vecsize vector size.
+@sa dft, dct, idft, idct, mulSpectrums
+*/
+CV_EXPORTS_W int getOptimalDFTSize(int vecsize);
+
+/** @brief Returns the default random number generator.
+
+The function cv::theRNG returns the default random number generator. For each
+thread, there is a separate random number generator, so you can use the function
+safely in multi-thread environments. If you just need to get a single random
+number using this generator or initialize an array, you can use randu or randn
+instead. But if you are going to generate many random numbers inside a loop, it
+is much faster to use this function to retrieve the generator and then use
+RNG::operator _Tp() .
+@sa RNG, randu, randn
+*/
+CV_EXPORTS RNG &theRNG();
+
+/** @brief Sets state of default random number generator.
+
+The function cv::setRNGSeed sets state of default random number generator to
+custom value.
+@param seed new state for default random number generator
+@sa RNG, randu, randn
+*/
+CV_EXPORTS_W void setRNGSeed(int seed);
+
+/** @brief Generates a single uniformly-distributed random number or an array of
+random numbers.
+
+Non-template variant of the function fills the matrix dst with
+uniformly-distributed random numbers from the specified range:
+\f[\texttt{low} _c  \leq \texttt{dst} (I)_c <  \texttt{high} _c\f]
+@param dst output array of random numbers; the array must be pre-allocated.
+@param low inclusive lower boundary of the generated random numbers.
+@param high exclusive upper boundary of the generated random numbers.
+@sa RNG, randn, theRNG
+*/
+CV_EXPORTS_W void randu(InputOutputArray dst, InputArray low, InputArray high);
+
+/** @brief Fills the array with normally distributed random numbers.
+
+The function cv::randn fills the matrix dst with normally distributed random
+numbers with the specified mean vector and the standard deviation matrix. The
+generated random numbers are clipped to fit the value range of the output array
+data type.
+@param dst output array of random numbers; the array must be pre-allocated and
+have 1 to 4 channels.
+@param mean mean value (expectation) of the generated random numbers.
+@param stddev standard deviation of the generated random numbers; it can be
+either a vector (in which case a diagonal standard deviation matrix is assumed)
+or a square matrix.
+@sa RNG, randu
+*/
+CV_EXPORTS_W void randn(InputOutputArray dst, InputArray mean,
+                        InputArray stddev);
+
+/** @brief Shuffles the array elements randomly.
+
+The function cv::randShuffle shuffles the specified 1D array by randomly
+choosing pairs of elements and swapping them. The number of such swap operations
+will be dst.rows\*dst.cols\*iterFactor .
+@param dst input/output numerical 1D array.
+@param iterFactor scale factor that determines the number of random swap
+operations (see the details below).
+@param rng optional random number generator used for shuffling; if it is zero,
+theRNG () is used instead.
+@sa RNG, sort
+*/
+CV_EXPORTS_W void randShuffle(InputOutputArray dst, double iterFactor = 1.,
+                              RNG *rng = 0);
+
+/** @brief Principal Component Analysis
+
+The class is used to calculate a special basis for a set of vectors. The
+basis will consist of eigenvectors of the covariance matrix calculated
+from the input set of vectors. The class %PCA can also transform
+vectors to/from the new coordinate space defined by the basis. Usually,
+in this new coordinate system, each vector from the original set (and
+any linear combination of such vectors) can be quite accurately
+approximated by taking its first few components, corresponding to the
+eigenvectors of the largest eigenvalues of the covariance matrix.
+Geometrically it means that you calculate a projection of the vector to
+a subspace formed by a few eigenvectors corresponding to the dominant
+eigenvalues of the covariance matrix. And usually such a projection is
+very close to the original vector. So, you can represent the original
+vector from a high-dimensional space with a much shorter vector
+consisting of the projected vector's coordinates in the subspace. Such a
+transformation is also known as Karhunen-Loeve Transform, or KLT.
+See http://en.wikipedia.org/wiki/Principal_component_analysis
+
+The sample below is the function that takes two matrices. The first
+function stores a set of vectors (a row per vector) that is used to
+calculate PCA. The second function stores another "test" set of vectors
+(a row per vector). First, these vectors are compressed with PCA, then
+reconstructed back, and then the reconstruction error norm is computed
+and printed for each vector. :
+
+@code{.cpp}
+using namespace cv;
+
+PCA compressPCA(const Mat& pcaset, int maxComponents,
+                const Mat& testset, Mat& compressed)
+{
+    PCA pca(pcaset, // pass the data
+            Mat(), // we do not have a pre-computed mean vector,
+                   // so let the PCA engine to compute it
+            PCA::DATA_AS_ROW, // indicate that the vectors
+                                // are stored as matrix rows
+                                // (use PCA::DATA_AS_COL if the vectors are
+                                // the matrix columns)
+            maxComponents // specify, how many principal components to retain
+            );
+    // if there is no test data, just return the computed basis, ready-to-use
+    if( !testset.data )
+        return pca;
+    CV_Assert( testset.cols == pcaset.cols );
+
+    compressed.create(testset.rows, maxComponents, testset.type());
+
+    Mat reconstructed;
+    for( int i = 0; i < testset.rows; i++ )
+    {
+        Mat vec = testset.row(i), coeffs = compressed.row(i), reconstructed;
+        // compress the vector, the result will be stored
+        // in the i-th row of the output matrix
+        pca.project(vec, coeffs);
+        // and then reconstruct it
+        pca.backProject(coeffs, reconstructed);
+        // and measure the error
+        printf("%d. diff = %g\n", i, norm(vec, reconstructed, NORM_L2));
+    }
+    return pca;
+}
+@endcode
+@sa calcCovarMatrix, mulTransposed, SVD, dft, dct
+*/
+class CV_EXPORTS PCA {
+public:
+  enum Flags {
+    DATA_AS_ROW =
+        0, //!< indicates that the input samples are stored as matrix rows
+    DATA_AS_COL =
+        1, //!< indicates that the input samples are stored as matrix columns
+    USE_AVG = 2 //!
+  };
+
+  /** @brief default constructor
+
+  The default constructor initializes an empty %PCA structure. The other
+  constructors initialize the structure and call PCA::operator()().
+  */
+  PCA();
+
+  /** @overload
+  @param data input samples stored as matrix rows or matrix columns.
+  @param mean optional mean value; if the matrix is empty (@c noArray()),
+  the mean is computed from the data.
+  @param flags operation flags; currently the parameter is only used to
+  specify the data layout (PCA::Flags)
+  @param maxComponents maximum number of components that %PCA should
+  retain; by default, all the components are retained.
+  */
+  PCA(InputArray data, InputArray mean, int flags, int maxComponents = 0);
+
+  /** @overload
+  @param data input samples stored as matrix rows or matrix columns.
+  @param mean optional mean value; if the matrix is empty (noArray()),
+  the mean is computed from the data.
+  @param flags operation flags; currently the parameter is only used to
+  specify the data layout (PCA::Flags)
+  @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.
+  */
+  PCA(InputArray data, InputArray mean, int flags, double retainedVariance);
+
+  /** @brief performs %PCA
+
+  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 @ref eigenvalues, @ref eigenvectors and @ref
+  mean are allocated and computed.
+
+  The computed @ref eigenvalues are sorted from the largest to the smallest and
+  the corresponding @ref eigenvectors are stored as eigenvectors rows.
+
+  @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.
+  @param flags operation flags; currently the parameter is only used to
+  specify the data layout. (Flags)
+  @param maxComponents maximum number of components that PCA should
+  retain; by default, all the components are retained.
+  */
+  PCA &operator()(InputArray data, InputArray mean, int flags,
+                  int maxComponents = 0);
+
+  /** @overload
+  @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.
+  @param flags operation flags; currently the parameter is only used to
+  specify the data layout. (PCA::Flags)
+  @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.
+   */
+  PCA &operator()(InputArray data, InputArray mean, int flags,
+                  double retainedVariance);
+
+  /** @brief Projects vector(s) to the principal component subspace.
+
+  The methods project one or more vectors to the principal component
+  subspace, where each vector projection is represented by coefficients in
+  the principal component basis. The first form of the method returns the
+  matrix that the second form writes to the result. So the first form can
+  be used as a part of expression while the second form can be more
+  efficient in a processing loop.
+  @param vec input vector(s); must have the same dimensionality and the
+  same layout as the input data used at %PCA phase, that is, if
+  DATA_AS_ROW are specified, then `vec.cols==data.cols`
+  (vector dimensionality) and `vec.rows` is the number of vectors to
+  project, and the same is true for the PCA::DATA_AS_COL case.
+  */
+  Mat project(InputArray vec) const;
+
+  /** @overload
+  @param vec input vector(s); must have the same dimensionality and the
+  same layout as the input data used at PCA phase, that is, if
+  DATA_AS_ROW are specified, then `vec.cols==data.cols`
+  (vector dimensionality) and `vec.rows` is the number of vectors to
+  project, and the same is true for the PCA::DATA_AS_COL case.
+  @param result output vectors; in case of PCA::DATA_AS_COL, the
+  output matrix has as many columns as the number of input vectors, this
+  means that `result.cols==vec.cols` and the number of rows match the
+  number of principal components (for example, `maxComponents` parameter
+  passed to the constructor).
+   */
+  void project(InputArray vec, OutputArray result) const;
+
+  /** @brief Reconstructs vectors from their PC projections.
+
+  The methods are inverse operations to PCA::project. They take PC
+  coordinates of projected vectors and reconstruct the original vectors.
+  Unless all the principal components have been retained, the
+  reconstructed vectors are different from the originals. But typically,
+  the difference is small if the number of components is large enough (but
+  still much smaller than the original vector dimensionality). As a
+  result, PCA is used.
+  @param vec coordinates of the vectors in the principal component
+  subspace, the layout and size are the same as of PCA::project output
+  vectors.
+   */
+  Mat backProject(InputArray vec) const;
+
+  /** @overload
+  @param vec coordinates of the vectors in the principal component
+  subspace, the layout and size are the same as of PCA::project output
+  vectors.
+  @param result reconstructed vectors; the layout and size are the same as
+  of PCA::project input vectors.
+   */
+  void backProject(InputArray vec, OutputArray result) const;
+
+  /** @brief write PCA objects
+
+  Writes @ref eigenvalues @ref eigenvectors and @ref mean to specified
+  FileStorage
+   */
+  void write(FileStorage &fs) const;
+
+  /** @brief load PCA objects
+
+  Loads @ref eigenvalues @ref eigenvectors and @ref mean from specified FileNode
+   */
+  void read(const FileNode &fn);
+
+  Mat eigenvectors; //!< eigenvectors of the covariation matrix
+  Mat eigenvalues;  //!< eigenvalues of the covariation matrix
+  Mat mean; //!< mean value subtracted before the projection and added after the
+            //!< back projection
+};
+
+/** @example samples/cpp/pca.cpp
+An example using %PCA for dimensionality reduction while maintaining an amount
+of variance
+*/
+
+/** @example
+samples/cpp/tutorial_code/ml/introduction_to_pca/introduction_to_pca.cpp Check
+@ref tutorial_introduction_to_pca "the corresponding tutorial" for more details
+*/
+
+/**
+@brief Linear Discriminant Analysis
+@todo document this class
+*/
+class CV_EXPORTS LDA {
+public:
+  /** @brief constructor
+  Initializes a LDA with num_components (default 0).
+  */
+  explicit LDA(int num_components = 0);
+
+  /** Initializes and performs a Discriminant Analysis with Fisher's
+   Optimization Criterion on given data in src and corresponding labels
+   in labels. If 0 (or less) number of components are given, they are
+   automatically determined for given data in computation.
+  */
+  LDA(InputArrayOfArrays src, InputArray labels, int num_components = 0);
+
+  /** Serializes this object to a given filename.
+   */
+  void save(const String &filename) const;
+
+  /** Deserializes this object from a given filename.
+   */
+  void load(const String &filename);
+
+  /** Serializes this object to a given cv::FileStorage.
+   */
+  void save(FileStorage &fs) const;
+
+  /** Deserializes this object from a given cv::FileStorage.
+   */
+  void load(const FileStorage &node);
+
+  /** destructor
+   */
+  ~LDA();
+
+  /** Compute the discriminants for data in src (row aligned) and labels.
+   */
+  void compute(InputArrayOfArrays src, InputArray labels);
+
+  /** Projects samples into the LDA subspace.
+      src may be one or more row aligned samples.
+    */
+  Mat project(InputArray src);
+
+  /** Reconstructs projections from the LDA subspace.
+      src may be one or more row aligned projections.
+    */
+  Mat reconstruct(InputArray src);
+
+  /** Returns the eigenvectors of this LDA.
+   */
+  Mat eigenvectors() const { return _eigenvectors; }
+
+  /** Returns the eigenvalues of this LDA.
+   */
+  Mat eigenvalues() const { return _eigenvalues; }
+
+  static Mat subspaceProject(InputArray W, InputArray mean, InputArray src);
+  static Mat subspaceReconstruct(InputArray W, InputArray mean, InputArray src);
+
+protected:
+  int _num_components;
+  Mat _eigenvectors;
+  Mat _eigenvalues;
+  void lda(InputArrayOfArrays src, InputArray labels);
+};
+
+/** @brief Singular Value Decomposition
+
+Class for computing Singular Value Decomposition of a floating-point
+matrix. The Singular Value Decomposition is used to solve least-square
+problems, under-determined linear systems, invert matrices, compute
+condition numbers, and so on.
+
+If you want to compute a condition number of a matrix or an absolute value of
+its determinant, you do not need `u` and `vt`. You can pass
+flags=SVD::NO_UV|... . Another flag SVD::FULL_UV indicates that full-size u
+and vt must be computed, which is not necessary most of the time.
+
+@sa invert, solve, eigen, determinant
+*/
+class CV_EXPORTS SVD {
+public:
+  enum Flags {
+    /** allow the algorithm to modify the decomposed matrix; it can save space
+       and speed up processing. currently ignored. */
+    MODIFY_A = 1,
+    /** indicates that only a vector of singular values `w` is to be processed,
+       while u and vt will be set to empty matrices */
+    NO_UV = 2,
+    /** when the matrix is not square, by default the algorithm produces u and
+       vt matrices of sufficiently large size for the further A reconstruction;
+       if, however, FULL_UV flag is specified, u and vt will be full-size square
+       orthogonal matrices.*/
+    FULL_UV = 4
+  };
+
+  /** @brief the default constructor
+
+  initializes an empty SVD structure
+    */
+  SVD();
+
+  /** @overload
+  initializes an empty SVD structure and then calls SVD::operator()
+  @param src decomposed matrix. The depth has to be CV_32F or CV_64F.
+  @param flags operation flags (SVD::Flags)
+    */
+  SVD(InputArray src, int flags = 0);
+
+  /** @brief the operator that performs SVD. The previously allocated u, w and
+  vt are released.
+
+  The operator performs the singular value decomposition of the supplied
+  matrix. The u,`vt` , and the vector of singular values w are stored in
+  the structure. The same SVD structure can be reused many times with
+  different matrices. Each time, if needed, the previous u,`vt` , and w
+  are reclaimed and the new matrices are created, which is all handled by
+  Mat::create.
+  @param src decomposed matrix. The depth has to be CV_32F or CV_64F.
+  @param flags operation flags (SVD::Flags)
+    */
+  SVD &operator()(InputArray src, int flags = 0);
+
+  /** @brief decomposes matrix and stores the results to user-provided matrices
+
+  The methods/functions perform SVD of matrix. Unlike SVD::SVD constructor
+  and SVD::operator(), they store the results to the user-provided
+  matrices:
+
+  @code{.cpp}
+  Mat A, w, u, vt;
+  SVD::compute(A, w, u, vt);
+  @endcode
+
+  @param src decomposed matrix. The depth has to be CV_32F or CV_64F.
+  @param w calculated singular values
+  @param u calculated left singular vectors
+  @param vt transposed matrix of right singular vectors
+  @param flags operation flags - see SVD::Flags.
+    */
+  static void compute(InputArray src, OutputArray w, OutputArray u,
+                      OutputArray vt, int flags = 0);
+
+  /** @overload
+  computes singular values of a matrix
+  @param src decomposed matrix. The depth has to be CV_32F or CV_64F.
+  @param w calculated singular values
+  @param flags operation flags - see SVD::Flags.
+    */
+  static void compute(InputArray src, OutputArray w, int flags = 0);
+
+  /** @brief performs back substitution
+   */
+  static void backSubst(InputArray w, InputArray u, InputArray vt,
+                        InputArray rhs, OutputArray dst);
+
+  /** @brief solves an under-determined singular linear system
+
+  The method finds a unit-length solution x of a singular linear system
+  A\*x = 0. Depending on the rank of A, there can be no solutions, a
+  single solution or an infinite number of solutions. In general, the
+  algorithm solves the following problem:
+  \f[dst =  \arg \min _{x:  \| x \| =1}  \| src  \cdot x  \|\f]
+  @param src left-hand-side matrix.
+  @param dst found solution.
+    */
+  static void solveZ(InputArray src, OutputArray dst);
+
+  /** @brief performs a singular value back substitution.
+
+  The method calculates a back substitution for the specified right-hand
+  side:
+
+  \f[\texttt{x} =  \texttt{vt} ^T  \cdot diag( \texttt{w} )^{-1}  \cdot
+  \texttt{u} ^T  \cdot \texttt{rhs} \sim \texttt{A} ^{-1}  \cdot \texttt{rhs}\f]
+
+  Using this technique you can either get a very accurate solution of the
+  convenient linear system, or the best (in the least-squares terms)
+  pseudo-solution of an overdetermined linear system.
+
+  @param rhs right-hand side of a linear system (u\*w\*v')\*dst = rhs to
+  be solved, where A has been previously decomposed.
+
+  @param dst found solution of the system.
+
+  @note Explicit SVD with the further back substitution only makes sense
+  if you need to solve many linear systems with the same left-hand side
+  (for example, src ). If all you need is to solve a single system
+  (possibly with multiple rhs immediately available), simply call solve
+  add pass #DECOMP_SVD there. It does absolutely the same thing.
+    */
+  void backSubst(InputArray rhs, OutputArray dst) const;
+
+  /** @todo document */
+  template <typename _Tp, int m, int n, int nm>
+  static void compute(const Matx<_Tp, m, n> &a, Matx<_Tp, nm, 1> &w,
+                      Matx<_Tp, m, nm> &u, Matx<_Tp, n, nm> &vt);
+
+  /** @todo document */
+  template <typename _Tp, int m, int n, int nm>
+  static void compute(const Matx<_Tp, m, n> &a, Matx<_Tp, nm, 1> &w);
+
+  /** @todo document */
+  template <typename _Tp, int m, int n, int nm, int nb>
+  static void backSubst(const Matx<_Tp, nm, 1> &w, const Matx<_Tp, m, nm> &u,
+                        const Matx<_Tp, n, nm> &vt, const Matx<_Tp, m, nb> &rhs,
+                        Matx<_Tp, n, nb> &dst);
+
+  Mat u, w, vt;
+};
+
+/** @brief Random Number Generator
+
+Random number generator. It encapsulates the state (currently, a 64-bit
+integer) and has methods to return scalar random values and to fill
+arrays with random values. Currently it supports uniform and Gaussian
+(normal) distributions. The generator uses Multiply-With-Carry
+algorithm, introduced by G. Marsaglia (
+<http://en.wikipedia.org/wiki/Multiply-with-carry> ).
+Gaussian-distribution random numbers are generated using the Ziggurat
+algorithm ( <http://en.wikipedia.org/wiki/Ziggurat_algorithm> ),
+introduced by G. Marsaglia and W. W. Tsang.
+*/
+class CV_EXPORTS RNG {
+public:
+  enum { UNIFORM = 0, NORMAL = 1 };
+
+  /** @brief constructor
+
+  These are the RNG constructors. The first form sets the state to some
+  pre-defined value, equal to 2\*\*32-1 in the current implementation. The
+  second form sets the state to the specified value. If you passed state=0
+  , the constructor uses the above default value instead to avoid the
+  singular random number sequence, consisting of all zeros.
+  */
+  RNG();
+  /** @overload
+  @param state 64-bit value used to initialize the RNG.
+  */
+  RNG(uint64 state);
+  /**The method updates the state using the MWC algorithm and returns the
+  next 32-bit random number.*/
+  unsigned next();
+
+  /**Each of the methods updates the state using the MWC algorithm and
+  returns the next random number of the specified type. In case of integer
+  types, the returned number is from the available value range for the
+  specified type. In case of floating-point types, the returned value is
+  from [0,1) range.
+  */
+  operator uchar();
+  /** @overload */
+  operator schar();
+  /** @overload */
+  operator ushort();
+  /** @overload */
+  operator short();
+  /** @overload */
+  operator unsigned();
+  /** @overload */
+  operator int();
+  /** @overload */
+  operator float();
+  /** @overload */
+  operator double();
+
+  /** @brief returns a random integer sampled uniformly from [0, N).
+
+  The methods transform the state using the MWC algorithm and return the
+  next random number. The first form is equivalent to RNG::next . The
+  second form returns the random number modulo N, which means that the
+  result is in the range [0, N) .
+  */
+  unsigned operator()();
+  /** @overload
+  @param N upper non-inclusive boundary of the returned random number.
+  */
+  unsigned operator()(unsigned N);
+
+  /** @brief returns uniformly distributed integer random number from [a,b)
+  range
+
+  The methods transform the state using the MWC algorithm and return the
+  next uniformly-distributed random number of the specified type, deduced
+  from the input parameter type, from the range [a, b) . There is a nuance
+  illustrated by the following sample:
+
+  @code{.cpp}
+  RNG rng;
+
+  // always produces 0
+  double a = rng.uniform(0, 1);
+
+  // produces double from [0, 1)
+  double a1 = rng.uniform((double)0, (double)1);
+
+  // produces float from [0, 1)
+  float b = rng.uniform(0.f, 1.f);
+
+  // produces double from [0, 1)
+  double c = rng.uniform(0., 1.);
+
+  // may cause compiler error because of ambiguity:
+  //  RNG::uniform(0, (int)0.999999)? or RNG::uniform((double)0, 0.99999)?
+  double d = rng.uniform(0, 0.999999);
+  @endcode
+
+  The compiler does not take into account the type of the variable to
+  which you assign the result of RNG::uniform . The only thing that
+  matters to the compiler is the type of a and b parameters. So, if you
+  want a floating-point random number, but the range boundaries are
+  integer numbers, either put dots in the end, if they are constants, or
+  use explicit type cast operators, as in the a1 initialization above.
+  @param a lower inclusive boundary of the returned random number.
+  @param b upper non-inclusive boundary of the returned random number.
+  */
+  int uniform(int a, int b);
+  /** @overload */
+  float uniform(float a, float b);
+  /** @overload */
+  double uniform(double a, double b);
+
+  /** @brief Fills arrays with random numbers.
+
+  @param mat 2D or N-dimensional matrix; currently matrices with more than
+  4 channels are not supported by the methods, use Mat::reshape as a
+  possible workaround.
+  @param distType distribution type, RNG::UNIFORM or RNG::NORMAL.
+  @param a first distribution parameter; in case of the uniform
+  distribution, this is an inclusive lower boundary, in case of the normal
+  distribution, this is a mean value.
+  @param b second distribution parameter; in case of the uniform
+  distribution, this is a non-inclusive upper boundary, in case of the
+  normal distribution, this is a standard deviation (diagonal of the
+  standard deviation matrix or the full standard deviation matrix).
+  @param saturateRange pre-saturation flag; for uniform distribution only;
+  if true, the method will first convert a and b to the acceptable value
+  range (according to the mat datatype) and then will generate uniformly
+  distributed random numbers within the range [saturate(a), saturate(b)),
+  if saturateRange=false, the method will generate uniformly distributed
+  random numbers in the original range [a, b) and then will saturate them,
+  it means, for example, that
+  <tt>theRNG().fill(mat_8u, RNG::UNIFORM, -DBL_MAX, DBL_MAX)</tt> will likely
+  produce array mostly filled with 0's and 255's, since the range (0, 255)
+  is significantly smaller than [-DBL_MAX, DBL_MAX).
+
+  Each of the methods fills the matrix with the random values from the
+  specified distribution. As the new numbers are generated, the RNG state
+  is updated accordingly. In case of multiple-channel images, every
+  channel is filled independently, which means that RNG cannot generate
+  samples from the multi-dimensional Gaussian distribution with
+  non-diagonal covariance matrix directly. To do that, the method
+  generates samples from multi-dimensional standard Gaussian distribution
+  with zero mean and identity covariation matrix, and then transforms them
+  using transform to get samples from the specified Gaussian distribution.
+  */
+  void fill(InputOutputArray mat, int distType, InputArray a, InputArray b,
+            bool saturateRange = false);
+
+  /** @brief Returns the next random number sampled from the Gaussian
+  distribution
+  @param sigma standard deviation of the distribution.
+
+  The method transforms the state using the MWC algorithm and returns the
+  next random number from the Gaussian distribution N(0,sigma) . That is,
+  the mean value of the returned random numbers is zero and the standard
+  deviation is the specified sigma .
+  */
+  double gaussian(double sigma);
+
+  uint64 state;
+
+  bool operator==(const RNG &other) const;
+};
+
+/** @brief Mersenne Twister random number generator
+
+Inspired by
+http://www.math.sci.hiroshima-u.ac.jp/~m-mat/MT/MT2002/CODES/mt19937ar.c
+@todo document
+*/
+class CV_EXPORTS RNG_MT19937 {
+public:
+  RNG_MT19937();
+  RNG_MT19937(unsigned s);
+  void seed(unsigned s);
+
+  unsigned next();
+
+  operator int();
+  operator unsigned();
+  operator float();
+  operator double();
+
+  unsigned operator()(unsigned N);
+  unsigned operator()();
+
+  /** @brief returns uniformly distributed integer random number from [a,b)
+   * range*/
+  int uniform(int a, int b);
+  /** @brief returns uniformly distributed floating-point random number from
+   * [a,b) range*/
+  float uniform(float a, float b);
+  /** @brief returns uniformly distributed double-precision floating-point
+   * random number from [a,b) range*/
+  double uniform(double a, double b);
+
+private:
+  enum PeriodParameters { N = 624, M = 397 };
+  unsigned state[N];
+  int mti;
+};
+
+//! @} core_array
+
+//! @addtogroup core_cluster
+//!  @{
+
+//! k-means flags
+enum KmeansFlags {
+  /** Select random initial centers in each attempt.*/
+  KMEANS_RANDOM_CENTERS = 0,
+  /** Use kmeans++ center initialization by Arthur and Vassilvitskii
+     [Arthur2007].*/
+  KMEANS_PP_CENTERS = 2,
+  /** During the first (and possibly the only) attempt, use the
+      user-supplied labels instead of computing them from the initial centers.
+     For the second and further attempts, use the random or semi-random centers.
+     Use one of KMEANS_\*_CENTERS flag to specify the exact method.*/
+  KMEANS_USE_INITIAL_LABELS = 1
+};
+
+/** @example samples/cpp/kmeans.cpp
+An example on k-means clustering
+*/
+
+/** @brief Finds centers of clusters and groups input samples around the
+clusters.
+
+The function kmeans implements a k-means algorithm that finds the centers of
+cluster_count clusters and groups the input samples around the clusters. As an
+output, \f$\texttt{bestLabels}_i\f$ contains a 0-based cluster index for the
+sample stored in the \f$i^{th}\f$ row of the samples matrix.
+
+@note
+-   (Python) An example on k-means clustering can be found at
+    opencv_source_code/samples/python/kmeans.py
+@param data Data for clustering. An array of N-Dimensional points with float
+coordinates is needed. Examples of this array can be:
+-   Mat points(count, 2, CV_32F);
+-   Mat points(count, 1, CV_32FC2);
+-   Mat points(1, count, CV_32FC2);
+-   std::vector\<cv::Point2f\> points(sampleCount);
+@param K Number of clusters to split the set by.
+@param bestLabels Input/output integer array that stores the cluster indices for
+every sample.
+@param criteria The algorithm termination criteria, that is, the maximum number
+of iterations and/or the desired accuracy. The accuracy is specified as
+criteria.epsilon. As soon as each of the cluster centers moves by less than
+criteria.epsilon on some iteration, the algorithm stops.
+@param attempts Flag to specify the number of times the algorithm is executed
+using different initial labellings. The algorithm returns the labels that yield
+the best compactness (see the last function parameter).
+@param flags Flag that can take values of cv::KmeansFlags
+@param centers Output matrix of the cluster centers, one row per each cluster
+center.
+@return The function returns the compactness measure that is computed as
+\f[\sum _i  \| \texttt{samples} _i -  \texttt{centers} _{ \texttt{labels} _i} \|
+^2\f] after every attempt. The best (minimum) value is chosen and the
+corresponding labels and the compactness value are returned by the function.
+Basically, you can use only the core of the function, set the number of attempts
+to 1, initialize labels each time using a custom algorithm, pass them with the (
+flags = #KMEANS_USE_INITIAL_LABELS ) flag, and then choose the best
+(most-compact) clustering.
+*/
+CV_EXPORTS_W double kmeans(InputArray data, int K, InputOutputArray bestLabels,
+                           TermCriteria criteria, int attempts, int flags,
+                           OutputArray centers = noArray());
+
+//! @} core_cluster
+
+//! @addtogroup core_basic
+//! @{
+
+/////////////////////////////// Formatted output of cv::Mat
+//////////////////////////////
+
+/** @todo document */
+class CV_EXPORTS Formatted {
+public:
+  virtual const char *next() = 0;
+  virtual void reset() = 0;
+  virtual ~Formatted();
+};
+
+/** @todo document */
+class CV_EXPORTS Formatter {
+public:
+  enum FormatType {
+    FMT_DEFAULT = 0,
+    FMT_MATLAB = 1,
+    FMT_CSV = 2,
+    FMT_PYTHON = 3,
+    FMT_NUMPY = 4,
+    FMT_C = 5
+  };
+
+  virtual ~Formatter();
+
+  virtual Ptr<Formatted> format(const Mat &mtx) const = 0;
+
+  virtual void set16fPrecision(int p = 4) = 0;
+  virtual void set32fPrecision(int p = 8) = 0;
+  virtual void set64fPrecision(int p = 16) = 0;
+  virtual void setMultiline(bool ml = true) = 0;
+
+  static Ptr<Formatter> get(Formatter::FormatType fmt = FMT_DEFAULT);
+};
+
+static inline String &operator<<(String &out, Ptr<Formatted> fmtd) {
+  fmtd->reset();
+  for (const char *str = fmtd->next(); str; str = fmtd->next())
+    out += cv::String(str);
+  return out;
+}
+
+static inline String &operator<<(String &out, const Mat &mtx) {
+  return out << Formatter::get()->format(mtx);
+}
+
+//////////////////////////////////////// Algorithm
+///////////////////////////////////////
+
+class CV_EXPORTS Algorithm;
+
+template <typename _Tp, typename _EnumTp = void> struct ParamType {};
+
+/** @brief This is a base class for all more or less complex algorithms in
+OpenCV
+
+especially for classes of algorithms, for which there can be multiple
+implementations. The examples are stereo correspondence (for which there are
+algorithms like block matching, semi-global block matching, graph-cut etc.),
+background subtraction (which can be done using mixture-of-gaussians models,
+codebook-based algorithm etc.), optical flow (block matching, Lucas-Kanade,
+Horn-Schunck etc.).
+
+Here is example of SimpleBlobDetector use in your application via Algorithm
+interface:
+@snippet snippets/core_various.cpp Algorithm
+*/
+class CV_EXPORTS_W Algorithm {
+public:
+  Algorithm();
+  virtual ~Algorithm();
+
+  /** @brief Clears the algorithm state
+   */
+  CV_WRAP virtual void clear() {}
+
+  /** @brief Stores algorithm parameters in a file storage
+   */
+  CV_WRAP virtual void write(FileStorage &fs) const { CV_UNUSED(fs); }
+
+  /**
+   * @overload
+   */
+  CV_WRAP void write(FileStorage &fs, const String &name) const;
+#if CV_VERSION_MAJOR < 5
+  /** @deprecated */
+  void write(const Ptr<FileStorage> &fs, const String &name = String()) const;
+#endif
+
+  /** @brief Reads algorithm parameters from a file storage
+   */
+  CV_WRAP virtual void read(const FileNode &fn) { CV_UNUSED(fn); }
+
+  /** @brief Returns true if the Algorithm is empty (e.g. in the very beginning
+   * or after unsuccessful read
+   */
+  CV_WRAP virtual bool empty() const { return false; }
+
+  /** @brief Reads algorithm from the file node
+
+  This is static template method of Algorithm. It's usage is following (in the
+  case of SVM):
+  @code
+  cv::FileStorage fsRead("example.xml", FileStorage::READ);
+  Ptr<SVM> svm = Algorithm::read<SVM>(fsRead.root());
+  @endcode
+  In order to make this method work, the derived class must overwrite
+  Algorithm::read(const FileNode& fn) and also have static create() method
+  without parameters (or with all the optional parameters)
+  */
+  template <typename _Tp> static Ptr<_Tp> read(const FileNode &fn) {
+    Ptr<_Tp> obj = _Tp::create();
+    obj->read(fn);
+    return !obj->empty() ? obj : Ptr<_Tp>();
+  }
+
+  /** @brief Loads algorithm from the file
+
+  @param filename Name of the file to read.
+  @param objname The optional name of the node to read (if empty, the first
+  top-level node will be used)
+
+  This is static template method of Algorithm. It's usage is following (in the
+  case of SVM):
+  @code
+  Ptr<SVM> svm = Algorithm::load<SVM>("my_svm_model.xml");
+  @endcode
+  In order to make this method work, the derived class must overwrite
+  Algorithm::read(const FileNode& fn).
+  */
+  template <typename _Tp>
+  static Ptr<_Tp> load(const String &filename,
+                       const String &objname = String()) {
+    FileStorage fs(filename, FileStorage::READ);
+    CV_Assert(fs.isOpened());
+    FileNode fn = objname.empty() ? fs.getFirstTopLevelNode() : fs[objname];
+    if (fn.empty())
+      return Ptr<_Tp>();
+    Ptr<_Tp> obj = _Tp::create();
+    obj->read(fn);
+    return !obj->empty() ? obj : Ptr<_Tp>();
+  }
+
+  /** @brief Loads algorithm from a String
+
+  @param strModel The string variable containing the model you want to load.
+  @param objname The optional name of the node to read (if empty, the first
+  top-level node will be used)
+
+  This is static template method of Algorithm. It's usage is following (in the
+  case of SVM):
+  @code
+  Ptr<SVM> svm = Algorithm::loadFromString<SVM>(myStringModel);
+  @endcode
+  */
+  template <typename _Tp>
+  static Ptr<_Tp> loadFromString(const String &strModel,
+                                 const String &objname = String()) {
+    FileStorage fs(strModel, FileStorage::READ + FileStorage::MEMORY);
+    FileNode fn = objname.empty() ? fs.getFirstTopLevelNode() : fs[objname];
+    Ptr<_Tp> obj = _Tp::create();
+    obj->read(fn);
+    return !obj->empty() ? obj : Ptr<_Tp>();
+  }
+
+  /** Saves the algorithm to a file.
+  In order to make this method work, the derived class must implement
+  Algorithm::write(FileStorage& fs). */
+  CV_WRAP virtual void save(const String &filename) const;
+
+  /** Returns the algorithm string identifier.
+  This string is used as top level xml/yml node tag when the object is saved to
+  a file or string. */
+  CV_WRAP virtual String getDefaultName() const;
+
+protected:
+  void writeFormat(FileStorage &fs) const;
+};
+
+enum struct Param {
+  INT = 0,
+  BOOLEAN = 1,
+  REAL = 2,
+  STRING = 3,
+  MAT = 4,
+  MAT_VECTOR = 5,
+  ALGORITHM = 6,
+  FLOAT = 7,
+  UNSIGNED_INT = 8,
+  UINT64 = 9,
+  UCHAR = 11,
+  SCALAR = 12
+};
+
+template <> struct ParamType<bool> {
+  typedef bool const_param_type;
+  typedef bool member_type;
+
+  static const Param type = Param::BOOLEAN;
+};
+
+template <> struct ParamType<int> {
+  typedef int const_param_type;
+  typedef int member_type;
+
+  static const Param type = Param::INT;
+};
+
+template <> struct ParamType<double> {
+  typedef double const_param_type;
+  typedef double member_type;
+
+  static const Param type = Param::REAL;
+};
+
+template <> struct ParamType<String> {
+  typedef const String &const_param_type;
+  typedef String member_type;
+
+  static const Param type = Param::STRING;
+};
+
+template <> struct ParamType<Mat> {
+  typedef const Mat &const_param_type;
+  typedef Mat member_type;
+
+  static const Param type = Param::MAT;
+};
+
+template <> struct ParamType<std::vector<Mat>> {
+  typedef const std::vector<Mat> &const_param_type;
+  typedef std::vector<Mat> member_type;
+
+  static const Param type = Param::MAT_VECTOR;
+};
+
+template <> struct ParamType<Algorithm> {
+  typedef const Ptr<Algorithm> &const_param_type;
+  typedef Ptr<Algorithm> member_type;
+
+  static const Param type = Param::ALGORITHM;
+};
+
+template <> struct ParamType<float> {
+  typedef float const_param_type;
+  typedef float member_type;
+
+  static const Param type = Param::FLOAT;
+};
+
+template <> struct ParamType<unsigned> {
+  typedef unsigned const_param_type;
+  typedef unsigned member_type;
+
+  static const Param type = Param::UNSIGNED_INT;
+};
+
+template <> struct ParamType<uint64> {
+  typedef uint64 const_param_type;
+  typedef uint64 member_type;
+
+  static const Param type = Param::UINT64;
+};
+
+template <> struct ParamType<uchar> {
+  typedef uchar const_param_type;
+  typedef uchar member_type;
+
+  static const Param type = Param::UCHAR;
+};
+
+template <> struct ParamType<Scalar> {
+  typedef const Scalar &const_param_type;
+  typedef Scalar member_type;
+
+  static const Param type = Param::SCALAR;
+};
+
+template <typename _Tp>
+struct ParamType<_Tp, typename std::enable_if<std::is_enum<_Tp>::value>::type> {
+  typedef typename std::underlying_type<_Tp>::type const_param_type;
+  typedef typename std::underlying_type<_Tp>::type member_type;
+
+  static const Param type = Param::INT;
+};
+
+//! @} core_basic
+
+} // namespace cv
+
+#include "opencv2/core/cvstd.inl.hpp"
+#include "opencv2/core/operations.hpp"
+#include "opencv2/core/optim.hpp"
+#include "opencv2/core/utility.hpp"
+
+#endif /*OPENCV_CORE_HPP*/