/**
* COLLECTION, MULTIPOINTTYPE, MULTILINETYPE, MULTIPOLYGONTYPE, COMPOUNDTYPE,
* MULTICURVETYPE, MULTISURFACETYPE,
* TINTYPE
*/
static LWCOLLECTION* lwcollection_from_wkb_state(wkb_parse_state *s)
{
uint32_t ngeoms = integer_from_wkb_state(s);
LWCOLLECTION *col = lwcollection_construct_empty(s->lwtype, s->srid, s->has_z, s->has_m);
LWGEOM *geom = NULL;
int i;
LWDEBUGF(4,"Collection has %d components", ngeoms);
/* Empty collection? */
if ( ngeoms == 0 )
return col;
/* Be strict in polyhedral surface closures */
if ( s->lwtype == POLYHEDRALSURFACETYPE )
s->check |= LW_PARSER_CHECK_ZCLOSURE;
for ( i = 0; i < ngeoms; i++ )
{
geom = lwgeom_from_wkb_state(s);
if ( lwcollection_add_lwgeom(col, geom) == NULL )
{
lwerror("Unable to add geometry (%p) to collection (%p)", geom, col);
return NULL;
}
}
return col;
}
static LWGEOM*
parse_geojson_geometrycollection(json_object *geojson, bool *hasz, int *root_srid)
{
LWGEOM *geom = NULL;
int i;
json_object* poObjGeoms = NULL;
if (!*root_srid)
{
geom = (LWGEOM *)lwcollection_construct_empty(COLLECTIONTYPE, *root_srid, 1, 0);
}
else
{
geom = (LWGEOM *)lwcollection_construct_empty(COLLECTIONTYPE, -1, 1, 0);
}
poObjGeoms = findMemberByName( geojson, "geometries" );
if ( ! poObjGeoms )
geojson_lwerror("Unable to find 'geometries' in GeoJSON string", 4);
if( json_type_array == json_object_get_type( poObjGeoms ) )
{
const int nGeoms = json_object_array_length( poObjGeoms );
json_object* poObjGeom = NULL;
for(i = 0; i < nGeoms; ++i )
{
poObjGeom = json_object_array_get_idx( poObjGeoms, i );
geom = (LWGEOM*)lwcollection_add_lwgeom((LWCOLLECTION *)geom,
parse_geojson(poObjGeom, hasz, root_srid));
}
}
return geom;
}
/**
* MULTIPOLYGON
*/
static LWCOLLECTION* lwmultipoly_from_twkb_state(twkb_parse_state *s)
{
int ngeoms, i;
LWGEOM *geom = NULL;
LWCOLLECTION *col = lwcollection_construct_empty(s->lwtype, SRID_UNKNOWN, s->has_z, s->has_m);
LWDEBUG(2,"Entering lwmultipolygon_from_twkb_state");
if ( s->is_empty )
return col;
/* Read number of geometries */
ngeoms = twkb_parse_state_uvarint(s);
LWDEBUGF(4,"Number of geometries %d",ngeoms);
/* It has an idlist, we need to skip that */
if ( s->has_idlist )
{
for ( i = 0; i < ngeoms; i++ )
twkb_parse_state_varint_skip(s);
}
for ( i = 0; i < ngeoms; i++ )
{
geom = lwpoly_as_lwgeom(lwpoly_from_twkb_state(s));
if ( lwcollection_add_lwgeom(col, geom) == NULL )
{
lwerror("Unable to add geometry (%p) to collection (%p)", geom, col);
return NULL;
}
}
return col;
}
int lwcompound_add_lwgeom(LWCOMPOUND *comp, LWGEOM *geom)
{
LWCOLLECTION *col = (LWCOLLECTION*)comp;
/* Empty things can't continuously join up with other things */
if ( lwgeom_is_empty(geom) )
{
LWDEBUG(4, "Got an empty component for a compound curve!");
return LW_FAILURE;
}
if( col->ngeoms > 0 )
{
POINT4D last, first;
/* First point of the component we are adding */
LWLINE *newline = (LWLINE*)geom;
/* Last point of the previous component */
LWLINE *prevline = (LWLINE*)(col->geoms[col->ngeoms-1]);
getPoint4d_p(newline->points, 0, &first);
getPoint4d_p(prevline->points, prevline->points->npoints-1, &last);
if ( !(FP_EQUALS(first.x,last.x) && FP_EQUALS(first.y,last.y)) )
{
LWDEBUG(4, "Components don't join up end-to-end!");
LWDEBUGF(4, "first pt (%g %g %g %g) last pt (%g %g %g %g)", first.x, first.y, first.z, first.m, last.x, last.y, last.z, last.m);
return LW_FAILURE;
}
}
col = lwcollection_add_lwgeom(col, geom);
return LW_SUCCESS;
}
/**
* Parse KML MultiGeometry
*/
static LWGEOM* parse_kml_multi(xmlNodePtr xnode, bool *hasz)
{
LWGEOM *geom;
xmlNodePtr xa;
geom = (LWGEOM *)lwcollection_construct_empty(COLLECTIONTYPE, 4326, 1, 0);
for (xa = xnode->children ; xa != NULL ; xa = xa->next)
{
if (xa->type != XML_ELEMENT_NODE) continue;
if (!is_kml_namespace(xa, false)) continue;
if ( !strcmp((char *) xa->name, "Point")
|| !strcmp((char *) xa->name, "LineString")
|| !strcmp((char *) xa->name, "Polygon")
|| !strcmp((char *) xa->name, "MultiGeometry"))
{
if (xa->children == NULL) break;
geom = (LWGEOM*)lwcollection_add_lwgeom((LWCOLLECTION*)geom, parse_kml(xa, hasz));
}
}
return geom;
}
/**
* Clip an input MULTIPOINT between two values, on any ordinate input.
*/
LWCOLLECTION*
lwmpoint_clip_to_ordinate_range(const LWMPOINT *mpoint, char ordinate, double from, double to)
{
LWCOLLECTION *lwgeom_out = NULL;
char hasz, hasm;
int i;
/* Nothing to do with NULL */
if ( ! mpoint )
lwerror("Null input geometry.");
/* Ensure 'from' is less than 'to'. */
if ( to < from )
{
double t = from;
from = to;
to = t;
}
/* Read Z/M info */
hasz = lwgeom_has_z(lwmpoint_as_lwgeom(mpoint));
hasm = lwgeom_has_m(lwmpoint_as_lwgeom(mpoint));
/* Prepare return object */
lwgeom_out = lwcollection_construct_empty(MULTIPOINTTYPE, mpoint->srid, hasz, hasm);
/* For each point, is its ordinate value between from and to? */
for ( i = 0; i < mpoint->ngeoms; i ++ )
{
POINT4D p4d;
double ordinate_value;
lwpoint_getPoint4d_p(mpoint->geoms[i], &p4d);
ordinate_value = lwpoint_get_ordinate(&p4d, ordinate);
if ( from <= ordinate_value && to >= ordinate_value )
{
LWPOINT *lwp = lwpoint_clone(mpoint->geoms[i]);
lwcollection_add_lwgeom(lwgeom_out, lwpoint_as_lwgeom(lwp));
}
}
/* Set the bbox */
lwgeom_drop_bbox((LWGEOM*)lwgeom_out);
lwgeom_add_bbox((LWGEOM*)lwgeom_out);
return lwgeom_out;
}
LWCOLLECTION* lwcollection_simplify(const LWCOLLECTION *igeom, double dist)
{
int i;
LWCOLLECTION *out = lwcollection_construct_empty(igeom->type, igeom->srid, FLAGS_GET_Z(igeom->flags), FLAGS_GET_M(igeom->flags));
if( lwcollection_is_empty(igeom) )
return out; /* should we return NULL instead ? */
for( i = 0; i < igeom->ngeoms; i++ )
{
LWGEOM *ngeom = lwgeom_simplify(igeom->geoms[i], dist);
if ( ngeom ) out = lwcollection_add_lwgeom(out, ngeom);
}
return out;
}
/**
* Clip an input POINT between two values, on any ordinate input.
*/
LWCOLLECTION*
lwpoint_clip_to_ordinate_range(const LWPOINT *point, char ordinate, double from, double to)
{
LWCOLLECTION *lwgeom_out = NULL;
char hasz, hasm;
POINT4D p4d;
double ordinate_value;
/* Nothing to do with NULL */
if ( ! point )
lwerror("Null input geometry.");
/* Ensure 'from' is less than 'to'. */
if ( to < from )
{
double t = from;
from = to;
to = t;
}
/* Read Z/M info */
hasz = lwgeom_has_z(lwpoint_as_lwgeom(point));
hasm = lwgeom_has_m(lwpoint_as_lwgeom(point));
/* Prepare return object */
lwgeom_out = lwcollection_construct_empty(MULTIPOINTTYPE, point->srid, hasz, hasm);
/* Test if ordinate is in range */
lwpoint_getPoint4d_p(point, &p4d);
ordinate_value = lwpoint_get_ordinate(&p4d, ordinate);
if ( from <= ordinate_value && to >= ordinate_value )
{
LWPOINT *lwp = lwpoint_clone(point);
lwcollection_add_lwgeom(lwgeom_out, lwpoint_as_lwgeom(lwp));
}
/* Set the bbox */
lwgeom_drop_bbox((LWGEOM*)lwgeom_out);
lwgeom_add_bbox((LWGEOM*)lwgeom_out);
return lwgeom_out;
}
/*
** Given a generic collection, return the "simplest" form.
**
** eg: GEOMETRYCOLLECTION(MULTILINESTRING()) => MULTILINESTRING()
**
** GEOMETRYCOLLECTION(MULTILINESTRING(), MULTILINESTRING(), POINT())
** => GEOMETRYCOLLECTION(MULTILINESTRING(), POINT())
**
** In general, if the subcomponents are homogeneous, return a properly
** typed collection.
** Otherwise, return a generic collection, with the subtypes in minimal
** typed collections.
*/
static void
lwcollection_build_buffer(const LWCOLLECTION *col, HomogenizeBuffer *buffer)
{
int i;
if ( ! col ) return;
if ( lwgeom_is_empty(lwcollection_as_lwgeom(col)) ) return;
for ( i = 0; i < col->ngeoms; i++ )
{
LWGEOM *geom = col->geoms[i];
switch(geom->type)
{
case POINTTYPE:
case LINETYPE:
case CIRCSTRINGTYPE:
case COMPOUNDTYPE:
case TRIANGLETYPE:
case CURVEPOLYTYPE:
case POLYGONTYPE:
{
/* Init if necessary */
if ( ! buffer->buf[geom->type] )
{
LWCOLLECTION *bufcol = lwcollection_construct_empty(COLLECTIONTYPE, col->srid, FLAGS_GET_Z(col->flags), FLAGS_GET_M(col->flags));
bufcol->type = lwtype_get_collectiontype(geom->type);
buffer->buf[geom->type] = bufcol;
}
/* Add sub-geom to buffer */
lwcollection_add_lwgeom(buffer->buf[geom->type], lwgeom_clone(geom));
/* Increment count for this singleton type */
buffer->cnt[geom->type] = buffer->cnt[geom->type] + 1;
}
default:
{
lwcollection_build_buffer(lwgeom_as_lwcollection(geom), buffer);
}
}
}
return;
}
LWGEOM* wkt_parser_collection_add_geom(LWGEOM *col, LWGEOM *geom)
{
LWDEBUG(4,"entered");
/* Toss error on null geometry input */
if( ! (geom && col) )
{
SET_PARSER_ERROR(PARSER_ERROR_OTHER);
return NULL;
}
/* All the elements must agree on dimensionality */
if( FLAGS_NDIMS(col->flags) != FLAGS_NDIMS(geom->flags) )
{
lwgeom_free(col);
lwgeom_free(geom);
SET_PARSER_ERROR(PARSER_ERROR_MIXDIMS);
return NULL;
}
return lwcollection_as_lwgeom(lwcollection_add_lwgeom(lwgeom_as_lwcollection(col), geom));
}
static LWCOLLECTION* lwcollection_set_effective_area(const LWCOLLECTION *igeom,int set_area, double trshld)
{
LWDEBUG(2, "Entered lwcollection_set_effective_area");
int i;
int set_m;
if(set_area)
set_m=1;
else
set_m=FLAGS_GET_M(igeom->flags);
LWCOLLECTION *out = lwcollection_construct_empty(igeom->type, igeom->srid, FLAGS_GET_Z(igeom->flags), set_m);
if( lwcollection_is_empty(igeom) )
return out; /* should we return NULL instead ? */
for( i = 0; i < igeom->ngeoms; i++ )
{
LWGEOM *ngeom = lwgeom_set_effective_area(igeom->geoms[i],set_area,trshld);
if ( ngeom ) out = lwcollection_add_lwgeom(out, ngeom);
}
return out;
}
static LWGEOM*
lwcollection_homogenize(const LWCOLLECTION *col)
{
int i;
int ntypes = 0;
int type = 0;
LWGEOM *outgeom = NULL;
HomogenizeBuffer buffer;
/* Sort all the parts into a buffer */
init_homogenizebuffer(&buffer);
lwcollection_build_buffer(col, &buffer);
/* Check for homogeneity */
for ( i = 0; i < NUMTYPES; i++ )
{
if ( buffer.cnt[i] > 0 )
{
ntypes++;
type = i;
}
}
/* No types? Huh. Return empty. */
if ( ntypes == 0 )
{
LWCOLLECTION *outcol;
outcol = lwcollection_construct_empty(COLLECTIONTYPE, col->srid, FLAGS_GET_Z(col->flags), FLAGS_GET_M(col->flags));
outgeom = lwcollection_as_lwgeom(outcol);
}
/* One type, return homogeneous collection */
else if ( ntypes == 1 )
{
LWCOLLECTION *outcol;
outcol = buffer.buf[type];
if ( outcol->ngeoms == 1 )
{
outgeom = outcol->geoms[0];
outcol->ngeoms=0; lwcollection_free(outcol);
}
else
{
outgeom = lwcollection_as_lwgeom(outcol);
}
outgeom->srid = col->srid;
}
/* Bah, more than out type, return anonymous collection */
else if ( ntypes > 1 )
{
int j;
LWCOLLECTION *outcol;
outcol = lwcollection_construct_empty(COLLECTIONTYPE, col->srid, FLAGS_GET_Z(col->flags), FLAGS_GET_M(col->flags));
for ( j = 0; j < NUMTYPES; j++ )
{
if ( buffer.buf[j] )
{
LWCOLLECTION *bcol = buffer.buf[j];
if ( bcol->ngeoms == 1 )
{
lwcollection_add_lwgeom(outcol, bcol->geoms[0]);
bcol->ngeoms=0; lwcollection_free(bcol);
}
else
{
lwcollection_add_lwgeom(outcol, lwcollection_as_lwgeom(bcol));
}
}
}
outgeom = lwcollection_as_lwgeom(outcol);
}
return outgeom;
}
LWTIN* lwtin_add_lwtriangle(LWTIN *mobj, const LWTRIANGLE *obj)
{
return (LWTIN*)lwcollection_add_lwgeom((LWCOLLECTION*)mobj, (LWGEOM*)obj);
}
LWGEOM*
pta_desegmentize(POINTARRAY *points, int type, int srid)
{
int i = 0, j, k;
POINT4D a1, a2, a3, b;
char *edges_in_arcs;
int found_arc = LW_FALSE;
int current_arc = 1;
int num_edges;
int edge_type = -1;
int start, end;
LWCOLLECTION *outcol;
/* Die on null input */
if ( ! points )
lwerror("pta_desegmentize called with null pointarray");
/* Null on empty input? */
if ( points->npoints == 0 )
return NULL;
/* We can't desegmentize anything shorter than four points */
if ( points->npoints < 4 )
{
/* Return a linestring here*/
lwerror("pta_desegmentize needs implementation for npoints < 4");
}
/* Allocate our result array of vertices that are part of arcs */
num_edges = points->npoints - 1;
edges_in_arcs = lwalloc(num_edges);
memset(edges_in_arcs, 0, num_edges);
/* We make a candidate arc of the first two edges, */
/* And then see if the next edge follows it */
while( i < num_edges-2 )
{
found_arc = LW_FALSE;
/* Make candidate arc */
getPoint4d_p(points, i , &a1);
getPoint4d_p(points, i+1, &a2);
getPoint4d_p(points, i+2, &a3);
for( j = i+3; j < num_edges+1; j++ )
{
LWDEBUGF(4, "i=%d, j=%d", i, j);
getPoint4d_p(points, j, &b);
/* Does this point fall on our candidate arc? */
if ( pt_continues_arc(&a1, &a2, &a3, &b) )
{
/* Yes. Mark this edge and the two preceding it as arc components */
LWDEBUGF(4, "pt_continues_arc #%d", current_arc);
found_arc = LW_TRUE;
for ( k = j-1; k > j-4; k-- )
edges_in_arcs[k] = current_arc;
}
else
{
/* No. So we're done with this candidate arc */
LWDEBUG(4, "pt_continues_arc = false");
current_arc++;
break;
}
}
/* Jump past all the edges that were added to the arc */
if ( found_arc )
{
i = j-1;
}
else
{
/* Mark this edge as a linear edge */
edges_in_arcs[i] = 0;
i = i+1;
}
}
#if POSTGIS_DEBUG_LEVEL > 3
{
char *edgestr = lwalloc(num_edges+1);
for ( i = 0; i < num_edges; i++ )
{
if ( edges_in_arcs[i] )
edgestr[i] = 48 + edges_in_arcs[i];
else
edgestr[i] = '.';
}
edgestr[num_edges] = 0;
LWDEBUGF(3, "edge pattern %s", edgestr);
lwfree(edgestr);
}
#endif
start = 0;
edge_type = edges_in_arcs[0];
outcol = lwcollection_construct_empty(COMPOUNDTYPE, srid, ptarray_has_z(points), ptarray_has_m(points));
for( i = 1; i < num_edges; i++ )
{
if( edge_type != edges_in_arcs[i] )
{
end = i - 1;
lwcollection_add_lwgeom(outcol, geom_from_pa(points, srid, edge_type, start, end));
start = i;
edge_type = edges_in_arcs[i];
}
}
/* Roll out last item */
end = num_edges - 1;
lwcollection_add_lwgeom(outcol, geom_from_pa(points, srid, edge_type, start, end));
/* Strip down to singleton if only one entry */
if ( outcol->ngeoms == 1 )
{
LWGEOM *outgeom = outcol->geoms[0];
lwfree(outcol);
return outgeom;
}
return lwcollection_as_lwgeom(outcol);
}
LWPSURFACE* lwpsurface_add_lwpoly(LWPSURFACE *mobj, const LWPOLY *obj)
{
return (LWPSURFACE*)lwcollection_add_lwgeom((LWCOLLECTION*)mobj, (LWGEOM*)obj);
}
LWMPOINT* lwmpoint_add_lwpoint(LWMPOINT *mobj, const LWPOINT *obj)
{
LWDEBUG(4, "Called");
return (LWMPOINT*)lwcollection_add_lwgeom((LWCOLLECTION*)mobj, (LWGEOM*)obj);
}
LWMPOLY* lwmpoly_add_lwpoly(LWMPOLY *mobj, const LWPOLY *obj)
{
return (LWMPOLY*)lwcollection_add_lwgeom((LWCOLLECTION*)mobj, (LWGEOM*)obj);
}
/**
* Take in a LINESTRING and return a MULTILINESTRING of those portions of the
* LINESTRING between the from/to range for the specified ordinate (XYZM)
*/
LWCOLLECTION*
lwline_clip_to_ordinate_range(const LWLINE *line, char ordinate, double from, double to)
{
POINTARRAY *pa_in = NULL;
LWCOLLECTION *lwgeom_out = NULL;
POINTARRAY *dp = NULL;
int i, rv;
int added_last_point = 0;
POINT4D *p = NULL, *q = NULL, *r = NULL;
double ordinate_value_p = 0.0, ordinate_value_q = 0.0;
char hasz = lwgeom_has_z(lwline_as_lwgeom(line));
char hasm = lwgeom_has_m(lwline_as_lwgeom(line));
char dims = FLAGS_NDIMS(line->flags);
/* Null input, nothing we can do. */
if ( ! line )
{
lwerror("Null input geometry.");
return NULL;
}
/* Ensure 'from' is less than 'to'. */
if ( to < from )
{
double t = from;
from = to;
to = t;
}
LWDEBUGF(4, "from = %g, to = %g, ordinate = %c", from, to, ordinate);
LWDEBUGF(4, "%s", lwgeom_to_ewkt((LWGEOM*)line));
/* Asking for an ordinate we don't have. Error. */
if ( (ordinate == 'Z' && ! hasz) || (ordinate == 'M' && ! hasm) )
{
lwerror("Cannot clip on ordinate %d in a %d-d geometry.", ordinate, dims);
return NULL;
}
/* Prepare our working point objects. */
p = lwalloc(sizeof(POINT4D));
q = lwalloc(sizeof(POINT4D));
r = lwalloc(sizeof(POINT4D));
/* Construct a collection to hold our outputs. */
lwgeom_out = lwcollection_construct_empty(MULTILINETYPE, line->srid, hasz, hasm);
/* Get our input point array */
pa_in = line->points;
for ( i = 0; i < pa_in->npoints; i++ )
{
LWDEBUGF(4, "Point #%d", i);
LWDEBUGF(4, "added_last_point %d", added_last_point);
if ( i > 0 )
{
*q = *p;
ordinate_value_q = ordinate_value_p;
}
rv = getPoint4d_p(pa_in, i, p);
ordinate_value_p = lwpoint_get_ordinate(p, ordinate);
LWDEBUGF(4, " ordinate_value_p %g (current)", ordinate_value_p);
LWDEBUGF(4, " ordinate_value_q %g (previous)", ordinate_value_q);
/* Is this point inside the ordinate range? Yes. */
if ( ordinate_value_p >= from && ordinate_value_p <= to )
{
LWDEBUGF(4, " inside ordinate range (%g, %g)", from, to);
if ( ! added_last_point )
{
LWDEBUG(4," new ptarray required");
/* We didn't add the previous point, so this is a new segment.
* Make a new point array. */
dp = ptarray_construct_empty(hasz, hasm, 32);
/* We're transiting into the range so add an interpolated
* point at the range boundary.
* If we're on a boundary and crossing from the far side,
* we also need an interpolated point. */
if ( i > 0 && ( /* Don't try to interpolate if this is the first point */
( ordinate_value_p > from && ordinate_value_p < to ) || /* Inside */
( ordinate_value_p == from && ordinate_value_q > to ) || /* Hopping from above */
( ordinate_value_p == to && ordinate_value_q < from ) ) ) /* Hopping from below */
{
double interpolation_value;
(ordinate_value_q > to) ? (interpolation_value = to) : (interpolation_value = from);
rv = point_interpolate(q, p, r, hasz, hasm, ordinate, interpolation_value);
rv = ptarray_append_point(dp, r, LW_FALSE);
LWDEBUGF(4, "[0] interpolating between (%g, %g) with interpolation point (%g)", ordinate_value_q, ordinate_value_p, interpolation_value);
}
}
/* Add the current vertex to the point array. */
rv = ptarray_append_point(dp, p, LW_FALSE);
if ( ordinate_value_p == from || ordinate_value_p == to )
{
added_last_point = 2; /* Added on boundary. */
}
else
{
added_last_point = 1; /* Added inside range. */
}
}
/* Is this point inside the ordinate range? No. */
else
{
LWDEBUGF(4, " added_last_point (%d)", added_last_point);
if ( added_last_point == 1 )
{
/* We're transiting out of the range, so add an interpolated point
* to the point array at the range boundary. */
double interpolation_value;
(ordinate_value_p > to) ? (interpolation_value = to) : (interpolation_value = from);
rv = point_interpolate(q, p, r, hasz, hasm, ordinate, interpolation_value);
rv = ptarray_append_point(dp, r, LW_FALSE);
LWDEBUGF(4, " [1] interpolating between (%g, %g) with interpolation point (%g)", ordinate_value_q, ordinate_value_p, interpolation_value);
}
else if ( added_last_point == 2 )
{
/* We're out and the last point was on the boundary.
* If the last point was the near boundary, nothing to do.
* If it was the far boundary, we need an interpolated point. */
if ( from != to && (
(ordinate_value_q == from && ordinate_value_p > from) ||
(ordinate_value_q == to && ordinate_value_p < to) ) )
{
double interpolation_value;
(ordinate_value_p > to) ? (interpolation_value = to) : (interpolation_value = from);
rv = point_interpolate(q, p, r, hasz, hasm, ordinate, interpolation_value);
rv = ptarray_append_point(dp, r, LW_FALSE);
LWDEBUGF(4, " [2] interpolating between (%g, %g) with interpolation point (%g)", ordinate_value_q, ordinate_value_p, interpolation_value);
}
}
else if ( i && ordinate_value_q < from && ordinate_value_p > to )
{
/* We just hopped over the whole range, from bottom to top,
* so we need to add *two* interpolated points! */
dp = ptarray_construct(hasz, hasm, 2);
/* Interpolate lower point. */
rv = point_interpolate(p, q, r, hasz, hasm, ordinate, from);
ptarray_set_point4d(dp, 0, r);
/* Interpolate upper point. */
rv = point_interpolate(p, q, r, hasz, hasm, ordinate, to);
ptarray_set_point4d(dp, 1, r);
}
else if ( i && ordinate_value_q > to && ordinate_value_p < from )
{
/* We just hopped over the whole range, from top to bottom,
* so we need to add *two* interpolated points! */
dp = ptarray_construct(hasz, hasm, 2);
/* Interpolate upper point. */
rv = point_interpolate(p, q, r, hasz, hasm, ordinate, to);
ptarray_set_point4d(dp, 0, r);
/* Interpolate lower point. */
rv = point_interpolate(p, q, r, hasz, hasm, ordinate, from);
ptarray_set_point4d(dp, 1, r);
}
/* We have an extant point-array, save it out to a multi-line. */
if ( dp )
{
LWDEBUG(4, "saving pointarray to multi-line (1)");
/* Only one point, so we have to make an lwpoint to hold this
* and set the overall output type to a generic collection. */
if ( dp->npoints == 1 )
{
LWPOINT *opoint = lwpoint_construct(line->srid, NULL, dp);
lwgeom_out->type = COLLECTIONTYPE;
lwgeom_out = lwcollection_add_lwgeom(lwgeom_out, lwpoint_as_lwgeom(opoint));
}
else
{
LWLINE *oline = lwline_construct(line->srid, NULL, dp);
lwgeom_out = lwcollection_add_lwgeom(lwgeom_out, lwline_as_lwgeom(oline));
}
/* Pointarray is now owned by lwgeom_out, so drop reference to it */
dp = NULL;
}
added_last_point = 0;
}
}
/* Still some points left to be saved out. */
if ( dp && dp->npoints > 0 )
{
LWDEBUG(4, "saving pointarray to multi-line (2)");
LWDEBUGF(4, "dp->npoints == %d", dp->npoints);
LWDEBUGF(4, "lwgeom_out->ngeoms == %d", lwgeom_out->ngeoms);
if ( dp->npoints == 1 )
{
LWPOINT *opoint = lwpoint_construct(line->srid, NULL, dp);
lwgeom_out->type = COLLECTIONTYPE;
lwgeom_out = lwcollection_add_lwgeom(lwgeom_out, lwpoint_as_lwgeom(opoint));
}
else
{
LWLINE *oline = lwline_construct(line->srid, NULL, dp);
lwgeom_out = lwcollection_add_lwgeom(lwgeom_out, lwline_as_lwgeom(oline));
}
/* Pointarray is now owned by lwgeom_out, so drop reference to it */
dp = NULL;
}
lwfree(p);
lwfree(q);
lwfree(r);
if ( lwgeom_out->ngeoms > 0 )
{
lwgeom_drop_bbox((LWGEOM*)lwgeom_out);
lwgeom_add_bbox((LWGEOM*)lwgeom_out);
}
return lwgeom_out;
}
LWCOLLECTION*
lwgeom_clip_to_ordinate_range(const LWGEOM *lwin, char ordinate, double from, double to, double offset)
{
LWCOLLECTION *out_col;
LWCOLLECTION *out_offset;
int i;
if ( ! lwin )
lwerror("lwgeom_clip_to_ordinate_range: null input geometry!");
switch ( lwin->type )
{
case LINETYPE:
out_col = lwline_clip_to_ordinate_range((LWLINE*)lwin, ordinate, from, to);
break;
case MULTILINETYPE:
out_col = lwmline_clip_to_ordinate_range((LWMLINE*)lwin, ordinate, from, to);
break;
case MULTIPOINTTYPE:
out_col = lwmpoint_clip_to_ordinate_range((LWMPOINT*)lwin, ordinate, from, to);
break;
case POINTTYPE:
out_col = lwpoint_clip_to_ordinate_range((LWPOINT*)lwin, ordinate, from, to);
break;
default:
lwerror("This function does not accept %s geometries.", lwtype_name(lwin->type));
return NULL;;
}
/* Stop if result is NULL */
if ( out_col == NULL )
lwerror("lwgeom_clip_to_ordinate_range clipping routine returned NULL");
/* Return if we aren't going to offset the result */
if ( FP_EQUALS(offset, 0.0) || lwgeom_is_empty(lwcollection_as_lwgeom(out_col)) )
return out_col;
/* Construct a collection to hold our outputs. */
/* Things get ugly: GEOS offset drops Z's and M's so we have to drop ours */
out_offset = lwcollection_construct_empty(MULTILINETYPE, lwin->srid, 0, 0);
/* Try and offset the linear portions of the return value */
for ( i = 0; i < out_col->ngeoms; i++ )
{
int type = out_col->geoms[i]->type;
if ( type == POINTTYPE )
{
lwnotice("lwgeom_clip_to_ordinate_range cannot offset a clipped point");
continue;
}
else if ( type == LINETYPE )
{
/* lwgeom_offsetcurve(line, offset, quadsegs, joinstyle (round), mitrelimit) */
LWGEOM *lwoff = lwgeom_offsetcurve(lwgeom_as_lwline(out_col->geoms[i]), offset, 8, 1, 5.0);
if ( ! lwoff )
{
lwerror("lwgeom_offsetcurve returned null");
}
lwcollection_add_lwgeom(out_offset, lwoff);
}
else
{
lwerror("lwgeom_clip_to_ordinate_range found an unexpected type (%s) in the offset routine",lwtype_name(type));
}
}
return out_offset;
}
LWMLINE* lwmline_add_lwline(LWMLINE *mobj, const LWLINE *obj)
{
return (LWMLINE*)lwcollection_add_lwgeom((LWCOLLECTION*)mobj, (LWGEOM*)obj);
}
LWGEOM*
pta_unstroke(const POINTARRAY *points, int type, int srid)
{
int i = 0, j, k;
POINT4D a1, a2, a3, b;
POINT4D first, center;
char *edges_in_arcs;
int found_arc = LW_FALSE;
int current_arc = 1;
int num_edges;
int edge_type; /* non-zero if edge is part of an arc */
int start, end;
LWCOLLECTION *outcol;
/* Minimum number of edges, per quadrant, required to define an arc */
const unsigned int min_quad_edges = 2;
/* Die on null input */
if ( ! points )
lwerror("pta_unstroke called with null pointarray");
/* Null on empty input? */
if ( points->npoints == 0 )
return NULL;
/* We can't desegmentize anything shorter than four points */
if ( points->npoints < 4 )
{
/* Return a linestring here*/
lwerror("pta_unstroke needs implementation for npoints < 4");
}
/* Allocate our result array of vertices that are part of arcs */
num_edges = points->npoints - 1;
edges_in_arcs = lwalloc(num_edges + 1);
memset(edges_in_arcs, 0, num_edges + 1);
/* We make a candidate arc of the first two edges, */
/* And then see if the next edge follows it */
while( i < num_edges-2 )
{
unsigned int arc_edges;
double num_quadrants;
double angle;
found_arc = LW_FALSE;
/* Make candidate arc */
getPoint4d_p(points, i , &a1);
getPoint4d_p(points, i+1, &a2);
getPoint4d_p(points, i+2, &a3);
memcpy(&first, &a1, sizeof(POINT4D));
for( j = i+3; j < num_edges+1; j++ )
{
LWDEBUGF(4, "i=%d, j=%d", i, j);
getPoint4d_p(points, j, &b);
/* Does this point fall on our candidate arc? */
if ( pt_continues_arc(&a1, &a2, &a3, &b) )
{
/* Yes. Mark this edge and the two preceding it as arc components */
LWDEBUGF(4, "pt_continues_arc #%d", current_arc);
found_arc = LW_TRUE;
for ( k = j-1; k > j-4; k-- )
edges_in_arcs[k] = current_arc;
}
else
{
/* No. So we're done with this candidate arc */
LWDEBUG(4, "pt_continues_arc = false");
current_arc++;
break;
}
memcpy(&a1, &a2, sizeof(POINT4D));
memcpy(&a2, &a3, sizeof(POINT4D));
memcpy(&a3, &b, sizeof(POINT4D));
}
/* Jump past all the edges that were added to the arc */
if ( found_arc )
{
/* Check if an arc was composed by enough edges to be
* really considered an arc
* See http://trac.osgeo.org/postgis/ticket/2420
*/
arc_edges = j - 1 - i;
LWDEBUGF(4, "arc defined by %d edges found", arc_edges);
if ( first.x == b.x && first.y == b.y ) {
LWDEBUG(4, "arc is a circle");
num_quadrants = 4;
}
else {
lw_arc_center((POINT2D*)&first, (POINT2D*)&b, (POINT2D*)&a1, (POINT2D*)¢er);
angle = lw_arc_angle((POINT2D*)&first, (POINT2D*)¢er, (POINT2D*)&b);
int p2_side = lw_segment_side((POINT2D*)&first, (POINT2D*)&a1, (POINT2D*)&b);
if ( p2_side >= 0 ) angle = -angle;
if ( angle < 0 ) angle = 2 * M_PI + angle;
num_quadrants = ( 4 * angle ) / ( 2 * M_PI );
LWDEBUGF(4, "arc angle (%g %g, %g %g, %g %g) is %g (side is %d), quandrants:%g", first.x, first.y, center.x, center.y, b.x, b.y, angle, p2_side, num_quadrants);
}
/* a1 is first point, b is last point */
if ( arc_edges < min_quad_edges * num_quadrants ) {
LWDEBUGF(4, "Not enough edges for a %g quadrants arc, %g needed", num_quadrants, min_quad_edges * num_quadrants);
for ( k = j-1; k >= i; k-- )
edges_in_arcs[k] = 0;
}
i = j-1;
}
else
{
/* Mark this edge as a linear edge */
edges_in_arcs[i] = 0;
i = i+1;
}
}
#if POSTGIS_DEBUG_LEVEL > 3
{
char *edgestr = lwalloc(num_edges+1);
for ( i = 0; i < num_edges; i++ )
{
if ( edges_in_arcs[i] )
edgestr[i] = 48 + edges_in_arcs[i];
else
edgestr[i] = '.';
}
edgestr[num_edges] = 0;
LWDEBUGF(3, "edge pattern %s", edgestr);
lwfree(edgestr);
}
#endif
start = 0;
edge_type = edges_in_arcs[0];
outcol = lwcollection_construct_empty(COMPOUNDTYPE, srid, ptarray_has_z(points), ptarray_has_m(points));
for( i = 1; i < num_edges; i++ )
{
if( edge_type != edges_in_arcs[i] )
{
end = i - 1;
lwcollection_add_lwgeom(outcol, geom_from_pa(points, srid, edge_type, start, end));
start = i;
edge_type = edges_in_arcs[i];
}
}
lwfree(edges_in_arcs); /* not needed anymore */
/* Roll out last item */
end = num_edges - 1;
lwcollection_add_lwgeom(outcol, geom_from_pa(points, srid, edge_type, start, end));
/* Strip down to singleton if only one entry */
if ( outcol->ngeoms == 1 )
{
LWGEOM *outgeom = outcol->geoms[0];
outcol->ngeoms = 0; lwcollection_free(outcol);
return outgeom;
}
return lwcollection_as_lwgeom(outcol);
}