完善GDAL与OpenCV间的数据格式转换与影像分块读写

本博客为原创内容，未经博主允许禁止转载，商用，谢谢。

一、前言

　　关于GDAL与openCV间的数据格式转换，在我之前的博客中已有简要说明，这里，由于最近工作上经常用到openCV里的函数进行图像处理，所以写了一个程序，进一步对这两个开源库进行连接。

　　除了格式转换外，该类还支持数据的分块读入与写出。

二、代码

　　所有功能在一个GDALOPENCV类中完成，其头文件如下：

//////////////////////////////////////////////////////////////////////
   ////////////完成GDAL文件与OpenCV的文件读写转换////////////////
//////////////////////支持数据分块读写////////////////////////////////
/////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////

#pragma once
#include <opencv2/core/core.hpp>
#include <opencv2/highgui/highgui.hpp>
#include <gdal_priv.h>
#include <vector>
#include <string>
#include <math.h>
#include <iostream>

/***********************************************************/
// GCDataType:GDAL和OpenCV数据类型转换的中间格式
// GC_Byte   =======  GDT_Byte   =======  CV_8U  =======  unsigned char
// GC_UInt16 =======  GDT_UInt16 =======  CV_16U =======  unsigned short
// GC_Int16  =======  GDT_Int16  =======  CV_16S =======  short int
// GC_UInt32 =======  GDT_UInt32 =======  缺失   =======  unsigned long
// GC_Int32  =======  GDT_Int32  =======  CV_32S =======  long
// GC_Float32=======  GDT_Float32=======  CV_32F =======  float
// GC_Float64=======  GDT_Float64=======  CV_64F =======  double
/***********************************************************/
typedef enum{
	GC_Byte = 0,
	GC_UInt16 = 1,
	GC_Int16 = 2,
	GC_UInt32 = 3,
	GC_Int32 = 4,
	GC_Float32 = 5,
	GC_Float64 = 6,
	GC_ERRType = 7
} GCDataType;

class GDALOpenCV
{
	/***********************************************************/
	// PatchIndex:存储具体影像分块信息
	// iPatch 分类表：1----两个边界重合    2----三个边界重合   3----四个边界重合
	//  11 12 13 14     21 22 23 24    31
	// =======================
	//   11 =    21    =  12
	// =======================
	//   24 =    31    =  22
	// =======================
	//   14 =    23    =  13 
	// =======================
    /***********************************************************/
	typedef struct {
		int iPatch;      //  第几类
		int row_begin;   // 影像中起始行
		int col_begin;   // 影像中起始列
		int width;       // 影像块的宽度
		int heigth;     // 影像块的高度
	} PatchIndex;


public:
	GDALOpenCV(const std::string fileName);  // 唯一构造函数
	~GDALOpenCV(void);   // 析构函数
	
public:
	void Initialization();   // 初始化  实际上为获取影像格式;
	cv::Size SetPatchSize(const int r,const int c)  // 设置分块大小
	{
		m_patchSize.width = c;	m_patchSize.height = r;
		return m_patchSize;
	};

	void SetOverlappedPixel(const int num)
	{
		m_overlappedPixel = num;
	};


	bool GDAL2Mat(cv::Mat &img);  // 影像读取为Mat格式  不分块
	bool Mat2File(const std::string outFileName,cv::Mat &img,const int flag = 1);  // Mat文件输出为影像
	//  flag = 默认为1  输出TIFF   另外还支持ENVI 和 ARDAS数据格式

	int GetImgToPatchNum();  // 返回影像分块数  和  获取影像分块信息
	void GetROIFromPatchIndex(const int,cv::Mat &);  //  获取对应块编号的影像
	bool SetROIMatToFileByIndex(const std::string outFile,cv::Mat &img,
		const int index,const int flag = 1); // 影像分块写入  有待改进  具体细节有点商榷  

