| /*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 <climits> |
| |
| #include "opencv2/core/cvdef.h" |
| #include "opencv2/core/cvstd.hpp" |
| #include "opencv2/hal.hpp" |
| |
| namespace cv |
| { |
| |
| //! @addtogroup core_utils |
| //! @{ |
| |
| namespace Error { |
| //! error codes |
| enum Code { |
| StsOk= 0, //!< everithing 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, //!< iter. 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, //!< |
| BadModelOrChSeq= -14, //!< |
| BadNumChannels= -15, //!< |
| BadNumChannel1U= -16, //!< |
| BadDepth= -17, //!< |
| BadAlphaChannel= -18, //!< |
| BadOrder= -19, //!< |
| BadOrigin= -20, //!< |
| BadAlign= -21, //!< |
| BadCallBack= -22, //!< |
| BadTileSize= -23, //!< |
| BadCOI= -24, //!< |
| BadROISize= -25, //!< |
| MaskIsTiled= -26, //!< |
| StsNullPtr= -27, //!< null pointer |
| StsVecLengthErr= -28, //!< incorrect vector length |
| StsFilterStructContentErr= -29, //!< incorr. filter structure content |
| StsKernelStructContentErr= -30, //!< incorr. transform kernel content |
| StsFilterOffsetErr= -31, //!< incorrect filter ofset 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, |
| GpuApiCallError= -217, |
| OpenGlNotSupported= -218, |
| OpenGlApiCallError= -219, |
| OpenCLApiCallError= -220, |
| OpenCLDoubleNotSupported= -221, |
| OpenCLInitError= -222, |
| OpenCLNoAMDBlasFft= -223 |
| }; |
| } //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 |
| - For one array: |
| \f[norm = \forkthree{\|\texttt{src1}\|_{L_{\infty}} = \max _I | \texttt{src1} (I)|}{if \(\texttt{normType} = \texttt{NORM\_INF}\) } |
| { \| \texttt{src1} \| _{L_1} = \sum _I | \texttt{src1} (I)|}{if \(\texttt{normType} = \texttt{NORM\_L1}\) } |
| { \| \texttt{src1} \| _{L_2} = \sqrt{\sum_I \texttt{src1}(I)^2} }{if \(\texttt{normType} = \texttt{NORM\_L2}\) }\f] |
| |
| - Absolute norm for two arrays |
| \f[norm = \forkthree{\|\texttt{src1}-\texttt{src2}\|_{L_{\infty}} = \max _I | \texttt{src1} (I) - \texttt{src2} (I)|}{if \(\texttt{normType} = \texttt{NORM\_INF}\) } |
| { \| \texttt{src1} - \texttt{src2} \| _{L_1} = \sum _I | \texttt{src1} (I) - \texttt{src2} (I)|}{if \(\texttt{normType} = \texttt{NORM\_L1}\) } |
| { \| \texttt{src1} - \texttt{src2} \| _{L_2} = \sqrt{\sum_I (\texttt{src1}(I) - \texttt{src2}(I))^2} }{if \(\texttt{normType} = \texttt{NORM\_L2}\) }\f] |
| |
| - Relative norm for two arrays |
| \f[norm = \forkthree{\frac{\|\texttt{src1}-\texttt{src2}\|_{L_{\infty}} }{\|\texttt{src2}\|_{L_{\infty}} }}{if \(\texttt{normType} = \texttt{NORM\_RELATIVE\_INF}\) } |
| { \frac{\|\texttt{src1}-\texttt{src2}\|_{L_1} }{\|\texttt{src2}\|_{L_1}} }{if \(\texttt{normType} = \texttt{NORM\_RELATIVE\_L1}\) } |
| { \frac{\|\texttt{src1}-\texttt{src2}\|_{L_2} }{\|\texttt{src2}\|_{L_2}} }{if \(\texttt{normType} = \texttt{NORM\_RELATIVE\_L2}\) }\f] |
| */ |
| enum NormTypes { NORM_INF = 1, |
| NORM_L1 = 2, |
| NORM_L2 = 4, |
| NORM_L2SQR = 5, |
| NORM_HAMMING = 6, |
| NORM_HAMMING2 = 7, |
| NORM_TYPE_MASK = 7, |
| 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, |
| /** 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|absdefgh|ijklmno` |
| |
| BORDER_REFLECT101 = BORDER_REFLECT_101, //!< same as BORDER_REFLECT_101 |
| BORDER_DEFAULT = BORDER_REFLECT_101, //!< same as BORDER_REFLECT_101 |
| BORDER_ISOLATED = 16 //!< do not look outside of ROI |
| }; |
| |
| //! @} core_array |
| |
| //! @addtogroup core_utils |
| //! @{ |
| |
| //! @cond IGNORED |
| |
| //////////////// static assert ///////////////// |
| #define CVAUX_CONCAT_EXP(a, b) a##b |
| #define CVAUX_CONCAT(a, b) CVAUX_CONCAT_EXP(a,b) |
| |
| #if defined(__clang__) |
| # ifndef __has_extension |
| # define __has_extension __has_feature /* compatibility, for older versions of clang */ |
| # endif |
| # if __has_extension(cxx_static_assert) |
| # define CV_StaticAssert(condition, reason) static_assert((condition), reason " " #condition) |
| # endif |
| #elif defined(__GNUC__) |
| # if (defined(__GXX_EXPERIMENTAL_CXX0X__) || __cplusplus >= 201103L) |
| # define CV_StaticAssert(condition, reason) static_assert((condition), reason " " #condition) |
| # endif |
| #elif defined(_MSC_VER) |
| # if _MSC_VER >= 1600 /* MSVC 10 */ |
| # define CV_StaticAssert(condition, reason) static_assert((condition), reason " " #condition) |
| # endif |
| #endif |
| #ifndef CV_StaticAssert |
| # if defined(__GNUC__) && (__GNUC__ > 3) && (__GNUC_MINOR__ > 2) |
| # define CV_StaticAssert(condition, reason) ({ extern int __attribute__((error("CV_StaticAssert: " reason " " #condition))) CV_StaticAssert(); ((condition) ? 0 : CV_StaticAssert()); }) |
| # else |
| template <bool x> struct CV_StaticAssert_failed; |
| template <> struct CV_StaticAssert_failed<true> { enum { val = 1 }; }; |
| template<int x> struct CV_StaticAssert_test {}; |
| # define CV_StaticAssert(condition, reason)\ |
| typedef cv::CV_StaticAssert_test< sizeof(cv::CV_StaticAssert_failed< static_cast<bool>(condition) >) > CVAUX_CONCAT(CV_StaticAssert_failed_at_, __LINE__) |
| # endif |
| #endif |
| |
| // Suppress warning "-Wdeprecated-declarations" / C4996 |
| #if defined(_MSC_VER) |
| #define CV_DO_PRAGMA(x) __pragma(x) |
| #elif defined(__GNUC__) |
| #define CV_DO_PRAGMA(x) _Pragma (#x) |
| #else |
| #define CV_DO_PRAGMA(x) |
| #endif |
| |
| #ifdef _MSC_VER |
| #define CV_SUPPRESS_DEPRECATED_START \ |
| CV_DO_PRAGMA(warning(push)) \ |
| CV_DO_PRAGMA(warning(disable: 4996)) |
| #define CV_SUPPRESS_DEPRECATED_END CV_DO_PRAGMA(warning(pop)) |
| #elif defined (__clang__) || ((__GNUC__) && ((__GNUC__ > 4) || ((__GNUC__ == 4) && (__GNUC_MINOR__ > 5)))) |
| #define CV_SUPPRESS_DEPRECATED_START \ |
| CV_DO_PRAGMA(GCC diagnostic push) \ |
| CV_DO_PRAGMA(GCC diagnostic ignored "-Wdeprecated-declarations") |
| #define CV_SUPPRESS_DEPRECATED_END CV_DO_PRAGMA(GCC diagnostic pop) |
| #else |
| #define CV_SUPPRESS_DEPRECATED_START |
| #define CV_SUPPRESS_DEPRECATED_END |
| #endif |
| //! @endcond |
| |
| /*! @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 occured |
| @param _line - line number in the source file where the error has occured |
| @see CV_Error, CV_Error_, CV_ErrorNoReturn, CV_ErrorNoReturn_, CV_Assert, CV_DbgAssert |
| */ |
| CV_EXPORTS void error(int _code, const String& _err, const char* _func, const char* _file, int _line); |
| |
| #ifdef __GNUC__ |
| # if defined __clang__ || defined __APPLE__ |
| # pragma GCC diagnostic push |
| # pragma GCC diagnostic ignored "-Winvalid-noreturn" |
| # endif |
| #endif |
| |
| /** same as cv::error, but does not return */ |
| CV_INLINE CV_NORETURN void errorNoReturn(int _code, const String& _err, const char* _func, const char* _file, int _line) |
| { |
| error(_code, _err, _func, _file, _line); |
| #ifdef __GNUC__ |
| # if !defined __clang__ && !defined __APPLE__ |
| // this suppresses this warning: "noreturn" function does return [enabled by default] |
| __builtin_trap(); |
| // or use infinite loop: for (;;) {} |
| # endif |
| #endif |
| } |
| #ifdef __GNUC__ |
| # if defined __clang__ || defined __APPLE__ |
| # pragma GCC diagnostic pop |
| # endif |
| #endif |
| |
| #if defined __GNUC__ |
| #define CV_Func __func__ |
| #elif defined _MSC_VER |
| #define CV_Func __FUNCTION__ |
| #else |
| #define CV_Func "" |
| #endif |
| |
| /** @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_( CV_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. |
| */ |
| #define CV_Assert( expr ) if(!!(expr)) ; else cv::error( cv::Error::StsAssert, #expr, CV_Func, __FILE__, __LINE__ ) |
| |
| /** same as CV_Error(code,msg), but does not return */ |
| #define CV_ErrorNoReturn( code, msg ) cv::errorNoReturn( code, msg, CV_Func, __FILE__, __LINE__ ) |
| |
| /** same as CV_Error_(code,args), but does not return */ |
| #define CV_ErrorNoReturn_( code, args ) cv::errorNoReturn( code, cv::format args, CV_Func, __FILE__, __LINE__ ) |
| |
| /** replaced with CV_Assert(expr) in Debug configuration */ |
| #ifdef _DEBUG |
| # define CV_DbgAssert(expr) CV_Assert(expr) |
| #else |
| # 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 |
| { |
| enum { 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); |
| |
| /** @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 UMat; |
| |
| 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 ogl |
| { |
| class CV_EXPORTS Buffer; |
| class CV_EXPORTS Texture2D; |
| class CV_EXPORTS Arrays; |
| } |
| |
| namespace cuda |
| { |
| class CV_EXPORTS GpuMat; |
| class CV_EXPORTS HostMem; |
| class CV_EXPORTS Stream; |
| class CV_EXPORTS Event; |
| } |
| |
| namespace cudev |
| { |
| template <typename _Tp> class GpuMat_; |
| } |
| |
| namespace ipp |
| { |
| 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 bool useIPP(); |
| CV_EXPORTS void setUseIPP(bool flag); |
| |
| } // ipp |
| |
| //! @endcond |
| |
| //! @} core_utils |
| |
| //! @addtogroup core_utils_neon |
| //! @{ |
| |
| #if CV_NEON |
| |
| inline int32x2_t cv_vrnd_s32_f32(float32x2_t v) |
| { |
| static int32x2_t v_sign = vdup_n_s32(1 << 31), |
| v_05 = vreinterpret_s32_f32(vdup_n_f32(0.5f)); |
| |
| int32x2_t v_addition = vorr_s32(v_05, vand_s32(v_sign, vreinterpret_s32_f32(v))); |
| return vcvt_s32_f32(vadd_f32(v, vreinterpret_f32_s32(v_addition))); |
| } |
| |
| inline int32x4_t cv_vrndq_s32_f32(float32x4_t v) |
| { |
| static int32x4_t v_sign = vdupq_n_s32(1 << 31), |
| v_05 = vreinterpretq_s32_f32(vdupq_n_f32(0.5f)); |
| |
| int32x4_t v_addition = vorrq_s32(v_05, vandq_s32(v_sign, vreinterpretq_s32_f32(v))); |
| return vcvtq_s32_f32(vaddq_f32(v, vreinterpretq_f32_s32(v_addition))); |
| } |
| |
| inline uint32x2_t cv_vrnd_u32_f32(float32x2_t v) |
| { |
| static float32x2_t v_05 = vdup_n_f32(0.5f); |
| return vcvt_u32_f32(vadd_f32(v, v_05)); |
| } |
| |
| inline uint32x4_t cv_vrndq_u32_f32(float32x4_t v) |
| { |
| static float32x4_t v_05 = vdupq_n_f32(0.5f); |
| return vcvtq_u32_f32(vaddq_f32(v, v_05)); |
| } |
| |
| inline float32x4_t cv_vrecpq_f32(float32x4_t val) |
| { |
| float32x4_t reciprocal = vrecpeq_f32(val); |
| reciprocal = vmulq_f32(vrecpsq_f32(val, reciprocal), reciprocal); |
| reciprocal = vmulq_f32(vrecpsq_f32(val, reciprocal), reciprocal); |
| return reciprocal; |
| } |
| |
| inline float32x2_t cv_vrecp_f32(float32x2_t val) |
| { |
| float32x2_t reciprocal = vrecpe_f32(val); |
| reciprocal = vmul_f32(vrecps_f32(val, reciprocal), reciprocal); |
| reciprocal = vmul_f32(vrecps_f32(val, reciprocal), reciprocal); |
| return reciprocal; |
| } |
| |
| inline float32x4_t cv_vrsqrtq_f32(float32x4_t val) |
| { |
| float32x4_t e = vrsqrteq_f32(val); |
| e = vmulq_f32(vrsqrtsq_f32(vmulq_f32(e, e), val), e); |
| e = vmulq_f32(vrsqrtsq_f32(vmulq_f32(e, e), val), e); |
| return e; |
| } |
| |
| inline float32x2_t cv_vrsqrt_f32(float32x2_t val) |
| { |
| float32x2_t e = vrsqrte_f32(val); |
| e = vmul_f32(vrsqrts_f32(vmul_f32(e, e), val), e); |
| e = vmul_f32(vrsqrts_f32(vmul_f32(e, e), val), e); |
| return e; |
| } |
| |
| inline float32x4_t cv_vsqrtq_f32(float32x4_t val) |
| { |
| return cv_vrecpq_f32(cv_vrsqrtq_f32(val)); |
| } |
| |
| inline float32x2_t cv_vsqrt_f32(float32x2_t val) |
| { |
| return cv_vrecp_f32(cv_vrsqrt_f32(val)); |
| } |
| |
| #endif |
| |
| //! @} core_utils_neon |
| |
| } // cv |
| |
| #include "sse_utils.hpp" |
| |
| #endif //__OPENCV_CORE_BASE_HPP__ |