mirror of
https://github.com/opencv/opencv.git
synced 2024-11-29 05:29:54 +08:00
Implementation of cv::Matx and cv::Vec is almost moved to matx.hpp
This commit is contained in:
Andrey Kamaev
parent
d2192c0759
commit
969a7133a9
@ -49,14 +49,17 @@
|
||||
#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>
|
||||
@ -127,22 +130,6 @@ public:
|
||||
*/
|
||||
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
|
||||
|
||||
@ -2059,26 +2046,6 @@ 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 //////////////////////////
|
||||
|
||||
/*!
|
||||
|
||||
@ -44,11 +44,71 @@
|
||||
#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,
|
||||
@ -95,6 +155,71 @@ enum { DFT_INVERSE = 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); }
|
||||
@ -144,6 +269,19 @@ template<> inline unsigned saturate_cast<unsigned>(double v) { return cvRound(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;
|
||||
@ -182,6 +320,8 @@ namespace gpu
|
||||
class CV_EXPORTS GpuMat;
|
||||
}
|
||||
|
||||
|
||||
|
||||
} // cv
|
||||
|
||||
#endif //__OPENCV_CORE_BASE_HPP__
|
||||
|
||||
@ -79,16 +79,18 @@ 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 = 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();
|
||||
|
||||
@ -234,6 +236,26 @@ public:
|
||||
};
|
||||
};
|
||||
|
||||
/*!
|
||||
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 /////////////////////
|
||||
@ -357,6 +379,930 @@ public:
|
||||
};
|
||||
};
|
||||
|
||||
/*!
|
||||
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__
|
||||
File diff suppressed because it is too large
Load Diff
@ -45,6 +45,7 @@
|
||||
#define __OPENCV_CORE_TYPES_HPP__
|
||||
|
||||
#include <climits>
|
||||
#include <cfloat>
|
||||
#include <vector>
|
||||
|
||||
#ifndef OPENCV_NOSTL
|
||||
|
||||
@ -136,14 +136,14 @@
|
||||
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
|
||||
|
||||
@ -465,6 +465,11 @@ void error( const Exception& exc )
|
||||
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)
|
||||
{
|
||||
|
||||
@ -47,7 +47,7 @@
|
||||
|
||||
using namespace cv;
|
||||
|
||||
namespace internal
|
||||
namespace
|
||||
{
|
||||
void __wrap_printf_func(const char* fmt, ...)
|
||||
{
|
||||
@ -62,7 +62,6 @@ namespace internal
|
||||
#define PRINT_TO_LOG __wrap_printf_func
|
||||
}
|
||||
|
||||
using internal::PRINT_TO_LOG;
|
||||
#define SHOW_IMAGE
|
||||
#undef SHOW_IMAGE
|
||||
|
||||
@ -359,7 +358,7 @@ CV_Resize_Test::~CV_Resize_Test()
|
||||
{
|
||||
}
|
||||
|
||||
namespace internal
|
||||
namespace
|
||||
{
|
||||
void interpolateLinear(float x, float* coeffs)
|
||||
{
|
||||
@ -523,7 +522,7 @@ void CV_Resize_Test::resize_1d(const Mat& _src, Mat& _dst, int dy, const dim& _d
|
||||
}
|
||||
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;
|
||||
@ -874,7 +873,7 @@ void CV_Remap_Test::remap_generic(const Mat& _src, Mat& _dst)
|
||||
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)
|
||||
{
|
||||
|
||||
Loading…
Reference in New Issue
Block a user