GDALDataset* openGDALDataSet() { cout << "Opening " << inDataFile->c_str() << "...\n"; GDALDataset* ds = (GDALDataset *)GDALOpen(inDataFile->c_str(), GA_ReadOnly); if (ds != NULL) { GDALDriver* drv = ds->GetDriver(); if (drv == NULL) { cout << " -- Unable to find GDAL driver for " << (char *)inDataFile->c_str() << " -- "; ds = NULL; } else { cout << "GDAL FILE TYPE: " << drv->GetDescription() << "\n"; cout << "CONTAINS " << ds->GetRasterCount() << " dataset(s); size " << ds->GetRasterXSize() << "x" << ds->GetRasterYSize() << "\n"; if (ds->GetRasterCount() == 0) { ds = NULL; cout << " -- FILE " << (char *)inDataFile->c_str() << " contains zero raster bands -- "; } } } else cout << " -- Unable to open " << (char *)inDataFile->c_str() << " -- "; cout << "...Done.\n"; return ds; }
int PDSDataset::ParseCompressedImage() { CPLString osFileName = GetKeyword( "COMPRESSED_FILE.FILE_NAME", "" ); CleanString( osFileName ); CPLString osPath = CPLGetPath(GetDescription()); CPLString osFullFileName = CPLFormFilename( osPath, osFileName, NULL ); int iBand; poCompressedDS = (GDALDataset*) GDALOpen( osFullFileName, GA_ReadOnly ); if( poCompressedDS == NULL ) return FALSE; nRasterXSize = poCompressedDS->GetRasterXSize(); nRasterYSize = poCompressedDS->GetRasterYSize(); for( iBand = 0; iBand < poCompressedDS->GetRasterCount(); iBand++ ) { SetBand( iBand+1, new PDSWrapperRasterBand( poCompressedDS->GetRasterBand( iBand+1 ) ) ); } return TRUE; }
/*! \file io.cpp With a little bit of a elaboration, should you feel it necessary. */ int printRasterInfo(const char* pszFilename) { /** An enum type. * The documentation block cannot be put after the enum! */ 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 { std::cout << "Dataset: " << pszFilename << std::endl; double adfGeoTransform[6]; std::cout << " Driver: " << poDataset->GetDriver()->GetDescription() << "/" << poDataset->GetDriver()->GetMetadataItem( GDAL_DMD_LONGNAME ) << std::endl; std::cout << " Size: " << poDataset->GetRasterXSize() << "x" << poDataset->GetRasterYSize() << "x" << poDataset->GetRasterCount() << std::endl; if( poDataset->GetProjectionRef() != NULL ) std::cout << " Projection: " << poDataset->GetProjectionRef() << std::endl; if( poDataset->GetGeoTransform( adfGeoTransform ) == CE_None ) { std::cout << " Origin: (" << adfGeoTransform[0] << ", " << adfGeoTransform[3] << ")" << std::endl; std::cout << " Pixel Size: (" << adfGeoTransform[1] << ", " << adfGeoTransform[5] << std::endl; } } return 0; }
/** *@brief tif图片投影转换 *@param tifPath [in] tif图片路径 *@param toWkt [in] 目标点的wkt字符串 *@param outPath [in] 转换后文件路径 *@return */ void GdalProjection::TifProjectionTransformation(const char *tifPath, const char *toWkt,const char *outPath) { GDALDataset *poDataset = gbase.OpenDatasetR(tifPath); const char *fromWkt = poDataset->GetProjectionRef(); //double *adfGeoTransform = (double *)CPLMalloc(sizeof(double) * 6); //int x = poDataset->GetRasterXSize(); //int y = poDataset->GetRasterYSize(); int bands = poDataset->GetRasterCount(); double adfGeoTransform[6]; GDALDataType gdt = poDataset->GetRasterBand(1)->GetRasterDataType(); void *hTransformArg; //cout<<fromWkt; hTransformArg = GDALCreateGenImgProjTransformer(poDataset,fromWkt,NULL,toWkt,FALSE,0,1); //cout<<toWkt<<endl; int nPixels = 0,nLines = 0; CPLErr eErr; eErr = GDALSuggestedWarpOutput(poDataset,GDALGenImgProjTransform,hTransformArg, adfGeoTransform,&nPixels,&nLines); //cout<<nPixels<<" : "<<nLines<<endl; //创建转换后的投影和坐标系的空图像 CreateTiff(outPath,gdt,toWkt,adfGeoTransform,nPixels,nLines,bands); ////重投影 TifReProjection(tifPath,outPath); }
void RasterImageLayer::loadFile() { GDALDataset *ds = static_cast<GDALDataset*>(GDALOpen(m_filename.toLocal8Bit(), GA_ReadOnly)); if (ds == nullptr) { qWarning() << "Error opening file:" << m_filename; } else { projection().setGeogCS(new OGRSpatialReference(ds->GetProjectionRef())); projection().setProjCS(new OGRSpatialReference(ds->GetProjectionRef())); projection().setDomain({-180., -90., 360., 180.}); std::vector<double> geoTransform(6); int xsize = ds->GetRasterXSize(); int ysize = ds->GetRasterYSize(); ds->GetGeoTransform(geoTransform.data()); vertData.resize(4); vertData[0] = QVector2D(geoTransform[0], geoTransform[3]); vertData[1] = QVector2D(geoTransform[0] + geoTransform[2] * ysize, geoTransform[3] + geoTransform[5] * ysize); vertData[2] = QVector2D(geoTransform[0] + geoTransform[1] * xsize + geoTransform[2] * ysize, geoTransform[3] + geoTransform[4] * xsize + geoTransform[5] * ysize); vertData[3] = QVector2D(geoTransform[0] + geoTransform[1] * xsize, geoTransform[3] + geoTransform[4] * xsize); texData = {{0., 0.}, {0., 1.}, {1., 1.}, {1., 0.}}; int numBands = ds->GetRasterCount(); qDebug() << "Bands:" << numBands; imData = QImage(xsize, ysize, QImage::QImage::Format_RGBA8888); imData.fill(QColor(255, 255, 255, 255)); // Bands start at 1 for (int i = 1; i <= numBands; ++i) { GDALRasterBand *band = ds->GetRasterBand(i); switch(band->GetColorInterpretation()) { case GCI_RedBand: band->RasterIO(GF_Read, 0, 0, xsize, ysize, imData.bits(), xsize, ysize, GDT_Byte, 4, 0); break; case GCI_GreenBand: band->RasterIO(GF_Read, 0, 0, xsize, ysize, imData.bits() + 1, xsize, ysize, GDT_Byte, 4, 0); break; case GCI_BlueBand: band->RasterIO(GF_Read, 0, 0, xsize, ysize, imData.bits() + 2, xsize, ysize, GDT_Byte, 4, 0); break; default: qWarning() << "Unhandled color interpretation:" << band->GetColorInterpretation(); } } GDALClose(ds); newFile = true; } }
SEXP RGDAL_GetRasterCount(SEXP sDataset) { GDALDataset *pDataset = getGDALDatasetPtr(sDataset); return(ScalarInteger(pDataset->GetRasterCount())); }
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; }
bool rgb_image::read_image() { int fd; int i; unsigned char header[16]; unsigned char jfif[] = { 0xff, 0xd8, 0xff, 0xe0, 0x00, 0x10, 0x4a, 0x46, 0x49, 0x46, 0x00, 0x01, 0x01, 0x00, 0x00, 0x01 }; GDALDataset *df; GDALRasterBand *bd; int bands; fd = open ( pathname.c_str(), O_RDWR ); if ( fd < 0 ) { fprintf(stderr,"Could not open %s to patch jpeg header\n", pathname.c_str() ); return false; } read ( fd, header, 16 ); if ( bcmp(header,jfif,4) != 0 ) { fprintf(stderr,"Apparently %s is not a jpeg file\n", pathname.c_str() ); return false; } if ( bcmp(header,jfif,16) != 0 ) { lseek ( fd, (off_t)0, SEEK_SET ); write ( fd, jfif, 16 ); } close ( fd ); df = (GDALDataset *) GDALOpen( pathname.c_str(), GA_ReadOnly ); if( df == NULL ) { fprintf(stderr,"Could not open %s\n", pathname.c_str() ); exit(1); } rows = df->GetRasterYSize(); cols = df->GetRasterXSize(); bands = df->GetRasterCount(); //create_image(rows,cols); if ( bands < 3 ) { fprintf(stderr,"%s does not have 3 bands\n", pathname.c_str() ); delete df; return false; } for ( i = 0; i < 3; i++ ) { bd = df->GetRasterBand(i+1); bd->RasterIO ( GF_Read, 0,0, cols, rows, img[i].data, cols, rows, GDT_Byte, 0,0); } delete df; }
Handle<Value> DatasetBands::create(const Arguments& args) { HandleScope scope; Handle<Object> parent = args.This()->GetHiddenValue(String::NewSymbol("parent_"))->ToObject(); Dataset *ds = ObjectWrap::Unwrap<Dataset>(parent); if (ds->uses_ogr){ return NODE_THROW("Dataset does not support getting creating bands"); } GDALDataset* raw = ds->getDataset(); if (!raw) { return NODE_THROW("Dataset object has already been destroyed"); } GDALDataType type; Handle<Array> band_options = Array::New(0); char **options = NULL; std::string *options_str = NULL; //NODE_ARG_ENUM(0, "data type", GDALDataType, type); if(args.Length() < 1) { return NODE_THROW("data type argument needed"); } if(args[0]->IsString()){ std::string type_name = TOSTR(args[0]); type = GDALGetDataTypeByName(type_name.c_str()); } else if (args[0]->IsNull() || args[0]->IsUndefined()) { type = GDT_Unknown; } else { return NODE_THROW("data type must be string or undefined"); } NODE_ARG_ARRAY_OPT(1, "band creation options", band_options); if (band_options->Length() > 0) { options = new char* [band_options->Length()]; options_str = new std::string [band_options->Length()]; for (unsigned int i = 0; i < band_options->Length(); ++i) { options_str[i] = TOSTR(band_options->Get(i)); options[i] = (char*) options_str[i].c_str(); } } CPLErr err = raw->AddBand(type, options); if(options) delete [] options; if(options_str) delete [] options_str; if (err) { return NODE_THROW_CPLERR(err); } return scope.Close(RasterBand::New(raw->GetRasterBand(raw->GetRasterCount()), raw)); }
bool gstIconManager::Validate(const std::string& path) { // ignore any non-png file if (!khHasExtension(path, "png") && !khHasExtension(path, "PNG")) return false; bool valid = false; GDALDataset* image = static_cast<GDALDataset*>( GDALOpen(path.c_str(), GA_ReadOnly)); if (image != NULL && (image->GetRasterCount() == 4 || (image->GetRasterCount() == 1 && image->GetRasterBand(1)->GetColorInterpretation() == GCI_PaletteIndex))) { valid = true; } delete image; return valid; }
bool ncepHrrrSurfInitialization::identify( std::string fileName ) { bool identified = true; if( fileName.find("nam") != fileName.npos ) { identified = false; return identified; } //ID based on 10u band GDALDataset *srcDS; srcDS = (GDALDataset*)GDALOpenShared( fileName.c_str(), GA_ReadOnly ); if( srcDS == NULL ) { CPLDebug( "ncepHRRRSurfaceInitialization::identify()", "Bad forecast file" ); return false; } if( srcDS->GetRasterCount() < 8 ) { /* Short circuit */ GDALClose( (GDALDatasetH)srcDS ); identified = false; return identified; } GDALRasterBand *poBand = srcDS->GetRasterBand( 33 ); //2010 structure const char *gc; gc = poBand->GetMetadataItem( "GRIB_COMMENT" ); std::string bandName( gc ); if( bandName.find( "u-component of wind [m/s]" ) == bandName.npos ){ poBand = srcDS->GetRasterBand( 49 ); //files after 2010 have different structure gc = poBand->GetMetadataItem( "GRIB_COMMENT" ); bandName = gc; if( bandName.find( "u-component of wind [m/s]" ) == bandName.npos ){ poBand = srcDS->GetRasterBand( 50 ); //2012 files have different structure gc = poBand->GetMetadataItem( "GRIB_COMMENT" ); bandName = gc; if( bandName.find( "u-component of wind [m/s]" ) == bandName.npos ){ poBand = srcDS->GetRasterBand( 53 ); //2013 files have different structure gc = poBand->GetMetadataItem( "GRIB_COMMENT" ); bandName = gc; if( bandName.find( "u-component of wind [m/s]" ) == bandName.npos ){ identified = false; } } } } GDALClose( (GDALDatasetH)srcDS ); return identified; }
int NBHeightMapper::loadTiff(const std::string& file) { #ifdef HAVE_GDAL GDALAllRegister(); GDALDataset* poDataset = (GDALDataset*)GDALOpen(file.c_str(), GA_ReadOnly); if (poDataset == 0) { WRITE_ERROR("Cannot load GeoTIFF file."); return 0; } const int xSize = poDataset->GetRasterXSize(); const int ySize = poDataset->GetRasterYSize(); double adfGeoTransform[6]; if (poDataset->GetGeoTransform(adfGeoTransform) == CE_None) { Position topLeft(adfGeoTransform[0], adfGeoTransform[3]); mySizeOfPixel.set(adfGeoTransform[1], adfGeoTransform[5]); const double horizontalSize = xSize * mySizeOfPixel.x(); const double verticalSize = ySize * mySizeOfPixel.y(); myBoundary.add(topLeft); myBoundary.add(topLeft.x() + horizontalSize, topLeft.y() + verticalSize); } else { WRITE_ERROR("Could not parse geo information from " + file + "."); return 0; } const int picSize = xSize * ySize; myRaster = (int16_t*)CPLMalloc(sizeof(int16_t) * picSize); for (int i = 1; i <= poDataset->GetRasterCount(); i++) { GDALRasterBand* poBand = poDataset->GetRasterBand(i); if (poBand->GetColorInterpretation() != GCI_GrayIndex) { WRITE_ERROR("Unknown color band in " + file + "."); clearData(); break; } if (poBand->GetRasterDataType() != GDT_Int16) { WRITE_ERROR("Unknown data type in " + file + "."); clearData(); break; } assert(xSize == poBand->GetXSize() && ySize == poBand->GetYSize()); if (poBand->RasterIO(GF_Read, 0, 0, xSize, ySize, myRaster, xSize, ySize, GDT_Int16, 0, 0) == CE_Failure) { WRITE_ERROR("Failure in reading " + file + "."); clearData(); break; } } GDALClose(poDataset); return picSize; #else UNUSED_PARAMETER(file); WRITE_ERROR("Cannot load GeoTIFF file since SUMO was compiled without GDAL support."); return 0; #endif }
SEXP RGDAL_GetRasterCount(SEXP sDataset) { GDALDataset *pDataset = getGDALDatasetPtr(sDataset); int res; installErrorHandler(); res = pDataset->GetRasterCount(); uninstallErrorHandlerAndTriggerError(); return(ScalarInteger(res)); }
bool vtImageInfo(const char *filename, int &width, int &height, int &depth) { g_GDALWrapper.RequestGDALFormats(); // open the input image and find out the image depth using gdal GDALDataset *poDataset; poDataset = (GDALDataset *) GDALOpen(filename, GA_ReadOnly); if (!poDataset) return false; width = poDataset->GetRasterXSize(); height = poDataset->GetRasterYSize(); depth = poDataset->GetRasterCount()*8; GDALClose(poDataset); return true; }
Handle<Value> DatasetBands::count(const Arguments& args) { HandleScope scope; Handle<Object> parent = args.This()->GetHiddenValue(String::NewSymbol("parent_"))->ToObject(); Dataset *ds = ObjectWrap::Unwrap<Dataset>(parent); if (ds->uses_ogr){ OGRDataSource* raw = ds->getDatasource(); if (!raw) { return NODE_THROW("Dataset object has already been destroyed"); } return scope.Close(Integer::New(0)); } else { GDALDataset* raw = ds->getDataset(); if (!raw) { return NODE_THROW("Dataset object has already been destroyed"); } return scope.Close(Integer::New(raw->GetRasterCount())); } }
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 main( int nArgc, char ** papszArgv ) { // register drivers GDALAllRegister(); if( nArgc < 2 ) return EXIT_FAILURE; double dfaCornersX[5] = {0}; double dfaCornersY[5] = {0}; CPLString sFileName; // parse input values for( int iArg = 1; iArg < nArgc; iArg++ ) { if( EQUAL(papszArgv[iArg],"-nw")) { CHECK_HAS_ENOUGH_ADDITIONAL_ARGS(2); const char* pszCoord = papszArgv[++iArg]; dfaCornersY[1] = CPLAtofM(pszCoord); pszCoord = papszArgv[++iArg]; dfaCornersX[1] = CPLAtofM(pszCoord); } else if( EQUAL(papszArgv[iArg],"-ne")) { CHECK_HAS_ENOUGH_ADDITIONAL_ARGS(2); const char* pszCoord = papszArgv[++iArg]; dfaCornersY[2] = CPLAtofM(pszCoord); pszCoord = papszArgv[++iArg]; dfaCornersX[2] = CPLAtofM(pszCoord); } else if( EQUAL(papszArgv[iArg],"-se")) { CHECK_HAS_ENOUGH_ADDITIONAL_ARGS(2); const char* pszCoord = papszArgv[++iArg]; dfaCornersY[3] = CPLAtofM(pszCoord); pszCoord = papszArgv[++iArg]; dfaCornersX[3] = CPLAtofM(pszCoord); } else if( EQUAL(papszArgv[iArg],"-sw")) { CHECK_HAS_ENOUGH_ADDITIONAL_ARGS(2); const char* pszCoord = papszArgv[++iArg]; dfaCornersY[4] = CPLAtofM(pszCoord); pszCoord = papszArgv[++iArg]; dfaCornersX[4] = CPLAtofM(pszCoord); } else if( EQUAL(papszArgv[iArg],"-c")) { CHECK_HAS_ENOUGH_ADDITIONAL_ARGS(2); const char* pszCoord = papszArgv[++iArg]; dfaCornersY[0] = CPLAtofM(pszCoord); pszCoord = papszArgv[++iArg]; dfaCornersX[0] = CPLAtofM(pszCoord); } else if(sFileName.empty()) sFileName = papszArgv[iArg]; } OGRSpatialReference oOGRSpatialReference(SRS_WKT_WGS84); int nZoneNo = ceil( (180.0 + dfaCornersX[0]) / 6.0 ); OGRSpatialReference oDstSpatialReference(SRS_WKT_WGS84); oDstSpatialReference.SetUTM(nZoneNo, dfaCornersY[0] > 0); // transform coordinates from WGS84 to UTM OGRCoordinateTransformation *poCT = OGRCreateCoordinateTransformation( &oOGRSpatialReference, &oDstSpatialReference); if(!poCT) { Usage("get coordinate transformation failed"); return EXIT_FAILURE; } int nResult = poCT->Transform(5, dfaCornersX, dfaCornersY, NULL); if(!nResult) { Usage("transformation failed"); return EXIT_FAILURE; } // open input dataset GDALDataset *poSrcDataset = (GDALDataset *) GDALOpen( sFileName, GA_ReadOnly ); // GA_Update char* pszSpaRefDef = NULL; if( oDstSpatialReference.exportToWkt(&pszSpaRefDef) != OGRERR_NONE) { CPLFree( pszSpaRefDef ); GDALClose( (GDALDatasetH) poSrcDataset ); return EXIT_FAILURE; } // search point along image // add GCP to opened raster OGRPoint ptCenter(dfaCornersX[0], dfaCornersY[0]); OGRPoint pt1(dfaCornersX[1], dfaCornersY[1]); // NW Cormer OGRPoint pt2(dfaCornersX[2], dfaCornersY[2]); // NE Corner OGRPoint pt3(dfaCornersX[3], dfaCornersY[3]); // SE Corner OGRPoint pt4(dfaCornersX[4], dfaCornersY[4]); // SW Corner int nGCPCount = 0; OGREnvelope DstEnv; GDAL_GCP *paGSPs = PrepareGCP(sFileName, &pt1, &pt2, &pt3, &pt4, &ptCenter, oDstSpatialReference, poSrcDataset->GetRasterXSize(), poSrcDataset->GetRasterYSize(), nGCPCount, DstEnv); if(poSrcDataset->SetGCPs(nGCPCount, paGSPs, pszSpaRefDef) != CE_None) { Usage( "Set GCPs failed" ); return EXIT_FAILURE; } // create warper char **papszTO = NULL; papszTO = CSLSetNameValue( papszTO, "METHOD", "GCP_TPS" ); papszTO = CSLSetNameValue( papszTO, "NUM_THREADS", "4" ); papszTO = CSLSetNameValue( papszTO, "DST_SRS", pszSpaRefDef ); papszTO = CSLSetNameValue( papszTO, "SRC_SRS", pszSpaRefDef ); papszTO = CSLSetNameValue( papszTO, "INSERT_CENTER_LONG", "FALSE" ); GDALDriver *poOutputDriver = (GDALDriver *) GDALGetDriverByName( "GTiff" ); CPLSetConfigOption( "CHECK_WITH_INVERT_PROJ", "TRUE" ); void* hTransformArg = GDALCreateGenImgProjTransformer2( poSrcDataset, NULL, papszTO ); GDALTransformerInfo* psInfo = (GDALTransformerInfo*)hTransformArg; double adfThisGeoTransform[6]; double adfExtent[4]; int nThisPixels, nThisLines; // suggest the raster output size if( GDALSuggestedWarpOutput2( poSrcDataset, psInfo->pfnTransform, hTransformArg, adfThisGeoTransform, &nThisPixels, &nThisLines, adfExtent, 0 ) != CE_None ) { Usage( "Suggest Output failed" ); return EXIT_FAILURE; } adfThisGeoTransform[0] = DstEnv.MinX; adfThisGeoTransform[3] = DstEnv.MaxY; int nPixels = (int) ((DstEnv.MaxX - DstEnv.MinX) / adfThisGeoTransform[1] + 0.5); int nLines = (int) ((DstEnv.MaxY - DstEnv.MinY) / -adfThisGeoTransform[5] + 0.5); GDALSetGenImgProjTransformerDstGeoTransform( hTransformArg, adfThisGeoTransform); // create new raster CPLString sOutputRasterPath = CPLResetExtension(sFileName, "tif"); GDALDataset *poDstDataset = poOutputDriver->Create(sOutputRasterPath, nPixels, nLines, poSrcDataset->GetRasterCount(), GDT_Byte, NULL ); if( NULL == poDstDataset ) { Usage( "Create Output failed" ); return EXIT_FAILURE; } poDstDataset->SetProjection( pszSpaRefDef ); poDstDataset->SetGeoTransform( adfThisGeoTransform ); #ifdef APRROX_MAXERROR hTransformArg = GDALCreateApproxTransformer( GDALGenImgProjTransform, hTransformArg, APRROX_MAXERROR); GDALTransformerFunc pfnTransformer = GDALApproxTransform; GDALApproxTransformerOwnsSubtransformer(hTransformArg, TRUE); #else GDALTransformerFunc pfnTransformer = GDALGenImgProjTransform; #endif // APRROX_MAXERROR // warp GDALWarpOptions *psWO = GDALCreateWarpOptions(); psWO->eWorkingDataType = GDT_Byte; psWO->eResampleAlg = GRA_NearestNeighbour; psWO->hSrcDS = poSrcDataset; psWO->hDstDS = poDstDataset; psWO->pfnTransformer = pfnTransformer; psWO->pTransformerArg = hTransformArg; psWO->pfnProgress = GDALTermProgress; psWO->nBandCount = poSrcDataset->GetRasterCount(); psWO->panSrcBands = (int *) CPLMalloc(psWO->nBandCount*sizeof(int)); psWO->panDstBands = (int *) CPLMalloc(psWO->nBandCount*sizeof(int)); for(int i = 0; i < psWO->nBandCount; ++i ) { psWO->panSrcBands[i] = i+1; psWO->panDstBands[i] = i+1; } GDALWarpOperation oWO; if( oWO.Initialize( psWO ) == CE_None ) { #ifdef MULTI if( oWO.ChunkAndWarpMulti( 0, 0, poDstDataset->GetRasterXSize(), poDstDataset->GetRasterYSize() ) != CE_None) #else //MULTI if( oWO.ChunkAndWarpImage( 0, 0, poDstDataset->GetRasterXSize(), poDstDataset->GetRasterYSize() ) != CE_None) #endif //MULTI { const char* err = CPLGetLastErrorMsg(); Usage( CPLSPrintf("Warp failed.%s", err) ); return EXIT_FAILURE; } } // cleanup GDALDestroyWarpOptions( psWO ); CSLDestroy( papszTO ); CPLFree( pszSpaRefDef ); GDALClose( (GDALDatasetH) poSrcDataset ); GDALClose( (GDALDatasetH) poDstDataset ); GDALDestroyDriverManager(); return EXIT_SUCCESS; }
int32_t RadiationUniform(char* filepath1, char* logfilepath, vector<double>& striperesult) { GDALDataset *poDataset; GDALAllRegister(); poDataset=(GDALDataset *)GDALOpen(filepath1,GA_ReadOnly); if( poDataset == NULL ) { cerr << "RadiationUniform filepath " << filepath1 << endl; WriteMsg(logfilepath,-1,"Image file open error!"); return -1; } else { WriteMsg(logfilepath,0,"Striperesidual algorithm is executing!"); } int32_t n,i,j; int32_t bandnum,width,height; bandnum=poDataset->GetRasterCount(); width=poDataset->GetRasterXSize(); height=poDataset->GetRasterYSize(); GDALRasterBand *pband; uint16_t *banddata=(uint16_t *)CPLMalloc(sizeof(uint16_t)*width*height); for(n=0;n<bandnum;n++) { pband=poDataset->GetRasterBand(n+1); pband->RasterIO(GF_Read,0,0,width,height,banddata,width,height,GDT_UInt16,0,0); double *colmeans=(double *)CPLMalloc(sizeof(double)*width); double imgmean=0.0; for(j=0;j<width;j++) { colmeans[j]=0.0; } for(i=0;i<height;i++) { for(j=0;j<width;j++) { colmeans[j]=colmeans[j]+banddata[i*width+j]/(double)height; } } for(j=0;j<width;j++) { imgmean = imgmean+colmeans[j]/(double)width; } double sum=0.0; for(j=1;j<width;j++) { sum = sum + (colmeans[j]-imgmean)*(colmeans[j]-imgmean)/width; } striperesult.push_back(100.0*(1-sqrt(sum)/imgmean)); CPLFree(colmeans); colmeans=NULL; GDALClose(pband); pband=NULL; //Writing the process and status of this Algorithm. int32_t temp = (int)(100.0*(n+1)/bandnum); temp = (temp>99) ? 99:temp; WriteMsg(logfilepath,temp,"Striperesidual algorithm is executing!"); } CPLFree(banddata); banddata=NULL; GDALClose(poDataset); poDataset=NULL; return 1; }
bool gstIconManager::CopyIcon(const std::string& src_path, const std::string& dst_path) { // file must not exist already if (khExists(dst_path)) { notify(NFY_WARN, "Icon \"%s\" already exists", dst_path.c_str()); return false; } GDALDataset* srcDataset = static_cast<GDALDataset*>( GDALOpen(src_path.c_str(), GA_ReadOnly)); if (!srcDataset) { notify(NFY_WARN, "Unable to open icon %s", src_path.c_str()); return false; } // determine the image type // is it rgb or palette_index type bool palette_type = false; if (srcDataset->GetRasterCount() == 1 && srcDataset->GetRasterBand(1)->GetColorInterpretation() == GCI_PaletteIndex) { palette_type = true; } else if (srcDataset->GetRasterCount() != 4) { notify(NFY_WARN, "%s: Image type not supported", src_path.c_str()); return false; } GDALDataset* oldSrcDataset = 0; int target_size = 0; bool need_scaling = false; int srcXSize = srcDataset->GetRasterXSize(); int srcYSize = srcDataset->GetRasterYSize(); if ((srcXSize == 32) || (srcXSize == 64)) { target_size = srcXSize; if ((srcYSize != srcXSize) && (srcYSize != srcXSize*2) && (srcYSize != srcXSize*3)) { need_scaling = true; } } else if (srcXSize < 32) { target_size = 32; need_scaling = true; } else { target_size = 64; need_scaling = true; } if (need_scaling) { // create a temp output dataset to scale the src // icon to a square target_size*target_size. Later we'll make a stack. VRTDataset* tempDataset = new VRTDataset(target_size, target_size); int numBands = palette_type ? 1 : 4; for (int b = 1; b <= numBands; ++b) { tempDataset->AddBand(GDT_Byte, NULL); VRTSourcedRasterBand* tempBand = static_cast<VRTSourcedRasterBand*>(tempDataset->GetRasterBand(b)); GDALRasterBand* srcBand = srcDataset->GetRasterBand(b); tempBand->AddSimpleSource(srcBand, 0, 0, srcXSize, srcYSize, 0, 0, target_size, target_size); if (palette_type) { tempBand->SetColorInterpretation(srcBand->GetColorInterpretation()); tempBand->SetColorTable(srcBand->GetColorTable()); } } oldSrcDataset = srcDataset; srcDataset = tempDataset; srcXSize = srcYSize = target_size; } assert(srcXSize == target_size); // From here on we assume that we have a square, a stack of 2, or a stack of // 3. It will be either 32 or 64 wide. The actual size is stored in srcXSize // and srcYSize bool simpleCopy = false; if (srcYSize == srcXSize * 3) simpleCopy = true; // create a virtual dataset to represent the desired output image VRTDataset* vds = new VRTDataset(target_size, target_size * 3); // copy all the bands from the source int numBands = palette_type ? 1 : 4; for (int b = 1; b <= numBands; ++b) { vds->AddBand(GDT_Byte, NULL); VRTSourcedRasterBand* vrtBand = static_cast<VRTSourcedRasterBand*>(vds->GetRasterBand(b)); GDALRasterBand* srcBand = srcDataset->GetRasterBand(b); if (!simpleCopy) { // extract the normal icon (on bottom of input image) // and put it on the bottom of new image // NOTE: srcYSize calculation lets us hand single, square images // as well as two squares stacked on top of each other vrtBand->AddSimpleSource( srcBand, 0, srcYSize-target_size, target_size, target_size, 0, target_size*2, target_size, target_size); // extract the highlight icon (on top of input image) // and put it in the middle of new image vrtBand->AddSimpleSource(srcBand, 0, 0, target_size, target_size, 0, target_size, target_size, target_size); // extract the normal icon (on bottom of input image), scale it to 16x16 // and put it on the top of the new image // NOTE: srcYSize calculation lets us hand single, square images // as well as two squares stacked on top of each other vrtBand->AddSimpleSource( srcBand, 0, srcYSize-target_size, target_size, target_size, 0, 0, 16, 16); } else { vrtBand->AddSimpleSource(srcBand, 0, 0, target_size, target_size * 3, 0, 0, target_size, target_size * 3); } if (palette_type) { vrtBand->SetColorInterpretation(srcBand->GetColorInterpretation()); vrtBand->SetColorTable(srcBand->GetColorTable()); } } // find output driver GDALDriver* pngDriver = GetGDALDriverManager()->GetDriverByName("PNG"); if (pngDriver == NULL) { notify(NFY_FATAL, "Unable to find png driver!"); return false; } // write out all bands at once GDALDataset* dest = pngDriver->CreateCopy( dst_path.c_str(), vds, false, NULL, NULL, NULL); delete dest; delete vds; delete srcDataset; delete oldSrcDataset; // just in case the umask trimmed any permissions khChmod(dst_path, 0666); return true; }
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)); }
gdal_datasource::gdal_datasource(parameters const& params) : datasource(params), desc_(gdal_datasource::name(), "utf-8"), nodata_value_(params.get<double>("nodata")), nodata_tolerance_(*params.get<double>("nodata_tolerance",1e-12)) { MAPNIK_LOG_DEBUG(gdal) << "gdal_datasource: Initializing..."; #ifdef MAPNIK_STATS mapnik::progress_timer __stats__(std::clog, "gdal_datasource::init"); #endif GDALAllRegister(); boost::optional<std::string> file = params.get<std::string>("file"); if (! file) throw datasource_exception("missing <file> parameter"); boost::optional<std::string> base = params.get<std::string>("base"); if (base) { dataset_name_ = *base + "/" + *file; } else { dataset_name_ = *file; } shared_dataset_ = *params.get<mapnik::boolean_type>("shared", false); band_ = *params.get<mapnik::value_integer>("band", -1); GDALDataset *dataset = open_dataset(); nbands_ = dataset->GetRasterCount(); width_ = dataset->GetRasterXSize(); height_ = dataset->GetRasterYSize(); desc_.add_descriptor(mapnik::attribute_descriptor("nodata", mapnik::Double)); double tr[6]; bool bbox_override = false; boost::optional<std::string> bbox_s = params.get<std::string>("extent"); if (bbox_s) { MAPNIK_LOG_DEBUG(gdal) << "gdal_datasource: BBox Parameter=" << *bbox_s; bbox_override = extent_.from_string(*bbox_s); if (! bbox_override) { throw datasource_exception("GDAL Plugin: bbox parameter '" + *bbox_s + "' invalid"); } } if (bbox_override) { tr[0] = extent_.minx(); tr[1] = extent_.width() / (double)width_; tr[2] = 0; tr[3] = extent_.maxy(); tr[4] = 0; tr[5] = -extent_.height() / (double)height_; MAPNIK_LOG_DEBUG(gdal) << "gdal_datasource extent override gives Geotransform=" << tr[0] << "," << tr[1] << "," << tr[2] << "," << tr[3] << "," << tr[4] << "," << tr[5]; } else { if (dataset->GetGeoTransform(tr) != CPLE_None) { MAPNIK_LOG_DEBUG(gdal) << "gdal_datasource GetGeotransform failure gives=" << tr[0] << "," << tr[1] << "," << tr[2] << "," << tr[3] << "," << tr[4] << "," << tr[5]; } else { MAPNIK_LOG_DEBUG(gdal) << "gdal_datasource Geotransform=" << tr[0] << "," << tr[1] << "," << tr[2] << "," << tr[3] << "," << tr[4] << "," << tr[5]; } } // TODO - We should throw for true non-north up images, but the check // below is clearly too restrictive. // https://github.com/mapnik/mapnik/issues/970 /* if (tr[2] != 0 || tr[4] != 0) { throw datasource_exception("GDAL Plugin: only 'north up' images are supported"); } */ dx_ = tr[1]; dy_ = tr[5]; if (! bbox_override) { double x0 = tr[0]; double y0 = tr[3]; double x1 = tr[0] + width_ * dx_ + height_ *tr[2]; double y1 = tr[3] + width_ *tr[4] + height_ * dy_; /* double x0 = tr[0] + (height_) * tr[2]; // minx double y0 = tr[3] + (height_) * tr[5]; // miny double x1 = tr[0] + (width_) * tr[1]; // maxx double y1 = tr[3] + (width_) * tr[4]; // maxy */ extent_.init(x0, y0, x1, y1); } GDALClose(dataset); MAPNIK_LOG_DEBUG(gdal) << "gdal_datasource: Raster Size=" << width_ << "," << height_; MAPNIK_LOG_DEBUG(gdal) << "gdal_datasource: Raster Extent=" << extent_; }
void gdal_datasource::bind() const { if (is_bound_) return; shared_dataset_ = *params_.get<mapnik::boolean>("shared", false); band_ = *params_.get<int>("band", -1); GDALDataset *dataset = open_dataset(); nbands_ = dataset->GetRasterCount(); width_ = dataset->GetRasterXSize(); height_ = dataset->GetRasterYSize(); double tr[6]; bool bbox_override = false; boost::optional<std::string> bbox_s = params_.get<std::string>("bbox"); if (bbox_s) { #ifdef MAPNIK_DEBUG std::clog << "GDAL Plugin: bbox parameter=" << *bbox_s << std::endl; #endif bbox_override = extent_.from_string(*bbox_s); if (! bbox_override) { throw datasource_exception("GDAL Plugin: bbox parameter '" + *bbox_s + "' invalid"); } } if (bbox_override) { tr[0] = extent_.minx(); tr[1] = extent_.width() / (double)width_; tr[2] = 0; tr[3] = extent_.maxy(); tr[4] = 0; tr[5] = -extent_.height() / (double)height_; } else { dataset->GetGeoTransform(tr); } #ifdef MAPNIK_DEBUG std::clog << "GDAL Plugin: geotransform=" << tr[0] << "," << tr[1] << "," << tr[2] << "," << tr[3] << "," << tr[4] << "," << tr[5] << std::endl; #endif // TODO - We should throw for true non-north up images, but the check // below is clearly too restrictive. // https://github.com/mapnik/mapnik/issues/970 /* if (tr[2] != 0 || tr[4] != 0) { throw datasource_exception("GDAL Plugin: only 'north up' images are supported"); } */ dx_ = tr[1]; dy_ = tr[5]; if (! bbox_override) { double x0 = tr[0]; double y0 = tr[3]; double x1 = tr[0] + width_ * dx_ + height_ *tr[2]; double y1 = tr[3] + width_ *tr[4] + height_ * dy_; /* double x0 = tr[0] + (height_) * tr[2]; // minx double y0 = tr[3] + (height_) * tr[5]; // miny double x1 = tr[0] + (width_) * tr[1]; // maxx double y1 = tr[3] + (width_) * tr[4]; // maxy */ extent_.init(x0, y0, x1, y1); } GDALClose(dataset); #ifdef MAPNIK_DEBUG std::clog << "GDAL Plugin: Raster Size=" << width_ << "," << height_ << std::endl; std::clog << "GDAL Plugin: Raster Extent=" << extent_ << std::endl; #endif is_bound_ = true; }
//Clarity-影像清晰度(点锐度算法) int32_t Clarity(char* filepath,char* logfilepath, vector<double>& result) { GDALDataset *poDataset = NULL; GDALAllRegister(); poDataset=(GDALDataset *)GDALOpen(filepath,GA_ReadOnly); if(poDataset == NULL) { printf("Image file open error!\n"); WriteMsg(logfilepath,-1,"Image file open error!"); return -1; } else { printf("Clarity algorithm is executing!\n"); WriteMsg(logfilepath,0,"Clarity algorithm is executing!"); } //开始解析图像数据集 int32_t n,i,j; int32_t bandnum,width,height; bandnum=poDataset->GetRasterCount(); width=poDataset->GetRasterXSize(); height=poDataset->GetRasterYSize(); GDALRasterBand *pband = NULL; uint16_t *banddata=(uint16_t *)CPLMalloc(sizeof(uint16_t)*width*height); for(n=0;n<bandnum;n++) { pband=poDataset->GetRasterBand(n+1); pband->RasterIO(GF_Read,0,0,width,height,banddata,width,height,GDT_UInt16,0,0); double clarity=0.0; int32_t blkcount=0; for(i=1;i<height-1;i++) { for(j=1;j<width-1;j++) { if(banddata[i*width+j]==0) continue; double colmean=0.0; colmean += fabs(1.0*banddata[(i-1)*width+(j-1)]-banddata[i*width+j])/sqrt(2.0); colmean += fabs(1.0*banddata[(i-1)*width+j]-banddata[i*width+j]); colmean += fabs(1.0*banddata[(i-1)*width+(j+1)]-banddata[i*width+j])/sqrt(2.0); colmean += fabs(1.0*banddata[i*width+(j-1)]-banddata[i*width+j]); colmean += fabs(1.0*banddata[i*width+(j+1)]-banddata[i*width+j]); colmean += fabs(1.0*banddata[(i+1)*width+(j-1)]-banddata[i*width+j])/sqrt(2.0); colmean += fabs(1.0*banddata[(i+1)*width+j]-banddata[i*width+j]); colmean += fabs(1.0*banddata[(i+1)*width+(j+1)]-banddata[i*width+j])/sqrt(2.0); colmean = colmean/8.0; clarity +=colmean; blkcount++; } } result.push_back(clarity/blkcount); GDALClose(pband); pband=NULL; //Writing the process and status of this Algorithm. int32_t temp = (int)(100.0*(n+1)/bandnum); temp = (temp>99) ? 99:temp; printf("Clarity algorithm is executing %d%%!\n",temp); WriteMsg(logfilepath,temp,"Clarity algorithm is executing!"); } CPLFree(banddata); banddata=NULL; GDALClose(poDataset); poDataset=NULL; return 1; }
int main(int argc, char *argv[]){ GDALDataset *poDataset; GDALAllRegister(); if(argc != 3){ std::cout << "usage:\n" << argv[0] << " src_file dest_file\n"; exit(0); } const std::string name = argv[1]; const std::string destName = argv[2]; poDataset = (GDALDataset *) GDALOpen(name.c_str(), GA_ReadOnly ); if( poDataset == NULL ){ std::cout << "Failed to open " << name << "\n"; }else{ const char *pszFormat = "GTiff"; GDALDriver *poDriver; char **papszMetadata; poDriver = GetGDALDriverManager()->GetDriverByName(pszFormat); if( poDriver == NULL ){ std::cout << "Cant open driver\n"; exit(1); } papszMetadata = GDALGetMetadata( poDriver, NULL ); if( !CSLFetchBoolean( papszMetadata, GDAL_DCAP_CREATE, FALSE ) ){ std::cout << "Create Method not suported!\n"; } if( !CSLFetchBoolean( papszMetadata, GDAL_DCAP_CREATECOPY, FALSE ) ){ std::cout << "CreateCopy() method not suported.\n"; } char **papszOptions = NULL; GDALDataset *dest = poDriver->Create(destName.c_str() , poDataset->GetRasterXSize(), poDataset->GetRasterYSize(), 3, GDT_Byte, papszOptions ); std::cout << "Reading file " << name << "\n"; std::cout << "x= " << poDataset->GetRasterXSize() << ", h=" << poDataset->GetRasterYSize() << ", bands= " << poDataset->GetRasterCount() << "\n"; GDALRasterBand *data; data = poDataset->GetRasterBand(1); GDALDataType type = data->GetRasterDataType(); printDataType(type); int size = data->GetXSize()*data->GetYSize(); std::cout << "size=" << size << " , w*h = " << poDataset->GetRasterXSize()*poDataset->GetRasterYSize() << "\n"; float *buffer; buffer = (float *) CPLMalloc(sizeof(float)*size); data->RasterIO(GF_Read, 0, 0, data->GetXSize(), data->GetYSize(), buffer, data->GetXSize(), data->GetYSize(), GDT_Float32, 0, 0 ); GDALRasterBand *destBand1 = dest->GetRasterBand(1); GDALRasterBand *destBand2 = dest->GetRasterBand(2); GDALRasterBand *destBand3 = dest->GetRasterBand(3); // GDALRasterBand *destBand4 = dest->GetRasterBand(4); // Metadata, double geot[6]; poDataset->GetGeoTransform(geot); dest->SetGeoTransform(geot);// adfGeoTransform ); dest->SetProjection( poDataset->GetProjectionRef() ); GByte destWrite1[size]; // = (GUInt32 *) CPLMalloc(sizeof(GUInt32)*size); GByte destWrite2[size]; GByte destWrite3[size]; // GByte destWrite4[size]; unsigned int i; float max=0, min=0; for(i=0; i<size; i++){ if(max < buffer[i]){ max = buffer[i]; } if(min > buffer[i]){ min = buffer[i]; } } float range = max - min; std::cout << "range=" << range << ", max=" << max << ", min=" << min << "\n"; std::map<float, unsigned int> counter; for(i=0; i<size; i++){ counter[buffer[i]]++; unsigned int v = buffer[i] * 100; destWrite1[i] = (v & (0xff << 0)) >> 0; destWrite2[i] = (v & (0xff << 8)) >> 8; destWrite3[i] = (v & (0xff << 16)) >> 16; // destWrite4[i] = 0x00; // (v & (0xff << 24)) >> 24; } destBand1->RasterIO( GF_Write, 0, 0, data->GetXSize(), data->GetYSize(), destWrite1, data->GetXSize(), data->GetYSize(), GDT_Byte, 0, 0 ); destBand2->RasterIO( GF_Write, 0, 0, data->GetXSize(), data->GetYSize(), destWrite2, data->GetXSize(), data->GetYSize(), GDT_Byte, 0, 0 ); destBand3->RasterIO( GF_Write, 0, 0, data->GetXSize(), data->GetYSize(), destWrite3, data->GetXSize(), data->GetYSize(), GDT_Byte, 0, 0 ); // destBand4->RasterIO( GF_Write, 0, 0, data->GetXSize(), data->GetYSize(), // destWrite4, data->GetXSize(), data->GetYSize(), GDT_Byte, 0, 0 ); /*std::map<float, unsigned int>::iterator it; std::cout << "Counter: \n"; for(it=counter.begin(); it!=counter.end(); it++){ std::cout << (it->first*1000) << " = " << it->second << "\n"; }*/ /* Once we're done, close properly the dataset */ if( dest != NULL ){ GDALClose(dest ); GDALClose(poDataset ); } /* unsigned int *buffer; buffer = (unsigned int *) CPLMalloc(sizeof(unsigned int)*size); data->RasterIO(GF_Read, 0, 0, size, 1, buffer, size, 1, GDT_UInt32, 0, 0 ); unsigned int i; std::map<unsigned int, unsigned int> counter; for(i=0; i<size; i++){ counter[buffer[i]]++; } std::map<unsigned int, unsigned int>::iterator it; std::cout << "Counter: \n"; for(it=counter.begin(); it!=counter.end(); it++){ std::cout << it->first << " = " << it->second << "\n"; }*/ } exit(0); }
void readFrames( int argc, char* argv[] ) { pfs::DOMIO pfsio; bool verbose = false; // Parse command line parameters static struct option cmdLineOptions[] = { { "help", no_argument, NULL, 'h' }, { "verbose", no_argument, NULL, 'v' }, { NULL, 0, NULL, 0 } }; static const char optstring[] = "hv"; pfs::FrameFileIterator it( argc, argv, "rb", NULL, NULL, optstring, cmdLineOptions ); int optionIndex = 0; while( 1 ) { int c = getopt_long (argc, argv, optstring, cmdLineOptions, &optionIndex); if( c == -1 ) break; switch( c ) { case 'h': printHelp(); throw QuietException(); case 'v': verbose = true; break; case '?': throw QuietException(); case ':': throw QuietException(); } } GDALAllRegister(); GDALDataset *poDataset; GDALRasterBand *poBand; double adfGeoTransform[6]; size_t nBlockXSize, nBlockYSize, nBands; int bGotMin, bGotMax; double adfMinMax[2]; float *pafScanline; while( true ) { pfs::FrameFile ff = it.getNextFrameFile(); if( ff.fh == NULL ) break; // No more frames it.closeFrameFile( ff ); VERBOSE_STR << "reading file '" << ff.fileName << "'" << std::endl; if( !( poDataset = (GDALDataset *) GDALOpen( ff.fileName, GA_ReadOnly ) ) ) { std::cerr << "input does not seem to be in a format supported by GDAL" << std::endl; throw QuietException(); } VERBOSE_STR << "GDAL driver: " << poDataset->GetDriver()->GetDescription() << " / " << poDataset->GetDriver()->GetMetadataItem( GDAL_DMD_LONGNAME ) << std::endl; nBlockXSize = poDataset->GetRasterXSize(); nBlockYSize = poDataset->GetRasterYSize(); nBands = poDataset->GetRasterCount(); VERBOSE_STR << "Data size " << nBlockXSize << "x" << nBlockYSize << "x" << nBands << std::endl; if( poDataset->GetProjectionRef() ) { VERBOSE_STR << "Projection " << poDataset->GetProjectionRef() << std::endl; } if( poDataset->GetGeoTransform( adfGeoTransform ) == CE_None ) { VERBOSE_STR << "Origin = (" << adfGeoTransform[0] << ", " << adfGeoTransform[3] << ")" << std::endl; VERBOSE_STR << "Pixel Size = (" << adfGeoTransform[1] << ", " << adfGeoTransform[5] << ")" << std::endl; } if( nBlockXSize==0 || nBlockYSize==0 || ( SIZE_MAX / nBlockYSize < nBlockXSize ) || ( SIZE_MAX / (nBlockXSize * nBlockYSize ) < 4 ) ) { std::cerr << "input data has invalid size" << std::endl; throw QuietException(); } if( !(pafScanline = (float *) CPLMalloc( sizeof(float) * nBlockXSize ) ) ) { std::cerr << "not enough memory" << std::endl; throw QuietException(); } pfs::Frame *frame = pfsio.createFrame( nBlockXSize, nBlockYSize ); pfs::Channel *C[nBands]; char channel_name[32]; frame->getTags()->setString( "X-GDAL_DRIVER_SHORTNAME", poDataset->GetDriver()->GetDescription() ); frame->getTags()->setString( "X-GDAL_DRIVER_LONGNAME", poDataset->GetDriver()->GetMetadataItem( GDAL_DMD_LONGNAME ) ); frame->getTags()->setString( "X-PROJECTION", poDataset->GetProjectionRef() ); if( poDataset->GetGeoTransform( adfGeoTransform ) == CE_None ) { frame->getTags()->setString( "X-ORIGIN_X", stringify(adfGeoTransform[0]).c_str() ); frame->getTags()->setString( "X-ORIGIN_Y", stringify(adfGeoTransform[3]).c_str() ); frame->getTags()->setString( "X-PIXEL_WIDTH", stringify(adfGeoTransform[1]).c_str() ); frame->getTags()->setString( "X-PIXEL_HEIGHT", stringify(adfGeoTransform[5]).c_str() ); } for ( size_t band = 1; band <= nBands; band++) { size_t nBandXSize, nBandYSize; VERBOSE_STR << "Band " << band << ": " << std::endl; snprintf( channel_name, 32, "X-GDAL%zu", band ); C[band - 1] = frame->createChannel( channel_name ); poBand = poDataset->GetRasterBand( band ); nBandXSize = poBand->GetXSize(); nBandYSize = poBand->GetYSize(); VERBOSE_STR << " " << nBandXSize << "x" << nBandYSize << std::endl; if( nBandXSize != (int)nBlockXSize || nBandYSize != (int)nBlockYSize ) { std::cerr << "data in band " << band << " has different size" << std::endl; throw QuietException(); } VERBOSE_STR << " Type " << GDALGetDataTypeName( poBand->GetRasterDataType() ) << ", " << "Color Interpretation " << GDALGetColorInterpretationName( poBand->GetColorInterpretation() ) << std::endl; adfMinMax[0] = poBand->GetMinimum( &bGotMin ); adfMinMax[1] = poBand->GetMaximum( &bGotMax ); if( ! (bGotMin && bGotMax) ) { GDALComputeRasterMinMax((GDALRasterBandH)poBand, TRUE, adfMinMax); } VERBOSE_STR << " Min " << adfMinMax[0] << ", Max " << adfMinMax[1] << std::endl; C[band - 1]->getTags()->setString( "X-TYPE", GDALGetDataTypeName( poBand->GetRasterDataType() ) ); C[band - 1]->getTags()->setString( "X-COLOR_INTERPRETATION", GDALGetColorInterpretationName( poBand->GetColorInterpretation() ) ); C[band - 1]->getTags()->setString( "X-MIN", stringify(adfMinMax[0]).c_str() ); C[band - 1]->getTags()->setString( "X-MAX", stringify(adfMinMax[1]).c_str() ); for( size_t y = 0; y < nBlockYSize; y++ ) { if( poBand->RasterIO( GF_Read, 0, y, nBlockXSize, 1, pafScanline, nBlockXSize, 1, GDT_Float32, 0, 0) != CE_None ) { std::cerr << "input error" << std::endl; throw QuietException(); } memcpy( C[band - 1]->getRawData() + y * nBlockXSize, pafScanline, nBlockXSize * sizeof(float) ); } } CPLFree( pafScanline ); GDALClose( poDataset ); const char *fileNameTag = strcmp( "-", ff.fileName )==0 ? "stdin" : ff.fileName; frame->getTags()->setString( "FILE_NAME", fileNameTag ); pfsio.writeFrame( frame, stdout ); pfsio.freeFrame( frame ); } }
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; }
int Image::scatterImageFileGDAL(const char * filename, int xOffset, int yOffset, PV::Communicator * comm, const PVLayerLoc * loc, float * buf, bool autoResizeFlag) { int status = 0; #ifdef PV_USE_GDAL // const int maxBands = 3; const int nxProcs = comm->numCommColumns(); const int nyProcs = comm->numCommRows(); const int icRank = comm->commRank(); const int nx = loc->nx; const int ny = loc->ny; const int numBands = loc->nf; int numTotal; // will be nx*ny*bandsInFile; const MPI_Comm mpi_comm = comm->communicator(); GDALDataType dataType; char** metadata; char isBinary = true; if (icRank > 0) { #ifdef PV_USE_MPI const int src = 0; const int tag = 13; MPI_Bcast(&dataType, 1, MPI_INT, 0, mpi_comm); MPI_Bcast(&isBinary, 1, MPI_CHAR, 0, mpi_comm); MPI_Bcast(&numTotal, 1, MPI_INT, 0, mpi_comm); #ifdef DEBUG_OUTPUT fprintf(stderr, "[%2d]: scatterImageFileGDAL: received from 0, total number of bytes in buffer is %d\n", numTotal); #endif // DEBUG_OUTPUT MPI_Recv(buf, numTotal, MPI_FLOAT, src, tag, mpi_comm, MPI_STATUS_IGNORE); #ifdef DEBUG_OUTPUT int nf=numTotal/(nx*ny); assert( nf*nx*ny == numTotal ); fprintf(stderr, "[%2d]: scatterImageFileGDAL: received from 0, nx==%d ny==%d nf==%d size==%d\n", comm->commRank(), nx, ny, nf, numTotal); #endif // DEBUG_OUTPUT #endif // PV_USE_MPI } else { GDALAllRegister(); GDALDataset * dataset = PV_GDALOpen(filename); // (GDALDataset *) GDALOpen(filename, GA_ReadOnly); GDALRasterBand * poBand = dataset->GetRasterBand(1); dataType = poBand->GetRasterDataType(); #ifdef PV_USE_MPI MPI_Bcast(&dataType, 1, MPI_INT, 0, mpi_comm); #endif // PV_USE_MPI // GDAL defines whether a band is binary, not whether the image as a whole is binary. // Set isBinary to false if any band is not binary (metadata doesn't have NBITS=1) for(int iBand = 0; iBand < GDALGetRasterCount(dataset); iBand++){ GDALRasterBandH hBand = GDALGetRasterBand(dataset, iBand+1); metadata = GDALGetMetadata(hBand, "Image_Structure"); if(CSLCount(metadata) > 0){ bool found = false; for(int i = 0; metadata[i] != NULL; i++){ if(strcmp(metadata[i], "NBITS=1") == 0){ found = true; break; } } if(!found){ isBinary = false; } } else{ isBinary = false; } } #ifdef PV_USE_MPI MPI_Bcast(&isBinary, 1, MPI_CHAR, 0, mpi_comm); #endif // PV_USE_MPI if (dataset==NULL) return 1; // PV_GDALOpen prints an error message. int xImageSize = dataset->GetRasterXSize(); int yImageSize = dataset->GetRasterYSize(); const int bandsInFile = dataset->GetRasterCount(); numTotal = nx * ny * bandsInFile; #ifdef PV_USE_MPI #ifdef DEBUG_OUTPUT fprintf(stderr, "[%2d]: scatterImageFileGDAL: broadcast from 0, total number of bytes in buffer is %d\n", numTotal); #endif // DEBUG_OUTPUT MPI_Bcast(&numTotal, 1, MPI_INT, 0, mpi_comm); #endif // PV_USE_MPI int xTotalSize = nx * nxProcs; int yTotalSize = ny * nyProcs; // if nf > bands of image, it will copy the gray image to each //band of layer assert(numBands == 1 || numBands == bandsInFile || (numBands > 1 && bandsInFile == 1)); int dest = -1; const int tag = 13; float padValue_conv; if(dataType == GDT_Byte){ padValue_conv = padValue * 255.0f; } else if(dataType == GDT_UInt16){ padValue_conv = padValue * 65535.0f; } else{ std::cout << "Image data type " << GDALGetDataTypeName(dataType) << " not implemented for image rescaling\n"; exit(-1); } using std::min; using std::max; for( dest = nyProcs*nxProcs-1; dest >= 0; dest-- ) { //Need to clear buffer before reading, since we're skipping some of the buffer #ifdef PV_USE_OPENMP_THREADS #pragma omp parallel for #endif for(int i = 0; i < nx * ny * bandsInFile; i++){ //Fill with padValue buf[i] = padValue_conv; } int col = columnFromRank(dest,nyProcs,nxProcs); int row = rowFromRank(dest,nyProcs,nxProcs); int kx = nx * col; int ky = ny * row; //? For the auto resize flag, PV checks which side (x or y) is the shortest, relative to the //? hypercolumn size specified. Then it determines the largest chunk it can possibly take //? from the image with the correct aspect ratio determined by hypercolumn. It then //? determines the offset needed in the long dimension to center the cropped image, //? and reads in that portion of the image. The offset can optionally be translated by //? offset{X,Y} specified in the params file (values can be positive or negative). //? If the specified offset takes the cropped image outside the image file, it uses the //? largest-magnitude offset that stays within the image file's borders. if (autoResizeFlag){ if (xImageSize/(double)xTotalSize < yImageSize/(double)yTotalSize){ int new_y = int(round(ny*xImageSize/(double)xTotalSize)); int y_off = int(round((yImageSize - new_y*nyProcs)/2.0)); int jitter_y = max(min(y_off,yOffset),-y_off); kx = xImageSize/nxProcs * col; ky = new_y * row; //fprintf(stderr, "kx = %d, ky = %d, nx = %d, new_y = %d", kx, ky, xImageSize/nxProcs, new_y); dataset->RasterIO(GF_Read, kx, ky + y_off + jitter_y, xImageSize/nxProcs, new_y, buf, nx, ny, GDT_Float32, bandsInFile, NULL, bandsInFile*sizeof(float), bandsInFile*nx*sizeof(float), sizeof(float)); } else{ int new_x = int(round(nx*yImageSize/(double)yTotalSize)); int x_off = int(round((xImageSize - new_x*nxProcs)/2.0)); int jitter_x = max(min(x_off,xOffset),-x_off); kx = new_x * col; ky = yImageSize/nyProcs * row; //fprintf(stderr, "kx = %d, ky = %d, new_x = %d, ny = %d, x_off = %d", kx, ky, new_x, yImageSize/nyProcs, x_off); dataset->RasterIO(GF_Read, kx + x_off + jitter_x, ky, new_x, yImageSize/nyProcs, buf, nx, ny, GDT_Float32, bandsInFile, NULL, bandsInFile*sizeof(float), bandsInFile*nx*sizeof(float),sizeof(float)); } }//End autoResizeFlag else { //Need to calculate corner image pixels in globalres space //offset is in Image space int img_left = -xOffset; int img_top = -yOffset; int img_right = img_left + xImageSize; int img_bot = img_top + yImageSize; //Check if in bounds if(img_left >= kx+nx || img_right <= kx || img_top >= ky+ny || img_bot <= ky){ //Do mpi_send to keep number of sends correct if(dest > 0){ MPI_Send(buf, numTotal, MPI_FLOAT, dest, tag, mpi_comm); } continue; } //start of the buffer on the left/top side int buf_left = img_left > kx ? img_left-kx : 0; int buf_top = img_top > ky ? img_top-ky : 0; int buf_right = img_right < kx+nx ? img_right-kx : nx; int buf_bot = img_bot < ky+ny ? img_bot-ky : ny; int buf_xSize = buf_right - buf_left; int buf_ySize = buf_bot - buf_top; assert(buf_xSize > 0 && buf_ySize > 0); int buf_offset = buf_top * nx * bandsInFile + buf_left * bandsInFile; int img_offset_x = kx+xOffset; int img_offset_y = ky+yOffset; if(img_offset_x < 0){ img_offset_x = 0; } if(img_offset_y < 0){ img_offset_y = 0; } float* buf_start = buf + buf_offset; dataset->RasterIO(GF_Read, img_offset_x, img_offset_y, buf_xSize, buf_ySize, buf_start, buf_xSize, buf_ySize, GDT_Float32, bandsInFile, NULL, bandsInFile*sizeof(float), bandsInFile*nx*sizeof(float), sizeof(float)); } #ifdef DEBUG_OUTPUT fprintf(stderr, "[%2d]: scatterImageFileGDAL: sending to %d xSize==%d" " ySize==%d bandsInFile==%d size==%d total(over all procs)==%d\n", comm->commRank(), dest, nx, ny, bandsInFile, numTotal, nx*ny*comm->commSize()); #endif // DEBUG_OUTPUT #ifdef PV_USE_MPI if(dest > 0){ MPI_Send(buf, numTotal, MPI_FLOAT, dest, tag, mpi_comm); } #endif // PV_USE_MPI } GDALClose(dataset); //Moved to above for loop // get local image portion //? same logic as before, except this time we know that the row and column are 0 //if (autoResizeFlag){ // if (xImageSize/(double)xTotalSize < yImageSize/(double)yTotalSize){ // int new_y = int(round(ny*xImageSize/(double)xTotalSize)); // int y_off = int(round((yImageSize - new_y*nyProcs)/2.0)); // int offset_y = max(min(y_off,yOffset),-y_off); // //fprintf(stderr, "kx = %d, ky = %d, nx = %d, new_y = %d", 0, 0, xImageSize/nxProcs, new_y); // dataset->RasterIO(GF_Read, 0, y_off + offset_y, xImageSize/nxProcs, new_y, buf, nx, ny, // GDT_Float32, bandsInFile, NULL, bandsInFile*sizeof(float), // bandsInFile*nx*sizeof(float), sizeof(float)); // } // else{ // int new_x = int(round(nx*yImageSize/(double)yTotalSize)); // int x_off = int(round((xImageSize - new_x*nxProcs)/2.0)); // int offset_x = max(min(x_off,xOffset),-x_off); // //fprintf(stderr, "xImageSize = %d, xTotalSize = %d, yImageSize = %d, yTotalSize = %d", xImageSize, xTotalSize, yImageSize, yTotalSize); // //fprintf(stderr, "kx = %d, ky = %d, new_x = %d, ny = %d", // //0, 0, new_x, yImageSize/nyProcs); // dataset->RasterIO(GF_Read, x_off + offset_x, 0, new_x, yImageSize/nyProcs, buf, nx, ny, // GDT_Float32, bandsInFile, NULL, bandsInFile*sizeof(float), // bandsInFile*nx*sizeof(float),sizeof(float)); // } //} //else { // //fprintf(stderr,"just checking"); // dataset->RasterIO(GF_Read, xOffset, yOffset, nx, ny, buf, nx, ny, // GDT_Float32, bandsInFile, NULL, bandsInFile*sizeof(float), bandsInFile*nx*sizeof(float), sizeof(float)); //} //GDALClose(dataset); } #else fprintf(stderr, GDAL_CONFIG_ERR_STR); exit(1); #endif // PV_USE_GDAL if (status == 0) { if(!isBinary){ float fac; if(dataType == GDT_Byte){ fac = 1.0f / 255.0f; // normalize to 1.0 } else if(dataType == GDT_UInt16){ fac = 1.0f / 65535.0f; // normalize to 1.0 } else{ std::cout << "Image data type " << GDALGetDataTypeName(dataType) << " not implemented for image rescaling\n"; exit(-1); } for( int n=0; n<numTotal; n++ ) { buf[n] *= fac; } } } return status; }
// Read image bool readImageGDAL(unsigned char **pImageData, int &width, int &height, int &nChannels, const char *filePath, double trans[6]) { GDALAllRegister(); GDALDataset *poDataset = NULL; poDataset = (GDALDataset *) GDALOpen(filePath, GA_ReadOnly); if(poDataset == NULL) { GDALClose(poDataset); return false; } width = poDataset->GetRasterXSize(); height = poDataset->GetRasterYSize(); printf("width=%d\n", width); printf("height=%d\n", height); CPLErr aaa = poDataset->GetGeoTransform(trans); int k = 0; GDALRasterBand *pBand; int i = 0; int nRastercount = poDataset->GetRasterCount(); // one channel, the gray image if (nRastercount == 1) { nChannels = 1; pBand = poDataset->GetRasterBand(1); *pImageData = new unsigned char[width * height]; pBand->RasterIO(GF_Read, 0, 0, width, height, *pImageData, width, height, GDT_Byte, 0, 0); GDALClose(poDataset); return true; } // three channels, and the output is RGB image else if ( nRastercount == 3 && (nChannels == 3 || nChannels < 0) ) { nChannels = 3; *pImageData = new unsigned char[nRastercount * width * height]; for (i = 1; i <= nRastercount; ++ i) { //Band GDAL RGB is stored in order, we usually need to be converted to BGR storage, namely low address to high address: B G R unsigned char *pImageOffset = *pImageData + i - 1; GDALRasterBand *pBand = poDataset->GetRasterBand(nRastercount - i + 1); pBand->RasterIO( GF_Read, 0, 0, width, height, pImageOffset, width, height, GDT_Byte, 3, 0); } GDALClose(poDataset); return true; } //3 channels, but the required output grayscale images else if ( nRastercount == 3 && nChannels == 1 ) { unsigned char **img = new unsigned char *[nRastercount]; for (i = 0; i < nRastercount; i++) { img[i] = new unsigned char[width * height]; } for (i = 1; i <= nRastercount; ++ i) { //Band GDAL RGB is stored in order, we usually need to be converted to BGR storage, namely low address to high address: B G R pBand = poDataset->GetRasterBand(nRastercount - i + 1); pBand->RasterIO(GF_Read, 0, 0, width, height, img[i - 1], width, height, GDT_Byte, 0, 0); } GDALClose(poDataset); *pImageData = new unsigned char[width * height]; for (int r = 0; r < height; ++ r) { for (int c = 0; c < width; ++ c) { int t = (r * width + c); //r g b components are accounted for in turn:0.299 0.587 0.144,can be simplified as 3:6:1 //img[1.2.3]Correspond to BGR (*pImageData)[t] = (img[2][t] * 3 + img[1][t] * 6 + img[0][t] + 5) / 10; } } for (i = 0; i < nRastercount; ++ i) { delete [] img[i]; } delete []img; img = NULL; return true; } else { return false; } }
FXImage* GUISUMOAbstractView::checkGDALImage(Decal& d) { #ifdef HAVE_GDAL GDALAllRegister(); GDALDataset* poDataset = (GDALDataset*)GDALOpen(d.filename.c_str(), GA_ReadOnly); if (poDataset == 0) { return 0; } const int xSize = poDataset->GetRasterXSize(); const int ySize = poDataset->GetRasterYSize(); // checking for geodata in the picture and try to adapt position and scale if (d.width <= 0.) { double adfGeoTransform[6]; if (poDataset->GetGeoTransform(adfGeoTransform) == CE_None) { Position topLeft(adfGeoTransform[0], adfGeoTransform[3]); const double horizontalSize = xSize * adfGeoTransform[1]; const double verticalSize = ySize * adfGeoTransform[5]; Position bottomRight(topLeft.x() + horizontalSize, topLeft.y() + verticalSize); if (GeoConvHelper::getProcessing().x2cartesian(topLeft) && GeoConvHelper::getProcessing().x2cartesian(bottomRight)) { d.width = bottomRight.x() - topLeft.x(); d.height = topLeft.y() - bottomRight.y(); d.centerX = (topLeft.x() + bottomRight.x()) / 2; d.centerY = (topLeft.y() + bottomRight.y()) / 2; //WRITE_MESSAGE("proj: " + toString(poDataset->GetProjectionRef()) + " dim: " + toString(d.width) + "," + toString(d.height) + " center: " + toString(d.centerX) + "," + toString(d.centerY)); } else { WRITE_WARNING("Could not convert coordinates in " + d.filename + "."); } } } #endif if (d.width <= 0.) { d.width = getGridWidth(); d.height = getGridHeight(); } // trying to read the picture #ifdef HAVE_GDAL const int picSize = xSize * ySize; FXColor* result; if (!FXMALLOC(&result, FXColor, picSize)) { WRITE_WARNING("Could not allocate memory for " + d.filename + "."); return 0; } for (int j = 0; j < picSize; j++) { result[j] = FXRGB(0, 0, 0); } bool valid = true; for (int i = 1; i <= poDataset->GetRasterCount(); i++) { GDALRasterBand* poBand = poDataset->GetRasterBand(i); int shift = -1; if (poBand->GetColorInterpretation() == GCI_RedBand) { shift = 0; } else if (poBand->GetColorInterpretation() == GCI_GreenBand) { shift = 1; } else if (poBand->GetColorInterpretation() == GCI_BlueBand) { shift = 2; } else if (poBand->GetColorInterpretation() == GCI_AlphaBand) { shift = 3; } else { WRITE_MESSAGE("Unknown color band in " + d.filename + ", maybe fox can parse it."); valid = false; break; } assert(xSize == poBand->GetXSize() && ySize == poBand->GetYSize()); if (poBand->RasterIO(GF_Read, 0, 0, xSize, ySize, ((unsigned char*)result) + shift, xSize, ySize, GDT_Byte, 4, 4 * xSize) == CE_Failure) { valid = false; break; } } GDALClose(poDataset); if (valid) { return new FXImage(getApp(), result, IMAGE_OWNED | IMAGE_KEEP | IMAGE_SHMI | IMAGE_SHMP, xSize, ySize); } FXFREE(&result); #endif return 0; }
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; }