/// file core.hpp
// brief The Core Functionality

(* ///////////////////////////////////////////////////////////////////////////////////////
  //
  //  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
  //
  //  By downloading, copying, installing or using the software you agree to this license.
  //  If you do not agree to this license, do not download, install,
  //  copy or use the software.
  //
  //
  //                           License Agreement
  //                For Open Source Computer Vision Library
  //
  // Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
  // Copyright (C) 2009-2011, Willow Garage Inc., all rights reserved.
  // Third party copyrights are property of their respective owners.
  //
  // Redistribution and use in source and binary forms, with or without modification,
  // are permitted provided that the following conditions are met:
  //
  //   * Redistribution's of source code must retain the above copyright notice,
  //     this list of conditions and the following disclaimer.
  //
  //   * Redistribution's in binary form must reproduce the above copyright notice,
  //     this list of conditions and the following disclaimer in the documentation
  //     and/or other materials provided with the distribution.
  //
  //   * The name of the copyright holders may not be used to endorse or promote products
  //     derived from this software without specific prior written permission.
  //
  // This software is provided by the copyright holders and contributors "as is" and
  // any express or implied warranties, including, but not limited to, the implied
  // warranties of merchantability and fitness for a particular purpose are disclaimed.
  // In no event shall the Intel Corporation or contributors be liable for any direct,
  // indirect, incidental, special, exemplary, or consequential damages
  // (including, but not limited to, procurement of substitute goods or services;
  // loss of use, data, or profits; or business interruption) however caused
  // and on any theory of liability, whether in contract, strict liability,
  // or tort (including negligence or otherwise) arising in any way out of
  // the use of this software, even if advised of the possibility of such damage.
  //
  //M *)

{$IFDEF DEBUG}
{$A8,B-,C+,D+,E-,F-,G+,H+,I+,J-,K-,L+,M-,N+,O-,P+,Q+,R+,S-,T-,U-,V+,W+,X+,Y+,Z1}
{$ELSE}
{$A8,B-,C-,D-,E-,F-,G+,H+,I+,J-,K-,L-,M-,N+,O+,P+,Q-,R-,S-,T-,U-,V+,W-,X+,Y-,Z1}
{$ENDIF}
{$WARN SYMBOL_DEPRECATED OFF}
{$WARN SYMBOL_PLATFORM OFF}
{$WARN UNIT_PLATFORM OFF}
{$WARN UNSAFE_TYPE OFF}
{$WARN UNSAFE_CODE OFF}
{$WARN UNSAFE_CAST OFF}
unit core;

interface

Uses core.types_c
  {,cvdef}
  {,version
    ,cvstd};

// {
//
// template<typename _Tp> class CV_EXPORTS Size_;
// template<typename _Tp> class CV_EXPORTS Point_;
// template<typename _Tp> class CV_EXPORTS Rect_;
// template<typename _Tp, int cn> class CV_EXPORTS Vec;
// template<typename _Tp, int m, int n> class CV_EXPORTS Matx;
//
// class Mat;
// class SparseMat;
// typedef Mat MatND;
//
// namespace ogl {
// class Buffer;
// class Texture2D;
// class Arrays;
// }
//
// namespace gpu {
// class GpuMat;
// }
//
// class CV_EXPORTS MatExpr;
// class CV_EXPORTS MatOp_Base;
// class CV_EXPORTS MatArg;
// class CV_EXPORTS MatConstIterator;
//
// template<typename _Tp> class CV_EXPORTS Mat_;
// template<typename _Tp> class CV_EXPORTS MatIterator_;
// template<typename _Tp> class CV_EXPORTS MatConstIterator_;
// template<typename _Tp> class CV_EXPORTS MatCommaInitializer_;
//
/// / matrix decomposition types
// enum { DECOMP_LU=0, DECOMP_SVD=1, DECOMP_EIG=2, DECOMP_CHOLESKY=3, DECOMP_QR=4, DECOMP_NORMAL=16 };
// enum { NORM_INF=1, NORM_L1=2, NORM_L2=4, NORM_L2SQR=5, NORM_HAMMING=6, NORM_HAMMING2=7, NORM_TYPE_MASK=7, NORM_RELATIVE=8, NORM_MINMAX=32 };
// enum { CMP_EQ=0, CMP_GT=1, CMP_GE=2, CMP_LT=3, CMP_LE=4, CMP_NE=5 };
// enum { GEMM_1_T=1, GEMM_2_T=2, GEMM_3_T=4 };
// enum { DFT_INVERSE=1, DFT_SCALE=2, DFT_ROWS=4, DFT_COMPLEX_OUTPUT=16, DFT_REAL_OUTPUT=32,
// DCT_INVERSE = DFT_INVERSE, DCT_ROWS=DFT_ROWS };
//
//
/// *!
// The standard OpenCV exception class.
// Instances of the class are thrown by various functions and methods in the case of critical errors.
// */
// class CV_EXPORTS Exception : public std::exception
// {
// public:
// /*!
// Default constructor
// */
// Exception();
// /*!
// Full constructor. Normally the constuctor is not called explicitly.
// Instead, the macros CV_Error(), CV_Error_() and CV_Assert() are used.
// */
// Exception(int _code, const String& _err, const String& _func, const String& _file, int _line);
// virtual ~Exception() throw();
//
// /*!
// \return the error description and the context as a text string.
// */
// virtual const char *what() const throw();
// void formatMessage();
//
// String msg; ///< the formatted error message
//
// int code; ///< error code @see CVStatus
// String err; ///< error description
// String func; ///< function name. Available only when the compiler supports __func__ macro
// String file; ///< source file name where the error has occured
// int line; ///< line number in the source file where the error has occured
// };
//
//
/// /! Signals an error and raises the exception.
//
/// *!
// By default the function prints information about the error to stderr,
// then it either stops if setBreakOnError() had been called before or raises the exception.
// It is possible to alternate error processing by using redirectError().
//
// \param exc the exception raisen.
// */
// CV_EXPORTS void error( const Exception& exc );
//
// #ifdef __GNUC__
// #define CV_Error( code, msg ) cv::error( cv::Exception(code, msg, __func__, __FILE__, __LINE__) )
// #define CV_Error_( code, args ) cv::error( cv::Exception(code, cv::format args, __func__, __FILE__, __LINE__) )
// #define CV_Assert( expr ) if(!!(expr)) ; else cv::error( cv::Exception(CV_StsAssert, #expr, __func__, __FILE__, __LINE__) )
// #else
// #define CV_Error( code, msg ) cv::error( cv::Exception(code, msg, "", __FILE__, __LINE__) )
// #define CV_Error_( code, args ) cv::error( cv::Exception(code, cv::format args, "", __FILE__, __LINE__) )
// #define CV_Assert( expr ) if(!!(expr)) ; else cv::error( cv::Exception(CV_StsAssert, #expr, "", __FILE__, __LINE__) )
// #endif
//
// #ifdef _DEBUG
// #define CV_DbgAssert(expr) CV_Assert(expr)
// #else
// #define CV_DbgAssert(expr)
// #endif
//
/// *!
// Allocates memory buffer
//
// This is specialized OpenCV memory allocation function that returns properly aligned memory buffers.
// The usage is identical to malloc(). The allocated buffers must be freed with cv::fastFree().
// If there is not enough memory, the function calls cv::error(), which raises an exception.
//
// \param bufSize buffer size in bytes
// \return the allocated memory buffer.
// */
// CV_EXPORTS void* fastMalloc(size_t bufSize);
//
/// *!
// Frees the memory allocated with cv::fastMalloc
//
// This is the corresponding deallocation function for cv::fastMalloc().
// When ptr==NULL, the function has no effect.
// */
// CV_EXPORTS void fastFree(void* ptr);
//
// template<typename _Tp> static inline _Tp* allocate(size_t n)
// {
// return new _Tp[n];
// }
//
// template<typename _Tp> static inline void deallocate(_Tp* ptr, size_t)
// {
// delete[] ptr;
// }
//
/// *!
// The STL-compilant memory Allocator based on cv::fastMalloc() and cv::fastFree()
// */
// template<typename _Tp> class CV_EXPORTS Allocator
// {
// public:
// typedef _Tp value_type;
// typedef value_type* pointer;
// typedef const value_type* const_pointer;
// typedef value_type& reference;
// typedef const value_type& const_reference;
// typedef size_t size_type;
// typedef ptrdiff_t difference_type;
// template<typename U> class rebind { typedef Allocator<U> other; };
//
// explicit Allocator() {}
// ~Allocator() {}
// explicit Allocator(Allocator const&) {}
// template<typename U>
// explicit Allocator(Allocator<U> const&) {}
//
// // address
// pointer address(reference r) { return &r; }
// const_pointer address(const_reference r) { return &r; }
//
// pointer allocate(size_type count, const void* =0)
// { return reinterpret_cast<pointer>(fastMalloc(count * sizeof (_Tp))); }
//
// void deallocate(pointer p, size_type) {fastFree(p); }
//
// size_type max_size() const
// { return max(static_cast<_Tp>(-1)/sizeof(_Tp), 1); }
//
// void construct(pointer p, const _Tp& v) { new(static_cast<void*>(p)) _Tp(v); }
// void destroy(pointer p) { p->~_Tp(); }
// };
//
/// ////////////////////// Vec (used as element of multi-channel images /////////////////////
//
/// *!
// A helper class for cv::DataType
//
// The class is specialized for each fundamental numerical data type supported by OpenCV.
// It provides DataDepth<T>::value constant.
// */
// template<typename _Tp> class CV_EXPORTS DataDepth {};
//
// template<> class DataDepth<bool> { public: enum { value = CV_8U, fmt=(int)'u' }; };
// template<> class DataDepth<uchar> { public: enum { value = CV_8U, fmt=(int)'u' }; };
// template<> class DataDepth<schar> { public: enum { value = CV_8S, fmt=(int)'c' }; };
// template<> class DataDepth<char> { public: enum { value = CV_8S, fmt=(int)'c' }; };
// template<> class DataDepth<ushort> { public: enum { value = CV_16U, fmt=(int)'w' }; };
// template<> class DataDepth<short> { public: enum { value = CV_16S, fmt=(int)'s' }; };
// template<> class DataDepth<int> { public: enum { value = CV_32S, fmt=(int)'i' }; };
/// / this is temporary solution to support 32-bit unsigned integers
// template<> class DataDepth<unsigned> { public: enum { value = CV_32S, fmt=(int)'i' }; };
// template<> class DataDepth<float> { public: enum { value = CV_32F, fmt=(int)'f' }; };
// template<> class DataDepth<double> { public: enum { value = CV_64F, fmt=(int)'d' }; };
// template<typename _Tp> class DataDepth<_Tp*> { public: enum { value = CV_USRTYPE1, fmt=(int)'r' }; };
//
//
/// ///////////////////////////// Small Matrix ///////////////////////////
//
/// *!
// A short numerical vector.
//
// This template class represents short numerical vectors (of 1, 2, 3, 4 ... elements)
// on which you can perform basic arithmetical operations, access individual elements using [] operator etc.
// The vectors are allocated on stack, as opposite to std::valarray, std::vector, cv::Mat etc.,
// which elements are dynamically allocated in the heap.
//
// The template takes 2 parameters:
// -# _Tp element type
// -# cn the number of elements
//
// In addition to the universal notation like Vec<float, 3>, you can use shorter aliases
// for the most popular specialized variants of Vec, e.g. Vec3f ~ Vec<float, 3>.
// */
//
// struct CV_EXPORTS Matx_AddOp {};
// struct CV_EXPORTS Matx_SubOp {};
// struct CV_EXPORTS Matx_ScaleOp {};
// struct CV_EXPORTS Matx_MulOp {};
// struct CV_EXPORTS Matx_MatMulOp {};
// struct CV_EXPORTS Matx_TOp {};
//
// template<typename _Tp, int m, int n> class CV_EXPORTS Matx
// {
// public:
// typedef _Tp value_type;
// typedef Matx<_Tp, (m < n ? m : n), 1> diag_type;
// typedef Matx<_Tp, m, n> mat_type;
// enum { depth = DataDepth<_Tp>::value, rows = m, cols = n, channels = rows*cols,
// type = CV_MAKETYPE(depth, channels) };
//
// //! default constructor
// Matx();
//
// Matx(_Tp v0); //!< 1x1 matrix
// Matx(_Tp v0, _Tp v1); //!< 1x2 or 2x1 matrix
// Matx(_Tp v0, _Tp v1, _Tp v2); //!< 1x3 or 3x1 matrix
// Matx(_Tp v0, _Tp v1, _Tp v2, _Tp v3); //!< 1x4, 2x2 or 4x1 matrix
// Matx(_Tp v0, _Tp v1, _Tp v2, _Tp v3, _Tp v4); //!< 1x5 or 5x1 matrix
// Matx(_Tp v0, _Tp v1, _Tp v2, _Tp v3, _Tp v4, _Tp v5); //!< 1x6, 2x3, 3x2 or 6x1 matrix
// Matx(_Tp v0, _Tp v1, _Tp v2, _Tp v3, _Tp v4, _Tp v5, _Tp v6); //!< 1x7 or 7x1 matrix
// Matx(_Tp v0, _Tp v1, _Tp v2, _Tp v3, _Tp v4, _Tp v5, _Tp v6, _Tp v7); //!< 1x8, 2x4, 4x2 or 8x1 matrix
// Matx(_Tp v0, _Tp v1, _Tp v2, _Tp v3, _Tp v4, _Tp v5, _Tp v6, _Tp v7, _Tp v8); //!< 1x9, 3x3 or 9x1 matrix
// Matx(_Tp v0, _Tp v1, _Tp v2, _Tp v3, _Tp v4, _Tp v5, _Tp v6, _Tp v7, _Tp v8, _Tp v9); //!< 1x10, 2x5 or 5x2 or 10x1 matrix
// Matx(_Tp v0, _Tp v1, _Tp v2, _Tp v3,
// _Tp v4, _Tp v5, _Tp v6, _Tp v7,
// _Tp v8, _Tp v9, _Tp v10, _Tp v11); //!< 1x12, 2x6, 3x4, 4x3, 6x2 or 12x1 matrix
// Matx(_Tp v0, _Tp v1, _Tp v2, _Tp v3,
// _Tp v4, _Tp v5, _Tp v6, _Tp v7,
// _Tp v8, _Tp v9, _Tp v10, _Tp v11,
// _Tp v12, _Tp v13, _Tp v14, _Tp v15); //!< 1x16, 4x4 or 16x1 matrix
// explicit Matx(const _Tp* vals); //!< initialize from a plain array
//
// static Matx all(_Tp alpha);
// static Matx zeros();
// static Matx ones();
// static Matx eye();
// static Matx diag(const diag_type& d);
// static Matx randu(_Tp a, _Tp b);
// static Matx randn(_Tp a, _Tp b);
//
// //! dot product computed with the default precision
// _Tp dot(const Matx<_Tp, m, n>& v) const;
//
// //! dot product computed in double-precision arithmetics
// double ddot(const Matx<_Tp, m, n>& v) const;
//
// //! convertion to another data type
// template<typename T2> operator Matx<T2, m, n>() const;
//
// //! change the matrix shape
// template<int m1, int n1> Matx<_Tp, m1, n1> reshape() const;
//
// //! extract part of the matrix
// template<int m1, int n1> Matx<_Tp, m1, n1> get_minor(int i, int j) const;
//
// //! extract the matrix row
// Matx<_Tp, 1, n> row(int i) const;
//
// //! extract the matrix column
// Matx<_Tp, m, 1> col(int i) const;
//
// //! extract the matrix diagonal
// diag_type diag() const;
//
// //! transpose the matrix
// Matx<_Tp, n, m> t() const;
//
// //! invert matrix the matrix
// Matx<_Tp, n, m> inv(int method=DECOMP_LU) const;
//
// //! solve linear system
// template<int l> Matx<_Tp, n, l> solve(const Matx<_Tp, m, l>& rhs, int flags=DECOMP_LU) const;
// Vec<_Tp, n> solve(const Vec<_Tp, m>& rhs, int method) const;
//
// //! multiply two matrices element-wise
// Matx<_Tp, m, n> mul(const Matx<_Tp, m, n>& a) const;
//
// //! element access
// const _Tp& operator ()(int i, int j) const;
// _Tp& operator ()(int i, int j);
//
// //! 1D element access
// const _Tp& operator ()(int i) const;
// _Tp& operator ()(int i);
//
// Matx(const Matx<_Tp, m, n>& a, const Matx<_Tp, m, n>& b, Matx_AddOp);
// Matx(const Matx<_Tp, m, n>& a, const Matx<_Tp, m, n>& b, Matx_SubOp);
// template<typename _T2> Matx(const Matx<_Tp, m, n>& a, _T2 alpha, Matx_ScaleOp);
// Matx(const Matx<_Tp, m, n>& a, const Matx<_Tp, m, n>& b, Matx_MulOp);
// template<int l> Matx(const Matx<_Tp, m, l>& a, const Matx<_Tp, l, n>& b, Matx_MatMulOp);
// Matx(const Matx<_Tp, n, m>& a, Matx_TOp);
//
// _Tp val[m*n]; //< matrix elements
// };
//
//
// typedef Matx<float, 1, 2> Matx12f;
// typedef Matx<double, 1, 2> Matx12d;
// typedef Matx<float, 1, 3> Matx13f;
// typedef Matx<double, 1, 3> Matx13d;
// typedef Matx<float, 1, 4> Matx14f;
// typedef Matx<double, 1, 4> Matx14d;
// typedef Matx<float, 1, 6> Matx16f;
// typedef Matx<double, 1, 6> Matx16d;
//
// typedef Matx<float, 2, 1> Matx21f;
// typedef Matx<double, 2, 1> Matx21d;
// typedef Matx<float, 3, 1> Matx31f;
// typedef Matx<double, 3, 1> Matx31d;
// typedef Matx<float, 4, 1> Matx41f;
// typedef Matx<double, 4, 1> Matx41d;
// typedef Matx<float, 6, 1> Matx61f;
// typedef Matx<double, 6, 1> Matx61d;
//
// typedef Matx<float, 2, 2> Matx22f;
// typedef Matx<double, 2, 2> Matx22d;
// typedef Matx<float, 2, 3> Matx23f;
// typedef Matx<double, 2, 3> Matx23d;
// typedef Matx<float, 3, 2> Matx32f;
// typedef Matx<double, 3, 2> Matx32d;
//
// typedef Matx<float, 3, 3> Matx33f;
// typedef Matx<double, 3, 3> Matx33d;
//
// typedef Matx<float, 3, 4> Matx34f;
// typedef Matx<double, 3, 4> Matx34d;
// typedef Matx<float, 4, 3> Matx43f;
// typedef Matx<double, 4, 3> Matx43d;
//
// typedef Matx<float, 4, 4> Matx44f;
// typedef Matx<double, 4, 4> Matx44d;
// typedef Matx<float, 6, 6> Matx66f;
// typedef Matx<double, 6, 6> Matx66d;
//
//
/// *!
// A short numerical vector.
//
// This template class represents short numerical vectors (of 1, 2, 3, 4 ... elements)
// on which you can perform basic arithmetical operations, access individual elements using [] operator etc.
// The vectors are allocated on stack, as opposite to std::valarray, std::vector, cv::Mat etc.,
// which elements are dynamically allocated in the heap.
//
// The template takes 2 parameters:
// -# _Tp element type
// -# cn the number of elements
//
// In addition to the universal notation like Vec<float, 3>, you can use shorter aliases
// for the most popular specialized variants of Vec, e.g. Vec3f ~ Vec<float, 3>.
// */
// template<typename _Tp, int cn> class CV_EXPORTS Vec : public Matx<_Tp, cn, 1>
// {
// public:
// typedef _Tp value_type;
// enum { depth = DataDepth<_Tp>::value, channels = cn, type = CV_MAKETYPE(depth, channels) };
//
// //! default constructor
// Vec();
//
// Vec(_Tp v0); //!< 1-element vector constructor
// Vec(_Tp v0, _Tp v1); //!< 2-element vector constructor
// Vec(_Tp v0, _Tp v1, _Tp v2); //!< 3-element vector constructor
// Vec(_Tp v0, _Tp v1, _Tp v2, _Tp v3); //!< 4-element vector constructor
// Vec(_Tp v0, _Tp v1, _Tp v2, _Tp v3, _Tp v4); //!< 5-element vector constructor
// Vec(_Tp v0, _Tp v1, _Tp v2, _Tp v3, _Tp v4, _Tp v5); //!< 6-element vector constructor
// Vec(_Tp v0, _Tp v1, _Tp v2, _Tp v3, _Tp v4, _Tp v5, _Tp v6); //!< 7-element vector constructor
// Vec(_Tp v0, _Tp v1, _Tp v2, _Tp v3, _Tp v4, _Tp v5, _Tp v6, _Tp v7); //!< 8-element vector constructor
// Vec(_Tp v0, _Tp v1, _Tp v2, _Tp v3, _Tp v4, _Tp v5, _Tp v6, _Tp v7, _Tp v8); //!< 9-element vector constructor
// Vec(_Tp v0, _Tp v1, _Tp v2, _Tp v3, _Tp v4, _Tp v5, _Tp v6, _Tp v7, _Tp v8, _Tp v9); //!< 10-element vector constructor
// explicit Vec(const _Tp* values);
//
// Vec(const Vec<_Tp, cn>& v);
//
// static Vec all(_Tp alpha);
//
// //! per-element multiplication
// Vec mul(const Vec<_Tp, cn>& v) const;
//
// //! conjugation (makes sense for complex numbers and quaternions)
// Vec conj() const;
//
// /*!
// cross product of the two 3D vectors.
//
// For other dimensionalities the exception is raised
// */
// Vec cross(const Vec& v) const;
// //! convertion to another data type
// template<typename T2> operator Vec<T2, cn>() const;
// //! conversion to 4-element CvScalar.
// operator CvScalar() const;
//
// /*! element access */
// const _Tp& operator [](int i) const;
// _Tp& operator[](int i);
// const _Tp& operator ()(int i) const;
// _Tp& operator ()(int i);
//
// Vec(const Matx<_Tp, cn, 1>& a, const Matx<_Tp, cn, 1>& b, Matx_AddOp);
// Vec(const Matx<_Tp, cn, 1>& a, const Matx<_Tp, cn, 1>& b, Matx_SubOp);
// template<typename _T2> Vec(const Matx<_Tp, cn, 1>& a, _T2 alpha, Matx_ScaleOp);
// };
//
//
/// * \typedef
//
// Shorter aliases for the most popular specializations of Vec<T,n>
// */
// typedef Vec<uchar, 2> Vec2b;
// typedef Vec<uchar, 3> Vec3b;
// typedef Vec<uchar, 4> Vec4b;
//
// typedef Vec<short, 2> Vec2s;
// typedef Vec<short, 3> Vec3s;
// typedef Vec<short, 4> Vec4s;
//
// typedef Vec<ushort, 2> Vec2w;
// typedef Vec<ushort, 3> Vec3w;
// typedef Vec<ushort, 4> Vec4w;
//
// typedef Vec<int, 2> Vec2i;
// typedef Vec<int, 3> Vec3i;
// typedef Vec<int, 4> Vec4i;
// typedef Vec<int, 6> Vec6i;
// typedef Vec<int, 8> Vec8i;
//
// typedef Vec<float, 2> Vec2f;
// typedef Vec<float, 3> Vec3f;
// typedef Vec<float, 4> Vec4f;
// typedef Vec<float, 6> Vec6f;
//
// typedef Vec<double, 2> Vec2d;
// typedef Vec<double, 3> Vec3d;
// typedef Vec<double, 4> Vec4d;
// typedef Vec<double, 6> Vec6d;
//
//
/// /////////////////////////////// Complex //////////////////////////////
//
/// *!
// A complex number class.
//
// The template class is similar and compatible with std::complex, however it provides slightly
// more convenient access to the real and imaginary parts using through the simple field access, as opposite
// to std::complex::real() and std::complex::imag().
// */
// template<typename _Tp> class CV_EXPORTS Complex
// {
// public:
//
// //! constructors
// Complex();
// Complex( _Tp _re, _Tp _im=0 );
// Complex( const std::complex<_Tp>& c );
//
// //! conversion to another data type
// template<typename T2> operator Complex<T2>() const;
// //! conjugation
// Complex conj() const;
// //! conversion to std::complex
// operator std::complex<_Tp>() const;
//
// _Tp re, im; //< the real and the imaginary parts
// };
//
//
/// *!
// \typedef
// */
// typedef Complex<float> Complexf;
// typedef Complex<double> Complexd;
//
//
/// /////////////////////////////// Point_ ////////////////////////////////
//
/// *!
// template 2D point class.
//
// The class defines a point in 2D space. Data type of the point coordinates is specified
// as a template parameter. There are a few shorter aliases available for user convenience.
// See cv::Point, cv::Point2i, cv::Point2f and cv::Point2d.
// */
// template<typename _Tp> class CV_EXPORTS Point_
// {
// public:
// typedef _Tp value_type;
//
// // various constructors
// Point_();
// Point_(_Tp _x, _Tp _y);
// Point_(const Point_& pt);
// Point_(const CvPoint& pt);
// Point_(const CvPoint2D32f& pt);
// Point_(const Size_<_Tp>& sz);
// Point_(const Vec<_Tp, 2>& v);
//
// Point_& operator = (const Point_& pt);
// //! conversion to another data type
// template<typename _Tp2> operator Point_<_Tp2>() const;
//
// //! conversion to the old-style C structures
// operator CvPoint() const;
// operator CvPoint2D32f() const;
// operator Vec<_Tp, 2>() const;
//
// //! dot product
// _Tp dot(const Point_& pt) const;
// //! dot product computed in double-precision arithmetics
// double ddot(const Point_& pt) const;
// //! cross-product
// double cross(const Point_& pt) const;
// //! checks whether the point is inside the specified rectangle
// bool inside(const Rect_<_Tp>& r) const;
//
// _Tp x, y; //< the point coordinates
// };
//
/// *!
// template 3D point class.
//
// The class defines a point in 3D space. Data type of the point coordinates is specified
// as a template parameter.
//
// \see cv::Point3i, cv::Point3f and cv::Point3d
// */
// template<typename _Tp> class CV_EXPORTS Point3_
// {
// public:
// typedef _Tp value_type;
//
// // various constructors
// Point3_();
// Point3_(_Tp _x, _Tp _y, _Tp _z);
// Point3_(const Point3_& pt);
// explicit Point3_(const Point_<_Tp>& pt);
// Point3_(const CvPoint3D32f& pt);
// Point3_(const Vec<_Tp, 3>& v);
//
// Point3_& operator = (const Point3_& pt);
// //! conversion to another data type
// template<typename _Tp2> operator Point3_<_Tp2>() const;
// //! conversion to the old-style CvPoint...
// operator CvPoint3D32f() const;
// //! conversion to cv::Vec<>
// operator Vec<_Tp, 3>() const;
//
// //! dot product
// _Tp dot(const Point3_& pt) const;
// //! dot product computed in double-precision arithmetics
// double ddot(const Point3_& pt) const;
// //! cross product of the 2 3D points
// Point3_ cross(const Point3_& pt) const;
//
// _Tp x, y, z; //< the point coordinates
// };
//
/// /////////////////////////////// Size_ ////////////////////////////////
//
/// *!
// The 2D size class
//
// The class represents the size of a 2D rectangle, image size, matrix size etc.
// Normally, cv::Size ~ cv::Size_<int> is used.
// */
// template<typename _Tp> class CV_EXPORTS Size_
// {
// public:
// typedef _Tp value_type;
//
// //! various constructors
// Size_();
// Size_(_Tp _width, _Tp _height);
// Size_(const Size_& sz);
// Size_(const CvSize& sz);
// Size_(const CvSize2D32f& sz);
// Size_(const Point_<_Tp>& pt);
//
// Size_& operator = (const Size_& sz);
// //! the area (width*height)
// _Tp area() const;
//
// //! conversion of another data type.
// template<typename _Tp2> operator Size_<_Tp2>() const;
//
// //! conversion to the old-style OpenCV types
// operator CvSize() const;
// operator CvSize2D32f() const;
//
// _Tp width, height; // the width and the height
// };
//
/// /////////////////////////////// Rect_ ////////////////////////////////
//
/// *!
// The 2D up-right rectangle class
//
// The class represents a 2D rectangle with coordinates of the specified data type.
// Normally, cv::Rect ~ cv::Rect_<int> is used.
// */
// template<typename _Tp> class CV_EXPORTS Rect_
// {
// public:
// typedef _Tp value_type;
//
// //! various constructors
// Rect_();
// Rect_(_Tp _x, _Tp _y, _Tp _width, _Tp _height);
// Rect_(const Rect_& r);
// Rect_(const CvRect& r);
// Rect_(const Point_<_Tp>& org, const Size_<_Tp>& sz);
// Rect_(const Point_<_Tp>& pt1, const Point_<_Tp>& pt2);
//
// Rect_& operator = ( const Rect_& r );
// //! the top-left corner
// Point_<_Tp> tl() const;
// //! the bottom-right corner
// Point_<_Tp> br() const;
//
// //! size (width, height) of the rectangle
// Size_<_Tp> size() const;
// //! area (width*height) of the rectangle
// _Tp area() const;
//
// //! conversion to another data type
// template<typename _Tp2> operator Rect_<_Tp2>() const;
// //! conversion to the old-style CvRect
// operator CvRect() const;
//
// //! checks whether the rectangle contains the point
// bool contains(const Point_<_Tp>& pt) const;
//
// _Tp x, y, width, height; //< the top-left corner, as well as width and height of the rectangle
// };
//
//
/// *!
// \typedef
//
// shorter aliases for the most popular cv::Point_<>, cv::Size_<> and cv::Rect_<> specializations
// */
// typedef Point_<int> Point2i;
// typedef Point2i Point;
// typedef Size_<int> Size2i;
// typedef Size2i Size;
// typedef Rect_<int> Rect;
// typedef Point_<float> Point2f;
// typedef Point_<double> Point2d;
// typedef Size_<float> Size2f;
// typedef Point3_<int> Point3i;
// typedef Point3_<float> Point3f;
// typedef Point3_<double> Point3d;
//
//
/// *!
// The rotated 2D rectangle.
//
// The class represents rotated (i.e. not up-right) rectangles on a plane.
// Each rectangle is described by the center point (mass center), length of each side
// (represented by cv::Size2f structure) and the rotation angle in degrees.
// */
// class CV_EXPORTS RotatedRect
// {
// public:
// //! various constructors
// RotatedRect();
// RotatedRect(const Point2f& center, const Size2f& size, float angle);
// RotatedRect(const CvBox2D& box);
//
// //! returns 4 vertices of the rectangle
// void points(Point2f pts[]) const;
// //! returns the minimal up-right rectangle containing the rotated rectangle
// Rect boundingRect() const;
// //! conversion to the old-style CvBox2D structure
// operator CvBox2D() const;
//
// Point2f center; //< the rectangle mass center
// Size2f size;    //< width and height of the rectangle
// float angle;    //< the rotation angle. When the angle is 0, 90, 180, 270 etc., the rectangle becomes an up-right rectangle.
// };
//
/// /////////////////////////////// Scalar_ ///////////////////////////////
//
/// *!
// The template scalar class.
//
// This is partially specialized cv::Vec class with the number of elements = 4, i.e. a short vector of four elements.
// Normally, cv::Scalar ~ cv::Scalar_<double> is used.
// */
// template<typename _Tp> class CV_EXPORTS Scalar_ : public Vec<_Tp, 4>
// {
// public:
// //! various constructors
// Scalar_();
// Scalar_(_Tp v0, _Tp v1, _Tp v2=0, _Tp v3=0);
// Scalar_(const CvScalar& s);
// Scalar_(_Tp v0);
//
// //! returns a scalar with all elements set to v0
// static Scalar_<_Tp> all(_Tp v0);
// //! conversion to the old-style CvScalar
// operator CvScalar() const;
//
// //! conversion to another data type
// template<typename T2> operator Scalar_<T2>() const;
//
// //! per-element product
// Scalar_<_Tp> mul(const Scalar_<_Tp>& t, double scale=1 ) const;
//
// // returns (v0, -v1, -v2, -v3)
// Scalar_<_Tp> conj() const;
//
// // returns true iff v1 == v2 == v3 == 0
// bool isReal() const;
// };
//
// typedef Scalar_<double> Scalar;
//
// CV_EXPORTS void scalarToRawData(const Scalar& s, void* buf, int type, int unroll_to=0);
//
/// /////////////////////////////// Range /////////////////////////////////
//
/// *!
// The 2D range class
//
// This is the class used to specify a continuous subsequence, i.e. part of a contour, or a column span in a matrix.
// */
// class CV_EXPORTS Range
// {
// public:
// Range();
// Range(int _start, int _end);
// Range(const CvSlice& slice);
// int size() const;
// bool empty() const;
// static Range all();
// operator CvSlice() const;
//
// int start, end;
// };
//
//
//
/// ////////////////////////////// KeyPoint ////////////////////////////////
//
/// *!
// The Keypoint Class
//
// The class instance stores a keypoint, i.e. a point feature found by one of many available keypoint detectors, such as
// Harris corner detector, cv::FAST, cv::StarDetector, cv::SURF, cv::SIFT, cv::LDetector etc.
//
// The keypoint is characterized by the 2D position, scale
// (proportional to the diameter of the neighborhood that needs to be taken into account),
// orientation and some other parameters. The keypoint neighborhood is then analyzed by another algorithm that builds a descriptor
// (usually represented as a feature vector). The keypoints representing the same object in different images can then be matched using
// cv::KDTree or another method.
// */
// class CV_EXPORTS_W_SIMPLE KeyPoint
// {
// public:
// //! the default constructor
// CV_WRAP KeyPoint();
// //! the full constructor
// KeyPoint(Point2f _pt, float _size, float _angle=-1, float _response=0, int _octave=0, int _class_id=-1);
// //! another form of the full constructor
// CV_WRAP KeyPoint(float x, float y, float _size, float _angle=-1, float _response=0, int _octave=0, int _class_id=-1);
//
// size_t hash() const;
//
// //! converts vector of keypoints to vector of points
// static void convert(const std::vector<KeyPoint>& keypoints,
// CV_OUT std::vector<Point2f>& points2f,
// const std::vector<int>& keypointIndexes=std::vector<int>());
// //! converts vector of points to the vector of keypoints, where each keypoint is assigned the same size and the same orientation
// static void convert(const std::vector<Point2f>& points2f,
// CV_OUT std::vector<KeyPoint>& keypoints,
// float size=1, float response=1, int octave=0, int class_id=-1);
//
// //! computes overlap for pair of keypoints;
// //! overlap is a ratio between area of keypoint regions intersection and
// //! area of keypoint regions union (now keypoint region is circle)
// static float overlap(const KeyPoint& kp1, const KeyPoint& kp2);
//
// CV_PROP_RW Point2f pt; //!< coordinates of the keypoints
// CV_PROP_RW float size; //!< diameter of the meaningful keypoint neighborhood
// CV_PROP_RW float angle; //!< computed orientation of the keypoint (-1 if not applicable);
// //!< it's in [0,360) degrees and measured relative to
// //!< image coordinate system, ie in clockwise.
// CV_PROP_RW float response; //!< the response by which the most strong keypoints have been selected. Can be used for the further sorting or subsampling
// CV_PROP_RW int octave; //!< octave (pyramid layer) from which the keypoint has been extracted
// CV_PROP_RW int class_id; //!< object class (if the keypoints need to be clustered by an object they belong to)
// };
//
// inline KeyPoint::KeyPoint() : pt(0,0), size(0), angle(-1), response(0), octave(0), class_id(-1) {}
// inline KeyPoint::KeyPoint(Point2f _pt, float _size, float _angle, float _response, int _octave, int _class_id)
// : pt(_pt), size(_size), angle(_angle), response(_response), octave(_octave), class_id(_class_id) {}
// inline KeyPoint::KeyPoint(float x, float y, float _size, float _angle, float _response, int _octave, int _class_id)
// : pt(x, y), size(_size), angle(_angle), response(_response), octave(_octave), class_id(_class_id) {}
//
//
//
/// /////////////////////////////// DMatch /////////////////////////////////
//
/// *
// * Struct for matching: query descriptor index, train descriptor index, train image index and distance between descriptors.
// */
// struct CV_EXPORTS_W_SIMPLE DMatch
// {
// CV_WRAP DMatch();
// CV_WRAP DMatch(int _queryIdx, int _trainIdx, float _distance);
// CV_WRAP DMatch(int _queryIdx, int _trainIdx, int _imgIdx, float _distance);
//
// CV_PROP_RW int queryIdx; // query descriptor index
// CV_PROP_RW int trainIdx; // train descriptor index
// CV_PROP_RW int imgIdx;   // train image index
//
// CV_PROP_RW float distance;
//
// // less is better
// bool operator<(const DMatch &m) const;
// };
//
// inline DMatch::DMatch() : queryIdx(-1), trainIdx(-1), imgIdx(-1), distance(FLT_MAX) {}
// inline DMatch::DMatch(int _queryIdx, int _trainIdx, float _distance)
// : queryIdx(_queryIdx), trainIdx(_trainIdx), imgIdx(-1), distance(_distance) {}
// inline DMatch::DMatch(int _queryIdx, int _trainIdx, int _imgIdx, float _distance)
// : queryIdx(_queryIdx), trainIdx(_trainIdx), imgIdx(_imgIdx), distance(_distance) {}
// inline bool DMatch::operator<(const DMatch &m) const { return distance < m.distance; }
//
//
//
/// ////////////////////////////// DataType ////////////////////////////////
//
/// *!
// Informative template class for OpenCV "scalars".
//
// The class is specialized for each primitive numerical type supported by OpenCV (such as unsigned char or float),
// as well as for more complex types, like cv::Complex<>, std::complex<>, cv::Vec<> etc.
// The common property of all such types (called "scalars", do not confuse it with cv::Scalar_)
// is that each of them is basically a tuple of numbers of the same type. Each "scalar" can be represented
// by the depth id (CV_8U ... CV_64F) and the number of channels.
// OpenCV matrices, 2D or nD, dense or sparse, can store "scalars",
// as long as the number of channels does not exceed CV_CN_MAX.
// */
// template<typename _Tp> class DataType
// {
// public:
// typedef _Tp value_type;
// typedef value_type work_type;
// typedef value_type channel_type;
// typedef value_type vec_type;
// enum { generic_type = 1, depth = -1, channels = 1, fmt=0,
// type = CV_MAKETYPE(depth, channels) };
// };
//
// template<> class DataType<bool>
// {
// public:
// typedef bool value_type;
// typedef int work_type;
// typedef value_type channel_type;
// typedef value_type vec_type;
// enum { generic_type = 0, depth = DataDepth<channel_type>::value, channels = 1,
// fmt=DataDepth<channel_type>::fmt,
// type = CV_MAKETYPE(depth, channels) };
// };
//
// template<> class DataType<uchar>
// {
// public:
// typedef uchar value_type;
// typedef int work_type;
// typedef value_type channel_type;
// typedef value_type vec_type;
// enum { generic_type = 0, depth = DataDepth<channel_type>::value, channels = 1,
// fmt=DataDepth<channel_type>::fmt,
// type = CV_MAKETYPE(depth, channels) };
// };
//
// template<> class DataType<schar>
// {
// public:
// typedef schar value_type;
// typedef int work_type;
// typedef value_type channel_type;
// typedef value_type vec_type;
// enum { generic_type = 0, depth = DataDepth<channel_type>::value, channels = 1,
// fmt=DataDepth<channel_type>::fmt,
// type = CV_MAKETYPE(depth, channels) };
// };
//
// template<> class DataType<char>
// {
// public:
// typedef schar value_type;
// typedef int work_type;
// typedef value_type channel_type;
// typedef value_type vec_type;
// enum { generic_type = 0, depth = DataDepth<channel_type>::value, channels = 1,
// fmt=DataDepth<channel_type>::fmt,
// type = CV_MAKETYPE(depth, channels) };
// };
//
// template<> class DataType<ushort>
// {
// public:
// typedef ushort value_type;
// typedef int work_type;
// typedef value_type channel_type;
// typedef value_type vec_type;
// enum { generic_type = 0, depth = DataDepth<channel_type>::value, channels = 1,
// fmt=DataDepth<channel_type>::fmt,
// type = CV_MAKETYPE(depth, channels) };
// };
//
// template<> class DataType<short>
// {
// public:
// typedef short value_type;
// typedef int work_type;
// typedef value_type channel_type;
// typedef value_type vec_type;
// enum { generic_type = 0, depth = DataDepth<channel_type>::value, channels = 1,
// fmt=DataDepth<channel_type>::fmt,
// type = CV_MAKETYPE(depth, channels) };
// };
//
// template<> class DataType<int>
// {
// public:
// typedef int value_type;
// typedef value_type work_type;
// typedef value_type channel_type;
// typedef value_type vec_type;
// enum { generic_type = 0, depth = DataDepth<channel_type>::value, channels = 1,
// fmt=DataDepth<channel_type>::fmt,
// type = CV_MAKETYPE(depth, channels) };
// };
//
// template<> class DataType<float>
// {
// public:
// typedef float value_type;
// typedef value_type work_type;
// typedef value_type channel_type;
// typedef value_type vec_type;
// enum { generic_type = 0, depth = DataDepth<channel_type>::value, channels = 1,
// fmt=DataDepth<channel_type>::fmt,
// type = CV_MAKETYPE(depth, channels) };
// };
//
// template<> class DataType<double>
// {
// public:
// typedef double value_type;
// typedef value_type work_type;
// typedef value_type channel_type;
// typedef value_type vec_type;
// enum { generic_type = 0, depth = DataDepth<channel_type>::value, channels = 1,
// fmt=DataDepth<channel_type>::fmt,
// type = CV_MAKETYPE(depth, channels) };
// };
//
// template<typename _Tp, int m, int n> class DataType<Matx<_Tp, m, n> >
// {
// public:
// typedef Matx<_Tp, m, n> value_type;
// typedef Matx<typename DataType<_Tp>::work_type, m, n> work_type;
// typedef _Tp channel_type;
// typedef value_type vec_type;
// enum { generic_type = 0, depth = DataDepth<channel_type>::value, channels = m*n,
// fmt = ((channels-1)<<8) + DataDepth<channel_type>::fmt,
// type = CV_MAKETYPE(depth, channels) };
// };
//
// template<typename _Tp, int cn> class DataType<Vec<_Tp, cn> >
// {
// public:
// typedef Vec<_Tp, cn> value_type;
// typedef Vec<typename DataType<_Tp>::work_type, cn> work_type;
// typedef _Tp channel_type;
// typedef value_type vec_type;
// enum { generic_type = 0, depth = DataDepth<channel_type>::value, channels = cn,
// fmt = ((channels-1)<<8) + DataDepth<channel_type>::fmt,
// type = CV_MAKETYPE(depth, channels) };
// };
//
// template<typename _Tp> class DataType<std::complex<_Tp> >
// {
// public:
// typedef std::complex<_Tp> value_type;
// typedef value_type work_type;
// typedef _Tp channel_type;
// enum { generic_type = 0, depth = DataDepth<channel_type>::value, channels = 2,
// fmt = ((channels-1)<<8) + DataDepth<channel_type>::fmt,
// type = CV_MAKETYPE(depth, channels) };
// typedef Vec<channel_type, channels> vec_type;
// };
//
// template<typename _Tp> class DataType<Complex<_Tp> >
// {
// public:
// typedef Complex<_Tp> value_type;
// typedef value_type work_type;
// typedef _Tp channel_type;
// enum { generic_type = 0, depth = DataDepth<channel_type>::value, channels = 2,
// fmt = ((channels-1)<<8) + DataDepth<channel_type>::fmt,
// type = CV_MAKETYPE(depth, channels) };
// typedef Vec<channel_type, channels> vec_type;
// };
//
// template<typename _Tp> class DataType<Point_<_Tp> >
// {
// public:
// typedef Point_<_Tp> value_type;
// typedef Point_<typename DataType<_Tp>::work_type> work_type;
// typedef _Tp channel_type;
// enum { generic_type = 0, depth = DataDepth<channel_type>::value, channels = 2,
// fmt = ((channels-1)<<8) + DataDepth<channel_type>::fmt,
// type = CV_MAKETYPE(depth, channels) };
// typedef Vec<channel_type, channels> vec_type;
// };
//
// template<typename _Tp> class DataType<Point3_<_Tp> >
// {
// public:
// typedef Point3_<_Tp> value_type;
// typedef Point3_<typename DataType<_Tp>::work_type> work_type;
// typedef _Tp channel_type;
// enum { generic_type = 0, depth = DataDepth<channel_type>::value, channels = 3,
// fmt = ((channels-1)<<8) + DataDepth<channel_type>::fmt,
// type = CV_MAKETYPE(depth, channels) };
// typedef Vec<channel_type, channels> vec_type;
// };
//
// template<typename _Tp> class DataType<Size_<_Tp> >
// {
// public:
// typedef Size_<_Tp> value_type;
// typedef Size_<typename DataType<_Tp>::work_type> work_type;
// typedef _Tp channel_type;
// enum { generic_type = 0, depth = DataDepth<channel_type>::value, channels = 2,
// fmt = ((channels-1)<<8) + DataDepth<channel_type>::fmt,
// type = CV_MAKETYPE(depth, channels) };
// typedef Vec<channel_type, channels> vec_type;
// };
//
// template<typename _Tp> class DataType<Rect_<_Tp> >
// {
// public:
// typedef Rect_<_Tp> value_type;
// typedef Rect_<typename DataType<_Tp>::work_type> work_type;
// typedef _Tp channel_type;
// enum { generic_type = 0, depth = DataDepth<channel_type>::value, channels = 4,
// fmt = ((channels-1)<<8) + DataDepth<channel_type>::fmt,
// type = CV_MAKETYPE(depth, channels) };
// typedef Vec<channel_type, channels> vec_type;
// };
//
// template<typename _Tp> class DataType<Scalar_<_Tp> >
// {
// public:
// typedef Scalar_<_Tp> value_type;
// typedef Scalar_<typename DataType<_Tp>::work_type> work_type;
// typedef _Tp channel_type;
// enum { generic_type = 0, depth = DataDepth<channel_type>::value, channels = 4,
// fmt = ((channels-1)<<8) + DataDepth<channel_type>::fmt,
// type = CV_MAKETYPE(depth, channels) };
// typedef Vec<channel_type, channels> vec_type;
// };
//
// template<> class DataType<Range>
// {
// public:
// typedef Range value_type;
// typedef value_type work_type;
// typedef int channel_type;
// enum { generic_type = 0, depth = DataDepth<channel_type>::value, channels = 2,
// fmt = ((channels-1)<<8) + DataDepth<channel_type>::fmt,
// type = CV_MAKETYPE(depth, channels) };
// typedef Vec<channel_type, channels> vec_type;
// };
//
/// /////////////////// generic_type ref-counting pointer class for C/C++ objects ////////////////////////
//
/// *!
// Smart pointer to dynamically allocated objects.
//
// This is template pointer-wrapping class that stores the associated reference counter along with the
// object pointer. The class is similar to std::smart_ptr<> from the recent addons to the C++ standard,
// but is shorter to write :) and self-contained (i.e. does add any dependency on the compiler or an external library).
//
// Basically, you can use "Ptr<MyObjectType> ptr" (or faster "const Ptr<MyObjectType>& ptr" for read-only access)
// everywhere instead of "MyObjectType* ptr", where MyObjectType is some C structure or a C++ class.
// To make it all work, you need to specialize Ptr<>::delete_obj(), like:
//
// \code
// template<> void Ptr<MyObjectType>::delete_obj() { call_destructor_func(obj); }
// \endcode
//
// \note{if MyObjectType is a C++ class with a destructor, you do not need to specialize delete_obj(),
// since the default implementation calls "delete obj;"}
//
// \note{Another good property of the class is that the operations on the reference counter are atomic,
// i.e. it is safe to use the class in multi-threaded applications}
// */
// template<typename _Tp> class CV_EXPORTS Ptr
// {
// public:
// //! empty constructor
// Ptr();
// //! take ownership of the pointer. The associated reference counter is allocated and set to 1
// Ptr(_Tp* _obj);
// //! calls release()
// ~Ptr();
// //! copy constructor. Copies the members and calls addref()
// Ptr(const Ptr& ptr);
// template<typename _Tp2> Ptr(const Ptr<_Tp2>& ptr);
// //! copy operator. Calls ptr.addref() and release() before copying the members
// Ptr& operator = (const Ptr& ptr);
// //! increments the reference counter
// void addref();
// //! decrements the reference counter. If it reaches 0, delete_obj() is called
// void release();
// //! deletes the object. Override if needed
// void delete_obj();
// //! returns true iff obj==NULL
// bool empty() const;
//
// //! cast pointer to another type
// template<typename _Tp2> Ptr<_Tp2> ptr();
// template<typename _Tp2> const Ptr<_Tp2> ptr() const;
//
// //! helper operators making "Ptr<T> ptr" use very similar to "T* ptr".
// _Tp* operator -> ();
// const _Tp* operator -> () const;
//
// operator _Tp* ();
// operator const _Tp*() const;
//
// _Tp* obj; //< the object pointer.
// int* refcount; //< the associated reference counter
// };
//
// template<class T, class U> bool operator==(Ptr<T> const & a, Ptr<U> const & b);
// template<class T, class U> bool operator!=(Ptr<T> const & a, Ptr<U> const & b);
//
//
/// /////////////////////// Input/Output Array Arguments /////////////////////////////////
//
/// *!
// Proxy datatype for passing Mat's and vector<>'s as input parameters
// */
// class CV_EXPORTS _InputArray
// {
// public:
// enum {
// KIND_SHIFT = 16,
// FIXED_TYPE = 0x8000 << KIND_SHIFT,
// FIXED_SIZE = 0x4000 << KIND_SHIFT,
// KIND_MASK = ~(FIXED_TYPE|FIXED_SIZE) - (1 << KIND_SHIFT) + 1,
//
// NONE              = 0 << KIND_SHIFT,
// MAT               = 1 << KIND_SHIFT,
// MATX              = 2 << KIND_SHIFT,
// STD_VECTOR        = 3 << KIND_SHIFT,
// STD_VECTOR_VECTOR = 4 << KIND_SHIFT,
// STD_VECTOR_MAT    = 5 << KIND_SHIFT,
// EXPR              = 6 << KIND_SHIFT,
// OPENGL_BUFFER     = 7 << KIND_SHIFT,
// OPENGL_TEXTURE    = 8 << KIND_SHIFT,
// GPU_MAT           = 9 << KIND_SHIFT
// };
// _InputArray();
//
// _InputArray(const Mat& m);
// _InputArray(const MatExpr& expr);
// template<typename _Tp> _InputArray(const _Tp* vec, int n);
// template<typename _Tp> _InputArray(const std::vector<_Tp>& vec);
// template<typename _Tp> _InputArray(const std::vector<std::vector<_Tp> >& vec);
// _InputArray(const std::vector<Mat>& vec);
// template<typename _Tp> _InputArray(const std::vector<Mat_<_Tp> >& vec);
// template<typename _Tp> _InputArray(const Mat_<_Tp>& m);
// template<typename _Tp, int m, int n> _InputArray(const Matx<_Tp, m, n>& matx);
// _InputArray(const Scalar& s);
// _InputArray(const double& val);
// _InputArray(const gpu::GpuMat& d_mat);
// _InputArray(const ogl::Buffer& buf);
// _InputArray(const ogl::Texture2D& tex);
//
// virtual Mat getMat(int i=-1) const;
// virtual void getMatVector(std::vector<Mat>& mv) const;
// virtual gpu::GpuMat getGpuMat() const;
// virtual ogl::Buffer getOGlBuffer() const;
// virtual ogl::Texture2D getOGlTexture2D() const;
//
// virtual int kind() const;
// virtual Size size(int i=-1) const;
// virtual size_t total(int i=-1) const;
// virtual int type(int i=-1) const;
// virtual int depth(int i=-1) const;
// virtual int channels(int i=-1) const;
// virtual bool empty() const;
//
// virtual ~_InputArray();
//
// int flags;
// void* obj;
// Size sz;
// };
//
//
// enum
// {
// DEPTH_MASK_8U = 1 << CV_8U,
// DEPTH_MASK_8S = 1 << CV_8S,
// DEPTH_MASK_16U = 1 << CV_16U,
// DEPTH_MASK_16S = 1 << CV_16S,
// DEPTH_MASK_32S = 1 << CV_32S,
// DEPTH_MASK_32F = 1 << CV_32F,
// DEPTH_MASK_64F = 1 << CV_64F,
// DEPTH_MASK_ALL = (DEPTH_MASK_64F<<1)-1,
// DEPTH_MASK_ALL_BUT_8S = DEPTH_MASK_ALL & ~DEPTH_MASK_8S,
// DEPTH_MASK_FLT = DEPTH_MASK_32F + DEPTH_MASK_64F
// };
//
//
/// *!
// Proxy datatype for passing Mat's and vector<>'s as input parameters
// */
// class CV_EXPORTS _OutputArray : public _InputArray
// {
// public:
// _OutputArray();
//
// _OutputArray(Mat& m);
// template<typename _Tp> _OutputArray(std::vector<_Tp>& vec);
// template<typename _Tp> _OutputArray(std::vector<std::vector<_Tp> >& vec);
// _OutputArray(std::vector<Mat>& vec);
// template<typename _Tp> _OutputArray(std::vector<Mat_<_Tp> >& vec);
// template<typename _Tp> _OutputArray(Mat_<_Tp>& m);
// template<typename _Tp, int m, int n> _OutputArray(Matx<_Tp, m, n>& matx);
// template<typename _Tp> _OutputArray(_Tp* vec, int n);
// _OutputArray(gpu::GpuMat& d_mat);
// _OutputArray(ogl::Buffer& buf);
// _OutputArray(ogl::Texture2D& tex);
//
// _OutputArray(const Mat& m);
// template<typename _Tp> _OutputArray(const std::vector<_Tp>& vec);
// template<typename _Tp> _OutputArray(const std::vector<std::vector<_Tp> >& vec);
// _OutputArray(const std::vector<Mat>& vec);
// template<typename _Tp> _OutputArray(const std::vector<Mat_<_Tp> >& vec);
// template<typename _Tp> _OutputArray(const Mat_<_Tp>& m);
// template<typename _Tp, int m, int n> _OutputArray(const Matx<_Tp, m, n>& matx);
// template<typename _Tp> _OutputArray(const _Tp* vec, int n);
// _OutputArray(const gpu::GpuMat& d_mat);
// _OutputArray(const ogl::Buffer& buf);
// _OutputArray(const ogl::Texture2D& tex);
//
// virtual bool fixedSize() const;
// virtual bool fixedType() const;
// virtual bool needed() const;
// virtual Mat& getMatRef(int i=-1) const;
// virtual gpu::GpuMat& getGpuMatRef() const;
// virtual ogl::Buffer& getOGlBufferRef() const;
// virtual ogl::Texture2D& getOGlTexture2DRef() const;
// virtual void create(Size sz, int type, int i=-1, bool allowTransposed=false, int fixedDepthMask=0) const;
// virtual void create(int rows, int cols, int type, int i=-1, bool allowTransposed=false, int fixedDepthMask=0) const;
// virtual void create(int dims, const int* size, int type, int i=-1, bool allowTransposed=false, int fixedDepthMask=0) const;
// virtual void release() const;
// virtual void clear() const;
//
// virtual ~_OutputArray();
// };
//
// typedef const _InputArray& InputArray;
// typedef InputArray InputArrayOfArrays;
// typedef const _OutputArray& OutputArray;
// typedef OutputArray OutputArrayOfArrays;
// typedef OutputArray InputOutputArray;
// typedef OutputArray InputOutputArrayOfArrays;
//
// CV_EXPORTS OutputArray noArray();
//
/// ////////////////////////////////////// Mat ///////////////////////////////////////////
//
// enum { MAGIC_MASK=0xFFFF0000, TYPE_MASK=0x00000FFF, DEPTH_MASK=7 };
//
/// *!
// Custom array allocator
//
// */
// class CV_EXPORTS MatAllocator
// {
// public:
// MatAllocator() {}
// virtual ~MatAllocator() {}
// virtual void allocate(int dims, const int* sizes, int type, int*& refcount,
// uchar*& datastart, uchar*& data, size_t* step) = 0;
// virtual void deallocate(int* refcount, uchar* datastart, uchar* data) = 0;
// };
//
/// *!
// The n-dimensional matrix class.
//
// The class represents an n-dimensional dense numerical array that can act as
// a matrix, image, optical flow map, 3-focal tensor etc.
// It is very similar to CvMat and CvMatND types from earlier versions of OpenCV,
// and similarly to those types, the matrix can be multi-channel. It also fully supports ROI mechanism.
//
// There are many different ways to create cv::Mat object. Here are the some popular ones:
// <ul>
// <li> using cv::Mat::create(nrows, ncols, type) method or
// the similar constructor cv::Mat::Mat(nrows, ncols, type[, fill_value]) constructor.
// A new matrix of the specified size and specifed type will be allocated.
// "type" has the same meaning as in cvCreateMat function,
// e.g. CV_8UC1 means 8-bit single-channel matrix, CV_32FC2 means 2-channel (i.e. complex)
// floating-point matrix etc:
//
// \code
// // make 7x7 complex matrix filled with 1+3j.
// cv::Mat M(7,7,CV_32FC2,Scalar(1,3));
// // and now turn M to 100x60 15-channel 8-bit matrix.
// // The old content will be deallocated
// M.create(100,60,CV_8UC(15));
// \endcode
//
// As noted in the introduction of this chapter, Mat::create()
// will only allocate a new matrix when the current matrix dimensionality
// or type are different from the specified.
//
// <li> by using a copy constructor or assignment operator, where on the right side it can
// be a matrix or expression, see below. Again, as noted in the introduction,
// matrix assignment is O(1) operation because it only copies the header
// and increases the reference counter. cv::Mat::clone() method can be used to get a full
// (a.k.a. deep) copy of the matrix when you need it.
//
// <li> by constructing a header for a part of another matrix. It can be a single row, single column,
// several rows, several columns, rectangular region in the matrix (called a minor in algebra) or
// a diagonal. Such operations are also O(1), because the new header will reference the same data.
// You can actually modify a part of the matrix using this feature, e.g.
//
// \code
// // add 5-th row, multiplied by 3 to the 3rd row
// M.row(3) = M.row(3) + M.row(5)*3;
//
// // now copy 7-th column to the 1-st column
// // M.col(1) = M.col(7); // this will not work
// Mat M1 = M.col(1);
// M.col(7).copyTo(M1);
//
// // create new 320x240 image
// cv::Mat img(Size(320,240),CV_8UC3);
// // select a roi
// cv::Mat roi(img, Rect(10,10,100,100));
// // fill the ROI with (0,255,0) (which is green in RGB space);
// // the original 320x240 image will be modified
// roi = Scalar(0,255,0);
// \endcode
//
// Thanks to the additional cv::Mat::datastart and cv::Mat::dataend members, it is possible to
// compute the relative sub-matrix position in the main "container" matrix using cv::Mat::locateROI():
//
// \code
// Mat A = Mat::eye(10, 10, CV_32S);
// // extracts A columns, 1 (inclusive) to 3 (exclusive).
// Mat B = A(Range::all(), Range(1, 3));
// // extracts B rows, 5 (inclusive) to 9 (exclusive).
// // that is, C ~ A(Range(5, 9), Range(1, 3))
// Mat C = B(Range(5, 9), Range::all());
// Size size; Point ofs;
// C.locateROI(size, ofs);
// // size will be (width=10,height=10) and the ofs will be (x=1, y=5)
// \endcode
//
// As in the case of whole matrices, if you need a deep copy, use cv::Mat::clone() method
// of the extracted sub-matrices.
//
// <li> by making a header for user-allocated-data. It can be useful for
// <ol>
// <li> processing "foreign" data using OpenCV (e.g. when you implement
// a DirectShow filter or a processing module for gstreamer etc.), e.g.
//
// \code
// void process_video_frame(const unsigned char* pixels,
// int width, int height, int step)
// {
// cv::Mat img(height, width, CV_8UC3, pixels, step);
// cv::GaussianBlur(img, img, cv::Size(7,7), 1.5, 1.5);
// }
// \endcode
//
// <li> for quick initialization of small matrices and/or super-fast element access
//
// \code
// double m[3][3] = {{a, b, c}, {d, e, f}, {g, h, i}};
// cv::Mat M = cv::Mat(3, 3, CV_64F, m).inv();
// \endcode
// </ol>
//
// partial yet very common cases of this "user-allocated data" case are conversions
// from CvMat and IplImage to cv::Mat. For this purpose there are special constructors
// taking pointers to CvMat or IplImage and the optional
// flag indicating whether to copy the data or not.
//
// Backward conversion from cv::Mat to CvMat or IplImage is provided via cast operators
// cv::Mat::operator CvMat() an cv::Mat::operator IplImage().
// The operators do not copy the data.
//
//
// \code
// IplImage* img = cvLoadImage("greatwave.jpg", 1);
// Mat mtx(img); // convert IplImage* -> cv::Mat
// CvMat oldmat = mtx; // convert cv::Mat -> CvMat
// CV_Assert(oldmat.cols == img->width && oldmat.rows == img->height &&
// oldmat.data.ptr == (uchar*)img->imageData && oldmat.step == img->widthStep);
// \endcode
//
// <li> by using MATLAB-style matrix initializers, cv::Mat::zeros(), cv::Mat::ones(), cv::Mat::eye(), e.g.:
//
// \code
// // create a double-precision identity martix and add it to M.
// M += Mat::eye(M.rows, M.cols, CV_64F);
// \endcode
//
// <li> by using comma-separated initializer:
//
// \code
// // create 3x3 double-precision identity matrix
// Mat M = (Mat_<double>(3,3) << 1, 0, 0, 0, 1, 0, 0, 0, 1);
// \endcode
//
// here we first call constructor of cv::Mat_ class (that we describe further) with the proper matrix,
// and then we just put "<<" operator followed by comma-separated values that can be constants,
// variables, expressions etc. Also, note the extra parentheses that are needed to avoid compiler errors.
//
// </ul>
//
// Once matrix is created, it will be automatically managed by using reference-counting mechanism
// (unless the matrix header is built on top of user-allocated data,
// in which case you should handle the data by yourself).
// The matrix data will be deallocated when no one points to it;
// if you want to release the data pointed by a matrix header before the matrix destructor is called,
// use cv::Mat::release().
//
// The next important thing to learn about the matrix class is element access. Here is how the matrix is stored.
// The elements are stored in row-major order (row by row). The cv::Mat::data member points to the first element of the first row,
// cv::Mat::rows contains the number of matrix rows and cv::Mat::cols - the number of matrix columns. There is yet another member,
// cv::Mat::step that is used to actually compute address of a matrix element. cv::Mat::step is needed because the matrix can be
// a part of another matrix or because there can some padding space in the end of each row for a proper alignment.
//
// \image html roi.png
//
// Given these parameters, address of the matrix element M_{ij} is computed as following:
//
// addr(M_{ij})=M.data + M.step*i + j*M.elemSize()
//
// if you know the matrix element type, e.g. it is float, then you can use cv::Mat::at() method:
//
// addr(M_{ij})=&M.at<float>(i,j)
//
// (where & is used to convert the reference returned by cv::Mat::at() to a pointer).
// if you need to process a whole row of matrix, the most efficient way is to get
// the pointer to the row first, and then just use plain C operator []:
//
// \code
// // compute sum of positive matrix elements
// // (assuming that M is double-precision matrix)
// double sum=0;
// for(int i = 0; i < M.rows; i++)
// {
// const double* Mi = M.ptr<double>(i);
// for(int j = 0; j < M.cols; j++)
// sum += std::max(Mi[j], 0.);
// }
// \endcode
//
// Some operations, like the above one, do not actually depend on the matrix shape,
// they just process elements of a matrix one by one (or elements from multiple matrices
// that are sitting in the same place, e.g. matrix addition). Such operations are called
// element-wise and it makes sense to check whether all the input/output matrices are continuous,
// i.e. have no gaps in the end of each row, and if yes, process them as a single long row:
//
// \code
// // compute sum of positive matrix elements, optimized variant
// double sum=0;
// int cols = M.cols, rows = M.rows;
// if(M.isContinuous())
// {
// cols *= rows;
// rows = 1;
// }
// for(int i = 0; i < rows; i++)
// {
// const double* Mi = M.ptr<double>(i);
// for(int j = 0; j < cols; j++)
// sum += std::max(Mi[j], 0.);
// }
// \endcode
// in the case of continuous matrix the outer loop body will be executed just once,
// so the overhead will be smaller, which will be especially noticeable in the case of small matrices.
//
// Finally, there are STL-style iterators that are smart enough to skip gaps between successive rows:
// \code
// // compute sum of positive matrix elements, iterator-based variant
// double sum=0;
// MatConstIterator_<double> it = M.begin<double>(), it_end = M.end<double>();
// for(; it != it_end; ++it)
// sum += std::max(*it, 0.);
// \endcode
//
// The matrix iterators are random-access iterators, so they can be passed
// to any STL algorithm, including std::sort().
// */
// class CV_EXPORTS Mat
// {
// public:
// //! default constructor
// Mat();
// //! constructs 2D matrix of the specified size and type
// // (_type is CV_8UC1, CV_64FC3, CV_32SC(12) etc.)
// Mat(int rows, int cols, int type);
// Mat(Size size, int type);
// //! constucts 2D matrix and fills it with the specified value _s.
// Mat(int rows, int cols, int type, const Scalar& s);
// Mat(Size size, int type, const Scalar& s);
//
// //! constructs n-dimensional matrix
// Mat(int ndims, const int* sizes, int type);
// Mat(int ndims, const int* sizes, int type, const Scalar& s);
//
// //! copy constructor
// Mat(const Mat& m);
// //! constructor for matrix headers pointing to user-allocated data
// Mat(int rows, int cols, int type, void* data, size_t step=AUTO_STEP);
// Mat(Size size, int type, void* data, size_t step=AUTO_STEP);
// Mat(int ndims, const int* sizes, int type, void* data, const size_t* steps=0);
//
// //! creates a matrix header for a part of the bigger matrix
// Mat(const Mat& m, const Range& rowRange, const Range& colRange=Range::all());
// Mat(const Mat& m, const Rect& roi);
// Mat(const Mat& m, const Range* ranges);
// //! converts old-style CvMat to the new matrix; the data is not copied by default
// Mat(const CvMat* m, bool copyData=false);
// //! converts old-style CvMatND to the new matrix; the data is not copied by default
// Mat(const CvMatND* m, bool copyData=false);
// //! converts old-style IplImage to the new matrix; the data is not copied by default
// Mat(const IplImage* img, bool copyData=false);
// //! builds matrix from std::vector with or without copying the data
// template<typename _Tp> explicit Mat(const std::vector<_Tp>& vec, bool copyData=false);
// //! builds matrix from cv::Vec; the data is copied by default
// template<typename _Tp, int n> explicit Mat(const Vec<_Tp, n>& vec, bool copyData=true);
// //! builds matrix from cv::Matx; the data is copied by default
// template<typename _Tp, int m, int n> explicit Mat(const Matx<_Tp, m, n>& mtx, bool copyData=true);
// //! builds matrix from a 2D point
// template<typename _Tp> explicit Mat(const Point_<_Tp>& pt, bool copyData=true);
// //! builds matrix from a 3D point
// template<typename _Tp> explicit Mat(const Point3_<_Tp>& pt, bool copyData=true);
// //! builds matrix from comma initializer
// template<typename _Tp> explicit Mat(const MatCommaInitializer_<_Tp>& commaInitializer);
//
// //! download data from GpuMat
// explicit Mat(const gpu::GpuMat& m);
//
// //! destructor - calls release()
// ~Mat();
// //! assignment operators
// Mat& operator = (const Mat& m);
// Mat& operator = (const MatExpr& expr);
//
// //! returns a new matrix header for the specified row
// Mat row(int y) const;
// //! returns a new matrix header for the specified column
// Mat col(int x) const;
// //! ... for the specified row span
// Mat rowRange(int startrow, int endrow) const;
// Mat rowRange(const Range& r) const;
// //! ... for the specified column span
// Mat colRange(int startcol, int endcol) const;
// Mat colRange(const Range& r) const;
// //! ... for the specified diagonal
// // (d=0 - the main diagonal,
// //  >0 - a diagonal from the lower half,
// //  <0 - a diagonal from the upper half)
// Mat diag(int d=0) const;
// //! constructs a square diagonal matrix which main diagonal is vector "d"
// static Mat diag(const Mat& d);
//
// //! returns deep copy of the matrix, i.e. the data is copied
// Mat clone() const;
// //! copies the matrix content to "m".
// // It calls m.create(this->size(), this->type()).
// void copyTo( OutputArray m ) const;
// //! copies those matrix elements to "m" that are marked with non-zero mask elements.
// void copyTo( OutputArray m, InputArray mask ) const;
// //! converts matrix to another datatype with optional scalng. See cvConvertScale.
// void convertTo( OutputArray m, int rtype, double alpha=1, double beta=0 ) const;
//
// void assignTo( Mat& m, int type=-1 ) const;
//
// //! sets every matrix element to s
// Mat& operator = (const Scalar& s);
// //! sets some of the matrix elements to s, according to the mask
// Mat& setTo(InputArray value, InputArray mask=noArray());
// //! creates alternative matrix header for the same data, with different
// // number of channels and/or different number of rows. see cvReshape.
// Mat reshape(int cn, int rows=0) const;
// Mat reshape(int cn, int newndims, const int* newsz) const;
//
// //! matrix transposition by means of matrix expressions
// MatExpr t() const;
// //! matrix inversion by means of matrix expressions
// MatExpr inv(int method=DECOMP_LU) const;
// //! per-element matrix multiplication by means of matrix expressions
// MatExpr mul(InputArray m, double scale=1) const;
//
// //! computes cross-product of 2 3D vectors
// Mat cross(InputArray m) const;
// //! computes dot-product
// double dot(InputArray m) const;
//
// //! Matlab-style matrix initialization
// static MatExpr zeros(int rows, int cols, int type);
// static MatExpr zeros(Size size, int type);
// static MatExpr zeros(int ndims, const int* sz, int type);
// static MatExpr ones(int rows, int cols, int type);
// static MatExpr ones(Size size, int type);
// static MatExpr ones(int ndims, const int* sz, int type);
// static MatExpr eye(int rows, int cols, int type);
// static MatExpr eye(Size size, int type);
//
// //! allocates new matrix data unless the matrix already has specified size and type.
// // previous data is unreferenced if needed.
// void create(int rows, int cols, int type);
// void create(Size size, int type);
// void create(int ndims, const int* sizes, int type);
//
// //! increases the reference counter; use with care to avoid memleaks
// void addref();
// //! decreases reference counter;
// // deallocates the data when reference counter reaches 0.
// void release();
//
// //! deallocates the matrix data
// void deallocate();
// //! internal use function; properly re-allocates _size, _step arrays
// void copySize(const Mat& m);
//
// //! reserves enough space to fit sz hyper-planes
// void reserve(size_t sz);
// //! resizes matrix to the specified number of hyper-planes
// void resize(size_t sz);
// //! resizes matrix to the specified number of hyper-planes; initializes the newly added elements
// void resize(size_t sz, const Scalar& s);
// //! internal function
// void push_back_(const void* elem);
// //! adds element to the end of 1d matrix (or possibly multiple elements when _Tp=Mat)
// template<typename _Tp> void push_back(const _Tp& elem);
// template<typename _Tp> void push_back(const Mat_<_Tp>& elem);
// void push_back(const Mat& m);
// //! removes several hyper-planes from bottom of the matrix
// void pop_back(size_t nelems=1);
//
// //! locates matrix header within a parent matrix. See below
// void locateROI( Size& wholeSize, Point& ofs ) const;
// //! moves/resizes the current matrix ROI inside the parent matrix.
// Mat& adjustROI( int dtop, int dbottom, int dleft, int dright );
// //! extracts a rectangular sub-matrix
// // (this is a generalized form of row, rowRange etc.)
// Mat operator()( Range rowRange, Range colRange ) const;
// Mat operator()( const Rect& roi ) const;
// Mat operator()( const Range* ranges ) const;
//
// //! converts header to CvMat; no data is copied
// operator CvMat() const;
// //! converts header to CvMatND; no data is copied
// operator CvMatND() const;
// //! converts header to IplImage; no data is copied
// operator IplImage() const;
//
// template<typename _Tp> operator std::vector<_Tp>() const;
// template<typename _Tp, int n> operator Vec<_Tp, n>() const;
// template<typename _Tp, int m, int n> operator Matx<_Tp, m, n>() const;
//
// //! returns true iff the matrix data is continuous
// // (i.e. when there are no gaps between successive rows).
// // similar to CV_IS_MAT_CONT(cvmat->type)
// bool isContinuous() const;
//
// //! returns true if the matrix is a submatrix of another matrix
// bool isSubmatrix() const;
//
// //! returns element size in bytes,
// // similar to CV_ELEM_SIZE(cvmat->type)
// size_t elemSize() const;
// //! returns the size of element channel in bytes.
// size_t elemSize1() const;
// //! returns element type, similar to CV_MAT_TYPE(cvmat->type)
// int type() const;
// //! returns element type, similar to CV_MAT_DEPTH(cvmat->type)
// int depth() const;
// //! returns element type, similar to CV_MAT_CN(cvmat->type)
// int channels() const;
// //! returns step/elemSize1()
// size_t step1(int i=0) const;
// //! returns true if matrix data is NULL
// bool empty() const;
// //! returns the total number of matrix elements
// size_t total() const;
//
// //! returns N if the matrix is 1-channel (N x ptdim) or ptdim-channel (1 x N) or (N x 1); negative number otherwise
// int checkVector(int elemChannels, int depth=-1, bool requireContinuous=true) const;
//
// //! returns pointer to i0-th submatrix along the dimension #0
// uchar* ptr(int i0=0);
// const uchar* ptr(int i0=0) const;
//
// //! returns pointer to (i0,i1) submatrix along the dimensions #0 and #1
// uchar* ptr(int i0, int i1);
// const uchar* ptr(int i0, int i1) const;
//
// //! returns pointer to (i0,i1,i3) submatrix along the dimensions #0, #1, #2
// uchar* ptr(int i0, int i1, int i2);
// const uchar* ptr(int i0, int i1, int i2) const;
//
// //! returns pointer to the matrix element
// uchar* ptr(const int* idx);
// //! returns read-only pointer to the matrix element
// const uchar* ptr(const int* idx) const;
//
// template<int n> uchar* ptr(const Vec<int, n>& idx);
// template<int n> const uchar* ptr(const Vec<int, n>& idx) const;
//
// //! template version of the above method
// template<typename _Tp> _Tp* ptr(int i0=0);
// template<typename _Tp> const _Tp* ptr(int i0=0) const;
//
// template<typename _Tp> _Tp* ptr(int i0, int i1);
// template<typename _Tp> const _Tp* ptr(int i0, int i1) const;
//
// template<typename _Tp> _Tp* ptr(int i0, int i1, int i2);
// template<typename _Tp> const _Tp* ptr(int i0, int i1, int i2) const;
//
// template<typename _Tp> _Tp* ptr(const int* idx);
// template<typename _Tp> const _Tp* ptr(const int* idx) const;
//
// template<typename _Tp, int n> _Tp* ptr(const Vec<int, n>& idx);
// template<typename _Tp, int n> const _Tp* ptr(const Vec<int, n>& idx) const;
//
// //! the same as above, with the pointer dereferencing
// template<typename _Tp> _Tp& at(int i0=0);
// template<typename _Tp> const _Tp& at(int i0=0) const;
//
// template<typename _Tp> _Tp& at(int i0, int i1);
// template<typename _Tp> const _Tp& at(int i0, int i1) const;
//
// template<typename _Tp> _Tp& at(int i0, int i1, int i2);
// template<typename _Tp> const _Tp& at(int i0, int i1, int i2) const;
//
// template<typename _Tp> _Tp& at(const int* idx);
// template<typename _Tp> const _Tp& at(const int* idx) const;
//
// template<typename _Tp, int n> _Tp& at(const Vec<int, n>& idx);
// template<typename _Tp, int n> const _Tp& at(const Vec<int, n>& idx) const;
//
// //! special versions for 2D arrays (especially convenient for referencing image pixels)
// template<typename _Tp> _Tp& at(Point pt);
// template<typename _Tp> const _Tp& at(Point pt) const;
//
// //! template methods for iteration over matrix elements.
// // the iterators take care of skipping gaps in the end of rows (if any)
// template<typename _Tp> MatIterator_<_Tp> begin();
// template<typename _Tp> MatIterator_<_Tp> end();
// template<typename _Tp> MatConstIterator_<_Tp> begin() const;
// template<typename _Tp> MatConstIterator_<_Tp> end() const;
//
// enum { MAGIC_VAL=0x42FF0000, AUTO_STEP=0, CONTINUOUS_FLAG=CV_MAT_CONT_FLAG, SUBMATRIX_FLAG=CV_SUBMAT_FLAG };
//
// /*! includes several bit-fields:
// - the magic signature
// - continuity flag
// - depth
// - number of channels
// */
// int flags;
// //! the matrix dimensionality, >= 2
// int dims;
// //! the number of rows and columns or (-1, -1) when the matrix has more than 2 dimensions
// int rows, cols;
// //! pointer to the data
// uchar* data;
//
// //! pointer to the reference counter;
// // when matrix points to user-allocated data, the pointer is NULL
// int* refcount;
//
// //! helper fields used in locateROI and adjustROI
// uchar* datastart;
// uchar* dataend;
// uchar* datalimit;
//
// //! custom allocator
// MatAllocator* allocator;
//
// struct CV_EXPORTS MSize
// {
// MSize(int* _p);
// Size operator()() const;
// const int& operator[](int i) const;
// int& operator[](int i);
// operator const int*() const;
// bool operator == (const MSize& sz) const;
// bool operator != (const MSize& sz) const;
//
// int* p;
// };
//
// struct CV_EXPORTS MStep
// {
// MStep();
// MStep(size_t s);
// const size_t& operator[](int i) const;
// size_t& operator[](int i);
// operator size_t() const;
// MStep& operator = (size_t s);
//
// size_t* p;
// size_t buf[2];
// protected:
// MStep& operator = (const MStep&);
// };
//
// MSize size;
// MStep step;
//
// protected:
// void initEmpty();
// };
//
//
/// *!
// Random Number Generator
//
// The class implements RNG using Multiply-with-Carry algorithm
// */
// class CV_EXPORTS RNG
// {
// public:
// enum { UNIFORM=0, NORMAL=1 };
//
// RNG();
// RNG(uint64 state);
// //! updates the state and returns the next 32-bit unsigned integer random number
// unsigned next();
//
// operator uchar();
// operator schar();
// operator ushort();
// operator short();
// operator unsigned();
// //! returns a random integer sampled uniformly from [0, N).
// unsigned operator ()(unsigned N);
// unsigned operator ()();
// operator int();
// operator float();
// operator double();
// //! returns uniformly distributed integer random number from [a,b) range
// int uniform(int a, int b);
// //! returns uniformly distributed floating-point random number from [a,b) range
// float uniform(float a, float b);
// //! returns uniformly distributed double-precision floating-point random number from [a,b) range
// double uniform(double a, double b);
// void fill( InputOutputArray mat, int distType, InputArray a, InputArray b, bool saturateRange=false );
// //! returns Gaussian random variate with mean zero.
// double gaussian(double sigma);
//
// uint64 state;
// };
//
// class CV_EXPORTS RNG_MT19937
// {
// public:
// RNG_MT19937();
// RNG_MT19937(unsigned s);
// void seed(unsigned s);
//
// unsigned next();
//
// operator int();
// operator unsigned();
// operator float();
// operator double();
//
// unsigned operator ()(unsigned N);
// unsigned operator ()();
//
// // returns uniformly distributed integer random number from [a,b) range
// int uniform(int a, int b);
// // returns uniformly distributed floating-point random number from [a,b) range
// float uniform(float a, float b);
// // returns uniformly distributed double-precision floating-point random number from [a,b) range
// double uniform(double a, double b);
//
// private:
// enum PeriodParameters {N = 624, M = 397};
// unsigned state[N];
// int mti;
// };
//
/// *!
// Termination criteria in iterative algorithms
// */
// class CV_EXPORTS TermCriteria
// {
// public:
// enum
// {
// COUNT=1, //!< the maximum number of iterations or elements to compute
// MAX_ITER=COUNT, //!< ditto
// EPS=2 //!< the desired accuracy or change in parameters at which the iterative algorithm stops
// };
//
// //! default constructor
// TermCriteria();
// //! full constructor
// TermCriteria(int type, int maxCount, double epsilon);
// //! conversion from CvTermCriteria
// TermCriteria(const CvTermCriteria& criteria);
// //! conversion to CvTermCriteria
// operator CvTermCriteria() const;
//
// int type; //!< the type of termination criteria: COUNT, EPS or COUNT + EPS
// int maxCount; // the maximum number of iterations/elements
// double epsilon; // the desired accuracy
// };
//
//
// typedef void (*BinaryFunc)(const uchar* src1, size_t step1,
// const uchar* src2, size_t step2,
// uchar* dst, size_t step, Size sz,
// void*);
//
// CV_EXPORTS BinaryFunc getConvertFunc(int sdepth, int ddepth);
// CV_EXPORTS BinaryFunc getConvertScaleFunc(int sdepth, int ddepth);
// CV_EXPORTS BinaryFunc getCopyMaskFunc(size_t esz);
//
/// /! swaps two matrices
// CV_EXPORTS void swap(Mat& a, Mat& b);
//
/// /! extracts Channel of Interest from CvMat or IplImage and makes cv::Mat out of it.
// CV_EXPORTS void extractImageCOI(const CvArr* arr, OutputArray coiimg, int coi=-1);
/// /! inserts single-channel cv::Mat into a multi-channel CvMat or IplImage
// CV_EXPORTS void insertImageCOI(InputArray coiimg, CvArr* arr, int coi=-1);
//
/// /! adds one matrix to another (dst = src1 + src2)
// CV_EXPORTS_W void add(InputArray src1, InputArray src2, OutputArray dst,
// InputArray mask=noArray(), int dtype=-1);
/// /! subtracts one matrix from another (dst = src1 - src2)
// CV_EXPORTS_W void subtract(InputArray src1, InputArray src2, OutputArray dst,
// InputArray mask=noArray(), int dtype=-1);
//
/// /! computes element-wise weighted product of the two arrays (dst = scale*src1*src2)
// CV_EXPORTS_W void multiply(InputArray src1, InputArray src2,
// OutputArray dst, double scale=1, int dtype=-1);
//
/// /! computes element-wise weighted quotient of the two arrays (dst = scale*src1/src2)
// CV_EXPORTS_W void divide(InputArray src1, InputArray src2, OutputArray dst,
// double scale=1, int dtype=-1);
//
/// /! computes element-wise weighted reciprocal of an array (dst = scale/src2)
// CV_EXPORTS_W void divide(double scale, InputArray src2,
// OutputArray dst, int dtype=-1);
//
/// /! adds scaled array to another one (dst = alpha*src1 + src2)
// CV_EXPORTS_W void scaleAdd(InputArray src1, double alpha, InputArray src2, OutputArray dst);
//
/// /! computes weighted sum of two arrays (dst = alpha*src1 + beta*src2 + gamma)
// CV_EXPORTS_W void addWeighted(InputArray src1, double alpha, InputArray src2,
// double beta, double gamma, OutputArray dst, int dtype=-1);
//
/// /! scales array elements, computes absolute values and converts the results to 8-bit unsigned integers: dst(i)=saturate_cast<uchar>abs(src(i)*alpha+beta)
// CV_EXPORTS_W void convertScaleAbs(InputArray src, OutputArray dst,
// double alpha=1, double beta=0);
/// /! transforms array of numbers using a lookup table: dst(i)=lut(src(i))
// CV_EXPORTS_W void LUT(InputArray src, InputArray lut, OutputArray dst,
// int interpolation=0);
//
/// /! computes sum of array elements
// CV_EXPORTS_AS(sumElems) Scalar sum(InputArray src);
/// /! computes the number of nonzero array elements
// CV_EXPORTS_W int countNonZero( InputArray src );
/// /! returns the list of locations of non-zero pixels
// CV_EXPORTS_W void findNonZero( InputArray src, OutputArray idx );
//
/// /! computes mean value of selected array elements
// CV_EXPORTS_W Scalar mean(InputArray src, InputArray mask=noArray());
/// /! computes mean value and standard deviation of all or selected array elements
// CV_EXPORTS_W void meanStdDev(InputArray src, OutputArray mean, OutputArray stddev,
// InputArray mask=noArray());
/// /! computes norm of the selected array part
// CV_EXPORTS_W double norm(InputArray src1, int normType=NORM_L2, InputArray mask=noArray());
/// /! computes norm of selected part of the difference between two arrays
// CV_EXPORTS_W double norm(InputArray src1, InputArray src2,
// int normType=NORM_L2, InputArray mask=noArray());
//
/// /! naive nearest neighbor finder
// CV_EXPORTS_W void batchDistance(InputArray src1, InputArray src2,
// OutputArray dist, int dtype, OutputArray nidx,
// int normType=NORM_L2, int K=0,
// InputArray mask=noArray(), int update=0,
// bool crosscheck=false);
//
/// /! scales and shifts array elements so that either the specified norm (alpha) or the minimum (alpha) and maximum (beta) array values get the specified values
// CV_EXPORTS_W void normalize( InputArray src, OutputArray dst, double alpha=1, double beta=0,
// int norm_type=NORM_L2, int dtype=-1, InputArray mask=noArray());
//
/// /! finds global minimum and maximum array elements and returns their values and their locations
// CV_EXPORTS_W void minMaxLoc(InputArray src, CV_OUT double* minVal,
// CV_OUT double* maxVal=0, CV_OUT Point* minLoc=0,
// CV_OUT Point* maxLoc=0, InputArray mask=noArray());
// CV_EXPORTS void minMaxIdx(InputArray src, double* minVal, double* maxVal,
// int* minIdx=0, int* maxIdx=0, InputArray mask=noArray());
//
/// /! transforms 2D matrix to 1D row or column vector by taking sum, minimum, maximum or mean value over all the rows
// CV_EXPORTS_W void reduce(InputArray src, OutputArray dst, int dim, int rtype, int dtype=-1);
//
/// /! makes multi-channel array out of several single-channel arrays
// CV_EXPORTS void merge(const Mat* mv, size_t count, OutputArray dst);
/// /! makes multi-channel array out of several single-channel arrays
// CV_EXPORTS_W void merge(InputArrayOfArrays mv, OutputArray dst);
//
/// /! copies each plane of a multi-channel array to a dedicated array
// CV_EXPORTS void split(const Mat& src, Mat* mvbegin);
/// /! copies each plane of a multi-channel array to a dedicated array
// CV_EXPORTS_W void split(InputArray m, OutputArrayOfArrays mv);
//
/// /! copies selected channels from the input arrays to the selected channels of the output arrays
// CV_EXPORTS void mixChannels(const Mat* src, size_t nsrcs, Mat* dst, size_t ndsts,
// const int* fromTo, size_t npairs);
// CV_EXPORTS void mixChannels(const std::vector<Mat>& src, std::vector<Mat>& dst,
// const int* fromTo, size_t npairs);
// CV_EXPORTS_W void mixChannels(InputArrayOfArrays src, InputArrayOfArrays dst,
// const std::vector<int>& fromTo);
//
/// /! extracts a single channel from src (coi is 0-based index)
// CV_EXPORTS_W void extractChannel(InputArray src, OutputArray dst, int coi);
//
/// /! inserts a single channel to dst (coi is 0-based index)
// CV_EXPORTS_W void insertChannel(InputArray src, InputOutputArray dst, int coi);
//
/// /! reverses the order of the rows, columns or both in a matrix
// CV_EXPORTS_W void flip(InputArray src, OutputArray dst, int flipCode);
//
/// /! replicates the input matrix the specified number of times in the horizontal and/or vertical direction
// CV_EXPORTS_W void repeat(InputArray src, int ny, int nx, OutputArray dst);
// CV_EXPORTS Mat repeat(const Mat& src, int ny, int nx);
//
// CV_EXPORTS void hconcat(const Mat* src, size_t nsrc, OutputArray dst);
// CV_EXPORTS void hconcat(InputArray src1, InputArray src2, OutputArray dst);
// CV_EXPORTS_W void hconcat(InputArrayOfArrays src, OutputArray dst);
//
// CV_EXPORTS void vconcat(const Mat* src, size_t nsrc, OutputArray dst);
// CV_EXPORTS void vconcat(InputArray src1, InputArray src2, OutputArray dst);
// CV_EXPORTS_W void vconcat(InputArrayOfArrays src, OutputArray dst);
//
/// /! computes bitwise conjunction of the two arrays (dst = src1 & src2)
// CV_EXPORTS_W void bitwise_and(InputArray src1, InputArray src2,
// OutputArray dst, InputArray mask=noArray());
/// /! computes bitwise disjunction of the two arrays (dst = src1 | src2)
// CV_EXPORTS_W void bitwise_or(InputArray src1, InputArray src2,
// OutputArray dst, InputArray mask=noArray());
/// /! computes bitwise exclusive-or of the two arrays (dst = src1 ^ src2)
// CV_EXPORTS_W void bitwise_xor(InputArray src1, InputArray src2,
// OutputArray dst, InputArray mask=noArray());
/// /! inverts each bit of array (dst = ~src)
// CV_EXPORTS_W void bitwise_not(InputArray src, OutputArray dst,
// InputArray mask=noArray());

// static BinaryFunc absdiffTab[] =
// {
// (BinaryFunc)GET_OPTIMIZED(absdiff8u), (BinaryFunc)GET_OPTIMIZED(absdiff8s),
// (BinaryFunc)GET_OPTIMIZED(absdiff16u), (BinaryFunc)GET_OPTIMIZED(absdiff16s),
// (BinaryFunc)GET_OPTIMIZED(absdiff32s),
// (BinaryFunc)GET_OPTIMIZED(absdiff32f), (BinaryFunc)absdiff64f,
// 0
// };

// ! computes element-wise absolute difference of two arrays (dst = abs(src1 - src2))
// CV_EXPORTS_W void absdiff(InputArray src1, InputArray src2, OutputArray dst);
procedure absdiff(src1: pIplImage; src2: pIplImage; dst: pIplImage);

/// /! set mask elements for those array elements which are within the element-specific bounding box (dst = lowerb <= src && src < upperb)
// CV_EXPORTS_W void inRange(InputArray src, InputArray lowerb,
// InputArray upperb, OutputArray dst);
/// /! compares elements of two arrays (dst = src1 <cmpop> src2)
// CV_EXPORTS_W void compare(InputArray src1, InputArray src2, OutputArray dst, int cmpop);
/// /! computes per-element minimum of two arrays (dst = min(src1, src2))
// CV_EXPORTS_W void min(InputArray src1, InputArray src2, OutputArray dst);
/// /! computes per-element maximum of two arrays (dst = max(src1, src2))
// CV_EXPORTS_W void max(InputArray src1, InputArray src2, OutputArray dst);
//
/// /! computes per-element minimum of two arrays (dst = min(src1, src2))
// CV_EXPORTS void min(const Mat& src1, const Mat& src2, Mat& dst);
/// /! computes per-element minimum of array and scalar (dst = min(src1, src2))
// CV_EXPORTS void min(const Mat& src1, double src2, Mat& dst);
/// /! computes per-element maximum of two arrays (dst = max(src1, src2))
// CV_EXPORTS void max(const Mat& src1, const Mat& src2, Mat& dst);
/// /! computes per-element maximum of array and scalar (dst = max(src1, src2))
// CV_EXPORTS void max(const Mat& src1, double src2, Mat& dst);
//
/// /! computes square root of each matrix element (dst = src**0.5)
// CV_EXPORTS_W void sqrt(InputArray src, OutputArray dst);
/// /! raises the input matrix elements to the specified power (b = a**power)
// CV_EXPORTS_W void pow(InputArray src, double power, OutputArray dst);
/// /! computes exponent of each matrix element (dst = e**src)
// CV_EXPORTS_W void exp(InputArray src, OutputArray dst);
/// /! computes natural logarithm of absolute value of each matrix element: dst = log(abs(src))
// CV_EXPORTS_W void log(InputArray src, OutputArray dst);
/// /! computes cube root of the argument
// CV_EXPORTS_W float cubeRoot(float val);
/// /! computes the angle in degrees (0..360) of the vector (x,y)
// CV_EXPORTS_W float fastAtan2(float y, float x);
//
// CV_EXPORTS void exp(const float* src, float* dst, int n);
// CV_EXPORTS void log(const float* src, float* dst, int n);
// CV_EXPORTS void fastAtan2(const float* y, const float* x, float* dst, int n, bool angleInDegrees);
// CV_EXPORTS void magnitude(const float* x, const float* y, float* dst, int n);
//
/// /! converts polar coordinates to Cartesian
// CV_EXPORTS_W void polarToCart(InputArray magnitude, InputArray angle,
// OutputArray x, OutputArray y, bool angleInDegrees=false);
/// /! converts Cartesian coordinates to polar
// CV_EXPORTS_W void cartToPolar(InputArray x, InputArray y,
// OutputArray magnitude, OutputArray angle,
// bool angleInDegrees=false);
/// /! computes angle (angle(i)) of each (x(i), y(i)) vector
// CV_EXPORTS_W void phase(InputArray x, InputArray y, OutputArray angle,
// bool angleInDegrees=false);
/// /! computes magnitude (magnitude(i)) of each (x(i), y(i)) vector
// CV_EXPORTS_W void magnitude(InputArray x, InputArray y, OutputArray magnitude);
/// /! checks that each matrix element is within the specified range.
// CV_EXPORTS_W bool checkRange(InputArray a, bool quiet=true, CV_OUT Point* pos=0,
// double minVal=-DBL_MAX, double maxVal=DBL_MAX);
/// /! converts NaN's to the given number
// CV_EXPORTS_W void patchNaNs(InputOutputArray a, double val=0);
//
/// /! implements generalized matrix product algorithm GEMM from BLAS
// CV_EXPORTS_W void gemm(InputArray src1, InputArray src2, double alpha,
// InputArray src3, double gamma, OutputArray dst, int flags=0);
/// /! multiplies matrix by its transposition from the left or from the right
// CV_EXPORTS_W void mulTransposed( InputArray src, OutputArray dst, bool aTa,
// InputArray delta=noArray(),
// double scale=1, int dtype=-1 );
/// /! transposes the matrix
// CV_EXPORTS_W void transpose(InputArray src, OutputArray dst);
/// /! performs affine transformation of each element of multi-channel input matrix
// CV_EXPORTS_W void transform(InputArray src, OutputArray dst, InputArray m );
/// /! performs perspective transformation of each element of multi-channel input matrix
// CV_EXPORTS_W void perspectiveTransform(InputArray src, OutputArray dst, InputArray m );
//
/// /! extends the symmetrical matrix from the lower half or from the upper half
// CV_EXPORTS_W void completeSymm(InputOutputArray mtx, bool lowerToUpper=false);
/// /! initializes scaled identity matrix
// CV_EXPORTS_W void setIdentity(InputOutputArray mtx, const Scalar& s=Scalar(1));
/// /! computes determinant of a square matrix
// CV_EXPORTS_W double determinant(InputArray mtx);
/// /! computes trace of a matrix
// CV_EXPORTS_W Scalar trace(InputArray mtx);
/// /! computes inverse or pseudo-inverse matrix
// CV_EXPORTS_W double invert(InputArray src, OutputArray dst, int flags=DECOMP_LU);
/// /! solves linear system or a least-square problem
// CV_EXPORTS_W bool solve(InputArray src1, InputArray src2,
// OutputArray dst, int flags=DECOMP_LU);
//
// enum
// {
// SORT_EVERY_ROW=0,
// SORT_EVERY_COLUMN=1,
// SORT_ASCENDING=0,
// SORT_DESCENDING=16
// };
//
/// /! sorts independently each matrix row or each matrix column
// CV_EXPORTS_W void sort(InputArray src, OutputArray dst, int flags);
/// /! sorts independently each matrix row or each matrix column
// CV_EXPORTS_W void sortIdx(InputArray src, OutputArray dst, int flags);
/// /! finds real roots of a cubic polynomial
// CV_EXPORTS_W int solveCubic(InputArray coeffs, OutputArray roots);
/// /! finds real and complex roots of a polynomial
// CV_EXPORTS_W double solvePoly(InputArray coeffs, OutputArray roots, int maxIters=300);
/// /! finds eigenvalues of a symmetric matrix
// CV_EXPORTS bool eigen(InputArray src, OutputArray eigenvalues, int lowindex=-1,
// int highindex=-1);
/// /! finds eigenvalues and eigenvectors of a symmetric matrix
// CV_EXPORTS bool eigen(InputArray src, OutputArray eigenvalues,
// OutputArray eigenvectors,
// int lowindex=-1, int highindex=-1);
// CV_EXPORTS_W bool eigen(InputArray src, bool computeEigenvectors,
// OutputArray eigenvalues, OutputArray eigenvectors);
//
// enum
// {
// COVAR_SCRAMBLED=0,
// COVAR_NORMAL=1,
// COVAR_USE_AVG=2,
// COVAR_SCALE=4,
// COVAR_ROWS=8,
// COVAR_COLS=16
// };
//
/// /! computes covariation matrix of a set of samples
// CV_EXPORTS void calcCovarMatrix( const Mat* samples, int nsamples, Mat& covar, Mat& mean,
// int flags, int ctype=CV_64F);
/// /! computes covariation matrix of a set of samples
// CV_EXPORTS_W void calcCovarMatrix( InputArray samples, OutputArray covar,
// OutputArray mean, int flags, int ctype=CV_64F);
//
/// *!
// Principal Component Analysis
//
// The class PCA is used to compute the special basis for a set of vectors.
// The basis will consist of eigenvectors of the covariance matrix computed
// from the input set of vectors. After PCA is performed, vectors can be transformed from
// the original high-dimensional space to the subspace formed by a few most
// prominent eigenvectors (called the principal components),
// corresponding to the largest eigenvalues of the covariation matrix.
// Thus the dimensionality of the vector and the correlation between the coordinates is reduced.
//
// The following sample is the function that takes two matrices. The first one stores the set
// of vectors (a row per vector) that is used to compute PCA, the second one stores another
// "test" set of vectors (a row per vector) that are first compressed with PCA,
// then reconstructed back and then the reconstruction error norm is computed and printed for each vector.
//
// \code
// using namespace cv;
//
// PCA compressPCA(const Mat& pcaset, int maxComponents,
// const Mat& testset, Mat& compressed)
// {
// PCA pca(pcaset, // pass the data
// Mat(), // we do not have a pre-computed mean vector,
// // so let the PCA engine to compute it
// CV_PCA_DATA_AS_ROW, // indicate that the vectors
// // are stored as matrix rows
// // (use CV_PCA_DATA_AS_COL if the vectors are
// // the matrix columns)
// maxComponents // specify, how many principal components to retain
// );
// // if there is no test data, just return the computed basis, ready-to-use
// if( !testset.data )
// return pca;
// CV_Assert( testset.cols == pcaset.cols );
//
// compressed.create(testset.rows, maxComponents, testset.type());
//
// Mat reconstructed;
// for( int i = 0; i < testset.rows; i++ )
// {
// Mat vec = testset.row(i), coeffs = compressed.row(i), reconstructed;
// // compress the vector, the result will be stored
// // in the i-th row of the output matrix
// pca.project(vec, coeffs);
// // and then reconstruct it
// pca.backProject(coeffs, reconstructed);
// // and measure the error
// printf("%d. diff = %g\n", i, norm(vec, reconstructed, NORM_L2));
// }
// return pca;
// }
// \endcode
// */
// class CV_EXPORTS PCA
// {
// public:
// //! default constructor
// PCA();
// //! the constructor that performs PCA
// PCA(InputArray data, InputArray mean, int flags, int maxComponents=0);
// PCA(InputArray data, InputArray mean, int flags, double retainedVariance);
// //! operator that performs PCA. The previously stored data, if any, is released
// PCA& operator()(InputArray data, InputArray mean, int flags, int maxComponents=0);
// PCA& operator()(InputArray data, InputArray mean, int flags, double retainedVariance);
// //! projects vector from the original space to the principal components subspace
// Mat project(InputArray vec) const;
// //! projects vector from the original space to the principal components subspace
// void project(InputArray vec, OutputArray result) const;
// //! reconstructs the original vector from the projection
// Mat backProject(InputArray vec) const;
// //! reconstructs the original vector from the projection
// void backProject(InputArray vec, OutputArray result) const;
//
// Mat eigenvectors; //!< eigenvectors of the covariation matrix
// Mat eigenvalues; //!< eigenvalues of the covariation matrix
// Mat mean; //!< mean value subtracted before the projection and added after the back projection
// };
//
// CV_EXPORTS_W void PCACompute(InputArray data, InputOutputArray mean,
// OutputArray eigenvectors, int maxComponents=0);
//
// CV_EXPORTS_W void PCACompute(InputArray data, InputOutputArray mean,
// OutputArray eigenvectors, double retainedVariance);
//
// CV_EXPORTS_W void PCAProject(InputArray data, InputArray mean,
// InputArray eigenvectors, OutputArray result);
//
// CV_EXPORTS_W void PCABackProject(InputArray data, InputArray mean,
// InputArray eigenvectors, OutputArray result);
//
//
/// *!
// Singular Value Decomposition class
//
// The class is used to compute Singular Value Decomposition of a floating-point matrix and then
// use it to solve least-square problems, under-determined linear systems, invert matrices,
// compute condition numbers etc.
//
// For a bit faster operation you can pass flags=SVD::MODIFY_A|... to modify the decomposed matrix
// when it is not necessarily to preserve it. If you want to compute condition number of a matrix
// or absolute value of its determinant - you do not need SVD::u or SVD::vt,
// so you can pass flags=SVD::NO_UV|... . Another flag SVD::FULL_UV indicates that the full-size SVD::u and SVD::vt
// must be computed, which is not necessary most of the time.
// */
// class CV_EXPORTS SVD
// {
// public:
// enum { MODIFY_A=1, NO_UV=2, FULL_UV=4 };
// //! the default constructor
// SVD();
// //! the constructor that performs SVD
// SVD( InputArray src, int flags=0 );
// //! the operator that performs SVD. The previously allocated SVD::u, SVD::w are SVD::vt are released.
// SVD& operator ()( InputArray src, int flags=0 );
//
// //! decomposes matrix and stores the results to user-provided matrices
// static void compute( InputArray src, OutputArray w,
// OutputArray u, OutputArray vt, int flags=0 );
// //! computes singular values of a matrix
// static void compute( InputArray src, OutputArray w, int flags=0 );
// //! performs back substitution
// static void backSubst( InputArray w, InputArray u,
// InputArray vt, InputArray rhs,
// OutputArray dst );
//
// template<typename _Tp, int m, int n, int nm> static void compute( const Matx<_Tp, m, n>& a,
// Matx<_Tp, nm, 1>& w, Matx<_Tp, m, nm>& u, Matx<_Tp, n, nm>& vt );
// template<typename _Tp, int m, int n, int nm> static void compute( const Matx<_Tp, m, n>& a,
// Matx<_Tp, nm, 1>& w );
// template<typename _Tp, int m, int n, int nm, int nb> static void backSubst( const Matx<_Tp, nm, 1>& w,
// const Matx<_Tp, m, nm>& u, const Matx<_Tp, n, nm>& vt, const Matx<_Tp, m, nb>& rhs, Matx<_Tp, n, nb>& dst );
//
// //! finds dst = arg min_{|dst|=1} |m*dst|
// static void solveZ( InputArray src, OutputArray dst );
// //! performs back substitution, so that dst is the solution or pseudo-solution of m*dst = rhs, where m is the decomposed matrix
// void backSubst( InputArray rhs, OutputArray dst ) const;
//
// Mat u, w, vt;
// };
//
/// /! computes SVD of src
// CV_EXPORTS_W void SVDecomp( InputArray src, OutputArray w, OutputArray u, OutputArray vt, int flags=0 );
//
/// /! performs back substitution for the previously computed SVD
// CV_EXPORTS_W void SVBackSubst( InputArray w, InputArray u, InputArray vt,
// InputArray rhs, OutputArray dst );
//
/// /! computes Mahalanobis distance between two vectors: sqrt((v1-v2)'*icovar*(v1-v2)), where icovar is the inverse covariation matrix
// CV_EXPORTS_W double Mahalanobis(InputArray v1, InputArray v2, InputArray icovar);
/// /! a synonym for Mahalanobis
// CV_EXPORTS double Mahalonobis(InputArray v1, InputArray v2, InputArray icovar);
//
/// /! performs forward or inverse 1D or 2D Discrete Fourier Transformation
// CV_EXPORTS_W void dft(InputArray src, OutputArray dst, int flags=0, int nonzeroRows=0);
/// /! performs inverse 1D or 2D Discrete Fourier Transformation
// CV_EXPORTS_W void idft(InputArray src, OutputArray dst, int flags=0, int nonzeroRows=0);
/// /! performs forward or inverse 1D or 2D Discrete Cosine Transformation
// CV_EXPORTS_W void dct(InputArray src, OutputArray dst, int flags=0);
/// /! performs inverse 1D or 2D Discrete Cosine Transformation
// CV_EXPORTS_W void idct(InputArray src, OutputArray dst, int flags=0);
/// /! computes element-wise product of the two Fourier spectrums. The second spectrum can optionally be conjugated before the multiplication
// CV_EXPORTS_W void mulSpectrums(InputArray a, InputArray b, OutputArray c,
// int flags, bool conjB=false);
/// /! computes the minimal vector size vecsize1 >= vecsize so that the dft() of the vector of length vecsize1 can be computed efficiently
// CV_EXPORTS_W int getOptimalDFTSize(int vecsize);
//
/// *!
// Various k-Means flags
// */
// enum
// {
// KMEANS_RANDOM_CENTERS=0, // Chooses random centers for k-Means initialization
// KMEANS_PP_CENTERS=2,     // Uses k-Means++ algorithm for initialization
// KMEANS_USE_INITIAL_LABELS=1 // Uses the user-provided labels for K-Means initialization
// };
/// /! clusters the input data using k-Means algorithm
// CV_EXPORTS_W double kmeans( InputArray data, int K, InputOutputArray bestLabels,
// TermCriteria criteria, int attempts,
// int flags, OutputArray centers=noArray() );
//
/// /! returns the thread-local Random number generator
// CV_EXPORTS RNG& theRNG();
//
/// /! returns the next unifomly-distributed random number of the specified type
// template<typename _Tp> static inline _Tp randu() { return (_Tp)theRNG(); }
//
/// /! fills array with uniformly-distributed random numbers from the range [low, high)
// CV_EXPORTS_W void randu(InputOutputArray dst, InputArray low, InputArray high);
//
/// /! fills array with normally-distributed random numbers with the specified mean and the standard deviation
// CV_EXPORTS_W void randn(InputOutputArray dst, InputArray mean, InputArray stddev);
//
/// /! shuffles the input array elements
// CV_EXPORTS void randShuffle(InputOutputArray dst, double iterFactor=1., RNG* rng=0);
// CV_EXPORTS_AS(randShuffle) void randShuffle_(InputOutputArray dst, double iterFactor=1.);
//
/// /! draws the line segment (pt1, pt2) in the image
// CV_EXPORTS_W void line(CV_IN_OUT Mat& img, Point pt1, Point pt2, const Scalar& color,
// int thickness=1, int lineType=8, int shift=0);
//
/// /! draws the rectangle outline or a solid rectangle with the opposite corners pt1 and pt2 in the image
// CV_EXPORTS_W void rectangle(CV_IN_OUT Mat& img, Point pt1, Point pt2,
// const Scalar& color, int thickness=1,
// int lineType=8, int shift=0);
//
/// /! draws the rectangle outline or a solid rectangle covering rec in the image
// CV_EXPORTS void rectangle(CV_IN_OUT Mat& img, Rect rec,
// const Scalar& color, int thickness=1,
// int lineType=8, int shift=0);
//
/// /! draws the circle outline or a solid circle in the image
// CV_EXPORTS_W void circle(CV_IN_OUT Mat& img, Point center, int radius,
// const Scalar& color, int thickness=1,
// int lineType=8, int shift=0);
//
/// /! draws an elliptic arc, ellipse sector or a rotated ellipse in the image
// CV_EXPORTS_W void ellipse(CV_IN_OUT Mat& img, Point center, Size axes,
// double angle, double startAngle, double endAngle,
// const Scalar& color, int thickness=1,
// int lineType=8, int shift=0);
//
/// /! draws a rotated ellipse in the image
// CV_EXPORTS_W void ellipse(CV_IN_OUT Mat& img, const RotatedRect& box, const Scalar& color,
// int thickness=1, int lineType=8);
//
/// /! draws a filled convex polygon in the image
// CV_EXPORTS void fillConvexPoly(Mat& img, const Point* pts, int npts,
// const Scalar& color, int lineType=8,
// int shift=0);
// CV_EXPORTS_W void fillConvexPoly(InputOutputArray img, InputArray points,
// const Scalar& color, int lineType=8,
// int shift=0);
//
/// /! fills an area bounded by one or more polygons
// CV_EXPORTS void fillPoly(Mat& img, const Point** pts,
// const int* npts, int ncontours,
// const Scalar& color, int lineType=8, int shift=0,
// Point offset=Point() );
//
// CV_EXPORTS_W void fillPoly(InputOutputArray img, InputArrayOfArrays pts,
// const Scalar& color, int lineType=8, int shift=0,
// Point offset=Point() );
//
/// /! draws one or more polygonal curves
// CV_EXPORTS void polylines(Mat& img, const Point* const* pts, const int* npts,
// int ncontours, bool isClosed, const Scalar& color,
// int thickness=1, int lineType=8, int shift=0 );
//
// CV_EXPORTS_W void polylines(InputOutputArray img, InputArrayOfArrays pts,
// bool isClosed, const Scalar& color,
// int thickness=1, int lineType=8, int shift=0 );
//
/// /! draws contours in the image
// CV_EXPORTS_W void drawContours( InputOutputArray image, InputArrayOfArrays contours,
// int contourIdx, const Scalar& color,
// int thickness=1, int lineType=8,
// InputArray hierarchy=noArray(),
// int maxLevel=INT_MAX, Point offset=Point() );
//
/// /! clips the line segment by the rectangle Rect(0, 0, imgSize.width, imgSize.height)
// CV_EXPORTS bool clipLine(Size imgSize, CV_IN_OUT Point& pt1, CV_IN_OUT Point& pt2);
//
/// /! clips the line segment by the rectangle imgRect
// CV_EXPORTS_W bool clipLine(Rect imgRect, CV_OUT CV_IN_OUT Point& pt1, CV_OUT CV_IN_OUT Point& pt2);
//
/// *!
// Line iterator class
//
// The class is used to iterate over all the pixels on the raster line
// segment connecting two specified points.
// */
// class CV_EXPORTS LineIterator
// {
// public:
// //! intializes the iterator
// LineIterator( const Mat& img, Point pt1, Point pt2,
// int connectivity=8, bool leftToRight=false );
// //! returns pointer to the current pixel
// uchar* operator *();
// //! prefix increment operator (++it). shifts iterator to the next pixel
// LineIterator& operator ++();
// //! postfix increment operator (it++). shifts iterator to the next pixel
// LineIterator operator ++(int);
// //! returns coordinates of the current pixel
// Point pos() const;
//
// uchar* ptr;
// const uchar* ptr0;
// int step, elemSize;
// int err, count;
// int minusDelta, plusDelta;
// int minusStep, plusStep;
// };
//
/// /! converts elliptic arc to a polygonal curve
// CV_EXPORTS_W void ellipse2Poly( Point center, Size axes, int angle,
// int arcStart, int arcEnd, int delta,
// CV_OUT std::vector<Point>& pts );
//
// enum
// {
// FONT_HERSHEY_SIMPLEX = 0,
// FONT_HERSHEY_PLAIN = 1,
// FONT_HERSHEY_DUPLEX = 2,
// FONT_HERSHEY_COMPLEX = 3,
// FONT_HERSHEY_TRIPLEX = 4,
// FONT_HERSHEY_COMPLEX_SMALL = 5,
// FONT_HERSHEY_SCRIPT_SIMPLEX = 6,
// FONT_HERSHEY_SCRIPT_COMPLEX = 7,
// FONT_ITALIC = 16
// };
//
/// /! renders text string in the image
// CV_EXPORTS_W void putText( Mat& img, const String& text, Point org,
// int fontFace, double fontScale, Scalar color,
// int thickness=1, int lineType=8,
// bool bottomLeftOrigin=false );
//
/// /! returns bounding box of the text string
// CV_EXPORTS_W Size getTextSize(const String& text, int fontFace,
// double fontScale, int thickness,
// CV_OUT int* baseLine);
//
/// //////////////////////////////// Mat_<_Tp> ////////////////////////////////////
//
/// *!
// Template matrix class derived from Mat
//
// The class Mat_ is a "thin" template wrapper on top of cv::Mat. It does not have any extra data fields,
// nor it or cv::Mat have any virtual methods and thus references or pointers to these two classes
// can be safely converted one to another. But do it with care, for example:
//
// \code
// // create 100x100 8-bit matrix
// Mat M(100,100,CV_8U);
// // this will compile fine. no any data conversion will be done.
// Mat_<float>& M1 = (Mat_<float>&)M;
// // the program will likely crash at the statement below
// M1(99,99) = 1.f;
// \endcode
//
// While cv::Mat is sufficient in most cases, cv::Mat_ can be more convenient if you use a lot of element
// access operations and if you know matrix type at compile time.
// Note that cv::Mat::at<_Tp>(int y, int x) and cv::Mat_<_Tp>::operator ()(int y, int x) do absolutely the
// same thing and run at the same speed, but the latter is certainly shorter:
//
// \code
// Mat_<double> M(20,20);
// for(int i = 0; i < M.rows; i++)
// for(int j = 0; j < M.cols; j++)
// M(i,j) = 1./(i+j+1);
// Mat E, V;
// eigen(M,E,V);
// cout << E.at<double>(0,0)/E.at<double>(M.rows-1,0);
// \endcode
//
// It is easy to use Mat_ for multi-channel images/matrices - just pass cv::Vec as cv::Mat_ template parameter:
//
// \code
// // allocate 320x240 color image and fill it with green (in RGB space)
// Mat_<Vec3b> img(240, 320, Vec3b(0,255,0));
// // now draw a diagonal white line
// for(int i = 0; i < 100; i++)
// img(i,i)=Vec3b(255,255,255);
// // and now modify the 2nd (red) channel of each pixel
// for(int i = 0; i < img.rows; i++)
// for(int j = 0; j < img.cols; j++)
// img(i,j)[2] ^= (uchar)(i ^ j); // img(y,x)[c] accesses c-th channel of the pixel (x,y)
// \endcode
// */
// template<typename _Tp> class CV_EXPORTS Mat_ : public Mat
// {
// public:
// typedef _Tp value_type;
// typedef typename DataType<_Tp>::channel_type channel_type;
// typedef MatIterator_<_Tp> iterator;
// typedef MatConstIterator_<_Tp> const_iterator;
//
// //! default constructor
// Mat_();
// //! equivalent to Mat(_rows, _cols, DataType<_Tp>::type)
// Mat_(int _rows, int _cols);
// //! constructor that sets each matrix element to specified value
// Mat_(int _rows, int _cols, const _Tp& value);
// //! equivalent to Mat(_size, DataType<_Tp>::type)
// explicit Mat_(Size _size);
// //! constructor that sets each matrix element to specified value
// Mat_(Size _size, const _Tp& value);
// //! n-dim array constructor
// Mat_(int _ndims, const int* _sizes);
// //! n-dim array constructor that sets each matrix element to specified value
// Mat_(int _ndims, const int* _sizes, const _Tp& value);
// //! copy/conversion contructor. If m is of different type, it's converted
// Mat_(const Mat& m);
// //! copy constructor
// Mat_(const Mat_& m);
// //! constructs a matrix on top of user-allocated data. step is in bytes(!!!), regardless of the type
// Mat_(int _rows, int _cols, _Tp* _data, size_t _step=AUTO_STEP);
// //! constructs n-dim matrix on top of user-allocated data. steps are in bytes(!!!), regardless of the type
// Mat_(int _ndims, const int* _sizes, _Tp* _data, const size_t* _steps=0);
// //! selects a submatrix
// Mat_(const Mat_& m, const Range& rowRange, const Range& colRange=Range::all());
// //! selects a submatrix
// Mat_(const Mat_& m, const Rect& roi);
// //! selects a submatrix, n-dim version
// Mat_(const Mat_& m, const Range* ranges);
// //! from a matrix expression
// explicit Mat_(const MatExpr& e);
// //! makes a matrix out of Vec, std::vector, Point_ or Point3_. The matrix will have a single column
// explicit Mat_(const std::vector<_Tp>& vec, bool copyData=false);
// template<int n> explicit Mat_(const Vec<typename DataType<_Tp>::channel_type, n>& vec, bool copyData=true);
// template<int m, int n> explicit Mat_(const Matx<typename DataType<_Tp>::channel_type, m, n>& mtx, bool copyData=true);
// explicit Mat_(const Point_<typename DataType<_Tp>::channel_type>& pt, bool copyData=true);
// explicit Mat_(const Point3_<typename DataType<_Tp>::channel_type>& pt, bool copyData=true);
// explicit Mat_(const MatCommaInitializer_<_Tp>& commaInitializer);
//
// Mat_& operator = (const Mat& m);
// Mat_& operator = (const Mat_& m);
// //! set all the elements to s.
// Mat_& operator = (const _Tp& s);
// //! assign a matrix expression
// Mat_& operator = (const MatExpr& e);
//
// //! iterators; they are smart enough to skip gaps in the end of rows
// iterator begin();
// iterator end();
// const_iterator begin() const;
// const_iterator end() const;
//
// //! equivalent to Mat::create(_rows, _cols, DataType<_Tp>::type)
// void create(int _rows, int _cols);
// //! equivalent to Mat::create(_size, DataType<_Tp>::type)
// void create(Size _size);
// //! equivalent to Mat::create(_ndims, _sizes, DatType<_Tp>::type)
// void create(int _ndims, const int* _sizes);
// //! cross-product
// Mat_ cross(const Mat_& m) const;
// //! data type conversion
// template<typename T2> operator Mat_<T2>() const;
// //! overridden forms of Mat::row() etc.
// Mat_ row(int y) const;
// Mat_ col(int x) const;
// Mat_ diag(int d=0) const;
// Mat_ clone() const;
//
// //! overridden forms of Mat::elemSize() etc.
// size_t elemSize() const;
// size_t elemSize1() const;
// int type() const;
// int depth() const;
// int channels() const;
// size_t step1(int i=0) const;
// //! returns step()/sizeof(_Tp)
// size_t stepT(int i=0) const;
//
// //! overridden forms of Mat::zeros() etc. Data type is omitted, of course
// static MatExpr zeros(int rows, int cols);
// static MatExpr zeros(Size size);
// static MatExpr zeros(int _ndims, const int* _sizes);
// static MatExpr ones(int rows, int cols);
// static MatExpr ones(Size size);
// static MatExpr ones(int _ndims, const int* _sizes);
// static MatExpr eye(int rows, int cols);
// static MatExpr eye(Size size);
//
// //! some more overriden methods
// Mat_& adjustROI( int dtop, int dbottom, int dleft, int dright );
// Mat_ operator()( const Range& rowRange, const Range& colRange ) const;
// Mat_ operator()( const Rect& roi ) const;
// Mat_ operator()( const Range* ranges ) const;
//
// //! more convenient forms of row and element access operators
// _Tp* operator [](int y);
// const _Tp* operator [](int y) const;
//
// //! returns reference to the specified element
// _Tp& operator ()(const int* idx);
// //! returns read-only reference to the specified element
// const _Tp& operator ()(const int* idx) const;
//
// //! returns reference to the specified element
// template<int n> _Tp& operator ()(const Vec<int, n>& idx);
// //! returns read-only reference to the specified element
// template<int n> const _Tp& operator ()(const Vec<int, n>& idx) const;
//
// //! returns reference to the specified element (1D case)
// _Tp& operator ()(int idx0);
// //! returns read-only reference to the specified element (1D case)
// const _Tp& operator ()(int idx0) const;
// //! returns reference to the specified element (2D case)
// _Tp& operator ()(int idx0, int idx1);
// //! returns read-only reference to the specified element (2D case)
// const _Tp& operator ()(int idx0, int idx1) const;
// //! returns reference to the specified element (3D case)
// _Tp& operator ()(int idx0, int idx1, int idx2);
// //! returns read-only reference to the specified element (3D case)
// const _Tp& operator ()(int idx0, int idx1, int idx2) const;
//
// _Tp& operator ()(Point pt);
// const _Tp& operator ()(Point pt) const;
//
// //! conversion to vector.
// operator std::vector<_Tp>() const;
// //! conversion to Vec
// template<int n> operator Vec<typename DataType<_Tp>::channel_type, n>() const;
// //! conversion to Matx
// template<int m, int n> operator Matx<typename DataType<_Tp>::channel_type, m, n>() const;
// };
//
// typedef Mat_<uchar> Mat1b;
// typedef Mat_<Vec2b> Mat2b;
// typedef Mat_<Vec3b> Mat3b;
// typedef Mat_<Vec4b> Mat4b;
//
// typedef Mat_<short> Mat1s;
// typedef Mat_<Vec2s> Mat2s;
// typedef Mat_<Vec3s> Mat3s;
// typedef Mat_<Vec4s> Mat4s;
//
// typedef Mat_<ushort> Mat1w;
// typedef Mat_<Vec2w> Mat2w;
// typedef Mat_<Vec3w> Mat3w;
// typedef Mat_<Vec4w> Mat4w;
//
// typedef Mat_<int>   Mat1i;
// typedef Mat_<Vec2i> Mat2i;
// typedef Mat_<Vec3i> Mat3i;
// typedef Mat_<Vec4i> Mat4i;
//
// typedef Mat_<float> Mat1f;
// typedef Mat_<Vec2f> Mat2f;
// typedef Mat_<Vec3f> Mat3f;
// typedef Mat_<Vec4f> Mat4f;
//
// typedef Mat_<double> Mat1d;
// typedef Mat_<Vec2d> Mat2d;
// typedef Mat_<Vec3d> Mat3d;
// typedef Mat_<Vec4d> Mat4d;
//
/// /////////// Iterators & Comma initializers //////////////////
//
// class CV_EXPORTS MatConstIterator
// {
// public:
// typedef uchar* value_type;
// typedef ptrdiff_t difference_type;
// typedef const uchar** pointer;
// typedef uchar* reference;
// typedef std::random_access_iterator_tag iterator_category;
//
// //! default constructor
// MatConstIterator();
// //! constructor that sets the iterator to the beginning of the matrix
// MatConstIterator(const Mat* _m);
// //! constructor that sets the iterator to the specified element of the matrix
// MatConstIterator(const Mat* _m, int _row, int _col=0);
// //! constructor that sets the iterator to the specified element of the matrix
// MatConstIterator(const Mat* _m, Point _pt);
// //! constructor that sets the iterator to the specified element of the matrix
// MatConstIterator(const Mat* _m, const int* _idx);
// //! copy constructor
// MatConstIterator(const MatConstIterator& it);
//
// //! copy operator
// MatConstIterator& operator = (const MatConstIterator& it);
// //! returns the current matrix element
// uchar* operator *() const;
// //! returns the i-th matrix element, relative to the current
// uchar* operator [](ptrdiff_t i) const;
//
// //! shifts the iterator forward by the specified number of elements
// MatConstIterator& operator += (ptrdiff_t ofs);
// //! shifts the iterator backward by the specified number of elements
// MatConstIterator& operator -= (ptrdiff_t ofs);
// //! decrements the iterator
// MatConstIterator& operator --();
// //! decrements the iterator
// MatConstIterator operator --(int);
// //! increments the iterator
// MatConstIterator& operator ++();
// //! increments the iterator
// MatConstIterator operator ++(int);
// //! returns the current iterator position
// Point pos() const;
// //! returns the current iterator position
// void pos(int* _idx) const;
// ptrdiff_t lpos() const;
// void seek(ptrdiff_t ofs, bool relative=false);
// void seek(const int* _idx, bool relative=false);
//
// const Mat* m;
// size_t elemSize;
// uchar* ptr;
// uchar* sliceStart;
// uchar* sliceEnd;
// };
//
/// *!
// Matrix read-only iterator
//
// */
// template<typename _Tp>
// class CV_EXPORTS MatConstIterator_ : public MatConstIterator
// {
// public:
// typedef _Tp value_type;
// typedef ptrdiff_t difference_type;
// typedef const _Tp* pointer;
// typedef const _Tp& reference;
// typedef std::random_access_iterator_tag iterator_category;
//
// //! default constructor
// MatConstIterator_();
// //! constructor that sets the iterator to the beginning of the matrix
// MatConstIterator_(const Mat_<_Tp>* _m);
// //! constructor that sets the iterator to the specified element of the matrix
// MatConstIterator_(const Mat_<_Tp>* _m, int _row, int _col=0);
// //! constructor that sets the iterator to the specified element of the matrix
// MatConstIterator_(const Mat_<_Tp>* _m, Point _pt);
// //! constructor that sets the iterator to the specified element of the matrix
// MatConstIterator_(const Mat_<_Tp>* _m, const int* _idx);
// //! copy constructor
// MatConstIterator_(const MatConstIterator_& it);
//
// //! copy operator
// MatConstIterator_& operator = (const MatConstIterator_& it);
// //! returns the current matrix element
// _Tp operator *() const;
// //! returns the i-th matrix element, relative to the current
// _Tp operator [](ptrdiff_t i) const;
//
// //! shifts the iterator forward by the specified number of elements
// MatConstIterator_& operator += (ptrdiff_t ofs);
// //! shifts the iterator backward by the specified number of elements
// MatConstIterator_& operator -= (ptrdiff_t ofs);
// //! decrements the iterator
// MatConstIterator_& operator --();
// //! decrements the iterator
// MatConstIterator_ operator --(int);
// //! increments the iterator
// MatConstIterator_& operator ++();
// //! increments the iterator
// MatConstIterator_ operator ++(int);
// //! returns the current iterator position
// Point pos() const;
// };
//
//
/// *!
// Matrix read-write iterator
//
// */
// template<typename _Tp>
// class CV_EXPORTS MatIterator_ : public MatConstIterator_<_Tp>
// {
// public:
// typedef _Tp* pointer;
// typedef _Tp& reference;
// typedef std::random_access_iterator_tag iterator_category;
//
// //! the default constructor
// MatIterator_();
// //! constructor that sets the iterator to the beginning of the matrix
// MatIterator_(Mat_<_Tp>* _m);
// //! constructor that sets the iterator to the specified element of the matrix
// MatIterator_(Mat_<_Tp>* _m, int _row, int _col=0);
// //! constructor that sets the iterator to the specified element of the matrix
// MatIterator_(const Mat_<_Tp>* _m, Point _pt);
// //! constructor that sets the iterator to the specified element of the matrix
// MatIterator_(const Mat_<_Tp>* _m, const int* _idx);
// //! copy constructor
// MatIterator_(const MatIterator_& it);
// //! copy operator
// MatIterator_& operator = (const MatIterator_<_Tp>& it );
//
// //! returns the current matrix element
// _Tp& operator *() const;
// //! returns the i-th matrix element, relative to the current
// _Tp& operator [](ptrdiff_t i) const;
//
// //! shifts the iterator forward by the specified number of elements
// MatIterator_& operator += (ptrdiff_t ofs);
// //! shifts the iterator backward by the specified number of elements
// MatIterator_& operator -= (ptrdiff_t ofs);
// //! decrements the iterator
// MatIterator_& operator --();
// //! decrements the iterator
// MatIterator_ operator --(int);
// //! increments the iterator
// MatIterator_& operator ++();
// //! increments the iterator
// MatIterator_ operator ++(int);
// };
//
// template<typename _Tp> class CV_EXPORTS MatOp_Iter_;
//
/// *!
// Comma-separated Matrix Initializer
//
// The class instances are usually not created explicitly.
// Instead, they are created on "matrix << firstValue" operator.
//
// The sample below initializes 2x2 rotation matrix:
//
// \code
// double angle = 30, a = cos(angle*CV_PI/180), b = sin(angle*CV_PI/180);
// Mat R = (Mat_<double>(2,2) << a, -b, b, a);
// \endcode
// */
// template<typename _Tp> class CV_EXPORTS MatCommaInitializer_
// {
// public:
// //! the constructor, created by "matrix << firstValue" operator, where matrix is cv::Mat
// MatCommaInitializer_(Mat_<_Tp>* _m);
// //! the operator that takes the next value and put it to the matrix
// template<typename T2> MatCommaInitializer_<_Tp>& operator , (T2 v);
// //! another form of conversion operator
// Mat_<_Tp> operator *() const;
// operator Mat_<_Tp>() const;
// protected:
// MatIterator_<_Tp> it;
// };
//
//
// template<typename _Tp, int m, int n> class CV_EXPORTS MatxCommaInitializer
// {
// public:
// MatxCommaInitializer(Matx<_Tp, m, n>* _mtx);
// template<typename T2> MatxCommaInitializer<_Tp, m, n>& operator , (T2 val);
// Matx<_Tp, m, n> operator *() const;
//
// Matx<_Tp, m, n>* dst;
// int idx;
// };
//
// template<typename _Tp, int m> class CV_EXPORTS VecCommaInitializer : public MatxCommaInitializer<_Tp, m, 1>
// {
// public:
// VecCommaInitializer(Vec<_Tp, m>* _vec);
// template<typename T2> VecCommaInitializer<_Tp, m>& operator , (T2 val);
// Vec<_Tp, m> operator *() const;
// };
//
/// ////////////////////////// multi-dimensional dense matrix //////////////////////////
//
/// *!
// n-Dimensional Dense Matrix Iterator Class.
//
// The class cv::NAryMatIterator is used for iterating over one or more n-dimensional dense arrays (cv::Mat's).
//
// The iterator is completely different from cv::Mat_ and cv::SparseMat_ iterators.
// It iterates through the slices (or planes), not the elements, where "slice" is a continuous part of the arrays.
//
// Here is the example on how the iterator can be used to normalize 3D histogram:
//
// \code
// void normalizeColorHist(Mat& hist)
// {
// #if 1
// // intialize iterator (the style is different from STL).
// // after initialization the iterator will contain
// // the number of slices or planes
// // the iterator will go through
// Mat* arrays[] = { &hist, 0 };
// Mat planes[1];
// NAryMatIterator it(arrays, planes);
// double s = 0;
// // iterate through the matrix. on each iteration
// // it.planes[i] (of type Mat) will be set to the current plane of
// // i-th n-dim matrix passed to the iterator constructor.
// for(int p = 0; p < it.nplanes; p++, ++it)
// s += sum(it.planes[0])[0];
// it = NAryMatIterator(hist);
// s = 1./s;
// for(int p = 0; p < it.nplanes; p++, ++it)
// it.planes[0] *= s;
// #elif 1
// // this is a shorter implementation of the above
// // using built-in operations on Mat
// double s = sum(hist)[0];
// hist.convertTo(hist, hist.type(), 1./s, 0);
// #else
// // and this is even shorter one
// // (assuming that the histogram elements are non-negative)
// normalize(hist, hist, 1, 0, NORM_L1);
// #endif
// }
// \endcode
//
// You can iterate through several matrices simultaneously as long as they have the same geometry
// (dimensionality and all the dimension sizes are the same), which is useful for binary
// and n-ary operations on such matrices. Just pass those matrices to cv::MatNDIterator.
// Then, during the iteration it.planes[0], it.planes[1], ... will
// be the slices of the corresponding matrices
// */
// class CV_EXPORTS NAryMatIterator
// {
// public:
// //! the default constructor
// NAryMatIterator();
// //! the full constructor taking arbitrary number of n-dim matrices
// NAryMatIterator(const Mat** arrays, uchar** ptrs, int narrays=-1);
// //! the full constructor taking arbitrary number of n-dim matrices
// NAryMatIterator(const Mat** arrays, Mat* planes, int narrays=-1);
// //! the separate iterator initialization method
// void init(const Mat** arrays, Mat* planes, uchar** ptrs, int narrays=-1);
//
// //! proceeds to the next plane of every iterated matrix
// NAryMatIterator& operator ++();
// //! proceeds to the next plane of every iterated matrix (postfix increment operator)
// NAryMatIterator operator ++(int);
//
// //! the iterated arrays
// const Mat** arrays;
// //! the current planes
// Mat* planes;
// //! data pointers
// uchar** ptrs;
// //! the number of arrays
// int narrays;
// //! the number of hyper-planes that the iterator steps through
// size_t nplanes;
// //! the size of each segment (in elements)
// size_t size;
// protected:
// int iterdepth;
// size_t idx;
// };
//
/// /typedef NAryMatIterator NAryMatNDIterator;
//
// typedef void (*ConvertData)(const void* from, void* to, int cn);
// typedef void (*ConvertScaleData)(const void* from, void* to, int cn, double alpha, double beta);
//
/// /! returns the function for converting pixels from one data type to another
// CV_EXPORTS ConvertData getConvertElem(int fromType, int toType);
/// /! returns the function for converting pixels from one data type to another with the optional scaling
// CV_EXPORTS ConvertScaleData getConvertScaleElem(int fromType, int toType);
//
//
/// ////////////////////////// multi-dimensional sparse matrix //////////////////////////
//
// class SparseMatIterator;
// class SparseMatConstIterator;
// template<typename _Tp> class SparseMatIterator_;
// template<typename _Tp> class SparseMatConstIterator_;
//
/// *!
// Sparse matrix class.
//
// The class represents multi-dimensional sparse numerical arrays. Such a sparse array can store elements
// of any type that cv::Mat is able to store. "Sparse" means that only non-zero elements
// are stored (though, as a result of some operations on a sparse matrix, some of its stored elements
// can actually become 0. It's user responsibility to detect such elements and delete them using cv::SparseMat::erase().
// The non-zero elements are stored in a hash table that grows when it's filled enough,
// so that the search time remains O(1) in average. Elements can be accessed using the following methods:
//
// <ol>
// <li>Query operations: cv::SparseMat::ptr() and the higher-level cv::SparseMat::ref(),
// cv::SparseMat::value() and cv::SparseMat::find, for example:
// \code
// const int dims = 5;
// int size[] = {10, 10, 10, 10, 10};
// SparseMat sparse_mat(dims, size, CV_32F);
// for(int i = 0; i < 1000; i++)
// {
// int idx[dims];
// for(int k = 0; k < dims; k++)
// idx[k] = rand()%sparse_mat.size(k);
// sparse_mat.ref<float>(idx) += 1.f;
// }
// \endcode
//
// <li>Sparse matrix iterators. Like cv::Mat iterators and unlike cv::Mat iterators, the sparse matrix iterators are STL-style,
// that is, the iteration is done as following:
// \code
// // prints elements of a sparse floating-point matrix and the sum of elements.
// SparseMatConstIterator_<float>
// it = sparse_mat.begin<float>(),
// it_end = sparse_mat.end<float>();
// double s = 0;
// int dims = sparse_mat.dims();
// for(; it != it_end; ++it)
// {
// // print element indices and the element value
// const Node* n = it.node();
// printf("(")
// for(int i = 0; i < dims; i++)
// printf("%3d%c", n->idx[i], i < dims-1 ? ',' : ')');
// printf(": %f\n", *it);
// s += *it;
// }
// printf("Element sum is %g\n", s);
// \endcode
// If you run this loop, you will notice that elements are enumerated
// in no any logical order (lexicographical etc.),
// they come in the same order as they stored in the hash table, i.e. semi-randomly.
//
// You may collect pointers to the nodes and sort them to get the proper ordering.
// Note, however, that pointers to the nodes may become invalid when you add more
// elements to the matrix; this is because of possible buffer reallocation.
//
// <li>A combination of the above 2 methods when you need to process 2 or more sparse
// matrices simultaneously, e.g. this is how you can compute unnormalized
// cross-correlation of the 2 floating-point sparse matrices:
// \code
// double crossCorr(const SparseMat& a, const SparseMat& b)
// {
// const SparseMat *_a = &a, *_b = &b;
// // if b contains less elements than a,
// // it's faster to iterate through b
// if(_a->nzcount() > _b->nzcount())
// std::swap(_a, _b);
// SparseMatConstIterator_<float> it = _a->begin<float>(),
// it_end = _a->end<float>();
// double ccorr = 0;
// for(; it != it_end; ++it)
// {
// // take the next element from the first matrix
// float avalue = *it;
// const Node* anode = it.node();
// // and try to find element with the same index in the second matrix.
// // since the hash value depends only on the element index,
// // we reuse hashvalue stored in the node
// float bvalue = _b->value<float>(anode->idx,&anode->hashval);
// ccorr += avalue*bvalue;
// }
// return ccorr;
// }
// \endcode
// </ol>
// */
// class CV_EXPORTS SparseMat
// {
// public:
// typedef SparseMatIterator iterator;
// typedef SparseMatConstIterator const_iterator;
//
// //! the sparse matrix header
// struct CV_EXPORTS Hdr
// {
// Hdr(int _dims, const int* _sizes, int _type);
// void clear();
// int refcount;
// int dims;
// int valueOffset;
// size_t nodeSize;
// size_t nodeCount;
// size_t freeList;
// std::vector<uchar> pool;
// std::vector<size_t> hashtab;
// int size[CV_MAX_DIM];
// };
//
// //! sparse matrix node - element of a hash table
// struct CV_EXPORTS Node
// {
// //! hash value
// size_t hashval;
// //! index of the next node in the same hash table entry
// size_t next;
// //! index of the matrix element
// int idx[CV_MAX_DIM];
// };
//
// //! default constructor
// SparseMat();
// //! creates matrix of the specified size and type
// SparseMat(int dims, const int* _sizes, int _type);
// //! copy constructor
// SparseMat(const SparseMat& m);
// //! converts dense 2d matrix to the sparse form
// /*!
// \param m the input matrix
// \param try1d if true and m is a single-column matrix (Nx1),
// then the sparse matrix will be 1-dimensional.
// */
// explicit SparseMat(const Mat& m);
// //! converts old-style sparse matrix to the new-style. All the data is copied
// SparseMat(const CvSparseMat* m);
// //! the destructor
// ~SparseMat();
//
// //! assignment operator. This is O(1) operation, i.e. no data is copied
// SparseMat& operator = (const SparseMat& m);
// //! equivalent to the corresponding constructor
// SparseMat& operator = (const Mat& m);
//
// //! creates full copy of the matrix
// SparseMat clone() const;
//
// //! copies all the data to the destination matrix. All the previous content of m is erased
// void copyTo( SparseMat& m ) const;
// //! converts sparse matrix to dense matrix.
// void copyTo( Mat& m ) const;
// //! multiplies all the matrix elements by the specified scale factor alpha and converts the results to the specified data type
// void convertTo( SparseMat& m, int rtype, double alpha=1 ) const;
// //! converts sparse matrix to dense n-dim matrix with optional type conversion and scaling.
// /*!
// \param rtype The output matrix data type. When it is =-1, the output array will have the same data type as (*this)
// \param alpha The scale factor
// \param beta The optional delta added to the scaled values before the conversion
// */
// void convertTo( Mat& m, int rtype, double alpha=1, double beta=0 ) const;
//
// // not used now
// void assignTo( SparseMat& m, int type=-1 ) const;
//
// //! reallocates sparse matrix.
// /*!
// If the matrix already had the proper size and type,
// it is simply cleared with clear(), otherwise,
// the old matrix is released (using release()) and the new one is allocated.
// */
// void create(int dims, const int* _sizes, int _type);
// //! sets all the sparse matrix elements to 0, which means clearing the hash table.
// void clear();
// //! manually increments the reference counter to the header.
// void addref();
// // decrements the header reference counter. When the counter reaches 0, the header and all the underlying data are deallocated.
// void release();
//
// //! converts sparse matrix to the old-style representation; all the elements are copied.
// operator CvSparseMat*() const;
// //! returns the size of each element in bytes (not including the overhead - the space occupied by SparseMat::Node elements)
// size_t elemSize() const;
// //! returns elemSize()/channels()
// size_t elemSize1() const;
//
// //! returns type of sparse matrix elements
// int type() const;
// //! returns the depth of sparse matrix elements
// int depth() const;
// //! returns the number of channels
// int channels() const;
//
// //! returns the array of sizes, or NULL if the matrix is not allocated
// const int* size() const;
// //! returns the size of i-th matrix dimension (or 0)
// int size(int i) const;
// //! returns the matrix dimensionality
// int dims() const;
// //! returns the number of non-zero elements (=the number of hash table nodes)
// size_t nzcount() const;
//
// //! computes the element hash value (1D case)
// size_t hash(int i0) const;
// //! computes the element hash value (2D case)
// size_t hash(int i0, int i1) const;
// //! computes the element hash value (3D case)
// size_t hash(int i0, int i1, int i2) const;
// //! computes the element hash value (nD case)
// size_t hash(const int* idx) const;
//
// //@{
// /*!
// specialized variants for 1D, 2D, 3D cases and the generic_type one for n-D case.
//
// return pointer to the matrix element.
// <ul>
// <li>if the element is there (it's non-zero), the pointer to it is returned
// <li>if it's not there and createMissing=false, NULL pointer is returned
// <li>if it's not there and createMissing=true, then the new element
// is created and initialized with 0. Pointer to it is returned
// <li>if the optional hashval pointer is not NULL, the element hash value is
// not computed, but *hashval is taken instead.
// </ul>
// */
// //! returns pointer to the specified element (1D case)
// uchar* ptr(int i0, bool createMissing, size_t* hashval=0);
// //! returns pointer to the specified element (2D case)
// uchar* ptr(int i0, int i1, bool createMissing, size_t* hashval=0);
// //! returns pointer to the specified element (3D case)
// uchar* ptr(int i0, int i1, int i2, bool createMissing, size_t* hashval=0);
// //! returns pointer to the specified element (nD case)
// uchar* ptr(const int* idx, bool createMissing, size_t* hashval=0);
// //@}
//
// //@{
// /*!
// return read-write reference to the specified sparse matrix element.
//
// ref<_Tp>(i0,...[,hashval]) is equivalent to *(_Tp*)ptr(i0,...,true[,hashval]).
// The methods always return a valid reference.
// If the element did not exist, it is created and initialiazed with 0.
// */
// //! returns reference to the specified element (1D case)
// template<typename _Tp> _Tp& ref(int i0, size_t* hashval=0);
// //! returns reference to the specified element (2D case)
// template<typename _Tp> _Tp& ref(int i0, int i1, size_t* hashval=0);
// //! returns reference to the specified element (3D case)
// template<typename _Tp> _Tp& ref(int i0, int i1, int i2, size_t* hashval=0);
// //! returns reference to the specified element (nD case)
// template<typename _Tp> _Tp& ref(const int* idx, size_t* hashval=0);
// //@}
//
// //@{
// /*!
// return value of the specified sparse matrix element.
//
// value<_Tp>(i0,...[,hashval]) is equivalent
//
// \code
// { const _Tp* p = find<_Tp>(i0,...[,hashval]); return p ? *p : _Tp(); }
// \endcode
//
// That is, if the element did not exist, the methods return 0.
// */
// //! returns value of the specified element (1D case)
// template<typename _Tp> _Tp value(int i0, size_t* hashval=0) const;
// //! returns value of the specified element (2D case)
// template<typename _Tp> _Tp value(int i0, int i1, size_t* hashval=0) const;
// //! returns value of the specified element (3D case)
// template<typename _Tp> _Tp value(int i0, int i1, int i2, size_t* hashval=0) const;
// //! returns value of the specified element (nD case)
// template<typename _Tp> _Tp value(const int* idx, size_t* hashval=0) const;
// //@}
//
// //@{
// /*!
// Return pointer to the specified sparse matrix element if it exists
//
// find<_Tp>(i0,...[,hashval]) is equivalent to (_const Tp*)ptr(i0,...false[,hashval]).
//
// If the specified element does not exist, the methods return NULL.
// */
// //! returns pointer to the specified element (1D case)
// template<typename _Tp> const _Tp* find(int i0, size_t* hashval=0) const;
// //! returns pointer to the specified element (2D case)
// template<typename _Tp> const _Tp* find(int i0, int i1, size_t* hashval=0) const;
// //! returns pointer to the specified element (3D case)
// template<typename _Tp> const _Tp* find(int i0, int i1, int i2, size_t* hashval=0) const;
// //! returns pointer to the specified element (nD case)
// template<typename _Tp> const _Tp* find(const int* idx, size_t* hashval=0) const;
//
// //! erases the specified element (2D case)
// void erase(int i0, int i1, size_t* hashval=0);
// //! erases the specified element (3D case)
// void erase(int i0, int i1, int i2, size_t* hashval=0);
// //! erases the specified element (nD case)
// void erase(const int* idx, size_t* hashval=0);
//
// //@{
// /*!
// return the sparse matrix iterator pointing to the first sparse matrix element
// */
// //! returns the sparse matrix iterator at the matrix beginning
// SparseMatIterator begin();
// //! returns the sparse matrix iterator at the matrix beginning
// template<typename _Tp> SparseMatIterator_<_Tp> begin();
// //! returns the read-only sparse matrix iterator at the matrix beginning
// SparseMatConstIterator begin() const;
// //! returns the read-only sparse matrix iterator at the matrix beginning
// template<typename _Tp> SparseMatConstIterator_<_Tp> begin() const;
// //@}
// /*!
// return the sparse matrix iterator pointing to the element following the last sparse matrix element
// */
// //! returns the sparse matrix iterator at the matrix end
// SparseMatIterator end();
// //! returns the read-only sparse matrix iterator at the matrix end
// SparseMatConstIterator end() const;
// //! returns the typed sparse matrix iterator at the matrix end
// template<typename _Tp> SparseMatIterator_<_Tp> end();
// //! returns the typed read-only sparse matrix iterator at the matrix end
// template<typename _Tp> SparseMatConstIterator_<_Tp> end() const;
//
// //! returns the value stored in the sparse martix node
// template<typename _Tp> _Tp& value(Node* n);
// //! returns the value stored in the sparse martix node
// template<typename _Tp> const _Tp& value(const Node* n) const;
//
// ////////////// some internal-use methods ///////////////
// Node* node(size_t nidx);
// const Node* node(size_t nidx) const;
//
// uchar* newNode(const int* idx, size_t hashval);
// void removeNode(size_t hidx, size_t nidx, size_t previdx);
// void resizeHashTab(size_t newsize);
//
// enum { MAGIC_VAL=0x42FD0000, MAX_DIM=CV_MAX_DIM, HASH_SCALE=0x5bd1e995, HASH_BIT=0x80000000 };
//
// int flags;
// Hdr* hdr;
// };
//
/// /! finds global minimum and maximum sparse array elements and returns their values and their locations
// CV_EXPORTS void minMaxLoc(const SparseMat& a, double* minVal,
// double* maxVal, int* minIdx=0, int* maxIdx=0);
/// /! computes norm of a sparse matrix
// CV_EXPORTS double norm( const SparseMat& src, int normType );
/// /! scales and shifts array elements so that either the specified norm (alpha) or the minimum (alpha) and maximum (beta) array values get the specified values
// CV_EXPORTS void normalize( const SparseMat& src, SparseMat& dst, double alpha, int normType );
//
/// *!
// Read-Only Sparse Matrix Iterator.
// Here is how to use the iterator to compute the sum of floating-point sparse matrix elements:
//
// \code
// SparseMatConstIterator it = m.begin(), it_end = m.end();
// double s = 0;
// CV_Assert( m.type() == CV_32F );
// for( ; it != it_end; ++it )
// s += it.value<float>();
// \endcode
// */
// class CV_EXPORTS SparseMatConstIterator
// {
// public:
// //! the default constructor
// SparseMatConstIterator();
// //! the full constructor setting the iterator to the first sparse matrix element
// SparseMatConstIterator(const SparseMat* _m);
// //! the copy constructor
// SparseMatConstIterator(const SparseMatConstIterator& it);
//
// //! the assignment operator
// SparseMatConstIterator& operator = (const SparseMatConstIterator& it);
//
// //! template method returning the current matrix element
// template<typename _Tp> const _Tp& value() const;
// //! returns the current node of the sparse matrix. it.node->idx is the current element index
// const SparseMat::Node* node() const;
//
// //! moves iterator to the previous element
// SparseMatConstIterator& operator --();
// //! moves iterator to the previous element
// SparseMatConstIterator operator --(int);
// //! moves iterator to the next element
// SparseMatConstIterator& operator ++();
// //! moves iterator to the next element
// SparseMatConstIterator operator ++(int);
//
// //! moves iterator to the element after the last element
// void seekEnd();
//
// const SparseMat* m;
// size_t hashidx;
// uchar* ptr;
// };
//
/// *!
// Read-write Sparse Matrix Iterator
//
// The class is similar to cv::SparseMatConstIterator,
// but can be used for in-place modification of the matrix elements.
// */
// class CV_EXPORTS SparseMatIterator : public SparseMatConstIterator
// {
// public:
// //! the default constructor
// SparseMatIterator();
// //! the full constructor setting the iterator to the first sparse matrix element
// SparseMatIterator(SparseMat* _m);
// //! the full constructor setting the iterator to the specified sparse matrix element
// SparseMatIterator(SparseMat* _m, const int* idx);
// //! the copy constructor
// SparseMatIterator(const SparseMatIterator& it);
//
// //! the assignment operator
// SparseMatIterator& operator = (const SparseMatIterator& it);
// //! returns read-write reference to the current sparse matrix element
// template<typename _Tp> _Tp& value() const;
// //! returns pointer to the current sparse matrix node. it.node->idx is the index of the current element (do not modify it!)
// SparseMat::Node* node() const;
//
// //! moves iterator to the next element
// SparseMatIterator& operator ++();
// //! moves iterator to the next element
// SparseMatIterator operator ++(int);
// };
//
/// *!
// The Template Sparse Matrix class derived from cv::SparseMat
//
// The class provides slightly more convenient operations for accessing elements.
//
// \code
// SparseMat m;
// ...
// SparseMat_<int> m_ = (SparseMat_<int>&)m;
// m_.ref(1)++; // equivalent to m.ref<int>(1)++;
// m_.ref(2) += m_(3); // equivalent to m.ref<int>(2) += m.value<int>(3);
// \endcode
// */
// template<typename _Tp> class CV_EXPORTS SparseMat_ : public SparseMat
// {
// public:
// typedef SparseMatIterator_<_Tp> iterator;
// typedef SparseMatConstIterator_<_Tp> const_iterator;
//
// //! the default constructor
// SparseMat_();
// //! the full constructor equivelent to SparseMat(dims, _sizes, DataType<_Tp>::type)
// SparseMat_(int dims, const int* _sizes);
// //! the copy constructor. If DataType<_Tp>.type != m.type(), the m elements are converted
// SparseMat_(const SparseMat& m);
// //! the copy constructor. This is O(1) operation - no data is copied
// SparseMat_(const SparseMat_& m);
// //! converts dense matrix to the sparse form
// SparseMat_(const Mat& m);
// //! converts the old-style sparse matrix to the C++ class. All the elements are copied
// SparseMat_(const CvSparseMat* m);
// //! the assignment operator. If DataType<_Tp>.type != m.type(), the m elements are converted
// SparseMat_& operator = (const SparseMat& m);
// //! the assignment operator. This is O(1) operation - no data is copied
// SparseMat_& operator = (const SparseMat_& m);
// //! converts dense matrix to the sparse form
// SparseMat_& operator = (const Mat& m);
//
// //! makes full copy of the matrix. All the elements are duplicated
// SparseMat_ clone() const;
// //! equivalent to cv::SparseMat::create(dims, _sizes, DataType<_Tp>::type)
// void create(int dims, const int* _sizes);
// //! converts sparse matrix to the old-style CvSparseMat. All the elements are copied
// operator CvSparseMat*() const;
//
// //! returns type of the matrix elements
// int type() const;
// //! returns depth of the matrix elements
// int depth() const;
// //! returns the number of channels in each matrix element
// int channels() const;
//
// //! equivalent to SparseMat::ref<_Tp>(i0, hashval)
// _Tp& ref(int i0, size_t* hashval=0);
// //! equivalent to SparseMat::ref<_Tp>(i0, i1, hashval)
// _Tp& ref(int i0, int i1, size_t* hashval=0);
// //! equivalent to SparseMat::ref<_Tp>(i0, i1, i2, hashval)
// _Tp& ref(int i0, int i1, int i2, size_t* hashval=0);
// //! equivalent to SparseMat::ref<_Tp>(idx, hashval)
// _Tp& ref(const int* idx, size_t* hashval=0);
//
// //! equivalent to SparseMat::value<_Tp>(i0, hashval)
// _Tp operator()(int i0, size_t* hashval=0) const;
// //! equivalent to SparseMat::value<_Tp>(i0, i1, hashval)
// _Tp operator()(int i0, int i1, size_t* hashval=0) const;
// //! equivalent to SparseMat::value<_Tp>(i0, i1, i2, hashval)
// _Tp operator()(int i0, int i1, int i2, size_t* hashval=0) const;
// //! equivalent to SparseMat::value<_Tp>(idx, hashval)
// _Tp operator()(const int* idx, size_t* hashval=0) const;
//
// //! returns sparse matrix iterator pointing to the first sparse matrix element
// SparseMatIterator_<_Tp> begin();
// //! returns read-only sparse matrix iterator pointing to the first sparse matrix element
// SparseMatConstIterator_<_Tp> begin() const;
// //! returns sparse matrix iterator pointing to the element following the last sparse matrix element
// SparseMatIterator_<_Tp> end();
// //! returns read-only sparse matrix iterator pointing to the element following the last sparse matrix element
// SparseMatConstIterator_<_Tp> end() const;
// };
//
//
/// *!
// Template Read-Only Sparse Matrix Iterator Class.
//
// This is the derived from SparseMatConstIterator class that
// introduces more convenient operator *() for accessing the current element.
// */
// template<typename _Tp> class CV_EXPORTS SparseMatConstIterator_ : public SparseMatConstIterator
// {
// public:
// typedef std::forward_iterator_tag iterator_category;
//
// //! the default constructor
// SparseMatConstIterator_();
// //! the full constructor setting the iterator to the first sparse matrix element
// SparseMatConstIterator_(const SparseMat_<_Tp>* _m);
// //! the copy constructor
// SparseMatConstIterator_(const SparseMatConstIterator_& it);
//
// //! the assignment operator
// SparseMatConstIterator_& operator = (const SparseMatConstIterator_& it);
// //! the element access operator
// const _Tp& operator *() const;
//
// //! moves iterator to the next element
// SparseMatConstIterator_& operator ++();
// //! moves iterator to the next element
// SparseMatConstIterator_ operator ++(int);
// };
//
/// *!
// Template Read-Write Sparse Matrix Iterator Class.
//
// This is the derived from cv::SparseMatConstIterator_ class that
// introduces more convenient operator *() for accessing the current element.
// */
// template<typename _Tp> class CV_EXPORTS SparseMatIterator_ : public SparseMatConstIterator_<_Tp>
// {
// public:
// typedef std::forward_iterator_tag iterator_category;
//
// //! the default constructor
// SparseMatIterator_();
// //! the full constructor setting the iterator to the first sparse matrix element
// SparseMatIterator_(SparseMat_<_Tp>* _m);
// //! the copy constructor
// SparseMatIterator_(const SparseMatIterator_& it);
//
// //! the assignment operator
// SparseMatIterator_& operator = (const SparseMatIterator_& it);
// //! returns the reference to the current element
// _Tp& operator *() const;
//
// //! moves the iterator to the next element
// SparseMatIterator_& operator ++();
// //! moves the iterator to the next element
// SparseMatIterator_ operator ++(int);
// };
//
/// /////////////////// Fast Nearest-Neighbor Search Structure ////////////////////
//
/// *!
// Fast Nearest Neighbor Search Class.
//
// The class implements D. Lowe BBF (Best-Bin-First) algorithm for the last
// approximate (or accurate) nearest neighbor search in multi-dimensional spaces.
//
// First, a set of vectors is passed to KDTree::KDTree() constructor
// or KDTree::build() method, where it is reordered.
//
// Then arbitrary vectors can be passed to KDTree::findNearest() methods, which
// find the K nearest neighbors among the vectors from the initial set.
// The user can balance between the speed and accuracy of the search by varying Emax
// parameter, which is the number of leaves that the algorithm checks.
// The larger parameter values yield more accurate results at the expense of lower processing speed.
//
// \code
// KDTree T(points, false);
// const int K = 3, Emax = INT_MAX;
// int idx[K];
// float dist[K];
// T.findNearest(query_vec, K, Emax, idx, 0, dist);
// CV_Assert(dist[0] <= dist[1] && dist[1] <= dist[2]);
// \endcode
// */
// class CV_EXPORTS_W KDTree
// {
// public:
// /*!
// The node of the search tree.
// */
// struct Node
// {
// Node() : idx(-1), left(-1), right(-1), boundary(0.f) {}
// Node(int _idx, int _left, int _right, float _boundary)
// : idx(_idx), left(_left), right(_right), boundary(_boundary) {}
// //! split dimension; >=0 for nodes (dim), < 0 for leaves (index of the point)
// int idx;
// //! node indices of the left and the right branches
// int left, right;
// //! go to the left if query_vec[node.idx]<=node.boundary, otherwise go to the right
// float boundary;
// };
//
// //! the default constructor
// CV_WRAP KDTree();
// //! the full constructor that builds the search tree
// CV_WRAP KDTree(InputArray points, bool copyAndReorderPoints=false);
// //! the full constructor that builds the search tree
// CV_WRAP KDTree(InputArray points, InputArray _labels,
// bool copyAndReorderPoints=false);
// //! builds the search tree
// CV_WRAP void build(InputArray points, bool copyAndReorderPoints=false);
// //! builds the search tree
// CV_WRAP void build(InputArray points, InputArray labels,
// bool copyAndReorderPoints=false);
// //! finds the K nearest neighbors of "vec" while looking at Emax (at most) leaves
// CV_WRAP int findNearest(InputArray vec, int K, int Emax,
// OutputArray neighborsIdx,
// OutputArray neighbors=noArray(),
// OutputArray dist=noArray(),
// OutputArray labels=noArray()) const;
// //! finds all the points from the initial set that belong to the specified box
// CV_WRAP void findOrthoRange(InputArray minBounds,
// InputArray maxBounds,
// OutputArray neighborsIdx,
// OutputArray neighbors=noArray(),
// OutputArray labels=noArray()) const;
// //! returns vectors with the specified indices
// CV_WRAP void getPoints(InputArray idx, OutputArray pts,
// OutputArray labels=noArray()) const;
// //! return a vector with the specified index
// const float* getPoint(int ptidx, int* label=0) const;
// //! returns the search space dimensionality
// CV_WRAP int dims() const;
//
// std::vector<Node> nodes; //!< all the tree nodes
// CV_PROP Mat points; //!< all the points. It can be a reordered copy of the input vector set or the original vector set.
// CV_PROP std::vector<int> labels; //!< the parallel array of labels.
// CV_PROP int maxDepth; //!< maximum depth of the search tree. Do not modify it
// CV_PROP_RW int normType; //!< type of the distance (cv::NORM_L1 or cv::NORM_L2) used for search. Initially set to cv::NORM_L2, but you can modify it
// };
//
/// /////////////////////////////////////// XML & YAML I/O ////////////////////////////////////
//
// class CV_EXPORTS FileNode;
//
/// *!
// XML/YAML File Storage Class.
//
// The class describes an object associated with XML or YAML file.
// It can be used to store data to such a file or read and decode the data.
//
// The storage is organized as a tree of nested sequences (or lists) and mappings.
// Sequence is a heterogenious array, which elements are accessed by indices or sequentially using an iterator.
// Mapping is analogue of std::map or C structure, which elements are accessed by names.
// The most top level structure is a mapping.
// Leaves of the file storage tree are integers, floating-point numbers and text strings.
//
// For example, the following code:
//
// \code
// // open file storage for writing. Type of the file is determined from the extension
// FileStorage fs("test.yml", FileStorage::WRITE);
// fs << "test_int" << 5 << "test_real" << 3.1 << "test_string" << "ABCDEFGH";
// fs << "test_mat" << Mat::eye(3,3,CV_32F);
//
// fs << "test_list" << "[" << 0.0000000000001 << 2 << CV_PI << -3435345 << "2-502 2-029 3egegeg" <<
// "{:" << "month" << 12 << "day" << 31 << "year" << 1969 << "}" << "]";
// fs << "test_map" << "{" << "x" << 1 << "y" << 2 << "width" << 100 << "height" << 200 << "lbp" << "[:";
//
// const uchar arr[] = {0, 1, 1, 0, 1, 1, 0, 1};
// fs.writeRaw("u", arr, (int)(sizeof(arr)/sizeof(arr[0])));
//
// fs << "]" << "}";
// \endcode
//
// will produce the following file:
//
// \verbatim
// %YAML:1.0
// test_int: 5
// test_real: 3.1000000000000001e+00
// test_string: ABCDEFGH
// test_mat: !!opencv-matrix
// rows: 3
// cols: 3
// dt: f
// data: [ 1., 0., 0., 0., 1., 0., 0., 0., 1. ]
// test_list:
// - 1.0000000000000000e-13
// - 2
// - 3.1415926535897931e+00
// - -3435345
// - "2-502 2-029 3egegeg"
// - { month:12, day:31, year:1969 }
// test_map:
// x: 1
// y: 2
// width: 100
// height: 200
// lbp: [ 0, 1, 1, 0, 1, 1, 0, 1 ]
// \endverbatim
//
// and to read the file above, the following code can be used:
//
// \code
// // open file storage for reading.
// // Type of the file is determined from the content, not the extension
// FileStorage fs("test.yml", FileStorage::READ);
// int test_int = (int)fs["test_int"];
// double test_real = (double)fs["test_real"];
// String test_string = (String)fs["test_string"];
//
// Mat M;
// fs["test_mat"] >> M;
//
// FileNode tl = fs["test_list"];
// CV_Assert(tl.type() == FileNode::SEQ && tl.size() == 6);
// double tl0 = (double)tl[0];
// int tl1 = (int)tl[1];
// double tl2 = (double)tl[2];
// int tl3 = (int)tl[3];
// String tl4 = (String)tl[4];
// CV_Assert(tl[5].type() == FileNode::MAP && tl[5].size() == 3);
//
// int month = (int)tl[5]["month"];
// int day = (int)tl[5]["day"];
// int year = (int)tl[5]["year"];
//
// FileNode tm = fs["test_map"];
//
// int x = (int)tm["x"];
// int y = (int)tm["y"];
// int width = (int)tm["width"];
// int height = (int)tm["height"];
//
// int lbp_val = 0;
// FileNodeIterator it = tm["lbp"].begin();
//
// for(int k = 0; k < 8; k++, ++it)
// lbp_val |= ((int)*it) << k;
// \endcode
// */
// class CV_EXPORTS_W FileStorage
// {
// public:
// //! file storage mode
// enum
// {
// READ=0, //! read mode
// WRITE=1, //! write mode
// APPEND=2, //! append mode
// MEMORY=4,
// FORMAT_MASK=(7<<3),
// FORMAT_AUTO=0,
// FORMAT_XML=(1<<3),
// FORMAT_YAML=(2<<3)
// };
// enum
// {
// UNDEFINED=0,
// VALUE_EXPECTED=1,
// NAME_EXPECTED=2,
// INSIDE_MAP=4
// };
// //! the default constructor
// CV_WRAP FileStorage();
// //! the full constructor that opens file storage for reading or writing
// CV_WRAP FileStorage(const String& source, int flags, const String& encoding=String());
// //! the constructor that takes pointer to the C FileStorage structure
// FileStorage(CvFileStorage* fs);
// //! the destructor. calls release()
// virtual ~FileStorage();
//
// //! opens file storage for reading or writing. The previous storage is closed with release()
// CV_WRAP virtual bool open(const String& filename, int flags, const String& encoding=String());
// //! returns true if the object is associated with currently opened file.
// CV_WRAP virtual bool isOpened() const;
// //! closes the file and releases all the memory buffers
// CV_WRAP virtual void release();
// //! closes the file, releases all the memory buffers and returns the text string
// CV_WRAP virtual String releaseAndGetString();
//
// //! returns the first element of the top-level mapping
// CV_WRAP FileNode getFirstTopLevelNode() const;
// //! returns the top-level mapping. YAML supports multiple streams
// CV_WRAP FileNode root(int streamidx=0) const;
// //! returns the specified element of the top-level mapping
// FileNode operator[](const String& nodename) const;
// //! returns the specified element of the top-level mapping
// CV_WRAP FileNode operator[](const char* nodename) const;
//
// //! returns pointer to the underlying C FileStorage structure
// CvFileStorage* operator *() { return fs; }
// //! returns pointer to the underlying C FileStorage structure
// const CvFileStorage* operator *() const { return fs; }
// //! writes one or more numbers of the specified format to the currently written structure
// void writeRaw( const String& fmt, const uchar* vec, size_t len );
// //! writes the registered C structure (CvMat, CvMatND, CvSeq). See cvWrite()
// void writeObj( const String& name, const void* obj );
//
// //! returns the normalized object name for the specified file name
// static String getDefaultObjectName(const String& filename);
//
// Ptr<CvFileStorage> fs; //!< the underlying C FileStorage structure
// String elname; //!< the currently written element
// std::vector<char> structs; //!< the stack of written structures
// int state; //!< the writer state
// };
//
// class CV_EXPORTS FileNodeIterator;
//
/// *!
// File Storage Node class
//
// The node is used to store each and every element of the file storage opened for reading -
// from the primitive objects, such as numbers and text strings, to the complex nodes:
// sequences, mappings and the registered objects.
//
// Note that file nodes are only used for navigating file storages opened for reading.
// When a file storage is opened for writing, no data is stored in memory after it is written.
// */
// class CV_EXPORTS_W_SIMPLE FileNode
// {
// public:
// //! type of the file storage node
// enum
// {
// NONE=0, //!< empty node
// INT=1, //!< an integer
// REAL=2, //!< floating-point number
// FLOAT=REAL, //!< synonym or REAL
// STR=3, //!< text string in UTF-8 encoding
// STRING=STR, //!< synonym for STR
// REF=4, //!< integer of size size_t. Typically used for storing complex dynamic structures where some elements reference the others
// SEQ=5, //!< sequence
// MAP=6, //!< mapping
// TYPE_MASK=7,
// FLOW=8, //!< compact representation of a sequence or mapping. Used only by YAML writer
// USER=16, //!< a registered object (e.g. a matrix)
// EMPTY=32, //!< empty structure (sequence or mapping)
// NAMED=64 //!< the node has a name (i.e. it is element of a mapping)
// };
// //! the default constructor
// CV_WRAP FileNode();
// //! the full constructor wrapping CvFileNode structure.
// FileNode(const CvFileStorage* fs, const CvFileNode* node);
// //! the copy constructor
// FileNode(const FileNode& node);
// //! returns element of a mapping node
// FileNode operator[](const String& nodename) const;
// //! returns element of a mapping node
// CV_WRAP FileNode operator[](const char* nodename) const;
// //! returns element of a sequence node
// CV_WRAP FileNode operator[](int i) const;
// //! returns type of the node
// CV_WRAP int type() const;
//
// //! returns true if the node is empty
// CV_WRAP bool empty() const;
// //! returns true if the node is a "none" object
// CV_WRAP bool isNone() const;
// //! returns true if the node is a sequence
// CV_WRAP bool isSeq() const;
// //! returns true if the node is a mapping
// CV_WRAP bool isMap() const;
// //! returns true if the node is an integer
// CV_WRAP bool isInt() const;
// //! returns true if the node is a floating-point number
// CV_WRAP bool isReal() const;
// //! returns true if the node is a text string
// CV_WRAP bool isString() const;
// //! returns true if the node has a name
// CV_WRAP bool isNamed() const;
// //! returns the node name or an empty string if the node is nameless
// CV_WRAP String name() const;
// //! returns the number of elements in the node, if it is a sequence or mapping, or 1 otherwise.
// CV_WRAP size_t size() const;
// //! returns the node content as an integer. If the node stores floating-point number, it is rounded.
// operator int() const;
// //! returns the node content as float
// operator float() const;
// //! returns the node content as double
// operator double() const;
// //! returns the node content as text string
// operator String() const;
// #ifndef OPENCV_NOSTL
// operator std::string() const;
// #endif
//
// //! returns pointer to the underlying file node
// CvFileNode* operator *();
// //! returns pointer to the underlying file node
// const CvFileNode* operator* () const;
//
// //! returns iterator pointing to the first node element
// FileNodeIterator begin() const;
// //! returns iterator pointing to the element following the last node element
// FileNodeIterator end() const;
//
// //! reads node elements to the buffer with the specified format
// void readRaw( const String& fmt, uchar* vec, size_t len ) const;
// //! reads the registered object and returns pointer to it
// void* readObj() const;
//
// // do not use wrapper pointer classes for better efficiency
// const CvFileStorage* fs;
// const CvFileNode* node;
// };
//
//
/// *!
// File Node Iterator
//
// The class is used for iterating sequences (usually) and mappings.
// */
// class CV_EXPORTS FileNodeIterator
// {
// public:
// //! the default constructor
// FileNodeIterator();
// //! the full constructor set to the ofs-th element of the node
// FileNodeIterator(const CvFileStorage* fs, const CvFileNode* node, size_t ofs=0);
// //! the copy constructor
// FileNodeIterator(const FileNodeIterator& it);
// //! returns the currently observed element
// FileNode operator *() const;
// //! accesses the currently observed element methods
// FileNode operator ->() const;
//
// //! moves iterator to the next node
// FileNodeIterator& operator ++ ();
// //! moves iterator to the next node
// FileNodeIterator operator ++ (int);
// //! moves iterator to the previous node
// FileNodeIterator& operator -- ();
// //! moves iterator to the previous node
// FileNodeIterator operator -- (int);
// //! moves iterator forward by the specified offset (possibly negative)
// FileNodeIterator& operator += (int ofs);
// //! moves iterator backward by the specified offset (possibly negative)
// FileNodeIterator& operator -= (int ofs);
//
// //! reads the next maxCount elements (or less, if the sequence/mapping last element occurs earlier) to the buffer with the specified format
// FileNodeIterator& readRaw( const String& fmt, uchar* vec,
// size_t maxCount=(size_t)INT_MAX );
//
// const CvFileStorage* fs;
// const CvFileNode* container;
// CvSeqReader reader;
// size_t remaining;
// };
//
/// ///////////// convenient wrappers for operating old-style dynamic structures //////////////
//
// template<typename _Tp> class SeqIterator;
//
// typedef Ptr<CvMemStorage> MemStorage;
//
/// *!
// Template Sequence Class derived from CvSeq
//
// The class provides more convenient access to sequence elements,
// STL-style operations and iterators.
//
// \note The class is targeted for simple data types,
// i.e. no constructors or destructors
// are called for the sequence elements.
// */
// template<typename _Tp> class CV_EXPORTS Seq
// {
// public:
// typedef SeqIterator<_Tp> iterator;
// typedef SeqIterator<_Tp> const_iterator;
//
// //! the default constructor
// Seq();
// //! the constructor for wrapping CvSeq structure. The real element type in CvSeq should match _Tp.
// Seq(const CvSeq* seq);
// //! creates the empty sequence that resides in the specified storage
// Seq(MemStorage& storage, int headerSize = sizeof(CvSeq));
// //! returns read-write reference to the specified element
// _Tp& operator [](int idx);
// //! returns read-only reference to the specified element
// const _Tp& operator[](int idx) const;
// //! returns iterator pointing to the beginning of the sequence
// SeqIterator<_Tp> begin() const;
// //! returns iterator pointing to the element following the last sequence element
// SeqIterator<_Tp> end() const;
// //! returns the number of elements in the sequence
// size_t size() const;
// //! returns the type of sequence elements (CV_8UC1 ... CV_64FC(CV_CN_MAX) ...)
// int type() const;
// //! returns the depth of sequence elements (CV_8U ... CV_64F)
// int depth() const;
// //! returns the number of channels in each sequence element
// int channels() const;
// //! returns the size of each sequence element
// size_t elemSize() const;
// //! returns index of the specified sequence element
// size_t index(const _Tp& elem) const;
// //! appends the specified element to the end of the sequence
// void push_back(const _Tp& elem);
// //! appends the specified element to the front of the sequence
// void push_front(const _Tp& elem);
// //! appends zero or more elements to the end of the sequence
// void push_back(const _Tp* elems, size_t count);
// //! appends zero or more elements to the front of the sequence
// void push_front(const _Tp* elems, size_t count);
// //! inserts the specified element to the specified position
// void insert(int idx, const _Tp& elem);
// //! inserts zero or more elements to the specified position
// void insert(int idx, const _Tp* elems, size_t count);
// //! removes element at the specified position
// void remove(int idx);
// //! removes the specified subsequence
// void remove(const Range& r);
//
// //! returns reference to the first sequence element
// _Tp& front();
// //! returns read-only reference to the first sequence element
// const _Tp& front() const;
// //! returns reference to the last sequence element
// _Tp& back();
// //! returns read-only reference to the last sequence element
// const _Tp& back() const;
// //! returns true iff the sequence contains no elements
// bool empty() const;
//
// //! removes all the elements from the sequence
// void clear();
// //! removes the first element from the sequence
// void pop_front();
// //! removes the last element from the sequence
// void pop_back();
// //! removes zero or more elements from the beginning of the sequence
// void pop_front(_Tp* elems, size_t count);
// //! removes zero or more elements from the end of the sequence
// void pop_back(_Tp* elems, size_t count);
//
// //! copies the whole sequence or the sequence slice to the specified vector
// void copyTo(std::vector<_Tp>& vec, const Range& range=Range::all()) const;
// //! returns the vector containing all the sequence elements
// operator std::vector<_Tp>() const;
//
// CvSeq* seq;
// };
//
//
/// *!
// STL-style Sequence Iterator inherited from the CvSeqReader structure
// */
// template<typename _Tp> class CV_EXPORTS SeqIterator : public CvSeqReader
// {
// public:
// //! the default constructor
// SeqIterator();
// //! the constructor setting the iterator to the beginning or to the end of the sequence
// SeqIterator(const Seq<_Tp>& seq, bool seekEnd=false);
// //! positions the iterator within the sequence
// void seek(size_t pos);
// //! reports the current iterator position
// size_t tell() const;
// //! returns reference to the current sequence element
// _Tp& operator *();
// //! returns read-only reference to the current sequence element
// const _Tp& operator *() const;
// //! moves iterator to the next sequence element
// SeqIterator& operator ++();
// //! moves iterator to the next sequence element
// SeqIterator operator ++(int) const;
// //! moves iterator to the previous sequence element
// SeqIterator& operator --();
// //! moves iterator to the previous sequence element
// SeqIterator operator --(int) const;
//
// //! moves iterator forward by the specified offset (possibly negative)
// SeqIterator& operator +=(int);
// //! moves iterator backward by the specified offset (possibly negative)
// SeqIterator& operator -=(int);
//
// // this is index of the current element module seq->total*2
// // (to distinguish between 0 and seq->total)
// int index;
// };
//
// class CV_EXPORTS Algorithm;
// class CV_EXPORTS AlgorithmInfo;
// struct CV_EXPORTS AlgorithmInfoData;
//
// template<typename _Tp> struct ParamType {};
//
/// *!
// Base class for high-level OpenCV algorithms
// */
// class CV_EXPORTS_W Algorithm
// {
// public:
// Algorithm();
// virtual ~Algorithm();
// String name() const;
//
// template<typename _Tp> typename ParamType<_Tp>::member_type get(const String& name) const;
// template<typename _Tp> typename ParamType<_Tp>::member_type get(const char* name) const;
//
// CV_WRAP int getInt(const String& name) const;
// CV_WRAP double getDouble(const String& name) const;
// CV_WRAP bool getBool(const String& name) const;
// CV_WRAP String getString(const String& name) const;
// CV_WRAP Mat getMat(const String& name) const;
// CV_WRAP std::vector<Mat> getMatVector(const String& name) const;
// CV_WRAP Ptr<Algorithm> getAlgorithm(const String& name) const;
//
// void set(const String& name, int value);
// void set(const String& name, double value);
// void set(const String& name, bool value);
// void set(const String& name, const String& value);
// void set(const String& name, const Mat& value);
// void set(const String& name, const std::vector<Mat>& value);
// void set(const String& name, const Ptr<Algorithm>& value);
// template<typename _Tp> void set(const String& name, const Ptr<_Tp>& value);
//
// CV_WRAP void setInt(const String& name, int value);
// CV_WRAP void setDouble(const String& name, double value);
// CV_WRAP void setBool(const String& name, bool value);
// CV_WRAP void setString(const String& name, const String& value);
// CV_WRAP void setMat(const String& name, const Mat& value);
// CV_WRAP void setMatVector(const String& name, const std::vector<Mat>& value);
// CV_WRAP void setAlgorithm(const String& name, const Ptr<Algorithm>& value);
// template<typename _Tp> void setAlgorithm(const String& name, const Ptr<_Tp>& value);
//
// void set(const char* name, int value);
// void set(const char* name, double value);
// void set(const char* name, bool value);
// void set(const char* name, const String& value);
// void set(const char* name, const Mat& value);
// void set(const char* name, const std::vector<Mat>& value);
// void set(const char* name, const Ptr<Algorithm>& value);
// template<typename _Tp> void set(const char* name, const Ptr<_Tp>& value);
//
// void setInt(const char* name, int value);
// void setDouble(const char* name, double value);
// void setBool(const char* name, bool value);
// void setString(const char* name, const String& value);
// void setMat(const char* name, const Mat& value);
// void setMatVector(const char* name, const std::vector<Mat>& value);
// void setAlgorithm(const char* name, const Ptr<Algorithm>& value);
// template<typename _Tp> void setAlgorithm(const char* name, const Ptr<_Tp>& value);
//
// CV_WRAP String paramHelp(const String& name) const;
// int paramType(const char* name) const;
// CV_WRAP int paramType(const String& name) const;
// CV_WRAP void getParams(CV_OUT std::vector<String>& names) const;
//
//
// virtual void write(FileStorage& fs) const;
// virtual void read(const FileNode& fn);
//
// typedef Algorithm* (*Constructor)(void);
// typedef int (Algorithm::*Getter)() const;
// typedef void (Algorithm::*Setter)(int);
//
// CV_WRAP static void getList(CV_OUT std::vector<String>& algorithms);
// CV_WRAP static Ptr<Algorithm> _create(const String& name);
// template<typename _Tp> static Ptr<_Tp> create(const String& name);
//
// virtual AlgorithmInfo* info() const /* TODO: make it = 0;*/ { return 0; }
// };
//
//
// class CV_EXPORTS AlgorithmInfo
// {
// public:
// friend class Algorithm;
// AlgorithmInfo(const String& name, Algorithm::Constructor create);
// ~AlgorithmInfo();
// void get(const Algorithm* algo, const char* name, int argType, void* value) const;
// void addParam_(Algorithm& algo, const char* name, int argType,
// void* value, bool readOnly,
// Algorithm::Getter getter, Algorithm::Setter setter,
// const String& help=String());
// String paramHelp(const char* name) const;
// int paramType(const char* name) const;
// void getParams(std::vector<String>& names) const;
//
// void write(const Algorithm* algo, FileStorage& fs) const;
// void read(Algorithm* algo, const FileNode& fn) const;
// String name() const;
//
// void addParam(Algorithm& algo, const char* name,
// int& value, bool readOnly=false,
// int (Algorithm::*getter)()=0,
// void (Algorithm::*setter)(int)=0,
// const String& help=String());
// void addParam(Algorithm& algo, const char* name,
// bool& value, bool readOnly=false,
// int (Algorithm::*getter)()=0,
// void (Algorithm::*setter)(int)=0,
// const String& help=String());
// void addParam(Algorithm& algo, const char* name,
// double& value, bool readOnly=false,
// double (Algorithm::*getter)()=0,
// void (Algorithm::*setter)(double)=0,
// const String& help=String());
// void addParam(Algorithm& algo, const char* name,
// String& value, bool readOnly=false,
// String (Algorithm::*getter)()=0,
// void (Algorithm::*setter)(const String&)=0,
// const String& help=String());
// void addParam(Algorithm& algo, const char* name,
// Mat& value, bool readOnly=false,
// Mat (Algorithm::*getter)()=0,
// void (Algorithm::*setter)(const Mat&)=0,
// const String& help=String());
// void addParam(Algorithm& algo, const char* name,
// std::vector<Mat>& value, bool readOnly=false,
// std::vector<Mat> (Algorithm::*getter)()=0,
// void (Algorithm::*setter)(const std::vector<Mat>&)=0,
// const String& help=String());
// void addParam(Algorithm& algo, const char* name,
// Ptr<Algorithm>& value, bool readOnly=false,
// Ptr<Algorithm> (Algorithm::*getter)()=0,
// void (Algorithm::*setter)(const Ptr<Algorithm>&)=0,
// const String& help=String());
// void addParam(Algorithm& algo, const char* name,
// float& value, bool readOnly=false,
// float (Algorithm::*getter)()=0,
// void (Algorithm::*setter)(float)=0,
// const String& help=String());
// void addParam(Algorithm& algo, const char* name,
// unsigned int& value, bool readOnly=false,
// unsigned int (Algorithm::*getter)()=0,
// void (Algorithm::*setter)(unsigned int)=0,
// const String& help=String());
// void addParam(Algorithm& algo, const char* name,
// uint64& value, bool readOnly=false,
// uint64 (Algorithm::*getter)()=0,
// void (Algorithm::*setter)(uint64)=0,
// const String& help=String());
// void addParam(Algorithm& algo, const char* name,
// uchar& value, bool readOnly=false,
// uchar (Algorithm::*getter)()=0,
// void (Algorithm::*setter)(uchar)=0,
// const String& help=String());
// template<typename _Tp, typename _Base> void addParam(Algorithm& algo, const char* name,
// Ptr<_Tp>& value, bool readOnly=false,
// Ptr<_Tp> (Algorithm::*getter)()=0,
// void (Algorithm::*setter)(const Ptr<_Tp>&)=0,
// const String& help=String());
// template<typename _Tp> void addParam(Algorithm& algo, const char* name,
// Ptr<_Tp>& value, bool readOnly=false,
// Ptr<_Tp> (Algorithm::*getter)()=0,
// void (Algorithm::*setter)(const Ptr<_Tp>&)=0,
// const String& help=String());
// protected:
// AlgorithmInfoData* data;
// void set(Algorithm* algo, const char* name, int argType,
// const void* value, bool force=false) const;
// };
//
//
// struct CV_EXPORTS Param
// {
// enum { INT=0, BOOLEAN=1, REAL=2, STRING=3, MAT=4, MAT_VECTOR=5, ALGORITHM=6, FLOAT=7, UNSIGNED_INT=8, UINT64=9, UCHAR=11 };
//
// Param();
// Param(int _type, bool _readonly, int _offset,
// Algorithm::Getter _getter=0,
// Algorithm::Setter _setter=0,
// const String& _help=String());
// int type;
// int offset;
// bool readonly;
// Algorithm::Getter getter;
// Algorithm::Setter setter;
// String help;
// };
//
// template<> struct ParamType<bool>
// {
// typedef bool const_param_type;
// typedef bool member_type;
//
// enum { type = Param::BOOLEAN };
// };
//
// template<> struct ParamType<int>
// {
// typedef int const_param_type;
// typedef int member_type;
//
// enum { type = Param::INT };
// };
//
// template<> struct ParamType<double>
// {
// typedef double const_param_type;
// typedef double member_type;
//
// enum { type = Param::REAL };
// };
//
// template<> struct ParamType<String>
// {
// typedef const String& const_param_type;
// typedef String member_type;
//
// enum { type = Param::STRING };
// };
//
// template<> struct ParamType<Mat>
// {
// typedef const Mat& const_param_type;
// typedef Mat member_type;
//
// enum { type = Param::MAT };
// };
//
// template<> struct ParamType<std::vector<Mat> >
// {
// typedef const std::vector<Mat>& const_param_type;
// typedef std::vector<Mat> member_type;
//
// enum { type = Param::MAT_VECTOR };
// };
//
// template<> struct ParamType<Algorithm>
// {
// typedef const Ptr<Algorithm>& const_param_type;
// typedef Ptr<Algorithm> member_type;
//
// enum { type = Param::ALGORITHM };
// };
//
// template<> struct ParamType<float>
// {
// typedef float const_param_type;
// typedef float member_type;
//
// enum { type = Param::FLOAT };
// };
//
// template<> struct ParamType<unsigned>
// {
// typedef unsigned const_param_type;
// typedef unsigned member_type;
//
// enum { type = Param::UNSIGNED_INT };
// };
//
// template<> struct ParamType<uint64>
// {
// typedef uint64 const_param_type;
// typedef uint64 member_type;
//
// enum { type = Param::UINT64 };
// };
//
// template<> struct ParamType<uchar>
// {
// typedef uchar const_param_type;
// typedef uchar member_type;
//
// enum { type = Param::UCHAR };
// };
//
// } //namespace cv
//
// #include "opencv2/core/operations.hpp"
// #include "opencv2/core/mat.hpp"
//
// #include "opencv2/core/cvstd.inl.hpp"
// #endif // __cplusplus
//
//
// #endif /*__OPENCV_CORE_HPP__*/

implementation

procedure absdiff(src1: pIplImage; src2: pIplImage; dst: pIplImage);
begin
  // arithm_op(src1, src2, dst, noArray(), -1, absdiffTab);
end;

end.