void object::test<2>()
{
ensure("SRS handle is NULL", NULL != srs_);
const char* wkt = "\"\"PROJCS[\"unnamed\",GEOGCS[\"NAD27\","
"DATUM[\"North_American_Datum_1927\","
"SPHEROID[\"Clarke 1866\",6378206.4,294.9786982139006,"
"AUTHORITY[\"EPSG\",\"7008\"]],AUTHORITY[\"EPSG\",\"6267\"]],"
"PRIMEM[\"Greenwich\",0],UNIT[\"degree\",0.0174532925199433],"
"AUTHORITY[\"EPSG\",\"4267\"]],PROJECTION[\"Lambert_Conformal_Conic_2SP\"],"
"PARAMETER[\"standard_parallel_1\",33.90363402777778],"
"PARAMETER[\"standard_parallel_2\",33.62529002777778],"
"PARAMETER[\"latitude_of_origin\",33.76446202777777],"
"PARAMETER[\"central_meridian\",-117.4745428888889],"
"PARAMETER[\"false_easting\",0],PARAMETER[\"false_northing\",0],"
"UNIT[\"metre\",1,AUTHORITY[\"EPSG\",\"9001\"]]]\"\"";
err_ = OSRImportFromWkt(srs_, (char**) &wkt);
ensure_equals("Can't import Lambert Conformal Conic projection",
err_, OGRERR_NONE);
char* proj = NULL;
char* units = NULL;
double* params = NULL;
const int size = 17;
err_ = OSRExportToPCI(srs_, &proj, &units, ¶ms);
ensure_equals("OSRExportToPCI() failed", err_, OGRERR_NONE);
ensure_equals("Invalid projection definition",
std::string(proj), std::string("LCC D-01"));
ensure_equals("Invalid projection units",
std::string(units), std::string("METRE"));
const double maxError = 0.0000005;
ensure("Invalid 2nd projection parameter",
std::fabs(params[2] - (-117.4745429)) <= maxError);
ensure("Invalid 3rd projection parameter",
std::fabs(params[3] - 33.76446203) <= maxError);
ensure("Invalid 4th projection parameter",
std::fabs(params[4] - 33.90363403) <= maxError);
ensure("Invalid 5th projection parameter",
std::fabs(params[5] - 33.62529003) <= maxError);
CPLFree(proj);
CPLFree(units);
CPLFree(params);
}
static QString _setSourceCrsFromWKT(const QString& wkt)
{
QString ret;
OGRSpatialReferenceH hSRS = OSRNewSpatialReference(NULL);
QByteArray arr = wkt.toUtf8();
const char* raw_data = arr.constData();
if (OSRImportFromWkt(hSRS, const_cast<char**>(&raw_data)) == OGRERR_NONE)
{
char * ppszReturn = 0;
if (OSRExportToProj4(hSRS, &ppszReturn) == OGRERR_NONE && ppszReturn != 0)
{
ret = ppszReturn;
}
}
OSRDestroySpatialReference(hSRS);
return ret;
}
bool QgsCoordinateReferenceSystem::createFromWkt( QString theWkt )
{
mIsValidFlag = false;
if ( theWkt.isEmpty() )
{
QgsDebugMsg( "theWkt is uninitialised, operation failed" );
return mIsValidFlag;
}
QgsDebugMsg( "QgsCoordinateReferenceSystem::createFromWkt(QString theWkt) using: " + theWkt );
QByteArray ba = theWkt.toLatin1();
const char *pWkt = ba.data();
OGRErr myInputResult = OSRImportFromWkt( mCRS, ( char ** ) & pWkt );
if ( myInputResult != OGRERR_NONE )
{
QgsDebugMsg( "\n---------------------------------------------------------------" );
QgsDebugMsg( "This CRS could *** NOT *** be set from the supplied Wkt " );
QgsDebugMsg( "INPUT: " + theWkt );
QgsDebugMsg( QString( "UNUSED WKT: %1" ).arg( pWkt ) );
QgsDebugMsg( "---------------------------------------------------------------\n" );
return mIsValidFlag;
}
// always morph from esri as it doesn't hurt anything
// FW: Hey, that's not right! It can screw stuff up! Disable
//myOgrSpatialRef.morphFromESRI();
// create the proj4 structs needed for transforming
char *proj4src = NULL;
OSRExportToProj4( mCRS, &proj4src );
//now that we have the proj4string, delegate to createFromProj4 so
// that we can try to fill in the remaining class members...
//create from Proj will set the isValidFlag
createFromProj4( QString( proj4src ) );
CPLFree( proj4src );
return mIsValidFlag;
//setMapunits will be called by createfromproj above
}
int main( int argc, char ** argv )
{
GDALDatasetH hDataset;
GDALRasterBandH hBand;
int i, iBand;
double adfGeoTransform[6];
GDALDriverH hDriver;
char **papszMetadata;
int bComputeMinMax = FALSE;
if( !GDALBridgeInitialize( "..", stderr ) )
{
fprintf( stderr, "Unable to intiailize GDAL bridge.\n" );
exit( 10 );
}
if( argc > 1 && strcmp(argv[1],"-mm") == 0 )
{
bComputeMinMax = TRUE;
argv++;
}
GDALAllRegister();
hDataset = GDALOpen( argv[1], GA_ReadOnly );
if( hDataset == NULL )
{
fprintf( stderr,
"GDALOpen failed - %d\n%s\n",
CPLGetLastErrorNo(), CPLGetLastErrorMsg() );
exit( 1 );
}
/* -------------------------------------------------------------------- */
/* Report general info. */
/* -------------------------------------------------------------------- */
hDriver = GDALGetDatasetDriver( hDataset );
printf( "Driver: %s/%s\n",
GDALGetDriverShortName( hDriver ),
GDALGetDriverLongName( hDriver ) );
printf( "Size is %d, %d\n",
GDALGetRasterXSize( hDataset ),
GDALGetRasterYSize( hDataset ) );
/* -------------------------------------------------------------------- */
/* Report projection. */
/* -------------------------------------------------------------------- */
if( GDALGetProjectionRef( hDataset ) != NULL )
{
OGRSpatialReferenceH hSRS;
char *pszProjection;
pszProjection = (char *) GDALGetProjectionRef( hDataset );
hSRS = OSRNewSpatialReference(NULL);
if( OSRImportFromWkt( hSRS, &pszProjection ) == CE_None )
{
char *pszPrettyWkt = NULL;
OSRExportToPrettyWkt( hSRS, &pszPrettyWkt, FALSE );
printf( "Coordinate System is:\n%s\n", pszPrettyWkt );
}
else
printf( "Coordinate System is `%s'\n",
GDALGetProjectionRef( hDataset ) );
OSRDestroySpatialReference( hSRS );
}
/* -------------------------------------------------------------------- */
/* Report Geotransform. */
/* -------------------------------------------------------------------- */
if( GDALGetGeoTransform( hDataset, adfGeoTransform ) == CE_None )
{
printf( "Origin = (%.6f,%.6f)\n",
adfGeoTransform[0], adfGeoTransform[3] );
printf( "Pixel Size = (%.6f,%.6f)\n",
adfGeoTransform[1], adfGeoTransform[5] );
}
/* -------------------------------------------------------------------- */
/* Report GCPs. */
/* -------------------------------------------------------------------- */
if( GDALGetGCPCount( hDataset ) > 0 )
{
printf( "GCP Projection = %s\n", GDALGetGCPProjection(hDataset) );
for( i = 0; i < GDALGetGCPCount(hDataset); i++ )
{
const GDAL_GCP *psGCP;
psGCP = GDALGetGCPs( hDataset ) + i;
printf( "GCP[%3d]: Id=%s, Info=%s\n"
" (%g,%g) -> (%g,%g,%g)\n",
i, psGCP->pszId, psGCP->pszInfo,
psGCP->dfGCPPixel, psGCP->dfGCPLine,
psGCP->dfGCPX, psGCP->dfGCPY, psGCP->dfGCPZ );
}
}
/* -------------------------------------------------------------------- */
/* Report metadata. */
/* -------------------------------------------------------------------- */
papszMetadata = GDALGetMetadata( hDataset, NULL );
if( papszMetadata != NULL )
{
printf( "Metadata:\n" );
for( i = 0; papszMetadata[i] != NULL; i++ )
{
printf( " %s\n", papszMetadata[i] );
}
}
/* -------------------------------------------------------------------- */
/* Report subdatasets. */
/* -------------------------------------------------------------------- */
papszMetadata = GDALGetMetadata( hDataset, "SUBDATASETS" );
if( papszMetadata != NULL )
{
printf( "Subdatasets:\n" );
for( i = 0; papszMetadata[i] != NULL; i++ )
{
printf( " %s\n", papszMetadata[i] );
}
}
/* -------------------------------------------------------------------- */
/* Report corners. */
/* -------------------------------------------------------------------- */
printf( "Corner Coordinates:\n" );
GDALInfoReportCorner( hDataset, "Upper Left",
0.0, 0.0 );
GDALInfoReportCorner( hDataset, "Lower Left",
0.0, GDALGetRasterYSize(hDataset));
GDALInfoReportCorner( hDataset, "Upper Right",
GDALGetRasterXSize(hDataset), 0.0 );
GDALInfoReportCorner( hDataset, "Lower Right",
GDALGetRasterXSize(hDataset),
GDALGetRasterYSize(hDataset) );
GDALInfoReportCorner( hDataset, "Center",
GDALGetRasterXSize(hDataset)/2.0,
GDALGetRasterYSize(hDataset)/2.0 );
/* ==================================================================== */
/* Loop over bands. */
/* ==================================================================== */
for( iBand = 0; iBand < GDALGetRasterCount( hDataset ); iBand++ )
{
double dfMin, dfMax, adfCMinMax[2], dfNoData;
int bGotMin, bGotMax, bGotNodata;
int nBlockXSize, nBlockYSize;
hBand = GDALGetRasterBand( hDataset, iBand+1 );
GDALGetBlockSize( hBand, &nBlockXSize, &nBlockYSize );
printf( "Band %d Block=%dx%d Type=%d, ColorInterp=%d\n", iBand+1,
nBlockXSize, nBlockYSize,
GDALGetRasterDataType(hBand),
GDALGetRasterColorInterpretation(hBand) );
dfMin = GDALGetRasterMinimum( hBand, &bGotMin );
dfMax = GDALGetRasterMaximum( hBand, &bGotMax );
printf( " Min=%.3f/%d, Max=%.3f/%d", dfMin, bGotMin, dfMax, bGotMax);
if( bComputeMinMax )
{
GDALComputeRasterMinMax( hBand, TRUE, adfCMinMax );
printf( ", Computed Min/Max=%.3f,%.3f",
adfCMinMax[0], adfCMinMax[1] );
}
printf( "\n" );
dfNoData = GDALGetRasterNoDataValue( hBand, &bGotNodata );
if( bGotNodata )
{
printf( " NoData Value=%g\n", dfNoData );
}
if( GDALGetOverviewCount(hBand) > 0 )
{
int iOverview;
printf( " Overviews: " );
for( iOverview = 0;
iOverview < GDALGetOverviewCount(hBand);
iOverview++ )
{
GDALRasterBandH hOverview;
if( iOverview != 0 )
printf( ", " );
hOverview = GDALGetOverview( hBand, iOverview );
printf( "%dx%d",
GDALGetRasterBandXSize( hOverview ),
GDALGetRasterBandYSize( hOverview ) );
}
printf( "\n" );
}
papszMetadata = GDALGetMetadata( hBand, NULL );
if( papszMetadata != NULL )
{
printf( "Metadata:\n" );
for( i = 0; papszMetadata[i] != NULL; i++ )
{
printf( " %s\n", papszMetadata[i] );
}
}
if( GDALGetRasterColorInterpretation(hBand) == GCI_PaletteIndex )
{
GDALColorTableH hTable;
int i;
hTable = GDALGetRasterColorTable( hBand );
printf( " Color Table (%s with %d entries)\n",
GDALGetPaletteInterpretationName(
GDALGetPaletteInterpretation( hTable )),
GDALGetColorEntryCount( hTable ) );
for( i = 0; i < GDALGetColorEntryCount( hTable ); i++ )
{
GDALColorEntry sEntry;
GDALGetColorEntryAsRGB( hTable, i, &sEntry );
printf( " %3d: %d,%d,%d,%d\n",
i,
sEntry.c1,
sEntry.c2,
sEntry.c3,
sEntry.c4 );
}
}
}
GDALClose( hDataset );
exit( 0 );
}
static CPLErr ProcessLayer(
OGRLayerH hSrcLayer, int bSRSIsSet,
GDALDatasetH hDstDS, std::vector<int> anBandList,
const 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 */
/* -------------------------------------------------------------------- */
OGRCoordinateTransformationH hCT = NULL;
if (!bSRSIsSet)
{
OGRSpatialReferenceH hDstSRS = NULL;
if( GDALGetProjectionRef( hDstDS ) != NULL )
{
char *pszProjection;
pszProjection = (char *) GDALGetProjectionRef( hDstDS );
hDstSRS = OSRNewSpatialReference(NULL);
if( OSRImportFromWkt( hDstSRS, &pszProjection ) != OGRERR_NONE )
{
OSRDestroySpatialReference(hDstSRS);
hDstSRS = NULL;
}
}
OGRSpatialReferenceH hSrcSRS = OGR_L_GetSpatialRef(hSrcLayer);
if( hDstSRS != NULL && hSrcSRS != NULL )
{
if( OSRIsSame(hSrcSRS, hDstSRS) == FALSE )
{
hCT = OCTNewCoordinateTransformation(hSrcSRS, hDstSRS);
if( hCT == NULL )
{
CPLError(CE_Warning, CPLE_AppDefined,
"The output raster dataset and the input vector layer do not have the same SRS.\n"
"And reprojection of input data did not work. Results might be incorrect.");
}
}
}
else if( hDstSRS != NULL && hSrcSRS == NULL )
{
CPLError(CE_Warning, CPLE_AppDefined,
"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.");
}
else if( hDstSRS == NULL && hSrcSRS != NULL )
{
CPLError(CE_Warning, CPLE_AppDefined,
"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.");
}
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 )
{
CPLError(CE_Failure, CPLE_AppDefined, "Failed to find field %s on layer %s, skipping.",
pszBurnAttribute,
OGR_FD_GetName( OGR_L_GetLayerDefn( hSrcLayer ) ) );
if( hCT != NULL )
OCTDestroyCoordinateTransformation(hCT);
return CE_Failure;
}
}
/* -------------------------------------------------------------------- */
/* 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 ) );
if( hCT != NULL )
{
if( OGR_G_Transform(hGeom, hCT) != OGRERR_NONE )
{
OGR_F_Destroy( hFeat );
OGR_G_DestroyGeometry(hGeom);
continue;
}
}
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( hCT != NULL )
OCTDestroyCoordinateTransformation(hCT);
/* -------------------------------------------------------------------- */
/* 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. */
/* -------------------------------------------------------------------- */
CPLErr eErr = GDALRasterizeGeometries( hDstDS, static_cast<int>(anBandList.size()), &(anBandList[0]),
static_cast<int>(ahGeometries.size()), &(ahGeometries[0]),
NULL, NULL, &(adfFullBurnValues[0]),
papszRasterizeOptions,
pfnProgress, pProgressData );
/* -------------------------------------------------------------------- */
/* Cleanup geometries. */
/* -------------------------------------------------------------------- */
int iGeom;
for( iGeom = static_cast<int>(ahGeometries.size())-1; iGeom >= 0; iGeom-- )
OGR_G_DestroyGeometry( ahGeometries[iGeom] );
return eErr;
}
int main( int argc, char ** argv )
{
GDALDatasetH hDataset;
GDALRasterBandH hBand;
int i, iBand;
double adfGeoTransform[6];
GDALDriverH hDriver;
char **papszMetadata;
int bComputeMinMax = FALSE, bSample = FALSE;
int bShowGCPs = TRUE, bShowMetadata = TRUE, bShowRAT=TRUE;
int bStats = FALSE, bApproxStats = TRUE, iMDD;
int bShowColorTable = TRUE, bComputeChecksum = FALSE;
int bReportHistograms = FALSE;
const char *pszFilename = NULL;
char **papszExtraMDDomains = NULL, **papszFileList;
const char *pszProjection = NULL;
OGRCoordinateTransformationH hTransform = NULL;
/* Check that we are running against at least GDAL 1.5 */
/* Note to developers : if we use newer API, please change the requirement */
if (atoi(GDALVersionInfo("VERSION_NUM")) < 1500)
{
fprintf(stderr, "At least, GDAL >= 1.5.0 is required for this version of %s, "
"which was compiled against GDAL %s\n", argv[0], GDAL_RELEASE_NAME);
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;
}
}
GDALAllRegister();
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], "-mm") )
bComputeMinMax = TRUE;
else if( EQUAL(argv[i], "-hist") )
bReportHistograms = TRUE;
else if( EQUAL(argv[i], "-stats") )
{
bStats = TRUE;
bApproxStats = FALSE;
}
else if( EQUAL(argv[i], "-approx_stats") )
{
bStats = TRUE;
bApproxStats = TRUE;
}
else if( EQUAL(argv[i], "-sample") )
bSample = TRUE;
else if( EQUAL(argv[i], "-checksum") )
bComputeChecksum = TRUE;
else if( EQUAL(argv[i], "-nogcp") )
bShowGCPs = FALSE;
else if( EQUAL(argv[i], "-nomd") )
bShowMetadata = FALSE;
else if( EQUAL(argv[i], "-norat") )
bShowRAT = FALSE;
else if( EQUAL(argv[i], "-noct") )
bShowColorTable = FALSE;
else if( EQUAL(argv[i], "-mdd") && i < argc-1 )
papszExtraMDDomains = CSLAddString( papszExtraMDDomains,
argv[++i] );
else if( argv[i][0] == '-' )
Usage();
else if( pszFilename == NULL )
pszFilename = argv[i];
else
Usage();
}
if( pszFilename == NULL )
Usage();
/* -------------------------------------------------------------------- */
/* Open dataset. */
/* -------------------------------------------------------------------- */
hDataset = GDALOpen( pszFilename, GA_ReadOnly );
if( hDataset == NULL )
{
fprintf( stderr,
"gdalinfo failed - unable to open '%s'.\n",
pszFilename );
CSLDestroy( argv );
GDALDumpOpenDatasets( stderr );
GDALDestroyDriverManager();
CPLDumpSharedList( NULL );
exit( 1 );
}
/* -------------------------------------------------------------------- */
/* Report general info. */
/* -------------------------------------------------------------------- */
hDriver = GDALGetDatasetDriver( hDataset );
printf( "Driver: %s/%s\n",
GDALGetDriverShortName( hDriver ),
GDALGetDriverLongName( hDriver ) );
papszFileList = GDALGetFileList( hDataset );
if( CSLCount(papszFileList) == 0 )
{
printf( "Files: none associated\n" );
}
else
{
printf( "Files: %s\n", papszFileList[0] );
for( i = 1; papszFileList[i] != NULL; i++ )
printf( " %s\n", papszFileList[i] );
}
CSLDestroy( papszFileList );
printf( "Size is %d, %d\n",
GDALGetRasterXSize( hDataset ),
GDALGetRasterYSize( hDataset ) );
/* -------------------------------------------------------------------- */
/* Report projection. */
/* -------------------------------------------------------------------- */
if( GDALGetProjectionRef( hDataset ) != NULL )
{
OGRSpatialReferenceH hSRS;
char *pszProjection;
pszProjection = (char *) GDALGetProjectionRef( hDataset );
hSRS = OSRNewSpatialReference(NULL);
if( OSRImportFromWkt( hSRS, &pszProjection ) == CE_None )
{
char *pszPrettyWkt = NULL;
OSRExportToPrettyWkt( hSRS, &pszPrettyWkt, FALSE );
printf( "Coordinate System is:\n%s\n", pszPrettyWkt );
CPLFree( pszPrettyWkt );
}
else
printf( "Coordinate System is `%s'\n",
GDALGetProjectionRef( hDataset ) );
OSRDestroySpatialReference( hSRS );
}
/* -------------------------------------------------------------------- */
/* Report Geotransform. */
/* -------------------------------------------------------------------- */
if( GDALGetGeoTransform( hDataset, adfGeoTransform ) == CE_None )
{
if( adfGeoTransform[2] == 0.0 && adfGeoTransform[4] == 0.0 )
{
printf( "Origin = (%.15f,%.15f)\n",
adfGeoTransform[0], adfGeoTransform[3] );
printf( "Pixel Size = (%.15f,%.15f)\n",
adfGeoTransform[1], adfGeoTransform[5] );
}
else
printf( "GeoTransform =\n"
" %.16g, %.16g, %.16g\n"
" %.16g, %.16g, %.16g\n",
adfGeoTransform[0],
adfGeoTransform[1],
adfGeoTransform[2],
adfGeoTransform[3],
adfGeoTransform[4],
adfGeoTransform[5] );
}
/* -------------------------------------------------------------------- */
/* Report GCPs. */
/* -------------------------------------------------------------------- */
if( bShowGCPs && GDALGetGCPCount( hDataset ) > 0 )
{
if (GDALGetGCPProjection(hDataset) != NULL)
{
OGRSpatialReferenceH hSRS;
char *pszProjection;
pszProjection = (char *) GDALGetGCPProjection( hDataset );
hSRS = OSRNewSpatialReference(NULL);
if( OSRImportFromWkt( hSRS, &pszProjection ) == CE_None )
{
char *pszPrettyWkt = NULL;
OSRExportToPrettyWkt( hSRS, &pszPrettyWkt, FALSE );
printf( "GCP Projection = \n%s\n", pszPrettyWkt );
CPLFree( pszPrettyWkt );
}
else
printf( "GCP Projection = %s\n",
GDALGetGCPProjection( hDataset ) );
OSRDestroySpatialReference( hSRS );
}
for( i = 0; i < GDALGetGCPCount(hDataset); i++ )
{
const GDAL_GCP *psGCP;
psGCP = GDALGetGCPs( hDataset ) + i;
printf( "GCP[%3d]: Id=%s, Info=%s\n"
" (%.15g,%.15g) -> (%.15g,%.15g,%.15g)\n",
i, psGCP->pszId, psGCP->pszInfo,
psGCP->dfGCPPixel, psGCP->dfGCPLine,
psGCP->dfGCPX, psGCP->dfGCPY, psGCP->dfGCPZ );
}
}
/* -------------------------------------------------------------------- */
/* Report metadata. */
/* -------------------------------------------------------------------- */
papszMetadata = (bShowMetadata) ? GDALGetMetadata( hDataset, NULL ) : NULL;
if( bShowMetadata && CSLCount(papszMetadata) > 0 )
{
printf( "Metadata:\n" );
for( i = 0; papszMetadata[i] != NULL; i++ )
{
printf( " %s\n", papszMetadata[i] );
}
}
for( iMDD = 0; bShowMetadata && iMDD < CSLCount(papszExtraMDDomains); iMDD++ )
{
papszMetadata = GDALGetMetadata( hDataset, papszExtraMDDomains[iMDD] );
if( CSLCount(papszMetadata) > 0 )
{
printf( "Metadata (%s):\n", papszExtraMDDomains[iMDD]);
for( i = 0; papszMetadata[i] != NULL; i++ )
{
printf( " %s\n", papszMetadata[i] );
}
}
}
/* -------------------------------------------------------------------- */
/* Report "IMAGE_STRUCTURE" metadata. */
/* -------------------------------------------------------------------- */
papszMetadata = (bShowMetadata) ? GDALGetMetadata( hDataset, "IMAGE_STRUCTURE" ) : NULL;
if( bShowMetadata && CSLCount(papszMetadata) > 0 )
{
printf( "Image Structure Metadata:\n" );
for( i = 0; papszMetadata[i] != NULL; i++ )
{
printf( " %s\n", papszMetadata[i] );
}
}
/* -------------------------------------------------------------------- */
/* Report subdatasets. */
/* -------------------------------------------------------------------- */
papszMetadata = GDALGetMetadata( hDataset, "SUBDATASETS" );
if( CSLCount(papszMetadata) > 0 )
{
printf( "Subdatasets:\n" );
for( i = 0; papszMetadata[i] != NULL; i++ )
{
printf( " %s\n", papszMetadata[i] );
}
}
/* -------------------------------------------------------------------- */
/* Report geolocation. */
/* -------------------------------------------------------------------- */
papszMetadata = (bShowMetadata) ? GDALGetMetadata( hDataset, "GEOLOCATION" ) : NULL;
if( bShowMetadata && CSLCount(papszMetadata) > 0 )
{
printf( "Geolocation:\n" );
for( i = 0; papszMetadata[i] != NULL; i++ )
{
printf( " %s\n", papszMetadata[i] );
}
}
/* -------------------------------------------------------------------- */
/* Report RPCs */
/* -------------------------------------------------------------------- */
papszMetadata = (bShowMetadata) ? GDALGetMetadata( hDataset, "RPC" ) : NULL;
if( bShowMetadata && CSLCount(papszMetadata) > 0 )
{
printf( "RPC Metadata:\n" );
for( i = 0; papszMetadata[i] != NULL; i++ )
{
printf( " %s\n", papszMetadata[i] );
}
}
/* -------------------------------------------------------------------- */
/* Setup projected to lat/long transform if appropriate. */
/* -------------------------------------------------------------------- */
if( GDALGetGeoTransform( hDataset, adfGeoTransform ) == CE_None )
pszProjection = GDALGetProjectionRef(hDataset);
if( pszProjection != NULL && strlen(pszProjection) > 0 )
{
OGRSpatialReferenceH hProj, hLatLong = NULL;
hProj = OSRNewSpatialReference( pszProjection );
if( hProj != NULL )
hLatLong = OSRCloneGeogCS( hProj );
if( hLatLong != NULL )
{
CPLPushErrorHandler( CPLQuietErrorHandler );
hTransform = OCTNewCoordinateTransformation( hProj, hLatLong );
CPLPopErrorHandler();
OSRDestroySpatialReference( hLatLong );
}
if( hProj != NULL )
OSRDestroySpatialReference( hProj );
}
/* -------------------------------------------------------------------- */
/* Report corners. */
/* -------------------------------------------------------------------- */
printf( "Corner Coordinates:\n" );
GDALInfoReportCorner( hDataset, hTransform, "Upper Left",
0.0, 0.0 );
GDALInfoReportCorner( hDataset, hTransform, "Lower Left",
0.0, GDALGetRasterYSize(hDataset));
GDALInfoReportCorner( hDataset, hTransform, "Upper Right",
GDALGetRasterXSize(hDataset), 0.0 );
GDALInfoReportCorner( hDataset, hTransform, "Lower Right",
GDALGetRasterXSize(hDataset),
GDALGetRasterYSize(hDataset) );
GDALInfoReportCorner( hDataset, hTransform, "Center",
GDALGetRasterXSize(hDataset)/2.0,
GDALGetRasterYSize(hDataset)/2.0 );
if( hTransform != NULL )
{
OCTDestroyCoordinateTransformation( hTransform );
hTransform = NULL;
}
/* ==================================================================== */
/* Loop over bands. */
/* ==================================================================== */
for( iBand = 0; iBand < GDALGetRasterCount( hDataset ); iBand++ )
{
double dfMin, dfMax, adfCMinMax[2], dfNoData;
int bGotMin, bGotMax, bGotNodata, bSuccess;
int nBlockXSize, nBlockYSize, nMaskFlags;
double dfMean, dfStdDev;
GDALColorTableH hTable;
CPLErr eErr;
hBand = GDALGetRasterBand( hDataset, iBand+1 );
if( bSample )
{
float afSample[10000];
int nCount;
nCount = GDALGetRandomRasterSample( hBand, 10000, afSample );
printf( "Got %d samples.\n", nCount );
}
GDALGetBlockSize( hBand, &nBlockXSize, &nBlockYSize );
printf( "Band %d Block=%dx%d Type=%s, ColorInterp=%s\n", iBand+1,
nBlockXSize, nBlockYSize,
GDALGetDataTypeName(
GDALGetRasterDataType(hBand)),
GDALGetColorInterpretationName(
GDALGetRasterColorInterpretation(hBand)) );
if( GDALGetDescription( hBand ) != NULL
&& strlen(GDALGetDescription( hBand )) > 0 )
printf( " Description = %s\n", GDALGetDescription(hBand) );
dfMin = GDALGetRasterMinimum( hBand, &bGotMin );
dfMax = GDALGetRasterMaximum( hBand, &bGotMax );
if( bGotMin || bGotMax || bComputeMinMax )
{
printf( " " );
if( bGotMin )
printf( "Min=%.3f ", dfMin );
if( bGotMax )
printf( "Max=%.3f ", dfMax );
if( bComputeMinMax )
{
CPLErrorReset();
GDALComputeRasterMinMax( hBand, FALSE, adfCMinMax );
if (CPLGetLastErrorType() == CE_None)
{
printf( " Computed Min/Max=%.3f,%.3f",
adfCMinMax[0], adfCMinMax[1] );
}
}
printf( "\n" );
}
eErr = GDALGetRasterStatistics( hBand, bApproxStats, bStats,
&dfMin, &dfMax, &dfMean, &dfStdDev );
if( eErr == CE_None )
{
printf( " Minimum=%.3f, Maximum=%.3f, Mean=%.3f, StdDev=%.3f\n",
dfMin, dfMax, dfMean, dfStdDev );
}
if( bReportHistograms )
{
int nBucketCount, *panHistogram = NULL;
eErr = GDALGetDefaultHistogram( hBand, &dfMin, &dfMax,
&nBucketCount, &panHistogram,
TRUE, GDALTermProgress, NULL );
if( eErr == CE_None )
{
int iBucket;
printf( " %d buckets from %g to %g:\n ",
nBucketCount, dfMin, dfMax );
for( iBucket = 0; iBucket < nBucketCount; iBucket++ )
printf( "%d ", panHistogram[iBucket] );
printf( "\n" );
CPLFree( panHistogram );
}
}
if ( bComputeChecksum)
{
printf( " Checksum=%d\n",
GDALChecksumImage(hBand, 0, 0,
GDALGetRasterXSize(hDataset),
GDALGetRasterYSize(hDataset)));
}
dfNoData = GDALGetRasterNoDataValue( hBand, &bGotNodata );
if( bGotNodata )
{
printf( " NoData Value=%.18g\n", dfNoData );
}
if( GDALGetOverviewCount(hBand) > 0 )
{
int iOverview;
printf( " Overviews: " );
for( iOverview = 0;
iOverview < GDALGetOverviewCount(hBand);
iOverview++ )
{
GDALRasterBandH hOverview;
const char *pszResampling = NULL;
if( iOverview != 0 )
printf( ", " );
hOverview = GDALGetOverview( hBand, iOverview );
printf( "%dx%d",
GDALGetRasterBandXSize( hOverview ),
GDALGetRasterBandYSize( hOverview ) );
pszResampling =
GDALGetMetadataItem( hOverview, "RESAMPLING", "" );
if( pszResampling != NULL
&& EQUALN(pszResampling,"AVERAGE_BIT2",12) )
printf( "*" );
}
printf( "\n" );
if ( bComputeChecksum)
{
printf( " Overviews checksum: " );
for( iOverview = 0;
iOverview < GDALGetOverviewCount(hBand);
iOverview++ )
{
GDALRasterBandH hOverview;
if( iOverview != 0 )
printf( ", " );
hOverview = GDALGetOverview( hBand, iOverview );
printf( "%d",
GDALChecksumImage(hOverview, 0, 0,
GDALGetRasterBandXSize(hOverview),
GDALGetRasterBandYSize(hOverview)));
}
printf( "\n" );
}
}
if( GDALHasArbitraryOverviews( hBand ) )
{
printf( " Overviews: arbitrary\n" );
}
nMaskFlags = GDALGetMaskFlags( hBand );
if( (nMaskFlags & (GMF_NODATA|GMF_ALL_VALID)) == 0 )
{
GDALRasterBandH hMaskBand = GDALGetMaskBand(hBand) ;
printf( " Mask Flags: " );
if( nMaskFlags & GMF_PER_DATASET )
printf( "PER_DATASET " );
if( nMaskFlags & GMF_ALPHA )
printf( "ALPHA " );
if( nMaskFlags & GMF_NODATA )
printf( "NODATA " );
if( nMaskFlags & GMF_ALL_VALID )
printf( "ALL_VALID " );
printf( "\n" );
if( hMaskBand != NULL &&
GDALGetOverviewCount(hMaskBand) > 0 )
{
int iOverview;
printf( " Overviews of mask band: " );
for( iOverview = 0;
iOverview < GDALGetOverviewCount(hMaskBand);
iOverview++ )
{
GDALRasterBandH hOverview;
if( iOverview != 0 )
printf( ", " );
hOverview = GDALGetOverview( hMaskBand, iOverview );
printf( "%dx%d",
GDALGetRasterBandXSize( hOverview ),
GDALGetRasterBandYSize( hOverview ) );
}
printf( "\n" );
}
}
if( strlen(GDALGetRasterUnitType(hBand)) > 0 )
{
printf( " Unit Type: %s\n", GDALGetRasterUnitType(hBand) );
}
if( GDALGetRasterCategoryNames(hBand) != NULL )
{
char **papszCategories = GDALGetRasterCategoryNames(hBand);
int i;
printf( " Categories:\n" );
for( i = 0; papszCategories[i] != NULL; i++ )
printf( " %3d: %s\n", i, papszCategories[i] );
}
if( GDALGetRasterScale( hBand, &bSuccess ) != 1.0
|| GDALGetRasterOffset( hBand, &bSuccess ) != 0.0 )
printf( " Offset: %.15g, Scale:%.15g\n",
GDALGetRasterOffset( hBand, &bSuccess ),
GDALGetRasterScale( hBand, &bSuccess ) );
papszMetadata = (bShowMetadata) ? GDALGetMetadata( hBand, NULL ) : NULL;
if( bShowMetadata && CSLCount(papszMetadata) > 0 )
{
printf( " Metadata:\n" );
for( i = 0; papszMetadata[i] != NULL; i++ )
{
printf( " %s\n", papszMetadata[i] );
}
}
papszMetadata = (bShowMetadata) ? GDALGetMetadata( hBand, "IMAGE_STRUCTURE" ) : NULL;
if( bShowMetadata && CSLCount(papszMetadata) > 0 )
{
printf( " Image Structure Metadata:\n" );
for( i = 0; papszMetadata[i] != NULL; i++ )
{
printf( " %s\n", papszMetadata[i] );
}
}
if( GDALGetRasterColorInterpretation(hBand) == GCI_PaletteIndex
&& (hTable = GDALGetRasterColorTable( hBand )) != NULL )
{
int i;
printf( " Color Table (%s with %d entries)\n",
GDALGetPaletteInterpretationName(
GDALGetPaletteInterpretation( hTable )),
GDALGetColorEntryCount( hTable ) );
if (bShowColorTable)
{
for( i = 0; i < GDALGetColorEntryCount( hTable ); i++ )
{
GDALColorEntry sEntry;
GDALGetColorEntryAsRGB( hTable, i, &sEntry );
printf( " %3d: %d,%d,%d,%d\n",
i,
sEntry.c1,
sEntry.c2,
sEntry.c3,
sEntry.c4 );
}
}
}
if( bShowRAT && GDALGetDefaultRAT( hBand ) != NULL )
{
GDALRasterAttributeTableH hRAT = GDALGetDefaultRAT( hBand );
GDALRATDumpReadable( hRAT, NULL );
}
}
GDALClose( hDataset );
CSLDestroy( papszExtraMDDomains );
CSLDestroy( argv );
GDALDumpOpenDatasets( stderr );
GDALDestroyDriverManager();
CPLDumpSharedList( NULL );
CPLCleanupTLS();
exit( 0 );
}
int main(int argc, char *argv[])
{
GDALDatasetH hDataset = NULL;
OGRDataSourceH hDS = NULL;
OGRSFDriverH *pahDriver = NULL;
OGRLayerH hLR = NULL;
OGREnvelope hEnv;
double adfGeoTransform[6];
int columns, lines;
double minx, miny, maxx, maxy, x, y, z;
register int i;
FILE *fin=NULL;
if(argc != 2)
{
printf("Usage: geo_extents <input file>\n");
return 1;
}
GDALAllRegister();
OGRRegisterAll();
char *egsa = "PROJCS[\"GGRS87 / Greek Grid\",GEOGCS[\"GGRS87\",DATUM[\"Greek_Geodetic_Reference_System_1987\",SPHEROID[\"GRS 1980\",6378137,298.257222101,AUTHORITY[\"EPSG\",\"7019\"]],TOWGS84[-199.87,74.79,246.62,0,0,0,0],AUTHORITY[\"EPSG\",\"6121\"]],PRIMEM[\"Greenwich\",0,AUTHORITY[\"EPSG\",\"8901\"]],UNIT[\"degree\",0.01745329251994328,AUTHORITY[\"EPSG\",\"9122\"]],AUTHORITY[\"EPSG\",\"4121\"]],UNIT[\"metre\",1,AUTHORITY[\"EPSG\",\"9001\"]],PROJECTION[\"Transverse_Mercator\"],PARAMETER[\"latitude_of_origin\",0],PARAMETER[\"central_meridian\",24],PARAMETER[\"scale_factor\",0.9996],PARAMETER[\"false_easting\",500000],PARAMETER[\"false_northing\",0],AUTHORITY[\"EPSG\",\"2100\"],AXIS[\"Easting\",EAST],AXIS[\"Northing\",NORTH]]";
char *wgs = "GEOGCS[\"WGS 84\",DATUM[\"WGS_1984\",SPHEROID[\"WGS 84\",6378137,298.257223563,AUTHORITY[\"EPSG\",\"7030\"]],AUTHORITY[\"EPSG\",\"6326\"]],PRIMEM[\"Greenwich\",0,AUTHORITY[\"EPSG\",\"8901\"]],UNIT[\"degree\",0.01745329251994328,AUTHORITY[\"EPSG\",\"9122\"]],AUTHORITY[\"EPSG\",\"4326\"]]";
OGRSpatialReferenceH oSourceSRS;
OGRSpatialReferenceH oTargetSRS;
oSourceSRS = OSRNewSpatialReference(NULL);
oTargetSRS = OSRNewSpatialReference(NULL);
OSRImportFromWkt(oSourceSRS, &egsa);
OSRImportFromWkt(oTargetSRS, &wgs);
OGRCoordinateTransformationH poCT;
poCT = OCTNewCoordinateTransformation(oSourceSRS, oTargetSRS);
hDataset = GDALOpen(argv[1], GA_ReadOnly);
if(hDataset != NULL)//It is raster
{
columns = GDALGetRasterXSize(hDataset);
lines = GDALGetRasterYSize(hDataset);
if(GDALGetGeoTransform(hDataset, adfGeoTransform) == CE_None)
{
minx = (adfGeoTransform[0] - (adfGeoTransform[1] / 2));
maxy = (adfGeoTransform[3] - (adfGeoTransform[5] / 2));
miny = (maxy + ((lines + 1) * adfGeoTransform[5]));
maxx = (minx + (adfGeoTransform[1] * (columns + 1)));
OCTTransform(poCT, 1, &minx, &miny, 0);
OCTTransform(poCT, 1, &maxx, &maxy, 0);
printf("BoundingBox: %f %f %f %f\n",minx ,miny, maxx, maxy);
GDALClose (hDataset);
}
else
{
printf("Failure: No Georeference info found for this raster file\n");
return 0;
}
}
else//Try if it is vector
{
hDS = OGROpen( argv[1], FALSE , pahDriver );
if( hDS == NULL )//Not vector
{
//Parse for DTM file
fin=fopen(argv[1],"r");
fseek(fin,0L,SEEK_SET);
minx=50000000.0;
miny=50000000.0;
maxx=0.0;
maxy=0.0;
while(!feof(fin))
{
fscanf(fin,"%lf,%lf,%lf\n",&x,&y,&z);
if(ferror(fin))//input error
{
printf("Failure: Unsupported file type\n");
return 0;
}
if(x>maxx) maxx=x;
if(y>maxy) maxy=y;
if(x<minx) minx=x;
if(y<miny) miny=y;
}
if(minx==50000000.0 || miny==50000000.0)
{
printf("Failure: Unsupported file type\n");
return 0;
}
if(maxx==0 || maxy==0)
{
printf("Failure: Unsupported file type\n");
return 0;
}
if(minx==maxx)
{
minx-=1;
maxx+=1;
}
if(miny==maxy)
{
miny-=1;
maxy+=1;
}
//DTM file
OCTTransform(poCT, 1, &minx, &miny, 0);
OCTTransform(poCT, 1, &maxx, &maxy, 0);
printf("BoundingBox: %f %f %f %f\n",minx ,miny, maxx, maxy);
return 0;
}
//It is vector
for(i=0; i< OGR_DS_GetLayerCount (hDS); i++)
{
hLR = OGR_DS_GetLayer(hDS, i);
if(OGR_L_GetExtent (hLR, &hEnv, FALSE) == OGRERR_NONE)
{
minx = hEnv.MinX;
miny = hEnv.MinY;
maxx = hEnv.MaxX;
maxy = hEnv.MaxY;
OCTTransform(poCT, 1, &minx, &miny, 0);
OCTTransform(poCT, 1, &maxx, &maxy, 0);
printf("BoundingBox: %f %f %f %f\n",minx ,miny, maxx, maxy);
}
}
OGRReleaseDataSource( hDS );
}
return 0;
}
bool rspfOgcWktTranslator::toOssimKwl( const rspfString& wktString,
rspfKeywordlist &kwl,
const char *prefix)const
{
static const char MODULE[] = "rspfOgcWktTranslator::toOssimKwl";
if(traceDebug())
{
rspfNotify(rspfNotifyLevel_DEBUG) << MODULE << " entered...\n";
}
const char* wkt = wktString.c_str();
OGRSpatialReferenceH hSRS = NULL;
rspfDpt falseEastingNorthing;
hSRS = OSRNewSpatialReference(NULL);
if( OSRImportFromWkt( hSRS, (char **) &wkt ) != OGRERR_NONE )
{
OSRDestroySpatialReference( hSRS );
return false;
}
rspfString rspfProj = "";
const char* epsg_code = OSRGetAttrValue( hSRS, "AUTHORITY", 1 );
if(traceDebug())
{
rspfNotify(rspfNotifyLevel_DEBUG)
<< "epsg_code: " << (epsg_code?epsg_code:"null") << "\n";
}
const char* units = NULL;
OGR_SRSNode* node = ((OGRSpatialReference *)hSRS)->GetRoot();
int nbChild = node->GetChildCount();
for (int i = 0; i < nbChild; i++)
{
OGR_SRSNode* curChild = node->GetChild(i);
if (strcmp(curChild->GetValue(), "UNIT") == 0)
{
units = curChild->GetChild(0)->GetValue();
}
}
if(traceDebug())
{
rspfNotify(rspfNotifyLevel_DEBUG)
<< "units: " << (units?units:"null") << "\n";
}
rspfString rspf_units;
bool bGeog = OSRIsGeographic(hSRS);
if ( bGeog == false )
{
rspf_units = "meters";
if ( units != NULL )
{
rspfString s = units;
s.downcase();
if( ( s == rspfString("us survey foot") ) ||
( s == rspfString("u.s. foot") ) ||
( s == rspfString("foot_us") ) )
{
rspf_units = "us_survey_feet";
}
else if( s == rspfString("degree") )
{
rspf_units = "degrees";
}
else if( ( s == rspfString("meter") ) ||
( s == rspfString("metre") ) )
{
rspf_units = "meters";
}
}
}
else
{
rspf_units = "degrees";
}
if(traceDebug())
{
rspfNotify(rspfNotifyLevel_DEBUG)
<< "rspf_units: " << rspf_units << "\n";
}
if (epsg_code)
{
rspfString epsg_spec ("EPSG:");
epsg_spec += rspfString::toString(epsg_code);
rspfProjection* proj = rspfEpsgProjectionFactory::instance()->createProjection(epsg_spec);
if (proj)
rspfProj = proj->getClassName();
delete proj;
}
if(rspfProj == "")
{
const char* pszProjection = OSRGetAttrValue( hSRS, "PROJECTION", 0 );
if(pszProjection)
{
rspfProj = wktToOssimProjection(pszProjection);
}
else
{
rspfString localCs = OSRGetAttrValue( hSRS, "LOCAL_CS", 0 );
localCs = localCs.upcase();
if(localCs == "GREATBRITAIN_GRID")
{
rspfProj = "rspfBngProjection";
}
else if (rspf_units.contains("degree"))
{
rspfProj = "rspfEquDistCylProjection";
}
}
}
if(rspfProj == "rspfEquDistCylProjection" )
rspf_units = "degrees";
kwl.add(prefix, rspfKeywordNames::UNITS_KW, rspf_units, true);
if (traceDebug())
{
rspfNotify(rspfNotifyLevel_DEBUG)
<< MODULE << "DEBUG:"
<< "\nrspfProj = " << rspfProj << endl;
}
kwl.add(prefix, rspfKeywordNames::TYPE_KW, rspfProj.c_str(), true);
falseEastingNorthing.x = OSRGetProjParm(hSRS, SRS_PP_FALSE_EASTING, 0.0, NULL);
falseEastingNorthing.y = OSRGetProjParm(hSRS, SRS_PP_FALSE_NORTHING, 0.0, NULL);
if (epsg_code)
{
kwl.add(prefix, rspfKeywordNames::PCS_CODE_KW, epsg_code, true);
}
if(rspfProj == "rspfBngProjection")
{
kwl.add(prefix,
rspfKeywordNames::TYPE_KW,
"rspfBngProjection",
true);
}
else if(rspfProj == "rspfCylEquAreaProjection")
{
kwl.add(prefix,
rspfKeywordNames::STD_PARALLEL_1_KW,
OSRGetProjParm(hSRS, SRS_PP_STANDARD_PARALLEL_1, 0.0, NULL),
true);
kwl.add(prefix,
rspfKeywordNames::ORIGIN_LATITUDE_KW,
OSRGetProjParm(hSRS, SRS_PP_STANDARD_PARALLEL_1, 0.0, NULL),
true);
rspfUnitType units =
static_cast<rspfUnitType>(rspfUnitTypeLut::instance()->
getEntryNumber(rspf_units.c_str()));
if ( units == RSPF_METERS ||
units == RSPF_FEET ||
units == RSPF_US_SURVEY_FEET )
{
kwl.add(prefix,
rspfKeywordNames::FALSE_EASTING_NORTHING_KW,
falseEastingNorthing.toString(),
true);
kwl.add(prefix,
rspfKeywordNames::FALSE_EASTING_NORTHING_UNITS_KW,
rspf_units,
true);
}
}
else if(rspfProj == "rspfEquDistCylProjection")
{
kwl.add(prefix,
rspfKeywordNames::TYPE_KW,
"rspfEquDistCylProjection",
true);
rspfUnitType units =
static_cast<rspfUnitType>(rspfUnitTypeLut::instance()->
getEntryNumber(rspf_units.c_str()));
if ( units == RSPF_METERS ||
units == RSPF_FEET ||
units == RSPF_US_SURVEY_FEET )
{
kwl.add(prefix,
rspfKeywordNames::FALSE_EASTING_NORTHING_KW,
falseEastingNorthing.toString(),
true);
kwl.add(prefix,
rspfKeywordNames::FALSE_EASTING_NORTHING_UNITS_KW,
rspf_units,
true);
}
kwl.add(prefix,
rspfKeywordNames::ORIGIN_LATITUDE_KW,
OSRGetProjParm(hSRS, SRS_PP_LATITUDE_OF_ORIGIN, 0.0, NULL),
true);
kwl.add(prefix,
rspfKeywordNames::CENTRAL_MERIDIAN_KW,
OSRGetProjParm(hSRS, SRS_PP_CENTRAL_MERIDIAN, 0.0, NULL),
true);
}
else if( (rspfProj == "rspfLambertConformalConicProjection") ||
(rspfProj == "rspfAlbersProjection") )
{
kwl.add(prefix,
rspfKeywordNames::TYPE_KW,
rspfProj.c_str(),
true);
kwl.add(prefix,
rspfKeywordNames::FALSE_EASTING_NORTHING_KW,
falseEastingNorthing.toString(),
true);
kwl.add(prefix,
rspfKeywordNames::FALSE_EASTING_NORTHING_UNITS_KW,
rspf_units,
true);
kwl.add(prefix,
rspfKeywordNames::ORIGIN_LATITUDE_KW,
OSRGetProjParm(hSRS, SRS_PP_LATITUDE_OF_ORIGIN, 0.0, NULL),
true);
kwl.add(prefix,
rspfKeywordNames::CENTRAL_MERIDIAN_KW,
OSRGetProjParm(hSRS, SRS_PP_CENTRAL_MERIDIAN, 0.0, NULL),
true);
kwl.add(prefix,
rspfKeywordNames::STD_PARALLEL_1_KW,
OSRGetProjParm(hSRS, SRS_PP_STANDARD_PARALLEL_1, 0.0, NULL),
true);
kwl.add(prefix,
rspfKeywordNames::STD_PARALLEL_2_KW,
OSRGetProjParm(hSRS, SRS_PP_STANDARD_PARALLEL_2, 0.0, NULL),
true);
}
else if(rspfProj == "rspfMercatorProjection")
{
kwl.add(prefix,
rspfKeywordNames::TYPE_KW,
"rspfMercatorProjection",
true);
kwl.add(prefix,
rspfKeywordNames::ORIGIN_LATITUDE_KW,
OSRGetProjParm(hSRS, SRS_PP_LATITUDE_OF_ORIGIN, 0.0, NULL),
true);
kwl.add(prefix,
rspfKeywordNames::CENTRAL_MERIDIAN_KW,
OSRGetProjParm(hSRS, SRS_PP_CENTRAL_MERIDIAN, 0.0, NULL),
true);
kwl.add(prefix,
rspfKeywordNames::FALSE_EASTING_NORTHING_KW,
falseEastingNorthing.toString(),
true);
kwl.add(prefix,
rspfKeywordNames::FALSE_EASTING_NORTHING_UNITS_KW,
rspf_units,
true);
}
else if(rspfProj == "rspfSinusoidalProjection")
{
kwl.add(prefix,
rspfKeywordNames::TYPE_KW,
"rspfSinusoidalProjection",
true);
kwl.add(prefix,
rspfKeywordNames::CENTRAL_MERIDIAN_KW,
OSRGetProjParm(hSRS, SRS_PP_CENTRAL_MERIDIAN, 0.0, NULL),
true);
kwl.add(prefix,
rspfKeywordNames::FALSE_EASTING_NORTHING_KW,
falseEastingNorthing.toString(),
true);
kwl.add(prefix,
rspfKeywordNames::FALSE_EASTING_NORTHING_UNITS_KW,
rspf_units,
true);
}
else if(rspfProj == "rspfTransMercatorProjection")
{
int bNorth;
int nZone = OSRGetUTMZone( hSRS, &bNorth );
if( nZone != 0 )
{
kwl.add(prefix,
rspfKeywordNames::TYPE_KW,
"rspfUtmProjection",
true);
kwl.add(prefix,
rspfKeywordNames::ZONE_KW,
nZone,
true);
if( bNorth )
{
kwl.add(prefix, rspfKeywordNames::HEMISPHERE_KW, "N", true);
}
else
{
kwl.add(prefix, rspfKeywordNames::HEMISPHERE_KW, "S", true);
}
}
else
{
kwl.add(prefix,
rspfKeywordNames::TYPE_KW,
"rspfTransMercatorProjection",
true);
kwl.add(prefix,
rspfKeywordNames::SCALE_FACTOR_KW,
OSRGetProjParm(hSRS, SRS_PP_SCALE_FACTOR, 1.0, NULL),
true);
kwl.add(prefix,
rspfKeywordNames::ORIGIN_LATITUDE_KW,
OSRGetProjParm(hSRS, SRS_PP_LATITUDE_OF_ORIGIN, 0.0, NULL),
true);
kwl.add(prefix,
rspfKeywordNames::CENTRAL_MERIDIAN_KW,
OSRGetProjParm(hSRS, SRS_PP_CENTRAL_MERIDIAN, 0.0, NULL),
true);
kwl.add(prefix,
rspfKeywordNames::FALSE_EASTING_NORTHING_KW,
falseEastingNorthing.toString(),
true);
kwl.add(prefix,
rspfKeywordNames::FALSE_EASTING_NORTHING_UNITS_KW,
rspf_units,
true);
}
}
else
{
if (traceDebug())
{
rspfNotify(rspfNotifyLevel_DEBUG)
<< "rspfOgcWktTranslator::toOssimKwl DEBUG:\n"
<< "Projection conversion to RSPF not supported !!!!!!!!!\n"
<< "Please send the following string to the development staff\n"
<< "to be added to the transaltion to RSPF\n"
<< wkt << endl;
}
return false;
}
const char *datum = OSRGetAttrValue( hSRS, "DATUM", 0 );
rspfString oDatum = "WGE";
if( datum )
{
oDatum = wktToOssimDatum(datum);
if(oDatum == "")
{
oDatum = "WGE";
}
}
kwl.add(prefix, rspfKeywordNames::DATUM_KW, oDatum, true);
OSRDestroySpatialReference( hSRS );
if (traceDebug())
{
rspfNotify(rspfNotifyLevel_DEBUG)
<< MODULE << " exit status = true"
<< std::endl;
}
return true;
}
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
}