devbox
从前慢现在也慢
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

QT中使用GDAL多线程读取遥感图像到QImage

作者：从前慢现在也慢 | 2024-03-21 21:31:43

赞

踩

QT中使用GDAL多线程读取遥感图像到QImage

GDAL 是一个很强大的可以读取很多格式 的带有GIS信息的栅格型图像。前阵子项目中需要读取遥感图像，并显示到QT界面，由于遥感图像一般很大，所以采取新开一个读图线程的方式来读取，防止界面假死。下面是代码共享，测试通过读取500MB的24000*24000像素GeoTiff图并在QT的QGraphicsView中显示。

环境：VS2005+SP1, Qt 4.6.0, GDAL 1.6.2

文件：commontoolfunctions.h, gdalimagereaderthread.h, gdalimagereaderthread.cpp

1. commontoolfunctions.h文件：

  1. /* 
  2.  * 工具函数：网上找来的根据两点的经纬度坐标计算两个点的大地距离。 
  3.  */ 
  4. #ifndef COMMONTOOLFUNCTIONS_H  
  5. #define COMMONTOOLFUNCTIONS_H  
  6. #include <math.h>  
  7. #define EARTH_RADIUS  6378.137  
  8. #define MY_PI 3.14159265358979  
  9. #define LB_CONVERT_TO_RAD(d) (d * MY_PI / 180.0)  
  10. /* 
  11.  * 输入经纬度坐标，单位'度'。 
  12.  * 返回值单位为公里。 
  13.  * code from google maps. 近似值. 
  14.  */ 
  15. double CalcDistanceByLB(double lat1, double lng1, double lat2, double lng2)  
  16. {  
  17.     double radLat1 = LB_CONVERT_TO_RAD(lat1);  
  18.     double radLat2 = LB_CONVERT_TO_RAD(lat2);  
  19.     double a = radLat1 - radLat2;  
  20.     double b = LB_CONVERT_TO_RAD(lng1) - LB_CONVERT_TO_RAD(lng2);  
  21.     double s = 2 * asin(sqrt(pow(sin(a/2),2) + cos(radLat1)*cos(radLat2)*pow(sin(b/2),2)));  
  22.     s = s * EARTH_RADIUS;  
  23.     return s;  
  24. }  
  25. #endif

2. gdalimagereaderthread.h文件

  1. /* 
  2.  * QT线程类：使用GDAL读取图像文件并转为QImage的线程。 
  3.  * 创建：MulinB 
  4.  * 日期：2010-1-8 
  5.  * 上次修改: 2010-06-20 
  6.  * HUST-IPRAI-CVL 
  7.  */ 
  8. #ifndef GDALIMAGEREADERTHREAD_H  
  9. #define GDALIMAGEREADERTHREAD_H  
  10.  
  11. #include <QThread>  
  12. #include <gdal_priv.h> //for GDAL  
  13.  
  14. class QImage;  
  15. class RSI_MapCanvas;  
  16.  
  17. class RSI_ImageReaderThread : public QThread  
  18. {  
  19.     Q_OBJECT  
  20.  
  21. public:  
  22.     RSI_ImageReaderThread(RSI_MapCanvas* pCanvas);  
  23.     ~RSI_ImageReaderThread();  
  24.  
  25. public:  
  26.     void ReadFile(const QString& imageFileName); //使用该函数读取文件  
  27.  
  28. protected:  
  29.     void run(); //线程函数  
  30.  
  31. private:  
  32.     RSI_MapCanvas*  m_pCanvas;  
  33.     QString         m_imageFileName;  
  34.  
  35. private:  
  36.     //GDAL读取图像文件时的临时变量  
  37.     GDALRasterBand* m_pBand_GDAL_;  
  38.     int             m_nXSize_GDAL_;  
  39.     int             m_nYSize_GDAL_;  
  40.     void*           m_pDataBufStart_GDAL_;  
  41.     int             m_nBufXSize_GDAL_;  
  42.     int             m_nBufYSize_GDAL_;  
  43.     GDALDataType    m_eBufDataType_GDAL_;  
  44.     int             m_nBufPixSpace_GDAL_;  
  45.     int             m_nBufLineSpace_GDAL_;  
  46.  
  47. private:  
  48.     enum IMG_OPEN_DRIVER_T  
  49.     {  
  50.         RSI_IMG_DRIVER_UNDEF = 0, //未定义的打开方式  
  51.         RSI_USE_OPENCV, //使用opencv  
  52.         RSI_USE_GDAL, //使用GDAL  
  53.     };  
  54.  
  55. private:  
  56.     //将图像宽度字节数32位对齐  
  57.     inline int Get32bitAlignedWidthBytes(int nImgPixWidth, int nBytesPerPix);  
  58.  
  59.     //GDAL buffer 转 QImage  
  60.     QImage*  CvtGDALBufferToGrayQImage(uchar* &pafScanblock, int nImgSizeX, int nImgSizeY, GDALDataType pixType);  
  61.  
  62.     //将非8位的灰度图转换为8位灰度图  
  63.     template <class T>  
  64.     void CvtImgDataTo8bitGrayImg(T* pOrigData, int nImgSizeX, int nImgSizeXAligned32bit, int nImgSizeY, uchar* pNew8bitImgBuf, int nNewImgSizeXAligned32bit, T maxVal, T minVal);  
  65. };  
  66.  
  67.  
  68. #endif // GDALIMAGEREADERTHREAD_H