	GCDataType GDALType2GCType(const GDALDataType ty); // GDAL Type ==========> GDALOpenCV Type
	GDALDataType GCType2GDALType(const GCDataType ty); //  GDALOpenCV Type ==========> GDAL Type
	GCDataType OPenCVType2GCType(const int ty); // OPenCV Type ==========> GDALOpenCV Type
	int GCType2OPenCVType(const GCDataType ty); // GDALOpenCV Type ==========> OPenCV Type

private:
	void* AllocateMemory(const GCDataType lDataType,const long long lSize);   // 智能分配内存
	void* SetMemCopy(void *dst,const void *src,const GCDataType lDataType,const long long lSize);

public:
	GCDataType m_dataType;  // 数据类型
	int m_imgWidth; // 影像宽度   列数
	int m_imgHeigth; // 影像高度   行数
	int m_bandNum; // 影像波段数
private:
	//GDALDataType m_gdalType;
	GDALDataset *m_poDataSet;  // 数据驱动集
	GDALDataset *m_outPoDataSet;
	cv::Size m_patchSize;// 分块图像大小
	//std::string m_fileName; // 文件名  打开
	cv::vector<PatchIndex> *m_patchIndex;//分块标识
	int m_overlappedPixel;
};


//////////////////////////////////////////////////////////
//    使用说明：
/////////////////////////////////////////////////////////
//   GDALOpenCV gdalOpenCV(fileName);
//   gdalOpenCV.Initialization();

　cpp文件如下：

#include "GDALOpenCV.h"

GDALOpenCV::GDALOpenCV(const std::string fileName)
{
	m_poDataSet = NULL;
	GDALAllRegister();
	m_poDataSet = (GDALDataset*)GDALOpen(fileName.c_str(),GA_ReadOnly);
	m_outPoDataSet = NULL;
}

GDALOpenCV::~GDALOpenCV(void)
{
	if(m_poDataSet!=NULL)
		GDALClose((GDALDatasetH)m_poDataSet);
	if(m_outPoDataSet!=NULL)
		GDALClose((GDALDatasetH)m_outPoDataSet);
	m_patchIndex->clear();
	delete m_patchIndex;
	m_patchIndex = NULL;

}

void GDALOpenCV::Initialization()
{
	if(!m_poDataSet)
		return;
	m_imgHeigth= m_poDataSet->GetRasterYSize();  // 影像行
	m_imgWidth = m_poDataSet->GetRasterXSize();  // 影像列
	m_bandNum = m_poDataSet->GetRasterCount(); // 影像波段数
	m_overlappedPixel = -1;     //  重复像素个数 

	GDALRasterBand *pBand = m_poDataSet->GetRasterBand(1);
	GDALDataType gdalTy = pBand->GetRasterDataType();
	m_dataType = GDALType2GCType(gdalTy);

	m_patchSize.width = m_imgWidth;
	m_patchSize.height = m_imgHeigth;

	m_patchIndex = new std::vector<PatchIndex>(1);
	PatchIndex tmp = {1,0,0,m_imgWidth,m_imgHeigth};
	m_patchIndex->at(0) = tmp;
}

bool GDALOpenCV::GDAL2Mat(cv::Mat &img)
{
	if(!m_poDataSet)
		return false;

	GDALRasterBand *pBand = NULL;  // 波段
	void *pafBuffer = AllocateMemory(m_dataType,m_imgHeigth*m_imgWidth);  // 开辟内存
	std::vector<cv::Mat> *imgMat = new std::vector<cv::Mat>(m_bandNum);   // 存储各波段
	cv::Mat *tmpMat = NULL;  // 临时存储一个波段

	int iBand = 0; // 波段标记
	while(iBand<m_bandNum)        
	{
		pBand = m_poDataSet->GetRasterBand(++iBand);
		pBand->RasterIO(GF_Read,0,0,m_imgWidth,m_imgHeigth,pafBuffer,m_imgWidth,
			m_imgHeigth,GCType2GDALType(m_dataType),0,0);
		tmpMat = new cv::Mat(m_imgHeigth,m_imgWidth,GCType2OPenCVType(m_dataType),pafBuffer);
		imgMat->at(iBand-1) = (*tmpMat).clone();
		delete tmpMat;
		tmpMat = NULL;
	}
	cv::merge(*imgMat,img);

	// 内存管理
	delete pafBuffer;	pafBuffer = NULL;
	imgMat->clear();	delete imgMat;	imgMat = NULL;

	return true;
}


