opencv 2.2.0
/usr/src/RPM/BUILD/libopencv2.2-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         const 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         const 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 { 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