3. gdalimagereaderthread.cpp文件

  1. /* 
  2.  * QT线程类：使用GDAL读取图像文件并转为QImage的线程。 
  3.  * 创建：MulinB 
  4.  * 日期：2010-1-8 
  5.  * 上次修改: 2010-06-20 
  6.  * TODO: 1.图像分辨率转换计算貌似有问题... 
  7.          2.代码比较乱，没时间整理...囧... 
  8.  * HUST-IPRAI-CVL 
  9.  */ 
  10. #include "GDALImageReaderThread.h"  
  11. #include "iplimagetoqimage.h" //for IplImage converting to QImage  
  12. #include "commontoolfunctions.h" //for calculate distance by LB  
  13. #include <cv.h> //for OpenCV  
  14. #include <highgui.h>  //for OpenCV  
  15.  
  16. #include <limits.h> //for INT_MAX, INT_MIN, ...  
  17. #include <float.h> //for FLT_MAX, FLT_MIN, ...  
  18.  
  19. QMutex G_imageReadMutex;  
  20. QWaitCondition G_imageReadComplete;  
  21.  
  22.  
  23. RSI_ImageReaderThread::RSI_ImageReaderThread(RSI_MapCanvas* pCanvas)  
  24.     : m_pCanvas(pCanvas)  
  25. {  
  26.  
  27. }  
  28.  
  29. RSI_ImageReaderThread::~RSI_ImageReaderThread()  
  30. {  
  31.  
  32. }  
  33.  
  34. //线程函数  
  35. void RSI_ImageReaderThread::run()  
  36. {  
  37.     //这里只将GDAL最费时的RasterIO()函数作为新线程  
  38.     /* 
  39.     GDALRasterBand::RasterIO() parameters: 
  40.         eRWFlag  Either GF_Read to read a region of data, or GT_Write to write a region of data.  
  41.         nXOff  The pixel offset to the top left corner of the region of the band to be accessed. This would be zero to start from the left side.  
  42.         nYOff  The line offset to the top left corner of the region of the band to be accessed. This would be zero to start from the top.  
  43.         nXSize  The width of the region of the band to be accessed in pixels.  
  44.         nYSize  The height of the region of the band to be accessed in lines.  
  45.         pData  The buffer into which the data should be read, or from which it should be written. This buffer must contain at least nBufXSize * nBufYSize words of type eBufType. It is organized in left to right, top to bottom pixel order. Spacing is controlled by the nPixelSpace, and nLineSpace parameters.  
  46.         nBufXSize  the width of the buffer image into which the desired region is to be read, or from which it is to be written.  
  47.         nBufYSize  the height of the buffer image into which the desired region is to be read, or from which it is to be written.  
  48.         eBufType  the type of the pixel values in the pData data buffer. The pixel values will automatically be translated to/from the GDALRasterBand data type as needed.  
  49.         nPixelSpace  The byte offset from the start of one pixel value in pData to the start of the next pixel value within a scanline. If defaulted (0) the size of the datatype eBufType is used.  
  50.         nLineSpace  The byte offset from the start of one scanline in pData to the start of the next. If defaulted the size of the datatype eBufType * nBufXSize is used.  
  51.     */ 
  52.     G_imageReadMutex.lock();  
  53.     m_pBand_GDAL_->RasterIO(GF_Read, 0, 0,  
  54.         m_nXSize_GDAL_, m_nYSize_GDAL_,   
  55.         m_pDataBufStart_GDAL_,   
  56.         m_nBufXSize_GDAL_, m_nBufYSize_GDAL_,   
  57.         m_eBufDataType_GDAL_,   
  58.         m_nBufPixSpace_GDAL_,  
  59.         m_nBufLineSpace_GDAL_);  
  60.       
  61.     //G_imageReadComplete.wakeAll();  
  62.     G_imageReadMutex.unlock();  
  63. }  
  64.  
  65. //读图函数：使用GDAL和OpenCV读取图像文件  
  66. void RSI_ImageReaderThread::ReadFile(const QString& imageFileName)  
  67. {  
  68.     m_imageFileName = imageFileName;  
  69.  
  70.     if (m_imageFileName.isEmpty() || m_pCanvas == NULL)  
  71.         return;  
  72.  
  73.     //选择打开图像的驱动方式: GDAL or OpenCV  
  74.     const QString strOpenCV = tr("OpenCV");  
  75.     const QString strGDAL = tr("GDAL");  
  76.     IMG_OPEN_DRIVER_T  eOpenDriverType;  
  77.     QStringList items; //for input dialog  
  78.     items << strOpenCV << strGDAL;  
  79.     int  curDriverItemIdx = 0;  
  80.  
  81.     //先根据扩展名推荐打开方式  
  82.     QString fileExtName = m_imageFileName.right(3).toLower();  
  83.     if (fileExtName == QString("bmp")   
  84.         || fileExtName == QString("png")  
  85.         || fileExtName == QString("jpg")  
  86.         || fileExtName == QString("peg")  
  87.         || fileExtName == QString("jpe")  
  88.         || fileExtName == QString("ppm")  
  89.         || fileExtName == QString("pbm")  
  90.         || fileExtName == QString("pgm"))  
  91.     {  
  92.         //如果是常用格式，推荐使用OpenCV打开: (*.bmp *.png *.jpg *.jpeg *.jpe *.ppm *.pgm *.pbm)  
  93.         eOpenDriverType = RSI_USE_OPENCV; //根据扩展名来推荐使用哪种打开方式  
  94.         curDriverItemIdx = 0;  
  95.     }  
  96.     else 
  97.     {  
  98.         eOpenDriverType = RSI_USE_GDAL;  
  99.         curDriverItemIdx = 1;  
  100.     }  
  101.  
  102.     //弹出对话框让用户选择使用哪种驱动方式打开图像  
  103.     bool dlgOk;  
  104.     QString itemSel = QInputDialog::getItem(m_pCanvas, tr("Please select..."),  
  105.         tr("Driver for image opener:"), items, curDriverItemIdx, false, &dlgOk);  
  106.  
  107.     if (dlgOk && !itemSel.isEmpty())  
  108.     {  
  109.         if (itemSel == strOpenCV)  
  110.         {  
  111.             eOpenDriverType = RSI_USE_OPENCV;  
  112.         }  
  113.         else if (itemSel == strGDAL)  
  114.         {  
  115.             eOpenDriverType = RSI_USE_GDAL;  
  116.         }  
  117.     }  
  118.     else 
  119.     {  
  120.         return;  
  121.     }  
  122.       
  123.     //进度条  
  124.     int progressBarValue = 2;  
  125.     QProgressDialog progress(tr("Reading image file..."), tr("Abort"), 0, 100, m_pCanvas);  
  126.     QProgressBar prgBar(&progress);  
  127.     prgBar.setTextVisible(false); //不显示百分比  
  128.     progress.setBar(&prgBar);  
  129.     progress.setWindowModality(Qt::ApplicationModal);  
  130.     progress.setCancelButton(NULL);  
  131.     progress.setWindowTitle(tr("Please wait..."));  // 标题  
  132.     progress.setValue(progressBarValue);  
  133.  
  134.     //use GDAL and OpenCV open image files  
  135.     if (eOpenDriverType == RSI_USE_OPENCV)  
  136.     {  
  137.         //打开图像文件  
  138.         IplImage* pIplImg = NULL; //声明IplImage指针  
  139.         if ((pIplImg = cvLoadImage(m_imageFileName.toStdString().c_str(), 1)) == 0) //使用OpenCV highgui打开图像文件  
  140.         {  
  141.             QMessageBox::warning(m_pCanvas, tr("Failed"), tr("Open Image File Failed!"), tr("OK"));  
  142.             return;  
  143.         }  
  144.  
  145.         //读取图像信息  
  146.         QString rsiFileInfo; //图像信息  
  147.         QString tempStr;  
  148.  
  149.         tempStr = tr("Size is %1 x %2 x [%3(bits) x %4(channels)]/n")  
  150.             .arg(pIplImg->width)  
  151.             .arg(pIplImg->height)  
  152.             .arg(pIplImg->depth)  
  153.             .arg(pIplImg->nChannels);  
  154.  
  155.         rsiFileInfo += tempStr;  
  156.  
  157.         //显示  
  158.         uchar* imageDataBuffer = NULL;  
  159.         QImage* pQImage = IplImageToQImage(pIplImg, &imageDataBuffer); //转换成QImage  
  160.  
  161.         //创建图层  
  162.         RSI_ImageLayer* pImageLayer = new RSI_ImageLayer(*pQImage);  
  163.         pImageLayer->setLayerName(m_imageFileName);  
  164.         pImageLayer->setImageLayerInfo(rsiFileInfo);  
  165.         pImageLayer->setBufferToBeFree(imageDataBuffer); //记录到m_bufferToBeFree中，待关闭图像时释放buffer内存  
  166.         pImageLayer->setVisible(false); //默认不显示  
  167.         pImageLayer->setFlag(QGraphicsItem::ItemIsMovable, false);  
  168.  
  169.         m_pCanvas->AddImageLayer(pImageLayer);  
  170.  
  171.         //释放临时内存  
  172.         cvReleaseImage(&pIplImg);  
  173.         delete pQImage;  
  174.         goto _READ_IMAGE_FILE_OVER; //读取完毕直接返回  
  175.     }  
  176.     else if (eOpenDriverType == RSI_USE_GDAL)  
  177.     {  
  178.         //如果是遥感图像格式，则使用GDAL打开  
  179.         GDALAllRegister();  
  180.         GDALDataset* poDataset;  //GDAL数据集  
  181.         poDataset = (GDALDataset*)GDALOpen(m_imageFileName.toStdString().c_str(), GA_ReadOnly);  
  182.         if( poDataset == NULL )  
  183.         {  
  184.             //QMessageBox::warning(NULL, tr("Failed"), tr("GDAL Open Image File Failed!"), tr("OK"));  
  185.             return;  
  186.         }  
  187.  
  188.         //读取遥感图像信息  
  189.         QString rsiFileInfo; //遥感图像信息  
  190.         QString tempStr;  
  191.  
  192.         tempStr = tr("GDAL Driver: %1/%2/n")  
  193.             .arg(QString(poDataset->GetDriver()->GetDescription()))  
  194.             .arg(QString(poDataset->GetDriver()->GetMetadataItem(GDAL_DMD_LONGNAME)));  
  195.  
  196.         rsiFileInfo += tempStr;  
  197.  
  198.         tempStr = tr("Size is %1 x %2 x %3(bands)/n")  
  199.             .arg(poDataset->GetRasterXSize())  
  200.             .arg(poDataset->GetRasterYSize())  
  201.             .arg(poDataset->GetRasterCount());  
  202.  
  203.         rsiFileInfo += tempStr;  
  204.  
  205.         /* 
  206.         地理参考坐标系统: 
  207.         The returned string defines the projection coordinate system of the image in OpenGIS WKT format. 
  208.         */ 
  209.         double adfGeoTransform[6];  
  210.         QString prjRefStr(poDataset->GetProjectionRef());  
  211.         if (prjRefStr.isEmpty())  
  212.         {  
  213.             prjRefStr = tr("none"); //如果此字段为空，那么投影方式可能是GCPs  
  214.         }  
  215.         else //非空时才读取仿射变换信息  
  216.         {  
  217.             tempStr = tr("Projection(WKT format) is '%1'/n").arg(prjRefStr);  
  218.             rsiFileInfo += tempStr;  
  219.  
  220.             //非空时才读取仿射变换信息  
  221.             /* 
  222.             仿射地理变换信息： 
  223.             adfGeoTransform[0] // top left x  
  224.             adfGeoTransform[1] // w-e pixel resolution  
  225.             adfGeoTransform[2] // rotation, 0 if image is "north up"  
  226.             adfGeoTransform[3] // top left y  
  227.             adfGeoTransform[4] // rotation, 0 if image is "north up"  
  228.             adfGeoTransform[5] // n-s pixel resolution  
  229.             计算某一点的地理坐标可以如下计算： 
  230.             Xgeo = GT(0) + Xpixel*GT(1) + Yline*GT(2) 
  231.             Ygeo = GT(3) + Xpixel*GT(4) + Yline*GT(5) 
  232.             */ 
  233.             poDataset->GetGeoTransform( adfGeoTransform );  
  234.  
  235.             tempStr = tr("Origin Cords = (%1,%2)/n")  
  236.                 .arg(adfGeoTransform[0], 0, 'f', 6)  
  237.                 .arg(adfGeoTransform[3], 0, 'f', 6);  
  238.             rsiFileInfo += tempStr;  
  239.  
  240.             tempStr = tr("Pixel Size(degrees) = (%1,%2)/n")  
  241.                 .arg(adfGeoTransform[1], 0, 'f', 6)  
  242.                 .arg(adfGeoTransform[5], 0, 'f', 6);  
  243.             rsiFileInfo += tempStr;  
  244.         }  
  245.  
  246.         //读取GCPs投影方式  
  247.         QString prjGCPStr(poDataset->GetGCPProjection());  
  248.         if (prjGCPStr.isEmpty())  
  249.         {  
  250.             prjGCPStr = tr("none");  
  251.         }  
  252.         else 
  253.         {  
  254.             tempStr = tr("GCPs Prj is '%1'/n").arg(prjGCPStr);  
  255.             rsiFileInfo += tempStr;  
  256.  
  257.             int nGCPs = poDataset->GetGCPCount(); //获得GCP控制点的个数  
  258.             const GDAL_GCP* pGCPs = poDataset->GetGCPs(); //获得GCP控制点  
  259.             tempStr = tr("Number of GCPs: %1/n").arg(nGCPs);  
  260.             rsiFileInfo += tempStr;  
  261.  
  262.             //由GCPs获得仿射变换参数  
  263.             GDALGCPsToGeoTransform( nGCPs, pGCPs, adfGeoTransform, TRUE );  
  264.  
  265.             tempStr = tr("Origin Cords = (%1,%2)/n")  
  266.                 .arg(adfGeoTransform[0], 0, 'f', 6)  
  267.                 .arg(adfGeoTransform[3], 0, 'f', 6);  
  268.             rsiFileInfo += tempStr;  
  269.  
  270.             tempStr = tr("Pixel Size(degrees) = (%1,%2)/n")  
  271.                 .arg(adfGeoTransform[1], 0, 'f', 6)  
  272.                 .arg(adfGeoTransform[5], 0, 'f', 6);  
  273.             rsiFileInfo += tempStr;  
  274.         }  
  275.  
  276.         //根据adfGeoTransform计算每个像素代表多少米距离  
  277.         double oriCordL = adfGeoTransform[0];  
  278.         double oriCordB = adfGeoTransform[3];  
  279.         double tempL, tempB;  
  280.         GDALApplyGeoTransform(adfGeoTransform, 100, 0, &tempL, &tempB); //计算(100,0)像素处的L,B坐标  
  281.         double tempDist = CalcDistanceByLB(oriCordL, oriCordB, tempL, tempB);  
  282.         double xMeterPerPix = tempDist * 1000.0 / 100.0; //单位为米  
  283.         GDALApplyGeoTransform(adfGeoTransform, 0, 100, &tempL, &tempB); //计算(0,100)像素处的L,B坐标  
  284.         tempDist = CalcDistanceByLB(oriCordL, oriCordB, tempL, tempB);  
  285.         double yMeterPerPix = tempDist * 1000.0 / 100.0; //单位为米  
  286.  
  287.         tempStr = tr("Pixel Size(meters) = (%1,%2)/n")  
  288.             .arg(xMeterPerPix, 0, 'f', 6)  
  289.             .arg(yMeterPerPix, 0, 'f', 6);  
  290.         rsiFileInfo += tempStr;  
  291.  
  292.           
  293.         //读取图像大小  
  294.         int nBandCount = poDataset->GetRasterCount();  
  295.         int nImgSizeX = poDataset->GetRasterXSize();  
  296.         int nImgSizeY = poDataset->GetRasterYSize();  
  297.  
  298.         //读取图像数据点类型  
  299.         GDALRasterBand* preBand = poDataset->GetRasterBand(1); //预读取遥感的第一个波段  
  300.         GDALDataType prePixType = preBand->GetRasterDataType();  
  301.         int prePixSize = GDALGetDataTypeSize(prePixType) / 8; //GDALGetDataTypeSize得到的是bit  
  302.  
  303.         if (nBandCount >= 3 && prePixSize == 1) //多于3个波段的图像给用户选择是否合并前三个波段用RGB显示  
  304.         {  
  305.             //QMessageBox::StandardButton userAnswer = QMessageBox::Yes;  
  306.             QMessageBox::StandardButton userAnswer = QMessageBox::question(m_pCanvas,   
  307.                 tr("Choose image show format"),   
  308.                 tr("%1 bands detected!/nWill you show it in RGB color format using the first three bands?").arg(nBandCount),   
  309.                 QMessageBox::Yes|QMessageBox::No);  
  310.             if (userAnswer == QMessageBox::Yes)  
  311.             {  
  312.                 //--------将前三个波段组合成RGB颜色显示, 使用QImage::Format_RGB32格式显示---------  
  313.                 uchar* pafScanblock = (uchar*)malloc(4*(nImgSizeX)*(nImgSizeY)); //Format_RGB32每个像素4个字节: RGBA  
  314.                 //assert(pafScanblock != NULL);  
  315.                 if (pafScanblock == NULL)  
  316.                 {  
  317.                     QMessageBox::warning(m_pCanvas, tr("Failed"), tr("Open Image File Failed! Out of memory!"), tr("OK"));  
  318.                     delete poDataset; //关闭数据集  
  319.                     goto _READ_IMAGE_FILE_OVER;  
  320.                 }  
  321.                 memset(pafScanblock, 0x00, 4*(nImgSizeX)*(nImgSizeY));  
  322.                   
  323.                 //读取图像  
  324.                 for (int nB=0; nB<nBandCount; nB++)  
  325.                 {  
  326.                     GDALRasterBand* poBand = poDataset->GetRasterBand(nB+1); //遥感的一个波段  
  327.                     assert(poBand != NULL);  
  328.                     GDALDataType pixType = poBand->GetRasterDataType();  
  329.                     int pixSize = GDALGetDataTypeSize(pixType) / 8; //GDALGetDataTypeSize得到的是bit  
  330.                     assert(pixSize == 1); //彩色图的每个通道的size应该是1个字节  
  331.  
  332.                     //用RasterIO()读取图像数据  
  333.                     //poBand->RasterIO(GF_Read, 0, 0, nImgSizeX, nImgSizeY,  
  334.                     //  pafScanblock+nB, nImgSizeX, nImgSizeY, pixType, 4, 0);  
  335.                     G_imageReadMutex.lock();  
  336.                     m_pBand_GDAL_ = poBand;  
  337.                     m_nXSize_GDAL_ = nImgSizeX;  
  338.                     m_nYSize_GDAL_ = nImgSizeY;  
  339.                     m_pDataBufStart_GDAL_ = pafScanblock+nB; //注意！  
  340.                     m_nBufXSize_GDAL_ = nImgSizeX;  
  341.                     m_nBufYSize_GDAL_ = nImgSizeY;  
  342.                     m_eBufDataType_GDAL_ = pixType;  
  343.                     m_nBufPixSpace_GDAL_ = 4; //注意！  
  344.                     m_nBufLineSpace_GDAL_ = 0;  
  345.                     start(); //开始新线程  
  346.                     G_imageReadMutex.unlock();  
  347.  
  348.                     while (this->isRunning())  
  349.                     {  
  350.                         progressBarValue += 8;  
  351.                         progress.setValue(progressBarValue % 100);  
  352.                         QThread::msleep(1000); //注意：这里是让主线程sleep，而不是新线程  
  353.                     }  
  354.                     //G_imageReadComplete.wait(&G_imageReadMutex);  
  355.                     //progressBarValue += 20;  
  356.                     //progress.setValue(progressBarValue % 100);  
  357.                     //G_imageReadMutex.unlock();  
  358.                 }  
  359.  
  360.                 //组合成彩色QImage  
  361.                 QImage* pQImage = NULL;  
  362.                 pQImage = new QImage(pafScanblock, nImgSizeX, nImgSizeY, QImage::Format_RGB32); //注意：QImage: each scanline of data in the image must also be 32-bit aligned  
  363.                 //assert(pQImage != NULL);  
  364.                 if (pQImage == NULL)  
  365.                 {  
  366.                     QMessageBox::warning(m_pCanvas, tr("Failed"), tr("Open Image File Failed! Out of memory!"), tr("OK"));  
  367.                     free(pafScanblock);  
  368.                     delete poDataset; //关闭数据集  
  369.                     goto _READ_IMAGE_FILE_OVER;  
  370.                 }  
  371.  
  372.                 //创建图层  
  373.                 RSI_ImageLayer* pImageLayer = new RSI_ImageLayer(*pQImage);  
  374.                 if (pImageLayer == NULL)  
  375.                 {  
  376.                     QMessageBox::warning(m_pCanvas, tr("Failed"), tr("Open Image File Failed! Out of memory!"), tr("OK"));  
  377.                     free(pafScanblock);  
  378.                     delete pQImage;   
  379.                     delete poDataset; //关闭数据集  
  380.                     goto _READ_IMAGE_FILE_OVER;  
  381.                 }  
  382.                 pImageLayer->setLayerName(tr("3 bands composited color image") + QString("(") + m_imageFileName + QString(")"));  
  383.                 pImageLayer->setImageLayerInfo(rsiFileInfo);  
  384.                 pImageLayer->setGeoTransform(adfGeoTransform);  
  385.                 pImageLayer->setResolutionX(xMeterPerPix);  
  386.                 pImageLayer->setResolutionY(yMeterPerPix);  
  387.                 pImageLayer->setBufferToBeFree(pafScanblock); //记录到m_bufferToBeFree中，待关闭图像时释放buffer内存  
  388.                 pImageLayer->setVisible(false); //默认不显示  
  389.                 pImageLayer->setFlag(QGraphicsItem::ItemIsMovable, false);  
  390.  
  391.                 m_pCanvas->AddImageLayer(pImageLayer);  
  392.  
  393.                 //释放临时对象  
  394.                 delete pQImage;   
  395.  
  396.                 delete poDataset; //关闭数据集  
  397.                 goto _READ_IMAGE_FILE_OVER; //读取完毕直接返回  
  398.             }  
  399.         }  
  400.  
  401.         //------------按照波段分别读取，每个波段显示成一个灰度图-------------  
  402.  
  403.         //读取图像  
  404.         for (int nB=0; nB<nBandCount; nB++)  
  405.         {  
  406.             GDALRasterBand* poBand = poDataset->GetRasterBand(nB+1); //遥感的一个波段  
  407.             assert(poBand != NULL);  
  408.             GDALDataType pixType = poBand->GetRasterDataType();  
  409.             int pixSize = GDALGetDataTypeSize(pixType) / 8; //GDALGetDataTypeSize得到的是bit  
  410.  
  411.             //注意：QImage: each scanline of data in the image must also be 32-bit aligned  
  412.             int nImgSizeXAligned32bit = Get32bitAlignedWidthBytes(nImgSizeX, pixSize) / pixSize; //对齐后的像素宽度  
  413.             uchar* pafScanblock = (uchar*)malloc(pixSize*(nImgSizeXAligned32bit)*(nImgSizeY));  
  414.             //assert(pafScanblock != NULL);  
  415.             if (pafScanblock == NULL)  
  416.             {  
  417.                 QMessageBox::warning(m_pCanvas, tr("Failed"), tr("Open Image File Failed! Out of memory!"), tr("OK"));  
  418.                 delete poDataset; //关闭数据集  
  419.                 goto _READ_IMAGE_FILE_OVER;  
  420.             }  
  421.               
  422.             //用RasterIO()读取图像数据  
  423.             //poBand->RasterIO(GF_Read, 0, 0, nImgSizeX, nImgSizeY,  
  424.             //  pafScanblock, nImgSizeXAligned32bit, nImgSizeY, pixType, 0, 0);  
  425.             G_imageReadMutex.lock();  
  426.             m_pBand_GDAL_ = poBand;  
  427.             m_nXSize_GDAL_ = nImgSizeX;  
  428.             m_nYSize_GDAL_ = nImgSizeY;  
  429.             m_pDataBufStart_GDAL_ = pafScanblock;  
  430.             m_nBufXSize_GDAL_ = nImgSizeXAligned32bit;  
  431.             m_nBufYSize_GDAL_ = nImgSizeY;  
  432.             m_eBufDataType_GDAL_ = pixType;  
  433.             m_nBufPixSpace_GDAL_ = 0;  
  434.             m_nBufLineSpace_GDAL_ = 0;  
  435.             start(); //开始新线程  
  436.             G_imageReadMutex.unlock();  
  437.  
  438.             while (this->isRunning())  
  439.             {  
  440.                 progressBarValue += 8;  
  441.                 progress.setValue(progressBarValue % 100);  
  442.                 QThread::msleep(1000); //注意：这里是让主线程sleep，而不是新线程  
  443.             }  
  444.             //G_imageReadComplete.wait(&G_imageReadMutex);  
  445.             //progressBarValue += 20;  
  446.             //progress.setValue(progressBarValue % 100);  
  447.             //G_imageReadMutex.unlock();  
  448.  
  449.             //转化为QImage  
  450.             QImage* pQImage = CvtGDALBufferToGrayQImage(pafScanblock, nImgSizeX, nImgSizeY, pixType);  
  451.             if (pQImage == NULL)  
  452.             {  
  453.                 QMessageBox::warning(m_pCanvas, tr("Failed"), tr("Open Image File Failed! Out of memory!"), tr("OK"));  
  454.                 free(pafScanblock);  
  455.                 delete poDataset; //关闭数据集  
  456.                 goto _READ_IMAGE_FILE_OVER;  
  457.             }  
  458.  
  459.             //创建图层  
  460.             RSI_ImageLayer* pImageLayer = new RSI_ImageLayer(*pQImage);  
  461.             if (pImageLayer == NULL)  
  462.             {  
  463.                 QMessageBox::warning(m_pCanvas, tr("Failed"), tr("Open Image File Failed! Out of memory!"), tr("OK"));  
  464.                 free(pafScanblock);  
  465.                 delete pQImage;   
  466.                 delete poDataset; //关闭数据集  
  467.                 goto _READ_IMAGE_FILE_OVER;  
  468.             }  
  469.             pImageLayer->setLayerName(tr("band") + QString("%1").arg(nB+1) + tr(": pixel type = ") + QString(GDALGetDataTypeName(pixType)) + QString("(") + QString("%1").arg(pixSize) + tr(" bytes)"));  
  470.             pImageLayer->setImageLayerInfo(rsiFileInfo);  
  471.             pImageLayer->setGeoTransform(adfGeoTransform);  
  472.             pImageLayer->setResolutionX(xMeterPerPix);  
  473.             pImageLayer->setResolutionY(yMeterPerPix);  
  474.             pImageLayer->setBufferToBeFree(pafScanblock); //记录到m_bufferToBeFree中，待关闭图像时释放buffer内存  
  475.             pImageLayer->setVisible(false); //默认不显示  
  476.             pImageLayer->setFlag(QGraphicsItem::ItemIsMovable, false);  
  477.  
  478.             m_pCanvas->AddImageLayer(pImageLayer);  
  479.  
  480.             //释放临时对象  
  481.             delete pQImage;   
  482.  
  483.         }  
  484.  
  485.         delete poDataset; //关闭数据集  
  486.         goto _READ_IMAGE_FILE_OVER; //读取完毕直接返回  
  487.     } //end if eOpenDriverType  
  488.       
  489.  
  490. _READ_IMAGE_FILE_OVER:  
  491.     return;  
  492. }  
  493.  
  494.  
  495. //将图像宽度字节数32位对齐，返回对齐后的字节数  
  496. int RSI_ImageReaderThread::Get32bitAlignedWidthBytes(int nImgPixWidth, int nBytesPerPix)  
  497. {  
  498.     return ((nImgPixWidth*nBytesPerPix/4) + (((nImgPixWidth*nBytesPerPix)%4)==0 ? 0 : 1)) * 4;  
  499. }  
  500.  
  501.  
  502. //GDAL buffer 转 QImage  
  503. QImage*  RSI_ImageReaderThread::CvtGDALBufferToGrayQImage(uchar* &pafScanblock, int nImgSizeX, int nImgSizeY, GDALDataType pixType)  
  504. {  
  505.     //准备颜色表  
  506.     QVector<QRgb> vcolorTable;  
  507.     for (int i = 0; i < 256; i++)  
  508.     {  
  509.         vcolorTable.push_back(qRgb(i, i, i));  
  510.     }  
  511.  
  512.     int pixSize = GDALGetDataTypeSize(pixType) / 8;  
  513.     int nImgSizeXAligned32bit = Get32bitAlignedWidthBytes(nImgSizeX, pixSize) / pixSize; //对齐后的像素宽度  
  514.     int nNewImgSizeXAligned32bit = Get32bitAlignedWidthBytes(nImgSizeX, 1);  
  515.  
  516.     //根据pixType转换  
  517.     if (pixType == GDT_Byte)  
  518.     {  
  519.         //do nothing  
  520.     }  
  521.     else //add by baolc, 2010-06-10  
  522.     {  
  523.         //将16位数据转为8位灰度显示  
  524.         uchar* pNew_pafScanblock_8bit = (uchar*)malloc(nNewImgSizeXAligned32bit * nImgSizeY);  
  525.         if (pNew_pafScanblock_8bit == NULL)  
  526.         {  
  527.             QMessageBox::warning(m_pCanvas, tr("Failed"), tr("Open Image File Failed! Out of memory!"), tr("OK"));  
  528.             return NULL;  
  529.         }  
  530.  
  531.         if (pixType == GDT_UInt16)  
  532.         {  
  533.             CvtImgDataTo8bitGrayImg<ushort>((ushort*)pafScanblock, nImgSizeX, nImgSizeXAligned32bit, nImgSizeY,   
  534.                 pNew_pafScanblock_8bit, nNewImgSizeXAligned32bit, USHRT_MAX, 0);  
  535.         }  
  536.         else if (pixType == GDT_Int16)  
  537.         {  
  538.             CvtImgDataTo8bitGrayImg<short>((short*)pafScanblock, nImgSizeX, nImgSizeXAligned32bit, nImgSizeY,   
  539.                 pNew_pafScanblock_8bit, nNewImgSizeXAligned32bit, SHRT_MAX, SHRT_MIN);  
  540.         }  
  541.         else if (pixType == GDT_UInt32)  
  542.         {  
  543.             CvtImgDataTo8bitGrayImg<int>((int*)pafScanblock, nImgSizeX, nImgSizeXAligned32bit, nImgSizeY,   
  544.                 pNew_pafScanblock_8bit, nNewImgSizeXAligned32bit, UINT_MAX, 0);  
  545.         }  
  546.         else if (pixType == GDT_Int32)  
  547.         {  
  548.             CvtImgDataTo8bitGrayImg<unsigned int>((unsigned int*)pafScanblock, nImgSizeX, nImgSizeXAligned32bit, nImgSizeY,   
  549.                 pNew_pafScanblock_8bit, nNewImgSizeXAligned32bit, INT_MAX, INT_MIN);  
  550.         }  
  551.         else if (pixType == GDT_Float32)  
  552.         {  
  553.             CvtImgDataTo8bitGrayImg<float>((float*)pafScanblock, nImgSizeX, nImgSizeXAligned32bit, nImgSizeY,   
  554.                 pNew_pafScanblock_8bit, nNewImgSizeXAligned32bit, FLT_MAX, FLT_MIN);  
  555.         }  
  556.         else if (pixType == GDT_Float64)  
  557.         {  
  558.             CvtImgDataTo8bitGrayImg<double>((double*)pafScanblock, nImgSizeX, nImgSizeXAligned32bit, nImgSizeY,   
  559.                 pNew_pafScanblock_8bit, nNewImgSizeXAligned32bit, DBL_MAX, DBL_MIN);  
  560.         }  
  561.  
  562.         free(pafScanblock); //释放原来的内存  
  563.         pafScanblock = pNew_pafScanblock_8bit; //指向新内存，注意，因为参数传进来是引用，所以可以改变其指向  
  564.  
  565.     }  
  566.       
  567.     QImage* pQImage = new QImage(pafScanblock, nImgSizeX, nImgSizeY, QImage::Format_Indexed8); //注意：QImage: each scanline of data in the image must also be 32-bit aligned  
  568.     if (pQImage == NULL)  
  569.     {  
  570.         QMessageBox::warning(m_pCanvas, tr("Failed"), tr("Open Image File Failed! Out of memory!"), tr("OK"));  
  571.     }  
  572.     else 
  573.     {  
  574.         pQImage->setColorTable(vcolorTable);  
  575.     }  
  576.     return pQImage;  
  577. }  
  578.  
  579.  
  580. //将非8位的灰度图转换为8位灰度图  
  581. template <class T>  
  582. void RSI_ImageReaderThread::CvtImgDataTo8bitGrayImg(T* pOrigData, int nImgSizeX, int nImgSizeXAligned32bit, int nImgSizeY, uchar* pNew8bitImgBuf, int nNewImgSizeXAligned32bit, T maxVal, T minVal)  
  583. {  
  584.     int oldIdxPos = 0;  
  585.     int newIdxPos = 0;  
  586.     T minPixVal = maxVal;  
  587.     T maxPixVal = minVal;  
  588.     T curPixVal;  
  589.  
  590.     //找到最大值和最小值  
  591.     for (int niY=0; niY<nImgSizeY; niY++)  
  592.     {  
  593.         for (int niX=0; niX<nImgSizeX; niX++)  
  594.         {  
  595.             oldIdxPos = niY * nImgSizeXAligned32bit + niX;  
  596.             curPixVal = pOrigData[oldIdxPos];  
  597.             if (curPixVal > maxPixVal)  
  598.                 maxPixVal = curPixVal;  
  599.             if (curPixVal < minPixVal)  
  600.                 minPixVal = curPixVal;  
  601.         }  
  602.     }  
  603.  
  604.     //根据最大值最小值进行归一化  
  605.     double pixValRange = maxPixVal - minPixVal;  
  606.     if (pixValRange == 0)  
  607.         pixValRange = 1;  
  608.     for (int niY=0; niY<nImgSizeY; niY++)  
  609.     {  
  610.         for (int niX=0; niX<nImgSizeX; niX++)  
  611.         {  
  612.             oldIdxPos = niY * nImgSizeXAligned32bit + niX;  
  613.             newIdxPos = niY * nNewImgSizeXAligned32bit + niX;  
  614.             curPixVal = pOrigData[oldIdxPos];  
  615.             pNew8bitImgBuf[newIdxPos] = (uchar)((curPixVal - minPixVal) / pixValRange * 255);  
  616.         }  
  617.     }  
  618. }

4. 结果显示

在我的机器上读取的一张遥感图像里，将上面读取到的imgFileInfo经过翻译后显示出来如下所示：

GDAL Driver: GTiff/GeoTIFF  
图像大小: 24000 X 24000 X 1(波段)  
GCPs投影方式: GEOGCS["WGS 84",DATUM["WGS_1984",SPHEROID["WGS 84",6378137,298.2572235630016,AUTHORITY["EPSG","7030"]],AUTHORITY["EPSG","6326"]],PRIMEM["Greenwich",0],UNIT["degree",0.0174532925199433],AUTHORITY["EPSG","4326"]]  
GCP个数: 4  
图像左上角坐标: (116.906446, 36.204771)  
像素跨度(经纬度): (0.000031, -0.000022)  
像素跨度(米): (3.486195, 1.279424)

转载链接

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/从前慢现在也慢/article/detail/282880
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号