OpenCV 4.5.3(日本語機械翻訳)
core.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-2015, Intel Corporation, all rights reserved.
14 // Copyright (C) 2009-2011, Willow Garage Inc., all rights reserved.
15 // Copyright (C) 2015, OpenCV Foundation, all rights reserved.
16 // Copyright (C) 2015, 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_HPP
46 #define OPENCV_CORE_HPP
47
48 #ifndef __cplusplus
49 # error core.hpp header must be compiled as C++
50 #endif
51
52 #include "opencv2/core/cvdef.h"
53 #include "opencv2/core/base.hpp"
54 #include "opencv2/core/cvstd.hpp"
55 #include "opencv2/core/traits.hpp"
56 #include "opencv2/core/matx.hpp"
57 #include "opencv2/core/types.hpp"
58 #include "opencv2/core/mat.hpp"
59 #include "opencv2/core/persistence.hpp"
60
106 namespace cv {
107
110
118 class CV_EXPORTS Exception : public std::exception
119{
120 public:
124 Exception();
129 Exception(int _code, const String& _err, const String& _func, const String& _file, int _line);
130 virtual ~Exception() throw();
131
135 virtual const char *what() const throw() CV_OVERRIDE;
136 void formatMessage();
137
138 String msg;
139
140 int code;
141 String err;
142 String func;
143 String file;
144 int line;
145};
146
155 CV_EXPORTS CV_NORETURN void error(const Exception& exc);
156
157 enum SortFlags { SORT_EVERY_ROW = 0,
158 SORT_EVERY_COLUMN = 1,
161 SORT_ASCENDING = 0,
163 SORT_DESCENDING = 16
166 };
167
169
172
174 enum CovarFlags {
182 COVAR_SCRAMBLED = 0,
187 COVAR_NORMAL = 1,
193 COVAR_USE_AVG = 2,
198 COVAR_SCALE = 4,
202 COVAR_ROWS = 8,
206 COVAR_COLS = 16
207 };
208
211
213 enum KmeansFlags {
215 KMEANS_RANDOM_CENTERS = 0,
217 KMEANS_PP_CENTERS = 2,
222 KMEANS_USE_INITIAL_LABELS = 1
223 };
224
226
229
230 enum ReduceTypes { REDUCE_SUM = 0,
231 REDUCE_AVG = 1,
232 REDUCE_MAX = 2,
233 REDUCE_MIN = 3
234 };
235
237
240 CV_EXPORTS void swap(Mat& a, Mat& b);
242 CV_EXPORTS void swap( UMat& a, UMat& b );
243
245
248
270 CV_EXPORTS_W int borderInterpolate(int p, int len, int borderType);
271
320 CV_EXPORTS_W void copyMakeBorder(InputArray src, OutputArray dst,
321 int top, int bottom, int left, int right,
322 int borderType, const Scalar& value = Scalar() );
323
360 CV_EXPORTS_W void add(InputArray src1, InputArray src2, OutputArray dst,
361 InputArray mask = noArray(), int dtype = -1);
362
400 CV_EXPORTS_W void subtract(InputArray src1, InputArray src2, OutputArray dst,
401 InputArray mask = noArray(), int dtype = -1);
402
403
425 CV_EXPORTS_W void multiply(InputArray src1, InputArray src2,
426 OutputArray dst, double scale = 1, int dtype = -1);
427
453 CV_EXPORTS_W void divide(InputArray src1, InputArray src2, OutputArray dst,
454 double scale = 1, int dtype = -1);
455
457 CV_EXPORTS_W void divide(double scale, InputArray src2,
458 OutputArray dst, int dtype = -1);
459
478 CV_EXPORTS_W void scaleAdd(InputArray src1, double alpha, InputArray src2, OutputArray dst);
479
506 CV_EXPORTS_W void addWeighted(InputArray src1, double alpha, InputArray src2,
507 double beta, double gamma, OutputArray dst, int dtype = -1);
508
534 CV_EXPORTS_W void convertScaleAbs(InputArray src, OutputArray dst,
535 double alpha = 1, double beta = 0);
536
547 CV_EXPORTS_W void convertFp16(InputArray src, OutputArray dst);
548
563 CV_EXPORTS_W void LUT(InputArray src, InputArray lut, OutputArray dst);
564
572 CV_EXPORTS_AS(sumElems) Scalar sum(InputArray src);
573
581 CV_EXPORTS_W int countNonZero( InputArray src );
582
609 CV_EXPORTS_W void findNonZero( InputArray src, OutputArray idx );
610
622 CV_EXPORTS_W Scalar mean(InputArray src, InputArray mask = noArray());
623
644 CV_EXPORTS_W void meanStdDev(InputArray src, OutputArray mean, OutputArray stddev,
645 InputArray mask=noArray());
646
683 CV_EXPORTS_W double norm(InputArray src1, int normType = NORM_L2, InputArray mask = noArray());
684
696 CV_EXPORTS_W double norm(InputArray src1, InputArray src2,
697 int normType = NORM_L2, InputArray mask = noArray());
702 CV_EXPORTS double norm( const SparseMat& src, int normType );
703
723 CV_EXPORTS_W double PSNR(InputArray src1, InputArray src2, double R=255.);
724
730 CV_EXPORTS_W void batchDistance(InputArray src1, InputArray src2,
731 OutputArray dist, int dtype, OutputArray nidx,
732 int normType = NORM_L2, int K = 0,
733 InputArray mask = noArray(), int update = 0,
734 bool crosscheck = false);
735
794 CV_EXPORTS_W void normalize( InputArray src, InputOutputArray dst, double alpha = 1, double beta = 0,
795 int norm_type = NORM_L2, int dtype = -1, InputArray mask = noArray());
796
804 CV_EXPORTS void normalize( const SparseMat& src, SparseMat& dst, double alpha, int normType );
805
824 CV_EXPORTS_W void minMaxLoc(InputArray src, CV_OUT double* minVal,
825 CV_OUT double* maxVal = 0, CV_OUT Point* minLoc = 0,
826 CV_OUT Point* maxLoc = 0, InputArray mask = noArray());
827
828
852 CV_EXPORTS void minMaxIdx(InputArray src, double* minVal, double* maxVal = 0,
853 int* minIdx = 0, int* maxIdx = 0, InputArray mask = noArray());
854
864 CV_EXPORTS void minMaxLoc(const SparseMat& a, double* minVal,
865 double* maxVal, int* minIdx = 0, int* maxIdx = 0);
866
891 CV_EXPORTS_W void reduce(InputArray src, OutputArray dst, int dim, int rtype, int dtype = -1);
892
912 CV_EXPORTS void merge(const Mat* mv, size_t count, OutputArray dst);
913
920 CV_EXPORTS_W void merge(InputArrayOfArrays mv, OutputArray dst);
921
937 CV_EXPORTS void split(const Mat& src, Mat* mvbegin);
938
943 CV_EXPORTS_W void split(InputArray m, OutputArrayOfArrays mv);
944
986 CV_EXPORTS void mixChannels(const Mat* src, size_t nsrcs, Mat* dst, size_t ndsts,
987 const int* fromTo, size_t npairs);
988
1003 CV_EXPORTS void mixChannels(InputArrayOfArrays src, InputOutputArrayOfArrays dst,
1004 const int* fromTo, size_t npairs);
1005
1019 CV_EXPORTS_W void mixChannels(InputArrayOfArrays src, InputOutputArrayOfArrays dst,
1020 const std::vector<int>& fromTo);
1021
1028 CV_EXPORTS_W void extractChannel(InputArray src, OutputArray dst, int coi);
1029
1036 CV_EXPORTS_W void insertChannel(InputArray src, InputOutputArray dst, int coi);
1037
1070 CV_EXPORTS_W void flip(InputArray src, OutputArray dst, int flipCode);
1071
1072 enum RotateFlags {
1073 ROTATE_90_CLOCKWISE = 0,
1074 ROTATE_180 = 1,
1075 ROTATE_90_COUNTERCLOCKWISE = 2,
1076};
1088 CV_EXPORTS_W void rotate(InputArray src, OutputArray dst, int rotateCode);
1089
1103 CV_EXPORTS_W void repeat(InputArray src, int ny, int nx, OutputArray dst);
1104
1112 CV_EXPORTS Mat repeat(const Mat& src, int ny, int nx);
1113
1135 CV_EXPORTS void hconcat(const Mat* src, size_t nsrc, OutputArray dst);
1156 CV_EXPORTS void hconcat(InputArray src1, InputArray src2, OutputArray dst);
1175 CV_EXPORTS_W void hconcat(InputArrayOfArrays src, OutputArray dst);
1176
1197 CV_EXPORTS void vconcat(const Mat* src, size_t nsrc, OutputArray dst);
1221 CV_EXPORTS void vconcat(InputArray src1, InputArray src2, OutputArray dst);
1239 CV_EXPORTS_W void vconcat(InputArrayOfArrays src, OutputArray dst);
1240
1266 CV_EXPORTS_W void bitwise_and(InputArray src1, InputArray src2,
1267 OutputArray dst, InputArray mask = noArray());
1268
1293 CV_EXPORTS_W void bitwise_or(InputArray src1, InputArray src2,
1294 OutputArray dst, InputArray mask = noArray());
1295
1321 CV_EXPORTS_W void bitwise_xor(InputArray src1, InputArray src2,
1322 OutputArray dst, InputArray mask = noArray());
1323
1338 CV_EXPORTS_W void bitwise_not(InputArray src, OutputArray dst,
1339 InputArray mask = noArray());
1340
1364 CV_EXPORTS_W void absdiff(InputArray src1, InputArray src2, OutputArray dst);
1365
1376 void CV_EXPORTS_W copyTo(InputArray src, OutputArray dst, InputArray mask);
1396 CV_EXPORTS_W void inRange(InputArray src, InputArray lowerb,
1397 InputArray upperb, OutputArray dst);
1398
1425 CV_EXPORTS_W void compare(InputArray src1, InputArray src2, OutputArray dst, int cmpop);
1426
1438 CV_EXPORTS_W void min(InputArray src1, InputArray src2, OutputArray dst);
1442 CV_EXPORTS void min(const Mat& src1, const Mat& src2, Mat& dst);
1446 CV_EXPORTS void min(const UMat& src1, const UMat& src2, UMat& dst);
1447
1459 CV_EXPORTS_W void max(InputArray src1, InputArray src2, OutputArray dst);
1463 CV_EXPORTS void max(const Mat& src1, const Mat& src2, Mat& dst);
1467 CV_EXPORTS void max(const UMat& src1, const UMat& src2, UMat& dst);
1468
1478 CV_EXPORTS_W void sqrt(InputArray src, OutputArray dst);
1479
1503 CV_EXPORTS_W void pow(InputArray src, double power, OutputArray dst);
1504
1519 CV_EXPORTS_W void exp(InputArray src, OutputArray dst);
1520
1532 CV_EXPORTS_W void log(InputArray src, OutputArray dst);
1533
1554 CV_EXPORTS_W void polarToCart(InputArray magnitude, InputArray angle,
1555 OutputArray x, OutputArray y, bool angleInDegrees = false);
1556
1575 CV_EXPORTS_W void cartToPolar(InputArray x, InputArray y,
1576 OutputArray magnitude, OutputArray angle,
1577 bool angleInDegrees = false);
1578
1595 CV_EXPORTS_W void phase(InputArray x, InputArray y, OutputArray angle,
1596 bool angleInDegrees = false);
1597
1609 CV_EXPORTS_W void magnitude(InputArray x, InputArray y, OutputArray magnitude);
1610
1626 CV_EXPORTS_W bool checkRange(InputArray a, bool quiet = true, CV_OUT Point* pos = 0,
1627 double minVal = -DBL_MAX, double maxVal = DBL_MAX);
1628
1633 CV_EXPORTS_W void patchNaNs(InputOutputArray a, double val = 0);
1634
1663 CV_EXPORTS_W void gemm(InputArray src1, InputArray src2, double alpha,
1664 InputArray src3, double beta, OutputArray dst, int flags = 0);
1665
1694 CV_EXPORTS_W void mulTransposed( InputArray src, OutputArray dst, bool aTa,
1695 InputArray delta = noArray(),
1696 double scale = 1, int dtype = -1 );
1697
1707 CV_EXPORTS_W void transpose(InputArray src, OutputArray dst);
1708
1733 CV_EXPORTS_W void transform(InputArray src, OutputArray dst, InputArray m );
1734
1760 CV_EXPORTS_W void perspectiveTransform(InputArray src, OutputArray dst, InputArray m );
1761
1776 CV_EXPORTS_W void completeSymm(InputOutputArray m, bool lowerToUpper = false);
1777
1793 CV_EXPORTS_W void setIdentity(InputOutputArray mtx, const Scalar& s = Scalar(1));
1794
1808 CV_EXPORTS_W double determinant(InputArray mtx);
1809
1817 CV_EXPORTS_W Scalar trace(InputArray mtx);
1818
1844 CV_EXPORTS_W double invert(InputArray src, OutputArray dst, int flags = DECOMP_LU);
1845
1868 CV_EXPORTS_W bool solve(InputArray src1, InputArray src2,
1869 OutputArray dst, int flags = DECOMP_LU);
1870
1884 CV_EXPORTS_W void sort(InputArray src, OutputArray dst, int flags);
1885
1904 CV_EXPORTS_W void sortIdx(InputArray src, OutputArray dst, int flags);
1905
1919 CV_EXPORTS_W int solveCubic(InputArray coeffs, OutputArray roots);
1920
1929 CV_EXPORTS_W double solvePoly(InputArray coeffs, OutputArray roots, int maxIters = 300);
1930
1950 CV_EXPORTS_W bool eigen(InputArray src, OutputArray eigenvalues,
1951 OutputArray eigenvectors = noArray());
1952
1967 CV_EXPORTS_W void eigenNonSymmetric(InputArray src, OutputArray eigenvalues,
1968 OutputArray eigenvectors);
1969
1983 CV_EXPORTS void calcCovarMatrix( const Mat* samples, int nsamples, Mat& covar, Mat& mean,
1984 int flags, int ctype = CV_64F);
1985
1994 CV_EXPORTS_W void calcCovarMatrix( InputArray samples, OutputArray covar,
1995 InputOutputArray mean, int flags, int ctype = CV_64F);
1996
1998 CV_EXPORTS_W void PCACompute(InputArray data, InputOutputArray mean,
1999 OutputArray eigenvectors, int maxComponents = 0);
2000
2002 CV_EXPORTS_AS(PCACompute2) void PCACompute(InputArray data, InputOutputArray mean,
2003 OutputArray eigenvectors, OutputArray eigenvalues,
2004 int maxComponents = 0);
2005
2007 CV_EXPORTS_W void PCACompute(InputArray data, InputOutputArray mean,
2008 OutputArray eigenvectors, double retainedVariance);
2009
2011 CV_EXPORTS_AS(PCACompute2) void PCACompute(InputArray data, InputOutputArray mean,
2012 OutputArray eigenvectors, OutputArray eigenvalues,
2013 double retainedVariance);
2014
2016 CV_EXPORTS_W void PCAProject(InputArray data, InputArray mean,
2017 InputArray eigenvectors, OutputArray result);
2018
2020 CV_EXPORTS_W void PCABackProject(InputArray data, InputArray mean,
2021 InputArray eigenvectors, OutputArray result);
2022
2024 CV_EXPORTS_W void SVDecomp( InputArray src, OutputArray w, OutputArray u, OutputArray vt, int flags = 0 );
2025
2027 CV_EXPORTS_W void SVBackSubst( InputArray w, InputArray u, InputArray vt,
2028 InputArray rhs, OutputArray dst );
2029
2040 CV_EXPORTS_W double Mahalanobis(InputArray v1, InputArray v2, InputArray icovar);
2041
2174 CV_EXPORTS_W void dft(InputArray src, OutputArray dst, int flags = 0, int nonzeroRows = 0);
2175
2188 CV_EXPORTS_W void idft(InputArray src, OutputArray dst, int flags = 0, int nonzeroRows = 0);
2189
2229 CV_EXPORTS_W void dct(InputArray src, OutputArray dst, int flags = 0);
2230
2239 CV_EXPORTS_W void idct(InputArray src, OutputArray dst, int flags = 0);
2240
2258 CV_EXPORTS_W void mulSpectrums(InputArray a, InputArray b, OutputArray c,
2259 int flags, bool conjB = false);
2260
2282 CV_EXPORTS_W int getOptimalDFTSize(int vecsize);
2283
2293 CV_EXPORTS RNG& theRNG();
2294
2301 CV_EXPORTS_W void setRNGSeed(int seed);
2302
2313 CV_EXPORTS_W void randu(InputOutputArray dst, InputArray low, InputArray high);
2314
2326 CV_EXPORTS_W void randn(InputOutputArray dst, InputArray mean, InputArray stddev);
2327
2339 CV_EXPORTS_W void randShuffle(InputOutputArray dst, double iterFactor = 1., RNG* rng = 0);
2340
2406 class CV_EXPORTS PCA
2407{
2408 public:
2409 enum Flags { DATA_AS_ROW = 0,
2410 DATA_AS_COL = 1,
2411 USE_AVG = 2
2412 };
2413
2419 PCA();
2420
2430 PCA(InputArray data, InputArray mean, int flags, int maxComponents = 0);
2431
2442 PCA(InputArray data, InputArray mean, int flags, double retainedVariance);
2443
2464 PCA& operator()(InputArray data, InputArray mean, int flags, int maxComponents = 0);
2465
2477 PCA& operator()(InputArray data, InputArray mean, int flags, double retainedVariance);
2478
2493 Mat project(InputArray vec) const;
2494
2507 void project(InputArray vec, OutputArray result) const;
2508
2522 Mat backProject(InputArray vec) const;
2523
2531 void backProject(InputArray vec, OutputArray result) const;
2532
2537 void write(FileStorage& fs) const;
2538
2543 void read(const FileNode& fn);
2544
2545 Mat eigenvectors;
2546 Mat eigenvalues;
2547 Mat mean;
2548};
2549
2562 class CV_EXPORTS LDA
2563{
2564 public:
2568 explicit LDA(int num_components = 0);
2569
2575 LDA(InputArrayOfArrays src, InputArray labels, int num_components = 0);
2576
2579 void save(const String& filename) const;
2580
2583 void load(const String& filename);
2584
2587 void save(FileStorage& fs) const;
2588
2591 void load(const FileStorage& node);
2592
2595 ~LDA();
2596
2599 void compute(InputArrayOfArrays src, InputArray labels);
2600
2604 Mat project(InputArray src);
2605
2609 Mat reconstruct(InputArray src);
2610
2613 Mat eigenvectors() const { return _eigenvectors; }
2614
2617 Mat eigenvalues() const { return _eigenvalues; }
2618
2619 static Mat subspaceProject(InputArray W, InputArray mean, InputArray src);
2620 static Mat subspaceReconstruct(InputArray W, InputArray mean, InputArray src);
2621
2622 protected:
2623 int _num_components;
2624 Mat _eigenvectors;
2625 Mat _eigenvalues;
2626 void lda(InputArrayOfArrays src, InputArray labels);
2627};
2628
2643 class CV_EXPORTS SVD
2644{
2645 public:
2646 enum Flags {
2649 MODIFY_A = 1,
2652 NO_UV = 2,
2656 FULL_UV = 4
2657 };
2658
2663 SVD();
2664
2670 SVD( InputArray src, int flags = 0 );
2671
2683 SVD& operator ()( InputArray src, int flags = 0 );
2684
2702 static void compute( InputArray src, OutputArray w,
2703 OutputArray u, OutputArray vt, int flags = 0 );
2704
2711 static void compute( InputArray src, OutputArray w, int flags = 0 );
2712
2715 static void backSubst( InputArray w, InputArray u,
2716 InputArray vt, InputArray rhs,
2717 OutputArray dst );
2718
2729 static void solveZ( InputArray src, OutputArray dst );
2730
2753 void backSubst( InputArray rhs, OutputArray dst ) const;
2754
2756 template<typename _Tp, int m, int n, int nm> static
2757 void compute( const Matx<_Tp, m, n>& a, Matx<_Tp, nm, 1>& w, Matx<_Tp, m, nm>& u, Matx<_Tp, n, nm>& vt );
2758
2760 template<typename _Tp, int m, int n, int nm> static
2761 void compute( const Matx<_Tp, m, n>& a, Matx<_Tp, nm, 1>& w );
2762
2764 template<typename _Tp, int m, int n, int nm, int nb> static
2765 void backSubst( const Matx<_Tp, nm, 1>& w, const Matx<_Tp, m, nm>& u, const Matx<_Tp, n, nm>& vt, const Matx<_Tp, m, nb>& rhs, Matx<_Tp, n, nb>& dst );
2766
2767 Mat u, w, vt;
2768};
2769
2782 class CV_EXPORTS RNG
2783{
2784 public:
2785 enum { UNIFORM = 0,
2786 NORMAL = 1
2787 };
2788
2797 RNG();
2801 RNG(uint64 state);
2804 unsigned next();
2805
2812 operator uchar();
2814 operator schar();
2816 operator ushort();
2818 operator short();
2820 operator unsigned();
2822 operator int();
2824 operator float();
2826 operator double();
2827
2835 unsigned operator ()();
2839 unsigned operator ()(unsigned N);
2840
2877 int uniform(int a, int b);
2879 float uniform(float a, float b);
2881 double uniform(double a, double b);
2882
2917 void fill( InputOutputArray mat, int distType, InputArray a, InputArray b, bool saturateRange = false );
2918
2927 double gaussian(double sigma);
2928
2929 uint64 state;
2930
2931 bool operator ==(const RNG& other) const;
2932};
2933
2939 class CV_EXPORTS RNG_MT19937
2940{
2941 public:
2942 RNG_MT19937();
2943 RNG_MT19937(unsigned s);
2944 void seed(unsigned s);
2945
2946 unsigned next();
2947
2948 operator int();
2949 operator unsigned();
2950 operator float();
2951 operator double();
2952
2953 unsigned operator ()(unsigned N);
2954 unsigned operator ()();
2955
2957 int uniform(int a, int b);
2959 float uniform(float a, float b);
2961 double uniform(double a, double b);
2962
2963 private:
2964 enum PeriodParameters {N = 624, M = 397};
2965 unsigned state[N];
2966 int mti;
2967};
2968
2970
2973
3011 CV_EXPORTS_W double kmeans( InputArray data, int K, InputOutputArray bestLabels,
3012 TermCriteria criteria, int attempts,
3013 int flags, OutputArray centers = noArray() );
3014
3016
3019
3021
3023 class CV_EXPORTS Formatted
3024{
3025 public:
3026 virtual const char* next() = 0;
3027 virtual void reset() = 0;
3028 virtual ~Formatted();
3029};
3030
3032 class CV_EXPORTS Formatter
3033{
3034 public:
3035 enum FormatType {
3036 FMT_DEFAULT = 0,
3037 FMT_MATLAB = 1,
3038 FMT_CSV = 2,
3039 FMT_PYTHON = 3,
3040 FMT_NUMPY = 4,
3041 FMT_C = 5
3042 };
3043
3044 virtual ~Formatter();
3045
3046 virtual Ptr<Formatted> format(const Mat& mtx) const = 0;
3047
3048 virtual void set16fPrecision(int p = 4) = 0;
3049 virtual void set32fPrecision(int p = 8) = 0;
3050 virtual void set64fPrecision(int p = 16) = 0;
3051 virtual void setMultiline(bool ml = true) = 0;
3052
3053 static Ptr<Formatter> get(Formatter::FormatType fmt = FMT_DEFAULT);
3054
3055};
3056
3057 static inline
3058String& operator << (String& out, Ptr<Formatted> fmtd)
3059{
3060 fmtd->reset();
3061 for(const char* str = fmtd->next(); str; str = fmtd->next())
3062 out += cv::String(str);
3063 return out;
3064}
3065
3066 static inline
3067String& operator << (String& out, const Mat& mtx)
3068{
3069 return out << Formatter::get()->format(mtx);
3070}
3071
3073
3074 class CV_EXPORTS Algorithm;
3075
3076 template<typename _Tp, typename _EnumTp = void> struct ParamType {};
3077
3078
3090 class CV_EXPORTS_W Algorithm
3091{
3092 public:
3093 Algorithm();
3094 virtual ~Algorithm();
3095
3098 CV_WRAP virtual void clear() {}
3099
3102 virtual void write(FileStorage& fs) const { CV_UNUSED(fs); }
3103
3107 CV_WRAP void write(const Ptr<FileStorage>& fs, const String& name = String()) const;
3108
3111 CV_WRAP virtual void read(const FileNode& fn) { CV_UNUSED(fn); }
3112
3115 CV_WRAP virtual bool empty() const { return false; }
3116
3128 template<typename _Tp> static Ptr<_Tp> read(const FileNode& fn)
3129 {
3130 Ptr<_Tp> obj = _Tp::create();
3131 obj->read(fn);
3132 return !obj->empty() ? obj : Ptr<_Tp>();
3133 }
3134
3147 template<typename _Tp> static Ptr<_Tp> load(const String& filename, const String& objname=String())
3148 {
3149 FileStorage fs(filename, FileStorage::READ);
3150 CV_Assert(fs.isOpened());
3151 FileNode fn = objname.empty() ? fs.getFirstTopLevelNode() : fs[objname];
3152 if (fn.empty()) return Ptr<_Tp>();
3153 Ptr<_Tp> obj = _Tp::create();
3154 obj->read(fn);
3155 return !obj->empty() ? obj : Ptr<_Tp>();
3156 }
3157
3168 template<typename _Tp> static Ptr<_Tp> loadFromString(const String& strModel, const String& objname=String())
3169 {
3170 FileStorage fs(strModel, FileStorage::READ + FileStorage::MEMORY);
3171 FileNode fn = objname.empty() ? fs.getFirstTopLevelNode() : fs[objname];
3172 Ptr<_Tp> obj = _Tp::create();
3173 obj->read(fn);
3174 return !obj->empty() ? obj : Ptr<_Tp>();
3175 }
3176
3179 CV_WRAP virtual void save(const String& filename) const;
3180
3183 CV_WRAP virtual String getDefaultName() const;
3184
3185 protected:
3186 void writeFormat(FileStorage& fs) const;
3187};
3188
3189 enum struct Param {
3190 INT=0, BOOLEAN=1, REAL=2, STRING=3, MAT=4, MAT_VECTOR=5, ALGORITHM=6, FLOAT=7,
3191 UNSIGNED_INT=8, UINT64=9, UCHAR=11, SCALAR=12
3192};
3193
3194
3195
3196 template<> struct ParamType<bool>
3197{
3198 typedef bool const_param_type;
3199 typedef bool member_type;
3200
3201 static const Param type = Param::BOOLEAN;
3202};
3203
3204 template<> struct ParamType<int>
3205{
3206 typedef int const_param_type;
3207 typedef int member_type;
3208
3209 static const Param type = Param::INT;
3210};
3211
3212 template<> struct ParamType<double>
3213{
3214 typedef double const_param_type;
3215 typedef double member_type;
3216
3217 static const Param type = Param::REAL;
3218};
3219
3220 template<> struct ParamType<String>
3221{
3222 typedef const String& const_param_type;
3223 typedef String member_type;
3224
3225 static const Param type = Param::STRING;
3226};
3227
3228 template<> struct ParamType<Mat>
3229{
3230 typedef const Mat& const_param_type;
3231 typedef Mat member_type;
3232
3233 static const Param type = Param::MAT;
3234};
3235
3236 template<> struct ParamType<std::vector<Mat> >
3237{
3238 typedef const std::vector<Mat>& const_param_type;
3239 typedef std::vector<Mat> member_type;
3240
3241 static const Param type = Param::MAT_VECTOR;
3242};
3243
3244 template<> struct ParamType<Algorithm>
3245{
3246 typedef const Ptr<Algorithm>& const_param_type;
3247 typedef Ptr<Algorithm> member_type;
3248
3249 static const Param type = Param::ALGORITHM;
3250};
3251
3252 template<> struct ParamType<float>
3253{
3254 typedef float const_param_type;
3255 typedef float member_type;
3256
3257 static const Param type = Param::FLOAT;
3258};
3259
3260 template<> struct ParamType<unsigned>
3261{
3262 typedef unsigned const_param_type;
3263 typedef unsigned member_type;
3264
3265 static const Param type = Param::UNSIGNED_INT;
3266};
3267
3268 template<> struct ParamType<uint64>
3269{
3270 typedef uint64 const_param_type;
3271 typedef uint64 member_type;
3272
3273 static const Param type = Param::UINT64;
3274};
3275
3276 template<> struct ParamType<uchar>
3277{
3278 typedef uchar const_param_type;
3279 typedef uchar member_type;
3280
3281 static const Param type = Param::UCHAR;
3282};
3283
3284 template<> struct ParamType<Scalar>
3285{
3286 typedef const Scalar& const_param_type;
3287 typedef Scalar member_type;
3288
3289 static const Param type = Param::SCALAR;
3290};
3291
3292 template<typename _Tp>
3293 struct ParamType<_Tp, typename std::enable_if< std::is_enum<_Tp>::value >::type>
3294{
3295 typedef typename std::underlying_type<_Tp>::type const_param_type;
3296 typedef typename std::underlying_type<_Tp>::type member_type;
3297
3298 static const Param type = Param::INT;
3299};
3300
3302
3303} //namespace cv
3304
3305 #include "opencv2/core/operations.hpp"
3306 #include "opencv2/core/cvstd.inl.hpp"
3307 #include "opencv2/core/utility.hpp"
3308 #include "opencv2/core/optim.hpp"
3309 #include "opencv2/core/ovx.hpp"
3310
3311 #endif /*OPENCV_CORE_HPP*/
cv::_InputOutputArray
Definition: mat.hpp:386
cv::_OutputArray
This type is very similar to InputArray except that it is used for input/output and output function p...
Definition: mat.hpp:295
cv::Algorithm
This is a base class for all more or less complex algorithms in OpenCV
Definition: core.hpp:3091
cv::Algorithm::write
virtual void write(FileStorage &fs) const
Stores algorithm parameters in a file storage
Definition: core.hpp:3102
cv::Algorithm::load
static Ptr< _Tp > load(const String &filename, const String &objname=String())
Loads algorithm from the file
Definition: core.hpp:3147
cv::Algorithm::read
static Ptr< _Tp > read(const FileNode &fn)
Reads algorithm from the file node
Definition: core.hpp:3128
cv::Algorithm::loadFromString
static Ptr< _Tp > loadFromString(const String &strModel, const String &objname=String())
Loads algorithm from a String
Definition: core.hpp:3168
cv::Exception
Class passed to an error.
Definition: core.hpp:119
cv::Exception::Exception
Exception(int _code, const String &_err, const String &_func, const String &_file, int _line)
cv::FileNode
File Storage Node class.
Definition: persistence.hpp:482
cv::FileNode::empty
CV_WRAP bool empty() const
returns true if the node is empty
cv::FileStorage
XML/YAML/JSON file storage class that encapsulates all the information necessary for writing or readi...
Definition: persistence.hpp:304
cv::FileStorage::getFirstTopLevelNode
CV_WRAP FileNode getFirstTopLevelNode() const
Returns the first element of the top-level mapping.
cv::FileStorage::READ
@ READ
value, open the file for reading
Definition: persistence.hpp:309
cv::FileStorage::MEMORY
@ MEMORY
returned by FileStorage::release)
Definition: persistence.hpp:312
cv::FileStorage::isOpened
virtual CV_WRAP bool isOpened() const
Checks whether the file is opened.
cv::Formatted
Definition: core.hpp:3024
cv::Formatter
Definition: core.hpp:3033
cv::LDA
Linear Discriminant Analysis
Definition: core.hpp:2563
cv::LDA::eigenvalues
Mat eigenvalues() const
Definition: core.hpp:2617
cv::LDA::save
void save(FileStorage &fs) const
cv::LDA::LDA
LDA(InputArrayOfArrays src, InputArray labels, int num_components=0)
cv::LDA::reconstruct
Mat reconstruct(InputArray src)
cv::LDA::save
void save(const String &filename) const
cv::LDA::compute
void compute(InputArrayOfArrays src, InputArray labels)
cv::LDA::LDA
LDA(int num_components=0)
constructor Initializes a LDA with num_components (default 0).
cv::LDA::eigenvectors
Mat eigenvectors() const
Definition: core.hpp:2613
cv::LDA::load
void load(const String &filename)
cv::LDA::project
Mat project(InputArray src)
cv::LDA::load
void load(const FileStorage &node)
cv::LDA::~LDA
~LDA()
cv::Mat
n-dimensional dense array class
Definition: mat.hpp:802
cv::Matx
Template class for small matrices whose type and size are known at compilation time
Definition: matx.hpp:100
cv::PCA
Principal Component Analysis
Definition: core.hpp:2407
cv::PCA::project
void project(InputArray vec, OutputArray result) const
cv::PCA::mean
Mat mean
mean value subtracted before the projection and added after the back projection
Definition: core.hpp:2547
cv::PCA::eigenvalues
Mat eigenvalues
eigenvalues of the covariation matrix
Definition: core.hpp:2546
cv::PCA::backProject
void backProject(InputArray vec, OutputArray result) const
cv::PCA::PCA
PCA()
default constructor
cv::PCA::PCA
PCA(InputArray data, InputArray mean, int flags, int maxComponents=0)
cv::PCA::backProject
Mat backProject(InputArray vec) const
Reconstructs vectors from their PC projections.
cv::PCA::operator()
PCA & operator()(InputArray data, InputArray mean, int flags, int maxComponents=0)
performs PCA
cv::PCA::operator()
PCA & operator()(InputArray data, InputArray mean, int flags, double retainedVariance)
cv::PCA::project
Mat project(InputArray vec) const
Projects vector(s) to the principal component subspace.
cv::PCA::write
void write(FileStorage &fs) const
write PCA objects
cv::PCA::eigenvectors
Mat eigenvectors
eigenvectors of the covariation matrix
Definition: core.hpp:2545
cv::PCA::read
void read(const FileNode &fn)
load PCA objects
cv::PCA::Flags
Flags
Definition: core.hpp:2409
cv::PCA::PCA
PCA(InputArray data, InputArray mean, int flags, double retainedVariance)
cv::Point_< int >
cv::RNG_MT19937
Mersenne Twister random number generator
Definition: core.hpp:2940
cv::RNG_MT19937::uniform
int uniform(int a, int b)
returns uniformly distributed integer random number from [a,b) range
cv::RNG_MT19937::uniform
float uniform(float a, float b)
returns uniformly distributed floating-point random number from [a,b) range
cv::RNG_MT19937::uniform
double uniform(double a, double b)
returns uniformly distributed double-precision floating-point random number from [a,...
cv::RNG
Random Number Generator
Definition: core.hpp:2783
cv::RNG::RNG
RNG()
constructor
cv::RNG::RNG
RNG(uint64 state)
cv::RNG::uniform
float uniform(float a, float b)
cv::RNG::uniform
double uniform(double a, double b)
cv::RNG::gaussian
double gaussian(double sigma)
Returns the next random number sampled from the Gaussian distribution
cv::RNG::uniform
int uniform(int a, int b)
returns uniformly distributed integer random number from [a,b) range
cv::RNG::fill
void fill(InputOutputArray mat, int distType, InputArray a, InputArray b, bool saturateRange=false)
Fills arrays with random numbers.
cv::RNG::next
unsigned next()
cv::SVD
Singular Value Decomposition
Definition: core.hpp:2644
cv::SVD::SVD
SVD()
the default constructor
cv::SVD::Flags
Flags
Definition: core.hpp:2646
cv::SVD::SVD
SVD(InputArray src, int flags=0)
cv::SVD::compute
static void compute(const Matx< _Tp, m, n > &a, Matx< _Tp, nm, 1 > &w)
cv::SVD::compute
static void compute(const Matx< _Tp, m, n > &a, Matx< _Tp, nm, 1 > &w, Matx< _Tp, m, nm > &u, Matx< _Tp, n, nm > &vt)
cv::SVD::compute
static void compute(InputArray src, OutputArray w, OutputArray u, OutputArray vt, int flags=0)
decomposes matrix and stores the results to user-provided matrices
cv::SVD::backSubst
static void backSubst(InputArray w, InputArray u, InputArray vt, InputArray rhs, OutputArray dst)
performs back substitution
cv::SVD::backSubst
void backSubst(InputArray rhs, OutputArray dst) const
performs a singular value back substitution.
cv::SVD::compute
static void compute(InputArray src, OutputArray w, int flags=0)
cv::SVD::solveZ
static void solveZ(InputArray src, OutputArray dst)
solves an under-determined singular linear system
cv::SVD::backSubst
static void backSubst(const Matx< _Tp, nm, 1 > &w, const Matx< _Tp, m, nm > &u, const Matx< _Tp, n, nm > &vt, const Matx< _Tp, m, nb > &rhs, Matx< _Tp, n, nb > &dst)
cv::Scalar_< double >
cv::SparseMat
The class SparseMat represents multi-dimensional sparse numerical arrays.
Definition: mat.hpp:2704
cv::TermCriteria
The class defining termination criteria for iterative algorithms.
Definition: core/types.hpp:853
cv::UMat
Definition: mat.hpp:2402
cv::CV_EXPORTS_AS
CV_EXPORTS_AS(calibrateCameraExtended) double calibrateCamera(InputArrayOfArrays objectPoints
Finds the camera intrinsic and extrinsic parameters from several views of a calibration pattern.
cv::insertChannel
CV_EXPORTS_W void insertChannel(InputArray src, InputOutputArray dst, int coi)
Inserts a single channel to dst (coi is 0-based index)
cv::borderInterpolate
CV_EXPORTS_W int borderInterpolate(int p, int len, int borderType)
Computes the source location of an extrapolated pixel.
cv::minMaxIdx
CV_EXPORTS void minMaxIdx(InputArray src, double *minVal, double *maxVal=0, int *minIdx=0, int *maxIdx=0, InputArray mask=noArray())
Finds the global minimum and maximum in an array
cv::bitwise_xor
CV_EXPORTS_W void bitwise_xor(InputArray src1, InputArray src2, OutputArray dst, InputArray mask=noArray())
Calculates the per-element bit-wise "exclusive or" operation on two arrays or an array and a scalar.
cv::convertScaleAbs
CV_EXPORTS_W void convertScaleAbs(InputArray src, OutputArray dst, double alpha=1, double beta=0)
Scales, calculates absolute values, and converts the result to 8-bit.
cv::PCACompute
CV_EXPORTS_W void PCACompute(InputArray data, InputOutputArray mean, OutputArray eigenvectors, int maxComponents=0)
cv::SVDecomp
CV_EXPORTS_W void SVDecomp(InputArray src, OutputArray w, OutputArray u, OutputArray vt, int flags=0)
cv::eigen
CV_EXPORTS_W bool eigen(InputArray src, OutputArray eigenvalues, OutputArray eigenvectors=noArray())
Calculates eigenvalues and eigenvectors of a symmetric matrix.
cv::copyTo
void CV_EXPORTS_W copyTo(InputArray src, OutputArray dst, InputArray mask)
This is an overloaded member function, provided for convenience (python) Copies the matrix to another...
cv::gemm
CV_EXPORTS_W void gemm(InputArray src1, InputArray src2, double alpha, InputArray src3, double beta, OutputArray dst, int flags=0)
Performs generalized matrix multiplication.
cv::reduce
CV_EXPORTS_W void reduce(InputArray src, OutputArray dst, int dim, int rtype, int dtype=-1)
Reduces a matrix to a vector.
cv::ReduceTypes
ReduceTypes
Definition: core.hpp:230
cv::Mahalanobis
CV_EXPORTS_W double Mahalanobis(InputArray v1, InputArray v2, InputArray icovar)
Calculates the Mahalanobis distance between two vectors.
cv::transform
CV_EXPORTS_W void transform(InputArray src, OutputArray dst, InputArray m)
Performs the matrix transformation of every array element.
cv::split
CV_EXPORTS void split(const Mat &src, Mat *mvbegin)
Divides a multi-channel array into several single-channel arrays.
cv::mulSpectrums
CV_EXPORTS_W void mulSpectrums(InputArray a, InputArray b, OutputArray c, int flags, bool conjB=false)
Performs the per-element multiplication of two Fourier spectrums.
cv::polarToCart
CV_EXPORTS_W void polarToCart(InputArray magnitude, InputArray angle, OutputArray x, OutputArray y, bool angleInDegrees=false)
Calculates x and y coordinates of 2D vectors from their magnitude and angle.
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::solveCubic
CV_EXPORTS_W int solveCubic(InputArray coeffs, OutputArray roots)
Finds the real roots of a cubic equation.
cv::sortIdx
CV_EXPORTS_W void sortIdx(InputArray src, OutputArray dst, int flags)
Sorts each row or each column of a matrix.
cv::sqrt
CV_EXPORTS_W void sqrt(InputArray src, OutputArray dst)
Calculates a square root of array elements.
cv::merge
CV_EXPORTS void merge(const Mat *mv, size_t count, OutputArray dst)
Creates one multi-channel array out of several single-channel ones.
cv::cartToPolar
CV_EXPORTS_W void cartToPolar(InputArray x, InputArray y, OutputArray magnitude, OutputArray angle, bool angleInDegrees=false)
Calculates the magnitude and angle of 2D vectors.
cv::dct
CV_EXPORTS_W void dct(InputArray src, OutputArray dst, int flags=0)
Performs a forward or inverse discrete Cosine transform of 1D or 2D array.
cv::completeSymm
CV_EXPORTS_W void completeSymm(InputOutputArray m, bool lowerToUpper=false)
Copies the lower or the upper half of a square matrix to its another half.
cv::SVBackSubst
CV_EXPORTS_W void SVBackSubst(InputArray w, InputArray u, InputArray vt, InputArray rhs, OutputArray dst)
cv::LUT
CV_EXPORTS_W void LUT(InputArray src, InputArray lut, OutputArray dst)
Performs a look-up table transform of an array.
cv::exp
CV_EXPORTS_W void exp(InputArray src, OutputArray dst)
Calculates the exponent of every array element.
cv::idct
CV_EXPORTS_W void idct(InputArray src, OutputArray dst, int flags=0)
Calculates the inverse Discrete Cosine Transform of a 1D or 2D array.
cv::phase
CV_EXPORTS_W void phase(InputArray x, InputArray y, OutputArray angle, bool angleInDegrees=false)
Calculates the rotation angle of 2D vectors.
cv::minMaxLoc
CV_EXPORTS_W void minMaxLoc(InputArray src, CV_OUT double *minVal, CV_OUT double *maxVal=0, CV_OUT Point *minLoc=0, CV_OUT Point *maxLoc=0, InputArray mask=noArray())
Finds the global minimum and maximum in an array.
cv::vconcat
CV_EXPORTS void vconcat(const Mat *src, size_t nsrc, OutputArray dst)
Applies vertical concatenation to given matrices.
cv::eigenNonSymmetric
CV_EXPORTS_W void eigenNonSymmetric(InputArray src, OutputArray eigenvalues, OutputArray eigenvectors)
Calculates eigenvalues and eigenvectors of a non-symmetric matrix (real eigenvalues only).
cv::getOptimalDFTSize
CV_EXPORTS_W int getOptimalDFTSize(int vecsize)
Returns the optimal DFT size for a given vector size.
cv::meanStdDev
CV_EXPORTS_W void meanStdDev(InputArray src, OutputArray mean, OutputArray stddev, InputArray mask=noArray())
cv::copyMakeBorder
CV_EXPORTS_W void copyMakeBorder(InputArray src, OutputArray dst, int top, int bottom, int left, int right, int borderType, const Scalar &value=Scalar())
Forms a border around an image.
cv::theRNG
CV_EXPORTS RNG & theRNG()
Returns the default random number generator.
cv::RotateFlags
RotateFlags
Definition: core.hpp:1072
cv::compare
CV_EXPORTS_W void compare(InputArray src1, InputArray src2, OutputArray dst, int cmpop)
Performs the per-element comparison of two arrays or an array and scalar value.
cv::bitwise_or
CV_EXPORTS_W void bitwise_or(InputArray src1, InputArray src2, OutputArray dst, InputArray mask=noArray())
Calculates the per-element bit-wise disjunction of two arrays or an array and a scalar.
cv::idft
CV_EXPORTS_W void idft(InputArray src, OutputArray dst, int flags=0, int nonzeroRows=0)
Calculates the inverse Discrete Fourier Transform of a 1D or 2D array.
cv::countNonZero
CV_EXPORTS_W int countNonZero(InputArray src)
Counts non-zero array elements.
cv::hconcat
CV_EXPORTS void hconcat(const Mat *src, size_t nsrc, OutputArray dst)
Applies horizontal concatenation to given matrices.
cv::norm
CV_EXPORTS_W double norm(InputArray src1, int normType=NORM_L2, InputArray mask=noArray())
Calculates the absolute norm of an array.
cv::mixChannels
CV_EXPORTS void mixChannels(const Mat *src, size_t nsrcs, Mat *dst, size_t ndsts, const int *fromTo, size_t npairs)
Copies specified channels from input arrays to the specified channels of output arrays.
cv::rotate
CV_EXPORTS_W void rotate(InputArray src, OutputArray dst, int rotateCode)
Rotates a 2D array in multiples of 90 degrees. The function cv::rotate rotates the array in one of th...
cv::scaleAdd
CV_EXPORTS_W void scaleAdd(InputArray src1, double alpha, InputArray src2, OutputArray dst)
Calculates the sum of a scaled array and another array.
cv::repeat
CV_EXPORTS_W void repeat(InputArray src, int ny, int nx, OutputArray dst)
Fills the output array with repeated copies of the input array.
cv::invert
CV_EXPORTS_W double invert(InputArray src, OutputArray dst, int flags=DECOMP_LU)
Finds the inverse or pseudo-inverse of a matrix.
cv::magnitude
CV_EXPORTS_W void magnitude(InputArray x, InputArray y, OutputArray magnitude)
Calculates the magnitude of 2D vectors.
cv::mulTransposed
CV_EXPORTS_W void mulTransposed(InputArray src, OutputArray dst, bool aTa, InputArray delta=noArray(), double scale=1, int dtype=-1)
Calculates the product of a matrix and its transposition.
cv::solve
CV_EXPORTS_W bool solve(InputArray src1, InputArray src2, OutputArray dst, int flags=DECOMP_LU)
Solves one or more linear systems or least-squares problems.
cv::extractChannel
CV_EXPORTS_W void extractChannel(InputArray src, OutputArray dst, int coi)
Extracts a single channel from src (coi is 0-based index)
cv::bitwise_not
CV_EXPORTS_W void bitwise_not(InputArray src, OutputArray dst, InputArray mask=noArray())
Inverts every bit of an array.
cv::PSNR
CV_EXPORTS_W double PSNR(InputArray src1, InputArray src2, double R=255.)
Computes the Peak Signal-to-Noise Ratio (PSNR) image quality metric.
cv::pow
CV_EXPORTS_W void pow(InputArray src, double power, OutputArray dst)
Raises every array element to a power.
cv::trace
CV_EXPORTS_W Scalar trace(InputArray mtx)
Returns the trace of a matrix.
cv::sort
CV_EXPORTS_W void sort(InputArray src, OutputArray dst, int flags)
Sorts each row or each column of a matrix.
cv::checkRange
CV_EXPORTS_W bool checkRange(InputArray a, bool quiet=true, CV_OUT Point *pos=0, double minVal=-DBL_MAX, double maxVal=DBL_MAX)
Checks every element of an input array for invalid values.
cv::PCABackProject
CV_EXPORTS_W void PCABackProject(InputArray data, InputArray mean, InputArray eigenvectors, OutputArray result)
cv::batchDistance
CV_EXPORTS_W void batchDistance(InputArray src1, InputArray src2, OutputArray dist, int dtype, OutputArray nidx, int normType=NORM_L2, int K=0, InputArray mask=noArray(), int update=0, bool crosscheck=false)
naive nearest neighbor finder
cv::flip
CV_EXPORTS_W void flip(InputArray src, OutputArray dst, int flipCode)
Flips a 2D array around vertical, horizontal, or both axes.
cv::absdiff
CV_EXPORTS_W void absdiff(InputArray src1, InputArray src2, OutputArray dst)
Calculates the per-element absolute difference between two arrays or between an array and a scalar.
cv::randu
CV_EXPORTS_W void randu(InputOutputArray dst, InputArray low, InputArray high)
Generates a single uniformly-distributed random number or an array of random numbers.
cv::transpose
CV_EXPORTS_W void transpose(InputArray src, OutputArray dst)
Transposes a matrix.
cv::min
CV_EXPORTS_W void min(InputArray src1, InputArray src2, OutputArray dst)
Calculates per-element minimum of two arrays or an array and a scalar.
cv::setIdentity
CV_EXPORTS_W void setIdentity(InputOutputArray mtx, const Scalar &s=Scalar(1))
Initializes a scaled identity matrix.
cv::add
CV_EXPORTS_W void add(InputArray src1, InputArray src2, OutputArray dst, InputArray mask=noArray(), int dtype=-1)
Calculates the per-element sum of two arrays or an array and a scalar.
cv::randShuffle
CV_EXPORTS_W void randShuffle(InputOutputArray dst, double iterFactor=1., RNG *rng=0)
Shuffles the array elements randomly.
cv::divide
CV_EXPORTS_W void divide(InputArray src1, InputArray src2, OutputArray dst, double scale=1, int dtype=-1)
Performs per-element division of two arrays or a scalar by an array.
cv::solvePoly
CV_EXPORTS_W double solvePoly(InputArray coeffs, OutputArray roots, int maxIters=300)
Finds the real or complex roots of a polynomial equation.
cv::log
CV_EXPORTS_W void log(InputArray src, OutputArray dst)
Calculates the natural logarithm of every array element.
cv::bitwise_and
CV_EXPORTS_W void bitwise_and(InputArray src1, InputArray src2, OutputArray dst, InputArray mask=noArray())
computes bitwise conjunction of the two arrays (dst = src1 & src2) Calculates the per-element bit-wis...
cv::convertFp16
CV_EXPORTS_W void convertFp16(InputArray src, OutputArray dst)
Converts an array to half precision floating number.
cv::inRange
CV_EXPORTS_W void inRange(InputArray src, InputArray lowerb, InputArray upperb, OutputArray dst)
Checks if array elements lie between the elements of two other arrays.
cv::findNonZero
CV_EXPORTS_W void findNonZero(InputArray src, OutputArray idx)
Returns the list of locations of non-zero pixels
cv::determinant
CV_EXPORTS_W double determinant(InputArray mtx)
Returns the determinant of a square floating-point matrix.
cv::randn
CV_EXPORTS_W void randn(InputOutputArray dst, InputArray mean, InputArray stddev)
Fills the array with normally distributed random numbers.
cv::multiply
CV_EXPORTS_W void multiply(InputArray src1, InputArray src2, OutputArray dst, double scale=1, int dtype=-1)
Calculates the per-element scaled product of two arrays.
cv::subtract
CV_EXPORTS_W void subtract(InputArray src1, InputArray src2, OutputArray dst, InputArray mask=noArray(), int dtype=-1)
Calculates the per-element difference between two arrays or array and a scalar.
cv::normalize
CV_EXPORTS_W void normalize(InputArray src, InputOutputArray dst, double alpha=1, double beta=0, int norm_type=NORM_L2, int dtype=-1, InputArray mask=noArray())
Normalizes the norm or value range of an array.
cv::patchNaNs
CV_EXPORTS_W void patchNaNs(InputOutputArray a, double val=0)
converts NaNs to the given number
cv::PCAProject
CV_EXPORTS_W void PCAProject(InputArray data, InputArray mean, InputArray eigenvectors, OutputArray result)
cv::perspectiveTransform
CV_EXPORTS_W void perspectiveTransform(InputArray src, OutputArray dst, InputArray m)
Performs the perspective matrix transformation of vectors.
cv::calcCovarMatrix
CV_EXPORTS void calcCovarMatrix(const Mat *samples, int nsamples, Mat &covar, Mat &mean, int flags, int ctype=CV_64F)
Calculates the covariance matrix of a set of vectors.
cv::setRNGSeed
CV_EXPORTS_W void setRNGSeed(int seed)
Sets state of default random number generator.
cv::dft
CV_EXPORTS_W void dft(InputArray src, OutputArray dst, int flags=0, int nonzeroRows=0)
Performs a forward or inverse Discrete Fourier transform of a 1D or 2D floating-point array.
cv::addWeighted
CV_EXPORTS_W void addWeighted(InputArray src1, double alpha, InputArray src2, double beta, double gamma, OutputArray dst, int dtype=-1)
Calculates the weighted sum of two arrays.
cv::REDUCE_SUM
@ REDUCE_SUM
the output is the sum of all rows/columns of the matrix.
Definition: core.hpp:230
cv::REDUCE_MIN
@ REDUCE_MIN
the output is the minimum (column/row-wise) of all rows/columns of the matrix.
Definition: core.hpp:233
cv::REDUCE_AVG
@ REDUCE_AVG
the output is the mean vector of all rows/columns of the matrix.
Definition: core.hpp:231
cv::REDUCE_MAX
@ REDUCE_MAX
the output is the maximum (column/row-wise) of all rows/columns of the matrix.
Definition: core.hpp:232
cv::ROTATE_90_CLOCKWISE
@ ROTATE_90_CLOCKWISE
Rotate 90 degrees clockwise
Definition: core.hpp:1073
cv::ROTATE_90_COUNTERCLOCKWISE
@ ROTATE_90_COUNTERCLOCKWISE
Rotate 270 degrees clockwise
Definition: core.hpp:1075
cv::ROTATE_180
@ ROTATE_180
Rotate 180 degrees clockwise
Definition: core.hpp:1074
cv::DECOMP_LU
@ DECOMP_LU
Definition: base.hpp:135
cv::NORM_L2
@ NORM_L2
Definition: base.hpp:185
cv::KmeansFlags
KmeansFlags
k-Means flags
Definition: core.hpp:213
cv::kmeans
CV_EXPORTS_W double kmeans(InputArray data, int K, InputOutputArray bestLabels, TermCriteria criteria, int attempts, int flags, OutputArray centers=noArray())
Finds centers of clusters and groups input samples around the clusters.
cv::KMEANS_USE_INITIAL_LABELS
@ KMEANS_USE_INITIAL_LABELS
Definition: core.hpp:222
cv::KMEANS_PP_CENTERS
@ KMEANS_PP_CENTERS
Definition: core.hpp:217
cv::KMEANS_RANDOM_CENTERS
@ KMEANS_RANDOM_CENTERS
Definition: core.hpp:215
cv::SortFlags
SortFlags
Definition: core.hpp:157
cv::error
CV_EXPORTS CV_NORETURN void error(const Exception &exc)
Signals an error and raises the exception.
CV_Assert
#define CV_Assert(expr)
Checks a condition at runtime and throws exception if it fails
Definition: base.hpp:342
cv::SORT_EVERY_COLUMN
@ SORT_EVERY_COLUMN
Definition: core.hpp:158
cv::SORT_ASCENDING
@ SORT_ASCENDING
Definition: core.hpp:161
cv::SORT_EVERY_ROW
@ SORT_EVERY_ROW
each matrix row is sorted independently
Definition: core.hpp:157
cv::SORT_DESCENDING
@ SORT_DESCENDING
Definition: core.hpp:163
cv::CovarFlags
CovarFlags
Covariation flags
Definition: core.hpp:174
cv::swap
CV_EXPORTS void swap(Mat &a, Mat &b)
Swaps two matrices
cv::COVAR_USE_AVG
@ COVAR_USE_AVG
Definition: core.hpp:193
cv::COVAR_NORMAL
@ COVAR_NORMAL
Definition: core.hpp:187
cv::COVAR_SCRAMBLED
@ COVAR_SCRAMBLED
Definition: core.hpp:182
cv::COVAR_COLS
@ COVAR_COLS
Definition: core.hpp:206
cv::COVAR_SCALE
@ COVAR_SCALE
Definition: core.hpp:198
cv::COVAR_ROWS
@ COVAR_ROWS
Definition: core.hpp:202
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::power
DualQuat< T > power(const DualQuat< T > &dq, const T t, QuatAssumeType assumeUnit=QUAT_ASSUME_NOT_UNIT)
Definition: dualquaternion.inl.hpp:358
cv::ParamType
Definition: core.hpp:3076
cv::Ptr
Definition: cvstd_wrapper.hpp:74
構築: doxygen 1.9.2