Raster* import_raster(string raster_filename, int band_number) { GDALAllRegister(); GDALDataset* poDataset = (GDALDataset *) GDALOpen( raster_filename.c_str(), GA_ReadOnly ); if( poDataset == NULL ) { cerr << "Error: Could not open raster data file" << endl; exit(1); } fprintf(stderr, "Driver: %s/%s\n", poDataset->GetDriver()->GetDescription(), poDataset->GetDriver()->GetMetadataItem( GDAL_DMD_LONGNAME ) ); fprintf(stderr, "Size is %dx%dx%d\n", poDataset->GetRasterXSize(), poDataset->GetRasterYSize(), poDataset->GetRasterCount() ); if( poDataset->GetProjectionRef() != NULL ) cerr << "Projection is `" << poDataset->GetProjectionRef() << "'" << endl;; GDALRasterBand* poBand = poDataset->GetRasterBand( band_number ); int nBlockXSize, nBlockYSize; poBand->GetBlockSize( &nBlockXSize, &nBlockYSize ); fprintf(stderr, "Block=%dx%d Type=%s, ColorInterp=%s\n", nBlockXSize, nBlockYSize, GDALGetDataTypeName(poBand->GetRasterDataType()), GDALGetColorInterpretationName( poBand->GetColorInterpretation()) ); Raster* raster = extract_raster_attributes( poDataset ); raster->band = poBand; return raster; }
void DemReader::MetaDataInfo(GDALDataset* gdalDataset, MapControllerPtr mapController) { FileMetaData* header = mapController->GetMapModel()->GetMetaData(); header->driverDesc = gdalDataset->GetDriver()->GetDescription(); header->driverMetaData = gdalDataset->GetDriver()->GetMetadataItem(GDAL_DMD_LONGNAME); Log::Inst().Write("Driver: " + header->driverDesc + " \\ " + header->driverMetaData); header->xSize = gdalDataset->GetRasterXSize(); header->ySize = gdalDataset->GetRasterYSize(); header->bands = gdalDataset->GetRasterCount(); Log::Inst().Write("Size (x,y): " + StringTools::ToString(header->xSize) + ", " + StringTools::ToString(header->ySize)); Log::Inst().Write("Bands: " + StringTools::ToString(header->bands)); header->projection = std::string(gdalDataset->GetProjectionRef()); Log::Inst().Write("Projection: " + header->projection); double adfGeoTransform[6]; gdalDataset->GetGeoTransform( adfGeoTransform ); header->originX = adfGeoTransform[0]; header->originY = adfGeoTransform[3]; Log::Inst().Write("Origin: " + StringTools::ToString(adfGeoTransform[0]) + ", " + StringTools::ToString(adfGeoTransform[3])); header->pixelSizeX = adfGeoTransform[1]; header->pixelSizeY = adfGeoTransform[5]; Log::Inst().Write("Pixel Size: " + StringTools::ToString(adfGeoTransform[1]) + ", " + StringTools::ToString(adfGeoTransform[5])); GDALRasterBand* gdalBand = gdalDataset->GetRasterBand(1); int nBlockXSize, nBlockYSize; gdalBand->GetBlockSize(&nBlockXSize, &nBlockYSize); header->dataType = std::string(GDALGetDataTypeName(gdalBand->GetRasterDataType())); Log::Inst().Write("Block, Type: " + StringTools::ToString(nBlockXSize) + ", " + StringTools::ToString(nBlockYSize) + ", " + std::string(header->dataType)); header->colourInterpretation = std::string(GDALGetColorInterpretationName(gdalBand->GetColorInterpretation())); Log::Inst().Write("Color Interpretation: " + header->colourInterpretation); header->extents.x = adfGeoTransform[0]; header->extents.y = adfGeoTransform[3] + gdalBand->GetYSize()*adfGeoTransform[5]; Log::Inst().Write("Lower, Left (x,y): " + StringTools::ToString(header->extents.x) + ", " + StringTools::ToString(header->extents.y)); header->extents.dx = adfGeoTransform[0]+gdalBand->GetXSize()*adfGeoTransform[1]; header->extents.dy = adfGeoTransform[3]; Log::Inst().Write("Upper, Right (x,y): " + StringTools::ToString(header->extents.dx) + ", " + StringTools::ToString(header->extents.dy)); Log::Inst().Write(""); }
TSXRasterBand::TSXRasterBand( TSXDataset *poDS, GDALDataType eDataType, ePolarization ePol, GDALDataset *poBand ) { this->poDS = poDS; this->eDataType = eDataType; this->ePol = ePol; switch (ePol) { case HH: SetMetadataItem( "POLARIMETRIC_INTERP", "HH" ); break; case HV: SetMetadataItem( "POLARIMETRIC_INTERP", "HV" ); break; case VH: SetMetadataItem( "POLARIMETRIC_INTERP", "VH" ); break; case VV: SetMetadataItem( "POLARIMETRIC_INTERP", "VV" ); break; } /* now setup the actual raster reader */ this->poBand = poBand; GDALRasterBand *poSrcBand = poBand->GetRasterBand( 1 ); poSrcBand->GetBlockSize( &nBlockXSize, &nBlockYSize ); }
TSXRasterBand::TSXRasterBand( TSXDataset *poDSIn, GDALDataType eDataTypeIn, ePolarization ePolIn, GDALDataset *poBandIn ) : poBand(poBandIn), ePol(ePolIn) { poDS = poDSIn; eDataType = eDataTypeIn; switch (ePol) { case HH: SetMetadataItem( "POLARIMETRIC_INTERP", "HH" ); break; case HV: SetMetadataItem( "POLARIMETRIC_INTERP", "HV" ); break; case VH: SetMetadataItem( "POLARIMETRIC_INTERP", "VH" ); break; case VV: SetMetadataItem( "POLARIMETRIC_INTERP", "VV" ); break; } /* now setup the actual raster reader */ GDALRasterBand *poSrcBand = poBandIn->GetRasterBand( 1 ); poSrcBand->GetBlockSize( &nBlockXSize, &nBlockYSize ); }
CALSRasterBand( CALSDataset* poDSIn ) { poDS = poDSIn; poUnderlyingBand = poDSIn->poUnderlyingDS->GetRasterBand(1); poUnderlyingBand->GetBlockSize(&nBlockXSize, &nBlockYSize); nBand = 1; eDataType = GDT_Byte; }
bool getRawValuesFromFile(string fname,vector<vector<float>>& vecs) { //vector<float> temp = vector<float>() GDALDataset *poDataset; GDALAllRegister(); poDataset= (GDALDataset*) GDALOpen(fname.c_str(),GA_ReadOnly); if(poDataset == NULL) { cout << "OUCH!" << endl; return false; } cout << "Data size: " << GDALGetRasterXSize(poDataset) << " " << GDALGetRasterYSize(poDataset) << endl; GDALRasterBand *poBand; int nBlockXSize, nBlockYSize; int bGotMin, bGotMax; double adfMinMax[2]; poBand = poDataset->GetRasterBand( 1 ); poBand->GetBlockSize( &nBlockXSize, &nBlockYSize ); printf( "Block=%dx%d Type=%s, ColorInterp=%s\n", nBlockXSize, nBlockYSize, GDALGetDataTypeName(poBand->GetRasterDataType()), GDALGetColorInterpretationName( poBand->GetColorInterpretation()) ); adfMinMax[0] = poBand->GetMinimum( &bGotMin ); adfMinMax[1] = poBand->GetMaximum( &bGotMax ); if( ! (bGotMin && bGotMax) ) GDALComputeRasterMinMax((GDALRasterBandH)poBand, TRUE, adfMinMax); int width = poBand->GetXSize(); int height = poBand->GetYSize(); int bands = poDataset->GetRasterCount(); float *pafScanline; std::cout << "Before allocation" << adfMinMax[0] << " " << adfMinMax[1] << endl; int dsize = 256; pafScanline = (float *) CPLMalloc(sizeof(float)*width*height); vector<vector<float>> out = vector<vector<float>>(height,vector<float> (width,0)); poBand->RasterIO(GF_Read,0,0,width,height,pafScanline,width,height,GDT_Float32,0,0); cout << "After allocation" << endl; for(int i = 0; i < height; i++) { for(int j = 0; j < width; j++) { //cout << i << j << endl << pafS; out[i][j] = pafScanline[i*width+j]; } } CPLFree(pafScanline); //for(auto i : out) //for(auto j : i) // cout << j << endl; cout << "After allocation" << endl; vecs = out; return true; }
int main() { GDALDataset *poDataset; GDALAllRegister(); poDataset = (GDALDataset *) GDALOpen( "GE01.tif", GA_ReadOnly ); printf("Working! \n"); if( poDataset != NULL ){ //Get Dataset Information double adfGeoTransform[6]; printf( "Driver: %s/%s\n", poDataset->GetDriver()->GetDescription(), poDataset->GetDriver()->GetMetadataItem( GDAL_DMD_LONGNAME ) ); printf( "Size is %dx%dx%d\n", poDataset->GetRasterXSize(), poDataset->GetRasterYSize(), poDataset->GetRasterCount() ); if( poDataset->GetProjectionRef() != NULL ) printf( "Projection is `%s'\n", poDataset->GetProjectionRef() ); if( poDataset->GetGeoTransform( adfGeoTransform ) == CE_None ){ printf( "Origin = (%.6f,%.6f)\n", adfGeoTransform[0], adfGeoTransform[3] ); printf( "Pixel Size = (%.6f,%.6f)\n", adfGeoTransform[1], adfGeoTransform[5] ); } //Fetch Raster Band GDALRasterBand *poBand; int nBlockXSize, nBlockYSize; int bGotMin, bGotMax; double adfMinMax[2]; poBand = poDataset->GetRasterBand( 1 ); poBand->GetBlockSize( &nBlockXSize, &nBlockYSize ); printf( "Block=%dx%d Type=%s, ColorInterp=%s\n", nBlockXSize, nBlockYSize, GDALGetDataTypeName(poBand->GetRasterDataType()), GDALGetColorInterpretationName( poBand->GetColorInterpretation()) ); adfMinMax[0] = poBand->GetMinimum( &bGotMin ); adfMinMax[1] = poBand->GetMaximum( &bGotMax ); if( ! (bGotMin && bGotMax) ) GDALComputeRasterMinMax((GDALRasterBandH)poBand, TRUE, adfMinMax); printf( "Min=%.3fd, Max=%.3f\n", adfMinMax[0], adfMinMax[1] ); if( poBand->GetOverviewCount() > 0 ) printf( "Band has %d overviews.\n", poBand->GetOverviewCount() ); if( poBand->GetColorTable() != NULL ) printf( "Band has a color table with %d entries.\n", poBand->GetColorTable()->GetColorEntryCount() ); //Close Dataset GDALClose(poDataset); //Exit return 0; } }
int GDAL_EDBFile::ReadBlock( int channel, int block_index, void *buffer, int win_xoff, int win_yoff, int win_xsize, int win_ysize ) { GDALRasterBand *poBand = poDS->GetRasterBand(channel); int nBlockXSize, nBlockYSize; int nBlockX, nBlockY; int nWidthInBlocks; int nPixelOffset; int nLineOffset; if( GetType(channel) == CHN_UNKNOWN ) { ThrowPCIDSKException("%s channel type not supported for PCIDSK access.", GDALGetDataTypeName(poBand->GetRasterDataType()) ); } poBand->GetBlockSize( &nBlockXSize, &nBlockYSize ); nWidthInBlocks = (poBand->GetXSize() + nBlockXSize - 1) / nBlockXSize; nBlockX = block_index % nWidthInBlocks; nBlockY = block_index / nWidthInBlocks; nPixelOffset = GDALGetDataTypeSize(poBand->GetRasterDataType()) / 8; nLineOffset = win_xsize * nPixelOffset; /* -------------------------------------------------------------------- */ /* Are we reading a partial block at the edge of the database? */ /* If so, ensure we don't read off the database. */ /* -------------------------------------------------------------------- */ if( nBlockX * nBlockXSize + win_xoff + win_xsize > poBand->GetXSize() ) win_xsize = poBand->GetXSize() - nBlockX * nBlockXSize - win_xoff; if( nBlockY * nBlockYSize + win_yoff + win_ysize > poBand->GetYSize() ) win_ysize = poBand->GetYSize() - nBlockY * nBlockYSize - win_yoff; CPLErr eErr = poBand->RasterIO( GF_Read, nBlockX * nBlockXSize + win_xoff, nBlockY * nBlockYSize + win_yoff, win_xsize, win_ysize, buffer, win_xsize, win_ysize, poBand->GetRasterDataType(), nPixelOffset, nLineOffset, NULL ); if( eErr != CE_None ) { ThrowPCIDSKException( "%s", CPLGetLastErrorMsg() ); } return 1; }
SEXP RGDAL_GetRasterBlockSize(SEXP rasterObj) { GDALRasterBand *raster = getGDALRasterPtr(rasterObj); SEXP blockSize = allocVector(INTSXP, 2); raster->GetBlockSize(INTEGER(blockSize) + 1, INTEGER(blockSize)); return(blockSize); }
int GDAL_EDBFile::WriteBlock( int channel, int block_index, void *buffer) { GDALRasterBand *poBand = poDS->GetRasterBand(channel); int nBlockXSize, nBlockYSize; int nBlockX, nBlockY; int nWinXSize, nWinYSize; int nWidthInBlocks; if( GetType(channel) == CHN_UNKNOWN ) { ThrowPCIDSKException("%s channel type not supported for PCIDSK access.", GDALGetDataTypeName(poBand->GetRasterDataType()) ); } poBand->GetBlockSize( &nBlockXSize, &nBlockYSize ); nWidthInBlocks = (poBand->GetXSize() + nBlockXSize - 1) / nBlockXSize; nBlockX = block_index % nWidthInBlocks; nBlockY = block_index / nWidthInBlocks; /* -------------------------------------------------------------------- */ /* Are we reading a partial block at the edge of the database? */ /* If so, ensure we don't read off the database. */ /* -------------------------------------------------------------------- */ if( nBlockX * nBlockXSize + nBlockXSize > poBand->GetXSize() ) nWinXSize = poBand->GetXSize() - nBlockX * nBlockXSize; else nWinXSize = nBlockXSize; if( nBlockY * nBlockYSize + nBlockYSize > poBand->GetYSize() ) nWinYSize = poBand->GetYSize() - nBlockY * nBlockYSize; else nWinYSize = nBlockYSize; CPLErr eErr = poBand->RasterIO( GF_Write, nBlockX * nBlockXSize, nBlockY * nBlockYSize, nWinXSize, nWinYSize, buffer, nWinXSize, nWinYSize, poBand->GetRasterDataType(), 0, 0, NULL ); if( eErr != CE_None ) { ThrowPCIDSKException( "%s", CPLGetLastErrorMsg() ); } return 1; }
SEXP RGDAL_GetRasterBlockSize(SEXP rasterObj) { GDALRasterBand *raster = getGDALRasterPtr(rasterObj); SEXP blockSize = allocVector(INTSXP, 2); installErrorHandler(); raster->GetBlockSize(INTEGER(blockSize) + 1, INTEGER(blockSize)); uninstallErrorHandlerAndTriggerError(); return(blockSize); }
SAFERasterBand::SAFERasterBand( SAFEDataset *poDSIn, GDALDataType eDataTypeIn, const char *pszSwath, const char *pszPolarisation, GDALDataset *poBandFileIn ) : poBandFile(poBandFileIn) { poDS = poDSIn; GDALRasterBand *poSrcBand = poBandFile->GetRasterBand( 1 ); poSrcBand->GetBlockSize( &nBlockXSize, &nBlockYSize ); eDataType = eDataTypeIn; if( *pszSwath != '\0' ) { SetMetadataItem( "SWATH", pszSwath ); } if( *pszPolarisation != '\0' ) { SetMetadataItem( "POLARISATION", pszPolarisation ); } }
static int ProxyMain( int argc, char ** argv ) { // GDALDatasetH hDataset, hOutDS; // int i; // int nRasterXSize, nRasterYSize; // const char *pszSource=NULL, *pszDest=NULL, *pszFormat = "GTiff"; // GDALDriverH hDriver; // int *panBandList = NULL; /* negative value of panBandList[i] means mask band of ABS(panBandList[i]) */ // int nBandCount = 0, bDefBands = TRUE; // double adfGeoTransform[6]; // GDALDataType eOutputType = GDT_Unknown; // int nOXSize = 0, nOYSize = 0; // char *pszOXSize=NULL, *pszOYSize=NULL; // char **papszCreateOptions = NULL; // int anSrcWin[4], bStrict = FALSE; // const char *pszProjection; // int bScale = FALSE, bHaveScaleSrc = FALSE, bUnscale=FALSE; // double dfScaleSrcMin=0.0, dfScaleSrcMax=255.0; // double dfScaleDstMin=0.0, dfScaleDstMax=255.0; // double dfULX, dfULY, dfLRX, dfLRY; // char **papszMetadataOptions = NULL; // char *pszOutputSRS = NULL; // int bQuiet = FALSE, bGotBounds = FALSE; // GDALProgressFunc pfnProgress = GDALTermProgress; // int nGCPCount = 0; // GDAL_GCP *pasGCPs = NULL; // int iSrcFileArg = -1, iDstFileArg = -1; // int bCopySubDatasets = FALSE; // double adfULLR[4] = { 0,0,0,0 }; // int bSetNoData = FALSE; // int bUnsetNoData = FALSE; // double dfNoDataReal = 0.0; // int nRGBExpand = 0; // int bParsedMaskArgument = FALSE; // int eMaskMode = MASK_AUTO; // int nMaskBand = 0; /* negative value means mask band of ABS(nMaskBand) */ // int bStats = FALSE, bApproxStats = FALSE; // GDALDatasetH hDataset, hOutDS; GDALDataset *hDataset = NULL; GDALDataset *hOutDS = NULL; int i; int nRasterXSize, nRasterYSize; const char *pszSource=NULL, *pszDest=NULL, *pszFormat = "GTiff"; // GDALDriverH hDriver; GDALDriver *hDriver; GDALDataType eOutputType = GDT_Unknown; char **papszCreateOptions = NULL; int bStrict = FALSE; int bQuiet = FALSE; GDALProgressFunc pfnProgress = GDALTermProgress; int iSrcFileArg = -1, iDstFileArg = -1; int bSetNoData = FALSE; int bUnsetNoData = FALSE; double dfNoDataReal = 0.0; GDALRasterBand *inBand = NULL; GDALRasterBand *outBand = NULL; GByte *srcBuffer; double adfGeoTransform[6]; int nRasterCount; int bReplaceIds = FALSE; const char *pszReplaceFilename = NULL; const char *pszReplaceFieldFrom = NULL; const char *pszReplaceFieldTo = NULL; std::map<GByte,GByte> mReplaceTable; /* Check strict compilation and runtime library version as we use C++ API */ if (! GDAL_CHECK_VERSION(argv[0])) exit(1); /* Must process GDAL_SKIP before GDALAllRegister(), but we can't call */ /* GDALGeneralCmdLineProcessor before it needs the drivers to be registered */ /* for the --format or --formats options */ for( i = 1; i < argc; i++ ) { if( EQUAL(argv[i],"--config") && i + 2 < argc && EQUAL(argv[i + 1], "GDAL_SKIP") ) { CPLSetConfigOption( argv[i+1], argv[i+2] ); i += 2; } } /* -------------------------------------------------------------------- */ /* Register standard GDAL drivers, and process generic GDAL */ /* command options. */ /* -------------------------------------------------------------------- */ GDALAllRegister(); argc = GDALGeneralCmdLineProcessor( argc, &argv, 0 ); if( argc < 1 ) exit( -argc ); /* -------------------------------------------------------------------- */ /* Handle command line arguments. */ /* -------------------------------------------------------------------- */ for( i = 1; i < argc; i++ ) { if( EQUAL(argv[i],"-of") && i < argc-1 ) pszFormat = argv[++i]; else if( EQUAL(argv[i],"-q") || EQUAL(argv[i],"-quiet") ) { bQuiet = TRUE; pfnProgress = GDALDummyProgress; } else if( EQUAL(argv[i],"-ot") && i < argc-1 ) { int iType; for( iType = 1; iType < GDT_TypeCount; iType++ ) { if( GDALGetDataTypeName((GDALDataType)iType) != NULL && EQUAL(GDALGetDataTypeName((GDALDataType)iType), argv[i+1]) ) { eOutputType = (GDALDataType) iType; } } if( eOutputType == GDT_Unknown ) { printf( "Unknown output pixel type: %s\n", argv[i+1] ); Usage(); GDALDestroyDriverManager(); exit( 2 ); } i++; } else if( EQUAL(argv[i],"-not_strict") ) bStrict = FALSE; else if( EQUAL(argv[i],"-strict") ) bStrict = TRUE; else if( EQUAL(argv[i],"-a_nodata") && i < argc - 1 ) { if (EQUAL(argv[i+1], "none")) { bUnsetNoData = TRUE; } else { bSetNoData = TRUE; dfNoDataReal = CPLAtofM(argv[i+1]); } i += 1; } else if( EQUAL(argv[i],"-co") && i < argc-1 ) { papszCreateOptions = CSLAddString( papszCreateOptions, argv[++i] ); } else if( EQUAL(argv[i],"-replace_ids") && i < argc-3 ) { bReplaceIds = TRUE; pszReplaceFilename = (argv[++i]); pszReplaceFieldFrom = (argv[++i]); pszReplaceFieldTo = (argv[++i]); } else if( argv[i][0] == '-' ) { printf( "Option %s incomplete, or not recognised.\n\n", argv[i] ); Usage(); GDALDestroyDriverManager(); exit( 2 ); } else if( pszSource == NULL ) { iSrcFileArg = i; pszSource = argv[i]; } else if( pszDest == NULL ) { pszDest = argv[i]; iDstFileArg = i; } else { printf( "Too many command options.\n\n" ); Usage(); GDALDestroyDriverManager(); exit( 2 ); } } if( pszDest == NULL ) { Usage(); GDALDestroyDriverManager(); exit( 10 ); } if ( strcmp(pszSource, pszDest) == 0) { fprintf(stderr, "Source and destination datasets must be different.\n"); GDALDestroyDriverManager(); exit( 1 ); } if( bReplaceIds ) { if ( ! pszReplaceFilename | ! pszReplaceFieldFrom | ! pszReplaceFieldTo ) Usage(); // FILE * ifile; // if ( (ifile = fopen(pszReplaceFilename, "r")) == NULL ) // { // fprintf( stderr, "Replace file %s cannot be read!\n\n", pszReplaceFilename ); // Usage(); // } // else // fclose( ifile ); mReplaceTable = InitReplaceTable(pszReplaceFilename, pszReplaceFieldFrom, pszReplaceFieldTo); printf("TMP ET size: %d\n",(int)mReplaceTable.size()); } /* -------------------------------------------------------------------- */ /* Attempt to open source file. */ /* -------------------------------------------------------------------- */ // hDataset = GDALOpenShared( pszSource, GA_ReadOnly ); hDataset = (GDALDataset *) GDALOpen(pszSource, GA_ReadOnly ); if( hDataset == NULL ) { fprintf( stderr, "GDALOpen failed - %d\n%s\n", CPLGetLastErrorNo(), CPLGetLastErrorMsg() ); GDALDestroyDriverManager(); exit( 1 ); } /* -------------------------------------------------------------------- */ /* Collect some information from the source file. */ /* -------------------------------------------------------------------- */ // nRasterXSize = GDALGetRasterXSize( hDataset ); // nRasterYSize = GDALGetRasterYSize( hDataset ); nRasterXSize = hDataset->GetRasterXSize(); nRasterYSize = hDataset->GetRasterYSize(); if( !bQuiet ) printf( "Input file size is %d, %d\n", nRasterXSize, nRasterYSize ); /* -------------------------------------------------------------------- */ /* Find the output driver. */ /* -------------------------------------------------------------------- */ hDriver = GetGDALDriverManager()->GetDriverByName( pszFormat ); if( hDriver == NULL ) { int iDr; printf( "Output driver `%s' not recognised.\n", pszFormat ); printf( "The following format drivers are configured and support output:\n" ); for( iDr = 0; iDr < GDALGetDriverCount(); iDr++ ) { GDALDriverH hDriver = GDALGetDriver(iDr); if( GDALGetMetadataItem( hDriver, GDAL_DCAP_CREATE, NULL ) != NULL || GDALGetMetadataItem( hDriver, GDAL_DCAP_CREATECOPY, NULL ) != NULL ) { printf( " %s: %s\n", GDALGetDriverShortName( hDriver ), GDALGetDriverLongName( hDriver ) ); } } printf( "\n" ); Usage(); GDALClose( (GDALDatasetH) hDataset ); GDALDestroyDriverManager(); CSLDestroy( argv ); CSLDestroy( papszCreateOptions ); exit( 1 ); } /* -------------------------------------------------------------------- */ /* Create Dataset and copy info */ /* -------------------------------------------------------------------- */ nRasterCount = hDataset->GetRasterCount(); printf("creating\n"); hOutDS = hDriver->Create( pszDest, nRasterXSize, nRasterYSize, nRasterCount, GDT_Byte, papszCreateOptions); printf("created\n"); if( hOutDS != NULL ) { hDataset->GetGeoTransform( adfGeoTransform); hOutDS->SetGeoTransform( adfGeoTransform ); hOutDS->SetProjection( hDataset->GetProjectionRef() ); /* ==================================================================== */ /* Process all bands. */ /* ==================================================================== */ // if (0) for( i = 1; i < nRasterCount+1; i++ ) { inBand = hDataset->GetRasterBand( i ); // hOutDS->AddBand(GDT_Byte); outBand = hOutDS->GetRasterBand( i ); CopyBandInfo( inBand, outBand, 0, 1, 1 ); nRasterXSize = inBand->GetXSize( ); nRasterYSize = inBand->GetYSize( ); GByte old_value, new_value; // char tmp_value[255]; // const char *tmp_value2; std::map<GByte,GByte>::iterator it; //tmp int nXBlocks, nYBlocks, nXBlockSize, nYBlockSize; int iXBlock, iYBlock; inBand->GetBlockSize( &nXBlockSize, &nYBlockSize ); // nXBlockSize = nXBlockSize / 4; // nYBlockSize = nYBlockSize / 4; nXBlocks = (inBand->GetXSize() + nXBlockSize - 1) / nXBlockSize; nYBlocks = (inBand->GetYSize() + nYBlockSize - 1) / nYBlockSize; printf("blocks: %d %d %d %d\n",nXBlockSize,nYBlockSize,nXBlocks,nYBlocks); printf("TMP ET creating raster %d x %d\n",nRasterXSize, nRasterYSize); // srcBuffer = new GByte[nRasterXSize * nRasterYSize]; // printf("reading\n"); // inBand->RasterIO( GF_Read, 0, 0, nRasterXSize, nRasterYSize, // srcBuffer, nRasterXSize, nRasterYSize, GDT_Byte, // 0, 0 ); // srcBuffer = (GByte *) CPLMalloc(sizeof(GByte)*nRasterXSize * nRasterYSize); srcBuffer = (GByte *) CPLMalloc(nXBlockSize * nYBlockSize); for( iYBlock = 0; iYBlock < nYBlocks; iYBlock++ ) { // if(iYBlock%1000 == 0) // printf("iXBlock: %d iYBlock: %d\n",iXBlock,iYBlock); if(iYBlock%1000 == 0) printf("iYBlock: %d / %d\n",iYBlock,nYBlocks); for( iXBlock = 0; iXBlock < nXBlocks; iXBlock++ ) { int nXValid, nYValid; // inBand->ReadBlock( iXBlock, iYBlock, srcBuffer ); inBand->RasterIO( GF_Read, iXBlock, iYBlock, nXBlockSize, nYBlockSize, srcBuffer, nXBlockSize, nYBlockSize, GDT_Byte, 0, 0 ); // Compute the portion of the block that is valid // for partial edge blocks. if( (iXBlock+1) * nXBlockSize > inBand->GetXSize() ) nXValid = inBand->GetXSize() - iXBlock * nXBlockSize; else nXValid = nXBlockSize; if( (iYBlock+1) * nYBlockSize > inBand->GetYSize() ) nYValid = inBand->GetYSize() - iYBlock * nYBlockSize; else nYValid = nYBlockSize; // printf("iXBlock: %d iYBlock: %d read, nXValid: %d nYValid: %d\n",iXBlock,iYBlock,nXValid, nYValid); // if(0) if ( pszReplaceFilename ) { for( int iY = 0; iY < nYValid; iY++ ) { for( int iX = 0; iX < nXValid; iX++ ) { // panHistogram[pabyData[iX + iY * nXBlockSize]] += 1; old_value = new_value = srcBuffer[iX + iY * nXBlockSize]; // sprintf(tmp_value,"%d",old_value); it = mReplaceTable.find(old_value); if ( it != mReplaceTable.end() ) new_value = it->second; if ( old_value != new_value ) { srcBuffer[iX + iY * nXBlockSize] = new_value; // printf("old_value %d new_value %d final %d\n",old_value,new_value, srcBuffer[iX + iY * nXBlockSize]); } // tmp_value2 = CSVGetField( pszReplaceFilename,pszReplaceFieldFrom, // tmp_value, CC_Integer, pszReplaceFieldTo); // if( tmp_value2 != NULL ) // { // new_value = atoi(tmp_value2); // } // new_value = old_value +1; // } } } // printf("writing\n"); // outBand->WriteBlock( iXBlock, iYBlock, srcBuffer ); outBand->RasterIO( GF_Write, iXBlock, iYBlock, nXBlockSize, nYBlockSize, srcBuffer, nXBlockSize, nYBlockSize, GDT_Byte, 0, 0 ); // printf("wrote\n"); } } CPLFree(srcBuffer); printf("read\n"); printf("mod\n"); // if ( pszReplaceFilename ) // { // GByte old_value, new_value; // // char tmp_value[255]; // // const char *tmp_value2; // std::map<GByte,GByte>::iterator it; // for ( int j=0; j<nRasterXSize*nRasterYSize; j++ ) // { // old_value = new_value = srcBuffer[j]; // // sprintf(tmp_value,"%d",old_value); // it = mReplaceTable.find(old_value); // if ( it != mReplaceTable.end() ) new_value = it->second; // // tmp_value2 = CSVGetField( pszReplaceFilename,pszReplaceFieldFrom, // // tmp_value, CC_Integer, pszReplaceFieldTo); // // if( tmp_value2 != NULL ) // // { // // new_value = atoi(tmp_value2); // // } // // new_value = old_value +1; // if ( old_value != new_value ) srcBuffer[j] = new_value; // // printf("old_value %d new_value %d final %d\n",old_value,new_value, srcBuffer[j]); // } // printf("writing\n"); // outBand->RasterIO( GF_Write, 0, 0, nRasterXSize, nRasterYSize, // srcBuffer, nRasterXSize, nRasterYSize, GDT_Byte, // 0, 0 ); // printf("wrote\n"); // delete [] srcBuffer; // } } } if( hOutDS != NULL ) GDALClose( (GDALDatasetH) hOutDS ); if( hDataset != NULL ) GDALClose( (GDALDatasetH) hDataset ); GDALDumpOpenDatasets( stderr ); // GDALDestroyDriverManager(); CSLDestroy( argv ); CSLDestroy( papszCreateOptions ); return hOutDS == NULL; }
T* GISToFloatArray(char* fname, int interpWidth, int interpHeight) { // Important note ------ Gdal considers images to be north up // the origin of datasets takes place in the upper-left or North-West corner. // Now to create a GDAL dataset // auto ds = ((GDALDataset*) GDALOpen(fname,GA_ReadOnly)); GDALDataset* ds = ((GDALDataset*) GDALOpen(fname,GA_ReadOnly)); if(ds == NULL) { return NULL; } // Creating a Raster band variable // A band represents one whole dataset within a dataset // in your case your files have one band. GDALRasterBand *poBand; int nBlockXSize, nBlockYSize; int bGotMin, bGotMax; double adfMinMax[2]; // Assign the band poBand = ds->GetRasterBand( 1 ); poBand->GetBlockSize( &nBlockXSize, &nBlockYSize ); // find the min and max adfMinMax[0] = poBand->GetMinimum( &bGotMin ); adfMinMax[1] = poBand->GetMaximum( &bGotMax ); if( ! (bGotMin && bGotMax) ) GDALComputeRasterMinMax((GDALRasterBandH)poBand, TRUE, adfMinMax); int min = adfMinMax[0]; int max = adfMinMax[1]; // get the width and height of the band or dataset int width = poBand->GetXSize(); int height = poBand->GetYSize(); // GDAL can handle files that have multiple datasets jammed witin it int bands = ds->GetRasterCount(); // the float variable to hold the DEM! T *pafScanline; // std::cout << "Min: " << adfMinMax[0] << " Max: " << adfMinMax[1] << endl; int dsize = 256; // pafScanline = (T *) CPLMalloc(sizeof(T)*width*height); pafScanline = (T *) CPLMalloc(sizeof(T)*interpWidth*interpHeight); // Lets acquire the data. ..... this funciton will interpolate for you // poBand->RasterIO(GF_Read,0,0,width,height,pafScanline,width,height,GDT_Float32,0,0); poBand->RasterIO(GF_Read,0,0,width,height,pafScanline,interpWidth,interpHeight,GDT_Float32,0,0); // chage these two to interpolate automatically ^ ^ // The Geotransform gives information on where a dataset is located in the world // and the resolution. // for more information look at http://www.gdal.org/gdal_datamodel.html double geot[6]; ds->GetGeoTransform(geot); // Get the x resolution per pixel(south and west) and y resolution per pixel (north and south) // float xres = geot[1]; // float yres = geot[5]; // string proj; // proj = string(ds->GetProjectionRef()); // You can get the projection string // The projection gives information about the coordinate system a dataset is in // This is important to allow other GIS softwares to place datasets into the same // coordinate space // char* test = &proj[0]; // The origin of the dataset // float startx = geot[0]; // east - west coord. // float starty = geot[3]; // north - south coord. // here is some code that I used to push that 1D array into a 2D array // I believe this puts everything in the correct order.... /*for(int i = 0; i < hsize; i++) { for(int j = 0; j < wsize; j++) { //cout << i << j << endl << pafS; vecs[i][j] = pafScanline[((int)i)*(int)wsize+((int)j)]; if(vecs[i][j]>0 && vecs[i][j] > max) { max = vecs[i][j]; } if(vecs[i][j]>0 && vecs[i][j] < min) { min = vecs[i][j]; } } }*/ //CPLFree(pafScanline); return pafScanline; }
CC_FILE_ERROR RasterGridFilter::loadFile(QString filename, ccHObject& container, bool alwaysDisplayLoadDialog/*=true*/, bool* coordinatesShiftEnabled/*=0*/, CCVector3d* coordinatesShift/*=0*/) { GDALAllRegister(); ccLog::PrintDebug("(GDAL drivers: %i)", GetGDALDriverManager()->GetDriverCount()); GDALDataset* poDataset = static_cast<GDALDataset*>(GDALOpen( qPrintable(filename), GA_ReadOnly )); if( poDataset != NULL ) { ccLog::Print(QString("Raster file: '%1'").arg(filename)); ccLog::Print( "Driver: %s/%s", poDataset->GetDriver()->GetDescription(), poDataset->GetDriver()->GetMetadataItem( GDAL_DMD_LONGNAME ) ); int rasterCount = poDataset->GetRasterCount(); int rasterX = poDataset->GetRasterXSize(); int rasterY = poDataset->GetRasterYSize(); ccLog::Print( "Size is %dx%dx%d", rasterX, rasterY, rasterCount ); ccPointCloud* pc = new ccPointCloud(); if (!pc->reserve(static_cast<unsigned>(rasterX * rasterY))) { delete pc; return CC_FERR_NOT_ENOUGH_MEMORY; } if( poDataset->GetProjectionRef() != NULL ) ccLog::Print( "Projection is `%s'", poDataset->GetProjectionRef() ); double adfGeoTransform[6] = { 0, //top left x 1, //w-e pixel resolution (can be negative) 0, //0 0, //top left y 0, //0 1 //n-s pixel resolution (can be negative) }; if( poDataset->GetGeoTransform( adfGeoTransform ) == CE_None ) { ccLog::Print( "Origin = (%.6f,%.6f)", adfGeoTransform[0], adfGeoTransform[3] ); ccLog::Print( "Pixel Size = (%.6f,%.6f)", adfGeoTransform[1], adfGeoTransform[5] ); } if (adfGeoTransform[1] == 0 || adfGeoTransform[5] == 0) { ccLog::Warning("Invalid pixel size! Forcing it to (1,1)"); adfGeoTransform[1] = adfGeoTransform[5] = 1; } CCVector3d origin( adfGeoTransform[0], adfGeoTransform[3], 0.0 ); CCVector3d Pshift(0,0,0); //check for 'big' coordinates { bool shiftAlreadyEnabled = (coordinatesShiftEnabled && *coordinatesShiftEnabled && coordinatesShift); if (shiftAlreadyEnabled) Pshift = *coordinatesShift; bool applyAll = false; if ( sizeof(PointCoordinateType) < 8 && ccCoordinatesShiftManager::Handle(origin,0,alwaysDisplayLoadDialog,shiftAlreadyEnabled,Pshift,0,&applyAll)) { pc->setGlobalShift(Pshift); ccLog::Warning("[RasterFilter::loadFile] Raster has been recentered! Translation: (%.2f,%.2f,%.2f)",Pshift.x,Pshift.y,Pshift.z); //we save coordinates shift information if (applyAll && coordinatesShiftEnabled && coordinatesShift) { *coordinatesShiftEnabled = true; *coordinatesShift = Pshift; } } } //create blank raster 'grid' { double z = 0.0 /*+ Pshift.z*/; for (int j=0; j<rasterY; ++j) { double y = adfGeoTransform[3] + static_cast<double>(j) * adfGeoTransform[5] + Pshift.y; CCVector3 P( 0, static_cast<PointCoordinateType>(y), static_cast<PointCoordinateType>(z)); for (int i=0; i<rasterX; ++i) { double x = adfGeoTransform[0] + static_cast<double>(i) * adfGeoTransform[1] + Pshift.x; P.x = static_cast<PointCoordinateType>(x); pc->addPoint(P); } } QVariant xVar = QVariant::fromValue<int>(rasterX); QVariant yVar = QVariant::fromValue<int>(rasterY); pc->setMetaData("raster_width",xVar); pc->setMetaData("raster_height",yVar); } //fetch raster bands bool zRasterProcessed = false; unsigned zInvalid = 0; double zMinMax[2] = {0, 0}; for (int i=1; i<=rasterCount; ++i) { ccLog::Print( "Reading band #%i", i); GDALRasterBand* poBand = poDataset->GetRasterBand(i); GDALColorInterp colorInterp = poBand->GetColorInterpretation(); GDALDataType bandType = poBand->GetRasterDataType(); int nBlockXSize, nBlockYSize; poBand->GetBlockSize( &nBlockXSize, &nBlockYSize ); ccLog::Print( "Block=%dx%d Type=%s, ColorInterp=%s", nBlockXSize, nBlockYSize, GDALGetDataTypeName(poBand->GetRasterDataType()), GDALGetColorInterpretationName(colorInterp) ); //fetching raster scan-line int nXSize = poBand->GetXSize(); int nYSize = poBand->GetYSize(); assert(nXSize == rasterX); assert(nYSize == rasterY); int bGotMin, bGotMax; double adfMinMax[2] = {0, 0}; adfMinMax[0] = poBand->GetMinimum( &bGotMin ); adfMinMax[1] = poBand->GetMaximum( &bGotMax ); if (!bGotMin || !bGotMax ) //DGM FIXME: if the file is corrupted (e.g. ASCII ArcGrid with missing rows) this method will enter in a infinite loop! GDALComputeRasterMinMax((GDALRasterBandH)poBand, TRUE, adfMinMax); ccLog::Print( "Min=%.3fd, Max=%.3f", adfMinMax[0], adfMinMax[1] ); GDALColorTable* colTable = poBand->GetColorTable(); if( colTable != NULL ) printf( "Band has a color table with %d entries", colTable->GetColorEntryCount() ); if( poBand->GetOverviewCount() > 0 ) printf( "Band has %d overviews", poBand->GetOverviewCount() ); if (colorInterp == GCI_Undefined && !zRasterProcessed/*&& !colTable*/) //probably heights? { zRasterProcessed = true; zMinMax[0] = adfMinMax[0]; zMinMax[1] = adfMinMax[1]; double* scanline = (double*) CPLMalloc(sizeof(double)*nXSize); //double* scanline = new double[nXSize]; memset(scanline,0,sizeof(double)*nXSize); for (int j=0; j<nYSize; ++j) { if (poBand->RasterIO( GF_Read, /*xOffset=*/0, /*yOffset=*/j, /*xSize=*/nXSize, /*ySize=*/1, /*buffer=*/scanline, /*bufferSizeX=*/nXSize, /*bufferSizeY=*/1, /*bufferType=*/GDT_Float64, /*x_offset=*/0, /*y_offset=*/0 ) != CE_None) { delete pc; CPLFree(scanline); GDALClose(poDataset); return CC_FERR_READING; } for (int k=0; k<nXSize; ++k) { double z = static_cast<double>(scanline[k]) + Pshift[2]; unsigned pointIndex = static_cast<unsigned>(k + j * rasterX); if (pointIndex <= pc->size()) { if (z < zMinMax[0] || z > zMinMax[1]) { z = zMinMax[0] - 1.0; ++zInvalid; } const_cast<CCVector3*>(pc->getPoint(pointIndex))->z = static_cast<PointCoordinateType>(z); } } } //update bounding-box pc->invalidateBoundingBox(); if (scanline) CPLFree(scanline); scanline = 0; } else //colors { bool isRGB = false; bool isScalar = false; bool isPalette = false; switch(colorInterp) { case GCI_Undefined: isScalar = true; break; case GCI_PaletteIndex: isPalette = true; break; case GCI_RedBand: case GCI_GreenBand: case GCI_BlueBand: isRGB = true; break; case GCI_AlphaBand: if (adfMinMax[0] != adfMinMax[1]) isScalar = true; else ccLog::Warning(QString("Alpha band ignored as it has a unique value (%1)").arg(adfMinMax[0])); break; default: isScalar = true; break; } if (isRGB || isPalette) { //first check that a palette exists if the band is a palette index if (isPalette && !colTable) { ccLog::Warning(QString("Band is declared as a '%1' but no palette is associated!").arg(GDALGetColorInterpretationName(colorInterp))); isPalette = false; } else { //instantiate memory for RBG colors if necessary if (!pc->hasColors() && !pc->setRGBColor(MAX_COLOR_COMP,MAX_COLOR_COMP,MAX_COLOR_COMP)) { ccLog::Warning(QString("Failed to instantiate memory for storing color band '%1'!").arg(GDALGetColorInterpretationName(colorInterp))); } else { assert(bandType <= GDT_Int32); int* colIndexes = (int*) CPLMalloc(sizeof(int)*nXSize); //double* scanline = new double[nXSize]; memset(colIndexes,0,sizeof(int)*nXSize); for (int j=0; j<nYSize; ++j) { if (poBand->RasterIO( GF_Read, /*xOffset=*/0, /*yOffset=*/j, /*xSize=*/nXSize, /*ySize=*/1, /*buffer=*/colIndexes, /*bufferSizeX=*/nXSize, /*bufferSizeY=*/1, /*bufferType=*/GDT_Int32, /*x_offset=*/0, /*y_offset=*/0 ) != CE_None) { CPLFree(colIndexes); delete pc; return CC_FERR_READING; } for (int k=0; k<nXSize; ++k) { unsigned pointIndex = static_cast<unsigned>(k + j * rasterX); if (pointIndex <= pc->size()) { colorType* C = const_cast<colorType*>(pc->getPointColor(pointIndex)); switch(colorInterp) { case GCI_PaletteIndex: assert(colTable); { GDALColorEntry col; colTable->GetColorEntryAsRGB(colIndexes[k],&col); C[0] = static_cast<colorType>(col.c1 & MAX_COLOR_COMP); C[1] = static_cast<colorType>(col.c2 & MAX_COLOR_COMP); C[2] = static_cast<colorType>(col.c3 & MAX_COLOR_COMP); } break; case GCI_RedBand: C[0] = static_cast<colorType>(colIndexes[k] & MAX_COLOR_COMP); break; case GCI_GreenBand: C[1] = static_cast<colorType>(colIndexes[k] & MAX_COLOR_COMP); break; case GCI_BlueBand: C[2] = static_cast<colorType>(colIndexes[k] & MAX_COLOR_COMP); break; default: assert(false); break; } } } } if (colIndexes) CPLFree(colIndexes); colIndexes = 0; pc->showColors(true); } } } else if (isScalar) { ccScalarField* sf = new ccScalarField(GDALGetColorInterpretationName(colorInterp)); if (!sf->resize(pc->size(),true,NAN_VALUE)) { ccLog::Warning(QString("Failed to instantiate memory for storing '%1' as a scalar field!").arg(sf->getName())); sf->release(); sf = 0; } else { double* colValues = (double*) CPLMalloc(sizeof(double)*nXSize); //double* scanline = new double[nXSize]; memset(colValues,0,sizeof(double)*nXSize); for (int j=0; j<nYSize; ++j) { if (poBand->RasterIO( GF_Read, /*xOffset=*/0, /*yOffset=*/j, /*xSize=*/nXSize, /*ySize=*/1, /*buffer=*/colValues, /*bufferSizeX=*/nXSize, /*bufferSizeY=*/1, /*bufferType=*/GDT_Float64, /*x_offset=*/0, /*y_offset=*/0 ) != CE_None) { CPLFree(colValues); delete pc; return CC_FERR_READING; } for (int k=0; k<nXSize; ++k) { unsigned pointIndex = static_cast<unsigned>(k + j * rasterX); if (pointIndex <= pc->size()) { ScalarType s = static_cast<ScalarType>(colValues[k]); sf->setValue(pointIndex,s); } } } if (colValues) CPLFree(colValues); colValues = 0; sf->computeMinAndMax(); pc->addScalarField(sf); if (pc->getNumberOfScalarFields() == 1) pc->setCurrentDisplayedScalarField(0); pc->showSF(true); } } } } if (pc) { if (!zRasterProcessed) { ccLog::Warning("Raster has no height (Z) information: you can convert one of its scalar fields to Z with 'Edit > Scalar Fields > Set SF as coordinate(s)'"); } else if (zInvalid != 0 && zInvalid < pc->size()) { //shall we remove the points with invalid heights? if (QMessageBox::question(0,"Remove NaN points?","This raster has pixels with invalid heights. Shall we remove them?",QMessageBox::Yes, QMessageBox::No) == QMessageBox::Yes) { CCLib::ReferenceCloud validPoints(pc); unsigned count = pc->size(); bool error = true; if (validPoints.reserve(count-zInvalid)) { for (unsigned i=0; i<count; ++i) { if (pc->getPoint(i)->z >= zMinMax[0]) validPoints.addPointIndex(i); } if (validPoints.size() > 0) { validPoints.resize(validPoints.size()); ccPointCloud* newPC = pc->partialClone(&validPoints); if (newPC) { delete pc; pc = newPC; error = false; } } else { assert(false); } } if (error) { ccLog::Error("Not enough memory to remove the points with invalid heights!"); } } } container.addChild(pc); } GDALClose(poDataset); } else { return CC_FERR_UNKNOWN_FILE; } return CC_FERR_NO_ERROR; }
GDALDataset *IntergraphDataset::CreateCopy( const char *pszFilename, GDALDataset *poSrcDS, int bStrict, char **papszOptions, GDALProgressFunc pfnProgress, void *pProgressData ) { (void) bStrict; int nBands = poSrcDS->GetRasterCount(); if (nBands == 0) { CPLError( CE_Failure, CPLE_NotSupported, "Intergraph driver does not support source dataset with zero band.\n"); return NULL; } if( !pfnProgress( 0.0, NULL, pProgressData ) ) { return NULL; } // -------------------------------------------------------------------- // Query GDAL Data Type // -------------------------------------------------------------------- GDALDataType eType = poSrcDS->GetRasterBand(1)->GetRasterDataType(); // -------------------------------------------------------------------- // Copy metadata // -------------------------------------------------------------------- char **papszCreateOptions = CSLDuplicate( papszOptions ); const char *pszValue; pszValue = CSLFetchNameValue(papszCreateOptions, "RESOLUTION"); if( pszValue == NULL ) { const char *value = poSrcDS->GetMetadataItem("RESOLUTION"); if (value) { papszCreateOptions = CSLSetNameValue( papszCreateOptions, "RESOLUTION", value ); } } // -------------------------------------------------------------------- // Create IntergraphDataset // -------------------------------------------------------------------- IntergraphDataset *poDstDS; poDstDS = (IntergraphDataset*) IntergraphDataset::Create( pszFilename, poSrcDS->GetRasterXSize(), poSrcDS->GetRasterYSize(), poSrcDS->GetRasterCount(), eType, papszCreateOptions ); CSLDestroy( papszCreateOptions ); if( poDstDS == NULL ) { return NULL; } // -------------------------------------------------------------------- // Copy Transformation Matrix to the dataset // -------------------------------------------------------------------- double adfGeoTransform[6]; poDstDS->SetProjection( poSrcDS->GetProjectionRef() ); poSrcDS->GetGeoTransform( adfGeoTransform ); poDstDS->SetGeoTransform( adfGeoTransform ); // -------------------------------------------------------------------- // Copy information to the raster band // -------------------------------------------------------------------- GDALRasterBand *poSrcBand; GDALRasterBand *poDstBand; double dfMin; double dfMax; double dfMean; double dfStdDev = -1; for( int i = 1; i <= poDstDS->nBands; i++) { delete poDstDS->GetRasterBand(i); } poDstDS->nBands = 0; if( poDstDS->hHeaderOne.DataTypeCode == Uncompressed24bit ) { poDstDS->SetBand( 1, new IntergraphRGBBand( poDstDS, 1, 0, 3 ) ); poDstDS->SetBand( 2, new IntergraphRGBBand( poDstDS, 2, 0, 2 ) ); poDstDS->SetBand( 3, new IntergraphRGBBand( poDstDS, 3, 0, 1 ) ); poDstDS->nBands = 3; } else { for( int i = 1; i <= poSrcDS->GetRasterCount(); i++ ) { poSrcBand = poSrcDS->GetRasterBand(i); eType = poSrcDS->GetRasterBand(i)->GetRasterDataType(); poDstBand = new IntergraphRasterBand( poDstDS, i, 0, eType ); poDstDS->SetBand( i, poDstBand ); poDstBand->SetCategoryNames( poSrcBand->GetCategoryNames() ); poDstBand->SetColorTable( poSrcBand->GetColorTable() ); poSrcBand->GetStatistics( false, true, &dfMin, &dfMax, &dfMean, &dfStdDev ); poDstBand->SetStatistics( dfMin, dfMax, dfMean, dfStdDev ); } } // -------------------------------------------------------------------- // Copy image data // -------------------------------------------------------------------- int nXSize = poDstDS->GetRasterXSize(); int nYSize = poDstDS->GetRasterYSize(); int nBlockXSize; int nBlockYSize; CPLErr eErr = CE_None; for( int iBand = 1; iBand <= poSrcDS->GetRasterCount(); iBand++ ) { GDALRasterBand *poDstBand = poDstDS->GetRasterBand( iBand ); GDALRasterBand *poSrcBand = poSrcDS->GetRasterBand( iBand ); // ------------------------------------------------------------ // Copy Untiled / Uncompressed // ------------------------------------------------------------ int iYOffset, iXOffset; void *pData; poSrcBand->GetBlockSize( &nBlockXSize, &nBlockYSize ); nBlockXSize = nXSize; nBlockYSize = 1; pData = CPLMalloc( nBlockXSize * nBlockYSize * GDALGetDataTypeSize( eType ) / 8 ); for( iYOffset = 0; iYOffset < nYSize; iYOffset += nBlockYSize ) { for( iXOffset = 0; iXOffset < nXSize; iXOffset += nBlockXSize ) { eErr = poSrcBand->RasterIO( GF_Read, iXOffset, iYOffset, nBlockXSize, nBlockYSize, pData, nBlockXSize, nBlockYSize, eType, 0, 0, NULL ); if( eErr != CE_None ) { return NULL; } eErr = poDstBand->RasterIO( GF_Write, iXOffset, iYOffset, nBlockXSize, nBlockYSize, pData, nBlockXSize, nBlockYSize, eType, 0, 0, NULL ); if( eErr != CE_None ) { return NULL; } } if( ( eErr == CE_None ) && ( ! pfnProgress( ( iYOffset + 1 ) / ( double ) nYSize, NULL, pProgressData ) ) ) { eErr = CE_Failure; CPLError( CE_Failure, CPLE_UserInterrupt, "User terminated CreateCopy()" ); } } CPLFree( pData ); } // -------------------------------------------------------------------- // Finalize // -------------------------------------------------------------------- poDstDS->FlushCache(); return poDstDS; }
bool DemReader::Open(std::wstring fullPath, StudyControllerPtr studyController, MapControllerPtr mapController, ProgressDlgPtr progressDlg) { GDALAllRegister(); bool bElevationMap; uint numBands; double adfGeoTransform[6]; GDALDataset* gdalDataset; int nBlockXSize, nBlockYSize; MapModelPtr mapModel = mapController->GetMapModel(); FileHeader* header = mapModel->GetHeader(); GDALRasterBand* gdalBand; if(App::Inst().GetLayerTreeController()->GetIsBlankRaster()) { LayerTreeControllerPtr ltc = App::Inst().GetLayerTreeController(); VectorMapLayerPtr vectorMapLayer =ltc->GetVectorMapLayer(0); VectorMapModelPtr vectorMapModel= vectorMapLayer->GetVectorMapController()->GetVectorMapModel(); double vectorMinX = vectorMapModel->GetVectorBoundary_MinX(); double vectorMinY = vectorMapModel->GetVectorBoundary_MinY(); double vectorMaxX = vectorMapModel->GetVectorBoundary_MaxX(); double vectorMaxY = vectorMapModel->GetVectorBoundary_MaxY(); double bRaster_width = 1000; double bRaster_height= 1000; double x_res = (vectorMaxX - vectorMinX) / bRaster_width; double y_res = (vectorMaxY - vectorMinY) / bRaster_height; numBands = 3; bElevationMap = false; header->nCols = 1000; header->nRows = 1000; header->noDataValue=0.0; //adfGeoTransform[6]= {vectorMinX, x_res, 0.0, vectorMaxY, 0.0, -y_res}; adfGeoTransform[0]= vectorMinX; adfGeoTransform[1]= x_res; adfGeoTransform[2]= 0.0; adfGeoTransform[3]= vectorMaxY; adfGeoTransform[4] = 0.0; adfGeoTransform[5]= -y_res; } else { std::string tempStr(fullPath.begin(), fullPath.end()); gdalDataset = (GDALDataset*) GDALOpen( tempStr.c_str(), GA_ReadOnly ); if(gdalDataset == NULL) { Log::Inst().Warning("(Warning) Failed to open file at " + tempStr + "."); return false; } // determine type of file based on number of raster bands numBands = gdalDataset->GetRasterCount(); if(numBands == 1) bElevationMap = true; else if(numBands == 3 || numBands == 4) bElevationMap = false; else { Log::Inst().Warning("(Warning) File type not supported. Please contact the GenGIS to request support for the file format."); } CPLErr err = gdalDataset->GetGeoTransform( adfGeoTransform ); // check if we have a map without any transformation information // in which case assume we have a custom image file where y should // be in the south (down) direction if(err == CE_Failure) adfGeoTransform[5] = -1; gdalBand = gdalDataset->GetRasterBand( 1 ); gdalBand->GetBlockSize( &nBlockXSize, &nBlockYSize ); // get original data dimensions header->nCols = gdalBand->GetXSize(); header->nRows = gdalBand->GetYSize(); header->noDataValue = gdalBand->GetNoDataValue(); // Setup desired projection if(!SetupProjection(gdalDataset, studyController, adfGeoTransform, header->nCols, header->nRows, bElevationMap)) { GDALClose(gdalDataset); return false; } } if(progressDlg) { if(!App::Inst().GetLayerTreeController()->GetIsBlankRaster()) { if(!progressDlg->Update(0, _T("Reading map file..."))) { GDALClose(gdalDataset); return false; } } else { if(!progressDlg->Update(0, _T("Initializing the Visualization..."))) { GDALClose(gdalDataset); return false; } } } // check whether it's too large to handle all the data float* elevations = NULL; if(bElevationMap && !App::Inst().GetLayerTreeController()->GetIsBlankRaster()) { try { elevations = new float[gdalBand->GetXSize()* gdalBand->GetYSize()]; } catch(std::bad_alloc&) { Log::Inst().Warning("(Warning) Insufficent memory for elevation map."); GDALClose(gdalDataset); return false; } gdalBand->RasterIO( GF_Read, 0, 0, gdalBand->GetXSize(), gdalBand->GetYSize(), elevations, gdalBand->GetXSize(), gdalBand->GetYSize(), GDT_Float32, 0, 0 ); } // project all map model cells Point3D* grid; try { grid = new Point3D[header->nCols*header->nRows]; } catch(std::bad_alloc&) { Log::Inst().Warning("(Warning) Insufficent memory to load map."); GDALClose(gdalDataset); delete[] elevations; return false; } // populate grid with projected points and find extents of projected map double xOffset = adfGeoTransform[0]; double zOffset = adfGeoTransform[3]; int index = 0; double x, z; header->projExtents.x = header->projExtents.y = std::numeric_limits<float>::max(); header->projExtents.dx = header->projExtents.dy = -std::numeric_limits<float>::max(); ProjectionToolPtr projTool = studyController->GetProjectionTool(); for(int m = 0; m < header->nRows ; ++m) { xOffset = adfGeoTransform[0]; for(int n = 0; n < header->nCols; ++n) { x = xOffset; z = zOffset; if(studyController->IsProjectData() && studyController->IsGeographic() && !App::Inst().GetLayerTreeController()->GetIsBlankRaster()) { double elevation = (double)elevations[index]; if(!projTool->Transform(1, &x, &z, &elevation)) { Log::Inst().Warning("(Warning) Failed to project map."); GDALClose(gdalDataset); delete[] elevations; return false; } } xOffset += adfGeoTransform[1]; if(App::Inst().GetLayerTreeController()->GetIsBlankRaster()) { double X = x; double Z = z; grid[index].x = X; grid[index].z = Z; index++; if(X < header->projExtents.x) header->projExtents.x = X; if(Z < header->projExtents.y) header->projExtents.y = Z; if(X > header->projExtents.dx) header->projExtents.dx = X; if(Z > header->projExtents.dy) header->projExtents.dy = Z; } else { float X = (float)x; float Z = (float)z; grid[index].x = X; grid[index].z = Z; index++; if(X < header->projExtents.x) header->projExtents.x = X; if(Z < header->projExtents.y) header->projExtents.y = Z; if(X > header->projExtents.dx) header->projExtents.dx = X; if(Z > header->projExtents.dy) header->projExtents.dy = Z; } } zOffset += adfGeoTransform[5]; if(progressDlg) { if(!progressDlg->Update(int((float(m)/header->nRows)*50))) { GDALClose(gdalDataset); if(elevations != NULL) delete[] elevations; return false; } } } if(App::Inst().GetLayerTreeController()->GetIsBlankRaster()) { LayerTreeControllerPtr ltc = App::Inst().GetLayerTreeController(); VectorMapLayerPtr vectorMapLayer =ltc->GetVectorMapLayer(0); VectorMapModelPtr vectorMapModel= vectorMapLayer->GetVectorMapController()->GetVectorMapModel(); header->projExtents.x = vectorMapModel->GetVectorBoundary_MinX(); header->projExtents.dx = vectorMapModel->GetVectorBoundary_MaxX(); header->projExtents.y = vectorMapModel->GetVectorBoundary_MinY(); header->projExtents.dy = vectorMapModel->GetVectorBoundary_MaxY(); } // transform all points into unit grid space float minElevation = std::numeric_limits<float>::max(); float maxElevation = -std::numeric_limits<float>::max(); if(!TransformToGridSpace(grid, header, elevations, bElevationMap, minElevation, maxElevation, progressDlg)) { GDALClose(gdalDataset); if(elevations != NULL) delete[] elevations; return false; } // setup map model mapModel->SetMinElevationGridSpace(minElevation); mapModel->SetMaxElevationGridSpace(maxElevation); mapModel->SetMinElevation(minElevation/header->scaleFactor); mapModel->SetMaxElevation(maxElevation/header->scaleFactor); mapModel->SetElevationMap(bElevationMap); mapModel->SetGrid(grid); // report information in file to user if (!App::Inst().GetLayerTreeController()->GetIsBlankRaster()) MetaDataInfo(gdalDataset, mapController); else MetaDataInfoForBlankRaster(mapController, adfGeoTransform); // build texture that will be mapped onto terrain if(!App::Inst().GetLayerTreeController()->GetIsBlankRaster()){ if(!BuildTerrainTexture(gdalDataset, mapController, progressDlg)) { GDALClose(gdalDataset); if(elevations != NULL) delete[] elevations; return false; } // will free memory allocated to any GDALRasterBand objects GDALClose(gdalDataset); } // will free memory allocated to any GDALRasterBand objects if(elevations != NULL) delete[] elevations; return true; }
int main(int argc, const char * argv[]) { boost::filesystem::path p = boost::filesystem::current_path(); fprintf(stdout,"cwp := %s\n",p.c_str()); GDALAllRegister(); // for (int i = 0; i < GDALGetDriverCount(); i++) { // GDALDriver * d = (GDALDriver *)GDALGetDriver(i); // const char * desc = d->GetDescription(); // fprintf(stdout, "GDAL: %s\n",desc); // } GDALDataset *poDataset = (GDALDataset *) GDALOpen(DataPath.c_str(), GA_ReadOnly ); std::string SupportedDriver = {"GTiff"}; if (poDataset != NULL) { GDALDriver * drv = poDataset->GetDriver(); assert(0 == SupportedDriver.compare(drv->GetDescription())); assert (1 == poDataset->GetRasterCount()); fprintf(stdout,"RasterXSize := %d\n",poDataset->GetRasterXSize()); fprintf(stdout,"RasterYSize := %d\n",poDataset->GetRasterYSize()); fprintf(stdout,"ProjectionRef := %s\n",poDataset->GetProjectionRef()); double adfGeoTransform[6]; if ( poDataset->GetGeoTransform(adfGeoTransform) == CE_None ) { fprintf(stdout, "Origin = (%.6f, %.6f)\n", adfGeoTransform[0],adfGeoTransform[3]); // upper left courner fprintf(stdout, "Pixel Size = (%.6f, %.6f)\n", adfGeoTransform[1],adfGeoTransform[5]); // pixel width/height } GDALRasterBand *poBand = poDataset->GetRasterBand(1); int nBlockXSize, nBlockYSize; poBand->GetBlockSize(&nBlockXSize, &nBlockYSize); std::string SupportedDataType = {"Int16"}; assert (GDT_Int16 == poBand->GetRasterDataType()); printf( "Block=%dx%d Type=%s, ColorInterp=%s\n", nBlockXSize, nBlockYSize, GDALGetDataTypeName(poBand->GetRasterDataType()), GDALGetColorInterpretationName( poBand->GetColorInterpretation()) ); FILE * patch = fopen("patch.txt","w"); for (int i = 0; i < poBand->GetYSize(); i++) { int nXSize = poBand->GetXSize(); float *pafScanline = (float *) CPLMalloc(sizeof(float)*nXSize); poBand->RasterIO( GF_Read, 0, 0, nXSize, 1, pafScanline, nXSize, 1, GDT_Float32, 0, 0); for (int j = 0; j < nXSize; j++) { fprintf(patch, "%f ", pafScanline[j]); } fprintf(patch, "\n"); CPLFree(pafScanline); } fclose(patch); GDALClose(poDataset); } DelaunayTriangulation dt; //std::srand(static_cast<unsigned int>(std::time(0))); // use current time as seed for random generator /* std::srand(static_cast<unsigned int>(3652123216145)); for (int i = 0; i < 10 ; i++) { double x = 180.0 * static_cast <float> (rand()) / static_cast <float> (RAND_MAX);; double y = 180.0 * static_cast <float> (rand()) / static_cast <float> (RAND_MAX);; dt.addPt(x, y, 0.0); } */ /* dt.addPt(-0.02222276248244826, -0.4979727817680433, 0.0); dt.addPt(-0.4285431913366012, 0.4745826469497594, 0.0); dt.addPt( 0.3105396575392593, 0.2400179190933871, 0.0); dt.addPt(-0.01883958887200765, 0.3630260628303755, 0.0); dt.addPt( 0.3790312361708201, 0.3779794437605696, 0.0); dt.addPt(-0.2994955874043476, 0.3776609263174803, 0.0); dt.addPt( 0.3471817493878135, 0.08365533089605659, 0.0); dt.addPt(-0.00485819764887746, 0.3482682405489201, 0.0); dt.addPt( 0.3443122672329771, -0.1437312230875075, 0.0); dt.addPt( 0.309330780347186, -0.07758103877080702, 0.0); dt.compute(); */ return 0; }
CMapDEM::CMapDEM(const QString& filename, CCanvas * parent) : IMap(eDEM, "",parent) , canvas(parent) , old_my_xscale(0) , old_my_yscale(0) , old_overlay(IMap::eNone) , idxGrade(1) { #ifdef WIN32 dataset = (GDALDataset*)GDALOpen(filename.toLocal8Bit(),GA_ReadOnly); #else dataset = (GDALDataset*)GDALOpen(filename.toUtf8(),GA_ReadOnly); #endif if(dataset == 0) { QMessageBox::warning(0, tr("Error..."), tr("Failed to load file: %1\n\n").arg(filename).append(tr(CPLGetLastErrorMsg()))); status = 0; return; } GDALRasterBand * pBand; pBand = dataset->GetRasterBand(1); if(pBand == 0) { delete dataset; dataset = 0; QMessageBox::warning(0, tr("Error..."), tr("Failed to load file: %1").arg(filename).append(tr(CPLGetLastErrorMsg()))); status = 0; return; } pBand->GetBlockSize(&tileWidth,&tileHeight); char str[1024]= {0}; if(dataset->GetProjectionRef()) { strncpy(str,dataset->GetProjectionRef(),sizeof(str)); } char * ptr = str; oSRS.importFromWkt(&ptr); oSRS.exportToProj4(&ptr); QString strProj = ptr; qDebug() << "DEM:" << strProj; pjsrc = pj_init_plus(strProj.toLatin1()); xsize_px = dataset->GetRasterXSize(); ysize_px = dataset->GetRasterYSize(); double adfGeoTransform[6]; dataset->GetGeoTransform( adfGeoTransform ); if (strProj.contains("longlat")) { xref1 = adfGeoTransform[0] * DEG_TO_RAD; yref1 = adfGeoTransform[3] * DEG_TO_RAD; xscale = adfGeoTransform[1] * DEG_TO_RAD; yscale = adfGeoTransform[5] * DEG_TO_RAD; } else { xref1 = adfGeoTransform[0]; yref1 = adfGeoTransform[3]; xscale = adfGeoTransform[1]; yscale = adfGeoTransform[5]; } xref2 = xref1 + xsize_px * xscale; yref2 = yref1 + ysize_px * yscale; // qDebug() << xref1 << yref1 << xref2 << yref2 << xscale << yscale; int i; for(i = 0; i < 256; ++i) { graytable2 << qRgba(0,0,0,i); } for(i = 0; i < 128; ++i) { graytable1 << qRgba(0,0,0,(128 - i)); } for(i = 128; i < 255; ++i) { graytable1 << qRgba(255,255,255, 1); } slopetable << slopeColorTable[0]; slopetable << slopeColorTable[1]; slopetable << slopeColorTable[2]; slopetable << slopeColorTable[3]; slopetable << slopeColorTable[4]; slopetable << slopeColorTable[5]; status = new CStatusDEM(theMainWindow->getCanvas()); theMainWindow->statusBar()->insertPermanentWidget(0,status); SETTINGS; idxGrade = cfg.value("map/overlay/grade",idxGrade).toInt(); }
static GDALDataset *FITCreateCopy(const char * pszFilename, GDALDataset *poSrcDS, int bStrict, char ** papszOptions, GDALProgressFunc pfnProgress, void * pProgressData ) { CPLDebug("FIT", "CreateCopy %s - %i", pszFilename, bStrict); int nBands = poSrcDS->GetRasterCount(); if (nBands == 0) { CPLError( CE_Failure, CPLE_NotSupported, "FIT driver does not support source dataset with zero band.\n"); return nullptr; } /* -------------------------------------------------------------------- */ /* Create the dataset. */ /* -------------------------------------------------------------------- */ if( !pfnProgress( 0.0, nullptr, pProgressData ) ) { CPLError( CE_Failure, CPLE_UserInterrupt, "User terminated" ); return nullptr; } VSILFILE *fpImage = VSIFOpenL( pszFilename, "wb" ); if( fpImage == nullptr ) { CPLError( CE_Failure, CPLE_OpenFailed, "FIT - unable to create file %s.\n", pszFilename ); return nullptr; } /* -------------------------------------------------------------------- */ /* Generate header. */ /* -------------------------------------------------------------------- */ // XXX - should FIT_PAGE_SIZE be based on file page size ?? const size_t size = std::max(sizeof(FIThead02), FIT_PAGE_SIZE); FIThead02 *head = (FIThead02 *) malloc(size); FreeGuard<FIThead02> guardHead( head ); // clean header so padding (past real header) is all zeros memset( head, 0, size ); memcpy((char *) &head->magic, "IT", 2); memcpy((char *) &head->version, "02", 2); head->xSize = poSrcDS->GetRasterXSize(); gst_swapb(head->xSize); head->ySize = poSrcDS->GetRasterYSize(); gst_swapb(head->ySize); head->zSize = 1; gst_swapb(head->zSize); head->cSize = nBands; gst_swapb(head->cSize); GDALRasterBand *firstBand = poSrcDS->GetRasterBand(1); if (! firstBand) { CPL_IGNORE_RET_VAL(VSIFCloseL(fpImage)); return nullptr; } head->dtype = fitGetDataType(firstBand->GetRasterDataType()); if (! head->dtype) { CPL_IGNORE_RET_VAL(VSIFCloseL(fpImage)); return nullptr; } gst_swapb(head->dtype); head->order = 1; // interleaved - RGBRGB gst_swapb(head->order); head->space = 1; // upper left gst_swapb(head->space); // XXX - need to check all bands head->cm = fitGetColorModel(firstBand->GetColorInterpretation(), nBands); gst_swapb(head->cm); int blockX, blockY; firstBand->GetBlockSize(&blockX, &blockY); blockX = std::min(blockX, poSrcDS->GetRasterXSize()); blockY = std::min(blockY, poSrcDS->GetRasterYSize()); int nDTSize = GDALGetDataTypeSizeBytes(firstBand->GetRasterDataType()); try { CPL_IGNORE_RET_VAL( CPLSM(blockX) * CPLSM(blockY) * CPLSM(nDTSize) * CPLSM(nBands)); CPLDebug("FIT write", "inherited block size %ix%i", blockX, blockY); } catch( ... ) { blockX = std::min(256, poSrcDS->GetRasterXSize()); blockY = std::min(256, poSrcDS->GetRasterYSize()); } if( CSLFetchNameValue(papszOptions,"PAGESIZE") != nullptr ) { const char *str = CSLFetchNameValue(papszOptions,"PAGESIZE"); int newBlockX, newBlockY; sscanf(str, "%i,%i", &newBlockX, &newBlockY); if (newBlockX && newBlockY) { blockX = newBlockX; blockY = newBlockY; } else { CPLError(CE_Failure, CPLE_OpenFailed, "FIT - Unable to parse option PAGESIZE values [%s]", str); } } // XXX - need to do lots of checking of block size // * provide ability to override block size with options // * handle non-square block size (like scanline) // - probably default from non-tiled image - have default block size // * handle block size bigger than image size // * undesirable block size (non power of 2, others?) // * mismatched block sizes for different bands // * image that isn't even pages (i.e. partially empty pages at edge) CPLDebug("FIT write", "using block size %ix%i", blockX, blockY); head->xPageSize = blockX; gst_swapb(head->xPageSize); head->yPageSize = blockY; gst_swapb(head->yPageSize); head->zPageSize = 1; gst_swapb(head->zPageSize); head->cPageSize = nBands; gst_swapb(head->cPageSize); // XXX - need to check all bands head->minValue = firstBand->GetMinimum(); gst_swapb(head->minValue); // XXX - need to check all bands head->maxValue = firstBand->GetMaximum(); gst_swapb(head->maxValue); head->dataOffset = static_cast<unsigned int>(size); gst_swapb(head->dataOffset); CPL_IGNORE_RET_VAL(VSIFWriteL(head, size, 1, fpImage)); /* -------------------------------------------------------------------- */ /* Loop over image, copying image data. */ /* -------------------------------------------------------------------- */ unsigned long bytesPerPixel = nBands * nDTSize; size_t pageBytes = blockX * blockY * bytesPerPixel; char *output = (char *) malloc(pageBytes); if (! output) { CPLError(CE_Failure, CPLE_OutOfMemory, "FITRasterBand couldn't allocate %lu bytes", static_cast<unsigned long>(pageBytes)); CPL_IGNORE_RET_VAL(VSIFCloseL(fpImage)); return nullptr; } FreeGuard<char> guardOutput( output ); long maxx = (long) ceil(poSrcDS->GetRasterXSize() / (double) blockX); long maxy = (long) ceil(poSrcDS->GetRasterYSize() / (double) blockY); long maxx_full = (long) floor(poSrcDS->GetRasterXSize() / (double) blockX); long maxy_full = (long) floor(poSrcDS->GetRasterYSize() / (double) blockY); CPLDebug("FIT", "about to write %ld x %ld blocks", maxx, maxy); for(long y=0; y < maxy; y++) for(long x=0; x < maxx; x++) { long readX = blockX; long readY = blockY; int do_clean = FALSE; // handle cases where image size isn't an exact multiple // of page size if (x >= maxx_full) { readX = poSrcDS->GetRasterXSize() % blockX; do_clean = TRUE; } if (y >= maxy_full) { readY = poSrcDS->GetRasterYSize() % blockY; do_clean = TRUE; } // clean out image if only doing partial reads if (do_clean) memset( output, 0, pageBytes ); for( int iBand = 0; iBand < nBands; iBand++ ) { GDALRasterBand * poBand = poSrcDS->GetRasterBand( iBand+1 ); CPLErr eErr = poBand->RasterIO( GF_Read, // eRWFlag static_cast<int>(x * blockX), // nXOff static_cast<int>(y * blockY), // nYOff static_cast<int>(readX), // nXSize static_cast<int>(readY), // nYSize output + iBand * nDTSize, // pData blockX, // nBufXSize blockY, // nBufYSize firstBand->GetRasterDataType(), // eBufType bytesPerPixel, // nPixelSpace bytesPerPixel * blockX, nullptr); // nLineSpace if (eErr != CE_None) { CPLError(CE_Failure, CPLE_FileIO, "FIT write - CreateCopy got read error %i", eErr); CPL_IGNORE_RET_VAL(VSIFCloseL( fpImage )); VSIUnlink( pszFilename ); return nullptr; } } // for iBand #ifdef swapping char *p = output; unsigned long i; switch(nDTSize) { case 1: // do nothing break; case 2: for(i=0; i < pageBytes; i+= nDTSize) gst_swap16(p + i); break; case 4: for(i=0; i < pageBytes; i+= nDTSize) gst_swap32(p + i); break; case 8: for(i=0; i < pageBytes; i+= nDTSize) gst_swap64(p + i); break; default: CPLError(CE_Failure, CPLE_NotSupported, "FIT write - unsupported bytesPerPixel %d", nDTSize); } // switch #endif // swapping if( VSIFWriteL(output, 1, pageBytes, fpImage) != pageBytes ) { CPLError( CE_Failure, CPLE_FileIO, "Write failed" ); CPL_IGNORE_RET_VAL(VSIFCloseL( fpImage )); VSIUnlink( pszFilename ); return nullptr; } double perc = ((double) (y * maxx + x)) / (maxx * maxy); if( !pfnProgress( perc, nullptr, pProgressData ) ) { CPLError( CE_Failure, CPLE_UserInterrupt, "User terminated" ); //free(output); CPL_IGNORE_RET_VAL(VSIFCloseL( fpImage )); VSIUnlink( pszFilename ); return nullptr; } } // for x //free(output); CPL_IGNORE_RET_VAL(VSIFCloseL( fpImage )); pfnProgress( 1.0, nullptr, pProgressData ); /* -------------------------------------------------------------------- */ /* Re-open dataset, and copy any auxiliary pam information. */ /* -------------------------------------------------------------------- */ GDALPamDataset *poDS = (GDALPamDataset *) GDALOpen( pszFilename, GA_ReadOnly ); if( poDS ) poDS->CloneInfo( poSrcDS, GCIF_PAM_DEFAULT ); return poDS; }
PDSWrapperRasterBand( GDALRasterBand* poBaseBand ) { this->poBaseBand = poBaseBand; eDataType = poBaseBand->GetRasterDataType(); poBaseBand->GetBlockSize(&nBlockXSize, &nBlockYSize); }
explicit NGWWrapperRasterBand( GDALRasterBand* poBaseBandIn ) : poBaseBand( poBaseBandIn ) { eDataType = poBaseBand->GetRasterDataType(); poBaseBand->GetBlockSize(&nBlockXSize, &nBlockYSize); }
bool GDALImageFileType::read( Image *OSG_GDAL_ARG(pImage), const Char8 *OSG_GDAL_ARG(fileName)) { #ifdef OSG_WITH_GDAL bool returnValue = false; GDALDataset *pDataset; pDataset = static_cast<GDALDataset *>(GDALOpen(fileName, GA_ReadOnly)); if(pDataset != NULL) { GeoReferenceAttachmentUnrecPtr pGeoRef = GeoReferenceAttachment::create(); pImage->addAttachment(pGeoRef); double adfGeoTransform[6]; if(pDataset->GetGeoTransform(adfGeoTransform) == CE_None) { pGeoRef->editOrigin().setValues(adfGeoTransform[0], adfGeoTransform[3]); pGeoRef->editPixelSize().setValues(adfGeoTransform[1], adfGeoTransform[5]); if(GDALGetProjectionRef(pDataset) != NULL) { OGRSpatialReferenceH hSRS; Char8 *szProjection = const_cast<char *>(GDALGetProjectionRef(pDataset)); hSRS = OSRNewSpatialReference(NULL); if(OSRImportFromWkt(hSRS, &szProjection) == CE_None) { pGeoRef->editEllipsoidAxis().setValues( OSRGetSemiMajor(hSRS, NULL), OSRGetSemiMinor(hSRS, NULL)); const Char8 *szDatum = OSRGetAttrValue(hSRS, "DATUM", 0); if(szDatum != NULL && 0 == strcmp(szDatum, "WGS_1984")) { pGeoRef->editDatum() = GeoReferenceAttachment::WGS84; } else { fprintf(stderr, "Unknow datum %s\n", szDatum); pGeoRef->editDatum() = GeoReferenceAttachment::UnknownDatum; } } OSRDestroySpatialReference(hSRS); } } GDALRasterBand *pBand; int nBlockXSize, nBlockYSize; int bGotMin, bGotMax; double adfMinMax[2]; pBand = pDataset->GetRasterBand( 1 ); pBand->GetBlockSize( &nBlockXSize, &nBlockYSize ); adfMinMax[0] = pBand->GetMinimum( &bGotMin ); adfMinMax[1] = pBand->GetMaximum( &bGotMax ); if(!(bGotMin && bGotMax)) GDALComputeRasterMinMax(GDALRasterBandH(pBand), TRUE, adfMinMax); pBand = pDataset->GetRasterBand(1); if(pBand != NULL) { Image::PixelFormat ePF = Image::OSG_INVALID_PF; switch(pDataset->GetRasterCount()) { case 1: ePF = Image::OSG_L_PF; break; case 2: ePF = Image::OSG_LA_PF; break; case 3: ePF = Image::OSG_RGB_PF; break; case 4: ePF = Image::OSG_RGBA_PF; break; } Image::Type eDT = Image::OSG_INVALID_IMAGEDATATYPE; switch(pBand->GetRasterDataType()) { case GDT_Byte: eDT = Image::OSG_UINT8_IMAGEDATA; break; case GDT_UInt16: eDT = Image::OSG_UINT16_IMAGEDATA; break; case GDT_Int16: eDT = Image::OSG_INT16_IMAGEDATA; break; case GDT_UInt32: eDT = Image::OSG_UINT32_IMAGEDATA; break; case GDT_Int32: eDT = Image::OSG_INT32_IMAGEDATA; break; case GDT_Float32: eDT = Image::OSG_FLOAT32_IMAGEDATA; break; case GDT_Float64: case GDT_CInt16: case GDT_CInt32: case GDT_CFloat32: case GDT_CFloat64: default: GDALClose(pDataset); return returnValue; break; } pImage->set(ePF, pDataset->GetRasterXSize(), pDataset->GetRasterYSize(), 1, 1, 1, 0.0, NULL, eDT); UChar8 *dst = pImage->editData(); pBand->RasterIO(GF_Read, 0, 0, pDataset->GetRasterXSize(), pDataset->GetRasterYSize(), dst, pDataset->GetRasterXSize(), pDataset->GetRasterYSize(), pBand->GetRasterDataType(), 0, 0); pGeoRef->setNoDataValue(pBand->GetNoDataValue()); returnValue = true; } GDALClose(pDataset); } return returnValue; #else SWARNING << getMimeType() << " read is not compiled into the current binary " << std::endl; return false; #endif // OSG_WITH_GDAL }
std::tuple<boost::shared_ptr<Map_Matrix<DataFormat> >, std::string, GeoTransform> read_in_map(fs::path file_path, GDALDataType data_type, const bool doCategorise) throw(std::runtime_error) { std::string projection; GeoTransform transformation; GDALDriver driver; //Check that the file name is valid if (!(fs::is_regular_file(file_path))) { throw std::runtime_error("Input file is not a regular file"); } // Get GDAL to open the file - code is based on the tutorial at http://www.gdal.org/gdal_tutorial.html GDALDataset *poDataset; GDALAllRegister(); //This registers all availble raster file formats for use with this utility. How neat is that. We can input any GDAL supported rater file format. //Open the Raster by calling GDALOpen. http://www.gdal.org/gdal_8h.html#a6836f0f810396c5e45622c8ef94624d4 //char pszfilename[] = file_path.c_str(); //Set this to the file name, as GDALOpen requires the standard C char pointer as function parameter. poDataset = (GDALDataset *) GDALOpen (file_path.string().c_str(), GA_ReadOnly); if (poDataset == NULL) { throw std::runtime_error("Unable to open file"); } // Print some general information about the raster double adfGeoTransform[6]; //An array of doubles that will be used to save information about the raster - where the origin is, what the raster pizel size is. printf( "Driver: %s/%s\n", poDataset->GetDriver()->GetDescription(), poDataset->GetDriver()->GetMetadataItem( GDAL_DMD_LONGNAME ) ); printf( "Size is %dx%dx%d\n", poDataset->GetRasterXSize(), poDataset->GetRasterYSize(), poDataset->GetRasterCount() ); if( poDataset->GetProjectionRef() != NULL ) { printf( "Projection is `%s'\n", poDataset->GetProjectionRef() ); projection = poDataset->GetProjectionRef(); } if( poDataset->GetGeoTransform( adfGeoTransform ) == CE_None ) { printf( "Origin = (%.6f,%.6f)\n", adfGeoTransform[0], adfGeoTransform[3] ); printf( "Pixel Size = (%.6f,%.6f)\n", adfGeoTransform[1], adfGeoTransform[5] ); transformation.x_origin = adfGeoTransform[0]; transformation.pixel_width = adfGeoTransform[1]; transformation.x_line_space = adfGeoTransform[2]; transformation.y_origin = adfGeoTransform[3]; transformation.pixel_height = adfGeoTransform[4]; transformation.y_line_space = adfGeoTransform[5]; } /// Some raster file formats allow many layers of data (called a 'band', with each having the same pixel size and origin location and spatial extent). We will get the data for the first layer into a Boost Array. //Get the data from the first band, // TODO implement method with input to specify what band. GDALRasterBand *poBand; int nBlockXSize, nBlockYSize; int bGotMin, bGotMax; double adfMinMax[2]; poBand = poDataset->GetRasterBand( 1 ); poBand->GetBlockSize( &nBlockXSize, &nBlockYSize ); printf( "Block=%dx%d Type=%s, ColorInterp=%s\n", nBlockXSize, nBlockYSize, GDALGetDataTypeName(poBand->GetRasterDataType()), GDALGetColorInterpretationName( poBand->GetColorInterpretation()) ); adfMinMax[0] = poBand->GetMinimum( &bGotMin ); adfMinMax[1] = poBand->GetMaximum( &bGotMax ); if( ! (bGotMin && bGotMax) ) GDALComputeRasterMinMax((GDALRasterBandH)poBand, TRUE, adfMinMax); printf( "Min=%.3fd, Max=%.3f\n", adfMinMax[0], adfMinMax[1] ); if( poBand->GetOverviewCount() > 0 ) printf( "Band has %d overviews.\n", poBand->GetOverviewCount() ); if( poBand->GetColorTable() != NULL ) printf( "Band has a color table with %d entries.\n", poBand->GetColorTable()->GetColorEntryCount() ); DataFormat * pafScanline; int nXSize = poBand->GetXSize(); int nYSize = poBand->GetYSize(); boost::shared_ptr<Map_Matrix<DataFormat> > in_map(new Map_Matrix<DataFormat>(nYSize, nXSize)); //get a c array of this size and read into this. //pafScanline = new DataFormat[nXSize]; //for (int i = 0; i < nYSize; i++) //rows //{ // poBand->RasterIO(GF_Read, 0, i, nXSize, 1, // pafScanline, nXSize, 1, data_type, // 0, 0); // for (int j = 0; j < nXSize; j++) //cols // { // in_map->Get(i, j) = pafScanline[j]; // } //} //get a c array of this size and read into this. pafScanline = new DataFormat[nXSize * nYSize]; //pafScanline = (float *) CPLMalloc(sizeof(float)*nXSize); poBand->RasterIO( GF_Read, 0, 0, nXSize, nYSize, pafScanline, nXSize, nYSize, data_type, 0, 0 ); //Copy into Map_Matrix. int pafIterator = 0; // Note: Map Matrixes indexes are in opposite order to C arrays. e.g. map matrix is indexed by (row, Col) which is (y, x) and c matrices are done by (x, y) which is (Col, Row) //for (int i = 0; i < nXSize; i++) //{ // for(int j = 0; j < nYSize; j++) // { // in_map->Get(j, i) = pafScanline[pafIterator]; // pafIterator++; // } //} for (int i = 0; i < nYSize; i++) //rows { for (int j = 0; j < nXSize; j++) //cols { in_map->Get(i, j) = pafScanline[pafIterator]; pafIterator++; } } //free the c array storage delete pafScanline; int pbsuccess; // can be used with get no data value in_map->SetNoDataValue(poBand->GetNoDataValue(&pbsuccess)); //This creates a list (map?) listing all the unique values contained in the raster. if (doCategorise) in_map->updateCategories(); //Close GDAL, freeing the memory GDAL is using GDALClose( (GDALDatasetH)poDataset); return (std::make_tuple(in_map, projection, transformation)); }
void generateTexture(string fname, GLuint& tex, int bandnum) { if(bandnum <= 0 ) { bandnum = 1; } GDALDataset *poDataset; GDALAllRegister(); poDataset= (GDALDataset*) GDALOpen(fname.c_str(),GA_ReadOnly); if(poDataset == NULL) { cout << "OUCH!" << endl; //exit(0); return; } cout << "Data size: " << GDALGetRasterXSize(poDataset) << " " << GDALGetRasterYSize(poDataset) << endl; GDALRasterBand *poBand; int nBlockXSize, nBlockYSize; int bGotMin, bGotMax; double adfMinMax[2]; int bands = poDataset->GetRasterCount(); bandnum = bandnum % bands + 1; if(bandnum > bands) { bandnum = 1; } poBand = poDataset->GetRasterBand( bandnum ); poBand->GetBlockSize( &nBlockXSize, &nBlockYSize ); printf( "Block=%dx%d Type=%s, ColorInterp=%s\n", nBlockXSize, nBlockYSize, GDALGetDataTypeName(poBand->GetRasterDataType()), GDALGetColorInterpretationName( poBand->GetColorInterpretation()) ); float max = adfMinMax[0] = poBand->GetMinimum( &bGotMin ); float min = adfMinMax[1] = poBand->GetMaximum( &bGotMax ); if( ! (bGotMin && bGotMax) ) GDALComputeRasterMinMax((GDALRasterBandH)poBand, TRUE, adfMinMax); int width = poBand->GetXSize(); int height = poBand->GetYSize(); float *pafScanline; std::cout << "Before allocation" << adfMinMax[0] << " " << adfMinMax[1] << endl; min = adfMinMax[0]; max = adfMinMax[1]; int dsize = 256; pafScanline = (float *) CPLMalloc(sizeof(float)*512*512); vector<vector<float>> out = vector<vector<float>>(height,vector<float> (width,0)); //vector<vector<unsigned char>> texs = vector<vector<unsigned char>>(height,vector<unsigned char> (width,0)); unsigned char texs[512*512]; poBand->RasterIO(GF_Read,0,0,width,height,pafScanline,512,512,GDT_Float32,0,0); float no = poBand->GetNoDataValue(); cout << "After allocation" << endl; for(int i = 0; i < 512; i++) { for(int j = 0; j < 512; j++) { //cout << i << j << endl << pafS; if(pafScanline[i*width+j] != no) { // set tex val texs[i*512+j] = (unsigned char)(255*((pafScanline[i*512+j] - min)/(max-min))); //if((int)texs[i*width] < 0) //cout << (int)texs[i*512 +j] << " " << pafScanline[i*512+j] << " " << no << " " << fname << " " << min << " " << max << endl; } else { // Set zero val texs[i*512+j] = 0; //cout << (int)texs[i*512 +j] << fname << endl; } //texs[i*512+j] = 255; //ut[i][j] = pafScanline[i*width+j]; } } CPLFree(pafScanline); //exit(0); // Create a texture glGenTextures(1,&tex); glBindTexture(GL_TEXTURE_2D,tex); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); glTexImage2D(GL_TEXTURE_2D, 0, GL_RED, 512,512, 0, GL_RED, GL_UNSIGNED_BYTE,texs); GDALClose( (GDALDatasetH) poDataset); return; }
int readRaster(const char* pszFilename) { // Set config options for GDAL (needs >= 2.0). Setting GTIFF_VIRTUAL_MEM_IO to "YES" can cause things bleed to // swap if enough RAM is not available. Use "IF_ENOUGH_RAM" for safer performance if unsure. NOTE that faster // mem io only works with *uncompressed* GeoTIFFs. // New in GDAL 2.0, from https://2015.foss4g-na.org/sites/default/files/slides/GDAL%202.0%20overview.pdf // GeoTIFF driver (with i7-4700 HQ (8 vCPUs)):with i7-4700 HQ (8 vCPUs) // - Default: time ./testblockcache -ondisk: 7.5s // - GTIFF_DIRECT_IO=YES: short circuit the block cache&libtiff for most RasterIO() operations (restricted to // uncompressed stripped GeoTIFF). time ./testblockcache -ondisk: 2s // - GTIFF_VIRTUAL_MEM_IO=YES: same as above, with tiled GeoTIFF as well. Uses memory-mapped file access. Linux // only for now, 64bit recommended (could be extended to other platforms possible). // time ./testblockcache -ondisk: 0.3s // CPLSetConfigOption("GTIFF_VIRTUAL_MEM_IO", "YES" ); // Open the dataset GDALDataset *poDataset; GDALAllRegister(); poDataset = (GDALDataset *) GDALOpen( pszFilename, GA_ReadOnly ); if( poDataset == NULL ) { std::cout << "Dataset " << pszFilename << " could not be opened." << std::endl; return -1; } else { GDALRasterBand *poBand; int nBlockXSize, nBlockYSize; int bGotMin, bGotMax; double adfMinMax[2]; // Get raster band and its size poBand = poDataset->GetRasterBand(1); poBand->GetBlockSize( &nBlockXSize, &nBlockYSize); std::cout << "Dataset: " << pszFilename << std::endl; std::cout << "Block=" << nBlockXSize << "x" << nBlockYSize << " Type=" << GDALGetDataTypeName(poBand->GetRasterDataType()) << " ColorInterp=" << GDALGetColorInterpretationName(poBand->GetColorInterpretation()) << std::endl; // Calculate some stats adfMinMax[0] = poBand->GetMinimum(&bGotMin); adfMinMax[1] = poBand->GetMaximum(&bGotMax); if(!(bGotMin && bGotMax)) { GDALComputeRasterMinMax((GDALRasterBandH) poBand, TRUE, adfMinMax); } std::cout << "Min=" << adfMinMax[0] << " Max=" << adfMinMax[1] << std::endl; if(poBand->GetOverviewCount() > 0) { std::cout << "Band has " << poBand->GetOverviewCount() << " overviews." << std::endl; } if( poBand->GetColorTable() != NULL ) { std::cout << "Band has a color table with " << poBand->GetColorTable()->GetColorEntryCount() << " entries." << std::endl; } // Get the actual data float *pafScanline; int nXSize = poBand->GetXSize(); pafScanline = (float *) CPLMalloc(sizeof(float) * nXSize); // RasterIO has a new argument psExtraArg in GDAL > 2.0. NOTE: that GDALRasterBand::ReadBlock() probably has // better performance for reading the whole data at one go. #ifdef USE_GDAL_2 GDALRasterIOExtraArg* arg = NULL; poBand->RasterIO(GF_Read, 0, 0, nXSize, 1, pafScanline, nXSize, 1, GDT_Float3GDALRasterBand::ReadBlock 2, 0, 0, arg); #else poBand->RasterIO(GF_Read, 0, 0, nXSize, 1, pafScanline, nXSize, 1, GDT_Float32, 0, 0); #endif // ... do something with the data ... // Free resources CPLFree(pafScanline); GDALClose((GDALDatasetH) poDataset); std::cout << std::endl; } return 0; }
bool vtImageGeo::ReadTIF(const char *filename, bool progress_callback(int)) { // Use GDAL to read a TIF file (or any other format that GDAL is // configured to read) into this OSG image. bool bRet = true; vtString message; setFileName(filename); g_GDALWrapper.RequestGDALFormats(); GDALDataset *pDataset = NULL; GDALRasterBand *pBand; GDALRasterBand *pRed = NULL; GDALRasterBand *pGreen = NULL; GDALRasterBand *pBlue = NULL; GDALRasterBand *pAlpha = NULL; GDALColorTable *pTable; uchar *pScanline = NULL; uchar *pRedline = NULL; uchar *pGreenline = NULL; uchar *pBlueline = NULL; uchar *pAlphaline = NULL; CPLErr Err; bool bColorPalette = false; int iXSize, iYSize; int nxBlocks, nyBlocks; int xBlockSize, yBlockSize; try { pDataset = (GDALDataset *) GDALOpen(filename, GA_ReadOnly); if(pDataset == NULL ) throw "Couldn't open that file."; // Get size iXSize = pDataset->GetRasterXSize(); iYSize = pDataset->GetRasterYSize(); // Try getting CRS vtProjection temp; bool bHaveProj = false; const char *pProjectionString = pDataset->GetProjectionRef(); if (pProjectionString) { OGRErr err = temp.importFromWkt((char**)&pProjectionString); if (err == OGRERR_NONE) { m_proj = temp; bHaveProj = true; } } if (!bHaveProj) { // check for existence of .prj file bool bSuccess = temp.ReadProjFile(filename); if (bSuccess) { m_proj = temp; bHaveProj = true; } } // Try getting extents double affineTransform[6]; if (pDataset->GetGeoTransform(affineTransform) == CE_None) { m_extents.left = affineTransform[0]; m_extents.right = m_extents.left + affineTransform[1] * iXSize; m_extents.top = affineTransform[3]; m_extents.bottom = m_extents.top + affineTransform[5] * iYSize; } // Raster count should be 3 for colour images (assume RGB) int iRasterCount = pDataset->GetRasterCount(); if (iRasterCount != 1 && iRasterCount != 3 && iRasterCount != 4) { message.Format("Image has %d bands (not 1, 3, or 4).", iRasterCount); throw (const char *)message; } if (iRasterCount == 1) { pBand = pDataset->GetRasterBand(1); // Check the band's data type GDALDataType dtype = pBand->GetRasterDataType(); if (dtype != GDT_Byte) { message.Format("Band is of type %s, but we support type Byte.", GDALGetDataTypeName(dtype)); throw (const char *)message; } GDALColorInterp ci = pBand->GetColorInterpretation(); if (ci == GCI_PaletteIndex) { if (NULL == (pTable = pBand->GetColorTable())) throw "Couldn't get color table."; bColorPalette = true; } else if (ci == GCI_GrayIndex) { // we will assume 0-255 is black to white } else throw "Unsupported color interpretation."; pBand->GetBlockSize(&xBlockSize, &yBlockSize); nxBlocks = (iXSize + xBlockSize - 1) / xBlockSize; nyBlocks = (iYSize + yBlockSize - 1) / yBlockSize; if (NULL == (pScanline = new uchar[xBlockSize * yBlockSize])) throw "Couldnt allocate scan line."; } if (iRasterCount == 3) { for (int i = 1; i <= 3; i++) { pBand = pDataset->GetRasterBand(i); // Check the band's data type GDALDataType dtype = pBand->GetRasterDataType(); if (dtype != GDT_Byte) { message.Format("Band is of type %s, but we support type Byte.", GDALGetDataTypeName(dtype)); throw (const char *)message; } switch (pBand->GetColorInterpretation()) { case GCI_RedBand: pRed = pBand; break; case GCI_GreenBand: pGreen = pBand; break; case GCI_BlueBand: pBlue = pBand; break; } } if ((NULL == pRed) || (NULL == pGreen) || (NULL == pBlue)) throw "Couldn't find bands for Red, Green, Blue."; pRed->GetBlockSize(&xBlockSize, &yBlockSize); nxBlocks = (iXSize + xBlockSize - 1) / xBlockSize; nyBlocks = (iYSize + yBlockSize - 1) / yBlockSize; pRedline = new uchar[xBlockSize * yBlockSize]; pGreenline = new uchar[xBlockSize * yBlockSize]; pBlueline = new uchar[xBlockSize * yBlockSize]; } if (iRasterCount == 4) { #if VTDEBUG VTLOG1("Band interpretations:"); #endif for (int i = 1; i <= 4; i++) { pBand = pDataset->GetRasterBand(i); // Check the band's data type GDALDataType dtype = pBand->GetRasterDataType(); if (dtype != GDT_Byte) { message.Format("Band is of type %s, but we support type Byte.", GDALGetDataTypeName(dtype)); throw (const char *)message; } GDALColorInterp ci = pBand->GetColorInterpretation(); #if VTDEBUG VTLOG(" %d", ci); #endif switch (ci) { case GCI_RedBand: pRed = pBand; break; case GCI_GreenBand: pGreen = pBand; break; case GCI_BlueBand: pBlue = pBand; break; case GCI_AlphaBand: pAlpha = pBand; break; case GCI_Undefined: // If we have four bands: R,G,B,undefined, then assume that // the undefined one is actually alpha if (pRed && pGreen && pBlue && !pAlpha) pAlpha = pBand; break; } } #if VTDEBUG VTLOG1("\n"); #endif if ((NULL == pRed) || (NULL == pGreen) || (NULL == pBlue) || (NULL == pAlpha)) throw "Couldn't find bands for Red, Green, Blue, Alpha."; pRed->GetBlockSize(&xBlockSize, &yBlockSize); nxBlocks = (iXSize + xBlockSize - 1) / xBlockSize; nyBlocks = (iYSize + yBlockSize - 1) / yBlockSize; pRedline = new uchar[xBlockSize * yBlockSize]; pGreenline = new uchar[xBlockSize * yBlockSize]; pBlueline = new uchar[xBlockSize * yBlockSize]; pAlphaline = new uchar[xBlockSize * yBlockSize]; } // Allocate the image buffer if (iRasterCount == 4) { Create(iXSize, iYSize, 32); } else if (iRasterCount == 3 || bColorPalette) { Create(iXSize, iYSize, 24); } else if (iRasterCount == 1) Create(iXSize, iYSize, 8); // Read the data #if LOG_IMAGE_LOAD VTLOG("Reading the image data (%d x %d pixels)\n", iXSize, iYSize); #endif int x, y; int ixBlock, iyBlock; int nxValid, nyValid; int iY, iX; RGBi rgb; RGBAi rgba; if (iRasterCount == 1) { GDALColorEntry Ent; for (iyBlock = 0; iyBlock < nyBlocks; iyBlock++) { if (progress_callback != NULL) progress_callback(iyBlock * 100 / nyBlocks); y = iyBlock * yBlockSize; for (ixBlock = 0; ixBlock < nxBlocks; ixBlock++) { x = ixBlock * xBlockSize; Err = pBand->ReadBlock(ixBlock, iyBlock, pScanline); if (Err != CE_None) throw "Problem reading the image data."; // Compute the portion of the block that is valid // for partial edge blocks. if ((ixBlock+1) * xBlockSize > iXSize) nxValid = iXSize - ixBlock * xBlockSize; else nxValid = xBlockSize; if( (iyBlock+1) * yBlockSize > iYSize) nyValid = iYSize - iyBlock * yBlockSize; else nyValid = yBlockSize; for( iY = 0; iY < nyValid; iY++ ) { for( iX = 0; iX < nxValid; iX++ ) { if (bColorPalette) { pTable->GetColorEntryAsRGB(pScanline[iY * xBlockSize + iX], &Ent); rgb.r = (uchar) Ent.c1; rgb.g = (uchar) Ent.c2; rgb.b = (uchar) Ent.c3; SetPixel24(x + iX, y + iY, rgb); } else SetPixel8(x + iX, y + iY, pScanline[iY * xBlockSize + iX]); } } } } } if (iRasterCount >= 3) { for (iyBlock = 0; iyBlock < nyBlocks; iyBlock++) { if (progress_callback != NULL) progress_callback(iyBlock * 100 / nyBlocks); y = iyBlock * yBlockSize; for (ixBlock = 0; ixBlock < nxBlocks; ixBlock++) { x = ixBlock * xBlockSize; Err = pRed->ReadBlock(ixBlock, iyBlock, pRedline); if (Err != CE_None) throw "Cannot read data."; Err = pGreen->ReadBlock(ixBlock, iyBlock, pGreenline); if (Err != CE_None) throw "Cannot read data."; Err = pBlue->ReadBlock(ixBlock, iyBlock, pBlueline); if (Err != CE_None) throw "Cannot read data."; if (iRasterCount == 4) { Err = pAlpha->ReadBlock(ixBlock, iyBlock, pAlphaline); if (Err != CE_None) throw "Cannot read data."; } // Compute the portion of the block that is valid // for partial edge blocks. if ((ixBlock+1) * xBlockSize > iXSize) nxValid = iXSize - ixBlock * xBlockSize; else nxValid = xBlockSize; if( (iyBlock+1) * yBlockSize > iYSize) nyValid = iYSize - iyBlock * yBlockSize; else nyValid = yBlockSize; for (int iY = 0; iY < nyValid; iY++) { for (int iX = 0; iX < nxValid; iX++) { if (iRasterCount == 3) { rgb.r = pRedline[iY * xBlockSize + iX]; rgb.g = pGreenline[iY * xBlockSize + iX]; rgb.b = pBlueline[iY * xBlockSize + iX]; SetPixel24(x + iX, y + iY, rgb); } else if (iRasterCount == 4) { rgba.r = pRedline[iY * xBlockSize + iX]; rgba.g = pGreenline[iY * xBlockSize + iX]; rgba.b = pBlueline[iY * xBlockSize + iX]; rgba.a = pAlphaline[iY * xBlockSize + iX]; SetPixel32(x + iX, y + iY, rgba); } } } } } } } catch (const char *msg) { VTLOG1("Problem: "); VTLOG1(msg); VTLOG1("\n"); bRet = false; } if (NULL != pDataset) GDALClose(pDataset); if (NULL != pScanline) delete pScanline; if (NULL != pRedline) delete pRedline; if (NULL != pGreenline) delete pGreenline; if (NULL != pBlueline) delete pBlueline; if (NULL != pAlphaline) delete pAlphaline; return bRet; }
CPLErr GDALDefaultOverviews::CreateMaskBand( int nFlags, int nBand ) { if( nBand < 1 ) nFlags |= GMF_PER_DATASET; /* -------------------------------------------------------------------- */ /* ensure existing file gets opened if there is one. */ /* -------------------------------------------------------------------- */ HaveMaskFile(); /* -------------------------------------------------------------------- */ /* Try creating the mask file. */ /* -------------------------------------------------------------------- */ if( poMaskDS == NULL ) { CPLString osMskFilename; GDALDriver *poDr = (GDALDriver *) GDALGetDriverByName( "GTiff" ); char **papszOpt = NULL; int nBX, nBY; int nBands; if( poDr == NULL ) return CE_Failure; GDALRasterBand *poTBand = poDS->GetRasterBand(1); if( poTBand == NULL ) return CE_Failure; if( nFlags & GMF_PER_DATASET ) nBands = 1; else nBands = poDS->GetRasterCount(); papszOpt = CSLSetNameValue( papszOpt, "COMPRESS", "DEFLATE" ); papszOpt = CSLSetNameValue( papszOpt, "INTERLEAVE", "BAND" ); poTBand->GetBlockSize( &nBX, &nBY ); // try to create matching tile size if legal in TIFF. if( (nBX % 16) == 0 && (nBY % 16) == 0 ) { papszOpt = CSLSetNameValue( papszOpt, "TILED", "YES" ); papszOpt = CSLSetNameValue( papszOpt, "BLOCKXSIZE", CPLString().Printf("%d",nBX) ); papszOpt = CSLSetNameValue( papszOpt, "BLOCKYSIZE", CPLString().Printf("%d",nBY) ); } osMskFilename.Printf( "%s.msk", poDS->GetDescription() ); poMaskDS = poDr->Create( osMskFilename, poDS->GetRasterXSize(), poDS->GetRasterYSize(), nBands, GDT_Byte, papszOpt ); CSLDestroy( papszOpt ); if( poMaskDS == NULL ) // presumably error already issued. return CE_Failure; bOwnMaskDS = TRUE; } /* -------------------------------------------------------------------- */ /* Save the mask flags for this band. */ /* -------------------------------------------------------------------- */ if( nBand > poMaskDS->GetRasterCount() ) { CPLError( CE_Failure, CPLE_AppDefined, "Attempt to create a mask band for band %d of %s,\n" "but the .msk file has a PER_DATASET mask.", nBand, poDS->GetDescription() ); return CE_Failure; } int iBand; for( iBand = 0; iBand < poDS->GetRasterCount(); iBand++ ) { // we write only the info for this band, unless we are // using PER_DATASET in which case we write for all. if( nBand != iBand + 1 && !(nFlags | GMF_PER_DATASET) ) continue; poMaskDS->SetMetadataItem( CPLString().Printf("INTERNAL_MASK_FLAGS_%d", iBand+1 ), CPLString().Printf("%d", nFlags ) ); } return CE_None; }
GDALDataset *ARGDataset::CreateCopy( const char *pszFilename, GDALDataset *poSrcDS, int /* bStrict */ , char ** /* papszOptions */ , GDALProgressFunc /* pfnProgress */ , void * /*pProgressData */ ) { const int nBands = poSrcDS->GetRasterCount(); if( nBands != 1 ) { CPLError( CE_Failure, CPLE_NotSupported, "ARG driver doesn't support %d bands. Must be 1 band.", nBands ); return nullptr; } CPLString pszDataType; int nPixelOffset = 0; GDALDataType eType = poSrcDS->GetRasterBand(1)->GetRasterDataType(); if( eType == GDT_Unknown || eType == GDT_CInt16 || eType == GDT_CInt32 || eType == GDT_CFloat32 || eType == GDT_CFloat64 ) { CPLError( CE_Failure, CPLE_NotSupported, "ARG driver doesn't support data type %s.", GDALGetDataTypeName(eType) ); return nullptr; } else if (eType == GDT_Int16) { pszDataType = "int16"; nPixelOffset = 2; } else if (eType == GDT_Int32) { pszDataType = "int32"; nPixelOffset = 4; } else if (eType == GDT_Byte) { pszDataType = "uint8"; nPixelOffset = 1; } else if (eType == GDT_UInt16) { pszDataType = "uint16"; nPixelOffset = 2; } else if (eType == GDT_UInt32) { pszDataType = "uint32"; nPixelOffset = 4; } else if (eType == GDT_Float32) { pszDataType = "float32"; nPixelOffset = 4; } else if (eType == GDT_Float64) { pszDataType = "float64"; nPixelOffset = 8; } double adfTransform[6]; poSrcDS->GetGeoTransform( adfTransform ); const char *pszWKT = poSrcDS->GetProjectionRef(); OGRSpatialReference oSRS; OGRErr nErr = oSRS.importFromWkt(pszWKT); if (nErr != OGRERR_NONE) { CPLError( CE_Failure, CPLE_NotSupported, "Cannot import spatial reference WKT from source dataset."); return nullptr; } int nSrs = 0; if (oSRS.GetAuthorityCode("PROJCS") != nullptr) { nSrs = atoi(oSRS.GetAuthorityCode("PROJCS")); } else if (oSRS.GetAuthorityCode("GEOGCS") != nullptr) { nSrs = atoi(oSRS.GetAuthorityCode("GEOGCS")); } else { // could not determine projected or geographic code // default to EPSG:3857 if no code could be found nSrs = 3857; } /********************************************************************/ /* Create JSON companion file. */ /********************************************************************/ const CPLString osJSONFilename = GetJsonFilename(pszFilename); json_object *poJSONObject = json_object_new_object(); char **pszTokens = poSrcDS->GetMetadata(); const char *pszLayer = CSLFetchNameValue(pszTokens, "LAYER"); if ( pszLayer == nullptr) { // Set the layer json_object_object_add(poJSONObject, "layer", json_object_new_string( CPLGetBasename(osJSONFilename) )); } else { // Set the layer json_object_object_add(poJSONObject, "layer", json_object_new_string( pszLayer )); } // Set the type json_object_object_add(poJSONObject, "type", json_object_new_string("arg")); // Set the datatype json_object_object_add(poJSONObject, "datatype", json_object_new_string(pszDataType)); const int nXSize = poSrcDS->GetRasterXSize(); const int nYSize = poSrcDS->GetRasterYSize(); // Set the number of rows json_object_object_add(poJSONObject, "rows", json_object_new_int(nYSize)); // Set the number of columns json_object_object_add(poJSONObject, "cols", json_object_new_int(nXSize)); // Set the xmin json_object_object_add(poJSONObject, "xmin", json_object_new_double(adfTransform[0])); // Set the ymax json_object_object_add(poJSONObject, "ymax", json_object_new_double(adfTransform[3])); // Set the cellwidth json_object_object_add(poJSONObject, "cellwidth", json_object_new_double(adfTransform[1])); // Set the cellheight json_object_object_add(poJSONObject, "cellheight", json_object_new_double(-adfTransform[5])); // Set the xmax json_object_object_add(poJSONObject, "xmax", json_object_new_double(adfTransform[0] + nXSize * adfTransform[1])); // Set the ymin json_object_object_add(poJSONObject, "ymin", json_object_new_double(adfTransform[3] + nYSize * adfTransform[5])); // Set the xskew json_object_object_add(poJSONObject, "xskew", json_object_new_double(adfTransform[2])); // Set the yskew json_object_object_add(poJSONObject, "yskew", json_object_new_double(adfTransform[4])); if (nSrs > 0) { // Set the epsg json_object_object_add(poJSONObject, "epsg", json_object_new_int(nSrs)); } if (json_object_to_file(const_cast<char *>(osJSONFilename.c_str()), poJSONObject) < 0) { CPLError( CE_Failure, CPLE_NotSupported, "ARG driver can't write companion file."); json_object_put(poJSONObject); poJSONObject = nullptr; return nullptr; } json_object_put(poJSONObject); poJSONObject = nullptr; VSILFILE *fpImage = VSIFOpenL(pszFilename, "wb"); if (fpImage == nullptr) { CPLError( CE_Failure, CPLE_NotSupported, "ARG driver can't create data file %s.", pszFilename); // remove JSON file VSIUnlink( osJSONFilename.c_str() ); return nullptr; } // only 1 raster band GDALRasterBand *poSrcBand = poSrcDS->GetRasterBand( 1 ); #ifdef CPL_LSB bool bNative = false; #else bool bNative = true; #endif RawRasterBand *poDstBand = new RawRasterBand( fpImage, 0, nPixelOffset, nPixelOffset * nXSize, eType, bNative, nXSize, nYSize, RawRasterBand::OwnFP::NO); int nXBlockSize, nYBlockSize; poSrcBand->GetBlockSize(&nXBlockSize, &nYBlockSize); void *pabyData = CPLMalloc(nXBlockSize * nPixelOffset); // convert any blocks into scanlines for (int nYBlock = 0; nYBlock * nYBlockSize < nYSize; nYBlock++) { for (int nYScanline = 0; nYScanline < nYBlockSize; nYScanline++) { if ((nYScanline+1) + nYBlock * nYBlockSize > poSrcBand->GetYSize() ) { continue; } for (int nXBlock = 0; nXBlock * nXBlockSize < nXSize; nXBlock++) { int nXValid; if( (nXBlock+1) * nXBlockSize > poSrcBand->GetXSize() ) nXValid = poSrcBand->GetXSize() - nXBlock * nXBlockSize; else nXValid = nXBlockSize; CPLErr eErr = poSrcBand->RasterIO(GF_Read, nXBlock * nXBlockSize, nYBlock * nYBlockSize + nYScanline, nXValid, 1, pabyData, nXBlockSize, 1, eType, 0, 0, nullptr); if (eErr != CE_None) { CPLError(CE_Failure, CPLE_AppDefined, "Error reading."); CPLFree( pabyData ); delete poDstBand; VSIFCloseL( fpImage ); return nullptr; } eErr = poDstBand->RasterIO(GF_Write, nXBlock * nXBlockSize, nYBlock * nYBlockSize + nYScanline, nXValid, 1, pabyData, nXBlockSize, 1, eType, 0, 0, nullptr); if (eErr != CE_None) { CPLError(CE_Failure, CPLE_AppDefined, "Error writing."); CPLFree( pabyData ); delete poDstBand; VSIFCloseL( fpImage ); return nullptr; } } } } CPLFree( pabyData ); delete poDstBand; VSIFCloseL( fpImage ); return reinterpret_cast<GDALDataset *>( GDALOpen( pszFilename, GA_ReadOnly ) ); }
bool DEM::load(const std::string& filename) { GDALAllRegister(); GDALDataset* poDS; poDS = (GDALDataset*)GDALOpenEx(filename.c_str(), GDAL_OF_RASTER, NULL, NULL, NULL); if (poDS == NULL) return false; double adfGeoTransform[6]; if (poDS->GetGeoTransform(adfGeoTransform) == CE_None) { origin.x = adfGeoTransform[0]; origin.y = adfGeoTransform[3]; pixelSize.x = adfGeoTransform[1]; pixelSize.y = abs(adfGeoTransform[5]); } width = poDS->GetRasterXSize() * pixelSize.x; height = poDS->GetRasterYSize() * pixelSize.y; data.resize(width * height); min_val = std::numeric_limits<float>::max(); max_val = -std::numeric_limits<float>::max(); // bandが存在しない場合は、エラー if (poDS->GetRasterCount() == 0) return false; // 最初のbandのみを読み込む。複数bandは未対応 GDALRasterBand* poBand = poDS->GetRasterBand(1); int nBlockXSize, nBlockYSize; poBand->GetBlockSize(&nBlockXSize, &nBlockYSize); //printf("Block=%dx%d Type=%s, ColorInterp=%s\n", nBlockXSize, nBlockYSize, GDALGetDataTypeName(poBand->GetRasterDataType()), GDALGetColorInterpretationName(poBand->GetColorInterpretation())); // 最低、最高の値を取得 int bGotMin, bGotMax; double adfMinMax[2]; adfMinMax[0] = poBand->GetMinimum(&bGotMin); adfMinMax[1] = poBand->GetMaximum(&bGotMax); if (!(bGotMin && bGotMax)) GDALComputeRasterMinMax((GDALRasterBandH)poBand, TRUE, adfMinMax); //printf("Min=%.3fd, Max=%.3f\n", adfMinMax[0], adfMinMax[1]); min_val = adfMinMax[0]; max_val = adfMinMax[1]; //int nXSize = poBand->GetXSize(); //int nYSize = poBand->GetYSize(); int nXBlocks = (poBand->GetXSize() + nBlockXSize - 1) / nBlockXSize; int nYBlocks = (poBand->GetYSize() + nBlockYSize - 1) / nBlockYSize; float *pData = (float *)CPLMalloc(sizeof(float*) * nBlockXSize * nBlockYSize); for (int iYBlock = 0; iYBlock < nYBlocks; iYBlock++) { for (int iXBlock = 0; iXBlock < nXBlocks; iXBlock++) { int nXValid, nYValid; poBand->ReadBlock(iXBlock, iYBlock, pData); // Compute the portion of the block that is valid // for partial edge blocks. if ((iXBlock + 1) * nBlockXSize > poBand->GetXSize()) nXValid = poBand->GetXSize() - iXBlock * nBlockXSize; else nXValid = nBlockXSize; if ((iYBlock + 1) * nBlockYSize > poBand->GetYSize()) nYValid = poBand->GetYSize() - iYBlock * nBlockYSize; else nYValid = nBlockYSize; for (int iY = 0; iY < nYValid; iY++) { for (int iX = 0; iX < nXValid; iX++) { float val; if (pData[iY * nBlockXSize + iX] > max_val) { val = max_val; } else if (pData[iY * nBlockXSize + iX] < min_val) { val = min_val; } else { val = pData[iY * nBlockXSize + iX]; } for (int y = 0; y < pixelSize.y; ++y) { for (int x = 0; x < pixelSize.x; ++x) { data[((iYBlock * nBlockYSize + iY) * pixelSize.y + y) * width + (iXBlock * nBlockXSize + iX) * pixelSize.x + x] = val; } } } } } } GDALClose(poDS); return true; }