Datum ST_LineCrossingDirection(PG_FUNCTION_ARGS)
{
int type1, type2, rv;
LWLINE *l1 = NULL;
LWLINE *l2 = NULL;
GSERIALIZED *geom1 = PG_GETARG_GSERIALIZED_P(0);
GSERIALIZED *geom2 = PG_GETARG_GSERIALIZED_P(1);
error_if_srid_mismatch(gserialized_get_srid(geom1), gserialized_get_srid(geom2));
type1 = gserialized_get_type(geom1);
type2 = gserialized_get_type(geom2);
if ( type1 != LINETYPE || type2 != LINETYPE )
{
elog(ERROR,"This function only accepts LINESTRING as arguments.");
PG_RETURN_NULL();
}
l1 = lwgeom_as_lwline(lwgeom_from_gserialized(geom1));
l2 = lwgeom_as_lwline(lwgeom_from_gserialized(geom2));
rv = lwline_crossing_direction(l1, l2);
PG_FREE_IF_COPY(geom1, 0);
PG_FREE_IF_COPY(geom2, 1);
PG_RETURN_INT32(rv);
}
Datum LWGEOM_line_locate_point(PG_FUNCTION_ARGS)
{
GSERIALIZED *geom1 = PG_GETARG_GSERIALIZED_P(0);
GSERIALIZED *geom2 = PG_GETARG_GSERIALIZED_P(1);
LWLINE *lwline;
LWPOINT *lwpoint;
POINTARRAY *pa;
POINT4D p, p_proj;
double ret;
if ( gserialized_get_type(geom1) != LINETYPE )
{
elog(ERROR,"line_locate_point: 1st arg isn't a line");
PG_RETURN_NULL();
}
if ( gserialized_get_type(geom2) != POINTTYPE )
{
elog(ERROR,"line_locate_point: 2st arg isn't a point");
PG_RETURN_NULL();
}
error_if_srid_mismatch(gserialized_get_srid(geom1), gserialized_get_srid(geom2));
lwline = lwgeom_as_lwline(lwgeom_from_gserialized(geom1));
lwpoint = lwgeom_as_lwpoint(lwgeom_from_gserialized(geom2));
pa = lwline->points;
lwpoint_getPoint4d_p(lwpoint, &p);
ret = ptarray_locate_point(pa, &p, NULL, &p_proj);
PG_RETURN_FLOAT8(ret);
}
Datum sfcgal_minkowski_sum(PG_FUNCTION_ARGS)
{
GSERIALIZED *input0, *input1, *output;
sfcgal_geometry_t *geom0, *geom1;
sfcgal_geometry_t *result;
srid_t srid;
sfcgal_postgis_init();
input0 = PG_GETARG_GSERIALIZED_P(0);
srid = gserialized_get_srid(input0);
input1 = PG_GETARG_GSERIALIZED_P(1);
geom0 = POSTGIS2SFCGALGeometry(input0);
PG_FREE_IF_COPY(input0, 0);
geom1 = POSTGIS2SFCGALGeometry(input1);
PG_FREE_IF_COPY(input1, 1);
result = sfcgal_geometry_minkowski_sum(geom0, geom1);
sfcgal_geometry_delete(geom0);
sfcgal_geometry_delete(geom1);
output = SFCGALGeometry2POSTGIS(result, 0, srid);
sfcgal_geometry_delete(result);
PG_RETURN_POINTER(output);
}
Datum ST_InterpolatePoint(PG_FUNCTION_ARGS)
{
GSERIALIZED *gser_line = PG_GETARG_GSERIALIZED_P(0);
GSERIALIZED *gser_point = PG_GETARG_GSERIALIZED_P(1);
LWGEOM *lwline;
LWPOINT *lwpoint;
if ( gserialized_get_type(gser_line) != LINETYPE )
{
elog(ERROR,"ST_InterpolatePoint: 1st argument isn't a line");
PG_RETURN_NULL();
}
if ( gserialized_get_type(gser_point) != POINTTYPE )
{
elog(ERROR,"ST_InterpolatePoint: 2st argument isn't a point");
PG_RETURN_NULL();
}
error_if_srid_mismatch(gserialized_get_srid(gser_line), gserialized_get_srid(gser_point));
if ( ! gserialized_has_m(gser_line) )
{
elog(ERROR,"ST_InterpolatePoint only accepts geometries that have an M dimension");
PG_RETURN_NULL();
}
lwpoint = lwgeom_as_lwpoint(lwgeom_from_gserialized(gser_point));
lwline = lwgeom_from_gserialized(gser_line);
PG_RETURN_FLOAT8(lwgeom_interpolate_point(lwline, lwpoint));
}
Datum geometry_distance_spheroid(PG_FUNCTION_ARGS)
{
GSERIALIZED *geom1 = PG_GETARG_GSERIALIZED_P(0);
GSERIALIZED *geom2 = PG_GETARG_GSERIALIZED_P(1);
SPHEROID *sphere = (SPHEROID *)PG_GETARG_POINTER(2);
int type1 = gserialized_get_type(geom1);
int type2 = gserialized_get_type(geom2);
bool use_spheroid = PG_GETARG_BOOL(3);
LWGEOM *lwgeom1, *lwgeom2;
double distance;
/* Calculate some other parameters on the spheroid */
spheroid_init(sphere, sphere->a, sphere->b);
/* Catch sphere special case and re-jig spheroid appropriately */
if ( ! use_spheroid )
{
sphere->a = sphere->b = sphere->radius;
}
if ( ! ( type1 == POINTTYPE || type1 == LINETYPE || type1 == POLYGONTYPE ||
type1 == MULTIPOINTTYPE || type1 == MULTILINETYPE || type1 == MULTIPOLYGONTYPE ))
{
elog(ERROR, "geometry_distance_spheroid: Only point/line/polygon supported.\n");
PG_RETURN_NULL();
}
if ( ! ( type2 == POINTTYPE || type2 == LINETYPE || type2 == POLYGONTYPE ||
type2 == MULTIPOINTTYPE || type2 == MULTILINETYPE || type2 == MULTIPOLYGONTYPE ))
{
elog(ERROR, "geometry_distance_spheroid: Only point/line/polygon supported.\n");
PG_RETURN_NULL();
}
if (gserialized_get_srid(geom1) != gserialized_get_srid(geom2))
{
elog(ERROR, "geometry_distance_spheroid: Operation on two GEOMETRIES with different SRIDs\n");
PG_RETURN_NULL();
}
/* Get #LWGEOM structures */
lwgeom1 = lwgeom_from_gserialized(geom1);
lwgeom2 = lwgeom_from_gserialized(geom2);
/* We are going to be calculating geodetic distances */
lwgeom_set_geodetic(lwgeom1, LW_TRUE);
lwgeom_set_geodetic(lwgeom2, LW_TRUE);
distance = lwgeom_distance_spheroid(lwgeom1, lwgeom2, sphere, 0.0);
PG_RETURN_FLOAT8(distance);
}
Datum BOX2D_combine(PG_FUNCTION_ARGS)
{
Pointer box2d_ptr = PG_GETARG_POINTER(0);
Pointer geom_ptr = PG_GETARG_POINTER(1);
GBOX *a,*b;
GSERIALIZED *lwgeom;
GBOX box, *result;
if ( (box2d_ptr == NULL) && (geom_ptr == NULL) )
{
PG_RETURN_NULL(); /* combine_box2d(null,null) => null */
}
result = (GBOX *)palloc(sizeof(GBOX));
if (box2d_ptr == NULL)
{
lwgeom = PG_GETARG_GSERIALIZED_P(1);
/* empty geom would make getbox2d_p return NULL */
if ( ! gserialized_get_gbox_p(lwgeom, &box) ) PG_RETURN_NULL();
memcpy(result, &box, sizeof(GBOX));
PG_RETURN_POINTER(result);
}
/* combine_bbox(BOX3D, null) => BOX3D */
if (geom_ptr == NULL)
{
memcpy(result, (char *)PG_GETARG_DATUM(0), sizeof(GBOX));
PG_RETURN_POINTER(result);
}
/*combine_bbox(BOX3D, geometry) => union(BOX3D, geometry->bvol) */
lwgeom = PG_GETARG_GSERIALIZED_P(1);
if ( ! gserialized_get_gbox_p(lwgeom, &box) )
{
/* must be the empty geom */
memcpy(result, (char *)PG_GETARG_DATUM(0), sizeof(GBOX));
PG_RETURN_POINTER(result);
}
a = (GBOX *)PG_GETARG_DATUM(0);
b = &box;
result->xmax = Max(a->xmax, b->xmax);
result->ymax = Max(a->ymax, b->ymax);
result->xmin = Min(a->xmin, b->xmin);
result->ymin = Min(a->ymin, b->ymin);
PG_RETURN_POINTER(result);
}
Datum sfcgal_approximate_medial_axis(PG_FUNCTION_ARGS)
{
#if POSTGIS_SFCGAL_VERSION < 12
lwpgerror("The SFCGAL version this PostGIS binary "
"was compiled against (%d) doesn't support "
"'sfcgal_geometry_approximate_medial_axis' function (1.2.0+ required)",
POSTGIS_SFCGAL_VERSION);
PG_RETURN_NULL();
#else /* POSTGIS_SFCGAL_VERSION >= 12 */
GSERIALIZED *input, *output;
sfcgal_geometry_t *geom;
sfcgal_geometry_t *result;
srid_t srid;
sfcgal_postgis_init();
input = PG_GETARG_GSERIALIZED_P(0);
srid = gserialized_get_srid(input);
geom = POSTGIS2SFCGALGeometry(input);
PG_FREE_IF_COPY(input, 0);
result = sfcgal_geometry_approximate_medial_axis(geom);
sfcgal_geometry_delete(geom);
output = SFCGALGeometry2POSTGIS(result, 0, srid);
sfcgal_geometry_delete(result);
PG_RETURN_POINTER(output);
#endif /* POSTGIS_SFCGAL_VERSION >= 12 */
}
Datum LWGEOM_curve_segmentize(PG_FUNCTION_ARGS)
{
GSERIALIZED *geom = PG_GETARG_GSERIALIZED_P(0);
int32 perQuad = PG_GETARG_INT32(1);
GSERIALIZED *ret;
LWGEOM *igeom = NULL, *ogeom = NULL;
POSTGIS_DEBUG(2, "LWGEOM_curve_segmentize called.");
if (perQuad < 0)
{
elog(ERROR, "2nd argument must be positive.");
PG_RETURN_NULL();
}
POSTGIS_DEBUGF(3, "perQuad = %d", perQuad);
igeom = lwgeom_from_gserialized(geom);
ogeom = lwgeom_stroke(igeom, perQuad);
lwgeom_free(igeom);
if (ogeom == NULL)
PG_RETURN_NULL();
ret = geometry_serialize(ogeom);
lwgeom_free(ogeom);
PG_FREE_IF_COPY(geom, 0);
PG_RETURN_POINTER(ret);
}
Datum LWGEOM_endpoint_linestring(PG_FUNCTION_ARGS)
{
GSERIALIZED *geom = PG_GETARG_GSERIALIZED_P(0);
LWGEOM *lwgeom = lwgeom_from_gserialized(geom);
LWPOINT *lwpoint = NULL;
int type = lwgeom->type;
if ( type == LINETYPE || type == CIRCSTRINGTYPE )
{
LWLINE *line = (LWLINE*)lwgeom;
if ( line->points )
lwpoint = lwline_get_lwpoint((LWLINE*)lwgeom, line->points->npoints - 1);
}
else if ( type == COMPOUNDTYPE )
{
lwpoint = lwcompound_get_endpoint((LWCOMPOUND*)lwgeom);
}
lwgeom_free(lwgeom);
PG_FREE_IF_COPY(geom, 0);
if ( ! lwpoint )
PG_RETURN_NULL();
PG_RETURN_POINTER(geometry_serialize(lwpoint_as_lwgeom(lwpoint)));
}
Datum LWGEOM_m_point(PG_FUNCTION_ARGS)
{
GSERIALIZED *geom;
LWPOINT *point = NULL;
LWGEOM *lwgeom;
POINT3DM p;
geom = PG_GETARG_GSERIALIZED_P(0);
if ( gserialized_get_type(geom) != POINTTYPE )
lwpgerror("Argument to ST_M() must be a point");
lwgeom = lwgeom_from_gserialized(geom);
point = lwgeom_as_lwpoint(lwgeom);
if ( lwgeom_is_empty(lwgeom) )
PG_RETURN_NULL();
/* no M in input */
if ( ! FLAGS_GET_M(point->flags) ) PG_RETURN_NULL();
getPoint3dm_p(point->point, 0, &p);
PG_FREE_IF_COPY(geom, 0);
PG_RETURN_FLOAT8(p.m);
}
Datum LWGEOM_pointn_linestring(PG_FUNCTION_ARGS)
{
GSERIALIZED *geom = PG_GETARG_GSERIALIZED_P(0);
int where = PG_GETARG_INT32(1);
LWGEOM *lwgeom = lwgeom_from_gserialized(geom);
LWPOINT *lwpoint = NULL;
int type = lwgeom->type;
/* Can't handle crazy index! */
if ( where < 1 )
PG_RETURN_NULL();
if ( type == LINETYPE || type == CIRCSTRINGTYPE )
{
/* OGC index starts at one, so we substract first. */
lwpoint = lwline_get_lwpoint((LWLINE*)lwgeom, where - 1);
}
else if ( type == COMPOUNDTYPE )
{
lwpoint = lwcompound_get_lwpoint((LWCOMPOUND*)lwgeom, where - 1);
}
lwgeom_free(lwgeom);
PG_FREE_IF_COPY(geom, 0);
if ( ! lwpoint )
PG_RETURN_NULL();
PG_RETURN_POINTER(geometry_serialize(lwpoint_as_lwgeom(lwpoint)));
}
Datum LWGEOM_numinteriorrings_polygon(PG_FUNCTION_ARGS)
{
GSERIALIZED *geom = PG_GETARG_GSERIALIZED_P(0);
LWGEOM *lwgeom = lwgeom_from_gserialized(geom);
LWPOLY *poly = NULL;
LWCURVEPOLY *curvepoly = NULL;
int result = -1;
if ( lwgeom->type == POLYGONTYPE )
{
poly = lwgeom_as_lwpoly(lwgeom);
result = poly->nrings - 1;
}
else if ( lwgeom->type == CURVEPOLYTYPE )
{
curvepoly = lwgeom_as_lwcurvepoly(lwgeom);
result = curvepoly->nrings - 1;
}
lwgeom_free(lwgeom);
PG_FREE_IF_COPY(geom, 0);
if ( result < 0 )
PG_RETURN_NULL();
PG_RETURN_INT32(result);
}
Datum sfcgal_extrude(PG_FUNCTION_ARGS)
{
GSERIALIZED *input, *output;
sfcgal_geometry_t *geom;
sfcgal_geometry_t *result;
double dx, dy, dz;
srid_t srid;
sfcgal_postgis_init();
input = PG_GETARG_GSERIALIZED_P(0);
srid = gserialized_get_srid(input);
geom = POSTGIS2SFCGALGeometry(input);
PG_FREE_IF_COPY(input, 0);
dx = PG_GETARG_FLOAT8(1);
dy = PG_GETARG_FLOAT8(2);
dz = PG_GETARG_FLOAT8(3);
result = sfcgal_geometry_extrude(geom, dx, dy, dz);
sfcgal_geometry_delete(geom);
output = SFCGALGeometry2POSTGIS(result, 0, srid);
sfcgal_geometry_delete(result);
PG_RETURN_POINTER(output);
}
Datum LWGEOM_simplify2d(PG_FUNCTION_ARGS)
{
GSERIALIZED *geom = PG_GETARG_GSERIALIZED_P(0);
GSERIALIZED *result;
int type = gserialized_get_type(geom);
LWGEOM *in;
LWGEOM *out;
double dist;
if ( type == POINTTYPE || type == MULTIPOINTTYPE )
PG_RETURN_POINTER(geom);
dist = PG_GETARG_FLOAT8(1);
in = lwgeom_from_gserialized(geom);
out = lwgeom_simplify(in, dist);
if ( ! out ) PG_RETURN_NULL();
/* COMPUTE_BBOX TAINTING */
if ( in->bbox ) lwgeom_add_bbox(out);
result = geometry_serialize(out);
lwgeom_free(out);
PG_FREE_IF_COPY(geom, 0);
PG_RETURN_POINTER(result);
}
Datum LWGEOM_get_srid(PG_FUNCTION_ARGS)
{
GSERIALIZED *geom=PG_GETARG_GSERIALIZED_P(0);
int srid = gserialized_get_srid (geom);
PG_FREE_IF_COPY(geom,0);
PG_RETURN_INT32(srid);
}
Datum LWGEOM_simplify2d(PG_FUNCTION_ARGS)
{
GSERIALIZED *geom = PG_GETARG_GSERIALIZED_P(0);
double dist = PG_GETARG_FLOAT8(1);
GSERIALIZED *result;
int type = gserialized_get_type(geom);
LWGEOM *in, *out;
bool preserve_collapsed = false;
/* Handle optional argument to preserve collapsed features */
if ( PG_NARGS() > 2 && ! PG_ARGISNULL(2) )
preserve_collapsed = true;
/* Can't simplify points! */
if ( type == POINTTYPE || type == MULTIPOINTTYPE )
PG_RETURN_POINTER(geom);
in = lwgeom_from_gserialized(geom);
out = lwgeom_simplify(in, dist, preserve_collapsed);
if ( ! out ) PG_RETURN_NULL();
/* COMPUTE_BBOX TAINTING */
if ( in->bbox ) lwgeom_add_bbox(out);
result = geometry_serialize(out);
lwgeom_free(out);
PG_FREE_IF_COPY(geom, 0);
PG_RETURN_POINTER(result);
}
Datum LWGEOM_SetEffectiveArea(PG_FUNCTION_ARGS)
{
GSERIALIZED *geom = PG_GETARG_GSERIALIZED_P(0);
GSERIALIZED *result;
int type = gserialized_get_type(geom);
LWGEOM *in;
LWGEOM *out;
double area=0;
int set_area=0;
if ( type == POINTTYPE || type == MULTIPOINTTYPE )
PG_RETURN_POINTER(geom);
if ( (PG_NARGS()>1) && (!PG_ARGISNULL(1)) )
area = PG_GETARG_FLOAT8(1);
if ( (PG_NARGS()>2) && (!PG_ARGISNULL(2)) )
set_area = PG_GETARG_INT32(2);
in = lwgeom_from_gserialized(geom);
out = lwgeom_set_effective_area(in,set_area, area);
if ( ! out ) PG_RETURN_NULL();
/* COMPUTE_BBOX TAINTING */
if ( in->bbox ) lwgeom_add_bbox(out);
result = geometry_serialize(out);
lwgeom_free(out);
PG_FREE_IF_COPY(geom, 0);
PG_RETURN_POINTER(result);
}
Datum LWGEOM_asText(PG_FUNCTION_ARGS)
{
GSERIALIZED *geom;
LWGEOM *lwgeom;
char *wkt;
size_t wkt_size;
text *result;
POSTGIS_DEBUG(2, "Called.");
geom = PG_GETARG_GSERIALIZED_P(0);
lwgeom = lwgeom_from_gserialized(geom);
/* Write to WKT and free the geometry */
wkt = lwgeom_to_wkt(lwgeom, WKT_ISO, DBL_DIG, &wkt_size);
lwgeom_free(lwgeom);
POSTGIS_DEBUGF(3, "WKT size = %u, WKT length = %u", (unsigned int)wkt_size, (unsigned int)strlen(wkt));
/* Write to text and free the WKT */
result = cstring2text(wkt);
pfree(wkt);
/* Return the text */
PG_FREE_IF_COPY(geom, 0);
PG_RETURN_TEXT_P(result);
}
Datum ST_AddMeasure(PG_FUNCTION_ARGS)
{
GSERIALIZED *gin = PG_GETARG_GSERIALIZED_P(0);
GSERIALIZED *gout;
double start_measure = PG_GETARG_FLOAT8(1);
double end_measure = PG_GETARG_FLOAT8(2);
LWGEOM *lwin, *lwout;
int type = gserialized_get_type(gin);
/* Raise an error if input is not a linestring or multilinestring */
if ( type != LINETYPE && type != MULTILINETYPE )
{
lwpgerror("Only LINESTRING and MULTILINESTRING are supported");
PG_RETURN_NULL();
}
lwin = lwgeom_from_gserialized(gin);
if ( type == LINETYPE )
lwout = (LWGEOM*)lwline_measured_from_lwline((LWLINE*)lwin, start_measure, end_measure);
else
lwout = (LWGEOM*)lwmline_measured_from_lwmline((LWMLINE*)lwin, start_measure, end_measure);
lwgeom_free(lwin);
if ( lwout == NULL )
PG_RETURN_NULL();
gout = geometry_serialize(lwout);
lwgeom_free(lwout);
PG_RETURN_POINTER(gout);
}
Datum LWGEOM_length_ellipsoid_linestring(PG_FUNCTION_ARGS)
{
GSERIALIZED *geom = PG_GETARG_GSERIALIZED_P(0);
LWGEOM *lwgeom = lwgeom_from_gserialized(geom);
SPHEROID *sphere = (SPHEROID *) PG_GETARG_POINTER(1);
double length = 0.0;
/* EMPTY things have no length */
if ( lwgeom_is_empty(lwgeom) )
{
lwgeom_free(lwgeom);
PG_RETURN_FLOAT8(0.0);
}
length = lwgeom_length_spheroid(lwgeom, sphere);
lwgeom_free(lwgeom);
PG_FREE_IF_COPY(geom, 0);
/* Something went wrong... */
if ( length < 0.0 )
{
elog(ERROR, "lwgeom_length_spheroid returned length < 0.0");
PG_RETURN_NULL();
}
/* Clean up */
PG_RETURN_FLOAT8(length);
}
Datum ST_CleanGeometry(PG_FUNCTION_ARGS)
{
#if POSTGIS_GEOS_VERSION < 33
elog(ERROR, "You need GEOS-3.3.0 or up for ST_CleanGeometry");
PG_RETURN_NULL();
#else /* POSTGIS_GEOS_VERSION >= 33 */
GSERIALIZED *in, *out;
LWGEOM *lwgeom_in, *lwgeom_out;
in = PG_GETARG_GSERIALIZED_P(0);
lwgeom_in = lwgeom_from_gserialized(in);
/* Short-circuit: empty geometry are the cleanest ! */
#if 0
if ( lwgeom_is_empty(lwgeom_in) )
{
out = geometry_serialize(lwgeom_in);
PG_FREE_IF_COPY(in, 0);
PG_RETURN_POINTER(out);
}
#endif
lwgeom_out = lwgeom_clean(lwgeom_in);
if ( ! lwgeom_out )
{
PG_FREE_IF_COPY(in, 0);
PG_RETURN_NULL();
}
out = geometry_serialize(lwgeom_out);
PG_RETURN_POINTER(out);
#endif /* POSTGIS_GEOS_VERSION >= 33 */
}
Datum ST_LocateBetween(PG_FUNCTION_ARGS)
{
GSERIALIZED *geom_in = PG_GETARG_GSERIALIZED_P(0);
double from = PG_GETARG_FLOAT8(1);
double to = PG_GETARG_FLOAT8(2);
double offset = PG_GETARG_FLOAT8(3);
LWCOLLECTION *geom_out = NULL;
LWGEOM *line_in = NULL;
static char ordinate = 'M'; /* M */
if ( ! gserialized_has_m(geom_in) )
{
elog(ERROR,"This function only accepts geometries that have an M dimension.");
PG_RETURN_NULL();
}
/* This should be a call to ST_LocateAlong! */
if ( to == from )
{
PG_RETURN_DATUM(DirectFunctionCall3(ST_LocateAlong, PG_GETARG_DATUM(0), PG_GETARG_DATUM(1), PG_GETARG_DATUM(3)));
}
line_in = lwgeom_from_gserialized(geom_in);
geom_out = lwgeom_clip_to_ordinate_range(line_in, ordinate, from, to, offset);
lwgeom_free(line_in);
PG_FREE_IF_COPY(geom_in, 0);
if ( ! geom_out )
{
elog(ERROR,"lwline_clip_to_ordinate_range returned null");
PG_RETURN_NULL();
}
PG_RETURN_POINTER(geometry_serialize((LWGEOM*)geom_out));
}
Datum ST_LocateBetweenElevations(PG_FUNCTION_ARGS)
{
GSERIALIZED *geom_in = PG_GETARG_GSERIALIZED_P(0);
double from = PG_GETARG_FLOAT8(1);
double to = PG_GETARG_FLOAT8(2);
LWCOLLECTION *geom_out = NULL;
LWGEOM *line_in = NULL;
static char ordinate = 'Z'; /* Z */
static double offset = 0.0;
if ( ! gserialized_has_z(geom_in) )
{
elog(ERROR,"This function only accepts LINESTRING or MULTILINESTRING with Z dimensions.");
PG_RETURN_NULL();
}
line_in = lwgeom_from_gserialized(geom_in);
geom_out = lwgeom_clip_to_ordinate_range(line_in, ordinate, from, to, offset);
lwgeom_free(line_in);
PG_FREE_IF_COPY(geom_in, 0);
if ( ! geom_out )
{
elog(ERROR,"lwline_clip_to_ordinate_range returned null");
PG_RETURN_NULL();
}
PG_RETURN_POINTER(geometry_serialize((LWGEOM*)geom_out));
}
Datum BOX2D_construct(PG_FUNCTION_ARGS)
{
GSERIALIZED *pgmin = PG_GETARG_GSERIALIZED_P(0);
GSERIALIZED *pgmax = PG_GETARG_GSERIALIZED_P(1);
GBOX *result;
LWPOINT *minpoint, *maxpoint;
double min, max, tmp;
minpoint = (LWPOINT*)lwgeom_from_gserialized(pgmin);
maxpoint = (LWPOINT*)lwgeom_from_gserialized(pgmax);
if ( (minpoint->type != POINTTYPE) || (maxpoint->type != POINTTYPE) )
{
elog(ERROR, "GBOX_construct: arguments must be points");
PG_RETURN_NULL();
}
error_if_srid_mismatch(minpoint->srid, maxpoint->srid);
result = gbox_new(gflags(0, 0, 0));
/* Process X min/max */
min = lwpoint_get_x(minpoint);
max = lwpoint_get_x(maxpoint);
if ( min > max )
{
tmp = min;
min = max;
max = tmp;
}
result->xmin = min;
result->xmax = max;
/* Process Y min/max */
min = lwpoint_get_y(minpoint);
max = lwpoint_get_y(maxpoint);
if ( min > max )
{
tmp = min;
min = max;
max = tmp;
}
result->ymin = min;
result->ymax = max;
PG_RETURN_POINTER(result);
}
Datum LWGEOM_has_arc(PG_FUNCTION_ARGS)
{
GSERIALIZED *geom = PG_GETARG_GSERIALIZED_P(0);
LWGEOM *lwgeom = lwgeom_from_gserialized(geom);
uint32 result = lwgeom_has_arc(lwgeom);
lwgeom_free(lwgeom);
PG_RETURN_BOOL(result == 1);
}
Datum geography_eq(PG_FUNCTION_ARGS)
{
/* Perfect equals test based on hash */
GSERIALIZED *g1 = PG_GETARG_GSERIALIZED_P(0);
GSERIALIZED *g2 = PG_GETARG_GSERIALIZED_P(1);
uint32 h1 = geography_hash(g1);
uint32 h2 = geography_hash(g2);
PG_FREE_IF_COPY(g1,0);
PG_FREE_IF_COPY(g2,0);
if ( h1 == h2 )
PG_RETURN_BOOL(TRUE);
PG_RETURN_BOOL(FALSE);
}
Datum LWGEOM_locate_between_m(PG_FUNCTION_ARGS)
{
GSERIALIZED *gin = PG_GETARG_GSERIALIZED_P(0);
GSERIALIZED *gout;
double start_measure = PG_GETARG_FLOAT8(1);
double end_measure = PG_GETARG_FLOAT8(2);
LWGEOM *lwin, *lwout;
int hasz = gserialized_has_z(gin);
int hasm = gserialized_has_m(gin);
int type;
elog(WARNING,"ST_Locate_Between_Measures and ST_Locate_Along_Measure were deprecated in 2.2.0. Please use ST_LocateAlong and ST_LocateBetween");
if ( end_measure < start_measure )
{
lwpgerror("locate_between_m: 2nd arg must be bigger then 1st arg");
PG_RETURN_NULL();
}
/*
* Return error if input doesn't have a measure
*/
if ( ! hasm )
{
lwpgerror("Geometry argument does not have an 'M' ordinate");
PG_RETURN_NULL();
}
/*
* Raise an error if input is a polygon, a multipolygon
* or a collection
*/
type = gserialized_get_type(gin);
if ( type == POLYGONTYPE || type == MULTIPOLYGONTYPE || type == COLLECTIONTYPE )
{
lwpgerror("Areal or Collection types are not supported");
PG_RETURN_NULL();
}
lwin = lwgeom_from_gserialized(gin);
lwout = lwgeom_locate_between_m(lwin,
start_measure, end_measure);
lwgeom_free(lwin);
if ( lwout == NULL )
{
lwout = (LWGEOM *)lwcollection_construct_empty(COLLECTIONTYPE,
gserialized_get_srid(gin), hasz, hasm);
}
gout = geometry_serialize(lwout);
lwgeom_free(lwout);
PG_RETURN_POINTER(gout);
}
Datum LWGEOM_length2d_ellipsoid(PG_FUNCTION_ARGS)
{
GSERIALIZED *geom = PG_GETARG_GSERIALIZED_P(0);
SPHEROID *sphere = (SPHEROID *) PG_GETARG_POINTER(1);
LWGEOM *lwgeom = lwgeom_from_gserialized(geom);
double dist = lwgeom_length_spheroid(lwgeom, sphere);
lwgeom_free(lwgeom);
PG_FREE_IF_COPY(geom, 0);
PG_RETURN_FLOAT8(dist);
}
Datum LWGEOM_isclosed(PG_FUNCTION_ARGS)
{
GSERIALIZED *geom = PG_GETARG_GSERIALIZED_P(0);
LWGEOM *lwgeom = lwgeom_from_gserialized(geom);
int closed = lwgeom_is_closed(lwgeom);
lwgeom_free(lwgeom);
PG_FREE_IF_COPY(geom, 0);
PG_RETURN_BOOL(closed);
}
Datum geometry_enforce_typmod(PG_FUNCTION_ARGS)
{
GSERIALIZED *arg = PG_GETARG_GSERIALIZED_P(0);
int32 typmod = PG_GETARG_INT32(1);
/* We don't need to have different behavior based on explicitness. */
/* bool isExplicit = PG_GETARG_BOOL(2); */
/* Check if geometry typmod is consistent with the supplied one. */
arg = postgis_valid_typmod(arg, typmod);
PG_RETURN_POINTER(arg);
}
