int main(int argc, char* argv[]) { CPLJoinableThread* hThread; printf("main thread %p\n", (void*)CPLGetPID()); argc = GDALGeneralCmdLineProcessor( argc, &argv, 0 ); CPLSetConfigOption("GDAL_CACHEMAX", "0"); CPLSetConfigOption("GDAL_DEBUG_BLOCK_CACHE", "ON"); MyDataset* poDS = new MyDataset(); char buf1[] = { 1 } ; CPL_IGNORE_RET_VAL(GDALRasterIO(GDALGetRasterBand(poDS, 1), GF_Write, 0, 0, 1, 1, buf1, 1, 1, GDT_Byte, 0, 0)); hThread = CPLCreateJoinableThread(thread_func, NULL); CPLSleep(0.3); CPL_IGNORE_RET_VAL(GDALRasterIO(GDALGetRasterBand(poDS, 1), GF_Write, 1, 0, 1, 1, buf1, 1, 1, GDT_Byte, 0, 0)); GDALFlushCacheBlock(); CPLJoinThread(hThread); delete poDS; GDALDestroyDriverManager(); CSLDestroy( argv ); return 0; }
//辐射校正处理===================================================================================================================================================================================== //绝对辐射校正 long QPDLevel1Process::Level1Proc_RadiationAbsolute(const char* pathImg, const char* pathImgRad, const char* pathAbsRegFile) { CPLSetConfigOption("GDAL_FILENAME_IS_UTF8", "NO"); //中文路径 GDALAllRegister(); long lError = 0; unsigned short *imgBuffer = NULL; //影像数据 float* parametersA = NULL, *parametersB = NULL, *parametersAux = NULL;//校正系数 GDALDatasetH m_dataset = GDALOpen(pathImg, GA_ReadOnly); int xsize = GDALGetRasterXSize(m_dataset); int ysize = GDALGetRasterYSize(m_dataset); int bands = GDALGetRasterCount(m_dataset); char **papszOptions = NULL; papszOptions = CSLSetNameValue(papszOptions, "INTERLEAVE", "BAND"); GDALDatasetH m_datasetdst = GDALCreate(GDALGetDriverByName("GTiff"), pathImgRad, xsize, ysize, bands, GDT_UInt16, papszOptions); //int nSamples, nLines, nLevels; //LevelProc_GetParameterInfo(pathImgRad, nSamples, nLines, nLevels); try { parametersA = new float[bands]; parametersB = new float[bands]; imgBuffer = new unsigned short[xsize*ysize]; } catch (bad_alloc) { printf("allocate memory error\n"); exit(-1); } Level1Proc_AbsoluteParameters(pathAbsRegFile, parametersA, parametersB); for (int i = 0; i < bands; i++) { GDALRasterIO(GDALGetRasterBand(m_dataset, i + 1), GF_Read, 0, 0, xsize, ysize, imgBuffer, xsize, ysize, GDT_UInt16, 0, 0); for (int j = 0; j < ysize; j++) { for (int k = 0; k < xsize; k++) { //扩大100倍精度为0.01 imgBuffer[k] = (unsigned short)((imgBuffer[j*xsize + k] * parametersA[i] + parametersB[i]) * 100); } } GDALRasterIO(GDALGetRasterBand(m_datasetdst, i + 1), GF_Write, 0, 0, xsize, ysize, imgBuffer, xsize, ysize, GDT_UInt16, 0, 0); } delete[]parametersA; parametersA = NULL; delete[]parametersB; parametersB = NULL; delete[]imgBuffer; imgBuffer = NULL; GDALClose(m_dataset); GDALClose(m_datasetdst); return lError; }
void CDialog3D::OnBnClickedBtnColor() { // TODO: 在此添加控件通知处理程序代码 CFileDialog fileDlg(TRUE); if(fileDlg.DoModal()!=IDOK) return; CString strExt =fileDlg.GetFileExt(); CString strPathName=fileDlg.GetPathName(); if(strExt=="BMP"||strExt=="bmp"||strExt=="JPG"||strExt=="jpg"||strExt=="TIF"||strExt=="tif"||strExt=="png"||strExt=="PNG") { GDALAllRegister(); GDALDatasetH hSrcDS=GDALOpen(strPathName,GA_ReadOnly); double adfGeoTrans[6]; double scalex=1,scaley=1; GDALGetGeoTransform(hSrcDS,adfGeoTrans); int xsize=GDALGetRasterXSize(hSrcDS); int ysize=GDALGetRasterYSize(hSrcDS); int tmpxsize=xsize,tmpysize=ysize; if(xsize>800) { tmpxsize=800; scalex=xsize/tmpxsize; } if(ysize>600) { tmpysize=600; scaley=ysize/tmpysize; } float *dataIn1=new float[tmpxsize*tmpysize]; float *dataIn2=new float[tmpxsize*tmpysize]; float *dataIn3=new float[tmpxsize*tmpysize]; GDALRasterIO(GDALGetRasterBand(hSrcDS,1),GF_Read,0,0,xsize,ysize,dataIn1,tmpxsize,tmpysize,GDT_Float32,0,0); GDALRasterIO(GDALGetRasterBand(hSrcDS,2),GF_Read,0,0,xsize,ysize,dataIn2,tmpxsize,tmpysize,GDT_Float32,0,0); GDALRasterIO(GDALGetRasterBand(hSrcDS,3),GF_Read,0,0,xsize,ysize,dataIn3,tmpxsize,tmpysize,GDT_Float32,0,0); for(int i=0;i<tmpxsize;i++) { for (int j=0;j<tmpysize;j++) { PNT3D tmpPnt; tmpPnt.DX=dataIn1[j*tmpxsize+i]/255; tmpPnt.DY=dataIn2[j*tmpxsize+i]/255; tmpPnt.DZ=dataIn3[j*tmpxsize+i]/255; m_vec_colors.push_back(tmpPnt); } } delete[]dataIn1; delete[]dataIn2; delete[]dataIn3; GDALClose(hSrcDS); } }
IplImage * GetDataFromImg(const char *pszImg,bool bIsColor) { GDALAllRegister(); GDALDatasetH hDs = GDALOpen(pszImg,GA_ReadOnly); if (hDs == NULL) return NULL; int nXSize = GDALGetRasterXSize(hDs); int nYSize = GDALGetRasterYSize(hDs); GDALRasterBandH hBand = GDALGetRasterBand(hDs,1); unsigned char *pData = NULL; if (!bIsColor) { pData = new unsigned char [ROW*COL]; GDALRasterIO(hBand, GF_Read, STAT_ROW, START_COL, ROW, COL, pData, ROW, COL, GDT_Byte, NULL, NULL); } else { pData = new unsigned char [ROW*COL*3]; int pBandMap[3]={1,2,3}; GDALDatasetRasterIO(hDs,GF_Read, STAT_ROW, START_COL, ROW, COL, pData, ROW, COL, GDT_Byte,3,pBandMap,3,3*COL,1); } GDALClose(hDs); cv::Mat mat(ROW,COL,CV_8UC3,pData); IplImage limg =(IplImage)mat; IplImage * img = (IplImage *)calloc(1,sizeof(IplImage) ) ; memcpy(img,&limg,sizeof(IplImage)); return img; }
void QgsZonalStatistics::statisticsFromMiddlePointTest( void* band, QgsGeometry* poly, int pixelOffsetX, int pixelOffsetY, int nCellsX, int nCellsY, double cellSizeX, double cellSizeY, const QgsRectangle& rasterBBox, double& sum, double& count ) { double cellCenterX, cellCenterY; float* scanLine = ( float * ) CPLMalloc( sizeof( float ) * nCellsX ); cellCenterY = rasterBBox.yMaximum() - pixelOffsetY * cellSizeY - cellSizeY / 2; count = 0; sum = 0; const GEOSGeometry* polyGeos = poly->asGeos(); if ( !polyGeos ) { return; } GEOSContextHandle_t geosctxt = QgsGeometry::getGEOSHandler(); const GEOSPreparedGeometry* polyGeosPrepared = GEOSPrepare_r( geosctxt, poly->asGeos() ); if ( !polyGeosPrepared ) { return; } GEOSCoordSequence* cellCenterCoords = 0; GEOSGeometry* currentCellCenter = 0; for ( int i = 0; i < nCellsY; ++i ) { if ( GDALRasterIO( band, GF_Read, pixelOffsetX, pixelOffsetY + i, nCellsX, 1, scanLine, nCellsX, 1, GDT_Float32, 0, 0 ) != CPLE_None ) { continue; } cellCenterX = rasterBBox.xMinimum() + pixelOffsetX * cellSizeX + cellSizeX / 2; for ( int j = 0; j < nCellsX; ++j ) { GEOSGeom_destroy_r( geosctxt, currentCellCenter ); cellCenterCoords = GEOSCoordSeq_create_r( geosctxt, 1, 2 ); GEOSCoordSeq_setX_r( geosctxt, cellCenterCoords, 0, cellCenterX ); GEOSCoordSeq_setY_r( geosctxt, cellCenterCoords, 0, cellCenterY ); currentCellCenter = GEOSGeom_createPoint_r( geosctxt, cellCenterCoords ); if ( scanLine[j] != mInputNodataValue ) //don't consider nodata values { if ( GEOSPreparedContains_r( geosctxt, polyGeosPrepared, currentCellCenter ) ) { if ( !qIsNaN( scanLine[j] ) ) { sum += scanLine[j]; } ++count; } } cellCenterX += cellSizeX; } cellCenterY -= cellSizeY; } CPLFree( scanLine ); GEOSPreparedGeom_destroy_r( geosctxt, polyGeosPrepared ); }
void QgsZonalStatistics::statisticsFromMiddlePointTest( void* band, QgsGeometry* poly, int pixelOffsetX, int pixelOffsetY, int nCellsX, int nCellsY, double cellSizeX, double cellSizeY, const QgsRectangle& rasterBBox, double& sum, double& count ) { double cellCenterX, cellCenterY; QgsPoint currentCellCenter; float* scanLine = ( float * ) CPLMalloc( sizeof( float ) * nCellsX ); cellCenterY = rasterBBox.yMaximum() - pixelOffsetY * cellSizeY - cellSizeY / 2; count = 0; sum = 0; for ( int i = 0; i < nCellsY; ++i ) { GDALRasterIO( band, GF_Read, pixelOffsetX, pixelOffsetY + i, nCellsX, 1, scanLine, nCellsX, 1, GDT_Float32, 0, 0 ); cellCenterX = rasterBBox.xMinimum() + pixelOffsetX * cellSizeX + cellSizeX / 2; for ( int j = 0; j < nCellsX; ++j ) { currentCellCenter = QgsPoint( cellCenterX, cellCenterY ); if ( poly->contains( ¤tCellCenter ) ) { if ( scanLine[j] != mInputNodataValue ) //don't consider nodata values { sum += scanLine[j]; ++count; } } cellCenterX += cellSizeX; } cellCenterY -= cellSizeY; } CPLFree( scanLine ); }
/* Function to read the density data from the GDAL file into the array rho. * Returns 1 if there was a problem, 0 otherwise */ int readpop(GDALRasterBandH hBand, double **rho, int xsize, int ysize) { int ix,iy; double mean; double sum; double *rasterData, *rasterDataPtr, *rhoPtr; // Read the raster band into rho. rasterData = malloc(xsize*ysize*sizeof(double)); GDALRasterIO(hBand, GF_Read, 0, 0, xsize, ysize, rasterData, xsize, ysize, GDT_Float64, 0, 0); // Compute the mean value. sum = 0.0; rasterDataPtr = rasterData; for (iy = 0; iy < ysize; iy++) { for (ix = 0; ix < xsize; ix++) { rho[ix][iy] = *rasterDataPtr; sum += *rasterDataPtr; rasterDataPtr++; } } mean = sum / ((double)xsize*(double)ysize); // Add an bias to all raster values. rhoPtr = *rho; for (iy = 0; iy < ysize; iy++) { for (ix = 0; ix < xsize; ix++) { *rhoPtr += OFFSET*mean; rhoPtr++; } } return 0; }
float* get_tif_data(char* tif_file, int* tif_width, int* tif_height) { GDALDatasetH hDataset; hDataset = GDALOpen(tif_file, GA_ReadOnly); if (hDataset == NULL ) { fprintf(stderr, "ERROR: Failed to open the file %s\n", tif_file); return NULL ; } GDALRasterBandH hBand; hBand = GDALGetRasterBand(hDataset, 1); int width1 = GDALGetRasterXSize(hDataset); int height1 = GDALGetRasterYSize(hDataset); double nodata1 = GDALGetRasterNoDataValue(hBand, NULL ); float* data = (float *) CPLMalloc(sizeof(float) * width1 * height1); if (!data) { fprintf(stderr, "ERROR: Failed to allocate data of size %d \n", width1 * height1); return NULL; } GDALRasterIO(hBand, GF_Read, 0, 0, width1, height1, data, width1, height1, GDT_Float32, 0, 0); *tif_width = width1; *tif_height = height1; return data; }
void ColorizationFilter::filter(PointView& view) { int32_t pixel(0); int32_t line(0); std::array<double, 2> pix = { {0.0, 0.0} }; for (PointId idx = 0; idx < view.size(); ++idx) { double x = view.getFieldAs<double>(Dimension::Id::X, idx); double y = view.getFieldAs<double>(Dimension::Id::Y, idx); if (!getPixelAndLinePosition(x, y, m_inverse_transform, pixel, line, m_ds)) continue; for (auto bi = m_bands.begin(); bi != m_bands.end(); ++bi) { BandInfo& b = *bi; GDALRasterBandH hBand = GDALGetRasterBand(m_ds, b.m_band); if (hBand == NULL) { std::ostringstream oss; oss << "Unable to get band " << b.m_band << " from data source!"; throw pdal_error(oss.str()); } if (GDALRasterIO(hBand, GF_Read, pixel, line, 1, 1, &pix[0], 1, 1, GDT_CFloat64, 0, 0) == CE_None) view.setField(b.m_dim, idx, pix[0] * b.m_scale); } } }
void MDAL::DriverGdal::addDataToOutput( GDALRasterBandH raster_band, std::shared_ptr<MemoryDataset> tos, bool is_vector, bool is_x ) { assert( raster_band ); double nodata = GDALGetRasterNoDataValue( raster_band, nullptr ); unsigned int mXSize = meshGDALDataset()->mXSize; unsigned int mYSize = meshGDALDataset()->mYSize; double *values = tos->values(); for ( unsigned int y = 0; y < mYSize; ++y ) { // buffering per-line CPLErr err = GDALRasterIO( raster_band, GF_Read, 0, //nXOff static_cast<int>( y ), //nYOff static_cast<int>( mXSize ), //nXSize 1, //nYSize mPafScanline, //pData static_cast<int>( mXSize ), //nBufXSize 1, //nBufYSize GDT_Float64, //eBufType 0, //nPixelSpace 0 //nLineSpace ); if ( err != CE_None ) { throw MDAL_Status::Err_InvalidData; } for ( unsigned int x = 0; x < mXSize; ++x ) { unsigned int idx = x + mXSize * y; double val = mPafScanline[x]; if ( !MDAL::equals( val, nodata ) ) { // values is prepolulated with NODATA values, so store only legal values if ( is_vector ) { if ( is_x ) { values[2 * idx] = val; } else { values[2 * idx + 1] = val; } } else { values[idx] = val; } } } } }
void QgsZonalStatistics::statisticsFromMiddlePointTest( void* band, const QgsGeometry& poly, int pixelOffsetX, int pixelOffsetY, int nCellsX, int nCellsY, double cellSizeX, double cellSizeY, const QgsRectangle& rasterBBox, FeatureStats &stats ) { double cellCenterX, cellCenterY; float* scanLine = ( float * ) CPLMalloc( sizeof( float ) * nCellsX ); cellCenterY = rasterBBox.yMaximum() - pixelOffsetY * cellSizeY - cellSizeY / 2; stats.reset(); GEOSGeometry* polyGeos = poly.exportToGeos(); if ( !polyGeos ) { return; } GEOSContextHandle_t geosctxt = QgsGeometry::getGEOSHandler(); const GEOSPreparedGeometry* polyGeosPrepared = GEOSPrepare_r( geosctxt, polyGeos ); if ( !polyGeosPrepared ) { GEOSGeom_destroy_r( geosctxt, polyGeos ); return; } GEOSCoordSequence* cellCenterCoords = nullptr; GEOSGeometry* currentCellCenter = nullptr; for ( int i = 0; i < nCellsY; ++i ) { if ( GDALRasterIO( band, GF_Read, pixelOffsetX, pixelOffsetY + i, nCellsX, 1, scanLine, nCellsX, 1, GDT_Float32, 0, 0 ) != CPLE_None ) { continue; } cellCenterX = rasterBBox.xMinimum() + pixelOffsetX * cellSizeX + cellSizeX / 2; for ( int j = 0; j < nCellsX; ++j ) { if ( validPixel( scanLine[j] ) ) { GEOSGeom_destroy_r( geosctxt, currentCellCenter ); cellCenterCoords = GEOSCoordSeq_create_r( geosctxt, 1, 2 ); GEOSCoordSeq_setX_r( geosctxt, cellCenterCoords, 0, cellCenterX ); GEOSCoordSeq_setY_r( geosctxt, cellCenterCoords, 0, cellCenterY ); currentCellCenter = GEOSGeom_createPoint_r( geosctxt, cellCenterCoords ); if ( GEOSPreparedContains_r( geosctxt, polyGeosPrepared, currentCellCenter ) ) { stats.addValue( scanLine[j] ); } } cellCenterX += cellSizeX; } cellCenterY -= cellSizeY; } GEOSGeom_destroy_r( geosctxt, currentCellCenter ); CPLFree( scanLine ); GEOSPreparedGeom_destroy_r( geosctxt, polyGeosPrepared ); GEOSGeom_destroy_r( geosctxt, polyGeos ); }
void QgsZonalStatistics::statisticsFromPreciseIntersection( void* band, const QgsGeometry* poly, int pixelOffsetX, int pixelOffsetY, int nCellsX, int nCellsY, double cellSizeX, double cellSizeY, const QgsRectangle& rasterBBox, FeatureStats &stats ) { stats.reset(); double currentY = rasterBBox.yMaximum() - pixelOffsetY * cellSizeY - cellSizeY / 2; float* pixelData = ( float * ) CPLMalloc( sizeof( float ) ); QgsGeometry* pixelRectGeometry = nullptr; double hCellSizeX = cellSizeX / 2.0; double hCellSizeY = cellSizeY / 2.0; double pixelArea = cellSizeX * cellSizeY; double weight = 0; for ( int row = 0; row < nCellsY; ++row ) { double currentX = rasterBBox.xMinimum() + cellSizeX / 2.0 + pixelOffsetX * cellSizeX; for ( int col = 0; col < nCellsX; ++col ) { if ( GDALRasterIO( band, GF_Read, pixelOffsetX + col, pixelOffsetY + row, nCellsX, 1, pixelData, 1, 1, GDT_Float32, 0, 0 ) != CE_None ) QgsDebugMsg( "Raster IO Error" ); if ( !validPixel( *pixelData ) ) continue; pixelRectGeometry = QgsGeometry::fromRect( QgsRectangle( currentX - hCellSizeX, currentY - hCellSizeY, currentX + hCellSizeX, currentY + hCellSizeY ) ); if ( pixelRectGeometry ) { //intersection QgsGeometry *intersectGeometry = pixelRectGeometry->intersection( poly ); if ( intersectGeometry ) { double intersectionArea = intersectGeometry->area(); if ( intersectionArea >= 0.0 ) { weight = intersectionArea / pixelArea; stats.addValue( *pixelData, weight ); } delete intersectGeometry; } delete pixelRectGeometry; pixelRectGeometry = nullptr; } currentX += cellSizeX; } currentY -= cellSizeY; } CPLFree( pixelData ); }
boost::uint32_t Colorization::readBufferImpl(PointBuffer& data) { const boost::uint32_t numRead = getPrevIterator().read(data); #ifdef PDAL_HAVE_GDAL boost::int32_t pixel(0); boost::int32_t line(0); double x(0.0); double y(0.0); bool fetched(false); boost::array<double, 2> pix; pix.assign(0.0); for (boost::uint32_t pointIndex=0; pointIndex<numRead; pointIndex++) { x = getScaledValue(data, *m_dimX, pointIndex); y = getScaledValue(data, *m_dimY, pointIndex); fetched = getPixelAndLinePosition(x, y, m_inverse_transform, pixel, line, m_ds); if (!fetched) continue; for (std::vector<boost::int32_t>::size_type i = 0; i < m_bands.size(); i++) { GDALRasterBandH hBand = GDALGetRasterBand(m_ds, m_bands[i]); if (hBand == NULL) { std::ostringstream oss; oss << "Unable to get band " << m_bands[i] << " from data source!"; throw pdal_error(oss.str()); } if (GDALRasterIO(hBand, GF_Read, pixel, line, 1, 1, &pix[0], 1, 1, GDT_CFloat64, 0, 0) == CE_None) { double output = pix[0]; output = output * m_scales[i]; setScaledValue(data, output, *m_dimensions[i], pointIndex); } } } #endif return numRead; }
double QgsAlignRaster::RasterInfo::identify( double mx, double my ) { GDALRasterBandH hBand = GDALGetRasterBand( mDataset, 1 ); // must not be rotated in order for this to work int px = int(( mx - mGeoTransform[0] ) / mGeoTransform[1] ); int py = int(( my - mGeoTransform[3] ) / mGeoTransform[5] ); float* pafScanline = ( float * ) CPLMalloc( sizeof( float ) ); CPLErr err = GDALRasterIO( hBand, GF_Read, px, py, 1, 1, pafScanline, 1, 1, GDT_Float32, 0, 0 ); double value = err == CE_None ? pafScanline[0] : NAN; CPLFree( pafScanline ); return value; }
void QgsZonalStatistics::statisticsFromPreciseIntersection( void* band, QgsGeometry* poly, int pixelOffsetX, int pixelOffsetY, int nCellsX, int nCellsY, double cellSizeX, double cellSizeY, const QgsRectangle& rasterBBox, double& sum, double& count ) { sum = 0; count = 0; double currentY = rasterBBox.yMaximum() - pixelOffsetY * cellSizeY - cellSizeY / 2; float* pixelData = ( float * ) CPLMalloc( sizeof( float ) ); QgsGeometry* pixelRectGeometry = 0; double hCellSizeX = cellSizeX / 2.0; double hCellSizeY = cellSizeY / 2.0; double pixelArea = cellSizeX * cellSizeY; double weight = 0; for ( int row = 0; row < nCellsY; ++row ) { double currentX = rasterBBox.xMinimum() + cellSizeX / 2.0 + pixelOffsetX * cellSizeX; for ( int col = 0; col < nCellsX; ++col ) { GDALRasterIO( band, GF_Read, pixelOffsetX + col, pixelOffsetY + row, nCellsX, 1, pixelData, 1, 1, GDT_Float32, 0, 0 ); pixelRectGeometry = QgsGeometry::fromRect( QgsRectangle( currentX - hCellSizeX, currentY - hCellSizeY, currentX + hCellSizeX, currentY + hCellSizeY ) ); if ( pixelRectGeometry ) { //intersection QgsGeometry *intersectGeometry = pixelRectGeometry->intersection( poly ); if ( intersectGeometry ) { double intersectionArea = intersectGeometry->area(); if ( intersectionArea >= 0.0 ) { weight = intersectionArea / pixelArea; count += weight; sum += *pixelData * weight; } delete intersectGeometry; } delete pixelRectGeometry; pixelRectGeometry = 0; } currentX += cellSizeX; } currentY -= cellSizeY; } CPLFree( pixelData ); }
static int vips__gdal_generate( VipsRegion *out, void *_seq, void *_read, void *unused, gboolean *stop ) { Read *read = _read; VipsRect *r = &out->valid; int n = r->width * r->height; unsigned char *buf = (unsigned char *) VIPS_REGION_ADDR( out, r->left, r->top ); VIPS_DEBUG_MSG( "vips__gdal_generate: %dx%d @ %dx%d\n", r->width, r->height, r->left, r->top ); /* We're inside a cache, so requests should always be * tile_width by tile_height pixels and on a tile boundary. */ g_assert( (r->left % read->tile_width) == 0 ); g_assert( (r->top % read->tile_height) == 0 ); g_assert( r->width <= read->tile_width ); g_assert( r->height <= read->tile_height ); g_assert( read->data_type == GDT_Byte ); g_assert( GDALGetRasterCount ); for (int channel = 0; channel < 3; ++channel) { GDALRasterBandH hBand; hBand = GDALGetRasterBand( read->hDataset, channel + 1 ); unsigned char* gdal_data; gdal_data = (unsigned char*) CPLMalloc(sizeof(unsigned char) * r->width * r->height); GDALRasterIO( hBand, GF_Read, r->left, r->top, r->width, r->height, gdal_data, r->width, r->height, GDT_Byte, 0, 0 ); for (int i = 0; i < r->width * r->height; ++i) { buf[i * 3 + channel] = gdal_data[i]; } CPLFree (gdal_data); } return( 0 ); }
int makeGeotiff (struct deminfo *d0, char *outpath,int nodata) { GDALAllRegister (); GDALDataType band_type = GDT_Float32; int bands = 1; int dsn_xsize = (d0->highx - d0->lowx + 1); int dsn_ysize = (d0->highy - d0->lowy + 1); char **papszCreateOptions = NULL; papszCreateOptions = CSLSetNameValue (papszCreateOptions, "PROFILE", "GeoTIFF"); //papszCreateOptions = CSLSetNameValue( papszCreateOptions, "TFW", "YES" ); //papszCreateOptions = CSLSetNameValue (papszCreateOptions, "INTERLEAVE", "PIXEL"); //papszCreateOptions = CSLSetNameValue (papszCreateOptions, "TILED", "YES"); //papszCreateOptions = CSLSetNameValue (papszCreateOptions, "COMPRESS", "LZW"); GDALDriverH hDriver = GDALGetDriverByName ("GTiff"); GDALDatasetH hDsnDS = GDALCreate (hDriver, outpath, dsn_xsize, dsn_ysize, bands, band_type, papszCreateOptions); double dsnGeoTransform[6]; dsnGeoTransform[0] = d0->W; dsnGeoTransform[1] = (d0->E - d0->W) / dsn_xsize; dsnGeoTransform[2] = 0; dsnGeoTransform[3] = d0->N; dsnGeoTransform[4] = 0; dsnGeoTransform[5] = -1.0 * (d0->N - d0->S) / dsn_ysize; GDALSetGeoTransform (hDsnDS, dsnGeoTransform); char pszSRS_WKT[1024] = "GEOGCS[\"JGD2000\", DATUM[\"Japanese Geodetic Datum 2000\", SPHEROID[\"GRS 1980\", 6378137.0, 298.257222101, AUTHORITY[\"EPSG\",\"7019\"]], TOWGS84[0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0],AUTHORITY[\"EPSG\",\"6612\"]], PRIMEM[\"Greenwich\", 0.0, AUTHORITY[\"EPSG\",\"8901\"]], UNIT[\"degree\", 0.017453292519943295], AXIS[\"Geodetic longitude\", EAST], AXIS[\"Geodetic latitude\", NORTH], AUTHORITY[\"EPSG\",\"4612\"]]"; GDALSetProjection (hDsnDS, pszSRS_WKT); GDALRasterBandH t_band = GDALGetRasterBand (hDsnDS, 1); if(nodata==1){ GDALSetRasterNoDataValue (t_band, -9999); } GDALRasterIO (t_band, GF_Write, 0, 0, dsn_xsize, dsn_ysize, d0->alti, dsn_xsize, dsn_ysize, band_type, 0, 0); CSLDestroy (papszCreateOptions); GDALClose (hDsnDS); return 0; }
// API: get a sample from an image, at the requested octave float fancy_image_getsample_oct(struct fancy_image *fi, int octave, int i,int j, int l) { struct FI *f = (void*)fi; if (octave < 0 || octave >= f->no) return NAN; if (l < 0) l = 0; if (l >= f->pd) l = f->pd - 1; if (f->tiffo) { #ifdef FANCY_TIFF uint8_t *p_pixel = tiff_octaves_getpixel(f->t, octave, i, j); if (!p_pixel) return NAN; uint8_t *p_sample = p_pixel + (l * f->t->i->bps) / 8; return convert_sample_to_float(f->t->i, p_sample); #else assert(false); #endif } else if (f->gdal) { #ifdef FANCY_GDAL if (octave != 0) return NAN; static float *roi = NULL; if (!roi) roi = CPLMalloc(1*1*sizeof*roi); GDALRasterBandH img = f->gdal_band[l]; int r = GDALRasterIO(img, GF_Read, i,j,1, 1, roi,1,1, GDT_Float32, 0,0); return roi[0*0+0]; #else assert(false); #endif } else { float *x = f->pyr_x[octave]; int w = f->pyr_w[octave]; int h = f->pyr_h[octave]; if (i < 0 || j < 0 || i >= w || j >= h) return NAN; int idx = (j * w + i) * f->pd + l; return x[idx]; } return NAN; }
static dErr JakoFileDataView(GDALDatasetH filedata,const char *name,PetscViewer viewer) { dErr err; CPLErr cplerr; double geo[6],data[8*12]; int nx=8,ny=12,snx,sny; GDALRasterBandH band; dFunctionBegin; cplerr = GDALGetGeoTransform(filedata,geo); err = dRealTableView(2,3,geo,PETSC_VIEWER_STDOUT_WORLD,"%s:geo",name);dCHK(err); snx = GDALGetRasterXSize(filedata); sny = GDALGetRasterYSize(filedata); err = PetscViewerASCIIPrintf(viewer,"%s: nx=%d ny=%d\n",name,snx,sny);dCHK(err); band = GDALGetRasterBand(filedata,1); cplerr = GDALRasterIO(band,GF_Read,snx/2,sny/2,nx,ny,data,nx,ny,GDT_Float64,0,0);dCPLCHK(cplerr); err = dRealTableView(ny,nx,data,PETSC_VIEWER_STDOUT_WORLD,name);dCHK(err); dFunctionReturn(0); }
CPLErr QgsGdalProviderBase::gdalRasterIO( GDALRasterBandH hBand, GDALRWFlag eRWFlag, int nXOff, int nYOff, int nXSize, int nYSize, void * pData, int nBufXSize, int nBufYSize, GDALDataType eBufType, int nPixelSpace, int nLineSpace ) { // See http://hub.qgis.org/issues/8356 and http://trac.osgeo.org/gdal/ticket/5170 #if GDAL_VERSION_MAJOR == 1 && ( (GDAL_VERSION_MINOR == 9 && GDAL_VERSION_REV <= 2) || (GDAL_VERSION_MINOR == 10 && GDAL_VERSION_REV <= 0) ) char* pszOldVal = CPLStrdup( CPLGetConfigOption( "VSI_CACHE", "FALSE" ) ); CPLSetThreadLocalConfigOption( "VSI_CACHE", "FALSE" ); QgsDebugMsg( "Disabled VSI_CACHE" ); #endif CPLErr err = GDALRasterIO( hBand, eRWFlag, nXOff, nYOff, nXSize, nYSize, pData, nBufXSize, nBufYSize, eBufType, nPixelSpace, nLineSpace ); #if GDAL_VERSION_MAJOR == 1 && ( (GDAL_VERSION_MINOR == 9 && GDAL_VERSION_REV <= 2) || (GDAL_VERSION_MINOR == 10 && GDAL_VERSION_REV <= 0) ) CPLSetThreadLocalConfigOption( "VSI_CACHE", pszOldVal ); CPLFree( pszOldVal ); QgsDebugMsg( "Reset VSI_CACHE" ); #endif return err; }
static CPLErr GPMaskImageData( GDALRasterBandH hMaskBand, GByte* pabyMaskLine, int iY, int nXSize, float *pafImageLine ) { CPLErr eErr; eErr = GDALRasterIO( hMaskBand, GF_Read, 0, iY, nXSize, 1, pabyMaskLine, nXSize, 1, GDT_Byte, 0, 0 ); if( eErr == CE_None ) { int i; for( i = 0; i < nXSize; i++ ) { if( pabyMaskLine[i] == 0 ) pafImageLine[i] = GP_NODATA_MARKER; } } return eErr; }
int GDALFillBandNoData(GDALDataset *poDS, int nBand, int nSearchPixels) { (void)nBand; (void)nSearchPixels; if(poDS == NULL) { fprintf(stderr, "Invalid GDAL Dataset Handle, cannot fill no data\n"); return -1; } int nPixels, nLines; nPixels = poDS->GetRasterXSize(); nLines = poDS->GetRasterYSize(); GDALRasterBand *poBand; poBand = poDS->GetRasterBand(1); GDALFillNodata(poBand, NULL, 100, 0, 0, NULL, NULL, NULL); double dfNoData = poBand->GetNoDataValue(NULL); double *padfScanline; padfScanline = (double *) CPLMalloc(sizeof(double)*nPixels); int nNoDataCount = 0; for(int i = 0;i < nLines;i++) { GDALRasterIO(poBand, GF_Read, 0, i, nPixels, 1, padfScanline, nPixels, 1, GDT_Float64, 0, 0); for(int j = 0; j < nPixels;j++) { if(CPLIsEqual(padfScanline[j], dfNoData)) nNoDataCount++; } } CPLFree(padfScanline); return nNoDataCount; }
void writeGeoTiffF(char * fileName, float * result, int nRow, int nCol, double xMin, double yMax, double cellSize) { GDALAllRegister(); OGRRegisterAll(); GDALDatasetH hDstDS; GDALDriverH hDriver; GDALRasterBandH hBand; double adfGeoTransform[6]; char *papszOptions[] = {"COMPRESS=LZW",NULL}; const char *pszFormat="GTiff"; if(NULL == (hDriver = GDALGetDriverByName(pszFormat))) { printf("ERROR: hDriver is null cannot output using GDAL\n"); exit(1); } hDstDS = GDALCreate(hDriver, fileName, nCol, nRow, 1, GDT_Float32, papszOptions); adfGeoTransform[0] = xMin; adfGeoTransform[1] = cellSize; adfGeoTransform[2] = 0; adfGeoTransform[3] = yMax; adfGeoTransform[4] = 0; adfGeoTransform[5] = -cellSize; GDALSetGeoTransform(hDstDS,adfGeoTransform); hBand=GDALGetRasterBand(hDstDS,1); GDALSetRasterNoDataValue(hBand,-1); GDALRasterIO(hBand, GF_Write, 0, 0, nCol, nRow, result, nCol, nRow, GDT_Float32, 0, 0 ); GDALClose(hDstDS); return; }
GByte * gdal_to_rgba( GDALDatasetH hDS ) { int nXSize, nYSize; GByte *pabyRGBABuf = NULL; /* validation of input parameters */ g_return_val_if_fail( hDS != NULL, NULL ); /* -------------------------------------------------------------------- */ /* Allocate RGBA Raster buffer. */ /* -------------------------------------------------------------------- */ nXSize = GDALGetRasterXSize( hDS ); nYSize = GDALGetRasterYSize( hDS ); CPLDebug( "OpenEV", "creating buffer of (%d,%d)", nXSize, nYSize ); pabyRGBABuf = (GByte *) CPLMalloc( nXSize * nYSize * 4 ); /* -------------------------------------------------------------------- */ /* Handle case where source is already presumed to be RGBA. */ /* -------------------------------------------------------------------- */ if( GDALGetRasterCount(hDS) == 4 ) { GDALRasterIO( GDALGetRasterBand( hDS, 1 ), GF_Read, 0, 0, nXSize, nYSize, pabyRGBABuf+0, nXSize, nYSize, GDT_Byte, 4, nXSize * 4 ); GDALRasterIO( GDALGetRasterBand( hDS, 2 ), GF_Read, 0, 0, nXSize, nYSize, pabyRGBABuf+1, nXSize, nYSize, GDT_Byte, 4, nXSize * 4 ); GDALRasterIO( GDALGetRasterBand( hDS, 3 ), GF_Read, 0, 0, nXSize, nYSize, pabyRGBABuf+2, nXSize, nYSize, GDT_Byte, 4, nXSize * 4 ); GDALRasterIO( GDALGetRasterBand( hDS, 4 ), GF_Read, 0, 0, nXSize, nYSize, pabyRGBABuf+3, nXSize, nYSize, GDT_Byte, 4, nXSize * 4 ); } /* -------------------------------------------------------------------- */ /* Source is RGB. Set Alpha to 255. */ /* -------------------------------------------------------------------- */ else if( GDALGetRasterCount(hDS) == 3 ) { memset( pabyRGBABuf, 255, 4 * nXSize * nYSize ); GDALRasterIO( GDALGetRasterBand( hDS, 1 ), GF_Read, 0, 0, nXSize, nYSize, pabyRGBABuf+0, nXSize, nYSize, GDT_Byte, 4, nXSize * 4 ); GDALRasterIO( GDALGetRasterBand( hDS, 2 ), GF_Read, 0, 0, nXSize, nYSize, pabyRGBABuf+1, nXSize, nYSize, GDT_Byte, 4, nXSize * 4 ); GDALRasterIO( GDALGetRasterBand( hDS, 3 ), GF_Read, 0, 0, nXSize, nYSize, pabyRGBABuf+2, nXSize, nYSize, GDT_Byte, 4, nXSize * 4 ); } /* -------------------------------------------------------------------- */ /* Source is pseudocolored. Load and then convert to RGBA. */ /* -------------------------------------------------------------------- */ else if( GDALGetRasterCount(hDS) == 1 && GDALGetRasterColorTable( GDALGetRasterBand( hDS, 1 )) != NULL ) { int i; GDALColorTableH hTable; GByte abyPCT[1024]; /* Load color table, and produce 256 entry table to RGBA. */ hTable = GDALGetRasterColorTable( GDALGetRasterBand( hDS, 1 ) ); for( i = 0; i < MIN(256,GDALGetColorEntryCount( hTable )); i++ ) { GDALColorEntry sEntry; GDALGetColorEntryAsRGB( hTable, i, &sEntry ); abyPCT[i*4+0] = sEntry.c1; abyPCT[i*4+1] = sEntry.c2; abyPCT[i*4+2] = sEntry.c3; abyPCT[i*4+3] = sEntry.c4; } /* Fill in any missing colors with greyscale. */ for( i = GDALGetColorEntryCount( hTable ); i < 256; i++ ) { abyPCT[i*4+0] = i; abyPCT[i*4+1] = i; abyPCT[i*4+2] = i; abyPCT[i*4+3] = 255; } /* Read indexed raster */ GDALRasterIO( GDALGetRasterBand( hDS, 1 ), GF_Read, 0, 0, nXSize, nYSize, pabyRGBABuf+0, nXSize, nYSize, GDT_Byte, 4, nXSize * 4 ); /* Convert to RGBA using palette. */ for( i = nXSize * nYSize - 1; i >= 0; i-- ) { memcpy( pabyRGBABuf + i*4, abyPCT + pabyRGBABuf[i*4]*4, 4 ); } } /* -------------------------------------------------------------------- */ /* Source band is greyscale. Load it into Red, Green and Blue. */ /* -------------------------------------------------------------------- */ else if( GDALGetRasterCount(hDS) == 1 ) { memset( pabyRGBABuf, 255, 4 * nXSize * nYSize ); GDALRasterIO( GDALGetRasterBand( hDS, 1 ), GF_Read, 0, 0, nXSize, nYSize, pabyRGBABuf+0, nXSize, nYSize, GDT_Byte, 4, nXSize * 4 ); GDALRasterIO( GDALGetRasterBand( hDS, 1 ), GF_Read, 0, 0, nXSize, nYSize, pabyRGBABuf+1, nXSize, nYSize, GDT_Byte, 4, nXSize * 4 ); GDALRasterIO( GDALGetRasterBand( hDS, 1 ), GF_Read, 0, 0, nXSize, nYSize, pabyRGBABuf+2, nXSize, nYSize, GDT_Byte, 4, nXSize * 4 ); } return pabyRGBABuf; }
void CDialog3D::OnBnClickedBtnOpen() { // TODO: 在此添加控件通知处理程序代码 CFileDialog fileDlg(TRUE); if(fileDlg.DoModal()!=IDOK) return; CString strExt =fileDlg.GetFileExt(); CString strPathName=fileDlg.GetPathName(); if(strExt=="txt") { ifstream ifs(strPathName,ios_base::in); char tmpchr[2048]; ifs.getline(tmpchr,2048); do { PNT3D tmpPnt; ifs.getline(tmpchr,2048); sscanf(tmpchr,"%f,%f,%f",&tmpPnt.DX,&tmpPnt.DY,&tmpPnt.DZ); m_vec_PNT3Ds.push_back(tmpPnt); } while (!ifs.eof()); ifs.close(); } if(strExt=="BMP"||strExt=="bmp"||strExt=="JPG"||strExt=="jpg"||strExt=="TIF"||strExt=="tif") { GDALAllRegister(); GDALDatasetH hSrcDS=GDALOpen(strPathName,GA_ReadOnly); double adfGeoTrans[6]; double scalex=1,scaley=1; GDALGetGeoTransform(hSrcDS,adfGeoTrans); int xsize=GDALGetRasterXSize(hSrcDS); int ysize=GDALGetRasterYSize(hSrcDS); int tmpxsize=xsize,tmpysize=ysize; if(xsize>800) { tmpxsize=800; scalex=xsize/tmpxsize; } if(ysize>600) { tmpysize=600; scaley=ysize/tmpysize; } float *dataIn=new float[tmpxsize*tmpysize]; GDALRasterIO(GDALGetRasterBand(hSrcDS,1),GF_Read,0,0,xsize,ysize,dataIn,tmpxsize,tmpysize,GDT_Float32,0,0); for(int i=0;i<tmpxsize;i++) { for (int j=0;j<tmpysize;j++) { PNT3D tmpPnt; tmpPnt.DX=adfGeoTrans[0]+adfGeoTrans[1]*i*scalex+adfGeoTrans[2]*j*scaley; tmpPnt.DY=adfGeoTrans[3]+adfGeoTrans[4]*i*scalex+adfGeoTrans[5]*j*scaley; //tmpPnt.DX=i; //tmpPnt.DY=j; tmpPnt.DZ=dataIn[j*tmpxsize+i]; m_vec_PNT3Ds.push_back(tmpPnt); } } delete[]dataIn; GDALClose(hSrcDS); } if(!m_vec_PNT3Ds.empty()) { m_min_DX=m_max_DX=m_vec_PNT3Ds[0].DX; m_min_DY=m_max_DY=m_vec_PNT3Ds[0].DY; m_min_DZ=m_max_DZ=m_vec_PNT3Ds[0].DZ; for (int i=0;i<m_vec_PNT3Ds.size();i++) { m_max_DX=max(m_vec_PNT3Ds[i].DX,m_max_DX); m_min_DX=min(m_vec_PNT3Ds[i].DX,m_min_DX); m_max_DY=max(m_vec_PNT3Ds[i].DY,m_max_DY); m_min_DY=min(m_vec_PNT3Ds[i].DY,m_min_DY); m_max_DZ=max(m_vec_PNT3Ds[i].DZ,m_max_DZ); m_min_DZ=min(m_vec_PNT3Ds[i].DZ,m_min_DZ); } AfxMessageBox("数据读取成功!\n"); InvalidateRect(NULL,FALSE); } }
void MDAL::LoaderGdal::addDataToOutput( GDALRasterBandH raster_band, std::shared_ptr<Dataset> tos, bool is_vector, bool is_x ) { assert( raster_band ); double nodata = GDALGetRasterNoDataValue( raster_band, nullptr ); unsigned int mXSize = meshGDALDataset()->mXSize; unsigned int mYSize = meshGDALDataset()->mYSize; for ( unsigned int y = 0; y < mYSize; ++y ) { // buffering per-line CPLErr err = GDALRasterIO( raster_band, GF_Read, 0, //nXOff static_cast<int>( y ), //nYOff static_cast<int>( mXSize ), //nXSize 1, //nYSize mPafScanline, //pData static_cast<int>( mXSize ), //nBufXSize 1, //nBufYSize GDT_Float64, //eBufType 0, //nPixelSpace 0 //nLineSpace ); if ( err != CE_None ) { throw MDAL_Status::Err_InvalidData; } for ( unsigned int x = 0; x < mXSize; ++x ) { unsigned int idx = x + mXSize * y; double val = mPafScanline[x]; bool noData = false; if ( MDAL::equals( val, nodata ) ) { // store all nodata value as this hardcoded number val = MDAL_NODATA; noData = true; } if ( is_vector ) { if ( is_x ) { tos->values[idx].x = val; tos->values[idx].noData = noData; } else { tos->values[idx].y = val; tos->values[idx].noData = noData; } } else { tos->values[idx].x = val; tos->values[idx].noData = noData; } } } }
int main( int argc, char ** argv ) { GDALDatasetH hSrcDS; int iY, iX, nOutLevel=0, nXSize, nYSize, iArg, nFillDist=0; void *pStream; GInt16 *panData; const char *pszFilename = NULL; GDALRasterBandH hSrcBand; double adfGeoTransform[6]; int bEnableTrim = FALSE; GInt16 noDataValue = 0; int bHasNoData; /* -------------------------------------------------------------------- */ /* Identify arguments. */ /* -------------------------------------------------------------------- */ for( iArg = 1; iArg < argc; iArg++ ) { if( EQUAL(argv[iArg],"-trim") ) bEnableTrim = TRUE; else if( EQUAL(argv[iArg],"-fill") ) nFillDist = atoi(argv[++iArg]); else if( EQUAL(argv[iArg],"-level") ) nOutLevel = atoi(argv[++iArg]); else { if( pszFilename != NULL ) Usage(); pszFilename = argv[iArg]; } } if( pszFilename == NULL ) Usage(); /* -------------------------------------------------------------------- */ /* Open input file. */ /* -------------------------------------------------------------------- */ GDALAllRegister(); hSrcDS = GDALOpen( pszFilename, GA_ReadOnly ); if( hSrcDS == NULL ) exit(1); hSrcBand = GDALGetRasterBand( hSrcDS, 1 ); noDataValue = (GInt16)GDALGetRasterNoDataValue(hSrcBand, &bHasNoData); nXSize = GDALGetRasterXSize( hSrcDS ); nYSize = GDALGetRasterYSize( hSrcDS ); GDALGetGeoTransform( hSrcDS, adfGeoTransform ); /* -------------------------------------------------------------------- */ /* Create output stream. */ /* -------------------------------------------------------------------- */ pStream = DTEDCreatePtStream( ".", nOutLevel ); if( pStream == NULL ) exit( 1 ); /* -------------------------------------------------------------------- */ /* Process all the profiles. */ /* -------------------------------------------------------------------- */ panData = (GInt16 *) malloc(sizeof(GInt16) * nXSize); for( iY = 0; iY < nYSize; iY++ ) { GDALRasterIO( hSrcBand, GF_Read, 0, iY, nXSize, 1, panData, nXSize, 1, GDT_Int16, 0, 0 ); if (bHasNoData) { for( iX = 0; iX < nXSize; iX++ ) { if (panData[iX] == noDataValue) panData[iX] = DTED_NODATA_VALUE; } } for( iX = 0; iX < nXSize; iX++ ) { DTEDWritePt( pStream, adfGeoTransform[0] + adfGeoTransform[1] * (iX + 0.5) + adfGeoTransform[2] * (iY + 0.5), adfGeoTransform[3] + adfGeoTransform[4] * (iX + 0.5) + adfGeoTransform[5] * (iY + 0.5), panData[iX] ); } } free( panData ); /* -------------------------------------------------------------------- */ /* Cleanup. */ /* -------------------------------------------------------------------- */ if( bEnableTrim ) DTEDPtStreamTrimEdgeOnlyTiles( pStream ); if( nFillDist > 0 ) DTEDFillPtStream( pStream, nFillDist ); DTEDClosePtStream( pStream ); GDALClose( hSrcDS ); exit( 0 ); }
CPLErr CPL_STDCALL GDALFPolygonize( GDALRasterBandH hSrcBand, GDALRasterBandH hMaskBand, OGRLayerH hOutLayer, int iPixValField, char **papszOptions, GDALProgressFunc pfnProgress, void * pProgressArg ) { #ifndef OGR_ENABLED CPLError(CE_Failure, CPLE_NotSupported, "GDALFPolygonize() unimplemented in a non OGR build"); return CE_Failure; #else VALIDATE_POINTER1( hSrcBand, "GDALFPolygonize", CE_Failure ); VALIDATE_POINTER1( hOutLayer, "GDALFPolygonize", CE_Failure ); if( pfnProgress == NULL ) pfnProgress = GDALDummyProgress; int nConnectedness = CSLFetchNameValue( papszOptions, "8CONNECTED" ) ? 8 : 4; /* -------------------------------------------------------------------- */ /* Confirm our output layer will support feature creation. */ /* -------------------------------------------------------------------- */ if( !OGR_L_TestCapability( hOutLayer, OLCSequentialWrite ) ) { CPLError( CE_Failure, CPLE_AppDefined, "Output feature layer does not appear to support creation\n" "of features in GDALFPolygonize()." ); return CE_Failure; } /* -------------------------------------------------------------------- */ /* Allocate working buffers. */ /* -------------------------------------------------------------------- */ CPLErr eErr = CE_None; int nXSize = GDALGetRasterBandXSize( hSrcBand ); int nYSize = GDALGetRasterBandYSize( hSrcBand ); float *pafLastLineVal = (float *) VSIMalloc2(sizeof(float),nXSize + 2); float *pafThisLineVal = (float *) VSIMalloc2(sizeof(float),nXSize + 2); GInt32 *panLastLineId = (GInt32 *) VSIMalloc2(sizeof(GInt32),nXSize + 2); GInt32 *panThisLineId = (GInt32 *) VSIMalloc2(sizeof(GInt32),nXSize + 2); GByte *pabyMaskLine = (hMaskBand != NULL) ? (GByte *) VSIMalloc(nXSize) : NULL; if (pafLastLineVal == NULL || pafThisLineVal == NULL || panLastLineId == NULL || panThisLineId == NULL || (hMaskBand != NULL && pabyMaskLine == NULL)) { CPLError(CE_Failure, CPLE_OutOfMemory, "Could not allocate enough memory for temporary buffers"); CPLFree( panThisLineId ); CPLFree( panLastLineId ); CPLFree( pafThisLineVal ); CPLFree( pafLastLineVal ); CPLFree( pabyMaskLine ); return CE_Failure; } /* -------------------------------------------------------------------- */ /* Get the geotransform, if there is one, so we can convert the */ /* vectors into georeferenced coordinates. */ /* -------------------------------------------------------------------- */ GDALDatasetH hSrcDS = GDALGetBandDataset( hSrcBand ); double adfGeoTransform[6] = { 0.0, 1.0, 0.0, 0.0, 0.0, 1.0 }; if( hSrcDS ) GDALGetGeoTransform( hSrcDS, adfGeoTransform ); /* -------------------------------------------------------------------- */ /* The first pass over the raster is only used to build up the */ /* polygon id map so we will know in advance what polygons are */ /* what on the second pass. */ /* -------------------------------------------------------------------- */ int iY; GDALRasterFPolygonEnumerator oFirstEnum(nConnectedness); for( iY = 0; eErr == CE_None && iY < nYSize; iY++ ) { eErr = GDALRasterIO( hSrcBand, GF_Read, 0, iY, nXSize, 1, pafThisLineVal, nXSize, 1, GDT_Float32, 0, 0 ); if( eErr == CE_None && hMaskBand != NULL ) eErr = GPMaskImageData( hMaskBand, pabyMaskLine, iY, nXSize, pafThisLineVal ); if( iY == 0 ) oFirstEnum.ProcessLine( NULL, pafThisLineVal, NULL, panThisLineId, nXSize ); else oFirstEnum.ProcessLine( pafLastLineVal, pafThisLineVal, panLastLineId, panThisLineId, nXSize ); // swap lines float * pafTmp = pafLastLineVal; pafLastLineVal = pafThisLineVal; pafThisLineVal = pafTmp; GInt32 * panTmp = panThisLineId; panThisLineId = panLastLineId; panLastLineId = panTmp; /* -------------------------------------------------------------------- */ /* Report progress, and support interrupts. */ /* -------------------------------------------------------------------- */ if( eErr == CE_None && !pfnProgress( 0.10 * ((iY+1) / (double) nYSize), "", pProgressArg ) ) { CPLError( CE_Failure, CPLE_UserInterrupt, "User terminated" ); eErr = CE_Failure; } } /* -------------------------------------------------------------------- */ /* Make a pass through the maps, ensuring every polygon id */ /* points to the final id it should use, not an intermediate */ /* value. */ /* -------------------------------------------------------------------- */ oFirstEnum.CompleteMerges(); /* -------------------------------------------------------------------- */ /* Initialize ids to -1 to serve as a nodata value for the */ /* previous line, and past the beginning and end of the */ /* scanlines. */ /* -------------------------------------------------------------------- */ int iX; panThisLineId[0] = -1; panThisLineId[nXSize+1] = -1; for( iX = 0; iX < nXSize+2; iX++ ) panLastLineId[iX] = -1; /* -------------------------------------------------------------------- */ /* We will use a new enumerator for the second pass primariliy */ /* so we can preserve the first pass map. */ /* -------------------------------------------------------------------- */ GDALRasterFPolygonEnumerator oSecondEnum(nConnectedness); RPolygonF **papoPoly = (RPolygonF **) CPLCalloc(sizeof(RPolygonF*),oFirstEnum.nNextPolygonId); /* ==================================================================== */ /* Second pass during which we will actually collect polygon */ /* edges as geometries. */ /* ==================================================================== */ for( iY = 0; eErr == CE_None && iY < nYSize+1; iY++ ) { /* -------------------------------------------------------------------- */ /* Read the image data. */ /* -------------------------------------------------------------------- */ if( iY < nYSize ) { eErr = GDALRasterIO( hSrcBand, GF_Read, 0, iY, nXSize, 1, pafThisLineVal, nXSize, 1, GDT_Float32, 0, 0 ); if( eErr == CE_None && hMaskBand != NULL ) eErr = GPMaskImageData( hMaskBand, pabyMaskLine, iY, nXSize, pafThisLineVal ); } if( eErr != CE_None ) continue; /* -------------------------------------------------------------------- */ /* Determine what polygon the various pixels belong to (redoing */ /* the same thing done in the first pass above). */ /* -------------------------------------------------------------------- */ if( iY == nYSize ) { for( iX = 0; iX < nXSize+2; iX++ ) panThisLineId[iX] = -1; } else if( iY == 0 ) oSecondEnum.ProcessLine( NULL, pafThisLineVal, NULL, panThisLineId+1, nXSize ); else oSecondEnum.ProcessLine( pafLastLineVal, pafThisLineVal, panLastLineId+1, panThisLineId+1, nXSize ); /* -------------------------------------------------------------------- */ /* Add polygon edges to our polygon list for the pixel */ /* boundaries within and above this line. */ /* -------------------------------------------------------------------- */ for( iX = 0; iX < nXSize+1; iX++ ) { AddEdges( panThisLineId, panLastLineId, oFirstEnum.panPolyIdMap, oFirstEnum.pafPolyValue, papoPoly, iX, iY ); } /* -------------------------------------------------------------------- */ /* Periodically we scan out polygons and write out those that */ /* haven't been added to on the last line as we can be sure */ /* they are complete. */ /* -------------------------------------------------------------------- */ if( iY % 8 == 7 ) { for( iX = 0; eErr == CE_None && iX < oSecondEnum.nNextPolygonId; iX++ ) { if( papoPoly[iX] && papoPoly[iX]->nLastLineUpdated < iY-1 ) { if( hMaskBand == NULL || !GDALFloatEquals(papoPoly[iX]->fPolyValue, GP_NODATA_MARKER) ) { eErr = EmitPolygonToLayer( hOutLayer, iPixValField, papoPoly[iX], adfGeoTransform ); } delete papoPoly[iX]; papoPoly[iX] = NULL; } } } /* -------------------------------------------------------------------- */ /* Swap pixel value, and polygon id lines to be ready for the */ /* next line. */ /* -------------------------------------------------------------------- */ float *pafTmp = pafLastLineVal; pafLastLineVal = pafThisLineVal; pafThisLineVal = pafTmp; GInt32 *panTmp = panThisLineId; panThisLineId = panLastLineId; panLastLineId = panTmp; /* -------------------------------------------------------------------- */ /* Report progress, and support interrupts. */ /* -------------------------------------------------------------------- */ if( eErr == CE_None && !pfnProgress( 0.10 + 0.90 * ((iY+1) / (double) nYSize), "", pProgressArg ) ) { CPLError( CE_Failure, CPLE_UserInterrupt, "User terminated" ); eErr = CE_Failure; } } /* -------------------------------------------------------------------- */ /* Make a cleanup pass for all unflushed polygons. */ /* -------------------------------------------------------------------- */ for( iX = 0; eErr == CE_None && iX < oSecondEnum.nNextPolygonId; iX++ ) { if( papoPoly[iX] ) { if( hMaskBand == NULL || !GDALFloatEquals(papoPoly[iX]->fPolyValue, GP_NODATA_MARKER) ) { eErr = EmitPolygonToLayer( hOutLayer, iPixValField, papoPoly[iX], adfGeoTransform ); } delete papoPoly[iX]; papoPoly[iX] = NULL; } } /* -------------------------------------------------------------------- */ /* Cleanup */ /* -------------------------------------------------------------------- */ CPLFree( panThisLineId ); CPLFree( panLastLineId ); CPLFree( pafThisLineVal ); CPLFree( pafLastLineVal ); CPLFree( pabyMaskLine ); CPLFree( papoPoly ); return eErr; #endif // OGR_ENABLED }
void QgsZonalStatistics::statisticsFromMiddlePointTest_improved( void* band, QgsGeometry* poly, int pixelOffsetX, int pixelOffsetY, int nCellsX, int nCellsY, double cellSizeX, double cellSizeY, const QgsRectangle& rasterBBox, double& sum, double& count ) { double cellCenterX, cellCenterY; QgsPoint currentCellCenter; float* scanLine = ( float * ) CPLMalloc( sizeof( float ) * nCellsX ); cellCenterY = rasterBBox.yMaximum() - pixelOffsetY * cellSizeY - cellSizeY / 2; count = 0; sum = 0; for ( int i = 0; i < nCellsY; ++i ) { GDALRasterIO( band, GF_Read, pixelOffsetX, pixelOffsetY + i, nCellsX, 1, scanLine, nCellsX, 1, GDT_Float32, 0, 0 ); cellCenterX = rasterBBox.xMinimum() + pixelOffsetX * cellSizeX + cellSizeX / 2; //do intersection of scanline with geometry GEOSCoordSequence* scanLineSequence = GEOSCoordSeq_create( 2, 2 ); GEOSCoordSeq_setX( scanLineSequence, 0, cellCenterX ); GEOSCoordSeq_setY( scanLineSequence, 0, cellCenterY ); GEOSCoordSeq_setX( scanLineSequence, 1, cellCenterX + nCellsX * cellSizeX ); GEOSCoordSeq_setY( scanLineSequence, 1, cellCenterY ); GEOSGeometry* scanLineGeos = GEOSGeom_createLineString( scanLineSequence ); //todo: delete GEOSGeometry* polyGeos = poly->asGeos(); GEOSGeometry* scanLineIntersection = GEOSIntersection( scanLineGeos, polyGeos ); GEOSGeom_destroy( scanLineGeos ); if ( !scanLineIntersection ) { cellCenterY -= cellSizeY; continue; } //debug //char* scanLineIntersectionType = GEOSGeomType( scanLineIntersection ); int numGeoms = GEOSGetNumGeometries( scanLineIntersection ); if ( numGeoms < 1 ) { GEOSGeom_destroy( scanLineIntersection ); cellCenterY -= cellSizeY; continue; } QList<double> scanLineList; double currentValue; GEOSGeometry* currentGeom = 0; for ( int z = 0; z < numGeoms; ++z ) { if ( numGeoms == 1 ) { currentGeom = scanLineIntersection; } else { currentGeom = GEOSGeom_clone( GEOSGetGeometryN( scanLineIntersection, z ) ); } const GEOSCoordSequence* scanLineCoordSequence = GEOSGeom_getCoordSeq( currentGeom ); if ( !scanLineCoordSequence ) { //error } unsigned int scanLineIntersectionSize; GEOSCoordSeq_getSize( scanLineCoordSequence, &scanLineIntersectionSize ); if ( !scanLineCoordSequence || scanLineIntersectionSize < 2 || ( scanLineIntersectionSize & 1 ) ) { //error } for ( unsigned int k = 0; k < scanLineIntersectionSize; ++k ) { GEOSCoordSeq_getX( scanLineCoordSequence, k, ¤tValue ); scanLineList.push_back( currentValue ); } if ( numGeoms != 1 ) { GEOSGeom_destroy( currentGeom ); } } GEOSGeom_destroy( scanLineIntersection ); qSort( scanLineList ); if ( scanLineList.size() < 1 ) { cellCenterY -= cellSizeY; continue; } int listPlace = -1; for ( int j = 0; j < nCellsX; ++j ) { //currentCellCenter = QgsPoint( cellCenterX, cellCenterY ); //instead of doing a contained test every time, find the place of scanLineList and check if even / odd if ( listPlace >= scanLineList.size() - 1 ) { break; } if ( cellCenterX >= scanLineList.at( listPlace + 1 ) ) { ++listPlace; if ( listPlace >= scanLineList.size() ) { break; } } if ( listPlace >= 0 && listPlace < ( scanLineList.size() - 1 ) && !( listPlace & 1 ) ) { if ( scanLine[j] != mInputNodataValue ) //don't consider nodata values { sum += scanLine[j]; ++count; } } cellCenterX += cellSizeX; } cellCenterY -= cellSizeY; } CPLFree( scanLine ); }
static void DumpBand( GDALDatasetH hBaseDS, GDALRasterBandH hSrcOver, const char *pszName ) { /* -------------------------------------------------------------------- */ /* Get base ds info. */ /* -------------------------------------------------------------------- */ double adfGeoTransform[6]; bool bHaveGT = GDALGetGeoTransform( hBaseDS, adfGeoTransform ) == CE_None; int nOrigXSize = GDALGetRasterXSize( hBaseDS ); int nOrigYSize = GDALGetRasterYSize( hBaseDS ); /* -------------------------------------------------------------------- */ /* Create matching output file. */ /* -------------------------------------------------------------------- */ int nXSize = GDALGetRasterBandXSize( hSrcOver ); int nYSize = GDALGetRasterBandYSize( hSrcOver ); GDALDataType eDT = GDALGetRasterDataType( hSrcOver ); GDALDriverH hDriver = GDALGetDriverByName( "GTiff" ); GDALDatasetH hDstDS = GDALCreate( hDriver, pszName, nXSize, nYSize, 1, eDT, NULL ); if( hDstDS == NULL ) exit( 1 ); /* -------------------------------------------------------------------- */ /* Apply corresponding georeferencing, scaled to size. */ /* -------------------------------------------------------------------- */ if( bHaveGT ) { double adfOvGeoTransform[6]; memcpy( adfOvGeoTransform, adfGeoTransform, sizeof(double) * 6 ); adfOvGeoTransform[1] *= (nOrigXSize / (double) nXSize); adfOvGeoTransform[2] *= (nOrigXSize / (double) nXSize); adfOvGeoTransform[4] *= (nOrigYSize / (double) nYSize); adfOvGeoTransform[5] *= (nOrigYSize / (double) nYSize); GDALSetGeoTransform( hDstDS, adfOvGeoTransform ); GDALSetProjection( hDstDS, GDALGetProjectionRef( hBaseDS ) ); } /* -------------------------------------------------------------------- */ /* Copy over all the image data. */ /* -------------------------------------------------------------------- */ void *pData = CPLMalloc(64 * nXSize); for( int iLine = 0; iLine < nYSize; iLine++ ) { GDALRasterIO( hSrcOver, GF_Read, 0, iLine, nXSize, 1, pData, nXSize, 1, eDT, 0, 0 ); GDALRasterIO( GDALGetRasterBand( hDstDS, 1 ), GF_Write, 0, iLine, nXSize, 1, pData, nXSize, 1, eDT, 0, 0 ); } CPLFree( pData ); GDALClose( hDstDS ); }