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; } } }