完善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,还请与我交流，共同提高。

　

完善GDAL与OpenCV间的数据格式转换与影像分块读写的相关教程结束。