static CPLString GDALGMLJP2EvalExpr(const CPLString& osTemplate,
xmlXPathContextPtr pXPathCtx,
xmlDocPtr pDoc)
{
CPLString osXMLRes;
size_t nPos = 0;
while( true )
{
// Get next expression.
size_t nStartPos = osTemplate.find("{{{", nPos);
if( nStartPos == std::string::npos)
{
// Add terminating portion of the template.
osXMLRes += osTemplate.substr(nPos);
break;
}
// Add portion of template before the expression.
osXMLRes += osTemplate.substr(nPos, nStartPos - nPos);
const char* pszExpr = osTemplate.c_str() + nStartPos;
GDALGMLJP2Expr* poExpr = GDALGMLJP2Expr::Build(pszExpr, pszExpr);
if( poExpr == nullptr )
break;
nPos = static_cast<size_t>(pszExpr - osTemplate.c_str());
osXMLRes += poExpr->Evaluate(pXPathCtx,pDoc).osValue;
delete poExpr;
}
return osXMLRes;
}
/*
* ExecuteSQL()
*/
OGRLayer *OGRNGWDataset::ExecuteSQL( const char *pszStatement,
OGRGeometry *poSpatialFilter, const char *pszDialect )
{
// Clean statement string.
CPLString osStatement(pszStatement);
osStatement = osStatement.Trim().replaceAll(" ", " ");
if( STARTS_WITH_CI(osStatement.c_str(), "DELLAYER:") )
{
CPLString osLayerName = osStatement.substr(9);
if( osLayerName.endsWith(";") )
{
osLayerName = osLayerName.substr(0, osLayerName.size() - 1);
osLayerName.Trim();
}
CPLDebug("NGW", "Delete layer with name %s.", osLayerName.c_str());
for( int iLayer = 0; iLayer < nLayers; ++iLayer )
{
if( EQUAL(papoLayers[iLayer]->GetName(), osLayerName.c_str() ) )
{
DeleteLayer( iLayer );
break;
}
}
return nullptr;
}
if( STARTS_WITH_CI(osStatement.c_str(), "DELETE FROM") )
{
// Get layer name from pszStatement DELETE FROM layer;.
CPLString osLayerName = osStatement.substr(12);
if( osLayerName.endsWith(";") )
{
osLayerName = osLayerName.substr(0, osLayerName.size() - 1);
osLayerName.Trim();
}
CPLDebug("NGW", "Delete features from layer with name %s.", osLayerName.c_str());
OGRNGWLayer *poLayer = static_cast<OGRNGWLayer*>(GetLayerByName(osLayerName));
if( poLayer )
{
poLayer->DeleteAllFeatures();
}
else
{
CPLError(CE_Failure, CPLE_AppDefined, "Unknown layer : %s",
osLayerName.c_str());
}
return nullptr;
}
return GDALDataset::ExecuteSQL(pszStatement, poSpatialFilter, pszDialect);
}
void ERSHdrNode::Set( const char *pszPath, const char *pszValue )
{
CPLString osPath = pszPath;
int iDot;
iDot = osPath.find_first_of('.');
/* -------------------------------------------------------------------- */
/* We have an intermediate node, find or create it and */
/* recurse. */
/* -------------------------------------------------------------------- */
if( iDot != -1 )
{
CPLString osPathFirst = osPath.substr(0,iDot);
CPLString osPathRest = osPath.substr(iDot+1);
ERSHdrNode *poFirst = FindNode( osPathFirst );
if( poFirst == NULL )
{
poFirst = new ERSHdrNode();
MakeSpace();
papszItemName[nItemCount] = CPLStrdup(osPathFirst);
papszItemValue[nItemCount] = NULL;
papoItemChild[nItemCount] = poFirst;
nItemCount++;
}
poFirst->Set( osPathRest, pszValue );
return;
}
/* -------------------------------------------------------------------- */
/* This is the final item name. Find or create it. */
/* -------------------------------------------------------------------- */
int i;
for( i = 0; i < nItemCount; i++ )
{
if( EQUAL(osPath,papszItemName[i])
&& papszItemValue[i] != NULL )
{
CPLFree( papszItemValue[i] );
papszItemValue[i] = CPLStrdup( pszValue );
return;
}
}
MakeSpace();
papszItemName[nItemCount] = CPLStrdup(osPath);
papszItemValue[nItemCount] = CPLStrdup(pszValue);
papoItemChild[nItemCount] = NULL;
nItemCount++;
}
CPLString OGRPLScenesDataV1Dataset::InsertAPIKeyInURL(CPLString osURL)
{
if( STARTS_WITH(osURL, "http://") )
{
osURL = "http://" + m_osAPIKey + ":@" + osURL.substr(strlen("http://"));
}
else if( STARTS_WITH(osURL, "https://") )
{
osURL = "https://" + m_osAPIKey + ":@" + osURL.substr(strlen("https://"));
}
return osURL;
}
void GDALGMLJP2Expr::ReportError( const char* pszOriStr,
const char* pszStr,
const char* pszIntroMessage )
{
size_t nDist = static_cast<size_t>(pszStr - pszOriStr);
if( nDist > 40 )
nDist = 40;
CPLString osErrMsg(pszIntroMessage);
CPLString osInvalidExpr = CPLString(pszStr - nDist).substr(0, nDist + 20);
for( int i = static_cast<int>(nDist) - 1; i >= 0; --i )
{
if( osInvalidExpr[i] == '\n' )
{
osInvalidExpr = osInvalidExpr.substr(i+1);
nDist -= i + 1;
break;
}
}
for( size_t i = nDist; i < osInvalidExpr.size(); ++i )
{
if( osInvalidExpr[i] == '\n' )
{
osInvalidExpr.resize(i);
break;
}
}
osErrMsg += osInvalidExpr;
osErrMsg += "\n";
for( size_t i = 0; i < nDist; ++i )
osErrMsg += " ";
osErrMsg += "^";
CPLError(CE_Failure, CPLE_AppDefined, "%s", osErrMsg.c_str());
}
/**
* CPLStrip()
*/
CPLString CPLStrip(const CPLString& sString, const char cChar)
{
if(sString.empty())
return sString;
size_t dCopyFrom = 0;
size_t dCopyCount = sString.size();
if (sString[0] == cChar)
{
dCopyFrom++;
dCopyCount--;
}
if (sString[sString.size() - 1] == cChar)
dCopyCount--;
if(dCopyCount == 0)
return CPLString();
return sString.substr(dCopyFrom, dCopyCount);
}
int OGRSelafinDataSource::OpenTable(const char * pszFilename) {
#ifdef DEBUG_VERBOSE
CPLDebug("Selafin", "OpenTable(%s,%i)",
pszFilename, static_cast<int>(bUpdate));
#endif
// Open the file
VSILFILE *fp = nullptr;
if( bUpdate )
{
fp = VSIFOpenExL( pszFilename, "rb+", true );
}
else
{
fp = VSIFOpenExL( pszFilename, "rb", true );
}
if( fp == nullptr ) {
CPLError( CE_Warning, CPLE_OpenFailed, "Failed to open %s.", VSIGetLastErrorMsg() );
return FALSE;
}
if( !bUpdate && strstr(pszFilename, "/vsigzip/") == nullptr && strstr(pszFilename, "/vsizip/") == nullptr ) fp = (VSILFILE*) VSICreateBufferedReaderHandle((VSIVirtualHandle*)fp);
// Quickly check if the file is in Selafin format, before actually starting to read to make it faster
char szBuf[9];
VSIFReadL(szBuf,1,4,fp);
if (szBuf[0]!=0 || szBuf[1]!=0 || szBuf[2]!=0 || szBuf[3]!=0x50) {
VSIFCloseL(fp);
return FALSE;
}
VSIFSeekL(fp,84,SEEK_SET);
VSIFReadL(szBuf,1,8,fp);
if (szBuf[0]!=0 || szBuf[1]!=0 || szBuf[2]!=0 || szBuf[3]!=0x50 || szBuf[4]!=0 || szBuf[5]!=0 || szBuf[6]!=0 || szBuf[7]!=8) {
VSIFCloseL(fp);
return FALSE;
}
/* VSIFSeekL(fp,76,SEEK_SET);
VSIFReadL(szBuf,1,8,fp);
if (STRNCASECMP(szBuf,"Seraphin",8)!=0 && STRNCASECMP(szBuf,"Serafin",7)!=0) {
VSIFCloseL(fp);
return FALSE;
} */
// Get layer base name
CPLString osBaseLayerName = CPLGetBasename(pszFilename);
CPLString osExt = CPLGetExtension(pszFilename);
if( STARTS_WITH(pszFilename, "/vsigzip/") && EQUAL(osExt, "gz") ) {
size_t nPos=std::string::npos;
if (strlen(pszFilename)>3) nPos=osExt.find_last_of('.',strlen(pszFilename)-4);
if (nPos!=std::string::npos) {
osExt=osExt.substr(nPos+1,strlen(pszFilename)-4-nPos);
osBaseLayerName=osBaseLayerName.substr(0,nPos);
} else {
osExt="";
}
}
// Read header of file to get common information for all layers
// poHeader now owns fp
poHeader=Selafin::read_header(fp,pszFilename);
if (poHeader==nullptr) {
CPLError( CE_Failure, CPLE_OpenFailed, "Failed to open %s, wrong format.\n", pszFilename);
return FALSE;
}
if (poHeader->nEpsg!=0) {
poSpatialRef=new OGRSpatialReference();
poSpatialRef->SetAxisMappingStrategy(OAMS_TRADITIONAL_GIS_ORDER);
if (poSpatialRef->importFromEPSG(poHeader->nEpsg)!=OGRERR_NONE) {
CPLError( CE_Warning, CPLE_AppDefined, "EPSG %d not found. Could not set datasource SRS.\n", poHeader->nEpsg);
delete poSpatialRef;
poSpatialRef=nullptr;
}
}
// To prevent int overflow in poRange.getSize() call where we do
// nSteps * 2
if( poHeader->nSteps >= INT_MAX / 2 )
{
CPLError( CE_Failure, CPLE_OpenFailed, "Invalid nSteps value" );
return FALSE;
}
// Create two layers for each selected time step: one for points, the other for elements
poRange.setMaxValue(poHeader->nSteps);
const int nNewLayers = static_cast<int>(poRange.getSize());
if (EQUAL(pszFilename, "/vsistdin/")) osBaseLayerName = "layer";
CPLString osLayerName;
papoLayers = (OGRSelafinLayer **) CPLRealloc(papoLayers, sizeof(void*) * (nLayers+nNewLayers));
for (size_t j=0;j<2;++j) {
SelafinTypeDef eType=(j==0)?POINTS:ELEMENTS;
for (int i=0;i<poHeader->nSteps;++i) {
if (poRange.contains(eType,i)) {
char szTemp[30];
double dfTime = 0.0;
if( VSIFSeekL(fp, poHeader->getPosition(i)+4, SEEK_SET)!=0 ||
Selafin::read_float(fp, dfTime)==0 )
{
CPLError( CE_Failure, CPLE_OpenFailed, "Failed to open %s, wrong format.\n", pszFilename);
return FALSE;
}
if (poHeader->panStartDate==nullptr) snprintf(szTemp,29,"%d",i); else {
struct tm sDate;
memset(&sDate, 0, sizeof(sDate));
sDate.tm_year=poHeader->panStartDate[0]-1900;
sDate.tm_mon=poHeader->panStartDate[1]-1;
sDate.tm_mday=poHeader->panStartDate[2];
sDate.tm_hour=poHeader->panStartDate[3];
sDate.tm_min=poHeader->panStartDate[4];
double dfSec=poHeader->panStartDate[5]+dfTime;
if( dfSec >= 0 && dfSec < 60 )
sDate.tm_sec=static_cast<int>(dfSec);
mktime(&sDate);
strftime(szTemp,29,"%Y_%m_%d_%H_%M_%S",&sDate);
}
if (eType==POINTS) osLayerName=osBaseLayerName+"_p"+szTemp; else osLayerName=osBaseLayerName+"_e"+szTemp;
papoLayers[nLayers++] =
new OGRSelafinLayer( osLayerName, bUpdate, poSpatialRef,
poHeader, i, eType);
//poHeader->nRefCount++;
}
}
}
// Free allocated variables and exit
return TRUE;
}
int ILI1Reader::ReadTable(CPL_UNUSED const char *layername) {
char **tokens = NULL;
int ret = TRUE;
int warned = FALSE;
int geomIdx = -1;
OGRFeatureDefn *featureDef = curLayer->GetLayerDefn();
OGRFeature *feature = NULL;
bool bFeatureAdded = false;
while (ret && (tokens = ReadParseLine()) != NULL)
{
const char *firsttok = CSLGetField(tokens, 0);
if (EQUAL(firsttok, "OBJE"))
{
if (featureDef->GetFieldCount() == 0 && curLayer->GetFeatureCount() == 0)
{
CPLError( CE_Warning, CPLE_AppDefined,
"No field definition found for table: %s",
featureDef->GetName() );
// Model not read - use heuristics.
for( int fIndex=1; fIndex<CSLCount(tokens); fIndex++ )
{
char szFieldName[32];
snprintf(szFieldName, sizeof(szFieldName), "Field%02d", fIndex);
OGRFieldDefn oFieldDefn(szFieldName, OFTString);
featureDef->AddFieldDefn(&oFieldDefn);
}
}
//start new feature
if( !bFeatureAdded )
delete feature;
feature = new OGRFeature(featureDef);
for( int fIndex=1, fieldno = 0;
fIndex<CSLCount(tokens) && fieldno < featureDef->GetFieldCount();
fIndex++, fieldno++ )
{
if (!(tokens[fIndex][0] == codeUndefined && tokens[fIndex][1] == '\0')) {
#ifdef DEBUG_VERBOSE
CPLDebug( "READ TABLE OGR_ILI", "Setting Field %d (Type %d): %s",
fieldno, featureDef->GetFieldDefn(fieldno)->GetType(),
tokens[fIndex] );
#endif
if (featureDef->GetFieldDefn(fieldno)->GetType() == OFTString) {
// Interlis 1 encoding is ISO 8859-1 (Latin1) -> Recode to UTF-8
char* pszRecoded = CPLRecode(
tokens[fIndex], CPL_ENC_ISO8859_1, CPL_ENC_UTF8);
// Replace space marks
for( char* pszString = pszRecoded;
*pszString != '\0';
pszString++ ) {
if (*pszString == codeBlank) *pszString = ' ';
}
feature->SetField(fieldno, pszRecoded);
CPLFree(pszRecoded);
} else {
feature->SetField(fieldno, tokens[fIndex]);
}
if (featureDef->GetFieldDefn(fieldno)->GetType() == OFTReal
&& fieldno > 0
&& featureDef->GetFieldDefn(fieldno-1)->GetType() == OFTReal) {
// Check for Point geometry (Coord type).
// If there is no ili model read,
// we have no chance to detect the
// geometry column.
CPLString geomfldname
= featureDef->GetFieldDefn(fieldno)->GetNameRef();
// Check if name ends with _1.
if (geomfldname.size() >= 2 && geomfldname[geomfldname.size()-2]
== '_') {
geomfldname = geomfldname.substr(0, geomfldname.size()-2);
geomIdx = featureDef->GetGeomFieldIndex(geomfldname.c_str());
if (geomIdx == -1)
{
CPLError( CE_Warning, CPLE_AppDefined,
"No matching definition for field '%s' of "
"table %s found",
geomfldname.c_str(), featureDef->GetName() );
}
} else {
geomIdx = -1;
}
if (geomIdx >= 0) {
if (featureDef->GetGeomFieldDefn(geomIdx)->GetType() ==
wkbPoint) {
// Add Point geometry.
OGRPoint *ogrPoint = new OGRPoint(
CPLAtof(tokens[fIndex-1]), CPLAtof(tokens[fIndex]));
feature->SetGeomFieldDirectly(geomIdx, ogrPoint);
} else if (featureDef->GetGeomFieldDefn(geomIdx)->GetType() ==
wkbPoint25D && fieldno > 1 &&
featureDef->GetFieldDefn(fieldno-2)->GetType() ==
OFTReal) {
// Add 3D Point geometry.
OGRPoint *ogrPoint = new OGRPoint(
CPLAtof(tokens[fIndex-2]), CPLAtof(tokens[fIndex-1]),
CPLAtof(tokens[fIndex]) );
feature->SetGeomFieldDirectly(geomIdx, ogrPoint);
}
}
}
}
}
if (!warned && featureDef->GetFieldCount() != CSLCount(tokens)-1) {
CPLError( CE_Warning, CPLE_AppDefined,
"Field count of table %s doesn't match. %d declared, "
"%d found (e.g. ignored LINEATTR)",
featureDef->GetName(), featureDef->GetFieldCount(),
CSLCount(tokens) - 1 );
warned = TRUE;
}
if (feature->GetFieldCount() > 0) {
// USE _TID as FID. TODO: respect IDENT field from model.
feature->SetFID(feature->GetFieldAsInteger64(0));
}
curLayer->AddFeature(feature);
bFeatureAdded = true;
geomIdx = -1; //Reset
}
else if (EQUAL(firsttok, "STPT") && feature != NULL)
{
//Find next non-Point geometry
if (geomIdx < 0) geomIdx = 0;
while (geomIdx < featureDef->GetGeomFieldCount() &&
featureDef->GetGeomFieldDefn(geomIdx)->GetType() == wkbPoint) {
geomIdx++;
}
OGRwkbGeometryType geomType
= (geomIdx < featureDef->GetGeomFieldCount()) ?
featureDef->GetGeomFieldDefn(geomIdx)->GetType() : wkbNone;
if( CSLCount(tokens) >= 3 )
ReadGeom(tokens, geomIdx, geomType, feature);
}
else if (EQUAL(firsttok, "ELIN"))
{
// Empty geom.
}
else if (EQUAL(firsttok, "EDGE") && feature != NULL)
{
CSLDestroy(tokens);
tokens = ReadParseLine(); //STPT
//Find next non-Point geometry
do {
geomIdx++;
} while (geomIdx < featureDef->GetGeomFieldCount() &&
featureDef->GetGeomFieldDefn(geomIdx)->GetType() == wkbPoint);
if( CSLCount(tokens) >= 3 )
ReadGeom(tokens, geomIdx, wkbMultiLineString, feature);
}
else if (EQUAL(firsttok, "PERI"))
{
}
else if (EQUAL(firsttok, "ETAB"))
{
CPLDebug( "OGR_ILI", "Total features: " CPL_FRMT_GIB,
curLayer->GetFeatureCount() );
CSLDestroy(tokens);
if( !bFeatureAdded )
delete feature;
return TRUE;
}
else
{
CPLError( CE_Warning, CPLE_AppDefined,
"Unexpected token: %s", firsttok );
}
CSLDestroy(tokens);
}
if( !bFeatureAdded )
delete feature;
return ret;
}
int PDSDataset::ParseImage( CPLString osPrefix )
{
/* ------------------------------------------------------------------- */
/* We assume the user is pointing to the label (ie. .lbl) file. */
/* ------------------------------------------------------------------- */
// IMAGE can be inline or detached and point to an image name
// ^IMAGE = 3
// ^IMAGE = "GLOBAL_ALBEDO_8PPD.IMG"
// ^IMAGE = "MEGT90N000CB.IMG"
// ^IMAGE = ("BLAH.IMG",1) -- start at record 1 (1 based)
// ^IMAGE = ("BLAH.IMG") -- still start at record 1 (equiv of "BLAH.IMG")
// ^IMAGE = ("BLAH.IMG", 5 <BYTES>) -- start at byte 5 (the fifth byte in the file)
// ^IMAGE = 10851 <BYTES>
// ^SPECTRAL_QUBE = 5 for multi-band images
CPLString osImageKeyword = osPrefix + "^IMAGE";
CPLString osQube = GetKeyword( osImageKeyword, "" );
CPLString osTargetFile = GetDescription();
if (EQUAL(osQube,"")) {
osImageKeyword = "^SPECTRAL_QUBE";
osQube = GetKeyword( osImageKeyword );
}
int nQube = atoi(osQube);
int nDetachedOffset = 0;
int bDetachedOffsetInBytes = FALSE;
if( osQube.size() && osQube[0] == '(' )
{
osQube = "\"";
osQube += GetKeywordSub( osImageKeyword, 1 );
osQube += "\"";
nDetachedOffset = atoi(GetKeywordSub( osImageKeyword, 2, "1")) - 1;
// If this is not explicitly in bytes, then it is assumed to be in
// records, and we need to translate to bytes.
if (strstr(GetKeywordSub(osImageKeyword,2),"<BYTES>") != NULL)
bDetachedOffsetInBytes = TRUE;
}
if( osQube.size() && osQube[0] == '"' )
{
CPLString osTPath = CPLGetPath(GetDescription());
CPLString osFilename = osQube;
CleanString( osFilename );
osTargetFile = CPLFormCIFilename( osTPath, osFilename, NULL );
osExternalCube = osTargetFile;
}
GDALDataType eDataType = GDT_Byte;
//image parameters
int nRows, nCols, nBands = 1;
int nSkipBytes = 0;
int itype;
int record_bytes;
char chByteOrder = 'M'; //default to MSB
double dfNoData = 0.0;
/* -------------------------------------------------------------------- */
/* Checks to see if this is raw PDS image not compressed image */
/* so ENCODING_TYPE either does not exist or it equals "N/A". */
/* Compressed types will not be supported in this routine */
/* -------------------------------------------------------------------- */
const char *value;
CPLString osEncodingType = GetKeyword(osPrefix+"IMAGE.ENCODING_TYPE","N/A");
CleanString(osEncodingType);
if ( !EQUAL(osEncodingType.c_str(),"N/A") )
{
CPLError( CE_Failure, CPLE_OpenFailed,
"*** PDS image file has an ENCODING_TYPE parameter:\n"
"*** gdal pds driver does not support compressed image types\n"
"found: (%s)\n\n", osEncodingType.c_str() );
return FALSE;
}
/**************** end ENCODING_TYPE check ***********************/
/*********** Grab layout type (BSQ, BIP, BIL) ************/
// AXIS_NAME = (SAMPLE,LINE,BAND)
/*********** Grab samples lines band **************/
/** if AXIS_NAME = "" then Bands=1 and Sample and Lines **/
/** are there own keywords "LINES" and "LINE_SAMPLES" **/
/** if not NULL then CORE_ITEMS keyword i.e. (234,322,2) **/
/***********************************************************/
char szLayout[10] = "BSQ"; //default to band seq.
value = GetKeyword( osPrefix+"IMAGE.AXIS_NAME", "" );
if (EQUAL(value,"(SAMPLE,LINE,BAND)") ) {
strcpy(szLayout,"BSQ");
nCols = atoi(GetKeywordSub(osPrefix+"IMAGE.CORE_ITEMS",1));
nRows = atoi(GetKeywordSub(osPrefix+"IMAGE.CORE_ITEMS",2));
nBands = atoi(GetKeywordSub(osPrefix+"IMAGE.CORE_ITEMS",3));
}
else if (EQUAL(value,"(BAND,LINE,SAMPLE)") ) {
strcpy(szLayout,"BIP");
nBands = atoi(GetKeywordSub(osPrefix+"IMAGE.CORE_ITEMS",1));
nRows = atoi(GetKeywordSub(osPrefix+"IMAGE.CORE_ITEMS",2));
nCols = atoi(GetKeywordSub(osPrefix+"IMAGE.CORE_ITEMS",3));
}
else if (EQUAL(value,"(SAMPLE,BAND,LINE)") ) {
strcpy(szLayout,"BIL");
nCols = atoi(GetKeywordSub(osPrefix+"IMAGE.CORE_ITEMS",1));
nBands = atoi(GetKeywordSub(osPrefix+"IMAGE.CORE_ITEMS",2));
nRows = atoi(GetKeywordSub(osPrefix+"IMAGE.CORE_ITEMS",3));
}
else if ( EQUAL(value,"") ) {
strcpy(szLayout,"BSQ");
nCols = atoi(GetKeyword(osPrefix+"IMAGE.LINE_SAMPLES",""));
nRows = atoi(GetKeyword(osPrefix+"IMAGE.LINES",""));
nBands = atoi(GetKeyword(osPrefix+"IMAGE.BANDS","1"));
}
else {
CPLError( CE_Failure, CPLE_OpenFailed,
"%s layout not supported. Abort\n\n", value);
return FALSE;
}
/*********** Grab Qube record bytes **********/
record_bytes = atoi(GetKeyword(osPrefix+"IMAGE.RECORD_BYTES"));
if (record_bytes == 0)
record_bytes = atoi(GetKeyword(osPrefix+"RECORD_BYTES"));
// this can happen with "record_type = undefined".
if( record_bytes == 0 )
record_bytes = 1;
if( nQube >0 && osQube.find("<BYTES>") != CPLString::npos )
nSkipBytes = nQube - 1;
else if (nQube > 0 )
nSkipBytes = (nQube - 1) * record_bytes;
else if( nDetachedOffset > 0 )
{
if (bDetachedOffsetInBytes)
nSkipBytes = nDetachedOffset;
else
nSkipBytes = nDetachedOffset * record_bytes;
}
else
nSkipBytes = 0;
nSkipBytes += atoi(GetKeyword(osPrefix+"IMAGE.LINE_PREFIX_BYTES",""));
/*********** Grab SAMPLE_TYPE *****************/
/** if keyword not found leave as "M" or "MSB" **/
CPLString osST = GetKeyword( osPrefix+"IMAGE.SAMPLE_TYPE" );
if( osST.size() >= 2 && osST[0] == '"' && osST[osST.size()-1] == '"' )
osST = osST.substr( 1, osST.size() - 2 );
if( (EQUAL(osST,"LSB_INTEGER")) ||
(EQUAL(osST,"LSB")) || // just incase
(EQUAL(osST,"LSB_UNSIGNED_INTEGER")) ||
(EQUAL(osST,"LSB_SIGNED_INTEGER")) ||
(EQUAL(osST,"UNSIGNED_INTEGER")) ||
(EQUAL(osST,"VAX_REAL")) ||
(EQUAL(osST,"VAX_INTEGER")) ||
(EQUAL(osST,"PC_INTEGER")) || //just incase
(EQUAL(osST,"PC_REAL")) ) {
chByteOrder = 'I';
}
/**** Grab format type - pds supports 1,2,4,8,16,32,64 (in theory) **/
/**** I have only seen 8, 16, 32 (float) in released datasets **/
itype = atoi(GetKeyword(osPrefix+"IMAGE.SAMPLE_BITS",""));
switch(itype) {
case 8 :
eDataType = GDT_Byte;
dfNoData = NULL1;
break;
case 16 :
if( strstr(osST,"UNSIGNED") != NULL )
eDataType = GDT_UInt16;
else
eDataType = GDT_Int16;
dfNoData = NULL2;
break;
case 32 :
eDataType = GDT_Float32;
dfNoData = NULL3;
break;
case 64 :
eDataType = GDT_Float64;
dfNoData = NULL3;
break;
default :
CPLError( CE_Failure, CPLE_AppDefined,
"Sample_bits of %d is not supported in this gdal PDS reader.",
itype);
return FALSE;
}
/* -------------------------------------------------------------------- */
/* Is there a specific nodata value in the file? Either the */
/* MISSING or MISSING_CONSTANT keywords are nodata. */
/* -------------------------------------------------------------------- */
if( GetKeyword( osPrefix+"IMAGE.MISSING", NULL ) != NULL )
dfNoData = CPLAtofM( GetKeyword( osPrefix+"IMAGE.MISSING", "" ) );
if( GetKeyword( osPrefix+"IMAGE.MISSING_CONSTANT", NULL ) != NULL )
dfNoData = CPLAtofM( GetKeyword( osPrefix+"IMAGE.MISSING_CONSTANT",""));
/* -------------------------------------------------------------------- */
/* Did we get the required keywords? If not we return with */
/* this never having been considered to be a match. This isn't */
/* an error! */
/* -------------------------------------------------------------------- */
if( nRows < 1 || nCols < 1 || nBands < 1 )
{
CPLError( CE_Failure, CPLE_AppDefined,
"File %s appears to be a PDS file, but failed to find some required keywords.",
GetDescription() );
return FALSE;
}
/* -------------------------------------------------------------------- */
/* Capture some information from the file that is of interest. */
/* -------------------------------------------------------------------- */
nRasterXSize = nCols;
nRasterYSize = nRows;
/* -------------------------------------------------------------------- */
/* Open target binary file. */
/* -------------------------------------------------------------------- */
if( eAccess == GA_ReadOnly )
{
fpImage = VSIFOpenL( osTargetFile, "rb" );
if( fpImage == NULL )
{
CPLError( CE_Failure, CPLE_OpenFailed,
"Failed to open %s.\n%s",
osTargetFile.c_str(),
VSIStrerror( errno ) );
return FALSE;
}
}
else
{
fpImage = VSIFOpenL( osTargetFile, "r+b" );
if( fpImage == NULL )
{
CPLError( CE_Failure, CPLE_OpenFailed,
"Failed to open %s with write permission.\n%s",
osTargetFile.c_str(),
VSIStrerror( errno ) );
return FALSE;
}
}
/* -------------------------------------------------------------------- */
/* Compute the line offset. */
/* -------------------------------------------------------------------- */
int nItemSize = GDALGetDataTypeSize(eDataType)/8;
int nLineOffset = record_bytes;
int nPixelOffset, nBandOffset;
if( EQUAL(szLayout,"BIP") )
{
nPixelOffset = nItemSize * nBands;
nBandOffset = nItemSize;
nLineOffset = ((nPixelOffset * nCols + record_bytes - 1)/record_bytes)
* record_bytes;
}
else if( EQUAL(szLayout,"BSQ") )
{
nPixelOffset = nItemSize;
nLineOffset = ((nPixelOffset * nCols + record_bytes - 1)/record_bytes)
* record_bytes;
nBandOffset = nLineOffset * nRows;
}
else /* assume BIL */
{
nPixelOffset = nItemSize;
nBandOffset = nItemSize * nCols;
nLineOffset = ((nBandOffset * nCols + record_bytes - 1)/record_bytes)
* record_bytes;
}
/* -------------------------------------------------------------------- */
/* Create band information objects. */
/* -------------------------------------------------------------------- */
int i;
for( i = 0; i < nBands; i++ )
{
RawRasterBand *poBand;
poBand =
new RawRasterBand( this, i+1, fpImage,
nSkipBytes + nBandOffset * i,
nPixelOffset, nLineOffset, eDataType,
#ifdef CPL_LSB
chByteOrder == 'I' || chByteOrder == 'L',
#else
chByteOrder == 'M',
#endif
TRUE );
if( nBands == 1 )
{
const char* pszMin = GetKeyword(osPrefix+"IMAGE.MINIMUM", NULL);
const char* pszMax = GetKeyword(osPrefix+"IMAGE.MAXIMUM", NULL);
const char* pszMean = GetKeyword(osPrefix+"IMAGE.MEAN", NULL);
const char* pszStdDev= GetKeyword(osPrefix+"IMAGE.STANDARD_DEVIATION", NULL);
if (pszMin != NULL && pszMax != NULL &&
pszMean != NULL && pszStdDev != NULL)
{
poBand->SetStatistics( CPLAtofM(pszMin),
CPLAtofM(pszMax),
CPLAtofM(pszMean),
CPLAtofM(pszStdDev));
}
}
poBand->SetNoDataValue( dfNoData );
SetBand( i+1, poBand );
// Set offset/scale values at the PAM level.
poBand->SetOffset(
CPLAtofM(GetKeyword(osPrefix+"IMAGE.OFFSET","0.0")));
poBand->SetScale(
CPLAtofM(GetKeyword(osPrefix+"IMAGE.SCALING_FACTOR","1.0")));
}
return TRUE;
}
GDALDataset *ERSDataset::Open( GDALOpenInfo * poOpenInfo )
{
/* -------------------------------------------------------------------- */
/* We assume the user selects the .ers file. */
/* -------------------------------------------------------------------- */
if( poOpenInfo->nHeaderBytes > 15
&& EQUALN((const char *) poOpenInfo->pabyHeader,"Algorithm Begin",15) )
{
CPLError( CE_Failure, CPLE_OpenFailed,
"%s appears to be an algorithm ERS file, which is not currently supported.",
poOpenInfo->pszFilename );
return NULL;
}
/* -------------------------------------------------------------------- */
/* We assume the user selects the .ers file. */
/* -------------------------------------------------------------------- */
if( poOpenInfo->nHeaderBytes < 15
|| !EQUALN((const char *) poOpenInfo->pabyHeader,"DatasetHeader ",14) )
return NULL;
/* -------------------------------------------------------------------- */
/* Open the .ers file, and read the first line. */
/* -------------------------------------------------------------------- */
VSILFILE *fpERS = VSIFOpenL( poOpenInfo->pszFilename, "rb" );
if( fpERS == NULL )
return NULL;
CPLReadLineL( fpERS );
/* -------------------------------------------------------------------- */
/* Now ingest the rest of the file as a tree of header nodes. */
/* -------------------------------------------------------------------- */
ERSHdrNode *poHeader = new ERSHdrNode();
if( !poHeader->ParseChildren( fpERS ) )
{
delete poHeader;
VSIFCloseL( fpERS );
return NULL;
}
VSIFCloseL( fpERS );
/* -------------------------------------------------------------------- */
/* Do we have the minimum required information from this header? */
/* -------------------------------------------------------------------- */
if( poHeader->Find( "RasterInfo.NrOfLines" ) == NULL
|| poHeader->Find( "RasterInfo.NrOfCellsPerLine" ) == NULL
|| poHeader->Find( "RasterInfo.NrOfBands" ) == NULL )
{
if( poHeader->FindNode( "Algorithm" ) != NULL )
{
CPLError( CE_Failure, CPLE_OpenFailed,
"%s appears to be an algorithm ERS file, which is not currently supported.",
poOpenInfo->pszFilename );
}
delete poHeader;
return NULL;
}
/* -------------------------------------------------------------------- */
/* Create a corresponding GDALDataset. */
/* -------------------------------------------------------------------- */
ERSDataset *poDS;
poDS = new ERSDataset();
poDS->poHeader = poHeader;
poDS->eAccess = poOpenInfo->eAccess;
/* -------------------------------------------------------------------- */
/* Capture some information from the file that is of interest. */
/* -------------------------------------------------------------------- */
int nBands = atoi(poHeader->Find( "RasterInfo.NrOfBands" ));
poDS->nRasterXSize = atoi(poHeader->Find( "RasterInfo.NrOfCellsPerLine" ));
poDS->nRasterYSize = atoi(poHeader->Find( "RasterInfo.NrOfLines" ));
if (!GDALCheckDatasetDimensions(poDS->nRasterXSize, poDS->nRasterYSize) ||
!GDALCheckBandCount(nBands, FALSE))
{
delete poDS;
return NULL;
}
/* -------------------------------------------------------------------- */
/* Get the HeaderOffset if it exists in the header */
/* -------------------------------------------------------------------- */
GIntBig nHeaderOffset = 0;
if( poHeader->Find( "HeaderOffset" ) != NULL )
{
nHeaderOffset = atoi(poHeader->Find( "HeaderOffset" ));
}
/* -------------------------------------------------------------------- */
/* Establish the data type. */
/* -------------------------------------------------------------------- */
GDALDataType eType;
CPLString osCellType = poHeader->Find( "RasterInfo.CellType",
"Unsigned8BitInteger" );
if( EQUAL(osCellType,"Unsigned8BitInteger") )
eType = GDT_Byte;
else if( EQUAL(osCellType,"Signed8BitInteger") )
eType = GDT_Byte;
else if( EQUAL(osCellType,"Unsigned16BitInteger") )
eType = GDT_UInt16;
else if( EQUAL(osCellType,"Signed16BitInteger") )
eType = GDT_Int16;
else if( EQUAL(osCellType,"Unsigned32BitInteger") )
eType = GDT_UInt32;
else if( EQUAL(osCellType,"Signed32BitInteger") )
eType = GDT_Int32;
else if( EQUAL(osCellType,"IEEE4ByteReal") )
eType = GDT_Float32;
else if( EQUAL(osCellType,"IEEE8ByteReal") )
eType = GDT_Float64;
else
{
CPLDebug( "ERS", "Unknown CellType '%s'", osCellType.c_str() );
eType = GDT_Byte;
}
/* -------------------------------------------------------------------- */
/* Pick up the word order. */
/* -------------------------------------------------------------------- */
int bNative;
#ifdef CPL_LSB
bNative = EQUAL(poHeader->Find( "ByteOrder", "LSBFirst" ),
"LSBFirst");
#else
bNative = EQUAL(poHeader->Find( "ByteOrder", "MSBFirst" ),
"MSBFirst");
#endif
/* -------------------------------------------------------------------- */
/* Figure out the name of the target file. */
/* -------------------------------------------------------------------- */
CPLString osPath = CPLGetPath( poOpenInfo->pszFilename );
CPLString osDataFile = poHeader->Find( "DataFile", "" );
CPLString osDataFilePath;
if( osDataFile.length() == 0 ) // just strip off extension.
{
osDataFile = CPLGetFilename( poOpenInfo->pszFilename );
osDataFile = osDataFile.substr( 0, osDataFile.find_last_of('.') );
}
osDataFilePath = CPLFormFilename( osPath, osDataFile, NULL );
/* -------------------------------------------------------------------- */
/* DataSetType = Translated files are links to things like ecw */
/* files. */
/* -------------------------------------------------------------------- */
if( EQUAL(poHeader->Find("DataSetType",""),"Translated") )
{
poDS->poDepFile = (GDALDataset *)
GDALOpenShared( osDataFilePath, poOpenInfo->eAccess );
if( poDS->poDepFile != NULL
&& poDS->poDepFile->GetRasterCount() >= nBands )
{
int iBand;
for( iBand = 0; iBand < nBands; iBand++ )
{
// Assume pixel interleaved.
poDS->SetBand( iBand+1,
poDS->poDepFile->GetRasterBand( iBand+1 ) );
}
}
}
/* ==================================================================== */
/* While ERStorage indicates a raw file. */
/* ==================================================================== */
else if( EQUAL(poHeader->Find("DataSetType",""),"ERStorage") )
{
// Open data file.
if( poOpenInfo->eAccess == GA_Update )
poDS->fpImage = VSIFOpenL( osDataFilePath, "r+" );
else
poDS->fpImage = VSIFOpenL( osDataFilePath, "r" );
poDS->osRawFilename = osDataFilePath;
if( poDS->fpImage != NULL )
{
int iWordSize = GDALGetDataTypeSize(eType) / 8;
int iBand;
for( iBand = 0; iBand < nBands; iBand++ )
{
// Assume pixel interleaved.
poDS->SetBand(
iBand+1,
new RawRasterBand( poDS, iBand+1, poDS->fpImage,
nHeaderOffset
+ iWordSize * iBand * poDS->nRasterXSize,
iWordSize,
iWordSize * nBands * poDS->nRasterXSize,
eType, bNative, TRUE ));
if( EQUAL(osCellType,"Signed8BitInteger") )
poDS->GetRasterBand(iBand+1)->
SetMetadataItem( "PIXELTYPE", "SIGNEDBYTE",
"IMAGE_STRUCTURE" );
}
}
}
/* -------------------------------------------------------------------- */
/* Otherwise we have an error! */
/* -------------------------------------------------------------------- */
if( poDS->nBands == 0 )
{
delete poDS;
return NULL;
}
/* -------------------------------------------------------------------- */
/* Look for band descriptions. */
/* -------------------------------------------------------------------- */
int iChild, iBand = 0;
ERSHdrNode *poRI = poHeader->FindNode( "RasterInfo" );
for( iChild = 0;
poRI != NULL && iChild < poRI->nItemCount && iBand < poDS->nBands;
iChild++ )
{
if( poRI->papoItemChild[iChild] != NULL
&& EQUAL(poRI->papszItemName[iChild],"BandId") )
{
const char *pszValue =
poRI->papoItemChild[iChild]->Find( "Value", NULL );
iBand++;
if( pszValue )
{
CPLPushErrorHandler( CPLQuietErrorHandler );
poDS->GetRasterBand( iBand )->SetDescription( pszValue );
CPLPopErrorHandler();
}
pszValue = poRI->papoItemChild[iChild]->Find( "Units", NULL );
if ( pszValue )
{
CPLPushErrorHandler( CPLQuietErrorHandler );
poDS->GetRasterBand( iBand )->SetUnitType( pszValue );
CPLPopErrorHandler();
}
}
}
/* -------------------------------------------------------------------- */
/* Look for projection. */
/* -------------------------------------------------------------------- */
OGRSpatialReference oSRS;
CPLString osProjection = poHeader->Find( "CoordinateSpace.Projection",
"RAW" );
CPLString osDatum = poHeader->Find( "CoordinateSpace.Datum", "WGS84" );
CPLString osUnits = poHeader->Find( "CoordinateSpace.Units", "METERS" );
oSRS.importFromERM( osProjection, osDatum, osUnits );
CPLFree( poDS->pszProjection );
oSRS.exportToWkt( &(poDS->pszProjection) );
/* -------------------------------------------------------------------- */
/* Look for the geotransform. */
/* -------------------------------------------------------------------- */
if( poHeader->Find( "RasterInfo.RegistrationCoord.Eastings", NULL )
&& poHeader->Find( "RasterInfo.CellInfo.Xdimension", NULL ) )
{
poDS->bGotTransform = TRUE;
poDS->adfGeoTransform[0] = CPLAtof(
poHeader->Find( "RasterInfo.RegistrationCoord.Eastings", "" ));
poDS->adfGeoTransform[1] = CPLAtof(
poHeader->Find( "RasterInfo.CellInfo.Xdimension", "" ));
poDS->adfGeoTransform[2] = 0.0;
poDS->adfGeoTransform[3] = CPLAtof(
poHeader->Find( "RasterInfo.RegistrationCoord.Northings", "" ));
poDS->adfGeoTransform[4] = 0.0;
poDS->adfGeoTransform[5] = -CPLAtof(
poHeader->Find( "RasterInfo.CellInfo.Ydimension", "" ));
}
else if( poHeader->Find( "RasterInfo.RegistrationCoord.Latitude", NULL )
&& poHeader->Find( "RasterInfo.CellInfo.Xdimension", NULL ) )
{
poDS->bGotTransform = TRUE;
poDS->adfGeoTransform[0] = ERSDMS2Dec(
poHeader->Find( "RasterInfo.RegistrationCoord.Longitude", "" ));
poDS->adfGeoTransform[1] = CPLAtof(
poHeader->Find( "RasterInfo.CellInfo.Xdimension", "" ));
poDS->adfGeoTransform[2] = 0.0;
poDS->adfGeoTransform[3] = ERSDMS2Dec(
poHeader->Find( "RasterInfo.RegistrationCoord.Latitude", "" ));
poDS->adfGeoTransform[4] = 0.0;
poDS->adfGeoTransform[5] = -CPLAtof(
poHeader->Find( "RasterInfo.CellInfo.Ydimension", "" ));
}
/* -------------------------------------------------------------------- */
/* Adjust if we have a registration cell. */
/* -------------------------------------------------------------------- */
int iCellX = atoi(poHeader->Find("RasterInfo.RegistrationCellX", "1"));
int iCellY = atoi(poHeader->Find("RasterInfo.RegistrationCellY", "1"));
if( poDS->bGotTransform )
{
poDS->adfGeoTransform[0] -=
(iCellX-1) * poDS->adfGeoTransform[1]
+ (iCellY-1) * poDS->adfGeoTransform[2];
poDS->adfGeoTransform[3] -=
(iCellX-1) * poDS->adfGeoTransform[4]
+ (iCellY-1) * poDS->adfGeoTransform[5];
}
/* -------------------------------------------------------------------- */
/* Check for null values. */
/* -------------------------------------------------------------------- */
if( poHeader->Find( "RasterInfo.NullCellValue", NULL ) )
{
CPLPushErrorHandler( CPLQuietErrorHandler );
for( iBand = 1; iBand <= poDS->nBands; iBand++ )
poDS->GetRasterBand(iBand)->SetNoDataValue(
CPLAtofM(poHeader->Find( "RasterInfo.NullCellValue" )) );
CPLPopErrorHandler();
}
/* -------------------------------------------------------------------- */
/* Do we have an "All" region? */
/* -------------------------------------------------------------------- */
ERSHdrNode *poAll = NULL;
for( iChild = 0;
poRI != NULL && iChild < poRI->nItemCount;
iChild++ )
{
if( poRI->papoItemChild[iChild] != NULL
&& EQUAL(poRI->papszItemName[iChild],"RegionInfo") )
{
if( EQUAL(poRI->papoItemChild[iChild]->Find("RegionName",""),
"All") )
poAll = poRI->papoItemChild[iChild];
}
}
/* -------------------------------------------------------------------- */
/* Do we have statistics? */
/* -------------------------------------------------------------------- */
if( poAll && poAll->FindNode( "Stats" ) )
{
CPLPushErrorHandler( CPLQuietErrorHandler );
for( iBand = 1; iBand <= poDS->nBands; iBand++ )
{
const char *pszValue =
poAll->FindElem( "Stats.MinimumValue", iBand-1 );
if( pszValue )
poDS->GetRasterBand(iBand)->SetMetadataItem(
"STATISTICS_MINIMUM", pszValue );
pszValue = poAll->FindElem( "Stats.MaximumValue", iBand-1 );
if( pszValue )
poDS->GetRasterBand(iBand)->SetMetadataItem(
"STATISTICS_MAXIMUM", pszValue );
pszValue = poAll->FindElem( "Stats.MeanValue", iBand-1 );
if( pszValue )
poDS->GetRasterBand(iBand)->SetMetadataItem(
"STATISTICS_MEAN", pszValue );
pszValue = poAll->FindElem( "Stats.MedianValue", iBand-1 );
if( pszValue )
poDS->GetRasterBand(iBand)->SetMetadataItem(
"STATISTICS_MEDIAN", pszValue );
}
CPLPopErrorHandler();
}
/* -------------------------------------------------------------------- */
/* Do we have GCPs. */
/* -------------------------------------------------------------------- */
if( poHeader->FindNode( "RasterInfo.WarpControl" ) )
poDS->ReadGCPs();
/* -------------------------------------------------------------------- */
/* Initialize any PAM information. */
/* -------------------------------------------------------------------- */
poDS->SetDescription( poOpenInfo->pszFilename );
poDS->TryLoadXML();
// if no SR in xml, try aux
const char* pszPrj = poDS->GDALPamDataset::GetProjectionRef();
if( !pszPrj || strlen(pszPrj) == 0 )
{
// try aux
GDALDataset* poAuxDS = GDALFindAssociatedAuxFile( poOpenInfo->pszFilename, GA_ReadOnly, poDS );
if( poAuxDS )
{
pszPrj = poAuxDS->GetProjectionRef();
if( pszPrj && strlen(pszPrj) > 0 )
{
CPLFree( poDS->pszProjection );
poDS->pszProjection = CPLStrdup(pszPrj);
}
GDALClose( poAuxDS );
}
}
/* -------------------------------------------------------------------- */
/* Check for overviews. */
/* -------------------------------------------------------------------- */
poDS->oOvManager.Initialize( poDS, poOpenInfo->pszFilename );
return( poDS );
}
GDALDataset* OGRPLScenesDataset::OpenRasterScene(GDALOpenInfo* poOpenInfo,
CPLString osScene,
char** papszOptions)
{
if( !(poOpenInfo->nOpenFlags & GDAL_OF_RASTER) )
{
return NULL;
}
for( char** papszIter = papszOptions; papszIter && *papszIter; papszIter ++ )
{
char* pszKey;
const char* pszValue = CPLParseNameValue(*papszIter, &pszKey);
if( pszValue != NULL )
{
if( !EQUAL(pszKey, "api_key") &&
!EQUAL(pszKey, "scene") &&
!EQUAL(pszKey, "product_type") )
{
CPLError(CE_Failure, CPLE_NotSupported, "Unsupported option %s", pszKey);
CPLFree(pszKey);
return NULL;
}
CPLFree(pszKey);
}
}
const char* pszProductType = CSLFetchNameValueDef(papszOptions, "product_type",
CSLFetchNameValueDef(poOpenInfo->papszOpenOptions, "PRODUCT_TYPE", "visual"));
CPLString osRasterURL;
osRasterURL = osBaseURL;
osRasterURL += "ortho/";
osRasterURL += osScene;
json_object* poObj = RunRequest( osRasterURL );
if( poObj == NULL )
return NULL;
json_object* poProperties = json_object_object_get(poObj, "properties");
if( poProperties == NULL || json_object_get_type(poProperties) != json_type_object )
{
CPLError(CE_Failure, CPLE_AppDefined, "Cannot find properties object");
json_object_put(poObj);
return NULL;
}
const char* pszLink = NULL;
if( EQUAL(pszProductType, "thumb") )
{
json_object* poLinks = json_object_object_get(poProperties, "links");
if( poLinks != NULL && json_object_get_type(poLinks) == json_type_object )
{
json_object* poThumbnail = json_object_object_get(poLinks, "thumbnail");
if( poThumbnail && json_object_get_type(poThumbnail) == json_type_string )
pszLink = json_object_get_string(poThumbnail);
}
}
else
{
json_object* poData = json_object_object_get(poProperties, "data");
if( poData != NULL && json_object_get_type(poData) == json_type_object )
{
json_object* poProducts = json_object_object_get(poData, "products");
if( poProducts != NULL && json_object_get_type(poProducts) == json_type_object )
{
json_object* poProduct = json_object_object_get(poProducts, pszProductType);
if( poProduct != NULL && json_object_get_type(poProduct) == json_type_object )
{
json_object* poFull = json_object_object_get(poProduct, "full");
if( poFull && json_object_get_type(poFull) == json_type_string )
pszLink = json_object_get_string(poFull);
}
}
}
}
osRasterURL = pszLink ? pszLink : "";
json_object_put(poObj);
if( osRasterURL.size() == 0 )
{
CPLError(CE_Failure, CPLE_AppDefined, "Cannot find link to scene %s",
osScene.c_str());
return NULL;
}
if( strncmp(osRasterURL, "http://", strlen("http://")) == 0 )
{
osRasterURL = "http://" + osAPIKey + ":@" + osRasterURL.substr(strlen("http://"));
}
else if( strncmp(osRasterURL, "https://", strlen("https://")) == 0 )
{
osRasterURL = "https://" + osAPIKey + ":@" + osRasterURL.substr(strlen("https://"));
}
CPLString osOldHead(CPLGetConfigOption("CPL_VSIL_CURL_USE_HEAD", ""));
CPLString osOldExt(CPLGetConfigOption("CPL_VSIL_CURL_ALLOWED_EXTENSIONS", ""));
int bUseVSICURL = CSLFetchBoolean(poOpenInfo->papszOpenOptions, "RANDOM_ACCESS", TRUE);
if( bUseVSICURL && !(strncmp(osBaseURL, "/vsimem/", strlen("/vsimem/")) == 0) )
{
CPLSetThreadLocalConfigOption("CPL_VSIL_CURL_USE_HEAD", "NO");
CPLSetThreadLocalConfigOption("CPL_VSIL_CURL_ALLOWED_EXTENSIONS", "{noext}");
VSIStatBufL sStat;
if( VSIStatL(("/vsicurl/" + osRasterURL).c_str(), &sStat) == 0 &&
sStat.st_size > 0 )
{
osRasterURL = "/vsicurl/" + osRasterURL;
}
else
{
CPLDebug("PLSCENES", "Cannot use random access for that file");
}
}
GDALDataset* poOutDS = (GDALDataset*) GDALOpen(osRasterURL, GA_ReadOnly);
if( poOutDS )
{
poOutDS->SetDescription(poOpenInfo->pszFilename);
poOutDS->GetFileList(); /* so as to probe all auxiliary files before reseting the allowed extensions */
if( !EQUAL(pszProductType, "thumb") )
{
OGRPLScenesLayer* poLayer = new OGRPLScenesLayer(this, "ortho",
(osBaseURL + "ortho/").c_str());
papoLayers = (OGRPLScenesLayer**) CPLRealloc(papoLayers,
sizeof(OGRPLScenesLayer*) * (nLayers + 1));
papoLayers[nLayers ++] = poLayer;
/* Attach scene matadata */
poLayer->SetAttributeFilter(CPLSPrintf("id = '%s'", osScene.c_str()));
OGRFeature* poFeat = poLayer->GetNextFeature();
if( poFeat )
{
for(int i=0;i<poFeat->GetFieldCount();i++)
{
if( poFeat->IsFieldSet(i) )
{
const char* pszKey = poFeat->GetFieldDefnRef(i)->GetNameRef();
const char* pszVal = poFeat->GetFieldAsString(i);
if( strstr(pszKey, "file_size") == NULL &&
strstr(pszVal, "https://") == NULL )
{
poOutDS->SetMetadataItem(pszKey, pszVal);
}
}
}
}
delete poFeat;
}
}
if( bUseVSICURL )
{
CPLSetThreadLocalConfigOption("CPL_VSIL_CURL_USE_HEAD",
osOldHead.size() ? osOldHead.c_str(): NULL);
CPLSetThreadLocalConfigOption("CPL_VSIL_CURL_ALLOWED_EXTENSIONS",
osOldExt.size() ? osOldExt.c_str(): NULL);
}
return poOutDS;
}
OGRErr OGRDXFWriterLayer::WriteTEXT( OGRFeature *poFeature )
{
WriteValue( 0, "MTEXT" );
WriteCore( poFeature );
WriteValue( 100, "AcDbEntity" );
WriteValue( 100, "AcDbMText" );
/* -------------------------------------------------------------------- */
/* Do we have styling information? */
/* -------------------------------------------------------------------- */
OGRStyleTool *poTool = nullptr;
OGRStyleMgr oSM;
if( poFeature->GetStyleString() != nullptr )
{
oSM.InitFromFeature( poFeature );
if( oSM.GetPartCount() > 0 )
poTool = oSM.GetPart(0);
}
/* ==================================================================== */
/* Process the LABEL tool. */
/* ==================================================================== */
double dfDx = 0.0;
double dfDy = 0.0;
if( poTool && poTool->GetType() == OGRSTCLabel )
{
OGRStyleLabel *poLabel = (OGRStyleLabel *) poTool;
GBool bDefault;
/* -------------------------------------------------------------------- */
/* Color */
/* -------------------------------------------------------------------- */
if( poLabel->ForeColor(bDefault) != nullptr && !bDefault )
WriteValue( 62, ColorStringToDXFColor(
poLabel->ForeColor(bDefault) ) );
/* -------------------------------------------------------------------- */
/* Angle */
/* -------------------------------------------------------------------- */
const double dfAngle = poLabel->Angle(bDefault);
if( !bDefault )
WriteValue( 50, dfAngle );
/* -------------------------------------------------------------------- */
/* Height - We need to fetch this in georeferenced units - I'm */
/* doubt the default translation mechanism will be much good. */
/* -------------------------------------------------------------------- */
poTool->SetUnit( OGRSTUGround );
const double dfHeight = poLabel->Size(bDefault);
if( !bDefault )
WriteValue( 40, dfHeight );
/* -------------------------------------------------------------------- */
/* Anchor / Attachment Point */
/* -------------------------------------------------------------------- */
const int nAnchor = poLabel->Anchor(bDefault);
if( !bDefault )
{
const static int anAnchorMap[] =
{ -1, 7, 8, 9, 4, 5, 6, 1, 2, 3, 7, 8, 9 };
if( nAnchor > 0 && nAnchor < 13 )
WriteValue( 71, anAnchorMap[nAnchor] );
}
/* -------------------------------------------------------------------- */
/* Offset */
/* -------------------------------------------------------------------- */
dfDx = poLabel->SpacingX(bDefault);
dfDy = poLabel->SpacingY(bDefault);
/* -------------------------------------------------------------------- */
/* Escape the text, and convert to ISO8859. */
/* -------------------------------------------------------------------- */
const char *pszText = poLabel->TextString( bDefault );
if( pszText != nullptr && !bDefault )
{
CPLString osEscaped = TextEscape( pszText );
while( osEscaped.size() > 250 )
{
WriteValue( 3, osEscaped.substr( 0, 250 ).c_str() );
osEscaped.erase( 0, 250 );
}
WriteValue( 1, osEscaped );
}
/* -------------------------------------------------------------------- */
/* Store the text style in the map. */
/* -------------------------------------------------------------------- */
std::map<CPLString, CPLString> oTextStyleDef =
PrepareTextStyleDefinition( poLabel );
CPLString osStyleName;
for( const auto& oPair: oNewTextStyles )
{
if( oPair.second == oTextStyleDef )
{
osStyleName = oPair.first;
break;
}
}
if( osStyleName == "" )
{
do
{
osStyleName.Printf( "AutoTextStyle-%d", nNextAutoID++ );
}
while( poDS->oHeaderDS.TextStyleExists( osStyleName ) );
oNewTextStyles[osStyleName] = oTextStyleDef;
}
WriteValue( 7, osStyleName );
}
delete poTool;
/* -------------------------------------------------------------------- */
/* Write the location. */
/* -------------------------------------------------------------------- */
OGRPoint *poPoint = poFeature->GetGeometryRef()->toPoint();
WriteValue( 10, poPoint->getX() + dfDx );
if( !WriteValue( 20, poPoint->getY() + dfDy ) )
return OGRERR_FAILURE;
if( poPoint->getGeometryType() == wkbPoint25D )
{
if( !WriteValue( 30, poPoint->getZ() ) )
return OGRERR_FAILURE;
}
return OGRERR_NONE;
}
int ERSHdrNode::ParseChildren( VSILFILE * fp )
{
while( TRUE )
{
size_t iOff;
CPLString osLine;
/* -------------------------------------------------------------------- */
/* Read the next line (or multi-line for bracketed value). */
/* -------------------------------------------------------------------- */
if( !ReadLine( fp, osLine ) )
return FALSE;
/* -------------------------------------------------------------------- */
/* Got a Name=Value. */
/* -------------------------------------------------------------------- */
if( (iOff = osLine.find_first_of( '=' )) != std::string::npos )
{
CPLString osName = osLine.substr(0,iOff-1);
osName.Trim();
CPLString osValue = osLine.c_str() + iOff + 1;
osValue.Trim();
MakeSpace();
papszItemName[nItemCount] = CPLStrdup(osName);
papszItemValue[nItemCount] = CPLStrdup(osValue);
papoItemChild[nItemCount] = NULL;
nItemCount++;
}
/* -------------------------------------------------------------------- */
/* Got a Begin for an object. */
/* -------------------------------------------------------------------- */
else if( (iOff = osLine.ifind( " Begin" )) != std::string::npos )
{
CPLString osName = osLine.substr(0,iOff);
osName.Trim();
MakeSpace();
papszItemName[nItemCount] = CPLStrdup(osName);
papszItemValue[nItemCount] = NULL;
papoItemChild[nItemCount] = new ERSHdrNode();
nItemCount++;
if( !papoItemChild[nItemCount-1]->ParseChildren( fp ) )
return FALSE;
}
/* -------------------------------------------------------------------- */
/* Got an End for our object. Well, at least we *assume* it */
/* must be for our object. */
/* -------------------------------------------------------------------- */
else if( osLine.ifind( " End" ) != std::string::npos )
{
return TRUE;
}
/* -------------------------------------------------------------------- */
/* Error? */
/* -------------------------------------------------------------------- */
else if( osLine.Trim().length() > 0 )
{
CPLError( CE_Failure, CPLE_AppDefined,
"Unexpected line parsing .ecw:\n%s",
osLine.c_str() );
return FALSE;
}
}
}
VSIVirtualHandle *
VSIMemFilesystemHandler::Open( const char *pszFilename,
const char *pszAccess,
bool bSetError )
{
CPLMutexHolder oHolder( &hMutex );
CPLString osFilename = pszFilename;
NormalizePath( osFilename );
if( osFilename.empty() )
return nullptr;
vsi_l_offset nMaxLength = GUINTBIG_MAX;
const size_t iPos = osFilename.find("||maxlength=");
if( iPos != std::string::npos )
{
nMaxLength = static_cast<vsi_l_offset>(CPLAtoGIntBig(
osFilename.substr(iPos + strlen("||maxlength=")).c_str()));
}
/* -------------------------------------------------------------------- */
/* Get the filename we are opening, create if needed. */
/* -------------------------------------------------------------------- */
VSIMemFile *poFile = nullptr;
if( oFileList.find(osFilename) != oFileList.end() )
poFile = oFileList[osFilename];
// If no file and opening in read, error out.
if( strstr(pszAccess, "w") == nullptr
&& strstr(pszAccess, "a") == nullptr
&& poFile == nullptr )
{
if( bSetError )
{
VSIError(VSIE_FileError, "No such file or directory");
}
errno = ENOENT;
return nullptr;
}
// Create.
if( poFile == nullptr )
{
poFile = new VSIMemFile;
poFile->osFilename = osFilename;
oFileList[poFile->osFilename] = poFile;
CPLAtomicInc(&(poFile->nRefCount)); // For file list.
poFile->nMaxLength = nMaxLength;
}
// Overwrite
else if( strstr(pszAccess, "w") )
{
poFile->SetLength(0);
poFile->nMaxLength = nMaxLength;
}
if( poFile->bIsDirectory )
{
errno = EISDIR;
return nullptr;
}
/* -------------------------------------------------------------------- */
/* Setup the file handle on this file. */
/* -------------------------------------------------------------------- */
VSIMemHandle *poHandle = new VSIMemHandle;
poHandle->poFile = poFile;
poHandle->m_nOffset = 0;
poHandle->bEOF = false;
poHandle->bUpdate =
strstr(pszAccess, "w") ||
strstr(pszAccess, "+") ||
strstr(pszAccess, "a");
CPLAtomicInc(&(poFile->nRefCount));
if( strstr(pszAccess, "a") )
poHandle->m_nOffset = poFile->nLength;
return poHandle;
}
static CPLString GetProj4Filename(const char* pszFilename)
{
CPLString osFilename;
/* or fixed path: /name, ./name or ../name */
if ( !CPLIsFilenameRelative(pszFilename) || *pszFilename == '.' )
{
return pszFilename;
}
#if defined(PROJ_STATIC) && PROJ_VERSION >= 5
PJ_GRID_INFO info = proj_grid_info(pszFilename);
if( info.filename[0] )
{
osFilename = info.filename;
}
#elif defined(PROJ_STATIC) && PJ_VERSION > 493
osFilename.resize(2048);
projCtx ctx = pj_ctx_alloc();
if( pj_find_file(ctx, pszFilename, &osFilename[0], osFilename.size()) )
{
osFilename.resize( strlen(osFilename) );
}
else
{
osFilename.clear();
}
pj_ctx_free(ctx);
#else
// Transpose some of the proj.4 pj_open_lib() logic...
/* check if ~/name */
char* pszSysname;
if (*pszFilename == '~' &&
(pszFilename[1] == '/' || pszFilename[1] == '\\') )
{
if ((pszSysname = getenv("HOME")) != nullptr)
{
osFilename = CPLFormFilename(pszSysname, pszFilename + 1, nullptr);
}
return osFilename;
}
/* or is environment PROJ_LIB defined */
else if ((pszSysname = getenv("PROJ_LIB")) != nullptr)
{
osFilename = CPLFormFilename(pszSysname, pszFilename, nullptr);
VSIStatBufL sStat;
if( VSIStatL(osFilename, &sStat) == 0 )
return osFilename;
osFilename.clear();
}
#if defined(PROJ_STATIC) && PJ_VERSION >= 490
// Super messy. proj.4 up to 4.9.3 had no public API to return the full
// path to a resource file, so we rely on the fact that it emits a log
// message with it...
// Basically this is needed in the case where the file is in the
// resource installation directory of proj.4, which we have no way to
// know otherwise.
CPLString osMsg;
projCtx ctx = pj_ctx_alloc();
pj_ctx_set_app_data(ctx, &osMsg);
pj_ctx_set_debug(ctx, PJ_LOG_DEBUG_MAJOR);
pj_ctx_set_logger(ctx, my_proj4_logger);
PAFile f = pj_open_lib(ctx, pszFilename, "rb");
if( f )
{
pj_ctx_fclose(ctx, f);
size_t nPos = osMsg.find("fopen(");
if( nPos != std::string::npos )
{
osFilename = osMsg.substr(nPos + strlen("fopen("));
nPos = osFilename.find(")");
if( nPos != std::string::npos )
osFilename = osFilename.substr(0, nPos);
}
}
pj_ctx_free(ctx);
#endif
#endif
return osFilename;
}
int OGRSelafinDataSource::OpenTable(const char * pszFilename) {
//CPLDebug("Selafin","OpenTable(%s,%i)",pszFilename,bUpdate);
// Open the file
VSILFILE * fp;
if( bUpdate ) {
// We have to implement this locking feature for write access because the same file may hold several layers, and some programs (like QGIS) open each layer in a single datasource,
// so the same file might be opened several times for write access
if (TakeLock(pszFilename)==0) {
CPLError(CE_Failure,CPLE_OpenFailed,"Failed to open %s for write access, lock file found %s.",pszFilename,pszLockName);
return FALSE;
}
fp = VSIFOpenL( pszFilename, "rb+" );
} else fp = VSIFOpenL( pszFilename, "rb" );
if( fp == NULL ) {
CPLError( CE_Warning, CPLE_OpenFailed, "Failed to open %s, %s.", pszFilename, VSIStrerror( errno ) );
return FALSE;
}
if( !bUpdate && strstr(pszFilename, "/vsigzip/") == NULL && strstr(pszFilename, "/vsizip/") == NULL ) fp = (VSILFILE*) VSICreateBufferedReaderHandle((VSIVirtualHandle*)fp);
// Quickly check if the file is in Selafin format, before actually starting to read to make it faster
char szBuf[9];
VSIFReadL(szBuf,1,4,fp);
if (szBuf[0]!=0 || szBuf[1]!=0 || szBuf[2]!=0 || szBuf[3]!=0x50) {
VSIFCloseL(fp);
return FALSE;
}
VSIFSeekL(fp,84,SEEK_SET);
VSIFReadL(szBuf,1,8,fp);
if (szBuf[0]!=0 || szBuf[1]!=0 || szBuf[2]!=0 || szBuf[3]!=0x50 || szBuf[4]!=0 || szBuf[5]!=0 || szBuf[6]!=0 || szBuf[7]!=8) {
VSIFCloseL(fp);
return FALSE;
}
/* VSIFSeekL(fp,76,SEEK_SET);
VSIFReadL(szBuf,1,8,fp);
if (STRNCASECMP(szBuf,"Seraphin",8)!=0 && STRNCASECMP(szBuf,"Serafin",7)!=0) {
VSIFCloseL(fp);
return FALSE;
} */
// Get layer base name
CPLString osBaseLayerName = CPLGetBasename(pszFilename);
CPLString osExt = CPLGetExtension(pszFilename);
if( STARTS_WITH(pszFilename, "/vsigzip/") && EQUAL(osExt, "gz") ) {
size_t nPos=std::string::npos;
if (strlen(pszFilename)>3) nPos=osExt.find_last_of('.',strlen(pszFilename)-4);
if (nPos!=std::string::npos) {
osExt=osExt.substr(nPos+1,strlen(pszFilename)-4-nPos);
osBaseLayerName=osBaseLayerName.substr(0,nPos);
} else {
osExt="";
}
}
// Read header of file to get common information for all layers
poHeader=Selafin::read_header(fp,pszFilename);
if (poHeader==NULL) {
VSIFCloseL(fp);
CPLError( CE_Failure, CPLE_OpenFailed, "Failed to open %s, wrong format.\n", pszFilename);
return FALSE;
}
if (poHeader->nEpsg!=0) {
poSpatialRef=new OGRSpatialReference();
if (poSpatialRef->importFromEPSG(poHeader->nEpsg)!=OGRERR_NONE) {
CPLError( CE_Warning, CPLE_AppDefined, "EPSG %d not found. Could not set datasource SRS.\n", poHeader->nEpsg);
delete poSpatialRef;
poSpatialRef=NULL;
}
}
// Create two layers for each selected time step: one for points, the other for elements
int nNewLayers;
poRange.setMaxValue(poHeader->nSteps);
nNewLayers=static_cast<int>(poRange.getSize());
if (EQUAL(pszFilename, "/vsistdin/")) osBaseLayerName = "layer";
CPLString osLayerName;
papoLayers = (OGRSelafinLayer **) CPLRealloc(papoLayers, sizeof(void*) * (nLayers+nNewLayers));
for (size_t j=0;j<2;++j) {
SelafinTypeDef eType=(j==0)?POINTS:ELEMENTS;
for (int i=0;i<poHeader->nSteps;++i) {
if (poRange.contains(eType,i)) {
char szTemp[30];
double dfTime;
if (VSIFSeekL(fp,poHeader->getPosition(i)+4,SEEK_SET)!=0 || Selafin::read_float(fp,dfTime)==0) {
VSIFCloseL(fp);
CPLError( CE_Failure, CPLE_OpenFailed, "Failed to open %s, wrong format.\n", pszFilename);
return FALSE;
}
if (poHeader->panStartDate==NULL) snprintf(szTemp,29,"%d",i); else {
struct tm sDate;
memset(&sDate, 0, sizeof(sDate));
sDate.tm_year=poHeader->panStartDate[0]-1900;
sDate.tm_mon=poHeader->panStartDate[1]-1;
sDate.tm_mday=poHeader->panStartDate[2];
sDate.tm_hour=poHeader->panStartDate[3];
sDate.tm_min=poHeader->panStartDate[4];
sDate.tm_sec=poHeader->panStartDate[5]+(int)dfTime;
mktime(&sDate);
strftime(szTemp,29,"%Y_%m_%d_%H_%M_%S",&sDate);
}
if (eType==POINTS) osLayerName=osBaseLayerName+"_p"+szTemp; else osLayerName=osBaseLayerName+"_e"+szTemp;
papoLayers[nLayers++] = new OGRSelafinLayer( osLayerName, bUpdate, poSpatialRef, poHeader,i,eType);
//poHeader->nRefCount++;
}
}
}
// Free allocated variables and exit
return TRUE;
}
int OGRCSVDataSource::OpenTable( const char * pszFilename,
const char* pszNfdcRunwaysGeomField,
const char* pszGeonamesGeomFieldPrefix)
{
/* -------------------------------------------------------------------- */
/* Open the file. */
/* -------------------------------------------------------------------- */
VSILFILE * fp;
if( bUpdate )
fp = VSIFOpenL( pszFilename, "rb+" );
else
fp = VSIFOpenL( pszFilename, "rb" );
if( fp == NULL )
{
CPLError( CE_Warning, CPLE_OpenFailed,
"Failed to open %s, %s.",
pszFilename, VSIStrerror( errno ) );
return FALSE;
}
if( !bUpdate && strstr(pszFilename, "/vsigzip/") == NULL &&
strstr(pszFilename, "/vsizip/") == NULL )
fp = (VSILFILE*) VSICreateBufferedReaderHandle((VSIVirtualHandle*)fp);
CPLString osLayerName = CPLGetBasename(pszFilename);
CPLString osExt = CPLGetExtension(pszFilename);
if( strncmp(pszFilename, "/vsigzip/", 9) == 0 && EQUAL(osExt, "gz") )
{
if( strlen(pszFilename) > 7 && EQUAL(pszFilename + strlen(pszFilename) - 7, ".csv.gz") )
{
osLayerName = osLayerName.substr(0, osLayerName.size() - 4);
osExt = "csv";
}
else if( strlen(pszFilename) > 7 && EQUAL(pszFilename + strlen(pszFilename) - 7, ".tsv.gz") )
{
osLayerName = osLayerName.substr(0, osLayerName.size() - 4);
osExt = "tsv";
}
}
/* -------------------------------------------------------------------- */
/* Read and parse a line. Did we get multiple fields? */
/* -------------------------------------------------------------------- */
const char* pszLine = CPLReadLineL( fp );
if (pszLine == NULL)
{
VSIFCloseL( fp );
return FALSE;
}
char chDelimiter = CSVDetectSeperator(pszLine);
/* Force the delimiter to be TAB for a .tsv file that has a tabulation */
/* in its first line */
if( EQUAL(osExt, "tsv") && chDelimiter != '\t' &&
strchr(pszLine, '\t') != NULL )
{
chDelimiter = '\t';
}
VSIRewindL( fp );
/* GNIS specific */
if (pszGeonamesGeomFieldPrefix != NULL &&
strchr(pszLine, '|') != NULL)
chDelimiter = '|';
char **papszFields = OGRCSVReadParseLineL( fp, chDelimiter, FALSE );
if( CSLCount(papszFields) < 2 )
{
VSIFCloseL( fp );
CSLDestroy( papszFields );
return FALSE;
}
VSIRewindL( fp );
CSLDestroy( papszFields );
/* -------------------------------------------------------------------- */
/* Create a layer. */
/* -------------------------------------------------------------------- */
nLayers++;
papoLayers = (OGRCSVLayer **) CPLRealloc(papoLayers,
sizeof(void*) * nLayers);
if (pszNfdcRunwaysGeomField != NULL)
{
osLayerName += "_";
osLayerName += pszNfdcRunwaysGeomField;
}
else if (pszGeonamesGeomFieldPrefix != NULL &&
!EQUAL(pszGeonamesGeomFieldPrefix, ""))
{
osLayerName += "_";
osLayerName += pszGeonamesGeomFieldPrefix;
}
if (EQUAL(pszFilename, "/vsistdin/"))
osLayerName = "layer";
papoLayers[nLayers-1] =
new OGRCSVLayer( osLayerName, fp, pszFilename, FALSE, bUpdate,
chDelimiter, pszNfdcRunwaysGeomField, pszGeonamesGeomFieldPrefix );
return TRUE;
}
int ERSHdrNode::ParseChildren( VSILFILE * fp, int nRecLevel )
{
if( nRecLevel == 100 ) // arbitrary limit
{
CPLError(CE_Failure, CPLE_AppDefined,
"Too many recursion level while parsing .ers header");
return false;
}
while( true )
{
/* -------------------------------------------------------------------- */
/* Read the next line (or multi-line for bracketed value). */
/* -------------------------------------------------------------------- */
CPLString osLine;
if( !ReadLine( fp, osLine ) )
return FALSE;
/* -------------------------------------------------------------------- */
/* Got a Name=Value. */
/* -------------------------------------------------------------------- */
size_t iOff;
if( (iOff = osLine.find_first_of( '=' )) != std::string::npos )
{
CPLString osName = osLine.substr(0,iOff-1);
osName.Trim();
CPLString osValue = osLine.c_str() + iOff + 1;
osValue.Trim();
MakeSpace();
papszItemName[nItemCount] = CPLStrdup(osName);
papszItemValue[nItemCount] = CPLStrdup(osValue);
papoItemChild[nItemCount] = nullptr;
nItemCount++;
}
/* -------------------------------------------------------------------- */
/* Got a Begin for an object. */
/* -------------------------------------------------------------------- */
else if( (iOff = osLine.ifind( " Begin" )) != std::string::npos )
{
CPLString osName = osLine.substr(0,iOff);
osName.Trim();
MakeSpace();
papszItemName[nItemCount] = CPLStrdup(osName);
papszItemValue[nItemCount] = nullptr;
papoItemChild[nItemCount] = new ERSHdrNode();
nItemCount++;
if( !papoItemChild[nItemCount-1]->ParseChildren( fp, nRecLevel + 1 ) )
return FALSE;
}
/* -------------------------------------------------------------------- */
/* Got an End for our object. Well, at least we *assume* it */
/* must be for our object. */
/* -------------------------------------------------------------------- */
else if( osLine.ifind( " End" ) != std::string::npos )
{
return TRUE;
}
/* -------------------------------------------------------------------- */
/* Error? */
/* -------------------------------------------------------------------- */
else if( osLine.Trim().length() > 0 )
{
CPLError( CE_Failure, CPLE_AppDefined,
"Unexpected line parsing .ecw:\n%s",
osLine.c_str() );
return FALSE;
}
}
}
int OGRCSVDataSource::OpenTable( const char * pszFilename,
char** papszOpenOptions,
const char* pszNfdcRunwaysGeomField,
const char* pszGeonamesGeomFieldPrefix)
{
/* -------------------------------------------------------------------- */
/* Open the file. */
/* -------------------------------------------------------------------- */
VSILFILE * fp;
if( bUpdate )
fp = VSIFOpenL( pszFilename, "rb+" );
else
fp = VSIFOpenL( pszFilename, "rb" );
if( fp == NULL )
{
CPLError( CE_Warning, CPLE_OpenFailed,
"Failed to open %s, %s.",
pszFilename, VSIStrerror( errno ) );
return FALSE;
}
if( !bUpdate && strstr(pszFilename, "/vsigzip/") == NULL &&
strstr(pszFilename, "/vsizip/") == NULL )
fp = (VSILFILE*) VSICreateBufferedReaderHandle((VSIVirtualHandle*)fp);
CPLString osLayerName = CPLGetBasename(pszFilename);
CPLString osExt = CPLGetExtension(pszFilename);
if( strncmp(pszFilename, "/vsigzip/", 9) == 0 && EQUAL(osExt, "gz") )
{
if( strlen(pszFilename) > 7 && EQUAL(pszFilename + strlen(pszFilename) - 7, ".csv.gz") )
{
osLayerName = osLayerName.substr(0, osLayerName.size() - 4);
osExt = "csv";
}
else if( strlen(pszFilename) > 7 && EQUAL(pszFilename + strlen(pszFilename) - 7, ".tsv.gz") )
{
osLayerName = osLayerName.substr(0, osLayerName.size() - 4);
osExt = "tsv";
}
}
/* -------------------------------------------------------------------- */
/* Read and parse a line. Did we get multiple fields? */
/* -------------------------------------------------------------------- */
const char* pszLine = CPLReadLineL( fp );
if (pszLine == NULL)
{
VSIFCloseL( fp );
return FALSE;
}
char chDelimiter = CSVDetectSeperator(pszLine);
if( chDelimiter != '\t' && strchr(pszLine, '\t') != NULL )
{
/* Force the delimiter to be TAB for a .tsv file that has a tabulation */
/* in its first line */
if( EQUAL(osExt, "tsv") )
{
chDelimiter = '\t';
}
else
{
for(int bDontHonourStrings=0; bDontHonourStrings<=1; bDontHonourStrings++)
{
// Read the first 2 lines to see if they have the same number of fields, if using tabulation
VSIRewindL( fp );
char** papszTokens = OGRCSVReadParseLineL( fp, '\t', bDontHonourStrings );
int nTokens1 = CSLCount(papszTokens);
CSLDestroy(papszTokens);
papszTokens = OGRCSVReadParseLineL( fp, '\t', bDontHonourStrings );
int nTokens2 = CSLCount(papszTokens);
CSLDestroy(papszTokens);
if( nTokens1 >= 2 && nTokens1 == nTokens2 )
{
chDelimiter = '\t';
break;
}
}
}
}
VSIRewindL( fp );
#if 0
const char *pszDelimiter = CSLFetchNameValueDef( papszOpenOptions, "SEPARATOR", "AUTO");
if( !EQUAL(pszDelimiter, "AUTO") )
{
if (EQUAL(pszDelimiter, "COMMA"))
chDelimiter = ',';
else if (EQUAL(pszDelimiter, "SEMICOLON"))
chDelimiter = ';';
else if (EQUAL(pszDelimiter, "TAB"))
chDelimiter = '\t';
else if (EQUAL(pszDelimiter, "SPACE"))
chDelimiter = ' ';
else
{
CPLError( CE_Warning, CPLE_AppDefined,
"SEPARATOR=%s not understood, use one of COMMA, SEMICOLON, SPACE or TAB.",
pszDelimiter );
}
}
#endif
/* GNIS specific */
if (pszGeonamesGeomFieldPrefix != NULL &&
strchr(pszLine, '|') != NULL)
chDelimiter = '|';
char **papszFields = OGRCSVReadParseLineL( fp, chDelimiter, FALSE );
if( CSLCount(papszFields) < 2 )
{
VSIFCloseL( fp );
CSLDestroy( papszFields );
return FALSE;
}
VSIRewindL( fp );
CSLDestroy( papszFields );
/* -------------------------------------------------------------------- */
/* Create a layer. */
/* -------------------------------------------------------------------- */
nLayers++;
papoLayers = (OGRCSVLayer **) CPLRealloc(papoLayers,
sizeof(void*) * nLayers);
if (pszNfdcRunwaysGeomField != NULL)
{
osLayerName += "_";
osLayerName += pszNfdcRunwaysGeomField;
}
else if (pszGeonamesGeomFieldPrefix != NULL &&
!EQUAL(pszGeonamesGeomFieldPrefix, ""))
{
osLayerName += "_";
osLayerName += pszGeonamesGeomFieldPrefix;
}
if (EQUAL(pszFilename, "/vsistdin/"))
osLayerName = "layer";
papoLayers[nLayers-1] =
new OGRCSVLayer( osLayerName, fp, pszFilename, FALSE, bUpdate,
chDelimiter );
papoLayers[nLayers-1]->BuildFeatureDefn( pszNfdcRunwaysGeomField,
pszGeonamesGeomFieldPrefix,
papszOpenOptions );
return TRUE;
}
OGRGmtLayer::OGRGmtLayer( const char * pszFilename, int bUpdateIn ) :
poSRS(NULL),
poFeatureDefn(NULL),
iNextFID(0),
bUpdate(CPL_TO_BOOL(bUpdateIn)),
// Assume header complete in readonly mode.
bHeaderComplete(CPL_TO_BOOL(!bUpdate)),
bRegionComplete(false),
nRegionOffset(0),
papszKeyedValues(NULL),
bValidFile(FALSE)
{
/* -------------------------------------------------------------------- */
/* Open file. */
/* -------------------------------------------------------------------- */
if( bUpdate )
fp = VSIFOpenL( pszFilename, "r+" );
else
fp = VSIFOpenL( pszFilename, "r" );
if( fp == NULL )
return;
/* -------------------------------------------------------------------- */
/* Read the header. */
/* -------------------------------------------------------------------- */
CPLString osFieldNames;
CPLString osFieldTypes;
CPLString osGeometryType;
CPLString osRegion;
CPLString osWKT;
CPLString osProj4;
CPLString osEPSG;
vsi_l_offset nStartOfLine = VSIFTellL(fp);
while( ReadLine() && osLine[0] == '#' )
{
if( strstr( osLine, "FEATURE_DATA" ) )
{
bHeaderComplete = TRUE;
ReadLine();
break;
}
if( STARTS_WITH_CI(osLine, "# REGION_STUB ") )
nRegionOffset = nStartOfLine;
for( int iKey = 0;
papszKeyedValues != NULL && papszKeyedValues[iKey] != NULL;
iKey++ )
{
if( papszKeyedValues[iKey][0] == 'N' )
osFieldNames = papszKeyedValues[iKey] + 1;
if( papszKeyedValues[iKey][0] == 'T' )
osFieldTypes = papszKeyedValues[iKey] + 1;
if( papszKeyedValues[iKey][0] == 'G' )
osGeometryType = papszKeyedValues[iKey] + 1;
if( papszKeyedValues[iKey][0] == 'R' )
osRegion = papszKeyedValues[iKey] + 1;
if( papszKeyedValues[iKey][0] == 'J' )
{
CPLString osArg = papszKeyedValues[iKey] + 2;
if( osArg[0] == '"' && osArg[osArg.length()-1] == '"' )
{
osArg = osArg.substr(1,osArg.length()-2);
char *pszArg = CPLUnescapeString(osArg, NULL,
CPLES_BackslashQuotable);
osArg = pszArg;
CPLFree( pszArg );
}
if( papszKeyedValues[iKey][1] == 'e' )
osEPSG = osArg;
if( papszKeyedValues[iKey][1] == 'p' )
osProj4 = osArg;
if( papszKeyedValues[iKey][1] == 'w' )
osWKT = osArg;
}
}
nStartOfLine = VSIFTellL(fp);
}
/* -------------------------------------------------------------------- */
/* Handle coordinate system. */
/* -------------------------------------------------------------------- */
if( osWKT.length() )
{
char *pszWKT = (char *) osWKT.c_str();
poSRS = new OGRSpatialReference();
if( poSRS->importFromWkt(&pszWKT) != OGRERR_NONE )
{
delete poSRS;
poSRS = NULL;
}
}
else if( osEPSG.length() )
{
poSRS = new OGRSpatialReference();
if( poSRS->importFromEPSG( atoi(osEPSG) ) != OGRERR_NONE )
{
delete poSRS;
poSRS = NULL;
}
}
else if( osProj4.length() )
{
poSRS = new OGRSpatialReference();
if( poSRS->importFromProj4( osProj4 ) != OGRERR_NONE )
{
delete poSRS;
poSRS = NULL;
}
}
/* -------------------------------------------------------------------- */
/* Create the feature definition, and set the geometry type, if */
/* known. */
/* -------------------------------------------------------------------- */
poFeatureDefn = new OGRFeatureDefn( CPLGetBasename(pszFilename) );
SetDescription( poFeatureDefn->GetName() );
poFeatureDefn->Reference();
poFeatureDefn->GetGeomFieldDefn(0)->SetSpatialRef(poSRS);
if( osGeometryType == "POINT" )
poFeatureDefn->SetGeomType( wkbPoint );
else if( osGeometryType == "MULTIPOINT" )
poFeatureDefn->SetGeomType( wkbMultiPoint );
else if( osGeometryType == "LINESTRING" )
poFeatureDefn->SetGeomType( wkbLineString );
else if( osGeometryType == "MULTILINESTRING" )
poFeatureDefn->SetGeomType( wkbMultiLineString );
else if( osGeometryType == "POLYGON" )
poFeatureDefn->SetGeomType( wkbPolygon );
else if( osGeometryType == "MULTIPOLYGON" )
poFeatureDefn->SetGeomType( wkbMultiPolygon );
/* -------------------------------------------------------------------- */
/* Process a region line. */
/* -------------------------------------------------------------------- */
if( osRegion.length() > 0 )
{
char **papszTokens = CSLTokenizeStringComplex( osRegion.c_str(),
"/", FALSE, FALSE );
if( CSLCount(papszTokens) == 4 )
{
sRegion.MinX = CPLAtofM(papszTokens[0]);
sRegion.MaxX = CPLAtofM(papszTokens[1]);
sRegion.MinY = CPLAtofM(papszTokens[2]);
sRegion.MaxY = CPLAtofM(papszTokens[3]);
}
bRegionComplete = TRUE;
CSLDestroy( papszTokens );
}
/* -------------------------------------------------------------------- */
/* Process fields. */
/* -------------------------------------------------------------------- */
if( osFieldNames.length() || osFieldTypes.length() )
{
char **papszFN = CSLTokenizeStringComplex( osFieldNames, "|",
TRUE, TRUE );
char **papszFT = CSLTokenizeStringComplex( osFieldTypes, "|",
TRUE, TRUE );
const int nFieldCount = MAX(CSLCount(papszFN),CSLCount(papszFT));
for( int iField = 0; iField < nFieldCount; iField++ )
{
OGRFieldDefn oField("", OFTString );
if( iField < CSLCount(papszFN) )
oField.SetName( papszFN[iField] );
else
oField.SetName( CPLString().Printf( "Field_%d", iField+1 ));
if( iField < CSLCount(papszFT) )
{
if( EQUAL(papszFT[iField],"integer") )
oField.SetType( OFTInteger );
else if( EQUAL(papszFT[iField],"double") )
oField.SetType( OFTReal );
else if( EQUAL(papszFT[iField],"datetime") )
oField.SetType( OFTDateTime );
}
poFeatureDefn->AddFieldDefn( &oField );
}
CSLDestroy( papszFN );
CSLDestroy( papszFT );
}
bValidFile = TRUE;
}