int main( int argc, char ** argv ) { int i, b3D = FALSE; int bInverse = FALSE; const char *pszSrcFilename = NULL; const char *pszDstFilename = NULL; char **papszLayers = NULL; const char *pszSQL = NULL; const char *pszBurnAttribute = NULL; const char *pszWHERE = NULL; std::vector<int> anBandList; std::vector<double> adfBurnValues; char **papszRasterizeOptions = NULL; double dfXRes = 0, dfYRes = 0; int bCreateOutput = FALSE; const char* pszFormat = "GTiff"; int bFormatExplicitelySet = FALSE; char **papszCreateOptions = NULL; GDALDriverH hDriver = NULL; GDALDataType eOutputType = GDT_Float64; std::vector<double> adfInitVals; int bNoDataSet = FALSE; double dfNoData = 0; OGREnvelope sEnvelop; int bGotBounds = FALSE; int nXSize = 0, nYSize = 0; int bQuiet = FALSE; GDALProgressFunc pfnProgress = GDALTermProgress; OGRSpatialReferenceH hSRS = NULL; int bTargetAlignedPixels = FALSE; /* Check that we are running against at least GDAL 1.4 */ /* Note to developers : if we use newer API, please change the requirement */ if (atoi(GDALVersionInfo("VERSION_NUM")) < 1400) { fprintf(stderr, "At least, GDAL >= 1.4.0 is required for this version of %s, " "which was compiled against GDAL %s\n", argv[0], GDAL_RELEASE_NAME); exit(1); } GDALAllRegister(); OGRRegisterAll(); argc = GDALGeneralCmdLineProcessor( argc, &argv, 0 ); if( argc < 1 ) exit( -argc ); /* -------------------------------------------------------------------- */ /* Parse arguments. */ /* -------------------------------------------------------------------- */ for( i = 1; i < argc; i++ ) { if( EQUAL(argv[i], "--utility_version") ) { printf("%s was compiled against GDAL %s and is running against GDAL %s\n", argv[0], GDAL_RELEASE_NAME, GDALVersionInfo("RELEASE_NAME")); return 0; } else if( EQUAL(argv[i],"-q") || EQUAL(argv[i],"-quiet") ) { bQuiet = TRUE; pfnProgress = GDALDummyProgress; } else if( EQUAL(argv[i],"-a") && i < argc-1 ) { pszBurnAttribute = argv[++i]; } else if( EQUAL(argv[i],"-b") && i < argc-1 ) { if (strchr(argv[i+1], ' ')) { char** papszTokens = CSLTokenizeString( argv[i+1] ); char** papszIter = papszTokens; while(papszIter && *papszIter) { anBandList.push_back(atoi(*papszIter)); papszIter ++; } CSLDestroy(papszTokens); i += 1; } else { while(i < argc-1 && ArgIsNumeric(argv[i+1])) { anBandList.push_back(atoi(argv[i+1])); i += 1; } } } else if( EQUAL(argv[i],"-3d") ) { b3D = TRUE; papszRasterizeOptions = CSLSetNameValue( papszRasterizeOptions, "BURN_VALUE_FROM", "Z"); } else if( EQUAL(argv[i],"-i") ) { bInverse = TRUE; } else if( EQUAL(argv[i],"-at") ) { papszRasterizeOptions = CSLSetNameValue( papszRasterizeOptions, "ALL_TOUCHED", "TRUE" ); } else if( EQUAL(argv[i],"-burn") && i < argc-1 ) { if (strchr(argv[i+1], ' ')) { char** papszTokens = CSLTokenizeString( argv[i+1] ); char** papszIter = papszTokens; while(papszIter && *papszIter) { adfBurnValues.push_back(atof(*papszIter)); papszIter ++; } CSLDestroy(papszTokens); i += 1; } else { while(i < argc-1 && ArgIsNumeric(argv[i+1])) { adfBurnValues.push_back(atof(argv[i+1])); i += 1; } } } else if( EQUAL(argv[i],"-where") && i < argc-1 ) { pszWHERE = argv[++i]; } else if( EQUAL(argv[i],"-l") && i < argc-1 ) { papszLayers = CSLAddString( papszLayers, argv[++i] ); } else if( EQUAL(argv[i],"-sql") && i < argc-1 ) { pszSQL = argv[++i]; } else if( EQUAL(argv[i],"-of") && i < argc-1 ) { pszFormat = argv[++i]; bFormatExplicitelySet = TRUE; bCreateOutput = TRUE; } else if( EQUAL(argv[i],"-init") && i < argc - 1 ) { if (strchr(argv[i+1], ' ')) { char** papszTokens = CSLTokenizeString( argv[i+1] ); char** papszIter = papszTokens; while(papszIter && *papszIter) { adfInitVals.push_back(atof(*papszIter)); papszIter ++; } CSLDestroy(papszTokens); i += 1; } else { while(i < argc-1 && ArgIsNumeric(argv[i+1])) { adfInitVals.push_back(atof(argv[i+1])); i += 1; } } bCreateOutput = TRUE; } else if( EQUAL(argv[i],"-a_nodata") && i < argc - 1 ) { dfNoData = atof(argv[i+1]); bNoDataSet = TRUE; i += 1; bCreateOutput = TRUE; } else if( EQUAL(argv[i],"-a_srs") && i < argc-1 ) { hSRS = OSRNewSpatialReference( NULL ); if( OSRSetFromUserInput(hSRS, argv[i+1]) != OGRERR_NONE ) { fprintf( stderr, "Failed to process SRS definition: %s\n", argv[i+1] ); exit( 1 ); } i++; bCreateOutput = TRUE; } else if( EQUAL(argv[i],"-te") && i < argc - 4 ) { sEnvelop.MinX = atof(argv[++i]); sEnvelop.MinY = atof(argv[++i]); sEnvelop.MaxX = atof(argv[++i]); sEnvelop.MaxY = atof(argv[++i]); bGotBounds = TRUE; bCreateOutput = TRUE; } else if( EQUAL(argv[i],"-a_ullr") && i < argc - 4 ) { sEnvelop.MinX = atof(argv[++i]); sEnvelop.MaxY = atof(argv[++i]); sEnvelop.MaxX = atof(argv[++i]); sEnvelop.MinY = atof(argv[++i]); bGotBounds = TRUE; bCreateOutput = TRUE; } else if( EQUAL(argv[i],"-co") && i < argc-1 ) { papszCreateOptions = CSLAddString( papszCreateOptions, argv[++i] ); bCreateOutput = TRUE; } 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(); } i++; bCreateOutput = TRUE; } else if( (EQUAL(argv[i],"-ts") || EQUAL(argv[i],"-outsize")) && i < argc-2 ) { nXSize = atoi(argv[++i]); nYSize = atoi(argv[++i]); if (nXSize <= 0 || nYSize <= 0) { printf( "Wrong value for -outsize parameters\n"); Usage(); } bCreateOutput = TRUE; } else if( EQUAL(argv[i],"-tr") && i < argc-2 ) { dfXRes = atof(argv[++i]); dfYRes = fabs(atof(argv[++i])); if( dfXRes == 0 || dfYRes == 0 ) { printf( "Wrong value for -tr parameters\n"); Usage(); } bCreateOutput = TRUE; } else if( EQUAL(argv[i],"-tap") ) { bTargetAlignedPixels = TRUE; bCreateOutput = TRUE; } else if( pszSrcFilename == NULL ) { pszSrcFilename = argv[i]; } else if( pszDstFilename == NULL ) { pszDstFilename = argv[i]; } else Usage(); } if( pszSrcFilename == NULL || pszDstFilename == NULL ) { fprintf( stderr, "Missing source or destination.\n\n" ); Usage(); } if( adfBurnValues.size() == 0 && pszBurnAttribute == NULL && !b3D ) { fprintf( stderr, "At least one of -3d, -burn or -a required.\n\n" ); Usage(); } if( bCreateOutput ) { if( dfXRes == 0 && dfYRes == 0 && nXSize == 0 && nYSize == 0 ) { fprintf( stderr, "'-tr xres yes' or '-ts xsize ysize' is required.\n\n" ); Usage(); } if (bTargetAlignedPixels && dfXRes == 0 && dfYRes == 0) { fprintf( stderr, "-tap option cannot be used without using -tr\n"); Usage(); } if( anBandList.size() != 0 ) { fprintf( stderr, "-b option cannot be used when creating a GDAL dataset.\n\n" ); Usage(); } int nBandCount = 1; if (adfBurnValues.size() != 0) nBandCount = adfBurnValues.size(); if ((int)adfInitVals.size() > nBandCount) nBandCount = adfInitVals.size(); if (adfInitVals.size() == 1) { for(i=1;i<=nBandCount - 1;i++) adfInitVals.push_back( adfInitVals[0] ); } int i; for(i=1;i<=nBandCount;i++) anBandList.push_back( i ); } else { if( anBandList.size() == 0 ) anBandList.push_back( 1 ); } /* -------------------------------------------------------------------- */ /* Open source vector dataset. */ /* -------------------------------------------------------------------- */ OGRDataSourceH hSrcDS; hSrcDS = OGROpen( pszSrcFilename, FALSE, NULL ); if( hSrcDS == NULL ) { fprintf( stderr, "Failed to open feature source: %s\n", pszSrcFilename); exit( 1 ); } if( pszSQL == NULL && papszLayers == NULL ) { if( OGR_DS_GetLayerCount(hSrcDS) == 1 ) { papszLayers = CSLAddString(NULL, OGR_L_GetName(OGR_DS_GetLayer(hSrcDS, 0))); } else { fprintf( stderr, "At least one of -l or -sql required.\n\n" ); Usage(); } } /* -------------------------------------------------------------------- */ /* Open target raster file. Eventually we will add optional */ /* creation. */ /* -------------------------------------------------------------------- */ GDALDatasetH hDstDS = NULL; if (bCreateOutput) { /* -------------------------------------------------------------------- */ /* Find the output driver. */ /* -------------------------------------------------------------------- */ hDriver = GDALGetDriverByName( pszFormat ); if( hDriver == NULL || GDALGetMetadataItem( hDriver, GDAL_DCAP_CREATE, NULL ) == NULL ) { int iDr; printf( "Output driver `%s' not recognised or does not support\n", pszFormat ); printf( "direct output file creation. The following format drivers are configured\n" "and support direct output:\n" ); for( iDr = 0; iDr < GDALGetDriverCount(); iDr++ ) { GDALDriverH hDriver = GDALGetDriver(iDr); if( GDALGetMetadataItem( hDriver, GDAL_DCAP_CREATE, NULL) != NULL ) { printf( " %s: %s\n", GDALGetDriverShortName( hDriver ), GDALGetDriverLongName( hDriver ) ); } } printf( "\n" ); exit( 1 ); } if (!bQuiet && !bFormatExplicitelySet) CheckExtensionConsistency(pszDstFilename, pszFormat); } else { hDstDS = GDALOpen( pszDstFilename, GA_Update ); if( hDstDS == NULL ) exit( 2 ); } /* -------------------------------------------------------------------- */ /* Process SQL request. */ /* -------------------------------------------------------------------- */ if( pszSQL != NULL ) { OGRLayerH hLayer; hLayer = OGR_DS_ExecuteSQL( hSrcDS, pszSQL, NULL, NULL ); if( hLayer != NULL ) { if (bCreateOutput) { std::vector<OGRLayerH> ahLayers; ahLayers.push_back(hLayer); hDstDS = CreateOutputDataset(ahLayers, hSRS, bGotBounds, sEnvelop, hDriver, pszDstFilename, nXSize, nYSize, dfXRes, dfYRes, bTargetAlignedPixels, anBandList.size(), eOutputType, papszCreateOptions, adfInitVals, bNoDataSet, dfNoData); } ProcessLayer( hLayer, hSRS != NULL, hDstDS, anBandList, adfBurnValues, b3D, bInverse, pszBurnAttribute, papszRasterizeOptions, pfnProgress, NULL ); OGR_DS_ReleaseResultSet( hSrcDS, hLayer ); } } /* -------------------------------------------------------------------- */ /* Create output file if necessary. */ /* -------------------------------------------------------------------- */ int nLayerCount = CSLCount(papszLayers); if (bCreateOutput && hDstDS == NULL) { std::vector<OGRLayerH> ahLayers; for( i = 0; i < nLayerCount; i++ ) { OGRLayerH hLayer = OGR_DS_GetLayerByName( hSrcDS, papszLayers[i] ); if( hLayer == NULL ) { continue; } ahLayers.push_back(hLayer); } hDstDS = CreateOutputDataset(ahLayers, hSRS, bGotBounds, sEnvelop, hDriver, pszDstFilename, nXSize, nYSize, dfXRes, dfYRes, bTargetAlignedPixels, anBandList.size(), eOutputType, papszCreateOptions, adfInitVals, bNoDataSet, dfNoData); } /* -------------------------------------------------------------------- */ /* Process each layer. */ /* -------------------------------------------------------------------- */ for( i = 0; i < nLayerCount; i++ ) { OGRLayerH hLayer = OGR_DS_GetLayerByName( hSrcDS, papszLayers[i] ); if( hLayer == NULL ) { fprintf( stderr, "Unable to find layer %s, skipping.\n", papszLayers[i] ); continue; } if( pszWHERE ) { if( OGR_L_SetAttributeFilter( hLayer, pszWHERE ) != OGRERR_NONE ) break; } void *pScaledProgress; pScaledProgress = GDALCreateScaledProgress( 0.0, 1.0 * (i + 1) / nLayerCount, pfnProgress, NULL ); ProcessLayer( hLayer, hSRS != NULL, hDstDS, anBandList, adfBurnValues, b3D, bInverse, pszBurnAttribute, papszRasterizeOptions, GDALScaledProgress, pScaledProgress ); GDALDestroyScaledProgress( pScaledProgress ); } /* -------------------------------------------------------------------- */ /* Cleanup */ /* -------------------------------------------------------------------- */ OGR_DS_Destroy( hSrcDS ); GDALClose( hDstDS ); OSRDestroySpatialReference(hSRS); CSLDestroy( argv ); CSLDestroy( papszRasterizeOptions ); CSLDestroy( papszLayers ); CSLDestroy( papszCreateOptions ); GDALDestroyDriverManager(); OGRCleanupAll(); return 0; }
QgsCoordinateReferenceSystem::~QgsCoordinateReferenceSystem() { OSRDestroySpatialReference( mCRS ); }
int QgsRasterCalculator::processCalculation( QProgressDialog* p ) { //prepare search string / tree QString errorString; QgsRasterCalcNode* calcNode = QgsRasterCalcNode::parseRasterCalcString( mFormulaString, errorString ); if ( !calcNode ) { //error } double targetGeoTransform[6]; outputGeoTransform( targetGeoTransform ); //open all input rasters for reading QMap< QString, GDALRasterBandH > mInputRasterBands; //raster references and corresponding scanline data QMap< QString, QgsRasterMatrix* > inputScanLineData; //stores raster references and corresponding scanline data QVector< GDALDatasetH > mInputDatasets; //raster references and corresponding dataset QVector<QgsRasterCalculatorEntry>::const_iterator it = mRasterEntries.constBegin(); for ( ; it != mRasterEntries.constEnd(); ++it ) { if ( !it->raster ) // no raster layer in entry { return 2; } GDALDatasetH inputDataset = GDALOpen( TO8( it->raster->source() ), GA_ReadOnly ); if ( inputDataset == NULL ) { return 2; } //check if the input dataset is south up or rotated. If yes, use GDALAutoCreateWarpedVRT to create a north up raster double inputGeoTransform[6]; if ( GDALGetGeoTransform( inputDataset, inputGeoTransform ) == CE_None && ( inputGeoTransform[1] < 0.0 || inputGeoTransform[2] != 0.0 || inputGeoTransform[4] != 0.0 || inputGeoTransform[5] > 0.0 ) ) { GDALDatasetH vDataset = GDALAutoCreateWarpedVRT( inputDataset, NULL, NULL, GRA_NearestNeighbour, 0.2, NULL ); mInputDatasets.push_back( vDataset ); mInputDatasets.push_back( inputDataset ); inputDataset = vDataset; } else { mInputDatasets.push_back( inputDataset ); } GDALRasterBandH inputRasterBand = GDALGetRasterBand( inputDataset, it->bandNumber ); if ( inputRasterBand == NULL ) { return 2; } int nodataSuccess; double nodataValue = GDALGetRasterNoDataValue( inputRasterBand, &nodataSuccess ); mInputRasterBands.insert( it->ref, inputRasterBand ); inputScanLineData.insert( it->ref, new QgsRasterMatrix( mNumOutputColumns, 1, new float[mNumOutputColumns], nodataValue ) ); } //open output dataset for writing GDALDriverH outputDriver = openOutputDriver(); if ( outputDriver == NULL ) { return 1; } GDALDatasetH outputDataset = openOutputFile( outputDriver ); //copy the projection info from the first input raster if ( mRasterEntries.size() > 0 ) { QgsRasterLayer* rl = mRasterEntries.at( 0 ).raster; if ( rl ) { char* crsWKT = 0; OGRSpatialReferenceH ogrSRS = OSRNewSpatialReference( NULL ); if ( OSRSetFromUserInput( ogrSRS, rl->crs().authid().toUtf8().constData() ) == OGRERR_NONE ) { OSRExportToWkt( ogrSRS, &crsWKT ); GDALSetProjection( outputDataset, crsWKT ); } else { GDALSetProjection( outputDataset, TO8( rl->crs().toWkt() ) ); } OSRDestroySpatialReference( ogrSRS ); CPLFree( crsWKT ); } } GDALRasterBandH outputRasterBand = GDALGetRasterBand( outputDataset, 1 ); float outputNodataValue = -FLT_MAX; GDALSetRasterNoDataValue( outputRasterBand, outputNodataValue ); float* resultScanLine = ( float * ) CPLMalloc( sizeof( float ) * mNumOutputColumns ); if ( p ) { p->setMaximum( mNumOutputRows ); } QgsRasterMatrix resultMatrix; //read / write line by line for ( int i = 0; i < mNumOutputRows; ++i ) { if ( p ) { p->setValue( i ); } if ( p && p->wasCanceled() ) { break; } //fill buffers QMap< QString, QgsRasterMatrix* >::iterator bufferIt = inputScanLineData.begin(); for ( ; bufferIt != inputScanLineData.end(); ++bufferIt ) { double sourceTransformation[6]; GDALRasterBandH sourceRasterBand = mInputRasterBands[bufferIt.key()]; GDALGetGeoTransform( GDALGetBandDataset( sourceRasterBand ), sourceTransformation ); //the function readRasterPart calls GDALRasterIO (and ev. does some conversion if raster transformations are not the same) readRasterPart( targetGeoTransform, 0, i, mNumOutputColumns, 1, sourceTransformation, sourceRasterBand, bufferIt.value()->data() ); } if ( calcNode->calculate( inputScanLineData, resultMatrix ) ) { bool resultIsNumber = resultMatrix.isNumber(); float* calcData; if ( resultIsNumber ) //scalar result. Insert number for every pixel { calcData = new float[mNumOutputColumns]; for ( int j = 0; j < mNumOutputColumns; ++j ) { calcData[j] = resultMatrix.number(); } } else //result is real matrix { calcData = resultMatrix.data(); } //replace all matrix nodata values with output nodatas for ( int j = 0; j < mNumOutputColumns; ++j ) { if ( calcData[j] == resultMatrix.nodataValue() ) { calcData[j] = outputNodataValue; } } //write scanline to the dataset if ( GDALRasterIO( outputRasterBand, GF_Write, 0, i, mNumOutputColumns, 1, calcData, mNumOutputColumns, 1, GDT_Float32, 0, 0 ) != CE_None ) { qWarning( "RasterIO error!" ); } if ( resultIsNumber ) { delete[] calcData; } } } if ( p ) { p->setValue( mNumOutputRows ); } //close datasets and release memory delete calcNode; QMap< QString, QgsRasterMatrix* >::iterator bufferIt = inputScanLineData.begin(); for ( ; bufferIt != inputScanLineData.end(); ++bufferIt ) { delete bufferIt.value(); } inputScanLineData.clear(); QVector< GDALDatasetH >::iterator datasetIt = mInputDatasets.begin(); for ( ; datasetIt != mInputDatasets.end(); ++ datasetIt ) { GDALClose( *datasetIt ); } if ( p && p->wasCanceled() ) { //delete the dataset without closing (because it is faster) GDALDeleteDataset( outputDriver, mOutputFile.toLocal8Bit().data() ); return 3; } GDALClose( outputDataset ); CPLFree( resultScanLine ); return 0; }
static void ProcessLayer( OGRLayerH hSrcLayer, int bSRSIsSet, GDALDatasetH hDstDS, std::vector<int> anBandList, std::vector<double> &adfBurnValues, int b3D, int bInverse, const char *pszBurnAttribute, char **papszRasterizeOptions, GDALProgressFunc pfnProgress, void* pProgressData ) { /* -------------------------------------------------------------------- */ /* Checkout that SRS are the same. */ /* If -a_srs is specified, skip the test */ /* -------------------------------------------------------------------- */ if (!bSRSIsSet) { OGRSpatialReferenceH hDstSRS = NULL; if( GDALGetProjectionRef( hDstDS ) != NULL ) { char *pszProjection; pszProjection = (char *) GDALGetProjectionRef( hDstDS ); hDstSRS = OSRNewSpatialReference(NULL); if( OSRImportFromWkt( hDstSRS, &pszProjection ) != CE_None ) { OSRDestroySpatialReference(hDstSRS); hDstSRS = NULL; } } OGRSpatialReferenceH hSrcSRS = OGR_L_GetSpatialRef(hSrcLayer); if( hDstSRS != NULL && hSrcSRS != NULL ) { if( OSRIsSame(hSrcSRS, hDstSRS) == FALSE ) { fprintf(stderr, "Warning : the output raster dataset and the input vector layer do not have the same SRS.\n" "Results might be incorrect (no on-the-fly reprojection of input data).\n"); } } else if( hDstSRS != NULL && hSrcSRS == NULL ) { fprintf(stderr, "Warning : the output raster dataset has a SRS, but the input vector layer SRS is unknown.\n" "Ensure input vector has the same SRS, otherwise results might be incorrect.\n"); } else if( hDstSRS == NULL && hSrcSRS != NULL ) { fprintf(stderr, "Warning : the input vector layer has a SRS, but the output raster dataset SRS is unknown.\n" "Ensure output raster dataset has the same SRS, otherwise results might be incorrect.\n"); } if( hDstSRS != NULL ) { OSRDestroySpatialReference(hDstSRS); } } /* -------------------------------------------------------------------- */ /* Get field index, and check. */ /* -------------------------------------------------------------------- */ int iBurnField = -1; if( pszBurnAttribute ) { iBurnField = OGR_FD_GetFieldIndex( OGR_L_GetLayerDefn( hSrcLayer ), pszBurnAttribute ); if( iBurnField == -1 ) { printf( "Failed to find field %s on layer %s, skipping.\n", pszBurnAttribute, OGR_FD_GetName( OGR_L_GetLayerDefn( hSrcLayer ) ) ); return; } } /* -------------------------------------------------------------------- */ /* Collect the geometries from this layer, and build list of */ /* burn values. */ /* -------------------------------------------------------------------- */ OGRFeatureH hFeat; std::vector<OGRGeometryH> ahGeometries; std::vector<double> adfFullBurnValues; OGR_L_ResetReading( hSrcLayer ); while( (hFeat = OGR_L_GetNextFeature( hSrcLayer )) != NULL ) { OGRGeometryH hGeom; if( OGR_F_GetGeometryRef( hFeat ) == NULL ) { OGR_F_Destroy( hFeat ); continue; } hGeom = OGR_G_Clone( OGR_F_GetGeometryRef( hFeat ) ); ahGeometries.push_back( hGeom ); for( unsigned int iBand = 0; iBand < anBandList.size(); iBand++ ) { if( adfBurnValues.size() > 0 ) adfFullBurnValues.push_back( adfBurnValues[MIN(iBand,adfBurnValues.size()-1)] ); else if( pszBurnAttribute ) { adfFullBurnValues.push_back( OGR_F_GetFieldAsDouble( hFeat, iBurnField ) ); } /* I have made the 3D option exclusive to other options since it can be used to modify the value from "-burn value" or "-a attribute_name" */ if( b3D ) { // TODO: get geometry "z" value /* Points and Lines will have their "z" values collected at the point and line levels respectively. However filled polygons (GDALdllImageFilledPolygon) can use some help by getting their "z" values here. */ adfFullBurnValues.push_back( 0.0 ); } } OGR_F_Destroy( hFeat ); } /* -------------------------------------------------------------------- */ /* If we are in inverse mode, we add one extra ring around the */ /* whole dataset to invert the concept of insideness and then */ /* merge everything into one geometry collection. */ /* -------------------------------------------------------------------- */ if( bInverse ) { if( ahGeometries.size() == 0 ) { for( unsigned int iBand = 0; iBand < anBandList.size(); iBand++ ) { if( adfBurnValues.size() > 0 ) adfFullBurnValues.push_back( adfBurnValues[MIN(iBand,adfBurnValues.size()-1)] ); else /* FIXME? Not sure what to do exactly in the else case, but we must insert a value */ adfFullBurnValues.push_back( 0.0 ); } } InvertGeometries( hDstDS, ahGeometries ); } /* -------------------------------------------------------------------- */ /* Perform the burn. */ /* -------------------------------------------------------------------- */ GDALRasterizeGeometries( hDstDS, anBandList.size(), &(anBandList[0]), ahGeometries.size(), &(ahGeometries[0]), NULL, NULL, &(adfFullBurnValues[0]), papszRasterizeOptions, pfnProgress, pProgressData ); /* -------------------------------------------------------------------- */ /* Cleanup geometries. */ /* -------------------------------------------------------------------- */ int iGeom; for( iGeom = ahGeometries.size()-1; iGeom >= 0; iGeom-- ) OGR_G_DestroyGeometry( ahGeometries[iGeom] ); }
~test_osr_data() { OSRDestroySpatialReference(srs_); }
int main(int argc, char *argv[]) { const char *index_filename = NULL; const char *tile_index = "location"; int i_arg, ti_field; OGRDataSourceH hTileIndexDS; OGRLayerH hLayer = NULL; OGRFeatureDefnH hFDefn; int write_absolute_path = FALSE; char* current_path = NULL; int i; int nExistingFiles; int skip_different_projection = FALSE; char** existingFilesTab = NULL; int alreadyExistingProjectionRefValid = FALSE; char* alreadyExistingProjectionRef = NULL; char* index_filename_mod; int bExists; VSIStatBuf sStatBuf; const char *pszTargetSRS = ""; int bSetTargetSRS = FALSE; OGRSpatialReferenceH hTargetSRS = NULL; /* Check that we are running against at least GDAL 1.4 */ /* Note to developers : if we use newer API, please change the requirement */ if (atoi(GDALVersionInfo("VERSION_NUM")) < 1400) { fprintf(stderr, "At least, GDAL >= 1.4.0 is required for this version of %s, " "which was compiled against GDAL %s\n", argv[0], GDAL_RELEASE_NAME); exit(1); } GDALAllRegister(); OGRRegisterAll(); argc = GDALGeneralCmdLineProcessor( argc, &argv, 0 ); if( argc < 1 ) exit( -argc ); /* -------------------------------------------------------------------- */ /* Get commandline arguments other than the GDAL raster filenames. */ /* -------------------------------------------------------------------- */ for( i_arg = 1; i_arg < argc; i_arg++ ) { if( EQUAL(argv[i_arg], "--utility_version") ) { printf("%s was compiled against GDAL %s and is running against GDAL %s\n", argv[0], GDAL_RELEASE_NAME, GDALVersionInfo("RELEASE_NAME")); return 0; } else if( EQUAL(argv[i_arg],"--help") ) Usage(NULL); else if( strcmp(argv[i_arg],"-tileindex") == 0 ) { CHECK_HAS_ENOUGH_ADDITIONAL_ARGS(1); tile_index = argv[++i_arg]; } else if( strcmp(argv[i_arg],"-t_srs") == 0 ) { CHECK_HAS_ENOUGH_ADDITIONAL_ARGS(1); pszTargetSRS = argv[++i_arg]; bSetTargetSRS = TRUE; } else if ( strcmp(argv[i_arg],"-write_absolute_path") == 0 ) { write_absolute_path = TRUE; } else if ( strcmp(argv[i_arg],"-skip_different_projection") == 0 ) { skip_different_projection = TRUE; } else if( argv[i_arg][0] == '-' ) Usage(CPLSPrintf("Unkown option name '%s'", argv[i_arg])); else if( index_filename == NULL ) { index_filename = argv[i_arg]; i_arg++; break; } } if( index_filename == NULL ) Usage("No index filename specified."); if( i_arg == argc ) Usage("No file to index specified."); /* -------------------------------------------------------------------- */ /* Create and validate target SRS if given. */ /* -------------------------------------------------------------------- */ if( bSetTargetSRS ) { if ( skip_different_projection ) { fprintf( stderr, "Warning : -skip_different_projection does not apply " "when -t_srs is requested.\n" ); } hTargetSRS = OSRNewSpatialReference(""); if( OSRSetFromUserInput( hTargetSRS, pszTargetSRS ) != CE_None ) { OSRDestroySpatialReference( hTargetSRS ); fprintf( stderr, "Invalid target SRS `%s'.\n", pszTargetSRS ); exit(1); } } /* -------------------------------------------------------------------- */ /* Open or create the target shapefile and DBF file. */ /* -------------------------------------------------------------------- */ index_filename_mod = CPLStrdup(CPLResetExtension(index_filename, "shp")); bExists = (VSIStat(index_filename_mod, &sStatBuf) == 0); if (!bExists) { CPLFree(index_filename_mod); index_filename_mod = CPLStrdup(CPLResetExtension(index_filename, "SHP")); bExists = (VSIStat(index_filename_mod, &sStatBuf) == 0); } CPLFree(index_filename_mod); if (bExists) { hTileIndexDS = OGROpen( index_filename, TRUE, NULL ); if (hTileIndexDS != NULL) { hLayer = OGR_DS_GetLayer(hTileIndexDS, 0); } } else { OGRSFDriverH hDriver; const char* pszDriverName = "ESRI Shapefile"; printf( "Creating new index file...\n" ); hDriver = OGRGetDriverByName( pszDriverName ); if( hDriver == NULL ) { printf( "%s driver not available.\n", pszDriverName ); exit( 1 ); } hTileIndexDS = OGR_Dr_CreateDataSource( hDriver, index_filename, NULL ); if (hTileIndexDS) { char* pszLayerName = CPLStrdup(CPLGetBasename(index_filename)); /* get spatial reference for output file from target SRS (if set) */ /* or from first input file */ OGRSpatialReferenceH hSpatialRef = NULL; if( bSetTargetSRS ) { hSpatialRef = OSRClone( hTargetSRS ); } else { GDALDatasetH hDS = GDALOpen( argv[i_arg], GA_ReadOnly ); if (hDS) { const char* pszWKT = GDALGetProjectionRef(hDS); if (pszWKT != NULL && pszWKT[0] != '\0') { hSpatialRef = OSRNewSpatialReference(pszWKT); } GDALClose(hDS); } } hLayer = OGR_DS_CreateLayer( hTileIndexDS, pszLayerName, hSpatialRef, wkbPolygon, NULL ); CPLFree(pszLayerName); if (hSpatialRef) OSRRelease(hSpatialRef); if (hLayer) { OGRFieldDefnH hFieldDefn = OGR_Fld_Create( tile_index, OFTString ); OGR_Fld_SetWidth( hFieldDefn, 255); OGR_L_CreateField( hLayer, hFieldDefn, TRUE ); OGR_Fld_Destroy(hFieldDefn); } } } if( hTileIndexDS == NULL || hLayer == NULL ) { fprintf( stderr, "Unable to open/create shapefile `%s'.\n", index_filename ); exit(2); } hFDefn = OGR_L_GetLayerDefn(hLayer); for( ti_field = 0; ti_field < OGR_FD_GetFieldCount(hFDefn); ti_field++ ) { OGRFieldDefnH hFieldDefn = OGR_FD_GetFieldDefn( hFDefn, ti_field ); if( strcmp(OGR_Fld_GetNameRef(hFieldDefn), tile_index) == 0 ) break; } if( ti_field == OGR_FD_GetFieldCount(hFDefn) ) { fprintf( stderr, "Unable to find field `%s' in DBF file `%s'.\n", tile_index, index_filename ); exit(2); } /* Load in memory existing file names in SHP */ nExistingFiles = OGR_L_GetFeatureCount(hLayer, FALSE); if (nExistingFiles) { OGRFeatureH hFeature; existingFilesTab = (char**)CPLMalloc(nExistingFiles * sizeof(char*)); for(i=0;i<nExistingFiles;i++) { hFeature = OGR_L_GetNextFeature(hLayer); existingFilesTab[i] = CPLStrdup(OGR_F_GetFieldAsString( hFeature, ti_field )); if (i == 0) { GDALDatasetH hDS = GDALOpen(existingFilesTab[i], GA_ReadOnly ); if (hDS) { alreadyExistingProjectionRefValid = TRUE; alreadyExistingProjectionRef = CPLStrdup(GDALGetProjectionRef(hDS)); GDALClose(hDS); } } OGR_F_Destroy( hFeature ); } } if (write_absolute_path) { current_path = CPLGetCurrentDir(); if (current_path == NULL) { fprintf( stderr, "This system does not support the CPLGetCurrentDir call. " "The option -write_absolute_path will have no effect\n"); write_absolute_path = FALSE; } } /* -------------------------------------------------------------------- */ /* loop over GDAL files, processing. */ /* -------------------------------------------------------------------- */ for( ; i_arg < argc; i_arg++ ) { GDALDatasetH hDS; double adfGeoTransform[6]; double adfX[5], adfY[5]; int nXSize, nYSize; char* fileNameToWrite; const char* projectionRef; VSIStatBuf sStatBuf; int k; OGRFeatureH hFeature; OGRGeometryH hPoly, hRing; /* Make sure it is a file before building absolute path name */ if (write_absolute_path && CPLIsFilenameRelative( argv[i_arg] ) && VSIStat( argv[i_arg], &sStatBuf ) == 0) { fileNameToWrite = CPLStrdup(CPLProjectRelativeFilename(current_path, argv[i_arg])); } else { fileNameToWrite = CPLStrdup(argv[i_arg]); } /* Checks that file is not already in tileindex */ for(i=0;i<nExistingFiles;i++) { if (EQUAL(fileNameToWrite, existingFilesTab[i])) { fprintf(stderr, "File %s is already in tileindex. Skipping it.\n", fileNameToWrite); break; } } if (i != nExistingFiles) { CPLFree(fileNameToWrite); continue; } hDS = GDALOpen( argv[i_arg], GA_ReadOnly ); if( hDS == NULL ) { fprintf( stderr, "Unable to open %s, skipping.\n", argv[i_arg] ); CPLFree(fileNameToWrite); continue; } GDALGetGeoTransform( hDS, adfGeoTransform ); if( adfGeoTransform[0] == 0.0 && adfGeoTransform[1] == 1.0 && adfGeoTransform[3] == 0.0 && ABS(adfGeoTransform[5]) == 1.0 ) { fprintf( stderr, "It appears no georeferencing is available for\n" "`%s', skipping.\n", argv[i_arg] ); GDALClose( hDS ); CPLFree(fileNameToWrite); continue; } projectionRef = GDALGetProjectionRef(hDS); /* if not set target srs, test that the current file uses same projection as others */ if( !bSetTargetSRS ) { if (alreadyExistingProjectionRefValid) { int projectionRefNotNull, alreadyExistingProjectionRefNotNull; projectionRefNotNull = projectionRef && projectionRef[0]; alreadyExistingProjectionRefNotNull = alreadyExistingProjectionRef && alreadyExistingProjectionRef[0]; if ((projectionRefNotNull && alreadyExistingProjectionRefNotNull && EQUAL(projectionRef, alreadyExistingProjectionRef) == 0) || (projectionRefNotNull != alreadyExistingProjectionRefNotNull)) { fprintf(stderr, "Warning : %s is not using the same projection system as " "other files in the tileindex.\n" "This may cause problems when using it in MapServer for example.\n" "Use -t_srs option to set target projection system (not supported by MapServer).\n" "%s\n", argv[i_arg], (skip_different_projection) ? "Skipping this file." : ""); if (skip_different_projection) { CPLFree(fileNameToWrite); GDALClose( hDS ); continue; } } } else { alreadyExistingProjectionRefValid = TRUE; alreadyExistingProjectionRef = CPLStrdup(projectionRef); } } nXSize = GDALGetRasterXSize( hDS ); nYSize = GDALGetRasterYSize( hDS ); adfX[0] = adfGeoTransform[0] + 0 * adfGeoTransform[1] + 0 * adfGeoTransform[2]; adfY[0] = adfGeoTransform[3] + 0 * adfGeoTransform[4] + 0 * adfGeoTransform[5]; adfX[1] = adfGeoTransform[0] + nXSize * adfGeoTransform[1] + 0 * adfGeoTransform[2]; adfY[1] = adfGeoTransform[3] + nXSize * adfGeoTransform[4] + 0 * adfGeoTransform[5]; adfX[2] = adfGeoTransform[0] + nXSize * adfGeoTransform[1] + nYSize * adfGeoTransform[2]; adfY[2] = adfGeoTransform[3] + nXSize * adfGeoTransform[4] + nYSize * adfGeoTransform[5]; adfX[3] = adfGeoTransform[0] + 0 * adfGeoTransform[1] + nYSize * adfGeoTransform[2]; adfY[3] = adfGeoTransform[3] + 0 * adfGeoTransform[4] + nYSize * adfGeoTransform[5]; adfX[4] = adfGeoTransform[0] + 0 * adfGeoTransform[1] + 0 * adfGeoTransform[2]; adfY[4] = adfGeoTransform[3] + 0 * adfGeoTransform[4] + 0 * adfGeoTransform[5]; /* if set target srs, do the forward transformation of all points */ if( bSetTargetSRS ) { OGRSpatialReferenceH hSourceSRS = NULL; OGRCoordinateTransformationH hCT = NULL; hSourceSRS = OSRNewSpatialReference( projectionRef ); if( hSourceSRS && !OSRIsSame( hSourceSRS, hTargetSRS ) ) { hCT = OCTNewCoordinateTransformation( hSourceSRS, hTargetSRS ); if( hCT == NULL || !OCTTransform( hCT, 5, adfX, adfY, NULL ) ) { fprintf( stderr, "Warning : unable to transform points from source SRS `%s' to target SRS `%s'\n" "for file `%s' - file skipped\n", projectionRef, pszTargetSRS, fileNameToWrite ); if ( hCT ) OCTDestroyCoordinateTransformation( hCT ); if ( hSourceSRS ) OSRDestroySpatialReference( hSourceSRS ); continue; } if ( hCT ) OCTDestroyCoordinateTransformation( hCT ); } if ( hSourceSRS ) OSRDestroySpatialReference( hSourceSRS ); } hFeature = OGR_F_Create( OGR_L_GetLayerDefn( hLayer ) ); OGR_F_SetFieldString( hFeature, ti_field, fileNameToWrite ); hPoly = OGR_G_CreateGeometry(wkbPolygon); hRing = OGR_G_CreateGeometry(wkbLinearRing); for(k=0;k<5;k++) OGR_G_SetPoint_2D(hRing, k, adfX[k], adfY[k]); OGR_G_AddGeometryDirectly( hPoly, hRing ); OGR_F_SetGeometryDirectly( hFeature, hPoly ); if( OGR_L_CreateFeature( hLayer, hFeature ) != OGRERR_NONE ) { printf( "Failed to create feature in shapefile.\n" ); break; } OGR_F_Destroy( hFeature ); CPLFree(fileNameToWrite); GDALClose( hDS ); } CPLFree(current_path); if (nExistingFiles) { for(i=0;i<nExistingFiles;i++) { CPLFree(existingFilesTab[i]); } CPLFree(existingFilesTab); } CPLFree(alreadyExistingProjectionRef); if ( hTargetSRS ) OSRDestroySpatialReference( hTargetSRS ); OGR_DS_Destroy( hTileIndexDS ); GDALDestroyDriverManager(); OGRCleanupAll(); CSLDestroy(argv); exit( 0 ); }
static int RasterliteInsertSRID(OGRDataSourceH hDS, const char* pszWKT) { CPLString osSQL; int nAuthorityCode = 0; CPLString osAuthorityName, osProjCS, osProj4; if (pszWKT != NULL && strlen(pszWKT) != 0) { OGRSpatialReferenceH hSRS = OSRNewSpatialReference(pszWKT); if (hSRS) { const char* pszAuthorityName = OSRGetAuthorityName(hSRS, NULL); if (pszAuthorityName) osAuthorityName = pszAuthorityName; const char* pszProjCS = OSRGetAttrValue(hSRS, "PROJCS", 0); if (pszProjCS) osProjCS = pszProjCS; const char* pszAuthorityCode = OSRGetAuthorityCode(hSRS, NULL); if (pszAuthorityCode) nAuthorityCode = atoi(pszAuthorityCode); char *pszProj4 = NULL; if( OSRExportToProj4( hSRS, &pszProj4 ) != OGRERR_NONE ) pszProj4 = CPLStrdup(""); osProj4 = pszProj4; CPLFree(pszProj4); } OSRDestroySpatialReference(hSRS); } int nSRSId = -1; if (nAuthorityCode != 0 && osAuthorityName.size() != 0) { osSQL.Printf ("SELECT srid FROM spatial_ref_sys WHERE auth_srid = %d", nAuthorityCode); OGRLayerH hLyr = OGR_DS_ExecuteSQL(hDS, osSQL.c_str(), NULL, NULL); if (hLyr == NULL) { nSRSId = nAuthorityCode; if ( osProjCS.size() != 0 ) osSQL.Printf( "INSERT INTO spatial_ref_sys " "(srid, auth_name, auth_srid, ref_sys_name, proj4text) " "VALUES (%d, '%s', '%d', '%s', '%s')", nSRSId, osAuthorityName.c_str(), nAuthorityCode, osProjCS.c_str(), osProj4.c_str() ); else osSQL.Printf( "INSERT INTO spatial_ref_sys " "(srid, auth_name, auth_srid, proj4text) " "VALUES (%d, '%s', '%d', '%s')", nSRSId, osAuthorityName.c_str(), nAuthorityCode, osProj4.c_str() ); OGR_DS_ExecuteSQL(hDS, osSQL.c_str(), NULL, NULL); } else { OGRFeatureH hFeat = OGR_L_GetNextFeature(hLyr); if (hFeat) { nSRSId = OGR_F_GetFieldAsInteger(hFeat, 0); OGR_F_Destroy(hFeat); } OGR_DS_ReleaseResultSet(hDS, hLyr); } } return nSRSId; }
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 }
void GDALBlockAccessor::open(const Char8 *szFilename) { #ifdef OSG_WITH_GDAL _pDataset = static_cast<GDALDataset *>(GDALOpen(szFilename, GA_ReadOnly)); if(_pDataset != NULL) { _pGeoRef = GeoReferenceAttachment::create(); 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); } } 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); } if(_pBand != NULL) { _eImgFormat = Image::OSG_INVALID_PF; switch(_pDataset->GetRasterCount()) { case 1: _eImgFormat = Image::OSG_L_PF; break; case 2: _eImgFormat = Image::OSG_LA_PF; break; case 3: _eImgFormat = Image::OSG_RGB_PF; break; case 4: _eImgFormat = Image::OSG_RGBA_PF; break; } _eImgType = Image::OSG_INVALID_IMAGEDATATYPE; switch(_pBand->GetRasterDataType()) { case GDT_Byte: _eImgType = Image::OSG_UINT8_IMAGEDATA; break; case GDT_UInt16: _eImgType = Image::OSG_UINT16_IMAGEDATA; break; case GDT_Int16: _eImgType = Image::OSG_INT16_IMAGEDATA; break; case GDT_UInt32: _eImgType = Image::OSG_UINT32_IMAGEDATA; break; case GDT_Int32: _eImgType = Image::OSG_INT32_IMAGEDATA; break; case GDT_Float32: _eImgType = Image::OSG_FLOAT32_IMAGEDATA; break; case GDT_Float64: case GDT_CInt16: case GDT_CInt32: case GDT_CFloat32: case GDT_CFloat64: default: GDALClose(_pDataset); _pDataset = NULL; break; } _vSize[0] = _pDataset->GetRasterXSize(); _vSize[1] = _pDataset->GetRasterYSize(); _fNoDataValue = _pBand->GetNoDataValue(); _pGeoRef->setNoDataValue(_fNoDataValue); } } #endif }