void KML::parse()
{
std::size_t nDone = 0;
std::size_t nLen = 0;
char aBuf[BUFSIZ] = { 0 };
if( NULL == pKMLFile_ )
{
sError_ = "No file given";
return;
}
if(poTrunk_ != NULL) {
delete poTrunk_;
poTrunk_ = NULL;
}
if(poCurrent_ != NULL)
{
delete poCurrent_;
poCurrent_ = NULL;
}
XML_Parser oParser = OGRCreateExpatXMLParser();
XML_SetUserData(oParser, this);
XML_SetElementHandler(oParser, startElement, endElement);
XML_SetCharacterDataHandler(oParser, dataHandler);
oCurrentParser = oParser;
nWithoutEventCounter = 0;
do
{
nDataHandlerCounter = 0;
nLen = (int)VSIFReadL( aBuf, 1, sizeof(aBuf), pKMLFile_ );
nDone = VSIFEofL(pKMLFile_);
if (XML_Parse(oParser, aBuf, nLen, nDone) == XML_STATUS_ERROR)
{
CPLError(CE_Failure, CPLE_AppDefined,
"XML parsing of KML file failed : %s at line %d, column %d",
XML_ErrorString(XML_GetErrorCode(oParser)),
(int)XML_GetCurrentLineNumber(oParser),
(int)XML_GetCurrentColumnNumber(oParser));
XML_ParserFree(oParser);
VSIRewindL(pKMLFile_);
return;
}
nWithoutEventCounter ++;
} while (!nDone && nLen > 0 && nWithoutEventCounter < 10);
XML_ParserFree(oParser);
VSIRewindL(pKMLFile_);
poCurrent_ = NULL;
if (nWithoutEventCounter == 10)
{
CPLError(CE_Failure, CPLE_AppDefined,
"Too much data inside one element. File probably corrupted");
}
}
void MoveOverwrite(VSILFILE *fpDest,VSILFILE *fpSource) {
VSIRewindL(fpSource);
VSIRewindL(fpDest);
VSIFTruncateL(fpDest,0);
char anBuf[0x10000];
while (!VSIFEofL(fpSource)) {
size_t nSize=VSIFReadL(anBuf,1,0x10000,fpSource);
size_t nLeft=nSize;
while (nLeft>0) nLeft-=VSIFWriteL(anBuf+nSize-nLeft,1,nLeft,fpDest);
}
VSIFCloseL(fpSource);
VSIFFlushL(fpDest);
}
int GDALOpenInfo::TryToIngest(int nBytes)
{
if( fpL == NULL )
return FALSE;
if( nHeaderBytes < nHeaderBytesTried )
return TRUE;
pabyHeader = (GByte*) CPLRealloc(pabyHeader, nBytes + 1);
memset(pabyHeader, 0, nBytes + 1);
VSIRewindL(fpL);
nHeaderBytesTried = nBytes;
nHeaderBytes = (int) VSIFReadL(pabyHeader, 1, nBytes, fpL);
VSIRewindL(fpL);
return TRUE;
}
int MIDDATAFile::Rewind()
{
if (m_fp == NULL || m_eAccessMode == TABWrite)
return -1;
else
{
VSIRewindL(m_fp);
SetEof(FALSE);
}
return 0;
}
void OGRCSVLayer::ResetReading()
{
if (fpCSV)
VSIRewindL( fpCSV );
if( bHasFieldNames )
CSLDestroy( OGRCSVReadParseLineL( fpCSV, chDelimiter, bDontHonourStrings ) );
bNeedRewindBeforeRead = FALSE;
nNextFID = 1;
}
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;
}
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;
}
OGRCSVLayer::OGRCSVLayer( const char *pszLayerNameIn,
VSILFILE * fp, const char *pszFilename, int bNew, int bInWriteMode,
char chDelimiter, const char* pszNfdcGeomField,
const char* pszGeonamesGeomFieldPrefix)
{
fpCSV = fp;
iWktGeomReadField = -1;
iNfdcLatitudeS = iNfdcLongitudeS = -1;
iLatitudeField = iLongitudeField = -1;
this->bInWriteMode = bInWriteMode;
this->bNew = bNew;
this->pszFilename = CPLStrdup(pszFilename);
this->chDelimiter = chDelimiter;
bFirstFeatureAppendedDuringSession = TRUE;
bUseCRLF = FALSE;
bNeedRewindBeforeRead = FALSE;
eGeometryFormat = OGR_CSV_GEOM_NONE;
nNextFID = 1;
poFeatureDefn = new OGRFeatureDefn( pszLayerNameIn );
poFeatureDefn->Reference();
poFeatureDefn->SetGeomType( wkbNone );
bCreateCSVT = FALSE;
bDontHonourStrings = FALSE;
bWriteBOM = FALSE;
bIsEurostatTSV = FALSE;
nEurostatDims = 0;
nTotalFeatures = -1;
/* -------------------------------------------------------------------- */
/* If this is not a new file, read ahead to establish if it is */
/* already in CRLF (DOS) mode, or just a normal unix CR mode. */
/* -------------------------------------------------------------------- */
if( !bNew && bInWriteMode )
{
int nBytesRead = 0;
char chNewByte;
while( nBytesRead < 10000 && VSIFReadL( &chNewByte, 1, 1, fpCSV ) == 1 )
{
if( chNewByte == 13 )
{
bUseCRLF = TRUE;
break;
}
nBytesRead ++;
}
VSIRewindL( fpCSV );
}
/* -------------------------------------------------------------------- */
/* Check if the first record seems to be field definitions or */
/* not. We assume it is field definitions if none of the */
/* values are strictly numeric. */
/* -------------------------------------------------------------------- */
char **papszTokens = NULL;
int nFieldCount=0, iField;
CPLValueType eType;
if( !bNew )
{
const char *pszLine = NULL;
char szDelimiter[2];
szDelimiter[0] = chDelimiter; szDelimiter[1] = '\0';
pszLine = CPLReadLineL( fpCSV );
if ( pszLine != NULL )
{
/* Detect and remove UTF-8 BOM marker if found (#4623) */
if (pszLine[0] == (char)0xEF &&
pszLine[1] == (char)0xBB &&
pszLine[2] == (char)0xBF)
{
pszLine += 3;
}
/* tokenize the strings and preserve quotes, so we can separate string from numeric */
/* this is only used in the test for bHasFeldNames (bug #4361) */
papszTokens = CSLTokenizeString2( pszLine, szDelimiter,
(CSLT_HONOURSTRINGS |
CSLT_ALLOWEMPTYTOKENS |
CSLT_PRESERVEQUOTES) );
nFieldCount = CSLCount( papszTokens );
bHasFieldNames = TRUE;
for( iField = 0; iField < nFieldCount && bHasFieldNames; iField++ )
{
eType = CPLGetValueType(papszTokens[iField]);
if ( (eType == CPL_VALUE_INTEGER ||
eType == CPL_VALUE_REAL) ) {
/* we have a numeric field, therefore do not consider the first line as field names */
bHasFieldNames = FALSE;
}
}
CPLString osExt = OGRCSVDataSource::GetRealExtension(pszFilename);
/* Eurostat .tsv files */
if( EQUAL(osExt, "tsv") && nFieldCount > 1 &&
strchr(papszTokens[0], ',') != NULL && strchr(papszTokens[0], '\\') != NULL )
{
bHasFieldNames = TRUE;
bIsEurostatTSV = TRUE;
}
/* tokenize without quotes to get the actual values */
CSLDestroy( papszTokens );
// papszTokens = OGRCSVReadParseLineL( fpCSV, chDelimiter, FALSE );
papszTokens = CSLTokenizeString2( pszLine, szDelimiter,
(CSLT_HONOURSTRINGS |
CSLT_ALLOWEMPTYTOKENS));
nFieldCount = CSLCount( papszTokens );
}
}
else
bHasFieldNames = FALSE;
if( !bNew && !bHasFieldNames )
VSIRewindL( fpCSV );
/* -------------------------------------------------------------------- */
/* Check for geonames.org tables */
/* -------------------------------------------------------------------- */
if( !bHasFieldNames && nFieldCount == 19 )
{
if (CPLGetValueType(papszTokens[0]) == CPL_VALUE_INTEGER &&
CPLGetValueType(papszTokens[4]) == CPL_VALUE_REAL &&
CPLGetValueType(papszTokens[5]) == CPL_VALUE_REAL &&
CPLAtof(papszTokens[4]) >= -90 && CPLAtof(papszTokens[4]) <= 90 &&
CPLAtof(papszTokens[5]) >= -180 && CPLAtof(papszTokens[4]) <= 180)
{
bHasFieldNames = TRUE;
CSLDestroy(papszTokens);
papszTokens = NULL;
static const struct {
const char* pszName;
OGRFieldType eType;
}
asGeonamesFieldDesc[] =
{
{ "GEONAMEID", OFTString },
{ "NAME", OFTString },
{ "ASCIINAME", OFTString },
{ "ALTNAMES", OFTString },
{ "LATITUDE", OFTReal },
{ "LONGITUDE", OFTReal },
{ "FEATCLASS", OFTString },
{ "FEATCODE", OFTString },
{ "COUNTRY", OFTString },
{ "CC2", OFTString },
{ "ADMIN1", OFTString },
{ "ADMIN2", OFTString },
{ "ADMIN3", OFTString },
{ "ADMIN4", OFTString },
{ "POPULATION", OFTReal },
{ "ELEVATION", OFTInteger },
{ "GTOPO30", OFTInteger },
{ "TIMEZONE", OFTString },
{ "MODDATE", OFTString }
};
for(iField = 0; iField < nFieldCount; iField++)
{
OGRFieldDefn oFieldDefn(asGeonamesFieldDesc[iField].pszName,
asGeonamesFieldDesc[iField].eType);
poFeatureDefn->AddFieldDefn(&oFieldDefn);
}
iLatitudeField = 4;
iLongitudeField = 5;
nFieldCount = 0;
}
}
/* -------------------------------------------------------------------- */
/* Search a csvt file for types */
/* -------------------------------------------------------------------- */
char** papszFieldTypes = NULL;
if (!bNew) {
char* dname = strdup(CPLGetDirname(pszFilename));
char* fname = strdup(CPLGetBasename(pszFilename));
VSILFILE* fpCSVT = VSIFOpenL(CPLFormFilename(dname, fname, ".csvt"), "r");
free(dname);
free(fname);
if (fpCSVT!=NULL) {
VSIRewindL(fpCSVT);
papszFieldTypes = OGRCSVReadParseLineL(fpCSVT, ',', FALSE);
VSIFCloseL(fpCSVT);
}
}
/* -------------------------------------------------------------------- */
/* Build field definitions. */
/* -------------------------------------------------------------------- */
for( iField = 0; !bIsEurostatTSV && iField < nFieldCount; iField++ )
{
char *pszFieldName = NULL;
char szFieldNameBuffer[100];
if( bHasFieldNames )
{
pszFieldName = papszTokens[iField];
// trim white space.
while( *pszFieldName == ' ' )
pszFieldName++;
while( pszFieldName[0] != '\0'
&& pszFieldName[strlen(pszFieldName)-1] == ' ' )
pszFieldName[strlen(pszFieldName)-1] = '\0';
if (*pszFieldName == '\0')
pszFieldName = NULL;
}
if (pszFieldName == NULL)
{
/* Re-read single column CSV files that have a trailing comma */
/* in the header line */
if( iField == 1 && nFieldCount == 2 && papszTokens[1][0] == '\0' )
{
nFieldCount = 1;
break;
}
pszFieldName = szFieldNameBuffer;
sprintf( szFieldNameBuffer, "field_%d", iField+1 );
}
OGRFieldDefn oField(pszFieldName, OFTString);
if (papszFieldTypes!=NULL && iField<CSLCount(papszFieldTypes)) {
char* pszLeftParenthesis = strchr(papszFieldTypes[iField], '(');
if (pszLeftParenthesis && pszLeftParenthesis != papszFieldTypes[iField] &&
pszLeftParenthesis[1] >= '0' && pszLeftParenthesis[1] <= '9')
{
int nWidth = 0;
int nPrecision = 0;
char* pszDot = strchr(pszLeftParenthesis, '.');
if (pszDot) *pszDot = 0;
*pszLeftParenthesis = 0;
if (pszLeftParenthesis[-1] == ' ')
pszLeftParenthesis[-1] = 0;
nWidth = atoi(pszLeftParenthesis+1);
if (pszDot)
nPrecision = atoi(pszDot+1);
oField.SetWidth(nWidth);
oField.SetPrecision(nPrecision);
}
if (EQUAL(papszFieldTypes[iField], "Integer"))
oField.SetType(OFTInteger);
else if (EQUAL(papszFieldTypes[iField], "Real"))
oField.SetType(OFTReal);
else if (EQUAL(papszFieldTypes[iField], "String"))
oField.SetType(OFTString);
else if (EQUAL(papszFieldTypes[iField], "Date"))
oField.SetType(OFTDate);
else if (EQUAL(papszFieldTypes[iField], "Time"))
oField.SetType(OFTTime);
else if (EQUAL(papszFieldTypes[iField], "DateTime"))
oField.SetType(OFTDateTime);
else
CPLError(CE_Warning, CPLE_NotSupported, "Unknown type : %s", papszFieldTypes[iField]);
}
if( EQUAL(oField.GetNameRef(),"WKT")
&& oField.GetType() == OFTString
&& iWktGeomReadField == -1 )
{
iWktGeomReadField = iField;
poFeatureDefn->SetGeomType( wkbUnknown );
}
/*http://www.faa.gov/airports/airport_safety/airportdata_5010/menu/index.cfm specific */
if ( pszNfdcGeomField != NULL &&
EQUALN(oField.GetNameRef(), pszNfdcGeomField, strlen(pszNfdcGeomField)) &&
EQUAL(oField.GetNameRef() + strlen(pszNfdcGeomField), "LatitudeS") )
iNfdcLatitudeS = iField;
else if ( pszNfdcGeomField != NULL &&
EQUALN(oField.GetNameRef(), pszNfdcGeomField, strlen(pszNfdcGeomField)) &&
EQUAL(oField.GetNameRef() + strlen(pszNfdcGeomField), "LongitudeS") )
iNfdcLongitudeS = iField;
/* GNIS specific */
else if ( pszGeonamesGeomFieldPrefix != NULL &&
EQUALN(oField.GetNameRef(), pszGeonamesGeomFieldPrefix, strlen(pszGeonamesGeomFieldPrefix)) &&
(EQUAL(oField.GetNameRef() + strlen(pszGeonamesGeomFieldPrefix), "_LAT_DEC") ||
EQUAL(oField.GetNameRef() + strlen(pszGeonamesGeomFieldPrefix), "_LATITUDE_DEC") ||
EQUAL(oField.GetNameRef() + strlen(pszGeonamesGeomFieldPrefix), "_LATITUDE")) )
{
oField.SetType(OFTReal);
iLatitudeField = iField;
}
else if ( pszGeonamesGeomFieldPrefix != NULL &&
EQUALN(oField.GetNameRef(), pszGeonamesGeomFieldPrefix, strlen(pszGeonamesGeomFieldPrefix)) &&
(EQUAL(oField.GetNameRef() + strlen(pszGeonamesGeomFieldPrefix), "_LONG_DEC") ||
EQUAL(oField.GetNameRef() + strlen(pszGeonamesGeomFieldPrefix), "_LONGITUDE_DEC") ||
EQUAL(oField.GetNameRef() + strlen(pszGeonamesGeomFieldPrefix), "_LONGITUDE")) )
{
oField.SetType(OFTReal);
iLongitudeField = iField;
}
poFeatureDefn->AddFieldDefn( &oField );
}
if ( iNfdcLatitudeS != -1 && iNfdcLongitudeS != -1 )
{
bDontHonourStrings = TRUE;
poFeatureDefn->SetGeomType( wkbPoint );
}
else if ( iLatitudeField != -1 && iLongitudeField != -1 )
{
poFeatureDefn->SetGeomType( wkbPoint );
}
/* -------------------------------------------------------------------- */
/* Build field definitions for Eurostat TSV files. */
/* -------------------------------------------------------------------- */
CPLString osSeqDim;
for( iField = 0; bIsEurostatTSV && iField < nFieldCount; iField++ )
{
if( iField == 0 )
{
char** papszDims = CSLTokenizeString2( papszTokens[0], ",\\", 0 );
nEurostatDims = CSLCount(papszDims) - 1;
for(int iSubField = 0; iSubField < nEurostatDims; iSubField++)
{
OGRFieldDefn oField(papszDims[iSubField], OFTString);
poFeatureDefn->AddFieldDefn( &oField );
}
osSeqDim = papszDims[nEurostatDims];
CSLDestroy(papszDims);
}
else
{
if( papszTokens[iField][0] != '\0'
&& papszTokens[iField][strlen(papszTokens[iField])-1] == ' ' )
papszTokens[iField][strlen(papszTokens[iField])-1] = '\0';
OGRFieldDefn oField(CPLSPrintf("%s_%s", osSeqDim.c_str(), papszTokens[iField]), OFTReal);
poFeatureDefn->AddFieldDefn( &oField );
OGRFieldDefn oField2(CPLSPrintf("%s_%s_flag", osSeqDim.c_str(), papszTokens[iField]), OFTString);
poFeatureDefn->AddFieldDefn( &oField2 );
}
}
/* -------------------------------------------------------------------- */
/* Cleanup. */
/* -------------------------------------------------------------------- */
CSLDestroy( papszTokens );
CSLDestroy( papszFieldTypes );
}
GDALDataset *E00GRIDDataset::Open( GDALOpenInfo * poOpenInfo )
{
if (!Identify(poOpenInfo))
return NULL;
/* -------------------------------------------------------------------- */
/* Find dataset characteristics */
/* -------------------------------------------------------------------- */
VSILFILE* fp = VSIFOpenL(poOpenInfo->pszFilename, "rb");
if (fp == NULL)
return NULL;
if (poOpenInfo->eAccess == GA_Update)
{
CPLError( CE_Failure, CPLE_NotSupported,
"The E00GRID driver does not support update access to existing"
" datasets.\n" );
VSIFCloseL(fp);
return NULL;
}
/* -------------------------------------------------------------------- */
/* Create a corresponding GDALDataset. */
/* -------------------------------------------------------------------- */
E00GRIDDataset *poDS = new E00GRIDDataset();
if (strstr((const char*)poOpenInfo->pabyHeader, "\r\n") != NULL)
poDS->nBytesEOL = 2;
poDS->fp = fp;
/* read EXP 0 or EXP 1 line */
const char* pszLine = CPLReadLine2L(fp, 81, NULL);
if (pszLine == NULL)
{
CPLDebug("E00GRID", "Bad 1st line");
delete poDS;
return NULL;
}
bool bCompressed = STARTS_WITH_CI(pszLine, "EXP 1");
E00ReadPtr e00ReadPtr = NULL;
if (bCompressed)
{
VSIRewindL(fp);
e00ReadPtr = E00ReadCallbackOpen(poDS,
E00GRIDDataset::ReadNextLine,
E00GRIDDataset::Rewind);
if (e00ReadPtr == NULL)
{
delete poDS;
return NULL;
}
E00ReadNextLine(e00ReadPtr);
poDS->e00ReadPtr = e00ReadPtr;
}
/* skip GRD 2 line */
if (e00ReadPtr)
pszLine = E00ReadNextLine(e00ReadPtr);
else
pszLine = CPLReadLine2L(fp, 81, NULL);
if (pszLine == NULL || !STARTS_WITH_CI(pszLine, "GRD 2"))
{
CPLDebug("E00GRID", "Bad 2nd line");
delete poDS;
return NULL;
}
/* read ncols, nrows and nodata value */
if (e00ReadPtr)
pszLine = E00ReadNextLine(e00ReadPtr);
else
pszLine = CPLReadLine2L(fp, 81, NULL);
if (pszLine == NULL || strlen(pszLine) <
E00_INT_SIZE+E00_INT_SIZE+2+E00_DOUBLE_SIZE)
{
CPLDebug("E00GRID", "Bad 3rd line");
delete poDS;
return NULL;
}
const int nRasterXSize = atoi(pszLine);
const int nRasterYSize = atoi(pszLine + E00_INT_SIZE);
if (!GDALCheckDatasetDimensions(nRasterXSize, nRasterYSize))
{
delete poDS;
return NULL;
}
GDALDataType eDT = GDT_Float32;
if (STARTS_WITH_CI(pszLine + E00_INT_SIZE + E00_INT_SIZE, " 1"))
eDT = GDT_Int32;
else if (STARTS_WITH_CI(pszLine + E00_INT_SIZE + E00_INT_SIZE, " 2"))
eDT = GDT_Float32;
else
{
CPLDebug("E00GRID", "Unknown data type : %s", pszLine);
}
const double dfNoData = CPLAtof(pszLine + E00_INT_SIZE + E00_INT_SIZE + 2);
/* read pixel size */
if (e00ReadPtr)
pszLine = E00ReadNextLine(e00ReadPtr);
else
pszLine = CPLReadLine2L(fp, 81, NULL);
if (pszLine == NULL || strlen(pszLine) < 2*E00_DOUBLE_SIZE)
{
CPLDebug("E00GRID", "Bad 4th line");
delete poDS;
return NULL;
}
/*
double dfPixelX = CPLAtof(pszLine);
double dfPixelY = CPLAtof(pszLine + E00_DOUBLE_SIZE);
*/
/* read xmin, ymin */
if (e00ReadPtr)
pszLine = E00ReadNextLine(e00ReadPtr);
else
pszLine = CPLReadLine2L(fp, 81, NULL);
if (pszLine == NULL || strlen(pszLine) < 2*E00_DOUBLE_SIZE)
{
CPLDebug("E00GRID", "Bad 5th line");
delete poDS;
return NULL;
}
const double dfMinX = CPLAtof(pszLine);
const double dfMinY = CPLAtof(pszLine + E00_DOUBLE_SIZE);
/* read xmax, ymax */
if (e00ReadPtr)
pszLine = E00ReadNextLine(e00ReadPtr);
else
pszLine = CPLReadLine2L(fp, 81, NULL);
if (pszLine == NULL || strlen(pszLine) < 2*E00_DOUBLE_SIZE)
{
CPLDebug("E00GRID", "Bad 6th line");
delete poDS;
return NULL;
}
const double dfMaxX = CPLAtof(pszLine);
const double dfMaxY = CPLAtof(pszLine + E00_DOUBLE_SIZE);
poDS->nRasterXSize = nRasterXSize;
poDS->nRasterYSize = nRasterYSize;
poDS->dfNoData = dfNoData;
poDS->adfGeoTransform[0] = dfMinX;
poDS->adfGeoTransform[1] = (dfMaxX - dfMinX) / nRasterXSize;
poDS->adfGeoTransform[2] = 0;
poDS->adfGeoTransform[3] = dfMaxY;
poDS->adfGeoTransform[4] = 0;
poDS->adfGeoTransform[5] = - (dfMaxY - dfMinY) / nRasterYSize;
poDS->nDataStart = VSIFTellL(fp);
if (bCompressed)
{
poDS->panOffsets = (vsi_l_offset*)
VSIMalloc2(sizeof(vsi_l_offset), nRasterYSize);
if (poDS->panOffsets == NULL)
{
delete poDS;
return NULL;
}
}
/* -------------------------------------------------------------------- */
/* Create band information objects. */
/* -------------------------------------------------------------------- */
poDS->nBands = 1;
for( int i = 0; i < poDS->nBands; i++ )
poDS->SetBand( i+1, new E00GRIDRasterBand( poDS, i+1, eDT ) );
/* -------------------------------------------------------------------- */
/* Initialize any PAM information. */
/* -------------------------------------------------------------------- */
poDS->SetDescription( poOpenInfo->pszFilename );
poDS->TryLoadXML();
/* -------------------------------------------------------------------- */
/* Support overviews. */
/* -------------------------------------------------------------------- */
poDS->oOvManager.Initialize( poDS, poOpenInfo->pszFilename );
return poDS;
}
void E00GRIDDataset::Rewind(void * ptr)
{
E00GRIDDataset* poDS = (E00GRIDDataset*) ptr;
VSIRewindL(poDS->fp);
}
OGRCSVLayer::OGRCSVLayer( const char *pszLayerNameIn,
VSILFILE * fp, const char *pszFilename, int bNew, int bInWriteMode,
char chDelimiter, const char* pszNfdcGeomField,
const char* pszGeonamesGeomFieldPrefix)
{
fpCSV = fp;
iWktGeomReadField = -1;
iNfdcLatitudeS = iNfdcLongitudeS = -1;
iLatitudeField = iLongitudeField = -1;
this->bInWriteMode = bInWriteMode;
this->bNew = bNew;
this->pszFilename = CPLStrdup(pszFilename);
this->chDelimiter = chDelimiter;
bFirstFeatureAppendedDuringSession = TRUE;
bUseCRLF = FALSE;
bNeedRewindBeforeRead = FALSE;
eGeometryFormat = OGR_CSV_GEOM_NONE;
nNextFID = 1;
poFeatureDefn = new OGRFeatureDefn( pszLayerNameIn );
poFeatureDefn->Reference();
poFeatureDefn->SetGeomType( wkbNone );
bCreateCSVT = FALSE;
bDontHonourStrings = FALSE;
nTotalFeatures = -1;
/* -------------------------------------------------------------------- */
/* If this is not a new file, read ahead to establish if it is */
/* already in CRLF (DOS) mode, or just a normal unix CR mode. */
/* -------------------------------------------------------------------- */
if( !bNew && bInWriteMode )
{
int nBytesRead = 0;
char chNewByte;
while( nBytesRead < 10000 && VSIFReadL( &chNewByte, 1, 1, fpCSV ) == 1 )
{
if( chNewByte == 13 )
{
bUseCRLF = TRUE;
break;
}
}
VSIRewindL( fpCSV );
}
/* -------------------------------------------------------------------- */
/* Check if the first record seems to be field definitions or */
/* not. We assume it is field definitions if none of the */
/* values are strictly numeric. */
/* -------------------------------------------------------------------- */
char **papszTokens = NULL;
int nFieldCount=0, iField;
CPLValueType eType;
if( !bNew )
{
papszTokens = OGRCSVReadParseLineL( fpCSV, chDelimiter, FALSE );
nFieldCount = CSLCount( papszTokens );
bHasFieldNames = TRUE;
}
else
bHasFieldNames = FALSE;
for( iField = 0; iField < nFieldCount && bHasFieldNames; iField++ )
{
eType = CPLGetValueType(papszTokens[iField]);
if ( eType == CPL_VALUE_INTEGER ||
eType == CPL_VALUE_REAL ) {
/* we have a numeric field, therefore do not consider the first line as field names */
bHasFieldNames = FALSE;
}
}
if( !bNew && !bHasFieldNames )
VSIRewindL( fpCSV );
/* -------------------------------------------------------------------- */
/* Check for geonames.org tables */
/* -------------------------------------------------------------------- */
if( !bHasFieldNames && nFieldCount == 19 )
{
if (CPLGetValueType(papszTokens[0]) == CPL_VALUE_INTEGER &&
CPLGetValueType(papszTokens[4]) == CPL_VALUE_REAL &&
CPLGetValueType(papszTokens[5]) == CPL_VALUE_REAL &&
CPLAtof(papszTokens[4]) >= -90 && CPLAtof(papszTokens[4]) <= 90 &&
CPLAtof(papszTokens[5]) >= -180 && CPLAtof(papszTokens[4]) <= 180)
{
bHasFieldNames = TRUE;
CSLDestroy(papszTokens);
papszTokens = NULL;
static const struct {
const char* pszName;
OGRFieldType eType;
}
asGeonamesFieldDesc[] =
{
{ "GEONAMEID", OFTString },
{ "NAME", OFTString },
{ "ASCIINAME", OFTString },
{ "ALTNAMES", OFTString },
{ "LATITUDE", OFTReal },
{ "LONGITUDE", OFTReal },
{ "FEATCLASS", OFTString },
{ "FEATCODE", OFTString },
{ "COUNTRY", OFTString },
{ "CC2", OFTString },
{ "ADMIN1", OFTString },
{ "ADMIN2", OFTString },
{ "ADMIN3", OFTString },
{ "ADMIN4", OFTString },
{ "POPULATION", OFTReal },
{ "ELEVATION", OFTInteger },
{ "GTOPO30", OFTInteger },
{ "TIMEZONE", OFTString },
{ "MODDATE", OFTString }
};
for(iField = 0; iField < nFieldCount; iField++)
{
OGRFieldDefn oFieldDefn(asGeonamesFieldDesc[iField].pszName,
asGeonamesFieldDesc[iField].eType);
poFeatureDefn->AddFieldDefn(&oFieldDefn);
}
iLatitudeField = 4;
iLongitudeField = 5;
nFieldCount = 0;
}
}
/* -------------------------------------------------------------------- */
/* Search a csvt file for types */
/* -------------------------------------------------------------------- */
char** papszFieldTypes = NULL;
if (!bNew) {
char* dname = strdup(CPLGetDirname(pszFilename));
char* fname = strdup(CPLGetBasename(pszFilename));
VSILFILE* fpCSVT = VSIFOpenL(CPLFormFilename(dname, fname, ".csvt"), "r");
free(dname);
free(fname);
if (fpCSVT!=NULL) {
VSIRewindL(fpCSVT);
papszFieldTypes = OGRCSVReadParseLineL(fpCSVT, ',', FALSE);
VSIFCloseL(fpCSVT);
}
}
/* -------------------------------------------------------------------- */
/* Build field definitions. */
/* -------------------------------------------------------------------- */
for( iField = 0; iField < nFieldCount; iField++ )
{
char *pszFieldName = NULL;
char szFieldNameBuffer[100];
if( bHasFieldNames )
{
pszFieldName = papszTokens[iField];
// trim white space.
while( *pszFieldName == ' ' )
pszFieldName++;
while( pszFieldName[0] != '\0'
&& pszFieldName[strlen(pszFieldName)-1] == ' ' )
pszFieldName[strlen(pszFieldName)-1] = '\0';
if (*pszFieldName == '\0')
pszFieldName = NULL;
}
if (pszFieldName == NULL)
{
pszFieldName = szFieldNameBuffer;
sprintf( szFieldNameBuffer, "field_%d", iField+1 );
}
OGRFieldDefn oField(pszFieldName, OFTString);
if (papszFieldTypes!=NULL && iField<CSLCount(papszFieldTypes)) {
char* pszLeftParenthesis = strchr(papszFieldTypes[iField], '(');
if (pszLeftParenthesis && pszLeftParenthesis != papszFieldTypes[iField] &&
pszLeftParenthesis[1] >= '0' && pszLeftParenthesis[1] <= '9')
{
int nWidth = 0;
int nPrecision = 0;
char* pszDot = strchr(pszLeftParenthesis, '.');
if (pszDot) *pszDot = 0;
*pszLeftParenthesis = 0;
if (pszLeftParenthesis[-1] == ' ')
pszLeftParenthesis[-1] = 0;
nWidth = atoi(pszLeftParenthesis+1);
if (pszDot)
nPrecision = atoi(pszDot+1);
oField.SetWidth(nWidth);
oField.SetPrecision(nPrecision);
}
if (EQUAL(papszFieldTypes[iField], "Integer"))
oField.SetType(OFTInteger);
else if (EQUAL(papszFieldTypes[iField], "Real"))
oField.SetType(OFTReal);
else if (EQUAL(papszFieldTypes[iField], "String"))
oField.SetType(OFTString);
else if (EQUAL(papszFieldTypes[iField], "Date"))
oField.SetType(OFTDate);
else if (EQUAL(papszFieldTypes[iField], "Time"))
oField.SetType(OFTTime);
else if (EQUAL(papszFieldTypes[iField], "DateTime"))
oField.SetType(OFTDateTime);
else
CPLError(CE_Warning, CPLE_NotSupported, "Unknown type : %s", papszFieldTypes[iField]);
}
if( EQUAL(oField.GetNameRef(),"WKT")
&& oField.GetType() == OFTString
&& iWktGeomReadField == -1 )
{
iWktGeomReadField = iField;
poFeatureDefn->SetGeomType( wkbUnknown );
}
/*http://www.faa.gov/airports/airport_safety/airportdata_5010/menu/index.cfm specific */
if ( pszNfdcGeomField != NULL &&
EQUALN(oField.GetNameRef(), pszNfdcGeomField, strlen(pszNfdcGeomField)) &&
EQUAL(oField.GetNameRef() + strlen(pszNfdcGeomField), "LatitudeS") )
iNfdcLatitudeS = iField;
else if ( pszNfdcGeomField != NULL &&
EQUALN(oField.GetNameRef(), pszNfdcGeomField, strlen(pszNfdcGeomField)) &&
EQUAL(oField.GetNameRef() + strlen(pszNfdcGeomField), "LongitudeS") )
iNfdcLongitudeS = iField;
/* GNIS specific */
else if ( pszGeonamesGeomFieldPrefix != NULL &&
EQUALN(oField.GetNameRef(), pszGeonamesGeomFieldPrefix, strlen(pszGeonamesGeomFieldPrefix)) &&
(EQUAL(oField.GetNameRef() + strlen(pszGeonamesGeomFieldPrefix), "_LAT_DEC") ||
EQUAL(oField.GetNameRef() + strlen(pszGeonamesGeomFieldPrefix), "_LATITUDE_DEC") ||
EQUAL(oField.GetNameRef() + strlen(pszGeonamesGeomFieldPrefix), "_LATITUDE")) )
{
oField.SetType(OFTReal);
iLatitudeField = iField;
}
else if ( pszGeonamesGeomFieldPrefix != NULL &&
EQUALN(oField.GetNameRef(), pszGeonamesGeomFieldPrefix, strlen(pszGeonamesGeomFieldPrefix)) &&
(EQUAL(oField.GetNameRef() + strlen(pszGeonamesGeomFieldPrefix), "_LONG_DEC") ||
EQUAL(oField.GetNameRef() + strlen(pszGeonamesGeomFieldPrefix), "_LONGITUDE_DEC") ||
EQUAL(oField.GetNameRef() + strlen(pszGeonamesGeomFieldPrefix), "_LONGITUDE")) )
{
oField.SetType(OFTReal);
iLongitudeField = iField;
}
poFeatureDefn->AddFieldDefn( &oField );
}
if ( iNfdcLatitudeS != -1 && iNfdcLongitudeS != -1 )
{
bDontHonourStrings = TRUE;
poFeatureDefn->SetGeomType( wkbPoint );
}
else if ( iLatitudeField != -1 && iLongitudeField != -1 )
{
poFeatureDefn->SetGeomType( wkbPoint );
}
CSLDestroy( papszTokens );
CSLDestroy( papszFieldTypes );
}
GDALDataset *IDADataset::Open( GDALOpenInfo * poOpenInfo )
{
/* -------------------------------------------------------------------- */
/* Is this an IDA file? */
/* -------------------------------------------------------------------- */
int nXSize, nYSize;
GIntBig nExpectedFileSize, nActualFileSize;
if( poOpenInfo->fpL == NULL )
return NULL;
if( poOpenInfo->nHeaderBytes < 512 )
return NULL;
// projection legal?
if( poOpenInfo->pabyHeader[23] > 10 )
return NULL;
// imagetype legal?
if( (poOpenInfo->pabyHeader[22] > 14
&& poOpenInfo->pabyHeader[22] < 100)
|| (poOpenInfo->pabyHeader[22] > 114
&& poOpenInfo->pabyHeader[22] != 200 ) )
return NULL;
nXSize = poOpenInfo->pabyHeader[30] + poOpenInfo->pabyHeader[31] * 256;
nYSize = poOpenInfo->pabyHeader[32] + poOpenInfo->pabyHeader[33] * 256;
if( nXSize == 0 || nYSize == 0 )
return NULL;
// The file just be exactly the image size + header size in length.
nExpectedFileSize = nXSize * nYSize + 512;
VSIFSeekL( poOpenInfo->fpL, 0, SEEK_END );
nActualFileSize = VSIFTellL( poOpenInfo->fpL );
VSIRewindL( poOpenInfo->fpL );
if( nActualFileSize != nExpectedFileSize )
return NULL;
/* -------------------------------------------------------------------- */
/* Create the dataset. */
/* -------------------------------------------------------------------- */
IDADataset *poDS = new IDADataset();
memcpy( poDS->abyHeader, poOpenInfo->pabyHeader, 512 );
/* -------------------------------------------------------------------- */
/* Parse various values out of the header. */
/* -------------------------------------------------------------------- */
poDS->nImageType = poOpenInfo->pabyHeader[22];
poDS->nProjection = poOpenInfo->pabyHeader[23];
poDS->nRasterYSize = poOpenInfo->pabyHeader[30]
+ poOpenInfo->pabyHeader[31] * 256;
poDS->nRasterXSize = poOpenInfo->pabyHeader[32]
+ poOpenInfo->pabyHeader[33] * 256;
strncpy( poDS->szTitle, (const char *) poOpenInfo->pabyHeader+38, 80 );
poDS->szTitle[80] = '\0';
int nLastTitleChar = strlen(poDS->szTitle)-1;
while( nLastTitleChar > -1
&& (poDS->szTitle[nLastTitleChar] == 10
|| poDS->szTitle[nLastTitleChar] == 13
|| poDS->szTitle[nLastTitleChar] == ' ') )
poDS->szTitle[nLastTitleChar--] = '\0';
poDS->dfLatCenter = tp2c( poOpenInfo->pabyHeader + 120 );
poDS->dfLongCenter = tp2c( poOpenInfo->pabyHeader + 126 );
poDS->dfXCenter = tp2c( poOpenInfo->pabyHeader + 132 );
poDS->dfYCenter = tp2c( poOpenInfo->pabyHeader + 138 );
poDS->dfDX = tp2c( poOpenInfo->pabyHeader + 144 );
poDS->dfDY = tp2c( poOpenInfo->pabyHeader + 150 );
poDS->dfParallel1 = tp2c( poOpenInfo->pabyHeader + 156 );
poDS->dfParallel2 = tp2c( poOpenInfo->pabyHeader + 162 );
poDS->ProcessGeoref();
poDS->SetMetadataItem( "TITLE", poDS->szTitle );
/* -------------------------------------------------------------------- */
/* Handle various image types. */
/* -------------------------------------------------------------------- */
/*
GENERIC = 0
FEW S NDVI = 1
EROS NDVI = 6
ARTEMIS CUTOFF = 10
ARTEMIS RECODE = 11
ARTEMIS NDVI = 12
ARTEMIS FEWS = 13
ARTEMIS NEWNASA = 14
GENERIC DIFF = 100
FEW S NDVI DIFF = 101
EROS NDVI DIFF = 106
ARTEMIS CUTOFF DIFF = 110
ARTEMIS RECODE DIFF = 111
ARTEMIS NDVI DIFF = 112
ARTEMIS FEWS DIFF = 113
ARTEMIS NEWNASA DIFF = 114
CALCULATED =200
*/
poDS->nMissing = 0;
switch( poDS->nImageType )
{
case 1:
poDS->SetMetadataItem( "IMAGETYPE", "1, FEWS NDVI" );
poDS->dfM = 1/256.0;
poDS->dfB = -82/256.0;
break;
case 6:
poDS->SetMetadataItem( "IMAGETYPE", "6, EROS NDVI" );
poDS->dfM = 1/100.0;
poDS->dfB = -100/100.0;
break;
case 10:
poDS->SetMetadataItem( "IMAGETYPE", "10, ARTEMIS CUTOFF" );
poDS->dfM = 1.0;
poDS->dfB = 0.0;
poDS->nMissing = 254;
break;
case 11:
poDS->SetMetadataItem( "IMAGETYPE", "11, ARTEMIS RECODE" );
poDS->dfM = 4.0;
poDS->dfB = 0.0;
poDS->nMissing = 254;
break;
case 12: /* ANDVI */
poDS->SetMetadataItem( "IMAGETYPE", "12, ARTEMIS NDVI" );
poDS->dfM = 4/500.0;
poDS->dfB = -3/500.0 - 1.0;
poDS->nMissing = 254;
break;
case 13: /* AFEWS */
poDS->SetMetadataItem( "IMAGETYPE", "13, ARTEMIS FEWS" );
poDS->dfM = 1/256.0;
poDS->dfB = -82/256.0;
poDS->nMissing = 254;
break;
case 14: /* NEWNASA */
poDS->SetMetadataItem( "IMAGETYPE", "13, ARTEMIS NEWNASA" );
poDS->dfM = 0.75/250.0;
poDS->dfB = 0.0;
poDS->nMissing = 254;
break;
case 101: /* NDVI_DIFF (FEW S) */
poDS->dfM = 1/128.0;
poDS->dfB = -1.0;
poDS->nMissing = 0;
break;
case 106: /* EROS_DIFF */
poDS->dfM = 1/50.0;
poDS->dfB = -128/50.0;
poDS->nMissing = 0;
break;
case 110: /* CUTOFF_DIFF */
poDS->dfM = 2.0;
poDS->dfB = -128*2;
poDS->nMissing = 254;
break;
case 111: /* RECODE_DIFF */
poDS->dfM = 8;
poDS->dfB = -128*8;
poDS->nMissing = 254;
break;
case 112: /* ANDVI_DIFF */
poDS->dfM = 8/1000.0;
poDS->dfB = (-128*8)/1000.0;
poDS->nMissing = 254;
break;
case 113: /* AFEWS_DIFF */
poDS->dfM = 1/128.0;
poDS->dfB = -1;
poDS->nMissing = 254;
break;
case 114: /* NEWNASA_DIFF */
poDS->dfM = 0.75/125.0;
poDS->dfB = -128*poDS->dfM;
poDS->nMissing = 254;
break;
case 200:
/* we use the values from the header */
poDS->dfM = tp2c( poOpenInfo->pabyHeader + 171 );
poDS->dfB = tp2c( poOpenInfo->pabyHeader + 177 );
poDS->nMissing = poOpenInfo->pabyHeader[170];
break;
default:
poDS->dfM = 1.0;
poDS->dfB = 0.0;
break;
}
/* -------------------------------------------------------------------- */
/* Create the band. */
/* -------------------------------------------------------------------- */
if( poOpenInfo->eAccess == GA_ReadOnly )
{
poDS->fpRaw = poOpenInfo->fpL;
poOpenInfo->fpL = NULL;
}
else
{
poDS->fpRaw = VSIFOpenL( poOpenInfo->pszFilename, "rb+" );
poDS->eAccess = GA_Update;
if( poDS->fpRaw == NULL )
{
CPLError( CE_Failure, CPLE_OpenFailed,
"Failed to open %s for write access.",
poOpenInfo->pszFilename );
return NULL;
}
}
poDS->SetBand( 1, new IDARasterBand( poDS, poDS->fpRaw,
poDS->nRasterXSize ) );
/* -------------------------------------------------------------------- */
/* Check for a color table. */
/* -------------------------------------------------------------------- */
poDS->SetDescription( poOpenInfo->pszFilename );
poDS->ReadColorTable();
/* -------------------------------------------------------------------- */
/* Initialize any PAM information. */
/* -------------------------------------------------------------------- */
poDS->TryLoadXML();
/* -------------------------------------------------------------------- */
/* Check for overviews. */
/* -------------------------------------------------------------------- */
poDS->oOvManager.Initialize( poDS, poOpenInfo->pszFilename );
return( poDS );
}
void KML::checkValidity()
{
std::size_t nDone = 0;
std::size_t nLen = 0;
char aBuf[BUFSIZ] = { 0 };
if(poTrunk_ != NULL)
{
delete poTrunk_;
poTrunk_ = NULL;
}
if(poCurrent_ != NULL)
{
delete poCurrent_;
poCurrent_ = NULL;
}
if(pKMLFile_ == NULL)
{
this->sError_ = "No file given";
return;
}
XML_Parser oParser = OGRCreateExpatXMLParser();
XML_SetUserData(oParser, this);
XML_SetElementHandler(oParser, startElementValidate, NULL);
XML_SetCharacterDataHandler(oParser, dataHandlerValidate);
int nCount = 0;
oCurrentParser = oParser;
/* Parses the file until we find the first element */
do
{
nDataHandlerCounter = 0;
nLen = (int)VSIFReadL( aBuf, 1, sizeof(aBuf), pKMLFile_ );
nDone = VSIFEofL(pKMLFile_);
if (XML_Parse(oParser, aBuf, nLen, nDone) == XML_STATUS_ERROR)
{
if (nLen <= BUFSIZ-1)
aBuf[nLen] = 0;
else
aBuf[BUFSIZ-1] = 0;
if (strstr(aBuf, "<?xml") && strstr(aBuf, "<kml"))
{
CPLError(CE_Failure, CPLE_AppDefined,
"XML parsing of KML file failed : %s at line %d, column %d",
XML_ErrorString(XML_GetErrorCode(oParser)),
(int)XML_GetCurrentLineNumber(oParser),
(int)XML_GetCurrentColumnNumber(oParser));
}
validity = KML_VALIDITY_INVALID;
XML_ParserFree(oParser);
VSIRewindL(pKMLFile_);
return;
}
nCount ++;
/* After reading 50 * BUFSIZE bytes, and not finding whether the file */
/* is KML or not, we give up and fail silently */
} while (!nDone && nLen > 0 && validity == KML_VALIDITY_UNKNOWN && nCount < 50);
XML_ParserFree(oParser);
VSIRewindL(pKMLFile_);
poCurrent_ = NULL;
}
GDALOpenInfo::GDALOpenInfo( const char * pszFilenameIn, int nOpenFlagsIn,
char **papszSiblingsIn )
{
/* -------------------------------------------------------------------- */
/* Ensure that C: is treated as C:\ so we can stat it on */
/* Windows. Similar to what is done in CPLStat(). */
/* -------------------------------------------------------------------- */
#ifdef WIN32
if( strlen(pszFilenameIn) == 2 && pszFilenameIn[1] == ':' )
{
char szAltPath[10];
strcpy( szAltPath, pszFilenameIn );
strcat( szAltPath, "\\" );
pszFilename = CPLStrdup( szAltPath );
}
else
#endif
pszFilename = CPLStrdup( pszFilenameIn );
/* -------------------------------------------------------------------- */
/* Initialize. */
/* -------------------------------------------------------------------- */
nHeaderBytes = 0;
nHeaderBytesTried = 0;
pabyHeader = NULL;
bIsDirectory = FALSE;
bStatOK = FALSE;
nOpenFlags = nOpenFlagsIn;
eAccess = (nOpenFlags & GDAL_OF_UPDATE) ? GA_Update : GA_ReadOnly;
fpL = NULL;
papszOpenOptions = NULL;
#ifdef HAVE_READLINK
bool bHasRetried = false;
#endif
/* -------------------------------------------------------------------- */
/* Collect information about the file. */
/* -------------------------------------------------------------------- */
VSIStatBufL sStat;
#ifdef HAVE_READLINK
retry:
#endif
bool bPotentialDirectory = false;
/* Check if the filename might be a directory of a special virtual file system */
if( strncmp(pszFilename, "/vsizip/", strlen("/vsizip/")) == 0 ||
strncmp(pszFilename, "/vsitar/", strlen("/vsitar/")) == 0 )
{
const char* pszExt = CPLGetExtension(pszFilename);
if( EQUAL(pszExt, "zip") || EQUAL(pszExt, "tar") || EQUAL(pszExt, "gz") )
bPotentialDirectory = true;
}
else if( strncmp(pszFilename, "/vsicurl/", strlen("/vsicurl/")) == 0 )
{
bPotentialDirectory = true;
}
if( bPotentialDirectory )
{
/* For those special files, opening them with VSIFOpenL() might result */
/* in content, even if they should be considered as directories, so */
/* use stat */
if( VSIStatExL( pszFilename, &sStat,
VSI_STAT_EXISTS_FLAG | VSI_STAT_NATURE_FLAG ) == 0 )
{
bStatOK = TRUE;
if( VSI_ISDIR( sStat.st_mode ) )
bIsDirectory = TRUE;
}
}
if( !bIsDirectory )
fpL = VSIFOpenL( pszFilename, (eAccess == GA_Update) ? "r+b" : "rb" );
if( fpL != NULL )
{
bStatOK = TRUE;
pabyHeader = (GByte *) CPLCalloc(1025,1);
nHeaderBytesTried = 1024;
nHeaderBytes = (int) VSIFReadL( pabyHeader, 1, nHeaderBytesTried, fpL );
VSIRewindL( fpL );
/* If we cannot read anything, check if it is not a directory instead */
if( nHeaderBytes == 0 &&
VSIStatExL( pszFilename, &sStat,
VSI_STAT_EXISTS_FLAG | VSI_STAT_NATURE_FLAG ) == 0 &&
VSI_ISDIR( sStat.st_mode ) )
{
VSIFCloseL(fpL);
fpL = NULL;
CPLFree(pabyHeader);
pabyHeader = NULL;
bIsDirectory = TRUE;
}
}
else if( !bStatOK )
{
if( VSIStatExL( pszFilename, &sStat,
VSI_STAT_EXISTS_FLAG | VSI_STAT_NATURE_FLAG ) == 0 )
{
bStatOK = TRUE;
if( VSI_ISDIR( sStat.st_mode ) )
bIsDirectory = TRUE;
}
#ifdef HAVE_READLINK
else if ( !bHasRetried && strncmp(pszFilename, "/vsi", strlen("/vsi")) != 0 )
{
/* If someone creates a file with "ln -sf /vsicurl/http://download.osgeo.org/gdal/data/gtiff/utm.tif my_remote_utm.tif" */
/* we will be able to open it by passing my_remote_utm.tif */
/* This helps a lot for GDAL based readers that only provide file explorers to open datasets */
char szPointerFilename[2048];
int nBytes = readlink(pszFilename, szPointerFilename, sizeof(szPointerFilename));
if (nBytes != -1)
{
szPointerFilename[MIN(nBytes, (int)sizeof(szPointerFilename)-1)] = 0;
CPLFree(pszFilename);
pszFilename = CPLStrdup(szPointerFilename);
papszSiblingsIn = NULL;
bHasRetried = true;
goto retry;
}
}
#endif
}
/* -------------------------------------------------------------------- */
/* Capture sibling list either from passed in values, or by */
/* scanning for them only if requested through GetSiblingFiles(). */
/* -------------------------------------------------------------------- */
if( papszSiblingsIn != NULL )
{
papszSiblingFiles = CSLDuplicate( papszSiblingsIn );
bHasGotSiblingFiles = TRUE;
}
else if( bStatOK && !bIsDirectory )
{
const char* pszOptionVal =
CPLGetConfigOption( "GDAL_DISABLE_READDIR_ON_OPEN", "NO" );
if (EQUAL(pszOptionVal, "EMPTY_DIR"))
{
papszSiblingFiles = CSLAddString( NULL, CPLGetFilename(pszFilename) );
bHasGotSiblingFiles = TRUE;
}
else if( CSLTestBoolean(pszOptionVal) )
{
/* skip reading the directory */
papszSiblingFiles = NULL;
bHasGotSiblingFiles = TRUE;
}
else
{
/* will be lazy loaded */
papszSiblingFiles = NULL;
bHasGotSiblingFiles = FALSE;
}
}
else
{
papszSiblingFiles = NULL;
bHasGotSiblingFiles = TRUE;
}
}