OGRGeometry *OGRGeometryFactory::forceToMultiPoint( OGRGeometry *poGeom )
{
if( poGeom == NULL )
return NULL;
/* -------------------------------------------------------------------- */
/* Check for the case of a geometrycollection that can be */
/* promoted to MultiPoint. */
/* -------------------------------------------------------------------- */
if( wkbFlatten(poGeom->getGeometryType()) == wkbGeometryCollection )
{
int iGeom;
int bAllPoint = TRUE;
OGRGeometryCollection *poGC = (OGRGeometryCollection *) poGeom;
for( iGeom = 0; iGeom < poGC->getNumGeometries(); iGeom++ )
{
if( wkbFlatten(poGC->getGeometryRef(iGeom)->getGeometryType())
!= wkbPoint )
bAllPoint = FALSE;
}
if( !bAllPoint )
return poGeom;
OGRMultiPoint *poMP = new OGRMultiPoint();
while( poGC->getNumGeometries() > 0 )
{
poMP->addGeometryDirectly( poGC->getGeometryRef(0) );
poGC->removeGeometry( 0, FALSE );
}
delete poGC;
return poMP;
}
if( wkbFlatten(poGeom->getGeometryType()) != wkbPoint )
return poGeom;
OGRMultiPoint *poMP = new OGRMultiPoint();
poMP->addGeometryDirectly( poGeom );
return poMP;
}
OGRMultiPoint* make()
{
OGRMultiPoint* poCollection = new OGRMultiPoint();
poCollection->addGeometryDirectly(make<OGRPoint>());
return poCollection;
}
OGRMultiPoint* OGRMSSQLGeometryParser::ReadMultiPoint(int iShape)
{
int i;
OGRMultiPoint* poMultiPoint = new OGRMultiPoint();
OGRGeometry* poGeom;
for (i = iShape + 1; i < nNumShapes; i++)
{
poGeom = NULL;
if (ParentOffset(i) == (unsigned int)iShape)
{
if ( ShapeType(i) == ST_POINT )
poGeom = ReadPoint(i);
}
if ( poGeom )
poMultiPoint->addGeometryDirectly( poGeom );
}
return poMultiPoint;
}
OGRMultiPoint* OGRMSSQLGeometryParser::ReadMultiPoint(int iShape)
{
int iFigure, iPoint, iNextPoint;
iFigure = FigureOffset(iShape);
OGRMultiPoint* poMultiPoint = new OGRMultiPoint();
iNextPoint = NextPointOffset(iFigure);
for (iPoint = PointOffset(iFigure); iPoint < iNextPoint; iPoint++)
{
OGRPoint* poPoint;
if ( chProps & SP_HASZVALUES )
poPoint = new OGRPoint( ReadX(iPoint), ReadY(iPoint), ReadZ(iPoint) );
else
poPoint = new OGRPoint( ReadX(iPoint), ReadY(iPoint) );
if ( poPoint )
poMultiPoint->addGeometryDirectly( poPoint );
}
return poMultiPoint;
}
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;
}
static void ParseObject(const char* pszId,
json_object* poObj, OGRGeoJSONLayer* poLayer,
json_object* poArcsDB, ScalingParams* psParams)
{
json_object* poType = OGRGeoJSONFindMemberByName(poObj, "type");
if( poType == NULL || json_object_get_type(poType) != json_type_string )
return;
const char* pszType = json_object_get_string(poType);
json_object* poArcsObj = OGRGeoJSONFindMemberByName(poObj, "arcs");
json_object* poCoordinatesObj = OGRGeoJSONFindMemberByName(poObj, "coordinates");
if( strcmp(pszType, "Point") == 0 || strcmp(pszType, "MultiPoint") == 0 )
{
if( poCoordinatesObj == NULL || json_type_array != json_object_get_type(poCoordinatesObj) )
return;
}
else
{
if( poArcsObj == NULL || json_type_array != json_object_get_type(poArcsObj) )
return;
}
if( pszId == NULL )
{
json_object* poId = OGRGeoJSONFindMemberByName(poObj, "id");
if( poId != NULL &&
(json_type_string == json_object_get_type(poId) ||
json_type_int == json_object_get_type(poId)) )
{
pszId = json_object_get_string(poId);
}
}
OGRFeature* poFeature = new OGRFeature(poLayer->GetLayerDefn());
if( pszId != NULL )
poFeature->SetField("id", pszId);
json_object* poProperties = OGRGeoJSONFindMemberByName(poObj, "properties");
if( poProperties != NULL && json_type_object == json_object_get_type(poProperties) )
{
json_object* poName = OGRGeoJSONFindMemberByName(poProperties, "name");
if( poName != NULL && json_type_string == json_object_get_type(poName) )
{
const char* pszName = json_object_get_string(poName);
poFeature->SetField("name", pszName);
}
}
OGRGeometry* poGeom = NULL;
if( strcmp(pszType, "Point") == 0 )
{
double dfX = 0.0, dfY = 0.0;
if( ParsePoint( poCoordinatesObj, &dfX, &dfY ) )
{
dfX = dfX * psParams->dfScale0 + psParams->dfTranslate0;
dfY = dfY * psParams->dfScale1 + psParams->dfTranslate1;
poGeom = new OGRPoint(dfX, dfY);
}
else
poGeom = new OGRPoint();
}
else if( strcmp(pszType, "MultiPoint") == 0 )
{
OGRMultiPoint* poMP = new OGRMultiPoint();
poGeom = poMP;
int nTuples = json_object_array_length(poCoordinatesObj);
for(int i=0; i<nTuples; i++)
{
json_object* poPair = json_object_array_get_idx(poCoordinatesObj, i);
double dfX = 0.0, dfY = 0.0;
if( ParsePoint( poPair, &dfX, &dfY ) )
{
dfX = dfX * psParams->dfScale0 + psParams->dfTranslate0;
dfY = dfY * psParams->dfScale1 + psParams->dfTranslate1;
poMP->addGeometryDirectly(new OGRPoint(dfX, dfY));
}
}
}
else if( strcmp(pszType, "LineString") == 0 )
{
OGRLineString* poLS = new OGRLineString();
poGeom = poLS;
ParseLineString(poLS, poArcsObj, poArcsDB, psParams);
}
else if( strcmp(pszType, "MultiLineString") == 0 )
{
OGRMultiLineString* poMLS = new OGRMultiLineString();
poGeom = poMLS;
ParseMultiLineString(poMLS, poArcsObj, poArcsDB, psParams);
}
else if( strcmp(pszType, "Polygon") == 0 )
{
OGRPolygon* poPoly = new OGRPolygon();
poGeom = poPoly;
ParsePolygon(poPoly, poArcsObj, poArcsDB, psParams);
}
else if( strcmp(pszType, "MultiPolygon") == 0 )
{
OGRMultiPolygon* poMultiPoly = new OGRMultiPolygon();
poGeom = poMultiPoly;
ParseMultiPolygon(poMultiPoly, poArcsObj, poArcsDB, psParams);
}
if( poGeom != NULL )
poFeature->SetGeometryDirectly(poGeom);
poLayer->AddFeature(poFeature);
delete poFeature;
}
