void OGRILI1Layer::JoinSurfaceLayer( OGRILI1Layer* poSurfaceLineLayer, int nSurfaceFieldIndex )
{
CPLDebug( "OGR_ILI", "Joining surface layer %s with geometries", GetLayerDefn()->GetName());
OGRwkbGeometryType geomType = GetLayerDefn()->GetGeomFieldDefn(nSurfaceFieldIndex)->GetType();
poSurfaceLineLayer->ResetReading();
while (OGRFeature *linefeature = poSurfaceLineLayer->GetNextFeatureRef()) {
//OBJE entries with same _RefTID are polygon rings of same feature
//TODO: non-numeric _RefTID/FID is not supported yet!
GIntBig reftid = linefeature->GetFieldAsInteger64(1); //_RefTID
OGRFeature *feature = GetFeatureRef((int)reftid);
if (feature) {
OGRCurvePolygon *poly;
if (feature->GetGeomFieldRef(nSurfaceFieldIndex)) {
CPLDebug( "OGR_ILI", "Adding ring to FID " CPL_FRMT_GIB, reftid );
poly = (OGRCurvePolygon *)feature->GetGeomFieldRef(nSurfaceFieldIndex);
} else {
poly = (geomType == wkbPolygon) ? new OGRPolygon() : new OGRCurvePolygon();
feature->SetGeomFieldDirectly(nSurfaceFieldIndex, poly);
}
OGRMultiCurve *lines = (OGRMultiCurve*)linefeature->GetGeomFieldRef(0);
for( int i = 0; i < lines->getNumGeometries(); i++ ) {
OGRCurve *line = (OGRCurve*)lines->getGeometryRef(i);
OGRCurve *ring = (geomType == wkbPolygon) ?
OGRCurve::CastToLinearRing((OGRCurve*)line->clone()) :
(OGRCurve*)line->clone();
poly->addRingDirectly(ring);
}
} else {
CPLError(CE_Warning, CPLE_AppDefined, "Couldn't join feature FID " CPL_FRMT_GIB, reftid );
}
}
ResetReading();
poSurfaceLineLayer = 0;
}
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;
}
OGRFeature *OGRPGResultLayer::GetNextFeature()
{
OGRPGGeomFieldDefn* poGeomFieldDefn = NULL;
if( poFeatureDefn->GetGeomFieldCount() != 0 )
poGeomFieldDefn = poFeatureDefn->myGetGeomFieldDefn(m_iGeomFieldFilter);
for( ; TRUE; )
{
OGRFeature *poFeature;
poFeature = GetNextRawFeature();
if( poFeature == NULL )
return NULL;
if( (m_poFilterGeom == NULL
|| poGeomFieldDefn == NULL
|| poGeomFieldDefn->ePostgisType == GEOM_TYPE_GEOMETRY
|| poGeomFieldDefn->ePostgisType == GEOM_TYPE_GEOGRAPHY
|| FilterGeometry( poFeature->GetGeomFieldRef(m_iGeomFieldFilter) ) )
&& (m_poAttrQuery == NULL
|| m_poAttrQuery->Evaluate( poFeature )) )
return poFeature;
delete poFeature;
}
}
OGRFeature *OGRGeoPackageLayer::GetNextFeature()
{
for( ; TRUE; )
{
OGRFeature *poFeature;
if( m_poQueryStatement == NULL )
{
ResetStatement();
if (m_poQueryStatement == NULL)
return NULL;
}
/* -------------------------------------------------------------------- */
/* Fetch a record (unless otherwise instructed) */
/* -------------------------------------------------------------------- */
if( bDoStep )
{
int rc;
rc = sqlite3_step( m_poQueryStatement );
if( rc != SQLITE_ROW )
{
if ( rc != SQLITE_DONE )
{
sqlite3_reset(m_poQueryStatement);
CPLError( CE_Failure, CPLE_AppDefined,
"In GetNextRawFeature(): sqlite3_step() : %s",
sqlite3_errmsg(m_poDS->GetDB()) );
}
ClearStatement();
return NULL;
}
}
else
bDoStep = TRUE;
poFeature = TranslateFeature(m_poQueryStatement);
if( poFeature == NULL )
return NULL;
if( (m_poFilterGeom == NULL
|| FilterGeometry( poFeature->GetGeomFieldRef(m_iGeomFieldFilter) ) )
&& (m_poAttrQuery == NULL
|| m_poAttrQuery->Evaluate( poFeature )) )
return poFeature;
delete poFeature;
}
}
OGRFeature* OGRGeoJSONSeqLayer::GetNextFeature()
{
while( true )
{
auto poObject = GetNextObject();
if( !poObject )
return nullptr;
OGRFeature* poFeature;
auto type = OGRGeoJSONGetType(poObject);
if( type == GeoJSONObject::eFeature )
{
poFeature = m_oReader.ReadFeature(
this, poObject, m_osFeatureBuffer.c_str() );
json_object_put(poObject);
}
else if( type == GeoJSONObject::eFeatureCollection ||
type == GeoJSONObject::eUnknown )
{
json_object_put(poObject);
continue;
}
else
{
OGRGeometry* poGeom = m_oReader.ReadGeometry(poObject,
GetSpatialRef());
json_object_put(poObject);
if( !poGeom )
{
continue;
}
poFeature = new OGRFeature(m_poFeatureDefn);
poFeature->SetGeometryDirectly(poGeom);
}
if( poFeature->GetFID() == OGRNullFID )
{
poFeature->SetFID(m_nNextFID);
m_nNextFID ++;
}
if( (m_poFilterGeom == nullptr ||
FilterGeometry(poFeature->GetGeomFieldRef(m_iGeomFieldFilter)) )
&& (m_poAttrQuery == nullptr ||
m_poAttrQuery->Evaluate(poFeature)) )
{
return poFeature;
}
delete poFeature;
}
}
OGRFeature *OGRWarpedLayer::SrcFeatureToWarpedFeature(OGRFeature* poSrcFeature)
{
OGRFeature* poFeature = new OGRFeature(GetLayerDefn());
poFeature->SetFrom(poSrcFeature);
poFeature->SetFID(poSrcFeature->GetFID());
OGRGeometry* poGeom = poFeature->GetGeomFieldRef(m_iGeomField);
if( poGeom == NULL )
return poFeature;
if( poGeom->transform(m_poCT) != OGRERR_NONE )
{
delete poFeature->StealGeometry(m_iGeomField);
}
return poFeature;
}
static swq_expr_node *OGRFeatureFetcher( swq_expr_node *op, void *pFeatureIn )
{
OGRFeature *poFeature = (OGRFeature *) pFeatureIn;
swq_expr_node *poRetNode = NULL;
if( op->field_type == SWQ_GEOMETRY )
{
int iField = op->field_index - (poFeature->GetFieldCount() + SPECIAL_FIELD_COUNT);
poRetNode = new swq_expr_node( poFeature->GetGeomFieldRef(iField) );
return poRetNode;
}
switch( op->field_type )
{
case SWQ_INTEGER:
case SWQ_BOOLEAN:
poRetNode = new swq_expr_node(
poFeature->GetFieldAsInteger(op->field_index) );
break;
case SWQ_INTEGER64:
poRetNode = new swq_expr_node(
poFeature->GetFieldAsInteger64(op->field_index) );
break;
case SWQ_FLOAT:
poRetNode = new swq_expr_node(
poFeature->GetFieldAsDouble(op->field_index) );
break;
default:
poRetNode = new swq_expr_node(
poFeature->GetFieldAsString(op->field_index) );
break;
}
poRetNode->is_null = !(poFeature->IsFieldSet(op->field_index));
return poRetNode;
}
OGRFeature *OGRWarpedLayer::GetNextFeature()
{
while(TRUE)
{
OGRFeature* poFeature = m_poDecoratedLayer->GetNextFeature();
if( poFeature == NULL )
return NULL;
OGRFeature* poFeatureNew = SrcFeatureToWarpedFeature(poFeature);
delete poFeature;
OGRGeometry* poGeom = poFeatureNew->GetGeomFieldRef(m_iGeomField);
if( m_poFilterGeom != NULL && !FilterGeometry( poGeom ) )
{
delete poFeatureNew;
continue;
}
return poFeatureNew;
}
}
OGRFeature *OGRMemLayer::GetNextFeature()
{
while( iNextReadFID < nMaxFeatureCount )
{
OGRFeature *poFeature = papoFeatures[iNextReadFID++];
if( poFeature == NULL )
continue;
if( (m_poFilterGeom == NULL
|| FilterGeometry( poFeature->GetGeomFieldRef(m_iGeomFieldFilter) ) )
&& (m_poAttrQuery == NULL
|| m_poAttrQuery->Evaluate( poFeature ) ) )
{
m_nFeaturesRead++;
return poFeature->Clone();
}
}
return NULL;
}
OGRFeature *OGRUnionLayer::GetNextFeature()
{
if( poFeatureDefn == NULL ) GetLayerDefn();
if( iCurLayer < 0 )
ResetReading();
if( iCurLayer == nSrcLayers )
return NULL;
while( true )
{
OGRFeature* poSrcFeature = papoSrcLayers[iCurLayer]->GetNextFeature();
if( poSrcFeature == NULL )
{
iCurLayer ++;
if( iCurLayer < nSrcLayers )
{
ConfigureActiveLayer();
continue;
}
else
break;
}
OGRFeature* poFeature = TranslateFromSrcLayer(poSrcFeature);
delete poSrcFeature;
if( (m_poFilterGeom == NULL ||
FilterGeometry( poFeature->GetGeomFieldRef(m_iGeomFieldFilter) ) ) &&
(m_poAttrQuery == NULL ||
m_poAttrQuery->Evaluate( poFeature )) )
{
return poFeature;
}
delete poFeature;
}
return NULL;
}
OGRFeature *OGRWarpedLayer::WarpedFeatureToSrcFeature(OGRFeature* poFeature)
{
OGRFeature* poSrcFeature = new OGRFeature(m_poDecoratedLayer->GetLayerDefn());
poSrcFeature->SetFrom(poFeature);
poSrcFeature->SetFID(poFeature->GetFID());
OGRGeometry* poGeom = poSrcFeature->GetGeomFieldRef(m_iGeomField);
if( poGeom != NULL )
{
if( m_poReversedCT == NULL )
{
delete poSrcFeature;
return NULL;
}
if( poGeom->transform(m_poReversedCT) != OGRERR_NONE )
{
delete poSrcFeature;
return NULL;
}
}
return poSrcFeature;
}
void OGRILI1Layer::PolygonizeAreaLayer( OGRILI1Layer* poAreaLineLayer, int nAreaFieldIndex, int nPointFieldIndex )
{
//add all lines from poAreaLineLayer to collection
OGRGeometryCollection *gc = new OGRGeometryCollection();
poAreaLineLayer->ResetReading();
while (OGRFeature *feature = poAreaLineLayer->GetNextFeatureRef())
gc->addGeometry(feature->GetGeometryRef());
//polygonize lines
CPLDebug( "OGR_ILI", "Polygonizing layer %s with %d multilines", poAreaLineLayer->GetLayerDefn()->GetName(), gc->getNumGeometries());
poAreaLineLayer = 0;
OGRMultiPolygon* polys = Polygonize( gc , false);
CPLDebug( "OGR_ILI", "Resulting polygons: %d", polys->getNumGeometries());
if (polys->getNumGeometries() != GetFeatureCount())
{
CPLDebug( "OGR_ILI", "Feature count of layer %s: " CPL_FRMT_GIB, GetLayerDefn()->GetName(), GetFeatureCount());
CPLDebug( "OGR_ILI", "Polygonizing again with crossing line fix");
delete polys;
polys = Polygonize( gc, true ); //try again with crossing line fix
CPLDebug( "OGR_ILI", "Resulting polygons: %d", polys->getNumGeometries());
}
delete gc;
//associate polygon feature with data row according to centroid
#if defined(HAVE_GEOS)
int i;
OGRPolygon emptyPoly;
GEOSGeom *ahInGeoms = NULL;
CPLDebug( "OGR_ILI", "Associating layer %s with area polygons", GetLayerDefn()->GetName());
ahInGeoms = (GEOSGeom *) CPLCalloc(sizeof(void*), polys->getNumGeometries());
GEOSContextHandle_t hGEOSCtxt = OGRGeometry::createGEOSContext();
for( i = 0; i < polys->getNumGeometries(); i++ )
{
ahInGeoms[i] = polys->getGeometryRef(i)->exportToGEOS(hGEOSCtxt);
if (!GEOSisValid_r(hGEOSCtxt, ahInGeoms[i])) ahInGeoms[i] = NULL;
}
for ( int nFidx = 0; nFidx < nFeatures; nFidx++)
{
OGRFeature *feature = papoFeatures[nFidx];
OGRGeometry* geomRef = feature->GetGeomFieldRef(nPointFieldIndex);
if( !geomRef )
{
continue;
}
GEOSGeom point = (GEOSGeom)(geomRef->exportToGEOS(hGEOSCtxt));
for (i = 0; i < polys->getNumGeometries(); i++ )
{
if (ahInGeoms[i] && GEOSWithin_r(hGEOSCtxt, point, ahInGeoms[i]))
{
feature->SetGeomField(nAreaFieldIndex, polys->getGeometryRef(i));
break;
}
}
if (i == polys->getNumGeometries())
{
CPLDebug( "OGR_ILI", "Association between area and point failed.");
feature->SetGeometry( &emptyPoly );
}
GEOSGeom_destroy_r( hGEOSCtxt, point );
}
for( i = 0; i < polys->getNumGeometries(); i++ )
GEOSGeom_destroy_r( hGEOSCtxt, ahInGeoms[i] );
CPLFree( ahInGeoms );
OGRGeometry::freeGEOSContext( hGEOSCtxt );
#endif
poAreaLineLayer = 0;
delete polys;
}
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;
}
