开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 图形图像 > OpenCV > 查看源码
cvutMatrix.h
资源名称：cameraCalibration.rar　[点击查看]
上传用户：jiayuled
上传日期：2020-03-04
资源大小：9338k
文件大小：16k
源码类别：

OpenCV

开发平台：

C/C++

cvutMatrix.h：源码内容
  1. /************************************************************************
  2. 没有考虑不同数据类型但相同矩阵形式之间的各种操作
  3. *************************************************************************/
  5. #ifndef CVUT_MATRIX_H
  6. #define CVUT_MATRIX_H
  8. #include "cv.h"
  9. #include <iostream>
  10. #include <sstream>
  11. #include <string>
  12. #include <typeinfo>
  14. using namespace std;
  16. //#pragma comment(lib,"cxcore.lib")
  18. namespace cvutMatrix {
  19. /************************************************************************
  20. Class Matrix
  21. *************************************************************************/
  22. template <typename T>
  23. class Matrix {
  24. public:
  25. T* data;
  26. int rows;
  27. int cols;
  28. int channels;
  29. CvMat* cvmat;
  31. public:
  32. /************************************************************************
  33. constructor
  34. *************************************************************************/
  35. Matrix(int rows,int cols,int channels=1,const T* arr=NULL) {
  36. int type=0;
  37. if (0 == strcmp(typeid(*data).name(),"unsigned char")) {
  38. type = 0;
  39. } else if (0 == strcmp(typeid(*data).name(),"char")) {
  40. type = 1;
  41. } else if (0 == strcmp(typeid(*data).name(),"short")) {
  42. type = 2;
  43. } else if (0 == strcmp(typeid(*data).name(),"unsigned short")) {
  44. type = 3;
  45. } else if (0 == strcmp(typeid(*data).name(),"int")) {
  46. type = 4;
  47. } else if (0 == strcmp(typeid(*data).name(),"float")) {
  48. type = 5;
  49. } else if (0 == strcmp(typeid(*data).name(),"double")) {
  50. type = 6;
  51. } else {
  52. cerr<<"unsupported matrix type!n";
  53. exit(1);
  54. }
  55. cvmat = cvCreateMat(rows,cols,type+8*(channels-1));
  56. data = (T*)cvmat->data.ptr;
  57. this->rows = rows;
  58. this->cols = cols;
  59. this->channels=channels;
  60. bool user_data=false;
  61. if (arr !=NULL) 
  62. user_data=true;
  63. for (int i=0;i<rows;i++) {
  64. for (int j=0;j<cols;j++) {
  65. for (int k=0;k<channels;k++) {
  66. if (user_data)
  67. data[i*cols*channels+j*channels+k]=arr[i*cols*channels+j*channels+k];
  68. else
  69. data[i*cols*channels+j*channels+k]=0;
  70. }
  71. }
  72. }
  73. };
  75. Matrix(CvMat* src) {
  76. cvmat = cvCloneMat(src);
  77. data = (T*)src->data.ptr;
  78. rows = src->rows;
  79. cols = src->cols;
  80. channels=cvmat->step/cols/sizeof(T);
  81. };
  83. Matrix(Matrix<T>& src) {
  84. cvmat=cvCloneMat(src.cvmat);
  85. data = (T*)(src.cvmat->data.ptr);
  86. rows = src.rows;
  87. cols = src.cols;
  88. channels=src.channels;
  89. };
  91. /************************************************************************
  92. deconstructor
  93. *************************************************************************/
  94. ~Matrix() {
  95. cvReleaseMat(&cvmat);
  96. data=NULL;
  97. };
  99. /************************************************************************
  100. access matrix element
  101. *************************************************************************/
  102. T& operator () (int i_row,int i_col,int i_channel=0) {
  103. if (i_row>=0 && i_row<rows && i_col>=0 && i_col<cols && i_channel>=0 && i_channel<channels)
  104. return data[i_row*cols+i_col*channels+i_channel];
  105. else {
  106. cerr<<"matrix access out of range"<<endl;
  107. exit(1);
  108. }
  109. };
  111. /************************************************************************
  112. overload = (Matrix = Matrix)
  113. *************************************************************************/
  114. Matrix<T>& operator =(Matrix<T>& src) {
  115. if (!mat_type_cmp(*this,src)) {
  116. cerr<<"matrix type unmatch!n";
  117. exit(1);
  118. }
  119. for (int i=0;i<rows;i++) {
  120. for (int j=0;j<cols;j++) {
  121. for (int k=0;k<channels;k++) {
  122. data[i*cols*channels+j*channels+k]=src.data[i*cols*channels+j*channels+k];
  123. }
  124. }
  125. }
  126. return *this;
  127. };
  129. /************************************************************************
  130. overload + (matrix + matrix)
  131. *************************************************************************/
  132. Matrix<T> operator + (Matrix<T>& src) {
  133. if (!mat_type_cmp(*this,src)) {
  134. cerr<<"matrix type unmatch!n";
  135. exit(1);
  136. }
  137. Matrix<T> temp(*this);
  138. cvAdd(cvmat,src.cvmat,temp.cvmat);
  139. return temp;
  140. };
  142. /************************************************************************
  143. overload += (matrix += matrix)
  144. *************************************************************************/
  145. Matrix<T>& operator +=(Matrix<T>& src) {
  146. if (!mat_type_cmp(*this,src)) {
  147. cerr<<"matrix type unmatch!n";
  148. exit(1);
  149. }
  150. cvAdd(cvmat,src.cvmat,cvmat);
  151. return *this;
  152. };
  154. /************************************************************************
  155. overload + (matrix + number)
  156. *************************************************************************/
  157. Matrix<T> operator + (double num) {
  158. Matrix<T> temp(*this);
  159. for (int i=0;i<rows;i++) {
  160. for (int j=0;j<cols;j++) {
  161. for (int k=0;k<channels;k++) {
  162. temp.data[i*cols*channels+j*channels+k]+=num;
  163. }
  164. }
  165. }
  166. return temp;
  167. };
  169. /************************************************************************
  170. overload += (matrix += number)
  171. *************************************************************************/
  172. Matrix<T>& operator +=(double num) {
  173. for (int i=0;i<rows;i++) {
  174. for (int j=0;j<cols;j++) {
  175. for (int k=0;k<channels;k++) {
  176. data[i*cols*channels+j*channels+k]+=num;
  177. }
  178. }
  179. }
  180. return *this;
  181. };
  183. /************************************************************************
  184. overload - (matrix - matrix)
  185. *************************************************************************/
  186. Matrix<T> operator - (Matrix<T>& src) {
  187. if (!mat_type_cmp(*this,src)) {
  188. cerr<<"matrix type unmatch!n";
  189. exit(1);
  190. }
  191. Matrix<T> temp(*this);
  192. cvSub(cvmat,src.cvmat,temp.cvmat);
  193. return temp;
  194. };
  196. /************************************************************************
  197. overload -= (matrix -= matrix)
  198. *************************************************************************/
  199. Matrix<T>& operator -=(Matrix<T>& src) {
  200. if (!mat_type_cmp(*this,src)) {
  201. cerr<<"matrix type unmatch!n";
  202. exit(1);
  203. }
  204. cvSub(cvmat,src.cvmat,cvmat);
  205. return *this;
  206. };
  208. /************************************************************************
  209. overload - (matrix - number)
  210. *************************************************************************/
  211. Matrix<T> operator - (double num) {
  212. Matrix<T> temp(*this);
  213. return temp+=(-num);;
  214. };
  216. /************************************************************************
  217. overload -= (matrix -= number)
  218. *************************************************************************/
  219. Matrix<T>& operator -=(double num) {
  220. return *this+=(-num);
  221. };
  223. /************************************************************************
  224. overload * (matrix * matrix)
  225. *************************************************************************/
  226. Matrix<T> operator * (Matrix<T>& src) {
  227. if (!can_mult(*this,src)) {
  228. cerr<<"matrix multiply fail!n";
  229. exit(1);
  230. }
  231. Matrix<T> temp(rows,src.cols,channels);
  232. cvMatMul(cvmat,src.cvmat,temp.cvmat);
  233. return temp;
  234. };
  236. /************************************************************************
  237. overload * (matrix * number)
  238. *************************************************************************/
  239. Matrix<T> operator * (double num) {
  240. Matrix<T> temp(*this);
  241. for (int i=0;i<rows;i++) {
  242. for (int j=0;j<cols;j++) {
  243. for (int k=0;k<channels;k++) {
  244. temp.data[i*cols*channels+j*channels+k] *= num;
  245. }
  246. }
  247. }
  248. return temp;
  249. };
  251. /************************************************************************
  252. overload *= (matrix *= number)
  253. *************************************************************************/
  254. Matrix<T>& operator *=(double num) {
  255. for (int i=0;i<rows;i++) {
  256. for (int j=0;j<cols;j++) {
  257. for (int k=0;k<channels;k++) {
  258. data[i*cols*channels+j*channels+k]*=num;
  259. }
  260. }
  261. }
  262. return *this;
  263. };
  265. /************************************************************************
  266. compare two matrixes (matrix == matrix)
  267. regardless of element type
  268. *************************************************************************/
  269. bool operator == (const Matrix<T>& src) {
  270. if (!mat_type_cmp(*this,src))
  271. return false;
  272. for (int i=0;i<src.rows;i++) {
  273. for (int j=0;j<src.cols;j++) {
  274. for (int k=0;k<src.channels;k++) {
  275. if (src.data[i*src.cols*src.channels+j*src.channels+k] !=
  276. data[i*src.cols*src.channels+j*src.channels+k]) 
  277. {
  278. return false;
  279. }
  280. }
  281. }
  282. }
  283. return true;
  284. };
  286. /************************************************************************
  287. set matrix identity
  288. *************************************************************************/
  289. void identity() {
  290. if (cols != rows) {
  291. cerr<<"identity fail! non-spuare!n";
  292. exit(1);
  293. }
  294. for (int i=0;i<cols;i++) {
  295. for (int j=0;j<rows;j++) {
  296. for (int k=0;k<channels;k++)
  297. data[i*cols*channels+j*channels+k]=(i == j)?1.0:0.0;
  298. }
  299. }
  300. };
  302. /************************************************************************
  303.        get row
  304. *************************************************************************/
  305. Matrix<T> get_row(int index) {
  306. if (index<0 || index>=rows) {
  307. cerr<<"out of range!n";
  308. exit(1);
  309. }
  310. Matrix<T> temp(1,cols,channels);
  311. for (int i=0;i<cols;i++) {
  312. for (int j=0;j<channels;j++) {
  313. temp(0,i,j) = data[index*cols*channels+i*channels+j];
  314. }
  315. }
  316. return temp;
  317. };
  319. /************************************************************************
  320.        get rows
  321. *************************************************************************/
  322. Matrix<T> get_rows(int first,int last) {
  323. if (first<0 || first>=rows || last<0 || last>=rows || first>last) {
  324. cerr<<"out of range!n";
  325. exit(1);
  326. }
  327. Matrix<T> temp(last-first+1,cols,channels);
  328. for (int t=0;t<last-first+1;t++) {
  329. for (int i=0;i<cols;i++) {
  330. for (int j=0;j<channels;j++) {
  331. temp(t,i,j) = data[(t+first)*cols*channels+i*channels+j];
  332. }
  333. }
  334. }
  335. return temp;
  336. };
  338. /************************************************************************
  339.        get column
  340. *************************************************************************/
  341. Matrix<T> get_col(int index) {
  342. if (index<0 || index>=cols) {
  343. cerr<<"out of range!n";
  344. exit(1);
  345. }
  346. Matrix<T> temp(rows,1,channels);
  347. for (int i=0;i<rows;i++) {
  348. for (int j=0;j<channels;j++) {
  349. temp(i,0,j) = data[i*cols*channels+index*channels+j];
  350. }
  351. }
  352. return temp;
  353. };
  355. /************************************************************************
  356.        get columns
  357. *************************************************************************/
  358. Matrix<T> get_cols(int first,int last) {
  359. if (first<0 || first>=cols || last<0 || last>=cols || first>last) {
  360. cerr<<"out of range!n";
  361. exit(1);
  362. }
  363. Matrix<T> temp(rows,last-first+1,channels);
  364. for (int t=0;t<rows;t++) {
  365. for (int i=0;i<last-first+1;i++) {
  366. for (int j=0;j<channels;j++) {
  367. temp(t,i,j) = data[t*cols*channels+(i+first)*channels+j];
  368. }
  369. }
  370. }
  371. return temp;
  372. };
  374. /************************************************************************
  375.        get sub-matrix
  376. *************************************************************************/
  377. Matrix<T> submat(int first_row,int last_row,int first_col,int last_col,int first_channel,int last_channel) {
  378. if (first_row<0 || first_row>=rows ||
  379. last_row<0 || last_row>=rows || first_row>last_row ||
  380. first_col<0 || first_col>=cols ||
  381. last_col<0 || last_col>=cols || first_col>last_col ||
  382. first_channel<0 || first_channel>=channels ||
  383. last_channel<0 || last_channel>=channels || first_channel>last_channel) 
  384. {
  385. cerr<<"out of range!n";
  386. exit(1);
  387. }
  388. Matrix<T> temp(last_row-first_row+1,last_col-first_col+1,last_channel-first_channel+1);
  389. for (int i=0;i<last_row-first_row+1;i++) {
  390. for (int j=0;j<last_col-first_col+1;j++) {
  391. for (int t=0;t<last_channel-first_channel+1;t++) {
  392. temp(i,j,t) = data[(i+first_row)*cols*channels+(j+first_col)*channels+t];
  393. }
  394. }
  395. }
  396. return temp;
  397. };
  399. /************************************************************************
  400.        get struct information of matrix
  401. *************************************************************************/
  402. string info() {
  403. stringstream stream;
  404. string rows,cols,cha;
  405. stream<<rows;
  406. stream>>rows;
  407. stream.clear();
  408. stream<<cols;
  409. stream>>cols;
  410. stream.clear();
  411. stream<<channels;
  412. stream>>cha;
  413. stream.clear();
  414. string s = "elem type : ";
  415. s+=typeid(*data).name();
  416. s+="nrows : ";
  417. s+=rows;
  418. s+="ncols : ";
  419. s+=cols;
  420. s+="nchannels : ";
  421. s+=cha;
  422. s+='n';
  423. return s;
  424. };
  425. }; /* class Matrix */
  427.    /************************************************************************
  428. Matrix tool function
  429.    *************************************************************************/ 
  430.    /************************************************************************
  431. whether matrix is square
  432.    *************************************************************************/
  433.    template <typename T>
  434.    bool is_square (const Matrix<T>& src) {
  435.    if (src.rows == src.cols)
  436.    return true;
  437.    else
  438.    return false;
  439.    };
  440.    
  441.    /************************************************************************
  442. whether matrix can mult
  443.    *************************************************************************/
  444.    template <typename T>
  445. bool can_mult(const Matrix<T>& mat1,const Matrix<T>& mat2) {
  446.    if ((mat1.cols == mat2.rows) && (mat1.channels == mat2.channels))
  447.    return true;
  448.    else
  449.    return false;
  450.    };
  451.    
  452.    /************************************************************************
  453. whether two matrix are same
  454. regardless of element type
  455.    *************************************************************************/
  456.    template <typename T>
  457. bool mat_type_cmp (const Matrix<T>& mat1,const Matrix<T>& mat2) {
  458.    if (mat1.channels != mat2.channels)
  459.    return false;
  460.    if (mat1.rows != mat2.rows)
  461.    return false;
  462.    if (mat1.cols != mat2.cols)
  463.    return false;
  464.    return true;
  465.    };
  466.    
  467.    /************************************************************************
  468. whether the element types of two matrix are same
  469.    *************************************************************************/
  470.    template <typename T,typename P>
  471. bool mat_data_type_cmp (const Matrix<T>& mat1,const Matrix<P>& mat2) {
  472.    if (typeid(*mat1.data) == typeid(*mat2.data))
  473.    return true;
  474.    return false;
  475.    };
  476.    
  477.    /************************************************************************
  478. matrix transpose
  479.    *************************************************************************/
  480.    template <typename T>
  481. Matrix<T> transpose(Matrix<T>& src) {
  482.    Matrix<T> temp(src.cols,src.rows,src.channels);
  483.    cvTranspose(src.cvmat,temp.cvmat);
  484.    return temp;
  485.    };
  486.    
  487.    /************************************************************************
  488. invert matrix
  489.    *************************************************************************/
  490.    template <typename T>
  491. Matrix<T> invert(Matrix<T>& src,int method=CV_SVD) {
  492.    if (!is_square(src)) {
  493.    cerr<<"can not invert a non-squre matrix!n";
  494.    exit(1);
  495.    }
  496.    Matrix<T> temp(src);
  497.    cvInvert(src.cvmat,temp.cvmat,method);
  498.    return temp;
  499.    };
  500.    
  501.    /************************************************************************
  502. matrix's det
  503.    *************************************************************************/
  504.    template <typename T>
  505. double det(Matrix<T>& src) {
  506.    if (!is_square(src)) {
  507.    cerr<<"con not get det from non-square matrix!n";
  508.    exit(1);
  509.    }
  510.    return cvDet(src.cvmat);
  511.    };
  512.    
  513.    template <typename T>
  514.    ostream& operator << (ostream& out,Matrix<T>& src) {
  515.    stringstream stream;
  516.    string data="";
  517.    for (int i=0;i<src.rows;i++) {
  518.    out<<'{';
  519.    for (int j=0;j<src.cols;j++) {
  520.    if (src.channels != 1)
  521.        out<<'{';
  522.    for (int k=0;k<src.channels;k++) {
  523.    stream.clear();
  524.    stream<<src.data[i*src.cols*src.channels+j*src.channels+k];
  525.    stream>>data;
  526.    out<<data;
  527.    if (k < src.channels-1)
  528.    out<<',';
  529.    }
  530.    if (src.channels != 1)
  531.        out<<'}';
  532.    if (j < src.cols-1)
  533.    out<<',';
  534.    }
  535.    out<<'}'<<'n';
  536.    }
  537.    return out;
  538.    };
  539.    
  540. } /* namespace cvutMatrix */
  542. #endif /* CVUT_MATRIX_H */