#include "opencv2/core/cvdef.h"
#include "opencv2/core/version.hpp"
-#include "opencv2/core/types_c.h"
-
#ifdef __cplusplus
-#include "opencv2/core/cvstd.hpp"
#include "opencv2/core/base.hpp"
+#include "opencv2/core/cvstd.hpp"
#include "opencv2/core/traits.hpp"
#include "opencv2/core/matx.hpp"
#include "opencv2/core/types.hpp"
+#endif
+
+#include "opencv2/core/types_c.h"
+
+#ifdef __cplusplus
#ifndef SKIP_INCLUDES
#include <limits.h>
*/
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
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 //////////////////////////
/*!
#ifndef __OPENCV_CORE_BASE_HPP__
#define __OPENCV_CORE_BASE_HPP__
+#include <climits>
+
#include "opencv2/core/cvdef.h"
+#include "opencv2/core/cvstd.hpp"
namespace cv
{
+// error codes
+namespace Error {
+enum {
+ StsOk= 0, /* everithing is ok */
+ StsBackTrace= -1, /* pseudo error for back trace */
+ StsError= -2, /* unknown /unspecified error */
+ StsInternal= -3, /* internal error (bad state) */
+ StsNoMem= -4, /* insufficient memory */
+ StsBadArg= -5, /* function arg/param is bad */
+ StsBadFunc= -6, /* unsupported function */
+ StsNoConv= -7, /* iter. didn't converge */
+ StsAutoTrace= -8, /* tracing */
+ HeaderIsNull= -9, /* image header is NULL */
+ BadImageSize= -10, /* image size is invalid */
+ BadOffset= -11, /* offset is invalid */
+ BadDataPtr= -12, /**/
+ BadStep= -13, /**/
+ BadModelOrChSeq= -14, /**/
+ BadNumChannels= -15, /**/
+ BadNumChannel1U= -16, /**/
+ BadDepth= -17, /**/
+ BadAlphaChannel= -18, /**/
+ BadOrder= -19, /**/
+ BadOrigin= -20, /**/
+ BadAlign= -21, /**/
+ BadCallBack= -22, /**/
+ BadTileSize= -23, /**/
+ BadCOI= -24, /**/
+ BadROISize= -25, /**/
+ MaskIsTiled= -26, /**/
+ StsNullPtr= -27, /* null pointer */
+ StsVecLengthErr= -28, /* incorrect vector length */
+ StsFilterStructContentErr= -29, /* incorr. filter structure content */
+ StsKernelStructContentErr= -30, /* incorr. transform kernel content */
+ StsFilterOffsetErr= -31, /* incorrect filter ofset value */
+ StsBadSize= -201, /* the input/output structure size is incorrect */
+ StsDivByZero= -202, /* division by zero */
+ StsInplaceNotSupported= -203, /* in-place operation is not supported */
+ StsObjectNotFound= -204, /* request can't be completed */
+ StsUnmatchedFormats= -205, /* formats of input/output arrays differ */
+ StsBadFlag= -206, /* flag is wrong or not supported */
+ StsBadPoint= -207, /* bad CvPoint */
+ StsBadMask= -208, /* bad format of mask (neither 8uC1 nor 8sC1)*/
+ StsUnmatchedSizes= -209, /* sizes of input/output structures do not match */
+ StsUnsupportedFormat= -210, /* the data format/type is not supported by the function*/
+ StsOutOfRange= -211, /* some of parameters are out of range */
+ StsParseError= -212, /* invalid syntax/structure of the parsed file */
+ StsNotImplemented= -213, /* the requested function/feature is not implemented */
+ StsBadMemBlock= -214, /* an allocated block has been corrupted */
+ StsAssert= -215, /* assertion failed */
+ GpuNotSupported= -216,
+ GpuApiCallError= -217,
+ OpenGlNotSupported= -218,
+ OpenGlApiCallError= -219
+};
+} //Error
+
// matrix decomposition types
enum { DECOMP_LU = 0,
DECOMP_SVD = 1,
+//////////////// static assert /////////////////
+
+#define CVAUX_CONCAT_EXP(a, b) a##b
+#define CVAUX_CONCAT(a, b) CVAUX_CONCAT_EXP(a,b)
+
+#if defined(__clang__)
+# ifndef __has_extension
+# define __has_extension __has_feature /* compatibility, for older versions of clang */
+# endif
+# if __has_extension(cxx_static_assert)
+# define CV_StaticAssert(condition, reason) static_assert((condition), reason " " #condition)
+# endif
+#elif defined(__GNUC__)
+# if (defined(__GXX_EXPERIMENTAL_CXX0X__) || __cplusplus >= 201103L)
+# define CV_StaticAssert(condition, reason) static_assert((condition), reason " " #condition)
+# endif
+#elif defined(_MSC_VER)
+# if _MSC_VER >= 1600 /* MSVC 10 */
+# define CV_StaticAssert(condition, reason) static_assert((condition), reason " " #condition)
+# endif
+#endif
+#ifndef CV_StaticAssert
+# if defined(__GNUC__) && (__GNUC__ > 3) && (__GNUC_MINOR__ > 2)
+# define CV_StaticAssert(condition, reason) ({ extern int __attribute__((error("CV_StaticAssert: " reason " " #condition))) CV_StaticAssert(); ((condition) ? 0 : CV_StaticAssert()); })
+# else
+ namespace cv {
+ template <bool x> struct CV_StaticAssert_failed;
+ template <> struct CV_StaticAssert_failed<true> { enum { val = 1 }; };
+ template<int x> struct CV_StaticAssert_test{};
+ }
+# define CV_StaticAssert(condition, reason)\
+ typedef cv::CV_StaticAssert_test< sizeof(cv::CV_StaticAssert_failed< static_cast<bool>(condition) >) > CVAUX_CONCAT(CV_StaticAssert_failed_at_, __LINE__)
+# endif
+#endif
+
+
+
+//! 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(int _code, const String& _err, const char* _func, const char* _file, int _line);
+
+#ifdef __GNUC__
+# define CV_Error( code, msg ) cv::error( code, msg, __func__, __FILE__, __LINE__ )
+# define CV_Error_( code, args ) cv::error( code, cv::format args, __func__, __FILE__, __LINE__ )
+# define CV_Assert( expr ) if(!!(expr)) ; else cv::error( cv::Error::StsAssert, #expr, __func__, __FILE__, __LINE__ )
+#else
+# define CV_Error( code, msg ) cv::error( code, msg, "", __FILE__, __LINE__ )
+# define CV_Error_( code, args ) cv::error( code, cv::format args, "", __FILE__, __LINE__ )
+# define CV_Assert( expr ) if(!!(expr)) ; else cv::error( cv::Error::StsAssert, #expr, "", __FILE__, __LINE__ )
+#endif
+
+#ifdef _DEBUG
+# define CV_DbgAssert(expr) CV_Assert(expr)
+#else
+# define CV_DbgAssert(expr)
+#endif
+
+
+
/////////////// saturate_cast (used in image & signal processing) ///////////////////
template<typename _Tp> static inline _Tp saturate_cast(uchar v) { return _Tp(v); }
+//////////////////////////////// low-level functions ////////////////////////////////
+CV_EXPORTS int LU(float* A, size_t astep, int m, float* b, size_t bstep, int n);
+CV_EXPORTS int LU(double* A, size_t astep, int m, double* b, size_t bstep, int n);
+CV_EXPORTS bool Cholesky(float* A, size_t astep, int m, float* b, size_t bstep, int n);
+CV_EXPORTS bool Cholesky(double* A, size_t astep, int m, double* b, size_t bstep, int n);
+CV_EXPORTS float normL2Sqr_(const float* a, const float* b, int n);
+CV_EXPORTS float normL1_(const float* a, const float* b, int n);
+CV_EXPORTS int normL1_(const uchar* a, const uchar* b, int n);
+CV_EXPORTS int normHamming(const uchar* a, const uchar* b, int n);
+CV_EXPORTS int normHamming(const uchar* a, const uchar* b, int n, int cellSize);
+
+
+
////////////////// forward declarations for important OpenCV types //////////////////
template<typename _Tp, int cn> class CV_EXPORTS Vec;
class CV_EXPORTS GpuMat;
}
+
+
} // cv
#endif //__OPENCV_CORE_BASE_HPP__
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 = DataType<_Tp>::depth,
rows = m,
cols = n,
channels = rows*cols,
- type = CV_MAKETYPE(depth, channels)
+ type = CV_MAKETYPE(depth, channels),
+ shortdim = (m < n ? m : n)
};
+ typedef _Tp value_type;
+ typedef Matx<_Tp, m, n> mat_type;
+ typedef Matx<_Tp, shortdim, 1> diag_type;
+
//! default constructor
Matx();
};
};
+/*!
+ Comma-separated Matrix Initializer
+*/
+template<typename _Tp, int m, int n> class 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;
+};
+
+/*!
+ Utility methods
+*/
+template<typename _Tp, int m> double determinant(const Matx<_Tp, m, m>& a);
+template<typename _Tp, int m, int n> double trace(const Matx<_Tp, m, n>& a);
+
/////////////////////// Vec (used as element of multi-channel images /////////////////////
};
};
+/*!
+ Comma-separated Vec Initializer
+*/
+template<typename _Tp, int m> class 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;
+};
+
+
+
+///////////////////////////////////// helper classes /////////////////////////////////////
+namespace internal
+{
+
+template<typename _Tp, int m> struct Matx_DetOp
+{
+ double operator ()(const Matx<_Tp, m, m>& a) const
+ {
+ Matx<_Tp, m, m> temp = a;
+ double p = LU(temp.val, m*sizeof(_Tp), m, 0, 0, 0);
+ if( p == 0 )
+ return p;
+ for( int i = 0; i < m; i++ )
+ p *= temp(i, i);
+ return 1./p;
+ }
+};
+
+template<typename _Tp> struct Matx_DetOp<_Tp, 1>
+{
+ double operator ()(const Matx<_Tp, 1, 1>& a) const
+ {
+ return a(0,0);
+ }
+};
+
+template<typename _Tp> struct Matx_DetOp<_Tp, 2>
+{
+ double operator ()(const Matx<_Tp, 2, 2>& a) const
+ {
+ return a(0,0)*a(1,1) - a(0,1)*a(1,0);
+ }
+};
+
+template<typename _Tp> struct Matx_DetOp<_Tp, 3>
+{
+ double operator ()(const Matx<_Tp, 3, 3>& a) const
+ {
+ return a(0,0)*(a(1,1)*a(2,2) - a(2,1)*a(1,2)) -
+ a(0,1)*(a(1,0)*a(2,2) - a(2,0)*a(1,2)) +
+ a(0,2)*(a(1,0)*a(2,1) - a(2,0)*a(1,1));
+ }
+};
+
+template<typename _Tp> Vec<_Tp, 2> inline conjugate(const Vec<_Tp, 2>& v)
+{
+ return Vec<_Tp, 2>(v[0], -v[1]);
+}
+
+template<typename _Tp> Vec<_Tp, 4> inline conjugate(const Vec<_Tp, 4>& v)
+{
+ return Vec<_Tp, 4>(v[0], -v[1], -v[2], -v[3]);
+}
+
+} // internal
+
+
+
+////////////////////////////////// Matx Implementation ///////////////////////////////////
+
+template<typename _Tp, int m, int n> inline
+Matx<_Tp, m, n>::Matx()
+{
+ for(int i = 0; i < channels; i++) val[i] = _Tp(0);
+}
+
+template<typename _Tp, int m, int n> inline
+Matx<_Tp, m, n>::Matx(_Tp v0)
+{
+ val[0] = v0;
+ for(int i = 1; i < channels; i++) val[i] = _Tp(0);
+}
+
+template<typename _Tp, int m, int n> inline
+Matx<_Tp, m, n>::Matx(_Tp v0, _Tp v1)
+{
+ CV_StaticAssert(channels >= 2, "Matx should have at least 2 elaments.");
+ val[0] = v0; val[1] = v1;
+ for(int i = 2; i < channels; i++) val[i] = _Tp(0);
+}
+
+template<typename _Tp, int m, int n> inline
+Matx<_Tp, m, n>::Matx(_Tp v0, _Tp v1, _Tp v2)
+{
+ CV_StaticAssert(channels >= 3, "Matx should have at least 3 elaments.");
+ val[0] = v0; val[1] = v1; val[2] = v2;
+ for(int i = 3; i < channels; i++) val[i] = _Tp(0);
+}
+
+template<typename _Tp, int m, int n> inline
+Matx<_Tp, m, n>::Matx(_Tp v0, _Tp v1, _Tp v2, _Tp v3)
+{
+ CV_StaticAssert(channels >= 4, "Matx should have at least 4 elaments.");
+ val[0] = v0; val[1] = v1; val[2] = v2; val[3] = v3;
+ for(int i = 4; i < channels; i++) val[i] = _Tp(0);
+}
+
+template<typename _Tp, int m, int n> inline
+Matx<_Tp, m, n>::Matx(_Tp v0, _Tp v1, _Tp v2, _Tp v3, _Tp v4)
+{
+ CV_StaticAssert(channels >= 5, "Matx should have at least 5 elaments.");
+ val[0] = v0; val[1] = v1; val[2] = v2; val[3] = v3; val[4] = v4;
+ for(int i = 5; i < channels; i++) val[i] = _Tp(0);
+}
+
+template<typename _Tp, int m, int n> inline
+Matx<_Tp, m, n>::Matx(_Tp v0, _Tp v1, _Tp v2, _Tp v3, _Tp v4, _Tp v5)
+{
+ CV_StaticAssert(channels >= 6, "Matx should have at least 6 elaments.");
+ val[0] = v0; val[1] = v1; val[2] = v2; val[3] = v3;
+ val[4] = v4; val[5] = v5;
+ for(int i = 6; i < channels; i++) val[i] = _Tp(0);
+}
+
+template<typename _Tp, int m, int n> inline
+Matx<_Tp, m, n>::Matx(_Tp v0, _Tp v1, _Tp v2, _Tp v3, _Tp v4, _Tp v5, _Tp v6)
+{
+ CV_StaticAssert(channels >= 7, "Matx should have at least 7 elaments.");
+ val[0] = v0; val[1] = v1; val[2] = v2; val[3] = v3;
+ val[4] = v4; val[5] = v5; val[6] = v6;
+ for(int i = 7; i < channels; i++) val[i] = _Tp(0);
+}
+
+template<typename _Tp, int m, int n> inline
+Matx<_Tp, m, n>::Matx(_Tp v0, _Tp v1, _Tp v2, _Tp v3, _Tp v4, _Tp v5, _Tp v6, _Tp v7)
+{
+ CV_StaticAssert(channels >= 8, "Matx should have at least 8 elaments.");
+ val[0] = v0; val[1] = v1; val[2] = v2; val[3] = v3;
+ val[4] = v4; val[5] = v5; val[6] = v6; val[7] = v7;
+ for(int i = 8; i < channels; i++) val[i] = _Tp(0);
+}
+
+template<typename _Tp, int m, int n> inline
+Matx<_Tp, m, n>::Matx(_Tp v0, _Tp v1, _Tp v2, _Tp v3, _Tp v4, _Tp v5, _Tp v6, _Tp v7, _Tp v8)
+{
+ CV_StaticAssert(channels >= 9, "Matx should have at least 9 elaments.");
+ val[0] = v0; val[1] = v1; val[2] = v2; val[3] = v3;
+ val[4] = v4; val[5] = v5; val[6] = v6; val[7] = v7;
+ val[8] = v8;
+ for(int i = 9; i < channels; i++) val[i] = _Tp(0);
+}
+
+template<typename _Tp, int m, int n> inline
+Matx<_Tp, m, n>::Matx(_Tp v0, _Tp v1, _Tp v2, _Tp v3, _Tp v4, _Tp v5, _Tp v6, _Tp v7, _Tp v8, _Tp v9)
+{
+ CV_StaticAssert(channels >= 10, "Matx should have at least 10 elaments.");
+ val[0] = v0; val[1] = v1; val[2] = v2; val[3] = v3;
+ val[4] = v4; val[5] = v5; val[6] = v6; val[7] = v7;
+ val[8] = v8; val[9] = v9;
+ for(int i = 10; i < channels; i++) val[i] = _Tp(0);
+}
+
+
+template<typename _Tp, int m, int n> inline
+Matx<_Tp,m,n>::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)
+{
+ CV_StaticAssert(channels == 12, "Matx should have at least 12 elaments.");
+ val[0] = v0; val[1] = v1; val[2] = v2; val[3] = v3;
+ val[4] = v4; val[5] = v5; val[6] = v6; val[7] = v7;
+ val[8] = v8; val[9] = v9; val[10] = v10; val[11] = v11;
+}
+
+template<typename _Tp, int m, int n> inline
+Matx<_Tp,m,n>::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)
+{
+ CV_StaticAssert(channels == 16, "Matx should have at least 16 elaments.");
+ val[0] = v0; val[1] = v1; val[2] = v2; val[3] = v3;
+ val[4] = v4; val[5] = v5; val[6] = v6; val[7] = v7;
+ val[8] = v8; val[9] = v9; val[10] = v10; val[11] = v11;
+ val[12] = v12; val[13] = v13; val[14] = v14; val[15] = v15;
+}
+
+template<typename _Tp, int m, int n> inline
+Matx<_Tp, m, n>::Matx(const _Tp* values)
+{
+ for( int i = 0; i < channels; i++ ) val[i] = values[i];
+}
+
+template<typename _Tp, int m, int n> inline
+Matx<_Tp, m, n> Matx<_Tp, m, n>::all(_Tp alpha)
+{
+ Matx<_Tp, m, n> M;
+ for( int i = 0; i < m*n; i++ ) M.val[i] = alpha;
+ return M;
+}
+
+template<typename _Tp, int m, int n> inline
+Matx<_Tp,m,n> Matx<_Tp,m,n>::zeros()
+{
+ return all(0);
+}
+
+template<typename _Tp, int m, int n> inline
+Matx<_Tp,m,n> Matx<_Tp,m,n>::ones()
+{
+ return all(1);
+}
+
+template<typename _Tp, int m, int n> inline
+Matx<_Tp,m,n> Matx<_Tp,m,n>::eye()
+{
+ Matx<_Tp,m,n> M;
+ for(int i = 0; i < shortdim; i++)
+ M(i,i) = 1;
+ return M;
+}
+
+template<typename _Tp, int m, int n> inline
+_Tp Matx<_Tp, m, n>::dot(const Matx<_Tp, m, n>& M) const
+{
+ _Tp s = 0;
+ for( int i = 0; i < channels; i++ ) s += val[i]*M.val[i];
+ return s;
+}
+
+template<typename _Tp, int m, int n> inline
+double Matx<_Tp, m, n>::ddot(const Matx<_Tp, m, n>& M) const
+{
+ double s = 0;
+ for( int i = 0; i < channels; i++ ) s += (double)val[i]*M.val[i];
+ return s;
+}
+
+template<typename _Tp, int m, int n> inline
+Matx<_Tp,m,n> Matx<_Tp,m,n>::diag(const typename Matx<_Tp,m,n>::diag_type& d)
+{
+ Matx<_Tp,m,n> M;
+ for(int i = 0; i < shortdim; i++)
+ M(i,i) = d(i, 0);
+ return M;
+}
+
+template<typename _Tp, int m, int n> template<typename T2>
+inline Matx<_Tp, m, n>::operator Matx<T2, m, n>() const
+{
+ Matx<T2, m, n> M;
+ for( int i = 0; i < m*n; i++ ) M.val[i] = saturate_cast<T2>(val[i]);
+ return M;
+}
+
+template<typename _Tp, int m, int n> template<int m1, int n1> inline
+Matx<_Tp, m1, n1> Matx<_Tp, m, n>::reshape() const
+{
+ CV_StaticAssert(m1*n1 == m*n, "Input and destnarion matrices must have the same number of elements");
+ return (const Matx<_Tp, m1, n1>&)*this;
+}
+
+template<typename _Tp, int m, int n>
+template<int m1, int n1> inline
+Matx<_Tp, m1, n1> Matx<_Tp, m, n>::get_minor(int i, int j) const
+{
+ CV_DbgAssert(0 <= i && i+m1 <= m && 0 <= j && j+n1 <= n);
+ Matx<_Tp, m1, n1> s;
+ for( int di = 0; di < m1; di++ )
+ for( int dj = 0; dj < n1; dj++ )
+ s(di, dj) = (*this)(i+di, j+dj);
+ return s;
+}
+
+template<typename _Tp, int m, int n> inline
+Matx<_Tp, 1, n> Matx<_Tp, m, n>::row(int i) const
+{
+ CV_DbgAssert((unsigned)i < (unsigned)m);
+ return Matx<_Tp, 1, n>(&val[i*n]);
+}
+
+template<typename _Tp, int m, int n> inline
+Matx<_Tp, m, 1> Matx<_Tp, m, n>::col(int j) const
+{
+ CV_DbgAssert((unsigned)j < (unsigned)n);
+ Matx<_Tp, m, 1> v;
+ for( int i = 0; i < m; i++ )
+ v.val[i] = val[i*n + j];
+ return v;
+}
+
+template<typename _Tp, int m, int n> inline
+typename Matx<_Tp, m, n>::diag_type Matx<_Tp, m, n>::diag() const
+{
+ diag_type d;
+ for( int i = 0; i < shortdim; i++ )
+ d.val[i] = val[i*n + i];
+ return d;
+}
+
+template<typename _Tp, int m, int n> inline
+const _Tp& Matx<_Tp, m, n>::operator()(int i, int j) const
+{
+ CV_DbgAssert( (unsigned)i < (unsigned)m && (unsigned)j < (unsigned)n );
+ return this->val[i*n + j];
+}
+
+template<typename _Tp, int m, int n> inline
+_Tp& Matx<_Tp, m, n>::operator ()(int i, int j)
+{
+ CV_DbgAssert( (unsigned)i < (unsigned)m && (unsigned)j < (unsigned)n );
+ return val[i*n + j];
+}
+
+template<typename _Tp, int m, int n> inline
+const _Tp& Matx<_Tp, m, n>::operator ()(int i) const
+{
+ CV_StaticAssert(m == 1 || n == 1, "Single index indexation requires matrix to be a column or a row");
+ CV_DbgAssert( (unsigned)i < (unsigned)(m+n-1) );
+ return val[i];
+}
+
+template<typename _Tp, int m, int n> inline
+_Tp& Matx<_Tp, m, n>::operator ()(int i)
+{
+ CV_StaticAssert(m == 1 || n == 1, "Single index indexation requires matrix to be a column or a row");
+ CV_DbgAssert( (unsigned)i < (unsigned)(m+n-1) );
+ return val[i];
+}
+
+template<typename _Tp, int m, int n> inline
+Matx<_Tp,m,n>::Matx(const Matx<_Tp, m, n>& a, const Matx<_Tp, m, n>& b, Matx_AddOp)
+{
+ for( int i = 0; i < channels; i++ )
+ val[i] = saturate_cast<_Tp>(a.val[i] + b.val[i]);
+}
+
+template<typename _Tp, int m, int n> inline
+Matx<_Tp,m,n>::Matx(const Matx<_Tp, m, n>& a, const Matx<_Tp, m, n>& b, Matx_SubOp)
+{
+ for( int i = 0; i < channels; i++ )
+ val[i] = saturate_cast<_Tp>(a.val[i] - b.val[i]);
+}
+
+template<typename _Tp, int m, int n> template<typename _T2> inline
+Matx<_Tp,m,n>::Matx(const Matx<_Tp, m, n>& a, _T2 alpha, Matx_ScaleOp)
+{
+ for( int i = 0; i < channels; i++ )
+ val[i] = saturate_cast<_Tp>(a.val[i] * alpha);
+}
+
+template<typename _Tp, int m, int n> inline
+Matx<_Tp,m,n>::Matx(const Matx<_Tp, m, n>& a, const Matx<_Tp, m, n>& b, Matx_MulOp)
+{
+ for( int i = 0; i < channels; i++ )
+ val[i] = saturate_cast<_Tp>(a.val[i] * b.val[i]);
+}
+
+template<typename _Tp, int m, int n> template<int l> inline
+Matx<_Tp,m,n>::Matx(const Matx<_Tp, m, l>& a, const Matx<_Tp, l, n>& b, Matx_MatMulOp)
+{
+ for( int i = 0; i < m; i++ )
+ for( int j = 0; j < n; j++ )
+ {
+ _Tp s = 0;
+ for( int k = 0; k < l; k++ )
+ s += a(i, k) * b(k, j);
+ val[i*n + j] = s;
+ }
+}
+
+template<typename _Tp, int m, int n> inline
+Matx<_Tp,m,n>::Matx(const Matx<_Tp, n, m>& a, Matx_TOp)
+{
+ for( int i = 0; i < m; i++ )
+ for( int j = 0; j < n; j++ )
+ val[i*n + j] = a(j, i);
+}
+
+template<typename _Tp, int m, int n> inline
+Matx<_Tp, m, n> Matx<_Tp, m, n>::mul(const Matx<_Tp, m, n>& a) const
+{
+ return Matx<_Tp, m, n>(*this, a, Matx_MulOp());
+}
+
+template<typename _Tp, int m, int n> inline
+Matx<_Tp, n, m> Matx<_Tp, m, n>::t() const
+{
+ return Matx<_Tp, n, m>(*this, Matx_TOp());
+}
+
+template<typename _Tp, int m, int n> inline
+Vec<_Tp, n> Matx<_Tp, m, n>::solve(const Vec<_Tp, m>& rhs, int method) const
+{
+ Matx<_Tp, n, 1> x = solve((const Matx<_Tp, m, 1>&)(rhs), method);
+ return (Vec<_Tp, n>&)(x);
+}
+
+template<typename _Tp, int m> static inline
+double determinant(const Matx<_Tp, m, m>& a)
+{
+ return internal::Matx_DetOp<_Tp, m>()(a);
+}
+
+template<typename _Tp, int m, int n> static inline
+double trace(const Matx<_Tp, m, n>& a)
+{
+ _Tp s = 0;
+ for( int i = 0; i < std::min(m, n); i++ )
+ s += a(i,i);
+ return s;
+}
+
+
+
+//////////////////////////////// matx comma initializer //////////////////////////////////
+
+template<typename _Tp, typename _T2, int m, int n> static inline
+MatxCommaInitializer<_Tp, m, n> operator << (const Matx<_Tp, m, n>& mtx, _T2 val)
+{
+ MatxCommaInitializer<_Tp, m, n> commaInitializer((Matx<_Tp, m, n>*)&mtx);
+ return (commaInitializer, val);
+}
+
+template<typename _Tp, int m, int n> inline
+MatxCommaInitializer<_Tp, m, n>::MatxCommaInitializer(Matx<_Tp, m, n>* _mtx)
+ : dst(_mtx), idx(0)
+{}
+
+template<typename _Tp, int m, int n> template<typename _T2> inline
+MatxCommaInitializer<_Tp, m, n>& MatxCommaInitializer<_Tp, m, n>::operator , (_T2 value)
+{
+ CV_DbgAssert( idx < m*n );
+ dst->val[idx++] = saturate_cast<_Tp>(value);
+ return *this;
+}
+
+template<typename _Tp, int m, int n> inline
+Matx<_Tp, m, n> MatxCommaInitializer<_Tp, m, n>::operator *() const
+{
+ CV_DbgAssert( idx == n*m );
+ return *dst;
+}
+
+
+
+/////////////////////////////////// Vec Implementation ///////////////////////////////////
+
+template<typename _Tp, int cn> inline
+Vec<_Tp, cn>::Vec() {}
+
+template<typename _Tp, int cn> inline
+Vec<_Tp, cn>::Vec(_Tp v0)
+ : Matx<_Tp, cn, 1>(v0) {}
+
+template<typename _Tp, int cn> inline
+Vec<_Tp, cn>::Vec(_Tp v0, _Tp v1)
+ : Matx<_Tp, cn, 1>(v0, v1) {}
+
+template<typename _Tp, int cn> inline
+Vec<_Tp, cn>::Vec(_Tp v0, _Tp v1, _Tp v2)
+ : Matx<_Tp, cn, 1>(v0, v1, v2) {}
+
+template<typename _Tp, int cn> inline
+Vec<_Tp, cn>::Vec(_Tp v0, _Tp v1, _Tp v2, _Tp v3)
+ : Matx<_Tp, cn, 1>(v0, v1, v2, v3) {}
+
+template<typename _Tp, int cn> inline
+Vec<_Tp, cn>::Vec(_Tp v0, _Tp v1, _Tp v2, _Tp v3, _Tp v4)
+ : Matx<_Tp, cn, 1>(v0, v1, v2, v3, v4) {}
+
+template<typename _Tp, int cn> inline
+Vec<_Tp, cn>::Vec(_Tp v0, _Tp v1, _Tp v2, _Tp v3, _Tp v4, _Tp v5)
+ : Matx<_Tp, cn, 1>(v0, v1, v2, v3, v4, v5) {}
+
+template<typename _Tp, int cn> inline
+Vec<_Tp, cn>::Vec(_Tp v0, _Tp v1, _Tp v2, _Tp v3, _Tp v4, _Tp v5, _Tp v6)
+ : Matx<_Tp, cn, 1>(v0, v1, v2, v3, v4, v5, v6) {}
+
+template<typename _Tp, int cn> inline
+Vec<_Tp, cn>::Vec(_Tp v0, _Tp v1, _Tp v2, _Tp v3, _Tp v4, _Tp v5, _Tp v6, _Tp v7)
+ : Matx<_Tp, cn, 1>(v0, v1, v2, v3, v4, v5, v6, v7) {}
+
+template<typename _Tp, int cn> inline
+Vec<_Tp, cn>::Vec(_Tp v0, _Tp v1, _Tp v2, _Tp v3, _Tp v4, _Tp v5, _Tp v6, _Tp v7, _Tp v8)
+ : Matx<_Tp, cn, 1>(v0, v1, v2, v3, v4, v5, v6, v7, v8) {}
+
+template<typename _Tp, int cn> inline
+Vec<_Tp, cn>::Vec(_Tp v0, _Tp v1, _Tp v2, _Tp v3, _Tp v4, _Tp v5, _Tp v6, _Tp v7, _Tp v8, _Tp v9)
+ : Matx<_Tp, cn, 1>(v0, v1, v2, v3, v4, v5, v6, v7, v8, v9) {}
+
+template<typename _Tp, int cn> inline
+Vec<_Tp, cn>::Vec(const _Tp* values)
+ : Matx<_Tp, cn, 1>(values) {}
+
+template<typename _Tp, int cn> inline
+Vec<_Tp, cn>::Vec(const Vec<_Tp, cn>& m)
+ : Matx<_Tp, cn, 1>(m.val) {}
+
+template<typename _Tp, int cn> inline
+Vec<_Tp, cn>::Vec(const Matx<_Tp, cn, 1>& a, const Matx<_Tp, cn, 1>& b, Matx_AddOp op)
+ : Matx<_Tp, cn, 1>(a, b, op) {}
+
+template<typename _Tp, int cn> inline
+Vec<_Tp, cn>::Vec(const Matx<_Tp, cn, 1>& a, const Matx<_Tp, cn, 1>& b, Matx_SubOp op)
+ : Matx<_Tp, cn, 1>(a, b, op) {}
+
+template<typename _Tp, int cn> template<typename _T2> inline
+Vec<_Tp, cn>::Vec(const Matx<_Tp, cn, 1>& a, _T2 alpha, Matx_ScaleOp op)
+ : Matx<_Tp, cn, 1>(a, alpha, op) {}
+
+template<typename _Tp, int cn> inline
+Vec<_Tp, cn> Vec<_Tp, cn>::all(_Tp alpha)
+{
+ Vec v;
+ for( int i = 0; i < cn; i++ ) v.val[i] = alpha;
+ return v;
+}
+
+template<typename _Tp, int cn> inline
+Vec<_Tp, cn> Vec<_Tp, cn>::mul(const Vec<_Tp, cn>& v) const
+{
+ Vec<_Tp, cn> w;
+ for( int i = 0; i < cn; i++ ) w.val[i] = saturate_cast<_Tp>(this->val[i]*v.val[i]);
+ return w;
+}
+
+template<> inline
+Vec<float, 2> Vec<float, 2>::conj() const
+{
+ return internal::conjugate(*this);
+}
+
+template<> inline
+Vec<double, 2> Vec<double, 2>::conj() const
+{
+ return internal::conjugate(*this);
+}
+
+template<> inline
+Vec<float, 4> Vec<float, 4>::conj() const
+{
+ return internal::conjugate(*this);
+}
+
+template<> inline
+Vec<double, 4> Vec<double, 4>::conj() const
+{
+ return internal::conjugate(*this);
+}
+
+template<typename _Tp, int cn> inline
+Vec<_Tp, cn> Vec<_Tp, cn>::cross(const Vec<_Tp, cn>&) const
+{
+ CV_StaticAssert(false, "for arbitrary-size vector there is no cross-product defined");
+ return Vec<_Tp, cn>();
+}
+
+template<> inline
+Vec<float, 3> Vec<float, 3>::cross(const Vec<float, 3>& v) const
+{
+ return Vec<float,3>(val[1]*v.val[2] - val[2]*v.val[1],
+ val[2]*v.val[0] - val[0]*v.val[2],
+ val[0]*v.val[1] - val[1]*v.val[0]);
+}
+
+template<> inline
+Vec<double, 3> Vec<double, 3>::cross(const Vec<double, 3>& v) const
+{
+ return Vec<double,3>(val[1]*v.val[2] - val[2]*v.val[1],
+ val[2]*v.val[0] - val[0]*v.val[2],
+ val[0]*v.val[1] - val[1]*v.val[0]);
+}
+
+template<typename _Tp, int cn> template<typename T2> inline
+Vec<_Tp, cn>::operator Vec<T2, cn>() const
+{
+ Vec<T2, cn> v;
+ for( int i = 0; i < cn; i++ ) v.val[i] = saturate_cast<T2>(this->val[i]);
+ return v;
+}
+
+template<typename _Tp, int cn> inline
+const _Tp& Vec<_Tp, cn>::operator [](int i) const
+{
+ CV_DbgAssert( (unsigned)i < (unsigned)cn );
+ return this->val[i];
+}
+
+template<typename _Tp, int cn> inline
+_Tp& Vec<_Tp, cn>::operator [](int i)
+{
+ CV_DbgAssert( (unsigned)i < (unsigned)cn );
+ return this->val[i];
+}
+
+template<typename _Tp, int cn> inline
+const _Tp& Vec<_Tp, cn>::operator ()(int i) const
+{
+ CV_DbgAssert( (unsigned)i < (unsigned)cn );
+ return this->val[i];
+}
+
+template<typename _Tp, int cn> inline
+_Tp& Vec<_Tp, cn>::operator ()(int i)
+{
+ CV_DbgAssert( (unsigned)i < (unsigned)cn );
+ return this->val[i];
+}
+
+
+
+//////////////////////////////// matx comma initializer //////////////////////////////////
+
+
+template<typename _Tp, typename _T2, int cn> static inline
+VecCommaInitializer<_Tp, cn> operator << (const Vec<_Tp, cn>& vec, _T2 val)
+{
+ VecCommaInitializer<_Tp, cn> commaInitializer((Vec<_Tp, cn>*)&vec);
+ return (commaInitializer, val);
+}
+
+template<typename _Tp, int cn> inline
+VecCommaInitializer<_Tp, cn>::VecCommaInitializer(Vec<_Tp, cn>* _vec)
+ : MatxCommaInitializer<_Tp, cn, 1>(_vec)
+{}
+
+template<typename _Tp, int cn> template<typename _T2> inline
+VecCommaInitializer<_Tp, cn>& VecCommaInitializer<_Tp, cn>::operator , (_T2 value)
+{
+ CV_DbgAssert( this->idx < cn );
+ this->dst->val[this->idx++] = saturate_cast<_Tp>(value);
+ return *this;
+}
+
+template<typename _Tp, int cn> inline
+Vec<_Tp, cn> VecCommaInitializer<_Tp, cn>::operator *() const
+{
+ CV_DbgAssert( this->idx == cn );
+ return *this->dst;
+}
+
+
+
+///////////////////////////// Matx out-of-class operators ////////////////////////////////
+
+template<typename _Tp1, typename _Tp2, int m, int n> static inline
+Matx<_Tp1, m, n>& operator += (Matx<_Tp1, m, n>& a, const Matx<_Tp2, m, n>& b)
+{
+ for( int i = 0; i < m*n; i++ )
+ a.val[i] = saturate_cast<_Tp1>(a.val[i] + b.val[i]);
+ return a;
+}
+
+template<typename _Tp1, typename _Tp2, int m, int n> static inline
+Matx<_Tp1, m, n>& operator -= (Matx<_Tp1, m, n>& a, const Matx<_Tp2, m, n>& b)
+{
+ for( int i = 0; i < m*n; i++ )
+ a.val[i] = saturate_cast<_Tp1>(a.val[i] - b.val[i]);
+ return a;
+}
+
+template<typename _Tp, int m, int n> static inline
+Matx<_Tp, m, n> operator + (const Matx<_Tp, m, n>& a, const Matx<_Tp, m, n>& b)
+{
+ return Matx<_Tp, m, n>(a, b, Matx_AddOp());
+}
+
+template<typename _Tp, int m, int n> static inline
+Matx<_Tp, m, n> operator - (const Matx<_Tp, m, n>& a, const Matx<_Tp, m, n>& b)
+{
+ return Matx<_Tp, m, n>(a, b, Matx_SubOp());
+}
+
+template<typename _Tp, int m, int n> static inline
+Matx<_Tp, m, n>& operator *= (Matx<_Tp, m, n>& a, int alpha)
+{
+ for( int i = 0; i < m*n; i++ )
+ a.val[i] = saturate_cast<_Tp>(a.val[i] * alpha);
+ return a;
+}
+
+template<typename _Tp, int m, int n> static inline
+Matx<_Tp, m, n>& operator *= (Matx<_Tp, m, n>& a, float alpha)
+{
+ for( int i = 0; i < m*n; i++ )
+ a.val[i] = saturate_cast<_Tp>(a.val[i] * alpha);
+ return a;
+}
+
+template<typename _Tp, int m, int n> static inline
+Matx<_Tp, m, n>& operator *= (Matx<_Tp, m, n>& a, double alpha)
+{
+ for( int i = 0; i < m*n; i++ )
+ a.val[i] = saturate_cast<_Tp>(a.val[i] * alpha);
+ return a;
+}
+
+template<typename _Tp, int m, int n> static inline
+Matx<_Tp, m, n> operator * (const Matx<_Tp, m, n>& a, int alpha)
+{
+ return Matx<_Tp, m, n>(a, alpha, Matx_ScaleOp());
+}
+
+template<typename _Tp, int m, int n> static inline
+Matx<_Tp, m, n> operator * (const Matx<_Tp, m, n>& a, float alpha)
+{
+ return Matx<_Tp, m, n>(a, alpha, Matx_ScaleOp());
+}
+
+template<typename _Tp, int m, int n> static inline
+Matx<_Tp, m, n> operator * (const Matx<_Tp, m, n>& a, double alpha)
+{
+ return Matx<_Tp, m, n>(a, alpha, Matx_ScaleOp());
+}
+
+template<typename _Tp, int m, int n> static inline
+Matx<_Tp, m, n> operator * (int alpha, const Matx<_Tp, m, n>& a)
+{
+ return Matx<_Tp, m, n>(a, alpha, Matx_ScaleOp());
+}
+
+template<typename _Tp, int m, int n> static inline
+Matx<_Tp, m, n> operator * (float alpha, const Matx<_Tp, m, n>& a)
+{
+ return Matx<_Tp, m, n>(a, alpha, Matx_ScaleOp());
+}
+
+template<typename _Tp, int m, int n> static inline
+Matx<_Tp, m, n> operator * (double alpha, const Matx<_Tp, m, n>& a)
+{
+ return Matx<_Tp, m, n>(a, alpha, Matx_ScaleOp());
+}
+
+template<typename _Tp, int m, int n> static inline
+Matx<_Tp, m, n> operator - (const Matx<_Tp, m, n>& a)
+{
+ return Matx<_Tp, m, n>(a, -1, Matx_ScaleOp());
+}
+
+template<typename _Tp, int m, int n, int l> static inline
+Matx<_Tp, m, n> operator * (const Matx<_Tp, m, l>& a, const Matx<_Tp, l, n>& b)
+{
+ return Matx<_Tp, m, n>(a, b, Matx_MatMulOp());
+}
+
+template<typename _Tp, int m, int n> static inline
+Vec<_Tp, m> operator * (const Matx<_Tp, m, n>& a, const Vec<_Tp, n>& b)
+{
+ Matx<_Tp, m, 1> c(a, b, Matx_MatMulOp());
+ return (const Vec<_Tp, m>&)(c);
+}
+
+template<typename _Tp, int m, int n> static inline
+bool operator == (const Matx<_Tp, m, n>& a, const Matx<_Tp, m, n>& b)
+{
+ for( int i = 0; i < m*n; i++ )
+ if( a.val[i] != b.val[i] ) return false;
+ return true;
+}
+
+template<typename _Tp, int m, int n> static inline
+bool operator != (const Matx<_Tp, m, n>& a, const Matx<_Tp, m, n>& b)
+{
+ return !(a == b);
+}
+
+
+
+////////////////////////////// Vec out-of-class operators ////////////////////////////////
+
+template<typename _Tp1, typename _Tp2, int cn> static inline
+Vec<_Tp1, cn>& operator += (Vec<_Tp1, cn>& a, const Vec<_Tp2, cn>& b)
+{
+ for( int i = 0; i < cn; i++ )
+ a.val[i] = saturate_cast<_Tp1>(a.val[i] + b.val[i]);
+ return a;
+}
+
+template<typename _Tp1, typename _Tp2, int cn> static inline
+Vec<_Tp1, cn>& operator -= (Vec<_Tp1, cn>& a, const Vec<_Tp2, cn>& b)
+{
+ for( int i = 0; i < cn; i++ )
+ a.val[i] = saturate_cast<_Tp1>(a.val[i] - b.val[i]);
+ return a;
+}
+
+template<typename _Tp, int cn> static inline
+Vec<_Tp, cn> operator + (const Vec<_Tp, cn>& a, const Vec<_Tp, cn>& b)
+{
+ return Vec<_Tp, cn>(a, b, Matx_AddOp());
+}
+
+template<typename _Tp, int cn> static inline
+Vec<_Tp, cn> operator - (const Vec<_Tp, cn>& a, const Vec<_Tp, cn>& b)
+{
+ return Vec<_Tp, cn>(a, b, Matx_SubOp());
+}
+
+template<typename _Tp, int cn> static inline
+Vec<_Tp, cn>& operator *= (Vec<_Tp, cn>& a, int alpha)
+{
+ for( int i = 0; i < cn; i++ )
+ a[i] = saturate_cast<_Tp>(a[i]*alpha);
+ return a;
+}
+
+template<typename _Tp, int cn> static inline
+Vec<_Tp, cn>& operator *= (Vec<_Tp, cn>& a, float alpha)
+{
+ for( int i = 0; i < cn; i++ )
+ a[i] = saturate_cast<_Tp>(a[i]*alpha);
+ return a;
+}
+
+template<typename _Tp, int cn> static inline
+Vec<_Tp, cn>& operator *= (Vec<_Tp, cn>& a, double alpha)
+{
+ for( int i = 0; i < cn; i++ )
+ a[i] = saturate_cast<_Tp>(a[i]*alpha);
+ return a;
+}
+
+template<typename _Tp, int cn> static inline
+Vec<_Tp, cn>& operator /= (Vec<_Tp, cn>& a, int alpha)
+{
+ double ialpha = 1./alpha;
+ for( int i = 0; i < cn; i++ )
+ a[i] = saturate_cast<_Tp>(a[i]*ialpha);
+ return a;
+}
+
+template<typename _Tp, int cn> static inline
+Vec<_Tp, cn>& operator /= (Vec<_Tp, cn>& a, float alpha)
+{
+ float ialpha = 1.f/alpha;
+ for( int i = 0; i < cn; i++ )
+ a[i] = saturate_cast<_Tp>(a[i]*ialpha);
+ return a;
+}
+
+template<typename _Tp, int cn> static inline
+Vec<_Tp, cn>& operator /= (Vec<_Tp, cn>& a, double alpha)
+{
+ double ialpha = 1./alpha;
+ for( int i = 0; i < cn; i++ )
+ a[i] = saturate_cast<_Tp>(a[i]*ialpha);
+ return a;
+}
+
+template<typename _Tp, int cn> static inline
+Vec<_Tp, cn> operator * (const Vec<_Tp, cn>& a, int alpha)
+{
+ return Vec<_Tp, cn>(a, alpha, Matx_ScaleOp());
+}
+
+template<typename _Tp, int cn> static inline
+Vec<_Tp, cn> operator * (int alpha, const Vec<_Tp, cn>& a)
+{
+ return Vec<_Tp, cn>(a, alpha, Matx_ScaleOp());
+}
+
+template<typename _Tp, int cn> static inline
+Vec<_Tp, cn> operator * (const Vec<_Tp, cn>& a, float alpha)
+{
+ return Vec<_Tp, cn>(a, alpha, Matx_ScaleOp());
+}
+
+template<typename _Tp, int cn> static inline
+Vec<_Tp, cn> operator * (float alpha, const Vec<_Tp, cn>& a)
+{
+ return Vec<_Tp, cn>(a, alpha, Matx_ScaleOp());
+}
+
+template<typename _Tp, int cn> static inline
+Vec<_Tp, cn> operator * (const Vec<_Tp, cn>& a, double alpha)
+{
+ return Vec<_Tp, cn>(a, alpha, Matx_ScaleOp());
+}
+
+template<typename _Tp, int cn> static inline
+Vec<_Tp, cn> operator * (double alpha, const Vec<_Tp, cn>& a)
+{
+ return Vec<_Tp, cn>(a, alpha, Matx_ScaleOp());
+}
+
+template<typename _Tp, int cn> static inline
+Vec<_Tp, cn> operator / (const Vec<_Tp, cn>& a, int alpha)
+{
+ return Vec<_Tp, cn>(a, 1./alpha, Matx_ScaleOp());
+}
+
+template<typename _Tp, int cn> static inline
+Vec<_Tp, cn> operator / (const Vec<_Tp, cn>& a, float alpha)
+{
+ return Vec<_Tp, cn>(a, 1.f/alpha, Matx_ScaleOp());
+}
+
+template<typename _Tp, int cn> static inline
+Vec<_Tp, cn> operator / (const Vec<_Tp, cn>& a, double alpha)
+{
+ return Vec<_Tp, cn>(a, 1./alpha, Matx_ScaleOp());
+}
+
+template<typename _Tp, int cn> static inline
+Vec<_Tp, cn> operator - (const Vec<_Tp, cn>& a)
+{
+ Vec<_Tp,cn> t;
+ for( int i = 0; i < cn; i++ ) t.val[i] = saturate_cast<_Tp>(-a.val[i]);
+ return t;
+}
+
+template<typename _Tp> inline Vec<_Tp, 4> operator * (const Vec<_Tp, 4>& v1, const Vec<_Tp, 4>& v2)
+{
+ return Vec<_Tp, 4>(saturate_cast<_Tp>(v1[0]*v2[0] - v1[1]*v2[1] - v1[2]*v2[2] - v1[3]*v2[3]),
+ saturate_cast<_Tp>(v1[0]*v2[1] + v1[1]*v2[0] + v1[2]*v2[3] - v1[3]*v2[2]),
+ saturate_cast<_Tp>(v1[0]*v2[2] - v1[1]*v2[3] + v1[2]*v2[0] + v1[3]*v2[1]),
+ saturate_cast<_Tp>(v1[0]*v2[3] + v1[1]*v2[2] - v1[2]*v2[1] + v1[3]*v2[0]));
+}
+
+template<typename _Tp> inline Vec<_Tp, 4>& operator *= (Vec<_Tp, 4>& v1, const Vec<_Tp, 4>& v2)
+{
+ v1 = v1 * v2;
+ return v1;
+}
+
} // cv
#endif // __OPENCV_CORE_MATX_HPP__
\ No newline at end of file
# pragma warning(disable:4127) //conditional expression is constant
#endif
-//////////////// static assert /////////////////
-
-#define CVAUX_CONCAT_EXP(a, b) a##b
-#define CVAUX_CONCAT(a, b) CVAUX_CONCAT_EXP(a,b)
-
-#ifdef __cplusplus
-# if defined(__clang__)
-# ifndef __has_extension
-# define __has_extension __has_feature /* compatibility, for older versions of clang */
-# endif
-# if __has_extension(cxx_static_assert)
-# define CV_StaticAssert(condition, reason) static_assert((condition), reason " " #condition)
-# endif
-# elif defined(__GNUC__)
-# if (defined(__GXX_EXPERIMENTAL_CXX0X__) || __cplusplus >= 201103L)
-# define CV_StaticAssert(condition, reason) static_assert((condition), reason " " #condition)
-# endif
-# elif defined(_MSC_VER)
-# if _MSC_VER >= 1600 /* MSVC 10 */
-# define CV_StaticAssert(condition, reason) static_assert((condition), reason " " #condition)
-# endif
-# endif
-# ifndef CV_StaticAssert
-# if defined(__GNUC__) && (__GNUC__ > 3) && (__GNUC_MINOR__ > 2)
-# define CV_StaticAssert(condition, reason) ({ extern int __attribute__((error("CV_StaticAssert: " reason " " #condition))) CV_StaticAssert(); ((condition) ? 0 : CV_StaticAssert()); })
-# else
- namespace cv {
- template <bool x> struct CV_StaticAssert_failed;
- template <> struct CV_StaticAssert_failed<true> { enum { val = 1 }; };
- template<int x> struct CV_StaticAssert_test{};
- }
-# define CV_StaticAssert(condition, reason)\
- typedef cv::CV_StaticAssert_test< sizeof(cv::CV_StaticAssert_failed< static_cast<bool>(condition) >) > CVAUX_CONCAT(CV_StaticAssert_failed_at_, __LINE__)
-# endif
-# endif
-#endif
-
namespace cv
{
inline float fast_abs(float v) { return std::abs(v); }
inline double fast_abs(double v) { return std::abs(v); }
-//////////////////////////////// Matx /////////////////////////////////
-
-
-template<typename _Tp, int m, int n> inline Matx<_Tp, m, n>::Matx()
-{
- for(int i = 0; i < channels; i++) val[i] = _Tp(0);
-}
-
-template<typename _Tp, int m, int n> inline Matx<_Tp, m, n>::Matx(_Tp v0)
-{
- val[0] = v0;
- for(int i = 1; i < channels; i++) val[i] = _Tp(0);
-}
-
-template<typename _Tp, int m, int n> inline Matx<_Tp, m, n>::Matx(_Tp v0, _Tp v1)
-{
- CV_StaticAssert(channels >= 2, "Matx should have at least 2 elaments.");
- val[0] = v0; val[1] = v1;
- for(int i = 2; i < channels; i++) val[i] = _Tp(0);
-}
-
-template<typename _Tp, int m, int n> inline Matx<_Tp, m, n>::Matx(_Tp v0, _Tp v1, _Tp v2)
-{
- CV_StaticAssert(channels >= 3, "Matx should have at least 3 elaments.");
- val[0] = v0; val[1] = v1; val[2] = v2;
- for(int i = 3; i < channels; i++) val[i] = _Tp(0);
-}
-
-template<typename _Tp, int m, int n> inline Matx<_Tp, m, n>::Matx(_Tp v0, _Tp v1, _Tp v2, _Tp v3)
-{
- CV_StaticAssert(channels >= 4, "Matx should have at least 4 elaments.");
- val[0] = v0; val[1] = v1; val[2] = v2; val[3] = v3;
- for(int i = 4; i < channels; i++) val[i] = _Tp(0);
-}
-
-template<typename _Tp, int m, int n> inline Matx<_Tp, m, n>::Matx(_Tp v0, _Tp v1, _Tp v2, _Tp v3, _Tp v4)
-{
- CV_StaticAssert(channels >= 5, "Matx should have at least 5 elaments.");
- val[0] = v0; val[1] = v1; val[2] = v2; val[3] = v3; val[4] = v4;
- for(int i = 5; i < channels; i++) val[i] = _Tp(0);
-}
-
-template<typename _Tp, int m, int n> inline Matx<_Tp, m, n>::Matx(_Tp v0, _Tp v1, _Tp v2, _Tp v3,
- _Tp v4, _Tp v5)
-{
- CV_StaticAssert(channels >= 6, "Matx should have at least 6 elaments.");
- val[0] = v0; val[1] = v1; val[2] = v2; val[3] = v3;
- val[4] = v4; val[5] = v5;
- for(int i = 6; i < channels; i++) val[i] = _Tp(0);
-}
-
-template<typename _Tp, int m, int n> inline Matx<_Tp, m, n>::Matx(_Tp v0, _Tp v1, _Tp v2, _Tp v3,
- _Tp v4, _Tp v5, _Tp v6)
-{
- CV_StaticAssert(channels >= 7, "Matx should have at least 7 elaments.");
- val[0] = v0; val[1] = v1; val[2] = v2; val[3] = v3;
- val[4] = v4; val[5] = v5; val[6] = v6;
- for(int i = 7; i < channels; i++) val[i] = _Tp(0);
-}
-
-template<typename _Tp, int m, int n> inline Matx<_Tp, m, n>::Matx(_Tp v0, _Tp v1, _Tp v2, _Tp v3,
- _Tp v4, _Tp v5, _Tp v6, _Tp v7)
-{
- CV_StaticAssert(channels >= 8, "Matx should have at least 8 elaments.");
- val[0] = v0; val[1] = v1; val[2] = v2; val[3] = v3;
- val[4] = v4; val[5] = v5; val[6] = v6; val[7] = v7;
- for(int i = 8; i < channels; i++) val[i] = _Tp(0);
-}
-
-template<typename _Tp, int m, int n> inline Matx<_Tp, m, n>::Matx(_Tp v0, _Tp v1, _Tp v2, _Tp v3,
- _Tp v4, _Tp v5, _Tp v6, _Tp v7,
- _Tp v8)
-{
- CV_StaticAssert(channels >= 9, "Matx should have at least 9 elaments.");
- val[0] = v0; val[1] = v1; val[2] = v2; val[3] = v3;
- val[4] = v4; val[5] = v5; val[6] = v6; val[7] = v7;
- val[8] = v8;
- for(int i = 9; i < channels; i++) val[i] = _Tp(0);
-}
-
-template<typename _Tp, int m, int n> inline Matx<_Tp, m, n>::Matx(_Tp v0, _Tp v1, _Tp v2, _Tp v3,
- _Tp v4, _Tp v5, _Tp v6, _Tp v7,
- _Tp v8, _Tp v9)
-{
- CV_StaticAssert(channels >= 10, "Matx should have at least 10 elaments.");
- val[0] = v0; val[1] = v1; val[2] = v2; val[3] = v3;
- val[4] = v4; val[5] = v5; val[6] = v6; val[7] = v7;
- val[8] = v8; val[9] = v9;
- for(int i = 10; i < channels; i++) val[i] = _Tp(0);
-}
-
-
-template<typename _Tp, int m, int n>
-inline Matx<_Tp,m,n>::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)
-{
- CV_StaticAssert(channels == 12, "Matx should have at least 12 elaments.");
- val[0] = v0; val[1] = v1; val[2] = v2; val[3] = v3;
- val[4] = v4; val[5] = v5; val[6] = v6; val[7] = v7;
- val[8] = v8; val[9] = v9; val[10] = v10; val[11] = v11;
-}
-
-template<typename _Tp, int m, int n>
-inline Matx<_Tp,m,n>::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)
-{
- CV_StaticAssert(channels == 16, "Matx should have at least 16 elaments.");
- val[0] = v0; val[1] = v1; val[2] = v2; val[3] = v3;
- val[4] = v4; val[5] = v5; val[6] = v6; val[7] = v7;
- val[8] = v8; val[9] = v9; val[10] = v10; val[11] = v11;
- val[12] = v12; val[13] = v13; val[14] = v14; val[15] = v15;
-}
-
-template<typename _Tp, int m, int n> inline Matx<_Tp, m, n>::Matx(const _Tp* values)
-{
- for( int i = 0; i < channels; i++ ) val[i] = values[i];
-}
-
-template<typename _Tp, int m, int n> inline Matx<_Tp, m, n> Matx<_Tp, m, n>::all(_Tp alpha)
-{
- Matx<_Tp, m, n> M;
- for( int i = 0; i < m*n; i++ ) M.val[i] = alpha;
- return M;
-}
-
-template<typename _Tp, int m, int n> inline
-Matx<_Tp,m,n> Matx<_Tp,m,n>::zeros()
-{
- return all(0);
-}
-
-template<typename _Tp, int m, int n> inline
-Matx<_Tp,m,n> Matx<_Tp,m,n>::ones()
-{
- return all(1);
-}
-
-template<typename _Tp, int m, int n> inline
-Matx<_Tp,m,n> Matx<_Tp,m,n>::eye()
-{
- Matx<_Tp,m,n> M;
- for(int i = 0; i < MIN(m,n); i++)
- M(i,i) = 1;
- return M;
-}
-
-template<typename _Tp, int m, int n> inline _Tp Matx<_Tp, m, n>::dot(const Matx<_Tp, m, n>& M) const
-{
- _Tp s = 0;
- for( int i = 0; i < m*n; i++ ) s += val[i]*M.val[i];
- return s;
-}
-
-
-template<typename _Tp, int m, int n> inline double Matx<_Tp, m, n>::ddot(const Matx<_Tp, m, n>& M) const
-{
- double s = 0;
- for( int i = 0; i < m*n; i++ ) s += (double)val[i]*M.val[i];
- return s;
-}
-
-
-
-template<typename _Tp, int m, int n> inline
-Matx<_Tp,m,n> Matx<_Tp,m,n>::diag(const typename Matx<_Tp,m,n>::diag_type& d)
-{
- Matx<_Tp,m,n> M;
- for(int i = 0; i < MIN(m,n); i++)
- M(i,i) = d(i, 0);
- return M;
-}
-
-template<typename _Tp, int m, int n> inline
-Matx<_Tp,m,n> Matx<_Tp,m,n>::randu(_Tp a, _Tp b)
-{
- Matx<_Tp,m,n> M;
- Mat matM(M, false);
- cv::randu(matM, Scalar(a), Scalar(b));
- return M;
-}
-
-template<typename _Tp, int m, int n> inline
-Matx<_Tp,m,n> Matx<_Tp,m,n>::randn(_Tp a, _Tp b)
-{
- Matx<_Tp,m,n> M;
- Mat matM(M, false);
- cv::randn(matM, Scalar(a), Scalar(b));
- return M;
-}
-
-template<typename _Tp, int m, int n> template<typename T2>
-inline Matx<_Tp, m, n>::operator Matx<T2, m, n>() const
-{
- Matx<T2, m, n> M;
- for( int i = 0; i < m*n; i++ ) M.val[i] = saturate_cast<T2>(val[i]);
- return M;
-}
-
-
-template<typename _Tp, int m, int n> template<int m1, int n1> inline
-Matx<_Tp, m1, n1> Matx<_Tp, m, n>::reshape() const
-{
- CV_DbgAssert(m1*n1 == m*n);
- return (const Matx<_Tp, m1, n1>&)*this;
-}
-
-
-template<typename _Tp, int m, int n>
-template<int m1, int n1> inline
-Matx<_Tp, m1, n1> Matx<_Tp, m, n>::get_minor(int i, int j) const
-{
- CV_DbgAssert(0 <= i && i+m1 <= m && 0 <= j && j+n1 <= n);
- Matx<_Tp, m1, n1> s;
- for( int di = 0; di < m1; di++ )
- for( int dj = 0; dj < n1; dj++ )
- s(di, dj) = (*this)(i+di, j+dj);
- return s;
-}
-
-
-template<typename _Tp, int m, int n> inline
-Matx<_Tp, 1, n> Matx<_Tp, m, n>::row(int i) const
-{
- CV_DbgAssert((unsigned)i < (unsigned)m);
- return Matx<_Tp, 1, n>(&val[i*n]);
-}
-
-
-template<typename _Tp, int m, int n> inline
-Matx<_Tp, m, 1> Matx<_Tp, m, n>::col(int j) const
-{
- CV_DbgAssert((unsigned)j < (unsigned)n);
- Matx<_Tp, m, 1> v;
- for( int i = 0; i < m; i++ )
- v.val[i] = val[i*n + j];
- return v;
-}
-
-
-template<typename _Tp, int m, int n> inline
-typename Matx<_Tp, m, n>::diag_type Matx<_Tp, m, n>::diag() const
-{
- diag_type d;
- for( int i = 0; i < MIN(m, n); i++ )
- d.val[i] = val[i*n + i];
- return d;
-}
-
-
-template<typename _Tp, int m, int n> inline
-const _Tp& Matx<_Tp, m, n>::operator ()(int i, int j) const
-{
- CV_DbgAssert( (unsigned)i < (unsigned)m && (unsigned)j < (unsigned)n );
- return this->val[i*n + j];
-}
-
-
-template<typename _Tp, int m, int n> inline
-_Tp& Matx<_Tp, m, n>::operator ()(int i, int j)
-{
- CV_DbgAssert( (unsigned)i < (unsigned)m && (unsigned)j < (unsigned)n );
- return val[i*n + j];
-}
-
-
-template<typename _Tp, int m, int n> inline
-const _Tp& Matx<_Tp, m, n>::operator ()(int i) const
-{
- CV_DbgAssert( (m == 1 || n == 1) && (unsigned)i < (unsigned)(m+n-1) );
- return val[i];
-}
-
-
-template<typename _Tp, int m, int n> inline
-_Tp& Matx<_Tp, m, n>::operator ()(int i)
-{
- CV_DbgAssert( (m == 1 || n == 1) && (unsigned)i < (unsigned)(m+n-1) );
- return val[i];
-}
-
-
-template<typename _Tp1, typename _Tp2, int m, int n> static inline
-Matx<_Tp1, m, n>& operator += (Matx<_Tp1, m, n>& a, const Matx<_Tp2, m, n>& b)
-{
- for( int i = 0; i < m*n; i++ )
- a.val[i] = saturate_cast<_Tp1>(a.val[i] + b.val[i]);
- return a;
-}
-
-
-template<typename _Tp1, typename _Tp2, int m, int n> static inline
-Matx<_Tp1, m, n>& operator -= (Matx<_Tp1, m, n>& a, const Matx<_Tp2, m, n>& b)
-{
- for( int i = 0; i < m*n; i++ )
- a.val[i] = saturate_cast<_Tp1>(a.val[i] - b.val[i]);
- return a;
-}
-
-
-template<typename _Tp, int m, int n> inline
-Matx<_Tp,m,n>::Matx(const Matx<_Tp, m, n>& a, const Matx<_Tp, m, n>& b, Matx_AddOp)
-{
- for( int i = 0; i < m*n; i++ )
- val[i] = saturate_cast<_Tp>(a.val[i] + b.val[i]);
-}
-
-
-template<typename _Tp, int m, int n> inline
-Matx<_Tp,m,n>::Matx(const Matx<_Tp, m, n>& a, const Matx<_Tp, m, n>& b, Matx_SubOp)
-{
- for( int i = 0; i < m*n; i++ )
- val[i] = saturate_cast<_Tp>(a.val[i] - b.val[i]);
-}
-
-
-template<typename _Tp, int m, int n> template<typename _T2> inline
-Matx<_Tp,m,n>::Matx(const Matx<_Tp, m, n>& a, _T2 alpha, Matx_ScaleOp)
-{
- for( int i = 0; i < m*n; i++ )
- val[i] = saturate_cast<_Tp>(a.val[i] * alpha);
-}
-
-
-template<typename _Tp, int m, int n> inline
-Matx<_Tp,m,n>::Matx(const Matx<_Tp, m, n>& a, const Matx<_Tp, m, n>& b, Matx_MulOp)
-{
- for( int i = 0; i < m*n; i++ )
- val[i] = saturate_cast<_Tp>(a.val[i] * b.val[i]);
-}
-
-
-template<typename _Tp, int m, int n> template<int l> inline
-Matx<_Tp,m,n>::Matx(const Matx<_Tp, m, l>& a, const Matx<_Tp, l, n>& b, Matx_MatMulOp)
-{
- for( int i = 0; i < m; i++ )
- for( int j = 0; j < n; j++ )
- {
- _Tp s = 0;
- for( int k = 0; k < l; k++ )
- s += a(i, k) * b(k, j);
- val[i*n + j] = s;
- }
-}
-
-
-template<typename _Tp, int m, int n> inline
-Matx<_Tp,m,n>::Matx(const Matx<_Tp, n, m>& a, Matx_TOp)
-{
- for( int i = 0; i < m; i++ )
- for( int j = 0; j < n; j++ )
- val[i*n + j] = a(j, i);
-}
-
-
-template<typename _Tp, int m, int n> static inline
-Matx<_Tp, m, n> operator + (const Matx<_Tp, m, n>& a, const Matx<_Tp, m, n>& b)
-{
- return Matx<_Tp, m, n>(a, b, Matx_AddOp());
-}
-
-
-template<typename _Tp, int m, int n> static inline
-Matx<_Tp, m, n> operator - (const Matx<_Tp, m, n>& a, const Matx<_Tp, m, n>& b)
-{
- return Matx<_Tp, m, n>(a, b, Matx_SubOp());
-}
-
-
-template<typename _Tp, int m, int n> static inline
-Matx<_Tp, m, n>& operator *= (Matx<_Tp, m, n>& a, int alpha)
-{
- for( int i = 0; i < m*n; i++ )
- a.val[i] = saturate_cast<_Tp>(a.val[i] * alpha);
- return a;
-}
-
-template<typename _Tp, int m, int n> static inline
-Matx<_Tp, m, n>& operator *= (Matx<_Tp, m, n>& a, float alpha)
-{
- for( int i = 0; i < m*n; i++ )
- a.val[i] = saturate_cast<_Tp>(a.val[i] * alpha);
- return a;
-}
-
-template<typename _Tp, int m, int n> static inline
-Matx<_Tp, m, n>& operator *= (Matx<_Tp, m, n>& a, double alpha)
-{
- for( int i = 0; i < m*n; i++ )
- a.val[i] = saturate_cast<_Tp>(a.val[i] * alpha);
- return a;
-}
-
-template<typename _Tp, int m, int n> static inline
-Matx<_Tp, m, n> operator * (const Matx<_Tp, m, n>& a, int alpha)
-{
- return Matx<_Tp, m, n>(a, alpha, Matx_ScaleOp());
-}
-
-template<typename _Tp, int m, int n> static inline
-Matx<_Tp, m, n> operator * (const Matx<_Tp, m, n>& a, float alpha)
-{
- return Matx<_Tp, m, n>(a, alpha, Matx_ScaleOp());
-}
-
-template<typename _Tp, int m, int n> static inline
-Matx<_Tp, m, n> operator * (const Matx<_Tp, m, n>& a, double alpha)
-{
- return Matx<_Tp, m, n>(a, alpha, Matx_ScaleOp());
-}
-
-template<typename _Tp, int m, int n> static inline
-Matx<_Tp, m, n> operator * (int alpha, const Matx<_Tp, m, n>& a)
-{
- return Matx<_Tp, m, n>(a, alpha, Matx_ScaleOp());
-}
-
-template<typename _Tp, int m, int n> static inline
-Matx<_Tp, m, n> operator * (float alpha, const Matx<_Tp, m, n>& a)
-{
- return Matx<_Tp, m, n>(a, alpha, Matx_ScaleOp());
-}
-
-template<typename _Tp, int m, int n> static inline
-Matx<_Tp, m, n> operator * (double alpha, const Matx<_Tp, m, n>& a)
-{
- return Matx<_Tp, m, n>(a, alpha, Matx_ScaleOp());
-}
-
-template<typename _Tp, int m, int n> static inline
-Matx<_Tp, m, n> operator - (const Matx<_Tp, m, n>& a)
-{
- return Matx<_Tp, m, n>(a, -1, Matx_ScaleOp());
-}
-
-
-template<typename _Tp, int m, int n, int l> static inline
-Matx<_Tp, m, n> operator * (const Matx<_Tp, m, l>& a, const Matx<_Tp, l, n>& b)
-{
- return Matx<_Tp, m, n>(a, b, Matx_MatMulOp());
-}
-
-
-template<typename _Tp, int m, int n> static inline
-Vec<_Tp, m> operator * (const Matx<_Tp, m, n>& a, const Vec<_Tp, n>& b)
-{
- Matx<_Tp, m, 1> c(a, b, Matx_MatMulOp());
- return reinterpret_cast<const Vec<_Tp, m>&>(c);
-}
-
-
-template<typename _Tp> static inline
-Point_<_Tp> operator * (const Matx<_Tp, 2, 2>& a, const Point_<_Tp>& b)
-{
- Matx<_Tp, 2, 1> tmp = a*Vec<_Tp,2>(b.x, b.y);
- return Point_<_Tp>(tmp.val[0], tmp.val[1]);
-}
-
-
-template<typename _Tp> static inline
-Point3_<_Tp> operator * (const Matx<_Tp, 3, 3>& a, const Point3_<_Tp>& b)
-{
- Matx<_Tp, 3, 1> tmp = a*Vec<_Tp,3>(b.x, b.y, b.z);
- return Point3_<_Tp>(tmp.val[0], tmp.val[1], tmp.val[2]);
-}
-
-
-template<typename _Tp> static inline
-Point3_<_Tp> operator * (const Matx<_Tp, 3, 3>& a, const Point_<_Tp>& b)
-{
- Matx<_Tp, 3, 1> tmp = a*Vec<_Tp,3>(b.x, b.y, 1);
- return Point3_<_Tp>(tmp.val[0], tmp.val[1], tmp.val[2]);
-}
-
-
-template<typename _Tp> static inline
-Matx<_Tp, 4, 1> operator * (const Matx<_Tp, 4, 4>& a, const Point3_<_Tp>& b)
-{
- return a*Matx<_Tp, 4, 1>(b.x, b.y, b.z, 1);
-}
-
-
-template<typename _Tp> static inline
-Scalar operator * (const Matx<_Tp, 4, 4>& a, const Scalar& b)
-{
- Matx<double, 4, 1> c(Matx<double, 4, 4>(a), b, Matx_MatMulOp());
- return reinterpret_cast<const Scalar&>(c);
-}
-
-
-static inline
-Scalar operator * (const Matx<double, 4, 4>& a, const Scalar& b)
-{
- Matx<double, 4, 1> c(a, b, Matx_MatMulOp());
- return reinterpret_cast<const Scalar&>(c);
-}
-
-
-template<typename _Tp, int m, int n> inline
-Matx<_Tp, m, n> Matx<_Tp, m, n>::mul(const Matx<_Tp, m, n>& a) const
-{
- return Matx<_Tp, m, n>(*this, a, Matx_MulOp());
-}
-
-
-CV_EXPORTS int LU(float* A, size_t astep, int m, float* b, size_t bstep, int n);
-CV_EXPORTS int LU(double* A, size_t astep, int m, double* b, size_t bstep, int n);
-CV_EXPORTS bool Cholesky(float* A, size_t astep, int m, float* b, size_t bstep, int n);
-CV_EXPORTS bool Cholesky(double* A, size_t astep, int m, double* b, size_t bstep, int n);
-
-
-template<typename _Tp, int m> struct CV_EXPORTS Matx_DetOp
-{
- double operator ()(const Matx<_Tp, m, m>& a) const
- {
- Matx<_Tp, m, m> temp = a;
- double p = LU(temp.val, m*sizeof(_Tp), m, 0, 0, 0);
- if( p == 0 )
- return p;
- for( int i = 0; i < m; i++ )
- p *= temp(i, i);
- return 1./p;
- }
-};
-
-
-template<typename _Tp> struct CV_EXPORTS Matx_DetOp<_Tp, 1>
-{
- double operator ()(const Matx<_Tp, 1, 1>& a) const
- {
- return a(0,0);
- }
-};
-
-
-template<typename _Tp> struct CV_EXPORTS Matx_DetOp<_Tp, 2>
-{
- double operator ()(const Matx<_Tp, 2, 2>& a) const
- {
- return a(0,0)*a(1,1) - a(0,1)*a(1,0);
- }
-};
-
-
-template<typename _Tp> struct CV_EXPORTS Matx_DetOp<_Tp, 3>
-{
- double operator ()(const Matx<_Tp, 3, 3>& a) const
- {
- return a(0,0)*(a(1,1)*a(2,2) - a(2,1)*a(1,2)) -
- a(0,1)*(a(1,0)*a(2,2) - a(2,0)*a(1,2)) +
- a(0,2)*(a(1,0)*a(2,1) - a(2,0)*a(1,1));
- }
-};
-
-template<typename _Tp, int m> static inline
-double determinant(const Matx<_Tp, m, m>& a)
-{
- return Matx_DetOp<_Tp, m>()(a);
-}
-
-
-template<typename _Tp, int m, int n> static inline
-double trace(const Matx<_Tp, m, n>& a)
-{
- _Tp s = 0;
- for( int i = 0; i < std::min(m, n); i++ )
- s += a(i,i);
- return s;
-}
-
-
-template<typename _Tp, int m, int n> inline
-Matx<_Tp, n, m> Matx<_Tp, m, n>::t() const
-{
- return Matx<_Tp, n, m>(*this, Matx_TOp());
-}
-
+namespace internal
+{
template<typename _Tp, int m> struct CV_EXPORTS Matx_FastInvOp
{
}
};
-
template<typename _Tp> struct CV_EXPORTS Matx_FastInvOp<_Tp, 2>
{
bool operator()(const Matx<_Tp, 2, 2>& a, Matx<_Tp, 2, 2>& b, int) const
}
};
-
template<typename _Tp> struct CV_EXPORTS Matx_FastInvOp<_Tp, 3>
{
bool operator()(const Matx<_Tp, 3, 3>& a, Matx<_Tp, 3, 3>& b, int) const
};
-template<typename _Tp, int m, int n> inline
-Matx<_Tp, n, m> Matx<_Tp, m, n>::inv(int method) const
-{
- Matx<_Tp, n, m> b;
- bool ok;
- if( method == DECOMP_LU || method == DECOMP_CHOLESKY )
- ok = Matx_FastInvOp<_Tp, m>()(*this, b, method);
- else
- {
- Mat A(*this, false), B(b, false);
- ok = (invert(A, B, method) != 0);
- }
- return ok ? b : Matx<_Tp, n, m>::zeros();
-}
-
-
template<typename _Tp, int m, int n> struct CV_EXPORTS Matx_FastSolveOp
{
bool operator()(const Matx<_Tp, m, m>& a, const Matx<_Tp, m, n>& b,
}
};
-
template<typename _Tp> struct CV_EXPORTS Matx_FastSolveOp<_Tp, 2, 1>
{
bool operator()(const Matx<_Tp, 2, 2>& a, const Matx<_Tp, 2, 1>& b,
}
};
-
template<typename _Tp> struct CV_EXPORTS Matx_FastSolveOp<_Tp, 3, 1>
{
bool operator()(const Matx<_Tp, 3, 3>& a, const Matx<_Tp, 3, 1>& b,
}
};
+} // internal
+
+template<typename _Tp, int m, int n> inline
+Matx<_Tp,m,n> Matx<_Tp,m,n>::randu(_Tp a, _Tp b)
+{
+ Matx<_Tp,m,n> M;
+ cv::randu(M, Scalar(a), Scalar(b));
+ return M;
+}
+
+template<typename _Tp, int m, int n> inline
+Matx<_Tp,m,n> Matx<_Tp,m,n>::randn(_Tp a, _Tp b)
+{
+ Matx<_Tp,m,n> M;
+ cv::randn(M, Scalar(a), Scalar(b));
+ return M;
+}
+
+template<typename _Tp, int m, int n> inline
+Matx<_Tp, n, m> Matx<_Tp, m, n>::inv(int method) const
+{
+ Matx<_Tp, n, m> b;
+ bool ok;
+ if( method == DECOMP_LU || method == DECOMP_CHOLESKY )
+ ok = internal::Matx_FastInvOp<_Tp, m>()(*this, b, method);
+ else
+ {
+ Mat A(*this, false), B(b, false);
+ ok = (invert(A, B, method) != 0);
+ }
+ return ok ? b : Matx<_Tp, n, m>::zeros();
+}
template<typename _Tp, int m, int n> template<int l> inline
Matx<_Tp, n, l> Matx<_Tp, m, n>::solve(const Matx<_Tp, m, l>& rhs, int method) const
Matx<_Tp, n, l> x;
bool ok;
if( method == DECOMP_LU || method == DECOMP_CHOLESKY )
- ok = Matx_FastSolveOp<_Tp, m, l>()(*this, rhs, x, method);
+ ok = internal::Matx_FastSolveOp<_Tp, m, l>()(*this, rhs, x, method);
else
{
Mat A(*this, false), B(rhs, false), X(x, false);
return ok ? x : Matx<_Tp, n, l>::zeros();
}
-template<typename _Tp, int m, int n> inline
-Vec<_Tp, n> Matx<_Tp, m, n>::solve(const Vec<_Tp, m>& rhs, int method) const
+template<typename _Tp> static inline
+Point_<_Tp> operator * (const Matx<_Tp, 2, 2>& a, const Point_<_Tp>& b)
+{
+ Matx<_Tp, 2, 1> tmp = a * Vec<_Tp,2>(b.x, b.y);
+ return Point_<_Tp>(tmp.val[0], tmp.val[1]);
+}
+
+
+template<typename _Tp> static inline
+Point3_<_Tp> operator * (const Matx<_Tp, 3, 3>& a, const Point3_<_Tp>& b)
+{
+ Matx<_Tp, 3, 1> tmp = a*Vec<_Tp,3>(b.x, b.y, b.z);
+ return Point3_<_Tp>(tmp.val[0], tmp.val[1], tmp.val[2]);
+}
+
+
+template<typename _Tp> static inline
+Point3_<_Tp> operator * (const Matx<_Tp, 3, 3>& a, const Point_<_Tp>& b)
+{
+ Matx<_Tp, 3, 1> tmp = a*Vec<_Tp,3>(b.x, b.y, 1);
+ return Point3_<_Tp>(tmp.val[0], tmp.val[1], tmp.val[2]);
+}
+
+
+template<typename _Tp> static inline
+Matx<_Tp, 4, 1> operator * (const Matx<_Tp, 4, 4>& a, const Point3_<_Tp>& b)
+{
+ return a*Matx<_Tp, 4, 1>(b.x, b.y, b.z, 1);
+}
+
+
+template<typename _Tp> static inline
+Scalar operator * (const Matx<_Tp, 4, 4>& a, const Scalar& b)
{
- Matx<_Tp, n, 1> x = solve(reinterpret_cast<const Matx<_Tp, m, 1>&>(rhs), method);
- return reinterpret_cast<Vec<_Tp, n>&>(x);
+ Matx<double, 4, 1> c(a, b, Matx_MatMulOp());
+ return reinterpret_cast<const Scalar&>(c);
}
template<typename _Tp, typename _AccTp> static inline
return s;
}
-CV_EXPORTS float normL2Sqr_(const float* a, const float* b, int n);
-CV_EXPORTS float normL1_(const float* a, const float* b, int n);
-CV_EXPORTS int normL1_(const uchar* a, const uchar* b, int n);
-CV_EXPORTS int normHamming(const uchar* a, const uchar* b, int n);
-CV_EXPORTS int normHamming(const uchar* a, const uchar* b, int n, int cellSize);
-
template<> inline float normL2Sqr(const float* a, const float* b, int n)
{
if( n >= 8 )
std::sqrt((double)normL2Sqr<_Tp, typename DataType<_Tp>::work_type>(M.val, m*n));
}
-
-template<typename _Tp, int m, int n> static inline
-bool operator == (const Matx<_Tp, m, n>& a, const Matx<_Tp, m, n>& b)
-{
- for( int i = 0; i < m*n; i++ )
- if( a.val[i] != b.val[i] ) return false;
- return true;
-}
-
-template<typename _Tp, int m, int n> static inline
-bool operator != (const Matx<_Tp, m, n>& a, const Matx<_Tp, m, n>& b)
-{
- return !(a == b);
-}
-
-
-template<typename _Tp, typename _T2, int m, int n> static inline
-MatxCommaInitializer<_Tp, m, n> operator << (const Matx<_Tp, m, n>& mtx, _T2 val)
-{
- MatxCommaInitializer<_Tp, m, n> commaInitializer((Matx<_Tp, m, n>*)&mtx);
- return (commaInitializer, val);
-}
-
-template<typename _Tp, int m, int n> inline
-MatxCommaInitializer<_Tp, m, n>::MatxCommaInitializer(Matx<_Tp, m, n>* _mtx)
- : dst(_mtx), idx(0)
-{}
-
-template<typename _Tp, int m, int n> template<typename _T2> inline
-MatxCommaInitializer<_Tp, m, n>& MatxCommaInitializer<_Tp, m, n>::operator , (_T2 value)
-{
- CV_DbgAssert( idx < m*n );
- dst->val[idx++] = saturate_cast<_Tp>(value);
- return *this;
-}
-
-template<typename _Tp, int m, int n> inline
-Matx<_Tp, m, n> MatxCommaInitializer<_Tp, m, n>::operator *() const
-{
- CV_DbgAssert( idx == n*m );
- return *dst;
-}
-
/////////////////////////// short vector (Vec) /////////////////////////////
-template<typename _Tp, int cn> inline Vec<_Tp, cn>::Vec()
-{}
-
-template<typename _Tp, int cn> inline Vec<_Tp, cn>::Vec(_Tp v0)
- : Matx<_Tp, cn, 1>(v0)
-{}
-
-template<typename _Tp, int cn> inline Vec<_Tp, cn>::Vec(_Tp v0, _Tp v1)
- : Matx<_Tp, cn, 1>(v0, v1)
-{}
-
-template<typename _Tp, int cn> inline Vec<_Tp, cn>::Vec(_Tp v0, _Tp v1, _Tp v2)
- : Matx<_Tp, cn, 1>(v0, v1, v2)
-{}
-
-template<typename _Tp, int cn> inline Vec<_Tp, cn>::Vec(_Tp v0, _Tp v1, _Tp v2, _Tp v3)
- : Matx<_Tp, cn, 1>(v0, v1, v2, v3)
-{}
-
-template<typename _Tp, int cn> inline Vec<_Tp, cn>::Vec(_Tp v0, _Tp v1, _Tp v2, _Tp v3, _Tp v4)
- : Matx<_Tp, cn, 1>(v0, v1, v2, v3, v4)
-{}
-
-template<typename _Tp, int cn> inline Vec<_Tp, cn>::Vec(_Tp v0, _Tp v1, _Tp v2, _Tp v3, _Tp v4, _Tp v5)
- : Matx<_Tp, cn, 1>(v0, v1, v2, v3, v4, v5)
-{}
-
-template<typename _Tp, int cn> inline Vec<_Tp, cn>::Vec(_Tp v0, _Tp v1, _Tp v2, _Tp v3,
- _Tp v4, _Tp v5, _Tp v6)
- : Matx<_Tp, cn, 1>(v0, v1, v2, v3, v4, v5, v6)
-{}
-
-template<typename _Tp, int cn> inline Vec<_Tp, cn>::Vec(_Tp v0, _Tp v1, _Tp v2, _Tp v3,
- _Tp v4, _Tp v5, _Tp v6, _Tp v7)
- : Matx<_Tp, cn, 1>(v0, v1, v2, v3, v4, v5, v6, v7)
-{}
-
-template<typename _Tp, int cn> inline Vec<_Tp, cn>::Vec(_Tp v0, _Tp v1, _Tp v2, _Tp v3,
- _Tp v4, _Tp v5, _Tp v6, _Tp v7,
- _Tp v8)
- : Matx<_Tp, cn, 1>(v0, v1, v2, v3, v4, v5, v6, v7, v8)
-{}
-
-template<typename _Tp, int cn> inline Vec<_Tp, cn>::Vec(_Tp v0, _Tp v1, _Tp v2, _Tp v3,
- _Tp v4, _Tp v5, _Tp v6, _Tp v7,
- _Tp v8, _Tp v9)
- : Matx<_Tp, cn, 1>(v0, v1, v2, v3, v4, v5, v6, v7, v8, v9)
-{}
-
-template<typename _Tp, int cn> inline Vec<_Tp, cn>::Vec(const _Tp* values)
- : Matx<_Tp, cn, 1>(values)
-{}
-
-
-template<typename _Tp, int cn> inline Vec<_Tp, cn>::Vec(const Vec<_Tp, cn>& m)
- : Matx<_Tp, cn, 1>(m.val)
-{}
-
-template<typename _Tp, int cn> inline
-Vec<_Tp, cn>::Vec(const Matx<_Tp, cn, 1>& a, const Matx<_Tp, cn, 1>& b, Matx_AddOp op)
-: Matx<_Tp, cn, 1>(a, b, op)
-{}
-
-template<typename _Tp, int cn> inline
-Vec<_Tp, cn>::Vec(const Matx<_Tp, cn, 1>& a, const Matx<_Tp, cn, 1>& b, Matx_SubOp op)
-: Matx<_Tp, cn, 1>(a, b, op)
-{}
-
-template<typename _Tp, int cn> template<typename _T2> inline
-Vec<_Tp, cn>::Vec(const Matx<_Tp, cn, 1>& a, _T2 alpha, Matx_ScaleOp op)
-: Matx<_Tp, cn, 1>(a, alpha, op)
-{}
-
-template<typename _Tp, int cn> inline Vec<_Tp, cn> Vec<_Tp, cn>::all(_Tp alpha)
-{
- Vec v;
- for( int i = 0; i < cn; i++ ) v.val[i] = alpha;
- return v;
-}
-
-template<typename _Tp, int cn> inline Vec<_Tp, cn> Vec<_Tp, cn>::mul(const Vec<_Tp, cn>& v) const
-{
- Vec<_Tp, cn> w;
- for( int i = 0; i < cn; i++ ) w.val[i] = saturate_cast<_Tp>(this->val[i]*v.val[i]);
- return w;
-}
-
-template<typename _Tp> Vec<_Tp, 2> conjugate(const Vec<_Tp, 2>& v)
-{
- return Vec<_Tp, 2>(v[0], -v[1]);
-}
-
-template<typename _Tp> Vec<_Tp, 4> conjugate(const Vec<_Tp, 4>& v)
-{
- return Vec<_Tp, 4>(v[0], -v[1], -v[2], -v[3]);
-}
-
-template<> inline Vec<float, 2> Vec<float, 2>::conj() const
-{
- return conjugate(*this);
-}
-
-template<> inline Vec<double, 2> Vec<double, 2>::conj() const
-{
- return conjugate(*this);
-}
-
-template<> inline Vec<float, 4> Vec<float, 4>::conj() const
-{
- return conjugate(*this);
-}
-
-template<> inline Vec<double, 4> Vec<double, 4>::conj() const
-{
- return conjugate(*this);
-}
-
-template<typename _Tp, int cn> inline Vec<_Tp, cn> Vec<_Tp, cn>::cross(const Vec<_Tp, cn>&) const
-{
- CV_Error(CV_StsError, "for arbitrary-size vector there is no cross-product defined");
- return Vec<_Tp, cn>();
-}
-
-template<typename _Tp, int cn> template<typename T2>
-inline Vec<_Tp, cn>::operator Vec<T2, cn>() const
-{
- Vec<T2, cn> v;
- for( int i = 0; i < cn; i++ ) v.val[i] = saturate_cast<T2>(this->val[i]);
- return v;
-}
-
-template<typename _Tp, int cn> inline const _Tp& Vec<_Tp, cn>::operator [](int i) const
-{
- CV_DbgAssert( (unsigned)i < (unsigned)cn );
- return this->val[i];
-}
-
-template<typename _Tp, int cn> inline _Tp& Vec<_Tp, cn>::operator [](int i)
-{
- CV_DbgAssert( (unsigned)i < (unsigned)cn );
- return this->val[i];
-}
-
-template<typename _Tp, int cn> inline const _Tp& Vec<_Tp, cn>::operator ()(int i) const
-{
- CV_DbgAssert( (unsigned)i < (unsigned)cn );
- return this->val[i];
-}
-
-template<typename _Tp, int cn> inline _Tp& Vec<_Tp, cn>::operator ()(int i)
-{
- CV_DbgAssert( (unsigned)i < (unsigned)cn );
- return this->val[i];
-}
-
-template<typename _Tp1, typename _Tp2, int cn> static inline Vec<_Tp1, cn>&
-operator += (Vec<_Tp1, cn>& a, const Vec<_Tp2, cn>& b)
-{
- for( int i = 0; i < cn; i++ )
- a.val[i] = saturate_cast<_Tp1>(a.val[i] + b.val[i]);
- return a;
-}
-
-template<typename _Tp1, typename _Tp2, int cn> static inline Vec<_Tp1, cn>&
-operator -= (Vec<_Tp1, cn>& a, const Vec<_Tp2, cn>& b)
-{
- for( int i = 0; i < cn; i++ )
- a.val[i] = saturate_cast<_Tp1>(a.val[i] - b.val[i]);
- return a;
-}
-
-template<typename _Tp, int cn> static inline Vec<_Tp, cn>
-operator + (const Vec<_Tp, cn>& a, const Vec<_Tp, cn>& b)
-{
- return Vec<_Tp, cn>(a, b, Matx_AddOp());
-}
-
-template<typename _Tp, int cn> static inline Vec<_Tp, cn>
-operator - (const Vec<_Tp, cn>& a, const Vec<_Tp, cn>& b)
-{
- return Vec<_Tp, cn>(a, b, Matx_SubOp());
-}
-
-template<typename _Tp, int cn> static inline
-Vec<_Tp, cn>& operator *= (Vec<_Tp, cn>& a, int alpha)
-{
- for( int i = 0; i < cn; i++ )
- a[i] = saturate_cast<_Tp>(a[i]*alpha);
- return a;
-}
-
-template<typename _Tp, int cn> static inline
-Vec<_Tp, cn>& operator *= (Vec<_Tp, cn>& a, float alpha)
-{
- for( int i = 0; i < cn; i++ )
- a[i] = saturate_cast<_Tp>(a[i]*alpha);
- return a;
-}
-
-template<typename _Tp, int cn> static inline
-Vec<_Tp, cn>& operator *= (Vec<_Tp, cn>& a, double alpha)
-{
- for( int i = 0; i < cn; i++ )
- a[i] = saturate_cast<_Tp>(a[i]*alpha);
- return a;
-}
-
-template<typename _Tp, int cn> static inline
-Vec<_Tp, cn>& operator /= (Vec<_Tp, cn>& a, int alpha)
-{
- double ialpha = 1./alpha;
- for( int i = 0; i < cn; i++ )
- a[i] = saturate_cast<_Tp>(a[i]*ialpha);
- return a;
-}
-
-template<typename _Tp, int cn> static inline
-Vec<_Tp, cn>& operator /= (Vec<_Tp, cn>& a, float alpha)
-{
- float ialpha = 1.f/alpha;
- for( int i = 0; i < cn; i++ )
- a[i] = saturate_cast<_Tp>(a[i]*ialpha);
- return a;
-}
-
-template<typename _Tp, int cn> static inline
-Vec<_Tp, cn>& operator /= (Vec<_Tp, cn>& a, double alpha)
-{
- double ialpha = 1./alpha;
- for( int i = 0; i < cn; i++ )
- a[i] = saturate_cast<_Tp>(a[i]*ialpha);
- return a;
-}
-
-template<typename _Tp, int cn> static inline Vec<_Tp, cn>
-operator * (const Vec<_Tp, cn>& a, int alpha)
-{
- return Vec<_Tp, cn>(a, alpha, Matx_ScaleOp());
-}
-
-template<typename _Tp, int cn> static inline Vec<_Tp, cn>
-operator * (int alpha, const Vec<_Tp, cn>& a)
-{
- return Vec<_Tp, cn>(a, alpha, Matx_ScaleOp());
-}
-
-template<typename _Tp, int cn> static inline Vec<_Tp, cn>
-operator * (const Vec<_Tp, cn>& a, float alpha)
-{
- return Vec<_Tp, cn>(a, alpha, Matx_ScaleOp());
-}
-
-template<typename _Tp, int cn> static inline Vec<_Tp, cn>
-operator * (float alpha, const Vec<_Tp, cn>& a)
-{
- return Vec<_Tp, cn>(a, alpha, Matx_ScaleOp());
-}
-
-template<typename _Tp, int cn> static inline Vec<_Tp, cn>
-operator * (const Vec<_Tp, cn>& a, double alpha)
-{
- return Vec<_Tp, cn>(a, alpha, Matx_ScaleOp());
-}
-
-template<typename _Tp, int cn> static inline Vec<_Tp, cn>
-operator * (double alpha, const Vec<_Tp, cn>& a)
-{
- return Vec<_Tp, cn>(a, alpha, Matx_ScaleOp());
-}
-
-template<typename _Tp, int cn> static inline Vec<_Tp, cn>
-operator / (const Vec<_Tp, cn>& a, int alpha)
-{
- return Vec<_Tp, cn>(a, 1./alpha, Matx_ScaleOp());
-}
-
-template<typename _Tp, int cn> static inline Vec<_Tp, cn>
-operator / (const Vec<_Tp, cn>& a, float alpha)
-{
- return Vec<_Tp, cn>(a, 1.f/alpha, Matx_ScaleOp());
-}
-
-template<typename _Tp, int cn> static inline Vec<_Tp, cn>
-operator / (const Vec<_Tp, cn>& a, double alpha)
-{
- return Vec<_Tp, cn>(a, 1./alpha, Matx_ScaleOp());
-}
-
-template<typename _Tp, int cn> static inline Vec<_Tp, cn>
-operator - (const Vec<_Tp, cn>& a)
-{
- Vec<_Tp,cn> t;
- for( int i = 0; i < cn; i++ ) t.val[i] = saturate_cast<_Tp>(-a.val[i]);
- return t;
-}
-
-template<typename _Tp> inline Vec<_Tp, 4> operator * (const Vec<_Tp, 4>& v1, const Vec<_Tp, 4>& v2)
-{
- return Vec<_Tp, 4>(saturate_cast<_Tp>(v1[0]*v2[0] - v1[1]*v2[1] - v1[2]*v2[2] - v1[3]*v2[3]),
- saturate_cast<_Tp>(v1[0]*v2[1] + v1[1]*v2[0] + v1[2]*v2[3] - v1[3]*v2[2]),
- saturate_cast<_Tp>(v1[0]*v2[2] - v1[1]*v2[3] + v1[2]*v2[0] + v1[3]*v2[1]),
- saturate_cast<_Tp>(v1[0]*v2[3] + v1[1]*v2[2] - v1[2]*v2[1] + v1[3]*v2[0]));
-}
-
-template<typename _Tp> inline Vec<_Tp, 4>& operator *= (Vec<_Tp, 4>& v1, const Vec<_Tp, 4>& v2)
-{
- v1 = v1 * v2;
- return v1;
-}
-
-template<> inline Vec<float, 3> Vec<float, 3>::cross(const Vec<float, 3>& v) const
-{
- return Vec<float,3>(val[1]*v.val[2] - val[2]*v.val[1],
- val[2]*v.val[0] - val[0]*v.val[2],
- val[0]*v.val[1] - val[1]*v.val[0]);
-}
-
-template<> inline Vec<double, 3> Vec<double, 3>::cross(const Vec<double, 3>& v) const
-{
- return Vec<double,3>(val[1]*v.val[2] - val[2]*v.val[1],
- val[2]*v.val[0] - val[0]*v.val[2],
- val[0]*v.val[1] - val[1]*v.val[0]);
-}
template<typename _Tp, int cn> inline Vec<_Tp, cn> normalize(const Vec<_Tp, cn>& v)
{
return v * (nv ? 1./nv : 0.);
}
-template<typename _Tp, typename _T2, int cn> static inline
-VecCommaInitializer<_Tp, cn> operator << (const Vec<_Tp, cn>& vec, _T2 val)
-{
- VecCommaInitializer<_Tp, cn> commaInitializer((Vec<_Tp, cn>*)&vec);
- return (commaInitializer, val);
-}
-
-template<typename _Tp, int cn> inline
-VecCommaInitializer<_Tp, cn>::VecCommaInitializer(Vec<_Tp, cn>* _vec)
- : MatxCommaInitializer<_Tp, cn, 1>(_vec)
-{}
-
-template<typename _Tp, int cn> template<typename _T2> inline
-VecCommaInitializer<_Tp, cn>& VecCommaInitializer<_Tp, cn>::operator , (_T2 value)
-{
- CV_DbgAssert( this->idx < cn );
- this->dst->val[this->idx++] = saturate_cast<_Tp>(value);
- return *this;
-}
-
-template<typename _Tp, int cn> inline
-Vec<_Tp, cn> VecCommaInitializer<_Tp, cn>::operator *() const
-{
- CV_DbgAssert( this->idx == cn );
- return *this->dst;
-}
-
//////////////////////////////// Complex //////////////////////////////
template<typename _Tp> inline Complex<_Tp>::Complex() : re(0), im(0) {}
#define __OPENCV_CORE_TYPES_HPP__
#include <climits>
+#include <cfloat>
#include <vector>
#ifndef OPENCV_NOSTL
void* func = (void*) CV_GL_GET_PROC_ADDRESS(name);
if (!func)
{
- CV_Error(CV_OpenGlApiCallError, cv::format("Can't load OpenGL extension [%s]", name) );
+ CV_Error(cv::Error::OpenGlApiCallError, cv::format("Can't load OpenGL extension [%s]", name) );
}
return func;
}
#else
static void* IntGetProcAddress(const char*)
{
- CV_Error(CV_OpenGlNotSupported, "The library is compiled without OpenGL support");
+ CV_Error(cv::Error::OpenGlNotSupported, "The library is compiled without OpenGL support");
return 0;
}
#endif
throw exc;
}
+void error(int _code, const String& _err, const char* _func, const char* _file, int _line)
+{
+ error(cv::Exception(_code, _err, _func, _file, _line));
+}
+
CvErrorCallback
redirectError( CvErrorCallback errCallback, void* userdata, void** prevUserdata)
{
using namespace cv;
-namespace internal
+namespace
{
void __wrap_printf_func(const char* fmt, ...)
{
#define PRINT_TO_LOG __wrap_printf_func
}
-using internal::PRINT_TO_LOG;
#define SHOW_IMAGE
#undef SHOW_IMAGE
{
}
-namespace internal
+namespace
{
void interpolateLinear(float x, float* coeffs)
{
}
else if (interpolation == INTER_LINEAR || interpolation == INTER_CUBIC || interpolation == INTER_LANCZOS4)
{
- internal::interpolate_method inter_func = internal::inter_array[interpolation - (interpolation == INTER_LANCZOS4 ? 2 : 1)];
+ interpolate_method inter_func = inter_array[interpolation - (interpolation == INTER_LANCZOS4 ? 2 : 1)];
size_t elemsize = _src.elemSize();
int ofs = 0, ksize = 2;
height1 = std::max(ssize.height - ksize + 1, 0);
float ix[8], w[16];
- internal::interpolate_method inter_func = internal::inter_array[interpolation - (interpolation == INTER_LANCZOS4 ? 2 : 1)];
+ interpolate_method inter_func = inter_array[interpolation - (interpolation == INTER_LANCZOS4 ? 2 : 1)];
for (int dy = 0; dy < dsize.height; ++dy)
{
projects / profile / ivi / opencv.git / commitdiff