OGRFeature* OGRUnionLayer::TranslateFromSrcLayer(OGRFeature* poSrcFeature)
{
CPLAssert(panMap != NULL);
CPLAssert(iCurLayer >= 0 && iCurLayer < nSrcLayers);
OGRFeature* poFeature = new OGRFeature(poFeatureDefn);
poFeature->SetFrom(poSrcFeature, panMap, TRUE);
if( osSourceLayerFieldName.size() &&
!poFeatureDefn->GetFieldDefn(0)->IsIgnored() )
{
poFeature->SetField(0, papoSrcLayers[iCurLayer]->GetName());
}
for(int i=0;i<poFeatureDefn->GetGeomFieldCount();i++)
{
if( poFeatureDefn->GetGeomFieldDefn(i)->IsIgnored() )
poFeature->SetGeomFieldDirectly(i, NULL);
else
{
OGRGeometry* poGeom = poFeature->GetGeomFieldRef(i);
if( poGeom != NULL )
{
poGeom->assignSpatialReference(
poFeatureDefn->GetGeomFieldDefn(i)->GetSpatialRef());
}
}
}
if( bPreserveSrcFID )
poFeature->SetFID(poSrcFeature->GetFID());
else
poFeature->SetFID(nNextFID ++);
return poFeature;
}
bool GDBGeometryToOGRGeometry(bool forceMulti, FileGDBAPI::ShapeBuffer* pGdbGeometry,
OGRSpatialReference* pOGRSR, OGRGeometry** ppOutGeometry)
{
OGRGeometry* pOGRGeometry = nullptr;
OGRErr eErr = OGRCreateFromShapeBin( pGdbGeometry->shapeBuffer,
&pOGRGeometry,
static_cast<int>(pGdbGeometry->inUseLength));
//OGRErr eErr = OGRGeometryFactory::createFromWkb(pGdbGeometry->shapeBuffer, pOGRSR, &pOGRGeometry, pGdbGeometry->inUseLength );
if (eErr != OGRERR_NONE)
{
CPLError( CE_Failure, CPLE_AppDefined, "Failed attempting to import GDB WKB Geometry. OGRGeometryFactory err:%d", eErr);
return false;
}
if( pOGRGeometry != nullptr )
{
// force geometries to multi if requested
// If it is a polygon, force to MultiPolygon since we always produce multipolygons
OGRwkbGeometryType eFlattenType = wkbFlatten(pOGRGeometry->getGeometryType());
if (eFlattenType == wkbPolygon)
{
pOGRGeometry = OGRGeometryFactory::forceToMultiPolygon(pOGRGeometry);
}
else if (eFlattenType == wkbCurvePolygon)
{
OGRMultiSurface* poMS = new OGRMultiSurface();
poMS->addGeometryDirectly( pOGRGeometry );
pOGRGeometry = poMS;
}
else if (forceMulti)
{
if (eFlattenType == wkbLineString)
{
pOGRGeometry = OGRGeometryFactory::forceToMultiLineString(pOGRGeometry);
}
else if (eFlattenType == wkbCompoundCurve)
{
OGRMultiCurve* poMC = new OGRMultiCurve();
poMC->addGeometryDirectly( pOGRGeometry );
pOGRGeometry = poMC;
}
else if (eFlattenType == wkbPoint)
{
pOGRGeometry = OGRGeometryFactory::forceToMultiPoint(pOGRGeometry);
}
}
if (pOGRGeometry)
pOGRGeometry->assignSpatialReference( pOGRSR );
}
*ppOutGeometry = pOGRGeometry;
return true;
}
OGRFeature *OGRAeronavFAANAVAIDLayer::GetNextRawFeature()
{
char szBuffer[134];
while( true )
{
const char* pszLine = CPLReadLine2L(fpAeronavFAA, 134, nullptr);
if (pszLine == nullptr)
{
bEOF = true;
return nullptr;
}
if (strlen(pszLine) != 132)
continue;
if ( !(pszLine[psRecordDesc->nLatStartCol-1] == 'N' ||
pszLine[psRecordDesc->nLatStartCol-1] == 'S') )
continue;
if ( !(pszLine[psRecordDesc->nLonStartCol-1] == 'E' ||
pszLine[psRecordDesc->nLonStartCol-1] == 'W') )
continue;
OGRFeature* poFeature = new OGRFeature(poFeatureDefn);
poFeature->SetFID(nNextFID ++);
for( int i=0; i < psRecordDesc->nFields; i++ )
{
int nWidth = psRecordDesc->pasFields[i].nLastCol - psRecordDesc->pasFields[i].nStartCol + 1;
strncpy(szBuffer, pszLine + psRecordDesc->pasFields[i].nStartCol - 1, nWidth);
szBuffer[nWidth] = 0;
while(nWidth > 0 && szBuffer[nWidth - 1] == ' ')
{
szBuffer[nWidth - 1] = 0;
nWidth --;
}
if (nWidth != 0)
poFeature->SetField(i, szBuffer);
}
double dfLat = 0.0;
double dfLon = 0.0;
GetLatLon(pszLine + psRecordDesc->nLatStartCol - 1,
pszLine + psRecordDesc->nLonStartCol - 1,
dfLat,
dfLon);
OGRGeometry* poGeom = new OGRPoint(dfLon, dfLat);
poGeom->assignSpatialReference(poSRS);
poFeature->SetGeometryDirectly( poGeom );
return poFeature;
}
}
/*!
\brief Get feature (private)
\return pointer to OGRFeature
\return NULL not found
*/
OGRFeature *OGRVFKLayer::GetFeature(VFKFeature *poVFKFeature)
{
OGRGeometry *poGeom;
/* skip feature with unknown geometry type */
if (poVFKFeature->GetGeometryType() == wkbUnknown)
return NULL;
/* get features geometry */
poGeom = CreateGeometry(poVFKFeature);
if (poGeom != NULL)
poGeom->assignSpatialReference(poSRS);
/* does it satisfy the spatial query, if there is one? */
if (m_poFilterGeom != NULL && poGeom && !FilterGeometry(poGeom)) {
return NULL;
}
/* convert the whole feature into an OGRFeature */
OGRFeature *poOGRFeature = new OGRFeature(GetLayerDefn());
poOGRFeature->SetFID(poVFKFeature->GetFID());
// poOGRFeature->SetFID(++m_iNextFeature);
for (int iField = 0; iField < poDataBlock->GetPropertyCount(); iField++) {
if (poVFKFeature->GetProperty(iField)->IsNull())
continue;
OGRFieldType fType = poOGRFeature->GetDefnRef()->GetFieldDefn(iField)->GetType();
if (fType == OFTInteger)
poOGRFeature->SetField(iField,
poVFKFeature->GetProperty(iField)->GetValueI());
else if (fType == OFTReal)
poOGRFeature->SetField(iField,
poVFKFeature->GetProperty(iField)->GetValueD());
else
poOGRFeature->SetField(iField,
poVFKFeature->GetProperty(iField)->GetValueS());
}
/* test against the attribute query */
if (m_poAttrQuery != NULL &&
!m_poAttrQuery->Evaluate(poOGRFeature)) {
delete poOGRFeature;
return NULL;
}
if (poGeom)
poOGRFeature->SetGeometryDirectly(poGeom->clone());
return poOGRFeature;
}
bool GDBGeometryToOGRGeometry(bool forceMulti, FileGDBAPI::ShapeBuffer* pGdbGeometry,
OGRSpatialReference* pOGRSR, OGRGeometry** ppOutGeometry)
{
OGRGeometry* pOGRGeometry = NULL;
OGRErr eErr = OGRCreateFromShapeBin( pGdbGeometry->shapeBuffer,
&pOGRGeometry,
pGdbGeometry->inUseLength);
//OGRErr eErr = OGRGeometryFactory::createFromWkb(pGdbGeometry->shapeBuffer, pOGRSR, &pOGRGeometry, pGdbGeometry->inUseLength );
if (eErr != OGRERR_NONE)
{
CPLError( CE_Failure, CPLE_AppDefined, "Failed attempting to import GDB WKB Geometry. OGRGeometryFactory err:%d", eErr);
return false;
}
if( pOGRGeometry != NULL )
{
// force geometries to multi if requested
// If it is a polygon, force to MultiPolygon since we always produce multipolygons
if (wkbFlatten(pOGRGeometry->getGeometryType()) == wkbPolygon)
{
pOGRGeometry = OGRGeometryFactory::forceToMultiPolygon(pOGRGeometry);
}
else if (forceMulti)
{
if (wkbFlatten(pOGRGeometry->getGeometryType()) == wkbLineString)
{
pOGRGeometry = OGRGeometryFactory::forceToMultiLineString(pOGRGeometry);
}
else if (wkbFlatten(pOGRGeometry->getGeometryType()) == wkbPoint)
{
pOGRGeometry = OGRGeometryFactory::forceToMultiPoint(pOGRGeometry);
}
}
if (pOGRGeometry)
pOGRGeometry->assignSpatialReference( pOGRSR );
}
*ppOutGeometry = pOGRGeometry;
return true;
}
int OGROSMLayer::AddFeature(OGRFeature* poFeature,
int bAttrFilterAlreadyEvaluated,
int* pbFilteredOut,
int bCheckFeatureThreshold)
{
if( !bUserInterested )
{
if (pbFilteredOut)
*pbFilteredOut = TRUE;
delete poFeature;
return TRUE;
}
OGRGeometry* poGeom = poFeature->GetGeometryRef();
if (poGeom)
poGeom->assignSpatialReference( poSRS );
if( (m_poFilterGeom == NULL
|| FilterGeometry( poFeature->GetGeometryRef() ) )
&& (m_poAttrQuery == NULL || bAttrFilterAlreadyEvaluated
|| m_poAttrQuery->Evaluate( poFeature )) )
{
if (!AddToArray(poFeature, bCheckFeatureThreshold))
{
delete poFeature;
return FALSE;
}
}
else
{
if (pbFilteredOut)
*pbFilteredOut = TRUE;
delete poFeature;
return TRUE;
}
if (pbFilteredOut)
*pbFilteredOut = FALSE;
return TRUE;
}
/*!
\brief Get feature (private)
\return pointer to OGRFeature or NULL not found
*/
OGRFeature *OGRVFKLayer::GetFeature(IVFKFeature *poVFKFeature)
{
OGRGeometry *poGeom;
/* skip feature with unknown geometry type */
if (poVFKFeature->GetGeometryType() == wkbUnknown)
return NULL;
/* get features geometry */
poGeom = CreateGeometry(poVFKFeature);
if (poGeom != NULL)
poGeom->assignSpatialReference(poSRS);
/* does it satisfy the spatial query, if there is one? */
if (m_poFilterGeom != NULL && poGeom && !FilterGeometry(poGeom)) {
return NULL;
}
/* convert the whole feature into an OGRFeature */
OGRFeature *poOGRFeature = new OGRFeature(GetLayerDefn());
poOGRFeature->SetFID(poVFKFeature->GetFID());
// poOGRFeature->SetFID(++m_iNextFeature);
poVFKFeature->LoadProperties(poOGRFeature);
/* test against the attribute query */
if (m_poAttrQuery != NULL &&
!m_poAttrQuery->Evaluate(poOGRFeature)) {
delete poOGRFeature;
return NULL;
}
if (poGeom)
poOGRFeature->SetGeometryDirectly(poGeom->clone());
return poOGRFeature;
}
OGRFeature *OGRSEGP1Layer::GetNextRawFeature()
{
if( bEOF )
return nullptr;
const char* pszLine = nullptr;
while( true )
{
pszLine = CPLReadLine2L(fp,81,nullptr);
if (pszLine == nullptr || STARTS_WITH_CI(pszLine, "EOF"))
{
bEOF = true;
return nullptr;
}
int nLineLen = static_cast<int>(strlen(pszLine));
while(nLineLen > 0 && pszLine[nLineLen-1] == ' ')
{
((char*)pszLine)[nLineLen-1] = '\0';
nLineLen --;
}
char* pszExpandedLine = ExpandTabs(pszLine);
pszLine = pszExpandedLine;
nLineLen = static_cast<int>(strlen(pszLine));
OGRFeature* poFeature = new OGRFeature(poFeatureDefn);
poFeature->SetFID(nNextFID ++);
OGRGeometry* poGeom = nullptr;
if (nLatitudeCol-1 + 19 <= nLineLen)
{
char szDeg[3+1];
char szMin[2+1];
char szSec[4+1];
ExtractField(szDeg, pszLine, nLatitudeCol-1, 2);
ExtractField(szMin, pszLine, nLatitudeCol+2-1, 2);
ExtractField(szSec, pszLine, nLatitudeCol+2+2-1, 4);
double dfLat = atoi(szDeg) + atoi(szMin) / 60.0 + atoi(szSec) / 100.0 / 3600.0;
if (pszLine[nLatitudeCol+2+2+4-1] == 'S')
dfLat = -dfLat;
poFeature->SetField(SEGP1_FIELD_LATITUDE, dfLat);
ExtractField(szDeg, pszLine, nLatitudeCol+9-1, 3);
ExtractField(szMin, pszLine, nLatitudeCol+9+3-1, 2);
ExtractField(szSec, pszLine, nLatitudeCol+9+3+2-1, 4);
double dfLon = atoi(szDeg) + atoi(szMin) / 60.0 + atoi(szSec) / 100.0 / 3600.0;
if (pszLine[nLatitudeCol+9+3+2+4-1] == 'W')
dfLon = -dfLon;
poFeature->SetField(SEGP1_FIELD_LONGITUDE, dfLon);
if (!bUseEastingNorthingAsGeometry)
poGeom = new OGRPoint(dfLon, dfLat);
}
/* Normal layout -> extract other fields */
if (nLatitudeCol == 27 && nLineLen >= 26-1+1)
{
char szLineName[16 + 1];
ExtractField(szLineName, pszLine, 2-1, 16);
int i = 15;
while (i >= 0)
{
if (szLineName[i] == ' ')
szLineName[i] = '\0';
else
break;
i --;
}
poFeature->SetField(SEGP1_FIELD_LINENAME, szLineName);
char szPointNumber[8+1];
ExtractField(szPointNumber, pszLine, 18-1, 8);
poFeature->SetField(SEGP1_FIELD_POINTNUMBER, atoi(szPointNumber));
char szReshootCode[1+1];
ExtractField(szReshootCode, pszLine, 26-1, 1);
poFeature->SetField(SEGP1_FIELD_RESHOOTCODE, szReshootCode);
if (nLineLen >= 61)
{
char szEasting[8+1];
ExtractField(szEasting, pszLine, 46-1, 8);
double dfEasting = CPLAtof(szEasting);
poFeature->SetField(SEGP1_FIELD_EASTING, dfEasting);
char szNorthing[8+1];
ExtractField(szNorthing, pszLine, 54-1, 8);
double dfNorthing = CPLAtof(szNorthing);
poFeature->SetField(SEGP1_FIELD_NORTHING, dfNorthing);
if (bUseEastingNorthingAsGeometry)
poGeom = new OGRPoint(dfEasting, dfNorthing);
}
if (nLineLen >= 66)
{
char szDepth[5+1];
ExtractField(szDepth, pszLine, 62-1, 5);
double dfDepth = CPLAtof(szDepth);
poFeature->SetField(SEGP1_FIELD_DEPTH, dfDepth);
}
}
if (poGeom)
{
if (poSRS)
poGeom->assignSpatialReference(poSRS);
poFeature->SetGeometryDirectly(poGeom);
}
CPLFree(pszExpandedLine);
return poFeature;
}
}
OGRFeature *OGRUKOOAP190Layer::GetNextRawFeature()
{
if( bEOF )
return nullptr;
while( true )
{
const char* pszLine = CPLReadLine2L(fp, 81, nullptr);
if (pszLine == nullptr || STARTS_WITH_CI(pszLine, "EOF"))
{
bEOF = true;
return nullptr;
}
int nLineLen = static_cast<int>(strlen(pszLine));
while(nLineLen > 0 && pszLine[nLineLen-1] == ' ')
{
((char*)pszLine)[nLineLen-1] = '\0';
nLineLen --;
}
if (pszLine[0] == 'H' || nLineLen < 46)
continue;
OGRFeature* poFeature = new OGRFeature(poFeatureDefn);
poFeature->SetFID(nNextFID ++);
char szLineName[12 + 1];
ExtractField(szLineName, pszLine, 2-1, 12);
int i = 11;
while (i >= 0)
{
if (szLineName[i] == ' ')
szLineName[i] = '\0';
else
break;
i --;
}
poFeature->SetField(FIELD_LINENAME, szLineName);
char szVesselId[1+1];
szVesselId[0] = pszLine[17-1];
if (szVesselId[0] != ' ')
{
szVesselId[1] = '\0';
poFeature->SetField(FIELD_VESSEL_ID, szVesselId);
}
char szSourceId[1+1];
szSourceId[0] = pszLine[18-1];
if (szSourceId[0] != ' ')
{
szSourceId[1] = '\0';
poFeature->SetField(FIELD_SOURCE_ID, szSourceId);
}
char szOtherId[1+1];
szOtherId[0] = pszLine[19-1];
if (szOtherId[0] != ' ')
{
szOtherId[1] = '\0';
poFeature->SetField(FIELD_OTHER_ID, szOtherId);
}
char szPointNumber[6+1];
ExtractField(szPointNumber, pszLine, 20-1, 6);
poFeature->SetField(4, atoi(szPointNumber));
char szDeg[3+1];
char szMin[2+1];
char szSec[5+1];
ExtractField(szDeg, pszLine, 26-1, 2);
ExtractField(szMin, pszLine, 26+2-1, 2);
ExtractField(szSec, pszLine, 26+2+2-1, 5);
double dfLat = atoi(szDeg) + atoi(szMin) / 60.0 + CPLAtof(szSec) / 3600.0;
if (pszLine[26+2+2+5-1] == 'S')
dfLat = -dfLat;
poFeature->SetField(FIELD_LATITUDE, dfLat);
ExtractField(szDeg, pszLine, 36-1, 3);
ExtractField(szMin, pszLine, 36+3-1, 2);
ExtractField(szSec, pszLine, 36+3+2-1, 5);
double dfLon = atoi(szDeg) + atoi(szMin) / 60.0 + CPLAtof(szSec) / 3600.0;
if (pszLine[36+3+2+5-1] == 'W')
dfLon = -dfLon;
poFeature->SetField(FIELD_LONGITUDE, dfLon);
OGRGeometry* poGeom = nullptr;
if (!bUseEastingNorthingAsGeometry)
poGeom = new OGRPoint(dfLon, dfLat);
if (nLineLen >= 64)
{
char szEasting[9+1];
ExtractField(szEasting, pszLine, 47-1, 9);
double dfEasting = CPLAtof(szEasting);
poFeature->SetField(FIELD_EASTING, dfEasting);
char szNorthing[9+1];
ExtractField(szNorthing, pszLine, 56-1, 9);
double dfNorthing = CPLAtof(szNorthing);
poFeature->SetField(FIELD_NORTHING, dfNorthing);
if (bUseEastingNorthingAsGeometry)
poGeom = new OGRPoint(dfEasting, dfNorthing);
}
if (poGeom)
{
if (poSRS)
poGeom->assignSpatialReference(poSRS);
poFeature->SetGeometryDirectly(poGeom);
}
if (nLineLen >= 70)
{
char szDepth[6+1];
ExtractField(szDepth, pszLine, 65-1, 6);
double dfDepth = CPLAtof(szDepth);
poFeature->SetField(FIELD_DEPTH, dfDepth);
}
int nDayOfYear = 0;
if (nLineLen >= 73)
{
char szDayOfYear[3+1];
ExtractField(szDayOfYear, pszLine, 71-1, 3);
nDayOfYear = atoi(szDayOfYear);
poFeature->SetField(FIELD_DAYOFYEAR, nDayOfYear);
}
if (nLineLen >= 79)
{
char szH[2+1], szM[2+1], szS[2+1];
ExtractField(szH, pszLine, 74-1, 2);
ExtractField(szM, pszLine, 74-1+2, 2);
ExtractField(szS, pszLine, 74-1+2+2, 2);
poFeature->SetField(FIELD_TIME, 0, 0, 0, atoi(szH), atoi(szM), static_cast<float>(atoi(szS)) );
if( nYear != 0 )
{
constexpr int mon_lengths[2][12] = {
{31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31},
{31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31}
} ;
const bool bIsLeap = isleap(nYear);
int nMonth = 0;
int nDays = 0;
if ((bIsLeap && nDayOfYear >= 1 && nDayOfYear <= 366) ||
(!bIsLeap && nDayOfYear >= 1 && nDayOfYear <= 365))
{
const int leap_offset = bIsLeap ? 1 : 0;
while( nDayOfYear >
nDays +
mon_lengths[leap_offset][nMonth] )
{
nDays += mon_lengths[leap_offset][nMonth];
nMonth ++;
}
const int nDayOfMonth = nDayOfYear - nDays;
nMonth++;
poFeature->SetField(FIELD_DATETIME,
nYear, nMonth, nDayOfMonth,
atoi(szH), atoi(szM),
static_cast<float>(atoi(szS)) );
}
}
}
return poFeature;
}
}
OGRFeature *OGRWalkLayer::GetNextRawFeature()
{
if( GetStatement() == NULL )
return NULL;
/* -------------------------------------------------------------------- */
/* If we are marked to restart then do so, and fetch a record. */
/* -------------------------------------------------------------------- */
if( !poStmt->Fetch() )
{
delete poStmt;
poStmt = NULL;
return NULL;
}
/* -------------------------------------------------------------------- */
/* Create a feature from the current result. */
/* -------------------------------------------------------------------- */
OGRFeature *poFeature = new OGRFeature( poFeatureDefn );
if( pszFIDColumn != NULL && poStmt->GetColId(pszFIDColumn) > -1 )
poFeature->SetFID(
atoi(poStmt->GetColData(poStmt->GetColId(pszFIDColumn))) );
else
poFeature->SetFID( iNextShapeId );
iNextShapeId++;
m_nFeaturesRead++;
/* -------------------------------------------------------------------- */
/* Set the fields. */
/* -------------------------------------------------------------------- */
for( int iField = 0; iField < poFeatureDefn->GetFieldCount(); iField++ )
{
int iSrcField = panFieldOrdinals[iField]-1;
const char *pszValue = poStmt->GetColData( iSrcField );
if( pszValue == NULL )
/* no value */;
else if( poFeature->GetFieldDefnRef(iField)->GetType() == OFTBinary )
poFeature->SetField( iField,
poStmt->GetColDataLength(iSrcField),
(GByte *) pszValue );
else
poFeature->SetField( iField, pszValue );
}
/* -------------------------------------------------------------------- */
/* Try to extract a geometry. */
/* -------------------------------------------------------------------- */
if( pszGeomColumn != NULL )
{
int iField = poStmt->GetColId( pszGeomColumn );
const char *pszGeomBin = poStmt->GetColData( iField );
int nGeomLength = poStmt->GetColDataLength( iField );
OGRGeometry *poGeom = NULL;
OGRErr eErr = OGRERR_NONE;
if( pszGeomBin != NULL && bGeomColumnWKB )
{
WKBGeometry *WalkGeom = (WKBGeometry *)CPLMalloc(sizeof(WKBGeometry));
if( Binary2WkbGeom((unsigned char *)pszGeomBin, WalkGeom, nGeomLength)
!= OGRERR_NONE )
{
CPLFree(WalkGeom);
return NULL;
}
eErr = TranslateWalkGeom(&poGeom, WalkGeom);
DeleteWKBGeometry(*WalkGeom);
CPLFree(WalkGeom);
}
if ( eErr != OGRERR_NONE )
{
const char *pszMessage;
switch ( eErr )
{
case OGRERR_NOT_ENOUGH_DATA:
pszMessage = "Not enough data to deserialize";
break;
case OGRERR_UNSUPPORTED_GEOMETRY_TYPE:
pszMessage = "Unsupported geometry type";
break;
case OGRERR_CORRUPT_DATA:
pszMessage = "Corrupt data";
break;
default:
pszMessage = "Unrecognized error";
}
CPLError(CE_Failure, CPLE_AppDefined,
"GetNextRawFeature(): %s", pszMessage);
}
if( poGeom != NULL && eErr == OGRERR_NONE )
{
poGeom->assignSpatialReference( poSRS );
poFeature->SetGeometryDirectly( poGeom );
}
}
return poFeature;
}
OGRFeature *OGRGMELayer::GetNextRawFeature()
{
/* -------------------------------------------------------------------- */
/* Fetch a new page of features if needed. */
/* -------------------------------------------------------------------- */
if (current_feature_page == NULL
|| index_in_page >= json_object_array_length(current_features_array))
{
GetPageOfFeatures();
}
if (current_feature_page == NULL)
{
return NULL;
}
/* -------------------------------------------------------------------- */
/* Identify our json feature. */
/* -------------------------------------------------------------------- */
json_object *feature_obj =
json_object_array_get_idx(current_features_array, index_in_page++);
if (feature_obj == NULL)
return NULL;
OGRFeature *poFeature = new OGRFeature(poFeatureDefn);
/* -------------------------------------------------------------------- */
/* Handle properties. */
/* -------------------------------------------------------------------- */
json_object *properties_obj =
json_object_object_get(feature_obj, "properties");
for (int iOGRField = 0;
iOGRField < poFeatureDefn->GetFieldCount();
iOGRField++ )
{
const char *pszValue =
OGRGMEGetJSONString(
properties_obj,
poFeatureDefn->GetFieldDefn(iOGRField)->GetNameRef(),
NULL);
if (pszValue != NULL) {
poFeature->SetField(iOGRField, pszValue);
}
}
/* -------------------------------------------------------------------- */
/* Handle gx_id. */
/* -------------------------------------------------------------------- */
const char *gx_id = OGRGMEGetJSONString(properties_obj, "gx_id");
if (gx_id) {
CPLString gmeId(gx_id);
omnosIdToGMEKey[++m_nFeaturesRead] = gmeId;
poFeature->SetFID(m_nFeaturesRead);
CPLDebug("GME", "Mapping ids: \"%s\" to %d", gx_id, (int)m_nFeaturesRead);
}
/* -------------------------------------------------------------------- */
/* Handle geometry. */
/* -------------------------------------------------------------------- */
json_object *geometry_obj =
json_object_object_get(feature_obj, "geometry");
OGRGeometry *poGeometry = NULL;
if (geometry_obj != NULL)
{
poGeometry = OGRGeoJSONReadGeometry(geometry_obj);
}
if (poGeometry != NULL)
{
poGeometry->assignSpatialReference(poSRS);
poFeature->SetGeometryDirectly(poGeometry);
}
return poFeature;
}
OGRErr OGRGMLLayer::CreateFeature( OGRFeature *poFeature )
{
int bIsGML3Output = poDS->IsGML3Output();
VSILFILE *fp = poDS->GetOutputFP();
int bWriteSpaceIndentation = poDS->WriteSpaceIndentation();
if( !bWriter )
return OGRERR_FAILURE;
if (bWriteSpaceIndentation)
VSIFPrintfL(fp, " ");
if (bIsGML3Output)
poDS->PrintLine( fp, "<ogr:featureMember>" );
else
poDS->PrintLine( fp, "<gml:featureMember>" );
if( poFeature->GetFID() == OGRNullFID )
poFeature->SetFID( iNextGMLId++ );
int nGMLIdIndex = -1;
if (bWriteSpaceIndentation)
VSIFPrintfL(fp, " ");
if (bIsGML3Output)
{
nGMLIdIndex = poFeatureDefn->GetFieldIndex("gml_id");
if (nGMLIdIndex >= 0 && poFeature->IsFieldSet( nGMLIdIndex ) )
poDS->PrintLine( fp, "<ogr:%s gml:id=\"%s\">",
poFeatureDefn->GetName(),
poFeature->GetFieldAsString(nGMLIdIndex) );
else
poDS->PrintLine( fp, "<ogr:%s gml:id=\"%s.%ld\">",
poFeatureDefn->GetName(),
poFeatureDefn->GetName(),
poFeature->GetFID() );
}
else
poDS->PrintLine( fp, "<ogr:%s fid=\"F%ld\">",
poFeatureDefn->GetName(),
poFeature->GetFID() );
// Write out Geometry - for now it isn't indented properly.
/* GML geometries don't like very much the concept of empty geometry */
OGRGeometry* poGeom = poFeature->GetGeometryRef();
if( poGeom != NULL && !poGeom->IsEmpty())
{
char *pszGeometry;
OGREnvelope sGeomBounds;
poGeom->getEnvelope( &sGeomBounds );
poDS->GrowExtents( &sGeomBounds );
if (bIsGML3Output)
{
int bCoordSwap;
if (poGeom->getSpatialReference() == NULL && poSRS != NULL)
poGeom->assignSpatialReference(poSRS);
char* pszSRSName = GML_GetSRSName(poGeom->getSpatialReference(), poDS->IsLongSRSRequired(), &bCoordSwap);
char szLowerCorner[75], szUpperCorner[75];
if (bCoordSwap)
{
OGRMakeWktCoordinate(szLowerCorner, sGeomBounds.MinY, sGeomBounds.MinX, 0, 2);
OGRMakeWktCoordinate(szUpperCorner, sGeomBounds.MaxY, sGeomBounds.MaxX, 0, 2);
}
else
{
OGRMakeWktCoordinate(szLowerCorner, sGeomBounds.MinX, sGeomBounds.MinY, 0, 2);
OGRMakeWktCoordinate(szUpperCorner, sGeomBounds.MaxX, sGeomBounds.MaxY, 0, 2);
}
if (bWriteSpaceIndentation)
VSIFPrintfL(fp, " ");
poDS->PrintLine( fp, "<gml:boundedBy><gml:Envelope%s><gml:lowerCorner>%s</gml:lowerCorner><gml:upperCorner>%s</gml:upperCorner></gml:Envelope></gml:boundedBy>",
pszSRSName, szLowerCorner, szUpperCorner);
CPLFree(pszSRSName);
}
char** papszOptions = (bIsGML3Output) ? CSLAddString(NULL, "FORMAT=GML3") : NULL;
if (bIsGML3Output && !poDS->IsLongSRSRequired())
papszOptions = CSLAddString(papszOptions, "GML3_LONGSRS=NO");
pszGeometry = poGeom->exportToGML(papszOptions);
CSLDestroy(papszOptions);
if (bWriteSpaceIndentation)
VSIFPrintfL(fp, " ");
poDS->PrintLine( fp, "<ogr:geometryProperty>%s</ogr:geometryProperty>",
pszGeometry );
CPLFree( pszGeometry );
}
// Write all "set" fields.
for( int iField = 0; iField < poFeatureDefn->GetFieldCount(); iField++ )
{
OGRFieldDefn *poFieldDefn = poFeatureDefn->GetFieldDefn( iField );
if( poFeature->IsFieldSet( iField ) && iField != nGMLIdIndex )
{
const char *pszRaw = poFeature->GetFieldAsString( iField );
while( *pszRaw == ' ' )
pszRaw++;
char *pszEscaped = OGRGetXML_UTF8_EscapedString( pszRaw );
if (poFieldDefn->GetType() == OFTReal)
{
/* Use point as decimal separator */
char* pszComma = strchr(pszEscaped, ',');
if (pszComma)
*pszComma = '.';
}
if (bWriteSpaceIndentation)
VSIFPrintfL(fp, " ");
poDS->PrintLine( fp, "<ogr:%s>%s</ogr:%s>",
poFieldDefn->GetNameRef(), pszEscaped,
poFieldDefn->GetNameRef() );
CPLFree( pszEscaped );
}
}
if (bWriteSpaceIndentation)
VSIFPrintfL(fp, " ");
poDS->PrintLine( fp, "</ogr:%s>", poFeatureDefn->GetName() );
if (bWriteSpaceIndentation)
VSIFPrintfL(fp, " ");
if (bIsGML3Output)
poDS->PrintLine( fp, "</ogr:featureMember>" );
else
poDS->PrintLine( fp, "</gml:featureMember>" );
return OGRERR_NONE;
}
OGRFeature *OGRMSSQLSpatialLayer::GetNextRawFeature()
{
if( GetStatement() == NULL )
return NULL;
/* -------------------------------------------------------------------- */
/* If we are marked to restart then do so, and fetch a record. */
/* -------------------------------------------------------------------- */
if( !poStmt->Fetch() )
{
delete poStmt;
poStmt = NULL;
return NULL;
}
/* -------------------------------------------------------------------- */
/* Create a feature from the current result. */
/* -------------------------------------------------------------------- */
int iField;
OGRFeature *poFeature = new OGRFeature( poFeatureDefn );
if( pszFIDColumn != NULL && poStmt->GetColId(pszFIDColumn) > -1 )
poFeature->SetFID(
CPLAtoGIntBig(poStmt->GetColData(poStmt->GetColId(pszFIDColumn))) );
else
poFeature->SetFID( iNextShapeId );
iNextShapeId++;
m_nFeaturesRead++;
/* -------------------------------------------------------------------- */
/* Set the fields. */
/* -------------------------------------------------------------------- */
for( iField = 0; iField < poFeatureDefn->GetFieldCount(); iField++ )
{
if ( poFeatureDefn->GetFieldDefn(iField)->IsIgnored() )
continue;
int iSrcField = panFieldOrdinals[iField];
const char *pszValue = poStmt->GetColData( iSrcField );
if( pszValue == NULL )
/* no value */;
else if( poFeature->GetFieldDefnRef(iField)->GetType() == OFTBinary )
poFeature->SetField( iField,
poStmt->GetColDataLength(iSrcField),
(GByte *) pszValue );
else
poFeature->SetField( iField, pszValue );
}
/* -------------------------------------------------------------------- */
/* Try to extract a geometry. */
/* -------------------------------------------------------------------- */
if( pszGeomColumn != NULL && !poFeatureDefn->IsGeometryIgnored())
{
int iField = poStmt->GetColId( pszGeomColumn );
const char *pszGeomText = poStmt->GetColData( iField );
OGRGeometry *poGeom = NULL;
OGRErr eErr = OGRERR_NONE;
if( pszGeomText != NULL )
{
int nLength = poStmt->GetColDataLength( iField );
if ( nGeomColumnType == MSSQLCOLTYPE_GEOMETRY ||
nGeomColumnType == MSSQLCOLTYPE_GEOGRAPHY ||
nGeomColumnType == MSSQLCOLTYPE_BINARY)
{
switch ( poDS->GetGeometryFormat() )
{
case MSSQLGEOMETRY_NATIVE:
{
OGRMSSQLGeometryParser oParser( nGeomColumnType );
eErr = oParser.ParseSqlGeometry(
(unsigned char *) pszGeomText, nLength, &poGeom );
nSRSId = oParser.GetSRSId();
}
break;
case MSSQLGEOMETRY_WKB:
case MSSQLGEOMETRY_WKBZM:
eErr = OGRGeometryFactory::createFromWkb((unsigned char *) pszGeomText,
NULL, &poGeom, nLength);
break;
case MSSQLGEOMETRY_WKT:
eErr = OGRGeometryFactory::createFromWkt((char **) &pszGeomText,
NULL, &poGeom);
break;
}
}
else if (nGeomColumnType == MSSQLCOLTYPE_TEXT)
{
eErr = OGRGeometryFactory::createFromWkt((char **) &pszGeomText,
NULL, &poGeom);
}
}
if ( eErr != OGRERR_NONE )
{
const char *pszMessage;
switch ( eErr )
{
case OGRERR_NOT_ENOUGH_DATA:
pszMessage = "Not enough data to deserialize";
break;
case OGRERR_UNSUPPORTED_GEOMETRY_TYPE:
pszMessage = "Unsupported geometry type";
break;
case OGRERR_CORRUPT_DATA:
pszMessage = "Corrupt data";
break;
default:
pszMessage = "Unrecognized error";
}
CPLError(CE_Failure, CPLE_AppDefined,
"GetNextRawFeature(): %s", pszMessage);
}
if( poGeom != NULL )
{
if ( GetSpatialRef() )
poGeom->assignSpatialReference( poSRS );
poFeature->SetGeometryDirectly( poGeom );
}
}
return poFeature;
}
OGRFeature* OGRPLScenesLayer::GetNextRawFeature()
{
if( bEOF ||
(!bFilterMustBeClientSideEvaluated && nFeatureCount >= 0 && nNextFID > nFeatureCount) )
return NULL;
if( poGeoJSONLayer == NULL )
{
if( !GetNextPage() )
return NULL;
}
#ifdef notdef
if( CSLTestBoolean(CPLGetConfigOption("OGR_LIMIT_TOO_MANY_FEATURES", "FALSE")) &&
nFeatureCount > nPageSize )
{
bEOF = TRUE;
OGRFeature* poFeature = new OGRFeature(poFeatureDefn);
OGRGeometry* poGeom;
const char* pszWKT = "MULTIPOLYGON(((-180 90,180 90,180 -90,-180 -90,-180 90)))";
OGRGeometryFactory::createFromWkt((char**)&pszWKT, poSRS, &poGeom);
poFeature->SetGeometryDirectly(poGeom);
return poFeature;
}
#endif
OGRFeature* poGeoJSONFeature = poGeoJSONLayer->GetNextFeature();
if( poGeoJSONFeature == NULL )
{
osRequestURL = osNextURL;
bStillInFirstPage = FALSE;
if( !GetNextPage() )
return NULL;
poGeoJSONFeature = poGeoJSONLayer->GetNextFeature();
if( poGeoJSONFeature == NULL )
{
bEOF = TRUE;
return NULL;
}
}
OGRFeature* poFeature = new OGRFeature(poFeatureDefn);
poFeature->SetFID(nNextFID++);
OGRGeometry* poGeom = poGeoJSONFeature->StealGeometry();
if( poGeom != NULL )
{
if( poGeom->getGeometryType() == wkbPolygon )
{
OGRMultiPolygon* poMP = new OGRMultiPolygon();
poMP->addGeometryDirectly(poGeom);
poGeom = poMP;
}
poGeom->assignSpatialReference(poSRS);
poFeature->SetGeometryDirectly(poGeom);
}
for(int i=0;i<poFeatureDefn->GetFieldCount();i++)
{
OGRFieldDefn* poFieldDefn = poFeatureDefn->GetFieldDefn(i);
OGRFieldType eType = poFieldDefn->GetType();
int iSrcField = poGeoJSONFeature->GetFieldIndex(poFieldDefn->GetNameRef());
if( iSrcField >= 0 && poGeoJSONFeature->IsFieldSet(iSrcField) )
{
if( eType == OFTInteger )
poFeature->SetField(i,
poGeoJSONFeature->GetFieldAsInteger(iSrcField));
else if( eType == OFTReal )
poFeature->SetField(i,
poGeoJSONFeature->GetFieldAsDouble(iSrcField));
else
poFeature->SetField(i,
poGeoJSONFeature->GetFieldAsString(iSrcField));
}
}
delete poGeoJSONFeature;
return poFeature;
}
OGRFeature *OGRMDBLayer::GetNextRawFeature()
{
OGRErr err = OGRERR_NONE;
if( !poMDBTable->GetNextRow() )
return NULL;
/* -------------------------------------------------------------------- */
/* Create a feature from the current result. */
/* -------------------------------------------------------------------- */
int iField;
OGRFeature *poFeature = new OGRFeature( poFeatureDefn );
if( pszFIDColumn != NULL && poMDBTable->GetColumnIndex(pszFIDColumn) > -1 )
poFeature->SetFID(
poMDBTable->GetColumnAsInt(poMDBTable->GetColumnIndex(pszFIDColumn)) );
else
poFeature->SetFID( iNextShapeId );
iNextShapeId++;
m_nFeaturesRead++;
/* -------------------------------------------------------------------- */
/* Set the fields. */
/* -------------------------------------------------------------------- */
for( iField = 0; iField < poFeatureDefn->GetFieldCount(); iField++ )
{
int iSrcField = panFieldOrdinals[iField]-1;
char *pszValue = poMDBTable->GetColumnAsString( iSrcField );
OGRFieldType eType = poFeature->GetFieldDefnRef(iField)->GetType();
if( pszValue == NULL )
/* no value */;
else if( eType == OFTBinary )
{
int nBytes = 0;
GByte* pData = poMDBTable->GetColumnAsBinary( iSrcField, &nBytes);
poFeature->SetField( iField,
nBytes,
pData );
CPLFree(pData);
}
else if ( eType == OFTInteger && EQUAL(pszValue, "true"))
{
poFeature->SetField( iField, 1 );
}
else
{
poFeature->SetField( iField, pszValue );
}
CPLFree(pszValue);
}
if( !(m_poAttrQuery == NULL
|| m_poAttrQuery->Evaluate( poFeature )) )
return poFeature;
/* -------------------------------------------------------------------- */
/* Try to extract a geometry. */
/* -------------------------------------------------------------------- */
if( eGeometryType == MDB_GEOM_PGEO && iGeomColumn >= 0)
{
int nBytes = 0;
GByte* pData = poMDBTable->GetColumnAsBinary( iGeomColumn, &nBytes);
OGRGeometry *poGeom = NULL;
if( pData != NULL )
{
err = OGRCreateFromShapeBin( pData, &poGeom, nBytes );
if( OGRERR_NONE != err )
{
CPLDebug( "MDB",
"Translation shape binary to OGR geometry failed (FID=%ld)",
(long)poFeature->GetFID() );
}
}
CPLFree(pData);
if( poGeom != NULL && OGRERR_NONE == err )
{
poGeom->assignSpatialReference( poSRS );
poFeature->SetGeometryDirectly( poGeom );
}
}
else if( eGeometryType == MDB_GEOM_GEOMEDIA && iGeomColumn >= 0)
{
int nBytes = 0;
GByte* pData = poMDBTable->GetColumnAsBinary( iGeomColumn, &nBytes);
OGRGeometry *poGeom = NULL;
if( pData != NULL )
{
err = OGRCreateFromGeomedia( pData, &poGeom, nBytes );
if( OGRERR_NONE != err )
{
CPLDebug( "MDB",
"Translation geomedia binary to OGR geometry failed (FID=%ld)",
(long)poFeature->GetFID() );
}
}
CPLFree(pData);
if( poGeom != NULL && OGRERR_NONE == err )
{
poGeom->assignSpatialReference( poSRS );
poFeature->SetGeometryDirectly( poGeom );
}
}
return poFeature;
}
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 int WFS_ExprDumpAsOGCFilter(CPLString& osFilter,
const swq_expr_node* poExpr,
int bExpectBinary,
ExprDumpFilterOptions* psOptions)
{
if( poExpr->eNodeType == SNT_COLUMN )
{
if (bExpectBinary)
return FALSE;
/* Special fields not understood by server */
if (EQUAL(poExpr->string_value, "gml_id") ||
EQUAL(poExpr->string_value, "FID") ||
EQUAL(poExpr->string_value, "OGR_GEOMETRY") ||
EQUAL(poExpr->string_value, "OGR_GEOM_WKT") ||
EQUAL(poExpr->string_value, "OGR_GEOM_AREA") ||
EQUAL(poExpr->string_value, "OGR_STYLE"))
{
CPLDebug("WFS", "Attribute refers to a OGR special field. Cannot use server-side filtering");
return FALSE;
}
const char* pszFieldname = NULL;
int nIndex;
int bSameTable = psOptions->poFDefn != NULL &&
( poExpr->table_name == NULL ||
EQUAL(poExpr->table_name, psOptions->poFDefn->GetName()) );
if( bSameTable )
{
if( (nIndex = psOptions->poFDefn->GetFieldIndex(poExpr->string_value)) >= 0 )
{
pszFieldname = psOptions->poFDefn->GetFieldDefn(nIndex)->GetNameRef();
}
else if( (nIndex = psOptions->poFDefn->GetGeomFieldIndex(poExpr->string_value)) >= 0 )
{
pszFieldname = psOptions->poFDefn->GetGeomFieldDefn(nIndex)->GetNameRef();
}
}
else if( psOptions->poDS != NULL )
{
OGRLayer* poLayer = psOptions->poDS->GetLayerByName(poExpr->table_name);
if( poLayer )
{
OGRFeatureDefn* poFDefn = poLayer->GetLayerDefn();
if( (nIndex = poFDefn->GetFieldIndex(poExpr->string_value)) >= 0 )
{
pszFieldname = CPLSPrintf("%s/%s",
poLayer->GetName(),
poFDefn->GetFieldDefn(nIndex)->GetNameRef());
}
else if( (nIndex = poFDefn->GetGeomFieldIndex(poExpr->string_value)) >= 0 )
{
pszFieldname = CPLSPrintf("%s/%s",
poLayer->GetName(),
poFDefn->GetGeomFieldDefn(nIndex)->GetNameRef());
}
}
}
if( psOptions->poFDefn == NULL && psOptions->poDS == NULL )
pszFieldname = poExpr->string_value;
if( pszFieldname == NULL )
{
if( poExpr->table_name != NULL )
CPLDebug("WFS", "Field \"%s\".\"%s\" unknown. Cannot use server-side filtering",
poExpr->table_name, poExpr->string_value);
else
CPLDebug("WFS", "Field \"%s\" unknown. Cannot use server-side filtering",
poExpr->string_value);
return FALSE;
}
if (psOptions->nVersion >= 200)
osFilter += CPLSPrintf("<%sValueReference>", psOptions->pszNSPrefix);
else
osFilter += CPLSPrintf("<%sPropertyName>", psOptions->pszNSPrefix);
char* pszFieldnameXML = CPLEscapeString(pszFieldname, -1, CPLES_XML);
osFilter += pszFieldnameXML;
CPLFree(pszFieldnameXML);
if (psOptions->nVersion >= 200)
osFilter += CPLSPrintf("</%sValueReference>", psOptions->pszNSPrefix);
else
osFilter += CPLSPrintf("</%sPropertyName>", psOptions->pszNSPrefix);
return TRUE;
}
if( poExpr->eNodeType == SNT_CONSTANT )
{
if (bExpectBinary)
return FALSE;
osFilter += CPLSPrintf("<%sLiteral>", psOptions->pszNSPrefix);
if( !WFS_ExprDumpRawLitteral(osFilter, poExpr) )
return FALSE;
osFilter += CPLSPrintf("</%sLiteral>", psOptions->pszNSPrefix);
return TRUE;
}
if( poExpr->eNodeType != SNT_OPERATION )
return FALSE; /* shouldn't happen */
if( poExpr->nOperation == SWQ_NOT )
{
osFilter += CPLSPrintf("<%sNot>", psOptions->pszNSPrefix);
if (!WFS_ExprDumpAsOGCFilter(osFilter, poExpr->papoSubExpr[0], TRUE, psOptions))
return FALSE;
osFilter += CPLSPrintf("</%sNot>", psOptions->pszNSPrefix);
return TRUE;
}
if( poExpr->nOperation == SWQ_LIKE )
{
CPLString osVal;
char ch;
char firstCh = 0;
int i;
if (psOptions->nVersion == 100)
osFilter += CPLSPrintf("<%sPropertyIsLike wildCard='*' singleChar='_' escape='!'>", psOptions->pszNSPrefix);
else
osFilter += CPLSPrintf("<%sPropertyIsLike wildCard='*' singleChar='_' escapeChar='!'>", psOptions->pszNSPrefix);
if (!WFS_ExprDumpAsOGCFilter(osFilter, poExpr->papoSubExpr[0], FALSE, psOptions))
return FALSE;
if (poExpr->papoSubExpr[1]->eNodeType != SNT_CONSTANT &&
poExpr->papoSubExpr[1]->field_type != SWQ_STRING)
return FALSE;
osFilter += CPLSPrintf("<%sLiteral>", psOptions->pszNSPrefix);
/* Escape value according to above special characters */
/* For URL compatibility reason, we remap the OGR SQL '%' wildchard into '*' */
i = 0;
ch = poExpr->papoSubExpr[1]->string_value[i];
if (ch == '\'' || ch == '"')
{
firstCh = ch;
i ++;
}
for(;(ch = poExpr->papoSubExpr[1]->string_value[i]) != '\0';i++)
{
if (ch == '%')
osVal += "*";
else if (ch == '!')
osVal += "!!";
else if (ch == '*')
osVal += "!*";
else if (ch == firstCh && poExpr->papoSubExpr[1]->string_value[i + 1] == 0)
break;
else
{
char ach[2];
ach[0] = ch;
ach[1] = 0;
osVal += ach;
}
}
char* pszXML = CPLEscapeString(osVal, -1, CPLES_XML);
osFilter += pszXML;
CPLFree(pszXML);
osFilter += CPLSPrintf("</%sLiteral>", psOptions->pszNSPrefix);
osFilter += CPLSPrintf("</%sPropertyIsLike>", psOptions->pszNSPrefix);
return TRUE;
}
if( poExpr->nOperation == SWQ_ISNULL )
{
osFilter += CPLSPrintf("<%sPropertyIsNull>", psOptions->pszNSPrefix);
if (!WFS_ExprDumpAsOGCFilter(osFilter, poExpr->papoSubExpr[0], FALSE, psOptions))
return FALSE;
osFilter += CPLSPrintf("</%sPropertyIsNull>", psOptions->pszNSPrefix);
psOptions->bOutNeedsNullCheck = TRUE;
return TRUE;
}
if( poExpr->nOperation == SWQ_EQ ||
poExpr->nOperation == SWQ_NE ||
poExpr->nOperation == SWQ_LE ||
poExpr->nOperation == SWQ_LT ||
poExpr->nOperation == SWQ_GE ||
poExpr->nOperation == SWQ_GT )
{
int nOperation = poExpr->nOperation;
int bAddClosingNot = FALSE;
if (!psOptions->bPropertyIsNotEqualToSupported && nOperation == SWQ_NE)
{
osFilter += CPLSPrintf("<%sNot>", psOptions->pszNSPrefix);
nOperation = SWQ_EQ;
bAddClosingNot = TRUE;
}
const char* pszName = NULL;
switch(nOperation)
{
case SWQ_EQ: pszName = "PropertyIsEqualTo"; break;
case SWQ_NE: pszName = "PropertyIsNotEqualTo"; break;
case SWQ_LE: pszName = "PropertyIsLessThanOrEqualTo"; break;
case SWQ_LT: pszName = "PropertyIsLessThan"; break;
case SWQ_GE: pszName = "PropertyIsGreaterThanOrEqualTo"; break;
case SWQ_GT: pszName = "PropertyIsGreaterThan"; break;
default: break;
}
osFilter += "<";
osFilter += psOptions->pszNSPrefix;
osFilter += pszName;
osFilter += ">";
if (!WFS_ExprDumpAsOGCFilter(osFilter, poExpr->papoSubExpr[0], FALSE, psOptions))
return FALSE;
if (!WFS_ExprDumpAsOGCFilter(osFilter, poExpr->papoSubExpr[1], FALSE, psOptions))
return FALSE;
osFilter += "</";
osFilter += psOptions->pszNSPrefix;
osFilter += pszName;
osFilter += ">";
if (bAddClosingNot)
osFilter += CPLSPrintf("</%sNot>", psOptions->pszNSPrefix);
return TRUE;
}
if( poExpr->nOperation == SWQ_AND ||
poExpr->nOperation == SWQ_OR )
{
const char* pszName = (poExpr->nOperation == SWQ_AND) ? "And" : "Or";
osFilter += "<";
osFilter += psOptions->pszNSPrefix;
osFilter += pszName;
osFilter += ">";
if (!WFS_ExprDumpAsOGCFilter(osFilter, poExpr->papoSubExpr[0], TRUE, psOptions))
return FALSE;
if (!WFS_ExprDumpAsOGCFilter(osFilter, poExpr->papoSubExpr[1], TRUE, psOptions))
return FALSE;
osFilter += "</";
osFilter += psOptions->pszNSPrefix;
osFilter += pszName;
osFilter += ">";
return TRUE;
}
if( poExpr->nOperation == SWQ_CUSTOM_FUNC &&
EQUAL(poExpr->string_value, "ST_MakeEnvelope") )
{
OGRSpatialReference oSRS;
const char* pszSRSName = WFS_ExprGetSRSName( poExpr, 4, psOptions, oSRS );
int bAxisSwap = FALSE;
osFilter += "<gml:Envelope";
if( pszSRSName )
{
osFilter += " srsName=\"";
osFilter += pszSRSName;
osFilter += "\"";
if( oSRS.EPSGTreatsAsLatLong() || oSRS.EPSGTreatsAsNorthingEasting() )
bAxisSwap = TRUE;
}
osFilter += ">";
osFilter += "<gml:lowerCorner>";
if (!WFS_ExprDumpRawLitteral(osFilter, poExpr->papoSubExpr[(bAxisSwap) ? 1 : 0]))
return FALSE;
osFilter += " ";
if (!WFS_ExprDumpRawLitteral(osFilter, poExpr->papoSubExpr[(bAxisSwap) ? 0 : 1]))
return FALSE;
osFilter += "</gml:lowerCorner>";
osFilter += "<gml:upperCorner>";
if (!WFS_ExprDumpRawLitteral(osFilter, poExpr->papoSubExpr[(bAxisSwap) ? 3 : 2]))
return FALSE;
osFilter += " ";
if (!WFS_ExprDumpRawLitteral(osFilter, poExpr->papoSubExpr[(bAxisSwap) ? 2 : 3]))
return FALSE;
osFilter += "</gml:upperCorner>";
osFilter += "</gml:Envelope>";
return TRUE;
}
if( poExpr->nOperation == SWQ_CUSTOM_FUNC &&
EQUAL(poExpr->string_value, "ST_GeomFromText") )
{
OGRSpatialReference oSRS;
const char* pszSRSName = WFS_ExprGetSRSName( poExpr, 1, psOptions, oSRS );
OGRGeometry* poGeom = NULL;
char* pszWKT = (char*)poExpr->papoSubExpr[0]->string_value;
OGRGeometryFactory::createFromWkt(&pszWKT, NULL, &poGeom);
char** papszOptions = NULL;
papszOptions = CSLSetNameValue(papszOptions, "FORMAT", "GML3");
if( pszSRSName != NULL )
{
if( oSRS.EPSGTreatsAsLatLong() || oSRS.EPSGTreatsAsNorthingEasting() )
{
OGR_SRSNode *poGEOGCS = oSRS.GetAttrNode( "GEOGCS" );
if( poGEOGCS != NULL )
poGEOGCS->StripNodes( "AXIS" );
OGR_SRSNode *poPROJCS = oSRS.GetAttrNode( "PROJCS" );
if (poPROJCS != NULL && oSRS.EPSGTreatsAsNorthingEasting())
poPROJCS->StripNodes( "AXIS" );
}
if( EQUALN(pszSRSName, "urn:ogc:def:crs:EPSG::", strlen("urn:ogc:def:crs:EPSG::")) )
papszOptions = CSLSetNameValue(papszOptions, "GML3_LONGSRS", "YES");
else
papszOptions = CSLSetNameValue(papszOptions, "GML3_LONGSRS", "NO");
poGeom->assignSpatialReference(&oSRS);
}
papszOptions = CSLSetNameValue(papszOptions, "GMLID",
CPLSPrintf("id%d", psOptions->nUniqueGeomGMLId ++));
char* pszGML = OGR_G_ExportToGMLEx( (OGRGeometryH)poGeom, papszOptions );
osFilter += pszGML;
CSLDestroy(papszOptions);
delete poGeom;
CPLFree(pszGML);
return TRUE;
}
if( poExpr->nOperation == SWQ_CUSTOM_FUNC )
{
const char* pszName =
EQUAL(poExpr->string_value, "ST_Equals") ? "Equals" :
EQUAL(poExpr->string_value, "ST_Disjoint") ? "Disjoint" :
EQUAL(poExpr->string_value, "ST_Touches") ? "Touches" :
EQUAL(poExpr->string_value, "ST_Contains") ? "Contains" :
EQUAL(poExpr->string_value, "ST_Intersects") ? "Intersects" :
EQUAL(poExpr->string_value, "ST_Within") ? "Within" :
EQUAL(poExpr->string_value, "ST_Crosses") ? "Crosses" :
EQUAL(poExpr->string_value, "ST_Overlaps") ? "Overlaps" :
EQUAL(poExpr->string_value, "ST_DWithin") ? "DWithin" :
EQUAL(poExpr->string_value, "ST_Beyond") ? "Beyond" :
NULL;
if( pszName == NULL )
return FALSE;
osFilter += "<";
osFilter += psOptions->pszNSPrefix;
osFilter += pszName;
osFilter += ">";
for(int i=0;i<2;i++)
{
if( i == 1 && poExpr->papoSubExpr[0]->eNodeType == SNT_COLUMN &&
poExpr->papoSubExpr[1]->eNodeType == SNT_OPERATION &&
poExpr->papoSubExpr[1]->nOperation == SWQ_CUSTOM_FUNC &&
(EQUAL(poExpr->papoSubExpr[1]->string_value, "ST_GeomFromText") ||
EQUAL(poExpr->papoSubExpr[1]->string_value, "ST_MakeEnvelope")) )
{
int bSameTable = psOptions->poFDefn != NULL &&
( poExpr->papoSubExpr[0]->table_name == NULL ||
EQUAL(poExpr->papoSubExpr[0]->table_name, psOptions->poFDefn->GetName()) );
if( bSameTable )
{
int nIndex;
if( (nIndex = psOptions->poFDefn->GetGeomFieldIndex(poExpr->papoSubExpr[0]->string_value)) >= 0 )
{
psOptions->poSRS = psOptions->poFDefn->GetGeomFieldDefn(nIndex)->GetSpatialRef();
}
}
else if( psOptions->poDS != NULL )
{
OGRLayer* poLayer = psOptions->poDS->GetLayerByName(poExpr->papoSubExpr[0]->table_name);
if( poLayer )
{
OGRFeatureDefn* poFDefn = poLayer->GetLayerDefn();
int nIndex;
if( (nIndex = poFDefn->GetGeomFieldIndex(poExpr->papoSubExpr[0]->string_value)) >= 0 )
{
psOptions->poSRS = poFDefn->GetGeomFieldDefn(nIndex)->GetSpatialRef();
}
}
}
}
int bRet = WFS_ExprDumpAsOGCFilter(osFilter, poExpr->papoSubExpr[i], FALSE, psOptions);
psOptions->poSRS = NULL;
if( !bRet )
return FALSE;
}
if( poExpr->nSubExprCount > 2 )
{
osFilter += CPLSPrintf("<%sDistance unit=\"m\">", psOptions->pszNSPrefix);
if (!WFS_ExprDumpRawLitteral(osFilter, poExpr->papoSubExpr[2]) )
return FALSE;
osFilter += CPLSPrintf("</%sDistance>", psOptions->pszNSPrefix);
}
osFilter += "</";
osFilter += psOptions->pszNSPrefix;
osFilter += pszName;
osFilter += ">";
return TRUE;
}
return FALSE;
}
OGRErr OGRGeometryFactory::createFromWkb(unsigned char *pabyData,
OGRSpatialReference * poSR,
OGRGeometry **ppoReturn,
int nBytes )
{
OGRwkbGeometryType eGeometryType;
OGRwkbByteOrder eByteOrder;
OGRErr eErr;
OGRGeometry *poGeom;
*ppoReturn = NULL;
if( nBytes < 5 && nBytes != -1 )
return OGRERR_NOT_ENOUGH_DATA;
/* -------------------------------------------------------------------- */
/* Get the byte order byte. The extra tests are to work around */
/* bug sin the WKB of DB2 v7.2 as identified by Safe Software. */
/* -------------------------------------------------------------------- */
eByteOrder = DB2_V72_FIX_BYTE_ORDER((OGRwkbByteOrder) *pabyData);
if( eByteOrder != wkbXDR && eByteOrder != wkbNDR )
{
CPLDebug( "OGR",
"OGRGeometryFactory::createFromWkb() - got corrupt data.\n"
"%02X%02X%02X%02X%02X%02X%02X%02X\n",
pabyData[0],
pabyData[1],
pabyData[2],
pabyData[3],
pabyData[4],
pabyData[5],
pabyData[6],
pabyData[7],
pabyData[8] );
return OGRERR_CORRUPT_DATA;
}
/* -------------------------------------------------------------------- */
/* Get the geometry feature type. For now we assume that */
/* geometry type is between 0 and 255 so we only have to fetch */
/* one byte. */
/* -------------------------------------------------------------------- */
if( eByteOrder == wkbNDR )
eGeometryType = (OGRwkbGeometryType) pabyData[1];
else
eGeometryType = (OGRwkbGeometryType) pabyData[4];
/* -------------------------------------------------------------------- */
/* Instantiate a geometry of the appropriate type, and */
/* initialize from the input stream. */
/* -------------------------------------------------------------------- */
poGeom = createGeometry( eGeometryType );
if( poGeom == NULL )
return OGRERR_UNSUPPORTED_GEOMETRY_TYPE;
/* -------------------------------------------------------------------- */
/* Import from binary. */
/* -------------------------------------------------------------------- */
eErr = poGeom->importFromWkb( pabyData, nBytes );
/* -------------------------------------------------------------------- */
/* Assign spatial reference system. */
/* -------------------------------------------------------------------- */
if( eErr == OGRERR_NONE )
{
poGeom->assignSpatialReference( poSR );
*ppoReturn = poGeom;
}
else
{
delete poGeom;
}
return eErr;
}
OGRErr OGRGeometryFactory::createFromWkt(char **ppszData,
OGRSpatialReference * poSR,
OGRGeometry **ppoReturn )
{
OGRErr eErr;
char szToken[OGR_WKT_TOKEN_MAX];
char *pszInput = *ppszData;
OGRGeometry *poGeom;
*ppoReturn = NULL;
/* -------------------------------------------------------------------- */
/* Get the first token, which should be the geometry type. */
/* -------------------------------------------------------------------- */
if( OGRWktReadToken( pszInput, szToken ) == NULL )
return OGRERR_CORRUPT_DATA;
/* -------------------------------------------------------------------- */
/* Instantiate a geometry of the appropriate type. */
/* -------------------------------------------------------------------- */
if( EQUAL(szToken,"POINT") )
{
poGeom = new OGRPoint();
}
else if( EQUAL(szToken,"LINESTRING") )
{
poGeom = new OGRLineString();
}
else if( EQUAL(szToken,"POLYGON") )
{
poGeom = new OGRPolygon();
}
else if( EQUAL(szToken,"GEOMETRYCOLLECTION") )
{
poGeom = new OGRGeometryCollection();
}
else if( EQUAL(szToken,"MULTIPOLYGON") )
{
poGeom = new OGRMultiPolygon();
}
else if( EQUAL(szToken,"MULTIPOINT") )
{
poGeom = new OGRMultiPoint();
}
else if( EQUAL(szToken,"MULTILINESTRING") )
{
poGeom = new OGRMultiLineString();
}
else
{
return OGRERR_UNSUPPORTED_GEOMETRY_TYPE;
}
/* -------------------------------------------------------------------- */
/* Do the import. */
/* -------------------------------------------------------------------- */
eErr = poGeom->importFromWkt( &pszInput );
/* -------------------------------------------------------------------- */
/* Assign spatial reference system. */
/* -------------------------------------------------------------------- */
if( eErr == OGRERR_NONE )
{
poGeom->assignSpatialReference( poSR );
*ppoReturn = poGeom;
*ppszData = pszInput;
}
else
{
delete poGeom;
}
return eErr;
}
OGRFeature *OGRSOSILayer::GetNextFeature() {
short nName, nNumLines;
long nNumCoo;
unsigned short nInfo;
/* iterate through the SOSI groups*/
while (LC_NextBgr(poNextSerial,LC_FRAMGR)) {
nName = LC_RxGr(&oNextSerial, LES_OPTIMALT, &nNumLines, &nNumCoo, &nInfo);
S2S oHeaders;
S2S::iterator iHeaders;
/* extract reference strings from group header */
CPLString osKey, osValue;
for (short i=1; i<=nNumLines; i++) {
char *pszLine = LC_GetGi(i);
if (pszLine[0] == '!') continue; /* If we have a comment line, skip it. */
if ((pszLine[0] == ':')||(pszLine[0] == '(')) { /* if we have a continued REF line... */
osValue.append(CPLString(pszLine)); /* append to previous line. */
oHeaders.insert(std::pair<CPLString,CPLString>(osKey,osValue));
continue;
}
while (pszLine[0] == '.') pszLine++; /* skipping the dots at the beginning of a SOSI line */
char *pszUTFLine = CPLRecode(pszLine, poParent->pszEncoding, CPL_ENC_UTF8); /* switch to UTF encoding here */
char *pszPos = strstr(pszUTFLine, " ");
if (pszPos != NULL) {
osKey = CPLString(std::string(pszUTFLine,pszPos));
osValue = CPLString(pszPos+1);
oHeaders.insert(std::pair<CPLString,CPLString>(osKey,osValue));
}
CPLFree(pszUTFLine);
}
/* get Feature from fyba, according to feature definition */
OGRGeometry *poGeom = NULL;
OGRwkbGeometryType oGType = wkbUnknown;
switch (nName) {
case INGEN_GRUPPE: { /* No group */
CPLDebug( "[GetNextFeature]", "Could not load further groups - FYBA reported INGEN_GRUPPE.");
break;
}
case L_FLATE: { /* Area */
oGType = wkbPolygon;
OGRLinearRing *poOuter = new OGRLinearRing(); /* Initialize a new closed polygon */
long nRefNr;
unsigned char nRefStatus;
long nRefCount;
bool correct = true;
LC_GRF_STATUS oGrfStat;
// Iterate through all objects that constitute this area.
LC_InitGetRefFlate(&oGrfStat);
nRefCount = LC_GetRefFlate(&oGrfStat, GRF_YTRE, &nRefNr, &nRefStatus, 1);
while (nRefCount > 0) {
if (poParent->papoBuiltGeometries[nRefNr] == NULL) {
// This should not happen under normal operation.
CPLError( CE_Warning, CPLE_AppDefined, "Feature %li referenced by %li, but it was not initialized. Geometry may be broken.", nRefNr, oNextSerial.lNr);
correct = false;
//return NULL;
break;
}
OGRGeometry *geom = poParent->papoBuiltGeometries[nRefNr];
if (geom->getGeometryType() == wkbLineString) {
OGRLineString *poCurve = (OGRLineString*)geom;
if (nRefStatus == LC_MED_DIG) { /* clockwise */
poOuter->addSubLineString(poCurve);
} else if (nRefStatus == LC_MOT_DIG) { /* counter-clockwise */
poOuter->addSubLineString(poCurve,poCurve->getNumPoints()-1,0);
} else {
CPLError( CE_Failure, CPLE_OpenFailed, "Internal error: GRF_*_OY encountered.");
return NULL;
}
} else {
CPLError( CE_Warning, CPLE_AppDefined, "Element %li composed of non-linestrings (REF %li of type %i). Ignored.", oNextSerial.lNr, nRefNr, geom->getGeometryType());
}
nRefCount = LC_GetRefFlate(&oGrfStat, GRF_YTRE, &nRefNr, &nRefStatus, 1);
}
if (correct) {
OGRPolygon *poLy = new OGRPolygon();
poOuter->closeRings();
poLy->addRingDirectly(poOuter);
OGRLinearRing *poInner = 0;
nRefCount = LC_GetRefFlate(&oGrfStat, GRF_INDRE, &nRefNr, &nRefStatus, 1);
while (nRefCount > 0) {
if (nRefNr == -1) {
if (poInner && (poInner->getNumPoints()>2)) { /* If this is not the first polygon, terminate and add the last */
poInner->closeRings();
poLy->addRingDirectly(poInner);
}
poInner = new OGRLinearRing(); /* Initialize a new closed polygon */
} else {
if (poParent->papoBuiltGeometries[nRefNr] == NULL) { /* this shouldn't happen under normal operation */
CPLError( CE_Fatal, CPLE_AppDefined, "Feature %li referenced by %li, but it was not initialized.", nRefNr, oNextSerial.lNr);
return NULL;
}
OGRGeometry *geom = poParent->papoBuiltGeometries[nRefNr];
if (geom->getGeometryType() == wkbLineString) {
OGRLineString *poCurve = (OGRLineString*)geom;
if (nRefStatus == LC_MED_DIG) { /* clockwise */
poInner->addSubLineString(poCurve);
} else if (nRefStatus == LC_MOT_DIG) { /* counter-clockwise */
poInner->addSubLineString(poCurve,poCurve->getNumPoints()-1,0);
} else {
CPLError( CE_Failure, CPLE_OpenFailed, "Internal error: GRF_*_OY encountered.");
return NULL;
}
} else {
CPLError( CE_Warning, CPLE_AppDefined, "Element %li composed of non-linestrings (REF %li of type %i). Ignored.", oNextSerial.lNr, nRefNr, geom->getGeometryType());
}
}
nRefCount = LC_GetRefFlate(&oGrfStat, GRF_INDRE, &nRefNr, &nRefStatus, 1);
}
poGeom = poLy;
}
break;
}
case L_KURVE: /* curve */
case L_LINJE: /* curve, not simplifyable */
case L_BUEP: { /* curve, interpolated from circular arc */
oGType = wkbLineString;
OGRLineString *poCurve = (OGRLineString*)(poParent->papoBuiltGeometries[oNextSerial.lNr]);
if (poCurve == NULL) {
CPLError( CE_Fatal, CPLE_AppDefined, "Curve %li was not initialized.", oNextSerial.lNr);
return NULL;
}
poGeom = poCurve->clone();
break;
}
case L_TEKST: { /* text */
oGType = wkbMultiPoint;
OGRMultiPoint *poMP = (OGRMultiPoint*)(poParent->papoBuiltGeometries[oNextSerial.lNr]);
if (poMP == NULL) {
CPLError( CE_Fatal, CPLE_AppDefined, "Tekst %li was not initialized.", oNextSerial.lNr);
return NULL;
}
poGeom = poMP->clone();
break;
}
case L_SYMBOL: {
//CPLError( CE_Warning, CPLE_OpenFailed, "Geometry of type SYMBOL treated as point (PUNKT).");
}
case L_PUNKT: { /* point */
oGType = wkbPoint;
OGRPoint *poPoint = (OGRPoint*)(poParent->papoBuiltGeometries[oNextSerial.lNr]);
if (poPoint == NULL) {
CPLError( CE_Fatal, CPLE_AppDefined, "Point %li was not initialized.", oNextSerial.lNr);
return NULL;
}
poGeom = poPoint->clone();
break;
}
case L_DEF: /* skip user definitions and headers here */
case L_HODE: {
break;
}
default: { /* complain a bit about anything else that is not implemented */
CPLError( CE_Failure, CPLE_OpenFailed, "Unrecognized geometry of type %i.", nName);
break;
}
}
if (poGeom == NULL) continue; /* skipping L_HODE and unrecognized groups */
if (oGType != poFeatureDefn->GetGeomType()) {
if (poGeom != NULL) delete poGeom;
continue; /* skipping features that are not the correct geometry */
}
OGRFeature *poFeature = new OGRFeature( poFeatureDefn );
/* set all headers found in this group - we export everything, just in case */
for (iHeaders = oHeaders.begin(); iHeaders != oHeaders.end(); iHeaders++) {
OGRSOSIDataType *poType = SOSIGetType(iHeaders->first);
OGRSOSISimpleDataType *poElements = poType->getElements();
const char *pszLine = iHeaders->second.c_str();
char** tokens = CSLTokenizeString(iHeaders->second.c_str());
for (int k=0; k<poType->getElementCount(); k++) {
if (tokens[k] == 0) break;
if (strcmp(poElements[k].GetName(),"")==0) continue;
int iHNr = poHeaderDefn->find(poElements[k].GetName())->second;
if (iHNr == -1) {
CPLError( CE_Warning, CPLE_AppDefined, "Could not find field definition for %s.", poElements[k].GetName());
continue;
}
OGRFieldType nType = poElements[k].GetType();
switch (nType) {
case OFTInteger: {
poFeature->SetField( iHNr, SOSITypeToInt(tokens[k]));
break;
}
case OFTDate: {
int date[3];
SOSITypeToDate(tokens[k], date);
poFeature->SetField( iHNr, date[0], date[1], date[2]);
break;
}
case OFTDateTime: {
int date[6];
SOSITypeToDateTime(tokens[k], date);
if (date[0]>0)
poFeature->SetField( iHNr, date[0], date[1], date[2], date[3], date[4], static_cast<float>(date[5]), 1);
break;
}
case OFTReal: {
poFeature->SetField( iHNr, SOSITypeToReal(tokens[k]));
break;
}
default: {
if ((k==0)&&((pszLine[0] == '\'')||(pszLine[0] == '\"'))) { /* If the value is quoted, ignore these */
int nLen = static_cast<int>(strlen(pszLine));
char *pszNline = (char*)CPLMalloc(nLen-1);
strncpy(pszNline, pszLine+1, nLen-2);
pszNline[nLen-2] = '\0';
poFeature->SetField( iHNr, pszNline);
CPLFree(pszNline);
} else {
poFeature->SetField( iHNr, tokens[k]);
}
break;
}
}
}
CSLDestroy(tokens);
}
if( poGeom != NULL )
poGeom->assignSpatialReference(poParent->poSRS);
poFeature->SetGeometryDirectly( poGeom );
poFeature->SetFID( nNextFID++ );
/* Loop until we have a feature that matches the definition */
if ( (m_poFilterGeom == NULL || FilterGeometry( poFeature->GetGeometryRef() ) )
&& (m_poAttrQuery == NULL || m_poAttrQuery->Evaluate( poFeature )) )
return poFeature;
delete poFeature;
}
return NULL;
}
OGRFeature *OGRGMLLayer::GetNextFeature()
{
if (bWriter)
{
CPLError(CE_Failure, CPLE_NotSupported,
"Cannot read features when writing a GML file");
return NULL;
}
if( poDS->GetLastReadLayer() != this )
{
if( poDS->GetReadMode() != INTERLEAVED_LAYERS )
ResetReading();
poDS->SetLastReadLayer(this);
}
/* ==================================================================== */
/* Loop till we find and translate a feature meeting all our */
/* requirements. */
/* ==================================================================== */
while( true )
{
GMLFeature *poGMLFeature = NULL;
OGRGeometry *poGeom = NULL;
poGMLFeature = poDS->PeekStoredGMLFeature();
if (poGMLFeature != NULL)
poDS->SetStoredGMLFeature(NULL);
else
{
poGMLFeature = poDS->GetReader()->NextFeature();
if( poGMLFeature == NULL )
return NULL;
// We count reading low level GML features as a feature read for
// work checking purposes, though at least we didn't necessary
// have to turn it into an OGRFeature.
m_nFeaturesRead++;
}
/* -------------------------------------------------------------------- */
/* Is it of the proper feature class? */
/* -------------------------------------------------------------------- */
if( poGMLFeature->GetClass() != poFClass )
{
if( poDS->GetReadMode() == INTERLEAVED_LAYERS ||
(poDS->GetReadMode() == SEQUENTIAL_LAYERS && iNextGMLId != 0) )
{
CPLAssert(poDS->PeekStoredGMLFeature() == NULL);
poDS->SetStoredGMLFeature(poGMLFeature);
return NULL;
}
else
{
delete poGMLFeature;
continue;
}
}
/* -------------------------------------------------------------------- */
/* Extract the fid: */
/* -Assumes the fids are non-negative integers with an optional */
/* prefix */
/* -If a prefix differs from the prefix of the first feature from */
/* the poDS then the fids from the poDS are ignored and are */
/* assigned serially thereafter */
/* -------------------------------------------------------------------- */
GIntBig nFID = -1;
const char * pszGML_FID = poGMLFeature->GetFID();
if( bInvalidFIDFound )
{
nFID = iNextGMLId++;
}
else if( pszGML_FID == NULL )
{
bInvalidFIDFound = true;
nFID = iNextGMLId++;
}
else if( iNextGMLId == 0 )
{
int j = 0;
int i = static_cast<int>(strlen( pszGML_FID ))-1;
while( i >= 0 && pszGML_FID[i] >= '0'
&& pszGML_FID[i] <= '9' && j<20)
i--, j++;
/* i points the last character of the fid */
if( i >= 0 && j < 20 && pszFIDPrefix == NULL)
{
pszFIDPrefix = (char *) CPLMalloc(i+2);
pszFIDPrefix[i+1] = '\0';
strncpy(pszFIDPrefix, pszGML_FID, i+1);
}
/* pszFIDPrefix now contains the prefix or NULL if no prefix is found */
if( j < 20 && sscanf(pszGML_FID+i+1, CPL_FRMT_GIB, &nFID)==1)
{
if( iNextGMLId <= nFID )
iNextGMLId = nFID + 1;
}
else
{
bInvalidFIDFound = true;
nFID = iNextGMLId++;
}
}
else if( iNextGMLId != 0 )
{
const char* pszFIDPrefix_notnull = pszFIDPrefix;
if (pszFIDPrefix_notnull == NULL) pszFIDPrefix_notnull = "";
int nLenPrefix = static_cast<int>(strlen(pszFIDPrefix_notnull));
if( strncmp(pszGML_FID, pszFIDPrefix_notnull, nLenPrefix) == 0 &&
strlen(pszGML_FID+nLenPrefix) < 20 &&
sscanf(pszGML_FID+nLenPrefix, CPL_FRMT_GIB, &nFID) == 1 )
{ /* fid with the prefix. Using its numerical part */
if( iNextGMLId < nFID )
iNextGMLId = nFID + 1;
}
else
{ /* fid without the aforementioned prefix or a valid numerical part */
bInvalidFIDFound = true;
nFID = iNextGMLId++;
}
}
/* -------------------------------------------------------------------- */
/* Does it satisfy the spatial query, if there is one? */
/* -------------------------------------------------------------------- */
OGRGeometry** papoGeometries = NULL;
const CPLXMLNode* const * papsGeometry = poGMLFeature->GetGeometryList();
if( poFeatureDefn->GetGeomFieldCount() > 1 )
{
papoGeometries = (OGRGeometry**)
CPLCalloc( poFeatureDefn->GetGeomFieldCount(), sizeof(OGRGeometry*) );
const char* pszSRSName = poDS->GetGlobalSRSName();
for( int i=0; i < poFeatureDefn->GetGeomFieldCount(); i++ )
{
const CPLXMLNode* psGeom = poGMLFeature->GetGeometryRef(i);
if( psGeom != NULL )
{
const CPLXMLNode* myGeometryList[2];
myGeometryList[0] = psGeom;
myGeometryList[1] = NULL;
poGeom = GML_BuildOGRGeometryFromList(myGeometryList, true,
poDS->GetInvertAxisOrderIfLatLong(),
pszSRSName,
poDS->GetConsiderEPSGAsURN(),
poDS->GetSecondaryGeometryOption(),
hCacheSRS,
bFaceHoleNegative );
/* Do geometry type changes if needed to match layer geometry type */
if (poGeom != NULL)
{
papoGeometries[i] = OGRGeometryFactory::forceTo(poGeom,
poFeatureDefn->GetGeomFieldDefn(i)->GetType());
poGeom = NULL;
}
else
// We assume the createFromGML() function would have already
// reported the error.
{
for( i=0; i < poFeatureDefn->GetGeomFieldCount(); i++)
{
delete papoGeometries[i];
}
CPLFree(papoGeometries);
delete poGMLFeature;
return NULL;
}
}
}
if( m_poFilterGeom != NULL &&
m_iGeomFieldFilter >= 0 &&
m_iGeomFieldFilter < poFeatureDefn->GetGeomFieldCount() &&
papoGeometries[m_iGeomFieldFilter] &&
!FilterGeometry( papoGeometries[m_iGeomFieldFilter] ) )
{
for( int i=0; i < poFeatureDefn->GetGeomFieldCount(); i++ )
{
delete papoGeometries[i];
}
CPLFree(papoGeometries);
delete poGMLFeature;
continue;
}
}
else if (papsGeometry[0] != NULL)
{
const char* pszSRSName = poDS->GetGlobalSRSName();
poGeom = GML_BuildOGRGeometryFromList(papsGeometry, true,
poDS->GetInvertAxisOrderIfLatLong(),
pszSRSName,
poDS->GetConsiderEPSGAsURN(),
poDS->GetSecondaryGeometryOption(),
hCacheSRS,
bFaceHoleNegative );
/* Do geometry type changes if needed to match layer geometry type */
if (poGeom != NULL)
{
poGeom = OGRGeometryFactory::forceTo(poGeom, GetGeomType());
}
else
// We assume the createFromGML() function would have already
// reported the error.
{
delete poGMLFeature;
return NULL;
}
if( m_poFilterGeom != NULL && !FilterGeometry( poGeom ) )
{
delete poGMLFeature;
delete poGeom;
continue;
}
}
/* -------------------------------------------------------------------- */
/* Convert the whole feature into an OGRFeature. */
/* -------------------------------------------------------------------- */
int iField;
int iDstField = 0;
OGRFeature *poOGRFeature = new OGRFeature( poFeatureDefn );
poOGRFeature->SetFID( nFID );
if (poDS->ExposeId())
{
if (pszGML_FID)
poOGRFeature->SetField( iDstField, pszGML_FID );
iDstField ++;
}
int nPropertyCount = poFClass->GetPropertyCount();
for( iField = 0; iField < nPropertyCount; iField++, iDstField ++ )
{
const GMLProperty *psGMLProperty = poGMLFeature->GetProperty( iField );
if( psGMLProperty == NULL || psGMLProperty->nSubProperties == 0 )
continue;
switch( poFClass->GetProperty(iField)->GetType() )
{
case GMLPT_Real:
{
poOGRFeature->SetField( iDstField, CPLAtof(psGMLProperty->papszSubProperties[0]) );
}
break;
case GMLPT_IntegerList:
{
int nCount = psGMLProperty->nSubProperties;
int *panIntList = (int *) CPLMalloc(sizeof(int) * nCount );
for( int i = 0; i < nCount; i++ )
panIntList[i]
= atoi(psGMLProperty->papszSubProperties[i]);
poOGRFeature->SetField( iDstField, nCount, panIntList );
CPLFree( panIntList );
}
break;
case GMLPT_Integer64List:
{
int nCount = psGMLProperty->nSubProperties;
GIntBig *panIntList = (GIntBig *) CPLMalloc(sizeof(GIntBig) * nCount );
for( int i = 0; i < nCount; i++ )
panIntList[i]
= CPLAtoGIntBig(psGMLProperty->papszSubProperties[i]);
poOGRFeature->SetField( iDstField, nCount, panIntList );
CPLFree( panIntList );
}
break;
case GMLPT_RealList:
{
int nCount = psGMLProperty->nSubProperties;
double *padfList = (double *)CPLMalloc(sizeof(double)*nCount);
for( int i = 0; i < nCount; i++ )
padfList[i]
= CPLAtof(psGMLProperty->papszSubProperties[i]);
poOGRFeature->SetField( iDstField, nCount, padfList );
CPLFree( padfList );
}
break;
case GMLPT_StringList:
case GMLPT_FeaturePropertyList:
{
poOGRFeature->SetField( iDstField, psGMLProperty->papszSubProperties );
}
break;
case GMLPT_Boolean:
{
if( strcmp(psGMLProperty->papszSubProperties[0], "true") == 0 ||
strcmp(psGMLProperty->papszSubProperties[0], "1") == 0 )
{
poOGRFeature->SetField( iDstField, 1);
}
else if( strcmp(psGMLProperty->papszSubProperties[0], "false") == 0 ||
strcmp(psGMLProperty->papszSubProperties[0], "0") == 0 )
{
poOGRFeature->SetField( iDstField, 0);
}
else
poOGRFeature->SetField( iDstField, psGMLProperty->papszSubProperties[0] );
break;
}
case GMLPT_BooleanList:
{
int nCount = psGMLProperty->nSubProperties;
int *panIntList = (int *) CPLMalloc(sizeof(int) * nCount );
for( int i = 0; i < nCount; i++ )
{
panIntList[i] = (
strcmp(psGMLProperty->papszSubProperties[i],
"true") == 0 ||
strcmp(psGMLProperty->papszSubProperties[i],
"1") == 0 );
}
poOGRFeature->SetField( iDstField, nCount, panIntList );
CPLFree( panIntList );
break;
}
default:
poOGRFeature->SetField( iDstField, psGMLProperty->papszSubProperties[0] );
break;
}
}
delete poGMLFeature;
poGMLFeature = NULL;
/* Assign the geometry before the attribute filter because */
/* the attribute filter may use a special field like OGR_GEOMETRY */
if( papoGeometries != NULL )
{
for( int i=0; i < poFeatureDefn->GetGeomFieldCount(); i++ )
{
poOGRFeature->SetGeomFieldDirectly( i, papoGeometries[i] );
}
CPLFree(papoGeometries);
papoGeometries = NULL;
}
else
poOGRFeature->SetGeometryDirectly( poGeom );
/* Assign SRS */
for( int i=0; i < poFeatureDefn->GetGeomFieldCount(); i++ )
{
poGeom = poOGRFeature->GetGeomFieldRef(i);
if( poGeom != NULL )
{
OGRSpatialReference* poSRS
= poFeatureDefn->GetGeomFieldDefn(i)->GetSpatialRef();
if (poSRS != NULL)
poGeom->assignSpatialReference(poSRS);
}
}
/* -------------------------------------------------------------------- */
/* Test against the attribute query. */
/* -------------------------------------------------------------------- */
if( m_poAttrQuery != NULL
&& !m_poAttrQuery->Evaluate( poOGRFeature ) )
{
delete poOGRFeature;
continue;
}
/* -------------------------------------------------------------------- */
/* Wow, we got our desired feature. Return it. */
/* -------------------------------------------------------------------- */
return poOGRFeature;
}
return NULL;
}
void OGRPDFLayer::Fill( GDALPDFArray* poArray )
{
for(int i=0;i<poArray->GetLength();i++)
{
GDALPDFObject* poFeatureObj = poArray->Get(i);
if (poFeatureObj->GetType() != PDFObjectType_Dictionary)
continue;
GDALPDFObject* poA = poFeatureObj->GetDictionary()->Get("A");
if (!(poA != NULL && poA->GetType() == PDFObjectType_Dictionary))
continue;
GDALPDFObject* poP = poA->GetDictionary()->Get("P");
if (!(poP != NULL && poP->GetType() == PDFObjectType_Array))
continue;
GDALPDFObject* poK = poFeatureObj->GetDictionary()->Get("K");
int nK = -1;
if (poK != NULL && poK->GetType() == PDFObjectType_Int)
nK = poK->GetInt();
GDALPDFArray* poPArray = poP->GetArray();
int j;
for(j = 0;j<poPArray->GetLength();j++)
{
GDALPDFObject* poKV = poPArray->Get(j);
if (poKV->GetType() == PDFObjectType_Dictionary)
{
GDALPDFObject* poN = poKV->GetDictionary()->Get("N");
GDALPDFObject* poV = poKV->GetDictionary()->Get("V");
if (poN != NULL && poN->GetType() == PDFObjectType_String &&
poV != NULL)
{
int nIdx = GetLayerDefn()->GetFieldIndex( poN->GetString().c_str() );
OGRFieldType eType = OFTString;
if (poV->GetType() == PDFObjectType_Int)
eType = OFTInteger;
else if (poV->GetType() == PDFObjectType_Real)
eType = OFTReal;
if (nIdx < 0)
{
OGRFieldDefn oField(poN->GetString().c_str(), eType);
CreateField(&oField);
}
else if (GetLayerDefn()->GetFieldDefn(nIdx)->GetType() != eType &&
GetLayerDefn()->GetFieldDefn(nIdx)->GetType() != OFTString)
{
OGRFieldDefn oField(poN->GetString().c_str(), OFTString);
AlterFieldDefn( nIdx, &oField, ALTER_TYPE_FLAG );
}
}
}
}
OGRFeature* poFeature = new OGRFeature(GetLayerDefn());
for(j = 0;j<poPArray->GetLength();j++)
{
GDALPDFObject* poKV = poPArray->Get(j);
if (poKV->GetType() == PDFObjectType_Dictionary)
{
GDALPDFObject* poN = poKV->GetDictionary()->Get("N");
GDALPDFObject* poV = poKV->GetDictionary()->Get("V");
if (poN != NULL && poN->GetType() == PDFObjectType_String &&
poV != NULL)
{
if (poV->GetType() == PDFObjectType_String)
poFeature->SetField(poN->GetString().c_str(), poV->GetString().c_str());
else if (poV->GetType() == PDFObjectType_Int)
poFeature->SetField(poN->GetString().c_str(), poV->GetInt());
else if (poV->GetType() == PDFObjectType_Real)
poFeature->SetField(poN->GetString().c_str(), poV->GetReal());
}
}
}
if (nK >= 0)
{
OGRGeometry* poGeom = poDS->GetGeometryFromMCID(nK);
if (poGeom)
{
poGeom->assignSpatialReference(GetSpatialRef());
poFeature->SetGeometry(poGeom);
}
}
OGRGeometry* poGeom = poFeature->GetGeometryRef();
if( !bGeomTypeMixed && poGeom != NULL )
{
if (!bGeomTypeSet)
{
bGeomTypeSet = TRUE;
GetLayerDefn()->SetGeomType(poGeom->getGeometryType());
}
else if (GetLayerDefn()->GetGeomType() != poGeom->getGeometryType())
{
bGeomTypeMixed = TRUE;
GetLayerDefn()->SetGeomType(wkbUnknown);
}
}
ICreateFeature(poFeature);
delete poFeature;
}
}
OGRFeature *OGRMySQLLayer::RecordToFeature( char **papszRow,
unsigned long *panLengths )
{
mysql_field_seek( hResultSet, 0 );
/* -------------------------------------------------------------------- */
/* Create a feature from the current result. */
/* -------------------------------------------------------------------- */
int iField;
OGRFeature *poFeature = new OGRFeature( poFeatureDefn );
poFeature->SetFID( iNextShapeId );
m_nFeaturesRead++;
/* ==================================================================== */
/* Transfer all result fields we can. */
/* ==================================================================== */
for( iField = 0;
iField < (int) mysql_num_fields(hResultSet);
iField++ )
{
int iOGRField;
MYSQL_FIELD *psMSField = mysql_fetch_field(hResultSet);
/* -------------------------------------------------------------------- */
/* Handle FID. */
/* -------------------------------------------------------------------- */
if( bHasFid && EQUAL(psMSField->name,pszFIDColumn) )
{
if( papszRow[iField] == NULL )
{
CPLError( CE_Failure, CPLE_AppDefined,
"NULL primary key in RecordToFeature()" );
return NULL;
}
poFeature->SetFID( CPLAtoGIntBig(papszRow[iField]) );
}
if( papszRow[iField] == NULL )
{
// CPLDebug("MYSQL", "%s was null for %d", psMSField->name,
// iNextShapeId);
continue;
}
/* -------------------------------------------------------------------- */
/* Handle MySQL geometry */
/* -------------------------------------------------------------------- */
if( pszGeomColumn && EQUAL(psMSField->name,pszGeomColumn))
{
OGRGeometry *poGeometry = NULL;
// Geometry columns will have the first 4 bytes contain the SRID.
OGRGeometryFactory::createFromWkb(
((GByte *)papszRow[iField]) + 4,
NULL,
&poGeometry,
panLengths[iField] - 4 );
if( poGeometry != NULL )
{
poGeometry->assignSpatialReference( GetSpatialRef() );
poFeature->SetGeometryDirectly( poGeometry );
}
continue;
}
/* -------------------------------------------------------------------- */
/* Transfer regular data fields. */
/* -------------------------------------------------------------------- */
iOGRField = poFeatureDefn->GetFieldIndex(psMSField->name);
if( iOGRField < 0 )
continue;
OGRFieldDefn *psFieldDefn = poFeatureDefn->GetFieldDefn( iOGRField );
if( psFieldDefn->GetType() == OFTBinary )
{
poFeature->SetField( iOGRField, panLengths[iField],
(GByte *) papszRow[iField] );
}
else
{
poFeature->SetField( iOGRField, papszRow[iField] );
}
}
return poFeature;
}
OGRErr OGRGMLLayer::ICreateFeature( OGRFeature *poFeature )
{
int bIsGML3Output = poDS->IsGML3Output();
VSILFILE *fp = poDS->GetOutputFP();
int bWriteSpaceIndentation = poDS->WriteSpaceIndentation();
const char* pszPrefix = poDS->GetAppPrefix();
int bRemoveAppPrefix = poDS->RemoveAppPrefix();
if( !bWriter )
return OGRERR_FAILURE;
poFeature->FillUnsetWithDefault(TRUE, NULL);
if( !poFeature->Validate( OGR_F_VAL_ALL & ~OGR_F_VAL_GEOM_TYPE & ~OGR_F_VAL_ALLOW_NULL_WHEN_DEFAULT, TRUE ) )
return OGRERR_FAILURE;
if (bWriteSpaceIndentation)
VSIFPrintfL(fp, " ");
if (bIsGML3Output)
{
if( bRemoveAppPrefix )
poDS->PrintLine( fp, "<featureMember>" );
else
poDS->PrintLine( fp, "<%s:featureMember>", pszPrefix );
}
else
poDS->PrintLine( fp, "<gml:featureMember>" );
if( iNextGMLId == 0 )
{
bSameSRS = true;
for( int iGeomField = 1; iGeomField < poFeatureDefn->GetGeomFieldCount(); iGeomField++ )
{
OGRGeomFieldDefn *poFieldDefn0 = poFeatureDefn->GetGeomFieldDefn(0);
OGRGeomFieldDefn *poFieldDefn = poFeatureDefn->GetGeomFieldDefn(iGeomField);
OGRSpatialReference* poSRS0 = poFieldDefn0->GetSpatialRef();
OGRSpatialReference* poSRS = poFieldDefn->GetSpatialRef();
if( poSRS0 != NULL && poSRS == NULL )
bSameSRS = false;
else if( poSRS0 == NULL && poSRS != NULL )
bSameSRS = false;
else if( poSRS0 != NULL && poSRS != NULL &&
poSRS0 != poSRS && !poSRS0->IsSame(poSRS) )
{
bSameSRS = false;
}
}
}
if( poFeature->GetFID() == OGRNullFID )
poFeature->SetFID( iNextGMLId++ );
int nGMLIdIndex = -1;
if (bWriteSpaceIndentation)
VSIFPrintfL(fp, " ");
VSIFPrintfL(fp, "<");
if( !bRemoveAppPrefix )
VSIFPrintfL(fp, "%s:", pszPrefix);
if (bIsGML3Output)
{
nGMLIdIndex = poFeatureDefn->GetFieldIndex("gml_id");
if (nGMLIdIndex >= 0 && poFeature->IsFieldSet( nGMLIdIndex ) )
poDS->PrintLine( fp, "%s gml:id=\"%s\">",
poFeatureDefn->GetName(),
poFeature->GetFieldAsString(nGMLIdIndex) );
else
poDS->PrintLine( fp, "%s gml:id=\"%s." CPL_FRMT_GIB "\">",
poFeatureDefn->GetName(),
poFeatureDefn->GetName(),
poFeature->GetFID() );
}
else
{
nGMLIdIndex = poFeatureDefn->GetFieldIndex("fid");
if (bUseOldFIDFormat)
{
poDS->PrintLine( fp, "%s fid=\"F" CPL_FRMT_GIB "\">",
poFeatureDefn->GetName(),
poFeature->GetFID() );
}
else if (nGMLIdIndex >= 0 && poFeature->IsFieldSet( nGMLIdIndex ) )
{
poDS->PrintLine( fp, "%s fid=\"%s\">",
poFeatureDefn->GetName(),
poFeature->GetFieldAsString(nGMLIdIndex) );
}
else
{
poDS->PrintLine( fp, "%s fid=\"%s." CPL_FRMT_GIB "\">",
poFeatureDefn->GetName(),
poFeatureDefn->GetName(),
poFeature->GetFID() );
}
}
for( int iGeomField = 0; iGeomField < poFeatureDefn->GetGeomFieldCount(); iGeomField++ )
{
OGRGeomFieldDefn *poFieldDefn = poFeatureDefn->GetGeomFieldDefn(iGeomField);
// Write out Geometry - for now it isn't indented properly.
/* GML geometries don't like very much the concept of empty geometry */
OGRGeometry* poGeom = poFeature->GetGeomFieldRef(iGeomField);
if( poGeom != NULL && !poGeom->IsEmpty())
{
char *pszGeometry;
OGREnvelope3D sGeomBounds;
int nCoordDimension = poGeom->getCoordinateDimension();
poGeom->getEnvelope( &sGeomBounds );
if( bSameSRS )
poDS->GrowExtents( &sGeomBounds, nCoordDimension );
if (poGeom->getSpatialReference() == NULL && poFieldDefn->GetSpatialRef() != NULL)
poGeom->assignSpatialReference(poFieldDefn->GetSpatialRef());
if (bIsGML3Output && poDS->WriteFeatureBoundedBy())
{
bool bCoordSwap;
char* pszSRSName = GML_GetSRSName(poGeom->getSpatialReference(), poDS->IsLongSRSRequired(), &bCoordSwap);
char szLowerCorner[75], szUpperCorner[75];
if (bCoordSwap)
{
OGRMakeWktCoordinate(szLowerCorner, sGeomBounds.MinY, sGeomBounds.MinX, sGeomBounds.MinZ, nCoordDimension);
OGRMakeWktCoordinate(szUpperCorner, sGeomBounds.MaxY, sGeomBounds.MaxX, sGeomBounds.MaxZ, nCoordDimension);
}
else
{
OGRMakeWktCoordinate(szLowerCorner, sGeomBounds.MinX, sGeomBounds.MinY, sGeomBounds.MinZ, nCoordDimension);
OGRMakeWktCoordinate(szUpperCorner, sGeomBounds.MaxX, sGeomBounds.MaxY, sGeomBounds.MaxZ, nCoordDimension);
}
if (bWriteSpaceIndentation)
VSIFPrintfL(fp, " ");
poDS->PrintLine( fp, "<gml:boundedBy><gml:Envelope%s%s><gml:lowerCorner>%s</gml:lowerCorner><gml:upperCorner>%s</gml:upperCorner></gml:Envelope></gml:boundedBy>",
(nCoordDimension == 3) ? " srsDimension=\"3\"" : "",pszSRSName, szLowerCorner, szUpperCorner);
CPLFree(pszSRSName);
}
char** papszOptions = (bIsGML3Output) ? CSLAddString(NULL, "FORMAT=GML3") : NULL;
if (bIsGML3Output && !poDS->IsLongSRSRequired())
papszOptions = CSLAddString(papszOptions, "GML3_LONGSRS=NO");
const char* pszSRSDimensionLoc = poDS->GetSRSDimensionLoc();
if( pszSRSDimensionLoc != NULL )
papszOptions = CSLSetNameValue(papszOptions, "SRSDIMENSION_LOC", pszSRSDimensionLoc);
if (poDS->IsGML32Output())
{
if( poFeatureDefn->GetGeomFieldCount() > 1 )
papszOptions = CSLAddString(papszOptions,
CPLSPrintf("GMLID=%s.%s." CPL_FRMT_GIB,
poFeatureDefn->GetName(),
poFieldDefn->GetNameRef(),
poFeature->GetFID()));
else
papszOptions = CSLAddString(papszOptions,
CPLSPrintf("GMLID=%s.geom." CPL_FRMT_GIB,
poFeatureDefn->GetName(), poFeature->GetFID()));
}
if( !bIsGML3Output && OGR_GT_IsNonLinear(poGeom->getGeometryType()) )
{
OGRGeometry* poGeomTmp = OGRGeometryFactory::forceTo(
poGeom->clone(),OGR_GT_GetLinear(poGeom->getGeometryType()));
pszGeometry = poGeomTmp->exportToGML(papszOptions);
delete poGeomTmp;
}
else
pszGeometry = poGeom->exportToGML(papszOptions);
CSLDestroy(papszOptions);
if (bWriteSpaceIndentation)
VSIFPrintfL(fp, " ");
if( bRemoveAppPrefix )
poDS->PrintLine( fp, "<%s>%s</%s>",
poFieldDefn->GetNameRef(),
pszGeometry,
poFieldDefn->GetNameRef() );
else
poDS->PrintLine( fp, "<%s:%s>%s</%s:%s>",
pszPrefix, poFieldDefn->GetNameRef(),
pszGeometry,
pszPrefix, poFieldDefn->GetNameRef() );
CPLFree( pszGeometry );
}
}
// Write all "set" fields.
for( int iField = 0; iField < poFeatureDefn->GetFieldCount(); iField++ )
{
OGRFieldDefn *poFieldDefn = poFeatureDefn->GetFieldDefn( iField );
if( poFeature->IsFieldSet( iField ) && iField != nGMLIdIndex )
{
OGRFieldType eType = poFieldDefn->GetType();
if (eType == OFTStringList )
{
char ** papszIter = poFeature->GetFieldAsStringList( iField );
while( papszIter != NULL && *papszIter != NULL )
{
char *pszEscaped = OGRGetXML_UTF8_EscapedString( *papszIter );
GMLWriteField(poDS, fp, bWriteSpaceIndentation, pszPrefix,
bRemoveAppPrefix, poFieldDefn, pszEscaped);
CPLFree( pszEscaped );
papszIter ++;
}
}
else if (eType == OFTIntegerList )
{
int nCount = 0;
const int* panVals = poFeature->GetFieldAsIntegerList( iField, &nCount );
if( poFieldDefn->GetSubType() == OFSTBoolean )
{
for(int i = 0; i < nCount; i++)
{
/* 0 and 1 are OK, but the canonical representation is false and true */
GMLWriteField(poDS, fp, bWriteSpaceIndentation, pszPrefix,
bRemoveAppPrefix, poFieldDefn,
panVals[i] ? "true" : "false");
}
}
else
{
for(int i = 0; i < nCount; i++)
{
GMLWriteField(poDS, fp, bWriteSpaceIndentation, pszPrefix,
bRemoveAppPrefix, poFieldDefn,
CPLSPrintf("%d", panVals[i]));
}
}
}
else if (eType == OFTInteger64List )
{
int nCount = 0;
const GIntBig* panVals = poFeature->GetFieldAsInteger64List( iField, &nCount );
if( poFieldDefn->GetSubType() == OFSTBoolean )
{
for(int i = 0; i < nCount; i++)
{
/* 0 and 1 are OK, but the canonical representation is false and true */
GMLWriteField(poDS, fp, bWriteSpaceIndentation, pszPrefix,
bRemoveAppPrefix, poFieldDefn,
panVals[i] ? "true" : "false");
}
}
else
{
for(int i = 0; i < nCount; i++)
{
GMLWriteField(poDS, fp, bWriteSpaceIndentation, pszPrefix,
bRemoveAppPrefix, poFieldDefn,
CPLSPrintf(CPL_FRMT_GIB, panVals[i]));
}
}
}
else if (eType == OFTRealList )
{
int nCount = 0;
const double* padfVals = poFeature->GetFieldAsDoubleList( iField, &nCount );
for(int i = 0; i < nCount; i++)
{
char szBuffer[80];
CPLsnprintf( szBuffer, sizeof(szBuffer), "%.15g", padfVals[i]);
GMLWriteField(poDS, fp, bWriteSpaceIndentation, pszPrefix,
bRemoveAppPrefix, poFieldDefn, szBuffer);
}
}
else if ((eType == OFTInteger || eType == OFTInteger64) &&
poFieldDefn->GetSubType() == OFSTBoolean )
{
/* 0 and 1 are OK, but the canonical representation is false and true */
GMLWriteField(poDS, fp, bWriteSpaceIndentation, pszPrefix,
bRemoveAppPrefix, poFieldDefn,
(poFeature->GetFieldAsInteger(iField)) ? "true" : "false");
}
else
{
const char *pszRaw = poFeature->GetFieldAsString( iField );
char *pszEscaped = OGRGetXML_UTF8_EscapedString( pszRaw );
GMLWriteField(poDS, fp, bWriteSpaceIndentation, pszPrefix,
bRemoveAppPrefix, poFieldDefn, pszEscaped);
CPLFree( pszEscaped );
}
}
}
if (bWriteSpaceIndentation)
VSIFPrintfL(fp, " ");
if( bRemoveAppPrefix )
poDS->PrintLine( fp, "</%s>", poFeatureDefn->GetName() );
else
poDS->PrintLine( fp, "</%s:%s>", pszPrefix, poFeatureDefn->GetName() );
if (bWriteSpaceIndentation)
VSIFPrintfL(fp, " ");
if (bIsGML3Output)
{
if( bRemoveAppPrefix )
poDS->PrintLine( fp, "</featureMember>" );
else
poDS->PrintLine( fp, "</%s:featureMember>", pszPrefix );
}
else
poDS->PrintLine( fp, "</gml:featureMember>" );
return OGRERR_NONE;
}
OGRFeature *OGRPGeoLayer::GetNextRawFeature()
{
OGRErr err = OGRERR_NONE;
if( GetStatement() == NULL )
return NULL;
/* -------------------------------------------------------------------- */
/* If we are marked to restart then do so, and fetch a record. */
/* -------------------------------------------------------------------- */
if( !poStmt->Fetch() )
{
delete poStmt;
poStmt = NULL;
return NULL;
}
/* -------------------------------------------------------------------- */
/* Create a feature from the current result. */
/* -------------------------------------------------------------------- */
int iField;
OGRFeature *poFeature = new OGRFeature( poFeatureDefn );
if( pszFIDColumn != NULL && poStmt->GetColId(pszFIDColumn) > -1 )
poFeature->SetFID(
atoi(poStmt->GetColData(poStmt->GetColId(pszFIDColumn))) );
else
poFeature->SetFID( iNextShapeId );
iNextShapeId++;
m_nFeaturesRead++;
/* -------------------------------------------------------------------- */
/* Set the fields. */
/* -------------------------------------------------------------------- */
for( iField = 0; iField < poFeatureDefn->GetFieldCount(); iField++ )
{
int iSrcField = panFieldOrdinals[iField]-1;
const char *pszValue = poStmt->GetColData( iSrcField );
if( pszValue == NULL )
/* no value */;
else if( poFeature->GetFieldDefnRef(iField)->GetType() == OFTBinary )
poFeature->SetField( iField,
poStmt->GetColDataLength(iSrcField),
(GByte *) pszValue );
else
poFeature->SetField( iField, pszValue );
}
/* -------------------------------------------------------------------- */
/* Try to extract a geometry. */
/* -------------------------------------------------------------------- */
if( pszGeomColumn != NULL )
{
int iField = poStmt->GetColId( pszGeomColumn );
GByte *pabyShape = (GByte *) poStmt->GetColData( iField );
int nBytes = poStmt->GetColDataLength(iField);
OGRGeometry *poGeom = NULL;
if( pabyShape != NULL )
{
err = OGRCreateFromShapeBin( pabyShape, &poGeom, nBytes );
if( OGRERR_NONE != err )
{
CPLDebug( "PGeo",
"Translation shape binary to OGR geometry failed (FID=%ld)",
(long)poFeature->GetFID() );
}
}
if( poGeom != NULL && OGRERR_NONE == err )
{
poGeom->assignSpatialReference( poSRS );
poFeature->SetGeometryDirectly( poGeom );
}
}
return poFeature;
}
OGRFeature *OGRDB2Layer::GetNextRawFeature()
{
if( GetStatement() == nullptr )
return nullptr;
/* -------------------------------------------------------------------- */
/* If we are marked to restart then do so, and fetch a record. */
/* -------------------------------------------------------------------- */
if( !m_poStmt->Fetch() ) // fail is normal for final fetch
{
// CPLDebug("OGR_DB2Layer::GetNextRawFeature","Fetch failed");
delete m_poStmt;
m_poStmt = nullptr;
return nullptr;
}
// CPLDebug("OGR_DB2Layer::GetNextRawFeature","Create feature");
/* -------------------------------------------------------------------- */
/* Create a feature from the current result. */
/* -------------------------------------------------------------------- */
int iField;
OGRFeature *poFeature = new OGRFeature( poFeatureDefn );
if( pszFIDColumn != nullptr && m_poStmt->GetColId(pszFIDColumn) > -1 )
poFeature->SetFID(
atoi(m_poStmt->GetColData(m_poStmt->GetColId(pszFIDColumn))) );
else
poFeature->SetFID( iNextShapeId );
iNextShapeId++;
m_nFeaturesRead++;
/* -------------------------------------------------------------------- */
/* Set the fields. */
/* -------------------------------------------------------------------- */
for( iField = 0; iField < poFeatureDefn->GetFieldCount(); iField++ )
{
if ( poFeatureDefn->GetFieldDefn(iField)->IsIgnored() )
continue;
int iSrcField = panFieldOrdinals[iField];
const char *pszValue = m_poStmt->GetColData( iSrcField );
if( pszValue == nullptr )
poFeature->SetFieldNull( iField );
else if( poFeature->GetFieldDefnRef(iField)->GetType() == OFTBinary )
poFeature->SetField( iField,
m_poStmt->GetColDataLength(iSrcField),
(GByte *) pszValue );
else
poFeature->SetField( iField, pszValue );
}
/* -------------------------------------------------------------------- */
/* Try to extract a geometry. */
/* -------------------------------------------------------------------- */
if( pszGeomColumn != nullptr && !poFeatureDefn->IsGeometryIgnored())
{
iField = m_poStmt->GetColId( pszGeomColumn );
const char *pszGeomText = m_poStmt->GetColData( iField );
OGRGeometry *poGeom = nullptr;
OGRErr eErr = OGRERR_NONE;
if( pszGeomText != nullptr )
{
eErr = OGRGeometryFactory::createFromWkt(pszGeomText,
nullptr, &poGeom);
}
if ( eErr != OGRERR_NONE )
{
const char *pszMessage;
switch ( eErr )
{
case OGRERR_NOT_ENOUGH_DATA:
pszMessage = "Not enough data to deserialize";
break;
case OGRERR_UNSUPPORTED_GEOMETRY_TYPE:
pszMessage = "Unsupported geometry type";
break;
case OGRERR_CORRUPT_DATA:
pszMessage = "Corrupt data";
break;
default:
pszMessage = "Unrecognized error";
}
CPLError(CE_Failure, CPLE_AppDefined,
"GetNextRawFeature(): %s", pszMessage);
}
if( poGeom != nullptr )
{
if ( GetSpatialRef() )
poGeom->assignSpatialReference( poSRS );
poFeature->SetGeometryDirectly( poGeom );
}
}
return poFeature;
}
OGRErr OGRMemLayer::ISetFeature( OGRFeature *poFeature )
{
if (!bUpdatable)
return OGRERR_FAILURE;
if( poFeature == NULL )
return OGRERR_FAILURE;
if( poFeature->GetFID() == OGRNullFID )
{
while( iNextCreateFID < nMaxFeatureCount
&& papoFeatures[iNextCreateFID] != NULL )
iNextCreateFID++;
poFeature->SetFID( iNextCreateFID++ );
}
else if ( poFeature->GetFID() < OGRNullFID )
{
CPLError(CE_Failure, CPLE_NotSupported,
"negative FID are not supported");
return OGRERR_FAILURE;
}
if( poFeature->GetFID() >= nMaxFeatureCount )
{
GIntBig nNewCount = MAX(2*nMaxFeatureCount+10, poFeature->GetFID() + 1 );
if( (GIntBig)(size_t)(sizeof(OGRFeature *) * nNewCount) !=
(GIntBig)sizeof(OGRFeature *) * nNewCount )
{
CPLError(CE_Failure, CPLE_OutOfMemory,
"Cannot allocate array of " CPL_FRMT_GIB " elements", nNewCount);
return OGRERR_FAILURE;
}
OGRFeature** papoNewFeatures = (OGRFeature **)
VSIRealloc( papoFeatures, (size_t)(sizeof(OGRFeature *) * nNewCount) );
if (papoNewFeatures == NULL)
{
CPLError(CE_Failure, CPLE_OutOfMemory,
"Cannot allocate array of " CPL_FRMT_GIB " elements", nNewCount);
return OGRERR_FAILURE;
}
papoFeatures = papoNewFeatures;
memset( papoFeatures + nMaxFeatureCount, 0,
sizeof(OGRFeature *) * (size_t)(nNewCount - nMaxFeatureCount) );
nMaxFeatureCount = nNewCount;
}
if( papoFeatures[poFeature->GetFID()] != NULL )
{
delete papoFeatures[poFeature->GetFID()];
papoFeatures[poFeature->GetFID()] = NULL;
nFeatureCount--;
}
papoFeatures[poFeature->GetFID()] = poFeature->Clone();
int i;
for(i = 0; i < poFeatureDefn->GetGeomFieldCount(); i ++)
{
OGRGeometry* poGeom = papoFeatures[poFeature->GetFID()]->GetGeomFieldRef(i);
if( poGeom != NULL && poGeom->getSpatialReference() == NULL )
{
poGeom->assignSpatialReference(
poFeatureDefn->GetGeomFieldDefn(i)->GetSpatialRef());
}
}
nFeatureCount++;
return OGRERR_NONE;
}
OGRFeature *OGRGMLLayer::GetNextFeature()
{
GMLFeature *poGMLFeature = NULL;
OGRGeometry *poGeom = NULL;
if (bWriter)
{
CPLError(CE_Failure, CPLE_NotSupported,
"Cannot read features when writing a GML file");
return NULL;
}
if( iNextGMLId == 0 )
ResetReading();
/* ==================================================================== */
/* Loop till we find and translate a feature meeting all our */
/* requirements. */
/* ==================================================================== */
while( TRUE )
{
/* -------------------------------------------------------------------- */
/* Cleanup last feature, and get a new raw gml feature. */
/* -------------------------------------------------------------------- */
if( poGMLFeature != NULL )
delete poGMLFeature;
if( poGeom != NULL )
{
delete poGeom;
poGeom = NULL;
}
poGMLFeature = poDS->GetReader()->NextFeature();
if( poGMLFeature == NULL )
return NULL;
/* -------------------------------------------------------------------- */
/* Is it of the proper feature class? */
/* -------------------------------------------------------------------- */
// We count reading low level GML features as a feature read for
// work checking purposes, though at least we didn't necessary
// have to turn it into an OGRFeature.
m_nFeaturesRead++;
if( poGMLFeature->GetClass() != poFClass )
continue;
/* -------------------------------------------------------------------- */
/* Extract the fid: */
/* -Assumes the fids are non-negative integers with an optional */
/* prefix */
/* -If a prefix differs from the prefix of the first feature from */
/* the poDS then the fids from the poDS are ignored and are */
/* assigned serially thereafter */
/* -------------------------------------------------------------------- */
int nFID = -1;
const char * pszGML_FID = poGMLFeature->GetFID();
if( bInvalidFIDFound )
{
nFID = iNextGMLId++;
}
else if( pszGML_FID == NULL )
{
bInvalidFIDFound = TRUE;
nFID = iNextGMLId++;
}
else if( iNextGMLId == 0 )
{
int i = strlen( pszGML_FID )-1, j = 0;
while( i >= 0 && pszGML_FID[i] >= '0'
&& pszGML_FID[i] <= '9' && j<8)
i--, j++;
/* i points the last character of the fid */
if( i >= 0 && j < 8 && pszFIDPrefix == NULL)
{
pszFIDPrefix = (char *) CPLMalloc(i+2);
pszFIDPrefix[i+1] = '\0';
strncpy(pszFIDPrefix, pszGML_FID, i+1);
}
/* pszFIDPrefix now contains the prefix or NULL if no prefix is found */
if( j < 8 && sscanf(pszGML_FID+i+1, "%d", &nFID)==1)
{
if( iNextGMLId <= nFID )
iNextGMLId = nFID + 1;
}
else
{
bInvalidFIDFound = TRUE;
nFID = iNextGMLId++;
}
}
else if( iNextGMLId != 0 )
{
const char* pszFIDPrefix_notnull = pszFIDPrefix;
if (pszFIDPrefix_notnull == NULL) pszFIDPrefix_notnull = "";
int nLenPrefix = strlen(pszFIDPrefix_notnull);
if( strncmp(pszGML_FID, pszFIDPrefix_notnull, nLenPrefix) == 0 &&
strlen(pszGML_FID+nLenPrefix) <= 9 &&
sscanf(pszGML_FID+nLenPrefix, "%d", &nFID) == 1 )
{ /* fid with the prefix. Using its numerical part */
if( iNextGMLId < nFID )
iNextGMLId = nFID + 1;
}
else
{ /* fid without the aforementioned prefix or a valid numerical part */
bInvalidFIDFound = TRUE;
nFID = iNextGMLId++;
}
}
/* -------------------------------------------------------------------- */
/* Does it satisfy the spatial query, if there is one? */
/* -------------------------------------------------------------------- */
char** papszGeometryList = poGMLFeature->GetGeometryList();
if( papszGeometryList != NULL )
{
const char* pszSRSName = poDS->GetGlobalSRSName();
poGeom = GML_BuildOGRGeometryFromList(papszGeometryList, TRUE,
m_bInvertAxisOrderIfLatLong, pszSRSName);
if (poGeom != NULL && poSRS != NULL)
poGeom->assignSpatialReference(poSRS);
// We assume the createFromGML() function would have already
// reported the error.
if( poGeom == NULL )
{
delete poGMLFeature;
return NULL;
}
if( m_poFilterGeom != NULL && !FilterGeometry( poGeom ) )
continue;
}
/* -------------------------------------------------------------------- */
/* Convert the whole feature into an OGRFeature. */
/* -------------------------------------------------------------------- */
int iField;
int iDstField = 0;
OGRFeature *poOGRFeature = new OGRFeature( GetLayerDefn() );
poOGRFeature->SetFID( nFID );
if (poDS->ExposeGMLId())
{
if (pszGML_FID)
poOGRFeature->SetField( iDstField, pszGML_FID );
iDstField ++;
}
for( iField = 0; iField < poFClass->GetPropertyCount(); iField++, iDstField ++ )
{
const GMLProperty *psGMLProperty = poGMLFeature->GetProperty( iField );
if( psGMLProperty == NULL || psGMLProperty->nSubProperties == 0 )
continue;
switch( poFClass->GetProperty(iField)->GetType() )
{
case GMLPT_Real:
{
poOGRFeature->SetField( iDstField, CPLAtof(psGMLProperty->papszSubProperties[0]) );
}
break;
case GMLPT_IntegerList:
{
int nCount = psGMLProperty->nSubProperties;
int *panIntList = (int *) CPLMalloc(sizeof(int) * nCount );
int i;
for( i = 0; i < nCount; i++ )
panIntList[i] = atoi(psGMLProperty->papszSubProperties[i]);
poOGRFeature->SetField( iDstField, nCount, panIntList );
CPLFree( panIntList );
}
break;
case GMLPT_RealList:
{
int nCount = psGMLProperty->nSubProperties;
double *padfList = (double *)CPLMalloc(sizeof(double)*nCount);
int i;
for( i = 0; i < nCount; i++ )
padfList[i] = CPLAtof(psGMLProperty->papszSubProperties[i]);
poOGRFeature->SetField( iDstField, nCount, padfList );
CPLFree( padfList );
}
break;
case GMLPT_StringList:
{
poOGRFeature->SetField( iDstField, psGMLProperty->papszSubProperties );
}
break;
default:
poOGRFeature->SetField( iDstField, psGMLProperty->papszSubProperties[0] );
break;
}
}
/* -------------------------------------------------------------------- */
/* Test against the attribute query. */
/* -------------------------------------------------------------------- */
if( m_poAttrQuery != NULL
&& !m_poAttrQuery->Evaluate( poOGRFeature ) )
{
delete poOGRFeature;
continue;
}
/* -------------------------------------------------------------------- */
/* Wow, we got our desired feature. Return it. */
/* -------------------------------------------------------------------- */
delete poGMLFeature;
poOGRFeature->SetGeometryDirectly( poGeom );
return poOGRFeature;
}
return NULL;
}
OGRGeometry* GML_BuildOGRGeometryFromList(const CPLXMLNode* const * papsGeometry,
int bTryToMakeMultipolygons,
int bInvertAxisOrderIfLatLong,
const char* pszDefaultSRSName,
int bConsiderEPSGAsURN,
int bGetSecondaryGeometryOption,
void* hCacheSRS,
int bFaceHoleNegative)
{
OGRGeometry* poGeom = NULL;
int i;
OGRGeometryCollection* poCollection = NULL;
for(i=0;papsGeometry[i] != NULL;i++)
{
OGRGeometry* poSubGeom = GML2OGRGeometry_XMLNode( papsGeometry[i],
bGetSecondaryGeometryOption,
0, 0, FALSE, TRUE,
bFaceHoleNegative );
if (poSubGeom)
{
if (poGeom == NULL)
poGeom = poSubGeom;
else
{
if (poCollection == NULL)
{
if (bTryToMakeMultipolygons &&
wkbFlatten(poGeom->getGeometryType()) == wkbPolygon &&
wkbFlatten(poSubGeom->getGeometryType()) == wkbPolygon)
{
OGRGeometryCollection* poGeomColl = new OGRMultiPolygon();
poGeomColl->addGeometryDirectly(poGeom);
poGeomColl->addGeometryDirectly(poSubGeom);
poGeom = poGeomColl;
}
else if (bTryToMakeMultipolygons &&
wkbFlatten(poGeom->getGeometryType()) == wkbMultiPolygon &&
wkbFlatten(poSubGeom->getGeometryType()) == wkbPolygon)
{
OGRGeometryCollection* poGeomColl = (OGRGeometryCollection* )poGeom;
poGeomColl->addGeometryDirectly(poSubGeom);
}
else if (bTryToMakeMultipolygons &&
wkbFlatten(poGeom->getGeometryType()) == wkbMultiPolygon &&
wkbFlatten(poSubGeom->getGeometryType()) == wkbMultiPolygon)
{
OGRGeometryCollection* poGeomColl = (OGRGeometryCollection* )poGeom;
OGRGeometryCollection* poGeomColl2 = (OGRGeometryCollection* )poSubGeom;
int nCount = poGeomColl2->getNumGeometries();
int i;
for(i=0;i<nCount;i++)
{
poGeomColl->addGeometry(poGeomColl2->getGeometryRef(i));
}
delete poSubGeom;
}
else if (bTryToMakeMultipolygons &&
wkbFlatten(poGeom->getGeometryType()) == wkbMultiPolygon)
{
delete poGeom;
delete poSubGeom;
return GML_BuildOGRGeometryFromList(papsGeometry, FALSE,
bInvertAxisOrderIfLatLong,
pszDefaultSRSName,
bConsiderEPSGAsURN,
bGetSecondaryGeometryOption,
hCacheSRS);
}
else
{
poCollection = new OGRGeometryCollection();
poCollection->addGeometryDirectly(poGeom);
poGeom = poCollection;
}
}
if (poCollection != NULL)
{
poCollection->addGeometryDirectly(poSubGeom);
}
}
}
}
if( poGeom == NULL )
return NULL;
std::string osWork;
const char* pszSRSName = GML_ExtractSrsNameFromGeometry(papsGeometry, osWork,
bConsiderEPSGAsURN);
const char* pszNameLookup = pszSRSName;
if( pszNameLookup == NULL )
pszNameLookup = pszDefaultSRSName;
if (pszNameLookup != NULL)
{
SRSCache* poSRSCache = (SRSCache*)hCacheSRS;
SRSDesc& oSRSDesc = poSRSCache->Get(pszNameLookup);
poGeom->assignSpatialReference(oSRSDesc.poSRS);
if (oSRSDesc.bAxisInvert && bInvertAxisOrderIfLatLong)
poGeom->swapXY();
}
return poGeom;
}
static OGRGeometry *kml2geom_rec (
GeometryPtr poKmlGeometry,
OGRSpatialReference *poOgrSRS)
{
/***** ogr geom vars *****/
OGRPoint *poOgrPoint;
OGRLineString *poOgrLineString;
OGRLinearRing *poOgrLinearRing;
OGRPolygon *poOgrPolygon;
OGRGeometryCollection *poOgrMultiGeometry;
OGRGeometry *poOgrGeometry = NULL;
OGRGeometry *poOgrTmpGeometry = NULL;
/***** libkml geom vars *****/
CoordinatesPtr poKmlCoordinates;
PointPtr poKmlPoint;
LineStringPtr poKmlLineString;
LinearRingPtr poKmlLinearRing;
OuterBoundaryIsPtr poKmlOuterRing;
InnerBoundaryIsPtr poKmlInnerRing;
PolygonPtr poKmlPolygon;
MultiGeometryPtr poKmlMultiGeometry;
GxTrackPtr poKmlGxTrack;
GxMultiTrackPtr poKmlGxMultiTrack;
GeometryPtr poKmlTmpGeometry;
Vec3 oKmlVec;
size_t nRings,
nCoords,
nGeom,
i;
switch ( poKmlGeometry->Type ( ) ) {
case kmldom::Type_Point:
poKmlPoint = AsPoint ( poKmlGeometry );
if ( poKmlPoint->has_coordinates ( ) ) {
poKmlCoordinates = poKmlPoint->get_coordinates ( );
nCoords = poKmlCoordinates->get_coordinates_array_size ( );
if (nCoords > 0)
{
oKmlVec = poKmlCoordinates->get_coordinates_array_at ( 0 );
if ( oKmlVec.has_altitude ( ) )
poOgrPoint = new OGRPoint ( oKmlVec.get_longitude ( ),
oKmlVec.get_latitude ( ),
oKmlVec.get_altitude ( ) );
else
poOgrPoint = new OGRPoint ( oKmlVec.get_longitude ( ),
oKmlVec.get_latitude ( ) );
poOgrGeometry = poOgrPoint;
}
else
{
poOgrGeometry = new OGRPoint();
}
}
else
{
poOgrGeometry = new OGRPoint();
}
break;
case kmldom::Type_LineString:
poKmlLineString = AsLineString ( poKmlGeometry );
poOgrLineString = new OGRLineString ( );
if ( poKmlLineString->has_coordinates ( ) ) {
poKmlCoordinates = poKmlLineString->get_coordinates ( );
nCoords = poKmlCoordinates->get_coordinates_array_size ( );
for ( i = 0; i < nCoords; i++ ) {
oKmlVec = poKmlCoordinates->get_coordinates_array_at ( i );
if ( oKmlVec.has_altitude ( ) )
poOgrLineString->
addPoint ( oKmlVec.get_longitude ( ),
oKmlVec.get_latitude ( ),
oKmlVec.get_altitude ( ) );
else
poOgrLineString->
addPoint ( oKmlVec.get_longitude ( ),
oKmlVec.get_latitude ( ) );
}
}
poOgrGeometry = poOgrLineString;
break;
case kmldom::Type_LinearRing:
poKmlLinearRing = AsLinearRing ( poKmlGeometry );
poOgrLinearRing = new OGRLinearRing ( );
if ( poKmlLinearRing->has_coordinates ( ) ) {
poKmlCoordinates = poKmlLinearRing->get_coordinates ( );
nCoords = poKmlCoordinates->get_coordinates_array_size ( );
for ( i = 0; i < nCoords; i++ ) {
oKmlVec = poKmlCoordinates->get_coordinates_array_at ( i );
if ( oKmlVec.has_altitude ( ) )
poOgrLinearRing->
addPoint ( oKmlVec.get_longitude ( ),
oKmlVec.get_latitude ( ),
oKmlVec.get_altitude ( ) );
else
poOgrLinearRing->
addPoint ( oKmlVec.get_longitude ( ),
oKmlVec.get_latitude ( ) );
}
}
poOgrGeometry = poOgrLinearRing;
break;
case kmldom::Type_Polygon:
poKmlPolygon = AsPolygon ( poKmlGeometry );
poOgrPolygon = new OGRPolygon ( );
if ( poKmlPolygon->has_outerboundaryis ( ) ) {
poKmlOuterRing = poKmlPolygon->get_outerboundaryis ( );
poKmlLinearRing = poKmlOuterRing->get_linearring ( );
if (poKmlLinearRing)
{
poOgrTmpGeometry = kml2geom_rec ( poKmlLinearRing, poOgrSRS );
poOgrPolygon->
addRingDirectly ( ( OGRLinearRing * ) poOgrTmpGeometry );
}
}
nRings = poKmlPolygon->get_innerboundaryis_array_size ( );
for ( i = 0; i < nRings; i++ ) {
poKmlInnerRing = poKmlPolygon->get_innerboundaryis_array_at ( i );
poKmlLinearRing = poKmlInnerRing->get_linearring ( );
if (poKmlLinearRing)
{
poOgrTmpGeometry = kml2geom_rec ( poKmlLinearRing, poOgrSRS );
poOgrPolygon->
addRingDirectly ( ( OGRLinearRing * ) poOgrTmpGeometry );
}
}
poOgrGeometry = poOgrPolygon;
break;
case kmldom::Type_MultiGeometry:
{
poKmlMultiGeometry = AsMultiGeometry ( poKmlGeometry );
nGeom = poKmlMultiGeometry->get_geometry_array_size ( );
// Detect subgeometry type to instantiate appropriate
// multi geometry type.
kmldom::KmlDomType type = kmldom::Type_Unknown;
for ( i = 0; i < nGeom; i++ ) {
poKmlTmpGeometry = poKmlMultiGeometry->get_geometry_array_at ( i );
if (type == kmldom::Type_Unknown)
type = poKmlTmpGeometry->Type();
else if (type != poKmlTmpGeometry->Type())
{
type = kmldom::Type_Unknown;
break;
}
}
if (type == kmldom::Type_Point)
poOgrMultiGeometry = new OGRMultiPoint();
else if (type == kmldom::Type_LineString)
poOgrMultiGeometry = new OGRMultiLineString();
else if (type == kmldom::Type_Polygon)
poOgrMultiGeometry = new OGRMultiPolygon();
else
poOgrMultiGeometry = new OGRGeometryCollection ();
for ( i = 0; i < nGeom; i++ ) {
poKmlTmpGeometry = poKmlMultiGeometry->get_geometry_array_at ( i );
poOgrTmpGeometry = kml2geom_rec ( poKmlTmpGeometry, poOgrSRS );
poOgrMultiGeometry->addGeometryDirectly ( poOgrTmpGeometry );
}
poOgrGeometry = poOgrMultiGeometry;
break;
}
case kmldom::Type_GxTrack:
poKmlGxTrack = AsGxTrack ( poKmlGeometry );
nCoords = poKmlGxTrack->get_gx_coord_array_size();
poOgrLineString = new OGRLineString ( );
for ( i = 0; i < nCoords; i++ ) {
oKmlVec = poKmlGxTrack->get_gx_coord_array_at ( i );
if ( oKmlVec.has_altitude ( ) )
poOgrLineString->
addPoint ( oKmlVec.get_longitude ( ),
oKmlVec.get_latitude ( ),
oKmlVec.get_altitude ( ) );
else
poOgrLineString->
addPoint ( oKmlVec.get_longitude ( ),
oKmlVec.get_latitude ( ) );
}
poOgrGeometry = poOgrLineString;
break;
case kmldom::Type_GxMultiTrack:
{
poKmlGxMultiTrack = AsGxMultiTrack ( poKmlGeometry );
nGeom = poKmlGxMultiTrack->get_gx_track_array_size ( );
poOgrMultiGeometry = new OGRMultiLineString();
for( size_t j = 0; j < nGeom; j++ )
{
poKmlGxTrack = poKmlGxMultiTrack->get_gx_track_array_at ( j );
nCoords = poKmlGxTrack->get_gx_coord_array_size();
poOgrLineString = new OGRLineString ( );
for ( i = 0; i < nCoords; i++ ) {
oKmlVec = poKmlGxTrack->get_gx_coord_array_at ( i );
if ( oKmlVec.has_altitude ( ) )
poOgrLineString->
addPoint ( oKmlVec.get_longitude ( ),
oKmlVec.get_latitude ( ),
oKmlVec.get_altitude ( ) );
else
poOgrLineString->
addPoint ( oKmlVec.get_longitude ( ),
oKmlVec.get_latitude ( ) );
}
poOgrMultiGeometry->addGeometryDirectly(poOgrLineString);
}
poOgrGeometry = poOgrMultiGeometry;
break;
}
default:
break;
}
if (poOgrGeometry)
poOgrGeometry->assignSpatialReference(poOgrSRS);
return poOgrGeometry;
}