- Main Page
- Related Pages
- Namespaces
- Classes
- Files

- File List
- File Members

# C:/opt/OpenCV-2.2.0/modules/core/include/opencv2/core/core.hpp

Go to the documentation of this file.

    00001
    00004 /*M///////////////////////////////////////////////////////////////////////////////////////
    00005 //
    00006 //  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
    00007 //
    00008 //  By downloading, copying, installing or using the software you agree to this license.
    00009 //  If you do not agree to this license, do not download, install,
    00010 //  copy or use the software.
    00011 //
    00012 //
    00013 //                           License Agreement
    00014 //                For Open Source Computer Vision Library
    00015 //
    00016 // Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
    00017 // Copyright (C) 2009, Willow Garage Inc., all rights reserved.
    00018 // Third party copyrights are property of their respective owners.
    00019 //
    00020 // Redistribution and use in source and binary forms, with or without modification,
    00021 // are permitted provided that the following conditions are met:
    00022 //
    00023 //   * Redistribution's of source code must retain the above copyright notice,
    00024 //     this list of conditions and the following disclaimer.
    00025 //
    00026 //   * Redistribution's in binary form must reproduce the above copyright notice,
    00027 //     this list of conditions and the following disclaimer in the documentation
    00028 //     and/or other materials provided with the distribution.
    00029 //
    00030 //   * The name of the copyright holders may not be used to endorse or promote products
    00031 //     derived from this software without specific prior written permission.
    00032 //
    00033 // This software is provided by the copyright holders and contributors "as is" and
    00034 // any express or implied warranties, including, but not limited to, the implied
    00035 // warranties of merchantability and fitness for a particular purpose are disclaimed.
    00036 // In no event shall the Intel Corporation or contributors be liable for any direct,
    00037 // indirect, incidental, special, exemplary, or consequential damages
    00038 // (including, but not limited to, procurement of substitute goods or services;
    00039 // loss of use, data, or profits; or business interruption) however caused
    00040 // and on any theory of liability, whether in contract, strict liability,
    00041 // or tort (including negligence or otherwise) arising in any way out of
    00042 // the use of this software, even if advised of the possibility of such damage.
    00043 //
    00044 //M*/
    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 <complex>
    00059 #include <map>
    00060 #include <new>
    00061 #include <string>
    00062 #include <vector>
    00063 #endif // SKIP_INCLUDES
    00064
    00068 namespace cv {
    00069
    00070 #undef abs
    00071 #undef min
    00072 #undef max
    00073 #undef Complex
    00074
    00075 using std::vector;
    00076 using std::string;
    00077
    00078 template<typename _Tp> class CV_EXPORTS Size_;
    00079 template<typename _Tp> class CV_EXPORTS Point_;
    00080 template<typename _Tp> class CV_EXPORTS Rect_;
    00081 template<typename _Tp, int cn> class CV_EXPORTS Vec;
    00082 template<typename _Tp, int m, int n> class CV_EXPORTS Matx;
    00083
    00084 typedef std::string String;
    00085 typedef std::basic_string<wchar_t> WString;
    00086
    00087 class Mat;
    00088 class SparseMat;
    00089 typedef Mat MatND;
    00090
    00091 class CV_EXPORTS MatExpr;
    00092 class CV_EXPORTS MatOp_Base;
    00093 class CV_EXPORTS MatArg;
    00094 class CV_EXPORTS MatConstIterator;
    00095
    00096 template<typename _Tp> class CV_EXPORTS Mat_;
    00097 template<typename _Tp> class CV_EXPORTS MatIterator_;
    00098 template<typename _Tp> class CV_EXPORTS MatConstIterator_;
    00099 template<typename _Tp> class CV_EXPORTS MatCommaInitializer_;
    00100
    00101 CV_EXPORTS string fromUtf16(const WString& str);
    00102 CV_EXPORTS WString toUtf16(const string& str);
    00103
    00104 CV_EXPORTS string format( const char* fmt, ... );
    00105
    00106
    00107 // matrix decomposition types
    00108 enum { DECOMP_LU=0, DECOMP_SVD=1, DECOMP_EIG=2, DECOMP_CHOLESKY=3, DECOMP_QR=4, DECOMP_NORMAL=16 };
    00109 enum { NORM_INF=1, NORM_L1=2, NORM_L2=4, NORM_TYPE_MASK=7, NORM_RELATIVE=8, NORM_MINMAX=32};
    00110 enum { CMP_EQ=0, CMP_GT=1, CMP_GE=2, CMP_LT=3, CMP_LE=4, CMP_NE=5 };
    00111 enum { GEMM_1_T=1, GEMM_2_T=2, GEMM_3_T=4 };
    00112 enum { DFT_INVERSE=1, DFT_SCALE=2, DFT_ROWS=4, DFT_COMPLEX_OUTPUT=16, DFT_REAL_OUTPUT=32,
    00113     DCT_INVERSE = DFT_INVERSE, DCT_ROWS=DFT_ROWS };
    00114
    00115
    00120 class CV_EXPORTS Exception : public std::exception
    00121 {
    00122 public:
    00126     Exception() { code = 0; line = 0; }
    00131         Exception(int _code, const string& _err, const string& _func, const string& _file, int _line)
    00132                 : code(_code), err(_err), func(_func), file(_file), line(_line)
    00133     { formatMessage(); }
    00134
    00135         virtual ~Exception() throw() {}
    00136
    00140         virtual const char *what() const throw() { return msg.c_str(); }
    00141
    00142     void formatMessage()
    00143     {
    00144         if( func.size() > 0 )
    00145             msg = format("%s:%d: error: (%d) %s in function %s\n", file.c_str(), line, code, err.c_str(), func.c_str());
    00146         else
    00147             msg = format("%s:%d: error: (%d) %s\n", file.c_str(), line, code, err.c_str());
    00148     }
    00149
    00150         string msg;
    00151
    00152         int code;
    00153         string err;
    00154         string func;
    00155         string file;
    00156         int line;
    00157 };
    00158
    00159
    00161
    00169 CV_EXPORTS void error( const Exception& exc );
    00170
    00172
    00179 CV_EXPORTS bool setBreakOnError(bool flag);
    00180
    00181 typedef int (CV_CDECL *ErrorCallback)( int status, const char* func_name,
    00182                                        const char* err_msg, const char* file_name,
    00183                                        int line, void* userdata );
    00184
    00186
    00196 CV_EXPORTS ErrorCallback redirectError( ErrorCallback errCallback,
    00197                                         void* userdata=0, void** prevUserdata=0);
    00198
    00199 #ifdef __GNUC__
    00200 #define CV_Error( code, msg ) cv::error( cv::Exception(code, msg, __func__, __FILE__, __LINE__) )
    00201 #define CV_Error_( code, args ) cv::error( cv::Exception(code, cv::format args, __func__, __FILE__, __LINE__) )
    00202 #define CV_Assert( expr ) if((expr)) ; else cv::error( cv::Exception(CV_StsAssert, #expr, __func__, __FILE__, __LINE__) )
    00203 #else
    00204 #define CV_Error( code, msg ) cv::error( cv::Exception(code, msg, "", __FILE__, __LINE__) )
    00205 #define CV_Error_( code, args ) cv::error( cv::Exception(code, cv::format args, "", __FILE__, __LINE__) )
    00206 #define CV_Assert( expr ) if((expr)) ; else cv::error( cv::Exception(CV_StsAssert, #expr, "", __FILE__, __LINE__) )
    00207 #endif
    00208
    00209 #ifdef _DEBUG
    00210 #define CV_DbgAssert(expr) CV_Assert(expr)
    00211 #else
    00212 #define CV_DbgAssert(expr)
    00213 #endif
    00214
    00215 CV_EXPORTS void setNumThreads(int nthreads);
    00216 CV_EXPORTS int getNumThreads();
    00217 CV_EXPORTS int getThreadNum();
    00218
    00220
    00227 CV_EXPORTS int64 getTickCount();
    00228
    00241 CV_EXPORTS_W double getTickFrequency();
    00242
    00251 CV_EXPORTS int64 getCPUTickCount();
    00252
    00271 CV_EXPORTS_W bool checkHardwareSupport(int feature);
    00272
    00283 CV_EXPORTS void* fastMalloc(size_t bufSize);
    00284
    00291 CV_EXPORTS void fastFree(void* ptr);
    00292
    00293 template<typename _Tp> static inline _Tp* allocate(size_t n)
    00294 {
    00295     return new _Tp[n];
    00296 }
    00297
    00298 template<typename _Tp> static inline void deallocate(_Tp* ptr, size_t)
    00299 {
    00300     delete[] ptr;
    00301 }
    00302
    00309 template<typename _Tp> static inline _Tp* alignPtr(_Tp* ptr, int n=(int)sizeof(_Tp))
    00310 {
    00311     return (_Tp*)(((size_t)ptr + n-1) & -n);
    00312 }
    00313
    00319 static inline size_t alignSize(size_t sz, int n)
    00320 {
    00321     return (sz + n-1) & -n;
    00322 }
    00323
    00333 CV_EXPORTS_W void setUseOptimized(bool onoff);
    00334
    00340 CV_EXPORTS_W bool useOptimized();
    00341
    00345 template<typename _Tp> class CV_EXPORTS Allocator
    00346 {
    00347 public:
    00348     typedef _Tp value_type;
    00349     typedef value_type* pointer;
    00350     typedef const value_type* const_pointer;
    00351     typedef value_type& reference;
    00352     typedef const value_type& const_reference;
    00353     typedef size_t size_type;
    00354     typedef ptrdiff_t difference_type;
    00355     template<typename U> class rebind { typedef Allocator<U> other; };
    00356
    00357     explicit Allocator() {}
    00358     ~Allocator() {}
    00359     explicit Allocator(Allocator const&) {}
    00360     template<typename U>
    00361     explicit Allocator(Allocator<U> const&) {}
    00362
    00363     // address
    00364     pointer address(reference r) { return &r; }
    00365     const_pointer address(const_reference r) { return &r; }
    00366
    00367     pointer allocate(size_type count, const void* =0)
    00368     { return reinterpret_cast<pointer>(fastMalloc(count * sizeof (_Tp))); }
    00369
    00370     void deallocate(pointer p, size_type) {fastFree(p); }
    00371
    00372     size_type max_size() const
    00373     { return max(static_cast<_Tp>(-1)/sizeof(_Tp), 1); }
    00374
    00375     void construct(pointer p, const _Tp& v) { new(static_cast<void*>(p)) _Tp(v); }
    00376     void destroy(pointer p) { p->~_Tp(); }
    00377 };
    00378
    00380
    00387 template<typename _Tp> class CV_EXPORTS DataDepth {};
    00388
    00389 template<> class DataDepth<bool> { public: enum { value = CV_8U, fmt=(int)'u' }; };
    00390 template<> class DataDepth<uchar> { public: enum { value = CV_8U, fmt=(int)'u' }; };
    00391 template<> class DataDepth<schar> { public: enum { value = CV_8S, fmt=(int)'c' }; };
    00392 template<> class DataDepth<char> { public: enum { value = CV_8S, fmt=(int)'c' }; };
    00393 template<> class DataDepth<ushort> { public: enum { value = CV_16U, fmt=(int)'w' }; };
    00394 template<> class DataDepth<short> { public: enum { value = CV_16S, fmt=(int)'s' }; };
    00395 template<> class DataDepth<int> { public: enum { value = CV_32S, fmt=(int)'i' }; };
    00396 // this is temporary solution to support 32-bit unsigned integers
    00397 template<> class DataDepth<unsigned> { public: enum { value = CV_32S, fmt=(int)'i' }; };
    00398 template<> class DataDepth<float> { public: enum { value = CV_32F, fmt=(int)'f' }; };
    00399 template<> class DataDepth<double> { public: enum { value = CV_64F, fmt=(int)'d' }; };
    00400 template<typename _Tp> class DataDepth<_Tp*> { public: enum { value = CV_USRTYPE1, fmt=(int)'r' }; };
    00401
    00402
    00404
    00421 struct CV_EXPORTS Matx_AddOp {};
    00422 struct CV_EXPORTS Matx_SubOp {};
    00423 struct CV_EXPORTS Matx_ScaleOp {};
    00424 struct CV_EXPORTS Matx_MulOp {};
    00425 struct CV_EXPORTS Matx_MatMulOp {};
    00426 struct CV_EXPORTS Matx_TOp {};
    00427
    00428 template<typename _Tp, int m, int n> class CV_EXPORTS Matx
    00429 {
    00430 public:
    00431     typedef _Tp value_type;
    00432     typedef Matx<_Tp, MIN(m, n), 1> diag_type;
    00433     typedef Matx<_Tp, m, n> mat_type;
    00434     enum { depth = DataDepth<_Tp>::value, rows = m, cols = n, channels = rows*cols,
    00435            type = CV_MAKETYPE(depth, channels) };
    00436
    00438     Matx();
    00439
    00440     Matx(_Tp v0);
    00441     Matx(_Tp v0, _Tp v1);
    00442     Matx(_Tp v0, _Tp v1, _Tp v2);
    00443     Matx(_Tp v0, _Tp v1, _Tp v2, _Tp v3);
    00444     Matx(_Tp v0, _Tp v1, _Tp v2, _Tp v3, _Tp v4);
    00445     Matx(_Tp v0, _Tp v1, _Tp v2, _Tp v3, _Tp v4, _Tp v5);
    00446     Matx(_Tp v0, _Tp v1, _Tp v2, _Tp v3, _Tp v4, _Tp v5, _Tp v6);
    00447     Matx(_Tp v0, _Tp v1, _Tp v2, _Tp v3, _Tp v4, _Tp v5, _Tp v6, _Tp v7);
    00448     Matx(_Tp v0, _Tp v1, _Tp v2, _Tp v3, _Tp v4, _Tp v5, _Tp v6, _Tp v7, _Tp v8);
    00449     Matx(_Tp v0, _Tp v1, _Tp v2, _Tp v3, _Tp v4, _Tp v5, _Tp v6, _Tp v7, _Tp v8, _Tp v9);
    00450     Matx(_Tp v0, _Tp v1, _Tp v2, _Tp v3,
    00451          _Tp v4, _Tp v5, _Tp v6, _Tp v7,
    00452          _Tp v8, _Tp v9, _Tp v10, _Tp v11);
    00453     Matx(_Tp v0, _Tp v1, _Tp v2, _Tp v3,
    00454          _Tp v4, _Tp v5, _Tp v6, _Tp v7,
    00455          _Tp v8, _Tp v9, _Tp v10, _Tp v11,
    00456          _Tp v12, _Tp v13, _Tp v14, _Tp v15);
    00457     explicit Matx(const _Tp* vals);
    00458
    00459     static Matx all(_Tp alpha);
    00460     static Matx zeros();
    00461     static Matx ones();
    00462     static Matx eye();
    00463     static Matx diag(const diag_type& d);
    00464     static Matx randu(_Tp a, _Tp b);
    00465     static Matx randn(_Tp a, _Tp b);
    00466
    00468     _Tp dot(const Matx<_Tp, m, n>& v) const;
    00469
    00471     double ddot(const Matx<_Tp, m, n>& v) const;
    00472
    00474     template<typename T2> operator Matx<T2, m, n>() const;
    00475
    00477     template<int m1, int n1> Matx<_Tp, m1, n1> reshape() const;
    00478
    00480     template<int m1, int n1> Matx<_Tp, m1, n1> get_minor(int i, int j) const;
    00481
    00483     Matx<_Tp, 1, n> row(int i) const;
    00484
    00486     Matx<_Tp, m, 1> col(int i) const;
    00487
    00489     Matx<_Tp, MIN(m,n), 1> diag() const;
    00490
    00492     Matx<_Tp, n, m> t() const;
    00493
    00495     Matx<_Tp, n, m> inv(int method=DECOMP_LU) const;
    00496
    00498     template<int l> Matx<_Tp, n, l> solve(const Matx<_Tp, m, l>& rhs, int flags=DECOMP_LU) const;
    00499     Matx<_Tp, n, 1> solve(const Matx<_Tp, m, 1>& rhs, int method) const;
    00500
    00502     Matx<_Tp, m, n> mul(const Matx<_Tp, m, n>& a) const;
    00503
    00505     const _Tp& operator ()(int i, int j) const;
    00506     _Tp& operator ()(int i, int j);
    00507
    00509     const _Tp& operator ()(int i) const;
    00510     _Tp& operator ()(int i);
    00511
    00512     Matx(const Matx<_Tp, m, n>& a, const Matx<_Tp, m, n>& b, Matx_AddOp);
    00513     Matx(const Matx<_Tp, m, n>& a, const Matx<_Tp, m, n>& b, Matx_SubOp);
    00514     template<typename _T2> Matx(const Matx<_Tp, m, n>& a, _T2 alpha, Matx_ScaleOp);
    00515     Matx(const Matx<_Tp, m, n>& a, const Matx<_Tp, m, n>& b, Matx_MulOp);
    00516     template<int l> Matx(const Matx<_Tp, m, l>& a, const Matx<_Tp, l, n>& b, Matx_MatMulOp);
    00517     Matx(const Matx<_Tp, n, m>& a, Matx_TOp);
    00518
    00519     _Tp val[m*n]; //< matrix elements
    00520 };
    00521
    00522
    00523 typedef Matx<float, 1, 2> Matx12f;
    00524 typedef Matx<double, 1, 2> Matx12d;
    00525 typedef Matx<float, 1, 3> Matx13f;
    00526 typedef Matx<double, 1, 3> Matx13d;
    00527 typedef Matx<float, 1, 4> Matx14f;
    00528 typedef Matx<double, 1, 4> Matx14d;
    00529 typedef Matx<float, 1, 6> Matx16f;
    00530 typedef Matx<double, 1, 6> Matx16d;
    00531
    00532 typedef Matx<float, 2, 1> Matx21f;
    00533 typedef Matx<double, 2, 1> Matx21d;
    00534 typedef Matx<float, 3, 1> Matx31f;
    00535 typedef Matx<double, 3, 1> Matx31d;
    00536 typedef Matx<float, 4, 1> Matx41f;
    00537 typedef Matx<double, 4, 1> Matx41d;
    00538 typedef Matx<float, 6, 1> Matx61f;
    00539 typedef Matx<double, 6, 1> Matx61d;
    00540
    00541 typedef Matx<float, 2, 2> Matx22f;
    00542 typedef Matx<double, 2, 2> Matx22d;
    00543 typedef Matx<float, 2, 3> Matx23f;
    00544 typedef Matx<double, 2, 3> Matx23d;
    00545 typedef Matx<float, 3, 2> Matx32f;
    00546 typedef Matx<double, 3, 2> Matx32d;
    00547
    00548 typedef Matx<float, 3, 3> Matx33f;
    00549 typedef Matx<double, 3, 3> Matx33d;
    00550
    00551 typedef Matx<float, 3, 4> Matx34f;
    00552 typedef Matx<double, 3, 4> Matx34d;
    00553 typedef Matx<float, 4, 3> Matx43f;
    00554 typedef Matx<double, 4, 3> Matx43d;
    00555
    00556 typedef Matx<float, 4, 4> Matx44f;
    00557 typedef Matx<double, 4, 4> Matx44d;
    00558 typedef Matx<float, 6, 6> Matx66f;
    00559 typedef Matx<double, 6, 6> Matx66d;
    00560
    00561
    00577 template<typename _Tp, int cn> class CV_EXPORTS Vec : public Matx<_Tp, cn, 1>
    00578 {
    00579 public:
    00580     typedef _Tp value_type;
    00581     enum { depth = DataDepth<_Tp>::value, channels = cn, type = CV_MAKETYPE(depth, channels) };
    00582
    00584     Vec();
    00585
    00586     Vec(_Tp v0);
    00587     Vec(_Tp v0, _Tp v1);
    00588     Vec(_Tp v0, _Tp v1, _Tp v2);
    00589     Vec(_Tp v0, _Tp v1, _Tp v2, _Tp v3);
    00590     Vec(_Tp v0, _Tp v1, _Tp v2, _Tp v3, _Tp v4);
    00591     Vec(_Tp v0, _Tp v1, _Tp v2, _Tp v3, _Tp v4, _Tp v5);
    00592     Vec(_Tp v0, _Tp v1, _Tp v2, _Tp v3, _Tp v4, _Tp v5, _Tp v6);
    00593     Vec(_Tp v0, _Tp v1, _Tp v2, _Tp v3, _Tp v4, _Tp v5, _Tp v6, _Tp v7);
    00594     Vec(_Tp v0, _Tp v1, _Tp v2, _Tp v3, _Tp v4, _Tp v5, _Tp v6, _Tp v7, _Tp v8);
    00595     Vec(_Tp v0, _Tp v1, _Tp v2, _Tp v3, _Tp v4, _Tp v5, _Tp v6, _Tp v7, _Tp v8, _Tp v9);
    00596     explicit Vec(const _Tp* values);
    00597
    00598     Vec(const Vec<_Tp, cn>& v);
    00599     static Vec all(_Tp alpha);
    00600
    00602     Vec mul(const Vec<_Tp, cn>& v) const;
    00603
    00609     Vec cross(const Vec& v) const;
    00611     template<typename T2> operator Vec<T2, cn>() const;
    00613     operator CvScalar() const;
    00614
    00616     const _Tp& operator [](int i) const;
    00617     _Tp& operator[](int i);
    00618     const _Tp& operator ()(int i) const;
    00619     _Tp& operator ()(int i);
    00620 };
    00621
    00622
    00623 /* \typedef
    00624
    00625    Shorter aliases for the most popular specializations of Vec<T,n>
    00626 */
    00627 typedef Vec<uchar, 2> Vec2b;
    00628 typedef Vec<uchar, 3> Vec3b;
    00629 typedef Vec<uchar, 4> Vec4b;
    00630
    00631 typedef Vec<short, 2> Vec2s;
    00632 typedef Vec<short, 3> Vec3s;
    00633 typedef Vec<short, 4> Vec4s;
    00634
    00635 typedef Vec<ushort, 2> Vec2w;
    00636 typedef Vec<ushort, 3> Vec3w;
    00637 typedef Vec<ushort, 4> Vec4w;
    00638
    00639 typedef Vec<int, 2> Vec2i;
    00640 typedef Vec<int, 3> Vec3i;
    00641 typedef Vec<int, 4> Vec4i;
    00642
    00643 typedef Vec<float, 2> Vec2f;
    00644 typedef Vec<float, 3> Vec3f;
    00645 typedef Vec<float, 4> Vec4f;
    00646 typedef Vec<float, 6> Vec6f;
    00647
    00648 typedef Vec<double, 2> Vec2d;
    00649 typedef Vec<double, 3> Vec3d;
    00650 typedef Vec<double, 4> Vec4d;
    00651 typedef Vec<double, 6> Vec6d;
    00652
    00653
    00655
    00663 template<typename _Tp> class CV_EXPORTS Complex
    00664 {
    00665 public:
    00666
    00668     Complex();
    00669     Complex( _Tp _re, _Tp _im=0 );
    00670     Complex( const std::complex<_Tp>& c );
    00671
    00673     template<typename T2> operator Complex<T2>() const;
    00675     Complex conj() const;
    00677     operator std::complex<_Tp>() const;
    00678
    00679     _Tp re, im; //< the real and the imaginary parts
    00680 };
    00681
    00682
    00686 typedef Complex<float> Complexf;
    00687 typedef Complex<double> Complexd;
    00688
    00689
    00691
    00699 template<typename _Tp> class CV_EXPORTS Point_
    00700 {
    00701 public:
    00702     typedef _Tp value_type;
    00703
    00704     // various constructors
    00705     Point_();
    00706     Point_(_Tp _x, _Tp _y);
    00707     Point_(const Point_& pt);
    00708     Point_(const CvPoint& pt);
    00709     Point_(const CvPoint2D32f& pt);
    00710     Point_(const Size_<_Tp>& sz);
    00711     Point_(const Vec<_Tp, 2>& v);
    00712
    00713     Point_& operator = (const Point_& pt);
    00715     template<typename _Tp2> operator Point_<_Tp2>() const;
    00716
    00718     operator CvPoint() const;
    00719     operator CvPoint2D32f() const;
    00720     operator Vec<_Tp, 2>() const;
    00721
    00723     _Tp dot(const Point_& pt) const;
    00725     double ddot(const Point_& pt) const;
    00727     bool inside(const Rect_<_Tp>& r) const;
    00728
    00729     _Tp x, y; //< the point coordinates
    00730 };
    00731
    00740 template<typename _Tp> class CV_EXPORTS Point3_
    00741 {
    00742 public:
    00743     typedef _Tp value_type;
    00744
    00745     // various constructors
    00746     Point3_();
    00747     Point3_(_Tp _x, _Tp _y, _Tp _z);
    00748     Point3_(const Point3_& pt);
    00749         explicit Point3_(const Point_<_Tp>& pt);
    00750     Point3_(const CvPoint3D32f& pt);
    00751     Point3_(const Vec<_Tp, 3>& v);
    00752
    00753     Point3_& operator = (const Point3_& pt);
    00755     template<typename _Tp2> operator Point3_<_Tp2>() const;
    00757     operator CvPoint3D32f() const;
    00759     operator Vec<_Tp, 3>() const;
    00760
    00762     _Tp dot(const Point3_& pt) const;
    00764     double ddot(const Point3_& pt) const;
    00766     Point3_ cross(const Point3_& pt) const;
    00767
    00768     _Tp x, y, z; //< the point coordinates
    00769 };
    00770
    00772
    00779 template<typename _Tp> class CV_EXPORTS Size_
    00780 {
    00781 public:
    00782     typedef _Tp value_type;
    00783
    00785     Size_();
    00786     Size_(_Tp _width, _Tp _height);
    00787     Size_(const Size_& sz);
    00788     Size_(const CvSize& sz);
    00789     Size_(const CvSize2D32f& sz);
    00790     Size_(const Point_<_Tp>& pt);
    00791
    00792     Size_& operator = (const Size_& sz);
    00794     _Tp area() const;
    00795
    00797     template<typename _Tp2> operator Size_<_Tp2>() const;
    00798
    00800     operator CvSize() const;
    00801     operator CvSize2D32f() const;
    00802
    00803     _Tp width, height; // the width and the height
    00804 };
    00805
    00807
    00814 template<typename _Tp> class CV_EXPORTS Rect_
    00815 {
    00816 public:
    00817     typedef _Tp value_type;
    00818
    00820     Rect_();
    00821     Rect_(_Tp _x, _Tp _y, _Tp _width, _Tp _height);
    00822     Rect_(const Rect_& r);
    00823     Rect_(const CvRect& r);
    00824     Rect_(const Point_<_Tp>& org, const Size_<_Tp>& sz);
    00825     Rect_(const Point_<_Tp>& pt1, const Point_<_Tp>& pt2);
    00826
    00827     Rect_& operator = ( const Rect_& r );
    00829     Point_<_Tp> tl() const;
    00831     Point_<_Tp> br() const;
    00832
    00834     Size_<_Tp> size() const;
    00836     _Tp area() const;
    00837
    00839     template<typename _Tp2> operator Rect_<_Tp2>() const;
    00841     operator CvRect() const;
    00842
    00844     bool contains(const Point_<_Tp>& pt) const;
    00845
    00846     _Tp x, y, width, height; //< the top-left corner, as well as width and height of the rectangle
    00847 };
    00848
    00849
    00855 typedef Point_<int> Point2i;
    00856 typedef Point2i Point;
    00857 typedef Size_<int> Size2i;
    00858 typedef Size2i Size;
    00859 typedef Rect_<int> Rect;
    00860 typedef Point_<float> Point2f;
    00861 typedef Point_<double> Point2d;
    00862 typedef Size_<float> Size2f;
    00863 typedef Point3_<int> Point3i;
    00864 typedef Point3_<float> Point3f;
    00865 typedef Point3_<double> Point3d;
    00866
    00867
    00875 class CV_EXPORTS RotatedRect
    00876 {
    00877 public:
    00879     RotatedRect();
    00880     RotatedRect(const Point2f& _center, const Size2f& _size, float _angle);
    00881     RotatedRect(const CvBox2D& box);
    00882
    00884     void points(Point2f pts[]) const;
    00886     Rect boundingRect() const;
    00888     operator CvBox2D() const;
    00889
    00890     Point2f center; //< the rectangle mass center
    00891     Size2f size;    //< width and height of the rectangle
    00892     float angle;    //< the rotation angle. When the angle is 0, 90, 180, 270 etc., the rectangle becomes an up-right rectangle.
    00893 };
    00894
    00896
    00903 template<typename _Tp> class CV_EXPORTS Scalar_ : public Vec<_Tp, 4>
    00904 {
    00905 public:
    00907     Scalar_();
    00908     Scalar_(_Tp v0, _Tp v1, _Tp v2=0, _Tp v3=0);
    00909     Scalar_(const CvScalar& s);
    00910     Scalar_(_Tp v0);
    00911
    00913     static Scalar_<_Tp> all(_Tp v0);
    00915     operator CvScalar() const;
    00916
    00918     template<typename T2> operator Scalar_<T2>() const;
    00919
    00921     Scalar_<_Tp> mul(const Scalar_<_Tp>& t, double scale=1 ) const;
    00922
    00923     // returns (v0, -v1, -v2, -v3)
    00924     Scalar_<_Tp> conj() const;
    00925
    00926     // returns true iff v1 == v2 == v3 == 0
    00927     bool isReal() const;
    00928 };
    00929
    00930 typedef Scalar_<double> Scalar;
    00931
    00932 CV_EXPORTS void scalarToRawData(const Scalar& s, void* buf, int type, int unroll_to=0);
    00933
    00935
    00941 class CV_EXPORTS Range
    00942 {
    00943 public:
    00944     Range();
    00945     Range(int _start, int _end);
    00946     Range(const CvSlice& slice);
    00947     int size() const;
    00948     bool empty() const;
    00949     static Range all();
    00950     operator CvSlice() const;
    00951
    00952     int start, end;
    00953 };
    00954
    00956
    00968 template<typename _Tp> class DataType
    00969 {
    00970 public:
    00971     typedef _Tp value_type;
    00972     typedef value_type work_type;
    00973     typedef value_type channel_type;
    00974     typedef value_type vec_type;
    00975
    00976     enum { generic_type = 1, depth = DataDepth<channel_type>::value, channels = 1,
    00977         fmt=DataDepth<channel_type>::fmt,
    00978         type = CV_MAKETYPE(depth, channels) };
    00979 };
    00980
    00981 template<> class DataType<bool>
    00982 {
    00983 public:
    00984     typedef bool value_type;
    00985     typedef int work_type;
    00986     typedef value_type channel_type;
    00987     typedef value_type vec_type;
    00988     enum { generic_type = 0, depth = DataDepth<channel_type>::value, channels = 1,
    00989            fmt=DataDepth<channel_type>::fmt,
    00990            type = CV_MAKETYPE(depth, channels) };
    00991 };
    00992
    00993 template<> class DataType<uchar>
    00994 {
    00995 public:
    00996     typedef uchar value_type;
    00997     typedef int work_type;
    00998     typedef value_type channel_type;
    00999     typedef value_type vec_type;
    01000     enum { generic_type = 0, depth = DataDepth<channel_type>::value, channels = 1,
    01001            fmt=DataDepth<channel_type>::fmt,
    01002            type = CV_MAKETYPE(depth, channels) };
    01003 };
    01004
    01005 template<> class DataType<schar>
    01006 {
    01007 public:
    01008     typedef schar value_type;
    01009     typedef int work_type;
    01010     typedef value_type channel_type;
    01011     typedef value_type vec_type;
    01012     enum { generic_type = 0, depth = DataDepth<channel_type>::value, channels = 1,
    01013            fmt=DataDepth<channel_type>::fmt,
    01014            type = CV_MAKETYPE(depth, channels) };
    01015 };
    01016
    01017 template<> class DataType<char>
    01018 {
    01019 public:
    01020     typedef schar value_type;
    01021     typedef int work_type;
    01022     typedef value_type channel_type;
    01023     typedef value_type vec_type;
    01024     enum { generic_type = 0, depth = DataDepth<channel_type>::value, channels = 1,
    01025            fmt=DataDepth<channel_type>::fmt,
    01026            type = CV_MAKETYPE(depth, channels) };
    01027 };
    01028
    01029 template<> class DataType<ushort>
    01030 {
    01031 public:
    01032     typedef ushort value_type;
    01033     typedef int work_type;
    01034     typedef value_type channel_type;
    01035     typedef value_type vec_type;
    01036     enum { generic_type = 0, depth = DataDepth<channel_type>::value, channels = 1,
    01037            fmt=DataDepth<channel_type>::fmt,
    01038            type = CV_MAKETYPE(depth, channels) };
    01039 };
    01040
    01041 template<> class DataType<short>
    01042 {
    01043 public:
    01044     typedef short value_type;
    01045     typedef int work_type;
    01046     typedef value_type channel_type;
    01047     typedef value_type vec_type;
    01048     enum { generic_type = 0, depth = DataDepth<channel_type>::value, channels = 1,
    01049            fmt=DataDepth<channel_type>::fmt,
    01050            type = CV_MAKETYPE(depth, channels) };
    01051 };
    01052
    01053 template<> class DataType<int>
    01054 {
    01055 public:
    01056     typedef int value_type;
    01057     typedef value_type work_type;
    01058     typedef value_type channel_type;
    01059     typedef value_type vec_type;
    01060     enum { generic_type = 0, depth = DataDepth<channel_type>::value, channels = 1,
    01061            fmt=DataDepth<channel_type>::fmt,
    01062            type = CV_MAKETYPE(depth, channels) };
    01063 };
    01064
    01065 template<> class DataType<float>
    01066 {
    01067 public:
    01068     typedef float value_type;
    01069     typedef value_type work_type;
    01070     typedef value_type channel_type;
    01071     typedef value_type vec_type;
    01072     enum { generic_type = 0, depth = DataDepth<channel_type>::value, channels = 1,
    01073            fmt=DataDepth<channel_type>::fmt,
    01074            type = CV_MAKETYPE(depth, channels) };
    01075 };
    01076
    01077 template<> class DataType<double>
    01078 {
    01079 public:
    01080     typedef double value_type;
    01081     typedef value_type work_type;
    01082     typedef value_type channel_type;
    01083     typedef value_type vec_type;
    01084     enum { generic_type = 0, depth = DataDepth<channel_type>::value, channels = 1,
    01085            fmt=DataDepth<channel_type>::fmt,
    01086            type = CV_MAKETYPE(depth, channels) };
    01087 };
    01088
    01089 template<typename _Tp, int cn> class DataType<Vec<_Tp, cn> >
    01090 {
    01091 public:
    01092     typedef Vec<_Tp, cn> value_type;
    01093     typedef Vec<typename DataType<_Tp>::work_type, cn> work_type;
    01094     typedef _Tp channel_type;
    01095     typedef value_type vec_type;
    01096     enum { generic_type = 0, depth = DataDepth<channel_type>::value, channels = cn,
    01097            fmt = ((channels-1)<<8) + DataDepth<channel_type>::fmt,
    01098            type = CV_MAKETYPE(depth, channels) };
    01099 };
    01100
    01101 template<typename _Tp> class DataType<std::complex<_Tp> >
    01102 {
    01103 public:
    01104     typedef std::complex<_Tp> value_type;
    01105     typedef value_type work_type;
    01106     typedef _Tp channel_type;
    01107     enum { generic_type = 0, depth = DataDepth<channel_type>::value, channels = 2,
    01108            fmt = ((channels-1)<<8) + DataDepth<channel_type>::fmt,
    01109            type = CV_MAKETYPE(depth, channels) };
    01110     typedef Vec<channel_type, channels> vec_type;
    01111 };
    01112
    01113 template<typename _Tp> class DataType<Complex<_Tp> >
    01114 {
    01115 public:
    01116     typedef Complex<_Tp> value_type;
    01117     typedef value_type work_type;
    01118     typedef _Tp channel_type;
    01119     enum { generic_type = 0, depth = DataDepth<channel_type>::value, channels = 2,
    01120            fmt = ((channels-1)<<8) + DataDepth<channel_type>::fmt,
    01121            type = CV_MAKETYPE(depth, channels) };
    01122     typedef Vec<channel_type, channels> vec_type;
    01123 };
    01124
    01125 template<typename _Tp> class DataType<Point_<_Tp> >
    01126 {
    01127 public:
    01128     typedef Point_<_Tp> value_type;
    01129     typedef Point_<typename DataType<_Tp>::work_type> work_type;
    01130     typedef _Tp channel_type;
    01131     enum { generic_type = 0, depth = DataDepth<channel_type>::value, channels = 2,
    01132            fmt = ((channels-1)<<8) + DataDepth<channel_type>::fmt,
    01133            type = CV_MAKETYPE(depth, channels) };
    01134     typedef Vec<channel_type, channels> vec_type;
    01135 };
    01136
    01137 template<typename _Tp> class DataType<Point3_<_Tp> >
    01138 {
    01139 public:
    01140     typedef Point3_<_Tp> value_type;
    01141     typedef Point3_<typename DataType<_Tp>::work_type> work_type;
    01142     typedef _Tp channel_type;
    01143     enum { generic_type = 0, depth = DataDepth<channel_type>::value, channels = 3,
    01144            fmt = ((channels-1)<<8) + DataDepth<channel_type>::fmt,
    01145            type = CV_MAKETYPE(depth, channels) };
    01146     typedef Vec<channel_type, channels> vec_type;
    01147 };
    01148
    01149 template<typename _Tp> class DataType<Size_<_Tp> >
    01150 {
    01151 public:
    01152     typedef Size_<_Tp> value_type;
    01153     typedef Size_<typename DataType<_Tp>::work_type> work_type;
    01154     typedef _Tp channel_type;
    01155     enum { generic_type = 0, depth = DataDepth<channel_type>::value, channels = 2,
    01156            fmt = ((channels-1)<<8) + DataDepth<channel_type>::fmt,
    01157            type = CV_MAKETYPE(depth, channels) };
    01158     typedef Vec<channel_type, channels> vec_type;
    01159 };
    01160
    01161 template<typename _Tp> class DataType<Rect_<_Tp> >
    01162 {
    01163 public:
    01164     typedef Rect_<_Tp> value_type;
    01165     typedef Rect_<typename DataType<_Tp>::work_type> work_type;
    01166     typedef _Tp channel_type;
    01167     enum { generic_type = 0, depth = DataDepth<channel_type>::value, channels = 4,
    01168            fmt = ((channels-1)<<8) + DataDepth<channel_type>::fmt,
    01169            type = CV_MAKETYPE(depth, channels) };
    01170     typedef Vec<channel_type, channels> vec_type;
    01171 };
    01172
    01173 template<typename _Tp> class DataType<Scalar_<_Tp> >
    01174 {
    01175 public:
    01176     typedef Scalar_<_Tp> value_type;
    01177     typedef Scalar_<typename DataType<_Tp>::work_type> work_type;
    01178     typedef _Tp channel_type;
    01179     enum { generic_type = 0, depth = DataDepth<channel_type>::value, channels = 4,
    01180            fmt = ((channels-1)<<8) + DataDepth<channel_type>::fmt,
    01181            type = CV_MAKETYPE(depth, channels) };
    01182     typedef Vec<channel_type, channels> vec_type;
    01183 };
    01184
    01185 template<> class DataType<Range>
    01186 {
    01187 public:
    01188     typedef Range value_type;
    01189     typedef value_type work_type;
    01190     typedef int channel_type;
    01191     enum { generic_type = 0, depth = DataDepth<channel_type>::value, channels = 2,
    01192            fmt = ((channels-1)<<8) + DataDepth<channel_type>::fmt,
    01193            type = CV_MAKETYPE(depth, channels) };
    01194     typedef Vec<channel_type, channels> vec_type;
    01195 };
    01196
    01197
    01199
    01221 template<typename _Tp> class CV_EXPORTS Ptr
    01222 {
    01223 public:
    01225     Ptr();
    01227     Ptr(_Tp* _obj);
    01229     ~Ptr();
    01231     Ptr(const Ptr& ptr);
    01233     Ptr& operator = (const Ptr& ptr);
    01235     void addref();
    01237     void release();
    01239     void delete_obj();
    01241     bool empty() const;
    01242
    01243
    01245     _Tp* operator -> ();
    01246     const _Tp* operator -> () const;
    01247
    01248     operator _Tp* ();
    01249     operator const _Tp*() const;
    01250
    01251 protected:
    01252     _Tp* obj; //< the object pointer.
    01253     int* refcount; //< the associated                         bbbbbbbbbbbbbbbbbb reference counter
    01254 };
    01255
    01257
    01258 enum { MAGIC_MASK=0xFFFF0000, TYPE_MASK=0x00000FFF, DEPTH_MASK=7 };
    01259
    01260 static inline size_t getElemSize(int type) { return CV_ELEM_SIZE(type); }
    01261
    01266 class CV_EXPORTS MatAllocator
    01267 {
    01268 public:
    01269     MatAllocator() {}
    01270     virtual ~MatAllocator() {}
    01271     virtual void allocate(int dims, const int* sizes, int type, int*& refcount,
    01272                           uchar*& datastart, uchar*& data, size_t* step) = 0;
    01273     virtual void deallocate(int* refcount, uchar* datastart, uchar* data) = 0;
    01274 };
    01275
    01488 class CV_EXPORTS Mat
    01489 {
    01490 public:
    01492     Mat();
    01494     // (_type is CV_8UC1, CV_64FC3, CV_32SC(12) etc.)
    01495     Mat(int _rows, int _cols, int _type);
    01496     Mat(Size _size, int _type);
    01498     Mat(int _rows, int _cols, int _type, const Scalar& _s);
    01499     Mat(Size _size, int _type, const Scalar& _s);
    01500
    01502     Mat(int _ndims, const int* _sizes, int _type);
    01503     Mat(int _ndims, const int* _sizes, int _type, const Scalar& _s);
    01504
    01506     Mat(const Mat& m);
    01508     Mat(int _rows, int _cols, int _type, void* _data, size_t _step=AUTO_STEP);
    01509     Mat(Size _size, int _type, void* _data, size_t _step=AUTO_STEP);
    01510     Mat(int _ndims, const int* _sizes, int _type, void* _data, const size_t* _steps=0);
    01511
    01513     Mat(const Mat& m, const Range& rowRange, const Range& colRange=Range::all());
    01514     Mat(const Mat& m, const Rect& roi);
    01515     Mat(const Mat& m, const Range* ranges);
    01517     Mat(const CvMat* m, bool copyData=false);
    01519     Mat(const CvMatND* m, bool copyData=false);
    01521     Mat(const IplImage* img, bool copyData=false);
    01523     template<typename _Tp> explicit Mat(const vector<_Tp>& vec, bool copyData=false);
    01525     template<typename _Tp, int n> explicit Mat(const Vec<_Tp, n>& vec,
    01526                                                bool copyData=true);
    01528     template<typename _Tp, int m, int n> explicit Mat(const Matx<_Tp, m, n>& mtx,
    01529                                                       bool copyData=true);
    01531     template<typename _Tp> explicit Mat(const Point_<_Tp>& pt, bool copyData=true);
    01533     template<typename _Tp> explicit Mat(const Point3_<_Tp>& pt, bool copyData=true);
    01535     template<typename _Tp> explicit Mat(const MatCommaInitializer_<_Tp>& commaInitializer);
    01537     ~Mat();
    01539     Mat& operator = (const Mat& m);
    01540     Mat& operator = (const MatExpr& expr);
    01541
    01543     Mat row(int y) const;
    01545     Mat col(int x) const;
    01547     Mat rowRange(int startrow, int endrow) const;
    01548     Mat rowRange(const Range& r) const;
    01550     Mat colRange(int startcol, int endcol) const;
    01551     Mat colRange(const Range& r) const;
    01553     // (d=0 - the main diagonal,
    01554     //  >0 - a diagonal from the lower half,
    01555     //  <0 - a diagonal from the upper half)
    01556     Mat diag(int d=0) const;
    01558     static Mat diag(const Mat& d);
    01559
    01561     Mat clone() const;
    01563     // It calls m.create(this->size(), this->type()).
    01564     void copyTo( Mat& m ) const;
    01565     template<typename _Tp> void copyTo( vector<_Tp>& v ) const;
    01567     void copyTo( Mat& m, const Mat& mask ) const;
    01569     void convertTo( Mat& m, int rtype, double alpha=1, double beta=0 ) const;
    01570
    01571     void assignTo( Mat& m, int type=-1 ) const;
    01572
    01574     Mat& operator = (const Scalar& s);
    01576     Mat& setTo(const Scalar& s, const Mat& mask=Mat());
    01578     // number of channels and/or different number of rows. see cvReshape.
    01579     Mat reshape(int _cn, int _rows=0) const;
    01580     Mat reshape(int _cn, int _newndims, const int* _newsz) const;
    01581
    01583     MatExpr t() const;
    01585     MatExpr inv(int method=DECOMP_LU) const;
    01587     MatExpr mul(const Mat& m, double scale=1) const;
    01588     MatExpr mul(const MatExpr& m, double scale=1) const;
    01589
    01591     Mat cross(const Mat& m) const;
    01593     double dot(const Mat& m) const;
    01594
    01596     static MatExpr zeros(int rows, int cols, int type);
    01597     static MatExpr zeros(Size size, int type);
    01598     static MatExpr zeros(int ndims, const int* sz, int type);
    01599     static MatExpr ones(int rows, int cols, int type);
    01600     static MatExpr ones(Size size, int type);
    01601     static MatExpr ones(int ndims, const int* sz, int type);
    01602     static MatExpr eye(int rows, int cols, int type);
    01603     static MatExpr eye(Size size, int type);
    01604
    01606     // previous data is unreferenced if needed.
    01607     void create(int _rows, int _cols, int _type);
    01608     void create(Size _size, int _type);
    01609     void create(int _ndims, const int* _sizes, int _type);
    01610
    01612     void addref();
    01614     // deallocates the data when reference counter reaches 0.
    01615     void release();
    01616
    01618     void deallocate();
    01620     void copySize(const Mat& m);
    01621
    01623     void reserve(size_t sz);
    01625     void resize(size_t sz);
    01627     void resize(size_t sz, const Scalar& s);
    01629     void push_back_(const void* elem);
    01631     template<typename _Tp> void push_back(const _Tp& elem);
    01632     template<typename _Tp> void push_back(const Mat_<_Tp>& elem);
    01633     void push_back(const Mat& m);
    01635     void pop_back(size_t nelems=1);
    01636
    01638     void locateROI( Size& wholeSize, Point& ofs ) const;
    01640     Mat& adjustROI( int dtop, int dbottom, int dleft, int dright );
    01642     // (this is a generalized form of row, rowRange etc.)
    01643     Mat operator()( Range rowRange, Range colRange ) const;
    01644     Mat operator()( const Rect& roi ) const;
    01645     Mat operator()( const Range* ranges ) const;
    01646
    01648     operator CvMat() const;
    01650     operator CvMatND() const;
    01652     operator IplImage() const;
    01653
    01654     template<typename _Tp> operator vector<_Tp>() const;
    01655     template<typename _Tp, int n> operator Vec<_Tp, n>() const;
    01656     template<typename _Tp, int m, int n> operator Matx<_Tp, m, n>() const;
    01657
    01659     // (i.e. when there are no gaps between successive rows).
    01660     // similar to CV_IS_MAT_CONT(cvmat->type)
    01661     bool isContinuous() const;
    01662
    01664     bool isSubmatrix() const;
    01665
    01667     // similar to CV_ELEM_SIZE(cvmat->type)
    01668     size_t elemSize() const;
    01670     size_t elemSize1() const;
    01672     int type() const;
    01674     int depth() const;
    01676     int channels() const;
    01678     size_t step1(int i=0) const;
    01680     bool empty() const;
    01682     size_t total() const;
    01683
    01685     int checkVector(int elemChannels, int depth=-1, bool requireContinuous=true) const;
    01686
    01688     uchar* ptr(int i0=0);
    01689     const uchar* ptr(int i0=0) const;
    01690
    01692     uchar* ptr(int i0, int i1);
    01693     const uchar* ptr(int i0, int i1) const;
    01694
    01696     uchar* ptr(int i0, int i1, int i2);
    01697     const uchar* ptr(int i0, int i1, int i2) const;
    01698
    01700     uchar* ptr(const int* idx);
    01702     const uchar* ptr(const int* idx) const;
    01703
    01704     template<int n> uchar* ptr(const Vec<int, n>& idx);
    01705     template<int n> const uchar* ptr(const Vec<int, n>& idx) const;
    01706
    01708     template<typename _Tp> _Tp* ptr(int i0=0);
    01709     template<typename _Tp> const _Tp* ptr(int i0=0) const;
    01710
    01711     template<typename _Tp> _Tp* ptr(int i0, int i1);
    01712     template<typename _Tp> const _Tp* ptr(int i0, int i1) const;
    01713
    01714     template<typename _Tp> _Tp* ptr(int i0, int i1, int i2);
    01715     template<typename _Tp> const _Tp* ptr(int i0, int i1, int i2) const;
    01716
    01717     template<typename _Tp> _Tp* ptr(const int* idx);
    01718     template<typename _Tp> const _Tp* ptr(const int* idx) const;
    01719
    01720     template<typename _Tp, int n> _Tp* ptr(const Vec<int, n>& idx);
    01721     template<typename _Tp, int n> const _Tp* ptr(const Vec<int, n>& idx) const;
    01722
    01724     template<typename _Tp> _Tp& at(int i0=0);
    01725     template<typename _Tp> const _Tp& at(int i0=0) const;
    01726
    01727     template<typename _Tp> _Tp& at(int i0, int i1);
    01728     template<typename _Tp> const _Tp& at(int i0, int i1) const;
    01729
    01730     template<typename _Tp> _Tp& at(int i0, int i1, int i2);
    01731     template<typename _Tp> const _Tp& at(int i0, int i1, int i2) const;
    01732
    01733     template<typename _Tp> _Tp& at(const int* idx);
    01734     template<typename _Tp> const _Tp& at(const int* idx) const;
    01735
    01736     template<typename _Tp, int n> _Tp& at(const Vec<int, n>& idx);
    01737     template<typename _Tp, int n> const _Tp& at(const Vec<int, n>& idx) const;
    01738
    01740     template<typename _Tp> _Tp& at(Point pt);
    01741     template<typename _Tp> const _Tp& at(Point pt) const;
    01742
    01744     // the iterators take care of skipping gaps in the end of rows (if any)
    01745     template<typename _Tp> MatIterator_<_Tp> begin();
    01746     template<typename _Tp> MatIterator_<_Tp> end();
    01747     template<typename _Tp> MatConstIterator_<_Tp> begin() const;
    01748     template<typename _Tp> MatConstIterator_<_Tp> end() const;
    01749
    01750     enum { MAGIC_VAL=0x42FF0000, AUTO_STEP=0, CONTINUOUS_FLAG=CV_MAT_CONT_FLAG, SUBMATRIX_FLAG=CV_SUBMAT_FLAG };
    01751
    01758     int flags;
    01760     int dims;
    01762     int rows, cols;
    01764     uchar* data;
    01765
    01767     // when matrix points to user-allocated data, the pointer is NULL
    01768     int* refcount;
    01769
    01771     uchar* datastart;
    01772     uchar* dataend;
    01773     uchar* datalimit;
    01774
    01776     MatAllocator* allocator;
    01777
    01778     struct CV_EXPORTS MSize
    01779     {
    01780         MSize(int* _p);
    01781         Size operator()() const;
    01782         int operator[](int i) const;
    01783         int& operator[](int i);
    01784         operator const int*() const;
    01785         bool operator == (const MSize& sz) const;
    01786         bool operator != (const MSize& sz) const;
    01787
    01788         int* p;
    01789     };
    01790
    01791     struct CV_EXPORTS MStep
    01792     {
    01793         MStep();
    01794         MStep(size_t s);
    01795         size_t operator[](int i) const;
    01796         size_t& operator[](int i);
    01797         operator size_t() const;
    01798         MStep& operator = (size_t s);
    01799
    01800         size_t* p;
    01801         size_t buf[2];
    01802     protected:
    01803         MStep& operator = (const MStep&);
    01804     };
    01805
    01806     MSize size;
    01807     MStep step;
    01808 };
    01809
    01810
    01816 class CV_EXPORTS RNG
    01817 {
    01818 public:
    01819     enum { A=4164903690U, UNIFORM=0, NORMAL=1 };
    01820
    01821     RNG();
    01822     RNG(uint64 _state);
    01824     unsigned next();
    01825
    01826     operator uchar();
    01827     operator schar();
    01828     operator ushort();
    01829     operator short();
    01830     operator unsigned();
    01832         unsigned operator()(unsigned N);
    01833         unsigned operator ()();
    01834     operator int();
    01835     operator float();
    01836     operator double();
    01838     int uniform(int a, int b);
    01840     float uniform(float a, float b);
    01842     double uniform(double a, double b);
    01843     void fill( Mat& mat, int distType, const Scalar& a, const Scalar& b );
    01845         double gaussian(double sigma);
    01846
    01847     uint64 state;
    01848 };
    01849
    01850
    01851
    01852
    01856 class CV_EXPORTS TermCriteria
    01857 {
    01858 public:
    01859     enum
    01860     {
    01861         COUNT=1,
    01862         MAX_ITER=COUNT,
    01863         EPS=2
    01864     };
    01865
    01867     TermCriteria();
    01869     TermCriteria(int _type, int _maxCount, double _epsilon);
    01871     TermCriteria(const CvTermCriteria& criteria);
    01873     operator CvTermCriteria() const;
    01874
    01875     int type;
    01876     int maxCount; // the maximum number of iterations/elements
    01877     double epsilon; // the desired accuracy
    01878 };
    01879
    01881 CV_EXPORTS void swap(Mat& a, Mat& b);
    01882
    01884 CV_EXPORTS Mat cvarrToMat(const CvArr* arr, bool copyData=false,
    01885                           bool allowND=true, int coiMode=0);
    01887 CV_EXPORTS void extractImageCOI(const CvArr* arr, CV_OUT Mat& coiimg, int coi=-1);
    01889 CV_EXPORTS void insertImageCOI(const Mat& coiimg, CvArr* arr, int coi=-1);
    01890
    01892 CV_EXPORTS_W void add(const Mat& src1, const Mat& src2, CV_OUT Mat& dst, const Mat& mask CV_WRAP_DEFAULT(Mat()));
    01894 CV_EXPORTS_W void subtract(const Mat& src1, const Mat& src2, CV_OUT Mat& dst, const Mat& mask CV_WRAP_DEFAULT(Mat()));
    01896 CV_EXPORTS void add(const Mat& src1, const Mat& src2, CV_OUT Mat& dst);
    01898 CV_EXPORTS void subtract(const Mat& src1, const Mat& src2, CV_OUT Mat& dst);
    01900 CV_EXPORTS_W void add(const Mat& src1, const Scalar& src2, CV_OUT Mat& dst, const Mat& mask=Mat());
    01902 CV_EXPORTS_W void subtract(const Mat& src1, const Scalar& src2, CV_OUT Mat& dst, const Mat& mask=Mat());
    01904 CV_EXPORTS_W void subtract(const Scalar& src1, const Mat& src2, CV_OUT Mat& dst, const Mat& mask=Mat());
    01905
    01907 CV_EXPORTS_W void multiply(const Mat& src1, const Mat& src2, CV_OUT Mat& dst, double scale=1);
    01909 CV_EXPORTS_W void divide(const Mat& src1, const Mat& src2, CV_OUT Mat& dst, double scale=1);
    01911 CV_EXPORTS_W void divide(double scale, const Mat& src2, CV_OUT Mat& dst);
    01912
    01914 CV_EXPORTS_W void scaleAdd(const Mat& src1, double alpha, const Mat& src2, CV_OUT Mat& dst);
    01916 CV_EXPORTS_W void addWeighted(const Mat& src1, double alpha, const Mat& src2,
    01917                             double beta, double gamma, CV_OUT Mat& dst);
    01919 CV_EXPORTS_W void convertScaleAbs(const Mat& src, CV_OUT Mat& dst, double alpha=1, double beta=0);
    01921 CV_EXPORTS_W void LUT(const Mat& src, const Mat& lut, CV_OUT Mat& dst);
    01922
    01924 CV_EXPORTS_W Scalar sum(const Mat& src);
    01926 CV_EXPORTS_W int countNonZero( const Mat& src );
    01927
    01929 CV_EXPORTS Scalar mean(const Mat& src);
    01931 CV_EXPORTS_W Scalar mean(const Mat& src, const Mat& mask CV_WRAP_DEFAULT(Mat()));
    01933 CV_EXPORTS_W void meanStdDev(const Mat& src, CV_OUT Scalar& mean, CV_OUT Scalar& stddev, const Mat& mask=Mat());
    01935 CV_EXPORTS double norm(const Mat& src1, int normType=NORM_L2);
    01937 CV_EXPORTS double norm(const Mat& src1, const Mat& src2, int normType=NORM_L2);
    01939 CV_EXPORTS_W double norm(const Mat& src1, int normType, const Mat& mask CV_WRAP_DEFAULT(Mat()));
    01941 CV_EXPORTS_W double norm(const Mat& src1, const Mat& src2,
    01942                        int normType, const Mat& mask CV_WRAP_DEFAULT(Mat()));
    01944 CV_EXPORTS_W void normalize( const Mat& src, CV_OUT Mat& dst, double alpha=1, double beta=0,
    01945                            int norm_type=NORM_L2, int rtype=-1, const Mat& mask=Mat());
    01946
    01948 CV_EXPORTS_W void minMaxLoc(const Mat& src, CV_OUT double* minVal,
    01949                           CV_OUT double* maxVal=0, CV_OUT Point* minLoc=0,
    01950                           CV_OUT Point* maxLoc=0, const Mat& mask=Mat());
    01951 CV_EXPORTS void minMaxIdx(const Mat& src, double* minVal, double* maxVal,
    01952                           int* minIdx=0, int* maxIdx=0, const Mat& mask=Mat());
    01953
    01955 CV_EXPORTS_W void reduce(const Mat& src, CV_OUT Mat& dst, int dim, int rtype, int dtype=-1);
    01957 CV_EXPORTS void merge(const Mat* mv, size_t count, CV_OUT Mat& dst);
    01959 CV_EXPORTS_W void merge(const vector<Mat>& mv, Mat& dst);
    01960
    01962 CV_EXPORTS void split(const Mat& src, Mat* mvbegin);
    01964 CV_EXPORTS_W void split(const Mat& m, vector<Mat>& mv);
    01965
    01967 CV_EXPORTS void mixChannels(const Mat* src, size_t nsrcs, Mat* dst, size_t ndsts,
    01968                             const int* fromTo, size_t npairs);
    01969 CV_EXPORTS void mixChannels(const vector<Mat>& src, vector<Mat>& dst,
    01970                             const int* fromTo, int npairs);
    01971
    01973 CV_EXPORTS_W void flip(const Mat& src, CV_OUT Mat& dst, int flipCode);
    01974
    01976 CV_EXPORTS_W void repeat(const Mat& src, int ny, int nx, CV_OUT Mat& dst);
    01977 CV_EXPORTS Mat repeat(const Mat& src, int ny, int nx);
    01978
    01979 CV_EXPORTS void hconcat(const Mat* src, size_t nsrc, Mat& dst);
    01980 CV_EXPORTS void hconcat(const Mat& src1, const Mat& src2, Mat& dst);
    01981 CV_EXPORTS_W void hconcat(const vector<Mat>& src, CV_OUT Mat& dst);
    01982
    01983 CV_EXPORTS void vconcat(const Mat* src, size_t nsrc, Mat& dst);
    01984 CV_EXPORTS void vconcat(const Mat& src1, const Mat& src2, Mat& dst);
    01985 CV_EXPORTS_W void vconcat(const vector<Mat>& src, CV_OUT Mat& dst);
    01986
    01988 CV_EXPORTS_W void bitwise_and(const Mat& src1, const Mat& src2, CV_OUT Mat& dst, const Mat& mask=Mat());
    01990 CV_EXPORTS_W void bitwise_or(const Mat& src1, const Mat& src2, CV_OUT Mat& dst, const Mat& mask=Mat());
    01992 CV_EXPORTS_W void bitwise_xor(const Mat& src1, const Mat& src2, CV_OUT Mat& dst, const Mat& mask=Mat());
    01994 CV_EXPORTS_W void bitwise_and(const Mat& src1, const Scalar& src2, CV_OUT Mat& dst, const Mat& mask=Mat());
    01996 CV_EXPORTS_W void bitwise_or(const Mat& src1, const Scalar& src2, CV_OUT Mat& dst, const Mat& mask=Mat());
    01998 CV_EXPORTS_W void bitwise_xor(const Mat& src1, const Scalar& src2, CV_OUT Mat& dst, const Mat& mask=Mat());
    02000 CV_EXPORTS_W void bitwise_not(const Mat& src, CV_OUT Mat& dst);
    02002 CV_EXPORTS_W void absdiff(const Mat& src1, const Mat& src2, CV_OUT Mat& dst);
    02004 CV_EXPORTS_W void absdiff(const Mat& src1, const Scalar& src2, CV_OUT Mat& dst);
    02006 CV_EXPORTS_W void inRange(const Mat& src, const Mat& lowerb,
    02007                         const Mat& upperb, CV_OUT Mat& dst);
    02009 CV_EXPORTS_W void inRange(const Mat& src, const Scalar& lowerb,
    02010                         const Scalar& upperb, CV_OUT Mat& dst);
    02012 CV_EXPORTS_W void compare(const Mat& src1, const Mat& src2, CV_OUT Mat& dst, int cmpop);
    02014 CV_EXPORTS_W void compare(const Mat& src1, double s, CV_OUT Mat& dst, int cmpop);
    02016 CV_EXPORTS_W void min(const Mat& src1, const Mat& src2, CV_OUT Mat& dst);
    02018 CV_EXPORTS_W void min(const Mat& src1, double src2, CV_OUT Mat& dst);
    02020 CV_EXPORTS_W void max(const Mat& src1, const Mat& src2, CV_OUT Mat& dst);
    02022 CV_EXPORTS_W void max(const Mat& src1, double src2, CV_OUT Mat& dst);
    02023
    02025 CV_EXPORTS_W void sqrt(const Mat& src, CV_OUT Mat& dst);
    02027 CV_EXPORTS_W void pow(const Mat& src, double power, CV_OUT Mat& dst);
    02029 CV_EXPORTS_W void exp(const Mat& src, CV_OUT Mat& dst);
    02031 CV_EXPORTS_W void log(const Mat& src, CV_OUT Mat& dst);
    02033 CV_EXPORTS_W float cubeRoot(float val);
    02035 CV_EXPORTS_W float fastAtan2(float y, float x);
    02037 CV_EXPORTS_W void polarToCart(const Mat& magnitude, const Mat& angle,
    02038                             CV_OUT Mat& x, CV_OUT Mat& y, bool angleInDegrees=false);
    02040 CV_EXPORTS_W void cartToPolar(const Mat& x, const Mat& y,
    02041                             CV_OUT Mat& magnitude, CV_OUT Mat& angle,
    02042                             bool angleInDegrees=false);
    02044 CV_EXPORTS_W void phase(const Mat& x, const Mat& y, CV_OUT Mat& angle,
    02045                         bool angleInDegrees=false);
    02047 CV_EXPORTS_W void magnitude(const Mat& x, const Mat& y, CV_OUT Mat& magnitude);
    02049 CV_EXPORTS_W bool checkRange(const Mat& a, bool quiet=true, CV_OUT Point* pt=0,
    02050                             double minVal=-DBL_MAX, double maxVal=DBL_MAX);
    02052 CV_EXPORTS_W void gemm(const Mat& src1, const Mat& src2, double alpha,
    02053                        const Mat& src3, double gamma, CV_OUT Mat& dst, int flags=0);
    02055 CV_EXPORTS_W void mulTransposed( const Mat& src, CV_OUT Mat& dst, bool aTa,
    02056                                  const Mat& delta=Mat(),
    02057                                  double scale=1, int rtype=-1 );
    02059 CV_EXPORTS_W void transpose(const Mat& src, CV_OUT Mat& dst);
    02061 CV_EXPORTS_W void transform(const Mat& src, CV_OUT Mat& dst, const Mat& m );
    02063 CV_EXPORTS_W void perspectiveTransform(const Mat& src, CV_OUT Mat& dst, const Mat& m );
    02064
    02066 CV_EXPORTS_W void completeSymm(Mat& mtx, bool lowerToUpper=false);
    02068 CV_EXPORTS_W void setIdentity(Mat& mtx, const Scalar& s=Scalar(1));
    02070 CV_EXPORTS_W double determinant(const Mat& mtx);
    02072 CV_EXPORTS_W Scalar trace(const Mat& mtx);
    02074 CV_EXPORTS_W double invert(const Mat& src, CV_OUT Mat& dst, int flags=DECOMP_LU);
    02076 CV_EXPORTS_W bool solve(const Mat& src1, const Mat& src2, CV_OUT Mat& dst, int flags=DECOMP_LU);
    02078 CV_EXPORTS_W void sort(const Mat& src, CV_OUT Mat& dst, int flags);
    02080 CV_EXPORTS_W void sortIdx(const Mat& src, CV_OUT Mat& dst, int flags);
    02082 CV_EXPORTS_W int solveCubic(const Mat& coeffs, CV_OUT Mat& roots);
    02084 CV_EXPORTS_W double solvePoly(const Mat& coeffs, CV_OUT Mat& roots, int maxIters=300);
    02086 CV_EXPORTS bool eigen(const Mat& src, CV_OUT Mat& eigenvalues, int lowindex=-1,
    02087                       int highindex=-1);
    02089 CV_EXPORTS bool eigen(const Mat& src, CV_OUT Mat& eigenvalues, CV_OUT Mat& eigenvectors,
    02090                       int lowindex=-1, int highindex=-1);
    02092 CV_EXPORTS void calcCovarMatrix( const Mat* samples, int nsamples, Mat& covar, Mat& mean,
    02093                                  int flags, int ctype=CV_64F);
    02095 CV_EXPORTS_W void calcCovarMatrix( const Mat& samples, CV_OUT Mat& covar, CV_OUT Mat& mean,
    02096                                  int flags, int ctype=CV_64F);
    02097
    02152 class CV_EXPORTS PCA
    02153 {
    02154 public:
    02156     PCA();
    02158     PCA(const Mat& data, const Mat& mean, int flags, int maxComponents=0);
    02160     PCA& operator()(const Mat& data, const Mat& mean, int flags, int maxComponents=0);
    02162     Mat project(const Mat& vec) const;
    02164     void project(const Mat& vec, CV_OUT Mat& result) const;
    02166     Mat backProject(const Mat& vec) const;
    02168     void backProject(const Mat& vec, CV_OUT Mat& result) const;
    02169
    02170     Mat eigenvectors;
    02171     Mat eigenvalues;
    02172     Mat mean;
    02173 };
    02174
    02188 class CV_EXPORTS SVD
    02189 {
    02190 public:
    02191     enum { MODIFY_A=1, NO_UV=2, FULL_UV=4 };
    02193     SVD();
    02195     SVD( const Mat& src, int flags=0 );
    02197     SVD& operator ()( const Mat& src, int flags=0 );
    02198
    02200     static void compute( const Mat& src, CV_OUT Mat& w, CV_OUT Mat& u, CV_OUT Mat& vt, int flags=0 );
    02202     static void compute( const Mat& src, CV_OUT Mat& w, int flags=0 );
    02204     static void backSubst( const Mat& w, const Mat& u, const Mat& vt,
    02205                            const Mat& rhs, CV_OUT Mat& dst );
    02206
    02207     template<typename _Tp, int m, int n, int nm> static void compute( const Matx<_Tp, m, n>& a,
    02208         Matx<_Tp, nm, 1>& w, Matx<_Tp, m, nm>& u, Matx<_Tp, n, nm>& vt );
    02209     template<typename _Tp, int m, int n, int nm> static void compute( const Matx<_Tp, m, n>& a,
    02210         Matx<_Tp, nm, 1>& w );
    02211     template<typename _Tp, int m, int n, int nm, int nb> static void backSubst( const Matx<_Tp, nm, 1>& w,
    02212         const Matx<_Tp, m, nm>& u, const Matx<_Tp, n, nm>& vt, const Matx<_Tp, m, nb>& rhs, Matx<_Tp, n, nb>& dst );
    02213
    02215     static void solveZ( const Mat& src, CV_OUT Mat& dst );
    02217     void backSubst( const Mat& rhs, CV_OUT Mat& dst ) const;
    02218
    02219     Mat u, w, vt;
    02220 };
    02221
    02223 CV_EXPORTS_W double Mahalanobis(const Mat& v1, const Mat& v2, const Mat& icovar);
    02225 CV_EXPORTS double Mahalonobis(const Mat& v1, const Mat& v2, const Mat& icovar);
    02226
    02228 CV_EXPORTS_W void dft(const Mat& src, CV_OUT Mat& dst, int flags=0, int nonzeroRows=0);
    02230 CV_EXPORTS_W void idft(const Mat& src, CV_OUT Mat& dst, int flags=0, int nonzeroRows=0);
    02232 CV_EXPORTS_W void dct(const Mat& src, CV_OUT Mat& dst, int flags=0);
    02234 CV_EXPORTS_W void idct(const Mat& src, CV_OUT Mat& dst, int flags=0);
    02236 CV_EXPORTS_W void mulSpectrums(const Mat& a, const Mat& b, CV_OUT Mat& c,
    02237                              int flags, bool conjB=false);
    02239 CV_EXPORTS_W int getOptimalDFTSize(int vecsize);
    02240
    02244 enum
    02245 {
    02246     KMEANS_RANDOM_CENTERS=0, // Chooses random centers for k-Means initialization
    02247     KMEANS_PP_CENTERS=2,     // Uses k-Means++ algorithm for initialization
    02248     KMEANS_USE_INITIAL_LABELS=1 // Uses the user-provided labels for K-Means initialization
    02249 };
    02251 CV_EXPORTS_W double kmeans( const Mat& data, int K, CV_OUT Mat& bestLabels,
    02252                           TermCriteria criteria, int attempts,
    02253                           int flags, CV_OUT Mat* centers=0 );
    02254
    02256 CV_EXPORTS RNG& theRNG();
    02257
    02259 template<typename _Tp> static inline _Tp randu() { return (_Tp)theRNG(); }
    02260
    02262 CV_EXPORTS_W void randu(CV_OUT Mat& dst, const Scalar& low, const Scalar& high);
    02263
    02265 CV_EXPORTS_W void randn(CV_OUT Mat& dst, const Scalar& mean, const Scalar& stddev);
    02266
    02268 CV_EXPORTS void randShuffle(Mat& dst, double iterFactor=1., RNG* rng=0);
    02269
    02271 CV_EXPORTS_W void line(Mat& img, Point pt1, Point pt2, const Scalar& color,
    02272                      int thickness=1, int lineType=8, int shift=0);
    02273
    02275 CV_EXPORTS_W void rectangle(Mat& img, Point pt1, Point pt2,
    02276                           const Scalar& color, int thickness=1,
    02277                           int lineType=8, int shift=0);
    02278
    02280 CV_EXPORTS void rectangle(Mat& img, Rect rec,
    02281                           const Scalar& color, int thickness=1,
    02282                           int lineType=8, int shift=0);
    02283
    02285 CV_EXPORTS_W void circle(Mat& img, Point center, int radius,
    02286                        const Scalar& color, int thickness=1,
    02287                        int lineType=8, int shift=0);
    02288
    02290 CV_EXPORTS_W void ellipse(Mat& img, Point center, Size axes,
    02291                         double angle, double startAngle, double endAngle,
    02292                         const Scalar& color, int thickness=1,
    02293                         int lineType=8, int shift=0);
    02294
    02296 CV_EXPORTS_W void ellipse(Mat& img, const RotatedRect& box, const Scalar& color,
    02297                         int thickness=1, int lineType=8);
    02298
    02300 CV_EXPORTS void fillConvexPoly(Mat& img, const Point* pts, int npts,
    02301                                const Scalar& color, int lineType=8,
    02302                                int shift=0);
    02303
    02305 CV_EXPORTS void fillPoly(Mat& img, const Point** pts,
    02306                          const int* npts, int ncontours,
    02307                          const Scalar& color, int lineType=8, int shift=0,
    02308                          Point offset=Point() );
    02309
    02311 CV_EXPORTS void polylines(Mat& img, const Point** pts, const int* npts,
    02312                           int ncontours, bool isClosed, const Scalar& color,
    02313                           int thickness=1, int lineType=8, int shift=0 );
    02314
    02316 CV_EXPORTS bool clipLine(Size imgSize, CV_IN_OUT Point& pt1, CV_IN_OUT Point& pt2);
    02317
    02319 CV_EXPORTS_W bool clipLine(Rect imgRect, CV_IN_OUT Point& pt1, CV_IN_OUT Point& pt2);
    02320
    02327 class CV_EXPORTS LineIterator
    02328 {
    02329 public:
    02331     LineIterator( const Mat& img, Point pt1, Point pt2,
    02332                   int connectivity=8, bool leftToRight=false );
    02334     uchar* operator *();
    02336     LineIterator& operator ++();
    02338     LineIterator operator ++(int);
    02340     Point pos() const;
    02341
    02342     uchar* ptr;
    02343     const uchar* ptr0;
    02344     int step, elemSize;
    02345     int err, count;
    02346     int minusDelta, plusDelta;
    02347     int minusStep, plusStep;
    02348 };
    02349
    02351 CV_EXPORTS_W void ellipse2Poly( Point center, Size axes, int angle,
    02352                               int arcStart, int arcEnd, int delta,
    02353                               CV_OUT vector<Point>& pts );
    02354
    02355 enum
    02356 {
    02357     FONT_HERSHEY_SIMPLEX = 0,
    02358     FONT_HERSHEY_PLAIN = 1,
    02359     FONT_HERSHEY_DUPLEX = 2,
    02360     FONT_HERSHEY_COMPLEX = 3,
    02361     FONT_HERSHEY_TRIPLEX = 4,
    02362     FONT_HERSHEY_COMPLEX_SMALL = 5,
    02363     FONT_HERSHEY_SCRIPT_SIMPLEX = 6,
    02364     FONT_HERSHEY_SCRIPT_COMPLEX = 7,
    02365     FONT_ITALIC = 16
    02366 };
    02367
    02369 CV_EXPORTS_W void putText( Mat& img, const string& text, Point org,
    02370                          int fontFace, double fontScale, Scalar color,
    02371                          int thickness=1, int linetype=8,
    02372                          bool bottomLeftOrigin=false );
    02373
    02375 CV_EXPORTS_W Size getTextSize(const string& text, int fontFace,
    02376                             double fontScale, int thickness,
    02377                             CV_OUT int* baseLine);
    02378
    02380
    02426 template<typename _Tp> class CV_EXPORTS Mat_ : public Mat
    02427 {
    02428 public:
    02429     typedef _Tp value_type;
    02430     typedef typename DataType<_Tp>::channel_type channel_type;
    02431     typedef MatIterator_<_Tp> iterator;
    02432     typedef MatConstIterator_<_Tp> const_iterator;
    02433
    02435     Mat_();
    02437     Mat_(int _rows, int _cols);
    02439     Mat_(int _rows, int _cols, const _Tp& value);
    02441     explicit Mat_(Size _size);
    02443     Mat_(Size _size, const _Tp& value);
    02445     Mat_(int _ndims, const int* _sizes);
    02447     Mat_(int _ndims, const int* _sizes, const _Tp& value);
    02449     Mat_(const Mat& m);
    02451     Mat_(const Mat_& m);
    02453     Mat_(int _rows, int _cols, _Tp* _data, size_t _step=AUTO_STEP);
    02455     Mat_(int _ndims, const int* _sizes, _Tp* _data, const size_t* _steps=0);
    02457     Mat_(const Mat_& m, const Range& rowRange, const Range& colRange=Range::all());
    02459     Mat_(const Mat_& m, const Rect& roi);
    02461     Mat_(const Mat_& m, const Range* ranges);
    02463     explicit Mat_(const vector<_Tp>& vec, bool copyData=false);
    02464     template<int n> explicit Mat_(const Vec<typename DataType<_Tp>::channel_type, n>& vec, bool copyData=true);
    02465     template<int m, int n> explicit Mat_(const Matx<typename DataType<_Tp>::channel_type, m, n>& mtx, bool copyData=true);
    02466     explicit Mat_(const Point_<typename DataType<_Tp>::channel_type>& pt, bool copyData=true);
    02467     explicit Mat_(const Point3_<typename DataType<_Tp>::channel_type>& pt, bool copyData=true);
    02468     explicit Mat_(const MatCommaInitializer_<_Tp>& commaInitializer);
    02469
    02470     Mat_& operator = (const Mat& m);
    02471     Mat_& operator = (const Mat_& m);
    02473     Mat_& operator = (const _Tp& s);
    02474
    02476     iterator begin();
    02477     iterator end();
    02478     const_iterator begin() const;
    02479     const_iterator end() const;
    02480
    02482     void create(int _rows, int _cols);
    02484     void create(Size _size);
    02486     void create(int _ndims, const int* _sizes);
    02488     Mat_ cross(const Mat_& m) const;
    02490     Mat_& operator = (const MatExpr& expr);
    02492     template<typename T2> operator Mat_<T2>() const;
    02494     Mat_ row(int y) const;
    02495     Mat_ col(int x) const;
    02496     Mat_ diag(int d=0) const;
    02497     Mat_ clone() const;
    02498
    02500     size_t elemSize() const;
    02501     size_t elemSize1() const;
    02502     int type() const;
    02503     int depth() const;
    02504     int channels() const;
    02505     size_t step1(int i=0) const;
    02507     size_t stepT(int i=0) const;
    02508
    02510     static MatExpr zeros(int rows, int cols);
    02511     static MatExpr zeros(Size size);
    02512     static MatExpr zeros(int _ndims, const int* _sizes);
    02513     static MatExpr ones(int rows, int cols);
    02514     static MatExpr ones(Size size);
    02515     static MatExpr ones(int _ndims, const int* _sizes);
    02516     static MatExpr eye(int rows, int cols);
    02517     static MatExpr eye(Size size);
    02518
    02520     Mat_ reshape(int _rows) const;
    02521     Mat_& adjustROI( int dtop, int dbottom, int dleft, int dright );
    02522     Mat_ operator()( const Range& rowRange, const Range& colRange ) const;
    02523     Mat_ operator()( const Rect& roi ) const;
    02524     Mat_ operator()( const Range* ranges ) const;
    02525
    02527     _Tp* operator [](int y);
    02528     const _Tp* operator [](int y) const;
    02529
    02531     _Tp& operator ()(const int* idx);
    02533     const _Tp& operator ()(const int* idx) const;
    02534
    02536     template<int n> _Tp& operator ()(const Vec<int, n>& idx);
    02538     template<int n> const _Tp& operator ()(const Vec<int, n>& idx) const;
    02539
    02541     _Tp& operator ()(int idx0);
    02543     const _Tp& operator ()(int idx0) const;
    02545     _Tp& operator ()(int idx0, int idx1);
    02547     const _Tp& operator ()(int idx0, int idx1) const;
    02549     _Tp& operator ()(int idx0, int idx1, int idx2);
    02551     const _Tp& operator ()(int idx0, int idx1, int idx2) const;
    02552
    02553     _Tp& operator ()(Point pt);
    02554     const _Tp& operator ()(Point pt) const;
    02555
    02557     operator vector<_Tp>() const;
    02559     template<int n> operator Vec<typename DataType<_Tp>::channel_type, n>() const;
    02561     template<int m, int n> operator Matx<typename DataType<_Tp>::channel_type, m, n>() const;
    02562 };
    02563
    02564 typedef Mat_<uchar> Mat1b;
    02565 typedef Mat_<Vec2b> Mat2b;
    02566 typedef Mat_<Vec3b> Mat3b;
    02567 typedef Mat_<Vec4b> Mat4b;
    02568
    02569 typedef Mat_<short> Mat1s;
    02570 typedef Mat_<Vec2s> Mat2s;
    02571 typedef Mat_<Vec3s> Mat3s;
    02572 typedef Mat_<Vec4s> Mat4s;
    02573
    02574 typedef Mat_<ushort> Mat1w;
    02575 typedef Mat_<Vec2w> Mat2w;
    02576 typedef Mat_<Vec3w> Mat3w;
    02577 typedef Mat_<Vec4w> Mat4w;
    02578
    02579 typedef Mat_<int>   Mat1i;
    02580 typedef Mat_<Vec2i> Mat2i;
    02581 typedef Mat_<Vec3i> Mat3i;
    02582 typedef Mat_<Vec4i> Mat4i;
    02583
    02584 typedef Mat_<float> Mat1f;
    02585 typedef Mat_<Vec2f> Mat2f;
    02586 typedef Mat_<Vec3f> Mat3f;
    02587 typedef Mat_<Vec4f> Mat4f;
    02588
    02589 typedef Mat_<double> Mat1d;
    02590 typedef Mat_<Vec2d> Mat2d;
    02591 typedef Mat_<Vec3d> Mat3d;
    02592 typedef Mat_<Vec4d> Mat4d;
    02593
    02595
    02596 class CV_EXPORTS MatConstIterator
    02597 {
    02598 public:
    02599     typedef uchar* value_type;
    02600     typedef ptrdiff_t difference_type;
    02601     typedef const uchar** pointer;
    02602     typedef uchar* reference;
    02603     typedef std::random_access_iterator_tag iterator_category;
    02604
    02606     MatConstIterator();
    02608     MatConstIterator(const Mat* _m);
    02610     MatConstIterator(const Mat* _m, int _row, int _col=0);
    02612     MatConstIterator(const Mat* _m, Point _pt);
    02614     MatConstIterator(const Mat* _m, const int* _idx);
    02616     MatConstIterator(const MatConstIterator& it);
    02617
    02619     MatConstIterator& operator = (const MatConstIterator& it);
    02621     uchar* operator *() const;
    02623     uchar* operator [](ptrdiff_t i) const;
    02624
    02626     MatConstIterator& operator += (ptrdiff_t ofs);
    02628     MatConstIterator& operator -= (ptrdiff_t ofs);
    02630     MatConstIterator& operator --();
    02632     MatConstIterator operator --(int);
    02634     MatConstIterator& operator ++();
    02636     MatConstIterator operator ++(int);
    02638     Point pos() const;
    02640     void pos(int* _idx) const;
    02641     ptrdiff_t lpos() const;
    02642     void seek(ptrdiff_t ofs, bool relative=false);
    02643     void seek(const int* _idx, bool relative=false);
    02644
    02645     const Mat* m;
    02646     size_t elemSize;
    02647     uchar* ptr;
    02648     uchar* sliceStart;
    02649     uchar* sliceEnd;
    02650 };
    02651
    02656 template<typename _Tp>
    02657 class CV_EXPORTS MatConstIterator_ : public MatConstIterator
    02658 {
    02659 public:
    02660     typedef _Tp value_type;
    02661     typedef ptrdiff_t difference_type;
    02662     typedef const _Tp* pointer;
    02663     typedef const _Tp& reference;
    02664     typedef std::random_access_iterator_tag iterator_category;
    02665
    02667     MatConstIterator_();
    02669     MatConstIterator_(const Mat_<_Tp>* _m);
    02671     MatConstIterator_(const Mat_<_Tp>* _m, int _row, int _col=0);
    02673     MatConstIterator_(const Mat_<_Tp>* _m, Point _pt);
    02675     MatConstIterator_(const Mat_<_Tp>* _m, const int* _idx);
    02677     MatConstIterator_(const MatConstIterator_& it);
    02678
    02680     MatConstIterator_& operator = (const MatConstIterator_& it);
    02682     _Tp operator *() const;
    02684     _Tp operator [](ptrdiff_t i) const;
    02685
    02687     MatConstIterator_& operator += (ptrdiff_t ofs);
    02689     MatConstIterator_& operator -= (ptrdiff_t ofs);
    02691     MatConstIterator_& operator --();
    02693     MatConstIterator_ operator --(int);
    02695     MatConstIterator_& operator ++();
    02697     MatConstIterator_ operator ++(int);
    02699     Point pos() const;
    02700 };
    02701
    02702
    02707 template<typename _Tp>
    02708 class CV_EXPORTS MatIterator_ : public MatConstIterator_<_Tp>
    02709 {
    02710 public:
    02711     typedef _Tp* pointer;
    02712     typedef _Tp& reference;
    02713     typedef std::random_access_iterator_tag iterator_category;
    02714
    02716     MatIterator_();
    02718     MatIterator_(Mat_<_Tp>* _m);
    02720     MatIterator_(Mat_<_Tp>* _m, int _row, int _col=0);
    02722     MatIterator_(const Mat_<_Tp>* _m, Point _pt);
    02724     MatIterator_(const Mat_<_Tp>* _m, const int* _idx);
    02726     MatIterator_(const MatIterator_& it);
    02728     MatIterator_& operator = (const MatIterator_<_Tp>& it );
    02729
    02731     _Tp& operator *() const;
    02733     _Tp& operator [](ptrdiff_t i) const;
    02734
    02736     MatIterator_& operator += (ptrdiff_t ofs);
    02738     MatIterator_& operator -= (ptrdiff_t ofs);
    02740     MatIterator_& operator --();
    02742     MatIterator_ operator --(int);
    02744     MatIterator_& operator ++();
    02746     MatIterator_ operator ++(int);
    02747 };
    02748
    02749 template<typename _Tp> class CV_EXPORTS MatOp_Iter_;
    02750
    02764 template<typename _Tp> class CV_EXPORTS MatCommaInitializer_
    02765 {
    02766 public:
    02768     MatCommaInitializer_(Mat_<_Tp>* _m);
    02770     template<typename T2> MatCommaInitializer_<_Tp>& operator , (T2 v);
    02772     Mat_<_Tp> operator *() const;
    02773     operator Mat_<_Tp>() const;
    02774 protected:
    02775     MatIterator_<_Tp> it;
    02776 };
    02777
    02778
    02779 template<typename _Tp, int m, int n> class CV_EXPORTS MatxCommaInitializer
    02780 {
    02781 public:
    02782     MatxCommaInitializer(Matx<_Tp, m, n>* _mtx);
    02783     template<typename T2> MatxCommaInitializer<_Tp, m, n>& operator , (T2 val);
    02784     Matx<_Tp, m, n> operator *() const;
    02785
    02786     Matx<_Tp, m, n>* dst;
    02787     int idx;
    02788 };
    02789
    02790 template<typename _Tp, int m> class CV_EXPORTS VecCommaInitializer : public MatxCommaInitializer<_Tp, m, 1>
    02791 {
    02792 public:
    02793     VecCommaInitializer(Vec<_Tp, m>* _vec);
    02794     template<typename T2> VecCommaInitializer<_Tp, m>& operator , (T2 val);
    02795     Vec<_Tp, m> operator *() const;
    02796 };
    02797
    02825 template<typename _Tp, size_t fixed_size=4096/sizeof(_Tp)+8> class CV_EXPORTS AutoBuffer
    02826 {
    02827 public:
    02828     typedef _Tp value_type;
    02829
    02831     AutoBuffer();
    02833     AutoBuffer(size_t _size);
    02835     ~AutoBuffer();
    02836
    02838     void allocate(size_t _size);
    02840     void deallocate();
    02842     operator _Tp* ();
    02844     operator const _Tp* () const;
    02845
    02846 protected:
    02848     _Tp* ptr;
    02850     size_t size;
    02852     _Tp buf[fixed_size];
    02853 };
    02854
    02856
    02907 class CV_EXPORTS NAryMatIterator
    02908 {
    02909 public:
    02911     NAryMatIterator();
    02913     NAryMatIterator(const Mat** arrays, Mat* planes, int narrays=-1);
    02915     void init(const Mat** arrays, Mat* planes, int narrays=-1);
    02916
    02918     NAryMatIterator& operator ++();
    02920     NAryMatIterator operator ++(int);
    02921
    02923     const Mat** arrays;
    02925     Mat* planes;
    02927     int narrays;
    02929     int nplanes;
    02930 protected:
    02931     int iterdepth, idx;
    02932 };
    02933
    02934 //typedef NAryMatIterator NAryMatNDIterator;
    02935
    02936 typedef void (*ConvertData)(const void* from, void* to, int cn);
    02937 typedef void (*ConvertScaleData)(const void* from, void* to, int cn, double alpha, double beta);
    02938
    02940 CV_EXPORTS ConvertData getConvertElem(int fromType, int toType);
    02942 CV_EXPORTS ConvertScaleData getConvertScaleElem(int fromType, int toType);
    02943
    02944
    02946
    02947 class SparseMatIterator;
    02948 class SparseMatConstIterator;
    02949 template<typename _Tp> class SparseMatIterator_;
    02950 template<typename _Tp> class SparseMatConstIterator_;
    02951
    03037 class CV_EXPORTS SparseMat
    03038 {
    03039 public:
    03040     typedef SparseMatIterator iterator;
    03041     typedef SparseMatConstIterator const_iterator;
    03042
    03044     struct CV_EXPORTS Hdr
    03045     {
    03046         Hdr(int _dims, const int* _sizes, int _type);
    03047         void clear();
    03048         int refcount;
    03049         int dims;
    03050         int valueOffset;
    03051         size_t nodeSize;
    03052         size_t nodeCount;
    03053         size_t freeList;
    03054         vector<uchar> pool;
    03055         vector<size_t> hashtab;
    03056         int size[CV_MAX_DIM];
    03057     };
    03058
    03060     struct CV_EXPORTS Node
    03061     {
    03063         size_t hashval;
    03065         size_t next;
    03067         int idx[CV_MAX_DIM];
    03068     };
    03069
    03071     SparseMat();
    03073     SparseMat(int dims, const int* _sizes, int _type);
    03075     SparseMat(const SparseMat& m);
    03077
    03082     SparseMat(const Mat& m);
    03084     SparseMat(const CvSparseMat* m);
    03086     ~SparseMat();
    03087
    03089     SparseMat& operator = (const SparseMat& m);
    03091     SparseMat& operator = (const Mat& m);
    03092
    03094     SparseMat clone() const;
    03095
    03097     void copyTo( SparseMat& m ) const;
    03099     void copyTo( Mat& m ) const;
    03101     void convertTo( SparseMat& m, int rtype, double alpha=1 ) const;
    03103
    03108     void convertTo( Mat& m, int rtype, double alpha=1, double beta=0 ) const;
    03109
    03110     // not used now
    03111     void assignTo( SparseMat& m, int type=-1 ) const;
    03112
    03114
    03119     void create(int dims, const int* _sizes, int _type);
    03121     void clear();
    03123     void addref();
    03124     // decrements the header reference counter. When the counter reaches 0, the header and all the underlying data are deallocated.
    03125     void release();
    03126
    03128     operator CvSparseMat*() const;
    03130     size_t elemSize() const;
    03132     size_t elemSize1() const;
    03133
    03135     int type() const;
    03137     int depth() const;
    03139     int channels() const;
    03140
    03142     const int* size() const;
    03144     int size(int i) const;
    03146     int dims() const;
    03148     size_t nzcount() const;
    03149
    03151     size_t hash(int i0) const;
    03153     size_t hash(int i0, int i1) const;
    03155     size_t hash(int i0, int i1, int i2) const;
    03157     size_t hash(const int* idx) const;
    03158
    03160
    03173
    03174     uchar* ptr(int i0, bool createMissing, size_t* hashval=0);
    03176     uchar* ptr(int i0, int i1, bool createMissing, size_t* hashval=0);
    03178     uchar* ptr(int i0, int i1, int i2, bool createMissing, size_t* hashval=0);
    03180     uchar* ptr(const int* idx, bool createMissing, size_t* hashval=0);
    03182
    03184
    03191
    03192     template<typename _Tp> _Tp& ref(int i0, size_t* hashval=0);
    03194     template<typename _Tp> _Tp& ref(int i0, int i1, size_t* hashval=0);
    03196     template<typename _Tp> _Tp& ref(int i0, int i1, int i2, size_t* hashval=0);
    03198     template<typename _Tp> _Tp& ref(const int* idx, size_t* hashval=0);
    03200
    03202
    03213
    03214     template<typename _Tp> _Tp value(int i0, size_t* hashval=0) const;
    03216     template<typename _Tp> _Tp value(int i0, int i1, size_t* hashval=0) const;
    03218     template<typename _Tp> _Tp value(int i0, int i1, int i2, size_t* hashval=0) const;
    03220     template<typename _Tp> _Tp value(const int* idx, size_t* hashval=0) const;
    03222
    03224
    03231
    03232     template<typename _Tp> const _Tp* find(int i0, size_t* hashval=0) const;
    03234     template<typename _Tp> const _Tp* find(int i0, int i1, size_t* hashval=0) const;
    03236     template<typename _Tp> const _Tp* find(int i0, int i1, int i2, size_t* hashval=0) const;
    03238     template<typename _Tp> const _Tp* find(const int* idx, size_t* hashval=0) const;
    03239
    03241     void erase(int i0, int i1, size_t* hashval=0);
    03243     void erase(int i0, int i1, int i2, size_t* hashval=0);
    03245     void erase(const int* idx, size_t* hashval=0);
    03246
    03248
    03251
    03252     SparseMatIterator begin();
    03254     template<typename _Tp> SparseMatIterator_<_Tp> begin();
    03256     SparseMatConstIterator begin() const;
    03258     template<typename _Tp> SparseMatConstIterator_<_Tp> begin() const;
    03260
    03263
    03264     SparseMatIterator end();
    03266     SparseMatConstIterator end() const;
    03268     template<typename _Tp> SparseMatIterator_<_Tp> end();
    03270     template<typename _Tp> SparseMatConstIterator_<_Tp> end() const;
    03271
    03273     template<typename _Tp> _Tp& value(Node* n);
    03275     template<typename _Tp> const _Tp& value(const Node* n) const;
    03276
    03278     Node* node(size_t nidx);
    03279     const Node* node(size_t nidx) const;
    03280
    03281     uchar* newNode(const int* idx, size_t hashval);
    03282     void removeNode(size_t hidx, size_t nidx, size_t previdx);
    03283     void resizeHashTab(size_t newsize);
    03284
    03285     enum { MAGIC_VAL=0x42FD0000, MAX_DIM=CV_MAX_DIM, HASH_SCALE=0x5bd1e995, HASH_BIT=0x80000000 };
    03286
    03287     int flags;
    03288     Hdr* hdr;
    03289 };
    03290
    03292 CV_EXPORTS void minMaxLoc(const SparseMat& a, double* minVal,
    03293                           double* maxVal, int* minIdx=0, int* maxIdx=0);
    03295 CV_EXPORTS double norm( const SparseMat& src, int normType );
    03297 CV_EXPORTS void normalize( const SparseMat& src, SparseMat& dst, double alpha, int normType );
    03298
    03311 class CV_EXPORTS SparseMatConstIterator
    03312 {
    03313 public:
    03315     SparseMatConstIterator();
    03317     SparseMatConstIterator(const SparseMat* _m);
    03319     SparseMatConstIterator(const SparseMatConstIterator& it);
    03320
    03322     SparseMatConstIterator& operator = (const SparseMatConstIterator& it);
    03323
    03325     template<typename _Tp> const _Tp& value() const;
    03327     const SparseMat::Node* node() const;
    03328
    03330     SparseMatConstIterator& operator --();
    03332     SparseMatConstIterator operator --(int);
    03334     SparseMatConstIterator& operator ++();
    03336     SparseMatConstIterator operator ++(int);
    03337
    03339     void seekEnd();
    03340
    03341     const SparseMat* m;
    03342     size_t hashidx;
    03343     uchar* ptr;
    03344 };
    03345
    03352 class CV_EXPORTS SparseMatIterator : public SparseMatConstIterator
    03353 {
    03354 public:
    03356     SparseMatIterator();
    03358     SparseMatIterator(SparseMat* _m);
    03360     SparseMatIterator(SparseMat* _m, const int* idx);
    03362     SparseMatIterator(const SparseMatIterator& it);
    03363
    03365     SparseMatIterator& operator = (const SparseMatIterator& it);
    03367     template<typename _Tp> _Tp& value() const;
    03369     SparseMat::Node* node() const;
    03370
    03372     SparseMatIterator& operator ++();
    03374     SparseMatIterator operator ++(int);
    03375 };
    03376
    03390 template<typename _Tp> class CV_EXPORTS SparseMat_ : public SparseMat
    03391 {
    03392 public:
    03393     typedef SparseMatIterator_<_Tp> iterator;
    03394     typedef SparseMatConstIterator_<_Tp> const_iterator;
    03395
    03397     SparseMat_();
    03399     SparseMat_(int dims, const int* _sizes);
    03401     SparseMat_(const SparseMat& m);
    03403     SparseMat_(const SparseMat_& m);
    03405     SparseMat_(const Mat& m);
    03407     SparseMat_(const CvSparseMat* m);
    03409     SparseMat_& operator = (const SparseMat& m);
    03411     SparseMat_& operator = (const SparseMat_& m);
    03413     SparseMat_& operator = (const Mat& m);
    03414
    03416     SparseMat_ clone() const;
    03418     void create(int dims, const int* _sizes);
    03420     operator CvSparseMat*() const;
    03421
    03423     int type() const;
    03425     int depth() const;
    03427     int channels() const;
    03428
    03430     _Tp& ref(int i0, size_t* hashval=0);
    03432     _Tp& ref(int i0, int i1, size_t* hashval=0);
    03434     _Tp& ref(int i0, int i1, int i2, size_t* hashval=0);
    03436     _Tp& ref(const int* idx, size_t* hashval=0);
    03437
    03439     _Tp operator()(int i0, size_t* hashval=0) const;
    03441     _Tp operator()(int i0, int i1, size_t* hashval=0) const;
    03443     _Tp operator()(int i0, int i1, int i2, size_t* hashval=0) const;
    03445     _Tp operator()(const int* idx, size_t* hashval=0) const;
    03446
    03448     SparseMatIterator_<_Tp> begin();
    03450     SparseMatConstIterator_<_Tp> begin() const;
    03452     SparseMatIterator_<_Tp> end();
    03454     SparseMatConstIterator_<_Tp> end() const;
    03455 };
    03456
    03457
    03464 template<typename _Tp> class CV_EXPORTS SparseMatConstIterator_ : public SparseMatConstIterator
    03465 {
    03466 public:
    03467     typedef std::forward_iterator_tag iterator_category;
    03468
    03470     SparseMatConstIterator_();
    03472     SparseMatConstIterator_(const SparseMat_<_Tp>* _m);
    03474     SparseMatConstIterator_(const SparseMatConstIterator_& it);
    03475
    03477     SparseMatConstIterator_& operator = (const SparseMatConstIterator_& it);
    03479     const _Tp& operator *() const;
    03480
    03482     SparseMatConstIterator_& operator ++();
    03484     SparseMatConstIterator_ operator ++(int);
    03485 };
    03486
    03493 template<typename _Tp> class CV_EXPORTS SparseMatIterator_ : public SparseMatConstIterator_<_Tp>
    03494 {
    03495 public:
    03496     typedef std::forward_iterator_tag iterator_category;
    03497
    03499     SparseMatIterator_();
    03501     SparseMatIterator_(SparseMat_<_Tp>* _m);
    03503     SparseMatIterator_(const SparseMatIterator_& it);
    03504
    03506     SparseMatIterator_& operator = (const SparseMatIterator_& it);
    03508     _Tp& operator *() const;
    03509
    03511     SparseMatIterator_& operator ++();
    03513     SparseMatIterator_ operator ++(int);
    03514 };
    03515
    03517
    03542 class CV_EXPORTS_W KDTree
    03543 {
    03544 public:
    03548     struct Node
    03549     {
    03550         Node() : idx(-1), left(-1), right(-1), boundary(0.f) {}
    03551         Node(int _idx, int _left, int _right, float _boundary)
    03552             : idx(_idx), left(_left), right(_right), boundary(_boundary) {}
    03554         int idx;
    03556         int left, right;
    03558         float boundary;
    03559     };
    03560
    03562     CV_WRAP KDTree();
    03564     CV_WRAP KDTree(const Mat& _points, bool copyAndReorderPoints=false);
    03566     CV_WRAP KDTree(const Mat& _points, const Mat& _labels, bool copyAndReorderPoints=false);
    03568     CV_WRAP void build(const Mat& _points, bool copyAndReorderPoints=false);
    03570     CV_WRAP void build(const Mat& _points, const Mat& _labels, bool copyAndReorderPoints=false);
    03572     int findNearest(const float* vec,
    03573                     int K, int Emax, int* neighborsIdx,
    03574                     Mat* neighbors=0, float* dist=0, int* labels=0) const;
    03576     int findNearest(const float* vec, int K, int Emax,
    03577                     vector<int>* neighborsIdx,
    03578                     Mat* neighbors=0,
    03579                     vector<float>* dist=0,
    03580                     vector<int>* labels=0) const;
    03581     CV_WRAP int findNearest(const vector<float>& vec, int K, int Emax,
    03582                     CV_OUT vector<int>* neighborsIdx,
    03583                     CV_OUT Mat* neighbors=0,
    03584                     CV_OUT vector<float>* dist=0,
    03585                     CV_OUT vector<int>* labels=0) const;
    03587     void findOrthoRange(const float* minBounds, const float* maxBounds,
    03588                         vector<int>* neighborsIdx, Mat* neighbors=0,
    03589                         vector<int>* labels=0) const;
    03590     CV_WRAP void findOrthoRange(const vector<float>& minBounds, const vector<float>& maxBounds,
    03591                                 CV_OUT vector<int>* neighborsIdx, CV_OUT Mat* neighbors=0,
    03592                                 CV_OUT vector<int>* labels=0) const;
    03594     void getPoints(const int* idx, size_t nidx, Mat& pts, vector<int>* labels=0) const;
    03596     CV_WRAP void getPoints(const vector<int>& idxs, Mat& pts, CV_OUT vector<int>* labels=0) const;
    03598     const float* getPoint(int ptidx, int* label=0) const;
    03600     CV_WRAP int dims() const;
    03601
    03602     vector<Node> nodes;
    03603     CV_PROP Mat points;
    03604     CV_PROP vector<int> labels;
    03605     CV_PROP int maxDepth;
    03606     CV_PROP_RW int normType;
    03607 };
    03608
    03610
    03611 class CV_EXPORTS FileNode;
    03612
    03710 class CV_EXPORTS_W FileStorage
    03711 {
    03712 public:
    03714     enum
    03715     {
    03716         READ=0,
    03717         WRITE=1,
    03718         APPEND=2
    03719     };
    03720     enum
    03721     {
    03722         UNDEFINED=0,
    03723         VALUE_EXPECTED=1,
    03724         NAME_EXPECTED=2,
    03725         INSIDE_MAP=4
    03726     };
    03728     CV_WRAP FileStorage();
    03730     CV_WRAP FileStorage(const string& filename, int flags);
    03732     FileStorage(CvFileStorage* fs);
    03734     virtual ~FileStorage();
    03735
    03737     CV_WRAP virtual bool open(const string& filename, int flags);
    03739     CV_WRAP virtual bool isOpened() const;
    03741     CV_WRAP virtual void release();
    03742
    03744     CV_WRAP FileNode getFirstTopLevelNode() const;
    03746     CV_WRAP FileNode root(int streamidx=0) const;
    03748     FileNode operator[](const string& nodename) const;
    03750     CV_WRAP FileNode operator[](const char* nodename) const;
    03751
    03753     CvFileStorage* operator *() { return fs; }
    03755     const CvFileStorage* operator *() const { return fs; }
    03757     void writeRaw( const string& fmt, const uchar* vec, size_t len );
    03759     void writeObj( const string& name, const void* obj );
    03760
    03762     static string getDefaultObjectName(const string& filename);
    03763
    03764     Ptr<CvFileStorage> fs;
    03765     string elname;
    03766     vector<char> structs;
    03767     int state;
    03768 };
    03769
    03770 class CV_EXPORTS FileNodeIterator;
    03771
    03782 class CV_EXPORTS_W_SIMPLE FileNode
    03783 {
    03784 public:
    03786     enum
    03787     {
    03788         NONE=0,
    03789         INT=1,
    03790         REAL=2,
    03791         FLOAT=REAL,
    03792         STR=3,
    03793         STRING=STR,
    03794         REF=4,
    03795         SEQ=5,
    03796         MAP=6,
    03797         TYPE_MASK=7,
    03798         FLOW=8,
    03799         USER=16,
    03800         EMPTY=32,
    03801         NAMED=64
    03802     };
    03804     CV_WRAP FileNode();
    03806     FileNode(const CvFileStorage* fs, const CvFileNode* node);
    03808     FileNode(const FileNode& node);
    03810     FileNode operator[](const string& nodename) const;
    03812     CV_WRAP FileNode operator[](const char* nodename) const;
    03814     CV_WRAP FileNode operator[](int i) const;
    03816     CV_WRAP int type() const;
    03817
    03819     CV_WRAP bool empty() const;
    03821     CV_WRAP bool isNone() const;
    03823     CV_WRAP bool isSeq() const;
    03825     CV_WRAP bool isMap() const;
    03827     CV_WRAP bool isInt() const;
    03829     CV_WRAP bool isReal() const;
    03831     CV_WRAP bool isString() const;
    03833     CV_WRAP bool isNamed() const;
    03835     CV_WRAP string name() const;
    03837     CV_WRAP size_t size() const;
    03839     operator int() const;
    03841     operator float() const;
    03843     operator double() const;
    03845     operator string() const;
    03846
    03848     CvFileNode* operator *();
    03850     const CvFileNode* operator* () const;
    03851
    03853     FileNodeIterator begin() const;
    03855     FileNodeIterator end() const;
    03856
    03858     void readRaw( const string& fmt, uchar* vec, size_t len ) const;
    03860     void* readObj() const;
    03861
    03862     // do not use wrapper pointer classes for better efficiency
    03863     const CvFileStorage* fs;
    03864     const CvFileNode* node;
    03865 };
    03866
    03867
    03873 class CV_EXPORTS FileNodeIterator
    03874 {
    03875 public:
    03877     FileNodeIterator();
    03879     FileNodeIterator(const CvFileStorage* fs, const CvFileNode* node, size_t ofs=0);
    03881     FileNodeIterator(const FileNodeIterator& it);
    03883     FileNode operator *() const;
    03885     FileNode operator ->() const;
    03886
    03888     FileNodeIterator& operator ++ ();
    03890     FileNodeIterator operator ++ (int);
    03892     FileNodeIterator& operator -- ();
    03894     FileNodeIterator operator -- (int);
    03896     FileNodeIterator& operator += (int);
    03898     FileNodeIterator& operator -= (int);
    03899
    03901     FileNodeIterator& readRaw( const string& fmt, uchar* vec,
    03902                                size_t maxCount=(size_t)INT_MAX );
    03903
    03904     const CvFileStorage* fs;
    03905     const CvFileNode* container;
    03906     CvSeqReader reader;
    03907     size_t remaining;
    03908 };
    03909
    03911
    03912 template<typename _Tp> class SeqIterator;
    03913
    03914 typedef Ptr<CvMemStorage> MemStorage;
    03915
    03926 template<typename _Tp> class CV_EXPORTS Seq
    03927 {
    03928 public:
    03929     typedef SeqIterator<_Tp> iterator;
    03930     typedef SeqIterator<_Tp> const_iterator;
    03931
    03933     Seq();
    03935     Seq(const CvSeq* seq);
    03937     Seq(MemStorage& storage, int headerSize = sizeof(CvSeq));
    03939     _Tp& operator [](int idx);
    03941     const _Tp& operator[](int idx) const;
    03943     SeqIterator<_Tp> begin() const;
    03945     SeqIterator<_Tp> end() const;
    03947     size_t size() const;
    03949     int type() const;
    03951     int depth() const;
    03953     int channels() const;
    03955     size_t elemSize() const;
    03957     size_t index(const _Tp& elem) const;
    03959     void push_back(const _Tp& elem);
    03961     void push_front(const _Tp& elem);
    03963     void push_back(const _Tp* elems, size_t count);
    03965     void push_front(const _Tp* elems, size_t count);
    03967     void insert(int idx, const _Tp& elem);
    03969     void insert(int idx, const _Tp* elems, size_t count);
    03971     void remove(int idx);
    03973     void remove(const Range& r);
    03974
    03976     _Tp& front();
    03978     const _Tp& front() const;
    03980     _Tp& back();
    03982     const _Tp& back() const;
    03984     bool empty() const;
    03985
    03987     void clear();
    03989     void pop_front();
    03991     void pop_back();
    03993     void pop_front(_Tp* elems, size_t count);
    03995     void pop_back(_Tp* elems, size_t count);
    03996
    03998     void copyTo(vector<_Tp>& vec, const Range& range=Range::all()) const;
    04000     operator vector<_Tp>() const;
    04001
    04002     CvSeq* seq;
    04003 };
    04004
    04005
    04009 template<typename _Tp> class CV_EXPORTS SeqIterator : public CvSeqReader
    04010 {
    04011 public:
    04013     SeqIterator();
    04015     SeqIterator(const Seq<_Tp>& seq, bool seekEnd=false);
    04017     void seek(size_t pos);
    04019     size_t tell() const;
    04021     _Tp& operator *();
    04023     const _Tp& operator *() const;
    04025     SeqIterator& operator ++();
    04027     SeqIterator operator ++(int) const;
    04029     SeqIterator& operator --();
    04031     SeqIterator operator --(int) const;
    04032
    04034     SeqIterator& operator +=(int);
    04036     SeqIterator& operator -=(int);
    04037
    04038     // this is index of the current element module seq->total*2
    04039     // (to distinguish between 0 and seq->total)
    04040     int index;
    04041 };
    04042
    04043 }
    04044
    04045 #endif // __cplusplus
    04046
    04047 #include "opencv2/core/operations.hpp"
    04048 #include "opencv2/core/mat.hpp"
    04049
    04050 #endif /*__OPENCV_CORE_HPP__*/

All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Defines