Datum LWGEOM_from_text(PG_FUNCTION_ARGS)
{
text *wkttext = PG_GETARG_TEXT_P(0);
char *wkt = text2cstring(wkttext);
LWGEOM_PARSER_RESULT lwg_parser_result;
GSERIALIZED *geom_result = NULL;
LWGEOM *lwgeom;
POSTGIS_DEBUG(2, "LWGEOM_from_text");
POSTGIS_DEBUGF(3, "wkt: [%s]", wkt);
if (lwgeom_parse_wkt(&lwg_parser_result, wkt, LW_PARSER_CHECK_ALL) == LW_FAILURE)
PG_PARSER_ERROR(lwg_parser_result);
lwgeom = lwg_parser_result.geom;
if ( lwgeom->srid != SRID_UNKNOWN )
{
elog(WARNING, "OGC WKT expected, EWKT provided - use GeomFromEWKT() for this");
}
/* read user-requested SRID if any */
if ( PG_NARGS() > 1 )
lwgeom_set_srid(lwgeom, PG_GETARG_INT32(1));
geom_result = geometry_serialize(lwgeom);
lwgeom_parser_result_free(&lwg_parser_result);
PG_RETURN_POINTER(geom_result);
}
Datum line_from_encoded_polyline(PG_FUNCTION_ARGS)
{
GSERIALIZED *geom;
LWGEOM *lwgeom;
text *encodedpolyline_input;
char *encodedpolyline;
int precision = 5;
if (PG_ARGISNULL(0)) PG_RETURN_NULL();
encodedpolyline_input = PG_GETARG_TEXT_P(0);
encodedpolyline = text2cstring(encodedpolyline_input);
if (PG_NARGS() >2 && !PG_ARGISNULL(2))
{
precision = PG_GETARG_INT32(2);
if ( precision < 0 ) precision = 5;
}
lwgeom = lwgeom_from_encoded_polyline(encodedpolyline, precision);
if ( ! lwgeom ) {
/* Shouldn't get here */
elog(ERROR, "lwgeom_from_encoded_polyline returned NULL");
PG_RETURN_NULL();
}
lwgeom_set_srid(lwgeom, 4326);
geom = geometry_serialize(lwgeom);
lwgeom_free(lwgeom);
PG_RETURN_POINTER(geom);
}
void wkt_parser_geometry_new(LWGEOM *geom, int srid)
{
LWDEBUG(4,"entered");
LWDEBUGF(4,"geom %p",geom);
LWDEBUGF(4,"srid %d",srid);
if ( geom == NULL )
{
lwerror("Parsed geometry is null!");
return;
}
if ( srid != SRID_UNKNOWN && srid < SRID_MAXIMUM )
lwgeom_set_srid(geom, srid);
else
lwgeom_set_srid(geom, SRID_UNKNOWN);
global_parser_result.geom = geom;
}
Datum LWGEOM_set_srid(PG_FUNCTION_ARGS)
{
GSERIALIZED *result;
GSERIALIZED *geom = (GSERIALIZED *)PG_DETOAST_DATUM(PG_GETARG_DATUM(0));
int srid = PG_GETARG_INT32(1);
LWGEOM *lwgeom = lwgeom_from_gserialized(geom);
lwgeom_set_srid(lwgeom, srid);
result = geometry_serialize(lwgeom);
lwgeom_free(lwgeom);
PG_FREE_IF_COPY(geom, 0);
PG_RETURN_POINTER(result);
}
LWGEOM* lwgeom_from_gserialized(const GSERIALIZED *g)
{
uint8_t g_flags = 0;
int32_t g_srid = 0;
uint32_t g_type = 0;
uint8_t *data_ptr = NULL;
LWGEOM *lwgeom = NULL;
GBOX bbox;
size_t g_size = 0;
assert(g);
g_srid = gserialized_get_srid(g);
g_flags = g->flags;
g_type = gserialized_get_type(g);
LWDEBUGF(4, "Got type %d (%s), srid=%d", g_type, lwtype_name(g_type), g_srid);
data_ptr = (uint8_t*)g->data;
if ( FLAGS_GET_BBOX(g_flags) )
data_ptr += gbox_serialized_size(g_flags);
lwgeom = lwgeom_from_gserialized_buffer(data_ptr, g_flags, &g_size);
if ( ! lwgeom )
lwerror("lwgeom_from_gserialized: unable create geometry"); /* Ooops! */
lwgeom->type = g_type;
lwgeom->flags = g_flags;
if ( gserialized_read_gbox_p(g, &bbox) == LW_SUCCESS )
{
lwgeom->bbox = gbox_copy(&bbox);
}
else if ( lwgeom_needs_bbox(lwgeom) && (lwgeom_calculate_gbox(lwgeom, &bbox) == LW_SUCCESS) )
{
lwgeom->bbox = gbox_copy(&bbox);
}
else
{
lwgeom->bbox = NULL;
}
lwgeom_set_srid(lwgeom, g_srid);
return lwgeom;
}
void lwgeom_set_srid(LWGEOM *geom, int32_t srid)
{
int i;
LWDEBUGF(4,"entered with srid=%d",srid);
geom->srid = srid;
if ( lwgeom_is_collection(geom) )
{
/* All the children are set to the unknown SRID value
TODO: change this so the children have a known SRID? */
LWCOLLECTION *col = lwgeom_as_lwcollection(geom);
for ( i = 0; i < col->ngeoms; i++ )
{
lwgeom_set_srid(col->geoms[i], SRID_UNKNOWN);
}
}
}
LWPOLY *
lwpoly_construct_envelope(int srid, double x1, double y1, double x2, double y2)
{
POINT4D p1, p2, p3, p4;
LWPOLY *poly;
p1.x = x1;
p1.y = y1;
p2.x = x1;
p2.y = y2;
p3.x = x2;
p3.y = y2;
p4.x = x2;
p4.y = y1;
poly = lwpoly_construct_rectangle(0, 0, &p1, &p2, &p3, &p4);
lwgeom_set_srid(lwpoly_as_lwgeom(poly), srid);
lwgeom_add_bbox(lwpoly_as_lwgeom(poly));
return poly;
}
Datum geom_from_geojson(PG_FUNCTION_ARGS)
{
#ifndef HAVE_LIBJSON
elog(ERROR, "You need JSON-C for ST_GeomFromGeoJSON");
PG_RETURN_NULL();
#else /* HAVE_LIBJSON */
GSERIALIZED *geom;
LWGEOM *lwgeom;
text *geojson_input;
char *geojson;
char *srs = NULL;
/* Get the geojson stream */
if (PG_ARGISNULL(0))
PG_RETURN_NULL();
geojson_input = PG_GETARG_TEXT_P(0);
geojson = text2cstring(geojson_input);
lwgeom = lwgeom_from_geojson(geojson, &srs);
if ( ! lwgeom )
{
/* Shouldn't get here */
elog(ERROR, "lwgeom_from_geojson returned NULL");
PG_RETURN_NULL();
}
if ( srs )
{
lwgeom_set_srid(lwgeom, getSRIDbySRS(srs));
lwfree(srs);
}
geom = geometry_serialize(lwgeom);
lwgeom_free(lwgeom);
PG_RETURN_POINTER(geom);
#endif
}
Datum LWGEOMFromWKB(PG_FUNCTION_ARGS)
{
bytea *bytea_wkb = (bytea*)PG_GETARG_BYTEA_P(0);
int32 srid = 0;
GSERIALIZED *geom;
LWGEOM *lwgeom;
uint8_t *wkb = (uint8_t*)VARDATA(bytea_wkb);
lwgeom = lwgeom_from_wkb(wkb, VARSIZE(bytea_wkb)-VARHDRSZ, LW_PARSER_CHECK_ALL);
if ( ( PG_NARGS()>1) && ( ! PG_ARGISNULL(1) ))
{
srid = PG_GETARG_INT32(1);
lwgeom_set_srid(lwgeom, srid);
}
if ( lwgeom_needs_bbox(lwgeom) )
lwgeom_add_bbox(lwgeom);
geom = geometry_serialize(lwgeom);
lwgeom_free(lwgeom);
PG_FREE_IF_COPY(bytea_wkb, 0);
PG_RETURN_POINTER(geom);
}
/* Initializes and uses GEOS internally */
static LWGEOM*
lwline_split_by_line(const LWLINE* lwline_in, const LWGEOM* blade_in)
{
LWGEOM** components;
LWGEOM* diff;
LWCOLLECTION* out;
GEOSGeometry* gdiff; /* difference */
GEOSGeometry* g1;
GEOSGeometry* g2;
int ret;
/* ASSERT blade_in is LINE or MULTILINE */
assert (blade_in->type == LINETYPE ||
blade_in->type == MULTILINETYPE ||
blade_in->type == POLYGONTYPE ||
blade_in->type == MULTIPOLYGONTYPE );
/* Possible outcomes:
*
* 1. The lines do not cross or overlap
* -> Return a collection with single element
* 2. The lines cross
* -> Return a collection of all elements resulting from the split
*/
initGEOS(lwgeom_geos_error, lwgeom_geos_error);
g1 = LWGEOM2GEOS((LWGEOM*)lwline_in, 0);
if ( ! g1 )
{
lwerror("LWGEOM2GEOS: %s", lwgeom_geos_errmsg);
return NULL;
}
g2 = LWGEOM2GEOS(blade_in, 0);
if ( ! g2 )
{
GEOSGeom_destroy(g1);
lwerror("LWGEOM2GEOS: %s", lwgeom_geos_errmsg);
return NULL;
}
/* If blade is a polygon, pick its boundary */
if ( blade_in->type == POLYGONTYPE || blade_in->type == MULTIPOLYGONTYPE )
{
gdiff = GEOSBoundary(g2);
GEOSGeom_destroy(g2);
if ( ! gdiff )
{
GEOSGeom_destroy(g1);
lwerror("GEOSBoundary: %s", lwgeom_geos_errmsg);
return NULL;
}
g2 = gdiff; gdiff = NULL;
}
/* If interior intersecton is linear we can't split */
ret = GEOSRelatePattern(g1, g2, "1********");
if ( 2 == ret )
{
lwerror("GEOSRelatePattern: %s", lwgeom_geos_errmsg);
GEOSGeom_destroy(g1);
GEOSGeom_destroy(g2);
return NULL;
}
if ( ret )
{
GEOSGeom_destroy(g1);
GEOSGeom_destroy(g2);
lwerror("Splitter line has linear intersection with input");
return NULL;
}
gdiff = GEOSDifference(g1,g2);
GEOSGeom_destroy(g1);
GEOSGeom_destroy(g2);
if (gdiff == NULL)
{
lwerror("GEOSDifference: %s", lwgeom_geos_errmsg);
return NULL;
}
diff = GEOS2LWGEOM(gdiff, FLAGS_GET_Z(lwline_in->flags));
GEOSGeom_destroy(gdiff);
if (NULL == diff)
{
lwerror("GEOS2LWGEOM: %s", lwgeom_geos_errmsg);
return NULL;
}
out = lwgeom_as_lwcollection(diff);
if ( ! out )
{
components = lwalloc(sizeof(LWGEOM*)*1);
components[0] = diff;
out = lwcollection_construct(COLLECTIONTYPE, lwline_in->srid,
NULL, 1, components);
}
else
{
/* Set SRID */
lwgeom_set_srid((LWGEOM*)out, lwline_in->srid);
/* Force collection type */
out->type = COLLECTIONTYPE;
}
return (LWGEOM*)out;
}
Datum LWGEOM_in(PG_FUNCTION_ARGS)
{
char *input = PG_GETARG_CSTRING(0);
int32 geom_typmod = -1;
char *str = input;
LWGEOM_PARSER_RESULT lwg_parser_result;
LWGEOM *lwgeom;
GSERIALIZED *ret;
int srid = 0;
if ( (PG_NARGS()>2) && (!PG_ARGISNULL(2)) ) {
geom_typmod = PG_GETARG_INT32(2);
}
lwgeom_parser_result_init(&lwg_parser_result);
/* Empty string. */
if ( str[0] == '\0' )
ereport(ERROR,(errmsg("parse error - invalid geometry")));
/* Starts with "SRID=" */
if( strncasecmp(str,"SRID=",5) == 0 )
{
/* Roll forward to semi-colon */
char *tmp = str;
while ( tmp && *tmp != ';' )
tmp++;
/* Check next character to see if we have WKB */
if ( tmp && *(tmp+1) == '0' )
{
/* Null terminate the SRID= string */
*tmp = '\0';
/* Set str to the start of the real WKB */
str = tmp + 1;
/* Move tmp to the start of the numeric part */
tmp = input + 5;
/* Parse out the SRID number */
srid = atoi(tmp);
}
}
/* WKB? Let's find out. */
if ( str[0] == '0' )
{
size_t hexsize = strlen(str);
unsigned char *wkb = bytes_from_hexbytes(str, hexsize);
/* TODO: 20101206: No parser checks! This is inline with current 1.5 behavior, but needs discussion */
lwgeom = lwgeom_from_wkb(wkb, hexsize/2, LW_PARSER_CHECK_NONE);
/* If we picked up an SRID at the head of the WKB set it manually */
if ( srid ) lwgeom_set_srid(lwgeom, srid);
/* Add a bbox if necessary */
if ( lwgeom_needs_bbox(lwgeom) ) lwgeom_add_bbox(lwgeom);
pfree(wkb);
ret = geometry_serialize(lwgeom);
lwgeom_free(lwgeom);
}
/* WKT then. */
else
{
if ( lwgeom_parse_wkt(&lwg_parser_result, str, LW_PARSER_CHECK_ALL) == LW_FAILURE )
{
PG_PARSER_ERROR(lwg_parser_result);
}
lwgeom = lwg_parser_result.geom;
if ( lwgeom_needs_bbox(lwgeom) )
lwgeom_add_bbox(lwgeom);
ret = geometry_serialize(lwgeom);
lwgeom_parser_result_free(&lwg_parser_result);
}
if ( geom_typmod >= 0 )
{
postgis_valid_typmod(ret, geom_typmod);
POSTGIS_DEBUG(3, "typmod and geometry were consistent");
}
else
{
POSTGIS_DEBUG(3, "typmod was -1");
}
/* Don't free the parser result (and hence lwgeom) until we have done */
/* the typemod check with lwgeom */
PG_RETURN_POINTER(ret);
}
