LWCOLLECTION *
lwcollection_construct(uint8_t type, int srid, GBOX *bbox,
uint32_t ngeoms, LWGEOM **geoms)
{
LWCOLLECTION *ret;
int hasz, hasm;
#ifdef CHECK_LWGEOM_ZM
char zm;
uint32_t i;
#endif
LWDEBUGF(2, "lwcollection_construct called with %d, %d, %p, %d, %p.", type, srid, bbox, ngeoms, geoms);
if( ! lwtype_is_collection(type) )
lwerror("Non-collection type specified in collection constructor!");
hasz = 0;
hasm = 0;
if ( ngeoms > 0 )
{
hasz = FLAGS_GET_Z(geoms[0]->flags);
hasm = FLAGS_GET_M(geoms[0]->flags);
#ifdef CHECK_LWGEOM_ZM
zm = FLAGS_GET_ZM(geoms[0]->flags);
LWDEBUGF(3, "lwcollection_construct type[0]=%d", geoms[0]->type);
for (i=1; i<ngeoms; i++)
{
LWDEBUGF(3, "lwcollection_construct type=[%d]=%d", i, geoms[i]->type);
if ( zm != FLAGS_GET_ZM(geoms[i]->flags) )
lwerror("lwcollection_construct: mixed dimension geometries: %d/%d", zm, FLAGS_GET_ZM(geoms[i]->flags));
}
#endif
}
ret = lwalloc(sizeof(LWCOLLECTION));
ret->type = type;
ret->flags = gflags(hasz,hasm,0);
FLAGS_SET_BBOX(ret->flags, bbox?1:0);
ret->srid = srid;
ret->ngeoms = ngeoms;
ret->maxgeoms = ngeoms;
ret->geoms = geoms;
ret->bbox = bbox;
return ret;
}
LWCOLLECTION *
lwcollection_construct_empty(uint8_t type, int srid, char hasz, char hasm)
{
LWCOLLECTION *ret;
if( ! lwtype_is_collection(type) )
lwerror("Non-collection type specified in collection constructor!");
ret = lwalloc(sizeof(LWCOLLECTION));
ret->type = type;
ret->flags = gflags(hasz,hasm,0);
ret->srid = srid;
ret->ngeoms = 0;
ret->maxgeoms = 1; /* Allocate room for sub-members, just in case. */
ret->geoms = lwalloc(ret->maxgeoms * sizeof(LWGEOM*));
ret->bbox = NULL;
return ret;
}
/**
* Force the dimensionality of a geometry to match the dimensionality
* of a set of flags (usually derived from a ZM WKT tag).
*/
static int wkt_parser_set_dims(LWGEOM *geom, uint8_t flags)
{
int hasz = FLAGS_GET_Z(flags);
int hasm = FLAGS_GET_M(flags);
int i = 0;
/* Error on junk */
if( ! geom )
return LW_FAILURE;
FLAGS_SET_Z(geom->flags, hasz);
FLAGS_SET_M(geom->flags, hasm);
if( ! lwgeom_is_empty(geom) )
{
if( geom->type == POINTTYPE )
{
LWPOINT *pt = (LWPOINT*)geom;
FLAGS_SET_Z(pt->point->flags, hasz);
FLAGS_SET_M(pt->point->flags, hasm);
return LW_SUCCESS;
}
else if ( (geom->type == TRIANGLETYPE) ||
(geom->type == CIRCSTRINGTYPE) ||
(geom->type == LINETYPE) )
{
LWLINE *ln = (LWLINE*)geom;
FLAGS_SET_Z(ln->points->flags, hasz);
FLAGS_SET_M(ln->points->flags, hasm);
return LW_SUCCESS;
}
else if ( geom->type == POLYGONTYPE )
{
LWPOLY *poly = (LWPOLY*)geom;
for ( i = 0; i < poly->nrings; i++ )
{
FLAGS_SET_Z(poly->rings[i]->flags, hasz);
FLAGS_SET_M(poly->rings[i]->flags, hasm);
}
return LW_SUCCESS;
}
else if ( geom->type == CURVEPOLYTYPE )
{
LWCURVEPOLY *poly = (LWCURVEPOLY*)geom;
for ( i = 0; i < poly->nrings; i++ )
wkt_parser_set_dims(poly->rings[i], flags);
return LW_SUCCESS;
}
else if ( lwtype_is_collection(geom->type) )
{
LWCOLLECTION *col = (LWCOLLECTION*)geom;
for ( i = 0; i < col->ngeoms; i++ )
wkt_parser_set_dims(col->geoms[i], flags);
return LW_SUCCESS;
}
else
{
LWDEBUGF(2,"Unknown geometry type: %d", geom->type);
return LW_FAILURE;
}
}
return LW_SUCCESS;
}
/**
* Takes a potentially heterogeneous collection and returns a homogeneous
* collection consisting only of the specified type.
*/
LWCOLLECTION* lwcollection_extract(LWCOLLECTION *col, int type)
{
int i = 0;
LWGEOM **geomlist;
LWCOLLECTION *outcol;
int geomlistsize = 16;
int geomlistlen = 0;
uint8_t outtype;
if ( ! col ) return NULL;
switch (type)
{
case POINTTYPE:
outtype = MULTIPOINTTYPE;
break;
case LINETYPE:
outtype = MULTILINETYPE;
break;
case POLYGONTYPE:
outtype = MULTIPOLYGONTYPE;
break;
default:
lwerror("Only POLYGON, LINESTRING and POINT are supported by lwcollection_extract. %s requested.", lwtype_name(type));
return NULL;
}
geomlist = lwalloc(sizeof(LWGEOM*) * geomlistsize);
/* Process each sub-geometry */
for ( i = 0; i < col->ngeoms; i++ )
{
int subtype = col->geoms[i]->type;
/* Don't bother adding empty sub-geometries */
if ( lwgeom_is_empty(col->geoms[i]) )
{
continue;
}
/* Copy our sub-types into the output list */
if ( subtype == type )
{
/* We've over-run our buffer, double the memory segment */
if ( geomlistlen == geomlistsize )
{
geomlistsize *= 2;
geomlist = lwrealloc(geomlist, sizeof(LWGEOM*) * geomlistsize);
}
geomlist[geomlistlen] = lwgeom_clone(col->geoms[i]);
geomlistlen++;
}
/* Recurse into sub-collections */
if ( lwtype_is_collection( subtype ) )
{
int j = 0;
LWCOLLECTION *tmpcol = lwcollection_extract((LWCOLLECTION*)col->geoms[i], type);
for ( j = 0; j < tmpcol->ngeoms; j++ )
{
/* We've over-run our buffer, double the memory segment */
if ( geomlistlen == geomlistsize )
{
geomlistsize *= 2;
geomlist = lwrealloc(geomlist, sizeof(LWGEOM*) * geomlistsize);
}
geomlist[geomlistlen] = tmpcol->geoms[j];
geomlistlen++;
}
lwfree(tmpcol);
}
}
if ( geomlistlen > 0 )
{
GBOX gbox;
outcol = lwcollection_construct(outtype, col->srid, NULL, geomlistlen, geomlist);
lwgeom_calculate_gbox((LWGEOM *) outcol, &gbox);
outcol->bbox = gbox_copy(&gbox);
}
else
{
lwfree(geomlist);
outcol = lwcollection_construct_empty(outtype, col->srid, FLAGS_GET_Z(col->flags), FLAGS_GET_M(col->flags));
}
return outcol;
}
int
lwgeom_is_collection(const LWGEOM *geom)
{
if( ! geom ) return LW_FALSE;
return lwtype_is_collection(geom->type);
}
/* 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;
}
