void object::test<2>()
{
ensure("SRS UTM handle is NULL", NULL != srs_utm_);
ensure("SRS LL handle is NULL", NULL != srs_ll_);
err_ = OSRSetUTM(srs_utm_, 11, TRUE);
ensure_equals("Can't set UTM zone", err_, OGRERR_NONE);
err_ = OSRSetWellKnownGeogCS(srs_utm_, "WGS84");
ensure_equals("Can't set GeogCS", err_, OGRERR_NONE);
err_ = OSRSetWellKnownGeogCS(srs_ll_, "WGS84");
ensure_equals("Can't set GeogCS", err_, OGRERR_NONE);
ct_ = OCTNewCoordinateTransformation(srs_ll_, srs_utm_);
ensure("PROJ.4 missing, transforms not available", NULL != ct_);
const int size = 1;
double x[size] = { -117.5 };
double y[size] = { 32.0 };
double z[size] = { 0.0 };
ensure_equals("OCTTransform() failed",
OCTTransform(ct_, size, x, y, z), TRUE);
ensure("Wrong X from LL to UTM result",
std::fabs(x[0] - 452772.06) <= 0.01);
ensure("Wrong Y from LL to UTM result",
std::fabs(y[0] - 3540544.89) <= 0.01);
ensure("Wrong Z from LL to UTM result",
std::fabs(z[0] - 0.0) <= 0.01);
}
void Reprojection::initialize()
{
Filter::initialize();
checkImpedance();
if (m_inferInputSRS)
{
m_inSRS = getPrevStage().getSpatialReference();
}
#ifdef PDAL_HAVE_GDAL
m_gdal_debug = boost::shared_ptr<pdal::gdal::Debug>( new pdal::gdal::Debug(isDebug(), log()));
m_in_ref_ptr = ReferencePtr(OSRNewSpatialReference(0), OGRSpatialReferenceDeleter());
m_out_ref_ptr = ReferencePtr(OSRNewSpatialReference(0), OGRSpatialReferenceDeleter());
int result = OSRSetFromUserInput(m_in_ref_ptr.get(), m_inSRS.getWKT(pdal::SpatialReference::eCompoundOK).c_str());
if (result != OGRERR_NONE)
{
std::ostringstream msg;
msg << "Could not import input spatial reference for ReprojectionFilter:: "
<< CPLGetLastErrorMsg() << " code: " << result
<< " wkt: '" << m_inSRS.getWKT() << "'";
throw std::runtime_error(msg.str());
}
result = OSRSetFromUserInput(m_out_ref_ptr.get(), m_outSRS.getWKT(pdal::SpatialReference::eCompoundOK).c_str());
if (result != OGRERR_NONE)
{
std::ostringstream msg;
msg << "Could not import output spatial reference for ReprojectionFilter:: "
<< CPLGetLastErrorMsg() << " code: " << result
<< " wkt: '" << m_outSRS.getWKT() << "'";
std::string message(msg.str());
throw std::runtime_error(message);
}
m_transform_ptr = TransformPtr(OCTNewCoordinateTransformation( m_in_ref_ptr.get(), m_out_ref_ptr.get()), OSRTransformDeleter());
if (!m_transform_ptr.get())
{
std::ostringstream msg;
msg << "Could not construct CoordinateTransformation in ReprojectionFilter:: ";
std::string message(msg.str());
throw std::runtime_error(message);
}
#endif
setSpatialReference(m_outSRS);
updateBounds();
return;
}
void InPlaceReprojection::initialize()
{
Filter::initialize();
if (m_inferInputSRS)
{
m_inSRS = getPrevStage().getSpatialReference();
}
#ifdef PDAL_HAVE_GDAL
pdal::GlobalEnvironment::get().getGDALDebug()->addLog(log());
m_in_ref_ptr = ReferencePtr(OSRNewSpatialReference(0), OGRSpatialReferenceDeleter());
m_out_ref_ptr = ReferencePtr(OSRNewSpatialReference(0), OGRSpatialReferenceDeleter());
int result = OSRSetFromUserInput(m_in_ref_ptr.get(), m_inSRS.getWKT(pdal::SpatialReference::eCompoundOK).c_str());
if (result != OGRERR_NONE)
{
std::ostringstream msg;
msg << "Could not import input spatial reference for InPlaceReprojection:: "
<< CPLGetLastErrorMsg() << " code: " << result
<< " wkt: '" << m_inSRS.getWKT() << "'";
throw std::runtime_error(msg.str());
}
result = OSRSetFromUserInput(m_out_ref_ptr.get(), m_outSRS.getWKT(pdal::SpatialReference::eCompoundOK).c_str());
if (result != OGRERR_NONE)
{
std::ostringstream msg;
msg << "Could not import output spatial reference for InPlaceReprojection:: "
<< CPLGetLastErrorMsg() << " code: " << result
<< " wkt: '" << m_outSRS.getWKT() << "'";
std::string message(msg.str());
throw std::runtime_error(message);
}
m_transform_ptr = TransformPtr(OCTNewCoordinateTransformation(m_in_ref_ptr.get(), m_out_ref_ptr.get()), OSRTransformDeleter());
if (!m_transform_ptr.get())
{
std::ostringstream msg;
msg << "Could not construct CoordinateTransformation in InPlaceReprojection:: ";
std::string message(msg.str());
throw std::runtime_error(message);
}
#endif
setSpatialReference(m_outSRS);
Schema& s = getSchemaRef();
s = alterSchema(s);
return;
}
void OgrFileImport::importFeature(MapPart* map_part, OGRFeatureDefnH feature_definition, OGRFeatureH feature, OGRGeometryH geometry)
{
to_map_coord = &OgrFileImport::fromProjected;
auto new_srs = OGR_G_GetSpatialReference(geometry);
if (new_srs && data_srs != new_srs)
{
// New SRS, indeed.
auto transformation = ogr::unique_transformation{ OCTNewCoordinateTransformation(new_srs, map_srs.get()) };
if (!transformation)
{
++no_transformation;
return;
}
// Commit change to data srs and coordinate transformation
data_srs = new_srs;
data_transform = std::move(transformation);
}
if (new_srs)
{
auto error = OGR_G_Transform(geometry, data_transform.get());
if (error)
{
++failed_transformation;
return;
}
}
else if (!drawing_from_projected)
{
to_map_coord = &OgrFileImport::fromDrawing;
}
auto object = importGeometry(map_part, feature, geometry);
if (object && feature_definition)
{
auto num_fields = OGR_FD_GetFieldCount(feature_definition);
for (int i = 0; i < num_fields; ++i)
{
auto value = OGR_F_GetFieldAsString(feature, i);
if (value && qstrlen(value) > 0)
{
auto field_definition = OGR_FD_GetFieldDefn(feature_definition, i);
object->setTag(OGR_Fld_GetNameRef(field_definition), value);
}
}
}
}
void ReprojectionFilter::ready(PointTableRef table)
{
if (m_inferInputSRS)
{
m_inSRS = table.spatialRef();
if (m_inSRS.getWKT().empty())
throw pdal_error("Source data has no spatial reference and none "
"is specified with the 'in_srs' option.");
}
m_in_ref_ptr = ReferencePtr(OSRNewSpatialReference(0),
OGRSpatialReferenceDeleter());
m_out_ref_ptr = ReferencePtr(OSRNewSpatialReference(0),
OGRSpatialReferenceDeleter());
int result =
OSRSetFromUserInput(m_in_ref_ptr.get(),
m_inSRS.getWKT(pdal::SpatialReference::eCompoundOK).c_str());
if (result != OGRERR_NONE)
{
std::ostringstream msg;
msg << "Invalid input spatial reference '" << m_inSRS.getWKT() <<
"'. This is usually caused by a bad value for the 'in_srs'"
"option or an invalid spatial reference in the source file.";
throw pdal_error(msg.str());
}
result = OSRSetFromUserInput(m_out_ref_ptr.get(),
m_outSRS.getWKT(pdal::SpatialReference::eCompoundOK).c_str());
if (result != OGRERR_NONE)
{
std::ostringstream msg;
msg << "Invalid output spatial reference '" << m_outSRS.getWKT() <<
"'. This is usually caused by a bad value for the 'out_srs'"
"option.";
throw pdal_error(msg.str());
}
m_transform_ptr = TransformPtr(
OCTNewCoordinateTransformation(m_in_ref_ptr.get(),
m_out_ref_ptr.get()), OSRTransformDeleter());
if (!m_transform_ptr.get())
{
std::string msg = "Could not construct CoordinateTransformation in "
"ReprojectionFilter:: ";
throw std::runtime_error(msg);
}
setSpatialReference(m_outSRS);
}
void object::test<1>()
{
ensure("SRS UTM handle is NULL", NULL != srs_utm_);
ensure("SRS LL handle is NULL", NULL != srs_ll_);
err_ = OSRSetUTM(srs_utm_, 11, TRUE);
ensure_equals("Can't set UTM zone", err_, OGRERR_NONE);
err_ = OSRSetWellKnownGeogCS(srs_utm_, "WGS84");
ensure_equals("Can't set GeogCS", err_, OGRERR_NONE);
err_ = OSRSetWellKnownGeogCS(srs_ll_, "WGS84");
ensure_equals("Can't set GeogCS", err_, OGRERR_NONE);
ct_ = OCTNewCoordinateTransformation(srs_ll_, srs_utm_);
ensure("PROJ.4 missing, transforms not available", NULL != ct_);
}
void object::test<3>()
{
ensure("SRS UTM handle is NULL", NULL != srs_utm_);
ensure("SRS LL handle is NULL", NULL != srs_ll_);
err_ = OSRSetUTM(srs_utm_, 11, TRUE);
ensure_equals("Can't set UTM zone", err_, OGRERR_NONE);
err_ = OSRSetWellKnownGeogCS(srs_utm_, "WGS84");
ensure_equals("Can't set GeogCS", err_, OGRERR_NONE);
err_ = OSRSetWellKnownGeogCS(srs_ll_, "WGS84");
ensure_equals("Can't set GeogCS", err_, OGRERR_NONE);
ct_ = OCTNewCoordinateTransformation(srs_ll_, srs_utm_);
ensure("PROJ.4 missing, transforms not available", NULL != ct_);
const char* wkt = "POINT(-117.5 32.0)";
OGRGeometryH geom = NULL;
err_ = OGR_G_CreateFromWkt((char**) &wkt, NULL, &geom);
ensure_equals("Can't import geometry from WKT", OGRERR_NONE, err_);
ensure("Can't create geometry", NULL != geom);
err_ = OGR_G_Transform(geom, ct_);
ensure_equals("OGR_G_Transform() failed", err_, OGRERR_NONE);
OGRSpatialReferenceH srs = NULL;
srs = OGR_G_GetSpatialReference(geom);
char* wktSrs = NULL;
err_ = OSRExportToPrettyWkt(srs, &wktSrs, FALSE);
ensure("Exported SRS to WKT is NULL", NULL != wktSrs);
std::string pretty(wktSrs);
ensure_equals("SRS output is incorrect", pretty.substr(0, 6), std::string("PROJCS"));
OGRFree(wktSrs);
OGR_G_DestroyGeometry(geom);
}
static int
GDALInfoReportCorner( GDALDatasetH hDataset,
const char * corner_name,
double x, double y )
{
double dfGeoX, dfGeoY;
const char *pszProjection;
double adfGeoTransform[6];
OGRCoordinateTransformationH hTransform = NULL;
printf( "%-11s ", corner_name );
/* -------------------------------------------------------------------- */
/* Transform the point into georeferenced coordinates. */
/* -------------------------------------------------------------------- */
if( GDALGetGeoTransform( hDataset, adfGeoTransform ) == CE_None )
{
pszProjection = GDALGetProjectionRef(hDataset);
dfGeoX = adfGeoTransform[0] + adfGeoTransform[1] * x
+ adfGeoTransform[2] * y;
dfGeoY = adfGeoTransform[3] + adfGeoTransform[4] * x
+ adfGeoTransform[5] * y;
}
else
{
printf( "(%7.1f,%7.1f)\n", x, y );
return FALSE;
}
/* -------------------------------------------------------------------- */
/* Report the georeferenced coordinates. */
/* -------------------------------------------------------------------- */
if( fabs(dfGeoX) < 181 && fabs(dfGeoY) < 91 )
{
printf( "(%12.7f,%12.7f) ", dfGeoX, dfGeoY );
}
else
{
printf( "(%12.3f,%12.3f) ", dfGeoX, dfGeoY );
}
/* -------------------------------------------------------------------- */
/* Setup transformation to lat/long. */
/* -------------------------------------------------------------------- */
if( pszProjection != NULL && strlen(pszProjection) > 0 )
{
OGRSpatialReferenceH hProj, hLatLong = NULL;
hProj = OSRNewSpatialReference( pszProjection );
if( hProj != NULL )
hLatLong = OSRCloneGeogCS( hProj );
if( hLatLong != NULL )
{
hTransform = OCTNewCoordinateTransformation( hProj, hLatLong );
OSRDestroySpatialReference( hLatLong );
}
if( hProj != NULL )
OSRDestroySpatialReference( hProj );
}
/* -------------------------------------------------------------------- */
/* Transform to latlong and report. */
/* -------------------------------------------------------------------- */
if( hTransform != NULL
&& OCTTransform(hTransform,1,&dfGeoX,&dfGeoY,NULL) )
{
printf( "(%s,", GDALDecToDMS( dfGeoX, "Long", 2 ) );
printf( "%s)", GDALDecToDMS( dfGeoY, "Lat", 2 ) );
}
if( hTransform != NULL )
OCTDestroyCoordinateTransformation( hTransform );
printf( "\n" );
return TRUE;
}
static dErr VHTCaseSetUp_Jako(VHTCase scase)
{
VHTCase_Jako *jako = scase->data;
dErr err;
OGRErr oerr;
dFunctionBegin;
jako->utmref = OSRNewSpatialReference(NULL);
oerr = OSRSetProjCS(jako->utmref,"UTM 22N (WGS84)");dOGRCHK(oerr);
oerr = OSRSetWellKnownGeogCS(jako->utmref,"WGS84");dOGRCHK(oerr);
oerr = OSRSetUTM(jako->utmref,22,1);dOGRCHK(oerr);
oerr = OSRSetLinearUnits(jako->utmref,SRS_UL_METER,1.0);dOGRCHK(oerr);
jako->llref = OSRNewSpatialReference(NULL);
oerr = OSRSetWellKnownGeogCS(jako->llref,"WGS84");dOGRCHK(oerr);
jako->ianref = OSRNewSpatialReference(NULL);
oerr = OSRSetProjCS(jako->ianref,"Stereographic Greenland (WGS84)");dOGRCHK(oerr);
oerr = OSRSetWellKnownGeogCS(jako->ianref,"WGS84");dOGRCHK(oerr);
oerr = OSRSetStereographic(jako->ianref,70.0,-45.0,100.0,-217.75e3,-2302.0e3);dOGRCHK(oerr);
// The computational domain is in UTM 22N
jako->myref = OSRNewSpatialReference(NULL);
oerr = OSRSetProjCS(jako->myref,"Computational Domain: UTM 22N (WGS84)");dOGRCHK(oerr);
oerr = OSRSetWellKnownGeogCS(jako->myref,"WGS84");dOGRCHK(oerr);
oerr = OSRSetUTM(jako->myref,22,1);dOGRCHK(oerr);
oerr = OSRSetLinearUnits(jako->myref,SRS_UL_METER,1.0);dOGRCHK(oerr);
jako->fromutm = OCTNewCoordinateTransformation(jako->utmref,jako->myref);
jako->fromll = OCTNewCoordinateTransformation(jako->llref,jako->myref);
jako->fromian = OCTNewCoordinateTransformation(jako->ianref,jako->myref);
if (jako->verbose) {err = VHTCaseView_Jako(scase,PETSC_VIEWER_STDOUT_WORLD);dCHK(err);}
if (1) {
GDALProgressFunc gdalprogress = jako->verbose ? GDALTermProgress : GDALDummyProgress;
double x0,y0,Lx,Ly,dx,dy;
GDALDatasetH filedata;
GDALErr gerr;
GDALRasterBandH band;
CPLErr cplerr;
x0 = scase->bbox[0][0];
y0 = scase->bbox[1][0];
Lx = scase->bbox[0][1] - x0;
Ly = scase->bbox[1][1] - y0;
// It appears from gdalwarp.cpp that pixels are cell centered
dx = Lx / jako->nx;
dy = Ly / jako->ny;
// Extend the domain in the positive direction for slope evaluation
jako->nx += 2;
jako->ny += 2;
Lx += 2*dx;
Ly += 2*dy;
// Convert a pixel to a physical coordinate in the current projection
jako->mygeo[0] = x0 + dx/2;
jako->mygeo[1] = dx;
jako->mygeo[2] = 0;
jako->mygeo[3] = y0 + Ly - dy/2; // Physical coordinates are "y up", pixels are "y down"
jako->mygeo[4] = 0;
jako->mygeo[5] = -dy;
// Convert a physical coordinate in the current projection to a pixel coordinate
gerr = GDALInvGeoTransform(jako->mygeo,jako->myinvgeo);dGDALCHK(gerr);
if (jako->verbose) {
dInt i,j;
double a,b;
err = dRealTableView(3,2,&scase->bbox[0][0],PETSC_VIEWER_STDOUT_WORLD,"bbox");dCHK(err);
err = dRealTableView(2,3,jako->mygeo,PETSC_VIEWER_STDOUT_WORLD,"mygeo");dCHK(err);
GDALApplyGeoTransform(jako->mygeo,0,0,&a,&b); printf("geo[0,0] = %f,%f\n",a,b);
GDALApplyGeoTransform(jako->mygeo,1,1,&a,&b); printf("geo[1,1] = %f,%f\n",a,b);
GDALApplyGeoTransform(jako->mygeo,0.5,0.5,&a,&b); printf("geo[0.5,0.5] = %f,%f\n",a,b);
err = JakoFindPixel(scase,(dReal[]){scase->bbox[0][0],scase->bbox[1][0]},&i,&j);dCHK(err);
printf("xmin,ymin: (%d,%d)\n",i,j);
err = JakoFindPixel(scase,(dReal[]){scase->bbox[0][1],scase->bbox[1][1]},&i,&j);dCHK(err);
printf("xmax,ymax: (%d,%d)\n",i,j);
}
static CPLErr ProcessLayer(
OGRLayerH hSrcLayer, int bSRSIsSet,
GDALDatasetH hDstDS, std::vector<int> anBandList,
const std::vector<double> &adfBurnValues, int b3D, int bInverse,
const char *pszBurnAttribute, char **papszRasterizeOptions,
GDALProgressFunc pfnProgress, void* pProgressData )
{
/* -------------------------------------------------------------------- */
/* Checkout that SRS are the same. */
/* If -a_srs is specified, skip the test */
/* -------------------------------------------------------------------- */
OGRCoordinateTransformationH hCT = NULL;
if (!bSRSIsSet)
{
OGRSpatialReferenceH hDstSRS = NULL;
if( GDALGetProjectionRef( hDstDS ) != NULL )
{
char *pszProjection;
pszProjection = (char *) GDALGetProjectionRef( hDstDS );
hDstSRS = OSRNewSpatialReference(NULL);
if( OSRImportFromWkt( hDstSRS, &pszProjection ) != OGRERR_NONE )
{
OSRDestroySpatialReference(hDstSRS);
hDstSRS = NULL;
}
}
OGRSpatialReferenceH hSrcSRS = OGR_L_GetSpatialRef(hSrcLayer);
if( hDstSRS != NULL && hSrcSRS != NULL )
{
if( OSRIsSame(hSrcSRS, hDstSRS) == FALSE )
{
hCT = OCTNewCoordinateTransformation(hSrcSRS, hDstSRS);
if( hCT == NULL )
{
CPLError(CE_Warning, CPLE_AppDefined,
"The output raster dataset and the input vector layer do not have the same SRS.\n"
"And reprojection of input data did not work. Results might be incorrect.");
}
}
}
else if( hDstSRS != NULL && hSrcSRS == NULL )
{
CPLError(CE_Warning, CPLE_AppDefined,
"The output raster dataset has a SRS, but the input vector layer SRS is unknown.\n"
"Ensure input vector has the same SRS, otherwise results might be incorrect.");
}
else if( hDstSRS == NULL && hSrcSRS != NULL )
{
CPLError(CE_Warning, CPLE_AppDefined,
"The input vector layer has a SRS, but the output raster dataset SRS is unknown.\n"
"Ensure output raster dataset has the same SRS, otherwise results might be incorrect.");
}
if( hDstSRS != NULL )
{
OSRDestroySpatialReference(hDstSRS);
}
}
/* -------------------------------------------------------------------- */
/* Get field index, and check. */
/* -------------------------------------------------------------------- */
int iBurnField = -1;
if( pszBurnAttribute )
{
iBurnField = OGR_FD_GetFieldIndex( OGR_L_GetLayerDefn( hSrcLayer ),
pszBurnAttribute );
if( iBurnField == -1 )
{
CPLError(CE_Failure, CPLE_AppDefined, "Failed to find field %s on layer %s, skipping.",
pszBurnAttribute,
OGR_FD_GetName( OGR_L_GetLayerDefn( hSrcLayer ) ) );
if( hCT != NULL )
OCTDestroyCoordinateTransformation(hCT);
return CE_Failure;
}
}
/* -------------------------------------------------------------------- */
/* Collect the geometries from this layer, and build list of */
/* burn values. */
/* -------------------------------------------------------------------- */
OGRFeatureH hFeat;
std::vector<OGRGeometryH> ahGeometries;
std::vector<double> adfFullBurnValues;
OGR_L_ResetReading( hSrcLayer );
while( (hFeat = OGR_L_GetNextFeature( hSrcLayer )) != NULL )
{
OGRGeometryH hGeom;
if( OGR_F_GetGeometryRef( hFeat ) == NULL )
{
OGR_F_Destroy( hFeat );
continue;
}
hGeom = OGR_G_Clone( OGR_F_GetGeometryRef( hFeat ) );
if( hCT != NULL )
{
if( OGR_G_Transform(hGeom, hCT) != OGRERR_NONE )
{
OGR_F_Destroy( hFeat );
OGR_G_DestroyGeometry(hGeom);
continue;
}
}
ahGeometries.push_back( hGeom );
for( unsigned int iBand = 0; iBand < anBandList.size(); iBand++ )
{
if( adfBurnValues.size() > 0 )
adfFullBurnValues.push_back(
adfBurnValues[MIN(iBand,adfBurnValues.size()-1)] );
else if( pszBurnAttribute )
{
adfFullBurnValues.push_back( OGR_F_GetFieldAsDouble( hFeat, iBurnField ) );
}
/* I have made the 3D option exclusive to other options since it
can be used to modify the value from "-burn value" or
"-a attribute_name" */
if( b3D )
{
// TODO: get geometry "z" value
/* Points and Lines will have their "z" values collected at the
point and line levels respectively. However filled polygons
(GDALdllImageFilledPolygon) can use some help by getting
their "z" values here. */
adfFullBurnValues.push_back( 0.0 );
}
}
OGR_F_Destroy( hFeat );
}
if( hCT != NULL )
OCTDestroyCoordinateTransformation(hCT);
/* -------------------------------------------------------------------- */
/* If we are in inverse mode, we add one extra ring around the */
/* whole dataset to invert the concept of insideness and then */
/* merge everything into one geometry collection. */
/* -------------------------------------------------------------------- */
if( bInverse )
{
if( ahGeometries.size() == 0 )
{
for( unsigned int iBand = 0; iBand < anBandList.size(); iBand++ )
{
if( adfBurnValues.size() > 0 )
adfFullBurnValues.push_back(
adfBurnValues[MIN(iBand,adfBurnValues.size()-1)] );
else /* FIXME? Not sure what to do exactly in the else case, but we must insert a value */
adfFullBurnValues.push_back( 0.0 );
}
}
InvertGeometries( hDstDS, ahGeometries );
}
/* -------------------------------------------------------------------- */
/* Perform the burn. */
/* -------------------------------------------------------------------- */
CPLErr eErr = GDALRasterizeGeometries( hDstDS, static_cast<int>(anBandList.size()), &(anBandList[0]),
static_cast<int>(ahGeometries.size()), &(ahGeometries[0]),
NULL, NULL, &(adfFullBurnValues[0]),
papszRasterizeOptions,
pfnProgress, pProgressData );
/* -------------------------------------------------------------------- */
/* Cleanup geometries. */
/* -------------------------------------------------------------------- */
int iGeom;
for( iGeom = static_cast<int>(ahGeometries.size())-1; iGeom >= 0; iGeom-- )
OGR_G_DestroyGeometry( ahGeometries[iGeom] );
return eErr;
}
int main( int argc, char ** argv )
{
GDALDatasetH hDataset;
GDALRasterBandH hBand;
int i, iBand;
double adfGeoTransform[6];
GDALDriverH hDriver;
char **papszMetadata;
int bComputeMinMax = FALSE, bSample = FALSE;
int bShowGCPs = TRUE, bShowMetadata = TRUE, bShowRAT=TRUE;
int bStats = FALSE, bApproxStats = TRUE, iMDD;
int bShowColorTable = TRUE, bComputeChecksum = FALSE;
int bReportHistograms = FALSE;
const char *pszFilename = NULL;
char **papszExtraMDDomains = NULL, **papszFileList;
const char *pszProjection = NULL;
OGRCoordinateTransformationH hTransform = NULL;
/* Check that we are running against at least GDAL 1.5 */
/* Note to developers : if we use newer API, please change the requirement */
if (atoi(GDALVersionInfo("VERSION_NUM")) < 1500)
{
fprintf(stderr, "At least, GDAL >= 1.5.0 is required for this version of %s, "
"which was compiled against GDAL %s\n", argv[0], GDAL_RELEASE_NAME);
exit(1);
}
/* Must process GDAL_SKIP before GDALAllRegister(), but we can't call */
/* GDALGeneralCmdLineProcessor before it needs the drivers to be registered */
/* for the --format or --formats options */
for( i = 1; i < argc; i++ )
{
if( EQUAL(argv[i],"--config") && i + 2 < argc && EQUAL(argv[i + 1], "GDAL_SKIP") )
{
CPLSetConfigOption( argv[i+1], argv[i+2] );
i += 2;
}
}
GDALAllRegister();
argc = GDALGeneralCmdLineProcessor( argc, &argv, 0 );
if( argc < 1 )
exit( -argc );
/* -------------------------------------------------------------------- */
/* Parse arguments. */
/* -------------------------------------------------------------------- */
for( i = 1; i < argc; i++ )
{
if( EQUAL(argv[i], "--utility_version") )
{
printf("%s was compiled against GDAL %s and is running against GDAL %s\n",
argv[0], GDAL_RELEASE_NAME, GDALVersionInfo("RELEASE_NAME"));
return 0;
}
else if( EQUAL(argv[i], "-mm") )
bComputeMinMax = TRUE;
else if( EQUAL(argv[i], "-hist") )
bReportHistograms = TRUE;
else if( EQUAL(argv[i], "-stats") )
{
bStats = TRUE;
bApproxStats = FALSE;
}
else if( EQUAL(argv[i], "-approx_stats") )
{
bStats = TRUE;
bApproxStats = TRUE;
}
else if( EQUAL(argv[i], "-sample") )
bSample = TRUE;
else if( EQUAL(argv[i], "-checksum") )
bComputeChecksum = TRUE;
else if( EQUAL(argv[i], "-nogcp") )
bShowGCPs = FALSE;
else if( EQUAL(argv[i], "-nomd") )
bShowMetadata = FALSE;
else if( EQUAL(argv[i], "-norat") )
bShowRAT = FALSE;
else if( EQUAL(argv[i], "-noct") )
bShowColorTable = FALSE;
else if( EQUAL(argv[i], "-mdd") && i < argc-1 )
papszExtraMDDomains = CSLAddString( papszExtraMDDomains,
argv[++i] );
else if( argv[i][0] == '-' )
Usage();
else if( pszFilename == NULL )
pszFilename = argv[i];
else
Usage();
}
if( pszFilename == NULL )
Usage();
/* -------------------------------------------------------------------- */
/* Open dataset. */
/* -------------------------------------------------------------------- */
hDataset = GDALOpen( pszFilename, GA_ReadOnly );
if( hDataset == NULL )
{
fprintf( stderr,
"gdalinfo failed - unable to open '%s'.\n",
pszFilename );
CSLDestroy( argv );
GDALDumpOpenDatasets( stderr );
GDALDestroyDriverManager();
CPLDumpSharedList( NULL );
exit( 1 );
}
/* -------------------------------------------------------------------- */
/* Report general info. */
/* -------------------------------------------------------------------- */
hDriver = GDALGetDatasetDriver( hDataset );
printf( "Driver: %s/%s\n",
GDALGetDriverShortName( hDriver ),
GDALGetDriverLongName( hDriver ) );
papszFileList = GDALGetFileList( hDataset );
if( CSLCount(papszFileList) == 0 )
{
printf( "Files: none associated\n" );
}
else
{
printf( "Files: %s\n", papszFileList[0] );
for( i = 1; papszFileList[i] != NULL; i++ )
printf( " %s\n", papszFileList[i] );
}
CSLDestroy( papszFileList );
printf( "Size is %d, %d\n",
GDALGetRasterXSize( hDataset ),
GDALGetRasterYSize( hDataset ) );
/* -------------------------------------------------------------------- */
/* Report projection. */
/* -------------------------------------------------------------------- */
if( GDALGetProjectionRef( hDataset ) != NULL )
{
OGRSpatialReferenceH hSRS;
char *pszProjection;
pszProjection = (char *) GDALGetProjectionRef( hDataset );
hSRS = OSRNewSpatialReference(NULL);
if( OSRImportFromWkt( hSRS, &pszProjection ) == CE_None )
{
char *pszPrettyWkt = NULL;
OSRExportToPrettyWkt( hSRS, &pszPrettyWkt, FALSE );
printf( "Coordinate System is:\n%s\n", pszPrettyWkt );
CPLFree( pszPrettyWkt );
}
else
printf( "Coordinate System is `%s'\n",
GDALGetProjectionRef( hDataset ) );
OSRDestroySpatialReference( hSRS );
}
/* -------------------------------------------------------------------- */
/* Report Geotransform. */
/* -------------------------------------------------------------------- */
if( GDALGetGeoTransform( hDataset, adfGeoTransform ) == CE_None )
{
if( adfGeoTransform[2] == 0.0 && adfGeoTransform[4] == 0.0 )
{
printf( "Origin = (%.15f,%.15f)\n",
adfGeoTransform[0], adfGeoTransform[3] );
printf( "Pixel Size = (%.15f,%.15f)\n",
adfGeoTransform[1], adfGeoTransform[5] );
}
else
printf( "GeoTransform =\n"
" %.16g, %.16g, %.16g\n"
" %.16g, %.16g, %.16g\n",
adfGeoTransform[0],
adfGeoTransform[1],
adfGeoTransform[2],
adfGeoTransform[3],
adfGeoTransform[4],
adfGeoTransform[5] );
}
/* -------------------------------------------------------------------- */
/* Report GCPs. */
/* -------------------------------------------------------------------- */
if( bShowGCPs && GDALGetGCPCount( hDataset ) > 0 )
{
if (GDALGetGCPProjection(hDataset) != NULL)
{
OGRSpatialReferenceH hSRS;
char *pszProjection;
pszProjection = (char *) GDALGetGCPProjection( hDataset );
hSRS = OSRNewSpatialReference(NULL);
if( OSRImportFromWkt( hSRS, &pszProjection ) == CE_None )
{
char *pszPrettyWkt = NULL;
OSRExportToPrettyWkt( hSRS, &pszPrettyWkt, FALSE );
printf( "GCP Projection = \n%s\n", pszPrettyWkt );
CPLFree( pszPrettyWkt );
}
else
printf( "GCP Projection = %s\n",
GDALGetGCPProjection( hDataset ) );
OSRDestroySpatialReference( hSRS );
}
for( i = 0; i < GDALGetGCPCount(hDataset); i++ )
{
const GDAL_GCP *psGCP;
psGCP = GDALGetGCPs( hDataset ) + i;
printf( "GCP[%3d]: Id=%s, Info=%s\n"
" (%.15g,%.15g) -> (%.15g,%.15g,%.15g)\n",
i, psGCP->pszId, psGCP->pszInfo,
psGCP->dfGCPPixel, psGCP->dfGCPLine,
psGCP->dfGCPX, psGCP->dfGCPY, psGCP->dfGCPZ );
}
}
/* -------------------------------------------------------------------- */
/* Report metadata. */
/* -------------------------------------------------------------------- */
papszMetadata = (bShowMetadata) ? GDALGetMetadata( hDataset, NULL ) : NULL;
if( bShowMetadata && CSLCount(papszMetadata) > 0 )
{
printf( "Metadata:\n" );
for( i = 0; papszMetadata[i] != NULL; i++ )
{
printf( " %s\n", papszMetadata[i] );
}
}
for( iMDD = 0; bShowMetadata && iMDD < CSLCount(papszExtraMDDomains); iMDD++ )
{
papszMetadata = GDALGetMetadata( hDataset, papszExtraMDDomains[iMDD] );
if( CSLCount(papszMetadata) > 0 )
{
printf( "Metadata (%s):\n", papszExtraMDDomains[iMDD]);
for( i = 0; papszMetadata[i] != NULL; i++ )
{
printf( " %s\n", papszMetadata[i] );
}
}
}
/* -------------------------------------------------------------------- */
/* Report "IMAGE_STRUCTURE" metadata. */
/* -------------------------------------------------------------------- */
papszMetadata = (bShowMetadata) ? GDALGetMetadata( hDataset, "IMAGE_STRUCTURE" ) : NULL;
if( bShowMetadata && CSLCount(papszMetadata) > 0 )
{
printf( "Image Structure Metadata:\n" );
for( i = 0; papszMetadata[i] != NULL; i++ )
{
printf( " %s\n", papszMetadata[i] );
}
}
/* -------------------------------------------------------------------- */
/* Report subdatasets. */
/* -------------------------------------------------------------------- */
papszMetadata = GDALGetMetadata( hDataset, "SUBDATASETS" );
if( CSLCount(papszMetadata) > 0 )
{
printf( "Subdatasets:\n" );
for( i = 0; papszMetadata[i] != NULL; i++ )
{
printf( " %s\n", papszMetadata[i] );
}
}
/* -------------------------------------------------------------------- */
/* Report geolocation. */
/* -------------------------------------------------------------------- */
papszMetadata = (bShowMetadata) ? GDALGetMetadata( hDataset, "GEOLOCATION" ) : NULL;
if( bShowMetadata && CSLCount(papszMetadata) > 0 )
{
printf( "Geolocation:\n" );
for( i = 0; papszMetadata[i] != NULL; i++ )
{
printf( " %s\n", papszMetadata[i] );
}
}
/* -------------------------------------------------------------------- */
/* Report RPCs */
/* -------------------------------------------------------------------- */
papszMetadata = (bShowMetadata) ? GDALGetMetadata( hDataset, "RPC" ) : NULL;
if( bShowMetadata && CSLCount(papszMetadata) > 0 )
{
printf( "RPC Metadata:\n" );
for( i = 0; papszMetadata[i] != NULL; i++ )
{
printf( " %s\n", papszMetadata[i] );
}
}
/* -------------------------------------------------------------------- */
/* Setup projected to lat/long transform if appropriate. */
/* -------------------------------------------------------------------- */
if( GDALGetGeoTransform( hDataset, adfGeoTransform ) == CE_None )
pszProjection = GDALGetProjectionRef(hDataset);
if( pszProjection != NULL && strlen(pszProjection) > 0 )
{
OGRSpatialReferenceH hProj, hLatLong = NULL;
hProj = OSRNewSpatialReference( pszProjection );
if( hProj != NULL )
hLatLong = OSRCloneGeogCS( hProj );
if( hLatLong != NULL )
{
CPLPushErrorHandler( CPLQuietErrorHandler );
hTransform = OCTNewCoordinateTransformation( hProj, hLatLong );
CPLPopErrorHandler();
OSRDestroySpatialReference( hLatLong );
}
if( hProj != NULL )
OSRDestroySpatialReference( hProj );
}
/* -------------------------------------------------------------------- */
/* Report corners. */
/* -------------------------------------------------------------------- */
printf( "Corner Coordinates:\n" );
GDALInfoReportCorner( hDataset, hTransform, "Upper Left",
0.0, 0.0 );
GDALInfoReportCorner( hDataset, hTransform, "Lower Left",
0.0, GDALGetRasterYSize(hDataset));
GDALInfoReportCorner( hDataset, hTransform, "Upper Right",
GDALGetRasterXSize(hDataset), 0.0 );
GDALInfoReportCorner( hDataset, hTransform, "Lower Right",
GDALGetRasterXSize(hDataset),
GDALGetRasterYSize(hDataset) );
GDALInfoReportCorner( hDataset, hTransform, "Center",
GDALGetRasterXSize(hDataset)/2.0,
GDALGetRasterYSize(hDataset)/2.0 );
if( hTransform != NULL )
{
OCTDestroyCoordinateTransformation( hTransform );
hTransform = NULL;
}
/* ==================================================================== */
/* Loop over bands. */
/* ==================================================================== */
for( iBand = 0; iBand < GDALGetRasterCount( hDataset ); iBand++ )
{
double dfMin, dfMax, adfCMinMax[2], dfNoData;
int bGotMin, bGotMax, bGotNodata, bSuccess;
int nBlockXSize, nBlockYSize, nMaskFlags;
double dfMean, dfStdDev;
GDALColorTableH hTable;
CPLErr eErr;
hBand = GDALGetRasterBand( hDataset, iBand+1 );
if( bSample )
{
float afSample[10000];
int nCount;
nCount = GDALGetRandomRasterSample( hBand, 10000, afSample );
printf( "Got %d samples.\n", nCount );
}
GDALGetBlockSize( hBand, &nBlockXSize, &nBlockYSize );
printf( "Band %d Block=%dx%d Type=%s, ColorInterp=%s\n", iBand+1,
nBlockXSize, nBlockYSize,
GDALGetDataTypeName(
GDALGetRasterDataType(hBand)),
GDALGetColorInterpretationName(
GDALGetRasterColorInterpretation(hBand)) );
if( GDALGetDescription( hBand ) != NULL
&& strlen(GDALGetDescription( hBand )) > 0 )
printf( " Description = %s\n", GDALGetDescription(hBand) );
dfMin = GDALGetRasterMinimum( hBand, &bGotMin );
dfMax = GDALGetRasterMaximum( hBand, &bGotMax );
if( bGotMin || bGotMax || bComputeMinMax )
{
printf( " " );
if( bGotMin )
printf( "Min=%.3f ", dfMin );
if( bGotMax )
printf( "Max=%.3f ", dfMax );
if( bComputeMinMax )
{
CPLErrorReset();
GDALComputeRasterMinMax( hBand, FALSE, adfCMinMax );
if (CPLGetLastErrorType() == CE_None)
{
printf( " Computed Min/Max=%.3f,%.3f",
adfCMinMax[0], adfCMinMax[1] );
}
}
printf( "\n" );
}
eErr = GDALGetRasterStatistics( hBand, bApproxStats, bStats,
&dfMin, &dfMax, &dfMean, &dfStdDev );
if( eErr == CE_None )
{
printf( " Minimum=%.3f, Maximum=%.3f, Mean=%.3f, StdDev=%.3f\n",
dfMin, dfMax, dfMean, dfStdDev );
}
if( bReportHistograms )
{
int nBucketCount, *panHistogram = NULL;
eErr = GDALGetDefaultHistogram( hBand, &dfMin, &dfMax,
&nBucketCount, &panHistogram,
TRUE, GDALTermProgress, NULL );
if( eErr == CE_None )
{
int iBucket;
printf( " %d buckets from %g to %g:\n ",
nBucketCount, dfMin, dfMax );
for( iBucket = 0; iBucket < nBucketCount; iBucket++ )
printf( "%d ", panHistogram[iBucket] );
printf( "\n" );
CPLFree( panHistogram );
}
}
if ( bComputeChecksum)
{
printf( " Checksum=%d\n",
GDALChecksumImage(hBand, 0, 0,
GDALGetRasterXSize(hDataset),
GDALGetRasterYSize(hDataset)));
}
dfNoData = GDALGetRasterNoDataValue( hBand, &bGotNodata );
if( bGotNodata )
{
printf( " NoData Value=%.18g\n", dfNoData );
}
if( GDALGetOverviewCount(hBand) > 0 )
{
int iOverview;
printf( " Overviews: " );
for( iOverview = 0;
iOverview < GDALGetOverviewCount(hBand);
iOverview++ )
{
GDALRasterBandH hOverview;
const char *pszResampling = NULL;
if( iOverview != 0 )
printf( ", " );
hOverview = GDALGetOverview( hBand, iOverview );
printf( "%dx%d",
GDALGetRasterBandXSize( hOverview ),
GDALGetRasterBandYSize( hOverview ) );
pszResampling =
GDALGetMetadataItem( hOverview, "RESAMPLING", "" );
if( pszResampling != NULL
&& EQUALN(pszResampling,"AVERAGE_BIT2",12) )
printf( "*" );
}
printf( "\n" );
if ( bComputeChecksum)
{
printf( " Overviews checksum: " );
for( iOverview = 0;
iOverview < GDALGetOverviewCount(hBand);
iOverview++ )
{
GDALRasterBandH hOverview;
if( iOverview != 0 )
printf( ", " );
hOverview = GDALGetOverview( hBand, iOverview );
printf( "%d",
GDALChecksumImage(hOverview, 0, 0,
GDALGetRasterBandXSize(hOverview),
GDALGetRasterBandYSize(hOverview)));
}
printf( "\n" );
}
}
if( GDALHasArbitraryOverviews( hBand ) )
{
printf( " Overviews: arbitrary\n" );
}
nMaskFlags = GDALGetMaskFlags( hBand );
if( (nMaskFlags & (GMF_NODATA|GMF_ALL_VALID)) == 0 )
{
GDALRasterBandH hMaskBand = GDALGetMaskBand(hBand) ;
printf( " Mask Flags: " );
if( nMaskFlags & GMF_PER_DATASET )
printf( "PER_DATASET " );
if( nMaskFlags & GMF_ALPHA )
printf( "ALPHA " );
if( nMaskFlags & GMF_NODATA )
printf( "NODATA " );
if( nMaskFlags & GMF_ALL_VALID )
printf( "ALL_VALID " );
printf( "\n" );
if( hMaskBand != NULL &&
GDALGetOverviewCount(hMaskBand) > 0 )
{
int iOverview;
printf( " Overviews of mask band: " );
for( iOverview = 0;
iOverview < GDALGetOverviewCount(hMaskBand);
iOverview++ )
{
GDALRasterBandH hOverview;
if( iOverview != 0 )
printf( ", " );
hOverview = GDALGetOverview( hMaskBand, iOverview );
printf( "%dx%d",
GDALGetRasterBandXSize( hOverview ),
GDALGetRasterBandYSize( hOverview ) );
}
printf( "\n" );
}
}
if( strlen(GDALGetRasterUnitType(hBand)) > 0 )
{
printf( " Unit Type: %s\n", GDALGetRasterUnitType(hBand) );
}
if( GDALGetRasterCategoryNames(hBand) != NULL )
{
char **papszCategories = GDALGetRasterCategoryNames(hBand);
int i;
printf( " Categories:\n" );
for( i = 0; papszCategories[i] != NULL; i++ )
printf( " %3d: %s\n", i, papszCategories[i] );
}
if( GDALGetRasterScale( hBand, &bSuccess ) != 1.0
|| GDALGetRasterOffset( hBand, &bSuccess ) != 0.0 )
printf( " Offset: %.15g, Scale:%.15g\n",
GDALGetRasterOffset( hBand, &bSuccess ),
GDALGetRasterScale( hBand, &bSuccess ) );
papszMetadata = (bShowMetadata) ? GDALGetMetadata( hBand, NULL ) : NULL;
if( bShowMetadata && CSLCount(papszMetadata) > 0 )
{
printf( " Metadata:\n" );
for( i = 0; papszMetadata[i] != NULL; i++ )
{
printf( " %s\n", papszMetadata[i] );
}
}
papszMetadata = (bShowMetadata) ? GDALGetMetadata( hBand, "IMAGE_STRUCTURE" ) : NULL;
if( bShowMetadata && CSLCount(papszMetadata) > 0 )
{
printf( " Image Structure Metadata:\n" );
for( i = 0; papszMetadata[i] != NULL; i++ )
{
printf( " %s\n", papszMetadata[i] );
}
}
if( GDALGetRasterColorInterpretation(hBand) == GCI_PaletteIndex
&& (hTable = GDALGetRasterColorTable( hBand )) != NULL )
{
int i;
printf( " Color Table (%s with %d entries)\n",
GDALGetPaletteInterpretationName(
GDALGetPaletteInterpretation( hTable )),
GDALGetColorEntryCount( hTable ) );
if (bShowColorTable)
{
for( i = 0; i < GDALGetColorEntryCount( hTable ); i++ )
{
GDALColorEntry sEntry;
GDALGetColorEntryAsRGB( hTable, i, &sEntry );
printf( " %3d: %d,%d,%d,%d\n",
i,
sEntry.c1,
sEntry.c2,
sEntry.c3,
sEntry.c4 );
}
}
}
if( bShowRAT && GDALGetDefaultRAT( hBand ) != NULL )
{
GDALRasterAttributeTableH hRAT = GDALGetDefaultRAT( hBand );
GDALRATDumpReadable( hRAT, NULL );
}
}
GDALClose( hDataset );
CSLDestroy( papszExtraMDDomains );
CSLDestroy( argv );
GDALDumpOpenDatasets( stderr );
GDALDestroyDriverManager();
CPLDumpSharedList( NULL );
CPLCleanupTLS();
exit( 0 );
}
MAIN_START(argc, argv)
{
// Check that we are running against at least GDAL 1.4.
// Note to developers: if we use newer API, please change the requirement.
if( atoi(GDALVersionInfo("VERSION_NUM")) < 1400 )
{
fprintf(stderr,
"At least, GDAL >= 1.4.0 is required for this version of %s, "
"which was compiled against GDAL %s\n",
argv[0], GDAL_RELEASE_NAME);
exit(1);
}
GDALAllRegister();
OGRRegisterAll();
argc = GDALGeneralCmdLineProcessor( argc, &argv, 0 );
if( argc < 1 )
exit( -argc );
/* -------------------------------------------------------------------- */
/* Get commandline arguments other than the GDAL raster filenames. */
/* -------------------------------------------------------------------- */
const char* pszIndexLayerName = nullptr;
const char *index_filename = nullptr;
const char *tile_index = "location";
const char* pszDriverName = nullptr;
size_t nMaxFieldSize = 254;
bool write_absolute_path = false;
char* current_path = nullptr;
bool skip_different_projection = false;
const char *pszTargetSRS = "";
bool bSetTargetSRS = false;
const char* pszSrcSRSName = nullptr;
int i_SrcSRSName = -1;
bool bSrcSRSFormatSpecified = false;
SrcSRSFormat eSrcSRSFormat = FORMAT_AUTO;
int iArg = 1; // Used after for.
for( ; iArg < argc; iArg++ )
{
if( EQUAL(argv[iArg], "--utility_version") )
{
printf("%s was compiled against GDAL %s and is running against "
"GDAL %s\n",
argv[0], GDAL_RELEASE_NAME, GDALVersionInfo("RELEASE_NAME"));
CSLDestroy( argv );
return 0;
}
else if( EQUAL(argv[iArg],"--help") )
Usage(nullptr);
else if( (strcmp(argv[iArg],"-f") == 0 || strcmp(argv[iArg],"-of") == 0) )
{
CHECK_HAS_ENOUGH_ADDITIONAL_ARGS(1);
pszDriverName = argv[++iArg];
}
else if( strcmp(argv[iArg],"-lyr_name") == 0 )
{
CHECK_HAS_ENOUGH_ADDITIONAL_ARGS(1);
pszIndexLayerName = argv[++iArg];
}
else if( strcmp(argv[iArg],"-tileindex") == 0 )
{
CHECK_HAS_ENOUGH_ADDITIONAL_ARGS(1);
tile_index = argv[++iArg];
}
else if( strcmp(argv[iArg],"-t_srs") == 0 )
{
CHECK_HAS_ENOUGH_ADDITIONAL_ARGS(1);
pszTargetSRS = argv[++iArg];
bSetTargetSRS = true;
}
else if ( strcmp(argv[iArg],"-write_absolute_path") == 0 )
{
write_absolute_path = true;
}
else if ( strcmp(argv[iArg],"-skip_different_projection") == 0 )
{
skip_different_projection = true;
}
else if( strcmp(argv[iArg], "-src_srs_name") == 0 )
{
CHECK_HAS_ENOUGH_ADDITIONAL_ARGS(1);
pszSrcSRSName = argv[++iArg];
}
else if( strcmp(argv[iArg], "-src_srs_format") == 0 )
{
const char* pszFormat;
bSrcSRSFormatSpecified = true;
CHECK_HAS_ENOUGH_ADDITIONAL_ARGS(1);
pszFormat = argv[++iArg];
if( EQUAL(pszFormat, "AUTO") )
eSrcSRSFormat = FORMAT_AUTO;
else if( EQUAL(pszFormat, "WKT") )
eSrcSRSFormat = FORMAT_WKT;
else if( EQUAL(pszFormat, "EPSG") )
eSrcSRSFormat = FORMAT_EPSG;
else if( EQUAL(pszFormat, "PROJ") )
eSrcSRSFormat = FORMAT_PROJ;
}
else if( argv[iArg][0] == '-' )
Usage(CPLSPrintf("Unknown option name '%s'", argv[iArg]));
else if( index_filename == nullptr )
{
index_filename = argv[iArg];
iArg++;
break;
}
}
if( index_filename == nullptr )
Usage("No index filename specified.");
if( iArg == argc )
Usage("No file to index specified.");
if( bSrcSRSFormatSpecified && pszSrcSRSName == nullptr )
Usage("-src_srs_name must be specified when -src_srs_format is "
"specified.");
/* -------------------------------------------------------------------- */
/* Create and validate target SRS if given. */
/* -------------------------------------------------------------------- */
OGRSpatialReferenceH hTargetSRS = nullptr;
if( bSetTargetSRS )
{
if( skip_different_projection )
{
fprintf( stderr,
"Warning : -skip_different_projection does not apply "
"when -t_srs is requested.\n" );
}
hTargetSRS = OSRNewSpatialReference("");
OSRSetAxisMappingStrategy(hTargetSRS, OAMS_TRADITIONAL_GIS_ORDER);
// coverity[tainted_data]
if( OSRSetFromUserInput( hTargetSRS, pszTargetSRS ) != CE_None )
{
OSRDestroySpatialReference( hTargetSRS );
fprintf( stderr, "Invalid target SRS `%s'.\n",
pszTargetSRS );
exit(1);
}
}
/* -------------------------------------------------------------------- */
/* Open or create the target datasource */
/* -------------------------------------------------------------------- */
GDALDatasetH hTileIndexDS = GDALOpenEx(
index_filename, GDAL_OF_VECTOR | GDAL_OF_UPDATE, nullptr, nullptr, nullptr );
OGRLayerH hLayer = nullptr;
CPLString osFormat;
if( hTileIndexDS != nullptr )
{
GDALDriverH hDriver = GDALGetDatasetDriver(hTileIndexDS);
if( hDriver )
osFormat = GDALGetDriverShortName(hDriver);
if( GDALDatasetGetLayerCount(hTileIndexDS) == 1 )
{
hLayer = GDALDatasetGetLayer(hTileIndexDS, 0);
}
else
{
if( pszIndexLayerName == nullptr )
{
printf( "-lyr_name must be specified.\n" );
exit( 1 );
}
CPLPushErrorHandler(CPLQuietErrorHandler);
hLayer = GDALDatasetGetLayerByName(hTileIndexDS, pszIndexLayerName);
CPLPopErrorHandler();
}
}
else
{
printf( "Creating new index file...\n" );
if( pszDriverName == nullptr )
{
std::vector<CPLString> aoDrivers =
GetOutputDriversFor(index_filename, GDAL_OF_VECTOR);
if( aoDrivers.empty() )
{
CPLError( CE_Failure, CPLE_AppDefined,
"Cannot guess driver for %s", index_filename);
exit( 10 );
}
else
{
if( aoDrivers.size() > 1 )
{
CPLError( CE_Warning, CPLE_AppDefined,
"Several drivers matching %s extension. Using %s",
CPLGetExtension(index_filename), aoDrivers[0].c_str() );
}
osFormat = aoDrivers[0];
}
}
else
{
osFormat = pszDriverName;
}
if( !EQUAL(osFormat, "ESRI Shapefile") )
nMaxFieldSize = 0;
GDALDriverH hDriver = GDALGetDriverByName( osFormat.c_str() );
if( hDriver == nullptr )
{
printf( "%s driver not available.\n", osFormat.c_str() );
exit( 1 );
}
hTileIndexDS =
GDALCreate( hDriver, index_filename, 0, 0, 0, GDT_Unknown, nullptr );
}
if( hTileIndexDS != nullptr && hLayer == nullptr )
{
OGRSpatialReferenceH hSpatialRef = nullptr;
char* pszLayerName = nullptr;
if( pszIndexLayerName == nullptr )
{
VSIStatBuf sStat;
if( EQUAL(osFormat, "ESRI Shapefile") ||
VSIStat(index_filename, &sStat) == 0 )
{
pszLayerName = CPLStrdup(CPLGetBasename(index_filename));
}
else
{
printf( "-lyr_name must be specified.\n" );
exit( 1 );
}
}
else
{
pszLayerName = CPLStrdup(pszIndexLayerName);
}
/* get spatial reference for output file from target SRS (if set) */
/* or from first input file */
if( bSetTargetSRS )
{
hSpatialRef = OSRClone( hTargetSRS );
}
else
{
GDALDatasetH hDS = GDALOpen( argv[iArg], GA_ReadOnly );
if( hDS )
{
const char* pszWKT = GDALGetProjectionRef(hDS);
if (pszWKT != nullptr && pszWKT[0] != '\0')
{
hSpatialRef = OSRNewSpatialReference(pszWKT);
OSRSetAxisMappingStrategy(hSpatialRef, OAMS_TRADITIONAL_GIS_ORDER);
}
GDALClose(hDS);
}
}
hLayer =
GDALDatasetCreateLayer( hTileIndexDS, pszLayerName, hSpatialRef,
wkbPolygon, nullptr );
CPLFree(pszLayerName);
if( hSpatialRef )
OSRRelease(hSpatialRef);
if( hLayer )
{
OGRFieldDefnH hFieldDefn = OGR_Fld_Create( tile_index, OFTString );
if( nMaxFieldSize )
OGR_Fld_SetWidth( hFieldDefn, static_cast<int>(nMaxFieldSize));
OGR_L_CreateField( hLayer, hFieldDefn, TRUE );
OGR_Fld_Destroy(hFieldDefn);
if( pszSrcSRSName != nullptr )
{
hFieldDefn = OGR_Fld_Create( pszSrcSRSName, OFTString );
if( nMaxFieldSize )
OGR_Fld_SetWidth(hFieldDefn,
static_cast<int>(nMaxFieldSize));
OGR_L_CreateField( hLayer, hFieldDefn, TRUE );
OGR_Fld_Destroy(hFieldDefn);
}
}
}
if( hTileIndexDS == nullptr || hLayer == nullptr )
{
fprintf( stderr, "Unable to open/create shapefile `%s'.\n",
index_filename );
exit(2);
}
OGRFeatureDefnH hFDefn = OGR_L_GetLayerDefn(hLayer);
const int ti_field = OGR_FD_GetFieldIndex( hFDefn, tile_index );
if( ti_field < 0 )
{
fprintf( stderr, "Unable to find field `%s' in file `%s'.\n",
tile_index, index_filename );
exit(2);
}
if( pszSrcSRSName != nullptr )
i_SrcSRSName = OGR_FD_GetFieldIndex( hFDefn, pszSrcSRSName );
// Load in memory existing file names in SHP.
int nExistingFiles = static_cast<int>(OGR_L_GetFeatureCount(hLayer, FALSE));
if( nExistingFiles < 0)
nExistingFiles = 0;
char** existingFilesTab = nullptr;
bool alreadyExistingProjectionRefValid = false;
char* alreadyExistingProjectionRef = nullptr;
if( nExistingFiles > 0 )
{
OGRFeatureH hFeature = nullptr;
existingFilesTab = static_cast<char **>(
CPLMalloc(nExistingFiles * sizeof(char*)));
for( int i = 0; i < nExistingFiles; i++ )
{
hFeature = OGR_L_GetNextFeature(hLayer);
existingFilesTab[i] =
CPLStrdup(OGR_F_GetFieldAsString( hFeature, ti_field ));
if( i == 0 )
{
GDALDatasetH hDS = GDALOpen(existingFilesTab[i], GA_ReadOnly );
if( hDS )
{
alreadyExistingProjectionRefValid = true;
alreadyExistingProjectionRef =
CPLStrdup(GDALGetProjectionRef(hDS));
GDALClose(hDS);
}
}
OGR_F_Destroy( hFeature );
}
}
if( write_absolute_path )
{
current_path = CPLGetCurrentDir();
if (current_path == nullptr)
{
fprintf( stderr,
"This system does not support the CPLGetCurrentDir call. "
"The option -write_absolute_path will have no effect\n" );
write_absolute_path = FALSE;
}
}
/* -------------------------------------------------------------------- */
/* loop over GDAL files, processing. */
/* -------------------------------------------------------------------- */
for( ; iArg < argc; iArg++ )
{
char *fileNameToWrite = nullptr;
VSIStatBuf sStatBuf;
// Make sure it is a file before building absolute path name.
if( write_absolute_path && CPLIsFilenameRelative( argv[iArg] ) &&
VSIStat( argv[iArg], &sStatBuf ) == 0 )
{
fileNameToWrite =
CPLStrdup(CPLProjectRelativeFilename(current_path, argv[iArg]));
}
else
{
fileNameToWrite = CPLStrdup(argv[iArg]);
}
// Checks that file is not already in tileindex.
{
int i = 0; // Used after for.
for( ; i < nExistingFiles; i++ )
{
if (EQUAL(fileNameToWrite, existingFilesTab[i]))
{
fprintf(stderr,
"File %s is already in tileindex. Skipping it.\n",
fileNameToWrite);
break;
}
}
if (i != nExistingFiles)
{
CPLFree(fileNameToWrite);
continue;
}
}
GDALDatasetH hDS = GDALOpen( argv[iArg], GA_ReadOnly );
if( hDS == nullptr )
{
fprintf( stderr, "Unable to open %s, skipping.\n",
argv[iArg] );
CPLFree(fileNameToWrite);
continue;
}
double adfGeoTransform[6] = { 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 };
GDALGetGeoTransform( hDS, adfGeoTransform );
if( adfGeoTransform[0] == 0.0
&& adfGeoTransform[1] == 1.0
&& adfGeoTransform[3] == 0.0
&& std::abs(adfGeoTransform[5]) == 1.0 )
{
fprintf( stderr,
"It appears no georeferencing is available for\n"
"`%s', skipping.\n",
argv[iArg] );
GDALClose( hDS );
CPLFree(fileNameToWrite);
continue;
}
const char *projectionRef = GDALGetProjectionRef(hDS);
// If not set target srs, test that the current file uses same
// projection as others.
if( !bSetTargetSRS )
{
if( alreadyExistingProjectionRefValid )
{
int projectionRefNotNull, alreadyExistingProjectionRefNotNull;
projectionRefNotNull = projectionRef && projectionRef[0];
alreadyExistingProjectionRefNotNull =
alreadyExistingProjectionRef &&
alreadyExistingProjectionRef[0];
if ((projectionRefNotNull &&
alreadyExistingProjectionRefNotNull &&
EQUAL(projectionRef, alreadyExistingProjectionRef) == 0) ||
(projectionRefNotNull != alreadyExistingProjectionRefNotNull))
{
fprintf(
stderr,
"Warning : %s is not using the same projection system "
"as other files in the tileindex.\n"
"This may cause problems when using it in MapServer "
"for example.\n"
"Use -t_srs option to set target projection system "
"(not supported by MapServer).\n"
"%s\n", argv[iArg],
skip_different_projection ? "Skipping this file." : "");
if( skip_different_projection )
{
CPLFree(fileNameToWrite);
GDALClose( hDS );
continue;
}
}
}
else
{
alreadyExistingProjectionRefValid = true;
alreadyExistingProjectionRef = CPLStrdup(projectionRef);
}
}
const int nXSize = GDALGetRasterXSize( hDS );
const int nYSize = GDALGetRasterYSize( hDS );
double adfX[5] = { 0.0, 0.0, 0.0, 0.0, 0.0 };
double adfY[5] = { 0.0, 0.0, 0.0, 0.0, 0.0 };
adfX[0] = adfGeoTransform[0]
+ 0 * adfGeoTransform[1]
+ 0 * adfGeoTransform[2];
adfY[0] = adfGeoTransform[3]
+ 0 * adfGeoTransform[4]
+ 0 * adfGeoTransform[5];
adfX[1] = adfGeoTransform[0]
+ nXSize * adfGeoTransform[1]
+ 0 * adfGeoTransform[2];
adfY[1] = adfGeoTransform[3]
+ nXSize * adfGeoTransform[4]
+ 0 * adfGeoTransform[5];
adfX[2] = adfGeoTransform[0]
+ nXSize * adfGeoTransform[1]
+ nYSize * adfGeoTransform[2];
adfY[2] = adfGeoTransform[3]
+ nXSize * adfGeoTransform[4]
+ nYSize * adfGeoTransform[5];
adfX[3] = adfGeoTransform[0]
+ 0 * adfGeoTransform[1]
+ nYSize * adfGeoTransform[2];
adfY[3] = adfGeoTransform[3]
+ 0 * adfGeoTransform[4]
+ nYSize * adfGeoTransform[5];
adfX[4] = adfGeoTransform[0]
+ 0 * adfGeoTransform[1]
+ 0 * adfGeoTransform[2];
adfY[4] = adfGeoTransform[3]
+ 0 * adfGeoTransform[4]
+ 0 * adfGeoTransform[5];
OGRSpatialReferenceH hSourceSRS = nullptr;
if( (bSetTargetSRS || i_SrcSRSName >= 0) &&
projectionRef != nullptr &&
projectionRef[0] != '\0' )
{
hSourceSRS = OSRNewSpatialReference( projectionRef );
OSRSetAxisMappingStrategy(hSourceSRS, OAMS_TRADITIONAL_GIS_ORDER);
}
// If set target srs, do the forward transformation of all points.
if( bSetTargetSRS && projectionRef != nullptr && projectionRef[0] != '\0' )
{
OGRCoordinateTransformationH hCT = nullptr;
if( hSourceSRS && !OSRIsSame( hSourceSRS, hTargetSRS ) )
{
hCT = OCTNewCoordinateTransformation( hSourceSRS, hTargetSRS );
if( hCT == nullptr || !OCTTransform( hCT, 5, adfX, adfY, nullptr ) )
{
fprintf(
stderr,
"Warning : unable to transform points from source "
"SRS `%s' to target SRS `%s'\n"
"for file `%s' - file skipped\n",
projectionRef, pszTargetSRS, fileNameToWrite );
if( hCT )
OCTDestroyCoordinateTransformation( hCT );
if( hSourceSRS )
OSRDestroySpatialReference( hSourceSRS );
continue;
}
if( hCT )
OCTDestroyCoordinateTransformation( hCT );
}
}
OGRFeatureH hFeature = OGR_F_Create( OGR_L_GetLayerDefn( hLayer ) );
OGR_F_SetFieldString( hFeature, ti_field, fileNameToWrite );
if( i_SrcSRSName >= 0 && hSourceSRS != nullptr )
{
const char* pszAuthorityCode =
OSRGetAuthorityCode(hSourceSRS, nullptr);
const char* pszAuthorityName =
OSRGetAuthorityName(hSourceSRS, nullptr);
if( eSrcSRSFormat == FORMAT_AUTO )
{
if( pszAuthorityName != nullptr && pszAuthorityCode != nullptr )
{
OGR_F_SetFieldString(
hFeature, i_SrcSRSName,
CPLSPrintf("%s:%s",
pszAuthorityName, pszAuthorityCode) );
}
else if( nMaxFieldSize == 0 ||
strlen(projectionRef) <= nMaxFieldSize )
{
OGR_F_SetFieldString(hFeature, i_SrcSRSName, projectionRef);
}
else
{
char* pszProj4 = nullptr;
if( OSRExportToProj4(hSourceSRS, &pszProj4) == OGRERR_NONE )
{
OGR_F_SetFieldString( hFeature, i_SrcSRSName,
pszProj4 );
CPLFree(pszProj4);
}
else
{
OGR_F_SetFieldString( hFeature, i_SrcSRSName,
projectionRef );
}
}
}
else if( eSrcSRSFormat == FORMAT_WKT )
{
if( nMaxFieldSize == 0 ||
strlen(projectionRef) <= nMaxFieldSize )
{
OGR_F_SetFieldString( hFeature, i_SrcSRSName,
projectionRef );
}
else
{
fprintf(stderr,
"Cannot write WKT for file %s as it is too long!\n",
fileNameToWrite);
}
}
else if( eSrcSRSFormat == FORMAT_PROJ )
{
char* pszProj4 = nullptr;
if( OSRExportToProj4(hSourceSRS, &pszProj4) == OGRERR_NONE )
{
OGR_F_SetFieldString( hFeature, i_SrcSRSName, pszProj4 );
CPLFree(pszProj4);
}
}
else if( eSrcSRSFormat == FORMAT_EPSG )
{
if( pszAuthorityName != nullptr && pszAuthorityCode != nullptr )
OGR_F_SetFieldString(
hFeature, i_SrcSRSName,
CPLSPrintf("%s:%s",
pszAuthorityName, pszAuthorityCode) );
}
}
if( hSourceSRS )
OSRDestroySpatialReference( hSourceSRS );
OGRGeometryH hPoly = OGR_G_CreateGeometry(wkbPolygon);
OGRGeometryH hRing = OGR_G_CreateGeometry(wkbLinearRing);
for( int k = 0; k < 5; k++ )
OGR_G_SetPoint_2D(hRing, k, adfX[k], adfY[k]);
OGR_G_AddGeometryDirectly( hPoly, hRing );
OGR_F_SetGeometryDirectly( hFeature, hPoly );
if( OGR_L_CreateFeature( hLayer, hFeature ) != OGRERR_NONE )
{
printf( "Failed to create feature in shapefile.\n" );
break;
}
OGR_F_Destroy( hFeature );
CPLFree(fileNameToWrite);
GDALClose( hDS );
}
CPLFree(current_path);
if (nExistingFiles)
{
for( int i = 0; i < nExistingFiles; i++ )
{
CPLFree(existingFilesTab[i]);
}
CPLFree(existingFilesTab);
}
CPLFree(alreadyExistingProjectionRef);
if ( hTargetSRS )
OSRDestroySpatialReference( hTargetSRS );
GDALClose( hTileIndexDS );
GDALDestroyDriverManager();
OGRCleanupAll();
CSLDestroy(argv);
exit( 0 );
}
int main(int argc, char *argv[])
{
GDALDatasetH hDataset = NULL;
OGRDataSourceH hDS = NULL;
OGRSFDriverH *pahDriver = NULL;
OGRLayerH hLR = NULL;
OGREnvelope hEnv;
double adfGeoTransform[6];
int columns, lines;
double minx, miny, maxx, maxy, x, y, z;
register int i;
FILE *fin=NULL;
if(argc != 2)
{
printf("Usage: geo_extents <input file>\n");
return 1;
}
GDALAllRegister();
OGRRegisterAll();
char *egsa = "PROJCS[\"GGRS87 / Greek Grid\",GEOGCS[\"GGRS87\",DATUM[\"Greek_Geodetic_Reference_System_1987\",SPHEROID[\"GRS 1980\",6378137,298.257222101,AUTHORITY[\"EPSG\",\"7019\"]],TOWGS84[-199.87,74.79,246.62,0,0,0,0],AUTHORITY[\"EPSG\",\"6121\"]],PRIMEM[\"Greenwich\",0,AUTHORITY[\"EPSG\",\"8901\"]],UNIT[\"degree\",0.01745329251994328,AUTHORITY[\"EPSG\",\"9122\"]],AUTHORITY[\"EPSG\",\"4121\"]],UNIT[\"metre\",1,AUTHORITY[\"EPSG\",\"9001\"]],PROJECTION[\"Transverse_Mercator\"],PARAMETER[\"latitude_of_origin\",0],PARAMETER[\"central_meridian\",24],PARAMETER[\"scale_factor\",0.9996],PARAMETER[\"false_easting\",500000],PARAMETER[\"false_northing\",0],AUTHORITY[\"EPSG\",\"2100\"],AXIS[\"Easting\",EAST],AXIS[\"Northing\",NORTH]]";
char *wgs = "GEOGCS[\"WGS 84\",DATUM[\"WGS_1984\",SPHEROID[\"WGS 84\",6378137,298.257223563,AUTHORITY[\"EPSG\",\"7030\"]],AUTHORITY[\"EPSG\",\"6326\"]],PRIMEM[\"Greenwich\",0,AUTHORITY[\"EPSG\",\"8901\"]],UNIT[\"degree\",0.01745329251994328,AUTHORITY[\"EPSG\",\"9122\"]],AUTHORITY[\"EPSG\",\"4326\"]]";
OGRSpatialReferenceH oSourceSRS;
OGRSpatialReferenceH oTargetSRS;
oSourceSRS = OSRNewSpatialReference(NULL);
oTargetSRS = OSRNewSpatialReference(NULL);
OSRImportFromWkt(oSourceSRS, &egsa);
OSRImportFromWkt(oTargetSRS, &wgs);
OGRCoordinateTransformationH poCT;
poCT = OCTNewCoordinateTransformation(oSourceSRS, oTargetSRS);
hDataset = GDALOpen(argv[1], GA_ReadOnly);
if(hDataset != NULL)//It is raster
{
columns = GDALGetRasterXSize(hDataset);
lines = GDALGetRasterYSize(hDataset);
if(GDALGetGeoTransform(hDataset, adfGeoTransform) == CE_None)
{
minx = (adfGeoTransform[0] - (adfGeoTransform[1] / 2));
maxy = (adfGeoTransform[3] - (adfGeoTransform[5] / 2));
miny = (maxy + ((lines + 1) * adfGeoTransform[5]));
maxx = (minx + (adfGeoTransform[1] * (columns + 1)));
OCTTransform(poCT, 1, &minx, &miny, 0);
OCTTransform(poCT, 1, &maxx, &maxy, 0);
printf("BoundingBox: %f %f %f %f\n",minx ,miny, maxx, maxy);
GDALClose (hDataset);
}
else
{
printf("Failure: No Georeference info found for this raster file\n");
return 0;
}
}
else//Try if it is vector
{
hDS = OGROpen( argv[1], FALSE , pahDriver );
if( hDS == NULL )//Not vector
{
//Parse for DTM file
fin=fopen(argv[1],"r");
fseek(fin,0L,SEEK_SET);
minx=50000000.0;
miny=50000000.0;
maxx=0.0;
maxy=0.0;
while(!feof(fin))
{
fscanf(fin,"%lf,%lf,%lf\n",&x,&y,&z);
if(ferror(fin))//input error
{
printf("Failure: Unsupported file type\n");
return 0;
}
if(x>maxx) maxx=x;
if(y>maxy) maxy=y;
if(x<minx) minx=x;
if(y<miny) miny=y;
}
if(minx==50000000.0 || miny==50000000.0)
{
printf("Failure: Unsupported file type\n");
return 0;
}
if(maxx==0 || maxy==0)
{
printf("Failure: Unsupported file type\n");
return 0;
}
if(minx==maxx)
{
minx-=1;
maxx+=1;
}
if(miny==maxy)
{
miny-=1;
maxy+=1;
}
//DTM file
OCTTransform(poCT, 1, &minx, &miny, 0);
OCTTransform(poCT, 1, &maxx, &maxy, 0);
printf("BoundingBox: %f %f %f %f\n",minx ,miny, maxx, maxy);
return 0;
}
//It is vector
for(i=0; i< OGR_DS_GetLayerCount (hDS); i++)
{
hLR = OGR_DS_GetLayer(hDS, i);
if(OGR_L_GetExtent (hLR, &hEnv, FALSE) == OGRERR_NONE)
{
minx = hEnv.MinX;
miny = hEnv.MinY;
maxx = hEnv.MaxX;
maxy = hEnv.MaxY;
OCTTransform(poCT, 1, &minx, &miny, 0);
OCTTransform(poCT, 1, &maxx, &maxy, 0);
printf("BoundingBox: %f %f %f %f\n",minx ,miny, maxx, maxy);
}
}
OGRReleaseDataSource( hDS );
}
return 0;
}
int SpatialReference::computeUTMZone(const BOX3D& box) const
{
// Nothing we can do if we're an empty SRS
if (empty())
return 0;
OGRSpatialReferenceH current =
OSRNewSpatialReference(getWKT(eHorizontalOnly, false).c_str());
if (! current)
throw std::invalid_argument("Could not fetch current SRS");
OGRSpatialReferenceH wgs84 = OSRNewSpatialReference(0);
if (OSRSetFromUserInput(wgs84, "EPSG:4326") != OGRERR_NONE)
{
OSRDestroySpatialReference(current);
OSRDestroySpatialReference(wgs84);
std::ostringstream msg;
msg << "Could not import GDAL input spatial reference for WGS84";
throw std::runtime_error(msg.str());
}
void* transform = OCTNewCoordinateTransformation(current, wgs84);
if (! transform)
{
OSRDestroySpatialReference(current);
OSRDestroySpatialReference(wgs84);
throw std::invalid_argument("could not comput transform from "
"coordinate system to WGS84");
}
double minx(0.0), miny(0.0), minz(0.0);
double maxx(0.0), maxy(0.0), maxz(0.0);
// OCTTransform modifies values in-place
minx = box.minx; miny = box.miny; minz = box.minz;
maxx = box.maxx; maxy = box.maxy; maxz = box.maxz;
int ret = OCTTransform(transform, 1, &minx, &miny, &minz);
if (ret == 0)
{
OCTDestroyCoordinateTransformation(transform);
OSRDestroySpatialReference(current);
OSRDestroySpatialReference(wgs84);
std::ostringstream msg;
msg << "Could not project minimum point for computeUTMZone::" <<
CPLGetLastErrorMsg() << ret;
throw pdal_error(msg.str());
}
ret = OCTTransform(transform, 1, &maxx, &maxy, &maxz);
if (ret == 0)
{
OCTDestroyCoordinateTransformation(transform);
OSRDestroySpatialReference(current);
OSRDestroySpatialReference(wgs84);
std::ostringstream msg;
msg << "Could not project maximum point for computeUTMZone::" <<
CPLGetLastErrorMsg() << ret;
throw pdal_error(msg.str());
}
int min_zone(0);
int max_zone(0);
min_zone = calculateZone(minx, miny);
max_zone = calculateZone(maxx, maxy);
if (min_zone != max_zone)
{
OCTDestroyCoordinateTransformation(transform);
OSRDestroySpatialReference(current);
OSRDestroySpatialReference(wgs84);
std::ostringstream msg;
msg << "Minimum zone is " << min_zone <<"' and maximum zone is '" <<
max_zone << "'. They do not match because they cross a "
"zone boundary";
throw pdal_error(msg.str());
}
OCTDestroyCoordinateTransformation(transform);
OSRDestroySpatialReference(current);
OSRDestroySpatialReference(wgs84);
return min_zone;
}
int main(int argc, char *argv[])
{
const char *index_filename = NULL;
const char *tile_index = "location";
int i_arg, ti_field;
OGRDataSourceH hTileIndexDS;
OGRLayerH hLayer = NULL;
OGRFeatureDefnH hFDefn;
int write_absolute_path = FALSE;
char* current_path = NULL;
int i;
int nExistingFiles;
int skip_different_projection = FALSE;
char** existingFilesTab = NULL;
int alreadyExistingProjectionRefValid = FALSE;
char* alreadyExistingProjectionRef = NULL;
char* index_filename_mod;
int bExists;
VSIStatBuf sStatBuf;
const char *pszTargetSRS = "";
int bSetTargetSRS = FALSE;
OGRSpatialReferenceH hTargetSRS = NULL;
/* Check that we are running against at least GDAL 1.4 */
/* Note to developers : if we use newer API, please change the requirement */
if (atoi(GDALVersionInfo("VERSION_NUM")) < 1400)
{
fprintf(stderr, "At least, GDAL >= 1.4.0 is required for this version of %s, "
"which was compiled against GDAL %s\n", argv[0], GDAL_RELEASE_NAME);
exit(1);
}
GDALAllRegister();
OGRRegisterAll();
argc = GDALGeneralCmdLineProcessor( argc, &argv, 0 );
if( argc < 1 )
exit( -argc );
/* -------------------------------------------------------------------- */
/* Get commandline arguments other than the GDAL raster filenames. */
/* -------------------------------------------------------------------- */
for( i_arg = 1; i_arg < argc; i_arg++ )
{
if( EQUAL(argv[i_arg], "--utility_version") )
{
printf("%s was compiled against GDAL %s and is running against GDAL %s\n",
argv[0], GDAL_RELEASE_NAME, GDALVersionInfo("RELEASE_NAME"));
return 0;
}
else if( strcmp(argv[i_arg],"-tileindex") == 0 )
{
tile_index = argv[++i_arg];
}
else if( strcmp(argv[i_arg],"-t_srs") == 0 )
{
pszTargetSRS = argv[++i_arg];
bSetTargetSRS = TRUE;
}
else if ( strcmp(argv[i_arg],"-write_absolute_path") == 0 )
{
write_absolute_path = TRUE;
}
else if ( strcmp(argv[i_arg],"-skip_different_projection") == 0 )
{
skip_different_projection = TRUE;
}
else if( argv[i_arg][0] == '-' )
Usage();
else if( index_filename == NULL )
{
index_filename = argv[i_arg];
i_arg++;
break;
}
}
if( index_filename == NULL || i_arg == argc )
Usage();
/* -------------------------------------------------------------------- */
/* Create and validate target SRS if given. */
/* -------------------------------------------------------------------- */
if( bSetTargetSRS )
{
if ( skip_different_projection )
{
fprintf( stderr,
"Warning : -skip_different_projection does not apply "
"when -t_srs is requested.\n" );
}
hTargetSRS = OSRNewSpatialReference("");
if( OSRSetFromUserInput( hTargetSRS, pszTargetSRS ) != CE_None )
{
OSRDestroySpatialReference( hTargetSRS );
fprintf( stderr, "Invalid target SRS `%s'.\n",
pszTargetSRS );
exit(1);
}
}
/* -------------------------------------------------------------------- */
/* Open or create the target shapefile and DBF file. */
/* -------------------------------------------------------------------- */
index_filename_mod = CPLStrdup(CPLResetExtension(index_filename, "shp"));
bExists = (VSIStat(index_filename_mod, &sStatBuf) == 0);
if (!bExists)
{
CPLFree(index_filename_mod);
index_filename_mod = CPLStrdup(CPLResetExtension(index_filename, "SHP"));
bExists = (VSIStat(index_filename_mod, &sStatBuf) == 0);
}
CPLFree(index_filename_mod);
if (bExists)
{
hTileIndexDS = OGROpen( index_filename, TRUE, NULL );
if (hTileIndexDS != NULL)
{
hLayer = OGR_DS_GetLayer(hTileIndexDS, 0);
}
}
else
{
OGRSFDriverH hDriver;
const char* pszDriverName = "ESRI Shapefile";
printf( "Creating new index file...\n" );
hDriver = OGRGetDriverByName( pszDriverName );
if( hDriver == NULL )
{
printf( "%s driver not available.\n", pszDriverName );
exit( 1 );
}
hTileIndexDS = OGR_Dr_CreateDataSource( hDriver, index_filename, NULL );
if (hTileIndexDS)
{
char* pszLayerName = CPLStrdup(CPLGetBasename(index_filename));
/* get spatial reference for output file from target SRS (if set) */
/* or from first input file */
OGRSpatialReferenceH hSpatialRef = NULL;
if( bSetTargetSRS )
{
hSpatialRef = OSRClone( hTargetSRS );
}
else
{
GDALDatasetH hDS = GDALOpen( argv[i_arg], GA_ReadOnly );
if (hDS)
{
const char* pszWKT = GDALGetProjectionRef(hDS);
if (pszWKT != NULL && pszWKT[0] != '\0')
{
hSpatialRef = OSRNewSpatialReference(pszWKT);
}
GDALClose(hDS);
}
}
hLayer = OGR_DS_CreateLayer( hTileIndexDS, pszLayerName, hSpatialRef, wkbPolygon, NULL );
CPLFree(pszLayerName);
if (hSpatialRef)
OSRRelease(hSpatialRef);
if (hLayer)
{
OGRFieldDefnH hFieldDefn = OGR_Fld_Create( tile_index, OFTString );
OGR_Fld_SetWidth( hFieldDefn, 255);
OGR_L_CreateField( hLayer, hFieldDefn, TRUE );
OGR_Fld_Destroy(hFieldDefn);
}
}
}
if( hTileIndexDS == NULL || hLayer == NULL )
{
fprintf( stderr, "Unable to open/create shapefile `%s'.\n",
index_filename );
exit(2);
}
hFDefn = OGR_L_GetLayerDefn(hLayer);
for( ti_field = 0; ti_field < OGR_FD_GetFieldCount(hFDefn); ti_field++ )
{
OGRFieldDefnH hFieldDefn = OGR_FD_GetFieldDefn( hFDefn, ti_field );
if( strcmp(OGR_Fld_GetNameRef(hFieldDefn), tile_index) == 0 )
break;
}
if( ti_field == OGR_FD_GetFieldCount(hFDefn) )
{
fprintf( stderr, "Unable to find field `%s' in DBF file `%s'.\n",
tile_index, index_filename );
exit(2);
}
/* Load in memory existing file names in SHP */
nExistingFiles = OGR_L_GetFeatureCount(hLayer, FALSE);
if (nExistingFiles)
{
OGRFeatureH hFeature;
existingFilesTab = (char**)CPLMalloc(nExistingFiles * sizeof(char*));
for(i=0;i<nExistingFiles;i++)
{
hFeature = OGR_L_GetNextFeature(hLayer);
existingFilesTab[i] = CPLStrdup(OGR_F_GetFieldAsString( hFeature, ti_field ));
if (i == 0)
{
GDALDatasetH hDS = GDALOpen(existingFilesTab[i], GA_ReadOnly );
if (hDS)
{
alreadyExistingProjectionRefValid = TRUE;
alreadyExistingProjectionRef = CPLStrdup(GDALGetProjectionRef(hDS));
GDALClose(hDS);
}
}
OGR_F_Destroy( hFeature );
}
}
if (write_absolute_path)
{
current_path = CPLGetCurrentDir();
if (current_path == NULL)
{
fprintf( stderr, "This system does not support the CPLGetCurrentDir call. "
"The option -write_absolute_path will have no effect\n");
write_absolute_path = FALSE;
}
}
/* -------------------------------------------------------------------- */
/* loop over GDAL files, processing. */
/* -------------------------------------------------------------------- */
for( ; i_arg < argc; i_arg++ )
{
GDALDatasetH hDS;
double adfGeoTransform[6];
double adfX[5], adfY[5];
int nXSize, nYSize;
char* fileNameToWrite;
const char* projectionRef;
VSIStatBuf sStatBuf;
int k;
OGRFeatureH hFeature;
OGRGeometryH hPoly, hRing;
/* Make sure it is a file before building absolute path name */
if (write_absolute_path && CPLIsFilenameRelative( argv[i_arg] ) &&
VSIStat( argv[i_arg], &sStatBuf ) == 0)
{
fileNameToWrite = CPLStrdup(CPLProjectRelativeFilename(current_path, argv[i_arg]));
}
else
{
fileNameToWrite = CPLStrdup(argv[i_arg]);
}
/* Checks that file is not already in tileindex */
for(i=0;i<nExistingFiles;i++)
{
if (EQUAL(fileNameToWrite, existingFilesTab[i]))
{
fprintf(stderr, "File %s is already in tileindex. Skipping it.\n",
fileNameToWrite);
break;
}
}
if (i != nExistingFiles)
{
CPLFree(fileNameToWrite);
continue;
}
hDS = GDALOpen( argv[i_arg], GA_ReadOnly );
if( hDS == NULL )
{
fprintf( stderr, "Unable to open %s, skipping.\n",
argv[i_arg] );
CPLFree(fileNameToWrite);
continue;
}
GDALGetGeoTransform( hDS, adfGeoTransform );
if( adfGeoTransform[0] == 0.0
&& adfGeoTransform[1] == 1.0
&& adfGeoTransform[3] == 0.0
&& ABS(adfGeoTransform[5]) == 1.0 )
{
fprintf( stderr,
"It appears no georeferencing is available for\n"
"`%s', skipping.\n",
argv[i_arg] );
GDALClose( hDS );
CPLFree(fileNameToWrite);
continue;
}
projectionRef = GDALGetProjectionRef(hDS);
/* if not set target srs, test that the current file uses same projection as others */
if( !bSetTargetSRS )
{
if (alreadyExistingProjectionRefValid)
{
int projectionRefNotNull, alreadyExistingProjectionRefNotNull;
projectionRefNotNull = projectionRef && projectionRef[0];
alreadyExistingProjectionRefNotNull = alreadyExistingProjectionRef && alreadyExistingProjectionRef[0];
if ((projectionRefNotNull &&
alreadyExistingProjectionRefNotNull &&
EQUAL(projectionRef, alreadyExistingProjectionRef) == 0) ||
(projectionRefNotNull != alreadyExistingProjectionRefNotNull))
{
fprintf(stderr, "Warning : %s is not using the same projection system as "
"other files in the tileindex.\n"
"This may cause problems when using it in MapServer for example.\n"
"Use -t_srs option to set target projection system (not supported by MapServer).\n"
"%s\n", argv[i_arg],
(skip_different_projection) ? "Skipping this file." : "");
if (skip_different_projection)
{
CPLFree(fileNameToWrite);
GDALClose( hDS );
continue;
}
}
}
else
{
alreadyExistingProjectionRefValid = TRUE;
alreadyExistingProjectionRef = CPLStrdup(projectionRef);
}
}
nXSize = GDALGetRasterXSize( hDS );
nYSize = GDALGetRasterYSize( hDS );
adfX[0] = adfGeoTransform[0]
+ 0 * adfGeoTransform[1]
+ 0 * adfGeoTransform[2];
adfY[0] = adfGeoTransform[3]
+ 0 * adfGeoTransform[4]
+ 0 * adfGeoTransform[5];
adfX[1] = adfGeoTransform[0]
+ nXSize * adfGeoTransform[1]
+ 0 * adfGeoTransform[2];
adfY[1] = adfGeoTransform[3]
+ nXSize * adfGeoTransform[4]
+ 0 * adfGeoTransform[5];
adfX[2] = adfGeoTransform[0]
+ nXSize * adfGeoTransform[1]
+ nYSize * adfGeoTransform[2];
adfY[2] = adfGeoTransform[3]
+ nXSize * adfGeoTransform[4]
+ nYSize * adfGeoTransform[5];
adfX[3] = adfGeoTransform[0]
+ 0 * adfGeoTransform[1]
+ nYSize * adfGeoTransform[2];
adfY[3] = adfGeoTransform[3]
+ 0 * adfGeoTransform[4]
+ nYSize * adfGeoTransform[5];
adfX[4] = adfGeoTransform[0]
+ 0 * adfGeoTransform[1]
+ 0 * adfGeoTransform[2];
adfY[4] = adfGeoTransform[3]
+ 0 * adfGeoTransform[4]
+ 0 * adfGeoTransform[5];
/* if set target srs, do the forward transformation of all points */
if( bSetTargetSRS )
{
OGRSpatialReferenceH hSourceSRS = NULL;
OGRCoordinateTransformationH hCT = NULL;
hSourceSRS = OSRNewSpatialReference( projectionRef );
if( hSourceSRS && !OSRIsSame( hSourceSRS, hTargetSRS ) )
{
hCT = OCTNewCoordinateTransformation( hSourceSRS, hTargetSRS );
if( hCT == NULL || !OCTTransform( hCT, 5, adfX, adfY, NULL ) )
{
fprintf( stderr,
"Warning : unable to transform points from source SRS `%s' to target SRS `%s'\n"
"for file `%s' - file skipped\n",
projectionRef, pszTargetSRS, fileNameToWrite );
if ( hCT )
OCTDestroyCoordinateTransformation( hCT );
if ( hSourceSRS )
OSRDestroySpatialReference( hSourceSRS );
continue;
}
if ( hCT )
OCTDestroyCoordinateTransformation( hCT );
}
if ( hSourceSRS )
OSRDestroySpatialReference( hSourceSRS );
}
hFeature = OGR_F_Create( OGR_L_GetLayerDefn( hLayer ) );
OGR_F_SetFieldString( hFeature, ti_field, fileNameToWrite );
hPoly = OGR_G_CreateGeometry(wkbPolygon);
hRing = OGR_G_CreateGeometry(wkbLinearRing);
for(k=0;k<5;k++)
OGR_G_SetPoint_2D(hRing, k, adfX[k], adfY[k]);
OGR_G_AddGeometryDirectly( hPoly, hRing );
OGR_F_SetGeometryDirectly( hFeature, hPoly );
if( OGR_L_CreateFeature( hLayer, hFeature ) != OGRERR_NONE )
{
printf( "Failed to create feature in shapefile.\n" );
break;
}
OGR_F_Destroy( hFeature );
CPLFree(fileNameToWrite);
GDALClose( hDS );
}
CPLFree(current_path);
if (nExistingFiles)
{
for(i=0;i<nExistingFiles;i++)
{
CPLFree(existingFilesTab[i]);
}
CPLFree(existingFilesTab);
}
CPLFree(alreadyExistingProjectionRef);
if ( hTargetSRS )
OSRDestroySpatialReference( hTargetSRS );
OGR_DS_Destroy( hTileIndexDS );
GDALDestroyDriverManager();
OGRCleanupAll();
CSLDestroy(argv);
exit( 0 );
}
int main( int argc, char ** argv )
{
const char *pszLocX = NULL, *pszLocY = NULL;
const char *pszSrcFilename = NULL;
char *pszSourceSRS = NULL;
std::vector<int> anBandList;
bool bAsXML = false, bLIFOnly = false;
bool bQuiet = false, bValOnly = false;
int nOverview = -1;
char **papszOpenOptions = NULL;
GDALAllRegister();
argc = GDALGeneralCmdLineProcessor( argc, &argv, 0 );
if( argc < 1 )
exit( -argc );
/* -------------------------------------------------------------------- */
/* Parse arguments. */
/* -------------------------------------------------------------------- */
int i;
for( i = 1; i < argc; i++ )
{
if( EQUAL(argv[i], "--utility_version") )
{
printf("%s was compiled against GDAL %s and is running against GDAL %s\n",
argv[0], GDAL_RELEASE_NAME, GDALVersionInfo("RELEASE_NAME"));
return 0;
}
else if( EQUAL(argv[i],"-b") && i < argc-1 )
{
anBandList.push_back( atoi(argv[++i]) );
}
else if( EQUAL(argv[i],"-overview") && i < argc-1 )
{
nOverview = atoi(argv[++i]) - 1;
}
else if( EQUAL(argv[i],"-l_srs") && i < argc-1 )
{
CPLFree(pszSourceSRS);
pszSourceSRS = SanitizeSRS(argv[++i]);
}
else if( EQUAL(argv[i],"-geoloc") )
{
CPLFree(pszSourceSRS);
pszSourceSRS = CPLStrdup("-geoloc");
}
else if( EQUAL(argv[i],"-wgs84") )
{
CPLFree(pszSourceSRS);
pszSourceSRS = SanitizeSRS("WGS84");
}
else if( EQUAL(argv[i],"-xml") )
{
bAsXML = true;
}
else if( EQUAL(argv[i],"-lifonly") )
{
bLIFOnly = true;
bQuiet = true;
}
else if( EQUAL(argv[i],"-valonly") )
{
bValOnly = true;
bQuiet = true;
}
else if( EQUAL(argv[i], "-oo") && i < argc-1 )
{
papszOpenOptions = CSLAddString( papszOpenOptions,
argv[++i] );
}
else if( argv[i][0] == '-' && !isdigit(argv[i][1]) )
Usage();
else if( pszSrcFilename == NULL )
pszSrcFilename = argv[i];
else if( pszLocX == NULL )
pszLocX = argv[i];
else if( pszLocY == NULL )
pszLocY = argv[i];
else
Usage();
}
if( pszSrcFilename == NULL || (pszLocX != NULL && pszLocY == NULL) )
Usage();
/* -------------------------------------------------------------------- */
/* Open source file. */
/* -------------------------------------------------------------------- */
GDALDatasetH hSrcDS = NULL;
hSrcDS = GDALOpenEx( pszSrcFilename, GDAL_OF_RASTER, NULL,
(const char* const* )papszOpenOptions, NULL );
if( hSrcDS == NULL )
exit( 1 );
/* -------------------------------------------------------------------- */
/* Setup coordinate transformation, if required */
/* -------------------------------------------------------------------- */
OGRSpatialReferenceH hSrcSRS = NULL, hTrgSRS = NULL;
OGRCoordinateTransformationH hCT = NULL;
if( pszSourceSRS != NULL && !EQUAL(pszSourceSRS,"-geoloc") )
{
hSrcSRS = OSRNewSpatialReference( pszSourceSRS );
hTrgSRS = OSRNewSpatialReference( GDALGetProjectionRef( hSrcDS ) );
hCT = OCTNewCoordinateTransformation( hSrcSRS, hTrgSRS );
if( hCT == NULL )
exit( 1 );
}
/* -------------------------------------------------------------------- */
/* If no bands were requested, we will query them all. */
/* -------------------------------------------------------------------- */
if( anBandList.size() == 0 )
{
for( i = 0; i < GDALGetRasterCount( hSrcDS ); i++ )
anBandList.push_back( i+1 );
}
/* -------------------------------------------------------------------- */
/* Turn the location into a pixel and line location. */
/* -------------------------------------------------------------------- */
int inputAvailable = 1;
double dfGeoX;
double dfGeoY;
CPLString osXML;
if( pszLocX == NULL && pszLocY == NULL )
{
if (fscanf(stdin, "%lf %lf", &dfGeoX, &dfGeoY) != 2)
{
inputAvailable = 0;
}
}
else
{
dfGeoX = CPLAtof(pszLocX);
dfGeoY = CPLAtof(pszLocY);
}
while (inputAvailable)
{
int iPixel, iLine;
if (hCT)
{
if( !OCTTransform( hCT, 1, &dfGeoX, &dfGeoY, NULL ) )
exit( 1 );
}
if( pszSourceSRS != NULL )
{
double adfGeoTransform[6], adfInvGeoTransform[6];
if( GDALGetGeoTransform( hSrcDS, adfGeoTransform ) != CE_None )
{
CPLError(CE_Failure, CPLE_AppDefined, "Cannot get geotransform");
exit( 1 );
}
if( !GDALInvGeoTransform( adfGeoTransform, adfInvGeoTransform ) )
{
CPLError(CE_Failure, CPLE_AppDefined, "Cannot invert geotransform");
exit( 1 );
}
iPixel = (int) floor(
adfInvGeoTransform[0]
+ adfInvGeoTransform[1] * dfGeoX
+ adfInvGeoTransform[2] * dfGeoY );
iLine = (int) floor(
adfInvGeoTransform[3]
+ adfInvGeoTransform[4] * dfGeoX
+ adfInvGeoTransform[5] * dfGeoY );
}
else
{
iPixel = (int) floor(dfGeoX);
iLine = (int) floor(dfGeoY);
}
/* -------------------------------------------------------------------- */
/* Prepare report. */
/* -------------------------------------------------------------------- */
CPLString osLine;
if( bAsXML )
{
osLine.Printf( "<Report pixel=\"%d\" line=\"%d\">",
iPixel, iLine );
osXML += osLine;
}
else if( !bQuiet )
{
printf( "Report:\n" );
printf( " Location: (%dP,%dL)\n", iPixel, iLine );
}
int bPixelReport = TRUE;
if( iPixel < 0 || iLine < 0
|| iPixel >= GDALGetRasterXSize( hSrcDS )
|| iLine >= GDALGetRasterYSize( hSrcDS ) )
{
if( bAsXML )
osXML += "<Alert>Location is off this file! No further details to report.</Alert>";
else if( bValOnly )
printf("\n");
else if( !bQuiet )
printf( "\nLocation is off this file! No further details to report.\n");
bPixelReport = FALSE;
}
/* -------------------------------------------------------------------- */
/* Process each band. */
/* -------------------------------------------------------------------- */
for( i = 0; bPixelReport && i < (int) anBandList.size(); i++ )
{
GDALRasterBandH hBand = GDALGetRasterBand( hSrcDS, anBandList[i] );
int iPixelToQuery = iPixel;
int iLineToQuery = iLine;
if (nOverview >= 0 && hBand != NULL)
{
GDALRasterBandH hOvrBand = GDALGetOverview(hBand, nOverview);
if (hOvrBand != NULL)
{
int nOvrXSize = GDALGetRasterBandXSize(hOvrBand);
int nOvrYSize = GDALGetRasterBandYSize(hOvrBand);
iPixelToQuery = (int)(0.5 + 1.0 * iPixel / GDALGetRasterXSize( hSrcDS ) * nOvrXSize);
iLineToQuery = (int)(0.5 + 1.0 * iLine / GDALGetRasterYSize( hSrcDS ) * nOvrYSize);
if (iPixelToQuery >= nOvrXSize)
iPixelToQuery = nOvrXSize - 1;
if (iLineToQuery >= nOvrYSize)
iLineToQuery = nOvrYSize - 1;
}
else
{
CPLError(CE_Failure, CPLE_AppDefined,
"Cannot get overview %d of band %d",
nOverview + 1, anBandList[i] );
}
hBand = hOvrBand;
}
if (hBand == NULL)
continue;
if( bAsXML )
{
osLine.Printf( "<BandReport band=\"%d\">", anBandList[i] );
osXML += osLine;
}
else if( !bQuiet )
{
printf( " Band %d:\n", anBandList[i] );
}
/* -------------------------------------------------------------------- */
/* Request location info for this location. It is possible */
/* only the VRT driver actually supports this. */
/* -------------------------------------------------------------------- */
CPLString osItem;
osItem.Printf( "Pixel_%d_%d", iPixelToQuery, iLineToQuery );
const char *pszLI = GDALGetMetadataItem( hBand, osItem, "LocationInfo");
if( pszLI != NULL )
{
if( bAsXML )
osXML += pszLI;
else if( !bQuiet )
printf( " %s\n", pszLI );
else if( bLIFOnly )
{
/* Extract all files, if any. */
CPLXMLNode *psRoot = CPLParseXMLString( pszLI );
if( psRoot != NULL
&& psRoot->psChild != NULL
&& psRoot->eType == CXT_Element
&& EQUAL(psRoot->pszValue,"LocationInfo") )
{
CPLXMLNode *psNode;
for( psNode = psRoot->psChild;
psNode != NULL;
psNode = psNode->psNext )
{
if( psNode->eType == CXT_Element
&& EQUAL(psNode->pszValue,"File")
&& psNode->psChild != NULL )
{
char* pszUnescaped = CPLUnescapeString(
psNode->psChild->pszValue, NULL, CPLES_XML);
printf( "%s\n", pszUnescaped );
CPLFree(pszUnescaped);
}
}
}
CPLDestroyXMLNode( psRoot );
}
}
/* -------------------------------------------------------------------- */
/* Report the pixel value of this band. */
/* -------------------------------------------------------------------- */
double adfPixel[2];
if( GDALRasterIO( hBand, GF_Read, iPixelToQuery, iLineToQuery, 1, 1,
adfPixel, 1, 1, GDT_CFloat64, 0, 0) == CE_None )
{
CPLString osValue;
if( GDALDataTypeIsComplex( GDALGetRasterDataType( hBand ) ) )
osValue.Printf( "%.15g+%.15gi", adfPixel[0], adfPixel[1] );
else
osValue.Printf( "%.15g", adfPixel[0] );
if( bAsXML )
{
osXML += "<Value>";
osXML += osValue;
osXML += "</Value>";
}
else if( !bQuiet )
printf( " Value: %s\n", osValue.c_str() );
else if( bValOnly )
printf( "%s\n", osValue.c_str() );
// Report unscaled if we have scale/offset values.
int bSuccess;
double dfOffset = GDALGetRasterOffset( hBand, &bSuccess );
double dfScale = GDALGetRasterScale( hBand, &bSuccess );
if( dfOffset != 0.0 || dfScale != 1.0 )
{
adfPixel[0] = adfPixel[0] * dfScale + dfOffset;
adfPixel[1] = adfPixel[1] * dfScale + dfOffset;
if( GDALDataTypeIsComplex( GDALGetRasterDataType( hBand ) ) )
osValue.Printf( "%.15g+%.15gi", adfPixel[0], adfPixel[1] );
else
osValue.Printf( "%.15g", adfPixel[0] );
if( bAsXML )
{
osXML += "<DescaledValue>";
osXML += osValue;
osXML += "</DescaledValue>";
}
else if( !bQuiet )
printf( " Descaled Value: %s\n", osValue.c_str() );
}
}
if( bAsXML )
osXML += "</BandReport>";
}
osXML += "</Report>";
if( (pszLocX != NULL && pszLocY != NULL) ||
(fscanf(stdin, "%lf %lf", &dfGeoX, &dfGeoY) != 2) )
{
inputAvailable = 0;
}
}
/* -------------------------------------------------------------------- */
/* Finalize xml report and print. */
/* -------------------------------------------------------------------- */
if( bAsXML )
{
CPLXMLNode *psRoot;
char *pszFormattedXML;
psRoot = CPLParseXMLString( osXML );
pszFormattedXML = CPLSerializeXMLTree( psRoot );
CPLDestroyXMLNode( psRoot );
printf( "%s", pszFormattedXML );
CPLFree( pszFormattedXML );
}
/* -------------------------------------------------------------------- */
/* Cleanup */
/* -------------------------------------------------------------------- */
if (hCT) {
OSRDestroySpatialReference( hSrcSRS );
OSRDestroySpatialReference( hTrgSRS );
OCTDestroyCoordinateTransformation( hCT );
}
if (hSrcDS)
GDALClose(hSrcDS);
GDALDumpOpenDatasets( stderr );
GDALDestroyDriverManager();
CPLFree(pszSourceSRS);
CSLDestroy(papszOpenOptions);
CSLDestroy( argv );
return 0;
}
