char *GXFGetMapProjectionAsPROJ4( GXFHandle hGXF )
{
GXFInfo_t *psGXF = (GXFInfo_t *) hGXF;
char **papszMethods = NULL;
char szPROJ4[512];
/* -------------------------------------------------------------------- */
/* If there was nothing in the file return "unknown". */
/* -------------------------------------------------------------------- */
if( CSLCount(psGXF->papszMapProjection) < 2 )
return( CPLStrdup( "unknown" ) );
szPROJ4[0] = '\0';
/* -------------------------------------------------------------------- */
/* Parse the third line, looking for known projection methods. */
/* -------------------------------------------------------------------- */
if( psGXF->papszMapProjection[2] != NULL )
{
if( strlen(psGXF->papszMapProjection[2]) > 80 )
return( CPLStrdup( "" ) );
papszMethods = CSLTokenizeStringComplex(psGXF->papszMapProjection[2],
",", TRUE, TRUE );
}
#ifdef DBMALLOC
malloc_chain_check(1);
#endif
if( papszMethods == NULL
|| papszMethods[0] == NULL
|| EQUAL(papszMethods[0],"Geographic") )
{
SAFE_strcat( szPROJ4, "+proj=longlat" );
}
#ifdef notdef
else if( EQUAL(papszMethods[0],"Lambert Conic Conformal (1SP)")
&& CSLCount(papszMethods) > 5 )
{
/* notdef: It isn't clear that this 1SP + scale method is even
supported by PROJ.4
Later note: It is not. */
SAFE_strcat( szPROJ4, "+proj=lcc" );
SAFE_strcat( szPROJ4, " +lat_0=" );
SAFE_strcat( szPROJ4, papszMethods[1] );
SAFE_strcat( szPROJ4, " +lon_0=" );
SAFE_strcat( szPROJ4, papszMethods[2] );
SAFE_strcat( szPROJ4, " +k=" );
SAFE_strcat( szPROJ4, papszMethods[3] );
SAFE_strcat( szPROJ4, " +x_0=" );
SAFE_strcat( szPROJ4, papszMethods[4] );
SAFE_strcat( szPROJ4, " +y_0=" );
SAFE_strcat( szPROJ4, papszMethods[5] );
}
#endif
else if( EQUAL(papszMethods[0],"Lambert Conic Conformal (2SP)")
|| EQUAL(papszMethods[0],"Lambert Conformal (2SP Belgium)") )
{
/* notdef: Note we are apparently losing whatever makes the
Belgium variant different than normal LCC, but hopefully
they are close! */
SAFE_strcat( szPROJ4, "+proj=lcc" );
if( CSLCount(papszMethods) > 1 )
{
SAFE_strcat( szPROJ4, " +lat_1=" );
SAFE_strcat( szPROJ4, papszMethods[1] );
}
if( CSLCount(papszMethods) > 2 )
{
SAFE_strcat( szPROJ4, " +lat_2=" );
SAFE_strcat( szPROJ4, papszMethods[2] );
}
if( CSLCount(papszMethods) > 3 )
{
SAFE_strcat( szPROJ4, " +lat_0=" );
SAFE_strcat( szPROJ4, papszMethods[3] );
}
if( CSLCount(papszMethods) > 4 )
{
SAFE_strcat( szPROJ4, " +lon_0=" );
SAFE_strcat( szPROJ4, papszMethods[4] );
}
if( CSLCount(papszMethods) > 5 )
{
SAFE_strcat( szPROJ4, " +x_0=" );
SAFE_strcat( szPROJ4, papszMethods[5] );
}
if( CSLCount(papszMethods) > 6 )
{
SAFE_strcat( szPROJ4, " +y_0=" );
SAFE_strcat( szPROJ4, papszMethods[6] );
}
}
else if( EQUAL(papszMethods[0],"Mercator (1SP)")
&& CSLCount(papszMethods) > 5 )
{
/* notdef: it isn't clear that +proj=merc support a scale of other
than 1.0 in PROJ.4 */
SAFE_strcat( szPROJ4, "+proj=merc" );
SAFE_strcat( szPROJ4, " +lat_ts=" );
SAFE_strcat( szPROJ4, papszMethods[1] );
SAFE_strcat( szPROJ4, " +lon_0=" );
SAFE_strcat( szPROJ4, papszMethods[2] );
SAFE_strcat( szPROJ4, " +k=" );
SAFE_strcat( szPROJ4, papszMethods[3] );
SAFE_strcat( szPROJ4, " +x_0=" );
SAFE_strcat( szPROJ4, papszMethods[4] );
SAFE_strcat( szPROJ4, " +y_0=" );
SAFE_strcat( szPROJ4, papszMethods[5] );
}
else if( EQUAL(papszMethods[0],"Mercator (2SP)")
&& CSLCount(papszMethods) > 4 )
{
/* notdef: it isn't clear that +proj=merc support a scale of other
than 1.0 in PROJ.4 */
SAFE_strcat( szPROJ4, "+proj=merc" );
SAFE_strcat( szPROJ4, " +lat_ts=" );
SAFE_strcat( szPROJ4, papszMethods[1] );
SAFE_strcat( szPROJ4, " +lon_0=" );
SAFE_strcat( szPROJ4, papszMethods[2] );
SAFE_strcat( szPROJ4, " +x_0=" );
SAFE_strcat( szPROJ4, papszMethods[3] );
SAFE_strcat( szPROJ4, " +y_0=" );
SAFE_strcat( szPROJ4, papszMethods[4] );
}
else if( EQUAL(papszMethods[0],"Hotine Oblique Mercator")
&& CSLCount(papszMethods) > 7 )
{
/* Note that only the second means of specifying omerc is supported
by this code in GXF. */
SAFE_strcat( szPROJ4, "+proj=omerc" );
SAFE_strcat( szPROJ4, " +lat_0=" );
SAFE_strcat( szPROJ4, papszMethods[1] );
SAFE_strcat( szPROJ4, " +lonc=" );
SAFE_strcat( szPROJ4, papszMethods[2] );
SAFE_strcat( szPROJ4, " +alpha=" );
SAFE_strcat( szPROJ4, papszMethods[3] );
if( CPLAtof(papszMethods[4]) < 0.00001 )
{
SAFE_strcat( szPROJ4, " +not_rot" );
}
else
{
#ifdef notdef
if( CPLAtof(papszMethods[4]) + CPLAtof(papszMethods[3]) < 0.00001 )
/* ok */;
else
/* notdef: no way to specify arbitrary angles! */;
#endif
}
SAFE_strcat( szPROJ4, " +k=" );
SAFE_strcat( szPROJ4, papszMethods[5] );
SAFE_strcat( szPROJ4, " +x_0=" );
SAFE_strcat( szPROJ4, papszMethods[6] );
SAFE_strcat( szPROJ4, " +y_0=" );
SAFE_strcat( szPROJ4, papszMethods[7] );
}
else if( EQUAL(papszMethods[0],"Laborde Oblique Mercator")
&& CSLCount(papszMethods) > 6 )
{
SAFE_strcat( szPROJ4, "+proj=labrd" );
SAFE_strcat( szPROJ4, " +lat_0=" );
SAFE_strcat( szPROJ4, papszMethods[1] );
SAFE_strcat( szPROJ4, " +lon_0=" );
SAFE_strcat( szPROJ4, papszMethods[2] );
SAFE_strcat( szPROJ4, " +azi=" );
SAFE_strcat( szPROJ4, papszMethods[3] );
SAFE_strcat( szPROJ4, " +k=" );
SAFE_strcat( szPROJ4, papszMethods[4] );
SAFE_strcat( szPROJ4, " +x_0=" );
SAFE_strcat( szPROJ4, papszMethods[5] );
SAFE_strcat( szPROJ4, " +y_0=" );
SAFE_strcat( szPROJ4, papszMethods[6] );
}
else if( EQUAL(papszMethods[0],"New Zealand Map Grid")
&& CSLCount(papszMethods) > 4 )
{
SAFE_strcat( szPROJ4, "+proj=nzmg" );
SAFE_strcat( szPROJ4, " +lat_0=" );
SAFE_strcat( szPROJ4, papszMethods[1] );
SAFE_strcat( szPROJ4, " +lon_0=" );
SAFE_strcat( szPROJ4, papszMethods[2] );
SAFE_strcat( szPROJ4, " +x_0=" );
SAFE_strcat( szPROJ4, papszMethods[3] );
SAFE_strcat( szPROJ4, " +y_0=" );
SAFE_strcat( szPROJ4, papszMethods[4] );
}
else if( EQUAL(papszMethods[0],"New Zealand Map Grid")
&& CSLCount(papszMethods) > 4 )
{
SAFE_strcat( szPROJ4, "+proj=nzmg" );
SAFE_strcat( szPROJ4, " +lat_0=" );
SAFE_strcat( szPROJ4, papszMethods[1] );
SAFE_strcat( szPROJ4, " +lon_0=" );
SAFE_strcat( szPROJ4, papszMethods[2] );
SAFE_strcat( szPROJ4, " +x_0=" );
SAFE_strcat( szPROJ4, papszMethods[3] );
SAFE_strcat( szPROJ4, " +y_0=" );
SAFE_strcat( szPROJ4, papszMethods[4] );
}
else if( EQUAL(papszMethods[0],"Oblique Stereographic")
&& CSLCount(papszMethods) > 5 )
{
/* there is an option to produce +lat_ts, which we ignore */
SAFE_strcat( szPROJ4, "+proj=stere" );
SAFE_strcat( szPROJ4, " +lat_0=45" );
SAFE_strcat( szPROJ4, " +lat_ts=" );
SAFE_strcat( szPROJ4, papszMethods[1] );
SAFE_strcat( szPROJ4, " +lon_0=" );
SAFE_strcat( szPROJ4, papszMethods[2] );
SAFE_strcat( szPROJ4, " +k=" );
SAFE_strcat( szPROJ4, papszMethods[3] );
SAFE_strcat( szPROJ4, " +x_0=" );
SAFE_strcat( szPROJ4, papszMethods[4] );
SAFE_strcat( szPROJ4, " +y_0=" );
SAFE_strcat( szPROJ4, papszMethods[5] );
}
else if( EQUAL(papszMethods[0],"Polar Stereographic")
&& CSLCount(papszMethods) > 5 )
{
/* there is an option to produce +lat_ts, which we ignore */
SAFE_strcat( szPROJ4, "+proj=stere" );
SAFE_strcat( szPROJ4, " +lat_0=90" );
SAFE_strcat( szPROJ4, " +lat_ts=" );
SAFE_strcat( szPROJ4, papszMethods[1] );
SAFE_strcat( szPROJ4, " +lon_0=" );
SAFE_strcat( szPROJ4, papszMethods[2] );
SAFE_strcat( szPROJ4, " +k=" );
SAFE_strcat( szPROJ4, papszMethods[3] );
SAFE_strcat( szPROJ4, " +x_0=" );
SAFE_strcat( szPROJ4, papszMethods[4] );
SAFE_strcat( szPROJ4, " +y_0=" );
SAFE_strcat( szPROJ4, papszMethods[5] );
}
else if( EQUAL(papszMethods[0],"Swiss Oblique Cylindrical")
&& CSLCount(papszMethods) > 4 )
{
/* notdef: geotiff's geo_ctrans.inc says this is the same as
ObliqueMercator_Rosenmund, which GG's geotiff support just
maps directly to +proj=omerc, though I find that questionable. */
SAFE_strcat( szPROJ4, "+proj=omerc" );
SAFE_strcat( szPROJ4, " +lat_0=" );
SAFE_strcat( szPROJ4, papszMethods[1] );
SAFE_strcat( szPROJ4, " +lonc=" );
SAFE_strcat( szPROJ4, papszMethods[2] );
SAFE_strcat( szPROJ4, " +x_0=" );
SAFE_strcat( szPROJ4, papszMethods[3] );
SAFE_strcat( szPROJ4, " +y_0=" );
SAFE_strcat( szPROJ4, papszMethods[4] );
}
else if( EQUAL(papszMethods[0],"Transverse Mercator")
&& CSLCount(papszMethods) > 5 )
{
/* notdef: geotiff's geo_ctrans.inc says this is the same as
ObliqueMercator_Rosenmund, which GG's geotiff support just
maps directly to +proj=omerc, though I find that questionable. */
SAFE_strcat( szPROJ4, "+proj=tmerc" );
SAFE_strcat( szPROJ4, " +lat_0=" );
SAFE_strcat( szPROJ4, papszMethods[1] );
SAFE_strcat( szPROJ4, " +lon_0=" );
SAFE_strcat( szPROJ4, papszMethods[2] );
SAFE_strcat( szPROJ4, " +k=" );
SAFE_strcat( szPROJ4, papszMethods[3] );
SAFE_strcat( szPROJ4, " +x_0=" );
SAFE_strcat( szPROJ4, papszMethods[4] );
SAFE_strcat( szPROJ4, " +y_0=" );
SAFE_strcat( szPROJ4, papszMethods[5] );
}
else if( EQUAL(papszMethods[0],"Transverse Mercator (South Oriented)")
&& CSLCount(papszMethods) > 5 )
{
/* notdef: I don't know how south oriented is different from
normal, and I don't find any mention of it in Geotiff;s geo_ctrans.
Translating as tmerc, but that is presumably wrong. */
SAFE_strcat( szPROJ4, "+proj=tmerc" );
SAFE_strcat( szPROJ4, " +lat_0=" );
SAFE_strcat( szPROJ4, papszMethods[1] );
SAFE_strcat( szPROJ4, " +lon_0=" );
SAFE_strcat( szPROJ4, papszMethods[2] );
SAFE_strcat( szPROJ4, " +k=" );
SAFE_strcat( szPROJ4, papszMethods[3] );
SAFE_strcat( szPROJ4, " +x_0=" );
SAFE_strcat( szPROJ4, papszMethods[4] );
SAFE_strcat( szPROJ4, " +y_0=" );
SAFE_strcat( szPROJ4, papszMethods[5] );
}
else if( EQUAL(papszMethods[0],"*Equidistant Conic")
&& CSLCount(papszMethods) > 6 )
{
SAFE_strcat( szPROJ4, "+proj=eqdc" );
SAFE_strcat( szPROJ4, " +lat_1=" );
SAFE_strcat( szPROJ4, papszMethods[1] );
SAFE_strcat( szPROJ4, " +lat_2=" );
SAFE_strcat( szPROJ4, papszMethods[2] );
SAFE_strcat( szPROJ4, " +lat_0=" );
SAFE_strcat( szPROJ4, papszMethods[3] );
SAFE_strcat( szPROJ4, " +lon_0=" );
SAFE_strcat( szPROJ4, papszMethods[4] );
SAFE_strcat( szPROJ4, " +x_0=" );
SAFE_strcat( szPROJ4, papszMethods[5] );
SAFE_strcat( szPROJ4, " +y_0=" );
SAFE_strcat( szPROJ4, papszMethods[6] );
}
else if( EQUAL(papszMethods[0],"*Polyconic")
&& CSLCount(papszMethods) > 5 )
{
SAFE_strcat( szPROJ4, "+proj=poly" );
SAFE_strcat( szPROJ4, " +lat_0=" );
SAFE_strcat( szPROJ4, papszMethods[1] );
SAFE_strcat( szPROJ4, " +lon_0=" );
SAFE_strcat( szPROJ4, papszMethods[2] );
#ifdef notdef
/*not supported by PROJ.4 */
SAFE_strcat( szPROJ4, " +k=" );
SAFE_strcat( szPROJ4, papszMethods[3] );
#endif
SAFE_strcat( szPROJ4, " +x_0=" );
SAFE_strcat( szPROJ4, papszMethods[4] );
SAFE_strcat( szPROJ4, " +y_0=" );
SAFE_strcat( szPROJ4, papszMethods[5] );
}
else
{
SAFE_strcat( szPROJ4, "unknown" );
}
CSLDestroy( papszMethods );
/* -------------------------------------------------------------------- */
/* Now get the ellipsoid parameters. For a bunch of common */
/* ones we preserve the name. For the rest we just carry over */
/* the parameters. */
/* -------------------------------------------------------------------- */
if( CSLCount(psGXF->papszMapProjection) > 1 )
{
char **papszTokens;
if( strlen(psGXF->papszMapProjection[1]) > 80 )
return CPLStrdup("");
papszTokens = CSLTokenizeStringComplex(psGXF->papszMapProjection[1],
",", TRUE, TRUE );
if( EQUAL(papszTokens[0],"WGS 84") )
SAFE_strcat( szPROJ4, " +ellps=WGS84" );
else if( EQUAL(papszTokens[0],"*WGS 72") )
SAFE_strcat( szPROJ4, " +ellps=WGS72" );
else if( EQUAL(papszTokens[0],"*WGS 66") )
SAFE_strcat( szPROJ4, " +ellps=WGS66" );
else if( EQUAL(papszTokens[0],"*WGS 60") )
SAFE_strcat( szPROJ4, " +ellps=WGS60" );
else if( EQUAL(papszTokens[0],"Clarke 1866") )
SAFE_strcat( szPROJ4, " +ellps=clrk66" );
else if( EQUAL(papszTokens[0],"Clarke 1880") )
SAFE_strcat( szPROJ4, " +ellps=clrk80" );
else if( EQUAL(papszTokens[0],"GRS 1980") )
SAFE_strcat( szPROJ4, " +ellps=GRS80" );
else if( CSLCount( papszTokens ) > 2 )
{
snprintf( szPROJ4+strlen(szPROJ4), sizeof(szPROJ4)-strlen(szPROJ4),
" +a=%s +e=%s",
papszTokens[1], papszTokens[2] );
}
CSLDestroy(papszTokens);
}
/* -------------------------------------------------------------------- */
/* Extract the units specification. */
/* -------------------------------------------------------------------- */
if( psGXF->pszUnitName != NULL )
{
if( EQUAL(psGXF->pszUnitName,"ft") )
{
SAFE_strcat( szPROJ4, " +units=ft" );
}
else if( EQUAL(psGXF->pszUnitName,"ftUS") )
{
SAFE_strcat( szPROJ4, " +units=us-ft" );
}
else if( EQUAL(psGXF->pszUnitName,"km") )
{
SAFE_strcat( szPROJ4, " +units=km" );
}
else if( EQUAL(psGXF->pszUnitName,"mm") )
{
SAFE_strcat( szPROJ4, " +units=mm" );
}
else if( EQUAL(psGXF->pszUnitName,"in") )
{
SAFE_strcat( szPROJ4, " +units=in" );
}
else if( EQUAL(psGXF->pszUnitName,"ftInd") )
{
SAFE_strcat( szPROJ4, " +units=ind-ft" );
}
else if( EQUAL(psGXF->pszUnitName,"lk") )
{
SAFE_strcat( szPROJ4, " +units=link" );
}
}
return( CPLStrdup( szPROJ4 ) );
}
OGRErr OGRSpatialReference::importFromOzi( const char *pszDatum,
const char *pszProj,
const char *pszProjParms )
{
Clear();
/* -------------------------------------------------------------------- */
/* Operate on the basis of the projection name. */
/* -------------------------------------------------------------------- */
char **papszProj = CSLTokenizeStringComplex( pszProj, ",", TRUE, TRUE );
char **papszProjParms = CSLTokenizeStringComplex( pszProjParms, ",",
TRUE, TRUE );
char **papszDatum = NULL;
if (CSLCount(papszProj) < 2)
{
goto not_enough_data;
}
if ( EQUALN(papszProj[1], "Latitude/Longitude", 18) )
{
}
else if ( EQUALN(papszProj[1], "Mercator", 8) )
{
if (CSLCount(papszProjParms) < 6) goto not_enough_data;
double dfScale = CPLAtof(papszProjParms[3]);
if (papszProjParms[3][0] == 0) dfScale = 1; /* if unset, default to scale = 1 */
SetMercator( CPLAtof(papszProjParms[1]), CPLAtof(papszProjParms[2]),
dfScale,
CPLAtof(papszProjParms[4]), CPLAtof(papszProjParms[5]) );
}
else if ( EQUALN(papszProj[1], "Transverse Mercator", 19) )
{
if (CSLCount(papszProjParms) < 6) goto not_enough_data;
SetTM( CPLAtof(papszProjParms[1]), CPLAtof(papszProjParms[2]),
CPLAtof(papszProjParms[3]),
CPLAtof(papszProjParms[4]), CPLAtof(papszProjParms[5]) );
}
else if ( EQUALN(papszProj[1], "Lambert Conformal Conic", 23) )
{
if (CSLCount(papszProjParms) < 8) goto not_enough_data;
SetLCC( CPLAtof(papszProjParms[6]), CPLAtof(papszProjParms[7]),
CPLAtof(papszProjParms[1]), CPLAtof(papszProjParms[2]),
CPLAtof(papszProjParms[4]), CPLAtof(papszProjParms[5]) );
}
else if ( EQUALN(papszProj[1], "Sinusoidal", 10) )
{
if (CSLCount(papszProjParms) < 6) goto not_enough_data;
SetSinusoidal( CPLAtof(papszProjParms[2]),
CPLAtof(papszProjParms[4]), CPLAtof(papszProjParms[5]) );
}
else if ( EQUALN(papszProj[1], "Albers Equal Area", 17) )
{
if (CSLCount(papszProjParms) < 8) goto not_enough_data;
SetACEA( CPLAtof(papszProjParms[6]), CPLAtof(papszProjParms[7]),
CPLAtof(papszProjParms[1]), CPLAtof(papszProjParms[2]),
CPLAtof(papszProjParms[4]), CPLAtof(papszProjParms[5]) );
}
else
{
CPLDebug( "OSR_Ozi", "Unsupported projection: \"%s\"", papszProj[1] );
SetLocalCS( CPLString().Printf("\"Ozi\" projection \"%s\"",
papszProj[1]) );
}
/* -------------------------------------------------------------------- */
/* Try to translate the datum/spheroid. */
/* -------------------------------------------------------------------- */
papszDatum = CSLTokenizeString2( pszDatum, ",",
CSLT_ALLOWEMPTYTOKENS
| CSLT_STRIPLEADSPACES
| CSLT_STRIPENDSPACES );
if ( papszDatum == NULL)
goto not_enough_data;
if ( !IsLocal() )
{
/* -------------------------------------------------------------------- */
/* Verify that we can find the CSV file containing the datums */
/* -------------------------------------------------------------------- */
if( CSVScanFileByName( CSVFilename( "ozi_datum.csv" ),
"EPSG_DATUM_CODE",
"4326", CC_Integer ) == NULL )
{
CPLError( CE_Failure, CPLE_OpenFailed,
"Unable to open OZI support file %s.\n"
"Try setting the GDAL_DATA environment variable to point\n"
"to the directory containing OZI csv files.",
CSVFilename( "ozi_datum.csv" ) );
goto other_error;
}
/* -------------------------------------------------------------------- */
/* Search for matching datum */
/* -------------------------------------------------------------------- */
const char *pszOziDatum = CSVFilename( "ozi_datum.csv" );
CPLString osDName = CSVGetField( pszOziDatum, "NAME", papszDatum[0],
CC_ApproxString, "NAME" );
if( strlen(osDName) == 0 )
{
CPLError( CE_Failure, CPLE_AppDefined,
"Failed to find datum %s in ozi_datum.csv.",
papszDatum[0] );
goto other_error;
}
int nDatumCode = atoi( CSVGetField( pszOziDatum, "NAME", papszDatum[0],
CC_ApproxString, "EPSG_DATUM_CODE" ) );
if ( nDatumCode > 0 ) // There is a matching EPSG code
{
OGRSpatialReference oGCS;
oGCS.importFromEPSG( nDatumCode );
CopyGeogCSFrom( &oGCS );
}
else // We use the parameters from the CSV files
{
CPLString osEllipseCode = CSVGetField( pszOziDatum, "NAME", papszDatum[0],
CC_ApproxString, "ELLIPSOID_CODE" );
double dfDeltaX = CPLAtof(CSVGetField( pszOziDatum, "NAME", papszDatum[0],
CC_ApproxString, "DELTAX" ) );
double dfDeltaY = CPLAtof(CSVGetField( pszOziDatum, "NAME", papszDatum[0],
CC_ApproxString, "DELTAY" ) );
double dfDeltaZ = CPLAtof(CSVGetField( pszOziDatum, "NAME", papszDatum[0],
CC_ApproxString, "DELTAZ" ) );
/* -------------------------------------------------------------------- */
/* Verify that we can find the CSV file containing the ellipsoids */
/* -------------------------------------------------------------------- */
if( CSVScanFileByName( CSVFilename( "ozi_ellips.csv" ),
"ELLIPSOID_CODE",
"20", CC_Integer ) == NULL )
{
CPLError( CE_Failure, CPLE_OpenFailed,
"Unable to open OZI support file %s.\n"
"Try setting the GDAL_DATA environment variable to point\n"
"to the directory containing OZI csv files.",
CSVFilename( "ozi_ellips.csv" ) );
goto other_error;
}
/* -------------------------------------------------------------------- */
/* Lookup the ellipse code. */
/* -------------------------------------------------------------------- */
const char *pszOziEllipse = CSVFilename( "ozi_ellips.csv" );
CPLString osEName = CSVGetField( pszOziEllipse, "ELLIPSOID_CODE", osEllipseCode,
CC_ApproxString, "NAME" );
if( strlen(osEName) == 0 )
{
CPLError( CE_Failure, CPLE_AppDefined,
"Failed to find ellipsoid %s in ozi_ellips.csv.",
osEllipseCode.c_str() );
goto other_error;
}
double dfA = CPLAtof(CSVGetField( pszOziEllipse, "ELLIPSOID_CODE", osEllipseCode,
CC_ApproxString, "A" ));
double dfInvF = CPLAtof(CSVGetField( pszOziEllipse, "ELLIPSOID_CODE", osEllipseCode,
CC_ApproxString, "INVF" ));
/* -------------------------------------------------------------------- */
/* Create geographic coordinate system. */
/* -------------------------------------------------------------------- */
SetGeogCS( osDName, osDName, osEName, dfA, dfInvF );
SetTOWGS84( dfDeltaX, dfDeltaY, dfDeltaZ );
}
}
/* -------------------------------------------------------------------- */
/* Grid units translation */
/* -------------------------------------------------------------------- */
if( IsLocal() || IsProjected() )
SetLinearUnits( SRS_UL_METER, 1.0 );
FixupOrdering();
CSLDestroy(papszProj);
CSLDestroy(papszProjParms);
CSLDestroy(papszDatum);
return OGRERR_NONE;
not_enough_data:
CSLDestroy(papszProj);
CSLDestroy(papszProjParms);
CSLDestroy(papszDatum);
return OGRERR_NOT_ENOUGH_DATA;
other_error:
CSLDestroy(papszProj);
CSLDestroy(papszProjParms);
CSLDestroy(papszDatum);
return OGRERR_FAILURE;
}
GDALDataset *EIRDataset::Open( GDALOpenInfo * poOpenInfo )
{
int i;
VSILFILE *fp;
const char * pszLine;
if( !Identify( poOpenInfo ) )
return NULL;
fp = VSIFOpenL( poOpenInfo->pszFilename, "r" );
if( fp == NULL )
return NULL;
/* header example and description
IMAGINE_RAW_FILE // must be on first line, by itself
WIDTH 581 // number of columns in the image
HEIGHT 695 // number of rows in the image
NUM_LAYERS 3 // number of spectral bands in the image; default 1
PIXEL_FILES raw8_3n_ui_sanjack.bl // raster file
// default: same name with no extension
FORMAT BIL // BIL BIP BSQ; default BIL
DATATYPE U8 // U1 U2 U4 U8 U16 U32 S16 S32 F32 F64; default U8
BYTE_ORDER // LSB MSB; required for U16 U32 S16 S32 F32 F64
DATA_OFFSET // start of image data in raster file; default 0 bytes
END_RAW_FILE // end RAW file - stop reading
For a true color image with three bands (R, G, B) stored using 8 bits
for each pixel in each band, DATA_TYPE equals U8 and NUM_LAYERS equals
3 for a total of 24 bits per pixel.
Note that the current version of ERDAS Raw Raster Reader/Writer does
not support the LAYER_SKIP_BYTES, RECORD_SKIP_BYTES, TILE_WIDTH and
TILE_HEIGHT directives. Since the reader does not read the PIXEL_FILES
directive, the reader always assumes that the raw binary file is the
dataset, and the name of this file is the name of the header without the
extension. Currently, the reader does not support multiple raw binary
files in one dataset or a single file with both the header and the raw
binary data at the same time.
*/
bool bDone = FALSE;
int nRows = -1, nCols = -1, nBands = 1;
int nSkipBytes = 0;
int nLineCount = 0;
GDALDataType eDataType = GDT_Byte;
int nBits = 8;
char chByteOrder = 'M';
char szLayout[10] = "BIL";
char **papszHDR = NULL;
// default raster file: same name with no extension
CPLString osPath = CPLGetPath( poOpenInfo->pszFilename );
CPLString osName = CPLGetBasename( poOpenInfo->pszFilename );
CPLString osRasterFilename = CPLFormCIFilename( osPath, osName, "" );
// parse the header file
while( !bDone && (pszLine = CPLReadLineL( fp )) != NULL )
{
char **papszTokens;
nLineCount++;
if ( (nLineCount == 1) && !EQUAL(pszLine,"IMAGINE_RAW_FILE") ) {
return NULL;
}
if ( (nLineCount > 50) || EQUAL(pszLine,"END_RAW_FILE") ) {
bDone = TRUE;
break;
}
if( strlen(pszLine) > 1000 )
break;
papszHDR = CSLAddString( papszHDR, pszLine );
papszTokens = CSLTokenizeStringComplex( pszLine, " \t", TRUE, FALSE );
if( CSLCount( papszTokens ) < 2 )
{
CSLDestroy( papszTokens );
continue;
}
if( EQUAL(papszTokens[0],"WIDTH") )
{
nCols = atoi(papszTokens[1]);
}
else if( EQUAL(papszTokens[0],"HEIGHT") )
{
nRows = atoi(papszTokens[1]);
}
else if( EQUAL(papszTokens[0],"NUM_LAYERS") )
{
nBands = atoi(papszTokens[1]);
}
else if( EQUAL(papszTokens[0],"PIXEL_FILES") )
{
osRasterFilename = CPLFormCIFilename( osPath, papszTokens[1], "" );
}
else if( EQUAL(papszTokens[0],"FORMAT") )
{
strncpy( szLayout, papszTokens[1], sizeof(szLayout) );
szLayout[sizeof(szLayout)-1] = '\0';
}
else if( EQUAL(papszTokens[0],"DATATYPE")
|| EQUAL(papszTokens[0],"DATA_TYPE") )
{
if ( EQUAL(papszTokens[1], "U1")
|| EQUAL(papszTokens[1], "U2")
|| EQUAL(papszTokens[1], "U4")
|| EQUAL(papszTokens[1], "U8") ) {
nBits = 8;
eDataType = GDT_Byte;
}
else if( EQUAL(papszTokens[1], "U16") ) {
nBits = 16;
eDataType = GDT_UInt16;
}
else if( EQUAL(papszTokens[1], "U32") ) {
nBits = 32;
eDataType = GDT_UInt32;
}
else if( EQUAL(papszTokens[1], "S16") ) {
nBits = 16;
eDataType = GDT_Int16;
}
else if( EQUAL(papszTokens[1], "S32") ) {
nBits = 32;
eDataType = GDT_Int32;
}
else if( EQUAL(papszTokens[1], "F32") ) {
nBits = 32;
eDataType = GDT_Float32;
}
else if( EQUAL(papszTokens[1], "F64") ) {
nBits = 64;
eDataType = GDT_Float64;
}
else {
CPLError( CE_Failure, CPLE_NotSupported,
"EIR driver does not support DATATYPE %s.",
papszTokens[1] );
CSLDestroy( papszTokens );
CSLDestroy( papszHDR );
VSIFCloseL( fp );
return NULL;
}
}
else if( EQUAL(papszTokens[0],"BYTE_ORDER") )
{
// M for MSB, L for LSB
chByteOrder = (char) toupper(papszTokens[1][0]);
}
else if( EQUAL(papszTokens[0],"DATA_OFFSET") )
{
nSkipBytes = atoi(papszTokens[1]); // TBD: is this mapping right?
}
CSLDestroy( papszTokens );
}
VSIFCloseL( fp );
/* -------------------------------------------------------------------- */
/* Did we get the required keywords? If not we return with */
/* this never having been considered to be a match. This isn't */
/* an error! */
/* -------------------------------------------------------------------- */
if( nRows == -1 || nCols == -1 )
{
CSLDestroy( papszHDR );
return NULL;
}
if (!GDALCheckDatasetDimensions(nCols, nRows) ||
!GDALCheckBandCount(nBands, FALSE))
{
CSLDestroy( papszHDR );
return NULL;
}
/* -------------------------------------------------------------------- */
/* Confirm the requested access is supported. */
/* -------------------------------------------------------------------- */
if( poOpenInfo->eAccess == GA_Update )
{
CSLDestroy( papszHDR );
CPLError( CE_Failure, CPLE_NotSupported,
"The EIR driver does not support update access to existing"
" datasets.\n" );
return NULL;
}
/* -------------------------------------------------------------------- */
/* Create a corresponding GDALDataset. */
/* -------------------------------------------------------------------- */
EIRDataset *poDS;
poDS = new EIRDataset();
/* -------------------------------------------------------------------- */
/* Capture some information from the file that is of interest. */
/* -------------------------------------------------------------------- */
poDS->nRasterXSize = nCols;
poDS->nRasterYSize = nRows;
poDS->papszHDR = papszHDR;
/* -------------------------------------------------------------------- */
/* Open target binary file. */
/* -------------------------------------------------------------------- */
poDS->fpImage = VSIFOpenL( osRasterFilename.c_str(), "rb" );
if( poDS->fpImage == NULL )
{
CPLError( CE_Failure, CPLE_OpenFailed,
"Failed to open %s.\n%s",
osRasterFilename.c_str(), VSIStrerror( errno ) );
delete poDS;
return NULL;
}
poDS->papszExtraFiles =
CSLAddString( poDS->papszExtraFiles,
osRasterFilename );
poDS->eAccess = poOpenInfo->eAccess;
/* -------------------------------------------------------------------- */
/* Compute the line offset. */
/* -------------------------------------------------------------------- */
int nItemSize = GDALGetDataTypeSize(eDataType)/8;
int nPixelOffset, nLineOffset;
vsi_l_offset nBandOffset;
if( EQUAL(szLayout,"BIP") )
{
nPixelOffset = nItemSize * nBands;
nLineOffset = nPixelOffset * nCols;
nBandOffset = (vsi_l_offset)nItemSize;
}
else if( EQUAL(szLayout,"BSQ") )
{
nPixelOffset = nItemSize;
nLineOffset = nPixelOffset * nCols;
nBandOffset = (vsi_l_offset)nLineOffset * nRows;
}
else /* assume BIL */
{
nPixelOffset = nItemSize;
nLineOffset = nItemSize * nBands * nCols;
nBandOffset = (vsi_l_offset)nItemSize * nCols;
}
poDS->SetDescription( poOpenInfo->pszFilename );
poDS->PamInitialize();
/* -------------------------------------------------------------------- */
/* Create band information objects. */
/* -------------------------------------------------------------------- */
poDS->nBands = nBands;
for( i = 0; i < poDS->nBands; i++ )
{
RawRasterBand *poBand;
poBand =
new RawRasterBand( poDS, i+1, poDS->fpImage,
nSkipBytes + nBandOffset * i,
nPixelOffset, nLineOffset, eDataType,
#ifdef CPL_LSB
chByteOrder == 'I' || chByteOrder == 'L',
#else
chByteOrder == 'M',
#endif
nBits);
poDS->SetBand( i+1, poBand );
}
/* -------------------------------------------------------------------- */
/* look for a worldfile */
/* -------------------------------------------------------------------- */
if( !poDS->bGotTransform )
poDS->bGotTransform =
GDALReadWorldFile( poOpenInfo->pszFilename, 0,
poDS->adfGeoTransform );
if( !poDS->bGotTransform )
poDS->bGotTransform =
GDALReadWorldFile( poOpenInfo->pszFilename, "wld",
poDS->adfGeoTransform );
/* -------------------------------------------------------------------- */
/* Initialize any PAM information. */
/* -------------------------------------------------------------------- */
poDS->TryLoadXML();
/* -------------------------------------------------------------------- */
/* Check for overviews. */
/* -------------------------------------------------------------------- */
poDS->oOvManager.Initialize( poDS, poOpenInfo->pszFilename );
return( poDS );
}
OGRLayer *OGRDGNDataSource::CreateLayer( const char *pszLayerName,
OGRSpatialReference *poSRS,
OGRwkbGeometryType eGeomType,
char **papszExtraOptions )
{
const char *pszSeed, *pszMasterUnit = "m", *pszSubUnit = "cm";
const char *pszValue;
int nUORPerSU=1, nSUPerMU=100;
int nCreationFlags = 0, b3DRequested;
double dfOriginX = -21474836.0, /* default origin centered on zero */
dfOriginY = -21474836.0, /* with two decimals of precision */
dfOriginZ = -21474836.0;
/* -------------------------------------------------------------------- */
/* Ensure only one layer gets created. */
/* -------------------------------------------------------------------- */
if( nLayers > 0 )
{
CPLError( CE_Failure, CPLE_AppDefined,
"DGN driver only supports one layer will all the elements in it." );
return NULL;
}
/* -------------------------------------------------------------------- */
/* If the coordinate system is geographic, we should use a */
/* localized default origin and resolution. */
/* -------------------------------------------------------------------- */
if( poSRS != NULL && poSRS->IsGeographic() )
{
dfOriginX = -200.0;
dfOriginY = -200.0;
pszMasterUnit = "d";
pszSubUnit = "s";
nSUPerMU = 3600;
nUORPerSU = 1000;
}
/* -------------------------------------------------------------------- */
/* Parse out various creation options. */
/* -------------------------------------------------------------------- */
CSLInsertStrings( papszOptions, 0, papszExtraOptions );
b3DRequested = CSLFetchBoolean( papszOptions, "3D",
(((int) eGeomType) & wkb25DBit) );
pszSeed = CSLFetchNameValue( papszOptions, "SEED" );
if( pszSeed )
nCreationFlags |= DGNCF_USE_SEED_ORIGIN | DGNCF_USE_SEED_UNITS;
else if( b3DRequested )
pszSeed = CPLFindFile( "gdal", "seed_3d.dgn" );
else
pszSeed = CPLFindFile( "gdal", "seed_2d.dgn" );
if( pszSeed == NULL )
{
CPLError( CE_Failure, CPLE_AppDefined,
"No seed file provided, and unable to find seed_2d.dgn." );
return NULL;
}
if( CSLFetchBoolean( papszOptions, "COPY_WHOLE_SEED_FILE", TRUE ) )
nCreationFlags |= DGNCF_COPY_WHOLE_SEED_FILE;
if( CSLFetchBoolean( papszOptions, "COPY_SEED_FILE_COLOR_TABLE", TRUE ) )
nCreationFlags |= DGNCF_COPY_SEED_FILE_COLOR_TABLE;
pszValue = CSLFetchNameValue( papszOptions, "MASTER_UNIT_NAME" );
if( pszValue != NULL )
{
nCreationFlags &= ~DGNCF_USE_SEED_UNITS;
pszMasterUnit = pszValue;
}
pszValue = CSLFetchNameValue( papszOptions, "SUB_UNIT_NAME" );
if( pszValue != NULL )
{
nCreationFlags &= ~DGNCF_USE_SEED_UNITS;
pszSubUnit = pszValue;
}
pszValue = CSLFetchNameValue( papszOptions, "SUB_UNITS_PER_MASTER_UNIT" );
if( pszValue != NULL )
{
nCreationFlags &= ~DGNCF_USE_SEED_UNITS;
nSUPerMU = atoi(pszValue);
}
pszValue = CSLFetchNameValue( papszOptions, "UOR_PER_SUB_UNIT" );
if( pszValue != NULL )
{
nCreationFlags &= ~DGNCF_USE_SEED_UNITS;
nUORPerSU = atoi(pszValue);
}
pszValue = CSLFetchNameValue( papszOptions, "ORIGIN" );
if( pszValue != NULL )
{
char **papszTuple = CSLTokenizeStringComplex( pszValue, " ,",
FALSE, FALSE );
nCreationFlags &= ~DGNCF_USE_SEED_ORIGIN;
if( CSLCount(papszTuple) == 3 )
{
dfOriginX = atof(papszTuple[0]);
dfOriginY = atof(papszTuple[1]);
dfOriginZ = atof(papszTuple[2]);
}
else if( CSLCount(papszTuple) == 2 )
{
dfOriginX = atof(papszTuple[0]);
dfOriginY = atof(papszTuple[1]);
dfOriginZ = 0.0;
}
else
{
CSLDestroy(papszTuple);
CPLError( CE_Failure, CPLE_AppDefined,
"ORIGIN is not a valid 2d or 3d tuple.\n"
"Separate tuple values with comma." );
return FALSE;
}
CSLDestroy(papszTuple);
}
/* -------------------------------------------------------------------- */
/* Try creating the base file. */
/* -------------------------------------------------------------------- */
hDGN = DGNCreate( pszName, pszSeed, nCreationFlags,
dfOriginX, dfOriginY, dfOriginZ,
nSUPerMU, nUORPerSU, pszMasterUnit, pszSubUnit );
if( hDGN == NULL )
return NULL;
/* -------------------------------------------------------------------- */
/* Create the layer object. */
/* -------------------------------------------------------------------- */
OGRDGNLayer *poLayer;
poLayer = new OGRDGNLayer( pszLayerName, hDGN, TRUE );
/* -------------------------------------------------------------------- */
/* Add layer to data source layer list. */
/* -------------------------------------------------------------------- */
papoLayers = (OGRDGNLayer **)
CPLRealloc( papoLayers, sizeof(OGRDGNLayer *) * (nLayers+1) );
papoLayers[nLayers++] = poLayer;
return poLayer;
}
int OGROCIDataSource::Open( const char * pszNewName,
char** papszOpenOptionsIn,
int bUpdate,
int bTestOpen )
{
CPLAssert( nLayers == 0 && poSession == NULL );
/* -------------------------------------------------------------------- */
/* Verify Oracle prefix. */
/* -------------------------------------------------------------------- */
if( !STARTS_WITH_CI(pszNewName,"OCI:") )
{
if( !bTestOpen )
{
CPLError( CE_Failure, CPLE_AppDefined,
"%s does not conform to Oracle OCI driver naming convention,"
" OCI:*\n", pszNewName );
}
return FALSE;
}
/* -------------------------------------------------------------------- */
/* Try to parse out name, password and database name. */
/* -------------------------------------------------------------------- */
char *pszUserid;
const char *pszPassword = "";
const char *pszDatabase = "";
char **papszTableList = NULL;
const char *pszWorkspace = "";
int i;
if( pszNewName[4] == '\0' )
{
pszUserid = CPLStrdup(CSLFetchNameValueDef(papszOpenOptionsIn, "USER", ""));
pszPassword = CSLFetchNameValueDef(papszOpenOptionsIn, "PASSWORD", "");
pszDatabase = CSLFetchNameValueDef(papszOpenOptionsIn, "DBNAME", "");
const char* pszTables = CSLFetchNameValue(papszOpenOptionsIn, "TABLES");
if( pszTables )
papszTableList = CSLTokenizeStringComplex(pszTables, ",", TRUE, FALSE );
pszWorkspace = CSLFetchNameValueDef(papszOpenOptions, "WORKSPACE", "");
}
else
{
pszUserid = CPLStrdup( pszNewName + 4 );
// Is there a table list?
for( i = static_cast<int>(strlen(pszUserid))-1; i > 1; i-- )
{
if( pszUserid[i] == ':' )
{
papszTableList = CSLTokenizeStringComplex( pszUserid+i+1, ",",
TRUE, FALSE );
pszUserid[i] = '\0';
break;
}
if( pszUserid[i] == '/' || pszUserid[i] == '@' )
break;
}
for( i = 0;
pszUserid[i] != '\0' && pszUserid[i] != '/' && pszUserid[i] != '@';
i++ ) {}
if( pszUserid[i] == '/' )
{
pszUserid[i++] = '\0';
pszPassword = pszUserid + i;
for( ; pszUserid[i] != '\0' && pszUserid[i] != '@'; i++ ) {}
}
if( pszUserid[i] == '@' )
{
pszUserid[i++] = '\0';
pszDatabase = pszUserid + i;
}
}
/* -------------------------------------------------------------------- */
/* Try to establish connection. */
/* -------------------------------------------------------------------- */
CPLDebug( "OCI", "Userid=%s, Password=%s, Database=%s",
pszUserid, pszPassword, pszDatabase );
if( EQUAL(pszDatabase, "") &&
EQUAL(pszPassword, "") &&
EQUAL(pszUserid, "") )
{
/* Use username/password OS Authentication and ORACLE_SID database */
poSession = OGRGetOCISession( "/", "", "" );
}
else
{
poSession = OGRGetOCISession( pszUserid, pszPassword, pszDatabase );
}
if( poSession == NULL )
{
CPLFree(pszUserid);
CSLDestroy(papszTableList);
return FALSE;
}
if( ! EQUAL(pszWorkspace, "") )
{
OGROCIStringBuf oValidateCmd;
OGROCIStatement oValidateStmt( GetSession() );
oValidateCmd.Append( "call DBMS_WM.GotoWorkspace('" );
oValidateCmd.Append( pszWorkspace );
oValidateCmd.Append( "')" );
oValidateStmt.Execute( oValidateCmd.GetString() );
}
pszName = CPLStrdup( pszNewName );
bDSUpdate = bUpdate;
/* -------------------------------------------------------------------- */
/* If no list of target tables was provided, collect a list of */
/* spatial tables now. */
/* -------------------------------------------------------------------- */
if( papszTableList == NULL )
{
OGROCIStatement oGetTables( poSession );
if( oGetTables.Execute(
"SELECT TABLE_NAME, OWNER FROM ALL_SDO_GEOM_METADATA" )
== CE_None )
{
char **papszRow;
while( (papszRow = oGetTables.SimpleFetchRow()) != NULL )
{
char szFullTableName[100];
if( EQUAL(papszRow[1],pszUserid) )
strcpy( szFullTableName, papszRow[0] );
else
snprintf( szFullTableName, sizeof(szFullTableName), "%s.%s",
papszRow[1], papszRow[0] );
if( CSLFindString( papszTableList, szFullTableName ) == -1 )
papszTableList = CSLAddString( papszTableList,
szFullTableName );
}
}
}
CPLFree( pszUserid );
/* -------------------------------------------------------------------- */
/* Open all the selected tables or views. */
/* -------------------------------------------------------------------- */
for( i = 0; papszTableList != NULL && papszTableList[i] != NULL; i++ )
{
OpenTable( papszTableList[i], -1, bUpdate, FALSE, papszOpenOptionsIn );
}
CSLDestroy( papszTableList );
return TRUE;
}
CPLErr VRTDataset::XMLInit( CPLXMLNode *psTree, const char *pszVRTPath )
{
if( pszVRTPath != NULL )
this->pszVRTPath = CPLStrdup(pszVRTPath);
/* -------------------------------------------------------------------- */
/* Check for an SRS node. */
/* -------------------------------------------------------------------- */
if( strlen(CPLGetXMLValue(psTree, "SRS", "")) > 0 )
{
OGRSpatialReference oSRS;
CPLFree( pszProjection );
pszProjection = NULL;
if( oSRS.SetFromUserInput( CPLGetXMLValue(psTree, "SRS", "") )
== OGRERR_NONE )
oSRS.exportToWkt( &pszProjection );
}
/* -------------------------------------------------------------------- */
/* Check for a GeoTransform node. */
/* -------------------------------------------------------------------- */
if( strlen(CPLGetXMLValue(psTree, "GeoTransform", "")) > 0 )
{
const char *pszGT = CPLGetXMLValue(psTree, "GeoTransform", "");
char **papszTokens;
papszTokens = CSLTokenizeStringComplex( pszGT, ",", FALSE, FALSE );
if( CSLCount(papszTokens) != 6 )
{
CPLError( CE_Warning, CPLE_AppDefined,
"GeoTransform node does not have expected six values.");
}
else
{
for( int iTA = 0; iTA < 6; iTA++ )
adfGeoTransform[iTA] = atof(papszTokens[iTA]);
bGeoTransformSet = TRUE;
}
CSLDestroy( papszTokens );
}
/* -------------------------------------------------------------------- */
/* Check for GCPs. */
/* -------------------------------------------------------------------- */
CPLXMLNode *psGCPList = CPLGetXMLNode( psTree, "GCPList" );
if( psGCPList != NULL )
{
CPLXMLNode *psXMLGCP;
OGRSpatialReference oSRS;
const char *pszRawProj = CPLGetXMLValue(psGCPList, "Projection", "");
CPLFree( pszGCPProjection );
if( strlen(pszRawProj) > 0
&& oSRS.SetFromUserInput( pszRawProj ) == OGRERR_NONE )
oSRS.exportToWkt( &pszGCPProjection );
else
pszGCPProjection = CPLStrdup("");
// Count GCPs.
int nGCPMax = 0;
for( psXMLGCP = psGCPList->psChild; psXMLGCP != NULL;
psXMLGCP = psXMLGCP->psNext )
nGCPMax++;
pasGCPList = (GDAL_GCP *) CPLCalloc(sizeof(GDAL_GCP),nGCPMax);
for( psXMLGCP = psGCPList->psChild; psXMLGCP != NULL;
psXMLGCP = psXMLGCP->psNext )
{
GDAL_GCP *psGCP = pasGCPList + nGCPCount;
if( !EQUAL(psXMLGCP->pszValue,"GCP") ||
psXMLGCP->eType != CXT_Element )
continue;
GDALInitGCPs( 1, psGCP );
CPLFree( psGCP->pszId );
psGCP->pszId = CPLStrdup(CPLGetXMLValue(psXMLGCP,"Id",""));
CPLFree( psGCP->pszInfo );
psGCP->pszInfo = CPLStrdup(CPLGetXMLValue(psXMLGCP,"Info",""));
psGCP->dfGCPPixel = atof(CPLGetXMLValue(psXMLGCP,"Pixel","0.0"));
psGCP->dfGCPLine = atof(CPLGetXMLValue(psXMLGCP,"Line","0.0"));
psGCP->dfGCPX = atof(CPLGetXMLValue(psXMLGCP,"X","0.0"));
psGCP->dfGCPY = atof(CPLGetXMLValue(psXMLGCP,"Y","0.0"));
psGCP->dfGCPZ = atof(CPLGetXMLValue(psXMLGCP,"Z","0.0"));
nGCPCount++;
}
}
/* -------------------------------------------------------------------- */
/* Apply any dataset level metadata. */
/* -------------------------------------------------------------------- */
oMDMD.XMLInit( psTree, TRUE );
/* -------------------------------------------------------------------- */
/* Create dataset mask band. */
/* -------------------------------------------------------------------- */
CPLXMLNode *psChild;
/* Parse dataset mask band first */
CPLXMLNode* psMaskBandNode = CPLGetXMLNode(psTree, "MaskBand");
if (psMaskBandNode)
psChild = psMaskBandNode->psChild;
else
psChild = NULL;
for( ; psChild != NULL; psChild=psChild->psNext )
{
if( psChild->eType == CXT_Element
&& EQUAL(psChild->pszValue,"VRTRasterBand") )
{
VRTRasterBand *poBand = NULL;
const char *pszSubclass = CPLGetXMLValue( psChild, "subclass",
"VRTSourcedRasterBand" );
if( EQUAL(pszSubclass,"VRTSourcedRasterBand") )
poBand = new VRTSourcedRasterBand( this, 0 );
else if( EQUAL(pszSubclass, "VRTDerivedRasterBand") )
poBand = new VRTDerivedRasterBand( this, 0 );
else if( EQUAL(pszSubclass, "VRTRawRasterBand") )
poBand = new VRTRawRasterBand( this, 0 );
else if( EQUAL(pszSubclass, "VRTWarpedRasterBand") )
poBand = new VRTWarpedRasterBand( this, 0 );
else
CPLError( CE_Failure, CPLE_AppDefined,
"VRTRasterBand of unrecognised subclass '%s'.",
pszSubclass );
if( poBand != NULL
&& poBand->XMLInit( psChild, pszVRTPath ) == CE_None )
{
SetMaskBand(poBand);
break;
}
else
{
if( poBand )
delete poBand;
return CE_Failure;
}
}
}
/* -------------------------------------------------------------------- */
/* Create band information objects. */
/* -------------------------------------------------------------------- */
int nBands = 0;
for( psChild=psTree->psChild; psChild != NULL; psChild=psChild->psNext )
{
if( psChild->eType == CXT_Element
&& EQUAL(psChild->pszValue,"VRTRasterBand") )
{
VRTRasterBand *poBand = NULL;
const char *pszSubclass = CPLGetXMLValue( psChild, "subclass",
"VRTSourcedRasterBand" );
if( EQUAL(pszSubclass,"VRTSourcedRasterBand") )
poBand = new VRTSourcedRasterBand( this, nBands+1 );
else if( EQUAL(pszSubclass, "VRTDerivedRasterBand") )
poBand = new VRTDerivedRasterBand( this, nBands+1 );
else if( EQUAL(pszSubclass, "VRTRawRasterBand") )
poBand = new VRTRawRasterBand( this, nBands+1 );
else if( EQUAL(pszSubclass, "VRTWarpedRasterBand") )
poBand = new VRTWarpedRasterBand( this, nBands+1 );
else
CPLError( CE_Failure, CPLE_AppDefined,
"VRTRasterBand of unrecognised subclass '%s'.",
pszSubclass );
if( poBand != NULL
&& poBand->XMLInit( psChild, pszVRTPath ) == CE_None )
{
SetBand( ++nBands, poBand );
}
else
{
if( poBand )
delete poBand;
return CE_Failure;
}
}
}
return CE_None;
}
GXFHandle GXFOpen( const char * pszFilename )
{
FILE *fp;
GXFInfo_t *psGXF;
char szTitle[71];
char **papszList;
int nHeaderCount = 0;
/* -------------------------------------------------------------------- */
/* We open in binary to ensure that we can efficiently seek() */
/* to any location when reading scanlines randomly. If we */
/* opened as text we might still be able to seek(), but I */
/* believe that on Windows, the C library has to read through */
/* all the data to find the right spot taking into account DOS */
/* CRs. */
/* -------------------------------------------------------------------- */
fp = VSIFOpen( pszFilename, "rb" );
if( fp == NULL )
{
/* how to effectively communicate this error out? */
CPLError( CE_Failure, CPLE_OpenFailed,
"Unable to open file: %s\n", pszFilename );
return NULL;
}
/* -------------------------------------------------------------------- */
/* Create the GXF Information object. */
/* -------------------------------------------------------------------- */
psGXF = (GXFInfo_t *) VSICalloc( sizeof(GXFInfo_t), 1 );
psGXF->fp = fp;
psGXF->dfTransformScale = 1.0;
psGXF->nSense = GXFS_LL_RIGHT;
psGXF->dfXPixelSize = 1.0;
psGXF->dfYPixelSize = 1.0;
psGXF->dfSetDummyTo = -1e12;
psGXF->dfUnitToMeter = 1.0;
psGXF->pszTitle = VSIStrdup("");
/* -------------------------------------------------------------------- */
/* Read the header, one line at a time. */
/* -------------------------------------------------------------------- */
while( (papszList = GXFReadHeaderValue( fp, szTitle)) != NULL && nHeaderCount < MAX_HEADER_COUNT )
{
if( EQUALN(szTitle,"#TITL",5) )
{
CPLFree( psGXF->pszTitle );
psGXF->pszTitle = CPLStrdup( papszList[0] );
}
else if( EQUALN(szTitle,"#POIN",5) )
{
psGXF->nRawXSize = atoi(papszList[0]);
}
else if( EQUALN(szTitle,"#ROWS",5) )
{
psGXF->nRawYSize = atoi(papszList[0]);
}
else if( EQUALN(szTitle,"#PTSE",5) )
{
psGXF->dfXPixelSize = CPLAtof(papszList[0]);
}
else if( EQUALN(szTitle,"#RWSE",5) )
{
psGXF->dfYPixelSize = CPLAtof(papszList[0]);
}
else if( EQUALN(szTitle,"#DUMM",5) )
{
memset( psGXF->szDummy, 0, sizeof(psGXF->szDummy));
strncpy( psGXF->szDummy, papszList[0], sizeof(psGXF->szDummy) - 1);
psGXF->dfSetDummyTo = CPLAtof(papszList[0]);
}
else if( EQUALN(szTitle,"#XORI",5) )
{
psGXF->dfXOrigin = CPLAtof(papszList[0]);
}
else if( EQUALN(szTitle,"#YORI",5) )
{
psGXF->dfYOrigin = CPLAtof(papszList[0]);
}
else if( EQUALN(szTitle,"#ZMIN",5) )
{
psGXF->dfZMinimum = CPLAtof(papszList[0]);
}
else if( EQUALN(szTitle,"#ZMAX",5) )
{
psGXF->dfZMaximum = CPLAtof(papszList[0]);
}
else if( EQUALN(szTitle,"#SENS",5) )
{
psGXF->nSense = atoi(papszList[0]);
}
else if( EQUALN(szTitle,"#MAP_PROJECTION",8) )
{
psGXF->papszMapProjection = papszList;
papszList = NULL;
}
else if( EQUALN(szTitle,"#MAP_D",5) )
{
psGXF->papszMapDatumTransform = papszList;
papszList = NULL;
}
else if( EQUALN(szTitle,"#UNIT",5) )
{
char **papszFields;
papszFields = CSLTokenizeStringComplex( papszList[0], ", ",
TRUE, TRUE );
if( CSLCount(papszFields) > 1 )
{
psGXF->pszUnitName = VSIStrdup( papszFields[0] );
psGXF->dfUnitToMeter = CPLAtof( papszFields[1] );
if( psGXF->dfUnitToMeter == 0.0 )
psGXF->dfUnitToMeter = 1.0;
}
CSLDestroy( papszFields );
}
else if( EQUALN(szTitle,"#TRAN",5) )
{
char **papszFields;
papszFields = CSLTokenizeStringComplex( papszList[0], ", ",
TRUE, TRUE );
if( CSLCount(papszFields) > 1 )
{
psGXF->dfTransformScale = CPLAtof(papszFields[0]);
psGXF->dfTransformOffset = CPLAtof(papszFields[1]);
}
if( CSLCount(papszFields) > 2 )
psGXF->pszTransformName = CPLStrdup( papszFields[2] );
CSLDestroy( papszFields );
}
else if( EQUALN(szTitle,"#GTYPE",5) )
{
psGXF->nGType = atoi(papszList[0]);
}
CSLDestroy( papszList );
nHeaderCount ++;
}
CSLDestroy( papszList );
/* -------------------------------------------------------------------- */
/* Did we find the #GRID? */
/* -------------------------------------------------------------------- */
if( !EQUALN(szTitle,"#GRID",5) )
{
GXFClose( psGXF );
CPLError( CE_Failure, CPLE_WrongFormat,
"Didn't parse through to #GRID successfully in.\n"
"file `%s'.\n",
pszFilename );
return NULL;
}
/* -------------------------------------------------------------------- */
/* Allocate, and initialize the raw scanline offset array. */
/* -------------------------------------------------------------------- */
if( psGXF->nRawYSize <= 0 )
{
GXFClose( psGXF );
return NULL;
}
psGXF->panRawLineOffset = (long *)
VSICalloc( sizeof(long), psGXF->nRawYSize+1 );
if( psGXF->panRawLineOffset == NULL )
{
GXFClose( psGXF );
return NULL;
}
psGXF->panRawLineOffset[0] = VSIFTell( psGXF->fp );
/* -------------------------------------------------------------------- */
/* Update the zmin/zmax values to take into account #TRANSFORM */
/* information. */
/* -------------------------------------------------------------------- */
if( psGXF->dfZMinimum != 0.0 || psGXF->dfZMaximum != 0.0 )
{
psGXF->dfZMinimum = (psGXF->dfZMinimum * psGXF->dfTransformScale)
+ psGXF->dfTransformOffset;
psGXF->dfZMaximum = (psGXF->dfZMaximum * psGXF->dfTransformScale)
+ psGXF->dfTransformOffset;
}
return( (GXFHandle) psGXF );
}
/**********************************************************************
* MITABCoordSys2TABProjInfo()
*
* Convert a MIF COORDSYS string into a TABProjInfo structure.
*
* Returns 0 on success, -1 on error.
**********************************************************************/
int MITABCoordSys2TABProjInfo(const char * pszCoordSys, TABProjInfo *psProj)
{
char **papszFields;
// Set all fields to zero, equivalent of NonEarth Units "mi"
memset(psProj, 0, sizeof(TABProjInfo));
if( pszCoordSys == NULL )
return -1;
/*-----------------------------------------------------------------
* Parse the passed string into words.
*----------------------------------------------------------------*/
while(*pszCoordSys == ' ') pszCoordSys++; // Eat leading spaces
if( EQUALN(pszCoordSys,"CoordSys",8) )
pszCoordSys += 9;
papszFields = CSLTokenizeStringComplex( pszCoordSys, " ,", TRUE, FALSE );
/*-----------------------------------------------------------------
* Clip off Bounds information.
*----------------------------------------------------------------*/
int iBounds = CSLFindString( papszFields, "Bounds" );
while( iBounds != -1 && papszFields[iBounds] != NULL )
{
CPLFree( papszFields[iBounds] );
papszFields[iBounds] = NULL;
iBounds++;
}
/*-----------------------------------------------------------------
* Fetch the projection.
*----------------------------------------------------------------*/
char **papszNextField;
if( CSLCount( papszFields ) >= 3
&& EQUAL(papszFields[0],"Earth")
&& EQUAL(papszFields[1],"Projection") )
{
int nProjId = atoi(papszFields[2]);
if (nProjId>=3000) nProjId -=3000;
else if (nProjId>=2000) nProjId -=2000;
else if (nProjId>=1000) nProjId -=1000;
psProj->nProjId = (GByte)nProjId;
papszNextField = papszFields + 3;
}
else if (CSLCount( papszFields ) >= 2
&& EQUAL(papszFields[0],"NonEarth") )
{
// NonEarth Units "..." Bounds (x, y) (x, y)
psProj->nProjId = 0;
papszNextField = papszFields + 2;
if( papszNextField[0] != NULL && EQUAL(papszNextField[0],"Units") )
papszNextField++;
}
else
{
// Invalid projection string ???
if (CSLCount(papszFields) > 0)
CPLError(CE_Warning, CPLE_IllegalArg,
"Failed parsing CoordSys: '%s'", pszCoordSys);
CSLDestroy(papszFields);
return -1;
}
/*-----------------------------------------------------------------
* Fetch the datum information.
*----------------------------------------------------------------*/
int nDatum = 0;
if( psProj->nProjId != 0 && CSLCount(papszNextField) > 0 )
{
nDatum = atoi(papszNextField[0]);
papszNextField++;
}
if( (nDatum == 999 || nDatum == 9999)
&& CSLCount(papszNextField) >= 4 )
{
psProj->nEllipsoidId = (GByte)atoi(papszNextField[0]);
psProj->dDatumShiftX = CPLAtof(papszNextField[1]);
psProj->dDatumShiftY = CPLAtof(papszNextField[2]);
psProj->dDatumShiftZ = CPLAtof(papszNextField[3]);
papszNextField += 4;
if( nDatum == 9999
&& CSLCount(papszNextField) >= 5 )
{
psProj->adDatumParams[0] = CPLAtof(papszNextField[0]);
psProj->adDatumParams[1] = CPLAtof(papszNextField[1]);
psProj->adDatumParams[2] = CPLAtof(papszNextField[2]);
psProj->adDatumParams[3] = CPLAtof(papszNextField[3]);
psProj->adDatumParams[4] = CPLAtof(papszNextField[4]);
papszNextField += 5;
}
}
else if (nDatum != 999 && nDatum != 9999)
{
/*-----------------------------------------------------------------
* Find the datum, and collect it's parameters if possible.
*----------------------------------------------------------------*/
int iDatum;
const MapInfoDatumInfo *psDatumInfo = NULL;
for(iDatum=0; asDatumInfoList[iDatum].nMapInfoDatumID != -1; iDatum++)
{
if( asDatumInfoList[iDatum].nMapInfoDatumID == nDatum )
{
psDatumInfo = asDatumInfoList + iDatum;
break;
}
}
if( asDatumInfoList[iDatum].nMapInfoDatumID == -1
&& nDatum != 999 && nDatum != 9999 )
{
/* use WGS84 */
psDatumInfo = asDatumInfoList + 0;
}
if( psDatumInfo != NULL )
{
psProj->nEllipsoidId = (GByte)psDatumInfo->nEllipsoid;
psProj->nDatumId = (GInt16)psDatumInfo->nMapInfoDatumID;
psProj->dDatumShiftX = psDatumInfo->dfShiftX;
psProj->dDatumShiftY = psDatumInfo->dfShiftY;
psProj->dDatumShiftZ = psDatumInfo->dfShiftZ;
psProj->adDatumParams[0] = psDatumInfo->dfDatumParm0;
psProj->adDatumParams[1] = psDatumInfo->dfDatumParm1;
psProj->adDatumParams[2] = psDatumInfo->dfDatumParm2;
psProj->adDatumParams[3] = psDatumInfo->dfDatumParm3;
psProj->adDatumParams[4] = psDatumInfo->dfDatumParm4;
}
}
/*-----------------------------------------------------------------
* Fetch the units string.
*----------------------------------------------------------------*/
if( CSLCount(papszNextField) > 0 )
{
psProj->nUnitsId = (GByte)TABUnitIdFromString(papszNextField[0]);
papszNextField++;
}
/*-----------------------------------------------------------------
* Finally the projection parameters.
*----------------------------------------------------------------*/
for(int iParam=0; iParam < 6 && CSLCount(papszNextField) > 0; iParam++)
{
psProj->adProjParams[iParam] = CPLAtof(papszNextField[0]);
papszNextField++;
}
CSLDestroy(papszFields);
return 0;
}
OGRErr OGRSpatialReference::importFromOzi(const char *pszDatum,
const char *pszProj,
const char *pszProjParms)
{
Clear();
/* -------------------------------------------------------------------- */
/* Operate on the basis of the projection name. */
/* -------------------------------------------------------------------- */
char **papszProj = CSLTokenizeStringComplex(pszProj, ",", TRUE, TRUE);
char **papszProjParms = CSLTokenizeStringComplex(pszProjParms, ",",
TRUE, TRUE);
char **papszDatum = NULL;
if (CSLCount(papszProj) < 2)
{
goto not_enough_data;
}
if (EQUALN(papszProj[1], "Latitude/Longitude", 18))
{}
else if (EQUALN(papszProj[1], "Mercator", 8))
{
if (CSLCount(papszProjParms) < 6)
goto not_enough_data;
double dfScale = CPLAtof(papszProjParms[3]);
if (papszProjParms[3][0] == 0)
dfScale = 1; /* if unset, default to scale = 1 */
SetMercator(CPLAtof(papszProjParms[1]), CPLAtof(papszProjParms[2]),
dfScale,
CPLAtof(papszProjParms[4]), CPLAtof(papszProjParms[5]));
}
else if (EQUALN(papszProj[1], "Transverse Mercator", 19))
{
if (CSLCount(papszProjParms) < 6)
goto not_enough_data;
SetTM(CPLAtof(papszProjParms[1]), CPLAtof(papszProjParms[2]),
CPLAtof(papszProjParms[3]),
CPLAtof(papszProjParms[4]), CPLAtof(papszProjParms[5]));
}
else if (EQUALN(papszProj[1], "Lambert Conformal Conic", 23))
{
if (CSLCount(papszProjParms) < 8)
goto not_enough_data;
SetLCC(CPLAtof(papszProjParms[6]), CPLAtof(papszProjParms[7]),
CPLAtof(papszProjParms[1]), CPLAtof(papszProjParms[2]),
CPLAtof(papszProjParms[4]), CPLAtof(papszProjParms[5]));
}
else if (EQUALN(papszProj[1], "Sinusoidal", 10))
{
if (CSLCount(papszProjParms) < 6)
goto not_enough_data;
SetSinusoidal(CPLAtof(papszProjParms[2]),
CPLAtof(papszProjParms[4]), CPLAtof(papszProjParms[5]));
}
else if (EQUALN(papszProj[1], "Albers Equal Area", 17))
{
if (CSLCount(papszProjParms) < 8)
goto not_enough_data;
SetACEA(CPLAtof(papszProjParms[6]), CPLAtof(papszProjParms[7]),
CPLAtof(papszProjParms[1]), CPLAtof(papszProjParms[2]),
CPLAtof(papszProjParms[4]), CPLAtof(papszProjParms[5]));
}
else
{
CPLDebug("OSR_Ozi", "Unsupported projection: \"%s\"", papszProj[1]);
SetLocalCS(CPLString().Printf("\"Ozi\" projection \"%s\"",
papszProj[1]));
}
/* -------------------------------------------------------------------- */
/* Try to translate the datum/spheroid. */
/* -------------------------------------------------------------------- */
papszDatum = CSLTokenizeString2(pszDatum, ",",
CSLT_ALLOWEMPTYTOKENS
| CSLT_STRIPLEADSPACES
| CSLT_STRIPENDSPACES);
if (papszDatum == NULL)
goto not_enough_data;
if (!IsLocal())
{
const OZIDatums *paoDatum = aoDatums;
// Search for matching datum
while (paoDatum->pszOziDatum)
{
if (EQUAL(papszDatum[0], paoDatum->pszOziDatum))
{
OGRSpatialReference oGCS;
oGCS.importFromEPSG(paoDatum->nEPSGCode);
CopyGeogCSFrom(&oGCS);
break;
}
paoDatum++;
}
if (!paoDatum->pszOziDatum)
{
CPLError(CE_Warning, CPLE_AppDefined,
"Wrong datum name \"%s\". Setting WGS84 as a fallback.",
papszDatum[0]);
SetWellKnownGeogCS("WGS84");
}
}
/* -------------------------------------------------------------------- */
/* Grid units translation */
/* -------------------------------------------------------------------- */
if (IsLocal() || IsProjected())
SetLinearUnits(SRS_UL_METER, 1.0);
FixupOrdering();
CSLDestroy(papszProj);
CSLDestroy(papszProjParms);
CSLDestroy(papszDatum);
return OGRERR_NONE;
not_enough_data:
CSLDestroy(papszProj);
CSLDestroy(papszProjParms);
CSLDestroy(papszDatum);
return OGRERR_NOT_ENOUGH_DATA;
}
int CPL_STDCALL
GDALSimpleImageWarp( GDALDatasetH hSrcDS, GDALDatasetH hDstDS,
int nBandCount, int *panBandList,
GDALTransformerFunc pfnTransform, void *pTransformArg,
GDALProgressFunc pfnProgress, void *pProgressArg,
char **papszWarpOptions )
{
VALIDATE_POINTER1( hSrcDS, "GDALSimpleImageWarp", 0 );
VALIDATE_POINTER1( hDstDS, "GDALSimpleImageWarp", 0 );
bool bError = false;
/* -------------------------------------------------------------------- */
/* If no bands provided assume we should process all bands. */
/* -------------------------------------------------------------------- */
if( nBandCount == 0 )
{
nBandCount = GDALGetRasterCount( hSrcDS );
if (nBandCount == 0)
{
CPLError(CE_Failure, CPLE_AppDefined,
"No raster band in source dataset");
return FALSE;
}
panBandList = (int *) CPLCalloc(sizeof(int),nBandCount);
for( int iBand = 0; iBand < nBandCount; iBand++ )
panBandList[iBand] = iBand+1;
const int nResult =
GDALSimpleImageWarp( hSrcDS, hDstDS, nBandCount, panBandList,
pfnTransform, pTransformArg,
pfnProgress, pProgressArg,
papszWarpOptions );
CPLFree( panBandList );
return nResult;
}
/* -------------------------------------------------------------------- */
/* Post initial progress. */
/* -------------------------------------------------------------------- */
if( pfnProgress )
{
if( !pfnProgress( 0.0, "", pProgressArg ) )
return FALSE;
}
/* -------------------------------------------------------------------- */
/* Load the source image band(s). */
/* -------------------------------------------------------------------- */
const int nSrcXSize = GDALGetRasterXSize(hSrcDS);
const int nSrcYSize = GDALGetRasterYSize(hSrcDS);
GByte **papabySrcData = static_cast<GByte **>(
CPLCalloc(nBandCount, sizeof(GByte*)) );
bool ok = true;
for( int iBand = 0; iBand < nBandCount; iBand++ )
{
papabySrcData[iBand] = static_cast<GByte *>(
VSI_MALLOC2_VERBOSE(nSrcXSize, nSrcYSize) );
if( papabySrcData[iBand] == NULL )
{
CPLError( CE_Failure, CPLE_OutOfMemory,
"GDALSimpleImageWarp out of memory.\n" );
ok = false;
break;
}
if( GDALRasterIO( GDALGetRasterBand(hSrcDS,panBandList[iBand]), GF_Read,
0, 0, nSrcXSize, nSrcYSize,
papabySrcData[iBand], nSrcXSize, nSrcYSize, GDT_Byte,
0, 0 ) != CE_None )
{
CPLError( CE_Failure, CPLE_FileIO, "GDALSimpleImageWarp "
"GDALRasterIO failure %s ",
CPLGetLastErrorMsg() );
ok = false;
break;
}
}
if( !ok ) {
for( int i=0; i <= nBandCount; i++ )
{
VSIFree(papabySrcData[i]);
}
CPLFree(papabySrcData);
return FALSE;
}
/* -------------------------------------------------------------------- */
/* Check for remap request(s). */
/* -------------------------------------------------------------------- */
GDALSimpleWarpRemapping( nBandCount, papabySrcData, nSrcXSize, nSrcYSize,
papszWarpOptions );
/* -------------------------------------------------------------------- */
/* Allocate scanline buffers for output image. */
/* -------------------------------------------------------------------- */
const int nDstXSize = GDALGetRasterXSize( hDstDS );
const int nDstYSize = GDALGetRasterYSize( hDstDS );
GByte **papabyDstLine = static_cast<GByte **>(
CPLCalloc(nBandCount, sizeof(GByte*)) );
for( int iBand = 0; iBand < nBandCount; iBand++ )
papabyDstLine[iBand] = static_cast<GByte *>(CPLMalloc( nDstXSize ));
/* -------------------------------------------------------------------- */
/* Allocate x,y,z coordinate arrays for transformation ... one */
/* scanlines worth of positions. */
/* -------------------------------------------------------------------- */
double *padfX = static_cast<double *>(
CPLMalloc(sizeof(double) * nDstXSize) );
double *padfY = static_cast<double *>(
CPLMalloc(sizeof(double) * nDstXSize) );
double *padfZ = static_cast<double *>(
CPLMalloc(sizeof(double) * nDstXSize) );
int *pabSuccess = static_cast<int *>( CPLMalloc(sizeof(int) * nDstXSize) );
/* -------------------------------------------------------------------- */
/* Establish the value we will use to initialize the bands. We */
/* default to -1 indicating the initial value should be read */
/* and preserved from the source file, but allow this to be */
/* overridden by passed */
/* option(s). */
/* -------------------------------------------------------------------- */
int * const panBandInit =
static_cast<int *>( CPLCalloc(sizeof(int), nBandCount) );
if( CSLFetchNameValue( papszWarpOptions, "INIT" ) )
{
char **papszTokens =
CSLTokenizeStringComplex( CSLFetchNameValue( papszWarpOptions,
"INIT" ),
" ,", FALSE, FALSE );
const int nTokenCount = CSLCount(papszTokens);
for( int iBand = 0; iBand < nBandCount; iBand++ )
{
if( nTokenCount == 0 )
panBandInit[iBand] = 0;
else
panBandInit[iBand] =
atoi(papszTokens[MIN(iBand,nTokenCount-1)]);
}
CSLDestroy(papszTokens);
}
/* -------------------------------------------------------------------- */
/* Loop over all the scanlines in the output image. */
/* -------------------------------------------------------------------- */
for( int iDstY = 0; iDstY < nDstYSize; iDstY++ )
{
// Clear output buffer to "transparent" value. Should not we
// really be reading from the destination file to support overlay?
for( int iBand = 0; iBand < nBandCount; iBand++ )
{
if( panBandInit[iBand] == -1 )
{
if( GDALRasterIO( GDALGetRasterBand(hDstDS,iBand+1), GF_Read,
0, iDstY, nDstXSize, 1,
papabyDstLine[iBand], nDstXSize, 1, GDT_Byte,
0, 0 ) != CE_None )
{
bError = TRUE;
break;
}
}
else
memset( papabyDstLine[iBand], panBandInit[iBand], nDstXSize );
}
// Set point to transform.
for( int iDstX = 0; iDstX < nDstXSize; iDstX++ )
{
padfX[iDstX] = iDstX + 0.5;
padfY[iDstX] = iDstY + 0.5;
padfZ[iDstX] = 0.0;
}
// Transform the points from destination pixel/line coordinates
// to source pixel/line coordinates.
pfnTransform( pTransformArg, TRUE, nDstXSize,
padfX, padfY, padfZ, pabSuccess );
// Loop over the output scanline.
for( int iDstX = 0; iDstX < nDstXSize; iDstX++ )
{
if( !pabSuccess[iDstX] )
continue;
// We test against the value before casting to avoid the
// problem of asymmetric truncation effects around zero. That is
// -0.5 will be 0 when cast to an int.
if( padfX[iDstX] < 0.0 || padfY[iDstX] < 0.0 )
continue;
const int iSrcX = static_cast<int>( padfX[iDstX] );
const int iSrcY = static_cast<int>( padfY[iDstX] );
if( iSrcX >= nSrcXSize || iSrcY >= nSrcYSize )
continue;
const int iSrcOffset = iSrcX + iSrcY * nSrcXSize;
for( int iBand = 0; iBand < nBandCount; iBand++ )
papabyDstLine[iBand][iDstX] = papabySrcData[iBand][iSrcOffset];
}
// Write scanline to disk.
for( int iBand = 0; iBand < nBandCount; iBand++ )
{
if( GDALRasterIO( GDALGetRasterBand(hDstDS,iBand+1), GF_Write,
0, iDstY, nDstXSize, 1,
papabyDstLine[iBand], nDstXSize, 1, GDT_Byte, 0, 0 ) != CE_None )
{
bError = TRUE;
break;
}
}
if( pfnProgress != NULL )
{
if( !pfnProgress( (iDstY+1) / (double) nDstYSize,
"", pProgressArg ) )
{
CPLError( CE_Failure, CPLE_UserInterrupt, "User terminated" );
bError = TRUE;
break;
}
}
}
/* -------------------------------------------------------------------- */
/* Cleanup working buffers. */
/* -------------------------------------------------------------------- */
for( int iBand = 0; iBand < nBandCount; iBand++ )
{
CPLFree( papabyDstLine[iBand] );
CPLFree( papabySrcData[iBand] );
}
CPLFree( panBandInit );
CPLFree( papabyDstLine );
CPLFree( papabySrcData );
CPLFree( padfX );
CPLFree( padfY );
CPLFree( padfZ );
CPLFree( pabSuccess );
return !bError;
}
int GDALJP2Metadata::ParseGMLCoverageDesc()
{
/* -------------------------------------------------------------------- */
/* Do we have an XML doc that is apparently a coverage */
/* description? */
/* -------------------------------------------------------------------- */
const char *pszCoverage = CSLFetchNameValue( papszGMLMetadata,
"gml.root-instance" );
if( pszCoverage == NULL )
return FALSE;
CPLDebug( "GDALJP2Metadata", "Found GML Box:\n%s", pszCoverage );
/* -------------------------------------------------------------------- */
/* Try parsing the XML. Wipe any namespace prefixes. */
/* -------------------------------------------------------------------- */
CPLXMLNode *psXML = CPLParseXMLString( pszCoverage );
if( psXML == NULL )
return FALSE;
CPLStripXMLNamespace( psXML, NULL, TRUE );
/* -------------------------------------------------------------------- */
/* Isolate RectifiedGrid. Eventually we will need to support */
/* other georeferencing objects. */
/* -------------------------------------------------------------------- */
CPLXMLNode *psRG = CPLSearchXMLNode( psXML, "=RectifiedGrid" );
CPLXMLNode *psOriginPoint = NULL;
const char *pszOffset1=NULL, *pszOffset2=NULL;
if( psRG != NULL )
{
psOriginPoint = CPLGetXMLNode( psRG, "origin.Point" );
CPLXMLNode *psOffset1 = CPLGetXMLNode( psRG, "offsetVector" );
if( psOffset1 != NULL )
{
pszOffset1 = CPLGetXMLValue( psOffset1, "", NULL );
pszOffset2 = CPLGetXMLValue( psOffset1->psNext, "=offsetVector",
NULL );
}
}
/* -------------------------------------------------------------------- */
/* If we are missing any of the origin or 2 offsets then give up. */
/* -------------------------------------------------------------------- */
if( psOriginPoint == NULL || pszOffset1 == NULL || pszOffset2 == NULL )
{
CPLDestroyXMLNode( psXML );
return FALSE;
}
/* -------------------------------------------------------------------- */
/* Extract origin location. */
/* -------------------------------------------------------------------- */
OGRPoint *poOriginGeometry = NULL;
const char *pszSRSName = NULL;
if( psOriginPoint != NULL )
{
poOriginGeometry = (OGRPoint *)
OGR_G_CreateFromGMLTree( psOriginPoint );
if( poOriginGeometry != NULL
&& wkbFlatten(poOriginGeometry->getGeometryType()) != wkbPoint )
{
delete poOriginGeometry;
poOriginGeometry = NULL;
}
// SRS?
pszSRSName = CPLGetXMLValue( psOriginPoint, "srsName", NULL );
}
/* -------------------------------------------------------------------- */
/* Extract offset(s) */
/* -------------------------------------------------------------------- */
char **papszOffset1Tokens = NULL;
char **papszOffset2Tokens = NULL;
int bSuccess = FALSE;
papszOffset1Tokens =
CSLTokenizeStringComplex( pszOffset1, " ,", FALSE, FALSE );
papszOffset2Tokens =
CSLTokenizeStringComplex( pszOffset2, " ,", FALSE, FALSE );
if( CSLCount(papszOffset1Tokens) >= 2
&& CSLCount(papszOffset2Tokens) >= 2
&& poOriginGeometry != NULL )
{
adfGeoTransform[0] = poOriginGeometry->getX();
adfGeoTransform[1] = atof(papszOffset1Tokens[0]);
adfGeoTransform[2] = atof(papszOffset2Tokens[0]);
adfGeoTransform[3] = poOriginGeometry->getY();
adfGeoTransform[4] = atof(papszOffset1Tokens[1]);
adfGeoTransform[5] = atof(papszOffset2Tokens[1]);
// offset from center of pixel.
adfGeoTransform[0] -= adfGeoTransform[1]*0.5;
adfGeoTransform[0] -= adfGeoTransform[2]*0.5;
adfGeoTransform[3] -= adfGeoTransform[4]*0.5;
adfGeoTransform[3] -= adfGeoTransform[5]*0.5;
bSuccess = TRUE;
bHaveGeoTransform = TRUE;
}
CSLDestroy( papszOffset1Tokens );
CSLDestroy( papszOffset2Tokens );
if( poOriginGeometry != NULL )
delete poOriginGeometry;
/* -------------------------------------------------------------------- */
/* If we still don't have an srsName, check for it on the */
/* boundedBy Envelope. Some products */
/* (ie. EuropeRasterTile23.jpx) use this as the only srsName */
/* delivery vehicle. */
/* -------------------------------------------------------------------- */
if( pszSRSName == NULL )
{
pszSRSName =
CPLGetXMLValue( psXML,
"=FeatureCollection.boundedBy.Envelope.srsName",
NULL );
}
/* -------------------------------------------------------------------- */
/* If we have gotten a geotransform, then try to interprete the */
/* srsName. */
/* -------------------------------------------------------------------- */
int bNeedAxisFlip = FALSE;
if( bSuccess && pszSRSName != NULL
&& (pszProjection == NULL || strlen(pszProjection) == 0) )
{
OGRSpatialReference oSRS;
if( EQUALN(pszSRSName,"epsg:",5) )
{
if( oSRS.SetFromUserInput( pszSRSName ) == OGRERR_NONE )
oSRS.exportToWkt( &pszProjection );
}
else if( EQUALN(pszSRSName,"urn:",4)
&& strstr(pszSRSName,":def:") != NULL
&& oSRS.importFromURN(pszSRSName) == OGRERR_NONE )
{
const char *pszCode = strrchr(pszSRSName,':') + 1;
oSRS.exportToWkt( &pszProjection );
// Per #2131
if( atoi(pszCode) >= 4000 && atoi(pszCode) <= 4999 )
{
CPLDebug( "GMLJP2", "Request axis flip for SRS=%s",
pszSRSName );
bNeedAxisFlip = TRUE;
}
}
else if( !GMLSRSLookup( pszSRSName ) )
{
CPLDebug( "GDALJP2Metadata",
"Unable to evaluate SRSName=%s",
pszSRSName );
}
}
if( pszProjection )
CPLDebug( "GDALJP2Metadata",
"Got projection from GML box: %s",
pszProjection );
CPLDestroyXMLNode( psXML );
psXML = NULL;
/* -------------------------------------------------------------------- */
/* Do we need to flip the axes? */
/* -------------------------------------------------------------------- */
if( bNeedAxisFlip
&& CSLTestBoolean( CPLGetConfigOption( "GDAL_IGNORE_AXIS_ORIENTATION",
"FALSE" ) ) )
{
bNeedAxisFlip = FALSE;
CPLDebug( "GMLJP2", "Supressed axis flipping based on GDAL_IGNORE_AXIS_ORIENTATION." );
}
if( bNeedAxisFlip )
{
double dfTemp;
CPLDebug( "GMLJP2",
"Flipping axis orientation in GMLJP2 coverage description." );
dfTemp = adfGeoTransform[0];
adfGeoTransform[0] = adfGeoTransform[3];
adfGeoTransform[3] = dfTemp;
dfTemp = adfGeoTransform[1];
adfGeoTransform[1] = adfGeoTransform[4];
adfGeoTransform[4] = dfTemp;
dfTemp = adfGeoTransform[2];
adfGeoTransform[2] = adfGeoTransform[5];
adfGeoTransform[5] = dfTemp;
}
return pszProjection != NULL && bSuccess;
}
CPLErr VRTWarpedDataset::ProcessBlock( int iBlockX, int iBlockY )
{
if( poWarper == NULL )
return CE_Failure;
const GDALWarpOptions *psWO = poWarper->GetOptions();
/* -------------------------------------------------------------------- */
/* Allocate block of memory large enough to hold all the bands */
/* for this block. */
/* -------------------------------------------------------------------- */
int iBand;
GByte *pabyDstBuffer;
int nDstBufferSize;
int nWordSize = (GDALGetDataTypeSize(psWO->eWorkingDataType) / 8);
// FIXME? : risk of overflow in multiplication if nBlockXSize or nBlockYSize are very large
nDstBufferSize = nBlockXSize * nBlockYSize * psWO->nBandCount * nWordSize;
pabyDstBuffer = (GByte *) VSIMalloc(nDstBufferSize);
if( pabyDstBuffer == NULL )
{
CPLError( CE_Failure, CPLE_OutOfMemory,
"Out of memory allocating %d byte buffer in VRTWarpedDataset::ProcessBlock()",
nDstBufferSize );
return CE_Failure;
}
memset( pabyDstBuffer, 0, nDstBufferSize );
/* -------------------------------------------------------------------- */
/* Process INIT_DEST option to initialize the buffer prior to */
/* warping into it. */
/* NOTE:The following code is 99% similar in gdalwarpoperation.cpp and */
/* vrtwarped.cpp. Be careful to keep it in sync ! */
/* -------------------------------------------------------------------- */
const char *pszInitDest = CSLFetchNameValue( psWO->papszWarpOptions,
"INIT_DEST" );
if( pszInitDest != NULL && !EQUAL(pszInitDest, "") )
{
char **papszInitValues =
CSLTokenizeStringComplex( pszInitDest, ",", FALSE, FALSE );
int nInitCount = CSLCount(papszInitValues);
for( iBand = 0; iBand < psWO->nBandCount; iBand++ )
{
double adfInitRealImag[2];
GByte *pBandData;
int nBandSize = nBlockXSize * nBlockYSize * nWordSize;
const char *pszBandInit = papszInitValues[MIN(iBand,nInitCount-1)];
if( EQUAL(pszBandInit,"NO_DATA")
&& psWO->padfDstNoDataReal != NULL )
{
adfInitRealImag[0] = psWO->padfDstNoDataReal[iBand];
adfInitRealImag[1] = psWO->padfDstNoDataImag[iBand];
}
else
{
CPLStringToComplex( pszBandInit,
adfInitRealImag + 0, adfInitRealImag + 1);
}
pBandData = ((GByte *) pabyDstBuffer) + iBand * nBandSize;
if( psWO->eWorkingDataType == GDT_Byte )
memset( pBandData,
MAX(0,MIN(255,(int)adfInitRealImag[0])),
nBandSize);
else if( adfInitRealImag[0] == 0.0 && adfInitRealImag[1] == 0 )
{
memset( pBandData, 0, nBandSize );
}
else if( adfInitRealImag[1] == 0.0 )
{
GDALCopyWords( &adfInitRealImag, GDT_Float64, 0,
pBandData,psWO->eWorkingDataType,nWordSize,
nBlockXSize * nBlockYSize );
}
else
{
GDALCopyWords( &adfInitRealImag, GDT_CFloat64, 0,
pBandData,psWO->eWorkingDataType,nWordSize,
nBlockXSize * nBlockYSize );
}
}
CSLDestroy( papszInitValues );
}
/* -------------------------------------------------------------------- */
/* Warp into this buffer. */
/* -------------------------------------------------------------------- */
CPLErr eErr;
eErr =
poWarper->WarpRegionToBuffer(
iBlockX * nBlockXSize, iBlockY * nBlockYSize,
nBlockXSize, nBlockYSize,
pabyDstBuffer, psWO->eWorkingDataType );
if( eErr != CE_None )
{
VSIFree( pabyDstBuffer );
return eErr;
}
/* -------------------------------------------------------------------- */
/* Copy out into cache blocks for each band. */
/* -------------------------------------------------------------------- */
for( iBand = 0; iBand < psWO->nBandCount; iBand++ )
{
GDALRasterBand *poBand;
GDALRasterBlock *poBlock;
poBand = GetRasterBand(iBand+1);
poBlock = poBand->GetLockedBlockRef( iBlockX, iBlockY, TRUE );
CPLAssert( poBlock != NULL && poBlock->GetDataRef() != NULL );
GDALCopyWords( pabyDstBuffer + iBand*nBlockXSize*nBlockYSize*nWordSize,
psWO->eWorkingDataType, nWordSize,
poBlock->GetDataRef(),
poBlock->GetDataType(),
GDALGetDataTypeSize(poBlock->GetDataType())/8,
nBlockXSize * nBlockYSize );
poBlock->DropLock();
}
VSIFree( pabyDstBuffer );
return CE_None;
}
void ERSDataset::ReadGCPs()
{
const char *pszCP =
poHeader->Find( "RasterInfo.WarpControl.ControlPoints", NULL );
if( pszCP == NULL )
return;
/* -------------------------------------------------------------------- */
/* Parse the control points. They will look something like: */
/* */
/* "1035" Yes No 2344.650885 3546.419458 483270.73 3620906.21 3.105 */
/* -------------------------------------------------------------------- */
char **papszTokens = CSLTokenizeStringComplex( pszCP, "{ \t}", TRUE,FALSE);
int nItemsPerLine;
int nItemCount = CSLCount(papszTokens);
/* -------------------------------------------------------------------- */
/* Work out if we have elevation values or not. */
/* -------------------------------------------------------------------- */
if( nItemCount == 7 )
nItemsPerLine = 7;
else if( nItemCount == 8 )
nItemsPerLine = 8;
else if( nItemCount < 14 )
{
CPLAssert( FALSE );
return;
}
else if( EQUAL(papszTokens[8],"Yes") || EQUAL(papszTokens[8],"No") )
nItemsPerLine = 7;
else if( EQUAL(papszTokens[9],"Yes") || EQUAL(papszTokens[9],"No") )
nItemsPerLine = 8;
else
{
CPLAssert( FALSE );
return;
}
/* -------------------------------------------------------------------- */
/* Setup GCPs. */
/* -------------------------------------------------------------------- */
int iGCP;
CPLAssert( nGCPCount == 0 );
nGCPCount = nItemCount / nItemsPerLine;
pasGCPList = (GDAL_GCP *) CPLCalloc(nGCPCount,sizeof(GDAL_GCP));
GDALInitGCPs( nGCPCount, pasGCPList );
for( iGCP = 0; iGCP < nGCPCount; iGCP++ )
{
GDAL_GCP *psGCP = pasGCPList + iGCP;
CPLFree( psGCP->pszId );
psGCP->pszId = CPLStrdup(papszTokens[iGCP*nItemsPerLine+0]);
psGCP->dfGCPPixel = atof(papszTokens[iGCP*nItemsPerLine+3]);
psGCP->dfGCPLine = atof(papszTokens[iGCP*nItemsPerLine+4]);
psGCP->dfGCPX = atof(papszTokens[iGCP*nItemsPerLine+5]);
psGCP->dfGCPY = atof(papszTokens[iGCP*nItemsPerLine+6]);
if( nItemsPerLine == 8 )
psGCP->dfGCPZ = atof(papszTokens[iGCP*nItemsPerLine+7]);
}
CSLDestroy( papszTokens );
/* -------------------------------------------------------------------- */
/* Parse the GCP projection. */
/* -------------------------------------------------------------------- */
OGRSpatialReference oSRS;
CPLString osProjection = poHeader->Find(
"RasterInfo.WarpControl.CoordinateSpace.Projection", "RAW" );
CPLString osDatum = poHeader->Find(
"RasterInfo.WarpControl.CoordinateSpace.Datum", "WGS84" );
CPLString osUnits = poHeader->Find(
"RasterInfo.WarpControl.CoordinateSpace.Units", "METERS" );
oSRS.importFromERM( osProjection, osDatum, osUnits );
CPLFree( pszGCPProjection );
oSRS.exportToWkt( &pszGCPProjection );
}
int ParseGMLCoordinates( CPLXMLNode *psGeomNode, OGRGeometry *poGeometry )
{
CPLXMLNode *psCoordinates = FindBareXMLChild( psGeomNode, "coordinates" );
int iCoord = 0;
/* -------------------------------------------------------------------- */
/* Handle <coordinates> case. */
/* -------------------------------------------------------------------- */
if( psCoordinates != NULL )
{
const char *pszCoordString = GetElementText( psCoordinates );
if( pszCoordString == NULL )
{
CPLError( CE_Failure, CPLE_AppDefined,
"<coordinates> element missing value." );
return FALSE;
}
while( *pszCoordString != '\0' )
{
double dfX, dfY, dfZ = 0.0;
int nDimension = 2;
// parse out 2 or 3 tuple.
dfX = atof( pszCoordString );
while( *pszCoordString != '\0'
&& *pszCoordString != ','
&& !isspace(*pszCoordString) )
pszCoordString++;
if( *pszCoordString == '\0' || isspace(*pszCoordString) )
{
CPLError( CE_Failure, CPLE_AppDefined,
"Corrupt <coordinates> value." );
return FALSE;
}
pszCoordString++;
dfY = atof( pszCoordString );
while( *pszCoordString != '\0'
&& *pszCoordString != ','
&& !isspace(*pszCoordString) )
pszCoordString++;
if( *pszCoordString == ',' )
{
pszCoordString++;
dfZ = atof( pszCoordString );
nDimension = 3;
while( *pszCoordString != '\0'
&& *pszCoordString != ','
&& !isspace(*pszCoordString) )
pszCoordString++;
}
while( isspace(*pszCoordString) )
pszCoordString++;
if( !AddPoint( poGeometry, dfX, dfY, dfZ, nDimension ) )
return FALSE;
iCoord++;
}
return iCoord > 0;
}
/* -------------------------------------------------------------------- */
/* Is this a "pos"? I think this is a GML 3 construct. */
/* -------------------------------------------------------------------- */
CPLXMLNode *psPos = FindBareXMLChild( psGeomNode, "pos" );
if( psPos != NULL )
{
char **papszTokens = CSLTokenizeStringComplex(
GetElementText( psPos ), " ,", FALSE, FALSE );
int bSuccess = FALSE;
if( CSLCount( papszTokens ) > 2 )
{
bSuccess = AddPoint( poGeometry,
atof(papszTokens[0]),
atof(papszTokens[1]),
atof(papszTokens[2]), 3 );
}
else if( CSLCount( papszTokens ) > 1 )
{
bSuccess = AddPoint( poGeometry,
atof(papszTokens[0]),
atof(papszTokens[1]),
0.0, 2 );
}
else
{
CPLError( CE_Failure, CPLE_AppDefined,
"Did not get 2+ values in <gml:pos>%s</gml:pos> tuple.",
GetElementText( psPos ) );
}
CSLDestroy( papszTokens );
return bSuccess;
}
/* -------------------------------------------------------------------- */
/* Handle form with a list of <coord> items each with an <X>, */
/* and <Y> element. */
/* -------------------------------------------------------------------- */
CPLXMLNode *psCoordNode;
for( psCoordNode = psGeomNode->psChild;
psCoordNode != NULL;
psCoordNode = psCoordNode->psNext )
{
if( psCoordNode->eType != CXT_Element
|| !EQUAL(BareGMLElement(psCoordNode->pszValue),"coord") )
continue;
CPLXMLNode *psXNode, *psYNode, *psZNode;
double dfX, dfY, dfZ = 0.0;
int nDimension = 2;
psXNode = FindBareXMLChild( psCoordNode, "X" );
psYNode = FindBareXMLChild( psCoordNode, "Y" );
psZNode = FindBareXMLChild( psCoordNode, "Z" );
if( psXNode == NULL || psYNode == NULL
|| GetElementText(psXNode) == NULL
|| GetElementText(psYNode) == NULL
|| (psZNode != NULL && GetElementText(psZNode) == NULL) )
{
CPLError( CE_Failure, CPLE_AppDefined,
"Corrupt <coord> element, missing <X> or <Y> element?" );
return FALSE;
}
dfX = atof( GetElementText(psXNode) );
dfY = atof( GetElementText(psYNode) );
if( psZNode != NULL && GetElementText(psZNode) != NULL )
{
dfZ = atof( GetElementText(psZNode) );
nDimension = 3;
}
if( !AddPoint( poGeometry, dfX, dfY, dfZ, nDimension ) )
return FALSE;
iCoord++;
}
return iCoord > 0.0;
}
void BAGDataset::LoadMetadata()
{
/* -------------------------------------------------------------------- */
/* Load the metadata from the file. */
/* -------------------------------------------------------------------- */
hid_t hMDDS = H5Dopen( hHDF5, "/BAG_root/metadata" );
hid_t datatype = H5Dget_type( hMDDS );
hid_t dataspace = H5Dget_space( hMDDS );
hid_t native = H5Tget_native_type( datatype, H5T_DIR_ASCEND );
hsize_t dims[3], maxdims[3];
H5Sget_simple_extent_dims( dataspace, dims, maxdims );
pszXMLMetadata = (char *) CPLCalloc(dims[0]+1,1);
H5Dread( hMDDS, native, H5S_ALL, dataspace, H5P_DEFAULT, pszXMLMetadata );
H5Sclose( dataspace );
H5Tclose( datatype );
H5Dclose( hMDDS );
if( strlen(pszXMLMetadata) == 0 )
return;
/* -------------------------------------------------------------------- */
/* Try to get the geotransform. */
/* -------------------------------------------------------------------- */
CPLXMLNode *psRoot = CPLParseXMLString( pszXMLMetadata );
if( psRoot == NULL )
return;
CPLStripXMLNamespace( psRoot, NULL, TRUE );
CPLXMLNode *psGeo = CPLSearchXMLNode( psRoot, "=MD_Georectified" );
if( psGeo != NULL )
{
char **papszCornerTokens =
CSLTokenizeStringComplex(
CPLGetXMLValue( psGeo, "cornerPoints.Point.coordinates", "" ),
" ,", FALSE, FALSE );
if( CSLCount(papszCornerTokens ) == 4 )
{
double dfLLX = atof( papszCornerTokens[0] );
double dfLLY = atof( papszCornerTokens[1] );
double dfURX = atof( papszCornerTokens[2] );
double dfURY = atof( papszCornerTokens[3] );
adfGeoTransform[0] = dfLLX;
adfGeoTransform[1] = (dfURX - dfLLX) / (GetRasterXSize()-1);
adfGeoTransform[3] = dfURY;
adfGeoTransform[5] = (dfLLY - dfURY) / (GetRasterYSize()-1);
adfGeoTransform[0] -= adfGeoTransform[1] * 0.5;
adfGeoTransform[3] -= adfGeoTransform[5] * 0.5;
}
CSLDestroy( papszCornerTokens );
}
CPLDestroyXMLNode( psRoot );
/* -------------------------------------------------------------------- */
/* Try to get the coordinate system. */
/* -------------------------------------------------------------------- */
OGRSpatialReference oSRS;
if( OGR_SRS_ImportFromISO19115( &oSRS, pszXMLMetadata )
== OGRERR_NONE )
{
oSRS.exportToWkt( &pszProjection );
}
}
GDALDataset *SAGADataset::Open( GDALOpenInfo * poOpenInfo )
{
/* -------------------------------------------------------------------- */
/* We assume the user is pointing to the binary (ie. .sdat) file. */
/* -------------------------------------------------------------------- */
if( !EQUAL(CPLGetExtension( poOpenInfo->pszFilename ), "sdat"))
{
return NULL;
}
CPLString osPath = CPLGetPath( poOpenInfo->pszFilename );
CPLString osName = CPLGetBasename( poOpenInfo->pszFilename );
CPLString osHDRFilename;
osHDRFilename = CPLFormCIFilename( osPath, osName, ".sgrd" );
VSILFILE *fp;
fp = VSIFOpenL( osHDRFilename, "r" );
if( fp == NULL )
{
return NULL;
}
/* -------------------------------------------------------------------- */
/* Is this file a SAGA header file? Read a few lines of text */
/* searching for something starting with nrows or ncols. */
/* -------------------------------------------------------------------- */
const char *pszLine;
int nRows = -1, nCols = -1;
double dXmin = 0.0, dYmin = 0.0, dCellsize = 0.0, dNoData = 0.0, dZFactor = 0.0;
int nLineCount = 0;
char szDataFormat[20] = "DOUBLE";
char szByteOrderBig[10] = "FALSE";
char szTopToBottom[10] = "FALSE";
char **papszHDR = NULL;
while( (pszLine = CPLReadLineL( fp )) != NULL )
{
char **papszTokens;
nLineCount++;
if( nLineCount > 50 || strlen(pszLine) > 1000 )
break;
papszHDR = CSLAddString( papszHDR, pszLine );
papszTokens = CSLTokenizeStringComplex( pszLine, " =", TRUE, FALSE );
if( CSLCount( papszTokens ) < 2 )
{
CSLDestroy( papszTokens );
continue;
}
if( EQUALN(papszTokens[0],"CELLCOUNT_X",strlen("CELLCOUNT_X")) )
nCols = atoi(papszTokens[1]);
else if( EQUALN(papszTokens[0],"CELLCOUNT_Y",strlen("CELLCOUNT_Y")) )
nRows = atoi(papszTokens[1]);
else if( EQUALN(papszTokens[0],"POSITION_XMIN",strlen("POSITION_XMIN")) )
dXmin = CPLAtofM(papszTokens[1]);
else if( EQUALN(papszTokens[0],"POSITION_YMIN",strlen("POSITION_YMIN")) )
dYmin = CPLAtofM(papszTokens[1]);
else if( EQUALN(papszTokens[0],"CELLSIZE",strlen("CELLSIZE")) )
dCellsize = CPLAtofM(papszTokens[1]);
else if( EQUALN(papszTokens[0],"NODATA_VALUE",strlen("NODATA_VALUE")) )
dNoData = CPLAtofM(papszTokens[1]);
else if( EQUALN(papszTokens[0],"DATAFORMAT",strlen("DATAFORMAT")) )
strncpy( szDataFormat, papszTokens[1], sizeof(szDataFormat)-1 );
else if( EQUALN(papszTokens[0],"BYTEORDER_BIG",strlen("BYTEORDER_BIG")) )
strncpy( szByteOrderBig, papszTokens[1], sizeof(szByteOrderBig)-1 );
else if( EQUALN(papszTokens[0],"TOPTOBOTTOM",strlen("TOPTOBOTTOM")) )
strncpy( szTopToBottom, papszTokens[1], sizeof(szTopToBottom)-1 );
else if( EQUALN(papszTokens[0],"Z_FACTOR",strlen("Z_FACTOR")) )
dZFactor = CPLAtofM(papszTokens[1]);
CSLDestroy( papszTokens );
}
VSIFCloseL( fp );
CSLDestroy( papszHDR );
/* -------------------------------------------------------------------- */
/* Did we get the required keywords? If not we return with */
/* this never having been considered to be a match. This isn't */
/* an error! */
/* -------------------------------------------------------------------- */
if( nRows == -1 || nCols == -1 )
{
return NULL;
}
if (!GDALCheckDatasetDimensions(nCols, nRows))
{
return NULL;
}
if( EQUALN(szTopToBottom,"TRUE",strlen("TRUE")) )
{
CPLError( CE_Failure, CPLE_AppDefined,
"Currently the SAGA Binary Grid driver does not support\n"
"SAGA grids written TOPTOBOTTOM.\n");
return NULL;
}
if( dZFactor != 1.0)
{
CPLError( CE_Warning, CPLE_AppDefined,
"Currently the SAGA Binary Grid driver does not support\n"
"ZFACTORs other than 1.\n");
}
/* -------------------------------------------------------------------- */
/* Create a corresponding GDALDataset. */
/* -------------------------------------------------------------------- */
SAGADataset *poDS = new SAGADataset();
poDS->eAccess = poOpenInfo->eAccess;
if( poOpenInfo->eAccess == GA_ReadOnly )
poDS->fp = VSIFOpenL( poOpenInfo->pszFilename, "rb" );
else
poDS->fp = VSIFOpenL( poOpenInfo->pszFilename, "r+b" );
if( poDS->fp == NULL )
{
delete poDS;
CPLError( CE_Failure, CPLE_OpenFailed,
"VSIFOpenL(%s) failed unexpectedly.",
poOpenInfo->pszFilename );
return NULL;
}
poDS->nRasterXSize = nCols;
poDS->nRasterYSize = nRows;
SAGARasterBand *poBand = new SAGARasterBand( poDS, 1 );
/* -------------------------------------------------------------------- */
/* Figure out the byte order. */
/* -------------------------------------------------------------------- */
if( EQUALN(szByteOrderBig,"TRUE",strlen("TRUE")) )
poBand->m_ByteOrder = 1;
else if( EQUALN(szByteOrderBig,"FALSE",strlen("FALSE")) )
poBand->m_ByteOrder = 0;
/* -------------------------------------------------------------------- */
/* Figure out the data type. */
/* -------------------------------------------------------------------- */
if( EQUAL(szDataFormat,"BIT") )
{
poBand->SetDataType(GDT_Byte);
poBand->m_nBits = 8;
}
else if( EQUAL(szDataFormat,"BYTE_UNSIGNED") )
{
poBand->SetDataType(GDT_Byte);
poBand->m_nBits = 8;
}
else if( EQUAL(szDataFormat,"BYTE") )
{
poBand->SetDataType(GDT_Byte);
poBand->m_nBits = 8;
}
else if( EQUAL(szDataFormat,"SHORTINT_UNSIGNED") )
{
poBand->SetDataType(GDT_UInt16);
poBand->m_nBits = 16;
}
else if( EQUAL(szDataFormat,"SHORTINT") )
{
poBand->SetDataType(GDT_Int16);
poBand->m_nBits = 16;
}
else if( EQUAL(szDataFormat,"INTEGER_UNSIGNED") )
{
poBand->SetDataType(GDT_UInt32);
poBand->m_nBits = 32;
}
else if( EQUAL(szDataFormat,"INTEGER") )
{
poBand->SetDataType(GDT_Int32);
poBand->m_nBits = 32;
}
else if( EQUAL(szDataFormat,"FLOAT") )
{
poBand->SetDataType(GDT_Float32);
poBand->m_nBits = 32;
}
else if( EQUAL(szDataFormat,"DOUBLE") )
{
poBand->SetDataType(GDT_Float64);
poBand->m_nBits = 64;
}
else
{
CPLError( CE_Failure, CPLE_NotSupported,
"SAGA driver does not support the dataformat %s.",
szDataFormat );
delete poBand;
delete poDS;
return NULL;
}
/* -------------------------------------------------------------------- */
/* Save band information */
/* -------------------------------------------------------------------- */
poBand->m_Xmin = dXmin;
poBand->m_Ymin = dYmin;
poBand->m_NoData = dNoData;
poBand->m_Cellsize = dCellsize;
poBand->m_Rows = nRows;
poBand->m_Cols = nCols;
poDS->SetBand( 1, poBand );
/* -------------------------------------------------------------------- */
/* Initialize any PAM information. */
/* -------------------------------------------------------------------- */
poDS->SetDescription( poOpenInfo->pszFilename );
poDS->TryLoadXML();
/* -------------------------------------------------------------------- */
/* Check for a .prj file. */
/* -------------------------------------------------------------------- */
const char *pszPrjFilename = CPLFormCIFilename( osPath, osName, "prj" );
fp = VSIFOpenL( pszPrjFilename, "r" );
if( fp != NULL )
{
char **papszLines;
OGRSpatialReference oSRS;
VSIFCloseL( fp );
papszLines = CSLLoad( pszPrjFilename );
if( oSRS.importFromESRI( papszLines ) == OGRERR_NONE )
{
CPLFree( poDS->pszProjection );
oSRS.exportToWkt( &(poDS->pszProjection) );
}
CSLDestroy( papszLines );
}
/* -------------------------------------------------------------------- */
/* Check for external overviews. */
/* -------------------------------------------------------------------- */
poDS->oOvManager.Initialize( poDS, poOpenInfo->pszFilename, poOpenInfo->papszSiblingFiles );
return poDS;
}
int S57ClassRegistrar::LoadInfo( const char * pszDirectory,
const char * pszProfile,
int bReportErr )
{
FILE *fp;
char szTargetFile[1024];
if( pszDirectory == NULL )
pszDirectory = CPLGetConfigOption("S57_CSV",NULL);
/* ==================================================================== */
/* Read the s57objectclasses file. */
/* ==================================================================== */
if( pszProfile == NULL )
pszProfile = CPLGetConfigOption( "S57_PROFILE", "" );
if( EQUAL(pszProfile, "Additional_Military_Layers") )
{
sprintf( szTargetFile, "s57objectclasses_%s.csv", "aml" );
}
else if ( EQUAL(pszProfile, "Inland_Waterways") )
{
sprintf( szTargetFile, "s57objectclasses_%s.csv", "iw" );
}
else if( strlen(pszProfile) > 0 )
{
sprintf( szTargetFile, "s57objectclasses_%s.csv", pszProfile );
}
else
{
strcpy( szTargetFile, "s57objectclasses.csv" );
}
if( !FindFile( szTargetFile, pszDirectory, bReportErr, &fp ) )
return FALSE;
/* -------------------------------------------------------------------- */
/* Skip the line defining the column titles. */
/* -------------------------------------------------------------------- */
const char * pszLine = ReadLine( fp );
if( !EQUAL(pszLine,
"\"Code\",\"ObjectClass\",\"Acronym\",\"Attribute_A\","
"\"Attribute_B\",\"Attribute_C\",\"Class\",\"Primitives\"" ) )
{
CPLError( CE_Failure, CPLE_AppDefined,
"s57objectclasses columns don't match expected format!\n" );
return FALSE;
}
/* -------------------------------------------------------------------- */
/* Read and form string list. */
/* -------------------------------------------------------------------- */
CSLDestroy( papszClassesInfo );
papszClassesInfo = (char **) CPLCalloc(sizeof(char *),MAX_CLASSES);
nClasses = 0;
while( nClasses < MAX_CLASSES
&& (pszLine = ReadLine(fp)) != NULL )
{
papszClassesInfo[nClasses] = CPLStrdup(pszLine);
if( papszClassesInfo[nClasses] == NULL )
break;
nClasses++;
}
if( nClasses == MAX_CLASSES )
CPLError( CE_Warning, CPLE_AppDefined,
"MAX_CLASSES exceeded in S57ClassRegistrar::LoadInfo().\n" );
/* -------------------------------------------------------------------- */
/* Cleanup, and establish state. */
/* -------------------------------------------------------------------- */
if( fp != NULL )
VSIFClose( fp );
iCurrentClass = -1;
if( nClasses == 0 )
return FALSE;
/* ==================================================================== */
/* Read the attributes list. */
/* ==================================================================== */
if( EQUAL(pszProfile, "Additional_Military_Layers") )
{
sprintf( szTargetFile, "s57attributes_%s.csv", "aml" );
}
else if ( EQUAL(pszProfile, "Inland_Waterways") )
{
sprintf( szTargetFile, "s57attributes_%s.csv", "iw" );
}
else if( strlen(pszProfile) > 0 )
{
sprintf( szTargetFile, "s57attributes_%s.csv", pszProfile );
}
else
{
strcpy( szTargetFile, "s57attributes.csv" );
}
if( !FindFile( szTargetFile, pszDirectory, bReportErr, &fp ) )
return FALSE;
/* -------------------------------------------------------------------- */
/* Skip the line defining the column titles. */
/* -------------------------------------------------------------------- */
pszLine = ReadLine( fp );
if( !EQUAL(pszLine,
"\"Code\",\"Attribute\",\"Acronym\",\"Attributetype\",\"Class\"") )
{
CPLError( CE_Failure, CPLE_AppDefined,
"s57attributes columns don't match expected format!\n" );
return FALSE;
}
/* -------------------------------------------------------------------- */
/* Prepare arrays for the per-attribute information. */
/* -------------------------------------------------------------------- */
nAttrMax = MAX_ATTRIBUTES-1;
papszAttrNames = (char **) CPLCalloc(sizeof(char *),MAX_ATTRIBUTES);
papszAttrAcronym = (char **) CPLCalloc(sizeof(char *),MAX_ATTRIBUTES);
//papapszAttrValues = (char ***) CPLCalloc(sizeof(char **),MAX_ATTRIBUTES);
pachAttrType = (char *) CPLCalloc(sizeof(char),MAX_ATTRIBUTES);
pachAttrClass = (char *) CPLCalloc(sizeof(char),MAX_ATTRIBUTES);
panAttrIndex = (GInt16 *) CPLCalloc(sizeof(GInt16),MAX_ATTRIBUTES);
/* -------------------------------------------------------------------- */
/* Read and form string list. */
/* -------------------------------------------------------------------- */
GInt16 iAttr;
while( (pszLine = ReadLine(fp)) != NULL )
{
char **papszTokens = CSLTokenizeStringComplex( pszLine, ",",
TRUE, TRUE );
if( CSLCount(papszTokens) < 5 )
{
CPLAssert( FALSE );
continue;
}
iAttr = (GInt16) atoi(papszTokens[0]);
if( iAttr < 0 || iAttr >= nAttrMax
|| papszAttrNames[iAttr] != NULL )
{
CPLDebug( "S57", "Duplicate definition for attribute %d:%s",
iAttr, papszTokens[2] );
continue;
}
papszAttrNames[iAttr] = CPLStrdup(papszTokens[1]);
papszAttrAcronym[iAttr] = CPLStrdup(papszTokens[2]);
pachAttrType[iAttr] = papszTokens[3][0];
pachAttrClass[iAttr] = papszTokens[4][0];
CSLDestroy( papszTokens );
}
if( fp != NULL )
VSIFClose( fp );
/* -------------------------------------------------------------------- */
/* Build unsorted index of attributes. */
/* -------------------------------------------------------------------- */
nAttrCount = 0;
for( iAttr = 0; iAttr < nAttrMax; iAttr++ )
{
if( papszAttrAcronym[iAttr] != NULL )
panAttrIndex[nAttrCount++] = iAttr;
}
/* -------------------------------------------------------------------- */
/* Sort index by acronym. */
/* -------------------------------------------------------------------- */
int bModified;
do
{
bModified = FALSE;
for( iAttr = 0; iAttr < nAttrCount-1; iAttr++ )
{
if( strcmp(papszAttrAcronym[panAttrIndex[iAttr]],
papszAttrAcronym[panAttrIndex[iAttr+1]]) > 0 )
{
GInt16 nTemp;
nTemp = panAttrIndex[iAttr];
panAttrIndex[iAttr] = panAttrIndex[iAttr+1];
panAttrIndex[iAttr+1] = nTemp;
bModified = TRUE;
}
}
} while( bModified );
return TRUE;
}
CPLErr GDALWriteRPBFile( const char *pszFilename, char **papszMD )
{
CPLString osRPBFilename = CPLResetExtension( pszFilename, "RPB" );
/* -------------------------------------------------------------------- */
/* Read file and parse. */
/* -------------------------------------------------------------------- */
VSILFILE *fp = VSIFOpenL( osRPBFilename, "w" );
if( fp == NULL )
{
CPLError( CE_Failure, CPLE_OpenFailed,
"Unable to create %s for writing.\n%s",
osRPBFilename.c_str(), CPLGetLastErrorMsg() );
return CE_Failure;
}
/* -------------------------------------------------------------------- */
/* Write the prefix information. */
/* -------------------------------------------------------------------- */
bool bOK = VSIFPrintfL( fp, "%s", "satId = \"QB02\";\n" ) > 0;
bOK &= VSIFPrintfL( fp, "%s", "bandId = \"P\";\n" ) > 0;
bOK &= VSIFPrintfL( fp, "%s", "SpecId = \"RPC00B\";\n" ) > 0;
bOK &= VSIFPrintfL( fp, "%s", "BEGIN_GROUP = IMAGE\n" ) > 0;
bOK &= VSIFPrintfL( fp, "%s", "\terrBias = 0.0;\n" ) > 0;
bOK &= VSIFPrintfL( fp, "%s", "\terrRand = 0.0;\n" ) > 0;
/* -------------------------------------------------------------------- */
/* Write RPC values from our RPC metadata. */
/* -------------------------------------------------------------------- */
for( int i = 0; apszRPBMap[i] != NULL; i += 2 )
{
const char *pszRPBVal = CSLFetchNameValue( papszMD, apszRPBMap[i] );
const char *pszRPBTag;
if( pszRPBVal == NULL )
{
CPLError( CE_Failure, CPLE_AppDefined,
"%s field missing in metadata, %s file not written.",
apszRPBMap[i], osRPBFilename.c_str() );
CPL_IGNORE_RET_VAL(VSIFCloseL( fp ));
VSIUnlink( osRPBFilename );
return CE_Failure;
}
pszRPBTag = apszRPBMap[i+1];
if( STARTS_WITH_CI(pszRPBTag, "IMAGE.") )
pszRPBTag += 6;
if( strstr(apszRPBMap[i], "COEF" ) == NULL )
{
bOK &= VSIFPrintfL( fp, "\t%s = %s;\n", pszRPBTag, pszRPBVal ) > 0;
}
else
{
// Reformat in brackets with commas over multiple lines.
bOK &= VSIFPrintfL( fp, "\t%s = (\n", pszRPBTag ) > 0;
char **papszItems = CSLTokenizeStringComplex( pszRPBVal, " ,",
FALSE, FALSE );
if( CSLCount(papszItems) != 20 )
{
CPLError( CE_Failure, CPLE_AppDefined,
"%s field is corrupt (not 20 values), %s file not "
"written.\n%s = %s",
apszRPBMap[i], osRPBFilename.c_str(),
apszRPBMap[i], pszRPBVal );
CPL_IGNORE_RET_VAL(VSIFCloseL( fp ));
VSIUnlink( osRPBFilename );
CSLDestroy( papszItems );
return CE_Failure;
}
for( int j = 0; j < 20; j++ )
{
if( j < 19 )
bOK &= VSIFPrintfL( fp, "\t\t\t%s,\n", papszItems[j] ) > 0;
else
bOK &= VSIFPrintfL( fp, "\t\t\t%s);\n", papszItems[j] ) > 0;
}
CSLDestroy( papszItems );
}
}
/* -------------------------------------------------------------------- */
/* Write end part */
/* -------------------------------------------------------------------- */
bOK &= VSIFPrintfL( fp, "%s", "END_GROUP = IMAGE\n" ) > 0;
bOK &= VSIFPrintfL( fp, "END;\n" ) > 0;
if( VSIFCloseL( fp ) != 0 )
bOK = false;
return bOK ? CE_None : CE_Failure;
}
CPLErr VRTDataset::AddBand( GDALDataType eType, char **papszOptions )
{
int i;
const char *pszSubClass = CSLFetchNameValue(papszOptions, "subclass");
bNeedsFlush = 1;
/* ==================================================================== */
/* Handle a new raw band. */
/* ==================================================================== */
if( pszSubClass != NULL && EQUAL(pszSubClass,"VRTRawRasterBand") )
{
int nWordDataSize = GDALGetDataTypeSize( eType ) / 8;
vsi_l_offset nImageOffset = 0;
int nPixelOffset = nWordDataSize;
int nLineOffset = nWordDataSize * GetRasterXSize();
const char *pszFilename;
const char *pszByteOrder = NULL;
int bRelativeToVRT = FALSE;
/* -------------------------------------------------------------------- */
/* Collect required information. */
/* -------------------------------------------------------------------- */
if( CSLFetchNameValue(papszOptions, "ImageOffset") != NULL )
nImageOffset = atoi(CSLFetchNameValue(papszOptions, "ImageOffset"));
if( CSLFetchNameValue(papszOptions, "PixelOffset") != NULL )
nPixelOffset = atoi(CSLFetchNameValue(papszOptions,"PixelOffset"));
if( CSLFetchNameValue(papszOptions, "LineOffset") != NULL )
nLineOffset = atoi(CSLFetchNameValue(papszOptions, "LineOffset"));
if( CSLFetchNameValue(papszOptions, "ByteOrder") != NULL )
pszByteOrder = CSLFetchNameValue(papszOptions, "ByteOrder");
if( CSLFetchNameValue(papszOptions, "SourceFilename") != NULL )
pszFilename = CSLFetchNameValue(papszOptions, "SourceFilename");
else
{
CPLError( CE_Failure, CPLE_AppDefined,
"AddBand() requires a SourceFilename option for VRTRawRasterBands." );
return CE_Failure;
}
bRelativeToVRT =
CSLFetchBoolean( papszOptions, "RelativeToVRT", FALSE );
/* -------------------------------------------------------------------- */
/* Create and initialize the band. */
/* -------------------------------------------------------------------- */
CPLErr eErr;
VRTRawRasterBand *poBand =
new VRTRawRasterBand( this, GetRasterCount() + 1, eType );
eErr =
poBand->SetRawLink( pszFilename, NULL, FALSE,
nImageOffset, nPixelOffset, nLineOffset,
pszByteOrder );
if( eErr != CE_None )
{
delete poBand;
return eErr;
}
SetBand( GetRasterCount() + 1, poBand );
return CE_None;
}
/* ==================================================================== */
/* Handle a new "sourced" band. */
/* ==================================================================== */
else
{
VRTSourcedRasterBand *poBand;
/* ---- Check for our sourced band 'derived' subclass ---- */
if(pszSubClass != NULL && EQUAL(pszSubClass,"VRTDerivedRasterBand")) {
/* We'll need a pointer to the subclass in case we need */
/* to set the new band's pixel function below. */
VRTDerivedRasterBand* poDerivedBand;
poDerivedBand = new VRTDerivedRasterBand
(this, GetRasterCount() + 1, eType,
GetRasterXSize(), GetRasterYSize());
/* Set the pixel function options it provided. */
const char* pszFuncName =
CSLFetchNameValue(papszOptions, "PixelFunctionType");
if (pszFuncName != NULL)
poDerivedBand->SetPixelFunctionName(pszFuncName);
const char* pszTransferTypeName =
CSLFetchNameValue(papszOptions, "SourceTransferType");
if (pszTransferTypeName != NULL) {
GDALDataType eTransferType =
GDALGetDataTypeByName(pszTransferTypeName);
if (eTransferType == GDT_Unknown) {
CPLError( CE_Failure, CPLE_AppDefined,
"invalid SourceTransferType: \"%s\".",
pszTransferTypeName);
delete poDerivedBand;
return CE_Failure;
}
poDerivedBand->SetSourceTransferType(eTransferType);
}
/* We're done with the derived band specific stuff, so */
/* we can assigned the base class pointer now. */
poBand = poDerivedBand;
}
else {
/* ---- Standard sourced band ---- */
poBand = new VRTSourcedRasterBand
(this, GetRasterCount() + 1, eType,
GetRasterXSize(), GetRasterYSize());
}
SetBand( GetRasterCount() + 1, poBand );
for( i=0; papszOptions != NULL && papszOptions[i] != NULL; i++ )
{
if( EQUALN(papszOptions[i],"AddFuncSource=", 14) )
{
VRTImageReadFunc pfnReadFunc = NULL;
void *pCBData = NULL;
double dfNoDataValue = VRT_NODATA_UNSET;
char **papszTokens = CSLTokenizeStringComplex( papszOptions[i]+14,
",", TRUE, FALSE );
if( CSLCount(papszTokens) < 1 )
{
CPLError( CE_Failure, CPLE_AppDefined,
"AddFuncSource() ... required argument missing." );
}
sscanf( papszTokens[0], "%p", &pfnReadFunc );
if( CSLCount(papszTokens) > 1 )
sscanf( papszTokens[1], "%p", &pCBData );
if( CSLCount(papszTokens) > 2 )
dfNoDataValue = atof( papszTokens[2] );
poBand->AddFuncSource( pfnReadFunc, pCBData, dfNoDataValue );
}
}
return CE_None;
}
}
GDALDataset *NDFDataset::Open( GDALOpenInfo * poOpenInfo )
{
/* -------------------------------------------------------------------- */
/* The user must select the header file (ie. .H1). */
/* -------------------------------------------------------------------- */
if( poOpenInfo->nHeaderBytes < 50 )
return NULL;
if( !EQUALN((const char *)poOpenInfo->pabyHeader,"NDF_REVISION=2",14)
&& !EQUALN((const char *)poOpenInfo->pabyHeader,"NDF_REVISION=0",14) )
return NULL;
/* -------------------------------------------------------------------- */
/* Read and process the header into a local name/value */
/* stringlist. We just take off the trailing semicolon. The */
/* keyword is already seperated from the value by an equal */
/* sign. */
/* -------------------------------------------------------------------- */
VSILFILE* fp = VSIFOpenL(poOpenInfo->pszFilename, "rb");
if (fp == NULL)
return NULL;
const char *pszLine;
const int nHeaderMax = 1000;
int nHeaderLines = 0;
char **papszHeader = (char **) CPLMalloc(sizeof(char *) * (nHeaderMax+1));
while( nHeaderLines < nHeaderMax
&& (pszLine = CPLReadLineL( fp )) != NULL
&& !EQUAL(pszLine,"END_OF_HDR;") )
{
char *pszFixed;
if( strstr(pszLine,"=") == NULL )
break;
pszFixed = CPLStrdup( pszLine );
if( pszFixed[strlen(pszFixed)-1] == ';' )
pszFixed[strlen(pszFixed)-1] = '\0';
papszHeader[nHeaderLines++] = pszFixed;
papszHeader[nHeaderLines] = NULL;
}
VSIFCloseL(fp);
fp = NULL;
if( CSLFetchNameValue( papszHeader, "PIXELS_PER_LINE" ) == NULL
|| CSLFetchNameValue( papszHeader, "LINES_PER_DATA_FILE" ) == NULL
|| CSLFetchNameValue( papszHeader, "BITS_PER_PIXEL" ) == NULL
|| CSLFetchNameValue( papszHeader, "PIXEL_FORMAT" ) == NULL )
{
CPLError( CE_Failure, CPLE_AppDefined,
"Dataset appears to be NDF but is missing a required field.");
CSLDestroy( papszHeader );
return NULL;
}
if( !EQUAL(CSLFetchNameValue( papszHeader, "PIXEL_FORMAT"),
"BYTE" )
|| !EQUAL(CSLFetchNameValue( papszHeader, "BITS_PER_PIXEL"),"8") )
{
CPLError( CE_Failure, CPLE_AppDefined,
"Currently NDF driver supports only 8bit BYTE format." );
CSLDestroy( papszHeader );
return NULL;
}
/* -------------------------------------------------------------------- */
/* Confirm the requested access is supported. */
/* -------------------------------------------------------------------- */
if( poOpenInfo->eAccess == GA_Update )
{
CSLDestroy( papszHeader );
CPLError( CE_Failure, CPLE_NotSupported,
"The NDF driver does not support update access to existing"
" datasets.\n" );
return NULL;
}
/* -------------------------------------------------------------------- */
/* Create a corresponding GDALDataset. */
/* -------------------------------------------------------------------- */
NDFDataset *poDS;
poDS = new NDFDataset();
poDS->papszHeader = papszHeader;
poDS->nRasterXSize = atoi(poDS->Get("PIXELS_PER_LINE",""));
poDS->nRasterYSize = atoi(poDS->Get("LINES_PER_DATA_FILE",""));
/* -------------------------------------------------------------------- */
/* Create a raw raster band for each file. */
/* -------------------------------------------------------------------- */
int iBand;
const char* pszBand = CSLFetchNameValue(papszHeader,
"NUMBER_OF_BANDS_IN_VOLUME");
if (pszBand == NULL)
{
CPLError(CE_Failure, CPLE_AppDefined, "Cannot find band count");
delete poDS;
return NULL;
}
int nBands = atoi(pszBand);
if (!GDALCheckDatasetDimensions(poDS->nRasterXSize, poDS->nRasterYSize) ||
!GDALCheckBandCount(nBands, FALSE))
{
delete poDS;
return NULL;
}
for( iBand = 0; iBand < nBands; iBand++ )
{
char szKey[100];
CPLString osFilename;
sprintf( szKey, "BAND%d_FILENAME", iBand+1 );
osFilename = poDS->Get(szKey,"");
// NDF1 file do not include the band filenames.
if( osFilename.size() == 0 )
{
char szBandExtension[15];
sprintf( szBandExtension, "I%d", iBand+1 );
osFilename = CPLResetExtension( poOpenInfo->pszFilename,
szBandExtension );
}
else
{
CPLString osBasePath = CPLGetPath(poOpenInfo->pszFilename);
osFilename = CPLFormFilename( osBasePath, osFilename, NULL);
}
VSILFILE *fpRaw = VSIFOpenL( osFilename, "rb" );
if( fpRaw == NULL )
{
CPLError( CE_Failure, CPLE_AppDefined,
"Failed to open band file: %s",
osFilename.c_str() );
delete poDS;
return NULL;
}
poDS->papszExtraFiles =
CSLAddString( poDS->papszExtraFiles,
osFilename );
RawRasterBand *poBand =
new RawRasterBand( poDS, iBand+1, fpRaw, 0, 1, poDS->nRasterXSize,
GDT_Byte, TRUE, TRUE );
sprintf( szKey, "BAND%d_NAME", iBand+1 );
poBand->SetDescription( poDS->Get(szKey, "") );
sprintf( szKey, "BAND%d_WAVELENGTHS", iBand+1 );
poBand->SetMetadataItem( "WAVELENGTHS", poDS->Get(szKey,"") );
sprintf( szKey, "BAND%d_RADIOMETRIC_GAINS/BIAS", iBand+1 );
poBand->SetMetadataItem( "RADIOMETRIC_GAINS_BIAS",
poDS->Get(szKey,"") );
poDS->SetBand( iBand+1, poBand );
}
/* -------------------------------------------------------------------- */
/* Fetch and parse USGS projection parameters. */
/* -------------------------------------------------------------------- */
double adfUSGSParms[15] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
char **papszParmTokens =
CSLTokenizeStringComplex( poDS->Get( "USGS_PROJECTION_NUMBER", "" ),
",", FALSE, TRUE );
if( CSLCount( papszParmTokens ) >= 15 )
{
int i;
for( i = 0; i < 15; i++ )
adfUSGSParms[i] = CPLAtof(papszParmTokens[i]);
}
CSLDestroy(papszParmTokens);
papszParmTokens = NULL;
/* -------------------------------------------------------------------- */
/* Minimal georef support ... should add full USGS style */
/* support at some point. */
/* -------------------------------------------------------------------- */
OGRSpatialReference oSRS;
int nUSGSProjection = atoi(poDS->Get( "USGS_PROJECTION_NUMBER", "" ));
int nZone = atoi(poDS->Get("USGS_MAP_ZONE","0"));
oSRS.importFromUSGS( nUSGSProjection, nZone, adfUSGSParms, 12 );
CPLString osDatum = poDS->Get( "HORIZONTAL_DATUM", "" );
if( EQUAL(osDatum,"WGS84") || EQUAL(osDatum,"NAD83")
|| EQUAL(osDatum,"NAD27") )
{
oSRS.SetWellKnownGeogCS( osDatum );
}
else if( EQUALN(osDatum,"NAD27",5) )
{
oSRS.SetWellKnownGeogCS( "NAD27" );
}
else
{
CPLError( CE_Warning, CPLE_AppDefined,
"Unrecognised datum name in NLAPS/NDF file:%s, assuming WGS84.",
osDatum.c_str() );
oSRS.SetWellKnownGeogCS( "WGS84" );
}
if( oSRS.GetRoot() != NULL )
{
CPLFree( poDS->pszProjection );
poDS->pszProjection = NULL;
oSRS.exportToWkt( &(poDS->pszProjection) );
}
/* -------------------------------------------------------------------- */
/* Get geotransform. */
/* -------------------------------------------------------------------- */
char **papszUL = CSLTokenizeString2(
poDS->Get("UPPER_LEFT_CORNER",""), ",", 0 );
char **papszUR = CSLTokenizeString2(
poDS->Get("UPPER_RIGHT_CORNER",""), ",", 0 );
char **papszLL = CSLTokenizeString2(
poDS->Get("LOWER_LEFT_CORNER",""), ",", 0 );
if( CSLCount(papszUL) == 4
&& CSLCount(papszUR) == 4
&& CSLCount(papszLL) == 4 )
{
poDS->adfGeoTransform[0] = CPLAtof(papszUL[2]);
poDS->adfGeoTransform[1] =
(CPLAtof(papszUR[2]) - CPLAtof(papszUL[2])) / (poDS->nRasterXSize-1);
poDS->adfGeoTransform[2] =
(CPLAtof(papszUR[3]) - CPLAtof(papszUL[3])) / (poDS->nRasterXSize-1);
poDS->adfGeoTransform[3] = CPLAtof(papszUL[3]);
poDS->adfGeoTransform[4] =
(CPLAtof(papszLL[2]) - CPLAtof(papszUL[2])) / (poDS->nRasterYSize-1);
poDS->adfGeoTransform[5] =
(CPLAtof(papszLL[3]) - CPLAtof(papszUL[3])) / (poDS->nRasterYSize-1);
// Move origin up-left half a pixel.
poDS->adfGeoTransform[0] -= poDS->adfGeoTransform[1] * 0.5;
poDS->adfGeoTransform[0] -= poDS->adfGeoTransform[4] * 0.5;
poDS->adfGeoTransform[3] -= poDS->adfGeoTransform[2] * 0.5;
poDS->adfGeoTransform[3] -= poDS->adfGeoTransform[5] * 0.5;
}
CSLDestroy( papszUL );
CSLDestroy( papszLL );
CSLDestroy( papszUR );
/* -------------------------------------------------------------------- */
/* Initialize any PAM information. */
/* -------------------------------------------------------------------- */
poDS->SetDescription( poOpenInfo->pszFilename );
poDS->TryLoadXML();
/* -------------------------------------------------------------------- */
/* Check for overviews. */
/* -------------------------------------------------------------------- */
poDS->oOvManager.Initialize( poDS, poOpenInfo->pszFilename );
return( poDS );
}
int OGRParseRFC822DateTime( const char* pszRFC822DateTime,
int *pnYear, int *pnMonth, int *pnDay,
int *pnHour, int *pnMinute, int *pnSecond, int *pnTZ)
{
/* Following http://asg.web.cmu.edu/rfc/rfc822.html#sec-5 : [Fri,] 28 Dec 2007 05:24[:17] GMT */
char** papszTokens = CSLTokenizeStringComplex( pszRFC822DateTime, " ,:", TRUE, FALSE );
char** papszVal = papszTokens;
int bRet = FALSE;
int nTokens = CSLCount(papszTokens);
if (nTokens >= 6)
{
if ( ! ((*papszVal)[0] >= '0' && (*papszVal)[0] <= '9') )
{
/* Ignore day of week */
papszVal ++;
}
int day = atoi(*papszVal);
papszVal ++;
int month = 0;
for(int i = 0; i < 12; i++)
{
if (EQUAL(*papszVal, aszMonthStr[i]))
month = i + 1;
}
papszVal ++;
int year = atoi(*papszVal);
papszVal ++;
if( year < 100 && year >= 30 )
year += 1900;
else if( year < 30 && year >= 0 )
year += 2000;
int hour = atoi(*papszVal);
papszVal ++;
int minute = atoi(*papszVal);
papszVal ++;
int second = 0;
if (*papszVal != NULL && (*papszVal)[0] >= '0' && (*papszVal)[0] <= '9')
{
second = atoi(*papszVal);
papszVal ++;
}
if (month != 0)
{
bRet = TRUE;
int TZ = 0;
if (*papszVal == NULL)
{
}
else if (strlen(*papszVal) == 5 &&
((*papszVal)[0] == '+' || (*papszVal)[0] == '-'))
{
char szBuf[3];
szBuf[0] = (*papszVal)[1];
szBuf[1] = (*papszVal)[2];
szBuf[2] = 0;
int TZHour = atoi(szBuf);
szBuf[0] = (*papszVal)[3];
szBuf[1] = (*papszVal)[4];
szBuf[2] = 0;
int TZMinute = atoi(szBuf);
TZ = 100 + (((*papszVal)[0] == '+') ? 1 : -1) * ((TZHour * 60 + TZMinute) / 15);
}
else
{
const char* aszTZStr[] = { "GMT", "UT", "Z", "EST", "EDT", "CST", "CDT", "MST", "MDT", "PST", "PDT" };
int anTZVal[] = { 0, 0, 0, -5, -4, -6, -5, -7, -6, -8, -7 };
for(int i = 0; i < 11; i++)
{
if (EQUAL(*papszVal, aszTZStr[i]))
{
TZ = 100 + anTZVal[i] * 4;
break;
}
}
}
if (pnYear) *pnYear = year;
if (pnMonth) *pnMonth = month;
if (pnDay) *pnDay = day;
if (pnHour) *pnHour = hour;
if (pnMinute) *pnMinute = minute;
if (pnSecond) *pnSecond = second;
if (pnTZ) *pnTZ = TZ;
}
}
CSLDestroy(papszTokens);
return bRet;
}
GDALDataset *SNODASDataset::Open( GDALOpenInfo * poOpenInfo )
{
if( !Identify(poOpenInfo) )
return NULL;
VSILFILE *fp;
fp = VSIFOpenL( poOpenInfo->pszFilename, "r" );
if( fp == NULL )
{
return NULL;
}
const char * pszLine;
int nRows = -1, nCols = -1;
CPLString osDataFilename;
int bIsInteger = FALSE, bIs2Bytes = FALSE;
double dfNoData = 0;
int bHasNoData = FALSE;
double dfMin = 0;
int bHasMin = FALSE;
double dfMax = 0;
int bHasMax = FALSE;
double dfMinX = 0.0, dfMinY = 0.0, dfMaxX = 0.0, dfMaxY = 0.0;
int bHasMinX = FALSE, bHasMinY = FALSE, bHasMaxX = FALSE, bHasMaxY = FALSE;
int bNotProjected = FALSE, bIsWGS84 = FALSE;
CPLString osDescription, osDataUnits;
int nStartYear = -1, nStartMonth = -1, nStartDay = -1,
nStartHour = -1, nStartMinute = -1, nStartSecond = -1;
int nStopYear = -1, nStopMonth = -1, nStopDay = -1,
nStopHour = -1, nStopMinute = -1, nStopSecond = -1;
while( (pszLine = CPLReadLine2L( fp, 256, NULL )) != NULL )
{
char** papszTokens = CSLTokenizeStringComplex( pszLine, ":", TRUE, FALSE );
if( CSLCount( papszTokens ) != 2 )
{
CSLDestroy( papszTokens );
continue;
}
if( papszTokens[1][0] == ' ' )
memmove(papszTokens[1], papszTokens[1] + 1, strlen(papszTokens[1] + 1) + 1);
if( EQUAL(papszTokens[0],"Data file pathname") )
{
osDataFilename = papszTokens[1];
}
else if( EQUAL(papszTokens[0],"Description") )
{
osDescription = papszTokens[1];
}
else if( EQUAL(papszTokens[0],"Data units") )
{
osDataUnits= papszTokens[1];
}
else if( EQUAL(papszTokens[0],"Start year") )
nStartYear = atoi(papszTokens[1]);
else if( EQUAL(papszTokens[0],"Start month") )
nStartMonth = atoi(papszTokens[1]);
else if( EQUAL(papszTokens[0],"Start day") )
nStartDay = atoi(papszTokens[1]);
else if( EQUAL(papszTokens[0],"Start hour") )
nStartHour = atoi(papszTokens[1]);
else if( EQUAL(papszTokens[0],"Start minute") )
nStartMinute = atoi(papszTokens[1]);
else if( EQUAL(papszTokens[0],"Start second") )
nStartSecond = atoi(papszTokens[1]);
else if( EQUAL(papszTokens[0],"Stop year") )
nStopYear = atoi(papszTokens[1]);
else if( EQUAL(papszTokens[0],"Stop month") )
nStopMonth = atoi(papszTokens[1]);
else if( EQUAL(papszTokens[0],"Stop day") )
nStopDay = atoi(papszTokens[1]);
else if( EQUAL(papszTokens[0],"Stop hour") )
nStopHour = atoi(papszTokens[1]);
else if( EQUAL(papszTokens[0],"Stop minute") )
nStopMinute = atoi(papszTokens[1]);
else if( EQUAL(papszTokens[0],"Stop second") )
nStopSecond = atoi(papszTokens[1]);
else if( EQUAL(papszTokens[0],"Number of columns") )
{
nCols = atoi(papszTokens[1]);
}
else if( EQUAL(papszTokens[0],"Number of rows") )
{
nRows = atoi(papszTokens[1]);
}
else if( EQUAL(papszTokens[0],"Data type"))
{
bIsInteger = EQUAL(papszTokens[1],"integer");
}
else if( EQUAL(papszTokens[0],"Data bytes per pixel"))
{
bIs2Bytes = EQUAL(papszTokens[1],"2");
}
else if( EQUAL(papszTokens[0],"Projected"))
{
bNotProjected = EQUAL(papszTokens[1],"no");
}
else if( EQUAL(papszTokens[0],"Horizontal datum"))
{
bIsWGS84 = EQUAL(papszTokens[1],"WGS84");
}
else if( EQUAL(papszTokens[0],"No data value"))
{
bHasNoData = TRUE;
dfNoData = CPLAtofM(papszTokens[1]);
}
else if( EQUAL(papszTokens[0],"Minimum data value"))
{
bHasMin = TRUE;
dfMin = CPLAtofM(papszTokens[1]);
}
else if( EQUAL(papszTokens[0],"Maximum data value"))
{
bHasMax = TRUE;
dfMax = CPLAtofM(papszTokens[1]);
}
else if( EQUAL(papszTokens[0],"Minimum x-axis coordinate") )
{
bHasMinX = TRUE;
dfMinX = CPLAtofM(papszTokens[1]);
}
else if( EQUAL(papszTokens[0],"Minimum y-axis coordinate") )
{
bHasMinY = TRUE;
dfMinY = CPLAtofM(papszTokens[1]);
}
else if( EQUAL(papszTokens[0],"Maximum x-axis coordinate") )
{
bHasMaxX = TRUE;
dfMaxX = CPLAtofM(papszTokens[1]);
}
else if( EQUAL(papszTokens[0],"Maximum y-axis coordinate") )
{
bHasMaxY = TRUE;
dfMaxY = CPLAtofM(papszTokens[1]);
}
CSLDestroy( papszTokens );
}
VSIFCloseL( fp );
/* -------------------------------------------------------------------- */
/* Did we get the required keywords? If not we return with */
/* this never having been considered to be a match. This isn't */
/* an error! */
/* -------------------------------------------------------------------- */
if( nRows == -1 || nCols == -1 || !bIsInteger || !bIs2Bytes )
return NULL;
if( !bNotProjected || !bIsWGS84 )
return NULL;
if( osDataFilename.size() == 0 )
return NULL;
if (!GDALCheckDatasetDimensions(nCols, nRows))
return NULL;
/* -------------------------------------------------------------------- */
/* Open target binary file. */
/* -------------------------------------------------------------------- */
const char* pszPath = CPLGetPath(poOpenInfo->pszFilename);
osDataFilename = CPLFormFilename(pszPath, osDataFilename, NULL);
VSILFILE* fpRaw = VSIFOpenL( osDataFilename, "rb" );
if( fpRaw == NULL )
return NULL;
/* -------------------------------------------------------------------- */
/* Create a corresponding GDALDataset. */
/* -------------------------------------------------------------------- */
SNODASDataset *poDS;
poDS = new SNODASDataset();
poDS->nRasterXSize = nCols;
poDS->nRasterYSize = nRows;
poDS->osDataFilename = osDataFilename;
poDS->bHasNoData = bHasNoData;
poDS->dfNoData = dfNoData;
poDS->bHasMin = bHasMin;
poDS->dfMin = dfMin;
poDS->bHasMax = bHasMax;
poDS->dfMax = dfMax;
if (bHasMinX && bHasMinY && bHasMaxX && bHasMaxY)
{
poDS->bGotTransform = TRUE;
poDS->adfGeoTransform[0] = dfMinX;
poDS->adfGeoTransform[1] = (dfMaxX - dfMinX) / nCols;
poDS->adfGeoTransform[2] = 0.0;
poDS->adfGeoTransform[3] = dfMaxY;
poDS->adfGeoTransform[4] = 0.0;
poDS->adfGeoTransform[5] = - (dfMaxY - dfMinY) / nRows;
}
if (osDescription.size())
poDS->SetMetadataItem("Description", osDescription);
if (osDataUnits.size())
poDS->SetMetadataItem("Data_Units", osDataUnits);
if (nStartYear != -1 && nStartMonth != -1 && nStartDay != -1 &&
nStartHour != -1 && nStartMinute != -1 && nStartSecond != -1)
poDS->SetMetadataItem("Start_Date",
CPLSPrintf("%04d/%02d/%02d %02d:%02d:%02d",
nStartYear, nStartMonth, nStartDay,
nStartHour, nStartMinute, nStartSecond));
if (nStopYear != -1 && nStopMonth != -1 && nStopDay != -1 &&
nStopHour != -1 && nStopMinute != -1 && nStopSecond != -1)
poDS->SetMetadataItem("Stop_Date",
CPLSPrintf("%04d/%02d/%02d %02d:%02d:%02d",
nStopYear, nStopMonth, nStopDay,
nStopHour, nStopMinute, nStopSecond));
/* -------------------------------------------------------------------- */
/* Create band information objects. */
/* -------------------------------------------------------------------- */
poDS->SetBand( 1, new SNODASRasterBand( fpRaw, nCols, nRows) );
/* -------------------------------------------------------------------- */
/* Initialize any PAM information. */
/* -------------------------------------------------------------------- */
poDS->SetDescription( poOpenInfo->pszFilename );
poDS->TryLoadXML();
/* -------------------------------------------------------------------- */
/* Check for overviews. */
/* -------------------------------------------------------------------- */
poDS->oOvManager.Initialize( poDS, poOpenInfo->pszFilename );
return( poDS );
}
char *GXFGetMapProjectionAsOGCWKT( GXFHandle hGXF )
{
GXFInfo_t *psGXF = (GXFInfo_t *) hGXF;
char **papszMethods = NULL;
char szWKT[1024];
char szGCS[512];
char szProjection[512];
/* -------------------------------------------------------------------- */
/* If there was nothing in the file return "unknown". */
/* -------------------------------------------------------------------- */
if( CSLCount(psGXF->papszMapProjection) < 2 )
return( CPLStrdup( "" ) );
strcpy( szWKT, "" );
strcpy( szGCS, "" );
strcpy( szProjection, "" );
/* -------------------------------------------------------------------- */
/* Parse the third line, looking for known projection methods. */
/* -------------------------------------------------------------------- */
if( psGXF->papszMapProjection[2] != NULL )
{
/* We allow more than 80 characters if the projection parameters */
/* are on 2 lines as allowed by GXF 3 */
if( strlen(psGXF->papszMapProjection[2]) > 120 )
return( CPLStrdup( "" ) );
papszMethods = CSLTokenizeStringComplex(psGXF->papszMapProjection[2],
",", TRUE, TRUE );
}
#ifdef DBMALLOC
malloc_chain_check(1);
#endif
/* -------------------------------------------------------------------- */
/* Create the PROJCS. */
/* -------------------------------------------------------------------- */
if( papszMethods == NULL
|| papszMethods[0] == NULL
|| EQUAL(papszMethods[0],"Geographic") )
{
/* do nothing */
}
else if( EQUAL(papszMethods[0],"Lambert Conic Conformal (1SP)") )
{
OGCWKTSetProj( szProjection, sizeof(szProjection), papszMethods,
SRS_PT_LAMBERT_CONFORMAL_CONIC_1SP,
SRS_PP_LATITUDE_OF_ORIGIN,
SRS_PP_CENTRAL_MERIDIAN,
SRS_PP_SCALE_FACTOR,
SRS_PP_FALSE_EASTING,
SRS_PP_FALSE_NORTHING,
NULL,
NULL );
}
else if( EQUAL(papszMethods[0],"Lambert Conic Conformal (2SP)") )
{
OGCWKTSetProj( szProjection, sizeof(szProjection), papszMethods,
SRS_PT_LAMBERT_CONFORMAL_CONIC_2SP,
SRS_PP_STANDARD_PARALLEL_1,
SRS_PP_STANDARD_PARALLEL_2,
SRS_PP_LATITUDE_OF_ORIGIN,
SRS_PP_CENTRAL_MERIDIAN,
SRS_PP_FALSE_EASTING,
SRS_PP_FALSE_NORTHING,
NULL );
}
else if( EQUAL(papszMethods[0],"Lambert Conformal (2SP Belgium)") )
{
OGCWKTSetProj( szProjection, sizeof(szProjection), papszMethods,
SRS_PT_LAMBERT_CONFORMAL_CONIC_2SP_BELGIUM,
SRS_PP_STANDARD_PARALLEL_1,
SRS_PP_STANDARD_PARALLEL_2,
SRS_PP_LATITUDE_OF_ORIGIN,
SRS_PP_CENTRAL_MERIDIAN,
SRS_PP_FALSE_EASTING,
SRS_PP_FALSE_NORTHING,
NULL );
}
else if( EQUAL(papszMethods[0],"Mercator (1SP)"))
{
OGCWKTSetProj( szProjection, sizeof(szProjection), papszMethods,
SRS_PT_MERCATOR_1SP,
SRS_PP_LATITUDE_OF_ORIGIN,
SRS_PP_CENTRAL_MERIDIAN,
SRS_PP_SCALE_FACTOR,
SRS_PP_FALSE_EASTING,
SRS_PP_FALSE_NORTHING,
NULL,
NULL );
}
else if( EQUAL(papszMethods[0],"Mercator (2SP)"))
{
OGCWKTSetProj( szProjection, sizeof(szProjection), papszMethods,
SRS_PT_MERCATOR_2SP,
SRS_PP_LATITUDE_OF_ORIGIN,/* should it be StdParalle1?*/
SRS_PP_CENTRAL_MERIDIAN,
SRS_PP_FALSE_EASTING,
SRS_PP_FALSE_NORTHING,
NULL,
NULL,
NULL );
}
else if( EQUAL(papszMethods[0],"Laborde Oblique Mercator") )
{
OGCWKTSetProj( szProjection, sizeof(szProjection), papszMethods,
SRS_PT_LABORDE_OBLIQUE_MERCATOR,
SRS_PP_LATITUDE_OF_CENTER,
SRS_PP_LONGITUDE_OF_CENTER,
SRS_PP_AZIMUTH,
SRS_PP_SCALE_FACTOR,
SRS_PP_FALSE_EASTING,
SRS_PP_FALSE_NORTHING,
NULL );
}
else if( EQUAL(papszMethods[0],"Hotine Oblique Mercator") )
{
OGCWKTSetProj( szProjection, sizeof(szProjection), papszMethods,
SRS_PT_HOTINE_OBLIQUE_MERCATOR,
SRS_PP_LATITUDE_OF_CENTER,
SRS_PP_LONGITUDE_OF_CENTER,
SRS_PP_AZIMUTH,
SRS_PP_RECTIFIED_GRID_ANGLE,
SRS_PP_SCALE_FACTOR, /* not in normal formulation */
SRS_PP_FALSE_EASTING,
SRS_PP_FALSE_NORTHING );
}
else if( EQUAL(papszMethods[0],"New Zealand Map Grid") )
{
OGCWKTSetProj( szProjection, sizeof(szProjection), papszMethods,
SRS_PT_NEW_ZEALAND_MAP_GRID,
SRS_PP_LATITUDE_OF_ORIGIN,
SRS_PP_CENTRAL_MERIDIAN,
SRS_PP_FALSE_EASTING,
SRS_PP_FALSE_NORTHING,
NULL,
NULL,
NULL );
}
else if( EQUAL(papszMethods[0],"Oblique Stereographic") )
{
OGCWKTSetProj( szProjection, sizeof(szProjection), papszMethods,
SRS_PT_OBLIQUE_STEREOGRAPHIC,
SRS_PP_LATITUDE_OF_ORIGIN,
SRS_PP_CENTRAL_MERIDIAN,
SRS_PP_SCALE_FACTOR,
SRS_PP_FALSE_EASTING,
SRS_PP_FALSE_NORTHING,
NULL,
NULL );
}
else if( EQUAL(papszMethods[0],"Polar Stereographic") )
{
OGCWKTSetProj( szProjection, sizeof(szProjection), papszMethods,
SRS_PT_POLAR_STEREOGRAPHIC,
SRS_PP_LATITUDE_OF_ORIGIN,
SRS_PP_CENTRAL_MERIDIAN,
SRS_PP_SCALE_FACTOR,
SRS_PP_FALSE_EASTING,
SRS_PP_FALSE_NORTHING,
NULL,
NULL );
}
else if( EQUAL(papszMethods[0],"Swiss Oblique Cylindrical") )
{
OGCWKTSetProj( szProjection, sizeof(szProjection), papszMethods,
SRS_PT_SWISS_OBLIQUE_CYLINDRICAL,
SRS_PP_LATITUDE_OF_CENTER,
SRS_PP_LONGITUDE_OF_CENTER,
SRS_PP_FALSE_EASTING,
SRS_PP_FALSE_NORTHING,
NULL,
NULL,
NULL );
}
else if( EQUAL(papszMethods[0],"Transverse Mercator") )
{
OGCWKTSetProj( szProjection, sizeof(szProjection), papszMethods,
SRS_PT_TRANSVERSE_MERCATOR,
SRS_PP_LATITUDE_OF_ORIGIN,
SRS_PP_CENTRAL_MERIDIAN,
SRS_PP_SCALE_FACTOR,
SRS_PP_FALSE_EASTING,
SRS_PP_FALSE_NORTHING,
NULL,
NULL );
}
else if( EQUAL(papszMethods[0],"Transverse Mercator (South Oriented)")
|| EQUAL(papszMethods[0],"Transverse Mercator (South Orientated)"))
{
OGCWKTSetProj( szProjection, sizeof(szProjection), papszMethods,
SRS_PT_TRANSVERSE_MERCATOR_SOUTH_ORIENTED,
SRS_PP_LATITUDE_OF_ORIGIN,
SRS_PP_CENTRAL_MERIDIAN,
SRS_PP_SCALE_FACTOR,
SRS_PP_FALSE_EASTING,
SRS_PP_FALSE_NORTHING,
NULL,
NULL );
}
else if( EQUAL(papszMethods[0],"*Albers Conic") )
{
OGCWKTSetProj( szProjection, sizeof(szProjection), papszMethods,
SRS_PT_ALBERS_CONIC_EQUAL_AREA,
SRS_PP_STANDARD_PARALLEL_1,
SRS_PP_STANDARD_PARALLEL_2,
SRS_PP_LATITUDE_OF_CENTER,
SRS_PP_LONGITUDE_OF_CENTER,
SRS_PP_FALSE_EASTING,
SRS_PP_FALSE_NORTHING,
NULL );
}
else if( EQUAL(papszMethods[0],"*Equidistant Conic") )
{
OGCWKTSetProj( szProjection, sizeof(szProjection), papszMethods,
SRS_PT_EQUIDISTANT_CONIC,
SRS_PP_STANDARD_PARALLEL_1,
SRS_PP_STANDARD_PARALLEL_2,
SRS_PP_LATITUDE_OF_CENTER,
SRS_PP_LONGITUDE_OF_CENTER,
SRS_PP_FALSE_EASTING,
SRS_PP_FALSE_NORTHING,
NULL );
}
else if( EQUAL(papszMethods[0],"*Polyconic") )
{
OGCWKTSetProj( szProjection, sizeof(szProjection), papszMethods,
SRS_PT_POLYCONIC,
SRS_PP_LATITUDE_OF_ORIGIN,
SRS_PP_CENTRAL_MERIDIAN,
SRS_PP_SCALE_FACTOR, /* not normally expected */
SRS_PP_FALSE_EASTING,
SRS_PP_FALSE_NORTHING,
NULL,
NULL );
}
CSLDestroy( papszMethods );
/* -------------------------------------------------------------------- */
/* Extract the linear Units specification. */
/* -------------------------------------------------------------------- */
if( psGXF->pszUnitName != NULL && strlen(szProjection) > 0 )
{
if( strlen(psGXF->pszUnitName) > 80 )
return CPLStrdup("");
CPLsnprintf( szProjection+strlen(szProjection),
sizeof(szProjection) - strlen(szProjection),
",UNIT[\"%s\",%.15g]",
psGXF->pszUnitName, psGXF->dfUnitToMeter );
}
/* -------------------------------------------------------------------- */
/* Build GEOGCS. There are still "issues" with the generation */
/* of the GEOGCS/Datum and Spheroid names. Of these, only the */
/* datum name is really significant. */
/* -------------------------------------------------------------------- */
if( CSLCount(psGXF->papszMapProjection) > 1 )
{
char **papszTokens;
if( strlen(psGXF->papszMapProjection[1]) > 80 )
return CPLStrdup("");
papszTokens = CSLTokenizeStringComplex(psGXF->papszMapProjection[1],
",", TRUE, TRUE );
if( CSLCount(papszTokens) > 2 )
{
double dfMajor = CPLAtof(papszTokens[1]);
double dfEccentricity = CPLAtof(papszTokens[2]);
double dfInvFlattening, dfMinor;
char *pszOGCDatum;
/* translate eccentricity to inv flattening. */
if( dfEccentricity == 0.0 )
dfInvFlattening = 0.0;
else
{
dfMinor = dfMajor * pow(1.0-dfEccentricity*dfEccentricity,0.5);
dfInvFlattening = OSRCalcInvFlattening(dfMajor, dfMinor);
}
pszOGCDatum = CPLStrdup(papszTokens[0]);
WKTMassageDatum( &pszOGCDatum );
CPLsnprintf( szGCS,
sizeof(szGCS),
"GEOGCS[\"%s\","
"DATUM[\"%s\","
"SPHEROID[\"%s\",%s,%.15g]],",
papszTokens[0],
pszOGCDatum,
papszTokens[0], /* this is datum, but should be ellipse*/
papszTokens[1],
dfInvFlattening );
CPLFree( pszOGCDatum );
}
if( CSLCount(papszTokens) > 3 )
CPLsnprintf( szGCS + strlen(szGCS),
sizeof(szGCS) - strlen(szGCS),
"PRIMEM[\"unnamed\",%s],",
papszTokens[3] );
CPLsnprintf( szGCS + strlen(szGCS),
sizeof(szGCS) - strlen(szGCS),
"%s",
"UNIT[\"degree\",0.0174532925199433]]" );
CSLDestroy( papszTokens );
}
CPLAssert(strlen(szProjection) < sizeof(szProjection));
CPLAssert(strlen(szGCS) < sizeof(szGCS));
/* -------------------------------------------------------------------- */
/* Put this all together into a full projection. */
/* -------------------------------------------------------------------- */
if( strlen(szProjection) > 0 )
{
if( strlen(psGXF->papszMapProjection[0]) > 80 )
return CPLStrdup("");
if( psGXF->papszMapProjection[0][0] == '"' )
snprintf( szWKT, sizeof(szWKT),
"PROJCS[%s,%s,%s]",
psGXF->papszMapProjection[0],
szGCS,
szProjection );
else
snprintf( szWKT, sizeof(szWKT),
"PROJCS[\"%s\",%s,%s]",
psGXF->papszMapProjection[0],
szGCS,
szProjection );
}
else
{
strcpy( szWKT, szGCS );
}
return( CPLStrdup( szWKT ) );
}
GDALDataset *
RasterliteCreateCopy( const char * pszFilename, GDALDataset *poSrcDS,
int bStrict, char ** papszOptions,
GDALProgressFunc pfnProgress, void * pProgressData )
{
int nBands = poSrcDS->GetRasterCount();
if (nBands == 0)
{
CPLError(CE_Failure, CPLE_NotSupported, "nBands == 0");
return NULL;
}
const char* pszDriverName = CSLFetchNameValueDef(papszOptions, "DRIVER", "GTiff");
GDALDriverH hTileDriver = GDALGetDriverByName(pszDriverName);
if ( hTileDriver == NULL)
{
CPLError(CE_Failure, CPLE_AppDefined, "Cannot load GDAL %s driver", pszDriverName);
return NULL;
}
GDALDriverH hMemDriver = GDALGetDriverByName("MEM");
if (hMemDriver == NULL)
{
CPLError(CE_Failure, CPLE_AppDefined, "Cannot load GDAL MEM driver");
return NULL;
}
int nXSize = GDALGetRasterXSize(poSrcDS);
int nYSize = GDALGetRasterYSize(poSrcDS);
double adfGeoTransform[6];
if (poSrcDS->GetGeoTransform(adfGeoTransform) != CE_None)
{
adfGeoTransform[0] = 0;
adfGeoTransform[1] = 1;
adfGeoTransform[2] = 0;
adfGeoTransform[3] = 0;
adfGeoTransform[4] = 0;
adfGeoTransform[5] = -1;
}
else if (adfGeoTransform[2] != 0.0 || adfGeoTransform[4] != 0.0)
{
CPLError(CE_Failure, CPLE_AppDefined, "Cannot use geotransform with rotational terms");
return NULL;
}
int bTiled = CSLTestBoolean(CSLFetchNameValueDef(papszOptions, "TILED", "YES"));
int nBlockXSize, nBlockYSize;
if (bTiled)
{
nBlockXSize = atoi(CSLFetchNameValueDef(papszOptions, "BLOCKXSIZE", "256"));
nBlockYSize = atoi(CSLFetchNameValueDef(papszOptions, "BLOCKYSIZE", "256"));
if (nBlockXSize < 64) nBlockXSize = 64;
else if (nBlockXSize > 4096) nBlockXSize = 4096;
if (nBlockYSize < 64) nBlockYSize = 64;
else if (nBlockYSize > 4096) nBlockYSize = 4096;
}
else
{
nBlockXSize = nXSize;
nBlockYSize = nYSize;
}
/* -------------------------------------------------------------------- */
/* Analyze arguments */
/* -------------------------------------------------------------------- */
CPLString osDBName;
CPLString osTableName;
VSIStatBuf sBuf;
int bExists;
/* Skip optionnal RASTERLITE: prefix */
const char* pszFilenameWithoutPrefix = pszFilename;
if (EQUALN(pszFilename, "RASTERLITE:", 11))
pszFilenameWithoutPrefix += 11;
char** papszTokens = CSLTokenizeStringComplex(
pszFilenameWithoutPrefix, ", ", FALSE, FALSE );
int nTokens = CSLCount(papszTokens);
if (nTokens == 0)
{
osDBName = pszFilenameWithoutPrefix;
osTableName = CPLGetBasename(pszFilenameWithoutPrefix);
}
else
{
osDBName = papszTokens[0];
int i;
for(i=1;i<nTokens;i++)
{
if (EQUALN(papszTokens[i], "table=", 6))
osTableName = papszTokens[i] + 6;
else
{
CPLError(CE_Warning, CPLE_AppDefined,
"Invalid option : %s", papszTokens[i]);
}
}
}
CSLDestroy(papszTokens);
papszTokens = NULL;
bExists = (VSIStat(osDBName.c_str(), &sBuf) == 0);
if (osTableName.size() == 0)
{
if (bExists)
{
CPLError(CE_Failure, CPLE_AppDefined,
"Database already exists. Explicit table name must be specified");
return NULL;
}
osTableName = CPLGetBasename(osDBName.c_str());
}
CPLString osRasterLayer;
osRasterLayer.Printf("%s_rasters", osTableName.c_str());
CPLString osMetatadataLayer;
osMetatadataLayer.Printf("%s_metadata", osTableName.c_str());
/* -------------------------------------------------------------------- */
/* Create or open the SQLite DB */
/* -------------------------------------------------------------------- */
if (OGRGetDriverCount() == 0)
OGRRegisterAll();
OGRSFDriverH hSQLiteDriver = OGRGetDriverByName("SQLite");
if (hSQLiteDriver == NULL)
{
CPLError(CE_Failure, CPLE_AppDefined, "Cannot load OGR SQLite driver");
return NULL;
}
OGRDataSourceH hDS;
CPLString osOldVal =
CPLGetConfigOption("SQLITE_LIST_ALL_TABLES", "FALSE");
CPLSetConfigOption("SQLITE_LIST_ALL_TABLES", "TRUE");
if (!bExists)
{
char** papszOGROptions = CSLAddString(NULL, "SPATIALITE=YES");
hDS = OGR_Dr_CreateDataSource(hSQLiteDriver,
osDBName.c_str(), papszOGROptions);
CSLDestroy(papszOGROptions);
}
else
{
hDS = OGROpen(osDBName.c_str(), TRUE, NULL);
}
CPLSetConfigOption("SQLITE_LIST_ALL_TABLES", osOldVal.c_str());
if (hDS == NULL)
{
CPLError(CE_Failure, CPLE_AppDefined,
"Cannot load or create SQLite database");
return NULL;
}
CPLString osSQL;
/* -------------------------------------------------------------------- */
/* Get the SRID for the SRS */
/* -------------------------------------------------------------------- */
int nSRSId = RasterliteInsertSRID(hDS, poSrcDS->GetProjectionRef());
/* -------------------------------------------------------------------- */
/* Create or wipe existing tables */
/* -------------------------------------------------------------------- */
int bWipeExistingData =
CSLTestBoolean(CSLFetchNameValueDef(papszOptions, "WIPE", "NO"));
hDS = RasterliteCreateTables(hDS, osTableName.c_str(),
nSRSId, bWipeExistingData);
if (hDS == NULL)
return NULL;
OGRLayerH hRasterLayer = OGR_DS_GetLayerByName(hDS, osRasterLayer.c_str());
OGRLayerH hMetadataLayer = OGR_DS_GetLayerByName(hDS, osMetatadataLayer.c_str());
if (hRasterLayer == NULL || hMetadataLayer == NULL)
{
CPLError(CE_Failure, CPLE_AppDefined,
"Cannot find metadata and/or raster tables");
OGRReleaseDataSource(hDS);
return NULL;
}
/* -------------------------------------------------------------------- */
/* Check if there is overlapping data and warn the user */
/* -------------------------------------------------------------------- */
double minx = adfGeoTransform[0];
double maxx = adfGeoTransform[0] + nXSize * adfGeoTransform[1];
double maxy = adfGeoTransform[3];
double miny = adfGeoTransform[3] + nYSize * adfGeoTransform[5];
osSQL.Printf("SELECT COUNT(geometry) FROM \"%s\" "
"WHERE rowid IN "
"(SELECT pkid FROM \"idx_%s_metadata_geometry\" "
"WHERE xmin < %.15f AND xmax > %.15f "
"AND ymin < %.15f AND ymax > %.15f) "
"AND pixel_x_size >= %.15f AND pixel_x_size <= %.15f AND "
"pixel_y_size >= %.15f AND pixel_y_size <= %.15f",
osMetatadataLayer.c_str(),
osTableName.c_str(),
maxx, minx, maxy, miny,
adfGeoTransform[1] - 1e-15, adfGeoTransform[1] + 1e-15,
- adfGeoTransform[5] - 1e-15, - adfGeoTransform[5] + 1e-15);
int nOverlappingGeoms = 0;
OGRLayerH hCountLyr = OGR_DS_ExecuteSQL(hDS, osSQL.c_str(), NULL, NULL);
if (hCountLyr)
{
OGRFeatureH hFeat = OGR_L_GetNextFeature(hCountLyr);
if (hFeat)
{
nOverlappingGeoms = OGR_F_GetFieldAsInteger(hFeat, 0);
OGR_F_Destroy(hFeat);
}
OGR_DS_ReleaseResultSet(hDS, hCountLyr);
}
if (nOverlappingGeoms != 0)
{
CPLError(CE_Warning, CPLE_AppDefined,
"Raster tiles already exist in the %s table within "
"the extent of the data to be inserted in",
osTableName.c_str());
}
/* -------------------------------------------------------------------- */
/* Iterate over blocks to add data into raster and metadata tables */
/* -------------------------------------------------------------------- */
int nXBlocks = (nXSize + nBlockXSize - 1) / nBlockXSize;
int nYBlocks = (nYSize + nBlockYSize - 1) / nBlockYSize;
GDALDataType eDataType = poSrcDS->GetRasterBand(1)->GetRasterDataType();
int nDataTypeSize = GDALGetDataTypeSize(eDataType) / 8;
GByte* pabyMEMDSBuffer =
(GByte*)VSIMalloc3(nBlockXSize, nBlockYSize, nBands * nDataTypeSize);
if (pabyMEMDSBuffer == NULL)
{
OGRReleaseDataSource(hDS);
return NULL;
}
CPLString osTempFileName;
osTempFileName.Printf("/vsimem/%p", hDS);
int nTileId = 0;
int nBlocks = 0;
int nTotalBlocks = nXBlocks * nYBlocks;
char** papszTileDriverOptions = RasterliteGetTileDriverOptions(papszOptions);
OGR_DS_ExecuteSQL(hDS, "BEGIN", NULL, NULL);
CPLErr eErr = CE_None;
int nBlockXOff, nBlockYOff;
for(nBlockYOff=0;eErr == CE_None && nBlockYOff<nYBlocks;nBlockYOff++)
{
for(nBlockXOff=0;eErr == CE_None && nBlockXOff<nXBlocks;nBlockXOff++)
{
/* -------------------------------------------------------------------- */
/* Create in-memory tile */
/* -------------------------------------------------------------------- */
int nReqXSize = nBlockXSize, nReqYSize = nBlockYSize;
if ((nBlockXOff+1) * nBlockXSize > nXSize)
nReqXSize = nXSize - nBlockXOff * nBlockXSize;
if ((nBlockYOff+1) * nBlockYSize > nYSize)
nReqYSize = nYSize - nBlockYOff * nBlockYSize;
eErr = poSrcDS->RasterIO(GF_Read,
nBlockXOff * nBlockXSize,
nBlockYOff * nBlockYSize,
nReqXSize, nReqYSize,
pabyMEMDSBuffer, nReqXSize, nReqYSize,
eDataType, nBands, NULL,
0, 0, 0);
if (eErr != CE_None)
{
break;
}
GDALDatasetH hMemDS = GDALCreate(hMemDriver, "MEM:::",
nReqXSize, nReqYSize, 0,
eDataType, NULL);
if (hMemDS == NULL)
{
eErr = CE_Failure;
break;
}
int iBand;
for(iBand = 0; iBand < nBands; iBand ++)
{
char** papszMEMDSOptions = NULL;
char szTmp[64];
memset(szTmp, 0, sizeof(szTmp));
CPLPrintPointer(szTmp,
pabyMEMDSBuffer + iBand * nDataTypeSize *
nReqXSize * nReqYSize, sizeof(szTmp));
papszMEMDSOptions = CSLSetNameValue(papszMEMDSOptions, "DATAPOINTER", szTmp);
GDALAddBand(hMemDS, eDataType, papszMEMDSOptions);
CSLDestroy(papszMEMDSOptions);
}
GDALDatasetH hOutDS = GDALCreateCopy(hTileDriver,
osTempFileName.c_str(), hMemDS, FALSE,
papszTileDriverOptions, NULL, NULL);
GDALClose(hMemDS);
if (hOutDS)
GDALClose(hOutDS);
else
{
eErr = CE_Failure;
break;
}
/* -------------------------------------------------------------------- */
/* Insert new entry into raster table */
/* -------------------------------------------------------------------- */
vsi_l_offset nDataLength;
GByte *pabyData = VSIGetMemFileBuffer( osTempFileName.c_str(),
&nDataLength, FALSE);
OGRFeatureH hFeat = OGR_F_Create( OGR_L_GetLayerDefn(hRasterLayer) );
OGR_F_SetFieldBinary(hFeat, 0, (int)nDataLength, pabyData);
OGR_L_CreateFeature(hRasterLayer, hFeat);
/* Query raster ID to set it as the ID of the associated metadata */
int nRasterID = (int)OGR_F_GetFID(hFeat);
OGR_F_Destroy(hFeat);
VSIUnlink(osTempFileName.c_str());
/* -------------------------------------------------------------------- */
/* Insert new entry into metadata table */
/* -------------------------------------------------------------------- */
hFeat = OGR_F_Create( OGR_L_GetLayerDefn(hMetadataLayer) );
OGR_F_SetFID(hFeat, nRasterID);
OGR_F_SetFieldString(hFeat, 0, GDALGetDescription(poSrcDS));
OGR_F_SetFieldInteger(hFeat, 1, nTileId ++);
OGR_F_SetFieldInteger(hFeat, 2, nReqXSize);
OGR_F_SetFieldInteger(hFeat, 3, nReqYSize);
OGR_F_SetFieldDouble(hFeat, 4, adfGeoTransform[1]);
OGR_F_SetFieldDouble(hFeat, 5, -adfGeoTransform[5]);
minx = adfGeoTransform[0] +
(nBlockXSize * nBlockXOff) * adfGeoTransform[1];
maxx = adfGeoTransform[0] +
(nBlockXSize * nBlockXOff + nReqXSize) * adfGeoTransform[1];
maxy = adfGeoTransform[3] +
(nBlockYSize * nBlockYOff) * adfGeoTransform[5];
miny = adfGeoTransform[3] +
(nBlockYSize * nBlockYOff + nReqYSize) * adfGeoTransform[5];
OGRGeometryH hRectangle = OGR_G_CreateGeometry(wkbPolygon);
OGRGeometryH hLinearRing = OGR_G_CreateGeometry(wkbLinearRing);
OGR_G_AddPoint_2D(hLinearRing, minx, miny);
OGR_G_AddPoint_2D(hLinearRing, minx, maxy);
OGR_G_AddPoint_2D(hLinearRing, maxx, maxy);
OGR_G_AddPoint_2D(hLinearRing, maxx, miny);
OGR_G_AddPoint_2D(hLinearRing, minx, miny);
OGR_G_AddGeometryDirectly(hRectangle, hLinearRing);
OGR_F_SetGeometryDirectly(hFeat, hRectangle);
OGR_L_CreateFeature(hMetadataLayer, hFeat);
OGR_F_Destroy(hFeat);
nBlocks++;
if (pfnProgress && !pfnProgress(1.0 * nBlocks / nTotalBlocks,
NULL, pProgressData))
eErr = CE_Failure;
}
}
if (eErr == CE_None)
OGR_DS_ExecuteSQL(hDS, "COMMIT", NULL, NULL);
else
OGR_DS_ExecuteSQL(hDS, "ROLLBACK", NULL, NULL);
CSLDestroy(papszTileDriverOptions);
VSIFree(pabyMEMDSBuffer);
OGRReleaseDataSource(hDS);
return (GDALDataset*) GDALOpen(pszFilename, GA_Update);
}
void PAuxDataset::ScanForGCPs()
{
static const int MAX_GCP = 256;
nGCPCount = 0;
pasGCPList = reinterpret_cast<GDAL_GCP *>(
CPLCalloc( sizeof(GDAL_GCP), MAX_GCP ) );
/* -------------------------------------------------------------------- */
/* Get the GCP coordinate system. */
/* -------------------------------------------------------------------- */
const char *pszMapUnits = CSLFetchNameValue( papszAuxLines, "GCP_1_MapUnits" );
const char *pszProjParms = CSLFetchNameValue( papszAuxLines, "GCP_1_ProjParms" );
if( pszMapUnits != NULL )
pszGCPProjection = PCI2WKT( pszMapUnits, pszProjParms );
/* -------------------------------------------------------------------- */
/* Collect standalone GCPs. They look like: */
/* */
/* GCP_1_n = row, col, x, y [,z [,"id"[, "desc"]]] */
/* -------------------------------------------------------------------- */
for( int i = 0; nGCPCount < MAX_GCP; i++ )
{
char szName[50];
snprintf( szName, sizeof(szName), "GCP_1_%d", i+1 );
if( CSLFetchNameValue( papszAuxLines, szName ) == NULL )
break;
char **papszTokens = CSLTokenizeStringComplex(
CSLFetchNameValue( papszAuxLines, szName ),
" ", TRUE, FALSE );
if( CSLCount(papszTokens) >= 4 )
{
GDALInitGCPs( 1, pasGCPList + nGCPCount );
pasGCPList[nGCPCount].dfGCPX = CPLAtof(papszTokens[2]);
pasGCPList[nGCPCount].dfGCPY = CPLAtof(papszTokens[3]);
pasGCPList[nGCPCount].dfGCPPixel = CPLAtof(papszTokens[0]);
pasGCPList[nGCPCount].dfGCPLine = CPLAtof(papszTokens[1]);
if( CSLCount(papszTokens) > 4 )
pasGCPList[nGCPCount].dfGCPZ = CPLAtof(papszTokens[4]);
CPLFree( pasGCPList[nGCPCount].pszId );
if( CSLCount(papszTokens) > 5 )
{
pasGCPList[nGCPCount].pszId = CPLStrdup(papszTokens[5]);
}
else
{
snprintf( szName, sizeof(szName), "GCP_%d", i+1 );
pasGCPList[nGCPCount].pszId = CPLStrdup( szName );
}
if( CSLCount(papszTokens) > 6 )
{
CPLFree( pasGCPList[nGCPCount].pszInfo );
pasGCPList[nGCPCount].pszInfo = CPLStrdup(papszTokens[6]);
}
nGCPCount++;
}
CSLDestroy(papszTokens);
}
}
GDALDataset *SDEDataset::Open( GDALOpenInfo * poOpenInfo )
{
/* -------------------------------------------------------------------- */
/* If we aren't prefixed with SDE: then ignore this datasource. */
/* -------------------------------------------------------------------- */
if( !STARTS_WITH_CI(poOpenInfo->pszFilename, "SDE:") )
return NULL;
/* -------------------------------------------------------------------- */
/* Parse arguments on comma. We expect (layer is optional): */
/* SDE:server,instance,database,username,password,layer */
/* -------------------------------------------------------------------- */
char **papszTokens = CSLTokenizeStringComplex( poOpenInfo->pszFilename+4,
",",
TRUE,
TRUE );
CPLDebug( "SDERASTER", "Open(\"%s\") revealed %d tokens.",
poOpenInfo->pszFilename,
CSLCount( papszTokens ) );
if( CSLCount( papszTokens ) < 5 || CSLCount( papszTokens ) > 7 )
{
CPLError( CE_Failure, CPLE_OpenFailed,
"SDE connect string had wrong number of arguments.\n"
"Expected 'SDE:server,instance,database,username,password,layer'\n"
"The layer name value is optional.\n"
"Got '%s'",
poOpenInfo->pszFilename );
return NULL;
}
/* -------------------------------------------------------------------- */
/* Create a corresponding GDALDataset. */
/* -------------------------------------------------------------------- */
SDEDataset *poDS;
poDS = new SDEDataset();
/* -------------------------------------------------------------------- */
/* Try to establish connection. */
/* -------------------------------------------------------------------- */
int nSDEErr;
SE_ERROR hSDEErrorInfo;
nSDEErr = SE_connection_create( papszTokens[0],
papszTokens[1],
papszTokens[2],
papszTokens[3],
papszTokens[4],
&(hSDEErrorInfo),
&(poDS->hConnection) );
if( nSDEErr != SE_SUCCESS )
{
IssueSDEError( nSDEErr, "SE_connection_create" );
return NULL;
}
/* -------------------------------------------------------------------- */
/* Set unprotected concurrency policy, suitable for single */
/* threaded access. */
/* -------------------------------------------------------------------- */
nSDEErr = SE_connection_set_concurrency( poDS->hConnection,
SE_UNPROTECTED_POLICY);
if( nSDEErr != SE_SUCCESS) {
IssueSDEError( nSDEErr, NULL );
return NULL;
}
/* -------------------------------------------------------------------- */
/* If we were given a layer name, use that directly, otherwise */
/* query for subdatasets. */
/* -------------------------------------------------------------------- */
// Get the RASTER column name if it was set
if (CSLCount (papszTokens) == 7) {
poDS->pszColumnName = CPLStrdup( papszTokens[6] );
}
else {
poDS->pszColumnName = CPLStrdup( "RASTER" );
}
CPLDebug ("SDERASTER", "SDE Column name is '%s'", poDS->pszColumnName);
if (CSLCount( papszTokens ) >= 6 ) {
poDS->pszLayerName = CPLStrdup( papszTokens[5] );
nSDEErr = SE_rascolinfo_create (&(poDS->hRasterColumn));
if( nSDEErr != SE_SUCCESS )
{
IssueSDEError( nSDEErr, "SE_rastercolumn_create" );
return NULL;
}
CPLDebug( "SDERASTER", "'%s' raster layer specified... "\
"using it directly with '%s' as the raster column name.",
poDS->pszLayerName,
poDS->pszColumnName);
nSDEErr = SE_rastercolumn_get_info_by_name( poDS->hConnection,
poDS->pszLayerName,
poDS->pszColumnName,
poDS->hRasterColumn);
if( nSDEErr != SE_SUCCESS )
{
IssueSDEError( nSDEErr, "SE_rastercolumn_get_info_by_name" );
return NULL;
}
poDS->ComputeRasterInfo();
} else {
nSDEErr = SE_rastercolumn_get_info_list(poDS->hConnection,
&(poDS->paohSDERasterColumns),
&(poDS->nSubDataCount));
if( nSDEErr != SE_SUCCESS )
{
IssueSDEError( nSDEErr, "SE_rascolinfo_get_info_list" );
return NULL;
}
CPLDebug( "SDERASTER", "No layername specified, %d subdatasets available.",
poDS->nSubDataCount);
for (int i = 0; i < poDS->nSubDataCount; i++) {
char szTableName[SE_QUALIFIED_TABLE_NAME+1];
char szColumnName[SE_MAX_COLUMN_LEN+1];
nSDEErr = SE_rascolinfo_get_raster_column (poDS->paohSDERasterColumns[i],
szTableName,
szColumnName);
CPLDebug( "SDERASTER",
"Layer '%s' with column '%s' found.",
szTableName,
szColumnName);
if( nSDEErr != SE_SUCCESS )
{
IssueSDEError( nSDEErr, "SE_rascolinfo_get_raster_column" );
return NULL;
}
}
return NULL;
}
CSLDestroy( papszTokens);
return( poDS );
}
/**********************************************************************
* TABDATFile::WriteDateField()
*
* Write the date field value at the current position in the data
* block.
*
* A date field is a 4 bytes binary value in which the first byte is
* the day, followed by 1 byte for the month, and 2 bytes for the year.
*
* The expected input is a 10 chars string in the format "YYYY/MM/DD"
* or "DD/MM/YYYY" or "YYYYMMDD"
*
* Returns 0 on success, or -1 if the operation failed, in which case
* CPLError() will have been called.
**********************************************************************/
int TABDATFile::WriteDateField(const char *pszValue,
TABINDFile *poINDFile, int nIndexNo)
{
int nDay, nMonth, nYear;
char **papszTok = NULL;
if (m_poRecordBlock == NULL)
{
CPLError(CE_Failure, CPLE_AssertionFailed,
"Can't write field value: GetRecordBlock() has not been called.");
return -1;
}
/*-----------------------------------------------------------------
* Try to automagically detect date format, one of:
* "YYYY/MM/DD", "DD/MM/YYYY", or "YYYYMMDD"
*----------------------------------------------------------------*/
if (strlen(pszValue) == 8)
{
/*-------------------------------------------------------------
* "YYYYMMDD"
*------------------------------------------------------------*/
char szBuf[9];
strcpy(szBuf, pszValue);
nDay = atoi(szBuf+6);
szBuf[6] = '\0';
nMonth = atoi(szBuf+4);
szBuf[4] = '\0';
nYear = atoi(szBuf);
}
else if (strlen(pszValue) == 10 &&
(papszTok = CSLTokenizeStringComplex(pszValue, "/",
FALSE, FALSE)) != NULL &&
CSLCount(papszTok) == 3 &&
(strlen(papszTok[0]) == 4 || strlen(papszTok[2]) == 4) )
{
/*-------------------------------------------------------------
* Either "YYYY/MM/DD" or "DD/MM/YYYY"
*------------------------------------------------------------*/
if (strlen(papszTok[0]) == 4)
{
nYear = atoi(papszTok[0]);
nMonth = atoi(papszTok[1]);
nDay = atoi(papszTok[2]);
}
else
{
nYear = atoi(papszTok[2]);
nMonth = atoi(papszTok[1]);
nDay = atoi(papszTok[0]);
}
}
else if (strlen(pszValue) == 0)
{
nYear = nMonth = nDay = 0;
}
else
{
CPLError(CE_Failure, CPLE_AppDefined,
"Invalid date field value `%s'. Date field values must "
"be in the format `YYYY/MM/DD', `MM/DD/YYYY' or `YYYYMMDD'",
pszValue);
CSLDestroy(papszTok);
return -1;
}
CSLDestroy(papszTok);
m_poRecordBlock->WriteInt16(nYear);
m_poRecordBlock->WriteByte(nMonth);
m_poRecordBlock->WriteByte(nDay);
if (CPLGetLastErrorNo() != 0)
return -1;
// Update Index
if (poINDFile && nIndexNo > 0)
{
GByte *pKey = poINDFile->BuildKey(nIndexNo, (nYear*0x10000 +
nMonth * 0x100 + nDay));
if (poINDFile->AddEntry(nIndexNo, pKey, m_nCurRecordId) != 0)
return -1;
}
return 0;
}
void BSBDataset::ScanForGCPsNos( const char *pszFilename )
{
char **Tokens;
const char *geofile;
const char *extension;
int fileGCPCount=0;
extension = CPLGetExtension(pszFilename);
// pseudointelligently try and guess whether we want a .geo or a .GEO
if (extension[1] == 'O')
{
geofile = CPLResetExtension( pszFilename, "GEO");
} else {
geofile = CPLResetExtension( pszFilename, "geo");
}
FILE *gfp = VSIFOpen( geofile, "r" ); // Text files
if( gfp == NULL )
{
CPLError( CE_Failure, CPLE_OpenFailed,
"Couldn't find a matching .GEO file: %s", geofile );
return;
}
char *thisLine = (char *) CPLMalloc( 80 ); // FIXME
// Count the GCPs (reference points) and seek the file pointer 'gfp' to the starting point
while (fgets(thisLine, 80, gfp))
{
if( EQUALN(thisLine, "Point", 5) )
fileGCPCount++;
}
VSIRewind( gfp );
// Memory has not been allocated to fileGCPCount yet
pasGCPList = (GDAL_GCP *) CPLCalloc(sizeof(GDAL_GCP),fileGCPCount+1);
while (fgets(thisLine, 80, gfp))
{
if( EQUALN(thisLine, "Point", 5) )
{
// got a point line, turn it into a gcp
Tokens = CSLTokenizeStringComplex(thisLine, "= ", FALSE, FALSE);
if (CSLCount(Tokens) >= 5)
{
GDALInitGCPs( 1, pasGCPList + nGCPCount );
pasGCPList[nGCPCount].dfGCPX = atof(Tokens[1]);
pasGCPList[nGCPCount].dfGCPY = atof(Tokens[2]);
pasGCPList[nGCPCount].dfGCPPixel = atof(Tokens[4]);
pasGCPList[nGCPCount].dfGCPLine = atof(Tokens[3]);
CPLFree( pasGCPList[nGCPCount].pszId );
char szName[50];
sprintf( szName, "GCP_%d", nGCPCount+1 );
pasGCPList[nGCPCount].pszId = CPLStrdup( szName );
nGCPCount++;
}
CSLDestroy(Tokens);
}
}
CPLFree(thisLine);
VSIFClose(gfp);
}
CPLErr GDALWriteRPCTXTFile( const char *pszFilename, char **papszMD )
{
CPLString osRPCFilename = pszFilename;
CPLString soPt(".");
size_t found = osRPCFilename.rfind(soPt);
if (found == CPLString::npos)
return CE_Failure;
osRPCFilename.replace (found, osRPCFilename.size() - found, "_RPC.TXT");
/* -------------------------------------------------------------------- */
/* Read file and parse. */
/* -------------------------------------------------------------------- */
VSILFILE *fp = VSIFOpenL( osRPCFilename, "w" );
if( fp == NULL )
{
CPLError( CE_Failure, CPLE_OpenFailed,
"Unable to create %s for writing.\n%s",
osRPCFilename.c_str(), CPLGetLastErrorMsg() );
return CE_Failure;
}
/* -------------------------------------------------------------------- */
/* Write RPC values from our RPC metadata. */
/* -------------------------------------------------------------------- */
int i;
for( i = 0; apszRPCTXTSingleValItems[i] != NULL; i ++ )
{
const char *pszRPCVal = CSLFetchNameValue( papszMD, apszRPCTXTSingleValItems[i] );
if( pszRPCVal == NULL )
{
CPLError( CE_Failure, CPLE_AppDefined,
"%s field missing in metadata, %s file not written.",
apszRPCTXTSingleValItems[i], osRPCFilename.c_str() );
VSIFCloseL( fp );
VSIUnlink( osRPCFilename );
return CE_Failure;
}
VSIFPrintfL( fp, "%s: %s\n", apszRPCTXTSingleValItems[i], pszRPCVal );
}
for( i = 0; apszRPCTXT20ValItems[i] != NULL; i ++ )
{
const char *pszRPCVal = CSLFetchNameValue( papszMD, apszRPCTXT20ValItems[i] );
if( pszRPCVal == NULL )
{
CPLError( CE_Failure, CPLE_AppDefined,
"%s field missing in metadata, %s file not written.",
apszRPCTXTSingleValItems[i], osRPCFilename.c_str() );
VSIFCloseL( fp );
VSIUnlink( osRPCFilename );
return CE_Failure;
}
char **papszItems = CSLTokenizeStringComplex( pszRPCVal, " ,",
FALSE, FALSE );
if( CSLCount(papszItems) != 20 )
{
CPLError( CE_Failure, CPLE_AppDefined,
"%s field is corrupt (not 20 values), %s file not written.\n%s = %s",
apszRPCTXT20ValItems[i], osRPCFilename.c_str(),
apszRPCTXT20ValItems[i], pszRPCVal );
VSIFCloseL( fp );
VSIUnlink( osRPCFilename );
CSLDestroy( papszItems );
return CE_Failure;
}
int j;
for( j = 0; j < 20; j++ )
{
VSIFPrintfL( fp, "%s_%d: %s\n", apszRPCTXT20ValItems[i], j+1,
papszItems[j] );
}
CSLDestroy( papszItems );
}
VSIFCloseL( fp );
return CE_None;
}
int OGRIngresDataSource::Open( const char *pszFullName,
char **papszOptions, int bUpdate )
{
CPLAssert( nLayers == 0 );
#define MAX_TARGET_STRING_LENGTH 512
char pszDBTarget[MAX_TARGET_STRING_LENGTH];
/* -------------------------------------------------------------------- */
/* Verify we have a dbname, this parameter is required. */
/* -------------------------------------------------------------------- */
const char *pszDBName = CSLFetchNameValue(papszOptions,"dbname");
if( pszDBName == NULL )
{
CPLError( CE_Failure, CPLE_OpenFailed,
"No DBNAME item provided in INGRES datasource name." );
return FALSE;
}
/* -------------------------------------------------------------------- */
/* Do we have a table list? */
/* -------------------------------------------------------------------- */
char **papszTableNames = NULL;
const char *pszTables = CSLFetchNameValue(papszOptions,"tables");
if( pszTables != NULL )
papszTableNames = CSLTokenizeStringComplex(pszTables,"/",TRUE,FALSE);
/* -------------------------------------------------------------------- */
/* Add support to dynamic vnode if passed */
/* -------------------------------------------------------------------- */
const char *pszHost = CSLFetchNameValue(papszOptions,"host");
if (pszHost)
{
const char *pszInstance = CSLFetchNameValue(papszOptions,"instance");
if (pszInstance == NULL || strlen(pszInstance) != 2)
{
CPLError( CE_Failure, CPLE_OpenFailed,
"instance name must be specified with host." );
return FALSE;
}
/*
** make sure the user name and password are passed too,
** note it could not be zero length.
*/
const char *pszUsername = CSLFetchNameValue(papszOptions,"username");
const char *pszPassword = CSLFetchNameValue(papszOptions,"password");
if (pszUsername == NULL || strlen(pszUsername) == 0)
{
CPLError( CE_Failure, CPLE_OpenFailed,
"user name must be specified in dynamic vnode." );
return FALSE;
}
if (pszPassword == NULL || strlen(pszPassword) == 0)
{
CPLError( CE_Failure, CPLE_OpenFailed,
"password must be specified in dynamic vnode." );
return FALSE;
}
/*
** construct the vnode string, like :
** @host,protocol,port[;attribute=value{;attribute=value}][[user,password]],
** visit for detail
** http://docs.actian.com/ingres/10.0/command-reference-guide/1207-dynamic-vnode-specificationconnect-to-remote-node
*/
sprintf(pszDBTarget, "@%s,%s,%s;%s[%s,%s]::%s ",
pszHost, /* host, compute name or IP address */
"TCP_IP", /* protocal, default with TCP/IP */
pszInstance, /* instance Name */
"" , /* option, Null */
pszUsername, /* user name, could not be empty */
pszPassword, /* pwd */
pszDBName /* database name */
);
CPLDebug("INGRES", pszDBTarget);
}
else
{
/* Remain the database name */
strcpy(pszDBTarget, pszDBName);
}
/* -------------------------------------------------------------------- */
/* Initialize the Ingres API. Should we only do this once per */
/* program run? Really we should also try to terminate the api */
/* on program exit. */
/* -------------------------------------------------------------------- */
IIAPI_INITPARM initParm;
initParm.in_version = IIAPI_VERSION_1;
initParm.in_timeout = -1;
IIapi_initialize( &initParm );
/* -------------------------------------------------------------------- */
/* check effective user and db password */
/* -------------------------------------------------------------------- */
hConn = NULL;
const char *pszEffuser = CSLFetchNameValue(papszOptions,"effuser");
const char *pszDBpwd = CSLFetchNameValue(papszOptions,"dbpwd");
if ( pszEffuser
&& strlen(pszEffuser) > 0
&& pszDBpwd
&& strlen(pszDBpwd) > 0 )
{
if (SetConnParam(&hConn, IIAPI_CP_EFFECTIVE_USER,
(II_PTR)pszEffuser) != IIAPI_ST_SUCCESS
|| SetConnParam(&hConn, IIAPI_CP_DBMS_PASSWORD,
(II_PTR)pszDBpwd) != IIAPI_ST_SUCCESS )
{
return FALSE;
}
}
/* -------------------------------------------------------------------- */
/* Try to connect to the database. */
/* -------------------------------------------------------------------- */
IIAPI_CONNPARM connParm;
IIAPI_WAITPARM waitParm = { -1 };
memset( &connParm, 0, sizeof(connParm) );
connParm.co_genParm.gp_callback = NULL;
connParm.co_genParm.gp_closure = NULL;
connParm.co_target = (II_CHAR *) pszDBTarget;
connParm.co_connHandle = hConn;
connParm.co_tranHandle = NULL;
connParm.co_username =
(II_CHAR*) CSLFetchNameValue(papszOptions,"username");
connParm.co_password =
(II_CHAR*)CSLFetchNameValue(papszOptions,"password");
connParm.co_timeout = -1;
if( CSLFetchNameValue(papszOptions,"timeout") != NULL )
connParm.co_timeout = atoi(CSLFetchNameValue(papszOptions,"timeout"));
IIapi_connect( &connParm );
while( connParm.co_genParm.gp_completed == FALSE )
IIapi_wait( &waitParm );
hConn = connParm.co_connHandle;
if( connParm.co_genParm.gp_status != IIAPI_ST_SUCCESS
|| hConn == NULL )
{
OGRIngresStatement::ReportError( &(connParm.co_genParm),
"Failed to connect to Ingres database." );
return FALSE;
}
pszName = CPLStrdup( pszFullName );
bDSUpdate = bUpdate;
// Check for new or old Ingres spatial library
{
OGRIngresStatement oStmt( hConn );
if( oStmt.ExecuteSQL("SELECT COUNT(*) FROM iicolumns WHERE table_name = 'iiattribute' AND column_name = 'attgeomtype'" ) )
{
char **papszFields;
while( (papszFields = oStmt.GetRow()) )
{
CPLString osCount = papszFields[0];
if( osCount[0] == '0' )
{
bNewIngres = FALSE;
}
else
{
bNewIngres = TRUE;
}
}
}
}
/* -------------------------------------------------------------------- */
/* Get a list of available tables. */
/* -------------------------------------------------------------------- */
if( papszTableNames == NULL )
{
OGRIngresStatement oStmt( hConn );
if( oStmt.ExecuteSQL( "select table_name from iitables where system_use = 'U' and table_name not like 'iietab_%'" ) )
{
char **papszFields;
while( (papszFields = oStmt.GetRow()) )
{
CPLString osTableName = papszFields[0];
osTableName.Trim();
papszTableNames = CSLAddString( papszTableNames,
osTableName );
}
}
}
/* -------------------------------------------------------------------- */
/* Get the schema of the available tables. */
/* -------------------------------------------------------------------- */
int iRecord;
for( iRecord = 0;
papszTableNames != NULL && papszTableNames[iRecord] != NULL;
iRecord++ )
{
OpenTable( papszTableNames[iRecord], bUpdate );
}
CSLDestroy( papszTableNames );
return TRUE;
}
