cvutmatrix.h

基于OpenCV的计算机视觉技术实现.rar

/************************************************************************
没有考虑不同数据类型但相同矩阵形式之间的各种操作
*************************************************************************/

#ifndef CVUT_MATRIX_H
#define CVUT_MATRIX_H

#include "cv.h"
#include <iostream>
#include <sstream>
#include <string>
#include <typeinfo>

using namespace std;

//#pragma comment(lib,"cxcore.lib")

namespace cvutMatrix {
/************************************************************************
Class Matrix
*************************************************************************/
template <typename T>
class Matrix {
public:
	T* data;
	int rows;
	int cols;
	int channels;
	CvMat* cvmat;
	
public:
	/************************************************************************
		constructor
	*************************************************************************/
	Matrix(int rows,int cols,int channels=1,const T* arr=NULL) {
		int type=0;
		if (0 == strcmp(typeid(*data).name(),"unsigned char")) {
			type = 0;
		} else if (0 == strcmp(typeid(*data).name(),"char")) {
			type = 1;
		} else if (0 == strcmp(typeid(*data).name(),"short")) {
			type = 2;
		} else if (0 == strcmp(typeid(*data).name(),"unsigned short")) {
			type = 3;
		} else if (0 == strcmp(typeid(*data).name(),"int")) {
			type = 4;
		} else if (0 == strcmp(typeid(*data).name(),"float")) {
			type = 5;
		} else if (0 == strcmp(typeid(*data).name(),"double")) {
			type = 6;
		} else {
			cerr<<"unsupported matrix type!\n";
			exit(1);
		}
		cvmat = cvCreateMat(rows,cols,type+8*(channels-1));
		data = (T*)cvmat->data.ptr;
		this->rows = rows;
		this->cols = cols;
		this->channels=channels;
		bool user_data=false;
		if (arr !=NULL) 
			user_data=true;
		for (int i=0;i<rows;i++) {
			for (int j=0;j<cols;j++) {
				for (int k=0;k<channels;k++) {
					if (user_data)
						data[i*cols*channels+j*channels+k]=arr[i*cols*channels+j*channels+k];
					else
						data[i*cols*channels+j*channels+k]=0;
				}
			}
		}
	};
	
	Matrix(CvMat* src) {
		cvmat = cvCloneMat(src);
		data = (T*)src->data.ptr;
		rows = src->rows;
		cols = src->cols;
		channels=cvmat->step/cols/sizeof(T);
	};
	
	Matrix(Matrix<T>& src) {
		cvmat=cvCloneMat(src.cvmat);
		data = (T*)(src.cvmat->data.ptr);
		rows = src.rows;
		cols = src.cols;
		channels=src.channels;
	};
	
	/************************************************************************
		deconstructor
	*************************************************************************/
	~Matrix() {
		cvReleaseMat(&cvmat);
		data=NULL;
	};
	
	/************************************************************************
		access matrix element
	*************************************************************************/
	T& operator () (int i_row,int i_col,int i_channel=0) {
		if (i_row>=0 && i_row<rows && i_col>=0 && i_col<cols && i_channel>=0 && i_channel<channels)
			return data[i_row*cols+i_col*channels+i_channel];
		else {
			cerr<<"matrix access out of range"<<endl;
			exit(1);
		}
	};
	
	/************************************************************************
		overload = (Matrix = Matrix)
	*************************************************************************/
	Matrix<T>& operator =(Matrix<T>& src) {
		if (!mat_type_cmp(*this,src)) {
			cerr<<"matrix type unmatch!\n";
			exit(1);
		}
		for (int i=0;i<rows;i++) {
			for (int j=0;j<cols;j++) {
				for (int k=0;k<channels;k++) {
					data[i*cols*channels+j*channels+k]=src.data[i*cols*channels+j*channels+k];
				}
			}
		}
		return *this;
	};
	
