You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
746 lines
27 KiB
746 lines
27 KiB
9 years ago
|
/*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__
|