OpenCV 4.5.3(日本語機械翻訳)
base.hpp
1 /*M///////////////////////////////////////////////////////////////////////////////////////
2 //
3 // IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
4 //
5 // By downloading, copying, installing or using the software you agree to this license.
6 // If you do not agree to this license, do not download, install,
7 // copy or use the software.
8 //
9 //
10 // License Agreement
11 // For Open Source Computer Vision Library
12 //
13 // Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
14 // Copyright (C) 2009, Willow Garage Inc., all rights reserved.
15 // Copyright (C) 2013, OpenCV Foundation, all rights reserved.
16 // Copyright (C) 2014, Itseez Inc., all rights reserved.
17 // Third party copyrights are property of their respective owners.
18 //
19 // Redistribution and use in source and binary forms, with or without modification,
20 // are permitted provided that the following conditions are met:
21 //
22 // * Redistribution's of source code must retain the above copyright notice,
23 // this list of conditions and the following disclaimer.
24 //
25 // * Redistribution's in binary form must reproduce the above copyright notice,
26 // this list of conditions and the following disclaimer in the documentation
27 // and/or other materials provided with the distribution.
28 //
29 // * The name of the copyright holders may not be used to endorse or promote products
30 // derived from this software without specific prior written permission.
31 //
32 // This software is provided by the copyright holders and contributors "as is" and
33 // any express or implied warranties, including, but not limited to, the implied
34 // warranties of merchantability and fitness for a particular purpose are disclaimed.
35 // In no event shall the Intel Corporation or contributors be liable for any direct,
36 // indirect, incidental, special, exemplary, or consequential damages
37 // (including, but not limited to, procurement of substitute goods or services;
38 // loss of use, data, or profits; or business interruption) however caused
39 // and on any theory of liability, whether in contract, strict liability,
40 // or tort (including negligence or otherwise) arising in any way out of
41 // the use of this software, even if advised of the possibility of such damage.
42 //
43 //M*/
44
45 #ifndef OPENCV_CORE_BASE_HPP
46 #define OPENCV_CORE_BASE_HPP
47
48 #ifndef __cplusplus
49 # error base.hpp header must be compiled as C++
50 #endif
51
52 #include "opencv2/opencv_modules.hpp"
53
54 #include <climits>
55 #include <algorithm>
56
57 #include "opencv2/core/cvdef.h"
58 #include "opencv2/core/cvstd.hpp"
59
60 namespace cv
61{
62
65
66 namespace Error {
68 enum Code {
69 StsOk= 0,
70 StsBackTrace= -1,
71 StsError= -2,
72 StsInternal= -3,
73 StsNoMem= -4,
74 StsBadArg= -5,
75 StsBadFunc= -6,
76 StsNoConv= -7,
77 StsAutoTrace= -8,
78 HeaderIsNull= -9,
79 BadImageSize= -10,
80 BadOffset= -11,
81 BadDataPtr= -12,
82 BadStep= -13,
83 BadModelOrChSeq= -14,
84 BadNumChannels= -15,
85 BadNumChannel1U= -16,
86 BadDepth= -17,
87 BadAlphaChannel= -18,
88 BadOrder= -19,
89 BadOrigin= -20,
90 BadAlign= -21,
91 BadCallBack= -22,
92 BadTileSize= -23,
93 BadCOI= -24,
94 BadROISize= -25,
95 MaskIsTiled= -26,
96 StsNullPtr= -27,
97 StsVecLengthErr= -28,
98 StsFilterStructContentErr= -29,
99 StsKernelStructContentErr= -30,
100 StsFilterOffsetErr= -31,
101 StsBadSize= -201,
102 StsDivByZero= -202,
103 StsInplaceNotSupported= -203,
104 StsObjectNotFound= -204,
105 StsUnmatchedFormats= -205,
106 StsBadFlag= -206,
107 StsBadPoint= -207,
108 StsBadMask= -208,
109 StsUnmatchedSizes= -209,
110 StsUnsupportedFormat= -210,
111 StsOutOfRange= -211,
112 StsParseError= -212,
113 StsNotImplemented= -213,
114 StsBadMemBlock= -214,
115 StsAssert= -215,
116 GpuNotSupported= -216,
117 GpuApiCallError= -217,
118 OpenGlNotSupported= -218,
119 OpenGlApiCallError= -219,
120 OpenCLApiCallError= -220,
121 OpenCLDoubleNotSupported= -221,
122 OpenCLInitError= -222,
123 OpenCLNoAMDBlasFft= -223
124};
125} //Error
126
128
131
133 enum DecompTypes {
135 DECOMP_LU = 0,
138 DECOMP_SVD = 1,
140 DECOMP_EIG = 2,
143 DECOMP_CHOLESKY = 3,
145 DECOMP_QR = 4,
151 DECOMP_NORMAL = 16
152 };
153
159 enum NormTypes {
168 NORM_INF = 1,
176 NORM_L1 = 2,
185 NORM_L2 = 4,
194 NORM_L2SQR = 5,
199 NORM_HAMMING = 6,
204 NORM_HAMMING2 = 7,
205 NORM_TYPE_MASK = 7,
206 NORM_RELATIVE = 8,
207 NORM_MINMAX = 32
208 };
209
211 enum CmpTypes { CMP_EQ = 0,
212 CMP_GT = 1,
213 CMP_GE = 2,
214 CMP_LT = 3,
215 CMP_LE = 4,
216 CMP_NE = 5
217 };
218
220 enum GemmFlags { GEMM_1_T = 1,
221 GEMM_2_T = 2,
222 GEMM_3_T = 4
223 };
224
225 enum DftFlags {
228 DFT_INVERSE = 1,
231 DFT_SCALE = 2,
236 DFT_ROWS = 4,
243 DFT_COMPLEX_OUTPUT = 16,
252 DFT_REAL_OUTPUT = 32,
256 DFT_COMPLEX_INPUT = 64,
258 DCT_INVERSE = DFT_INVERSE,
263 DCT_ROWS = DFT_ROWS
264 };
265
268 enum BorderTypes {
269 BORDER_CONSTANT = 0,
270 BORDER_REPLICATE = 1,
271 BORDER_REFLECT = 2,
272 BORDER_WRAP = 3,
273 BORDER_REFLECT_101 = 4,
274 BORDER_TRANSPARENT = 5,
275
276 BORDER_REFLECT101 = BORDER_REFLECT_101,
277 BORDER_DEFAULT = BORDER_REFLECT_101,
278 BORDER_ISOLATED = 16
279 };
280
282
285
298 CV_EXPORTS CV_NORETURN void error(int _code, const String& _err, const char* _func, const char* _file, int _line);
299
300 #ifdef CV_STATIC_ANALYSIS
301
302 // In practice, some macro are not processed correctly (noreturn is not detected).
303 // We need to use simplified definition for them.
304 #define CV_Error(code, msg) do { (void)(code); (void)(msg); abort(); } while (0)
305 #define CV_Error_(code, args) do { (void)(code); (void)(cv::format args); abort(); } while (0)
306 #define CV_Assert( expr ) do { if (!(expr)) abort(); } while (0)
307
308 #else // CV_STATIC_ANALYSIS
309
320 #define CV_Error( code, msg ) cv::error( code, msg, CV_Func, __FILE__, __LINE__ )
321
334 #define CV_Error_( code, args ) cv::error( code, cv::format args, CV_Func, __FILE__, __LINE__ )
335
342 #define CV_Assert( expr ) do { if(!!(expr)) ; else cv::error( cv::Error::StsAssert, #expr, CV_Func, __FILE__, __LINE__ ); } while(0)
343
344 #endif // CV_STATIC_ANALYSIS
345
347 #if !defined(__OPENCV_BUILD) // TODO: backward compatibility only
348 #ifndef CV_ErrorNoReturn
349 #define CV_ErrorNoReturn CV_Error
350 #endif
351 #ifndef CV_ErrorNoReturn_
352 #define CV_ErrorNoReturn_ CV_Error_
353 #endif
354 #endif
355
356 #define CV_Assert_1 CV_Assert
357 #define CV_Assert_2( expr, ... ) CV_Assert_1(expr); __CV_EXPAND(CV_Assert_1( __VA_ARGS__ ))
358 #define CV_Assert_3( expr, ... ) CV_Assert_1(expr); __CV_EXPAND(CV_Assert_2( __VA_ARGS__ ))
359 #define CV_Assert_4( expr, ... ) CV_Assert_1(expr); __CV_EXPAND(CV_Assert_3( __VA_ARGS__ ))
360 #define CV_Assert_5( expr, ... ) CV_Assert_1(expr); __CV_EXPAND(CV_Assert_4( __VA_ARGS__ ))
361 #define CV_Assert_6( expr, ... ) CV_Assert_1(expr); __CV_EXPAND(CV_Assert_5( __VA_ARGS__ ))
362 #define CV_Assert_7( expr, ... ) CV_Assert_1(expr); __CV_EXPAND(CV_Assert_6( __VA_ARGS__ ))
363 #define CV_Assert_8( expr, ... ) CV_Assert_1(expr); __CV_EXPAND(CV_Assert_7( __VA_ARGS__ ))
364 #define CV_Assert_9( expr, ... ) CV_Assert_1(expr); __CV_EXPAND(CV_Assert_8( __VA_ARGS__ ))
365 #define CV_Assert_10( expr, ... ) CV_Assert_1(expr); __CV_EXPAND(CV_Assert_9( __VA_ARGS__ ))
366
367 #define CV_Assert_N(...) do { __CV_EXPAND(__CV_CAT(CV_Assert_, __CV_VA_NUM_ARGS(__VA_ARGS__)) (__VA_ARGS__)); } while(0)
368
370
371 #if defined _DEBUG || defined CV_STATIC_ANALYSIS
372 # define CV_DbgAssert(expr) CV_Assert(expr)
373 #else
375 # define CV_DbgAssert(expr)
376 #endif
377
378 /*
379 * Hamming distance functor - counts the bit differences between two strings - useful for the Brief descriptor
380 * bit count of A exclusive XOR'ed with B
381 */
382 struct CV_EXPORTS Hamming
383{
384 static const NormTypes normType = NORM_HAMMING;
385 typedef unsigned char ValueType;
386 typedef int ResultType;
387
390 ResultType operator()( const unsigned char* a, const unsigned char* b, int size ) const;
391};
392
393 typedef Hamming HammingLUT;
394
396
397 template<typename _Tp> inline _Tp cv_abs(_Tp x) { return std::abs(x); }
398 inline int cv_abs(uchar x) { return x; }
399 inline int cv_abs(schar x) { return std::abs(x); }
400 inline int cv_abs(ushort x) { return x; }
401 inline int cv_abs(short x) { return std::abs(x); }
402
403 template<typename _Tp, typename _AccTp> static inline
404_AccTp normL2Sqr(const _Tp* a, int n)
405{
406 _AccTp s = 0;
407 int i=0;
408 #if CV_ENABLE_UNROLLED
409 for( ; i <= n - 4; i += 4 )
410 {
411 _AccTp v0 = a[i], v1 = a[i+1], v2 = a[i+2], v3 = a[i+3];
412 s += v0*v0 + v1*v1 + v2*v2 + v3*v3;
413 }
414 #endif
415 for( ; i < n; i++ )
416 {
417 _AccTp v = a[i];
418 s += v*v;
419 }
420 return s;
421}
422
423 template<typename _Tp, typename _AccTp> static inline
424_AccTp normL1(const _Tp* a, int n)
425{
426 _AccTp s = 0;
427 int i = 0;
428 #if CV_ENABLE_UNROLLED
429 for(; i <= n - 4; i += 4 )
430 {
431 s += (_AccTp)cv_abs(a[i]) + (_AccTp)cv_abs(a[i+1]) +
432 (_AccTp)cv_abs(a[i+2]) + (_AccTp)cv_abs(a[i+3]);
433 }
434 #endif
435 for( ; i < n; i++ )
436 s += cv_abs(a[i]);
437 return s;
438}
439
440 template<typename _Tp, typename _AccTp> static inline
441_AccTp normInf(const _Tp* a, int n)
442{
443 _AccTp s = 0;
444 for( int i = 0; i < n; i++ )
445 s = std::max(s, (_AccTp)cv_abs(a[i]));
446 return s;
447}
448
449 template<typename _Tp, typename _AccTp> static inline
450_AccTp normL2Sqr(const _Tp* a, const _Tp* b, int n)
451{
452 _AccTp s = 0;
453 int i= 0;
454 #if CV_ENABLE_UNROLLED
455 for(; i <= n - 4; i += 4 )
456 {
457 _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]);
458 s += v0*v0 + v1*v1 + v2*v2 + v3*v3;
459 }
460 #endif
461 for( ; i < n; i++ )
462 {
463 _AccTp v = _AccTp(a[i] - b[i]);
464 s += v*v;
465 }
466 return s;
467}
468
469 static inline float normL2Sqr(const float* a, const float* b, int n)
470{
471 float s = 0.f;
472 for( int i = 0; i < n; i++ )
473 {
474 float v = a[i] - b[i];
475 s += v*v;
476 }
477 return s;
478}
479
480 template<typename _Tp, typename _AccTp> static inline
481_AccTp normL1(const _Tp* a, const _Tp* b, int n)
482{
483 _AccTp s = 0;
484 int i= 0;
485 #if CV_ENABLE_UNROLLED
486 for(; i <= n - 4; i += 4 )
487 {
488 _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]);
489 s += std::abs(v0) + std::abs(v1) + std::abs(v2) + std::abs(v3);
490 }
491 #endif
492 for( ; i < n; i++ )
493 {
494 _AccTp v = _AccTp(a[i] - b[i]);
495 s += std::abs(v);
496 }
497 return s;
498}
499
500 inline float normL1(const float* a, const float* b, int n)
501{
502 float s = 0.f;
503 for( int i = 0; i < n; i++ )
504 {
505 s += std::abs(a[i] - b[i]);
506 }
507 return s;
508}
509
510 inline int normL1(const uchar* a, const uchar* b, int n)
511{
512 int s = 0;
513 for( int i = 0; i < n; i++ )
514 {
515 s += std::abs(a[i] - b[i]);
516 }
517 return s;
518}
519
520 template<typename _Tp, typename _AccTp> static inline
521_AccTp normInf(const _Tp* a, const _Tp* b, int n)
522{
523 _AccTp s = 0;
524 for( int i = 0; i < n; i++ )
525 {
526 _AccTp v0 = a[i] - b[i];
527 s = std::max(s, std::abs(v0));
528 }
529 return s;
530}
531
539 CV_EXPORTS_W float cubeRoot(float val);
540
545 static inline
546 double cubeRoot(double val)
547{
548 return std::cbrt(val);
549}
550
558 CV_EXPORTS_W float fastAtan2(float y, float x);
559
561 CV_EXPORTS int LU(float* A, size_t astep, int m, float* b, size_t bstep, int n);
563 CV_EXPORTS int LU(double* A, size_t astep, int m, double* b, size_t bstep, int n);
565 CV_EXPORTS bool Cholesky(float* A, size_t astep, int m, float* b, size_t bstep, int n);
567 CV_EXPORTS bool Cholesky(double* A, size_t astep, int m, double* b, size_t bstep, int n);
568
570
572
573 template<typename _Tp, int cn> class Vec;
574 template<typename _Tp, int m, int n> class Matx;
575
576 template<typename _Tp> class Complex;
577 template<typename _Tp> class Point_;
578 template<typename _Tp> class Point3_;
579 template<typename _Tp> class Size_;
580 template<typename _Tp> class Rect_;
581 template<typename _Tp> class Scalar_;
582
583 class CV_EXPORTS RotatedRect;
584 class CV_EXPORTS Range;
585 class CV_EXPORTS TermCriteria;
586 class CV_EXPORTS KeyPoint;
587 class CV_EXPORTS DMatch;
588 class CV_EXPORTS RNG;
589
590 class CV_EXPORTS Mat;
591 class CV_EXPORTS MatExpr;
592
593 class CV_EXPORTS UMat;
594
595 class CV_EXPORTS SparseMat;
596 typedef Mat MatND;
597
598 template<typename _Tp> class Mat_;
599 template<typename _Tp> class SparseMat_;
600
601 class CV_EXPORTS MatConstIterator;
602 class CV_EXPORTS SparseMatIterator;
603 class CV_EXPORTS SparseMatConstIterator;
604 template<typename _Tp> class MatIterator_;
605 template<typename _Tp> class MatConstIterator_;
606 template<typename _Tp> class SparseMatIterator_;
607 template<typename _Tp> class SparseMatConstIterator_;
608
609 namespace ogl
610{
611 class CV_EXPORTS Buffer;
612 class CV_EXPORTS Texture2D;
613 class CV_EXPORTS Arrays;
614}
615
616 namespace cuda
617{
618 class CV_EXPORTS GpuMat;
619 class CV_EXPORTS HostMem;
620 class CV_EXPORTS Stream;
621 class CV_EXPORTS Event;
622}
623
624 namespace cudev
625{
626 template <typename _Tp> class GpuMat_;
627}
628
629 namespace ipp
630{
631CV_EXPORTS unsigned long long getIppFeatures();
632CV_EXPORTS void setIppStatus(int status, const char * const funcname = NULL, const char * const filename = NULL,
633 int line = 0);
634CV_EXPORTS int getIppStatus();
635CV_EXPORTS String getIppErrorLocation();
636CV_EXPORTS_W bool useIPP();
637CV_EXPORTS_W void setUseIPP(bool flag);
638CV_EXPORTS_W String getIppVersion();
639
640 // IPP Not-Exact mode. This function may force use of IPP then both IPP and OpenCV provide proper results
641 // but have internal accuracy differences which have too much direct or indirect impact on accuracy tests.
642CV_EXPORTS_W bool useIPP_NotExact();
643CV_EXPORTS_W void setUseIPP_NotExact(bool flag);
644 #ifndef DISABLE_OPENCV_3_COMPATIBILITY
645 static inline bool useIPP_NE() { return useIPP_NotExact(); }
646 static inline void setUseIPP_NE(bool flag) { setUseIPP_NotExact(flag); }
647 #endif
648
649} // ipp
650
652
654
655
656
657
658} // cv
659
660 #include "opencv2/core/neon_utils.hpp"
661 #include "opencv2/core/vsx_utils.hpp"
662 #include "opencv2/core/check.hpp"
663
664 #endif //OPENCV_CORE_BASE_HPP
cv::Complex
A complex number class.
Definition: core/types.hpp:75
cv::DMatch
Class for matching keypoint descriptors
Definition: core/types.hpp:809
cv::KeyPoint
Data structure for salient point detectors.
Definition: core/types.hpp:712
cv::Mat_
Template matrix class derived from Mat
Definition: mat.hpp:2199
cv::MatConstIterator_
Matrix read-only iterator
Definition: mat.hpp:3118
cv::MatConstIterator
Definition: mat.hpp:3053
cv::MatExpr
Matrix expression representation This is a list of implemented matrix operations that can be combined...
Definition: mat.hpp:3555
cv::Mat
n-dimensional dense array class
Definition: mat.hpp:802
cv::MatIterator_
Matrix read-write iterator
Definition: mat.hpp:3171
cv::Matx
Template class for small matrices whose type and size are known at compilation time
Definition: matx.hpp:100
cv::Point3_
Template class for 3D points specified by its coordinates x, y and z.
Definition: core/types.hpp:240
cv::Point_
Template class for 2D points specified by its coordinates x and y.
Definition: core/types.hpp:158
cv::RNG
Random Number Generator
Definition: core.hpp:2783
cv::Range
Template class specifying a continuous subsequence (slice) of a sequence.
Definition: core/types.hpp:590
cv::Rect_
Template class for 2D rectangles
Definition: core/types.hpp:421
cv::RotatedRect
The class represents rotated (i.e. not up-right) rectangles on a plane.
Definition: core/types.hpp:504
cv::Scalar_
Template class for a 4-element vector derived from Vec.
Definition: core/types.hpp:637
cv::Size_
Template class for specifying the size of an image or rectangle.
Definition: core/types.hpp:316
cv::SparseMat_
Template sparse n-dimensional array class derived from SparseMat
Definition: mat.hpp:2982
cv::SparseMatConstIterator_
Template Read-Only Sparse Matrix Iterator Class.
Definition: mat.hpp:3307
cv::SparseMatConstIterator
Read-Only Sparse Matrix Iterator.
Definition: mat.hpp:3229
cv::SparseMat
The class SparseMat represents multi-dimensional sparse numerical arrays.
Definition: mat.hpp:2704
cv::SparseMatIterator_
Template Read-Write Sparse Matrix Iterator Class.
Definition: mat.hpp:3341
cv::SparseMatIterator
Read-write Sparse Matrix Iterator
Definition: mat.hpp:3273
cv::TermCriteria
The class defining termination criteria for iterative algorithms.
Definition: core/types.hpp:853
cv::UMat
Definition: mat.hpp:2402
cv::Vec
Template class for short numerical vectors, a partial case of Matx
Definition: matx.hpp:342
cv::CmpTypes
CmpTypes
comparison types
Definition: base.hpp:211
cv::BorderTypes
BorderTypes
Definition: base.hpp:268
cv::max
CV_EXPORTS_W void max(InputArray src1, InputArray src2, OutputArray dst)
Calculates per-element maximum of two arrays or an array and a scalar.
cv::GemmFlags
GemmFlags
generalized matrix multiplication flags
Definition: base.hpp:220
cv::DecompTypes
DecompTypes
matrix decomposition types
Definition: base.hpp:133
cv::NormTypes
NormTypes
Definition: base.hpp:159
cv::DftFlags
DftFlags
Definition: base.hpp:225
cv::CMP_GE
@ CMP_GE
src1 is greater than or equal to src2.
Definition: base.hpp:213
cv::CMP_LE
@ CMP_LE
src1 is less than or equal to src2.
Definition: base.hpp:215
cv::CMP_LT
@ CMP_LT
src1 is less than src2.
Definition: base.hpp:214
cv::CMP_NE
@ CMP_NE
src1 is unequal to src2.
Definition: base.hpp:216
cv::CMP_EQ
@ CMP_EQ
src1 is equal to src2.
Definition: base.hpp:211
cv::CMP_GT
@ CMP_GT
src1 is greater than src2.
Definition: base.hpp:212
cv::BORDER_REFLECT101
@ BORDER_REFLECT101
same as BORDER_REFLECT_101
Definition: base.hpp:276
cv::BORDER_ISOLATED
@ BORDER_ISOLATED
do not look outside of ROI
Definition: base.hpp:278
cv::BORDER_WRAP
@ BORDER_WRAP
cdefgh|abcdefgh|abcdefg
Definition: base.hpp:272
cv::BORDER_REFLECT
@ BORDER_REFLECT
fedcba|abcdefgh|hgfedcb
Definition: base.hpp:271
cv::BORDER_TRANSPARENT
@ BORDER_TRANSPARENT
uvwxyz|abcdefgh|ijklmno
Definition: base.hpp:274
cv::BORDER_REPLICATE
@ BORDER_REPLICATE
aaaaaa|abcdefgh|hhhhhhh
Definition: base.hpp:270
cv::BORDER_REFLECT_101
@ BORDER_REFLECT_101
gfedcb|abcdefgh|gfedcba
Definition: base.hpp:273
cv::BORDER_CONSTANT
@ BORDER_CONSTANT
iiiiii|abcdefgh|iiiiiii with some specified i
Definition: base.hpp:269
cv::BORDER_DEFAULT
@ BORDER_DEFAULT
same as BORDER_REFLECT_101
Definition: base.hpp:277
cv::GEMM_1_T
@ GEMM_1_T
transposes src1
Definition: base.hpp:220
cv::GEMM_2_T
@ GEMM_2_T
transposes src2
Definition: base.hpp:221
cv::GEMM_3_T
@ GEMM_3_T
transposes src3
Definition: base.hpp:222
cv::DECOMP_NORMAL
@ DECOMP_NORMAL
Definition: base.hpp:151
cv::DECOMP_LU
@ DECOMP_LU
Definition: base.hpp:135
cv::DECOMP_CHOLESKY
@ DECOMP_CHOLESKY
Definition: base.hpp:143
cv::DECOMP_EIG
@ DECOMP_EIG
Definition: base.hpp:140
cv::DECOMP_SVD
@ DECOMP_SVD
Definition: base.hpp:138
cv::DECOMP_QR
@ DECOMP_QR
Definition: base.hpp:145
cv::NORM_RELATIVE
@ NORM_RELATIVE
flag
Definition: base.hpp:206
cv::NORM_HAMMING
@ NORM_HAMMING
Definition: base.hpp:199
cv::NORM_L2
@ NORM_L2
Definition: base.hpp:185
cv::NORM_HAMMING2
@ NORM_HAMMING2
Definition: base.hpp:204
cv::NORM_MINMAX
@ NORM_MINMAX
flag
Definition: base.hpp:207
cv::NORM_TYPE_MASK
@ NORM_TYPE_MASK
bit-mask which can be used to separate norm type from norm flags
Definition: base.hpp:205
cv::NORM_L1
@ NORM_L1
Definition: base.hpp:176
cv::NORM_L2SQR
@ NORM_L2SQR
Definition: base.hpp:194
cv::NORM_INF
@ NORM_INF
Definition: base.hpp:168
cv::DFT_COMPLEX_OUTPUT
@ DFT_COMPLEX_OUTPUT
Definition: base.hpp:243
cv::DFT_ROWS
@ DFT_ROWS
Definition: base.hpp:236
cv::DFT_REAL_OUTPUT
@ DFT_REAL_OUTPUT
Definition: base.hpp:252
cv::DCT_ROWS
@ DCT_ROWS
Definition: base.hpp:263
cv::DFT_INVERSE
@ DFT_INVERSE
Definition: base.hpp:228
cv::DFT_SCALE
@ DFT_SCALE
Definition: base.hpp:231
cv::DCT_INVERSE
@ DCT_INVERSE
Definition: base.hpp:258
cv::DFT_COMPLEX_INPUT
@ DFT_COMPLEX_INPUT
Definition: base.hpp:256
cv::abs
softfloat abs(softfloat a)
Absolute value
Definition: softfloat.hpp:444
cv::cbrt
CV_EXPORTS softfloat cbrt(const softfloat &a)
Cube root
cv::LU
CV_EXPORTS int LU(float *A, size_t astep, int m, float *b, size_t bstep, int n)
cv::cubeRoot
CV_EXPORTS_W float cubeRoot(float val)
Computes the cube root of an argument.
cv::error
CV_EXPORTS CV_NORETURN void error(const Exception &exc)
Signals an error and raises the exception.
cv::fastAtan2
CV_EXPORTS_W float fastAtan2(float y, float x)
Calculates the angle of a 2D vector in degrees.
cv::Cholesky
CV_EXPORTS bool Cholesky(float *A, size_t astep, int m, float *b, size_t bstep, int n)
cv::line
CV_EXPORTS_W void line(InputOutputArray img, Point pt1, Point pt2, const Scalar &color, int thickness=1, int lineType=LINE_8, int shift=0)
Draws a line segment connecting two points.
cv
"black box" representation of the file storage associated with a file on disk.
Definition: aruco.hpp:75
cv::Hamming
Definition: base.hpp:383
cv::Hamming::operator()
ResultType operator()(const unsigned char *a, const unsigned char *b, int size) const
構築: doxygen 1.9.2