POINTARRAY*
ptarray_force_dims(const POINTARRAY *pa, int hasz, int hasm)
{
/* TODO handle zero-length point arrays */
int i;
int in_hasz = FLAGS_GET_Z(pa->flags);
int in_hasm = FLAGS_GET_M(pa->flags);
POINT4D pt;
POINTARRAY *pa_out = ptarray_construct_empty(hasz, hasm, pa->npoints);
for( i = 0; i < pa->npoints; i++ )
{
getPoint4d_p(pa, i, &pt);
if( hasz && ! in_hasz )
pt.z = 0.0;
if( hasm && ! in_hasm )
pt.m = 0.0;
ptarray_append_point(pa_out, &pt, LW_TRUE);
}
return pa_out;
}
static LWGEOM*
parse_geojson_multipoint(json_object *geojson, bool *hasz, int *root_srid)
{
LWGEOM *geom;
int i = 0;
json_object* poObjPoints = NULL;
if (!*root_srid)
{
geom = (LWGEOM *)lwcollection_construct_empty(MULTIPOINTTYPE, *root_srid, 1, 0);
}
else
{
geom = (LWGEOM *)lwcollection_construct_empty(MULTIPOINTTYPE, -1, 1, 0);
}
poObjPoints = findMemberByName( geojson, "coordinates" );
if ( ! poObjPoints )
geojson_lwerror("Unable to find 'coordinates' in GeoJSON string", 4);
if( json_type_array == json_object_get_type( poObjPoints ) )
{
const int nPoints = json_object_array_length( poObjPoints );
for( i = 0; i < nPoints; ++i)
{
POINTARRAY *pa;
json_object* poObjCoords = NULL;
poObjCoords = json_object_array_get_idx( poObjPoints, i );
pa = ptarray_construct_empty(1, 0, 1);
parse_geojson_coord(poObjCoords, hasz, pa);
geom = (LWGEOM*)lwmpoint_add_lwpoint((LWMPOINT*)geom,
(LWPOINT*)lwpoint_construct(*root_srid, NULL, pa));
}
}
return geom;
}
/*
* Stick an array of points to the given gridspec.
* Return "gridded" points in *outpts and their number in *outptsn.
*
* Two consecutive points falling on the same grid cell are collapsed
* into one single point.
*
*/
POINTARRAY *
ptarray_grid(POINTARRAY *pa, gridspec *grid)
{
POINT4D pbuf;
int ipn, opn; /* point numbers (input/output) */
POINTARRAY *dpa;
POSTGIS_DEBUGF(2, "ptarray_grid called on %p", pa);
dpa = ptarray_construct_empty(FLAGS_GET_Z(pa->flags),FLAGS_GET_M(pa->flags), pa->npoints);
for (ipn=0, opn=0; ipn<pa->npoints; ++ipn)
{
getPoint4d_p(pa, ipn, &pbuf);
if ( grid->xsize )
pbuf.x = rint((pbuf.x - grid->ipx)/grid->xsize) *
grid->xsize + grid->ipx;
if ( grid->ysize )
pbuf.y = rint((pbuf.y - grid->ipy)/grid->ysize) *
grid->ysize + grid->ipy;
if ( FLAGS_GET_Z(pa->flags) && grid->zsize )
pbuf.z = rint((pbuf.z - grid->ipz)/grid->zsize) *
grid->zsize + grid->ipz;
if ( FLAGS_GET_M(pa->flags) && grid->msize )
pbuf.m = rint((pbuf.m - grid->ipm)/grid->msize) *
grid->msize + grid->ipm;
ptarray_append_point(dpa, &pbuf, LW_FALSE);
}
return dpa;
}
/*
* Stick an array of points to the given gridspec.
* Return "gridded" points in *outpts and their number in *outptsn.
*
* Two consecutive points falling on the same grid cell are collapsed
* into one single point.
*
*/
POINTARRAY *
ptarray_grid(const POINTARRAY *pa, const gridspec *grid)
{
POINT4D pt;
int ipn; /* input point numbers */
POINTARRAY *dpa;
LWDEBUGF(2, "ptarray_grid called on %p", pa);
dpa = ptarray_construct_empty(FLAGS_GET_Z(pa->flags),FLAGS_GET_M(pa->flags), pa->npoints);
for (ipn=0; ipn<pa->npoints; ++ipn)
{
getPoint4d_p(pa, ipn, &pt);
if ( grid->xsize )
pt.x = rint((pt.x - grid->ipx)/grid->xsize) *
grid->xsize + grid->ipx;
if ( grid->ysize )
pt.y = rint((pt.y - grid->ipy)/grid->ysize) *
grid->ysize + grid->ipy;
if ( FLAGS_GET_Z(pa->flags) && grid->zsize )
pt.z = rint((pt.z - grid->ipz)/grid->zsize) *
grid->zsize + grid->ipz;
if ( FLAGS_GET_M(pa->flags) && grid->msize )
pt.m = rint((pt.m - grid->ipm)/grid->msize) *
grid->msize + grid->ipm;
ptarray_append_point(dpa, &pt, LW_FALSE);
}
return dpa;
}
static LWGEOM*
parse_geojson_point(json_object *geojson, int *hasz, int root_srid)
{
LWGEOM *geom;
POINTARRAY *pa;
json_object* coords = NULL;
LWDEBUGF(3, "parse_geojson_point called with root_srid = %d.", root_srid );
coords = findMemberByName( geojson, "coordinates" );
if ( ! coords )
{
geojson_lwerror("Unable to find 'coordinates' in GeoJSON string", 4);
return NULL;
}
pa = ptarray_construct_empty(1, 0, 1);
parse_geojson_coord(coords, hasz, pa);
geom = (LWGEOM *) lwpoint_construct(root_srid, NULL, pa);
LWDEBUG(2, "parse_geojson_point finished.");
return geom;
}
/**
* @brief Generate an allocated geometry string for shapefile object obj using the state parameters
*/
int
GenerateLineStringGeometry(SHPLOADERSTATE *state, SHPObject *obj, char **geometry)
{
LWGEOM **lwmultilinestrings;
LWGEOM *lwgeom = NULL;
POINT4D point4d;
int dims = 0;
int u, v, start_vertex, end_vertex;
char *mem;
size_t mem_length;
FLAGS_SET_Z(dims, state->has_z);
FLAGS_SET_M(dims, state->has_m);
if (state->config->simple_geometries == 1 && obj->nParts > 1)
{
snprintf(state->message, SHPLOADERMSGLEN, _("We have a Multilinestring with %d parts, can't use -S switch!"), obj->nParts);
return SHPLOADERERR;
}
/* Allocate memory for our array of LWLINEs and our dynptarrays */
lwmultilinestrings = malloc(sizeof(LWPOINT *) * obj->nParts);
/* We need an array of pointers to each of our sub-geometries */
for (u = 0; u < obj->nParts; u++)
{
/* Create a ptarray containing the line points */
POINTARRAY *pa = ptarray_construct_empty(state->has_z, state->has_m, obj->nParts);
/* Set the start/end vertices depending upon whether this is
a MULTILINESTRING or not */
if ( u == obj->nParts-1 )
end_vertex = obj->nVertices;
else
end_vertex = obj->panPartStart[u + 1];
start_vertex = obj->panPartStart[u];
for (v = start_vertex; v < end_vertex; v++)
{
/* Generate the point */
point4d.x = obj->padfX[v];
point4d.y = obj->padfY[v];
if (state->has_z)
point4d.z = obj->padfZ[v];
if (state->has_m)
point4d.m = obj->padfM[v];
ptarray_append_point(pa, &point4d, LW_FALSE);
}
/* Generate the LWLINE */
lwmultilinestrings[u] = lwline_as_lwgeom(lwline_construct(state->from_srid, NULL, pa));
}
/* If using MULTILINESTRINGs then generate the serialized collection, otherwise just a single LINESTRING */
if (state->config->simple_geometries == 0)
{
lwgeom = lwcollection_as_lwgeom(lwcollection_construct(MULTILINETYPE, state->from_srid, NULL, obj->nParts, lwmultilinestrings));
}
else
{
lwgeom = lwmultilinestrings[0];
lwfree(lwmultilinestrings);
}
if (!state->config->use_wkt)
mem = lwgeom_to_hexwkb(lwgeom, WKB_EXTENDED, &mem_length);
else
mem = lwgeom_to_wkt(lwgeom, WKT_EXTENDED, WKT_PRECISION, &mem_length);
if ( !mem )
{
snprintf(state->message, SHPLOADERMSGLEN, "unable to write geometry");
return SHPLOADERERR;
}
/* Free all of the allocated items */
lwgeom_free(lwgeom);
/* Return the string - everything ok */
*geometry = mem;
return SHPLOADEROK;
}
/**
* 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;
}
/**
* Parse kml:coordinates
*/
static POINTARRAY* parse_kml_coordinates(xmlNodePtr xnode, bool *hasz)
{
xmlChar *kml_coord;
bool digit, found;
POINTARRAY *dpa;
int kml_dims;
char *p, *q;
POINT4D pt;
if (xnode == NULL) lwerror("invalid KML representation");
for (found = false ; xnode != NULL ; xnode = xnode->next)
{
if (xnode->type != XML_ELEMENT_NODE) continue;
if (!is_kml_namespace(xnode, false)) continue;
if (strcmp((char *) xnode->name, "coordinates")) continue;
found = true;
break;
}
if (!found) lwerror("invalid KML representation");
/* We begin to retrieve coordinates string */
kml_coord = xmlNodeGetContent(xnode);
p = (char *) kml_coord;
/* KML coordinates pattern: x1,y1 x2,y2
* x1,y1,z1 x2,y2,z2
*/
/* Now we create PointArray from coordinates values */
/* HasZ, !HasM, 1pt */
dpa = ptarray_construct_empty(1, 0, 1);
for (q = p, kml_dims=0, digit = false ; *p ; p++)
{
if (isdigit(*p)) digit = true; /* One state parser */
/* Coordinate Separator */
if (*p == ',')
{
*p = '\0';
kml_dims++;
if (*(p+1) == '\0') lwerror("invalid KML representation");
if (kml_dims == 1) pt.x = parse_kml_double(q, true, true);
else if (kml_dims == 2) pt.y = parse_kml_double(q, true, true);
q = p+1;
/* Tuple Separator (or end string) */
}
else if (digit && (isspace(*p) || *(p+1) == '\0'))
{
if (isspace(*p)) *p = '\0';
kml_dims++;
if (kml_dims < 2 || kml_dims > 3)
lwerror("invalid KML representation");
if (kml_dims == 3)
pt.z = parse_kml_double(q, true, true);
else
{
pt.y = parse_kml_double(q, true, true);
*hasz = false;
}
ptarray_append_point(dpa, &pt, LW_FALSE);
digit = false;
q = p+1;
kml_dims = 0;
}
}
xmlFree(kml_coord);
/* TODO: we shouldn't need to clone here */
return ptarray_clone_deep(dpa);
}
POINTARRAY *
ptarray_substring(POINTARRAY *ipa, double from, double to, double tolerance)
{
POINTARRAY *dpa;
POINT4D pt;
POINT4D p1, p2;
POINT4D *p1ptr=&p1; /* don't break strict-aliasing rule */
POINT4D *p2ptr=&p2;
int nsegs, i;
double length, slength, tlength;
int state = 0; /* 0=before, 1=inside */
/*
* Create a dynamic pointarray with an initial capacity
* equal to full copy of input points
*/
dpa = ptarray_construct_empty(FLAGS_GET_Z(ipa->flags), FLAGS_GET_M(ipa->flags), ipa->npoints);
/* Compute total line length */
length = ptarray_length_2d(ipa);
LWDEBUGF(3, "Total length: %g", length);
/* Get 'from' and 'to' lengths */
from = length*from;
to = length*to;
LWDEBUGF(3, "From/To: %g/%g", from, to);
tlength = 0;
getPoint4d_p(ipa, 0, &p1);
nsegs = ipa->npoints - 1;
for ( i = 0; i < nsegs; i++ )
{
double dseg;
getPoint4d_p(ipa, i+1, &p2);
LWDEBUGF(3 ,"Segment %d: (%g,%g,%g,%g)-(%g,%g,%g,%g)",
i, p1.x, p1.y, p1.z, p1.m, p2.x, p2.y, p2.z, p2.m);
/* Find the length of this segment */
slength = distance2d_pt_pt((POINT2D *)p1ptr, (POINT2D *)p2ptr);
/*
* We are before requested start.
*/
if ( state == 0 ) /* before */
{
LWDEBUG(3, " Before start");
if ( fabs ( from - ( tlength + slength ) ) <= tolerance )
{
LWDEBUG(3, " Second point is our start");
/*
* Second point is our start
*/
ptarray_append_point(dpa, &p2, LW_FALSE);
state=1; /* we're inside now */
goto END;
}
else if ( fabs(from - tlength) <= tolerance )
{
LWDEBUG(3, " First point is our start");
/*
* First point is our start
*/
ptarray_append_point(dpa, &p1, LW_FALSE);
/*
* We're inside now, but will check
* 'to' point as well
*/
state=1;
}
/*
* Didn't reach the 'from' point,
* nothing to do
*/
else if ( from > tlength + slength ) goto END;
else /* tlength < from < tlength+slength */
{
LWDEBUG(3, " Seg contains first point");
/*
* Our start is between first and
* second point
*/
dseg = (from - tlength) / slength;
interpolate_point4d(&p1, &p2, &pt, dseg);
ptarray_append_point(dpa, &pt, LW_FALSE);
/*
* We're inside now, but will check
* 'to' point as well
*/
state=1;
}
}
if ( state == 1 ) /* inside */
{
LWDEBUG(3, " Inside");
/*
* 'to' point is our second point.
*/
if ( fabs(to - ( tlength + slength ) ) <= tolerance )
{
LWDEBUG(3, " Second point is our end");
ptarray_append_point(dpa, &p2, LW_FALSE);
break; /* substring complete */
}
/*
* 'to' point is our first point.
* (should only happen if 'to' is 0)
*/
else if ( fabs(to - tlength) <= tolerance )
{
LWDEBUG(3, " First point is our end");
ptarray_append_point(dpa, &p1, LW_FALSE);
break; /* substring complete */
}
/*
* Didn't reach the 'end' point,
* just copy second point
*/
else if ( to > tlength + slength )
{
ptarray_append_point(dpa, &p2, LW_FALSE);
goto END;
}
/*
* 'to' point falls on this segment
* Interpolate and break.
*/
else if ( to < tlength + slength )
{
LWDEBUG(3, " Seg contains our end");
dseg = (to - tlength) / slength;
interpolate_point4d(&p1, &p2, &pt, dseg);
ptarray_append_point(dpa, &pt, LW_FALSE);
break;
}
else
{
LWDEBUG(3, "Unhandled case");
}
}
END:
tlength += slength;
memcpy(&p1, &p2, sizeof(POINT4D));
}
LWDEBUGF(3, "Out of loop, ptarray has %d points", dpa->npoints);
return dpa;
}
Datum BOX3D_to_LWGEOM(PG_FUNCTION_ARGS)
{
BOX3D *box = (BOX3D *)PG_GETARG_POINTER(0);
POINTARRAY *pa;
GSERIALIZED *result;
POINT4D pt;
/**
* Alter BOX3D cast so that a valid geometry is always
* returned depending upon the size of the BOX3D. The
* code makes the following assumptions:
* - If the BOX3D is a single point then return a
* POINT geometry
* - If the BOX3D represents either a horizontal or
* vertical line, return a LINESTRING geometry
* - Otherwise return a POLYGON
*/
pa = ptarray_construct_empty(0, 0, 5);
if ( (box->xmin == box->xmax) && (box->ymin == box->ymax) )
{
LWPOINT *lwpt = lwpoint_construct(SRID_UNKNOWN, NULL, pa);
pt.x = box->xmin;
pt.y = box->ymin;
ptarray_append_point(pa, &pt, LW_TRUE);
result = geometry_serialize(lwpoint_as_lwgeom(lwpt));
}
else if (box->xmin == box->xmax ||
box->ymin == box->ymax)
{
LWLINE *lwline = lwline_construct(SRID_UNKNOWN, NULL, pa);
pt.x = box->xmin;
pt.y = box->ymin;
ptarray_append_point(pa, &pt, LW_TRUE);
pt.x = box->xmax;
pt.y = box->ymax;
ptarray_append_point(pa, &pt, LW_TRUE);
result = geometry_serialize(lwline_as_lwgeom(lwline));
}
else
{
LWPOLY *lwpoly = lwpoly_construct(SRID_UNKNOWN, NULL, 1, &pa);
pt.x = box->xmin;
pt.y = box->ymin;
ptarray_append_point(pa, &pt, LW_TRUE);
pt.x = box->xmin;
pt.y = box->ymax;
ptarray_append_point(pa, &pt, LW_TRUE);
pt.x = box->xmax;
pt.y = box->ymax;
ptarray_append_point(pa, &pt, LW_TRUE);
pt.x = box->xmax;
pt.y = box->ymin;
ptarray_append_point(pa, &pt, LW_TRUE);
pt.x = box->xmin;
pt.y = box->ymin;
ptarray_append_point(pa, &pt, LW_TRUE);
result = geometry_serialize(lwpoly_as_lwgeom(lwpoly));
}
gserialized_set_srid(result, box->srid);
PG_RETURN_POINTER(result);
}
/**
* Segmentize an arc
*
* Does not add the final vertex
*
* @param to POINTARRAY to append segmentized vertices to
* @param p1 first point defining the arc
* @param p2 second point defining the arc
* @param p3 third point defining the arc
* @param tol tolerance, semantic driven by tolerance_type
* @param tolerance_type see LW_LINEARIZE_TOLERANCE_TYPE
* @param flags LW_LINEARIZE_FLAGS
*
* @return number of points appended (0 if collinear),
* or -1 on error (lwerror would be called).
*
*/
static int
lwarc_linearize(POINTARRAY *to,
const POINT4D *p1, const POINT4D *p2, const POINT4D *p3,
double tol, LW_LINEARIZE_TOLERANCE_TYPE tolerance_type,
int flags)
{
POINT2D center;
POINT2D *t1 = (POINT2D*)p1;
POINT2D *t2 = (POINT2D*)p2;
POINT2D *t3 = (POINT2D*)p3;
POINT4D pt;
int p2_side = 0;
int clockwise = LW_TRUE;
double radius; /* Arc radius */
double increment; /* Angle per segment */
double angle_shift = 0;
double a1, a2, a3, angle;
POINTARRAY *pa = to;
int is_circle = LW_FALSE;
int points_added = 0;
int reverse = 0;
LWDEBUG(2, "lwarc_linearize called.");
p2_side = lw_segment_side(t1, t3, t2);
/* Force counterclockwise scan if SYMMETRIC operation is requsested */
if ( p2_side == -1 && flags & LW_LINEARIZE_FLAG_SYMMETRIC )
{
/* swap p1-p3 */
t1 = (POINT2D*)p3;
t3 = (POINT2D*)p1;
p1 = (POINT4D*)t1;
p3 = (POINT4D*)t3;
p2_side = 1;
reverse = 1;
}
radius = lw_arc_center(t1, t2, t3, ¢er);
LWDEBUGF(2, " center is POINT(%.15g %.15g) - radius:%g", center.x, center.y, radius);
/* Matched start/end points imply circle */
if ( p1->x == p3->x && p1->y == p3->y )
is_circle = LW_TRUE;
/* Negative radius signals straight line, p1/p2/p3 are colinear */
if ( (radius < 0.0 || p2_side == 0) && ! is_circle )
return 0;
/* The side of the p1/p3 line that p2 falls on dictates the sweep
direction from p1 to p3. */
if ( p2_side == -1 )
clockwise = LW_TRUE;
else
clockwise = LW_FALSE;
if ( tolerance_type == LW_LINEARIZE_TOLERANCE_TYPE_SEGS_PER_QUAD )
{{
int perQuad = rint(tol);
// error out if tol != perQuad ? (not-round)
if ( perQuad != tol )
{
lwerror("lwarc_linearize: segments per quadrant must be an integer value, got %.15g", tol, perQuad);
return -1;
}
if ( perQuad < 1 )
{
lwerror("lwarc_linearize: segments per quadrant must be at least 1, got %d", perQuad);
return -1;
}
increment = fabs(M_PI_2 / perQuad);
LWDEBUGF(2, "lwarc_linearize: perQuad:%d, increment:%g (%g degrees)", perQuad, increment, increment*180/M_PI);
}}
else if ( tolerance_type == LW_LINEARIZE_TOLERANCE_TYPE_MAX_DEVIATION )
{{
double halfAngle;
if ( tol <= 0 )
{
lwerror("lwarc_linearize: max deviation must be bigger than 0, got %.15g", tol);
return -1;
}
halfAngle = acos( -tol / radius + 1 );
increment = 2 * halfAngle;
LWDEBUGF(2, "lwarc_linearize: maxDiff:%g, radius:%g, halfAngle:%g, increment:%g (%g degrees)", tol, radius, halfAngle, increment, increment*180/M_PI);
}}
else if ( tolerance_type == LW_LINEARIZE_TOLERANCE_TYPE_MAX_ANGLE )
{
increment = tol;
if ( increment <= 0 )
{
lwerror("lwarc_linearize: max angle must be bigger than 0, got %.15g", tol);
return -1;
}
}
else
{
lwerror("lwarc_linearize: unsupported tolerance type %d", tolerance_type);
return LW_FALSE;
}
/* Angles of each point that defines the arc section */
a1 = atan2(p1->y - center.y, p1->x - center.x);
a2 = atan2(p2->y - center.y, p2->x - center.x);
a3 = atan2(p3->y - center.y, p3->x - center.x);
LWDEBUGF(2, "lwarc_linearize A1:%g (%g) A2:%g (%g) A3:%g (%g)",
a1, a1*180/M_PI, a2, a2*180/M_PI, a3, a3*180/M_PI);
if ( flags & LW_LINEARIZE_FLAG_SYMMETRIC )
{{
/* Calculate total arc angle, in radians */
double angle = clockwise ? a1 - a3 : a3 - a1;
if ( angle < 0 ) angle += M_PI * 2;
LWDEBUGF(2, "lwarc_linearize SYMMETRIC requested - total angle %g deg",
angle * 180 / M_PI);
if ( flags & LW_LINEARIZE_FLAG_RETAIN_ANGLE )
{{
/* Number of steps */
int steps = trunc(angle / increment);
/* Angle reminder */
double angle_reminder = angle - ( increment * steps );
angle_shift = angle_reminder / 2.0;
LWDEBUGF(2, "lwarc_linearize RETAIN_ANGLE operation requested - "
"total angle %g, steps %d, increment %g, reminder %g",
angle * 180 / M_PI, steps, increment * 180 / M_PI,
angle_reminder * 180 / M_PI);
}}
else
{{
/* Number of segments in output */
int segs = ceil(angle / increment);
/* Tweak increment to be regular for all the arc */
increment = angle/segs;
LWDEBUGF(2, "lwarc_linearize SYMMETRIC operation requested - "
"total angle %g degrees - LINESTRING(%g %g,%g %g,%g %g) - S:%d - I:%g",
angle*180/M_PI, p1->x, p1->y, center.x, center.y, p3->x, p3->y,
segs, increment*180/M_PI);
}}
}}
/* p2 on left side => clockwise sweep */
if ( clockwise )
{
LWDEBUG(2, " Clockwise sweep");
increment *= -1;
angle_shift *= -1;
/* Adjust a3 down so we can decrement from a1 to a3 cleanly */
if ( a3 > a1 )
a3 -= 2.0 * M_PI;
if ( a2 > a1 )
a2 -= 2.0 * M_PI;
}
/* p2 on right side => counter-clockwise sweep */
else
{
LWDEBUG(2, " Counterclockwise sweep");
/* Adjust a3 up so we can increment from a1 to a3 cleanly */
if ( a3 < a1 )
a3 += 2.0 * M_PI;
if ( a2 < a1 )
a2 += 2.0 * M_PI;
}
/* Override angles for circle case */
if( is_circle )
{
a3 = a1 + 2.0 * M_PI;
a2 = a1 + M_PI;
increment = fabs(increment);
clockwise = LW_FALSE;
}
LWDEBUGF(2, "lwarc_linearize angle_shift:%g, increment:%g",
angle_shift * 180/M_PI, increment * 180/M_PI);
if ( reverse ) {{
const int capacity = 8; /* TODO: compute exactly ? */
pa = ptarray_construct_empty(ptarray_has_z(to), ptarray_has_m(to), capacity);
}}
/* Sweep from a1 to a3 */
if ( ! reverse )
{
ptarray_append_point(pa, p1, LW_FALSE);
}
++points_added;
if ( angle_shift ) angle_shift -= increment;
LWDEBUGF(2, "a1:%g (%g deg), a3:%g (%g deg), inc:%g, shi:%g, cw:%d",
a1, a1 * 180 / M_PI, a3, a3 * 180 / M_PI, increment, angle_shift, clockwise);
for ( angle = a1 + increment + angle_shift; clockwise ? angle > a3 : angle < a3; angle += increment )
{
LWDEBUGF(2, " SA: %g ( %g deg )", angle, angle*180/M_PI);
pt.x = center.x + radius * cos(angle);
pt.y = center.y + radius * sin(angle);
pt.z = interpolate_arc(angle, a1, a2, a3, p1->z, p2->z, p3->z);
pt.m = interpolate_arc(angle, a1, a2, a3, p1->m, p2->m, p3->m);
ptarray_append_point(pa, &pt, LW_FALSE);
++points_added;
angle_shift = 0;
}
if ( reverse ) {{
int i;
ptarray_append_point(to, p3, LW_FALSE);
for ( i=pa->npoints; i>0; i-- ) {
getPoint4d_p(pa, i-1, &pt);
ptarray_append_point(to, &pt, LW_FALSE);
}
ptarray_free(pa);
}}
return points_added;
}
static LWGEOM*
parse_geojson_multipolygon(json_object *geojson, bool *hasz, int *root_srid)
{
LWGEOM *geom = NULL;
int i, j, k;
json_object* poObjPolys = NULL;
if (!*root_srid)
{
geom = (LWGEOM *)lwcollection_construct_empty(MULTIPOLYGONTYPE, *root_srid, 1, 0);
}
else
{
geom = (LWGEOM *)lwcollection_construct_empty(MULTIPOLYGONTYPE, -1, 1, 0);
}
poObjPolys = findMemberByName( geojson, "coordinates" );
if ( ! poObjPolys )
geojson_lwerror("Unable to find 'coordinates' in GeoJSON string", 4);
if( json_type_array == json_object_get_type( poObjPolys ) )
{
const int nPolys = json_object_array_length( poObjPolys );
for(i = 0; i < nPolys; ++i)
{
POINTARRAY **ppa;
json_object* poObjPoly = NULL;
poObjPoly = json_object_array_get_idx( poObjPolys, i );
ppa = (POINTARRAY**) lwalloc(sizeof(POINTARRAY*));
if( json_type_array == json_object_get_type( poObjPoly ) )
{
int nPoints;
json_object* points = NULL;
int ring = json_object_array_length( poObjPoly );
ppa[0] = ptarray_construct_empty(1, 0, 1);
points = json_object_array_get_idx( poObjPoly, 0 );
nPoints = json_object_array_length( points );
for (j=0; j < nPoints; j++ )
{
json_object* coords = NULL;
coords = json_object_array_get_idx( points, j );
parse_geojson_coord(coords, hasz, ppa[0]);
}
for(j = 1; j < ring; ++j)
{
int nPoints;
ppa = (POINTARRAY**) lwrealloc((POINTARRAY *) ppa, sizeof(POINTARRAY*) * (j + 1));
ppa[i] = ptarray_construct_empty(1, 0, 1);
points = json_object_array_get_idx( poObjPoly, j );
nPoints = json_object_array_length( points );
for (k=0; k < nPoints; k++ )
{
json_object* coords = NULL;
coords = json_object_array_get_idx( points, k );
parse_geojson_coord(coords, hasz, ppa[i]);
}
}
geom = (LWGEOM*)lwmpoly_add_lwpoly((LWMPOLY*)geom,
(LWPOLY*)lwpoly_construct(*root_srid, NULL, ring, ppa));
}
}
}
return geom;
}
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;
}
static POINTARRAYSET
ptarray_locate_between_m(POINTARRAY *ipa, double m0, double m1)
{
POINTARRAYSET ret;
POINTARRAY *dpa=NULL;
int i;
ret.nptarrays=0;
/*
* We allocate space for as many pointarray as
* segments in the input POINTARRAY, as worst
* case is for each segment to cross the M range
* window.
* TODO: rework this to reduce used memory
*/
ret.ptarrays=lwalloc(sizeof(POINTARRAY *)*ipa->npoints-1);
POSTGIS_DEBUGF(2, "ptarray_locate...: called for pointarray %p, m0:%g, m1:%g",
ipa, m0, m1);
for (i=1; i<ipa->npoints; i++)
{
POINT4D p1, p2;
int clipval;
getPoint4d_p(ipa, i-1, &p1);
getPoint4d_p(ipa, i, &p2);
POSTGIS_DEBUGF(3, " segment %d-%d [ %g %g %g %g - %g %g %g %g ]",
i-1, i,
p1.x, p1.y, p1.z, p1.m,
p2.x, p2.y, p2.z, p2.m);
clipval = clip_seg_by_m_range(&p1, &p2, m0, m1);
/* segment completely outside, nothing to do */
if (! clipval ) continue;
POSTGIS_DEBUGF(3, " clipped to: [ %g %g %g %g - %g %g %g %g ] clipval: %d", p1.x, p1.y, p1.z, p1.m,
p2.x, p2.y, p2.z, p2.m, clipval);
/* If no points have been accumulated so far, then if clipval != 0 the first point must be the
start of the intersection */
if (dpa == NULL)
{
POSTGIS_DEBUGF(3, " 1 creating new POINTARRAY with first point %g,%g,%g,%g", p1.x, p1.y, p1.z, p1.m);
dpa = ptarray_construct_empty(FLAGS_GET_Z(ipa->flags), FLAGS_GET_M(ipa->flags), ipa->npoints-i);
ptarray_append_point(dpa, &p1, LW_TRUE);
}
/* Otherwise always add the next point, avoiding duplicates */
if (dpa)
ptarray_append_point(dpa, &p2, LW_FALSE);
/*
* second point has been clipped
*/
if ( clipval & 0x0100 || i == ipa->npoints-1 )
{
POSTGIS_DEBUGF(3, " closing pointarray %p with %d points", dpa, dpa->npoints);
ret.ptarrays[ret.nptarrays++] = dpa;
dpa = NULL;
}
}
/*
* if dpa!=NULL it means we didn't close it yet.
* this should never happen.
*/
if ( dpa != NULL ) lwpgerror("Something wrong with algorithm");
return ret;
}
/**
* @brief Generate an allocated geometry string for shapefile object obj using the state parameters
* if "force_multi" is true, single points will instead be created as multipoints with a single vertice.
*/
int
GeneratePointGeometry(SHPLOADERSTATE *state, SHPObject *obj, char **geometry, int force_multi)
{
LWGEOM **lwmultipoints;
LWGEOM *lwgeom = NULL;
POINT4D point4d;
int dims = 0;
int u;
char *mem;
size_t mem_length;
FLAGS_SET_Z(dims, state->has_z);
FLAGS_SET_M(dims, state->has_m);
/* Allocate memory for our array of LWPOINTs and our dynptarrays */
lwmultipoints = malloc(sizeof(LWPOINT *) * obj->nVertices);
/* We need an array of pointers to each of our sub-geometries */
for (u = 0; u < obj->nVertices; u++)
{
/* Create a ptarray containing a single point */
POINTARRAY *pa = ptarray_construct_empty(state->has_z, state->has_m, 1);
/* Generate the point */
point4d.x = obj->padfX[u];
point4d.y = obj->padfY[u];
if (state->has_z)
point4d.z = obj->padfZ[u];
if (state->has_m)
point4d.m = obj->padfM[u];
/* Add in the point! */
ptarray_append_point(pa, &point4d, LW_TRUE);
/* Generate the LWPOINT */
lwmultipoints[u] = lwpoint_as_lwgeom(lwpoint_construct(state->from_srid, NULL, pa));
}
/* If we have more than 1 vertex then we are working on a MULTIPOINT and so generate a MULTIPOINT
rather than a POINT */
if ((obj->nVertices > 1) || force_multi)
{
lwgeom = lwcollection_as_lwgeom(lwcollection_construct(MULTIPOINTTYPE, state->from_srid, NULL, obj->nVertices, lwmultipoints));
}
else
{
lwgeom = lwmultipoints[0];
lwfree(lwmultipoints);
}
if (state->config->use_wkt)
{
mem = lwgeom_to_wkt(lwgeom, WKT_EXTENDED, WKT_PRECISION, &mem_length);
}
else
{
mem = lwgeom_to_hexwkb(lwgeom, WKB_EXTENDED, &mem_length);
}
if ( !mem )
{
snprintf(state->message, SHPLOADERMSGLEN, "unable to write geometry");
return SHPLOADERERR;
}
/* Free all of the allocated items */
lwgeom_free(lwgeom);
/* Return the string - everything ok */
*geometry = mem;
return SHPLOADEROK;
}
static LWGEOM*
parse_geojson_multipolygon(json_object *geojson, int *hasz, int root_srid)
{
LWGEOM *geom = NULL;
int i, j, k;
json_object* poObjPolys = NULL;
if (!root_srid)
{
geom = (LWGEOM *)lwcollection_construct_empty(MULTIPOLYGONTYPE, root_srid, 1, 0);
}
else
{
geom = (LWGEOM *)lwcollection_construct_empty(MULTIPOLYGONTYPE, -1, 1, 0);
}
poObjPolys = findMemberByName( geojson, "coordinates" );
if ( ! poObjPolys )
{
geojson_lwerror("Unable to find 'coordinates' in GeoJSON string", 4);
return NULL;
}
if( json_type_array == json_object_get_type( poObjPolys ) )
{
const int nPolys = json_object_array_length( poObjPolys );
for(i = 0; i < nPolys; ++i)
{
json_object* poObjPoly = json_object_array_get_idx( poObjPolys, i );
if( json_type_array == json_object_get_type( poObjPoly ) )
{
LWPOLY *lwpoly = lwpoly_construct_empty(geom->srid, lwgeom_has_z(geom), lwgeom_has_m(geom));
int nRings = json_object_array_length( poObjPoly );
for(j = 0; j < nRings; ++j)
{
json_object* points = json_object_array_get_idx( poObjPoly, j );
if( json_type_array == json_object_get_type( points ) )
{
POINTARRAY *pa = ptarray_construct_empty(1, 0, 1);
int nPoints = json_object_array_length( points );
for ( k=0; k < nPoints; k++ )
{
json_object* coords = json_object_array_get_idx( points, k );
parse_geojson_coord(coords, hasz, pa);
}
lwpoly_add_ring(lwpoly, pa);
}
}
geom = (LWGEOM*)lwmpoly_add_lwpoly((LWMPOLY*)geom, lwpoly);
}
}
}
return geom;
}
static LWGEOM*
parse_geojson_polygon(json_object *geojson, int *hasz, int root_srid)
{
POINTARRAY **ppa = NULL;
json_object* rings = NULL;
json_object* points = NULL;
int i = 0, j = 0;
int nRings = 0, nPoints = 0;
rings = findMemberByName( geojson, "coordinates" );
if ( ! rings )
{
geojson_lwerror("Unable to find 'coordinates' in GeoJSON string", 4);
return NULL;
}
if ( json_type_array != json_object_get_type(rings) )
{
geojson_lwerror("The 'coordinates' in GeoJSON are not an array", 4);
return NULL;
}
nRings = json_object_array_length( rings );
/* No rings => POLYGON EMPTY */
if ( ! nRings )
{
return (LWGEOM *)lwpoly_construct_empty(root_srid, 0, 0);
}
for ( i = 0; i < nRings; i++ )
{
points = json_object_array_get_idx(rings, i);
if ( ! points || json_object_get_type(points) != json_type_array )
{
geojson_lwerror("The 'coordinates' in GeoJSON ring are not an array", 4);
return NULL;
}
nPoints = json_object_array_length(points);
/* Skip empty rings */
if ( nPoints == 0 ) continue;
if ( ! ppa )
ppa = (POINTARRAY**)lwalloc(sizeof(POINTARRAY*) * nRings);
ppa[i] = ptarray_construct_empty(1, 0, 1);
for ( j = 0; j < nPoints; j++ )
{
json_object* coords = NULL;
coords = json_object_array_get_idx( points, j );
parse_geojson_coord(coords, hasz, ppa[i]);
}
}
/* All the rings were empty! */
if ( ! ppa )
return (LWGEOM *)lwpoly_construct_empty(root_srid, 0, 0);
return (LWGEOM *) lwpoly_construct(root_srid, NULL, nRings, ppa);
}
static POINTARRAY *
lwcircle_segmentize(POINT4D *p1, POINT4D *p2, POINT4D *p3, uint32_t perQuad)
{
POINT4D center;
POINT4D pt;
int p2_side = 0;
int clockwise = LW_TRUE;
double radius; /* Arc radius */
double increment; /* Angle per segment */
double a1, a2, a3, angle;
POINTARRAY *pa;
int result;
int is_circle = LW_FALSE;
LWDEBUG(2, "lwcircle_calculate_gbox called.");
radius = lwcircle_center(p1, p2, p3, ¢er);
p2_side = signum(lw_segment_side((POINT2D*)p1, (POINT2D*)p3, (POINT2D*)p2));
/* Matched start/end points imply circle */
if ( p1->x == p3->x && p1->y == p3->y )
is_circle = LW_TRUE;
/* Negative radius signals straight line, p1/p2/p3 are colinear */
if ( radius < 0.0 || p2_side == 0 )
return NULL;
/* The side of the p1/p3 line that p2 falls on dictates the sweep
direction from p1 to p3. */
if ( p2_side == -1 )
clockwise = LW_TRUE;
else
clockwise = LW_FALSE;
increment = fabs(M_PI_2 / perQuad);
/* Angles of each point that defines the arc section */
a1 = atan2(p1->y - center.y, p1->x - center.x);
a2 = atan2(p2->y - center.y, p2->x - center.x);
a3 = atan2(p3->y - center.y, p3->x - center.x);
/* p2 on left side => clockwise sweep */
if ( clockwise )
{
increment *= -1;
/* Adjust a3 down so we can decrement from a1 to a3 cleanly */
if ( a3 > a1 )
a3 -= 2.0 * M_PI;
if ( a2 > a1 )
a2 -= 2.0 * M_PI;
}
/* p2 on right side => counter-clockwise sweep */
else
{
/* Adjust a3 up so we can increment from a1 to a3 cleanly */
if ( a3 < a1 )
a3 += 2.0 * M_PI;
if ( a2 < a1 )
a2 += 2.0 * M_PI;
}
/* Override angles for circle case */
if( is_circle )
{
a3 = a1 + 2.0 * M_PI;
a2 = a1 + M_PI;
increment = fabs(increment);
clockwise = LW_FALSE;
}
/* Initialize point array */
pa = ptarray_construct_empty(1, 1, 32);
/* Sweep from a1 to a3 */
for ( angle = a1; clockwise ? angle > a3 : angle < a3; angle += increment )
{
pt.x = center.x + radius * cos(angle);
pt.y = center.y + radius * sin(angle);
pt.z = interpolate_arc(angle, a1, a2, a3, p1->z, p2->z, p3->z);
pt.m = interpolate_arc(angle, a1, a2, a3, p1->m, p2->m, p3->m);
result = ptarray_append_point(pa, &pt, LW_FALSE);
}
return pa;
}
/**
* @brief Generate an allocated geometry string for shapefile object obj using the state parameters
*
* This function basically deals with the polygon case. It sorts the polys in order of outer,
* inner,inner, so that inners always come after outers they are within.
*
*/
int
GeneratePolygonGeometry(SHPLOADERSTATE *state, SHPObject *obj, char **geometry)
{
Ring **Outer;
int polygon_total, ring_total;
int pi, vi; /* part index and vertex index */
LWGEOM **lwpolygons;
LWGEOM *lwgeom;
POINT4D point4d;
int dims = 0;
char *mem;
size_t mem_length;
FLAGS_SET_Z(dims, state->has_z);
FLAGS_SET_M(dims, state->has_m);
polygon_total = FindPolygons(obj, &Outer);
if (state->config->simple_geometries == 1 && polygon_total != 1) /* We write Non-MULTI geometries, but have several parts: */
{
snprintf(state->message, SHPLOADERMSGLEN, _("We have a Multipolygon with %d parts, can't use -S switch!"), polygon_total);
return SHPLOADERERR;
}
/* Allocate memory for our array of LWPOLYs */
lwpolygons = malloc(sizeof(LWPOLY *) * polygon_total);
/* Cycle through each individual polygon */
for (pi = 0; pi < polygon_total; pi++)
{
LWPOLY *lwpoly = lwpoly_construct_empty(state->from_srid, state->has_z, state->has_m);
Ring *polyring;
int ring_index = 0;
/* Firstly count through the total number of rings in this polygon */
ring_total = 0;
polyring = Outer[pi];
while (polyring)
{
ring_total++;
polyring = polyring->next;
}
/* Cycle through each ring within the polygon, starting with the outer */
polyring = Outer[pi];
while (polyring)
{
/* Create a POINTARRAY containing the points making up the ring */
POINTARRAY *pa = ptarray_construct_empty(state->has_z, state->has_m, polyring->n);
for (vi = 0; vi < polyring->n; vi++)
{
/* Build up a point array of all the points in this ring */
point4d.x = polyring->list[vi].x;
point4d.y = polyring->list[vi].y;
if (state->has_z)
point4d.z = polyring->list[vi].z;
if (state->has_m)
point4d.m = polyring->list[vi].m;
ptarray_append_point(pa, &point4d, LW_TRUE);
}
/* Copy the POINTARRAY pointer so we can use the LWPOLY constructor */
lwpoly_add_ring(lwpoly, pa);
polyring = polyring->next;
ring_index++;
}
/* Generate the LWGEOM */
lwpolygons[pi] = lwpoly_as_lwgeom(lwpoly);
}
/* If using MULTIPOLYGONS then generate the serialized collection, otherwise just a single POLYGON */
if (state->config->simple_geometries == 0)
{
lwgeom = lwcollection_as_lwgeom(lwcollection_construct(MULTIPOLYGONTYPE, state->from_srid, NULL, polygon_total, lwpolygons));
}
else
{
lwgeom = lwpolygons[0];
lwfree(lwpolygons);
}
if (!state->config->use_wkt)
mem = lwgeom_to_hexwkb(lwgeom, WKB_EXTENDED, &mem_length);
else
mem = lwgeom_to_wkt(lwgeom, WKT_EXTENDED, WKT_PRECISION, &mem_length);
if ( !mem )
{
snprintf(state->message, SHPLOADERMSGLEN, "unable to write geometry");
return SHPLOADERERR;
}
/* Free all of the allocated items */
lwgeom_free(lwgeom);
/* Free the linked list of rings */
ReleasePolygons(Outer, polygon_total);
/* Return the string - everything ok */
*geometry = mem;
return SHPLOADEROK;
}
Datum BOX2D_to_LWGEOM(PG_FUNCTION_ARGS)
{
GBOX *box = (GBOX *)PG_GETARG_POINTER(0);
POINTARRAY *pa = ptarray_construct_empty(0, 0, 5);
POINT4D pt;
GSERIALIZED *result;
/*
* Alter BOX2D cast so that a valid geometry is always
* returned depending upon the size of the BOX2D. The
* code makes the following assumptions:
* - If the BOX2D is a single point then return a
* POINT geometry
* - If the BOX2D represents either a horizontal or
* vertical line, return a LINESTRING geometry
* - Otherwise return a POLYGON
*/
if ( (box->xmin == box->xmax) && (box->ymin == box->ymax) )
{
/* Construct and serialize point */
LWPOINT *point = lwpoint_make2d(SRID_UNKNOWN, box->xmin, box->ymin);
result = geometry_serialize(lwpoint_as_lwgeom(point));
lwpoint_free(point);
}
else if ( (box->xmin == box->xmax) || (box->ymin == box->ymax) )
{
LWLINE *line;
/* Assign coordinates to point array */
pt.x = box->xmin;
pt.y = box->ymin;
ptarray_append_point(pa, &pt, LW_TRUE);
pt.x = box->xmax;
pt.y = box->ymax;
ptarray_append_point(pa, &pt, LW_TRUE);
/* Construct and serialize linestring */
line = lwline_construct(SRID_UNKNOWN, NULL, pa);
result = geometry_serialize(lwline_as_lwgeom(line));
lwline_free(line);
}
else
{
LWPOLY *poly;
POINTARRAY **ppa = lwalloc(sizeof(POINTARRAY*));
/* Assign coordinates to point array */
pt.x = box->xmin;
pt.y = box->ymin;
ptarray_append_point(pa, &pt, LW_TRUE);
pt.x = box->xmin;
pt.y = box->ymax;
ptarray_append_point(pa, &pt, LW_TRUE);
pt.x = box->xmax;
pt.y = box->ymax;
ptarray_append_point(pa, &pt, LW_TRUE);
pt.x = box->xmax;
pt.y = box->ymin;
ptarray_append_point(pa, &pt, LW_TRUE);
pt.x = box->xmin;
pt.y = box->ymin;
ptarray_append_point(pa, &pt, LW_TRUE);
/* Construct polygon */
ppa[0] = pa;
poly = lwpoly_construct(SRID_UNKNOWN, NULL, 1, ppa);
result = geometry_serialize(lwpoly_as_lwgeom(poly));
lwpoly_free(poly);
}
PG_RETURN_POINTER(result);
}
/**
* @brief Returns a modified #POINTARRAY so that no segment is
* longer than the given distance (computed using 2d).
*
* Every input point is kept.
* Z and M values for added points (if needed) are set to 0.
*/
POINTARRAY *
ptarray_segmentize2d(const POINTARRAY *ipa, double dist)
{
double segdist;
POINT4D p1, p2;
POINT4D pbuf;
POINTARRAY *opa;
int ipoff=0; /* input point offset */
int hasz = FLAGS_GET_Z(ipa->flags);
int hasm = FLAGS_GET_M(ipa->flags);
pbuf.x = pbuf.y = pbuf.z = pbuf.m = 0;
/* Initial storage */
opa = ptarray_construct_empty(hasz, hasm, ipa->npoints);
/* Add first point */
getPoint4d_p(ipa, ipoff, &p1);
ptarray_append_point(opa, &p1, LW_FALSE);
ipoff++;
while (ipoff<ipa->npoints)
{
/*
* We use these pointers to avoid
* "strict-aliasing rules break" warning raised
* by gcc (3.3 and up).
*
* It looks that casting a variable address (also
* referred to as "type-punned pointer")
* breaks those "strict" rules.
*
*/
POINT4D *p1ptr=&p1, *p2ptr=&p2;
getPoint4d_p(ipa, ipoff, &p2);
segdist = distance2d_pt_pt((POINT2D *)p1ptr, (POINT2D *)p2ptr);
if (segdist > dist) /* add an intermediate point */
{
pbuf.x = p1.x + (p2.x-p1.x)/segdist * dist;
pbuf.y = p1.y + (p2.y-p1.y)/segdist * dist;
if( hasz )
pbuf.z = p1.z + (p2.z-p1.z)/segdist * dist;
if( hasm )
pbuf.m = p1.m + (p2.m-p1.m)/segdist * dist;
ptarray_append_point(opa, &pbuf, LW_FALSE);
p1 = pbuf;
}
else /* copy second point */
{
ptarray_append_point(opa, &p2, (ipa->npoints==2)?LW_TRUE:LW_FALSE);
p1 = p2;
ipoff++;
}
}
return opa;
}
int
lwline_split_by_point_to(const LWLINE* lwline_in, const LWPOINT* blade_in,
LWMLINE* v)
{
double mindist = -1;
POINT4D pt, pt_projected;
POINT4D p1, p2;
POINTARRAY *ipa = lwline_in->points;
POINTARRAY* pa1;
POINTARRAY* pa2;
int i, nsegs, seg = -1;
/* Possible outcomes:
*
* 1. The point is not on the line or on the boundary
* -> Leave collection untouched, return 0
* 2. The point is on the boundary
* -> Leave collection untouched, return 1
* 3. The point is in the line
* -> Push 2 elements on the collection:
* o start_point - cut_point
* o cut_point - last_point
* -> Return 2
*/
getPoint4d_p(blade_in->point, 0, &pt);
/* Find closest segment */
getPoint4d_p(ipa, 0, &p1);
nsegs = ipa->npoints - 1;
for ( i = 0; i < nsegs; i++ )
{
getPoint4d_p(ipa, i+1, &p2);
double dist;
dist = distance2d_pt_seg((POINT2D*)&pt, (POINT2D*)&p1, (POINT2D*)&p2);
LWDEBUGF(4, " Distance of point %g %g to segment %g %g, %g %g: %g", pt.x, pt.y, p1.x, p1.y, p2.x, p2.y, dist);
if (i==0 || dist < mindist )
{
mindist = dist;
seg=i;
if ( mindist == 0.0 ) break; /* can't be closer than ON line */
}
p1 = p2;
}
LWDEBUGF(3, "Closest segment: %d", seg);
LWDEBUGF(3, "mindist: %g", mindist);
/* No intersection */
if ( mindist > 0 ) return 0;
/* empty or single-point line, intersection on boundary */
if ( seg < 0 ) return 1;
/*
* We need to project the
* point on the closest segment,
* to interpolate Z and M if needed
*/
getPoint4d_p(ipa, seg, &p1);
getPoint4d_p(ipa, seg+1, &p2);
closest_point_on_segment(&pt, &p1, &p2, &pt_projected);
/* But X and Y we want the ones of the input point,
* as on some architectures the interpolation math moves the
* coordinates (see #3422)
*/
pt_projected.x = pt.x;
pt_projected.y = pt.y;
LWDEBUGF(3, "Projected point:(%g %g), seg:%d, p1:(%g %g), p2:(%g %g)", pt_projected.x, pt_projected.y, seg, p1.x, p1.y, p2.x, p2.y);
/* When closest point == an endpoint, this is a boundary intersection */
if ( ( (seg == nsegs-1) && p4d_same(&pt_projected, &p2) ) ||
( (seg == 0) && p4d_same(&pt_projected, &p1) ) )
{
return 1;
}
/* This is an internal intersection, let's build the two new pointarrays */
pa1 = ptarray_construct_empty(FLAGS_GET_Z(ipa->flags), FLAGS_GET_M(ipa->flags), seg+2);
/* TODO: replace with a memcpy ? */
for (i=0; i<=seg; ++i)
{
getPoint4d_p(ipa, i, &p1);
ptarray_append_point(pa1, &p1, LW_FALSE);
}
ptarray_append_point(pa1, &pt_projected, LW_FALSE);
pa2 = ptarray_construct_empty(FLAGS_GET_Z(ipa->flags), FLAGS_GET_M(ipa->flags), ipa->npoints-seg);
ptarray_append_point(pa2, &pt_projected, LW_FALSE);
/* TODO: replace with a memcpy (if so need to check for duplicated point) ? */
for (i=seg+1; i<ipa->npoints; ++i)
{
getPoint4d_p(ipa, i, &p1);
ptarray_append_point(pa2, &p1, LW_FALSE);
}
/* NOTE: I've seen empty pointarrays with loc != 0 and loc != 1 */
if ( pa1->npoints == 0 || pa2->npoints == 0 ) {
ptarray_free(pa1);
ptarray_free(pa2);
/* Intersection is on the boundary */
return 1;
}
lwmline_add_lwline(v, lwline_construct(SRID_UNKNOWN, NULL, pa1));
lwmline_add_lwline(v, lwline_construct(SRID_UNKNOWN, NULL, pa2));
return 2;
}
/*
* Return a LWGEOM pointer from an TGEOM struct
* Geometries are NOT copied
*/
LWGEOM*
lwgeom_from_tgeom(TGEOM *tgeom)
{
int i, j, k;
LWGEOM *geom;
POINTARRAY *dpa;
POINTARRAY **ppa;
int hasz, hasm, edge_id;
int dims=0;
assert(tgeom);
hasz=FLAGS_GET_Z(tgeom->flags);
hasm=FLAGS_GET_M(tgeom->flags);
geom = (LWGEOM *)lwcollection_construct_empty(COLLECTIONTYPE, tgeom->srid, hasz, hasm);
switch (tgeom->type)
{
case TINTYPE:
geom->type = TINTYPE;
for (i=0 ; i < tgeom->nfaces ; i++)
{
FLAGS_SET_Z(dims, hasz?1:0);
FLAGS_SET_M(dims, hasm?1:0);
dpa = ptarray_construct_empty(hasz, hasm, 4);
for (j=0 ; j < tgeom->faces[i]->nedges ; j++)
{
edge_id = tgeom->faces[i]->edges[j];
LWDEBUGF(3, "TIN edge_id: %i\n", edge_id);
assert(edge_id);
if (edge_id > 0)
ptarray_append_point(dpa, tgeom->edges[edge_id]->s, LW_TRUE);
else
ptarray_append_point(dpa, tgeom->edges[-edge_id]->e, LW_TRUE);
}
edge_id = tgeom->faces[i]->edges[0];
LWDEBUGF(3, "TIN edge_id: %i\n", edge_id);
if (edge_id > 0)
ptarray_append_point(dpa, tgeom->edges[edge_id]->s, LW_TRUE);
else
ptarray_append_point(dpa, tgeom->edges[-edge_id]->e, LW_TRUE);
geom = (LWGEOM *) lwtin_add_lwtriangle((LWTIN *) geom,
lwtriangle_construct(tgeom->srid, NULL, dpa));
}
break;
case POLYHEDRALSURFACETYPE:
geom->type = POLYHEDRALSURFACETYPE;
for (i=0 ; i < tgeom->nfaces ; i++)
{
FLAGS_SET_Z(dims, hasz?1:0);
FLAGS_SET_M(dims, hasm?1:0);;
dpa = ptarray_construct_empty(hasz, hasm, 4);
for (j=0 ; j < tgeom->faces[i]->nedges ; j++)
{
edge_id = tgeom->faces[i]->edges[j];
assert(edge_id);
LWDEBUGF(3, "POLYHEDRALSURFACE edge_id: %i\n", edge_id);
if (edge_id > 0)
ptarray_append_point(dpa, tgeom->edges[edge_id]->s, LW_TRUE);
else
ptarray_append_point(dpa, tgeom->edges[-edge_id]->e, LW_TRUE);
}
edge_id = tgeom->faces[i]->edges[0];
LWDEBUGF(3, "POLYHEDRALSURFACE edge_id: %i\n", edge_id);
if (edge_id > 0)
ptarray_append_point(dpa, tgeom->edges[edge_id]->s, LW_TRUE);
else
ptarray_append_point(dpa, tgeom->edges[-edge_id]->e, LW_TRUE);
ppa = lwalloc(sizeof(POINTARRAY*)
* (tgeom->faces[i]->nrings + 1));
ppa[0] = dpa;
for (k=0; k < tgeom->faces[i]->nrings ; k++)
ppa[k+1] = tgeom->faces[i]->rings[k];
geom = (LWGEOM *) lwpsurface_add_lwpoly((LWPSURFACE *) geom,
lwpoly_construct(tgeom->srid, NULL, k + 1, ppa));
}
break;
default:
lwerror("lwgeom_from_tgeom: Unkwnown type %i - %s\n",
tgeom->type, lwtype_name(tgeom->type));
}
if (geom->srid == 0) geom->srid = SRID_UNKNOWN;
return geom;
}
