| /*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*/ | |
| 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 | |
| }; | |
| } //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; | |
| // In practice, some macro are not processed correctly (noreturn is not detected). | |
| // We need to use simplified definition for them. | |
| /** @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 | |
| */ | |
| /** @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 | |
| */ | |
| /** @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. | |
| */ | |
| //! @cond IGNORED | |
| //! @endcond | |
| /** replaced with CV_Assert(expr) in Debug configuration */ | |
| /* | |
| * 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; | |
| 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; | |
| } | |
| 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; | |
| 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]); | |
| } | |
| 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; | |
| 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; | |
| } | |
| 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; | |
| 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); | |
| } | |
| 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 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 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); | |
| static inline bool useIPP_NE() { return useIPP_NotExact(); } | |
| static inline void setUseIPP_NE(bool flag) { setUseIPP_NotExact(flag); } | |
| } // ipp | |
| //! @endcond | |
| //! @} core_utils | |
| } // cv | |