void geo_points(sqlite3_context *context,int argc,sqlite3_value **argv)
{
if(argc == 1 && sqlite3_value_type(argv[0]) == SQLITE_BLOB)
{
GEOSGeometry* geometry;
const void* data = sqlite3_value_blob(argv[0]);
size_t data_size = sqlite3_value_bytes(argv[0]);
_init_geos();
geometry = _geo_from_wkb((const unsigned char*)data,data_size);
if(geometry != 0)
{
int num_points = GEOSGetNumCoordinates(geometry);
sqlite3_result_int(context,num_points);
}
GEOSGeom_destroy(geometry);
finishGEOS();
}
}
void geo_empty(sqlite3_context *context,int argc,sqlite3_value **argv)
{
if(argc == 1 && sqlite3_value_type(argv[0]) == SQLITE_BLOB)
{
GEOSGeometry* geometry;
const void* data = sqlite3_value_blob(argv[0]);
size_t data_size = sqlite3_value_bytes(argv[0]);
_init_geos();
geometry = _geo_from_wkb((const unsigned char*)data,data_size);
if(geometry != 0)
{
char empty = (GEOSisEmpty(geometry) == 1) ? 1 : 0;
sqlite3_result_int(context,empty);
}
GEOSGeom_destroy(geometry);
finishGEOS();
}
}
void geo_length(sqlite3_context *context,int argc,sqlite3_value **argv)
{
if(argc == 1 && sqlite3_value_type(argv[0]) == SQLITE_BLOB)
{
GEOSGeometry* geometry;
const void* data = sqlite3_value_blob(argv[0]);
size_t data_size = sqlite3_value_bytes(argv[0]);
_init_geos();
geometry = _geo_from_wkb((const unsigned char*)data,data_size);
if(geometry != 0)
{
double length = 0;
GEOSLength(geometry,&length);
sqlite3_result_double(context,length);
}
GEOSGeom_destroy(geometry);
finishGEOS();
}
}
void geo_maxy(sqlite3_context *context,int argc,sqlite3_value **argv)
{
if(argc == 1 && sqlite3_value_type(argv[0]) == SQLITE_BLOB)
{
GEOSGeometry* geometry;
Rect rect;
const void* data = sqlite3_value_blob(argv[0]);
size_t data_size = sqlite3_value_bytes(argv[0]);
_init_geos();
geometry = _geo_from_wkb((const unsigned char*)data,data_size);
if(geometry != 0)
{
_get_envelope(geometry,&rect);
sqlite3_result_double(context,rect.maxY);
}
GEOSGeom_destroy(geometry);
finishGEOS();
}
}
void object::test<4>
()
{
initGEOS(notice, notice);
GEOSGeometry* geom1 = GEOSGeomFromWKT("LINESTRING(0 0, 1 0)");
ensure("GEOSGeomFromWKT failed", nullptr != geom1);
GEOS_interruptRegisterCallback(interruptNow);
GEOSGeometry* geom2 = GEOSBuffer(geom1, 1, 8);
ensure("GEOSBuffer wasn't interrupted", nullptr == geom2);
GEOS_interruptRegisterCallback(nullptr); /* unregister */
// TODO: check the actual exception ? (sent to notice() callback)
GEOSGeom_destroy(geom1);
finishGEOS();
}
LWGEOM *
lwgeom_normalize(const LWGEOM *geom1)
{
LWGEOM *result ;
GEOSGeometry *g1;
int is3d ;
int srid ;
srid = (int)(geom1->srid);
is3d = FLAGS_GET_Z(geom1->flags);
initGEOS(lwnotice, lwgeom_geos_error);
g1 = LWGEOM2GEOS(geom1);
if ( 0 == g1 ) /* exception thrown at construction */
{
lwerror("First argument geometry could not be converted to GEOS.");
return NULL ;
}
if ( -1 == GEOSNormalize(g1) )
{
lwerror("Error in GEOSNormalize: %s", lwgeom_geos_errmsg);
return NULL; /* never get here */
}
GEOSSetSRID(g1, srid); /* needed ? */
result = GEOS2LWGEOM(g1, is3d);
GEOSGeom_destroy(g1);
if (result == NULL)
{
lwerror("Error performing intersection: GEOS2LWGEOM: %s",
lwgeom_geos_errmsg);
return NULL ; /* never get here */
}
return result ;
}
void geo_type(sqlite3_context *context,int argc,sqlite3_value **argv)
{
if(argc == 1 && sqlite3_value_type(argv[0]) == SQLITE_BLOB)
{
GEOSGeometry* geometry;
char* type;
const void* data = sqlite3_value_blob(argv[0]);
size_t data_size = sqlite3_value_bytes(argv[0]);
_init_geos();
geometry = _geo_from_wkb((const unsigned char*)data,data_size);
if(geometry != 0)
{
type = GEOSGeomType(geometry);
sqlite3_result_text(context,type,-1,SQLITE_TRANSIENT);
GEOSFree(type);
}
GEOSGeom_destroy(geometry);
finishGEOS();
}
}
static void
PreparedCacheDelete(MemoryContext context)
{
PrepGeomHashEntry* pghe;
/* Lookup the hash entry pointer in the global hash table so we can free it */
pghe = GetPrepGeomHashEntry(context);
if (!pghe)
elog(ERROR, "PreparedCacheDelete: Trying to delete non-existant hash entry object with MemoryContext key (%p)", (void *)context);
POSTGIS_DEBUGF(3, "deleting geom object (%p) and prepared geom object (%p) with MemoryContext key (%p)", pghe->geom, pghe->prepared_geom, context);
/* Free them */
if ( pghe->prepared_geom )
GEOSPreparedGeom_destroy( pghe->prepared_geom );
if ( pghe->geom )
GEOSGeom_destroy( (GEOSGeometry *)pghe->geom );
/* Remove the hash entry as it is no longer needed */
DeletePrepGeomHashEntry(context);
}
void geo_wkb(sqlite3_context *context,int argc,sqlite3_value **argv)
{
if(argc == 1 && sqlite3_value_type(argv[0]) == SQLITE_TEXT)
{
GEOSGeometry* geometry;
const char* wkt = (const char*)sqlite3_value_text(argv[0]);
unsigned char* wkb;
size_t size;
_init_geos();
geometry = _geo_from_wkt(wkt);
if(geometry != 0)
{
wkb = GEOSGeomToWKB_buf(geometry,&size);
sqlite3_result_blob(context,(const void*)wkb,size,SQLITE_TRANSIENT);
GEOSFree(wkb);
}
GEOSGeom_destroy(geometry);
finishGEOS();
}
}
void geo_y(sqlite3_context *context,int argc,sqlite3_value **argv)
{
if(argc == 1 && sqlite3_value_type(argv[0]) == SQLITE_BLOB)
{
GEOSGeometry* geometry;
const void* data = sqlite3_value_blob(argv[0]);
size_t data_size = sqlite3_value_bytes(argv[0]);
_init_geos();
geometry = _geo_from_wkb((const unsigned char*)data,data_size);
if(geometry != 0)
{
if(GEOSGeomTypeId(geometry) == GEOS_POINT)
{
double y;
GEOSGeomGetY(geometry,&y);
sqlite3_result_double(context,y);
}
}
GEOSGeom_destroy(geometry);
finishGEOS();
}
}
void object::test<5>
()
{
numcalls = 0;
initGEOS(notice, notice);
GEOSGeometry* geom1 = GEOSGeomFromWKT("LINESTRING(0 0, 1 0)");
ensure("GEOSGeomFromWKT failed", nullptr != geom1);
GEOS_interruptRegisterCallback(interruptNow);
nextcb = GEOS_interruptRegisterCallback(countCalls);
GEOSGeometry* geom2 = GEOSBuffer(geom1, 1, 8);
ensure("GEOSBuffer wasn't interrupted", nullptr == geom2);
ensure_equals(numcalls, 1);
GEOS_interruptRegisterCallback(nullptr); /* unregister */
nextcb = nullptr;
GEOSGeom_destroy(geom1);
finishGEOS();
}
LWGEOM*
lwgeom_geos_noop(const LWGEOM* geom_in)
{
GEOSGeometry *geosgeom;
LWGEOM* geom_out;
int is3d = FLAGS_GET_Z(geom_in->flags);
initGEOS(lwnotice, lwgeom_geos_error);
geosgeom = LWGEOM2GEOS(geom_in);
if ( ! geosgeom ) {
lwerror("Geometry could not be converted to GEOS: %s",
lwgeom_geos_errmsg);
return NULL;
}
geom_out = GEOS2LWGEOM(geosgeom, is3d);
GEOSGeom_destroy(geosgeom);
if ( ! geom_out ) {
lwerror("GEOS Geometry could not be converted to LWGEOM: %s",
lwgeom_geos_errmsg);
}
return geom_out;
}
static ERL_NIF_TERM
topology_preserve_simplify(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[])
{
GEOSGeometry **geom;
GEOSGeometry *simpler_geom;
double dbl_tol;
int int_tol;
ERL_NIF_TERM eterm;
if(!enif_get_resource(env, argv[0], GEOSGEOM_RESOURCE, (void**)&geom)) {
return 0;
}
if (enif_get_int(env, argv[1], &int_tol)) {
dbl_tol = int_tol;
}
else if (!enif_get_double(env, argv[1], &dbl_tol)) {
return 0;
}
simpler_geom = GEOSTopologyPreserveSimplify(*geom, dbl_tol);
eterm = geom_to_eterm(env, simpler_geom);
GEOSGeom_destroy(simpler_geom);
return eterm;
}
char *msudf_intersection(UDF_INIT *initid,UDF_ARGS *args, char *buf,
unsigned long *length, char *is_null, char *error)
{
char *result;
GEOSGeom geomFirst,geomSecond,geomResult;
DEBUG("msudf_intersection");
geomFirst = msudf_getGeometry((unsigned char *)args->args[0],args->lengths[0]);
if (geomFirst == NULL) {
strcpy(error,"Invalid geometry.");
*is_null = 1;
return 0;
}
geomSecond = msudf_getGeometry((unsigned char *)args->args[1],args->lengths[1]);
if (geomSecond == NULL) {
GEOSGeom_destroy(geomFirst);
strcpy(error,"Invalid geometry.");
*is_null = 1;
return 0;
}
geomResult = GEOSIntersection(geomFirst,geomSecond);
if (geomResult!= NULL) {
GEOSSetSRID(geomResult,GEOSGetSRID(geomFirst));
result = msudf_returnGeometry(initid,length,geomResult);
GEOSGeom_destroy(geomFirst);
GEOSGeom_destroy(geomSecond);
GEOSGeom_destroy(geomResult);
return result;
} else {
GEOSGeom_destroy(geomFirst);
GEOSGeom_destroy(geomSecond);
*is_null = 1;
return NULL;
}
}
/*
** GetPrepGeomCache
**
** Pull the current prepared geometry from the cache or make
** one if there is not one available. Only prepare geometry
** if we are seeing a key for the second time. That way rapidly
** cycling keys don't cause too much preparing.
*/
PrepGeomCache*
GetPrepGeomCache(FunctionCallInfoData *fcinfo, GSERIALIZED *pg_geom1, GSERIALIZED *pg_geom2)
{
MemoryContext old_context;
PrepGeomCache* cache = fcinfo->flinfo->fn_extra;
int copy_keys = 1;
size_t pg_geom1_size = 0;
size_t pg_geom2_size = 0;
/* Make sure this isn't someone else's cache object. */
if ( cache && cache->type != 2 ) cache = NULL;
if (!PrepGeomHash)
CreatePrepGeomHash();
if ( pg_geom1 )
pg_geom1_size = VARSIZE(pg_geom1) + VARHDRSZ;
if ( pg_geom2 )
pg_geom2_size = VARSIZE(pg_geom2) + VARHDRSZ;
if ( cache == NULL)
{
/*
** Cache requested, but the cache isn't set up yet.
** Set it up, but don't prepare the geometry yet.
** That way if the next call is a cache miss we haven't
** wasted time preparing a geometry we don't need.
*/
PrepGeomHashEntry pghe;
old_context = MemoryContextSwitchTo(fcinfo->flinfo->fn_mcxt);
cache = palloc(sizeof(PrepGeomCache));
MemoryContextSwitchTo(old_context);
cache->type = 2;
cache->prepared_geom = 0;
cache->geom = 0;
cache->argnum = 0;
cache->pg_geom1 = 0;
cache->pg_geom2 = 0;
cache->pg_geom1_size = 0;
cache->pg_geom2_size = 0;
cache->context = MemoryContextCreate(T_AllocSetContext, 8192,
&PreparedCacheContextMethods,
fcinfo->flinfo->fn_mcxt,
"PostGIS Prepared Geometry Context");
POSTGIS_DEBUGF(3, "GetPrepGeomCache: creating cache: %p", cache);
pghe.context = cache->context;
pghe.geom = 0;
pghe.prepared_geom = 0;
AddPrepGeomHashEntry( pghe );
fcinfo->flinfo->fn_extra = cache;
POSTGIS_DEBUGF(3, "GetPrepGeomCache: adding context to hash: %p", cache);
}
else if ( pg_geom1 &&
cache->argnum != 2 &&
cache->pg_geom1_size == pg_geom1_size &&
memcmp(cache->pg_geom1, pg_geom1, pg_geom1_size) == 0)
{
if ( !cache->prepared_geom )
{
/*
** Cache hit, but we haven't prepared our geometry yet.
** Prepare it.
*/
PrepGeomHashEntry* pghe;
cache->geom = POSTGIS2GEOS( pg_geom1 );
cache->prepared_geom = GEOSPrepare( cache->geom );
cache->argnum = 1;
POSTGIS_DEBUG(3, "GetPrepGeomCache: preparing obj in argument 1");
pghe = GetPrepGeomHashEntry(cache->context);
pghe->geom = cache->geom;
pghe->prepared_geom = cache->prepared_geom;
POSTGIS_DEBUG(3, "GetPrepGeomCache: storing references to prepared obj in argument 1");
}
else
{
/*
** Cache hit, and we're good to go. Do nothing.
*/
POSTGIS_DEBUG(3, "GetPrepGeomCache: cache hit, argument 1");
}
/* We don't need new keys until we have a cache miss */
copy_keys = 0;
}
else if ( pg_geom2 &&
cache->argnum != 1 &&
cache->pg_geom2_size == pg_geom2_size &&
memcmp(cache->pg_geom2, pg_geom2, pg_geom2_size) == 0)
{
if ( !cache->prepared_geom )
{
/*
** Cache hit on arg2, but we haven't prepared our geometry yet.
** Prepare it.
*/
PrepGeomHashEntry* pghe;
cache->geom = POSTGIS2GEOS( pg_geom2 );
cache->prepared_geom = GEOSPrepare( cache->geom );
cache->argnum = 2;
POSTGIS_DEBUG(3, "GetPrepGeomCache: preparing obj in argument 2");
pghe = GetPrepGeomHashEntry(cache->context);
pghe->geom = cache->geom;
pghe->prepared_geom = cache->prepared_geom;
POSTGIS_DEBUG(3, "GetPrepGeomCache: storing references to prepared obj in argument 2");
}
else
{
/*
** Cache hit, and we're good to go. Do nothing.
*/
POSTGIS_DEBUG(3, "GetPrepGeomCache: cache hit, argument 2");
}
/* We don't need new keys until we have a cache miss */
copy_keys = 0;
}
else if ( cache->prepared_geom )
{
/*
** No cache hits, so this must be a miss.
** Destroy the GEOS objects, empty the cache.
*/
PrepGeomHashEntry* pghe;
pghe = GetPrepGeomHashEntry(cache->context);
pghe->geom = 0;
pghe->prepared_geom = 0;
POSTGIS_DEBUGF(3, "GetPrepGeomCache: cache miss, argument %d", cache->argnum);
GEOSPreparedGeom_destroy( cache->prepared_geom );
GEOSGeom_destroy( (GEOSGeometry *)cache->geom );
cache->prepared_geom = 0;
cache->geom = 0;
cache->argnum = 0;
}
if ( copy_keys && pg_geom1 )
{
/*
** If this is a new key (cache miss) we flip into the function
** manager memory context and make a copy. We can't just store a pointer
** because this copy will be pfree'd at the end of this function
** call.
*/
POSTGIS_DEBUG(3, "GetPrepGeomCache: copying pg_geom1 into cache");
old_context = MemoryContextSwitchTo(fcinfo->flinfo->fn_mcxt);
if ( cache->pg_geom1 )
pfree(cache->pg_geom1);
cache->pg_geom1 = palloc(pg_geom1_size);
MemoryContextSwitchTo(old_context);
memcpy(cache->pg_geom1, pg_geom1, pg_geom1_size);
cache->pg_geom1_size = pg_geom1_size;
}
if ( copy_keys && pg_geom2 )
{
POSTGIS_DEBUG(3, "GetPrepGeomCache: copying pg_geom2 into cache");
old_context = MemoryContextSwitchTo(fcinfo->flinfo->fn_mcxt);
if ( cache->pg_geom2 )
pfree(cache->pg_geom2);
cache->pg_geom2 = palloc(pg_geom2_size);
MemoryContextSwitchTo(old_context);
memcpy(cache->pg_geom2, pg_geom2, pg_geom2_size);
cache->pg_geom2_size = pg_geom2_size;
}
return cache;
}
LWGEOM*
lwgeom_snap(const LWGEOM* geom1, const LWGEOM* geom2, double tolerance)
{
#if POSTGIS_GEOS_VERSION < 33
lwerror("The GEOS version this lwgeom library "
"was compiled against (%d) doesn't support "
"'Snap' function (3.3.0+ required)",
POSTGIS_GEOS_VERSION);
return NULL;
#else /* POSTGIS_GEOS_VERSION >= 33 */
int srid, is3d;
GEOSGeometry *g1, *g2, *g3;
LWGEOM* out;
srid = geom1->srid;
error_if_srid_mismatch(srid, (int)(geom2->srid));
is3d = (FLAGS_GET_Z(geom1->flags) || FLAGS_GET_Z(geom2->flags)) ;
initGEOS(lwnotice, lwgeom_geos_error);
g1 = (GEOSGeometry *)LWGEOM2GEOS(geom1);
if ( 0 == g1 ) /* exception thrown at construction */
{
lwerror("First argument geometry could not be converted to GEOS: %s", lwgeom_geos_errmsg);
return NULL;
}
g2 = (GEOSGeometry *)LWGEOM2GEOS(geom2);
if ( 0 == g2 ) /* exception thrown at construction */
{
lwerror("Second argument geometry could not be converted to GEOS: %s", lwgeom_geos_errmsg);
GEOSGeom_destroy(g1);
return NULL;
}
g3 = GEOSSnap(g1, g2, tolerance);
if (g3 == NULL)
{
GEOSGeom_destroy(g1);
GEOSGeom_destroy(g2);
lwerror("GEOSSnap: %s", lwgeom_geos_errmsg);
return NULL;
}
GEOSGeom_destroy(g1);
GEOSGeom_destroy(g2);
GEOSSetSRID(g3, srid);
out = GEOS2LWGEOM(g3, is3d);
if (out == NULL)
{
GEOSGeom_destroy(g3);
lwerror("GEOSSnap() threw an error (result LWGEOM geometry formation)!");
return NULL;
}
GEOSGeom_destroy(g3);
return out;
#endif /* POSTGIS_GEOS_VERSION >= 33 */
}
void ReadStoreDelete(struct ReadStore * store)
{
if ( store->location != NULL )
GEOSGeom_destroy(store->location);
pfree(store);
}
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;
}
/* Initializes and uses GEOS internally */
static LWGEOM*
lwline_split_by_line(const LWLINE* lwline_in, const LWLINE* blade_in)
{
LWGEOM** components;
LWGEOM* diff;
LWCOLLECTION* out;
GEOSGeometry* gdiff; /* difference */
GEOSGeometry* g1;
GEOSGeometry* g2;
int ret;
/* Possible outcomes:
*
* 1. The lines do not cross or overlap
* -> Return a collection with single element
* 2. The lines cross
* -> Return a collection of all elements resulting from the split
*/
initGEOS(lwgeom_geos_error, lwgeom_geos_error);
g1 = LWGEOM2GEOS((LWGEOM*)lwline_in);
if ( ! g1 )
{
lwerror("LWGEOM2GEOS: %s", lwgeom_geos_errmsg);
return NULL;
}
g2 = LWGEOM2GEOS((LWGEOM*)blade_in);
if ( ! g2 )
{
GEOSGeom_destroy(g1);
lwerror("LWGEOM2GEOS: %s", lwgeom_geos_errmsg);
return NULL;
}
/* If interior intersecton is linear we can't split */
ret = GEOSRelatePattern(g1, g2, "1********");
if ( 2 == ret )
{
lwerror("GEOSRelatePattern: %s", lwgeom_geos_errmsg);
GEOSGeom_destroy(g1);
GEOSGeom_destroy(g2);
return NULL;
}
if ( ret )
{
GEOSGeom_destroy(g1);
GEOSGeom_destroy(g2);
lwerror("Splitter line has linear intersection with input");
return NULL;
}
gdiff = GEOSDifference(g1,g2);
GEOSGeom_destroy(g1);
GEOSGeom_destroy(g2);
if (gdiff == NULL)
{
lwerror("GEOSDifference: %s", lwgeom_geos_errmsg);
return NULL;
}
diff = GEOS2LWGEOM(gdiff, FLAGS_GET_Z(lwline_in->flags));
GEOSGeom_destroy(gdiff);
if (NULL == diff)
{
lwerror("GEOS2LWGEOM: %s", lwgeom_geos_errmsg);
return NULL;
}
if ( ! lwtype_is_collection(diff->type) )
{
components = lwalloc(sizeof(LWGEOM*)*1);
components[0] = diff;
out = lwcollection_construct(COLLECTIONTYPE, lwline_in->srid,
NULL, 1, components);
}
else
{
out = lwcollection_construct(COLLECTIONTYPE, lwline_in->srid,
NULL, ((LWCOLLECTION*)diff)->ngeoms,
((LWCOLLECTION*)diff)->geoms);
}
return (LWGEOM*)out;
}
static void
geom_destroy(ErlNifEnv *env, void *obj)
{
GEOSGeometry **geom = (GEOSGeometry**)obj;
GEOSGeom_destroy(*geom);
}
/* Initializes and uses GEOS internally */
static LWGEOM*
lwpoly_split_by_line(const LWPOLY* lwpoly_in, const LWLINE* blade_in)
{
LWCOLLECTION* out;
GEOSGeometry* g1;
GEOSGeometry* g2;
GEOSGeometry* g1_bounds;
GEOSGeometry* polygons;
const GEOSGeometry *vgeoms[1];
int i,n;
int hasZ = FLAGS_GET_Z(lwpoly_in->flags);
/* Possible outcomes:
*
* 1. The line does not split the polygon
* -> Return a collection with single element
* 2. The line does split the polygon
* -> Return a collection of all elements resulting from the split
*/
initGEOS(lwgeom_geos_error, lwgeom_geos_error);
g1 = LWGEOM2GEOS((LWGEOM*)lwpoly_in, 0);
if ( NULL == g1 )
{
lwerror("LWGEOM2GEOS: %s", lwgeom_geos_errmsg);
return NULL;
}
g1_bounds = GEOSBoundary(g1);
if ( NULL == g1_bounds )
{
GEOSGeom_destroy(g1);
lwerror("GEOSBoundary: %s", lwgeom_geos_errmsg);
return NULL;
}
g2 = LWGEOM2GEOS((LWGEOM*)blade_in, 0);
if ( NULL == g2 )
{
GEOSGeom_destroy(g1);
GEOSGeom_destroy(g1_bounds);
lwerror("LWGEOM2GEOS: %s", lwgeom_geos_errmsg);
return NULL;
}
vgeoms[0] = GEOSUnion(g1_bounds, g2);
if ( NULL == vgeoms[0] )
{
GEOSGeom_destroy(g1);
GEOSGeom_destroy(g2);
GEOSGeom_destroy(g1_bounds);
lwerror("GEOSUnion: %s", lwgeom_geos_errmsg);
return NULL;
}
polygons = GEOSPolygonize(vgeoms, 1);
if ( NULL == polygons )
{
GEOSGeom_destroy(g1);
GEOSGeom_destroy(g2);
GEOSGeom_destroy(g1_bounds);
GEOSGeom_destroy((GEOSGeometry*)vgeoms[0]);
lwerror("GEOSPolygonize: %s", lwgeom_geos_errmsg);
return NULL;
}
#if PARANOIA_LEVEL > 0
if ( GEOSGeomTypeId(polygons) != COLLECTIONTYPE )
{
GEOSGeom_destroy(g1);
GEOSGeom_destroy(g2);
GEOSGeom_destroy(g1_bounds);
GEOSGeom_destroy((GEOSGeometry*)vgeoms[0]);
GEOSGeom_destroy(polygons);
lwerror("%s [%s] Unexpected return from GEOSpolygonize", __FILE__, __LINE__);
return 0;
}
#endif
/* We should now have all polygons, just skip
* the ones which are in holes of the original
* geometries and return the rest in a collection
*/
n = GEOSGetNumGeometries(polygons);
out = lwcollection_construct_empty(COLLECTIONTYPE, lwpoly_in->srid,
hasZ, 0);
/* Allocate space for all polys */
out->geoms = lwrealloc(out->geoms, sizeof(LWGEOM*)*n);
assert(0 == out->ngeoms);
for (i=0; i<n; ++i)
{
GEOSGeometry* pos; /* point on surface */
const GEOSGeometry* p = GEOSGetGeometryN(polygons, i);
int contains;
pos = GEOSPointOnSurface(p);
if ( ! pos )
{
GEOSGeom_destroy(g1);
GEOSGeom_destroy(g2);
GEOSGeom_destroy(g1_bounds);
GEOSGeom_destroy((GEOSGeometry*)vgeoms[0]);
GEOSGeom_destroy(polygons);
lwerror("GEOSPointOnSurface: %s", lwgeom_geos_errmsg);
return NULL;
}
contains = GEOSContains(g1, pos);
if ( 2 == contains )
{
GEOSGeom_destroy(g1);
GEOSGeom_destroy(g2);
GEOSGeom_destroy(g1_bounds);
GEOSGeom_destroy((GEOSGeometry*)vgeoms[0]);
GEOSGeom_destroy(polygons);
GEOSGeom_destroy(pos);
lwerror("GEOSContains: %s", lwgeom_geos_errmsg);
return NULL;
}
GEOSGeom_destroy(pos);
if ( 0 == contains )
{
/* Original geometry doesn't contain
* a point in this ring, must be an hole
*/
continue;
}
out->geoms[out->ngeoms++] = GEOS2LWGEOM(p, hasZ);
}
GEOSGeom_destroy(g1);
GEOSGeom_destroy(g2);
GEOSGeom_destroy(g1_bounds);
GEOSGeom_destroy((GEOSGeometry*)vgeoms[0]);
GEOSGeom_destroy(polygons);
return (LWGEOM*)out;
}
void OGRILI1Layer::PolygonizeAreaLayer()
{
if (poAreaLineLayer == 0) return;
//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());
OGRMultiPolygon* polys = Polygonize( gc , false);
CPLDebug( "OGR_ILI", "Resulting polygons: %d", polys->getNumGeometries());
if (polys->getNumGeometries() != poAreaReferenceLayer->GetFeatureCount())
{
CPLDebug( "OGR_ILI", "Feature count of layer %s: %d", poAreaReferenceLayer->GetLayerDefn()->GetName(), GetFeatureCount());
CPLDebug( "OGR_ILI", "Polygonizing again with crossing line fix");
delete polys;
polys = Polygonize( gc, true ); //try again with crossing line fix
}
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());
for( i = 0; i < polys->getNumGeometries(); i++ )
{
ahInGeoms[i] = polys->getGeometryRef(i)->exportToGEOS();
if (!GEOSisValid(ahInGeoms[i])) ahInGeoms[i] = NULL;
}
poAreaReferenceLayer->ResetReading();
while (OGRFeature *feature = poAreaReferenceLayer->GetNextFeatureRef())
{
GEOSGeom point = (GEOSGeom)feature->GetGeometryRef()->exportToGEOS();
for (i = 0; i < polys->getNumGeometries(); i++ )
{
if (ahInGeoms[i] && GEOSWithin(point, ahInGeoms[i]))
{
OGRFeature* areaFeature = feature->Clone();
areaFeature->SetGeometry( polys->getGeometryRef(i) );
AddFeature(areaFeature);
break;
}
}
if (i == polys->getNumGeometries())
{
CPLDebug( "OGR_ILI", "Association between area and point failed.");
feature->SetGeometry( &emptyPoly );
}
GEOSGeom_destroy( point );
}
for( i = 0; i < polys->getNumGeometries(); i++ )
GEOSGeom_destroy( ahInGeoms[i] );
CPLFree( ahInGeoms );
#endif
poAreaReferenceLayer = 0;
poAreaLineLayer = 0;
}
LWGEOM*
lwgeom_node(const LWGEOM* lwgeom_in)
{
#if POSTGIS_GEOS_VERSION < 33
lwerror("The GEOS version this postgis binary "
"was compiled against (%d) doesn't support "
"'GEOSUnaryUnion' function (3.3.0+ required)",
POSTGIS_GEOS_VERSION);
return NULL;
#else /* POSTGIS_GEOS_VERSION >= 33 */
GEOSGeometry *g1, *gu, *gm;
LWGEOM *ep, *lines;
LWCOLLECTION *col, *tc;
int pn, ln, np, nl;
if ( lwgeom_dimension(lwgeom_in) != 1 ) {
lwerror("Noding geometries of dimension != 1 is unsupported");
return NULL;
}
initGEOS(lwgeom_geos_error, lwgeom_geos_error);
g1 = LWGEOM2GEOS(lwgeom_in);
if ( ! g1 ) {
lwerror("LWGEOM2GEOS: %s", lwgeom_geos_errmsg);
return NULL;
}
ep = lwgeom_extract_unique_endpoints(lwgeom_in);
if ( ! ep ) {
GEOSGeom_destroy(g1);
lwerror("Error extracting unique endpoints from input");
return NULL;
}
/* Unary union input to fully node */
gu = GEOSUnaryUnion(g1);
GEOSGeom_destroy(g1);
if ( ! gu ) {
lwgeom_free(ep);
lwerror("GEOSUnaryUnion: %s", lwgeom_geos_errmsg);
return NULL;
}
/* Linemerge (in case of overlaps) */
gm = GEOSLineMerge(gu);
GEOSGeom_destroy(gu);
if ( ! gm ) {
lwgeom_free(ep);
lwerror("GEOSLineMerge: %s", lwgeom_geos_errmsg);
return NULL;
}
lines = GEOS2LWGEOM(gm, FLAGS_GET_Z(lwgeom_in->flags));
GEOSGeom_destroy(gm);
if ( ! lines ) {
lwgeom_free(ep);
lwerror("Error during GEOS2LWGEOM");
return NULL;
}
/*
* Reintroduce endpoints from input, using split-line-by-point.
* Note that by now we can be sure that each point splits at
* most _one_ segment as any point shared by multiple segments
* would already be a node. Also we can be sure that any of
* the segments endpoints won't split any other segment.
* We can use the above 2 assertions to early exit the loop.
*/
col = lwcollection_construct_empty(MULTILINETYPE, lwgeom_in->srid,
FLAGS_GET_Z(lwgeom_in->flags),
FLAGS_GET_M(lwgeom_in->flags));
np = lwgeom_ngeoms(ep);
for (pn=0; pn<np; ++pn) { /* for each point */
const LWPOINT* p = (LWPOINT*)lwgeom_subgeom(ep, pn);
nl = lwgeom_ngeoms(lines);
for (ln=0; ln<nl; ++ln) { /* for each line */
const LWLINE* l = (LWLINE*)lwgeom_subgeom(lines, ln);
int s = lwline_split_by_point_to(l, p, (LWMLINE*)col);
if ( ! s ) continue; /* not on this line */
if ( s == 1 ) {
/* found on this line, but not splitting it */
break;
}
/* splits this line */
/* replace this line with the two splits */
if ( lwgeom_is_collection(lines) ) {
tc = (LWCOLLECTION*)lines;
lwcollection_reserve(tc, nl + 1);
while (nl > ln+1) {
tc->geoms[nl] = tc->geoms[nl-1];
--nl;
}
lwgeom_free(tc->geoms[ln]);
tc->geoms[ln] = col->geoms[0];
tc->geoms[ln+1] = col->geoms[1];
tc->ngeoms++;
} else {
lwgeom_free(lines);
/* transfer ownership rather than cloning */
lines = (LWGEOM*)lwcollection_clone_deep(col);
assert(col->ngeoms == 2);
lwgeom_free(col->geoms[0]);
lwgeom_free(col->geoms[1]);
}
/* reset the vector */
assert(col->ngeoms == 2);
col->ngeoms = 0;
break;
}
}
lwgeom_free(ep);
lwcollection_free(col);
lines->srid = lwgeom_in->srid;
return (LWGEOM*)lines;
#endif /* POSTGIS_GEOS_VERSION >= 33 */
}
~test_capigeouserdata_data()
{
GEOSGeom_destroy(geom_);
geom_ = nullptr;
finishGEOS();
}
void QgsZonalStatistics::statisticsFromMiddlePointTest_improved( void* band, QgsGeometry* poly, int pixelOffsetX, int pixelOffsetY, int nCellsX, int nCellsY,
double cellSizeX, double cellSizeY, const QgsRectangle& rasterBBox, double& sum, double& count )
{
double cellCenterX, cellCenterY;
QgsPoint currentCellCenter;
float* scanLine = ( float * ) CPLMalloc( sizeof( float ) * nCellsX );
cellCenterY = rasterBBox.yMaximum() - pixelOffsetY * cellSizeY - cellSizeY / 2;
count = 0;
sum = 0;
for ( int i = 0; i < nCellsY; ++i )
{
GDALRasterIO( band, GF_Read, pixelOffsetX, pixelOffsetY + i, nCellsX, 1, scanLine, nCellsX, 1, GDT_Float32, 0, 0 );
cellCenterX = rasterBBox.xMinimum() + pixelOffsetX * cellSizeX + cellSizeX / 2;
//do intersection of scanline with geometry
GEOSCoordSequence* scanLineSequence = GEOSCoordSeq_create( 2, 2 );
GEOSCoordSeq_setX( scanLineSequence, 0, cellCenterX );
GEOSCoordSeq_setY( scanLineSequence, 0, cellCenterY );
GEOSCoordSeq_setX( scanLineSequence, 1, cellCenterX + nCellsX * cellSizeX );
GEOSCoordSeq_setY( scanLineSequence, 1, cellCenterY );
GEOSGeometry* scanLineGeos = GEOSGeom_createLineString( scanLineSequence ); //todo: delete
GEOSGeometry* polyGeos = poly->asGeos();
GEOSGeometry* scanLineIntersection = GEOSIntersection( scanLineGeos, polyGeos );
GEOSGeom_destroy( scanLineGeos );
if ( !scanLineIntersection )
{
cellCenterY -= cellSizeY;
continue;
}
//debug
//char* scanLineIntersectionType = GEOSGeomType( scanLineIntersection );
int numGeoms = GEOSGetNumGeometries( scanLineIntersection );
if ( numGeoms < 1 )
{
GEOSGeom_destroy( scanLineIntersection );
cellCenterY -= cellSizeY;
continue;
}
QList<double> scanLineList;
double currentValue;
GEOSGeometry* currentGeom = 0;
for ( int z = 0; z < numGeoms; ++z )
{
if ( numGeoms == 1 )
{
currentGeom = scanLineIntersection;
}
else
{
currentGeom = GEOSGeom_clone( GEOSGetGeometryN( scanLineIntersection, z ) );
}
const GEOSCoordSequence* scanLineCoordSequence = GEOSGeom_getCoordSeq( currentGeom );
if ( !scanLineCoordSequence )
{
//error
}
unsigned int scanLineIntersectionSize;
GEOSCoordSeq_getSize( scanLineCoordSequence, &scanLineIntersectionSize );
if ( !scanLineCoordSequence || scanLineIntersectionSize < 2 || ( scanLineIntersectionSize & 1 ) )
{
//error
}
for ( unsigned int k = 0; k < scanLineIntersectionSize; ++k )
{
GEOSCoordSeq_getX( scanLineCoordSequence, k, ¤tValue );
scanLineList.push_back( currentValue );
}
if ( numGeoms != 1 )
{
GEOSGeom_destroy( currentGeom );
}
}
GEOSGeom_destroy( scanLineIntersection );
qSort( scanLineList );
if ( scanLineList.size() < 1 )
{
cellCenterY -= cellSizeY;
continue;
}
int listPlace = -1;
for ( int j = 0; j < nCellsX; ++j )
{
//currentCellCenter = QgsPoint( cellCenterX, cellCenterY );
//instead of doing a contained test every time, find the place of scanLineList and check if even / odd
if ( listPlace >= scanLineList.size() - 1 )
{
break;
}
if ( cellCenterX >= scanLineList.at( listPlace + 1 ) )
{
++listPlace;
if ( listPlace >= scanLineList.size() )
{
break;
}
}
if ( listPlace >= 0 && listPlace < ( scanLineList.size() - 1 ) && !( listPlace & 1 ) )
{
if ( scanLine[j] != mInputNodataValue ) //don't consider nodata values
{
sum += scanLine[j];
++count;
}
}
cellCenterX += cellSizeX;
}
cellCenterY -= cellSizeY;
}
CPLFree( scanLine );
}
LWGEOM *
lwgeom_symdifference(const LWGEOM* geom1, const LWGEOM* geom2)
{
GEOSGeometry *g1, *g2, *g3;
LWGEOM *result;
int is3d;
int srid;
/* A.SymDifference(Empty) == A */
if ( lwgeom_is_empty(geom2) )
return lwgeom_clone(geom1);
/* Empty.DymDifference(B) == Empty */
if ( lwgeom_is_empty(geom1) )
return lwgeom_clone(geom1);
/* ensure srids are identical */
srid = (int)(geom1->srid);
error_if_srid_mismatch(srid, (int)(geom2->srid));
is3d = (FLAGS_GET_Z(geom1->flags) || FLAGS_GET_Z(geom2->flags)) ;
initGEOS(lwnotice, lwgeom_geos_error);
g1 = LWGEOM2GEOS(geom1);
if ( 0 == g1 ) /* exception thrown at construction */
{
lwerror("First argument geometry could not be converted to GEOS: %s", lwgeom_geos_errmsg);
return NULL;
}
g2 = LWGEOM2GEOS(geom2);
if ( 0 == g2 ) /* exception thrown at construction */
{
lwerror("Second argument geometry could not be converted to GEOS: %s", lwgeom_geos_errmsg);
GEOSGeom_destroy(g1);
return NULL;
}
g3 = GEOSSymDifference(g1,g2);
if (g3 == NULL)
{
GEOSGeom_destroy(g1);
GEOSGeom_destroy(g2);
lwerror("GEOSSymDifference: %s", lwgeom_geos_errmsg);
return NULL; /*never get here */
}
LWDEBUGF(3, "result: %s", GEOSGeomToWKT(g3));
GEOSSetSRID(g3, srid);
result = GEOS2LWGEOM(g3, is3d);
if (result == NULL)
{
GEOSGeom_destroy(g1);
GEOSGeom_destroy(g2);
GEOSGeom_destroy(g3);
lwerror("GEOS symdifference() threw an error (result postgis geometry formation)!");
return NULL ; /*never get here */
}
GEOSGeom_destroy(g1);
GEOSGeom_destroy(g2);
GEOSGeom_destroy(g3);
return result;
}
/* Initializes and uses GEOS internally */
static LWGEOM*
lwline_split_by_line(const LWLINE* lwline_in, const LWGEOM* blade_in)
{
LWGEOM** components;
LWGEOM* diff;
LWCOLLECTION* out;
GEOSGeometry* gdiff; /* difference */
GEOSGeometry* g1;
GEOSGeometry* g2;
int ret;
/* ASSERT blade_in is LINE or MULTILINE */
assert (blade_in->type == LINETYPE ||
blade_in->type == MULTILINETYPE ||
blade_in->type == POLYGONTYPE ||
blade_in->type == MULTIPOLYGONTYPE );
/* Possible outcomes:
*
* 1. The lines do not cross or overlap
* -> Return a collection with single element
* 2. The lines cross
* -> Return a collection of all elements resulting from the split
*/
initGEOS(lwgeom_geos_error, lwgeom_geos_error);
g1 = LWGEOM2GEOS((LWGEOM*)lwline_in, 0);
if ( ! g1 )
{
lwerror("LWGEOM2GEOS: %s", lwgeom_geos_errmsg);
return NULL;
}
g2 = LWGEOM2GEOS(blade_in, 0);
if ( ! g2 )
{
GEOSGeom_destroy(g1);
lwerror("LWGEOM2GEOS: %s", lwgeom_geos_errmsg);
return NULL;
}
/* If blade is a polygon, pick its boundary */
if ( blade_in->type == POLYGONTYPE || blade_in->type == MULTIPOLYGONTYPE )
{
gdiff = GEOSBoundary(g2);
GEOSGeom_destroy(g2);
if ( ! gdiff )
{
GEOSGeom_destroy(g1);
lwerror("GEOSBoundary: %s", lwgeom_geos_errmsg);
return NULL;
}
g2 = gdiff; gdiff = NULL;
}
/* If interior intersecton is linear we can't split */
ret = GEOSRelatePattern(g1, g2, "1********");
if ( 2 == ret )
{
lwerror("GEOSRelatePattern: %s", lwgeom_geos_errmsg);
GEOSGeom_destroy(g1);
GEOSGeom_destroy(g2);
return NULL;
}
if ( ret )
{
GEOSGeom_destroy(g1);
GEOSGeom_destroy(g2);
lwerror("Splitter line has linear intersection with input");
return NULL;
}
gdiff = GEOSDifference(g1,g2);
GEOSGeom_destroy(g1);
GEOSGeom_destroy(g2);
if (gdiff == NULL)
{
lwerror("GEOSDifference: %s", lwgeom_geos_errmsg);
return NULL;
}
diff = GEOS2LWGEOM(gdiff, FLAGS_GET_Z(lwline_in->flags));
GEOSGeom_destroy(gdiff);
if (NULL == diff)
{
lwerror("GEOS2LWGEOM: %s", lwgeom_geos_errmsg);
return NULL;
}
out = lwgeom_as_lwcollection(diff);
if ( ! out )
{
components = lwalloc(sizeof(LWGEOM*)*1);
components[0] = diff;
out = lwcollection_construct(COLLECTIONTYPE, lwline_in->srid,
NULL, 1, components);
}
else
{
/* Set SRID */
lwgeom_set_srid((LWGEOM*)out, lwline_in->srid);
/* Force collection type */
out->type = COLLECTIONTYPE;
}
return (LWGEOM*)out;
}
LWGEOM *
lwgeom_intersection(const LWGEOM *geom1, const LWGEOM *geom2)
{
LWGEOM *result ;
GEOSGeometry *g1, *g2, *g3 ;
int is3d ;
int srid ;
/* A.Intersection(Empty) == Empty */
if ( lwgeom_is_empty(geom2) )
return lwgeom_clone(geom2);
/* Empty.Intersection(A) == Empty */
if ( lwgeom_is_empty(geom1) )
return lwgeom_clone(geom1);
/* ensure srids are identical */
srid = (int)(geom1->srid);
error_if_srid_mismatch(srid, (int)(geom2->srid));
is3d = (FLAGS_GET_Z(geom1->flags) || FLAGS_GET_Z(geom2->flags)) ;
initGEOS(lwnotice, lwgeom_geos_error);
LWDEBUG(3, "intersection() START");
g1 = LWGEOM2GEOS(geom1);
if ( 0 == g1 ) /* exception thrown at construction */
{
lwerror("First argument geometry could not be converted to GEOS.");
return NULL ;
}
g2 = LWGEOM2GEOS(geom2);
if ( 0 == g2 ) /* exception thrown at construction */
{
lwerror("Second argument geometry could not be converted to GEOS.");
GEOSGeom_destroy(g1);
return NULL ;
}
LWDEBUG(3, " constructed geometrys - calling geos");
LWDEBUGF(3, " g1 = %s", GEOSGeomToWKT(g1));
LWDEBUGF(3, " g2 = %s", GEOSGeomToWKT(g2));
/*LWDEBUGF(3, "g2 is valid = %i",GEOSisvalid(g2)); */
/*LWDEBUGF(3, "g1 is valid = %i",GEOSisvalid(g1)); */
g3 = GEOSIntersection(g1,g2);
LWDEBUG(3, " intersection finished");
if (g3 == NULL)
{
GEOSGeom_destroy(g1);
GEOSGeom_destroy(g2);
lwerror("Error performing intersection: %s",
lwgeom_geos_errmsg);
return NULL; /* never get here */
}
LWDEBUGF(3, "result: %s", GEOSGeomToWKT(g3) ) ;
GEOSSetSRID(g3, srid);
result = GEOS2LWGEOM(g3, is3d);
if (result == NULL)
{
GEOSGeom_destroy(g1);
GEOSGeom_destroy(g2);
GEOSGeom_destroy(g3);
lwerror("Error performing intersection: GEOS2LWGEOM: %s",
lwgeom_geos_errmsg);
return NULL ; /* never get here */
}
GEOSGeom_destroy(g1);
GEOSGeom_destroy(g2);
GEOSGeom_destroy(g3);
return result ;
}
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;
}
LWGEOM*
lwgeom_union(const LWGEOM *geom1, const LWGEOM *geom2)
{
int is3d;
int srid;
GEOSGeometry *g1, *g2, *g3;
LWGEOM *result;
LWDEBUG(2, "in geomunion");
/* A.Union(empty) == A */
if ( lwgeom_is_empty(geom1) )
return lwgeom_clone(geom2);
/* B.Union(empty) == B */
if ( lwgeom_is_empty(geom2) )
return lwgeom_clone(geom1);
/* ensure srids are identical */
srid = (int)(geom1->srid);
error_if_srid_mismatch(srid, (int)(geom2->srid));
is3d = (FLAGS_GET_Z(geom1->flags) || FLAGS_GET_Z(geom2->flags)) ;
initGEOS(lwnotice, lwgeom_geos_error);
g1 = LWGEOM2GEOS(geom1);
if ( 0 == g1 ) /* exception thrown at construction */
{
lwerror("First argument geometry could not be converted to GEOS: %s", lwgeom_geos_errmsg);
return NULL;
}
g2 = LWGEOM2GEOS(geom2);
if ( 0 == g2 ) /* exception thrown at construction */
{
GEOSGeom_destroy(g1);
lwerror("Second argument geometry could not be converted to GEOS: %s", lwgeom_geos_errmsg);
return NULL;
}
LWDEBUGF(3, "g1=%s", GEOSGeomToWKT(g1));
LWDEBUGF(3, "g2=%s", GEOSGeomToWKT(g2));
g3 = GEOSUnion(g1,g2);
LWDEBUGF(3, "g3=%s", GEOSGeomToWKT(g3));
GEOSGeom_destroy(g1);
GEOSGeom_destroy(g2);
if (g3 == NULL)
{
lwerror("GEOSUnion: %s", lwgeom_geos_errmsg);
return NULL; /* never get here */
}
GEOSSetSRID(g3, srid);
result = GEOS2LWGEOM(g3, is3d);
GEOSGeom_destroy(g3);
if (result == NULL)
{
lwerror("Error performing union: GEOS2LWGEOM: %s",
lwgeom_geos_errmsg);
return NULL; /*never get here */
}
return result;
}