int ogr_features_intersect_tile(mapcache_context *ctx, mapcache_tile *tile) {
mapcache_metatile *mt = mapcache_tileset_metatile_get(ctx,tile);
GEOSCoordSequence *mtbboxls = GEOSCoordSeq_create(5,2);
double *e = mt->map.extent;
GEOSCoordSeq_setX(mtbboxls,0,e[0]);
GEOSCoordSeq_setY(mtbboxls,0,e[1]);
GEOSCoordSeq_setX(mtbboxls,1,e[2]);
GEOSCoordSeq_setY(mtbboxls,1,e[1]);
GEOSCoordSeq_setX(mtbboxls,2,e[2]);
GEOSCoordSeq_setY(mtbboxls,2,e[3]);
GEOSCoordSeq_setX(mtbboxls,3,e[0]);
GEOSCoordSeq_setY(mtbboxls,3,e[3]);
GEOSCoordSeq_setX(mtbboxls,4,e[0]);
GEOSCoordSeq_setY(mtbboxls,4,e[1]);
GEOSGeometry *mtbbox = GEOSGeom_createLinearRing(mtbboxls);
GEOSGeometry *mtbboxg = GEOSGeom_createPolygon(mtbbox,NULL,0);
int i;
int intersects = 0;
for(i=0;i<nClippers;i++) {
const GEOSPreparedGeometry *clipper = clippers[i];
if(GEOSPreparedIntersects(clipper,mtbboxg)) {
intersects = 1;
break;
}
}
GEOSGeom_destroy(mtbboxg);
return intersects;
}
GEOSGeometry*
eterm_to_geom_polygon(ErlNifEnv *env, const ERL_NIF_TERM *eterm)
{
ERL_NIF_TERM outer_eterm, inner_eterm, tail;
unsigned int rings_num, i;
GEOSCoordSequence *outer_seq, *inner_seq;
GEOSGeometry *outer_geom, *geom;
GEOSGeometry **geoms;
enif_get_list_length(env, *eterm, &rings_num);
enif_get_list_cell(env, *eterm, &outer_eterm, &inner_eterm);
outer_seq = eterm_to_geom_linestring_coords(env, &outer_eterm);
outer_geom = GEOSGeom_createLinearRing(outer_seq);
// if there are holes
geoms = malloc(sizeof(GEOSGeometry*)*rings_num-1);
for (i=0; enif_get_list_cell(env, inner_eterm, &inner_eterm, &tail); i++) {
inner_seq = eterm_to_geom_linestring_coords(env, &inner_eterm);
geoms[i] = GEOSGeom_createLinearRing(inner_seq);
inner_eterm = tail;
}
geom = GEOSGeom_createPolygon(outer_geom, geoms, rings_num-1);
free(geoms);
return geom;
}
static GEOSGeom msGEOSShape2Geometry_simplepolygon(shapeObj *shape, int r, int *outerList)
{
int i, j, k;
GEOSCoordSeq coords;
GEOSGeom g;
GEOSGeom outerRing;
GEOSGeom *innerRings=NULL;
int numInnerRings=0, *innerList;
if(!shape || !outerList) return NULL;
/* build the outer shell */
coords = GEOSCoordSeq_create(shape->line[r].numpoints, 2); /* todo handle z's */
if(!coords) return NULL;
for(i=0; i<shape->line[r].numpoints; i++) {
GEOSCoordSeq_setX(coords, i, shape->line[r].point[i].x);
GEOSCoordSeq_setY(coords, i, shape->line[r].point[i].y);
/* GEOSCoordSeq_setZ(coords, i, shape->line[r].point[i].z); */
}
outerRing = GEOSGeom_createLinearRing(coords); /* outerRing owns the coordinates in coords */
/* build the holes */
innerList = msGetInnerList(shape, r, outerList);
for(j=0; j<shape->numlines; j++)
if(innerList[j] == MS_TRUE) numInnerRings++;
if(numInnerRings > 0) {
k = 0; /* inner ring counter */
innerRings = malloc(numInnerRings*sizeof(GEOSGeom));
if(!innerRings) return NULL; /* todo, this will leak memory (outerRing) */
for(j=0; j<shape->numlines; j++) {
if(innerList[j] == MS_FALSE) continue;
coords = GEOSCoordSeq_create(shape->line[j].numpoints, 2); /* todo handle z's */
if(!coords) return NULL; /* todo, this will leak memory (shell + allocated holes) */
for(i=0; i<shape->line[j].numpoints; i++) {
GEOSCoordSeq_setX(coords, i, shape->line[j].point[i].x);
GEOSCoordSeq_setY(coords, i, shape->line[j].point[i].y);
/* GEOSCoordSeq_setZ(coords, i, shape->line[j].point[i].z); */
}
innerRings[k] = GEOSGeom_createLinearRing(coords); /* innerRings[k] owns the coordinates in coords */
k++;
}
}
g = GEOSGeom_createPolygon(outerRing, innerRings, numInnerRings);
free(innerList); /* clean up */
free(innerRings); /* clean up */
return g;
}
static YAP_Bool list_to_geometry (YAP_Term term,
unsigned int minimum,
procedure_to_geometry_t procedure,
geometry_type_t geometry_type,
geometry_t *geometry)
{
geometry_t *p;
unsigned int size;
unsigned int v, n;
YAP_Term head;
assert (geometry != NULL);
term = YAP_ArgOfTerm (1, term);
if ((is_list_get_size (term, &size) == FALSE) || (size < minimum))
return (FALSE);
p = (geometry_t *) malloc (sizeof (geometry_t) * size);
if (p == NULL)
{
warning ("%s: list_to_geometry: not enough memory", __FILE__);
return (FALSE);
}
memset (p, 0, sizeof (geometry_t) * size);
for (n = 0; YAP_IsPairTerm (term) != FALSE; n ++)
{
assert (n < size);
head = YAP_HeadOfTerm (term);
if (procedure (head, &p[n]) == FALSE)
{
for (v = 0; v < n; v ++)
GEOSGeom_destroy (p[v]);
free (p);
return (FALSE);
}
term = YAP_TailOfTerm (term);
}
assert (n == size);
assert (YAP_IsAtomTerm (term) != FALSE);
assert (strcmp (YAP_AtomName (YAP_AtomOfTerm (term)), "[]") == 0);
if (geometry_type == GEOS_POLYGON)
*geometry = GEOSGeom_createPolygon (p[0], p + 1, size - 1);
else
*geometry = GEOSGeom_createCollection (geometry_type, p, size);
memset (p, 0, sizeof (geometry_t) * size);
free (p);
if (*geometry == NULL)
return (FALSE);
return (TRUE);
}
GEOSGeometry *Geometry::ApplyPointTransformationToSingleGeometry(PointTransformer *t, const GEOSGeometry *g)
{
int gtype = GEOSGeomTypeId(g);
GEOSGeometry *ng = NULL;
if (gtype == GEOS_POINT || gtype == GEOS_LINESTRING || gtype == GEOS_LINEARRING) {
const GEOSCoordSequence *seq = GEOSGeom_getCoordSeq(g);
GEOSCoordSequence *nseq = ApplyPointTransformationToCoordSequence(t, seq);
// this is silly -- GEOS really needs a shortcut for this
if (gtype == GEOS_POINT) {
ng = GEOSGeom_createPoint(nseq);
}
if (gtype == GEOS_LINESTRING) {
ng = GEOSGeom_createLineString(nseq);
}
if (gtype == GEOS_LINEARRING) {
ng = GEOSGeom_createLinearRing(nseq);
}
}
else if (gtype == GEOS_POLYGON) {
int ircnt = GEOSGetNumInteriorRings(g);
const GEOSGeometry *ext = GEOSGetExteriorRing(g);
GEOSGeometry *next = ApplyPointTransformationToSingleGeometry(t, ext);
GEOSGeometry **rings = NULL;
if (ircnt > 0) {
// This shares a lot in common with the code below in ApplyPointTransformation,
// refactor into a single method?
rings = new GEOSGeometry *[ircnt];
for (int i = 0; i < ircnt; i++) {
rings[i] = ApplyPointTransformationToSingleGeometry(t, GEOSGetInteriorRingN(g, i));
}
}
ng = GEOSGeom_createPolygon(next, rings, ircnt);
if (rings) {
delete rings;
}
}
return ng;
}
void object::test<4>()
{
GEOSCoordSequence* cs = GEOSCoordSeq_create(5, 2);
double nan = std::numeric_limits<double>::quiet_NaN();
GEOSCoordSeq_setX(cs, 0, 1); GEOSCoordSeq_setY(cs, 0, 1);
for (unsigned int i=1; i<4; ++i) {
GEOSCoordSeq_setX(cs, i, nan);
GEOSCoordSeq_setY(cs, i, nan);
}
GEOSCoordSeq_setX(cs, 4, 1); GEOSCoordSeq_setY(cs, 4, 1);
geom1_ = GEOSGeom_createPolygon(GEOSGeom_createLinearRing(cs),
NULL, 0);
char const r1 = GEOSIntersects(geom1_, geom1_);
ensure_equals(int(r1), 2);
}
GEOSGeometry* random_polygon(double x, double y, double r, size_t num_points)
{
std::vector<double> angle(num_points);
std::vector<double> radius(num_points);
for (size_t i = 0; i < num_points; i++) {
angle[i] = 2 * M_PI * std::rand() / RAND_MAX;
radius[i] = r*std::rand() / RAND_MAX;
}
std::sort(angle.begin(), angle.end());
GEOSCoordSequence* seq_1 = GEOSCoordSeq_create(static_cast<unsigned int>(num_points), 2);
for (unsigned int i = 0; i < num_points; i++)
{
auto idx = i == (num_points - 1) ? 0 : i;
GEOSCoordSeq_setX(seq_1, i, x + radius[idx] * cos(angle[idx]));
GEOSCoordSeq_setY(seq_1, i, y + radius[idx] * sin(angle[idx]));
}
return GEOSGeom_createPolygon(GEOSGeom_createLinearRing(seq_1), nullptr, 0);
}
GEOSGeometry*
LWGEOM_GEOS_buildArea(const GEOSGeometry* geom_in)
{
GEOSGeometry *tmp;
GEOSGeometry *geos_result, *shp;
GEOSGeometry const *vgeoms[1];
uint32_t i, ngeoms;
int srid = GEOSGetSRID(geom_in);
vgeoms[0] = geom_in;
geos_result = GEOSPolygonize(vgeoms, 1);
LWDEBUGF(3, "GEOSpolygonize returned @ %p", geos_result);
/* Null return from GEOSpolygonize (an exception) */
if ( ! geos_result ) return 0;
/*
* We should now have a collection
*/
#if PARANOIA_LEVEL > 0
if ( GEOSGeometryTypeId(geos_result) != COLLECTIONTYPE )
{
GEOSGeom_destroy(geos_result);
lwerror("Unexpected return from GEOSpolygonize");
return 0;
}
#endif
ngeoms = GEOSGetNumGeometries(geos_result);
LWDEBUGF(3, "GEOSpolygonize: ngeoms in polygonize output: %d", ngeoms);
LWDEBUGF(3, "GEOSpolygonize: polygonized:%s",
lwgeom_to_ewkt(GEOS2LWGEOM(geos_result, 0)));
/*
* No geometries in collection, early out
*/
if ( ngeoms == 0 )
{
GEOSSetSRID(geos_result, srid);
return geos_result;
}
/*
* Return first geometry if we only have one in collection,
* to avoid the unnecessary Geometry clone below.
*/
if ( ngeoms == 1 )
{
tmp = (GEOSGeometry *)GEOSGetGeometryN(geos_result, 0);
if ( ! tmp )
{
GEOSGeom_destroy(geos_result);
return 0; /* exception */
}
shp = GEOSGeom_clone(tmp);
GEOSGeom_destroy(geos_result); /* only safe after the clone above */
GEOSSetSRID(shp, srid);
return shp;
}
/*
* Iteratively invoke symdifference on outer rings
* as suggested by Carl Anderson:
* postgis-devel/2005-December/001805.html
*/
shp = NULL;
for (i=0; i<ngeoms; ++i)
{
GEOSGeom extring;
GEOSCoordSeq sq;
/*
* Construct a Polygon from geometry i exterior ring
* We don't use GEOSGeom_clone on the ExteriorRing
* due to a bug in CAPI contained in GEOS 2.2 branch
* failing to properly return a LinearRing from
* a LinearRing clone.
*/
sq=GEOSCoordSeq_clone(GEOSGeom_getCoordSeq(
GEOSGetExteriorRing(GEOSGetGeometryN( geos_result, i))
));
extring = GEOSGeom_createPolygon(
GEOSGeom_createLinearRing(sq),
NULL, 0
);
if ( extring == NULL ) /* exception */
{
lwerror("GEOSCreatePolygon threw an exception");
return 0;
}
if ( shp == NULL )
{
shp = extring;
LWDEBUGF(3, "GEOSpolygonize: shp:%s",
lwgeom_to_ewkt(GEOS2LWGEOM(shp, 0)));
}
else
{
tmp = GEOSSymDifference(shp, extring);
LWDEBUGF(3, "GEOSpolygonize: SymDifference(%s, %s):%s",
lwgeom_to_ewkt(GEOS2LWGEOM(shp, 0)),
lwgeom_to_ewkt(GEOS2LWGEOM(extring, 0)),
lwgeom_to_ewkt(GEOS2LWGEOM(tmp, 0))
);
GEOSGeom_destroy(shp);
GEOSGeom_destroy(extring);
shp = tmp;
}
}
GEOSGeom_destroy(geos_result);
GEOSSetSRID(shp, srid);
return shp;
}
GEOSGeometry *
LWGEOM2GEOS(const LWGEOM *lwgeom)
{
GEOSCoordSeq sq;
GEOSGeom g, shell;
GEOSGeom *geoms = NULL;
/*
LWGEOM *tmp;
*/
uint32_t ngeoms, i;
int geostype;
#if LWDEBUG_LEVEL >= 4
char *wkt;
#endif
LWDEBUGF(4, "LWGEOM2GEOS got a %s", lwtype_name(lwgeom->type));
if (lwgeom_has_arc(lwgeom))
{
LWDEBUG(3, "LWGEOM2GEOS: arced geometry found.");
lwerror("Exception in LWGEOM2GEOS: curved geometry not supported.");
return NULL;
}
switch (lwgeom->type)
{
LWPOINT *lwp = NULL;
LWPOLY *lwpoly = NULL;
LWLINE *lwl = NULL;
LWCOLLECTION *lwc = NULL;
#if POSTGIS_GEOS_VERSION < 33
POINTARRAY *pa = NULL;
#endif
case POINTTYPE:
lwp = (LWPOINT *)lwgeom;
if ( lwgeom_is_empty(lwgeom) )
{
#if POSTGIS_GEOS_VERSION < 33
pa = ptarray_construct_empty(lwgeom_has_z(lwgeom), lwgeom_has_m(lwgeom), 2);
sq = ptarray_to_GEOSCoordSeq(pa);
shell = GEOSGeom_createLinearRing(sq);
g = GEOSGeom_createPolygon(shell, NULL, 0);
#else
g = GEOSGeom_createEmptyPolygon();
#endif
}
else
{
sq = ptarray_to_GEOSCoordSeq(lwp->point);
g = GEOSGeom_createPoint(sq);
}
if ( ! g )
{
/* lwnotice("Exception in LWGEOM2GEOS"); */
return NULL;
}
break;
case LINETYPE:
lwl = (LWLINE *)lwgeom;
if ( lwl->points->npoints == 1 ) {
/* Duplicate point, to make geos-friendly */
lwl->points = ptarray_addPoint(lwl->points,
getPoint_internal(lwl->points, 0),
FLAGS_NDIMS(lwl->points->flags),
lwl->points->npoints);
}
sq = ptarray_to_GEOSCoordSeq(lwl->points);
g = GEOSGeom_createLineString(sq);
if ( ! g )
{
/* lwnotice("Exception in LWGEOM2GEOS"); */
return NULL;
}
break;
case POLYGONTYPE:
lwpoly = (LWPOLY *)lwgeom;
if ( lwgeom_is_empty(lwgeom) )
{
#if POSTGIS_GEOS_VERSION < 33
POINTARRAY *pa = ptarray_construct_empty(lwgeom_has_z(lwgeom), lwgeom_has_m(lwgeom), 2);
sq = ptarray_to_GEOSCoordSeq(pa);
shell = GEOSGeom_createLinearRing(sq);
g = GEOSGeom_createPolygon(shell, NULL, 0);
#else
g = GEOSGeom_createEmptyPolygon();
#endif
}
else
{
sq = ptarray_to_GEOSCoordSeq(lwpoly->rings[0]);
/* TODO: check ring for being closed and fix if not */
shell = GEOSGeom_createLinearRing(sq);
if ( ! shell ) return NULL;
/*lwerror("LWGEOM2GEOS: exception during polygon shell conversion"); */
ngeoms = lwpoly->nrings-1;
if ( ngeoms > 0 )
geoms = malloc(sizeof(GEOSGeom)*ngeoms);
for (i=1; i<lwpoly->nrings; ++i)
{
sq = ptarray_to_GEOSCoordSeq(lwpoly->rings[i]);
geoms[i-1] = GEOSGeom_createLinearRing(sq);
if ( ! geoms[i-1] )
{
--i;
while (i) GEOSGeom_destroy(geoms[--i]);
free(geoms);
GEOSGeom_destroy(shell);
return NULL;
}
/*lwerror("LWGEOM2GEOS: exception during polygon hole conversion"); */
}
g = GEOSGeom_createPolygon(shell, geoms, ngeoms);
if (geoms) free(geoms);
}
if ( ! g ) return NULL;
break;
case MULTIPOINTTYPE:
case MULTILINETYPE:
case MULTIPOLYGONTYPE:
case COLLECTIONTYPE:
if ( lwgeom->type == MULTIPOINTTYPE )
geostype = GEOS_MULTIPOINT;
else if ( lwgeom->type == MULTILINETYPE )
geostype = GEOS_MULTILINESTRING;
else if ( lwgeom->type == MULTIPOLYGONTYPE )
geostype = GEOS_MULTIPOLYGON;
else
geostype = GEOS_GEOMETRYCOLLECTION;
lwc = (LWCOLLECTION *)lwgeom;
ngeoms = lwc->ngeoms;
if ( ngeoms > 0 )
geoms = malloc(sizeof(GEOSGeom)*ngeoms);
for (i=0; i<ngeoms; ++i)
{
GEOSGeometry* g = LWGEOM2GEOS(lwc->geoms[i]);
if ( ! g )
{
while (i) GEOSGeom_destroy(geoms[--i]);
free(geoms);
return NULL;
}
geoms[i] = g;
}
g = GEOSGeom_createCollection(geostype, geoms, ngeoms);
if ( geoms ) free(geoms);
if ( ! g ) return NULL;
break;
default:
lwerror("Unknown geometry type: %d - %s", lwgeom->type, lwtype_name(lwgeom->type));
return NULL;
}
GEOSSetSRID(g, lwgeom->srid);
#if LWDEBUG_LEVEL >= 4
wkt = GEOSGeomToWKT(g);
LWDEBUGF(4, "LWGEOM2GEOS: GEOSGeom: %s", wkt);
free(wkt);
#endif
return g;
}
void VertexSnapper::editGeometry( MyGEOSGeom *geom, GEOSCoordSequence *coord )
{
// edit geometry according to coord -> GeometryEditor and GeometryEditorOperation/interface classes ??????
qDebug("VertexSnapper::editGeometry: ENTERING EDIT GEOMETRY");
// new geometry
GEOSGeometry *newGeom = NULL;
GEOSGeometry *ring = NULL;
// change geometry according to its type // NOTE: improve this according to http://trac.osgeo.org/geos/browser/trunk/tests/geostest/geostest.c - fineGrainedReconstructionTest
int type = GEOSGeomTypeId( geom->getGEOSGeom() );
switch ( type )
{
case GEOS_POINT:
newGeom = GEOSGeom_createPoint( coord );
break;
case GEOS_LINESTRING:
newGeom = GEOSGeom_createLineString( coord );
break;
case GEOS_LINEARRING:
newGeom = GEOSGeom_createLinearRing( coord );
break;
case GEOS_POLYGON:
ring = GEOSGeom_createLinearRing( coord ); // NOTE: Fails if polygon has holes
newGeom = GEOSGeom_createPolygon( ring, NULL, 0 );
break;
case GEOS_MULTIPOINT:
newGeom = GEOSGeom_createEmptyCollection(4);
qDebug("VertexSnapper::editGeometry: Multi geometry is not supported yet.");
break;
case GEOS_MULTILINESTRING:
newGeom = GEOSGeom_createEmptyCollection(5);
qDebug("VertexSnapper::editGeometry: Multi geometry is not supported yet.");
break;
case GEOS_MULTIPOLYGON:
newGeom = GEOSGeom_createEmptyCollection(6);
qDebug("VertexSnapper::editGeometry: Multi geometry is not supported yet.");
break;
case GEOS_GEOMETRYCOLLECTION:
newGeom = GEOSGeom_createEmptyCollection(7);
qDebug("VertexSnapper::editGeometry: Multi geometry is not supported yet.");
break;
default:
qDebug("VertexSnapper::editGeometry: Unknown geometry type.");
}
// return edited geometry
geom->setGEOSGeom( newGeom );
if( GEOSisEmpty( geom->getGEOSGeom() ) )
qDebug("VertexSnapper::editGeometry: Geom is empty.");
if( GEOSisValid( geom->getGEOSGeom() ) )
qDebug("VertexSnapper::editGeometry: Geom is valid.");
//GEOSGeom_destroy(newGeom);
} // void VertexSnapper::editGeometry( MyGEOSGeom &geom, CoordinateSequence &coord )
static GEOSGeometry *
toGeosGeometry (const gaiaGeomCollPtr gaia)
{
/* converting a GAIA Geometry into a GEOS Geometry */
int pts = 0;
int lns = 0;
int pgs = 0;
int type;
int geos_type;
unsigned int dims;
int iv;
int ib;
int nItem;
double x;
double y;
double z;
double m;
gaiaPointPtr pt;
gaiaLinestringPtr ln;
gaiaPolygonPtr pg;
gaiaRingPtr rng;
GEOSGeometry *geos;
GEOSGeometry *geos_ext;
GEOSGeometry *geos_int;
GEOSGeometry *geos_item;
GEOSGeometry **geos_holes;
GEOSGeometry **geos_coll;
GEOSCoordSequence *cs;
if (!gaia)
return NULL;
pt = gaia->FirstPoint;
while (pt)
{
/* counting how many POINTs are there */
pts++;
pt = pt->Next;
}
ln = gaia->FirstLinestring;
while (ln)
{
/* counting how many LINESTRINGs are there */
lns++;
ln = ln->Next;
}
pg = gaia->FirstPolygon;
while (pg)
{
/* counting how many POLYGONs are there */
pgs++;
pg = pg->Next;
}
if (pts == 0 && lns == 0 && pgs == 0)
type = GAIA_UNKNOWN;
else if (pts == 1 && lns == 0 && pgs == 0)
{
if (gaia->DeclaredType == GAIA_MULTIPOINT)
type = GAIA_MULTIPOINT;
else if (gaia->DeclaredType == GAIA_GEOMETRYCOLLECTION)
type = GAIA_GEOMETRYCOLLECTION;
else
type = GAIA_POINT;
}
else if (pts == 0 && lns == 1 && pgs == 0)
{
if (gaia->DeclaredType == GAIA_MULTILINESTRING)
type = GAIA_MULTILINESTRING;
else if (gaia->DeclaredType == GAIA_GEOMETRYCOLLECTION)
type = GAIA_GEOMETRYCOLLECTION;
else
type = GAIA_LINESTRING;
}
else if (pts == 0 && lns == 0 && pgs == 1)
{
if (gaia->DeclaredType == GAIA_MULTIPOLYGON)
type = GAIA_MULTIPOLYGON;
else if (gaia->DeclaredType == GAIA_GEOMETRYCOLLECTION)
type = GAIA_GEOMETRYCOLLECTION;
else
type = GAIA_POLYGON;
}
else if (pts > 1 && lns == 0 && pgs == 0)
{
if (gaia->DeclaredType == GAIA_GEOMETRYCOLLECTION)
type = GAIA_GEOMETRYCOLLECTION;
else
type = GAIA_MULTIPOINT;
}
else if (pts == 0 && lns > 1 && pgs == 0)
{
if (gaia->DeclaredType == GAIA_GEOMETRYCOLLECTION)
type = GAIA_GEOMETRYCOLLECTION;
else
type = GAIA_MULTILINESTRING;
}
else if (pts == 0 && lns == 0 && pgs > 1)
{
if (gaia->DeclaredType == GAIA_GEOMETRYCOLLECTION)
type = GAIA_GEOMETRYCOLLECTION;
else
type = GAIA_MULTIPOLYGON;
}
else
type = GAIA_GEOMETRYCOLLECTION;
switch (gaia->DimensionModel)
{
case GAIA_XY_Z:
case GAIA_XY_Z_M:
dims = 3;
break;
default:
dims = 2;
break;
};
switch (type)
{
case GAIA_POINT:
pt = gaia->FirstPoint;
cs = GEOSCoordSeq_create (1, dims);
switch (gaia->DimensionModel)
{
case GAIA_XY_Z:
case GAIA_XY_Z_M:
GEOSCoordSeq_setX (cs, 0, pt->X);
GEOSCoordSeq_setY (cs, 0, pt->Y);
GEOSCoordSeq_setZ (cs, 0, pt->Z);
break;
default:
GEOSCoordSeq_setX (cs, 0, pt->X);
GEOSCoordSeq_setY (cs, 0, pt->Y);
break;
};
geos = GEOSGeom_createPoint (cs);
break;
case GAIA_LINESTRING:
ln = gaia->FirstLinestring;
cs = GEOSCoordSeq_create (ln->Points, dims);
for (iv = 0; iv < ln->Points; iv++)
{
switch (ln->DimensionModel)
{
case GAIA_XY_Z:
gaiaGetPointXYZ (ln->Coords, iv, &x, &y, &z);
GEOSCoordSeq_setX (cs, iv, x);
GEOSCoordSeq_setY (cs, iv, y);
GEOSCoordSeq_setZ (cs, iv, z);
break;
case GAIA_XY_M:
gaiaGetPointXYM (ln->Coords, iv, &x, &y, &m);
GEOSCoordSeq_setX (cs, iv, x);
GEOSCoordSeq_setY (cs, iv, y);
break;
case GAIA_XY_Z_M:
gaiaGetPointXYZM (ln->Coords, iv, &x, &y, &z, &m);
GEOSCoordSeq_setX (cs, iv, x);
GEOSCoordSeq_setY (cs, iv, y);
GEOSCoordSeq_setZ (cs, iv, z);
break;
default:
gaiaGetPoint (ln->Coords, iv, &x, &y);
GEOSCoordSeq_setX (cs, iv, x);
GEOSCoordSeq_setY (cs, iv, y);
break;
};
}
geos = GEOSGeom_createLineString (cs);
break;
case GAIA_POLYGON:
pg = gaia->FirstPolygon;
rng = pg->Exterior;
/* exterior ring */
cs = GEOSCoordSeq_create (rng->Points, dims);
for (iv = 0; iv < rng->Points; iv++)
{
switch (rng->DimensionModel)
{
case GAIA_XY_Z:
gaiaGetPointXYZ (rng->Coords, iv, &x, &y, &z);
GEOSCoordSeq_setX (cs, iv, x);
GEOSCoordSeq_setY (cs, iv, y);
GEOSCoordSeq_setZ (cs, iv, z);
break;
case GAIA_XY_M:
gaiaGetPointXYM (rng->Coords, iv, &x, &y, &m);
GEOSCoordSeq_setX (cs, iv, x);
GEOSCoordSeq_setY (cs, iv, y);
break;
case GAIA_XY_Z_M:
gaiaGetPointXYZM (rng->Coords, iv, &x, &y, &z, &m);
GEOSCoordSeq_setX (cs, iv, x);
GEOSCoordSeq_setY (cs, iv, y);
GEOSCoordSeq_setZ (cs, iv, z);
break;
default:
gaiaGetPoint (rng->Coords, iv, &x, &y);
GEOSCoordSeq_setX (cs, iv, x);
GEOSCoordSeq_setY (cs, iv, y);
break;
};
}
geos_ext = GEOSGeom_createLinearRing (cs);
geos_holes = NULL;
if (pg->NumInteriors > 0)
{
geos_holes =
malloc (sizeof (GEOSGeometry *) * pg->NumInteriors);
for (ib = 0; ib < pg->NumInteriors; ib++)
{
/* interior ring */
rng = pg->Interiors + ib;
cs = GEOSCoordSeq_create (rng->Points, dims);
for (iv = 0; iv < rng->Points; iv++)
{
switch (rng->DimensionModel)
{
case GAIA_XY_Z:
gaiaGetPointXYZ (rng->Coords, iv, &x, &y, &z);
GEOSCoordSeq_setX (cs, iv, x);
GEOSCoordSeq_setY (cs, iv, y);
GEOSCoordSeq_setZ (cs, iv, z);
break;
case GAIA_XY_M:
gaiaGetPointXYM (rng->Coords, iv, &x, &y, &m);
GEOSCoordSeq_setX (cs, iv, x);
GEOSCoordSeq_setY (cs, iv, y);
break;
case GAIA_XY_Z_M:
gaiaGetPointXYZM (rng->Coords, iv, &x, &y, &z,
&m);
GEOSCoordSeq_setX (cs, iv, x);
GEOSCoordSeq_setY (cs, iv, y);
GEOSCoordSeq_setZ (cs, iv, z);
break;
default:
gaiaGetPoint (rng->Coords, iv, &x, &y);
GEOSCoordSeq_setX (cs, iv, x);
GEOSCoordSeq_setY (cs, iv, y);
break;
};
}
geos_int = GEOSGeom_createLinearRing (cs);
*(geos_holes + ib) = geos_int;
}
}
geos =
GEOSGeom_createPolygon (geos_ext, geos_holes, pg->NumInteriors);
if (geos_holes)
free (geos_holes);
break;
case GAIA_MULTIPOINT:
case GAIA_MULTILINESTRING:
case GAIA_MULTIPOLYGON:
case GAIA_GEOMETRYCOLLECTION:
nItem = 0;
geos_coll = malloc (sizeof (GEOSGeometry *) * (pts + lns + pgs));
pt = gaia->FirstPoint;
while (pt)
{
cs = GEOSCoordSeq_create (1, dims);
switch (pt->DimensionModel)
{
case GAIA_XY_Z:
case GAIA_XY_Z_M:
GEOSCoordSeq_setX (cs, 0, pt->X);
GEOSCoordSeq_setY (cs, 0, pt->Y);
GEOSCoordSeq_setZ (cs, 0, pt->Z);
break;
default:
GEOSCoordSeq_setX (cs, 0, pt->X);
GEOSCoordSeq_setY (cs, 0, pt->Y);
break;
};
geos_item = GEOSGeom_createPoint (cs);
*(geos_coll + nItem++) = geos_item;
pt = pt->Next;
}
ln = gaia->FirstLinestring;
while (ln)
{
cs = GEOSCoordSeq_create (ln->Points, dims);
for (iv = 0; iv < ln->Points; iv++)
{
switch (ln->DimensionModel)
{
case GAIA_XY_Z:
gaiaGetPointXYZ (ln->Coords, iv, &x, &y, &z);
GEOSCoordSeq_setX (cs, iv, x);
GEOSCoordSeq_setY (cs, iv, y);
GEOSCoordSeq_setZ (cs, iv, z);
break;
case GAIA_XY_M:
gaiaGetPointXYM (ln->Coords, iv, &x, &y, &m);
GEOSCoordSeq_setX (cs, iv, x);
GEOSCoordSeq_setY (cs, iv, y);
break;
case GAIA_XY_Z_M:
gaiaGetPointXYZM (ln->Coords, iv, &x, &y, &z, &m);
GEOSCoordSeq_setX (cs, iv, x);
GEOSCoordSeq_setY (cs, iv, y);
GEOSCoordSeq_setZ (cs, iv, z);
break;
default:
gaiaGetPoint (ln->Coords, iv, &x, &y);
GEOSCoordSeq_setX (cs, iv, x);
GEOSCoordSeq_setY (cs, iv, y);
break;
};
}
geos_item = GEOSGeom_createLineString (cs);
*(geos_coll + nItem++) = geos_item;
ln = ln->Next;
}
pg = gaia->FirstPolygon;
while (pg)
{
rng = pg->Exterior;
/* exterior ring */
cs = GEOSCoordSeq_create (rng->Points, dims);
for (iv = 0; iv < rng->Points; iv++)
{
switch (rng->DimensionModel)
{
case GAIA_XY_Z:
gaiaGetPointXYZ (rng->Coords, iv, &x, &y, &z);
GEOSCoordSeq_setX (cs, iv, x);
GEOSCoordSeq_setY (cs, iv, y);
GEOSCoordSeq_setZ (cs, iv, z);
break;
case GAIA_XY_M:
gaiaGetPointXYM (rng->Coords, iv, &x, &y, &m);
GEOSCoordSeq_setX (cs, iv, x);
GEOSCoordSeq_setY (cs, iv, y);
break;
case GAIA_XY_Z_M:
gaiaGetPointXYZM (rng->Coords, iv, &x, &y, &z, &m);
GEOSCoordSeq_setX (cs, iv, x);
GEOSCoordSeq_setY (cs, iv, y);
GEOSCoordSeq_setZ (cs, iv, z);
break;
default:
gaiaGetPoint (rng->Coords, iv, &x, &y);
GEOSCoordSeq_setX (cs, iv, x);
GEOSCoordSeq_setY (cs, iv, y);
break;
};
}
geos_ext = GEOSGeom_createLinearRing (cs);
geos_holes = NULL;
if (pg->NumInteriors > 0)
{
geos_holes =
malloc (sizeof (GEOSGeometry *) * pg->NumInteriors);
for (ib = 0; ib < pg->NumInteriors; ib++)
{
/* interior ring */
rng = pg->Interiors + ib;
cs = GEOSCoordSeq_create (rng->Points, dims);
for (iv = 0; iv < rng->Points; iv++)
{
switch (rng->DimensionModel)
{
case GAIA_XY_Z:
gaiaGetPointXYZ (rng->Coords, iv, &x,
&y, &z);
GEOSCoordSeq_setX (cs, iv, x);
GEOSCoordSeq_setY (cs, iv, y);
GEOSCoordSeq_setZ (cs, iv, z);
break;
case GAIA_XY_M:
gaiaGetPointXYM (rng->Coords, iv, &x,
&y, &m);
GEOSCoordSeq_setX (cs, iv, x);
GEOSCoordSeq_setY (cs, iv, y);
break;
case GAIA_XY_Z_M:
gaiaGetPointXYZM (rng->Coords, iv, &x,
&y, &z, &m);
GEOSCoordSeq_setX (cs, iv, x);
GEOSCoordSeq_setY (cs, iv, y);
GEOSCoordSeq_setZ (cs, iv, z);
break;
default:
gaiaGetPoint (rng->Coords, iv, &x, &y);
GEOSCoordSeq_setX (cs, iv, x);
GEOSCoordSeq_setY (cs, iv, y);
break;
};
}
geos_int = GEOSGeom_createLinearRing (cs);
*(geos_holes + ib) = geos_int;
}
}
geos_item =
GEOSGeom_createPolygon (geos_ext, geos_holes,
pg->NumInteriors);
if (geos_holes)
free (geos_holes);
*(geos_coll + nItem++) = geos_item;
pg = pg->Next;
}
geos_type = GEOS_GEOMETRYCOLLECTION;
if (type == GAIA_MULTIPOINT)
geos_type = GEOS_MULTIPOINT;
if (type == GAIA_MULTILINESTRING)
geos_type = GEOS_MULTILINESTRING;
if (type == GAIA_MULTIPOLYGON)
geos_type = GEOS_MULTIPOLYGON;
geos =
GEOSGeom_createCollection (geos_type, geos_coll, pts + lns + pgs);
if (geos_coll)
free (geos_coll);
break;
default:
geos = NULL;
};
if (geos)
GEOSSetSRID (geos, gaia->Srid);
return geos;
}
