void object::test<2>()
{
TestStringStruct apszTestStrings[] =
{
{ "+25.e+3", CPL_VALUE_REAL },
{ "-25.e-3", CPL_VALUE_REAL },
{ "25.e3", CPL_VALUE_REAL },
{ "25e3", CPL_VALUE_REAL },
{ " 25e3 ", CPL_VALUE_REAL },
{ "25", CPL_VALUE_INTEGER },
{ "-25", CPL_VALUE_INTEGER },
{ "+25", CPL_VALUE_INTEGER },
{ "25e 3", CPL_VALUE_STRING },
{ "25e.3", CPL_VALUE_STRING },
{ "-2-5e3", CPL_VALUE_STRING },
{ "2-5e3", CPL_VALUE_STRING },
{ "25.25.3", CPL_VALUE_STRING },
{ "25e25e3", CPL_VALUE_STRING },
};
size_t i;
for(i=0;i < sizeof(apszTestStrings) / sizeof(apszTestStrings[0]); i++)
{
ensure(CPLGetValueType(apszTestStrings[i].testString) == apszTestStrings[i].expectedResult);
if (CPLGetValueType(apszTestStrings[i].testString) != apszTestStrings[i].expectedResult)
fprintf(stderr, "mismatch on item %d : value=\"%s\", expect_result=%d, result=%d\n", (int)i,
apszTestStrings[i].testString,
apszTestStrings[i].expectedResult,
CPLGetValueType(apszTestStrings[i].testString));
}
}
void GMLPropertyDefn::AnalysePropertyValue( const GMLProperty* psGMLProperty,
int bSetWidth )
{
/* -------------------------------------------------------------------- */
/* Does the string consist entirely of numeric values? */
/* -------------------------------------------------------------------- */
int bIsReal = FALSE;
int j;
for(j=0;j<psGMLProperty->nSubProperties;j++)
{
if (j > 0)
{
if( m_eType == GMLPT_Integer )
m_eType = GMLPT_IntegerList;
else if( m_eType == GMLPT_Real )
m_eType = GMLPT_RealList;
else if( m_eType == GMLPT_String )
{
m_eType = GMLPT_StringList;
m_nWidth = 0;
}
}
const char* pszValue = psGMLProperty->papszSubProperties[j];
/* -------------------------------------------------------------------- */
/* If it is a zero length string, just return. We can't deduce */
/* much from this. */
/* -------------------------------------------------------------------- */
if( *pszValue == '\0' )
continue;
CPLValueType valueType = CPLGetValueType(pszValue);
/* This might not fit into a int32. For now, let's */
/* consider this as a real value then. */
/* FIXME once RFC31 / 64 bit support is set, we could */
/* choose a different behaviour */
if (valueType == CPL_VALUE_INTEGER && strlen(pszValue) >= 10)
{
/* Skip leading spaces */
while( isspace( (unsigned char)*pszValue ) )
pszValue ++;
char szVal[32];
sprintf(szVal, "%d", atoi(pszValue));
if (strcmp(pszValue, szVal) != 0)
valueType = CPL_VALUE_REAL;
}
if (valueType == CPL_VALUE_STRING
&& m_eType != GMLPT_String
&& m_eType != GMLPT_StringList )
{
if( m_eType == GMLPT_IntegerList
|| m_eType == GMLPT_RealList )
m_eType = GMLPT_StringList;
else
m_eType = GMLPT_String;
}
else
bIsReal = (valueType == CPL_VALUE_REAL);
if( m_eType == GMLPT_String )
{
if( bSetWidth )
{
/* grow the Width to the length of the string passed in */
int nWidth;
nWidth = strlen(pszValue);
if ( m_nWidth < nWidth )
SetWidth( nWidth );
}
}
else if( m_eType == GMLPT_Untyped || m_eType == GMLPT_Integer )
{
if( bIsReal )
m_eType = GMLPT_Real;
else
m_eType = GMLPT_Integer;
}
else if( m_eType == GMLPT_IntegerList && bIsReal )
{
m_eType = GMLPT_RealList;
}
}
}
int OGRGFTTableLayer::FetchDescribe()
{
poFeatureDefn = new OGRFeatureDefn( osTableName );
poFeatureDefn->Reference();
poFeatureDefn->GetGeomFieldDefn(0)->SetSpatialRef(poSRS);
const CPLString& osAuth = poDS->GetAccessToken();
std::vector<CPLString> aosHeaderAndFirstDataLine;
if (osAuth.size())
{
CPLString osSQL("DESCRIBE ");
osSQL += osTableId;
CPLHTTPResult * psResult = poDS->RunSQL(osSQL);
if (psResult == NULL)
return FALSE;
char* pszLine = (char*) psResult->pabyData;
if (pszLine == NULL ||
psResult->pszErrBuf != NULL ||
strncmp(pszLine, "column id,name,type",
strlen("column id,name,type")) != 0)
{
CPLHTTPDestroyResult(psResult);
return FALSE;
}
pszLine = OGRGFTGotoNextLine(pszLine);
std::vector<CPLString> aosLines;
ParseCSVResponse(pszLine, aosLines);
for(int i=0;i<(int)aosLines.size();i++)
{
char** papszTokens = OGRGFTCSVSplitLine(aosLines[i], ',');
if (CSLCount(papszTokens) == 3)
{
aosColumnInternalName.push_back(papszTokens[0]);
//CPLDebug("GFT", "%s %s %s", papszTokens[0], papszTokens[1], papszTokens[2]);
OGRFieldType eType = OFTString;
if (EQUAL(papszTokens[2], "number"))
eType = OFTReal;
else if (EQUAL(papszTokens[2], "datetime"))
eType = OFTDateTime;
if (EQUAL(papszTokens[2], "location") && osGeomColumnName.size() == 0)
{
if (iGeometryField < 0)
iGeometryField = poFeatureDefn->GetFieldCount();
else
CPLDebug("GFT", "Multiple geometry fields detected. "
"Only first encountered one is handled");
}
CPLString osLaunderedColName(LaunderColName(papszTokens[1]));
OGRFieldDefn oFieldDefn(osLaunderedColName, eType);
poFeatureDefn->AddFieldDefn(&oFieldDefn);
}
CSLDestroy(papszTokens);
}
CPLHTTPDestroyResult(psResult);
}
else
{
/* http://code.google.com/intl/fr/apis/fusiontables/docs/developers_guide.html#Exploring states */
/* that DESCRIBE should work on public tables without authentication, but it is not true... */
CPLString osSQL("SELECT * FROM ");
osSQL += osTableId;
osSQL += " OFFSET 0 LIMIT 1";
CPLHTTPResult * psResult = poDS->RunSQL(osSQL);
if (psResult == NULL)
return FALSE;
char* pszLine = (char*) psResult->pabyData;
if (pszLine == NULL || psResult->pszErrBuf != NULL)
{
CPLHTTPDestroyResult(psResult);
return FALSE;
}
ParseCSVResponse(pszLine, aosHeaderAndFirstDataLine);
if (aosHeaderAndFirstDataLine.size() > 0)
{
char** papszTokens = OGRGFTCSVSplitLine(aosHeaderAndFirstDataLine[0], ',');
for(int i=0;papszTokens && papszTokens[i];i++)
{
CPLString osLaunderedColName(LaunderColName(papszTokens[i]));
OGRFieldDefn oFieldDefn(osLaunderedColName, OFTString);
poFeatureDefn->AddFieldDefn(&oFieldDefn);
}
CSLDestroy(papszTokens);
}
CPLHTTPDestroyResult(psResult);
}
if (osGeomColumnName.size() > 0)
{
iGeometryField = poFeatureDefn->GetFieldIndex(osGeomColumnName);
if (iGeometryField < 0)
{
CPLError(CE_Warning, CPLE_AppDefined,
"Cannot find column called %s", osGeomColumnName.c_str());
}
}
for(int i=0;i<poFeatureDefn->GetFieldCount();i++)
{
const char* pszName = poFeatureDefn->GetFieldDefn(i)->GetNameRef();
if (EQUAL(pszName, "latitude") || EQUAL(pszName, "lat") ||
EQUAL(pszName, "latdec"))
iLatitudeField = i;
else if (EQUAL(pszName, "longitude") || EQUAL(pszName, "lon") ||
EQUAL(pszName, "londec") || EQUAL(pszName, "long"))
iLongitudeField = i;
}
if (iLatitudeField >= 0 && iLongitudeField >= 0)
{
if (iGeometryField < 0)
iGeometryField = iLatitudeField;
poFeatureDefn->GetFieldDefn(iLatitudeField)->SetType(OFTReal);
poFeatureDefn->GetFieldDefn(iLongitudeField)->SetType(OFTReal);
poFeatureDefn->SetGeomType( wkbPoint );
}
else if (iGeometryField < 0 && osGeomColumnName.size() == 0)
{
iLatitudeField = iLongitudeField = -1;
/* In the unauthentified case, we try to parse the first record to */
/* autodetect the geometry field */
OGRwkbGeometryType eType = wkbUnknown;
if (aosHeaderAndFirstDataLine.size() == 2)
{
char** papszTokens = OGRGFTCSVSplitLine(aosHeaderAndFirstDataLine[1], ',');
if (CSLCount(papszTokens) == poFeatureDefn->GetFieldCount())
{
for(int i=0;i<poFeatureDefn->GetFieldCount();i++)
{
const char* pszVal = papszTokens[i];
if (pszVal != NULL &&
(strncmp(pszVal, "<Point>", 7) == 0 ||
strncmp(pszVal, "<LineString>", 12) == 0 ||
strncmp(pszVal, "<Polygon>", 9) == 0 ||
strncmp(pszVal, "<MultiGeometry>", 15) == 0))
{
if (iGeometryField < 0)
{
iGeometryField = i;
}
else
{
CPLDebug("GFT", "Multiple geometry fields detected. "
"Only first encountered one is handled");
}
}
else if (pszVal)
{
/* http://www.google.com/fusiontables/DataSource?dsrcid=423292 */
char** papszTokens2 = CSLTokenizeString2(pszVal, " ,", 0);
if (CSLCount(papszTokens2) == 2 &&
CPLGetValueType(papszTokens2[0]) == CPL_VALUE_REAL &&
CPLGetValueType(papszTokens2[1]) == CPL_VALUE_REAL &&
fabs(CPLAtof(papszTokens2[0])) <= 90 &&
fabs(CPLAtof(papszTokens2[1])) <= 180 )
{
if (iGeometryField < 0)
{
iGeometryField = i;
eType = wkbPoint;
}
else
{
CPLDebug("GFT", "Multiple geometry fields detected. "
"Only first encountered one is handled");
}
}
CSLDestroy(papszTokens2);
}
}
}
CSLDestroy(papszTokens);
}
if (iGeometryField < 0)
poFeatureDefn->SetGeomType( wkbNone );
else
poFeatureDefn->SetGeomType( eType );
}
SetGeomFieldName();
return TRUE;
}
OGRFeature * OGRCSVLayer::GetNextUnfilteredFeature()
{
if (fpCSV == NULL)
return NULL;
/* -------------------------------------------------------------------- */
/* Read the CSV record. */
/* -------------------------------------------------------------------- */
char **papszTokens;
while(TRUE)
{
papszTokens = OGRCSVReadParseLineL( fpCSV, chDelimiter, bDontHonourStrings );
if( papszTokens == NULL )
return NULL;
if( papszTokens[0] != NULL )
break;
CSLDestroy(papszTokens);
}
/* -------------------------------------------------------------------- */
/* Create the OGR feature. */
/* -------------------------------------------------------------------- */
OGRFeature *poFeature;
poFeature = new OGRFeature( poFeatureDefn );
/* -------------------------------------------------------------------- */
/* Set attributes for any indicated attribute records. */
/* -------------------------------------------------------------------- */
int iAttr;
int nAttrCount = MIN(CSLCount(papszTokens),
poFeatureDefn->GetFieldCount() );
CPLValueType eType;
for( iAttr = 0; !bIsEurostatTSV && iAttr < nAttrCount; iAttr++)
{
if( iAttr == iWktGeomReadField && papszTokens[iAttr][0] != '\0' )
{
char *pszWKT = papszTokens[iAttr];
OGRGeometry *poGeom = NULL;
if( OGRGeometryFactory::createFromWkt( &pszWKT, NULL, &poGeom )
== OGRERR_NONE )
poFeature->SetGeometryDirectly( poGeom );
}
OGRFieldType eFieldType = poFeatureDefn->GetFieldDefn(iAttr)->GetType();
if ( eFieldType == OFTReal || eFieldType == OFTInteger )
{
if (chDelimiter == ';' && eFieldType == OFTReal)
{
char* chComma = strchr(papszTokens[iAttr], ',');
if (chComma)
*chComma = '.';
}
eType = CPLGetValueType(papszTokens[iAttr]);
if ( (papszTokens[iAttr][0] != '\0') &&
( eType == CPL_VALUE_INTEGER ||
eType == CPL_VALUE_REAL ) )
{
poFeature->SetField( iAttr, papszTokens[iAttr] );
}
}
else if (eFieldType != OFTString)
{
if (papszTokens[iAttr][0] != '\0')
poFeature->SetField( iAttr, papszTokens[iAttr] );
}
else
poFeature->SetField( iAttr, papszTokens[iAttr] );
}
/* -------------------------------------------------------------------- */
/* Eurostat TSV files. */
/* -------------------------------------------------------------------- */
for( iAttr = 0; bIsEurostatTSV && iAttr < nAttrCount; iAttr++)
{
if( iAttr == 0 )
{
char** papszDims = CSLTokenizeString2( papszTokens[0], ",", 0 );
if( CSLCount(papszDims) != nEurostatDims )
{
CSLDestroy(papszDims);
break;
}
for( int iSubAttr = 0; iSubAttr < nEurostatDims; iSubAttr ++ )
{
poFeature->SetField( iSubAttr, papszDims[iSubAttr] );
}
CSLDestroy(papszDims);
}
else
{
char** papszVals = CSLTokenizeString2( papszTokens[iAttr], " ", 0 );
eType = CPLGetValueType(papszVals[0]);
if ( (papszVals[0][0] != '\0') &&
( eType == CPL_VALUE_INTEGER ||
eType == CPL_VALUE_REAL ) )
{
poFeature->SetField( nEurostatDims + 2 * (iAttr - 1), papszVals[0] );
}
if( CSLCount(papszVals) == 2 )
{
poFeature->SetField( nEurostatDims + 2 * (iAttr - 1) + 1, papszVals[1] );
}
CSLDestroy(papszVals);
}
}
/* -------------------------------------------------------------------- */
/*http://www.faa.gov/airports/airport_safety/airportdata_5010/menu/index.cfm specific */
/* -------------------------------------------------------------------- */
if ( iNfdcLatitudeS != -1 &&
iNfdcLongitudeS != -1 &&
nAttrCount > iNfdcLatitudeS &&
nAttrCount > iNfdcLongitudeS &&
papszTokens[iNfdcLongitudeS][0] != 0 &&
papszTokens[iNfdcLatitudeS][0] != 0)
{
double dfLon = atof(papszTokens[iNfdcLongitudeS]) / 3600;
if (strchr(papszTokens[iNfdcLongitudeS], 'W'))
dfLon *= -1;
double dfLat = atof(papszTokens[iNfdcLatitudeS]) / 3600;
if (strchr(papszTokens[iNfdcLatitudeS], 'S'))
dfLat *= -1;
poFeature->SetGeometryDirectly( new OGRPoint(dfLon, dfLat) );
}
/* -------------------------------------------------------------------- */
/* GNIS specific */
/* -------------------------------------------------------------------- */
else if ( iLatitudeField != -1 &&
iLongitudeField != -1 &&
nAttrCount > iLatitudeField &&
nAttrCount > iLongitudeField &&
papszTokens[iLongitudeField][0] != 0 &&
papszTokens[iLatitudeField][0] != 0)
{
/* Some records have dummy 0,0 value */
if (papszTokens[iLongitudeField][0] != '0' ||
papszTokens[iLongitudeField][1] != '\0' ||
papszTokens[iLatitudeField][0] != '0' ||
papszTokens[iLatitudeField][1] != '\0')
{
double dfLon = atof(papszTokens[iLongitudeField]);
double dfLat = atof(papszTokens[iLatitudeField]);
poFeature->SetGeometryDirectly( new OGRPoint(dfLon, dfLat) );
}
}
CSLDestroy( papszTokens );
/* -------------------------------------------------------------------- */
/* Translate the record id. */
/* -------------------------------------------------------------------- */
poFeature->SetFID( nNextFID++ );
m_nFeaturesRead++;
return poFeature;
}
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 );
}
OGRFeature *OGRGFTLayer::BuildFeatureFromSQL(const char* pszLine)
{
OGRFeature* poFeature = new OGRFeature(poFeatureDefn);
char** papszTokens = OGRGFTCSVSplitLine(pszLine, ',');
int nTokens = CSLCount(papszTokens);
CPLString osFID;
int nAttrOffset = 0;
int iROWID = -1;
if (bFirstTokenIsFID)
{
osFID = papszTokens[0];
nAttrOffset = 1;
}
else
{
iROWID = poFeatureDefn->GetFieldIndex("rowid");
if (iROWID < 0)
iROWID = poFeatureDefn->GetFieldIndex("ROWID");
}
int nFieldCount = poFeatureDefn->GetFieldCount();
if (nTokens == nFieldCount + bHiddenGeometryField + nAttrOffset)
{
for(int i=0;i<nFieldCount+bHiddenGeometryField;i++)
{
const char* pszVal = papszTokens[i+nAttrOffset];
if (pszVal[0])
{
if (i<nFieldCount)
poFeature->SetField(i, pszVal);
if (i == iGeometryField && i != iLatitudeField)
{
if (pszVal[0] == '-' || (pszVal[0] >= '0' && pszVal[0] <= '9'))
{
char** papszLatLon = CSLTokenizeString2(pszVal, " ,", 0);
if (CSLCount(papszLatLon) == 2 &&
CPLGetValueType(papszLatLon[0]) != CPL_VALUE_STRING &&
CPLGetValueType(papszLatLon[1]) != CPL_VALUE_STRING)
{
OGRPoint* poPoint = new OGRPoint(CPLAtof( papszLatLon[1]),
CPLAtof( papszLatLon[0]));
poPoint->assignSpatialReference(poSRS);
poFeature->SetGeometryDirectly(poPoint);
}
CSLDestroy(papszLatLon);
}
else if (strstr(pszVal, "<Point>") ||
strstr(pszVal, "<LineString>") ||
strstr(pszVal, "<Polygon>"))
{
OGRGeometry* poGeom = ParseKMLGeometry(pszVal);
if (poGeom)
{
poGeom->assignSpatialReference(poSRS);
poFeature->SetGeometryDirectly(poGeom);
}
}
}
else if (i == iROWID)
{
osFID = pszVal;
}
}
}
if (iLatitudeField >= 0 && iLongitudeField >= 0)
{
const char* pszLat = papszTokens[iLatitudeField+nAttrOffset];
const char* pszLong = papszTokens[iLongitudeField+nAttrOffset];
if (pszLat[0] != 0 && pszLong[0] != 0 &&
CPLGetValueType(pszLat) != CPL_VALUE_STRING &&
CPLGetValueType(pszLong) != CPL_VALUE_STRING)
{
OGRPoint* poPoint = new OGRPoint(CPLAtof(pszLong), CPLAtof(pszLat));
poPoint->assignSpatialReference(poSRS);
poFeature->SetGeometryDirectly(poPoint);
}
}
}
else
{
CPLDebug("GFT", "Only %d columns for feature %s", nTokens, osFID.c_str());
}
CSLDestroy(papszTokens);
int nFID = atoi(osFID);
if (strcmp(CPLSPrintf("%d", nFID), osFID.c_str()) == 0)
poFeature->SetFID(nFID);
else
poFeature->SetFID(nNextInSeq);
return poFeature;
}
static GDALDataset *OGRARCGENDriverOpen( GDALOpenInfo* poOpenInfo )
{
if( poOpenInfo->eAccess == GA_Update ||
poOpenInfo->fpL == NULL )
{
return NULL;
}
/* Check that the first line is compatible with a generate file */
/* and in particular contain >= 32 && <= 127 bytes */
int i;
int bFoundEOL = FALSE;
char* szFirstLine = CPLStrdup((const char*) poOpenInfo->pabyHeader);
for(i=0;szFirstLine[i] != '\0';i++)
{
if (szFirstLine[i] == '\n' || szFirstLine[i] == '\r')
{
bFoundEOL = TRUE;
szFirstLine[i] = '\0';
break;
}
if (szFirstLine[i] < 32)
{
CPLFree(szFirstLine);
return NULL;
}
}
if (!bFoundEOL)
{
CPLFree(szFirstLine);
return NULL;
}
char** papszTokens = CSLTokenizeString2( szFirstLine, " ,", 0 );
int nTokens = CSLCount(papszTokens);
if (nTokens != 1 && nTokens != 3 && nTokens != 4)
{
CSLDestroy(papszTokens);
CPLFree(szFirstLine);
return NULL;
}
for(int i=0;i<nTokens;i++)
{
if( CPLGetValueType(papszTokens[i]) == CPL_VALUE_STRING )
{
CSLDestroy(papszTokens);
CPLFree(szFirstLine);
return NULL;
}
}
CSLDestroy(papszTokens);
CPLFree(szFirstLine);
OGRARCGENDataSource *poDS = new OGRARCGENDataSource();
if( !poDS->Open( poOpenInfo->pszFilename ) )
{
delete poDS;
poDS = NULL;
}
return poDS;
}
MAIN_START(argc, argv)
{
// Check that we are running against at least GDAL 1.5.
// Note to developers: if we use newer API, please change the requirement.
if (atoi(GDALVersionInfo("VERSION_NUM")) < 1500)
{
fprintf(stderr,
"At least, GDAL >= 1.5.0 is required for this version of %s, "
"which was compiled against GDAL %s\n",
argv[0], GDAL_RELEASE_NAME);
exit(1);
}
GDALAllRegister();
argc = GDALGeneralCmdLineProcessor( argc, &argv, 0 );
if( argc < 1 )
exit( -argc );
const char *pszSrcFilename = nullptr;
const char *pszDstFilename = nullptr;
int nOrder = 0;
void *hTransformArg;
GDALTransformerFunc pfnTransformer = nullptr;
int nGCPCount = 0;
GDAL_GCP *pasGCPs = nullptr;
int bInverse = FALSE;
CPLStringList aosTO;
int bOutputXY = FALSE;
double dfX = 0.0;
double dfY = 0.0;
double dfZ = 0.0;
double dfT = 0.0;
bool bCoordOnCommandLine = false;
/* -------------------------------------------------------------------- */
/* Parse arguments. */
/* -------------------------------------------------------------------- */
for( int i = 1; i < argc && argv[i] != nullptr; i++ )
{
if( EQUAL(argv[i], "--utility_version") )
{
printf("%s was compiled against GDAL %s and "
"is running against GDAL %s\n",
argv[0], GDAL_RELEASE_NAME, GDALVersionInfo("RELEASE_NAME"));
CSLDestroy(argv);
return 0;
}
else if( EQUAL(argv[i],"--help") )
{
Usage();
}
else if( EQUAL(argv[i],"-t_srs") )
{
CHECK_HAS_ENOUGH_ADDITIONAL_ARGS(1);
const char *pszSRS = argv[++i];
if( !IsValidSRS(pszSRS) )
exit(1);
aosTO.SetNameValue("DST_SRS", pszSRS );
}
else if( EQUAL(argv[i],"-s_srs") )
{
CHECK_HAS_ENOUGH_ADDITIONAL_ARGS(1);
const char *pszSRS = argv[++i];
if( !IsValidSRS(pszSRS) )
exit(1);
aosTO.SetNameValue("SRC_SRS", pszSRS );
}
else if( EQUAL(argv[i],"-ct") )
{
CHECK_HAS_ENOUGH_ADDITIONAL_ARGS(1);
const char *pszCT = argv[++i];
aosTO.SetNameValue("COORDINATE_OPERATION", pszCT );
}
else if( EQUAL(argv[i],"-order") )
{
CHECK_HAS_ENOUGH_ADDITIONAL_ARGS(1);
nOrder = atoi(argv[++i]);
aosTO.SetNameValue("MAX_GCP_ORDER", argv[i] );
}
else if( EQUAL(argv[i],"-tps") )
{
aosTO.SetNameValue("METHOD", "GCP_TPS" );
nOrder = -1;
}
else if( EQUAL(argv[i],"-rpc") )
{
aosTO.SetNameValue("METHOD", "RPC" );
}
else if( EQUAL(argv[i],"-geoloc") )
{
aosTO.SetNameValue("METHOD", "GEOLOC_ARRAY" );
}
else if( EQUAL(argv[i],"-i") )
{
bInverse = TRUE;
}
else if( EQUAL(argv[i],"-to") )
{
CHECK_HAS_ENOUGH_ADDITIONAL_ARGS(1);
aosTO.AddString( argv[++i] );
}
else if( EQUAL(argv[i],"-gcp") )
{
CHECK_HAS_ENOUGH_ADDITIONAL_ARGS(4);
char* endptr = nullptr;
/* -gcp pixel line easting northing [elev] */
nGCPCount++;
pasGCPs = static_cast<GDAL_GCP *>(
CPLRealloc(pasGCPs, sizeof(GDAL_GCP) * nGCPCount));
GDALInitGCPs( 1, pasGCPs + nGCPCount - 1 );
pasGCPs[nGCPCount-1].dfGCPPixel = CPLAtof(argv[++i]);
pasGCPs[nGCPCount-1].dfGCPLine = CPLAtof(argv[++i]);
pasGCPs[nGCPCount-1].dfGCPX = CPLAtof(argv[++i]);
pasGCPs[nGCPCount-1].dfGCPY = CPLAtof(argv[++i]);
if( argv[i+1] != nullptr &&
(CPLStrtod(argv[i+1], &endptr) != 0.0 || argv[i+1][0] == '0') )
{
// Check that last argument is really a number and not a
// filename looking like a number (see ticket #863).
if (endptr && *endptr == 0)
pasGCPs[nGCPCount-1].dfGCPZ = CPLAtof(argv[++i]);
}
/* should set id and info? */
}
else if( EQUAL(argv[i],"-output_xy") )
{
bOutputXY = TRUE;
}
else if( EQUAL(argv[i],"-coord") && i + 2 < argc)
{
bCoordOnCommandLine = true;
dfX = CPLAtof(argv[++i]);
dfY = CPLAtof(argv[++i]);
if( i + 1 < argc && CPLGetValueType(argv[i+1]) != CPL_VALUE_STRING )
dfZ = CPLAtof(argv[++i]);
if( i + 1 < argc && CPLGetValueType(argv[i+1]) != CPL_VALUE_STRING )
dfT = CPLAtof(argv[++i]);
}
else if( argv[i][0] == '-' )
{
Usage(CPLSPrintf("Unknown option name '%s'", argv[i]));
}
else if( pszSrcFilename == nullptr )
{
pszSrcFilename = argv[i];
}
else if( pszDstFilename == nullptr )
{
pszDstFilename = argv[i];
}
else
{
Usage("Too many command options.");
}
}
/* -------------------------------------------------------------------- */
/* Open src and destination file, if appropriate. */
/* -------------------------------------------------------------------- */
GDALDatasetH hSrcDS = nullptr;
if( pszSrcFilename != nullptr )
{
hSrcDS = GDALOpen( pszSrcFilename, GA_ReadOnly );
if( hSrcDS == nullptr )
exit( 1 );
}
GDALDatasetH hDstDS = nullptr;
if( pszDstFilename != nullptr )
{
hDstDS = GDALOpen( pszDstFilename, GA_ReadOnly );
if( hDstDS == nullptr )
exit( 1 );
}
if( hSrcDS != nullptr && nGCPCount > 0 )
{
fprintf(stderr,
"Command line GCPs and input file specified, "
"specify one or the other.\n");
exit( 1 );
}
/* -------------------------------------------------------------------- */
/* Create a transformation object from the source to */
/* destination coordinate system. */
/* -------------------------------------------------------------------- */
if( nGCPCount != 0 && nOrder == -1 )
{
pfnTransformer = GDALTPSTransform;
hTransformArg =
GDALCreateTPSTransformer( nGCPCount, pasGCPs, FALSE );
}
else if( nGCPCount != 0 )
{
pfnTransformer = GDALGCPTransform;
hTransformArg =
GDALCreateGCPTransformer( nGCPCount, pasGCPs, nOrder, FALSE );
}
else
{
pfnTransformer = GDALGenImgProjTransform;
hTransformArg =
GDALCreateGenImgProjTransformer2( hSrcDS, hDstDS, aosTO.List() );
}
if( hTransformArg == nullptr )
{
exit( 1 );
}
/* -------------------------------------------------------------------- */
/* Read points from stdin, transform and write to stdout. */
/* -------------------------------------------------------------------- */
double dfLastT = 0.0;
while( bCoordOnCommandLine || !feof(stdin) )
{
if( !bCoordOnCommandLine )
{
char szLine[1024];
if( fgets( szLine, sizeof(szLine)-1, stdin ) == nullptr )
break;
char **papszTokens = CSLTokenizeString(szLine);
const int nCount = CSLCount(papszTokens);
if( nCount < 2 )
{
CSLDestroy(papszTokens);
continue;
}
dfX = CPLAtof(papszTokens[0]);
dfY = CPLAtof(papszTokens[1]);
if( nCount >= 3 )
dfZ = CPLAtof(papszTokens[2]);
else
dfZ = 0.0;
if( nCount == 4 )
dfT = CPLAtof(papszTokens[3]);
else
dfT = 0.0;
CSLDestroy(papszTokens);
}
if( dfT != dfLastT && nGCPCount == 0 )
{
if( dfT != 0.0 )
{
aosTO.SetNameValue("COORDINATE_EPOCH", CPLSPrintf("%g", dfT));
}
else
{
aosTO.SetNameValue("COORDINATE_EPOCH", nullptr);
}
GDALDestroyGenImgProjTransformer(hTransformArg);
hTransformArg =
GDALCreateGenImgProjTransformer2( hSrcDS, hDstDS, aosTO.List() );
}
int bSuccess = TRUE;
if( pfnTransformer( hTransformArg, bInverse, 1,
&dfX, &dfY, &dfZ, &bSuccess )
&& bSuccess )
{
if( bOutputXY )
CPLprintf( "%.15g %.15g\n", dfX, dfY );
else
CPLprintf( "%.15g %.15g %.15g\n", dfX, dfY, dfZ );
}
else
{
printf( "transformation failed.\n" );
}
if( bCoordOnCommandLine )
break;
dfLastT = dfT;
}
if( nGCPCount != 0 && nOrder == -1 )
{
GDALDestroyTPSTransformer(hTransformArg);
}
else if( nGCPCount != 0 )
{
GDALDestroyGCPTransformer(hTransformArg);
}
else
{
GDALDestroyGenImgProjTransformer(hTransformArg);
}
if (nGCPCount)
{
GDALDeinitGCPs( nGCPCount, pasGCPs );
CPLFree( pasGCPs );
}
if (hSrcDS)
GDALClose(hSrcDS);
if (hDstDS)
GDALClose(hDstDS);
GDALDumpOpenDatasets( stderr );
GDALDestroyDriverManager();
CSLDestroy( argv );
return 0;
}
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 );
}
OGRFeatureDefn *OGRMySQLTableLayer::ReadTableDefinition( const char *pszTable )
{
MYSQL_RES *hResult;
CPLString osCommand;
/* -------------------------------------------------------------------- */
/* Fire off commands to get back the schema of the table. */
/* -------------------------------------------------------------------- */
osCommand.Printf("DESCRIBE `%s`", pszTable );
pszGeomColumnTable = CPLStrdup(pszTable);
if( mysql_query( poDS->GetConn(), osCommand ) )
{
poDS->ReportError( "DESCRIBE Failed" );
return NULL;
}
hResult = mysql_store_result( poDS->GetConn() );
if( hResult == NULL )
{
poDS->ReportError( "mysql_store_result() failed on DESCRIBE result." );
return NULL;
}
/* -------------------------------------------------------------------- */
/* Parse the returned table information. */
/* -------------------------------------------------------------------- */
OGRFeatureDefn *poDefn = new OGRFeatureDefn( pszTable );
char **papszRow;
OGRwkbGeometryType eForcedGeomType = wkbUnknown;
int bGeomColumnNotNullable = FALSE;
poDefn->Reference();
while( (papszRow = mysql_fetch_row( hResult )) != NULL )
{
const char *pszType;
OGRFieldDefn oField( papszRow[0], OFTString);
int nLenType;
pszType = papszRow[1];
if( pszType == NULL )
continue;
nLenType = (int)strlen(pszType);
if( EQUAL(pszType,"varbinary")
|| (nLenType>=4 && EQUAL(pszType+nLenType-4,"blob")))
{
oField.SetType( OFTBinary );
}
else if( EQUAL(pszType,"varchar")
|| (nLenType>=4 && EQUAL(pszType+nLenType-4,"enum"))
|| (nLenType>=3 && EQUAL(pszType+nLenType-3,"set")) )
{
oField.SetType( OFTString );
}
else if( STARTS_WITH_CI(pszType, "char") )
{
oField.SetType( OFTString );
char ** papszTokens;
papszTokens = CSLTokenizeString2(pszType,"(),",0);
if (CSLCount(papszTokens) >= 2)
{
/* width is the second */
oField.SetWidth(atoi(papszTokens[1]));
}
CSLDestroy( papszTokens );
oField.SetType( OFTString );
}
if(nLenType>=4 && EQUAL(pszType+nLenType-4,"text"))
{
oField.SetType( OFTString );
}
else if( STARTS_WITH_CI(pszType,"varchar") )
{
/*
pszType is usually in the form "varchar(15)"
so we'll split it up and get the width and precision
*/
oField.SetType( OFTString );
char ** papszTokens;
papszTokens = CSLTokenizeString2(pszType,"(),",0);
if (CSLCount(papszTokens) >= 2)
{
/* width is the second */
oField.SetWidth(atoi(papszTokens[1]));
}
CSLDestroy( papszTokens );
oField.SetType( OFTString );
}
else if( STARTS_WITH_CI(pszType, "int") )
{
oField.SetType( OFTInteger );
}
else if( STARTS_WITH_CI(pszType, "tinyint") )
{
oField.SetType( OFTInteger );
}
else if( STARTS_WITH_CI(pszType, "smallint") )
{
oField.SetType( OFTInteger );
}
else if( STARTS_WITH_CI(pszType, "mediumint") )
{
oField.SetType( OFTInteger );
}
else if( STARTS_WITH_CI(pszType, "bigint") )
{
oField.SetType( OFTInteger64 );
}
else if( STARTS_WITH_CI(pszType, "decimal") )
{
/*
pszType is usually in the form "decimal(15,2)"
so we'll split it up and get the width and precision
*/
oField.SetType( OFTReal );
char ** papszTokens;
papszTokens = CSLTokenizeString2(pszType,"(),",0);
if (CSLCount(papszTokens) >= 3)
{
/* width is the second and precision is the third */
oField.SetWidth(atoi(papszTokens[1]));
oField.SetPrecision(atoi(papszTokens[2]));
}
CSLDestroy( papszTokens );
}
else if( STARTS_WITH_CI(pszType, "float") )
{
oField.SetType( OFTReal );
}
else if( EQUAL(pszType,"double") )
{
oField.SetType( OFTReal );
}
else if( STARTS_WITH_CI(pszType, "double") )
{
// double can also be double(15,2)
// so we'll handle this case here after
// we check for just a regular double
// without a width and precision specified
char ** papszTokens=NULL;
papszTokens = CSLTokenizeString2(pszType,"(),",0);
if (CSLCount(papszTokens) >= 3)
{
/* width is the second and precision is the third */
oField.SetWidth(atoi(papszTokens[1]));
oField.SetPrecision(atoi(papszTokens[2]));
}
CSLDestroy( papszTokens );
oField.SetType( OFTReal );
}
else if( EQUAL(pszType,"decimal") )
{
oField.SetType( OFTReal );
}
else if( EQUAL(pszType, "date") )
{
oField.SetType( OFTDate );
}
else if( EQUAL(pszType, "time") )
{
oField.SetType( OFTTime );
}
else if( EQUAL(pszType, "datetime")
|| EQUAL(pszType, "timestamp") )
{
oField.SetType( OFTDateTime );
}
else if( EQUAL(pszType, "year") )
{
oField.SetType( OFTString );
oField.SetWidth( 10 );
}
else if( EQUAL(pszType, "geometry") ||
OGRFromOGCGeomType(pszType) != wkbUnknown)
{
if (pszGeomColumn == NULL)
{
pszGeomColumn = CPLStrdup(papszRow[0]);
eForcedGeomType = OGRFromOGCGeomType(pszType);
bGeomColumnNotNullable = ( papszRow[2] != NULL && EQUAL(papszRow[2], "NO") );
}
else
{
CPLDebug("MYSQL",
"Ignoring %s as geometry column. Another one(%s) has already been found before",
papszRow[0], pszGeomColumn);
}
continue;
}
// Is this an integer primary key field?
if( !bHasFid && papszRow[3] != NULL && EQUAL(papszRow[3],"PRI")
&& (oField.GetType() == OFTInteger || oField.GetType() == OFTInteger64) )
{
bHasFid = TRUE;
pszFIDColumn = CPLStrdup(oField.GetNameRef());
if( oField.GetType() == OFTInteger64 )
SetMetadataItem(OLMD_FID64, "YES");
continue;
}
// Is not nullable ?
if( papszRow[2] != NULL && EQUAL(papszRow[2], "NO") )
oField.SetNullable(FALSE);
// Has default ?
const char* pszDefault = papszRow[4];
if( pszDefault != NULL )
{
if( !EQUAL(pszDefault, "NULL") &&
!STARTS_WITH_CI(pszDefault, "CURRENT_") &&
pszDefault[0] != '(' &&
pszDefault[0] != '\'' &&
CPLGetValueType(pszDefault) == CPL_VALUE_STRING )
{
int nYear, nMonth, nDay, nHour, nMinute;
float fSecond;
if( oField.GetType() == OFTDateTime &&
sscanf(pszDefault, "%d-%d-%d %d:%d:%f", &nYear, &nMonth, &nDay,
&nHour, &nMinute, &fSecond) == 6 )
{
oField.SetDefault(CPLSPrintf("'%04d/%02d/%02d %02d:%02d:%02d'",
nYear, nMonth, nDay, nHour, nMinute, (int)(fSecond+0.5)));
}
else
{
CPLString osDefault("'");
char* pszTmp = CPLEscapeString(pszDefault, -1, CPLES_SQL);
osDefault += pszTmp;
CPLFree(pszTmp);
osDefault += "'";
oField.SetDefault(osDefault);
}
}
else
{
oField.SetDefault(pszDefault);
}
}
poDefn->AddFieldDefn( &oField );
}
// set to none for now... if we have a geometry column it will be set layer.
poDefn->SetGeomType( wkbNone );
if( hResult != NULL )
{
mysql_free_result( hResult );
hResultSet = NULL;
}
if( bHasFid )
CPLDebug( "MySQL", "table %s has FID column %s.",
pszTable, pszFIDColumn );
else
CPLDebug( "MySQL",
"table %s has no FID column, FIDs will not be reliable!",
pszTable );
if (pszGeomColumn)
{
char* pszType=NULL;
// set to unknown first
poDefn->SetGeomType( wkbUnknown );
osCommand = "SELECT type, coord_dimension FROM geometry_columns WHERE f_table_name='";
osCommand += pszTable;
osCommand += "'";
hResult = NULL;
if( !mysql_query( poDS->GetConn(), osCommand ) )
hResult = mysql_store_result( poDS->GetConn() );
papszRow = NULL;
if( hResult != NULL )
papszRow = mysql_fetch_row( hResult );
if( papszRow != NULL && papszRow[0] != NULL )
{
pszType = papszRow[0];
OGRwkbGeometryType l_nGeomType = OGRFromOGCGeomType(pszType);
if( papszRow[1] != NULL && atoi(papszRow[1]) == 3 )
l_nGeomType = wkbSetZ(l_nGeomType);
poDefn->SetGeomType( l_nGeomType );
}
else if (eForcedGeomType != wkbUnknown)
poDefn->SetGeomType(eForcedGeomType);
if( bGeomColumnNotNullable )
poDefn->GetGeomFieldDefn(0)->SetNullable(FALSE);
if( hResult != NULL )
mysql_free_result( hResult ); //Free our query results for finding type.
hResult = NULL;
}
// Fetch the SRID for this table now
nSRSId = FetchSRSId();
return poDefn;
}
int OGRARCGENDataSource::Open( const char * pszFilename, int bUpdateIn)
{
if (bUpdateIn)
{
return FALSE;
}
pszName = CPLStrdup( pszFilename );
// --------------------------------------------------------------------
// Does this appear to be a Arc/Info generate file?
// --------------------------------------------------------------------
VSILFILE* fp = VSIFOpenL(pszFilename, "rb");
if (fp == NULL)
return FALSE;
/* Check that the first line is compatible with a generate file */
/* and in particular contain >= 32 && <= 127 bytes */
char szFirstLine[256+1];
int nRet = VSIFReadL(szFirstLine, 1, 256, fp);
szFirstLine[nRet] = '\0';
int i;
int bFoundEOL = FALSE;
for(i=0;szFirstLine[i] != '\0';i++)
{
if (szFirstLine[i] == '\n' || szFirstLine[i] == '\r')
{
bFoundEOL = TRUE;
szFirstLine[i] = '\0';
break;
}
if (szFirstLine[i] < 32)
{
VSIFCloseL(fp);
return FALSE;
}
}
if (!bFoundEOL)
{
VSIFCloseL(fp);
return FALSE;
}
char** papszTokens = CSLTokenizeString2( szFirstLine, " ,", 0 );
int nTokens = CSLCount(papszTokens);
if (nTokens != 1 && nTokens != 3 && nTokens != 4)
{
VSIFCloseL(fp);
CSLDestroy(papszTokens);
return FALSE;
}
for(int i=0;i<nTokens;i++)
{
if( CPLGetValueType(papszTokens[i]) == CPL_VALUE_STRING )
{
VSIFCloseL(fp);
CSLDestroy(papszTokens);
return FALSE;
}
}
CSLDestroy(papszTokens);
/* Go to end of file, and count the number of END keywords */
/* If there's 1, it's a point layer */
/* If there's 2, it's a linestring or polygon layer */
VSIFSeekL( fp, 0, SEEK_END );
vsi_l_offset nSize = VSIFTellL(fp);
if (nSize < 10)
{
VSIFCloseL(fp);
return FALSE;
}
char szBuffer[10+1];
VSIFSeekL( fp, nSize - 10, SEEK_SET );
VSIFReadL( szBuffer, 1, 10, fp );
szBuffer[10] = '\0';
VSIFSeekL( fp, 0, SEEK_SET );
OGRwkbGeometryType eType;
const char* szPtr = szBuffer;
const char* szEnd = strstr(szPtr, "END");
if (szEnd == NULL) szEnd = strstr(szPtr, "end");
if (szEnd == NULL)
{
VSIFCloseL(fp);
return FALSE;
}
szPtr = szEnd + 3;
szEnd = strstr(szPtr, "END");
if (szEnd == NULL) szEnd = strstr(szPtr, "end");
if (szEnd == NULL)
{
const char* pszLine = CPLReadLine2L(fp,256,NULL);
if (pszLine == NULL)
{
VSIFCloseL(fp);
return FALSE;
}
char** papszTokens = CSLTokenizeString2( pszLine, " ,", 0 );
int nTokens = CSLCount(papszTokens);
CSLDestroy(papszTokens);
if (nTokens == 3)
eType = wkbPoint;
else if (nTokens == 4)
eType = wkbPoint25D;
else
{
VSIFCloseL(fp);
return FALSE;
}
}
else
{
int nLineNumber = 0;
eType = wkbUnknown;
CPLString osFirstX, osFirstY;
CPLString osLastX, osLastY;
int bIs3D = FALSE;
const char* pszLine;
while((pszLine = CPLReadLine2L(fp,256,NULL)) != NULL)
{
nLineNumber ++;
if (nLineNumber == 2)
{
char** papszTokens = CSLTokenizeString2( pszLine, " ,", 0 );
int nTokens = CSLCount(papszTokens);
if (nTokens == 2 || nTokens == 3)
{
if (nTokens == 3)
bIs3D = TRUE;
osFirstX = papszTokens[0];
osFirstY = papszTokens[1];
}
CSLDestroy(papszTokens);
if (nTokens != 2 && nTokens != 3)
break;
}
else if (nLineNumber > 2)
{
if (EQUAL(pszLine, "END"))
{
if (osFirstX.compare(osLastX) == 0 &&
osFirstY.compare(osLastY) == 0)
eType = (bIs3D) ? wkbPolygon25D : wkbPolygon;
else
eType = (bIs3D) ? wkbLineString25D : wkbLineString;
break;
}
char** papszTokens = CSLTokenizeString2( pszLine, " ,", 0 );
int nTokens = CSLCount(papszTokens);
if (nTokens == 2 || nTokens == 3)
{
osLastX = papszTokens[0];
osLastY = papszTokens[1];
}
CSLDestroy(papszTokens);
if (nTokens != 2 && nTokens != 3)
break;
}
}
if (eType == wkbUnknown)
{
VSIFCloseL(fp);
return FALSE;
}
}
VSIFSeekL( fp, 0, SEEK_SET );
nLayers = 1;
papoLayers = (OGRLayer**) CPLMalloc(sizeof(OGRLayer*));
papoLayers[0] = new OGRARCGENLayer(pszName, fp, eType);
return TRUE;
}
static int ArgIsNumeric( const char *pszArg )
{
return CPLGetValueType(pszArg) != CPL_VALUE_STRING;
}
void GMLPropertyDefn::AnalysePropertyValue( const GMLProperty* psGMLProperty,
int bSetWidth )
{
/* -------------------------------------------------------------------- */
/* Does the string consist entirely of numeric values? */
/* -------------------------------------------------------------------- */
int bIsReal = FALSE;
int j;
for(j=0; j<psGMLProperty->nSubProperties; j++)
{
if (j > 0)
{
if( m_eType == GMLPT_Integer )
m_eType = GMLPT_IntegerList;
else if( m_eType == GMLPT_Integer64 )
m_eType = GMLPT_Integer64List;
else if( m_eType == GMLPT_Real )
m_eType = GMLPT_RealList;
else if( m_eType == GMLPT_String )
{
m_eType = GMLPT_StringList;
m_nWidth = 0;
}
else if( m_eType == GMLPT_Boolean )
m_eType = GMLPT_BooleanList;
}
const char* pszValue = psGMLProperty->papszSubProperties[j];
/* -------------------------------------------------------------------- */
/* If it is a zero length string, just return. We can't deduce */
/* much from this. */
/* -------------------------------------------------------------------- */
if( *pszValue == '\0' )
continue;
CPLValueType valueType = CPLGetValueType(pszValue);
if (valueType == CPL_VALUE_STRING
&& m_eType != GMLPT_String
&& m_eType != GMLPT_StringList )
{
if( (m_eType == GMLPT_Untyped || m_eType == GMLPT_Boolean) &&
(strcmp(pszValue, "true") == 0 ||
strcmp(pszValue, "false") == 0) )
m_eType = GMLPT_Boolean;
else if( m_eType == GMLPT_BooleanList )
{
if( !(strcmp(pszValue, "true") == 0 ||
strcmp(pszValue, "false") == 0) )
m_eType = GMLPT_StringList;
}
else if( m_eType == GMLPT_IntegerList ||
m_eType == GMLPT_Integer64List ||
m_eType == GMLPT_RealList )
m_eType = GMLPT_StringList;
else
m_eType = GMLPT_String;
}
else
bIsReal = (valueType == CPL_VALUE_REAL);
if( m_eType == GMLPT_String )
{
if( bSetWidth )
{
/* grow the Width to the length of the string passed in */
int nWidth;
nWidth = strlen(pszValue);
if ( m_nWidth < nWidth )
SetWidth( nWidth );
}
}
else if( m_eType == GMLPT_Untyped || m_eType == GMLPT_Integer ||
m_eType == GMLPT_Integer64 )
{
if( bIsReal )
m_eType = GMLPT_Real;
else if( m_eType != GMLPT_Integer64 )
{
GIntBig nVal = CPLAtoGIntBig(pszValue);
if( (GIntBig)(int)nVal != nVal )
m_eType = GMLPT_Integer64;
else
m_eType = GMLPT_Integer;
}
}
else if( (m_eType == GMLPT_IntegerList ||
m_eType == GMLPT_Integer64List) && bIsReal )
{
m_eType = GMLPT_RealList;
}
else if( m_eType == GMLPT_IntegerList && valueType == CPL_VALUE_INTEGER )
{
GIntBig nVal = CPLAtoGIntBig(pszValue);
if( (GIntBig)(int)nVal != nVal )
m_eType = GMLPT_Integer64List;
}
}
}