bool GDALOpenCV::Mat2File( const std::string outFileName,cv::Mat &img,
						  const int flag /*= 1*/ )
{
	if(img.empty())
		return false;

	const int nBandCount=img.channels();
	const int nImgSizeX=img.cols;
	const int nImgSizeY=img.rows;

	std::vector<cv::Mat> *imgMat = new std::vector<cv::Mat>(nBandCount);
	cv::split(img,*imgMat);	

	GDALAllRegister();
	//GDALDataset *poDataset;   //GDAL数据集
	GDALDriver *poDriver;     //驱动，用于创建新的文件
	////////////////////////////////
	///flag：1 ====》TIFF
	///      2 ====》HFA
	///      3 ====》ENVI
	std::string pszFormat; //存储数据类型
	switch (flag) {
	case 1:
		pszFormat = "GTiff";
		break;
	case 2:
		pszFormat = "HFA";
		break;
	case 3:
		pszFormat = "ENVI";
		break;
	default:
		return 0;
	}

	int OPenCVty = imgMat->at(0).type();
	GCDataType GCty = OPenCVType2GCType(OPenCVty);

	poDriver = GetGDALDriverManager()->GetDriverByName(pszFormat.c_str());
	if(poDriver == NULL)
		return 0;
	if(m_outPoDataSet == NULL)
	{
		m_outPoDataSet=poDriver->Create(outFileName.c_str(),nImgSizeX,nImgSizeY,nBandCount,
			GCType2GDALType(GCty),NULL);
		m_outPoDataSet->SetProjection(m_poDataSet->GetProjectionRef());
		double dGeotransform[6];
		m_poDataSet->GetGeoTransform(dGeotransform);
		m_outPoDataSet->SetGeoTransform(dGeotransform);
	}

	//  循环写入文件
	GDALRasterBand *pBand = NULL;
	void *ppafScan = AllocateMemory(GCty,nImgSizeX*nImgSizeY);
	int n1 = nImgSizeY;
	int nc = nImgSizeX;
	cv::Mat tmpMat;
	for(int i = 1;i<=nBandCount;i++)
	{
		pBand = m_outPoDataSet->GetRasterBand(i);
		tmpMat = imgMat->at(i-1);
		if(tmpMat.isContinuous())
			SetMemCopy(ppafScan,(void*)tmpMat.ptr(0),GCty,nImgSizeX*nImgSizeY);
		else
			return false;
		CPLErr err = pBand->RasterIO(GF_Write,0,0,nImgSizeX,nImgSizeY,ppafScan,
			nImgSizeX,nImgSizeY,GCType2GDALType(GCty),0,0);
	}

	delete ppafScan;	ppafScan = NULL;
	imgMat->clear();delete imgMat;imgMat = NULL;	
	return 1;
}


int GDALOpenCV::GetImgToPatchNum()
{
	if(m_patchSize.width >= m_imgWidth || m_patchSize.height >= m_imgHeigth)
		return 1;
	if(m_overlappedPixel == -1)
		return 1;
	////////////////分块核心代码/////////////////////
	//////////////分块数确定////////////////////////
	int rPatchNum = cvCeil((m_imgHeigth*1.0 -m_patchSize.height)/(m_patchSize.height - m_overlappedPixel)) + 1;
	int cPatchNum = cvCeil((m_imgWidth*1.0 - m_patchSize.width)/(m_patchSize.width - m_overlappedPixel)) +1;

	PatchIndex tmpPatchIndex;
	int rowBegin = 0;
	int colBegin = 0;

	m_patchIndex->clear();
	for(int i = 0;i != rPatchNum; i++)
	{
		for(int j = 0;j != cPatchNum; j++)
		{
			if(0x00 == i && 0x00 == j)
				tmpPatchIndex.iPatch = 11;
			else if(0x00 == i && cPatchNum-1 == j)
				tmpPatchIndex.iPatch = 12;
			else if(rPatchNum-1 == i && cPatchNum-1 == j)
				tmpPatchIndex.iPatch = 13;
			else if(rPatchNum-1 == i && 0x00 == j)
				tmpPatchIndex.iPatch = 14;
			else if(0x00 == i && j>0 && j< cPatchNum-1)
				tmpPatchIndex.iPatch = 21;
			else if(j == cPatchNum -1 && i>0 && i<rPatchNum -1)
				tmpPatchIndex.iPatch = 22;
			else if(i == rPatchNum-1 && j>0 && j<cPatchNum -1)
				tmpPatchIndex.iPatch = 23;
			else if(0x00 == j && i > 0 && i<rPatchNum -1)
				tmpPatchIndex.iPatch = 24;
			else
				tmpPatchIndex.iPatch = 31;

			tmpPatchIndex.row_begin = rowBegin;
			tmpPatchIndex.col_begin = colBegin;
			if(rowBegin+m_patchSize.height > m_imgHeigth)
				tmpPatchIndex.heigth = m_imgHeigth - rowBegin;
			else
				tmpPatchIndex.heigth = m_patchSize.height;
			if(colBegin+m_patchSize.width > m_imgWidth)
				tmpPatchIndex.width = m_imgWidth - colBegin;
			else
				tmpPatchIndex.width = m_patchSize.width;
			m_patchIndex->push_back(tmpPatchIndex);
			colBegin = colBegin + m_patchSize.width - m_overlappedPixel;
		}
		rowBegin = rowBegin + m_patchSize.height - m_overlappedPixel;
		colBegin = 0;
	}
	return (int)m_patchIndex->size();
}


