00001
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027
00028
00029
00030
00031
00032
00033
00034
00035
00036
00037
00038
00039
00040
00041
00042
00043
00044
00045
00046 #ifndef __OPENCV_CORE_HPP__
00047 #define __OPENCV_CORE_HPP__
00048
00049 #include "opencv2/core/types_c.h"
00050 #include "opencv2/core/version.hpp"
00051
00052 #ifdef __cplusplus
00053
00054 #ifndef SKIP_INCLUDES
00055 #include <limits.h>
00056 #include <algorithm>
00057 #include <cmath>
00058 #include <cstddef>
00059 #include <complex>
00060 #include <map>
00061 #include <new>
00062 #include <string>
00063 #include <vector>
00064 #endif // SKIP_INCLUDES
00065
00069 namespace cv {
00070
00071 #undef abs
00072 #undef min
00073 #undef max
00074 #undef Complex
00075
00076 using std::vector;
00077 using std::string;
00078 using std::ptrdiff_t;
00079
00080 template<typename _Tp> class CV_EXPORTS Size_;
00081 template<typename _Tp> class CV_EXPORTS Point_;
00082 template<typename _Tp> class CV_EXPORTS Rect_;
00083 template<typename _Tp, int cn> class CV_EXPORTS Vec;
00084 template<typename _Tp, int m, int n> class CV_EXPORTS Matx;
00085
00086 typedef std::string String;
00087 typedef std::basic_string<wchar_t> WString;
00088
00089 class Mat;
00090 class SparseMat;
00091 typedef Mat MatND;
00092
00093 class CV_EXPORTS MatExpr;
00094 class CV_EXPORTS MatOp_Base;
00095 class CV_EXPORTS MatArg;
00096 class CV_EXPORTS MatConstIterator;
00097
00098 template<typename _Tp> class CV_EXPORTS Mat_;
00099 template<typename _Tp> class CV_EXPORTS MatIterator_;
00100 template<typename _Tp> class CV_EXPORTS MatConstIterator_;
00101 template<typename _Tp> class CV_EXPORTS MatCommaInitializer_;
00102
00103 CV_EXPORTS string fromUtf16(const WString& str);
00104 CV_EXPORTS WString toUtf16(const string& str);
00105
00106 CV_EXPORTS string format( const char* fmt, ... );
00107 CV_EXPORTS string tempfile( const char* suffix CV_DEFAULT(0));
00108
00109
00110 enum { DECOMP_LU=0, DECOMP_SVD=1, DECOMP_EIG=2, DECOMP_CHOLESKY=3, DECOMP_QR=4, DECOMP_NORMAL=16 };
00111 enum { NORM_INF=1, NORM_L1=2, NORM_L2=4, NORM_TYPE_MASK=7, NORM_RELATIVE=8, NORM_MINMAX=32};
00112 enum { CMP_EQ=0, CMP_GT=1, CMP_GE=2, CMP_LT=3, CMP_LE=4, CMP_NE=5 };
00113 enum { GEMM_1_T=1, GEMM_2_T=2, GEMM_3_T=4 };
00114 enum { DFT_INVERSE=1, DFT_SCALE=2, DFT_ROWS=4, DFT_COMPLEX_OUTPUT=16, DFT_REAL_OUTPUT=32,
00115 DCT_INVERSE = DFT_INVERSE, DCT_ROWS=DFT_ROWS };
00116
00117
00122 class CV_EXPORTS Exception : public std::exception
00123 {
00124 public:
00128 Exception();
00133 Exception(int _code, const string& _err, const string& _func, const string& _file, int _line);
00134 virtual ~Exception() throw();
00135
00139 virtual const char *what() const throw();
00140 void formatMessage();
00141
00142 string msg;
00143
00144 int code;
00145 string err;
00146 string func;
00147 string file;
00148 int line;
00149 };
00150
00151
00153
00161 CV_EXPORTS void error( const Exception& exc );
00162
00164
00171 CV_EXPORTS bool setBreakOnError(bool flag);
00172
00173 typedef int (CV_CDECL *ErrorCallback)( int status, const char* func_name,
00174 const char* err_msg, const char* file_name,
00175 int line, void* userdata );
00176
00178
00188 CV_EXPORTS ErrorCallback redirectError( ErrorCallback errCallback,
00189 void* userdata=0, void** prevUserdata=0);
00190
00191 #ifdef __GNUC__
00192 #define CV_Error( code, msg ) cv::error( cv::Exception(code, msg, __func__, __FILE__, __LINE__) )
00193 #define CV_Error_( code, args ) cv::error( cv::Exception(code, cv::format args, __func__, __FILE__, __LINE__) )
00194 #define CV_Assert( expr ) if((expr)) ; else cv::error( cv::Exception(CV_StsAssert, #expr, __func__, __FILE__, __LINE__) )
00195 #else
00196 #define CV_Error( code, msg ) cv::error( cv::Exception(code, msg, "", __FILE__, __LINE__) )
00197 #define CV_Error_( code, args ) cv::error( cv::Exception(code, cv::format args, "", __FILE__, __LINE__) )
00198 #define CV_Assert( expr ) if((expr)) ; else cv::error( cv::Exception(CV_StsAssert, #expr, "", __FILE__, __LINE__) )
00199 #endif
00200
00201 #ifdef _DEBUG
00202 #define CV_DbgAssert(expr) CV_Assert(expr)
00203 #else
00204 #define CV_DbgAssert(expr)
00205 #endif
00206
00207 CV_EXPORTS void setNumThreads(int nthreads);
00208 CV_EXPORTS int getNumThreads();
00209 CV_EXPORTS int getThreadNum();
00210
00212
00219 CV_EXPORTS int64 getTickCount();
00220
00233 CV_EXPORTS_W double getTickFrequency();
00234
00243 CV_EXPORTS int64 getCPUTickCount();
00244
00264 CV_EXPORTS_W bool checkHardwareSupport(int feature);
00265
00276 CV_EXPORTS void* fastMalloc(size_t bufSize);
00277
00284 CV_EXPORTS void fastFree(void* ptr);
00285
00286 template<typename _Tp> static inline _Tp* allocate(size_t n)
00287 {
00288 return new _Tp[n];
00289 }
00290
00291 template<typename _Tp> static inline void deallocate(_Tp* ptr, size_t)
00292 {
00293 delete[] ptr;
00294 }
00295
00302 template<typename _Tp> static inline _Tp* alignPtr(_Tp* ptr, int n=(int)sizeof(_Tp))
00303 {
00304 return (_Tp*)(((size_t)ptr + n-1) & -n);
00305 }
00306
00312 static inline size_t alignSize(size_t sz, int n)
00313 {
00314 return (sz + n-1) & -n;
00315 }
00316
00326 CV_EXPORTS_W void setUseOptimized(bool onoff);
00327
00333 CV_EXPORTS_W bool useOptimized();
00334
00338 template<typename _Tp> class CV_EXPORTS Allocator
00339 {
00340 public:
00341 typedef _Tp value_type;
00342 typedef value_type* pointer;
00343 typedef const value_type* const_pointer;
00344 typedef value_type& reference;
00345 typedef const value_type& const_reference;
00346 typedef size_t size_type;
00347 typedef ptrdiff_t difference_type;
00348 template<typename U> class rebind { typedef Allocator<U> other; };
00349
00350 explicit Allocator() {}
00351 ~Allocator() {}
00352 explicit Allocator(Allocator const&) {}
00353 template<typename U>
00354 explicit Allocator(Allocator<U> const&) {}
00355
00356
00357 pointer address(reference r) { return &r; }
00358 const_pointer address(const_reference r) { return &r; }
00359
00360 pointer allocate(size_type count, const void* =0)
00361 { return reinterpret_cast<pointer>(fastMalloc(count * sizeof (_Tp))); }
00362
00363 void deallocate(pointer p, size_type) {fastFree(p); }
00364
00365 size_type max_size() const
00366 { return max(static_cast<_Tp>(-1)/sizeof(_Tp), 1); }
00367
00368 void construct(pointer p, const _Tp& v) { new(static_cast<void*>(p)) _Tp(v); }
00369 void destroy(pointer p) { p->~_Tp(); }
00370 };
00371
00373
00380 template<typename _Tp> class CV_EXPORTS DataDepth {};
00381
00382 template<> class DataDepth<bool> { public: enum { value = CV_8U, fmt=(int)'u' }; };
00383 template<> class DataDepth<uchar> { public: enum { value = CV_8U, fmt=(int)'u' }; };
00384 template<> class DataDepth<schar> { public: enum { value = CV_8S, fmt=(int)'c' }; };
00385 template<> class DataDepth<char> { public: enum { value = CV_8S, fmt=(int)'c' }; };
00386 template<> class DataDepth<ushort> { public: enum { value = CV_16U, fmt=(int)'w' }; };
00387 template<> class DataDepth<short> { public: enum { value = CV_16S, fmt=(int)'s' }; };
00388 template<> class DataDepth<int> { public: enum { value = CV_32S, fmt=(int)'i' }; };
00389
00390 template<> class DataDepth<unsigned> { public: enum { value = CV_32S, fmt=(int)'i' }; };
00391 template<> class DataDepth<float> { public: enum { value = CV_32F, fmt=(int)'f' }; };
00392 template<> class DataDepth<double> { public: enum { value = CV_64F, fmt=(int)'d' }; };
00393 template<typename _Tp> class DataDepth<_Tp*> { public: enum { value = CV_USRTYPE1, fmt=(int)'r' }; };
00394
00395
00397
00414 struct CV_EXPORTS Matx_AddOp {};
00415 struct CV_EXPORTS Matx_SubOp {};
00416 struct CV_EXPORTS Matx_ScaleOp {};
00417 struct CV_EXPORTS Matx_MulOp {};
00418 struct CV_EXPORTS Matx_MatMulOp {};
00419 struct CV_EXPORTS Matx_TOp {};
00420
00421 template<typename _Tp, int m, int n> class CV_EXPORTS Matx
00422 {
00423 public:
00424 typedef _Tp value_type;
00425 typedef Matx<_Tp, MIN(m, n), 1> diag_type;
00426 typedef Matx<_Tp, m, n> mat_type;
00427 enum { depth = DataDepth<_Tp>::value, rows = m, cols = n, channels = rows*cols,
00428 type = CV_MAKETYPE(depth, channels) };
00429
00431 Matx();
00432
00433 Matx(_Tp v0);
00434 Matx(_Tp v0, _Tp v1);
00435 Matx(_Tp v0, _Tp v1, _Tp v2);
00436 Matx(_Tp v0, _Tp v1, _Tp v2, _Tp v3);
00437 Matx(_Tp v0, _Tp v1, _Tp v2, _Tp v3, _Tp v4);
00438 Matx(_Tp v0, _Tp v1, _Tp v2, _Tp v3, _Tp v4, _Tp v5);
00439 Matx(_Tp v0, _Tp v1, _Tp v2, _Tp v3, _Tp v4, _Tp v5, _Tp v6);
00440 Matx(_Tp v0, _Tp v1, _Tp v2, _Tp v3, _Tp v4, _Tp v5, _Tp v6, _Tp v7);
00441 Matx(_Tp v0, _Tp v1, _Tp v2, _Tp v3, _Tp v4, _Tp v5, _Tp v6, _Tp v7, _Tp v8);
00442 Matx(_Tp v0, _Tp v1, _Tp v2, _Tp v3, _Tp v4, _Tp v5, _Tp v6, _Tp v7, _Tp v8, _Tp v9);
00443 Matx(_Tp v0, _Tp v1, _Tp v2, _Tp v3,
00444 _Tp v4, _Tp v5, _Tp v6, _Tp v7,
00445 _Tp v8, _Tp v9, _Tp v10, _Tp v11);
00446 Matx(_Tp v0, _Tp v1, _Tp v2, _Tp v3,
00447 _Tp v4, _Tp v5, _Tp v6, _Tp v7,
00448 _Tp v8, _Tp v9, _Tp v10, _Tp v11,
00449 _Tp v12, _Tp v13, _Tp v14, _Tp v15);
00450 explicit Matx(const _Tp* vals);
00451
00452 static Matx all(_Tp alpha);
00453 static Matx zeros();
00454 static Matx ones();
00455 static Matx eye();
00456 static Matx diag(const diag_type& d);
00457 static Matx randu(_Tp a, _Tp b);
00458 static Matx randn(_Tp a, _Tp b);
00459
00461 _Tp dot(const Matx<_Tp, m, n>& v) const;
00462
00464 double ddot(const Matx<_Tp, m, n>& v) const;
00465
00467 template<typename T2> operator Matx<T2, m, n>() const;
00468
00470 template<int m1, int n1> Matx<_Tp, m1, n1> reshape() const;
00471
00473 template<int m1, int n1> Matx<_Tp, m1, n1> get_minor(int i, int j) const;
00474
00476 Matx<_Tp, 1, n> row(int i) const;
00477
00479 Matx<_Tp, m, 1> col(int i) const;
00480
00482 Matx<_Tp, MIN(m,n), 1> diag() const;
00483
00485 Matx<_Tp, n, m> t() const;
00486
00488 Matx<_Tp, n, m> inv(int method=DECOMP_LU) const;
00489
00491 template<int l> Matx<_Tp, n, l> solve(const Matx<_Tp, m, l>& rhs, int flags=DECOMP_LU) const;
00492 Matx<_Tp, n, 1> solve(const Matx<_Tp, m, 1>& rhs, int method) const;
00493
00495 Matx<_Tp, m, n> mul(const Matx<_Tp, m, n>& a) const;
00496
00498 const _Tp& operator ()(int i, int j) const;
00499 _Tp& operator ()(int i, int j);
00500
00502 const _Tp& operator ()(int i) const;
00503 _Tp& operator ()(int i);
00504
00505 Matx(const Matx<_Tp, m, n>& a, const Matx<_Tp, m, n>& b, Matx_AddOp);
00506 Matx(const Matx<_Tp, m, n>& a, const Matx<_Tp, m, n>& b, Matx_SubOp);
00507 template<typename _T2> Matx(const Matx<_Tp, m, n>& a, _T2 alpha, Matx_ScaleOp);
00508 Matx(const Matx<_Tp, m, n>& a, const Matx<_Tp, m, n>& b, Matx_MulOp);
00509 template<int l> Matx(const Matx<_Tp, m, l>& a, const Matx<_Tp, l, n>& b, Matx_MatMulOp);
00510 Matx(const Matx<_Tp, n, m>& a, Matx_TOp);
00511
00512 _Tp val[m*n];
00513 };
00514
00515
00516 typedef Matx<float, 1, 2> Matx12f;
00517 typedef Matx<double, 1, 2> Matx12d;
00518 typedef Matx<float, 1, 3> Matx13f;
00519 typedef Matx<double, 1, 3> Matx13d;
00520 typedef Matx<float, 1, 4> Matx14f;
00521 typedef Matx<double, 1, 4> Matx14d;
00522 typedef Matx<float, 1, 6> Matx16f;
00523 typedef Matx<double, 1, 6> Matx16d;
00524
00525 typedef Matx<float, 2, 1> Matx21f;
00526 typedef Matx<double, 2, 1> Matx21d;
00527 typedef Matx<float, 3, 1> Matx31f;
00528 typedef Matx<double, 3, 1> Matx31d;
00529 typedef Matx<float, 4, 1> Matx41f;
00530 typedef Matx<double, 4, 1> Matx41d;
00531 typedef Matx<float, 6, 1> Matx61f;
00532 typedef Matx<double, 6, 1> Matx61d;
00533
00534 typedef Matx<float, 2, 2> Matx22f;
00535 typedef Matx<double, 2, 2> Matx22d;
00536 typedef Matx<float, 2, 3> Matx23f;
00537 typedef Matx<double, 2, 3> Matx23d;
00538 typedef Matx<float, 3, 2> Matx32f;
00539 typedef Matx<double, 3, 2> Matx32d;
00540
00541 typedef Matx<float, 3, 3> Matx33f;
00542 typedef Matx<double, 3, 3> Matx33d;
00543
00544 typedef Matx<float, 3, 4> Matx34f;
00545 typedef Matx<double, 3, 4> Matx34d;
00546 typedef Matx<float, 4, 3> Matx43f;
00547 typedef Matx<double, 4, 3> Matx43d;
00548
00549 typedef Matx<float, 4, 4> Matx44f;
00550 typedef Matx<double, 4, 4> Matx44d;
00551 typedef Matx<float, 6, 6> Matx66f;
00552 typedef Matx<double, 6, 6> Matx66d;
00553
00554
00570 template<typename _Tp, int cn> class CV_EXPORTS Vec : public Matx<_Tp, cn, 1>
00571 {
00572 public:
00573 typedef _Tp value_type;
00574 enum { depth = DataDepth<_Tp>::value, channels = cn, type = CV_MAKETYPE(depth, channels) };
00575
00577 Vec();
00578
00579 Vec(_Tp v0);
00580 Vec(_Tp v0, _Tp v1);
00581 Vec(_Tp v0, _Tp v1, _Tp v2);
00582 Vec(_Tp v0, _Tp v1, _Tp v2, _Tp v3);
00583 Vec(_Tp v0, _Tp v1, _Tp v2, _Tp v3, _Tp v4);
00584 Vec(_Tp v0, _Tp v1, _Tp v2, _Tp v3, _Tp v4, _Tp v5);
00585 Vec(_Tp v0, _Tp v1, _Tp v2, _Tp v3, _Tp v4, _Tp v5, _Tp v6);
00586 Vec(_Tp v0, _Tp v1, _Tp v2, _Tp v3, _Tp v4, _Tp v5, _Tp v6, _Tp v7);
00587 Vec(_Tp v0, _Tp v1, _Tp v2, _Tp v3, _Tp v4, _Tp v5, _Tp v6, _Tp v7, _Tp v8);
00588 Vec(_Tp v0, _Tp v1, _Tp v2, _Tp v3, _Tp v4, _Tp v5, _Tp v6, _Tp v7, _Tp v8, _Tp v9);
00589 explicit Vec(const _Tp* values);
00590
00591 Vec(const Vec<_Tp, cn>& v);
00592 static Vec all(_Tp alpha);
00593
00595 Vec mul(const Vec<_Tp, cn>& v) const;
00596
00602 Vec cross(const Vec& v) const;
00604 template<typename T2> operator Vec<T2, cn>() const;
00606 operator CvScalar() const;
00607
00609 const _Tp& operator [](int i) const;
00610 _Tp& operator[](int i);
00611 const _Tp& operator ()(int i) const;
00612 _Tp& operator ()(int i);
00613 };
00614
00615
00616
00617
00618
00619
00620 typedef Vec<uchar, 2> Vec2b;
00621 typedef Vec<uchar, 3> Vec3b;
00622 typedef Vec<uchar, 4> Vec4b;
00623
00624 typedef Vec<short, 2> Vec2s;
00625 typedef Vec<short, 3> Vec3s;
00626 typedef Vec<short, 4> Vec4s;
00627
00628 typedef Vec<ushort, 2> Vec2w;
00629 typedef Vec<ushort, 3> Vec3w;
00630 typedef Vec<ushort, 4> Vec4w;
00631
00632 typedef Vec<int, 2> Vec2i;
00633 typedef Vec<int, 3> Vec3i;
00634 typedef Vec<int, 4> Vec4i;
00635 typedef Vec<int, 6> Vec6i;
00636 typedef Vec<int, 8> Vec8i;
00637
00638 typedef Vec<float, 2> Vec2f;
00639 typedef Vec<float, 3> Vec3f;
00640 typedef Vec<float, 4> Vec4f;
00641 typedef Vec<float, 6> Vec6f;
00642
00643 typedef Vec<double, 2> Vec2d;
00644 typedef Vec<double, 3> Vec3d;
00645 typedef Vec<double, 4> Vec4d;
00646 typedef Vec<double, 6> Vec6d;
00647
00648
00650
00658 template<typename _Tp> class CV_EXPORTS Complex
00659 {
00660 public:
00661
00663 Complex();
00664 Complex( _Tp _re, _Tp _im=0 );
00665 Complex( const std::complex<_Tp>& c );
00666
00668 template<typename T2> operator Complex<T2>() const;
00670 Complex conj() const;
00672 operator std::complex<_Tp>() const;
00673
00674 _Tp re, im;
00675 };
00676
00677
00681 typedef Complex<float> Complexf;
00682 typedef Complex<double> Complexd;
00683
00684
00686
00694 template<typename _Tp> class CV_EXPORTS Point_
00695 {
00696 public:
00697 typedef _Tp value_type;
00698
00699
00700 Point_();
00701 Point_(_Tp _x, _Tp _y);
00702 Point_(const Point_& pt);
00703 Point_(const CvPoint& pt);
00704 Point_(const CvPoint2D32f& pt);
00705 Point_(const Size_<_Tp>& sz);
00706 Point_(const Vec<_Tp, 2>& v);
00707
00708 Point_& operator = (const Point_& pt);
00710 template<typename _Tp2> operator Point_<_Tp2>() const;
00711
00713 operator CvPoint() const;
00714 operator CvPoint2D32f() const;
00715 operator Vec<_Tp, 2>() const;
00716
00718 _Tp dot(const Point_& pt) const;
00720 double ddot(const Point_& pt) const;
00722 bool inside(const Rect_<_Tp>& r) const;
00723
00724 _Tp x, y;
00725 };
00726
00735 template<typename _Tp> class CV_EXPORTS Point3_
00736 {
00737 public:
00738 typedef _Tp value_type;
00739
00740
00741 Point3_();
00742 Point3_(_Tp _x, _Tp _y, _Tp _z);
00743 Point3_(const Point3_& pt);
00744 explicit Point3_(const Point_<_Tp>& pt);
00745 Point3_(const CvPoint3D32f& pt);
00746 Point3_(const Vec<_Tp, 3>& v);
00747
00748 Point3_& operator = (const Point3_& pt);
00750 template<typename _Tp2> operator Point3_<_Tp2>() const;
00752 operator CvPoint3D32f() const;
00754 operator Vec<_Tp, 3>() const;
00755
00757 _Tp dot(const Point3_& pt) const;
00759 double ddot(const Point3_& pt) const;
00761 Point3_ cross(const Point3_& pt) const;
00762
00763 _Tp x, y, z;
00764 };
00765
00767
00774 template<typename _Tp> class CV_EXPORTS Size_
00775 {
00776 public:
00777 typedef _Tp value_type;
00778
00780 Size_();
00781 Size_(_Tp _width, _Tp _height);
00782 Size_(const Size_& sz);
00783 Size_(const CvSize& sz);
00784 Size_(const CvSize2D32f& sz);
00785 Size_(const Point_<_Tp>& pt);
00786
00787 Size_& operator = (const Size_& sz);
00789 _Tp area() const;
00790
00792 template<typename _Tp2> operator Size_<_Tp2>() const;
00793
00795 operator CvSize() const;
00796 operator CvSize2D32f() const;
00797
00798 _Tp width, height;
00799 };
00800
00802
00809 template<typename _Tp> class CV_EXPORTS Rect_
00810 {
00811 public:
00812 typedef _Tp value_type;
00813
00815 Rect_();
00816 Rect_(_Tp _x, _Tp _y, _Tp _width, _Tp _height);
00817 Rect_(const Rect_& r);
00818 Rect_(const CvRect& r);
00819 Rect_(const Point_<_Tp>& org, const Size_<_Tp>& sz);
00820 Rect_(const Point_<_Tp>& pt1, const Point_<_Tp>& pt2);
00821
00822 Rect_& operator = ( const Rect_& r );
00824 Point_<_Tp> tl() const;
00826 Point_<_Tp> br() const;
00827
00829 Size_<_Tp> size() const;
00831 _Tp area() const;
00832
00834 template<typename _Tp2> operator Rect_<_Tp2>() const;
00836 operator CvRect() const;
00837
00839 bool contains(const Point_<_Tp>& pt) const;
00840
00841 _Tp x, y, width, height;
00842 };
00843
00844
00850 typedef Point_<int> Point2i;
00851 typedef Point2i Point;
00852 typedef Size_<int> Size2i;
00853 typedef Size2i Size;
00854 typedef Rect_<int> Rect;
00855 typedef Point_<float> Point2f;
00856 typedef Point_<double> Point2d;
00857 typedef Size_<float> Size2f;
00858 typedef Point3_<int> Point3i;
00859 typedef Point3_<float> Point3f;
00860 typedef Point3_<double> Point3d;
00861
00862
00870 class CV_EXPORTS RotatedRect
00871 {
00872 public:
00874 RotatedRect();
00875 RotatedRect(const Point2f& _center, const Size2f& _size, float _angle);
00876 RotatedRect(const CvBox2D& box);
00877
00879 void points(Point2f pts[]) const;
00881 Rect boundingRect() const;
00883 operator CvBox2D() const;
00884
00885 Point2f center;
00886 Size2f size;
00887 float angle;
00888 };
00889
00891
00898 template<typename _Tp> class CV_EXPORTS Scalar_ : public Vec<_Tp, 4>
00899 {
00900 public:
00902 Scalar_();
00903 Scalar_(_Tp v0, _Tp v1, _Tp v2=0, _Tp v3=0);
00904 Scalar_(const CvScalar& s);
00905 Scalar_(_Tp v0);
00906
00908 static Scalar_<_Tp> all(_Tp v0);
00910 operator CvScalar() const;
00911
00913 template<typename T2> operator Scalar_<T2>() const;
00914
00916 Scalar_<_Tp> mul(const Scalar_<_Tp>& t, double scale=1 ) const;
00917
00918
00919 Scalar_<_Tp> conj() const;
00920
00921
00922 bool isReal() const;
00923 };
00924
00925 typedef Scalar_<double> Scalar;
00926
00927 CV_EXPORTS void scalarToRawData(const Scalar& s, void* buf, int type, int unroll_to=0);
00928
00930
00936 class CV_EXPORTS Range
00937 {
00938 public:
00939 Range();
00940 Range(int _start, int _end);
00941 Range(const CvSlice& slice);
00942 int size() const;
00943 bool empty() const;
00944 static Range all();
00945 operator CvSlice() const;
00946
00947 int start, end;
00948 };
00949
00951
00963 template<typename _Tp> class DataType
00964 {
00965 public:
00966 typedef _Tp value_type;
00967 typedef value_type work_type;
00968 typedef value_type channel_type;
00969 typedef value_type vec_type;
00970
00971 enum { generic_type = 1, depth = -1, channels = 1, fmt=0,
00972 type = CV_MAKETYPE(depth, channels) };
00973 };
00974
00975 template<> class DataType<bool>
00976 {
00977 public:
00978 typedef bool value_type;
00979 typedef int work_type;
00980 typedef value_type channel_type;
00981 typedef value_type vec_type;
00982 enum { generic_type = 0, depth = DataDepth<channel_type>::value, channels = 1,
00983 fmt=DataDepth<channel_type>::fmt,
00984 type = CV_MAKETYPE(depth, channels) };
00985 };
00986
00987 template<> class DataType<uchar>
00988 {
00989 public:
00990 typedef uchar value_type;
00991 typedef int work_type;
00992 typedef value_type channel_type;
00993 typedef value_type vec_type;
00994 enum { generic_type = 0, depth = DataDepth<channel_type>::value, channels = 1,
00995 fmt=DataDepth<channel_type>::fmt,
00996 type = CV_MAKETYPE(depth, channels) };
00997 };
00998
00999 template<> class DataType<schar>
01000 {
01001 public:
01002 typedef schar value_type;
01003 typedef int work_type;
01004 typedef value_type channel_type;
01005 typedef value_type vec_type;
01006 enum { generic_type = 0, depth = DataDepth<channel_type>::value, channels = 1,
01007 fmt=DataDepth<channel_type>::fmt,
01008 type = CV_MAKETYPE(depth, channels) };
01009 };
01010
01011 template<> class DataType<char>
01012 {
01013 public:
01014 typedef schar value_type;
01015 typedef int work_type;
01016 typedef value_type channel_type;
01017 typedef value_type vec_type;
01018 enum { generic_type = 0, depth = DataDepth<channel_type>::value, channels = 1,
01019 fmt=DataDepth<channel_type>::fmt,
01020 type = CV_MAKETYPE(depth, channels) };
01021 };
01022
01023 template<> class DataType<ushort>
01024 {
01025 public:
01026 typedef ushort value_type;
01027 typedef int work_type;
01028 typedef value_type channel_type;
01029 typedef value_type vec_type;
01030 enum { generic_type = 0, depth = DataDepth<channel_type>::value, channels = 1,
01031 fmt=DataDepth<channel_type>::fmt,
01032 type = CV_MAKETYPE(depth, channels) };
01033 };
01034
01035 template<> class DataType<short>
01036 {
01037 public:
01038 typedef short value_type;
01039 typedef int work_type;
01040 typedef value_type channel_type;
01041 typedef value_type vec_type;
01042 enum { generic_type = 0, depth = DataDepth<channel_type>::value, channels = 1,
01043 fmt=DataDepth<channel_type>::fmt,
01044 type = CV_MAKETYPE(depth, channels) };
01045 };
01046
01047 template<> class DataType<int>
01048 {
01049 public:
01050 typedef int value_type;
01051 typedef value_type work_type;
01052 typedef value_type channel_type;
01053 typedef value_type vec_type;
01054 enum { generic_type = 0, depth = DataDepth<channel_type>::value, channels = 1,
01055 fmt=DataDepth<channel_type>::fmt,
01056 type = CV_MAKETYPE(depth, channels) };
01057 };
01058
01059 template<> class DataType<float>
01060 {
01061 public:
01062 typedef float value_type;
01063 typedef value_type work_type;
01064 typedef value_type channel_type;
01065 typedef value_type vec_type;
01066 enum { generic_type = 0, depth = DataDepth<channel_type>::value, channels = 1,
01067 fmt=DataDepth<channel_type>::fmt,
01068 type = CV_MAKETYPE(depth, channels) };
01069 };
01070
01071 template<> class DataType<double>
01072 {
01073 public:
01074 typedef double value_type;
01075 typedef value_type work_type;
01076 typedef value_type channel_type;
01077 typedef value_type vec_type;
01078 enum { generic_type = 0, depth = DataDepth<channel_type>::value, channels = 1,
01079 fmt=DataDepth<channel_type>::fmt,
01080 type = CV_MAKETYPE(depth, channels) };
01081 };
01082
01083 template<typename _Tp, int cn> class DataType<Vec<_Tp, cn> >
01084 {
01085 public:
01086 typedef Vec<_Tp, cn> value_type;
01087 typedef Vec<typename DataType<_Tp>::work_type, cn> work_type;
01088 typedef _Tp channel_type;
01089 typedef value_type vec_type;
01090 enum { generic_type = 0, depth = DataDepth<channel_type>::value, channels = cn,
01091 fmt = ((channels-1)<<8) + DataDepth<channel_type>::fmt,
01092 type = CV_MAKETYPE(depth, channels) };
01093 };
01094
01095 template<typename _Tp> class DataType<std::complex<_Tp> >
01096 {
01097 public:
01098 typedef std::complex<_Tp> value_type;
01099 typedef value_type work_type;
01100 typedef _Tp channel_type;
01101 enum { generic_type = 0, depth = DataDepth<channel_type>::value, channels = 2,
01102 fmt = ((channels-1)<<8) + DataDepth<channel_type>::fmt,
01103 type = CV_MAKETYPE(depth, channels) };
01104 typedef Vec<channel_type, channels> vec_type;
01105 };
01106
01107 template<typename _Tp> class DataType<Complex<_Tp> >
01108 {
01109 public:
01110 typedef Complex<_Tp> value_type;
01111 typedef value_type work_type;
01112 typedef _Tp channel_type;
01113 enum { generic_type = 0, depth = DataDepth<channel_type>::value, channels = 2,
01114 fmt = ((channels-1)<<8) + DataDepth<channel_type>::fmt,
01115 type = CV_MAKETYPE(depth, channels) };
01116 typedef Vec<channel_type, channels> vec_type;
01117 };
01118
01119 template<typename _Tp> class DataType<Point_<_Tp> >
01120 {
01121 public:
01122 typedef Point_<_Tp> value_type;
01123 typedef Point_<typename DataType<_Tp>::work_type> work_type;
01124 typedef _Tp channel_type;
01125 enum { generic_type = 0, depth = DataDepth<channel_type>::value, channels = 2,
01126 fmt = ((channels-1)<<8) + DataDepth<channel_type>::fmt,
01127 type = CV_MAKETYPE(depth, channels) };
01128 typedef Vec<channel_type, channels> vec_type;
01129 };
01130
01131 template<typename _Tp> class DataType<Point3_<_Tp> >
01132 {
01133 public:
01134 typedef Point3_<_Tp> value_type;
01135 typedef Point3_<typename DataType<_Tp>::work_type> work_type;
01136 typedef _Tp channel_type;
01137 enum { generic_type = 0, depth = DataDepth<channel_type>::value, channels = 3,
01138 fmt = ((channels-1)<<8) + DataDepth<channel_type>::fmt,
01139 type = CV_MAKETYPE(depth, channels) };
01140 typedef Vec<channel_type, channels> vec_type;
01141 };
01142
01143 template<typename _Tp> class DataType<Size_<_Tp> >
01144 {
01145 public:
01146 typedef Size_<_Tp> value_type;
01147 typedef Size_<typename DataType<_Tp>::work_type> work_type;
01148 typedef _Tp channel_type;
01149 enum { generic_type = 0, depth = DataDepth<channel_type>::value, channels = 2,
01150 fmt = ((channels-1)<<8) + DataDepth<channel_type>::fmt,
01151 type = CV_MAKETYPE(depth, channels) };
01152 typedef Vec<channel_type, channels> vec_type;
01153 };
01154
01155 template<typename _Tp> class DataType<Rect_<_Tp> >
01156 {
01157 public:
01158 typedef Rect_<_Tp> value_type;
01159 typedef Rect_<typename DataType<_Tp>::work_type> work_type;
01160 typedef _Tp channel_type;
01161 enum { generic_type = 0, depth = DataDepth<channel_type>::value, channels = 4,
01162 fmt = ((channels-1)<<8) + DataDepth<channel_type>::fmt,
01163 type = CV_MAKETYPE(depth, channels) };
01164 typedef Vec<channel_type, channels> vec_type;
01165 };
01166
01167 template<typename _Tp> class DataType<Scalar_<_Tp> >
01168 {
01169 public:
01170 typedef Scalar_<_Tp> value_type;
01171 typedef Scalar_<typename DataType<_Tp>::work_type> work_type;
01172 typedef _Tp channel_type;
01173 enum { generic_type = 0, depth = DataDepth<channel_type>::value, channels = 4,
01174 fmt = ((channels-1)<<8) + DataDepth<channel_type>::fmt,
01175 type = CV_MAKETYPE(depth, channels) };
01176 typedef Vec<channel_type, channels> vec_type;
01177 };
01178
01179 template<> class DataType<Range>
01180 {
01181 public:
01182 typedef Range value_type;
01183 typedef value_type work_type;
01184 typedef int channel_type;
01185 enum { generic_type = 0, depth = DataDepth<channel_type>::value, channels = 2,
01186 fmt = ((channels-1)<<8) + DataDepth<channel_type>::fmt,
01187 type = CV_MAKETYPE(depth, channels) };
01188 typedef Vec<channel_type, channels> vec_type;
01189 };
01190
01191
01193
01215 template<typename _Tp> class CV_EXPORTS Ptr
01216 {
01217 public:
01219 Ptr();
01221 Ptr(_Tp* _obj);
01223 ~Ptr();
01225 Ptr(const Ptr& ptr);
01227 Ptr& operator = (const Ptr& ptr);
01229 void addref();
01231 void release();
01233 void delete_obj();
01235 bool empty() const;
01236
01237
01239 _Tp* operator -> ();
01240 const _Tp* operator -> () const;
01241
01242 operator _Tp* ();
01243 operator const _Tp*() const;
01244
01245 protected:
01246 _Tp* obj;
01247 int* refcount;
01248 };
01249
01250
01252
01256 class CV_EXPORTS _InputArray
01257 {
01258 public:
01259 enum { KIND_SHIFT=16, NONE=0<<KIND_SHIFT, MAT=1<<KIND_SHIFT,
01260 MATX=2<<KIND_SHIFT, STD_VECTOR=3<<KIND_SHIFT,
01261 STD_VECTOR_VECTOR=4<<KIND_SHIFT,
01262 STD_VECTOR_MAT=5<<KIND_SHIFT, EXPR=6<<KIND_SHIFT };
01263 _InputArray();
01264 _InputArray(const Mat& m);
01265 _InputArray(const MatExpr& expr);
01266 template<typename _Tp> _InputArray(const vector<_Tp>& vec);
01267 template<typename _Tp> _InputArray(const vector<vector<_Tp> >& vec);
01268 _InputArray(const vector<Mat>& vec);
01269 template<typename _Tp, int m, int n> _InputArray(const Matx<_Tp, m, n>& matx);
01270 _InputArray(const double& val);
01271 virtual Mat getMat(int i=-1) const;
01272 virtual void getMatVector(vector<Mat>& mv) const;
01273 virtual int kind() const;
01274 virtual Size size(int i=-1) const;
01275 virtual size_t total(int i=-1) const;
01276 virtual int type(int i=-1) const;
01277 virtual int depth(int i=-1) const;
01278 virtual int channels(int i=-1) const;
01279 virtual bool empty() const;
01280
01281 int flags;
01282 void* obj;
01283 Size sz;
01284 };
01285
01286
01287 enum
01288 {
01289 DEPTH_MASK_8U = 1 << CV_8U,
01290 DEPTH_MASK_8S = 1 << CV_8S,
01291 DEPTH_MASK_16U = 1 << CV_16U,
01292 DEPTH_MASK_16S = 1 << CV_16S,
01293 DEPTH_MASK_32S = 1 << CV_32S,
01294 DEPTH_MASK_32F = 1 << CV_32F,
01295 DEPTH_MASK_64F = 1 << CV_64F,
01296 DEPTH_MASK_ALL = (DEPTH_MASK_64F<<1)-1,
01297 DEPTH_MASK_ALL_BUT_8S = DEPTH_MASK_ALL & ~DEPTH_MASK_8S,
01298 DEPTH_MASK_FLT = DEPTH_MASK_32F + DEPTH_MASK_64F
01299 };
01300
01301
01305 class CV_EXPORTS _OutputArray : public _InputArray
01306 {
01307 public:
01308 _OutputArray();
01309 _OutputArray(Mat& m);
01310 template<typename _Tp> _OutputArray(vector<_Tp>& vec);
01311 template<typename _Tp> _OutputArray(vector<vector<_Tp> >& vec);
01312 _OutputArray(vector<Mat>& vec);
01313 template<typename _Tp, int m, int n> _OutputArray(Matx<_Tp, m, n>& matx);
01314 virtual bool fixedSize() const;
01315 virtual bool fixedType() const;
01316 virtual bool needed() const;
01317 virtual Mat& getMatRef(int i=-1) const;
01318 virtual void create(Size sz, int type, int i=-1, bool allocateVector=false, int fixedDepthMask=0) const;
01319 virtual void create(int rows, int cols, int type, int i=-1, bool allowTransposed=false, int fixedDepthMask=0) const;
01320 virtual void create(int dims, const int* size, int type, int i=-1, bool allowTransposed=false, int fixedDepthMask=0) const;
01321 virtual void release() const;
01322 virtual void clear() const;
01323 };
01324
01325 typedef const _InputArray& InputArray;
01326 typedef InputArray InputArrayOfArrays;
01327 typedef const _OutputArray& OutputArray;
01328 typedef OutputArray OutputArrayOfArrays;
01329 typedef OutputArray InputOutputArray;
01330
01331 CV_EXPORTS OutputArray noArray();
01332
01334
01335 enum { MAGIC_MASK=0xFFFF0000, TYPE_MASK=0x00000FFF, DEPTH_MASK=7 };
01336
01337 static inline size_t getElemSize(int type) { return CV_ELEM_SIZE(type); }
01338
01343 class CV_EXPORTS MatAllocator
01344 {
01345 public:
01346 MatAllocator() {}
01347 virtual ~MatAllocator() {}
01348 virtual void allocate(int dims, const int* sizes, int type, int*& refcount,
01349 uchar*& datastart, uchar*& data, size_t* step) = 0;
01350 virtual void deallocate(int* refcount, uchar* datastart, uchar* data) = 0;
01351 };
01352
01565 class CV_EXPORTS Mat
01566 {
01567 public:
01569 Mat();
01571
01572 Mat(int _rows, int _cols, int _type);
01573 Mat(Size _size, int _type);
01575 Mat(int _rows, int _cols, int _type, const Scalar& _s);
01576 Mat(Size _size, int _type, const Scalar& _s);
01577
01579 Mat(int _ndims, const int* _sizes, int _type);
01580 Mat(int _ndims, const int* _sizes, int _type, const Scalar& _s);
01581
01583 Mat(const Mat& m);
01585 Mat(int _rows, int _cols, int _type, void* _data, size_t _step=AUTO_STEP);
01586 Mat(Size _size, int _type, void* _data, size_t _step=AUTO_STEP);
01587 Mat(int _ndims, const int* _sizes, int _type, void* _data, const size_t* _steps=0);
01588
01590 Mat(const Mat& m, const Range& rowRange, const Range& colRange=Range::all());
01591 Mat(const Mat& m, const Rect& roi);
01592 Mat(const Mat& m, const Range* ranges);
01594 Mat(const CvMat* m, bool copyData=false);
01596 Mat(const CvMatND* m, bool copyData=false);
01598 Mat(const IplImage* img, bool copyData=false);
01600 template<typename _Tp> explicit Mat(const vector<_Tp>& vec, bool copyData=false);
01602 template<typename _Tp, int n> explicit Mat(const Vec<_Tp, n>& vec,
01603 bool copyData=true);
01605 template<typename _Tp, int m, int n> explicit Mat(const Matx<_Tp, m, n>& mtx,
01606 bool copyData=true);
01608 template<typename _Tp> explicit Mat(const Point_<_Tp>& pt, bool copyData=true);
01610 template<typename _Tp> explicit Mat(const Point3_<_Tp>& pt, bool copyData=true);
01612 template<typename _Tp> explicit Mat(const MatCommaInitializer_<_Tp>& commaInitializer);
01614 ~Mat();
01616 Mat& operator = (const Mat& m);
01617 Mat& operator = (const MatExpr& expr);
01618
01620 Mat row(int y) const;
01622 Mat col(int x) const;
01624 Mat rowRange(int startrow, int endrow) const;
01625 Mat rowRange(const Range& r) const;
01627 Mat colRange(int startcol, int endcol) const;
01628 Mat colRange(const Range& r) const;
01630
01631
01632
01633 Mat diag(int d=0) const;
01635 static Mat diag(const Mat& d);
01636
01638 Mat clone() const;
01640
01641 void copyTo( OutputArray m ) const;
01643 void copyTo( OutputArray m, InputArray mask ) const;
01645 void convertTo( OutputArray m, int rtype, double alpha=1, double beta=0 ) const;
01646
01647 void assignTo( Mat& m, int type=-1 ) const;
01648
01650 Mat& operator = (const Scalar& s);
01652 Mat& setTo(InputArray value, InputArray mask=noArray());
01654
01655 Mat reshape(int _cn, int _rows=0) const;
01656 Mat reshape(int _cn, int _newndims, const int* _newsz) const;
01657
01659 MatExpr t() const;
01661 MatExpr inv(int method=DECOMP_LU) const;
01663 MatExpr mul(InputArray m, double scale=1) const;
01664
01666 Mat cross(InputArray m) const;
01668 double dot(InputArray m) const;
01669
01671 static MatExpr zeros(int rows, int cols, int type);
01672 static MatExpr zeros(Size size, int type);
01673 static MatExpr zeros(int ndims, const int* sz, int type);
01674 static MatExpr ones(int rows, int cols, int type);
01675 static MatExpr ones(Size size, int type);
01676 static MatExpr ones(int ndims, const int* sz, int type);
01677 static MatExpr eye(int rows, int cols, int type);
01678 static MatExpr eye(Size size, int type);
01679
01681
01682 void create(int _rows, int _cols, int _type);
01683 void create(Size _size, int _type);
01684 void create(int _ndims, const int* _sizes, int _type);
01685
01687 void addref();
01689
01690 void release();
01691
01693 void deallocate();
01695 void copySize(const Mat& m);
01696
01698 void reserve(size_t sz);
01700 void resize(size_t sz);
01702 void resize(size_t sz, const Scalar& s);
01704 void push_back_(const void* elem);
01706 template<typename _Tp> void push_back(const _Tp& elem);
01707 template<typename _Tp> void push_back(const Mat_<_Tp>& elem);
01708 void push_back(const Mat& m);
01710 void pop_back(size_t nelems=1);
01711
01713 void locateROI( Size& wholeSize, Point& ofs ) const;
01715 Mat& adjustROI( int dtop, int dbottom, int dleft, int dright );
01717
01718 Mat operator()( Range rowRange, Range colRange ) const;
01719 Mat operator()( const Rect& roi ) const;
01720 Mat operator()( const Range* ranges ) const;
01721
01723 operator CvMat() const;
01725 operator CvMatND() const;
01727 operator IplImage() const;
01728
01729 template<typename _Tp> operator vector<_Tp>() const;
01730 template<typename _Tp, int n> operator Vec<_Tp, n>() const;
01731 template<typename _Tp, int m, int n> operator Matx<_Tp, m, n>() const;
01732
01734
01735
01736 bool isContinuous() const;
01737
01739 bool isSubmatrix() const;
01740
01742
01743 size_t elemSize() const;
01745 size_t elemSize1() const;
01747 int type() const;
01749 int depth() const;
01751 int channels() const;
01753 size_t step1(int i=0) const;
01755 bool empty() const;
01757 size_t total() const;
01758
01760 int checkVector(int elemChannels, int depth=-1, bool requireContinuous=true) const;
01761
01763 uchar* ptr(int i0=0);
01764 const uchar* ptr(int i0=0) const;
01765
01767 uchar* ptr(int i0, int i1);
01768 const uchar* ptr(int i0, int i1) const;
01769
01771 uchar* ptr(int i0, int i1, int i2);
01772 const uchar* ptr(int i0, int i1, int i2) const;
01773
01775 uchar* ptr(const int* idx);
01777 const uchar* ptr(const int* idx) const;
01778
01779 template<int n> uchar* ptr(const Vec<int, n>& idx);
01780 template<int n> const uchar* ptr(const Vec<int, n>& idx) const;
01781
01783 template<typename _Tp> _Tp* ptr(int i0=0);
01784 template<typename _Tp> const _Tp* ptr(int i0=0) const;
01785
01786 template<typename _Tp> _Tp* ptr(int i0, int i1);
01787 template<typename _Tp> const _Tp* ptr(int i0, int i1) const;
01788
01789 template<typename _Tp> _Tp* ptr(int i0, int i1, int i2);
01790 template<typename _Tp> const _Tp* ptr(int i0, int i1, int i2) const;
01791
01792 template<typename _Tp> _Tp* ptr(const int* idx);
01793 template<typename _Tp> const _Tp* ptr(const int* idx) const;
01794
01795 template<typename _Tp, int n> _Tp* ptr(const Vec<int, n>& idx);
01796 template<typename _Tp, int n> const _Tp* ptr(const Vec<int, n>& idx) const;
01797
01799 template<typename _Tp> _Tp& at(int i0=0);
01800 template<typename _Tp> const _Tp& at(int i0=0) const;
01801
01802 template<typename _Tp> _Tp& at(int i0, int i1);
01803 template<typename _Tp> const _Tp& at(int i0, int i1) const;
01804
01805 template<typename _Tp> _Tp& at(int i0, int i1, int i2);
01806 template<typename _Tp> const _Tp& at(int i0, int i1, int i2) const;
01807
01808 template<typename _Tp> _Tp& at(const int* idx);
01809 template<typename _Tp> const _Tp& at(const int* idx) const;
01810
01811 template<typename _Tp, int n> _Tp& at(const Vec<int, n>& idx);
01812 template<typename _Tp, int n> const _Tp& at(const Vec<int, n>& idx) const;
01813
01815 template<typename _Tp> _Tp& at(Point pt);
01816 template<typename _Tp> const _Tp& at(Point pt) const;
01817
01819
01820 template<typename _Tp> MatIterator_<_Tp> begin();
01821 template<typename _Tp> MatIterator_<_Tp> end();
01822 template<typename _Tp> MatConstIterator_<_Tp> begin() const;
01823 template<typename _Tp> MatConstIterator_<_Tp> end() const;
01824
01825 enum { MAGIC_VAL=0x42FF0000, AUTO_STEP=0, CONTINUOUS_FLAG=CV_MAT_CONT_FLAG, SUBMATRIX_FLAG=CV_SUBMAT_FLAG };
01826
01833 int flags;
01835 int dims;
01837 int rows, cols;
01839 uchar* data;
01840
01842
01843 int* refcount;
01844
01846 uchar* datastart;
01847 uchar* dataend;
01848 uchar* datalimit;
01849
01851 MatAllocator* allocator;
01852
01853 struct CV_EXPORTS MSize
01854 {
01855 MSize(int* _p);
01856 Size operator()() const;
01857 const int& operator[](int i) const;
01858 int& operator[](int i);
01859 operator const int*() const;
01860 bool operator == (const MSize& sz) const;
01861 bool operator != (const MSize& sz) const;
01862
01863 int* p;
01864 };
01865
01866 struct CV_EXPORTS MStep
01867 {
01868 MStep();
01869 MStep(size_t s);
01870 const size_t& operator[](int i) const;
01871 size_t& operator[](int i);
01872 operator size_t() const;
01873 MStep& operator = (size_t s);
01874
01875 size_t* p;
01876 size_t buf[2];
01877 protected:
01878 MStep& operator = (const MStep&);
01879 };
01880
01881 MSize size;
01882 MStep step;
01883 };
01884
01885
01891 class CV_EXPORTS RNG
01892 {
01893 public:
01894 enum { UNIFORM=0, NORMAL=1 };
01895
01896 RNG();
01897 RNG(uint64 _state);
01899 unsigned next();
01900
01901 operator uchar();
01902 operator schar();
01903 operator ushort();
01904 operator short();
01905 operator unsigned();
01907 unsigned operator()(unsigned N);
01908 unsigned operator ()();
01909 operator int();
01910 operator float();
01911 operator double();
01913 int uniform(int a, int b);
01915 float uniform(float a, float b);
01917 double uniform(double a, double b);
01918 void fill( InputOutputArray mat, int distType, InputArray a, InputArray b );
01920 double gaussian(double sigma);
01921
01922 uint64 state;
01923 };
01924
01925
01929 class CV_EXPORTS TermCriteria
01930 {
01931 public:
01932 enum
01933 {
01934 COUNT=1,
01935 MAX_ITER=COUNT,
01936 EPS=2
01937 };
01938
01940 TermCriteria();
01942 TermCriteria(int _type, int _maxCount, double _epsilon);
01944 TermCriteria(const CvTermCriteria& criteria);
01946 operator CvTermCriteria() const;
01947
01948 int type;
01949 int maxCount;
01950 double epsilon;
01951 };
01952
01953
01955 CV_EXPORTS void swap(Mat& a, Mat& b);
01956
01958 CV_EXPORTS Mat cvarrToMat(const CvArr* arr, bool copyData=false,
01959 bool allowND=true, int coiMode=0);
01961 CV_EXPORTS void extractImageCOI(const CvArr* arr, OutputArray coiimg, int coi=-1);
01963 CV_EXPORTS void insertImageCOI(InputArray coiimg, CvArr* arr, int coi=-1);
01964
01966 CV_EXPORTS_W void add(InputArray src1, InputArray src2, OutputArray dst,
01967 InputArray mask=noArray(), int dtype=-1);
01969 CV_EXPORTS_W void subtract(InputArray src1, InputArray src2, OutputArray dst,
01970 InputArray mask=noArray(), int dtype=-1);
01971
01973 CV_EXPORTS_W void multiply(InputArray src1, InputArray src2,
01974 OutputArray dst, double scale=1, int dtype=-1);
01975
01977 CV_EXPORTS_W void divide(InputArray src1, InputArray src2, OutputArray dst,
01978 double scale=1, int dtype=-1);
01979
01981 CV_EXPORTS_W void divide(double scale, InputArray src2,
01982 OutputArray dst, int dtype=-1);
01983
01985 CV_EXPORTS_W void scaleAdd(InputArray src1, double alpha, InputArray src2, OutputArray dst);
01986
01988 CV_EXPORTS_W void addWeighted(InputArray src1, double alpha, InputArray src2,
01989 double beta, double gamma, OutputArray dst, int dtype=-1);
01990
01992 CV_EXPORTS_W void convertScaleAbs(InputArray src, OutputArray dst,
01993 double alpha=1, double beta=0);
01995 CV_EXPORTS_W void LUT(InputArray src, InputArray lut, OutputArray dst,
01996 int interpolation=0);
01997
01999 CV_EXPORTS_AS(sumElems) Scalar sum(InputArray src);
02001 CV_EXPORTS_W int countNonZero( InputArray src );
02003 CV_EXPORTS_W Scalar mean(InputArray src, InputArray mask=noArray());
02005 CV_EXPORTS_W void meanStdDev(InputArray src, OutputArray mean, OutputArray stddev,
02006 InputArray mask=noArray());
02008 CV_EXPORTS_W double norm(InputArray src1, int normType=NORM_L2, InputArray mask=noArray());
02010 CV_EXPORTS_W double norm(InputArray src1, InputArray src2,
02011 int normType=NORM_L2, InputArray mask=noArray());
02013 CV_EXPORTS_W void normalize( InputArray src, OutputArray dst, double alpha=1, double beta=0,
02014 int norm_type=NORM_L2, int dtype=-1, InputArray mask=noArray());
02015
02017 CV_EXPORTS_W void minMaxLoc(InputArray src, CV_OUT double* minVal,
02018 CV_OUT double* maxVal=0, CV_OUT Point* minLoc=0,
02019 CV_OUT Point* maxLoc=0, InputArray mask=noArray());
02020 CV_EXPORTS void minMaxIdx(InputArray src, double* minVal, double* maxVal,
02021 int* minIdx=0, int* maxIdx=0, InputArray mask=noArray());
02022
02024 CV_EXPORTS_W void reduce(InputArray src, OutputArray dst, int dim, int rtype, int dtype=-1);
02025
02027 CV_EXPORTS void merge(const Mat* mv, size_t count, OutputArray dst);
02029 CV_EXPORTS_W void merge(const vector<Mat>& mv, OutputArray dst);
02030
02032 CV_EXPORTS void split(const Mat& src, Mat* mvbegin);
02034 CV_EXPORTS_W void split(const Mat& m, vector<Mat>& mv);
02035
02037 CV_EXPORTS void mixChannels(const Mat* src, size_t nsrcs, Mat* dst, size_t ndsts,
02038 const int* fromTo, size_t npairs);
02039 CV_EXPORTS void mixChannels(const vector<Mat>& src, vector<Mat>& dst,
02040 const int* fromTo, size_t npairs);
02041
02043 CV_EXPORTS_W void extractChannel(InputArray src, OutputArray dst, int coi);
02044
02046 CV_EXPORTS_W void insertChannel(InputArray src, InputOutputArray dst, int coi);
02047
02049 CV_EXPORTS_W void flip(InputArray src, OutputArray dst, int flipCode);
02050
02052 CV_EXPORTS_W void repeat(InputArray src, int ny, int nx, OutputArray dst);
02053 CV_EXPORTS Mat repeat(const Mat& src, int ny, int nx);
02054
02055 CV_EXPORTS void hconcat(const Mat* src, size_t nsrc, OutputArray dst);
02056 CV_EXPORTS void hconcat(InputArray src1, InputArray src2, OutputArray dst);
02057 CV_EXPORTS_W void hconcat(InputArray src, OutputArray dst);
02058
02059 CV_EXPORTS void vconcat(const Mat* src, size_t nsrc, OutputArray dst);
02060 CV_EXPORTS void vconcat(InputArray src1, InputArray src2, OutputArray dst);
02061 CV_EXPORTS_W void vconcat(InputArray src, OutputArray dst);
02062
02064 CV_EXPORTS_W void bitwise_and(InputArray src1, InputArray src2,
02065 OutputArray dst, InputArray mask=noArray());
02067 CV_EXPORTS_W void bitwise_or(InputArray src1, InputArray src2,
02068 OutputArray dst, InputArray mask=noArray());
02070 CV_EXPORTS_W void bitwise_xor(InputArray src1, InputArray src2,
02071 OutputArray dst, InputArray mask=noArray());
02073 CV_EXPORTS_W void bitwise_not(InputArray src, OutputArray dst,
02074 InputArray mask=noArray());
02076 CV_EXPORTS_W void absdiff(InputArray src1, InputArray src2, OutputArray dst);
02078 CV_EXPORTS_W void inRange(InputArray src, InputArray lowerb,
02079 InputArray upperb, OutputArray dst);
02081 CV_EXPORTS_W void compare(InputArray src1, InputArray src2, OutputArray dst, int cmpop);
02083 CV_EXPORTS_W void min(InputArray src1, InputArray src2, OutputArray dst);
02085 CV_EXPORTS_W void max(InputArray src1, InputArray src2, OutputArray dst);
02086
02088 CV_EXPORTS void min(const Mat& src1, const Mat& src2, Mat& dst);
02090 CV_EXPORTS void min(const Mat& src1, double src2, Mat& dst);
02092 CV_EXPORTS void max(const Mat& src1, const Mat& src2, Mat& dst);
02094 CV_EXPORTS void max(const Mat& src1, double src2, Mat& dst);
02095
02097 CV_EXPORTS_W void sqrt(InputArray src, OutputArray dst);
02099 CV_EXPORTS_W void pow(InputArray src, double power, OutputArray dst);
02101 CV_EXPORTS_W void exp(InputArray src, OutputArray dst);
02103 CV_EXPORTS_W void log(InputArray src, OutputArray dst);
02105 CV_EXPORTS_W float cubeRoot(float val);
02107 CV_EXPORTS_W float fastAtan2(float y, float x);
02109 CV_EXPORTS_W void polarToCart(InputArray magnitude, InputArray angle,
02110 OutputArray x, OutputArray y, bool angleInDegrees=false);
02112 CV_EXPORTS_W void cartToPolar(InputArray x, InputArray y,
02113 OutputArray magnitude, OutputArray angle,
02114 bool angleInDegrees=false);
02116 CV_EXPORTS_W void phase(InputArray x, InputArray y, OutputArray angle,
02117 bool angleInDegrees=false);
02119 CV_EXPORTS_W void magnitude(InputArray x, InputArray y, OutputArray magnitude);
02121 CV_EXPORTS_W bool checkRange(InputArray a, bool quiet=true, CV_OUT Point* pt=0,
02122 double minVal=-DBL_MAX, double maxVal=DBL_MAX);
02124 CV_EXPORTS_W void gemm(InputArray src1, InputArray src2, double alpha,
02125 InputArray src3, double gamma, OutputArray dst, int flags=0);
02127 CV_EXPORTS_W void mulTransposed( InputArray src, OutputArray dst, bool aTa,
02128 InputArray delta=noArray(),
02129 double scale=1, int dtype=-1 );
02131 CV_EXPORTS_W void transpose(InputArray src, OutputArray dst);
02133 CV_EXPORTS_W void transform(InputArray src, OutputArray dst, InputArray m );
02135 CV_EXPORTS_W void perspectiveTransform(InputArray src, OutputArray dst, InputArray m );
02136
02138 CV_EXPORTS_W void completeSymm(InputOutputArray mtx, bool lowerToUpper=false);
02140 CV_EXPORTS_W void setIdentity(InputOutputArray mtx, const Scalar& s=Scalar(1));
02142 CV_EXPORTS_W double determinant(InputArray mtx);
02144 CV_EXPORTS_W Scalar trace(InputArray mtx);
02146 CV_EXPORTS_W double invert(InputArray src, OutputArray dst, int flags=DECOMP_LU);
02148 CV_EXPORTS_W bool solve(InputArray src1, InputArray src2,
02149 OutputArray dst, int flags=DECOMP_LU);
02151 CV_EXPORTS_W void sort(InputArray src, OutputArray dst, int flags);
02153 CV_EXPORTS_W void sortIdx(InputArray src, OutputArray dst, int flags);
02155 CV_EXPORTS_W int solveCubic(InputArray coeffs, OutputArray roots);
02157 CV_EXPORTS_W double solvePoly(InputArray coeffs, OutputArray roots, int maxIters=300);
02159 CV_EXPORTS bool eigen(InputArray src, OutputArray eigenvalues, int lowindex=-1,
02160 int highindex=-1);
02162 CV_EXPORTS bool eigen(InputArray src, OutputArray eigenvalues,
02163 OutputArray eigenvectors,
02164 int lowindex=-1, int highindex=-1);
02166 CV_EXPORTS void calcCovarMatrix( const Mat* samples, int nsamples, Mat& covar, Mat& mean,
02167 int flags, int ctype=CV_64F);
02169 CV_EXPORTS_W void calcCovarMatrix( InputArray samples, OutputArray covar,
02170 OutputArray mean, int flags, int ctype=CV_64F);
02171
02226 class CV_EXPORTS PCA
02227 {
02228 public:
02230 PCA();
02232 PCA(InputArray data, InputArray mean, int flags, int maxComponents=0);
02234 PCA& operator()(InputArray data, InputArray mean, int flags, int maxComponents=0);
02236 Mat project(InputArray vec) const;
02238 void project(InputArray vec, OutputArray result) const;
02240 Mat backProject(InputArray vec) const;
02242 void backProject(InputArray vec, OutputArray result) const;
02243
02244 Mat eigenvectors;
02245 Mat eigenvalues;
02246 Mat mean;
02247 };
02248
02262 class CV_EXPORTS SVD
02263 {
02264 public:
02265 enum { MODIFY_A=1, NO_UV=2, FULL_UV=4 };
02267 SVD();
02269 SVD( InputArray src, int flags=0 );
02271 SVD& operator ()( InputArray src, int flags=0 );
02272
02274 static void compute( InputArray src, OutputArray w,
02275 OutputArray u, OutputArray vt, int flags=0 );
02277 static void compute( InputArray src, OutputArray w, int flags=0 );
02279 static void backSubst( InputArray w, InputArray u,
02280 InputArray vt, InputArray rhs,
02281 OutputArray dst );
02282
02283 template<typename _Tp, int m, int n, int nm> static void compute( const Matx<_Tp, m, n>& a,
02284 Matx<_Tp, nm, 1>& w, Matx<_Tp, m, nm>& u, Matx<_Tp, n, nm>& vt );
02285 template<typename _Tp, int m, int n, int nm> static void compute( const Matx<_Tp, m, n>& a,
02286 Matx<_Tp, nm, 1>& w );
02287 template<typename _Tp, int m, int n, int nm, int nb> static void backSubst( const Matx<_Tp, nm, 1>& w,
02288 const Matx<_Tp, m, nm>& u, const Matx<_Tp, n, nm>& vt, const Matx<_Tp, m, nb>& rhs, Matx<_Tp, n, nb>& dst );
02289
02291 static void solveZ( InputArray src, OutputArray dst );
02293 void backSubst( InputArray rhs, OutputArray dst ) const;
02294
02295 Mat u, w, vt;
02296 };
02297
02299 CV_EXPORTS_W double Mahalanobis(InputArray v1, InputArray v2, InputArray icovar);
02301 CV_EXPORTS double Mahalonobis(InputArray v1, InputArray v2, InputArray icovar);
02302
02304 CV_EXPORTS_W void dft(InputArray src, OutputArray dst, int flags=0, int nonzeroRows=0);
02306 CV_EXPORTS_W void idft(InputArray src, OutputArray dst, int flags=0, int nonzeroRows=0);
02308 CV_EXPORTS_W void dct(InputArray src, OutputArray dst, int flags=0);
02310 CV_EXPORTS_W void idct(InputArray src, OutputArray dst, int flags=0);
02312 CV_EXPORTS_W void mulSpectrums(InputArray a, InputArray b, OutputArray c,
02313 int flags, bool conjB=false);
02315 CV_EXPORTS_W int getOptimalDFTSize(int vecsize);
02316
02320 enum
02321 {
02322 KMEANS_RANDOM_CENTERS=0,
02323 KMEANS_PP_CENTERS=2,
02324 KMEANS_USE_INITIAL_LABELS=1
02325 };
02327 CV_EXPORTS_W double kmeans( InputArray data, int K, CV_OUT InputOutputArray bestLabels,
02328 TermCriteria criteria, int attempts,
02329 int flags, OutputArray centers=noArray() );
02330
02332 CV_EXPORTS RNG& theRNG();
02333
02335 template<typename _Tp> static inline _Tp randu() { return (_Tp)theRNG(); }
02336
02338 CV_EXPORTS_W void randu(InputOutputArray dst, InputArray low, InputArray high);
02339
02341 CV_EXPORTS_W void randn(InputOutputArray dst, InputArray mean, InputArray stddev);
02342
02344 CV_EXPORTS void randShuffle(InputOutputArray dst, double iterFactor=1., RNG* rng=0);
02345
02347 CV_EXPORTS_W void line(Mat& img, Point pt1, Point pt2, const Scalar& color,
02348 int thickness=1, int lineType=8, int shift=0);
02349
02351 CV_EXPORTS_W void rectangle(Mat& img, Point pt1, Point pt2,
02352 const Scalar& color, int thickness=1,
02353 int lineType=8, int shift=0);
02354
02356 CV_EXPORTS void rectangle(Mat& img, Rect rec,
02357 const Scalar& color, int thickness=1,
02358 int lineType=8, int shift=0);
02359
02361 CV_EXPORTS_W void circle(Mat& img, Point center, int radius,
02362 const Scalar& color, int thickness=1,
02363 int lineType=8, int shift=0);
02364
02366 CV_EXPORTS_W void ellipse(Mat& img, Point center, Size axes,
02367 double angle, double startAngle, double endAngle,
02368 const Scalar& color, int thickness=1,
02369 int lineType=8, int shift=0);
02370
02372 CV_EXPORTS_W void ellipse(Mat& img, const RotatedRect& box, const Scalar& color,
02373 int thickness=1, int lineType=8);
02374
02376 CV_EXPORTS void fillConvexPoly(Mat& img, const Point* pts, int npts,
02377 const Scalar& color, int lineType=8,
02378 int shift=0);
02379
02381 CV_EXPORTS void fillPoly(Mat& img, const Point** pts,
02382 const int* npts, int ncontours,
02383 const Scalar& color, int lineType=8, int shift=0,
02384 Point offset=Point() );
02385
02387 CV_EXPORTS void polylines(Mat& img, const Point** pts, const int* npts,
02388 int ncontours, bool isClosed, const Scalar& color,
02389 int thickness=1, int lineType=8, int shift=0 );
02390
02392 CV_EXPORTS bool clipLine(Size imgSize, CV_IN_OUT Point& pt1, CV_IN_OUT Point& pt2);
02393
02395 CV_EXPORTS_W bool clipLine(Rect imgRect, CV_IN_OUT Point& pt1, CV_IN_OUT Point& pt2);
02396
02403 class CV_EXPORTS LineIterator
02404 {
02405 public:
02407 LineIterator( const Mat& img, Point pt1, Point pt2,
02408 int connectivity=8, bool leftToRight=false );
02410 uchar* operator *();
02412 LineIterator& operator ++();
02414 LineIterator operator ++(int);
02416 Point pos() const;
02417
02418 uchar* ptr;
02419 const uchar* ptr0;
02420 int step, elemSize;
02421 int err, count;
02422 int minusDelta, plusDelta;
02423 int minusStep, plusStep;
02424 };
02425
02427 CV_EXPORTS_W void ellipse2Poly( Point center, Size axes, int angle,
02428 int arcStart, int arcEnd, int delta,
02429 CV_OUT vector<Point>& pts );
02430
02431 enum
02432 {
02433 FONT_HERSHEY_SIMPLEX = 0,
02434 FONT_HERSHEY_PLAIN = 1,
02435 FONT_HERSHEY_DUPLEX = 2,
02436 FONT_HERSHEY_COMPLEX = 3,
02437 FONT_HERSHEY_TRIPLEX = 4,
02438 FONT_HERSHEY_COMPLEX_SMALL = 5,
02439 FONT_HERSHEY_SCRIPT_SIMPLEX = 6,
02440 FONT_HERSHEY_SCRIPT_COMPLEX = 7,
02441 FONT_ITALIC = 16
02442 };
02443
02445 CV_EXPORTS_W void putText( Mat& img, const string& text, Point org,
02446 int fontFace, double fontScale, Scalar color,
02447 int thickness=1, int linetype=8,
02448 bool bottomLeftOrigin=false );
02449
02451 CV_EXPORTS_W Size getTextSize(const string& text, int fontFace,
02452 double fontScale, int thickness,
02453 CV_OUT int* baseLine);
02454
02456
02502 template<typename _Tp> class CV_EXPORTS Mat_ : public Mat
02503 {
02504 public:
02505 typedef _Tp value_type;
02506 typedef typename DataType<_Tp>::channel_type channel_type;
02507 typedef MatIterator_<_Tp> iterator;
02508 typedef MatConstIterator_<_Tp> const_iterator;
02509
02511 Mat_();
02513 Mat_(int _rows, int _cols);
02515 Mat_(int _rows, int _cols, const _Tp& value);
02517 explicit Mat_(Size _size);
02519 Mat_(Size _size, const _Tp& value);
02521 Mat_(int _ndims, const int* _sizes);
02523 Mat_(int _ndims, const int* _sizes, const _Tp& value);
02525 Mat_(const Mat& m);
02527 Mat_(const Mat_& m);
02529 Mat_(int _rows, int _cols, _Tp* _data, size_t _step=AUTO_STEP);
02531 Mat_(int _ndims, const int* _sizes, _Tp* _data, const size_t* _steps=0);
02533 Mat_(const Mat_& m, const Range& rowRange, const Range& colRange=Range::all());
02535 Mat_(const Mat_& m, const Rect& roi);
02537 Mat_(const Mat_& m, const Range* ranges);
02539 explicit Mat_(const MatExpr& e);
02541 explicit Mat_(const vector<_Tp>& vec, bool copyData=false);
02542 template<int n> explicit Mat_(const Vec<typename DataType<_Tp>::channel_type, n>& vec, bool copyData=true);
02543 template<int m, int n> explicit Mat_(const Matx<typename DataType<_Tp>::channel_type, m, n>& mtx, bool copyData=true);
02544 explicit Mat_(const Point_<typename DataType<_Tp>::channel_type>& pt, bool copyData=true);
02545 explicit Mat_(const Point3_<typename DataType<_Tp>::channel_type>& pt, bool copyData=true);
02546 explicit Mat_(const MatCommaInitializer_<_Tp>& commaInitializer);
02547
02548 Mat_& operator = (const Mat& m);
02549 Mat_& operator = (const Mat_& m);
02551 Mat_& operator = (const _Tp& s);
02553 Mat_& operator = (const MatExpr& e);
02554
02556 iterator begin();
02557 iterator end();
02558 const_iterator begin() const;
02559 const_iterator end() const;
02560
02562 void create(int _rows, int _cols);
02564 void create(Size _size);
02566 void create(int _ndims, const int* _sizes);
02568 Mat_ cross(const Mat_& m) const;
02570 template<typename T2> operator Mat_<T2>() const;
02572 Mat_ row(int y) const;
02573 Mat_ col(int x) const;
02574 Mat_ diag(int d=0) const;
02575 Mat_ clone() const;
02576
02578 size_t elemSize() const;
02579 size_t elemSize1() const;
02580 int type() const;
02581 int depth() const;
02582 int channels() const;
02583 size_t step1(int i=0) const;
02585 size_t stepT(int i=0) const;
02586
02588 static MatExpr zeros(int rows, int cols);
02589 static MatExpr zeros(Size size);
02590 static MatExpr zeros(int _ndims, const int* _sizes);
02591 static MatExpr ones(int rows, int cols);
02592 static MatExpr ones(Size size);
02593 static MatExpr ones(int _ndims, const int* _sizes);
02594 static MatExpr eye(int rows, int cols);
02595 static MatExpr eye(Size size);
02596
02598 Mat_ reshape(int _rows) const;
02599 Mat_& adjustROI( int dtop, int dbottom, int dleft, int dright );
02600 Mat_ operator()( const Range& rowRange, const Range& colRange ) const;
02601 Mat_ operator()( const Rect& roi ) const;
02602 Mat_ operator()( const Range* ranges ) const;
02603
02605 _Tp* operator [](int y);
02606 const _Tp* operator [](int y) const;
02607
02609 _Tp& operator ()(const int* idx);
02611 const _Tp& operator ()(const int* idx) const;
02612
02614 template<int n> _Tp& operator ()(const Vec<int, n>& idx);
02616 template<int n> const _Tp& operator ()(const Vec<int, n>& idx) const;
02617
02619 _Tp& operator ()(int idx0);
02621 const _Tp& operator ()(int idx0) const;
02623 _Tp& operator ()(int idx0, int idx1);
02625 const _Tp& operator ()(int idx0, int idx1) const;
02627 _Tp& operator ()(int idx0, int idx1, int idx2);
02629 const _Tp& operator ()(int idx0, int idx1, int idx2) const;
02630
02631 _Tp& operator ()(Point pt);
02632 const _Tp& operator ()(Point pt) const;
02633
02635 operator vector<_Tp>() const;
02637 template<int n> operator Vec<typename DataType<_Tp>::channel_type, n>() const;
02639 template<int m, int n> operator Matx<typename DataType<_Tp>::channel_type, m, n>() const;
02640 };
02641
02642 typedef Mat_<uchar> Mat1b;
02643 typedef Mat_<Vec2b> Mat2b;
02644 typedef Mat_<Vec3b> Mat3b;
02645 typedef Mat_<Vec4b> Mat4b;
02646
02647 typedef Mat_<short> Mat1s;
02648 typedef Mat_<Vec2s> Mat2s;
02649 typedef Mat_<Vec3s> Mat3s;
02650 typedef Mat_<Vec4s> Mat4s;
02651
02652 typedef Mat_<ushort> Mat1w;
02653 typedef Mat_<Vec2w> Mat2w;
02654 typedef Mat_<Vec3w> Mat3w;
02655 typedef Mat_<Vec4w> Mat4w;
02656
02657 typedef Mat_<int> Mat1i;
02658 typedef Mat_<Vec2i> Mat2i;
02659 typedef Mat_<Vec3i> Mat3i;
02660 typedef Mat_<Vec4i> Mat4i;
02661
02662 typedef Mat_<float> Mat1f;
02663 typedef Mat_<Vec2f> Mat2f;
02664 typedef Mat_<Vec3f> Mat3f;
02665 typedef Mat_<Vec4f> Mat4f;
02666
02667 typedef Mat_<double> Mat1d;
02668 typedef Mat_<Vec2d> Mat2d;
02669 typedef Mat_<Vec3d> Mat3d;
02670 typedef Mat_<Vec4d> Mat4d;
02671
02673
02674 class CV_EXPORTS MatConstIterator
02675 {
02676 public:
02677 typedef uchar* value_type;
02678 typedef ptrdiff_t difference_type;
02679 typedef const uchar** pointer;
02680 typedef uchar* reference;
02681 typedef std::random_access_iterator_tag iterator_category;
02682
02684 MatConstIterator();
02686 MatConstIterator(const Mat* _m);
02688 MatConstIterator(const Mat* _m, int _row, int _col=0);
02690 MatConstIterator(const Mat* _m, Point _pt);
02692 MatConstIterator(const Mat* _m, const int* _idx);
02694 MatConstIterator(const MatConstIterator& it);
02695
02697 MatConstIterator& operator = (const MatConstIterator& it);
02699 uchar* operator *() const;
02701 uchar* operator [](ptrdiff_t i) const;
02702
02704 MatConstIterator& operator += (ptrdiff_t ofs);
02706 MatConstIterator& operator -= (ptrdiff_t ofs);
02708 MatConstIterator& operator --();
02710 MatConstIterator operator --(int);
02712 MatConstIterator& operator ++();
02714 MatConstIterator operator ++(int);
02716 Point pos() const;
02718 void pos(int* _idx) const;
02719 ptrdiff_t lpos() const;
02720 void seek(ptrdiff_t ofs, bool relative=false);
02721 void seek(const int* _idx, bool relative=false);
02722
02723 const Mat* m;
02724 size_t elemSize;
02725 uchar* ptr;
02726 uchar* sliceStart;
02727 uchar* sliceEnd;
02728 };
02729
02734 template<typename _Tp>
02735 class CV_EXPORTS MatConstIterator_ : public MatConstIterator
02736 {
02737 public:
02738 typedef _Tp value_type;
02739 typedef ptrdiff_t difference_type;
02740 typedef const _Tp* pointer;
02741 typedef const _Tp& reference;
02742 typedef std::random_access_iterator_tag iterator_category;
02743
02745 MatConstIterator_();
02747 MatConstIterator_(const Mat_<_Tp>* _m);
02749 MatConstIterator_(const Mat_<_Tp>* _m, int _row, int _col=0);
02751 MatConstIterator_(const Mat_<_Tp>* _m, Point _pt);
02753 MatConstIterator_(const Mat_<_Tp>* _m, const int* _idx);
02755 MatConstIterator_(const MatConstIterator_& it);
02756
02758 MatConstIterator_& operator = (const MatConstIterator_& it);
02760 _Tp operator *() const;
02762 _Tp operator [](ptrdiff_t i) const;
02763
02765 MatConstIterator_& operator += (ptrdiff_t ofs);
02767 MatConstIterator_& operator -= (ptrdiff_t ofs);
02769 MatConstIterator_& operator --();
02771 MatConstIterator_ operator --(int);
02773 MatConstIterator_& operator ++();
02775 MatConstIterator_ operator ++(int);
02777 Point pos() const;
02778 };
02779
02780
02785 template<typename _Tp>
02786 class CV_EXPORTS MatIterator_ : public MatConstIterator_<_Tp>
02787 {
02788 public:
02789 typedef _Tp* pointer;
02790 typedef _Tp& reference;
02791 typedef std::random_access_iterator_tag iterator_category;
02792
02794 MatIterator_();
02796 MatIterator_(Mat_<_Tp>* _m);
02798 MatIterator_(Mat_<_Tp>* _m, int _row, int _col=0);
02800 MatIterator_(const Mat_<_Tp>* _m, Point _pt);
02802 MatIterator_(const Mat_<_Tp>* _m, const int* _idx);
02804 MatIterator_(const MatIterator_& it);
02806 MatIterator_& operator = (const MatIterator_<_Tp>& it );
02807
02809 _Tp& operator *() const;
02811 _Tp& operator [](ptrdiff_t i) const;
02812
02814 MatIterator_& operator += (ptrdiff_t ofs);
02816 MatIterator_& operator -= (ptrdiff_t ofs);
02818 MatIterator_& operator --();
02820 MatIterator_ operator --(int);
02822 MatIterator_& operator ++();
02824 MatIterator_ operator ++(int);
02825 };
02826
02827 template<typename _Tp> class CV_EXPORTS MatOp_Iter_;
02828
02842 template<typename _Tp> class CV_EXPORTS MatCommaInitializer_
02843 {
02844 public:
02846 MatCommaInitializer_(Mat_<_Tp>* _m);
02848 template<typename T2> MatCommaInitializer_<_Tp>& operator , (T2 v);
02850 Mat_<_Tp> operator *() const;
02851 operator Mat_<_Tp>() const;
02852 protected:
02853 MatIterator_<_Tp> it;
02854 };
02855
02856
02857 template<typename _Tp, int m, int n> class CV_EXPORTS MatxCommaInitializer
02858 {
02859 public:
02860 MatxCommaInitializer(Matx<_Tp, m, n>* _mtx);
02861 template<typename T2> MatxCommaInitializer<_Tp, m, n>& operator , (T2 val);
02862 Matx<_Tp, m, n> operator *() const;
02863
02864 Matx<_Tp, m, n>* dst;
02865 int idx;
02866 };
02867
02868 template<typename _Tp, int m> class CV_EXPORTS VecCommaInitializer : public MatxCommaInitializer<_Tp, m, 1>
02869 {
02870 public:
02871 VecCommaInitializer(Vec<_Tp, m>* _vec);
02872 template<typename T2> VecCommaInitializer<_Tp, m>& operator , (T2 val);
02873 Vec<_Tp, m> operator *() const;
02874 };
02875
02903 template<typename _Tp, size_t fixed_size=4096/sizeof(_Tp)+8> class CV_EXPORTS AutoBuffer
02904 {
02905 public:
02906 typedef _Tp value_type;
02907 enum { buffer_padding = (int)((16 + sizeof(_Tp) - 1)/sizeof(_Tp)) };
02908
02910 AutoBuffer();
02912 AutoBuffer(size_t _size);
02914 ~AutoBuffer();
02915
02917 void allocate(size_t _size);
02919 void deallocate();
02921 operator _Tp* ();
02923 operator const _Tp* () const;
02924
02925 protected:
02927 _Tp* ptr;
02929 size_t size;
02931 _Tp buf[fixed_size+buffer_padding];
02932 };
02933
02935
02986 class CV_EXPORTS NAryMatIterator
02987 {
02988 public:
02990 NAryMatIterator();
02992 NAryMatIterator(const Mat** arrays, uchar** ptrs, int narrays=-1);
02994 NAryMatIterator(const Mat** arrays, Mat* planes, int narrays=-1);
02996 void init(const Mat** arrays, Mat* planes, uchar** ptrs, int narrays=-1);
02997
02999 NAryMatIterator& operator ++();
03001 NAryMatIterator operator ++(int);
03002
03004 const Mat** arrays;
03006 Mat* planes;
03008 uchar** ptrs;
03010 int narrays;
03012 size_t nplanes;
03014 size_t size;
03015 protected:
03016 int iterdepth;
03017 size_t idx;
03018 };
03019
03020
03021
03022 typedef void (*ConvertData)(const void* from, void* to, int cn);
03023 typedef void (*ConvertScaleData)(const void* from, void* to, int cn, double alpha, double beta);
03024
03026 CV_EXPORTS ConvertData getConvertElem(int fromType, int toType);
03028 CV_EXPORTS ConvertScaleData getConvertScaleElem(int fromType, int toType);
03029
03030
03032
03033 class SparseMatIterator;
03034 class SparseMatConstIterator;
03035 template<typename _Tp> class SparseMatIterator_;
03036 template<typename _Tp> class SparseMatConstIterator_;
03037
03123 class CV_EXPORTS SparseMat
03124 {
03125 public:
03126 typedef SparseMatIterator iterator;
03127 typedef SparseMatConstIterator const_iterator;
03128
03130 struct CV_EXPORTS Hdr
03131 {
03132 Hdr(int _dims, const int* _sizes, int _type);
03133 void clear();
03134 int refcount;
03135 int dims;
03136 int valueOffset;
03137 size_t nodeSize;
03138 size_t nodeCount;
03139 size_t freeList;
03140 vector<uchar> pool;
03141 vector<size_t> hashtab;
03142 int size[CV_MAX_DIM];
03143 };
03144
03146 struct CV_EXPORTS Node
03147 {
03149 size_t hashval;
03151 size_t next;
03153 int idx[CV_MAX_DIM];
03154 };
03155
03157 SparseMat();
03159 SparseMat(int dims, const int* _sizes, int _type);
03161 SparseMat(const SparseMat& m);
03163
03168 explicit SparseMat(const Mat& m);
03170 SparseMat(const CvSparseMat* m);
03172 ~SparseMat();
03173
03175 SparseMat& operator = (const SparseMat& m);
03177 SparseMat& operator = (const Mat& m);
03178
03180 SparseMat clone() const;
03181
03183 void copyTo( SparseMat& m ) const;
03185 void copyTo( Mat& m ) const;
03187 void convertTo( SparseMat& m, int rtype, double alpha=1 ) const;
03189
03194 void convertTo( Mat& m, int rtype, double alpha=1, double beta=0 ) const;
03195
03196
03197 void assignTo( SparseMat& m, int type=-1 ) const;
03198
03200
03205 void create(int dims, const int* _sizes, int _type);
03207 void clear();
03209 void addref();
03210
03211 void release();
03212
03214 operator CvSparseMat*() const;
03216 size_t elemSize() const;
03218 size_t elemSize1() const;
03219
03221 int type() const;
03223 int depth() const;
03225 int channels() const;
03226
03228 const int* size() const;
03230 int size(int i) const;
03232 int dims() const;
03234 size_t nzcount() const;
03235
03237 size_t hash(int i0) const;
03239 size_t hash(int i0, int i1) const;
03241 size_t hash(int i0, int i1, int i2) const;
03243 size_t hash(const int* idx) const;
03244
03246
03259
03260 uchar* ptr(int i0, bool createMissing, size_t* hashval=0);
03262 uchar* ptr(int i0, int i1, bool createMissing, size_t* hashval=0);
03264 uchar* ptr(int i0, int i1, int i2, bool createMissing, size_t* hashval=0);
03266 uchar* ptr(const int* idx, bool createMissing, size_t* hashval=0);
03268
03270
03277
03278 template<typename _Tp> _Tp& ref(int i0, size_t* hashval=0);
03280 template<typename _Tp> _Tp& ref(int i0, int i1, size_t* hashval=0);
03282 template<typename _Tp> _Tp& ref(int i0, int i1, int i2, size_t* hashval=0);
03284 template<typename _Tp> _Tp& ref(const int* idx, size_t* hashval=0);
03286
03288
03299
03300 template<typename _Tp> _Tp value(int i0, size_t* hashval=0) const;
03302 template<typename _Tp> _Tp value(int i0, int i1, size_t* hashval=0) const;
03304 template<typename _Tp> _Tp value(int i0, int i1, int i2, size_t* hashval=0) const;
03306 template<typename _Tp> _Tp value(const int* idx, size_t* hashval=0) const;
03308
03310
03317
03318 template<typename _Tp> const _Tp* find(int i0, size_t* hashval=0) const;
03320 template<typename _Tp> const _Tp* find(int i0, int i1, size_t* hashval=0) const;
03322 template<typename _Tp> const _Tp* find(int i0, int i1, int i2, size_t* hashval=0) const;
03324 template<typename _Tp> const _Tp* find(const int* idx, size_t* hashval=0) const;
03325
03327 void erase(int i0, int i1, size_t* hashval=0);
03329 void erase(int i0, int i1, int i2, size_t* hashval=0);
03331 void erase(const int* idx, size_t* hashval=0);
03332
03334
03337
03338 SparseMatIterator begin();
03340 template<typename _Tp> SparseMatIterator_<_Tp> begin();
03342 SparseMatConstIterator begin() const;
03344 template<typename _Tp> SparseMatConstIterator_<_Tp> begin() const;
03346
03349
03350 SparseMatIterator end();
03352 SparseMatConstIterator end() const;
03354 template<typename _Tp> SparseMatIterator_<_Tp> end();
03356 template<typename _Tp> SparseMatConstIterator_<_Tp> end() const;
03357
03359 template<typename _Tp> _Tp& value(Node* n);
03361 template<typename _Tp> const _Tp& value(const Node* n) const;
03362
03364 Node* node(size_t nidx);
03365 const Node* node(size_t nidx) const;
03366
03367 uchar* newNode(const int* idx, size_t hashval);
03368 void removeNode(size_t hidx, size_t nidx, size_t previdx);
03369 void resizeHashTab(size_t newsize);
03370
03371 enum { MAGIC_VAL=0x42FD0000, MAX_DIM=CV_MAX_DIM, HASH_SCALE=0x5bd1e995, HASH_BIT=0x80000000 };
03372
03373 int flags;
03374 Hdr* hdr;
03375 };
03376
03378 CV_EXPORTS void minMaxLoc(const SparseMat& a, double* minVal,
03379 double* maxVal, int* minIdx=0, int* maxIdx=0);
03381 CV_EXPORTS double norm( const SparseMat& src, int normType );
03383 CV_EXPORTS void normalize( const SparseMat& src, SparseMat& dst, double alpha, int normType );
03384
03397 class CV_EXPORTS SparseMatConstIterator
03398 {
03399 public:
03401 SparseMatConstIterator();
03403 SparseMatConstIterator(const SparseMat* _m);
03405 SparseMatConstIterator(const SparseMatConstIterator& it);
03406
03408 SparseMatConstIterator& operator = (const SparseMatConstIterator& it);
03409
03411 template<typename _Tp> const _Tp& value() const;
03413 const SparseMat::Node* node() const;
03414
03416 SparseMatConstIterator& operator --();
03418 SparseMatConstIterator operator --(int);
03420 SparseMatConstIterator& operator ++();
03422 SparseMatConstIterator operator ++(int);
03423
03425 void seekEnd();
03426
03427 const SparseMat* m;
03428 size_t hashidx;
03429 uchar* ptr;
03430 };
03431
03438 class CV_EXPORTS SparseMatIterator : public SparseMatConstIterator
03439 {
03440 public:
03442 SparseMatIterator();
03444 SparseMatIterator(SparseMat* _m);
03446 SparseMatIterator(SparseMat* _m, const int* idx);
03448 SparseMatIterator(const SparseMatIterator& it);
03449
03451 SparseMatIterator& operator = (const SparseMatIterator& it);
03453 template<typename _Tp> _Tp& value() const;
03455 SparseMat::Node* node() const;
03456
03458 SparseMatIterator& operator ++();
03460 SparseMatIterator operator ++(int);
03461 };
03462
03476 template<typename _Tp> class CV_EXPORTS SparseMat_ : public SparseMat
03477 {
03478 public:
03479 typedef SparseMatIterator_<_Tp> iterator;
03480 typedef SparseMatConstIterator_<_Tp> const_iterator;
03481
03483 SparseMat_();
03485 SparseMat_(int dims, const int* _sizes);
03487 SparseMat_(const SparseMat& m);
03489 SparseMat_(const SparseMat_& m);
03491 SparseMat_(const Mat& m);
03493 SparseMat_(const CvSparseMat* m);
03495 SparseMat_& operator = (const SparseMat& m);
03497 SparseMat_& operator = (const SparseMat_& m);
03499 SparseMat_& operator = (const Mat& m);
03500
03502 SparseMat_ clone() const;
03504 void create(int dims, const int* _sizes);
03506 operator CvSparseMat*() const;
03507
03509 int type() const;
03511 int depth() const;
03513 int channels() const;
03514
03516 _Tp& ref(int i0, size_t* hashval=0);
03518 _Tp& ref(int i0, int i1, size_t* hashval=0);
03520 _Tp& ref(int i0, int i1, int i2, size_t* hashval=0);
03522 _Tp& ref(const int* idx, size_t* hashval=0);
03523
03525 _Tp operator()(int i0, size_t* hashval=0) const;
03527 _Tp operator()(int i0, int i1, size_t* hashval=0) const;
03529 _Tp operator()(int i0, int i1, int i2, size_t* hashval=0) const;
03531 _Tp operator()(const int* idx, size_t* hashval=0) const;
03532
03534 SparseMatIterator_<_Tp> begin();
03536 SparseMatConstIterator_<_Tp> begin() const;
03538 SparseMatIterator_<_Tp> end();
03540 SparseMatConstIterator_<_Tp> end() const;
03541 };
03542
03543
03550 template<typename _Tp> class CV_EXPORTS SparseMatConstIterator_ : public SparseMatConstIterator
03551 {
03552 public:
03553 typedef std::forward_iterator_tag iterator_category;
03554
03556 SparseMatConstIterator_();
03558 SparseMatConstIterator_(const SparseMat_<_Tp>* _m);
03560 SparseMatConstIterator_(const SparseMatConstIterator_& it);
03561
03563 SparseMatConstIterator_& operator = (const SparseMatConstIterator_& it);
03565 const _Tp& operator *() const;
03566
03568 SparseMatConstIterator_& operator ++();
03570 SparseMatConstIterator_ operator ++(int);
03571 };
03572
03579 template<typename _Tp> class CV_EXPORTS SparseMatIterator_ : public SparseMatConstIterator_<_Tp>
03580 {
03581 public:
03582 typedef std::forward_iterator_tag iterator_category;
03583
03585 SparseMatIterator_();
03587 SparseMatIterator_(SparseMat_<_Tp>* _m);
03589 SparseMatIterator_(const SparseMatIterator_& it);
03590
03592 SparseMatIterator_& operator = (const SparseMatIterator_& it);
03594 _Tp& operator *() const;
03595
03597 SparseMatIterator_& operator ++();
03599 SparseMatIterator_ operator ++(int);
03600 };
03601
03603
03628 class CV_EXPORTS_W KDTree
03629 {
03630 public:
03634 struct Node
03635 {
03636 Node() : idx(-1), left(-1), right(-1), boundary(0.f) {}
03637 Node(int _idx, int _left, int _right, float _boundary)
03638 : idx(_idx), left(_left), right(_right), boundary(_boundary) {}
03640 int idx;
03642 int left, right;
03644 float boundary;
03645 };
03646
03648 CV_WRAP KDTree();
03650 CV_WRAP KDTree(InputArray points, bool copyAndReorderPoints=false);
03652 CV_WRAP KDTree(InputArray points, InputArray _labels,
03653 bool copyAndReorderPoints=false);
03655 CV_WRAP void build(InputArray points, bool copyAndReorderPoints=false);
03657 CV_WRAP void build(InputArray points, InputArray labels,
03658 bool copyAndReorderPoints=false);
03660 CV_WRAP int findNearest(InputArray vec, int K, int Emax,
03661 OutputArray neighborsIdx,
03662 OutputArray neighbors=noArray(),
03663 OutputArray dist=noArray(),
03664 OutputArray labels=noArray()) const;
03666 CV_WRAP void findOrthoRange(InputArray minBounds,
03667 InputArray maxBounds,
03668 OutputArray neighborsIdx,
03669 OutputArray neighbors=noArray(),
03670 OutputArray labels=noArray()) const;
03672 CV_WRAP void getPoints(InputArray idx, OutputArray pts,
03673 OutputArray labels=noArray()) const;
03675 const float* getPoint(int ptidx, int* label=0) const;
03677 CV_WRAP int dims() const;
03678
03679 vector<Node> nodes;
03680 CV_PROP Mat points;
03681 CV_PROP vector<int> labels;
03682 CV_PROP int maxDepth;
03683 CV_PROP_RW int normType;
03684 };
03685
03687
03688 class CV_EXPORTS FileNode;
03689
03787 class CV_EXPORTS_W FileStorage
03788 {
03789 public:
03791 enum
03792 {
03793 READ=0,
03794 WRITE=1,
03795 APPEND=2
03796 };
03797 enum
03798 {
03799 UNDEFINED=0,
03800 VALUE_EXPECTED=1,
03801 NAME_EXPECTED=2,
03802 INSIDE_MAP=4
03803 };
03805 CV_WRAP FileStorage();
03807 CV_WRAP FileStorage(const string& filename, int flags, const string& encoding=string());
03809 FileStorage(CvFileStorage* fs);
03811 virtual ~FileStorage();
03812
03814 CV_WRAP virtual bool open(const string& filename, int flags, const string& encoding=string());
03816 CV_WRAP virtual bool isOpened() const;
03818 CV_WRAP virtual void release();
03819
03821 CV_WRAP FileNode getFirstTopLevelNode() const;
03823 CV_WRAP FileNode root(int streamidx=0) const;
03825 FileNode operator[](const string& nodename) const;
03827 CV_WRAP FileNode operator[](const char* nodename) const;
03828
03830 CvFileStorage* operator *() { return fs; }
03832 const CvFileStorage* operator *() const { return fs; }
03834 void writeRaw( const string& fmt, const uchar* vec, size_t len );
03836 void writeObj( const string& name, const void* obj );
03837
03839 static string getDefaultObjectName(const string& filename);
03840
03841 Ptr<CvFileStorage> fs;
03842 string elname;
03843 vector<char> structs;
03844 int state;
03845 };
03846
03847 class CV_EXPORTS FileNodeIterator;
03848
03859 class CV_EXPORTS_W_SIMPLE FileNode
03860 {
03861 public:
03863 enum
03864 {
03865 NONE=0,
03866 INT=1,
03867 REAL=2,
03868 FLOAT=REAL,
03869 STR=3,
03870 STRING=STR,
03871 REF=4,
03872 SEQ=5,
03873 MAP=6,
03874 TYPE_MASK=7,
03875 FLOW=8,
03876 USER=16,
03877 EMPTY=32,
03878 NAMED=64
03879 };
03881 CV_WRAP FileNode();
03883 FileNode(const CvFileStorage* fs, const CvFileNode* node);
03885 FileNode(const FileNode& node);
03887 FileNode operator[](const string& nodename) const;
03889 CV_WRAP FileNode operator[](const char* nodename) const;
03891 CV_WRAP FileNode operator[](int i) const;
03893 CV_WRAP int type() const;
03894
03896 CV_WRAP bool empty() const;
03898 CV_WRAP bool isNone() const;
03900 CV_WRAP bool isSeq() const;
03902 CV_WRAP bool isMap() const;
03904 CV_WRAP bool isInt() const;
03906 CV_WRAP bool isReal() const;
03908 CV_WRAP bool isString() const;
03910 CV_WRAP bool isNamed() const;
03912 CV_WRAP string name() const;
03914 CV_WRAP size_t size() const;
03916 operator int() const;
03918 operator float() const;
03920 operator double() const;
03922 operator string() const;
03923
03925 CvFileNode* operator *();
03927 const CvFileNode* operator* () const;
03928
03930 FileNodeIterator begin() const;
03932 FileNodeIterator end() const;
03933
03935 void readRaw( const string& fmt, uchar* vec, size_t len ) const;
03937 void* readObj() const;
03938
03939
03940 const CvFileStorage* fs;
03941 const CvFileNode* node;
03942 };
03943
03944
03950 class CV_EXPORTS FileNodeIterator
03951 {
03952 public:
03954 FileNodeIterator();
03956 FileNodeIterator(const CvFileStorage* fs, const CvFileNode* node, size_t ofs=0);
03958 FileNodeIterator(const FileNodeIterator& it);
03960 FileNode operator *() const;
03962 FileNode operator ->() const;
03963
03965 FileNodeIterator& operator ++ ();
03967 FileNodeIterator operator ++ (int);
03969 FileNodeIterator& operator -- ();
03971 FileNodeIterator operator -- (int);
03973 FileNodeIterator& operator += (int);
03975 FileNodeIterator& operator -= (int);
03976
03978 FileNodeIterator& readRaw( const string& fmt, uchar* vec,
03979 size_t maxCount=(size_t)INT_MAX );
03980
03981 const CvFileStorage* fs;
03982 const CvFileNode* container;
03983 CvSeqReader reader;
03984 size_t remaining;
03985 };
03986
03988
03989 template<typename _Tp> class SeqIterator;
03990
03991 typedef Ptr<CvMemStorage> MemStorage;
03992
04003 template<typename _Tp> class CV_EXPORTS Seq
04004 {
04005 public:
04006 typedef SeqIterator<_Tp> iterator;
04007 typedef SeqIterator<_Tp> const_iterator;
04008
04010 Seq();
04012 Seq(const CvSeq* seq);
04014 Seq(MemStorage& storage, int headerSize = sizeof(CvSeq));
04016 _Tp& operator [](int idx);
04018 const _Tp& operator[](int idx) const;
04020 SeqIterator<_Tp> begin() const;
04022 SeqIterator<_Tp> end() const;
04024 size_t size() const;
04026 int type() const;
04028 int depth() const;
04030 int channels() const;
04032 size_t elemSize() const;
04034 size_t index(const _Tp& elem) const;
04036 void push_back(const _Tp& elem);
04038 void push_front(const _Tp& elem);
04040 void push_back(const _Tp* elems, size_t count);
04042 void push_front(const _Tp* elems, size_t count);
04044 void insert(int idx, const _Tp& elem);
04046 void insert(int idx, const _Tp* elems, size_t count);
04048 void remove(int idx);
04050 void remove(const Range& r);
04051
04053 _Tp& front();
04055 const _Tp& front() const;
04057 _Tp& back();
04059 const _Tp& back() const;
04061 bool empty() const;
04062
04064 void clear();
04066 void pop_front();
04068 void pop_back();
04070 void pop_front(_Tp* elems, size_t count);
04072 void pop_back(_Tp* elems, size_t count);
04073
04075 void copyTo(vector<_Tp>& vec, const Range& range=Range::all()) const;
04077 operator vector<_Tp>() const;
04078
04079 CvSeq* seq;
04080 };
04081
04082
04086 template<typename _Tp> class CV_EXPORTS SeqIterator : public CvSeqReader
04087 {
04088 public:
04090 SeqIterator();
04092 SeqIterator(const Seq<_Tp>& seq, bool seekEnd=false);
04094 void seek(size_t pos);
04096 size_t tell() const;
04098 _Tp& operator *();
04100 const _Tp& operator *() const;
04102 SeqIterator& operator ++();
04104 SeqIterator operator ++(int) const;
04106 SeqIterator& operator --();
04108 SeqIterator operator --(int) const;
04109
04111 SeqIterator& operator +=(int);
04113 SeqIterator& operator -=(int);
04114
04115
04116
04117 int index;
04118 };
04119
04120
04121 #if 0
04122 class CV_EXPORTS AlgorithmImpl;
04123
04127 class CV_EXPORTS Algorithm
04128 {
04129 public:
04130 virtual ~Algorithm();
04131 virtual string name() const;
04132
04133 template<typename _Tp> _Tp get(int paramId) const;
04134 template<typename _Tp> bool set(int paramId, const _Tp& value);
04135 string paramName(int paramId) const;
04136 string paramHelp(int paramId) const;
04137 int paramType(int paramId) const;
04138 int findParam(const string& name) const;
04139 template<typename _Tp> _Tp paramDefaultValue(int paramId) const;
04140 template<typename _Tp> bool paramRange(int paramId, _Tp& minVal, _Tp& maxVal) const;
04141
04142 virtual void getParams(vector<int>& ids) const;
04143 virtual void write(vector<uchar>& buf) const;
04144 virtual bool read(const vector<uchar>& buf);
04145
04146 typedef Algorithm* (*Constructor)(void);
04147 static void add(const string& name, Constructor create);
04148 static void getList(vector<string>& algorithms);
04149 static Ptr<Algorithm> create(const string& name);
04150
04151 protected:
04152 template<typename _Tp> void addParam(int propId, _Tp& value, bool readOnly, const string& name,
04153 const string& help=string(), const _Tp& defaultValue=_Tp(),
04154 _Tp (Algorithm::*getter)()=0, bool (Algorithm::*setter)(const _Tp&)=0);
04155 template<typename _Tp> void setParamRange(int propId, const _Tp& minVal, const _Tp& maxVal);
04156
04157 bool set_(int paramId, int argType, const void* value);
04158 void get_(int paramId, int argType, void* value);
04159 void paramDefaultValue_(int paramId, int argType, void* value);
04160 void paramRange_(int paramId, int argType, void* minval, void* maxval);
04161 void addParam_(int propId, int argType, void* value, bool readOnly, const string& name,
04162 const string& help, const void* defaultValue, void* getter, void* setter);
04163 void setParamRange_(int propId, int argType, const void* minVal, const void* maxVal);
04164
04165 Ptr<AlgorithmImpl> impl;
04166 };
04167 #endif
04168
04187 class CV_EXPORTS CommandLineParser
04188 {
04189 public:
04190
04192 CommandLineParser(int argc, const char* argv[]);
04193
04195 template<typename _Tp>
04196 _Tp get(const std::string& name, const _Tp& default_value = _Tp())
04197 {
04198 std::string str = getString(name);
04199 if (!has(name))
04200 return default_value;
04201 return analyzeValue<_Tp>(str);
04202 }
04203
04204 protected:
04205 std::map<std::string, std::string > data;
04206 std::string getString(const std::string& name) const;
04207
04208 bool has(const std::string& keys) const;
04209
04210 template<typename _Tp>
04211 static _Tp getData(const std::string& str)
04212 {
04213 _Tp res;
04214 std::stringstream s1(str);
04215 s1 >> res;
04216 return res;
04217 }
04218
04219 template<typename _Tp>
04220 _Tp fromStringNumber(const std::string& str);
04221
04222 template<typename _Tp>
04223 _Tp analyzeValue(const std::string& str);
04224 };
04225 template<> CV_EXPORTS
04226 bool CommandLineParser::get<bool>(const std::string& name, const bool& default_value);
04227
04228 template<> CV_EXPORTS
04229 std::string CommandLineParser::analyzeValue<std::string>(const std::string& str);
04230
04231 template<> CV_EXPORTS
04232 int CommandLineParser::analyzeValue<int>(const std::string& str);
04233
04234 template<> CV_EXPORTS
04235 unsigned CommandLineParser::analyzeValue<unsigned int>(const std::string& str);
04236
04237 template<> CV_EXPORTS
04238 float CommandLineParser::analyzeValue<float>(const std::string& str);
04239
04240 template<> CV_EXPORTS
04241 double CommandLineParser::analyzeValue<double>(const std::string& str);
04242
04243 }
04244
04245 #endif // __cplusplus
04246
04247 #include "opencv2/core/operations.hpp"
04248 #include "opencv2/core/mat.hpp"
04249
04250 #endif