react-native-executorch 0.4.7 → 0.5.0

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

@@ -0,0 +1,735 @@
+/*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-2008, Intel Corporation, all rights reserved.
+// Copyright (C) 2009, Willow Garage Inc., all rights reserved.
+// Copyright (C) 2013, OpenCV Foundation, all rights reserved.
+// Copyright (C) 2014, 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_BASE_HPP
+#define OPENCV_CORE_BASE_HPP
+
+#ifndef __cplusplus
+#error base.hpp header must be compiled as C++
+#endif
+
+#include "opencv2/opencv_modules.hpp"
+
+#include <algorithm>
+#include <climits>
+
+#include "opencv2/core/cvdef.h"
+#include "opencv2/core/cvstd.hpp"
+
+namespace cv {
+
+//! @addtogroup core_utils
+//! @{
+
+namespace Error {
+//! error codes
+enum Code {
+  StsOk = 0,          //!< everything is ok
+  StsBackTrace = -1,  //!< pseudo error for back trace
+  StsError = -2,      //!< unknown /unspecified error
+  StsInternal = -3,   //!< internal error (bad state)
+  StsNoMem = -4,      //!< insufficient memory
+  StsBadArg = -5,     //!< function arg/param is bad
+  StsBadFunc = -6,    //!< unsupported function
+  StsNoConv = -7,     //!< iteration didn't converge
+  StsAutoTrace = -8,  //!< tracing
+  HeaderIsNull = -9,  //!< image header is NULL
+  BadImageSize = -10, //!< image size is invalid
+  BadOffset = -11,    //!< offset is invalid
+  BadDataPtr = -12,   //!<
+  BadStep = -13, //!< image step is wrong, this may happen for a non-continuous
+                 //!< matrix.
+  BadModelOrChSeq = -14, //!<
+  BadNumChannels = -15, //!< bad number of channels, for example, some functions
+                        //!< accept only single channel matrices.
+  BadNumChannel1U = -16, //!<
+  BadDepth = -17,        //!< input image depth is not supported by the function
+  BadAlphaChannel = -18, //!<
+  BadOrder = -19,        //!< number of dimensions is out of range
+  BadOrigin = -20,       //!< incorrect input origin
+  BadAlign = -21,        //!< incorrect input align
+  BadCallBack = -22,     //!<
+  BadTileSize = -23,     //!<
+  BadCOI = -24,          //!< input COI is not supported
+  BadROISize = -25,      //!< incorrect input roi
+  MaskIsTiled = -26,     //!<
+  StsNullPtr = -27,      //!< null pointer
+  StsVecLengthErr = -28, //!< incorrect vector length
+  StsFilterStructContentErr = -29, //!< incorrect filter structure content
+  StsKernelStructContentErr = -30, //!< incorrect transform kernel content
+  StsFilterOffsetErr = -31,        //!< incorrect filter offset value
+  StsBadSize = -201,   //!< the input/output structure size is incorrect
+  StsDivByZero = -202, //!< division by zero
+  StsInplaceNotSupported = -203, //!< in-place operation is not supported
+  StsObjectNotFound = -204,      //!< request can't be completed
+  StsUnmatchedFormats = -205,    //!< formats of input/output arrays differ
+  StsBadFlag = -206,             //!< flag is wrong or not supported
+  StsBadPoint = -207,            //!< bad CvPoint
+  StsBadMask = -208,             //!< bad format of mask (neither 8uC1 nor 8sC1)
+  StsUnmatchedSizes = -209, //!< sizes of input/output structures do not match
+  StsUnsupportedFormat =
+      -210, //!< the data format/type is not supported by the function
+  StsOutOfRange = -211, //!< some of parameters are out of range
+  StsParseError = -212, //!< invalid syntax/structure of the parsed file
+  StsNotImplemented =
+      -213,               //!< the requested function/feature is not implemented
+  StsBadMemBlock = -214,  //!< an allocated block has been corrupted
+  StsAssert = -215,       //!< assertion failed
+  GpuNotSupported = -216, //!< no CUDA support
+  GpuApiCallError = -217, //!< GPU API call error
+  OpenGlNotSupported = -218, //!< no OpenGL support
+  OpenGlApiCallError = -219, //!< OpenGL API call error
+  OpenCLApiCallError = -220, //!< OpenCL API call error
+  OpenCLDoubleNotSupported = -221,
+  OpenCLInitError = -222, //!< OpenCL initialization error
+  OpenCLNoAMDBlasFft = -223
+};
+} // namespace Error
+
+//! @} core_utils
+
+//! @addtogroup core_array
+//! @{
+
+//! matrix decomposition types
+enum DecompTypes {
+  /** Gaussian elimination with the optimal pivot element chosen. */
+  DECOMP_LU = 0,
+  /** singular value decomposition (SVD) method; the system can be over-defined
+  and/or the matrix src1 can be singular */
+  DECOMP_SVD = 1,
+  /** eigenvalue decomposition; the matrix src1 must be symmetrical */
+  DECOMP_EIG = 2,
+  /** Cholesky \f$LL^T\f$ factorization; the matrix src1 must be symmetrical and
+  positively defined */
+  DECOMP_CHOLESKY = 3,
+  /** QR factorization; the system can be over-defined and/or the matrix src1
+     can be singular */
+  DECOMP_QR = 4,
+  /** while all the previous flags are mutually exclusive, this flag can be used
+  together with any of the previous; it means that the normal equations
+  \f$\texttt{src1}^T\cdot\texttt{src1}\cdot\texttt{dst}=\texttt{src1}^T\texttt{src2}\f$
+  are solved instead of the original system
+  \f$\texttt{src1}\cdot\texttt{dst}=\texttt{src2}\f$ */
+  DECOMP_NORMAL = 16
+};
+
+/** norm types
+
+src1 and src2 denote input arrays.
+*/
+
+enum NormTypes {
+  /**
+  \f[
+  norm =  \forkthree
+  {\|\texttt{src1}\|_{L_{\infty}} =  \max _I | \texttt{src1} (I)|}{if
+  \(\texttt{normType} = \texttt{NORM_INF}\) }
+  {\|\texttt{src1}-\texttt{src2}\|_{L_{\infty}} =  \max _I | \texttt{src1} (I) -
+  \texttt{src2} (I)|}{if  \(\texttt{normType} = \texttt{NORM_INF}\) }
+  {\frac{\|\texttt{src1}-\texttt{src2}\|_{L_{\infty}}
+  }{\|\texttt{src2}\|_{L_{\infty}} }}{if  \(\texttt{normType} =
+  \texttt{NORM_RELATIVE | NORM_INF}\) }
+  \f]
+  */
+  NORM_INF = 1,
+  /**
+  \f[
+  norm =  \forkthree
+  {\| \texttt{src1} \| _{L_1} =  \sum _I | \texttt{src1} (I)|}{if
+  \(\texttt{normType} = \texttt{NORM_L1}\)} { \| \texttt{src1} - \texttt{src2}
+  \| _{L_1} =  \sum _I | \texttt{src1} (I) -  \texttt{src2} (I)|}{if
+  \(\texttt{normType} = \texttt{NORM_L1}\) } {
+  \frac{\|\texttt{src1}-\texttt{src2}\|_{L_1} }{\|\texttt{src2}\|_{L_1}} }{if
+  \(\texttt{normType} = \texttt{NORM_RELATIVE | NORM_L1}\) }
+  \f]*/
+  NORM_L1 = 2,
+  /**
+  \f[
+  norm =  \forkthree
+  { \| \texttt{src1} \| _{L_2} =  \sqrt{\sum_I \texttt{src1}(I)^2} }{if
+  \(\texttt{normType} = \texttt{NORM_L2}\) } { \| \texttt{src1} - \texttt{src2}
+  \| _{L_2} =  \sqrt{\sum_I (\texttt{src1}(I) - \texttt{src2}(I))^2} }{if
+  \(\texttt{normType} = \texttt{NORM_L2}\) } {
+  \frac{\|\texttt{src1}-\texttt{src2}\|_{L_2} }{\|\texttt{src2}\|_{L_2}} }{if
+  \(\texttt{normType} = \texttt{NORM_RELATIVE | NORM_L2}\) }
+  \f]
+  */
+  NORM_L2 = 4,
+  /**
+  \f[
+  norm =  \forkthree
+  { \| \texttt{src1} \| _{L_2} ^{2} = \sum_I \texttt{src1}(I)^2} {if
+  \(\texttt{normType} = \texttt{NORM_L2SQR}\)} { \| \texttt{src1} -
+  \texttt{src2} \| _{L_2} ^{2} =  \sum_I (\texttt{src1}(I) - \texttt{src2}(I))^2
+  }{if  \(\texttt{normType} = \texttt{NORM_L2SQR}\) } {
+  \left(\frac{\|\texttt{src1}-\texttt{src2}\|_{L_2}
+  }{\|\texttt{src2}\|_{L_2}}\right)^2 }{if  \(\texttt{normType} =
+  \texttt{NORM_RELATIVE | NORM_L2SQR}\) }
+  \f]
+  */
+  NORM_L2SQR = 5,
+  /**
+  In the case of one input array, calculates the Hamming distance of the array
+  from zero, In the case of two input arrays, calculates the Hamming distance
+  between the arrays.
+  */
+  NORM_HAMMING = 6,
+  /**
+  Similar to NORM_HAMMING, but in the calculation, each two bits of the input
+  sequence will be added and treated as a single bit to be used in the same
+  calculation as NORM_HAMMING.
+  */
+  NORM_HAMMING2 = 7,
+  NORM_TYPE_MASK =
+      7, //!< bit-mask which can be used to separate norm type from norm flags
+  NORM_RELATIVE = 8, //!< flag
+  NORM_MINMAX = 32   //!< flag
+};
+
+//! comparison types
+enum CmpTypes {
+  CMP_EQ = 0, //!< src1 is equal to src2.
+  CMP_GT = 1, //!< src1 is greater than src2.
+  CMP_GE = 2, //!< src1 is greater than or equal to src2.
+  CMP_LT = 3, //!< src1 is less than src2.
+  CMP_LE = 4, //!< src1 is less than or equal to src2.
+  CMP_NE = 5  //!< src1 is unequal to src2.
+};
+
+//! generalized matrix multiplication flags
+enum GemmFlags {
+  GEMM_1_T = 1, //!< transposes src1
+  GEMM_2_T = 2, //!< transposes src2
+  GEMM_3_T = 4  //!< transposes src3
+};
+
+enum DftFlags {
+  /** performs an inverse 1D or 2D transform instead of the default forward
+      transform. */
+  DFT_INVERSE = 1,
+  /** scales the result: divide it by the number of array elements. Normally, it
+     is combined with DFT_INVERSE. */
+  DFT_SCALE = 2,
+  /** performs a forward or inverse transform of every individual row of the
+     input matrix; this flag enables you to transform multiple vectors
+     simultaneously and can be used to decrease the overhead (which is sometimes
+     several times larger than the processing itself) to perform 3D and
+     higher-dimensional transformations and so forth.*/
+  DFT_ROWS = 4,
+  /** performs a forward transformation of 1D or 2D real array; the result,
+      though being a complex array, has complex-conjugate symmetry (*CCS*, see
+     the function description below for details), and such an array can be
+     packed into a real array of the same size as input, which is the fastest
+     option and which is what the function does by default; however, you may
+     wish to get a full complex array (for simpler spectrum analysis, and so on)
+     - pass the flag to enable the function to produce a full-size complex
+     output array. */
+  DFT_COMPLEX_OUTPUT = 16,
+  /** performs an inverse transformation of a 1D or 2D complex array; the
+      result is normally a complex array of the same size, however, if the input
+     array has conjugate-complex symmetry (for example, it is a result of
+     forward transformation with DFT_COMPLEX_OUTPUT flag), the output is a real
+     array; while the function itself does not check whether the input is
+     symmetrical or not, you can pass the flag and then the function will assume
+     the symmetry and produce the real output array (note that when the input is
+     packed into a real array and inverse transformation is executed, the
+     function treats the input as a packed complex-conjugate symmetrical array,
+     and the output will also be a real array). */
+  DFT_REAL_OUTPUT = 32,
+  /** specifies that input is complex input. If this flag is set, the input must
+     have 2 channels. On the other hand, for backwards compatibility reason, if
+     input has 2 channels, input is already considered complex. */
+  DFT_COMPLEX_INPUT = 64,
+  /** performs an inverse 1D or 2D transform instead of the default forward
+     transform. */
+  DCT_INVERSE = DFT_INVERSE,
+  /** performs a forward or inverse transform of every individual row of the
+     input matrix. This flag enables you to transform multiple vectors
+     simultaneously and can be used to decrease the overhead (which is sometimes
+     several times larger than the processing itself) to perform 3D and
+     higher-dimensional transforms and so forth.*/
+  DCT_ROWS = DFT_ROWS
+};
+
+//! Various border types, image boundaries are denoted with `|`
+//! @see borderInterpolate, copyMakeBorder
+enum BorderTypes {
+  BORDER_CONSTANT = 0,  //!< `iiiiii|abcdefgh|iiiiiii`  with some specified `i`
+  BORDER_REPLICATE = 1, //!< `aaaaaa|abcdefgh|hhhhhhh`
+  BORDER_REFLECT = 2,   //!< `fedcba|abcdefgh|hgfedcb`
+  BORDER_WRAP = 3,      //!< `cdefgh|abcdefgh|abcdefg`
+  BORDER_REFLECT_101 = 4, //!< `gfedcb|abcdefgh|gfedcba`
+  BORDER_TRANSPARENT =
+      5, //!< `uvwxyz|abcdefgh|ijklmno` - Treats outliers as transparent.
+
+  BORDER_REFLECT101 = BORDER_REFLECT_101, //!< same as BORDER_REFLECT_101
+  BORDER_DEFAULT = BORDER_REFLECT_101,    //!< same as BORDER_REFLECT_101
+  BORDER_ISOLATED = 16 //!< Interpolation restricted within the ROI boundaries.
+};
+
+//! @} core_array
+
+//! @addtogroup core_utils
+//! @{
+
+/*! @brief Signals an error and raises the exception.
+
+By default the function prints information about the error to stderr,
+then it either stops if setBreakOnError() had been called before or raises the
+exception. It is possible to alternate error processing by using
+redirectError().
+@param code - error code (Error::Code)
+@param err - error description
+@param func - function name. Available only when the compiler supports getting
+it
+@param file - source file name where the error has occurred
+@param line - line number in the source file where the error has occurred
+@see CV_Error, CV_Error_, CV_Assert, CV_DbgAssert
+ */
+CV_EXPORTS CV_NORETURN void error(int code, const String &err, const char *func,
+                                  const char *file, int line);
+
+/*! @brief Signals an error and terminate application.
+
+By default the function prints information about the error to stderr, then it
+terminates application with std::terminate. The function is designed for
+invariants check in functions and methods with noexcept attribute.
+@param code - error code (Error::Code)
+@param err - error description
+@param func - function name. Available only when the compiler supports getting
+it
+@param file - source file name where the error has occurred
+@param line - line number in the source file where the error has occurred
+@see CV_AssertTerminate
+ */
+CV_EXPORTS CV_NORETURN void terminate(int code, const String &err,
+                                      const char *func, const char *file,
+                                      int line) CV_NOEXCEPT;
+
+#ifdef CV_STATIC_ANALYSIS
+
+// In practice, some macro are not processed correctly (noreturn is not
+// detected). We need to use simplified definition for them.
+#define CV_Error(code, msg)                                                    \
+  do {                                                                         \
+    (void)(code);                                                              \
+    (void)(msg);                                                               \
+    abort();                                                                   \
+  } while (0)
+#define CV_Error_(code, args)                                                  \
+  do {                                                                         \
+    (void)(code);                                                              \
+    (void)(cv::format args);                                                   \
+    abort();                                                                   \
+  } while (0)
+#define CV_Assert(expr)                                                        \
+  do {                                                                         \
+    if (!(expr))                                                               \
+      abort();                                                                 \
+  } while (0)
+
+#else // CV_STATIC_ANALYSIS
+
+/** @brief Call the error handler.
+
+Currently, the error handler prints the error code and the error message to the
+standard error stream `stderr`. In the Debug configuration, it then provokes
+memory access violation, so that the execution stack and all the parameters can
+be analyzed by the debugger. In the Release configuration, the exception is
+thrown.
+
+@param code one of Error::Code
+@param msg error message
+*/
+#define CV_Error(code, msg) cv::error(code, msg, CV_Func, __FILE__, __LINE__)
+
+/**  @brief Call the error handler.
+
+This macro can be used to construct an error message on-fly to include some
+dynamic information, for example:
+@code
+    // note the extra parentheses around the formatted text message
+    CV_Error_(Error::StsOutOfRange,
+    ("the value at (%d, %d)=%g is out of range", badPt.x, badPt.y, badValue));
+@endcode
+@param code one of Error::Code
+@param args printf-like formatted error message in parentheses
+*/
+#define CV_Error_(code, args)                                                  \
+  cv::error(code, cv::format args, CV_Func, __FILE__, __LINE__)
+
+/** @brief Checks a condition at runtime and throws exception if it fails
+
+The macros CV_Assert (and CV_DbgAssert(expr)) evaluate the specified expression.
+If it is 0, the macros raise an error (see cv::error). The macro CV_Assert
+checks the condition in both Debug and Release configurations while CV_DbgAssert
+is only retained in the Debug configuration. CV_AssertTerminate is analog of
+CV_Assert for invariants check in functions with noexcept attribute. It does not
+throw exception, but terminates the application.
+*/
+#define CV_Assert(expr)                                                        \
+  do {                                                                         \
+    if (!!(expr))                                                              \
+      ;                                                                        \
+    else                                                                       \
+      cv::error(cv::Error::StsAssert, #expr, CV_Func, __FILE__, __LINE__);     \
+  } while (0)
+#define CV_AssertTerminate(expr)                                               \
+  do {                                                                         \
+    if (!!(expr))                                                              \
+      ;                                                                        \
+    else                                                                       \
+      cv::terminate(#expr, CV_Func, __FILE__, __LINE__);                       \
+  } while (0)
+
+#endif // CV_STATIC_ANALYSIS
+
+//! @cond IGNORED
+#if !defined(__OPENCV_BUILD) // TODO: backward compatibility only
+#ifndef CV_ErrorNoReturn
+#define CV_ErrorNoReturn CV_Error
+#endif
+#ifndef CV_ErrorNoReturn_
+#define CV_ErrorNoReturn_ CV_Error_
+#endif
+#endif
+
+#define CV_Assert_1 CV_Assert
+#define CV_Assert_2(expr, ...)                                                 \
+  CV_Assert_1(expr);                                                           \
+  __CV_EXPAND(CV_Assert_1(__VA_ARGS__))
+#define CV_Assert_3(expr, ...)                                                 \
+  CV_Assert_1(expr);                                                           \
+  __CV_EXPAND(CV_Assert_2(__VA_ARGS__))
+#define CV_Assert_4(expr, ...)                                                 \
+  CV_Assert_1(expr);                                                           \
+  __CV_EXPAND(CV_Assert_3(__VA_ARGS__))
+#define CV_Assert_5(expr, ...)                                                 \
+  CV_Assert_1(expr);                                                           \
+  __CV_EXPAND(CV_Assert_4(__VA_ARGS__))
+#define CV_Assert_6(expr, ...)                                                 \
+  CV_Assert_1(expr);                                                           \
+  __CV_EXPAND(CV_Assert_5(__VA_ARGS__))
+#define CV_Assert_7(expr, ...)                                                 \
+  CV_Assert_1(expr);                                                           \
+  __CV_EXPAND(CV_Assert_6(__VA_ARGS__))
+#define CV_Assert_8(expr, ...)                                                 \
+  CV_Assert_1(expr);                                                           \
+  __CV_EXPAND(CV_Assert_7(__VA_ARGS__))
+#define CV_Assert_9(expr, ...)                                                 \
+  CV_Assert_1(expr);                                                           \
+  __CV_EXPAND(CV_Assert_8(__VA_ARGS__))
+#define CV_Assert_10(expr, ...)                                                \
+  CV_Assert_1(expr);                                                           \
+  __CV_EXPAND(CV_Assert_9(__VA_ARGS__))
+
+#define CV_Assert_N(...)                                                       \
+  do {                                                                         \
+    __CV_EXPAND(                                                               \
+        __CV_CAT(CV_Assert_, __CV_VA_NUM_ARGS(__VA_ARGS__))(__VA_ARGS__));     \
+  } while (0)
+
+//! @endcond
+
+#if defined _DEBUG || defined CV_STATIC_ANALYSIS
+#define CV_DbgAssert(expr) CV_Assert(expr)
+#else
+/** replaced with CV_Assert(expr) in Debug configuration */
+#define CV_DbgAssert(expr)
+#endif
+
+/*
+ * Hamming distance functor - counts the bit differences between two strings -
+ * useful for the Brief descriptor bit count of A exclusive XOR'ed with B
+ */
+struct CV_EXPORTS Hamming {
+  static const NormTypes normType = NORM_HAMMING;
+  typedef unsigned char ValueType;
+  typedef int ResultType;
+
+  /** this will count the bits in a ^ b
+   */
+  ResultType operator()(const unsigned char *a, const unsigned char *b,
+                        int size) const;
+};
+
+typedef Hamming HammingLUT;
+
+/////////////////////////////////// inline norms
+///////////////////////////////////////
+
+template <typename _Tp> inline _Tp cv_abs(_Tp x) { return std::abs(x); }
+inline int cv_abs(uchar x) { return x; }
+inline int cv_abs(schar x) { return std::abs(x); }
+inline int cv_abs(ushort x) { return x; }
+inline int cv_abs(short x) { return std::abs(x); }
+
+template <typename _Tp, typename _AccTp>
+static inline _AccTp normL2Sqr(const _Tp *a, int n) {
+  _AccTp s = 0;
+  int i = 0;
+#if CV_ENABLE_UNROLLED
+  for (; i <= n - 4; i += 4) {
+    _AccTp v0 = a[i], v1 = a[i + 1], v2 = a[i + 2], v3 = a[i + 3];
+    s += v0 * v0 + v1 * v1 + v2 * v2 + v3 * v3;
+  }
+#endif
+  for (; i < n; i++) {
+    _AccTp v = a[i];
+    s += v * v;
+  }
+  return s;
+}
+
+template <typename _Tp, typename _AccTp>
+static inline _AccTp normL1(const _Tp *a, int n) {
+  _AccTp s = 0;
+  int i = 0;
+#if CV_ENABLE_UNROLLED
+  for (; i <= n - 4; i += 4) {
+    s += (_AccTp)cv_abs(a[i]) + (_AccTp)cv_abs(a[i + 1]) +
+         (_AccTp)cv_abs(a[i + 2]) + (_AccTp)cv_abs(a[i + 3]);
+  }
+#endif
+  for (; i < n; i++)
+    s += cv_abs(a[i]);
+  return s;
+}
+
+template <typename _Tp, typename _AccTp>
+static inline _AccTp normInf(const _Tp *a, int n) {
+  _AccTp s = 0;
+  for (int i = 0; i < n; i++)
+    s = std::max(s, (_AccTp)cv_abs(a[i]));
+  return s;
+}
+
+template <typename _Tp, typename _AccTp>
+static inline _AccTp normL2Sqr(const _Tp *a, const _Tp *b, int n) {
+  _AccTp s = 0;
+  int i = 0;
+#if CV_ENABLE_UNROLLED
+  for (; i <= n - 4; i += 4) {
+    _AccTp v0 = _AccTp(a[i] - b[i]), v1 = _AccTp(a[i + 1] - b[i + 1]),
+           v2 = _AccTp(a[i + 2] - b[i + 2]), v3 = _AccTp(a[i + 3] - b[i + 3]);
+    s += v0 * v0 + v1 * v1 + v2 * v2 + v3 * v3;
+  }
+#endif
+  for (; i < n; i++) {
+    _AccTp v = _AccTp(a[i] - b[i]);
+    s += v * v;
+  }
+  return s;
+}
+
+static inline float normL2Sqr(const float *a, const float *b, int n) {
+  float s = 0.f;
+  for (int i = 0; i < n; i++) {
+    float v = a[i] - b[i];
+    s += v * v;
+  }
+  return s;
+}
+
+template <typename _Tp, typename _AccTp>
+static inline _AccTp normL1(const _Tp *a, const _Tp *b, int n) {
+  _AccTp s = 0;
+  int i = 0;
+#if CV_ENABLE_UNROLLED
+  for (; i <= n - 4; i += 4) {
+    _AccTp v0 = _AccTp(a[i] - b[i]), v1 = _AccTp(a[i + 1] - b[i + 1]),
+           v2 = _AccTp(a[i + 2] - b[i + 2]), v3 = _AccTp(a[i + 3] - b[i + 3]);
+    s += std::abs(v0) + std::abs(v1) + std::abs(v2) + std::abs(v3);
+  }
+#endif
+  for (; i < n; i++) {
+    _AccTp v = _AccTp(a[i] - b[i]);
+    s += std::abs(v);
+  }
+  return s;
+}
+
+inline float normL1(const float *a, const float *b, int n) {
+  float s = 0.f;
+  for (int i = 0; i < n; i++) {
+    s += std::abs(a[i] - b[i]);
+  }
+  return s;
+}
+
+inline int normL1(const uchar *a, const uchar *b, int n) {
+  int s = 0;
+  for (int i = 0; i < n; i++) {
+    s += std::abs(a[i] - b[i]);
+  }
+  return s;
+}
+
+template <typename _Tp, typename _AccTp>
+static inline _AccTp normInf(const _Tp *a, const _Tp *b, int n) {
+  _AccTp s = 0;
+  for (int i = 0; i < n; i++) {
+    _AccTp v0 = a[i] - b[i];
+    s = std::max(s, std::abs(v0));
+  }
+  return s;
+}
+
+/** @brief Computes the cube root of an argument.
+
+ The function cubeRoot computes \f$\sqrt[3]{\texttt{val}}\f$. Negative arguments
+ are handled correctly. NaN and Inf are not handled. The accuracy approaches the
+ maximum possible accuracy for single-precision data.
+ @param val A function argument.
+ */
+CV_EXPORTS_W float cubeRoot(float val);
+
+/** @overload
+
+cubeRoot with argument of `double` type calls `std::cbrt(double)`
+*/
+static inline double cubeRoot(double val) { return std::cbrt(val); }
+
+/** @brief Calculates the angle of a 2D vector in degrees.
+
+ The function fastAtan2 calculates the full-range angle of an input 2D vector.
+ The angle is measured in degrees and varies from 0 to 360 degrees. The accuracy
+ is about 0.3 degrees.
+ @param x x-coordinate of the vector.
+ @param y y-coordinate of the vector.
+ */
+CV_EXPORTS_W float fastAtan2(float y, float x);
+
+/** proxy for hal::LU */
+CV_EXPORTS int LU(float *A, size_t astep, int m, float *b, size_t bstep, int n);
+/** proxy for hal::LU */
+CV_EXPORTS int LU(double *A, size_t astep, int m, double *b, size_t bstep,
+                  int n);
+/** proxy for hal::Cholesky */
+CV_EXPORTS bool Cholesky(float *A, size_t astep, int m, float *b, size_t bstep,
+                         int n);
+/** proxy for hal::Cholesky */
+CV_EXPORTS bool Cholesky(double *A, size_t astep, int m, double *b,
+                         size_t bstep, int n);
+
+////////////////// forward declarations for important OpenCV types
+/////////////////////
+
+//! @cond IGNORED
+
+template <typename _Tp, int cn> class Vec;
+template <typename _Tp, int m, int n> class Matx;
+
+template <typename _Tp> class Complex;
+template <typename _Tp> class Point_;
+template <typename _Tp> class Point3_;
+template <typename _Tp> class Size_;
+template <typename _Tp> class Rect_;
+template <typename _Tp> class Scalar_;
+
+class CV_EXPORTS RotatedRect;
+class CV_EXPORTS Range;
+class CV_EXPORTS TermCriteria;
+class CV_EXPORTS KeyPoint;
+class CV_EXPORTS DMatch;
+class CV_EXPORTS RNG;
+
+class CV_EXPORTS Mat;
+class CV_EXPORTS MatExpr;
+
+class CV_EXPORTS SparseMat;
+typedef Mat MatND;
+
+template <typename _Tp> class Mat_;
+template <typename _Tp> class SparseMat_;
+
+class CV_EXPORTS MatConstIterator;
+class CV_EXPORTS SparseMatIterator;
+class CV_EXPORTS SparseMatConstIterator;
+template <typename _Tp> class MatIterator_;
+template <typename _Tp> class MatConstIterator_;
+template <typename _Tp> class SparseMatIterator_;
+template <typename _Tp> class SparseMatConstIterator_;
+
+namespace ipp {
+CV_EXPORTS unsigned long long getIppFeatures();
+CV_EXPORTS void setIppStatus(int status, const char *const funcname = NULL,
+                             const char *const filename = NULL, int line = 0);
+CV_EXPORTS int getIppStatus();
+CV_EXPORTS String getIppErrorLocation();
+CV_EXPORTS_W bool useIPP();
+CV_EXPORTS_W void setUseIPP(bool flag);
+CV_EXPORTS_W String getIppVersion();
+
+// IPP Not-Exact mode. This function may force use of IPP then both IPP and
+// OpenCV provide proper results but have internal accuracy differences which
+// have too much direct or indirect impact on accuracy tests.
+CV_EXPORTS_W bool useIPP_NotExact();
+CV_EXPORTS_W void setUseIPP_NotExact(bool flag);
+#ifndef DISABLE_OPENCV_3_COMPATIBILITY
+static inline bool useIPP_NE() { return useIPP_NotExact(); }
+static inline void setUseIPP_NE(bool flag) { setUseIPP_NotExact(flag); }
+#endif
+
+} // namespace ipp
+
+//! @endcond
+
+//! @} core_utils
+
+} // namespace cv
+
+#include "opencv2/core/check.hpp"
+#include "opencv2/core/neon_utils.hpp"
+#include "opencv2/core/vsx_utils.hpp"
+
+#endif // OPENCV_CORE_BASE_HPP