void GDALOpenCV::GetROIFromPatchIndex(const int index,cv::Mat &img)
{
	int patchNum = (int)m_patchIndex->size();
	if(index > patchNum || index < 1)
		return;
	PatchIndex curPatchIndex = m_patchIndex->at(index-1);
	int patchRowBegin = curPatchIndex.row_begin;
	int patchColBegin = curPatchIndex.col_begin;
	int patchWidth = curPatchIndex.width;
	int patchHeight = curPatchIndex.heigth;

	std::vector<cv::Mat> *imgMat = new std::vector<cv::Mat>(m_bandNum);// 存储读取的每个波段数据 
	void *pafBuffer = AllocateMemory(m_dataType,patchWidth*patchHeight); // 内存分配
	GDALRasterBand *pBand = NULL;
	cv::Mat *tmpMat = NULL;

	int iBand = 0; // 波段标记
	while(iBand<m_bandNum)
	{
		pBand = m_poDataSet->GetRasterBand(++iBand);
		pBand->RasterIO(GF_Read,patchColBegin,patchRowBegin,patchWidth,patchHeight,pafBuffer,
			patchWidth,patchHeight,GCType2GDALType(m_dataType),0,0);
		tmpMat =new cv::Mat(patchHeight,patchWidth,GCType2OPenCVType(m_dataType),pafBuffer);
		imgMat->at(iBand-1) = (*tmpMat).clone();
		delete tmpMat;
		tmpMat = NULL;
	}
	cv::merge(*imgMat,img);

	delete pafBuffer;pafBuffer = NULL;
	//delete pBand;pBand = NULL;
	imgMat->clear();delete imgMat;imgMat = NULL;
}


