OGRGeometryH OGR_G_CreateFromGML( const char *pszGML )
{
if( pszGML == NULL || strlen(pszGML) == 0 )
{
CPLError( CE_Failure, CPLE_AppDefined,
"GML Geometry is empty in GML2OGRGeometry()." );
return NULL;
}
/* -------------------------------------------------------------------- */
/* Try to parse the XML snippet using the MiniXML API. If this */
/* fails, we assume the minixml api has already posted a CPL */
/* error, and just return NULL. */
/* -------------------------------------------------------------------- */
CPLXMLNode *psGML = CPLParseXMLString( pszGML );
if( psGML == NULL )
return NULL;
/* -------------------------------------------------------------------- */
/* Convert geometry recursively. */
/* -------------------------------------------------------------------- */
OGRGeometry *poGeometry;
poGeometry = GML2OGRGeometry_XMLNode( psGML );
CPLDestroyXMLNode( psGML );
return (OGRGeometryH) poGeometry;
}
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;
}
OGRGeometry* GML_BuildOGRGeometryFromList(const CPLXMLNode* const * papsGeometry,
int bTryToMakeMultipolygons,
int bInvertAxisOrderIfLatLong,
const char* pszDefaultSRSName,
int bConsiderEPSGAsURN,
int bGetSecondaryGeometryOption,
void* hCacheSRS)
{
OGRGeometry* poGeom = NULL;
int i;
OGRGeometryCollection* poCollection = NULL;
for(i=0;papsGeometry[i] != NULL;i++)
{
OGRGeometry* poSubGeom = GML2OGRGeometry_XMLNode( papsGeometry[i],
bGetSecondaryGeometryOption );
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 && bInvertAxisOrderIfLatLong )
{
std::string osWork;
const char* pszSRSName = GML_ExtractSrsNameFromGeometry(papsGeometry, osWork,
bConsiderEPSGAsURN);
const char* pszNameLookup = pszSRSName ? pszSRSName : pszDefaultSRSName;
if (pszNameLookup != NULL)
{
SRSCache* poSRSCache = (SRSCache*)hCacheSRS;
int bSwap;
if (strcmp(poSRSCache->osLastSRSName.c_str(), pszNameLookup) == 0)
{
bSwap = poSRSCache->bAxisInvertLastSRSName;
}
else
{
bSwap = GML_IsSRSLatLongOrder(pszNameLookup);
poSRSCache->osLastSRSName = pszNameLookup;
poSRSCache->bAxisInvertLastSRSName= bSwap;
}
if (bSwap)
poGeom->swapXY();
}
}
return poGeom;
}
OGRGeometryH OGR_G_CreateFromGMLTree( const CPLXMLNode *psTree )
{
return (OGRGeometryH) GML2OGRGeometry_XMLNode( (CPLXMLNode *) psTree );
}
static OGRGeometry *GML2OGRGeometry_XMLNode( CPLXMLNode *psNode )
{
const char *pszBaseGeometry = BareGMLElement( psNode->pszValue );
/* -------------------------------------------------------------------- */
/* Polygon */
/* -------------------------------------------------------------------- */
if( EQUAL(pszBaseGeometry,"Polygon") )
{
CPLXMLNode *psChild;
OGRPolygon *poPolygon = new OGRPolygon();
OGRLinearRing *poRing;
// Find outer ring.
psChild = FindBareXMLChild( psNode, "outerBoundaryIs" );
if( psChild == NULL || psChild->psChild == NULL )
{
CPLError( CE_Failure, CPLE_AppDefined,
"Missing outerBoundaryIs property on Polygon." );
delete poPolygon;
return NULL;
}
// Translate outer ring and add to polygon.
poRing = (OGRLinearRing *)
GML2OGRGeometry_XMLNode( psChild->psChild );
if( poRing == NULL )
{
delete poPolygon;
return NULL;
}
if( !EQUAL(poRing->getGeometryName(),"LINEARRING") )
{
CPLError( CE_Failure, CPLE_AppDefined,
"Got %.500s geometry as outerBoundaryIs instead of LINEARRING.",
poRing->getGeometryName() );
delete poPolygon;
delete poRing;
return NULL;
}
poPolygon->addRingDirectly( poRing );
// Find all inner rings
for( psChild = psNode->psChild;
psChild != NULL;
psChild = psChild->psNext )
{
if( psChild->eType == CXT_Element
&& EQUAL(BareGMLElement(psChild->pszValue),"innerBoundaryIs") )
{
poRing = (OGRLinearRing *)
GML2OGRGeometry_XMLNode( psChild->psChild );
if( !EQUAL(poRing->getGeometryName(),"LINEARRING") )
{
CPLError( CE_Failure, CPLE_AppDefined,
"Got %.500s geometry as innerBoundaryIs instead of LINEARRING.",
poRing->getGeometryName() );
delete poPolygon;
delete poRing;
return NULL;
}
poPolygon->addRingDirectly( poRing );
}
}
return poPolygon;
}
/* -------------------------------------------------------------------- */
/* LinearRing */
/* -------------------------------------------------------------------- */
if( EQUAL(pszBaseGeometry,"LinearRing") )
{
OGRLinearRing *poLinearRing = new OGRLinearRing();
if( !ParseGMLCoordinates( psNode, poLinearRing ) )
{
delete poLinearRing;
return NULL;
}
return poLinearRing;
}
/* -------------------------------------------------------------------- */
/* LineString */
/* -------------------------------------------------------------------- */
if( EQUAL(pszBaseGeometry,"LineString") )
{
OGRLineString *poLine = new OGRLineString();
if( !ParseGMLCoordinates( psNode, poLine ) )
{
delete poLine;
return NULL;
}
return poLine;
}
/* -------------------------------------------------------------------- */
/* PointType */
/* -------------------------------------------------------------------- */
if( EQUAL(pszBaseGeometry,"PointType")
|| EQUAL(pszBaseGeometry,"Point") )
{
OGRPoint *poPoint = new OGRPoint();
if( !ParseGMLCoordinates( psNode, poPoint ) )
{
delete poPoint;
return NULL;
}
return poPoint;
}
/* -------------------------------------------------------------------- */
/* Box */
/* -------------------------------------------------------------------- */
if( EQUAL(pszBaseGeometry,"BoxType") || EQUAL(pszBaseGeometry,"Box") )
{
OGRLineString oPoints;
if( !ParseGMLCoordinates( psNode, &oPoints ) )
return NULL;
if( oPoints.getNumPoints() < 2 )
return NULL;
OGRLinearRing *poBoxRing = new OGRLinearRing();
OGRPolygon *poBoxPoly = new OGRPolygon();
poBoxRing->setNumPoints( 5 );
poBoxRing->setPoint(
0, oPoints.getX(0), oPoints.getY(0), oPoints.getZ(0) );
poBoxRing->setPoint(
1, oPoints.getX(1), oPoints.getY(0), oPoints.getZ(0) );
poBoxRing->setPoint(
2, oPoints.getX(1), oPoints.getY(1), oPoints.getZ(1) );
poBoxRing->setPoint(
3, oPoints.getX(0), oPoints.getY(1), oPoints.getZ(0) );
poBoxRing->setPoint(
4, oPoints.getX(0), oPoints.getY(0), oPoints.getZ(0) );
poBoxPoly->addRingDirectly( poBoxRing );
return poBoxPoly;
}
/* -------------------------------------------------------------------- */
/* MultiPolygon */
/* -------------------------------------------------------------------- */
if( EQUAL(pszBaseGeometry,"MultiPolygon") )
{
CPLXMLNode *psChild;
OGRMultiPolygon *poMPoly = new OGRMultiPolygon();
// Find all inner rings
for( psChild = psNode->psChild;
psChild != NULL;
psChild = psChild->psNext )
{
if( psChild->eType == CXT_Element
&& EQUAL(BareGMLElement(psChild->pszValue),"polygonMember") )
{
OGRPolygon *poPolygon;
poPolygon = (OGRPolygon *)
GML2OGRGeometry_XMLNode( psChild->psChild );
if( poPolygon == NULL )
{
delete poMPoly;
return NULL;
}
if( !EQUAL(poPolygon->getGeometryName(),"POLYGON") )
{
CPLError( CE_Failure, CPLE_AppDefined,
"Got %.500s geometry as polygonMember instead of MULTIPOLYGON.",
poPolygon->getGeometryName() );
delete poPolygon;
delete poMPoly;
return NULL;
}
poMPoly->addGeometryDirectly( poPolygon );
}
}
return poMPoly;
}
/* -------------------------------------------------------------------- */
/* MultiPoint */
/* -------------------------------------------------------------------- */
if( EQUAL(pszBaseGeometry,"MultiPoint") )
{
CPLXMLNode *psChild;
OGRMultiPoint *poMP = new OGRMultiPoint();
// collect points.
for( psChild = psNode->psChild;
psChild != NULL;
psChild = psChild->psNext )
{
if( psChild->eType == CXT_Element
&& EQUAL(BareGMLElement(psChild->pszValue),"pointMember") )
{
OGRPoint *poPoint;
poPoint = (OGRPoint *)
GML2OGRGeometry_XMLNode( psChild->psChild );
if( poPoint == NULL
|| wkbFlatten(poPoint->getGeometryType()) != wkbPoint )
{
CPLError( CE_Failure, CPLE_AppDefined,
"Got %.500s geometry as pointMember instead of MULTIPOINT",
poPoint ? poPoint->getGeometryName() : "NULL" );
delete poPoint;
delete poMP;
return NULL;
}
poMP->addGeometryDirectly( poPoint );
}
}
return poMP;
}
/* -------------------------------------------------------------------- */
/* MultiLineString */
/* -------------------------------------------------------------------- */
if( EQUAL(pszBaseGeometry,"MultiLineString") )
{
CPLXMLNode *psChild;
OGRMultiLineString *poMP = new OGRMultiLineString();
// collect lines
for( psChild = psNode->psChild;
psChild != NULL;
psChild = psChild->psNext )
{
if( psChild->eType == CXT_Element
&& EQUAL(BareGMLElement(psChild->pszValue),"lineStringMember") )
{
OGRGeometry *poGeom;
poGeom = GML2OGRGeometry_XMLNode( psChild->psChild );
if( poGeom == NULL
|| wkbFlatten(poGeom->getGeometryType()) != wkbLineString )
{
CPLError( CE_Failure, CPLE_AppDefined,
"Got %.500s geometry as Member instead of LINESTRING.",
poGeom ? poGeom->getGeometryName() : "NULL" );
delete poGeom;
delete poMP;
return NULL;
}
poMP->addGeometryDirectly( poGeom );
}
}
return poMP;
}
/* -------------------------------------------------------------------- */
/* GeometryCollection */
/* -------------------------------------------------------------------- */
if( EQUAL(pszBaseGeometry,"GeometryCollection") )
{
CPLXMLNode *psChild;
OGRGeometryCollection *poGC = new OGRGeometryCollection();
// collect geoms
for( psChild = psNode->psChild;
psChild != NULL;
psChild = psChild->psNext )
{
if( psChild->eType == CXT_Element
&& EQUAL(BareGMLElement(psChild->pszValue),"geometryMember") )
{
OGRGeometry *poGeom;
poGeom = GML2OGRGeometry_XMLNode( psChild->psChild );
if( poGeom == NULL )
{
CPLError( CE_Failure, CPLE_AppDefined,
"Failed to get geometry in geometryMember" );
delete poGeom;
delete poGC;
return NULL;
}
poGC->addGeometryDirectly( poGeom );
}
}
return poGC;
}
CPLError( CE_Failure, CPLE_AppDefined,
"Unrecognised geometry type <%.500s>.",
pszBaseGeometry );
return NULL;
}
