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;
}
bool SpatialReference::equals(const SpatialReference& input) const
{
OGRSpatialReferenceH current =
OSRNewSpatialReference(getWKT(eCompoundOK, false).c_str());
OGRSpatialReferenceH other =
OSRNewSpatialReference(input.getWKT(eCompoundOK, false).c_str());
int output = OSRIsSame(current, other);
OSRDestroySpatialReference(current);
OSRDestroySpatialReference(other);
return (output == 1);
}
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);
}
QgsCoordinateReferenceSystem::QgsCoordinateReferenceSystem()
: mMapUnits( QGis::UnknownUnit )
, mIsValidFlag( 0 )
, mValidationHint( "" )
{
mCRS = OSRNewSpatialReference( NULL );
}
std::string SpatialReference::getVerticalUnits() const
{
std::string tmp("");
std::string wkt = getWKT(eCompoundOK);
const char* poWKT = wkt.c_str();
OGRSpatialReference* poSRS =
(OGRSpatialReference*)OSRNewSpatialReference(m_wkt.c_str());
if (poSRS)
{
OGR_SRSNode* node = poSRS->GetAttrNode("VERT_CS");
if (node)
{
char* units(0);
double u = poSRS->GetLinearUnits(&units);
tmp = units;
CPLFree(units);
Utils::trim(tmp);
}
}
return tmp;
}
// returned WKT string should be free by OGRFree or CPLFree
static char* get_wkt_of(int epsg_code) {
OGRSpatialReferenceH srs = OSRNewSpatialReference(NULL);
OSRImportFromEPSG(srs, epsg_code);
char* srs_wkt;
OSRExportToWkt(srs, &srs_wkt);
return srs_wkt;
}
/// Fetch the SRS as WKT
std::string SpatialReference::getWKT(WKTModeFlag mode_flag , bool pretty) const
{
std::string result_wkt = m_wkt;
if ((mode_flag == eHorizontalOnly
&& strstr(result_wkt.c_str(),"COMPD_CS") != NULL)
|| pretty)
{
OGRSpatialReference* poSRS =
(OGRSpatialReference*)OSRNewSpatialReference(result_wkt.c_str());
char *pszWKT = NULL;
if (mode_flag == eHorizontalOnly)
poSRS->StripVertical();
if (pretty)
poSRS->exportToPrettyWkt(&pszWKT, FALSE);
else
poSRS->exportToWkt(&pszWKT);
OSRDestroySpatialReference(poSRS);
result_wkt = pszWKT;
CPLFree(pszWKT);
}
return result_wkt;
}
bool QgsOgrLayerItem::setCrs( QgsCoordinateReferenceSystem crs )
{
QgsDebugMsg( "mPath = " + mPath );
OGRRegisterAll();
OGRSFDriverH hDriver;
OGRDataSourceH hDataSource = OGROpen( TO8F( mPath ), true, &hDriver );
if ( !hDataSource )
return false;
QString driverName = OGR_Dr_GetName( hDriver );
OGR_DS_Destroy( hDataSource );
// we are able to assign CRS only to shapefiles :-(
if ( driverName == "ESRI Shapefile" )
{
QString layerName = mPath.left( mPath.indexOf( ".shp", Qt::CaseInsensitive ) );
QString wkt = crs.toWkt();
// save ordinary .prj file
OGRSpatialReferenceH hSRS = OSRNewSpatialReference( wkt.toLocal8Bit().data() );
OSRMorphToESRI( hSRS ); // this is the important stuff for shapefile .prj
char* pszOutWkt = NULL;
OSRExportToWkt( hSRS, &pszOutWkt );
QFile prjFile( layerName + ".prj" );
if ( prjFile.open( QIODevice::WriteOnly ) )
{
QTextStream prjStream( &prjFile );
prjStream << pszOutWkt << endl;
prjFile.close();
}
else
{
QgsMessageLog::logMessage( tr( "Couldn't open file %1.prj" ).arg( layerName ), tr( "OGR" ) );
return false;
}
OSRDestroySpatialReference( hSRS );
CPLFree( pszOutWkt );
// save qgis-specific .qpj file (maybe because of better wkt compatibility?)
QFile qpjFile( layerName + ".qpj" );
if ( qpjFile.open( QIODevice::WriteOnly ) )
{
QTextStream qpjStream( &qpjFile );
qpjStream << wkt.toLocal8Bit().data() << endl;
qpjFile.close();
}
else
{
QgsMessageLog::logMessage( tr( "Couldn't open file %1.qpj" ).arg( layerName ), tr( "OGR" ) );
return false;
}
return true;
}
// It it is impossible to assign a crs to an existing layer
// No OGR_L_SetSpatialRef : http://trac.osgeo.org/gdal/ticket/4032
return false;
}
char *msProjectionObj2OGCWKT( projectionObj *projection )
{
#if !defined(USE_GDAL) && !defined(USE_OGR)
msSetError(MS_OGRERR,
"Not implemented since neither OGR nor GDAL is enabled.",
"msProjectionObj2OGCWKT()");
return NULL;
#else /* defined USE_GDAL or USE_OGR */
OGRSpatialReferenceH hSRS;
char *pszWKT=NULL, *pszProj4;
int nLength = 0, i;
OGRErr eErr;
if( projection->proj == NULL )
return NULL;
/* -------------------------------------------------------------------- */
/* Form arguments into a full Proj.4 definition string. */
/* -------------------------------------------------------------------- */
for( i = 0; i < projection->numargs; i++ )
nLength += strlen(projection->args[i]) + 2;
pszProj4 = (char *) CPLMalloc(nLength+2);
pszProj4[0] = '\0';
for( i = 0; i < projection->numargs; i++ ) {
strcat( pszProj4, "+" );
strcat( pszProj4, projection->args[i] );
strcat( pszProj4, " " );
}
/* -------------------------------------------------------------------- */
/* Ingest the string into OGRSpatialReference. */
/* -------------------------------------------------------------------- */
hSRS = OSRNewSpatialReference( NULL );
eErr = OSRImportFromProj4( hSRS, pszProj4 );
CPLFree( pszProj4 );
/* -------------------------------------------------------------------- */
/* Export as a WKT string. */
/* -------------------------------------------------------------------- */
if( eErr == OGRERR_NONE )
eErr = OSRExportToWkt( hSRS, &pszWKT );
OSRDestroySpatialReference( hSRS );
if( pszWKT ) {
char *pszWKT2 = msStrdup(pszWKT);
CPLFree( pszWKT );
return pszWKT2;
} else
return NULL;
#endif /* defined USE_GDAL or USE_OGR */
}
bool SpatialReference::isGeocentric() const
{
OGRSpatialReferenceH current =
OSRNewSpatialReference(getWKT(eCompoundOK, false).c_str());
bool output = OSRIsGeocentric(current);
OSRDestroySpatialReference(current);
return output;
}
QgsCoordinateReferenceSystem::QgsCoordinateReferenceSystem( QString theWkt )
: mMapUnits( QGis::UnknownUnit )
, mIsValidFlag( 0 )
, mValidationHint( "" )
{
mCRS = OSRNewSpatialReference( NULL );
createFromWkt( theWkt );
}
QgsCoordinateReferenceSystem::QgsCoordinateReferenceSystem( const long theId, CrsType theType )
: mMapUnits( QGis::UnknownUnit )
, mIsValidFlag( 0 )
, mValidationHint( "" )
{
mCRS = OSRNewSpatialReference( NULL );
createFromId( theId, theType );
}
CProjection::CProjection(CProjection const& in)
{
m_pProjPJ = NULL;
m_prjID = PRJ_NOT_INIT;
m_pSpatialReference = (OGRSpatialReference *)OSRNewSpatialReference(NULL);
if (in.IsInit())
{
operator=(in);
}
}
bool SpatialReference::valid() const
{
std::string wkt = getWKT();
OGRSpatialReferenceH current =
OSRNewSpatialReference(wkt.c_str());
OGRErr err = OSRValidate(current);
OSRDestroySpatialReference(current);
return err == OGRERR_NONE;
}
CProjection::CProjection(const char* prjStr, size_t prjID, const OGRSpatialReference& SR, projPJ pProjPJ)
{
m_pSpatialReference = (OGRSpatialReference *)OSRNewSpatialReference(prjStr);
if (m_pSpatialReference)
{
m_prjID = prjID;
m_prjStr = prjStr;
m_pProjPJ = pProjPJ;
}
else
{
m_prjID = PRJ_UNKNOWN;
}
}
CProjection::CProjection(bool bWGS84)
{
m_pSpatialReference = (OGRSpatialReference *)OSRNewSpatialReference(NULL);
m_pProjPJ = NULL;
m_prjID = PRJ_NOT_INIT;
if (bWGS84)
{
m_prjID = PRJ_WGS_84;
m_prjStr = PRJ_WGS_84_WKT;
m_pSpatialReference->SetWellKnownGeogCS("WGS84");
}
}
void QgsCoordinateReferenceSystem::setProj4String( QString theProj4String )
{
const char *oldlocale = setlocale( LC_NUMERIC, NULL );
setlocale( LC_NUMERIC, "C" );
OSRDestroySpatialReference( mCRS );
mCRS = OSRNewSpatialReference( NULL );
mIsValidFlag = OSRImportFromProj4( mCRS, theProj4String.toLatin1().constData() ) == OGRERR_NONE;
setMapUnits();
#if defined(QGISDEBUG) && QGISDEBUG>=3
debugPrint();
#endif
setlocale( LC_NUMERIC, oldlocale );
}
bool WebMapService::Layer::InitBase(libconfig::ChainedSetting& config)
{
auto crs = config["CRS"];
const int numCRS = crs.getLength();
if (numCRS > 0)
{
for (int c = 0; c < numCRS; c++)
{
supportedCRS[crs[c]] = (OGRSpatialReference*)OSRNewSpatialReference(NULL);
}
}
else
{
cout << "WebMapService::Layer: " << "At least one CRS must be defined" << endl;
return false;
}
for (auto it = supportedCRS.begin(); it != supportedCRS.end(); it++)
{
OGRErr err = OGRERR_UNSUPPORTED_SRS;
string crsString = it->first;
if (crsString.length() > 5)
{
int epsgCode = stoi(crsString.c_str() + 5); // TODO: support non-EPSG codes
err = it->second->importFromEPSG(epsgCode);
}
if (err == OGRERR_UNSUPPORTED_SRS)
{
cout << "WebMapService::Layer: " << "requested CRS is unsupported:" << crsString << endl;
return false;
}
}
// create all possible SRS transformation permutations
for (auto it1 = supportedCRS.begin(); it1 != supportedCRS.end(); it1++)
{
for (auto it2 = it1; it2 != supportedCRS.end(); it2++)
{
if (it2 == supportedCRS.end()) break;
CreateTransform(it1->second, it2->second);
CreateTransform(it2->second, it1->second);
}
}
return true;
}
Q_NOWARN_DEPRECATED_POP
bool QgsOgrLayerItem::setCrs( QgsCoordinateReferenceSystem crs )
{
if ( !( mCapabilities & SetCrs ) )
return false;
QString layerName = mPath.left( mPath.indexOf( ".shp", Qt::CaseInsensitive ) );
QString wkt = crs.toWkt();
// save ordinary .prj file
OGRSpatialReferenceH hSRS = OSRNewSpatialReference( wkt.toLocal8Bit().data() );
OSRMorphToESRI( hSRS ); // this is the important stuff for shapefile .prj
char* pszOutWkt = nullptr;
OSRExportToWkt( hSRS, &pszOutWkt );
QFile prjFile( layerName + ".prj" );
if ( prjFile.open( QIODevice::WriteOnly ) )
{
QTextStream prjStream( &prjFile );
prjStream << pszOutWkt << endl;
prjFile.close();
}
else
{
QgsMessageLog::logMessage( tr( "Couldn't open file %1.prj" ).arg( layerName ), tr( "OGR" ) );
return false;
}
OSRDestroySpatialReference( hSRS );
CPLFree( pszOutWkt );
// save qgis-specific .qpj file (maybe because of better wkt compatibility?)
QFile qpjFile( layerName + ".qpj" );
if ( qpjFile.open( QIODevice::WriteOnly ) )
{
QTextStream qpjStream( &qpjFile );
qpjStream << wkt.toLocal8Bit().data() << endl;
qpjFile.close();
}
else
{
QgsMessageLog::logMessage( tr( "Couldn't open file %1.qpj" ).arg( layerName ), tr( "OGR" ) );
return false;
}
return true;
}
static QString _setSourceCrsFromWKT(const QString& wkt)
{
QString ret;
OGRSpatialReferenceH hSRS = OSRNewSpatialReference(NULL);
QByteArray arr = wkt.toUtf8();
const char* raw_data = arr.constData();
if (OSRImportFromWkt(hSRS, const_cast<char**>(&raw_data)) == OGRERR_NONE)
{
char * ppszReturn = 0;
if (OSRExportToProj4(hSRS, &ppszReturn) == OGRERR_NONE && ppszReturn != 0)
{
ret = ppszReturn;
}
}
OSRDestroySpatialReference(hSRS);
return ret;
}
static QString _setSourceCrsFromESRI(const QString& wkt)
{
QString ret;
QString wkt2("ESRI::" + wkt);
OGRSpatialReferenceH hSRS = OSRNewSpatialReference(NULL);
QByteArray arr = wkt2.toUtf8();
if (OSRSetFromUserInput(hSRS, arr.constData()) == OGRERR_NONE)
{
char * ppszReturn = 0;
if (OSRExportToProj4(hSRS, &ppszReturn) == OGRERR_NONE && ppszReturn != 0)
{
ret = ppszReturn;
}
}
OSRDestroySpatialReference(hSRS);
return ret;
}
void object::test<4>()
{
ensure("SRS handle is NULL", nullptr != srs_);
err_ = OSRSetGS(srs_, -117.0, 100000.0, 100000);
ensure_equals("OSRSetGS failed", err_, OGRERR_NONE);
err_ = OSRSetGeogCS(srs_, "Test GCS", "Test Datum", "WGS84",
SRS_WGS84_SEMIMAJOR, SRS_WGS84_INVFLATTENING,
nullptr, 0, nullptr, 0);
ensure_equals("OSRSetGeogCS failed", err_, OGRERR_NONE);
err_ = OSRSetTOWGS84(srs_, 1, 2, 3, 0, 0, 0, 0);
ensure_equals("OSRSetTOWGS84 failed", err_, OGRERR_NONE);
const int coeffSize = 7;
double coeff[coeffSize] = { 0 };
const double expect[coeffSize] = { 1, 2, 3, 0, 0, 0, 0 };
err_ = OSRGetTOWGS84(srs_, coeff, 7);
ensure_equals("OSRSetTOWGS84 failed", err_, OGRERR_NONE);
ensure("GetTOWGS84 result is wrong",
std::equal(coeff, coeff + coeffSize, expect));
OSRSetLinearUnits(srs_, "Metre", 1);
char* proj4 = nullptr;
err_ = OSRExportToProj4(srs_, &proj4);
ensure_equals("OSRExportToProj4 failed", err_, OGRERR_NONE);
OGRSpatialReferenceH srs2 = nullptr;
srs2 = OSRNewSpatialReference(nullptr);
err_ = OSRImportFromProj4(srs2, proj4);
ensure_equals("OSRImportFromProj4 failed", err_, OGRERR_NONE);
err_ = OSRGetTOWGS84(srs2, coeff, 7);
ensure_equals("OSRSetTOWGS84 failed", err_, OGRERR_NONE);
ensure("GetTOWGS84 result is wrong",
std::equal(coeff, coeff + coeffSize, expect));
OSRDestroySpatialReference(srs2);
CPLFree(proj4);
}
std::string SpatialReference::getVertical() const
{
std::string tmp("");
OGRSpatialReference* poSRS =
(OGRSpatialReference*)OSRNewSpatialReference(m_wkt.c_str());
char *pszWKT = NULL;
OGR_SRSNode* node = poSRS->GetAttrNode("VERT_CS");
if (node && poSRS)
{
node->exportToWkt(&pszWKT);
tmp = pszWKT;
CPLFree(pszWKT);
OSRDestroySpatialReference(poSRS);
}
return tmp;
}
std::string SpatialReference::getHorizontal() const
{
std::string tmp("");
OGRSpatialReference* poSRS =
(OGRSpatialReference*)OSRNewSpatialReference(m_wkt.c_str());
char *pszWKT = NULL;
if (poSRS)
{
poSRS->StripVertical();
poSRS->exportToWkt(&pszWKT);
tmp = pszWKT;
CPLFree(pszWKT);
OSRDestroySpatialReference(poSRS);
}
return tmp;
}
static bool IsValidSRS( const char *pszUserInput )
{
OGRSpatialReferenceH hSRS;
bool bRes = true;
CPLErrorReset();
hSRS = OSRNewSpatialReference( nullptr );
if( OSRSetFromUserInput( hSRS, pszUserInput ) != OGRERR_NONE )
{
bRes = false;
CPLError( CE_Failure, CPLE_AppDefined,
"Translating source or target SRS failed:\n%s",
pszUserInput );
}
OSRDestroySpatialReference( hSRS );
return bRes;
}
char *SanitizeSRS( const char *pszUserInput )
{
OGRSpatialReferenceH hSRS;
char *pszResult = NULL;
CPLErrorReset();
hSRS = OSRNewSpatialReference( NULL );
if( OSRSetFromUserInput( hSRS, pszUserInput ) == OGRERR_NONE )
OSRExportToWkt( hSRS, &pszResult );
else
{
CPLError( CE_Failure, CPLE_AppDefined,
"Translating source or target SRS failed:\n%s",
pszUserInput );
exit( 1 );
}
OSRDestroySpatialReference( hSRS );
return pszResult;
}
int GPJ_wkt_to_grass(struct Cell_head *cellhd, struct Key_Value **projinfo,
struct Key_Value **projunits, const char *wkt,
int datumtrans)
{
int retval;
if (wkt == NULL)
retval =
GPJ_osr_to_grass(cellhd, projinfo, projunits, NULL, datumtrans);
else {
OGRSpatialReferenceH hSRS;
/* Set finder function for locating OGR csv co-ordinate system tables */
SetCSVFilenameHook(GPJ_set_csv_loc);
hSRS = OSRNewSpatialReference(wkt);
retval =
GPJ_osr_to_grass(cellhd, projinfo, projunits, hSRS, datumtrans);
OSRDestroySpatialReference(hSRS);
}
return retval;
}
test_osr_data()
: err_(OGRERR_NONE), srs_(NULL)
{
srs_ = OSRNewSpatialReference(NULL);
}
int main( int argc, char ** argv )
{
GDALDatasetH hDataset;
GDALRasterBandH hBand;
int i, iBand;
double adfGeoTransform[6];
GDALDriverH hDriver;
char **papszMetadata;
int bComputeMinMax = FALSE;
if( !GDALBridgeInitialize( "..", stderr ) )
{
fprintf( stderr, "Unable to intiailize GDAL bridge.\n" );
exit( 10 );
}
if( argc > 1 && strcmp(argv[1],"-mm") == 0 )
{
bComputeMinMax = TRUE;
argv++;
}
GDALAllRegister();
hDataset = GDALOpen( argv[1], GA_ReadOnly );
if( hDataset == NULL )
{
fprintf( stderr,
"GDALOpen failed - %d\n%s\n",
CPLGetLastErrorNo(), CPLGetLastErrorMsg() );
exit( 1 );
}
/* -------------------------------------------------------------------- */
/* Report general info. */
/* -------------------------------------------------------------------- */
hDriver = GDALGetDatasetDriver( hDataset );
printf( "Driver: %s/%s\n",
GDALGetDriverShortName( hDriver ),
GDALGetDriverLongName( hDriver ) );
printf( "Size is %d, %d\n",
GDALGetRasterXSize( hDataset ),
GDALGetRasterYSize( hDataset ) );
/* -------------------------------------------------------------------- */
/* Report projection. */
/* -------------------------------------------------------------------- */
if( GDALGetProjectionRef( hDataset ) != NULL )
{
OGRSpatialReferenceH hSRS;
char *pszProjection;
pszProjection = (char *) GDALGetProjectionRef( hDataset );
hSRS = OSRNewSpatialReference(NULL);
if( OSRImportFromWkt( hSRS, &pszProjection ) == CE_None )
{
char *pszPrettyWkt = NULL;
OSRExportToPrettyWkt( hSRS, &pszPrettyWkt, FALSE );
printf( "Coordinate System is:\n%s\n", pszPrettyWkt );
}
else
printf( "Coordinate System is `%s'\n",
GDALGetProjectionRef( hDataset ) );
OSRDestroySpatialReference( hSRS );
}
/* -------------------------------------------------------------------- */
/* Report Geotransform. */
/* -------------------------------------------------------------------- */
if( GDALGetGeoTransform( hDataset, adfGeoTransform ) == CE_None )
{
printf( "Origin = (%.6f,%.6f)\n",
adfGeoTransform[0], adfGeoTransform[3] );
printf( "Pixel Size = (%.6f,%.6f)\n",
adfGeoTransform[1], adfGeoTransform[5] );
}
/* -------------------------------------------------------------------- */
/* Report GCPs. */
/* -------------------------------------------------------------------- */
if( GDALGetGCPCount( hDataset ) > 0 )
{
printf( "GCP Projection = %s\n", GDALGetGCPProjection(hDataset) );
for( i = 0; i < GDALGetGCPCount(hDataset); i++ )
{
const GDAL_GCP *psGCP;
psGCP = GDALGetGCPs( hDataset ) + i;
printf( "GCP[%3d]: Id=%s, Info=%s\n"
" (%g,%g) -> (%g,%g,%g)\n",
i, psGCP->pszId, psGCP->pszInfo,
psGCP->dfGCPPixel, psGCP->dfGCPLine,
psGCP->dfGCPX, psGCP->dfGCPY, psGCP->dfGCPZ );
}
}
/* -------------------------------------------------------------------- */
/* Report metadata. */
/* -------------------------------------------------------------------- */
papszMetadata = GDALGetMetadata( hDataset, NULL );
if( papszMetadata != NULL )
{
printf( "Metadata:\n" );
for( i = 0; papszMetadata[i] != NULL; i++ )
{
printf( " %s\n", papszMetadata[i] );
}
}
/* -------------------------------------------------------------------- */
/* Report subdatasets. */
/* -------------------------------------------------------------------- */
papszMetadata = GDALGetMetadata( hDataset, "SUBDATASETS" );
if( papszMetadata != NULL )
{
printf( "Subdatasets:\n" );
for( i = 0; papszMetadata[i] != NULL; i++ )
{
printf( " %s\n", papszMetadata[i] );
}
}
/* -------------------------------------------------------------------- */
/* Report corners. */
/* -------------------------------------------------------------------- */
printf( "Corner Coordinates:\n" );
GDALInfoReportCorner( hDataset, "Upper Left",
0.0, 0.0 );
GDALInfoReportCorner( hDataset, "Lower Left",
0.0, GDALGetRasterYSize(hDataset));
GDALInfoReportCorner( hDataset, "Upper Right",
GDALGetRasterXSize(hDataset), 0.0 );
GDALInfoReportCorner( hDataset, "Lower Right",
GDALGetRasterXSize(hDataset),
GDALGetRasterYSize(hDataset) );
GDALInfoReportCorner( hDataset, "Center",
GDALGetRasterXSize(hDataset)/2.0,
GDALGetRasterYSize(hDataset)/2.0 );
/* ==================================================================== */
/* Loop over bands. */
/* ==================================================================== */
for( iBand = 0; iBand < GDALGetRasterCount( hDataset ); iBand++ )
{
double dfMin, dfMax, adfCMinMax[2], dfNoData;
int bGotMin, bGotMax, bGotNodata;
int nBlockXSize, nBlockYSize;
hBand = GDALGetRasterBand( hDataset, iBand+1 );
GDALGetBlockSize( hBand, &nBlockXSize, &nBlockYSize );
printf( "Band %d Block=%dx%d Type=%d, ColorInterp=%d\n", iBand+1,
nBlockXSize, nBlockYSize,
GDALGetRasterDataType(hBand),
GDALGetRasterColorInterpretation(hBand) );
dfMin = GDALGetRasterMinimum( hBand, &bGotMin );
dfMax = GDALGetRasterMaximum( hBand, &bGotMax );
printf( " Min=%.3f/%d, Max=%.3f/%d", dfMin, bGotMin, dfMax, bGotMax);
if( bComputeMinMax )
{
GDALComputeRasterMinMax( hBand, TRUE, adfCMinMax );
printf( ", Computed Min/Max=%.3f,%.3f",
adfCMinMax[0], adfCMinMax[1] );
}
printf( "\n" );
dfNoData = GDALGetRasterNoDataValue( hBand, &bGotNodata );
if( bGotNodata )
{
printf( " NoData Value=%g\n", dfNoData );
}
if( GDALGetOverviewCount(hBand) > 0 )
{
int iOverview;
printf( " Overviews: " );
for( iOverview = 0;
iOverview < GDALGetOverviewCount(hBand);
iOverview++ )
{
GDALRasterBandH hOverview;
if( iOverview != 0 )
printf( ", " );
hOverview = GDALGetOverview( hBand, iOverview );
printf( "%dx%d",
GDALGetRasterBandXSize( hOverview ),
GDALGetRasterBandYSize( hOverview ) );
}
printf( "\n" );
}
papszMetadata = GDALGetMetadata( hBand, NULL );
if( papszMetadata != NULL )
{
printf( "Metadata:\n" );
for( i = 0; papszMetadata[i] != NULL; i++ )
{
printf( " %s\n", papszMetadata[i] );
}
}
if( GDALGetRasterColorInterpretation(hBand) == GCI_PaletteIndex )
{
GDALColorTableH hTable;
int i;
hTable = GDALGetRasterColorTable( hBand );
printf( " Color Table (%s with %d entries)\n",
GDALGetPaletteInterpretationName(
GDALGetPaletteInterpretation( hTable )),
GDALGetColorEntryCount( hTable ) );
for( i = 0; i < GDALGetColorEntryCount( hTable ); i++ )
{
GDALColorEntry sEntry;
GDALGetColorEntryAsRGB( hTable, i, &sEntry );
printf( " %3d: %d,%d,%d,%d\n",
i,
sEntry.c1,
sEntry.c2,
sEntry.c3,
sEntry.c4 );
}
}
}
GDALClose( hDataset );
exit( 0 );
}