bool GDALOpenCV::SetROIMatToFileByIndex( const std::string outFileName,cv::Mat &img, 
										const int index,const int flag /*= 1*/ )
{
	if(!outFileName.c_str() || img.empty())
		return false;

	const int nBandCount=img.channels();
	const int nImgSizeX=img.cols;
	const int nImgSizeY=img.rows;

	PatchIndex tmpPatchIndex = m_patchIndex->at(index-1);
	if(tmpPatchIndex.heigth != nImgSizeY || tmpPatchIndex.width != nImgSizeX)
		return false;

	std::vector<cv::Mat> *imgMat = new std::vector<cv::Mat>(m_bandNum);
	cv::split(img,*imgMat);

	const int ty = (*imgMat).at(0).type();

	GDALAllRegister();
	//GDALDataset *poDataset = NULL;   //GDAL数据集
	GDALDriver *poDriver = NULL;      //驱动，用于创建新的文件

	////////////////////////////////
	///flag：1 ====》TIFF
	///      2 ====》HFA
	///      3 ====》ENVI
	std::string pszFormat; //存储数据类型
	switch (flag) {
	case 1:
		pszFormat = "GTiff";
		break;
	case 2:
		pszFormat = "HFA";
		break;
	case 3:
		pszFormat = "ENVI";
		break;
	default:
		return 0;
	}

	poDriver = GetGDALDriverManager()->GetDriverByName(pszFormat.c_str());
	int OPenCVty = imgMat->at(0).type();
	GCDataType GCty = OPenCVType2GCType(OPenCVty);
	if(poDriver == NULL)
		return 0;
	if(m_outPoDataSet == NULL)
	{
		m_outPoDataSet=poDriver->Create(outFileName.c_str(),m_imgWidth,m_imgHeigth,nBandCount,
			GCType2GDALType(GCty),NULL);
		m_outPoDataSet->SetProjection(m_poDataSet->GetProjectionRef());
		double dGeotransform[6];
		m_poDataSet->GetGeoTransform(dGeotransform);
		m_outPoDataSet->SetGeoTransform(dGeotransform);
	}
	//  循环写入文件
	GDALRasterBand *pBand = NULL;	
	int n1 = nImgSizeY;
	int nc = nImgSizeX;
	int overPix = int(m_overlappedPixel/2);

	void *ppafScan = NULL;
	int curCol = 0;
	int curRow = 0;
	
	for(int i = 1;i<=nBandCount;i++)
	{
		pBand = m_outPoDataSet->GetRasterBand(i);
		cv::Mat tmpMat;
		tmpMat = imgMat->at(i-1);
		// 文件的写入
		if(tmpPatchIndex.iPatch == 11)      
		{	
			curCol = nImgSizeX-overPix;
			curRow = nImgSizeY - overPix;
			cv::Rect r1(0,0,curCol,curRow);
			tmpMat = tmpMat(r1);
			cv::Mat *newMat = new cv::Mat(curRow,curCol,ty);
			*newMat = tmpMat.clone();
			ppafScan = AllocateMemory(GCty,curCol*curRow);
			if((*newMat).isContinuous())
				SetMemCopy(ppafScan,(void*)(*newMat).ptr(0),GCty,curCol*curRow);
			else
				return false;
			pBand->RasterIO(GF_Write,tmpPatchIndex.col_begin,tmpPatchIndex.row_begin,
				curCol,curRow,ppafScan,curCol,curRow,GCType2GDALType(GCty),0,0);
			delete newMat;newMat = NULL;
		}
		if(tmpPatchIndex.iPatch == 12)
		{	
			curCol = nImgSizeX-overPix;
			curRow = nImgSizeY - overPix;
			cv::Rect r1(overPix,0,curCol,curRow);
			tmpMat = tmpMat(r1);
			cv::Mat *newMat = new cv::Mat(curRow,curCol,ty);
			*newMat = tmpMat.clone();
			ppafScan = AllocateMemory(GCty,curCol*curRow);
			if((*newMat).isContinuous())
				SetMemCopy(ppafScan,(void*)(*newMat).ptr(0),GCty,curCol*curRow);
			else
				return false;
			pBand->RasterIO(GF_Write,tmpPatchIndex.col_begin+overPix,tmpPatchIndex.row_begin,
				curCol,curRow,ppafScan,curCol,curRow,GCType2GDALType(GCty),0,0);
			delete newMat;newMat = NULL;
		}
		if(tmpPatchIndex.iPatch == 13)
		{
			curCol = nImgSizeX-overPix;
			curRow = nImgSizeY - overPix;
			cv::Rect r1(overPix,overPix,curCol,curRow);
			tmpMat = tmpMat(r1);
			cv::Mat *newMat = new cv::Mat(curRow,curCol,ty);
			*newMat = tmpMat.clone();
			ppafScan = AllocateMemory(GCty,curCol*curRow);
			if((*newMat).isContinuous())
				SetMemCopy(ppafScan,(void*)(*newMat).ptr(0),GCty,curCol*curRow);
			else
				return false;
			pBand->RasterIO(GF_Write,tmpPatchIndex.col_begin+overPix,tmpPatchIndex.row_begin+overPix,
				curCol,curRow,ppafScan,curCol,curRow,GCType2GDALType(GCty),0,0);
			delete newMat;newMat = NULL;
		}
		if(tmpPatchIndex.iPatch == 14)
		{
			curCol = nImgSizeX-overPix;
			curRow = nImgSizeY - overPix;
			cv::Rect r1(0,overPix,curCol,curRow);
			tmpMat = tmpMat(r1);
			cv::Mat *newMat = new cv::Mat(curRow,curCol,ty);
			*newMat = tmpMat.clone();
			ppafScan = AllocateMemory(GCty,curCol*curRow);
			if((*newMat).isContinuous())
				SetMemCopy(ppafScan,(void*)(*newMat).ptr(0),GCty,curCol*curRow);
			else
				return false;
			pBand->RasterIO(GF_Write,tmpPatchIndex.col_begin,tmpPatchIndex.row_begin+overPix,
				curCol,curRow,ppafScan,curCol,curRow,GCType2GDALType(GCty),0,0);
			delete newMat;newMat = NULL;
		}
		if(tmpPatchIndex.iPatch == 21)
		{
			curCol = nImgSizeX-2*overPix;
			curRow = nImgSizeY - overPix;
			cv::Rect r1(overPix,0,curCol,curRow);
			tmpMat = tmpMat(r1);
			cv::Mat *newMat = new cv::Mat(curRow,curCol,ty);
			*newMat = tmpMat.clone();
			ppafScan = AllocateMemory(GCty,curCol*curRow);
			if((*newMat).isContinuous())
				SetMemCopy(ppafScan,(void*)(*newMat).ptr(0),GCty,curCol*curRow);
			else
				return false;
			pBand->RasterIO(GF_Write,tmpPatchIndex.col_begin+overPix,tmpPatchIndex.row_begin,
				curCol,curRow,ppafScan,curCol,curRow,GCType2GDALType(GCty),0,0);
			delete newMat;newMat = NULL;
		}
		if(tmpPatchIndex.iPatch == 22)
		{
			curCol = nImgSizeX- overPix;
			curRow = nImgSizeY - 2*overPix;
			cv::Rect r1(overPix,overPix,curCol,curRow);
			tmpMat = tmpMat(r1);
			cv::Mat *newMat = new cv::Mat(curRow,curCol,ty);
			*newMat = tmpMat.clone();
			ppafScan = AllocateMemory(GCty,curCol*curRow);
			if((*newMat).isContinuous())
				SetMemCopy(ppafScan,(void*)(*newMat).ptr(0),GCty,curCol*curRow);
			else
				return false;
			pBand->RasterIO(GF_Write,tmpPatchIndex.col_begin+overPix,tmpPatchIndex.row_begin+overPix,
				curCol,curRow,ppafScan,curCol,curRow,GCType2GDALType(GCty),0,0);
			delete newMat;newMat = NULL;
		}
		if(tmpPatchIndex.iPatch == 23)
		{
			curCol = nImgSizeX- 2*overPix;
			curRow = nImgSizeY - overPix;
			cv::Rect r1(overPix,overPix,curCol,curRow);
			tmpMat = tmpMat(r1);
			cv::Mat *newMat = new cv::Mat(curRow,curCol,ty);
			*newMat = tmpMat.clone();
			ppafScan = AllocateMemory(GCty,curCol*curRow);
			if((*newMat).isContinuous())
				SetMemCopy(ppafScan,(void*)(*newMat).ptr(0),GCty,curCol*curRow);
			else
				return false;
			pBand->RasterIO(GF_Write,tmpPatchIndex.col_begin+overPix,tmpPatchIndex.row_begin+overPix,
				curCol,curRow,ppafScan,curCol,curRow,GCType2GDALType(GCty),0,0);
			delete newMat;newMat = NULL;
		}
		if(tmpPatchIndex.iPatch == 24)
		{
			curCol = nImgSizeX- overPix;
			curRow = nImgSizeY - 2*overPix;
			cv::Rect r1(0,overPix,curCol,curRow);
			tmpMat = tmpMat(r1);
			cv::Mat *newMat = new cv::Mat(curRow,curCol,ty);
			*newMat = tmpMat.clone();
			ppafScan = AllocateMemory(GCty,curCol*curRow);
			if((*newMat).isContinuous())
				SetMemCopy(ppafScan,(void*)(*newMat).ptr(0),GCty,curCol*curRow);
			else
				return false;
			pBand->RasterIO(GF_Write,tmpPatchIndex.col_begin,tmpPatchIndex.row_begin+overPix,
				curCol,curRow,ppafScan,curCol,curRow,GCType2GDALType(GCty),0,0);
			delete newMat;newMat = NULL;
		}
		if(tmpPatchIndex.iPatch == 31)
		{
			curCol = nImgSizeX- 2*overPix;
			curRow = nImgSizeY - 2*overPix;
			cv::Rect r1(overPix,overPix,curCol,curRow);
			tmpMat = tmpMat(r1);
			cv::Mat *newMat = new cv::Mat(curRow,curCol,ty);
			*newMat = tmpMat.clone();
			ppafScan = AllocateMemory(GCty,curCol*curRow);
			if((*newMat).isContinuous())
				SetMemCopy(ppafScan,(void*)(*newMat).ptr(0),GCty,curCol*curRow);
			else
				return false;
			pBand->RasterIO(GF_Write,tmpPatchIndex.col_begin+overPix,tmpPatchIndex.row_begin+overPix,
				curCol,curRow,ppafScan,curCol,curRow,GCType2GDALType(GCty),0,0);
			delete newMat;newMat = NULL;
		}
	}
	delete ppafScan;ppafScan = NULL;
	imgMat->clear();delete imgMat;imgMat = NULL;
	return 1;
}

