/*
* Construct a polygon from a LWLINE being
* the shell and an array of LWLINE (possibly NULL) being holes.
* Pointarrays from intput geoms are cloned.
* SRID must be the same for each input line.
* Input lines must have at least 4 points, and be closed.
*/
LWPOLY *
lwpoly_from_lwlines(const LWLINE *shell,
uint32_t nholes, const LWLINE **holes)
{
uint32_t nrings;
POINTARRAY **rings = lwalloc((nholes+1)*sizeof(POINTARRAY *));
int srid = shell->srid;
LWPOLY *ret;
if ( shell->points->npoints < 4 )
lwerror("lwpoly_from_lwlines: shell must have at least 4 points");
if ( ! ptarray_is_closed_2d(shell->points) )
lwerror("lwpoly_from_lwlines: shell must be closed");
rings[0] = ptarray_clone_deep(shell->points);
for (nrings=1; nrings<=nholes; nrings++)
{
const LWLINE *hole = holes[nrings-1];
if ( hole->srid != srid )
lwerror("lwpoly_from_lwlines: mixed SRIDs in input lines");
if ( hole->points->npoints < 4 )
lwerror("lwpoly_from_lwlines: holes must have at least 4 points");
if ( ! ptarray_is_closed_2d(hole->points) )
lwerror("lwpoly_from_lwlines: holes must be closed");
rings[nrings] = ptarray_clone_deep(hole->points);
}
ret = lwpoly_construct(srid, NULL, nrings, rings);
return ret;
}
LWMPOLY *
lwmsurface_segmentize(LWMSURFACE *msurface, uint32_t perQuad)
{
LWMPOLY *ogeom;
LWGEOM *tmp;
LWPOLY *poly;
LWGEOM **polys;
POINTARRAY **ptarray;
int i, j;
LWDEBUG(2, "lwmsurface_segmentize called.");
polys = lwalloc(sizeof(LWGEOM *)*msurface->ngeoms);
for (i = 0; i < msurface->ngeoms; i++)
{
tmp = msurface->geoms[i];
if (tmp->type == CURVEPOLYTYPE)
{
polys[i] = (LWGEOM *)lwcurvepoly_segmentize((LWCURVEPOLY *)tmp, perQuad);
}
else if (tmp->type == POLYGONTYPE)
{
poly = (LWPOLY *)tmp;
ptarray = lwalloc(sizeof(POINTARRAY *)*poly->nrings);
for (j = 0; j < poly->nrings; j++)
{
ptarray[j] = ptarray_clone_deep(poly->rings[j]);
}
polys[i] = (LWGEOM *)lwpoly_construct(msurface->srid, NULL, poly->nrings, ptarray);
}
}
ogeom = (LWMPOLY *)lwcollection_construct(MULTIPOLYGONTYPE, msurface->srid, NULL, msurface->ngeoms, polys);
return ogeom;
}
static LWGEOM*
parse_geojson_polygon(json_object *geojson, bool *hasz, int *root_srid)
{
LWGEOM *geom;
POINTARRAY **ppa;
json_object* rings = NULL;
int i = 0, j = 0;
int ring = 0;
rings = findMemberByName( geojson, "coordinates" );
if ( ! rings )
geojson_lwerror("Unable to find 'coordinates' in GeoJSON string", 4);
ppa = (POINTARRAY**) lwalloc(sizeof(POINTARRAY*));
if( json_type_array == json_object_get_type( rings ) )
{
int nPoints;
json_object* points = NULL;
ppa[0] = ptarray_construct_empty(1, 0, 1);
ring = json_object_array_length( rings );
points = json_object_array_get_idx( rings, 0 );
nPoints = json_object_array_length( points );
for (i=0; i < nPoints; i++ )
{
json_object* coords = NULL;
coords = json_object_array_get_idx( points, i );
parse_geojson_coord(coords, hasz, ppa[0]);
}
for(i = 1; i < ring; ++i)
{
int nPoints;
ppa = (POINTARRAY**) lwrealloc((POINTARRAY *) ppa, sizeof(POINTARRAY*) * (i + 1));
ppa[i] = ptarray_construct_empty(1, 0, 1);
points = json_object_array_get_idx( rings, i );
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[i]);
}
}
}
geom = (LWGEOM *) lwpoly_construct(*root_srid, NULL, ring, ppa);
return geom;
}
LWPOLY *
lwpoly_segmentize2d(LWPOLY *poly, double dist)
{
POINTARRAY **newrings;
uint32_t i;
newrings = lwalloc(sizeof(POINTARRAY *)*poly->nrings);
for (i=0; i<poly->nrings; i++)
{
newrings[i] = ptarray_segmentize2d(poly->rings[i], dist);
}
return lwpoly_construct(poly->srid, NULL,
poly->nrings, newrings);
}
LWGEOM*
lwpoly_remove_repeated_points(LWPOLY *poly)
{
uint32_t i;
POINTARRAY **newrings;
newrings = lwalloc(sizeof(POINTARRAY *)*poly->nrings);
for (i=0; i<poly->nrings; i++)
{
newrings[i] = ptarray_remove_repeated_points(poly->rings[i]);
}
return (LWGEOM*)lwpoly_construct(poly->srid,
poly->bbox ? gbox_copy(poly->bbox) : NULL,
poly->nrings, newrings);
}
/*
* @param icompound input curve polygon
* @param tol tolerance, semantic driven by tolerance_type
* @param tolerance_type see LW_LINEARIZE_TOLERANCE_TYPE
* @param flags see flags in lwarc_linearize
*
* @return a newly allocated LWPOLY
*/
static LWPOLY *
lwcurvepoly_linearize(const LWCURVEPOLY *curvepoly, double tol,
LW_LINEARIZE_TOLERANCE_TYPE tolerance_type,
int flags)
{
LWPOLY *ogeom;
LWGEOM *tmp;
LWLINE *line;
POINTARRAY **ptarray;
int i;
LWDEBUG(2, "lwcurvepoly_linearize called.");
ptarray = lwalloc(sizeof(POINTARRAY *)*curvepoly->nrings);
for (i = 0; i < curvepoly->nrings; i++)
{
tmp = curvepoly->rings[i];
if (tmp->type == CIRCSTRINGTYPE)
{
line = lwcircstring_linearize((LWCIRCSTRING *)tmp, tol, tolerance_type, flags);
ptarray[i] = ptarray_clone_deep(line->points);
lwline_free(line);
}
else if (tmp->type == LINETYPE)
{
line = (LWLINE *)tmp;
ptarray[i] = ptarray_clone_deep(line->points);
}
else if (tmp->type == COMPOUNDTYPE)
{
line = lwcompound_linearize((LWCOMPOUND *)tmp, tol, tolerance_type, flags);
ptarray[i] = ptarray_clone_deep(line->points);
lwline_free(line);
}
else
{
lwerror("Invalid ring type found in CurvePoly.");
return NULL;
}
}
ogeom = lwpoly_construct(curvepoly->srid, NULL, curvepoly->nrings, ptarray);
return ogeom;
}
LWPOLY *
lwcurvepoly_segmentize(const LWCURVEPOLY *curvepoly, uint32_t perQuad)
{
LWPOLY *ogeom;
LWGEOM *tmp;
LWLINE *line;
POINTARRAY **ptarray;
int i;
LWDEBUG(2, "lwcurvepoly_segmentize called.");
ptarray = lwalloc(sizeof(POINTARRAY *)*curvepoly->nrings);
for (i = 0; i < curvepoly->nrings; i++)
{
tmp = curvepoly->rings[i];
if (tmp->type == CIRCSTRINGTYPE)
{
line = lwcircstring_segmentize((LWCIRCSTRING *)tmp, perQuad);
ptarray[i] = ptarray_clone_deep(line->points);
lwfree(line);
}
else if (tmp->type == LINETYPE)
{
line = (LWLINE *)tmp;
ptarray[i] = ptarray_clone_deep(line->points);
}
else if (tmp->type == COMPOUNDTYPE)
{
line = lwcompound_segmentize((LWCOMPOUND *)tmp, perQuad);
ptarray[i] = ptarray_clone_deep(line->points);
lwfree(line);
}
else
{
lwerror("Invalid ring type found in CurvePoly.");
return NULL;
}
}
ogeom = lwpoly_construct(curvepoly->srid, NULL, curvepoly->nrings, ptarray);
return ogeom;
}
/**
* @param msurface input multi surface
* @param tol tolerance, semantic driven by tolerance_type
* @param tolerance_type see LW_LINEARIZE_TOLERANCE_TYPE
* @param flags see flags in lwarc_linearize
*
* @return a newly allocated LWMPOLY
*/
static LWMPOLY *
lwmsurface_linearize(const LWMSURFACE *msurface, double tol,
LW_LINEARIZE_TOLERANCE_TYPE type,
int flags)
{
LWMPOLY *ogeom;
LWGEOM *tmp;
LWPOLY *poly;
LWGEOM **polys;
POINTARRAY **ptarray;
int i, j;
LWDEBUG(2, "lwmsurface_linearize called.");
polys = lwalloc(sizeof(LWGEOM *)*msurface->ngeoms);
for (i = 0; i < msurface->ngeoms; i++)
{
tmp = msurface->geoms[i];
if (tmp->type == CURVEPOLYTYPE)
{
polys[i] = (LWGEOM *)lwcurvepoly_linearize((LWCURVEPOLY *)tmp, tol, type, flags);
}
else if (tmp->type == POLYGONTYPE)
{
poly = (LWPOLY *)tmp;
ptarray = lwalloc(sizeof(POINTARRAY *)*poly->nrings);
for (j = 0; j < poly->nrings; j++)
{
ptarray[j] = ptarray_clone_deep(poly->rings[j]);
}
polys[i] = (LWGEOM *)lwpoly_construct(msurface->srid, NULL, poly->nrings, ptarray);
}
}
ogeom = (LWMPOLY *)lwcollection_construct(MULTIPOLYGONTYPE, msurface->srid, NULL, msurface->ngeoms, polys);
return ogeom;
}
LWPOLY*
lwpoly_force_dims(const LWPOLY *poly, int hasz, int hasm)
{
LWPOLY *polyout;
/* Return 2D empty */
if( lwpoly_is_empty(poly) )
{
polyout = lwpoly_construct_empty(poly->srid, hasz, hasm);
}
else
{
POINTARRAY **rings = NULL;
int i;
rings = lwalloc(sizeof(POINTARRAY*) * poly->nrings);
for( i = 0; i < poly->nrings; i++ )
{
rings[i] = ptarray_force_dims(poly->rings[i], hasz, hasm);
}
polyout = lwpoly_construct(poly->srid, NULL, poly->nrings, rings);
}
polyout->type = poly->type;
return polyout;
}
Datum BOX2DFLOAT4_to_LWGEOM(PG_FUNCTION_ARGS)
{
BOX2DFLOAT4 *box = (BOX2DFLOAT4 *)PG_GETARG_POINTER(0);
POINTARRAY *pa;
int wantbbox = 0;
PG_LWGEOM *result;
uchar *ser;
/*
* 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 = make_lwpoint2d(-1, box->xmin, box->ymin);
ser = lwpoint_serialize(point);
}
else if (box->xmin == box->xmax ||
box->ymin == box->ymax)
{
LWLINE *line;
POINT2D *pts = palloc(sizeof(POINT2D)*2);
/* Assign coordinates to POINT2D array */
pts[0].x = box->xmin;
pts[0].y = box->ymin;
pts[1].x = box->xmax;
pts[1].y = box->ymax;
/* Construct point array */
pa = pointArray_construct((uchar *)pts, 0, 0, 2);
/* Construct and serialize linestring */
line = lwline_construct(-1, NULL, pa);
ser = lwline_serialize(line);
}
else
{
LWPOLY *poly;
POINT2D *pts = palloc(sizeof(POINT2D)*5);
/* Assign coordinates to POINT2D array */
pts[0].x = box->xmin;
pts[0].y = box->ymin;
pts[1].x = box->xmin;
pts[1].y = box->ymax;
pts[2].x = box->xmax;
pts[2].y = box->ymax;
pts[3].x = box->xmax;
pts[3].y = box->ymin;
pts[4].x = box->xmin;
pts[4].y = box->ymin;
/* Construct point array */
pa = pointArray_construct((uchar *)pts, 0, 0, 5);
/* Construct polygon */
poly = lwpoly_construct(-1, NULL, 1, &pa);
/* Serialize polygon */
ser = lwpoly_serialize(poly);
}
/* Construct PG_LWGEOM */
result = PG_LWGEOM_construct(ser, -1, wantbbox);
PG_RETURN_POINTER(result);
}
/*
* 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;
}
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);
}
/**
* @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 */
int u;
LWCOLLECTION *lwcollection = NULL;
LWGEOM **lwpolygons;
uchar *serialized_lwgeom;
LWGEOM_UNPARSER_RESULT lwg_unparser_result;
LWPOLY *lwpoly;
DYNPTARRAY *dpas;
POINTARRAY ***pas;
POINT4D point4d;
int dims = 0, hasz = 0, hasm = 0;
int result;
char *mem;
/* Determine the correct dimensions: note that in hwgeom-compatible mode we cannot use
the M coordinate */
if (state->wkbtype & WKBZOFFSET)
hasz = 1;
if (!state->config->hwgeom)
if (state->wkbtype & WKBMOFFSET)
hasm = 1;
TYPE_SETZM(dims, hasz, hasm);
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);
/* Allocate memory for our POINTARRAY pointers for each polygon */
pas = malloc(sizeof(POINTARRAY **) * polygon_total);
/* Cycle through each individual polygon */
for (pi = 0; pi < polygon_total; pi++)
{
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;
}
/* Reserve memory for the POINTARRAYs representing each ring */
pas[pi] = malloc(sizeof(POINTARRAY *) * ring_total);
/* Cycle through each ring within the polygon, starting with the outer */
polyring = Outer[pi];
while (polyring)
{
/* Create a DYNPTARRAY containing the points making up the ring */
dpas = dynptarray_create(polyring->n, dims);
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->wkbtype & WKBZOFFSET)
point4d.z = polyring->list[vi].z;
if (state->wkbtype & WKBMOFFSET)
point4d.m = polyring->list[vi].m;
dynptarray_addPoint4d(dpas, &point4d, 0);
}
/* Copy the POINTARRAY pointer from the DYNPTARRAY structure so we can
use the LWPOLY constructor */
pas[pi][ring_index] = dpas->pa;
/* Free the DYNPTARRAY structure (we don't need this part anymore as we
have the reference to the internal POINTARRAY) */
lwfree(dpas);
polyring = polyring->next;
ring_index++;
}
/* Generate the LWGEOM */
lwpoly = lwpoly_construct(state->config->sr_id, NULL, ring_total, pas[pi]);
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)
{
lwcollection = lwcollection_construct(MULTIPOLYGONTYPE, state->config->sr_id, NULL, polygon_total, lwpolygons);
/* When outputting wkt rather than wkb, we need to remove the SRID from the inner geometries */
if (state->config->hwgeom)
{
for (u = 0; u < pi; u++)
lwpolygons[u]->SRID = -1;
}
serialized_lwgeom = lwgeom_serialize(lwcollection_as_lwgeom(lwcollection));
}
else
{
serialized_lwgeom = lwgeom_serialize(lwpolygons[0]);
}
/* Note: lwpoly_free() currently doesn't free its serialized pointlist, so do it manually */
for (pi = 0; pi < polygon_total; pi++)
{
Ring *polyring = Outer[pi];
int ring_index = 0;
while (polyring)
{
if (pas[pi][ring_index]->serialized_pointlist)
lwfree(pas[pi][ring_index]->serialized_pointlist);
polyring = polyring->next;
ring_index++;
}
}
ReleasePolygons(Outer, polygon_total);
if (!state->config->hwgeom)
result = serialized_lwgeom_to_hexwkb(&lwg_unparser_result, serialized_lwgeom, PARSER_CHECK_NONE, -1);
else
result = serialized_lwgeom_to_ewkt(&lwg_unparser_result, serialized_lwgeom, PARSER_CHECK_NONE);
if (result)
{
snprintf(state->message, SHPLOADERMSGLEN, "%s", lwg_unparser_result.message);
return SHPLOADERERR;
}
/* Allocate a string containing the resulting geometry */
mem = malloc(strlen(lwg_unparser_result.wkoutput) + 1);
strcpy(mem, lwg_unparser_result.wkoutput);
/* Free all of the allocated items */
lwfree(lwg_unparser_result.wkoutput);
lwfree(serialized_lwgeom);
/* Cycle through each polygon, freeing everything we need... */
for (u = 0; u < polygon_total; u++)
lwpoly_free(lwgeom_as_lwpoly(lwpolygons[u]));
/* Free the pointer arrays */
lwfree(pas);
lwfree(lwpolygons);
if (lwcollection)
lwfree(lwcollection);
/* Return the string - everything ok */
*geometry = mem;
return SHPLOADEROK;
}
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 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;
}
int main()
{
/*
* An example to show how to call the WKT/WKB unparsers in liblwgeom
*/
LWGEOM_UNPARSER_RESULT lwg_unparser_result;
int result;
LWGEOM *lwgeom;
uchar *serialized_lwgeom;
DYNPTARRAY *dpa;
POINT4D point4d;
POINTARRAY **rings;
LWPOINT *testpoint;
LWLINE *testline;
LWPOLY *testpoly;
/*
* Construct a geometry equivalent to POINT(0 51)
*/
dpa = dynptarray_create(10, 2);
point4d.x = 0;
point4d.y = 51;
dynptarray_addPoint4d(dpa, &point4d, 0);
testpoint = lwpoint_construct(-1, NULL, dpa->pa);
/* Generate the LWGEOM from LWPOINT, then serialize it ready for the parser */
lwgeom = lwpoint_as_lwgeom(testpoint);
serialized_lwgeom = lwgeom_serialize(lwgeom);
/* Output the geometry in WKT and WKB */
result = serialized_lwgeom_to_ewkt(&lwg_unparser_result, serialized_lwgeom, PARSER_CHECK_ALL);
printf("WKT format : %s\n", lwg_unparser_result.wkoutput);
result = serialized_lwgeom_to_hexwkb(&lwg_unparser_result, serialized_lwgeom, PARSER_CHECK_ALL, NDR);
printf("HEXWKB format : %s\n\n", lwg_unparser_result.wkoutput);
/* Free all of the allocated items */
lwfree(lwg_unparser_result.wkoutput);
lwfree(serialized_lwgeom);
lwpoint_free(testpoint);
lwfree(dpa);
/*
* Construct a geometry equivalent to LINESTRING(0 0, 2 2, 4 1)
*/
dpa = dynptarray_create(10, 2);
point4d.x = 0;
point4d.y = 0;
dynptarray_addPoint4d(dpa, &point4d, 0);
point4d.x = 2;
point4d.y = 2;
dynptarray_addPoint4d(dpa, &point4d, 0);
point4d.x = 4;
point4d.y = 1;
dynptarray_addPoint4d(dpa, &point4d, 0);
testline = lwline_construct(-1, NULL, dpa->pa);
/* Generate the LWGEOM from LWLINE, then serialize it ready for the parser */
lwgeom = lwline_as_lwgeom(testline);
serialized_lwgeom = lwgeom_serialize(lwgeom);
/* Output the geometry in WKT and WKB */
result = serialized_lwgeom_to_ewkt(&lwg_unparser_result, serialized_lwgeom, PARSER_CHECK_ALL);
printf("WKT format : %s\n", lwg_unparser_result.wkoutput);
result = serialized_lwgeom_to_hexwkb(&lwg_unparser_result, serialized_lwgeom, PARSER_CHECK_ALL, NDR);
printf("HEXWKB format : %s\n\n", lwg_unparser_result.wkoutput);
/* Free all of the allocated items */
lwfree(lwg_unparser_result.wkoutput);
lwfree(serialized_lwgeom);
lwline_free(testline);
lwfree(dpa);
/*
* Construct a geometry equivalent to POLYGON((0 0, 0 10, 10 10, 10 0, 0 0)(3 3, 3 6, 6 6, 6 3, 3 3))
*/
/* Allocate memory for the rings */
rings = lwalloc(sizeof(POINTARRAY) * 2);
/* Construct the first ring */
dpa = dynptarray_create(10, 2);
point4d.x = 0;
point4d.y = 0;
dynptarray_addPoint4d(dpa, &point4d, 0);
point4d.x = 0;
point4d.y = 10;
dynptarray_addPoint4d(dpa, &point4d, 0);
point4d.x = 10;
point4d.y = 10;
dynptarray_addPoint4d(dpa, &point4d, 0);
point4d.x = 10;
point4d.y = 0;
dynptarray_addPoint4d(dpa, &point4d, 0);
point4d.x = 0;
point4d.y = 0;
dynptarray_addPoint4d(dpa, &point4d, 0);
rings[0] = dpa->pa;
lwfree(dpa);
/* Construct the second ring */
dpa = dynptarray_create(10, 2);
point4d.x = 3;
point4d.y = 3;
dynptarray_addPoint4d(dpa, &point4d, 0);
point4d.x = 3;
point4d.y = 6;
dynptarray_addPoint4d(dpa, &point4d, 0);
point4d.x = 6;
point4d.y = 6;
dynptarray_addPoint4d(dpa, &point4d, 0);
point4d.x = 6;
point4d.y = 3;
dynptarray_addPoint4d(dpa, &point4d, 0);
point4d.x = 3;
point4d.y = 3;
dynptarray_addPoint4d(dpa, &point4d, 0);
rings[1] = dpa->pa;
lwfree(dpa);
testpoly = lwpoly_construct(-1, NULL, 2, rings);
/* Generate the LWGEOM from LWPOLY, then serialize it ready for the parser */
lwgeom = lwpoly_as_lwgeom(testpoly);
serialized_lwgeom = lwgeom_serialize(lwgeom);
/* Output the geometry in WKT and WKB */
result = serialized_lwgeom_to_ewkt(&lwg_unparser_result, serialized_lwgeom, PARSER_CHECK_NONE);
printf("WKT format : %s\n", lwg_unparser_result.wkoutput);
result = serialized_lwgeom_to_hexwkb(&lwg_unparser_result, serialized_lwgeom, PARSER_CHECK_NONE, NDR);
printf("HEXWKB format : %s\n\n", lwg_unparser_result.wkoutput);
/* Free all of the allocated items */
lwfree(lwg_unparser_result.wkoutput);
lwfree(serialized_lwgeom);
lwpoly_free(testpoly);
}
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);
}
/* Return an LWGEOM from a Geometry */
LWGEOM *
GEOS2LWGEOM(const GEOSGeometry *geom, char want3d)
{
int type = GEOSGeomTypeId(geom) ;
int hasZ;
int SRID = GEOSGetSRID(geom);
/* GEOS's 0 is equivalent to our unknown as for SRID values */
if ( SRID == 0 ) SRID = SRID_UNKNOWN;
if ( want3d )
{
hasZ = GEOSHasZ(geom);
if ( ! hasZ )
{
LWDEBUG(3, "Geometry has no Z, won't provide one");
want3d = 0;
}
}
/*
if ( GEOSisEmpty(geom) )
{
return (LWGEOM*)lwcollection_construct_empty(COLLECTIONTYPE, SRID, want3d, 0);
}
*/
switch (type)
{
const GEOSCoordSequence *cs;
POINTARRAY *pa, **ppaa;
const GEOSGeometry *g;
LWGEOM **geoms;
uint32_t i, ngeoms;
case GEOS_POINT:
LWDEBUG(4, "lwgeom_from_geometry: it's a Point");
cs = GEOSGeom_getCoordSeq(geom);
if ( GEOSisEmpty(geom) )
return (LWGEOM*)lwpoint_construct_empty(SRID, want3d, 0);
pa = ptarray_from_GEOSCoordSeq(cs, want3d);
return (LWGEOM *)lwpoint_construct(SRID, NULL, pa);
case GEOS_LINESTRING:
case GEOS_LINEARRING:
LWDEBUG(4, "lwgeom_from_geometry: it's a LineString or LinearRing");
if ( GEOSisEmpty(geom) )
return (LWGEOM*)lwline_construct_empty(SRID, want3d, 0);
cs = GEOSGeom_getCoordSeq(geom);
pa = ptarray_from_GEOSCoordSeq(cs, want3d);
return (LWGEOM *)lwline_construct(SRID, NULL, pa);
case GEOS_POLYGON:
LWDEBUG(4, "lwgeom_from_geometry: it's a Polygon");
if ( GEOSisEmpty(geom) )
return (LWGEOM*)lwpoly_construct_empty(SRID, want3d, 0);
ngeoms = GEOSGetNumInteriorRings(geom);
ppaa = lwalloc(sizeof(POINTARRAY *)*(ngeoms+1));
g = GEOSGetExteriorRing(geom);
cs = GEOSGeom_getCoordSeq(g);
ppaa[0] = ptarray_from_GEOSCoordSeq(cs, want3d);
for (i=0; i<ngeoms; i++)
{
g = GEOSGetInteriorRingN(geom, i);
cs = GEOSGeom_getCoordSeq(g);
ppaa[i+1] = ptarray_from_GEOSCoordSeq(cs,
want3d);
}
return (LWGEOM *)lwpoly_construct(SRID, NULL,
ngeoms+1, ppaa);
case GEOS_MULTIPOINT:
case GEOS_MULTILINESTRING:
case GEOS_MULTIPOLYGON:
case GEOS_GEOMETRYCOLLECTION:
LWDEBUG(4, "lwgeom_from_geometry: it's a Collection or Multi");
ngeoms = GEOSGetNumGeometries(geom);
geoms = NULL;
if ( ngeoms )
{
geoms = lwalloc(sizeof(LWGEOM *)*ngeoms);
for (i=0; i<ngeoms; i++)
{
g = GEOSGetGeometryN(geom, i);
geoms[i] = GEOS2LWGEOM(g, want3d);
}
}
return (LWGEOM *)lwcollection_construct(type,
SRID, NULL, ngeoms, geoms);
default:
lwerror("GEOS2LWGEOM: unknown geometry type: %d", type);
return NULL;
}
}
/**
* Parse KML Polygon
*/
static LWGEOM* parse_kml_polygon(xmlNodePtr xnode, bool *hasz)
{
int ring;
xmlNodePtr xa, xb;
POINTARRAY **ppa = NULL;
for (xa = xnode->children ; xa != NULL ; xa = xa->next)
{
/* Polygon/outerBoundaryIs */
if (xa->type != XML_ELEMENT_NODE) continue;
if (!is_kml_namespace(xa, false)) continue;
if (strcmp((char *) xa->name, "outerBoundaryIs")) continue;
for (xb = xa->children ; xb != NULL ; xb = xb->next)
{
if (xb->type != XML_ELEMENT_NODE) continue;
if (!is_kml_namespace(xb, false)) continue;
if (strcmp((char *) xb->name, "LinearRing")) continue;
ppa = (POINTARRAY**) lwalloc(sizeof(POINTARRAY*));
ppa[0] = parse_kml_coordinates(xb->children, hasz);
if (ppa[0]->npoints < 4
|| (!*hasz && !ptarray_isclosed2d(ppa[0]))
|| (*hasz && !ptarray_isclosed3d(ppa[0])))
lwerror("invalid KML representation");
}
}
for (ring=1, xa = xnode->children ; xa != NULL ; xa = xa->next)
{
/* Polygon/innerBoundaryIs */
if (xa->type != XML_ELEMENT_NODE) continue;
if (!is_kml_namespace(xa, false)) continue;
if (strcmp((char *) xa->name, "innerBoundaryIs")) continue;
for (xb = xa->children ; xb != NULL ; xb = xb->next)
{
if (xb->type != XML_ELEMENT_NODE) continue;
if (!is_kml_namespace(xb, false)) continue;
if (strcmp((char *) xb->name, "LinearRing")) continue;
ppa = (POINTARRAY**) lwrealloc((POINTARRAY *) ppa,
sizeof(POINTARRAY*) * (ring + 1));
ppa[ring] = parse_kml_coordinates(xb->children, hasz);
if (ppa[ring]->npoints < 4
|| (!*hasz && !ptarray_isclosed2d(ppa[ring]))
|| (*hasz && !ptarray_isclosed3d(ppa[ring])))
lwerror("invalid KML representation");
ring++;
}
}
/* Exterior Ring is mandatory */
if (ppa == NULL || ppa[0] == NULL) lwerror("invalid KML representation");
return (LWGEOM *) lwpoly_construct(4326, NULL, ring, ppa);
}
LWPOLY *
lwpoly_grid(LWPOLY *poly, gridspec *grid)
{
LWPOLY *opoly;
int ri;
POINTARRAY **newrings = NULL;
int nrings = 0;
double minvisiblearea;
/*
* TODO: control this assertion
* it is assumed that, since the grid size will be a pixel,
* a visible ring should show at least a white pixel inside,
* thus, for a square, that would be grid_xsize*grid_ysize
*/
minvisiblearea = grid->xsize * grid->ysize;
nrings = 0;
POSTGIS_DEBUGF(3, "grid_polygon3d: applying grid to polygon with %d rings",
poly->nrings);
for (ri=0; ri<poly->nrings; ri++)
{
POINTARRAY *ring = poly->rings[ri];
POINTARRAY *newring;
#if POSTGIS_DEBUG_LEVEL >= 4
POINT2D p1, p2;
getPoint2d_p(ring, 0, &p1);
getPoint2d_p(ring, ring->npoints-1, &p2);
if ( ! SAMEPOINT(&p1, &p2) )
POSTGIS_DEBUG(4, "Before gridding: first point != last point");
#endif
newring = ptarray_grid(ring, grid);
/* Skip ring if not composed by at least 4 pts (3 segments) */
if ( newring->npoints < 4 )
{
pfree(newring);
POSTGIS_DEBUGF(3, "grid_polygon3d: ring%d skipped ( <4 pts )", ri);
if ( ri ) continue;
else break; /* this is the external ring, no need to work on holes */
}
#if POSTGIS_DEBUG_LEVEL >= 4
getPoint2d_p(newring, 0, &p1);
getPoint2d_p(newring, newring->npoints-1, &p2);
if ( ! SAMEPOINT(&p1, &p2) )
POSTGIS_DEBUG(4, "After gridding: first point != last point");
#endif
POSTGIS_DEBUGF(3, "grid_polygon3d: ring%d simplified from %d to %d points", ri,
ring->npoints, newring->npoints);
/*
* Add ring to simplified ring array
* (TODO: dinamic allocation of pts_per_ring)
*/
if ( ! nrings )
{
newrings = palloc(sizeof(POINTARRAY *));
}
else
{
newrings = repalloc(newrings, sizeof(POINTARRAY *)*(nrings+1));
}
if ( ! newrings )
{
elog(ERROR, "Out of virtual memory");
return NULL;
}
newrings[nrings++] = newring;
}
POSTGIS_DEBUGF(3, "grid_polygon3d: simplified polygon with %d rings", nrings);
if ( ! nrings ) return NULL;
opoly = lwpoly_construct(poly->srid, NULL, nrings, newrings);
return opoly;
}