	/************************************************************************
		overload + (matrix + matrix)
	*************************************************************************/
	Matrix<T> operator + (Matrix<T>& src) {
		if (!mat_type_cmp(*this,src)) {
			cerr<<"matrix type unmatch!\n";
			exit(1);
		}
		Matrix<T> temp(*this);
		cvAdd(cvmat,src.cvmat,temp.cvmat);
		return temp;
	};
	
	/************************************************************************
		overload += (matrix += matrix)
	*************************************************************************/
	Matrix<T>& operator +=(Matrix<T>& src) {
		if (!mat_type_cmp(*this,src)) {
			cerr<<"matrix type unmatch!\n";
			exit(1);
		}
		cvAdd(cvmat,src.cvmat,cvmat);
		return *this;
	};
	
	/************************************************************************
		overload + (matrix + number)
	*************************************************************************/
	Matrix<T> operator + (double num) {
		Matrix<T> temp(*this);
		for (int i=0;i<rows;i++) {
			for (int j=0;j<cols;j++) {
				for (int k=0;k<channels;k++) {
					temp.data[i*cols*channels+j*channels+k]+=num;
				}
			}
		}
		return temp;
	};
	
	/************************************************************************
		overload += (matrix += number)
	*************************************************************************/
	Matrix<T>& operator +=(double num) {
		for (int i=0;i<rows;i++) {
			for (int j=0;j<cols;j++) {
				for (int k=0;k<channels;k++) {
					data[i*cols*channels+j*channels+k]+=num;
				}
			}
		}
		return *this;
	};
	
	/************************************************************************
		overload - (matrix - matrix)
	*************************************************************************/
	Matrix<T> operator - (Matrix<T>& src) {
		if (!mat_type_cmp(*this,src)) {
			cerr<<"matrix type unmatch!\n";
			exit(1);
		}
		Matrix<T> temp(*this);
		cvSub(cvmat,src.cvmat,temp.cvmat);
		return temp;
	};
	
	/************************************************************************
		overload -= (matrix -= matrix)
	*************************************************************************/
	Matrix<T>& operator -=(Matrix<T>& src) {
		if (!mat_type_cmp(*this,src)) {
			cerr<<"matrix type unmatch!\n";
			exit(1);
		}
		cvSub(cvmat,src.cvmat,cvmat);
		return *this;
	};
	
	/************************************************************************
		overload - (matrix - number)
	*************************************************************************/
	Matrix<T> operator - (double num) {
		Matrix<T> temp(*this);
		return temp+=(-num);;
	};
	
	/************************************************************************
		overload -= (matrix -= number)
	*************************************************************************/
	Matrix<T>& operator -=(double num) {
		return *this+=(-num);
	};
	
	/************************************************************************
		overload * (matrix * matrix)
	*************************************************************************/
	Matrix<T> operator * (Matrix<T>& src) {
		if (!can_mult(*this,src)) {
			cerr<<"matrix multiply fail!\n";
			exit(1);
		}
		Matrix<T> temp(rows,src.cols,channels);
		cvMatMul(cvmat,src.cvmat,temp.cvmat);
		return temp;
	};
	
	/************************************************************************
		overload * (matrix * number)
	*************************************************************************/
	Matrix<T> operator * (double num) {
		Matrix<T> temp(*this);
		for (int i=0;i<rows;i++) {
			for (int j=0;j<cols;j++) {
				for (int k=0;k<channels;k++) {
					temp.data[i*cols*channels+j*channels+k] *= num;
				}
			}
		}
		return temp;
	};
	
	/************************************************************************
		overload *= (matrix *= number)
	*************************************************************************/
	Matrix<T>& operator *=(double num) {
		for (int i=0;i<rows;i++) {
			for (int j=0;j<cols;j++) {
				for (int k=0;k<channels;k++) {
					data[i*cols*channels+j*channels+k]*=num;
				}
			}
		}
		return *this;
	};
	
	/************************************************************************
		compare two matrixes (matrix == matrix)
		regardless of element type
	*************************************************************************/
	bool operator == (const Matrix<T>& src) {
		if (!mat_type_cmp(*this,src))
			return false;