GCDataType GDALOpenCV::GDALType2GCType( const GDALDataType ty )
{
	switch(ty)
	{
	case GDT_Byte:
		return GC_Byte;
	case GDT_UInt16:
		return GC_UInt16;
	case GDT_Int16:
		return GC_Int16;
	case GDT_UInt32:
		return GC_UInt32;
	case GDT_Int32:
		return GC_Int32;
	case GDT_Float32:
		return GC_Float32;
	case GDT_Float64:
		return GC_Float64;
	default:
		assert(false);
		return GC_ERRType;
	}
}

GCDataType GDALOpenCV::OPenCVType2GCType( const int ty )
{
	switch(ty)
	{
	case 0:
		return GC_Byte;
	case 2:
		return GC_UInt16;
	case 3:
		return GC_Int16;
	case 4:
		return GC_Int32;
	case 5:
		return GC_Float32;
	case 6:
		return GC_Float64;
	default:
		assert(false);
		return GC_ERRType;
	}
}

GDALDataType GDALOpenCV::GCType2GDALType( const GCDataType ty )
{
	switch(ty)
	{
	case GC_Byte:
		return GDT_Byte;
	case GC_UInt16:
		return GDT_UInt16;
	case GC_Int16:
		return GDT_Int16;
	case GC_UInt32:
		return GDT_UInt32;
	case GC_Int32:
		return GDT_Int32;
	case GC_Float32:
		return GDT_Float32;
	case GC_Float64:
		return GDT_Float64;
	default:
		assert(false);
		return GDT_TypeCount;
	}
}

int GDALOpenCV::GCType2OPenCVType( const GCDataType ty )
{
	switch(ty)
	{
	case GC_Byte:
		return 0;
	case GC_UInt16:
		return 2;
	case GC_Int16:
		return 3;
	case GC_Int32:
		return 4;
	case GC_Float32:
		return 5;
	case GC_Float64:
		return 6;
	default:
		assert(false);
		return -1;
	}
}

void* GDALOpenCV::AllocateMemory(const GCDataType lDataType,const long long lSize )
{
	assert(0!=lSize);
	void* pvData = NULL;
	switch (lDataType)
	{
	case GC_Byte:
		pvData = new(std::nothrow) unsigned char[lSize];
		break;
	case GC_UInt16:
		pvData = new(std::nothrow) unsigned short int[lSize];
		break;
	case GC_Int16:
		pvData = new(std::nothrow) short int[lSize];
		break;
	case GC_UInt32:
		pvData = new(std::nothrow) unsigned long[lSize];
		break;
	case GC_Int32:
		pvData = new(std::nothrow) long[lSize];
		break;
	case GC_Float32:
		pvData = new(std::nothrow) float[lSize];
		break;
	case GC_Float64:
		pvData = new(std::nothrow) double[lSize];
		break;
	default: 
		assert(false);
		break;
	}
	return pvData;
}

void* GDALOpenCV::SetMemCopy( void *dst,const void *src,
							 const GCDataType lDataType,
							 const long long lSize )
{
	assert(0!=lSize);
	switch (lDataType)
	{
	case GC_Byte:
		return memmove(dst,src,sizeof(unsigned char)*lSize);
	case GC_UInt16:
		return memmove(dst,src,sizeof(unsigned short)*lSize);
	case GC_Int16:
		return memmove(dst,src,sizeof(short int)*lSize);
	case GC_UInt32:
		return memmove(dst,src,sizeof(unsigned long)*lSize);
	case GC_Int32:
		return memmove(dst,src,sizeof(long)*lSize);
	case GC_Float32:
		return memmove(dst,src,sizeof(float)*lSize);
	case GC_Float64:
		return memmove(dst,src,sizeof(double)*lSize);
	default: 
		return NULL;
	}
}

　　这个类我已经用了一段时间，可以直接使用，如果有啥bug,还请与我交流，共同提高。