-/**********************************************************************
- *
- * PostGIS - Spatial Types for PostgreSQL
- * http://postgis.refractions.net
- * Copyright 2001-2006 Refractions Research Inc.
- * Copyright 2010 Nicklas Avén
- *
- * This is free software; you can redistribute and/or modify it under
- * the terms of the GNU General Public Licence. See the COPYING file.
- *
- **********************************************************************/
-
-#include <string.h>
-#include <stdlib.h>
-
-#include "measures.h"
-#include "lwgeom_log.h"
-
-
-/*------------------------------------------------------------------------------------------------------------
-Initializing functions
-The functions starting the distance-calculation processses
---------------------------------------------------------------------------------------------------------------*/
-
-/**
-Function initializing shortestline and longestline calculations.
-*/
-LWGEOM *
-lw_dist2d_distanceline(LWGEOM *lw1, LWGEOM *lw2,int srid,int mode)
-{
- double x1,x2,y1,y2;
-
- double initdistance = ( mode == DIST_MIN ? MAXFLOAT : -1.0);
- DISTPTS thedl;
- LWPOINT *lwpoints[2];
- LWGEOM *result;
-
- thedl.mode = mode;
- thedl.distance = initdistance;
- thedl.tolerance = 0.0;
-
- LWDEBUG(2, "lw_dist2d_distanceline is called");
-
- if (!lw_dist2d_comp( lw1,lw2,&thedl))
- {
- /*should never get here. all cases ought to be error handled earlier*/
- lwerror("Some unspecified error.");
- result = (LWGEOM *)lwcollection_construct_empty(COLLECTIONTYPE, srid, 0, 0);
- }
-
- /*if thedl.distance is unchanged there where only empty geometries input*/
- if (thedl.distance == initdistance)
- {
- LWDEBUG(3, "didn't find geometries to measure between, returning null");
- result = (LWGEOM *)lwcollection_construct_empty(COLLECTIONTYPE, srid, 0, 0);
- }
- else
- {
- x1=thedl.p1.x;
- y1=thedl.p1.y;
- x2=thedl.p2.x;
- y2=thedl.p2.y;
-
- lwpoints[0] = lwpoint_make2d(srid, x1, y1);
- lwpoints[1] = lwpoint_make2d(srid, x2, y2);
-
- result = (LWGEOM *)lwline_from_ptarray(srid, 2, lwpoints);
- }
- return result;
-}
-
-/**
-Function initializing closestpoint calculations.
-*/
-LWGEOM *
-lw_dist2d_distancepoint(LWGEOM *lw1, LWGEOM *lw2,int srid,int mode)
-{
- double x,y;
- DISTPTS thedl;
- double initdistance = MAXFLOAT;
- LWGEOM *result;
-
- thedl.mode = mode;
- thedl.distance= initdistance;
- thedl.tolerance = 0;
-
- LWDEBUG(2, "lw_dist2d_distancepoint is called");
-
- if (!lw_dist2d_comp( lw1,lw2,&thedl))
- {
- /*should never get here. all cases ought to be error handled earlier*/
- lwerror("Some unspecified error.");
- result = (LWGEOM *)lwcollection_construct_empty(COLLECTIONTYPE, srid, 0, 0);
- }
- if (thedl.distance == initdistance)
- {
- LWDEBUG(3, "didn't find geometries to measure between, returning null");
- result = (LWGEOM *)lwcollection_construct_empty(COLLECTIONTYPE, srid, 0, 0);
- }
- else
- {
- x=thedl.p1.x;
- y=thedl.p1.y;
- result = (LWGEOM *)lwpoint_make2d(srid, x, y);
- }
- return result;
-}
-
-
-/**
-Function initialazing max distance calculation
-*/
-double
-lwgeom_maxdistance2d(LWGEOM *lw1, LWGEOM *lw2)
-{
- LWDEBUG(2, "lwgeom_maxdistance2d is called");
-
- return lwgeom_maxdistance2d_tolerance( lw1, lw2, 0.0 );
-}
-
-/**
-Function handling max distance calculations and dfyllywithin calculations.
-The difference is just the tolerance.
-*/
-double
-lwgeom_maxdistance2d_tolerance(LWGEOM *lw1, LWGEOM *lw2, double tolerance)
-{
- /*double thedist;*/
- DISTPTS thedl;
- LWDEBUG(2, "lwgeom_maxdistance2d_tolerance is called");
- thedl.mode = DIST_MAX;
- thedl.distance= -1;
- thedl.tolerance = tolerance;
- if (lw_dist2d_comp( lw1,lw2,&thedl))
- {
- return thedl.distance;
- }
- /*should never get here. all cases ought to be error handled earlier*/
- lwerror("Some unspecified error.");
- return -1;
-}
-
-/**
- Function initialazing min distance calculation
-*/
-double
-lwgeom_mindistance2d(LWGEOM *lw1, LWGEOM *lw2)
-{
- LWDEBUG(2, "lwgeom_mindistance2d is called");
- return lwgeom_mindistance2d_tolerance( lw1, lw2, 0.0 );
-}
-
-/**
- Function handling min distance calculations and dwithin calculations.
- The difference is just the tolerance.
-*/
-double
-lwgeom_mindistance2d_tolerance(LWGEOM *lw1, LWGEOM *lw2, double tolerance)
-{
- DISTPTS thedl;
- LWDEBUG(2, "lwgeom_mindistance2d_tolerance is called");
- thedl.mode = DIST_MIN;
- thedl.distance= MAXFLOAT;
- thedl.tolerance = tolerance;
- if (lw_dist2d_comp( lw1,lw2,&thedl))
- {
- return thedl.distance;
- }
- /*should never get here. all cases ought to be error handled earlier*/
- lwerror("Some unspecified error.");
- return MAXFLOAT;
-}
-
-
-/*------------------------------------------------------------------------------------------------------------
-End of Initializing functions
---------------------------------------------------------------------------------------------------------------*/
-
-/*------------------------------------------------------------------------------------------------------------
-Preprocessing functions
-Functions preparing geometries for distance-calculations
---------------------------------------------------------------------------------------------------------------*/
-
-/**
- This function just deserializes geometries
- Bboxes is not checked here since it is the subgeometries
- bboxes we will use anyway.
-*/
-int
-lw_dist2d_comp(LWGEOM *lw1, LWGEOM *lw2, DISTPTS *dl)
-{
- LWDEBUG(2, "lw_dist2d_comp is called");
-
- return lw_dist2d_recursive(lw1, lw2, dl);
-}
-
-/**
-This is a recursive function delivering every possible combinatin of subgeometries
-*/
-int lw_dist2d_recursive(const LWGEOM *lwg1, const LWGEOM *lwg2, DISTPTS *dl)
-{
- int i, j;
- int n1=1;
- int n2=1;
- LWGEOM *g1 = NULL;
- LWGEOM *g2 = NULL;
- LWCOLLECTION *c1 = NULL;
- LWCOLLECTION *c2 = NULL;
-
- LWDEBUGF(2, "lw_dist2d_comp is called with type1=%d, type2=%d", lwg1->type, lwg2->type);
-
- if (lwgeom_is_collection(lwg1))
- {
- LWDEBUG(3, "First geometry is collection");
- c1 = lwgeom_as_lwcollection(lwg1);
- n1 = c1->ngeoms;
- }
- if (lwgeom_is_collection(lwg2))
- {
- LWDEBUG(3, "Second geometry is collection");
- c2 = lwgeom_as_lwcollection(lwg2);
- n2 = c2->ngeoms;
- }
-
- for ( i = 0; i < n1; i++ )
- {
-
- if (lwgeom_is_collection(lwg1))
- {
- g1 = c1->geoms[i];
- }
- else
- {
- g1 = (LWGEOM*)lwg1;
- }
-
- if (lwgeom_is_empty(g1)) return LW_TRUE;
-
- if (lwgeom_is_collection(g1))
- {
- LWDEBUG(3, "Found collection inside first geometry collection, recursing");
- if (!lw_dist2d_recursive(g1, lwg2, dl)) return LW_FALSE;
- continue;
- }
- for ( j = 0; j < n2; j++ )
- {
- if (lwgeom_is_collection(lwg2))
- {
- g2 = c2->geoms[j];
- }
- else
- {
- g2 = (LWGEOM*)lwg2;
- }
- if (lwgeom_is_collection(g2))
- {
- LWDEBUG(3, "Found collection inside second geometry collection, recursing");
- if (!lw_dist2d_recursive(g1, g2, dl)) return LW_FALSE;
- continue;
- }
-
- if ( ! g1->bbox )
- {
- lwgeom_add_bbox(g1);
- }
- if ( ! g2->bbox )
- {
- lwgeom_add_bbox(g2);
- }
-
- /*If one of geometries is empty, return. True here only means continue searching. False would have stoped the process*/
- if (lwgeom_is_empty(g1)||lwgeom_is_empty(g2)) return LW_TRUE;
-
- if ((dl->mode==DIST_MAX)||(g1->type==POINTTYPE) ||(g2->type==POINTTYPE)||lw_dist2d_check_overlap(g1, g2))
- {
- if (!lw_dist2d_distribute_bruteforce(g1, g2, dl)) return LW_FALSE;
- if (dl->distance<=dl->tolerance && dl->mode == DIST_MIN) return LW_TRUE; /*just a check if the answer is already given*/
- }
- else
- {
- if (!lw_dist2d_distribute_fast(g1, g2, dl)) return LW_FALSE;
- }
- }
- }
- return LW_TRUE;
-}
-
-
-
-/**
-
-This function distributes the "old-type" brut-force tasks depending on type
-*/
-int
-lw_dist2d_distribute_bruteforce(LWGEOM *lwg1, LWGEOM *lwg2, DISTPTS *dl)
-{
-
- int t1 = lwg1->type;
- int t2 = lwg2->type;
-
- LWDEBUGF(2, "lw_dist2d_distribute_bruteforce is called with typ1=%d, type2=%d", lwg1->type, lwg2->type);
-
- if ( t1 == POINTTYPE )
- {
- if ( t2 == POINTTYPE )
- {
- dl->twisted=1;
- return lw_dist2d_point_point((LWPOINT *)lwg1, (LWPOINT *)lwg2, dl);
- }
- else if ( t2 == LINETYPE )
- {
- dl->twisted=1;
- return lw_dist2d_point_line((LWPOINT *)lwg1, (LWLINE *)lwg2, dl);
- }
- else if ( t2 == POLYGONTYPE )
- {
- dl->twisted=1;
- return lw_dist2d_point_poly((LWPOINT *)lwg1, (LWPOLY *)lwg2,dl);
- }
- else
- {
- lwerror("Unsupported geometry type: %s", lwtype_name(t2));
- return LW_FALSE;
- }
- }
- else if ( t1 == LINETYPE )
- {
- if ( t2 == POINTTYPE )
- {
- dl->twisted=(-1);
- return lw_dist2d_point_line((LWPOINT *)lwg2,(LWLINE *)lwg1,dl);
- }
- else if ( t2 == LINETYPE )
- {
- dl->twisted=1;
- /*lwnotice("start line");*/
- return lw_dist2d_line_line((LWLINE *)lwg1,(LWLINE *)lwg2,dl);
- }
- else if ( t2 == POLYGONTYPE )
- {
- dl->twisted=1;
- return lw_dist2d_line_poly((LWLINE *)lwg1,(LWPOLY *)lwg2,dl);
- }
- else
- {
- lwerror("Unsupported geometry type: %s", lwtype_name(t2));
- return LW_FALSE;
- }
- }
- else if ( t1 == POLYGONTYPE )
- {
- if ( t2 == POLYGONTYPE )
- {
- dl->twisted=(1);
- return lw_dist2d_poly_poly((LWPOLY *)lwg1,(LWPOLY *)lwg2,dl);
- }
- else if ( t2 == POINTTYPE )
- {
- dl->twisted=(-1);
- return lw_dist2d_point_poly((LWPOINT *)lwg2, (LWPOLY *)lwg1, dl);
- }
- else if ( t2 == LINETYPE )
- {
- dl->twisted=(-1);
- return lw_dist2d_line_poly((LWLINE *)lwg2,(LWPOLY *)lwg1,dl);
- }
- else
- {
- lwerror("Unsupported geometry type: %s", lwtype_name(t2));
- return LW_FALSE;
- }
- }
- else
- {
- lwerror("Unsupported geometry type: %s", lwtype_name(t1));
- return LW_FALSE;
- }
- /*You shouldn't being able to get here*/
- lwerror("unspecified error in function lw_dist2d_distribute_bruteforce");
- return LW_FALSE;
-}
-
-/**
-
-We have to check for overlapping bboxes
-*/
-int
-lw_dist2d_check_overlap(LWGEOM *lwg1,LWGEOM *lwg2)
-{
- LWDEBUG(2, "lw_dist2d_check_overlap is called");
- if ( ! lwg1->bbox )
- lwgeom_calculate_gbox(lwg1, lwg1->bbox);
- if ( ! lwg2->bbox )
- lwgeom_calculate_gbox(lwg2, lwg2->bbox);
-
- /*Check if the geometries intersect.
- */
- if ((lwg1->bbox->xmax<lwg2->bbox->xmin||lwg1->bbox->xmin>lwg2->bbox->xmax||lwg1->bbox->ymax<lwg2->bbox->ymin||lwg1->bbox->ymin>lwg2->bbox->ymax))
- {
- LWDEBUG(3, "geometries bboxes did not overlap");
- return LW_FALSE;
- }
- LWDEBUG(3, "geometries bboxes overlap");
- return LW_TRUE;
-}
-
-/**
-
-Here the geometries are distributed for the new faster distance-calculations
-*/
-int
-lw_dist2d_distribute_fast(LWGEOM *lwg1, LWGEOM *lwg2, DISTPTS *dl)
-{
- POINTARRAY *pa1, *pa2;
- int type1 = lwg1->type;
- int type2 = lwg2->type;
-
- LWDEBUGF(2, "lw_dist2d_distribute_fast is called with typ1=%d, type2=%d", lwg1->type, lwg2->type);
-
- switch (type1)
- {
- case LINETYPE:
- pa1 = ((LWLINE *)lwg1)->points;
- break;
- case POLYGONTYPE:
- pa1 = ((LWPOLY *)lwg1)->rings[0];
- break;
- default:
- lwerror("Unsupported geometry1 type: %s", lwtype_name(type1));
- return LW_FALSE;
- }
- switch (type2)
- {
- case LINETYPE:
- pa2 = ((LWLINE *)lwg2)->points;
- break;
- case POLYGONTYPE:
- pa2 = ((LWPOLY *)lwg2)->rings[0];
- break;
- default:
- lwerror("Unsupported geometry2 type: %s", lwtype_name(type1));
- return LW_FALSE;
- }
- dl->twisted=1;
- return lw_dist2d_fast_ptarray_ptarray(pa1, pa2, dl, lwg1->bbox, lwg2->bbox);
-}
-
-/*------------------------------------------------------------------------------------------------------------
-End of Preprocessing functions
---------------------------------------------------------------------------------------------------------------*/
-
-
-/*------------------------------------------------------------------------------------------------------------
-Brute force functions
-The old way of calculating distances, now used for:
-1) distances to points (because there shouldn't be anything to gain by the new way of doing it)
-2) distances when subgeometries geometries bboxes overlaps
---------------------------------------------------------------------------------------------------------------*/
-
-/**
-
-point to point calculation
-*/
-int
-lw_dist2d_point_point(LWPOINT *point1, LWPOINT *point2, DISTPTS *dl)
-{
- POINT2D p1;
- POINT2D p2;
-
- getPoint2d_p(point1->point, 0, &p1);
- getPoint2d_p(point2->point, 0, &p2);
-
- return lw_dist2d_pt_pt(&p1, &p2,dl);
-}
-/**
-
-point to line calculation
-*/
-int
-lw_dist2d_point_line(LWPOINT *point, LWLINE *line, DISTPTS *dl)
-{
- POINT2D p;
- POINTARRAY *pa = line->points;
- LWDEBUG(2, "lw_dist2d_point_line is called");
- getPoint2d_p(point->point, 0, &p);
- return lw_dist2d_pt_ptarray(&p, pa, dl);
-}
-/**
- * 1. see if pt in outer boundary. if no, then treat the outer ring like a line
- * 2. if in the boundary, test to see if its in a hole.
- * if so, then return dist to hole, else return 0 (point in polygon)
- */
-int
-lw_dist2d_point_poly(LWPOINT *point, LWPOLY *poly, DISTPTS *dl)
-{
- POINT2D p;
- int i;
-
- LWDEBUG(2, "lw_dist2d_point_poly called");
-
- getPoint2d_p(point->point, 0, &p);
-
- if (dl->mode == DIST_MAX)
- {
- LWDEBUG(3, "looking for maxdistance");
- return lw_dist2d_pt_ptarray(&p, poly->rings[0], dl);
- }
- /* Return distance to outer ring if not inside it */
- if ( ! pt_in_ring_2d(&p, poly->rings[0]) )
- {
- LWDEBUG(3, "first point not inside outer-ring");
- return lw_dist2d_pt_ptarray(&p, poly->rings[0], dl);
- }
-
- /*
- * Inside the outer ring.
- * Scan though each of the inner rings looking to
- * see if its inside. If not, distance==0.
- * Otherwise, distance = pt to ring distance
- */
- for (i=1; i<poly->nrings; i++)
- {
- /* Inside a hole. Distance = pt -> ring */
- if ( pt_in_ring_2d(&p, poly->rings[i]) )
- {
- LWDEBUG(3, " inside an hole");
- return lw_dist2d_pt_ptarray(&p, poly->rings[i], dl);
- }
- }
-
- LWDEBUG(3, " inside the polygon");
- if (dl->mode == DIST_MIN)
- {
- dl->distance=0.0;
- dl->p1.x=p.x;
- dl->p1.y=p.y;
- dl->p2.x=p.x;
- dl->p2.y=p.y;
- }
- return LW_TRUE; /* Is inside the polygon */
-}
-/**
-
-line to line calculation
-*/
-int
-lw_dist2d_line_line(LWLINE *line1, LWLINE *line2, DISTPTS *dl)
-{
- POINTARRAY *pa1 = line1->points;
- POINTARRAY *pa2 = line2->points;
- LWDEBUG(2, "lw_dist2d_line_line is called");
- return lw_dist2d_ptarray_ptarray(pa1, pa2, dl);
-}
-/**
-
-line to polygon calculation
-*/
-int
-lw_dist2d_line_poly(LWLINE *line, LWPOLY *poly, DISTPTS *dl)
-{
- LWDEBUG(2, "lw_dist2d_line_poly is called");
- return lw_dist2d_ptarray_poly(line->points, poly, dl);
-}
-
-/**
-
-Function handling polygon to polygon calculation
-1 if we are looking for maxdistance, just check the outer rings.
-2 check if poly1 has first point outside poly2 and vice versa, if so, just check outer rings
-3 check if first point of poly2 is in a hole of poly1. If so check outer ring of poly2 against that hole of poly1
-4 check if first point of poly1 is in a hole of poly2. If so check outer ring of poly1 against that hole of poly2
-5 If we have come all the way here we know that the first point of one of them is inside the other ones outer ring and not in holes so we check wich one is inside.
- */
-int
-lw_dist2d_poly_poly(LWPOLY *poly1, LWPOLY *poly2, DISTPTS *dl)
-{
-
- POINT2D pt;
- int i;
-
- LWDEBUG(2, "lw_dist2d_poly_poly called");
-
- /*1 if we are looking for maxdistance, just check the outer rings.*/
- if (dl->mode == DIST_MAX)
- {
- return lw_dist2d_ptarray_ptarray(poly1->rings[0], poly2->rings[0],dl);
- }
-
-
- /* 2 check if poly1 has first point outside poly2 and vice versa, if so, just check outer rings
- here it would be possible to handle the information about wich one is inside wich one and only search for the smaller ones in the bigger ones holes.*/
- getPoint2d_p(poly1->rings[0], 0, &pt);
- if ( !pt_in_ring_2d(&pt, poly2->rings[0]))
- {
- getPoint2d_p(poly2->rings[0], 0, &pt);
- if (!pt_in_ring_2d(&pt, poly1->rings[0]))
- {
- return lw_dist2d_ptarray_ptarray(poly1->rings[0], poly2->rings[0],dl);
- }
- }
-
- /*3 check if first point of poly2 is in a hole of poly1. If so check outer ring of poly2 against that hole of poly1*/
- getPoint2d_p(poly2->rings[0], 0, &pt);
- for (i=1; i<poly1->nrings; i++)
- {
- /* Inside a hole */
- if ( pt_in_ring_2d(&pt, poly1->rings[i]) )
- {
- return lw_dist2d_ptarray_ptarray(poly1->rings[i], poly2->rings[0],dl);
- }
- }
-
- /*4 check if first point of poly1 is in a hole of poly2. If so check outer ring of poly1 against that hole of poly2*/
- getPoint2d_p(poly1->rings[0], 0, &pt);
- for (i=1; i<poly2->nrings; i++)
- {
- /* Inside a hole */
- if ( pt_in_ring_2d(&pt, poly2->rings[i]) )
- {
- return lw_dist2d_ptarray_ptarray(poly1->rings[0], poly2->rings[i],dl);
- }
- }
-
-
- /*5 If we have come all the way here we know that the first point of one of them is inside the other ones outer ring and not in holes so we check wich one is inside.*/
- getPoint2d_p(poly1->rings[0], 0, &pt);
- if ( pt_in_ring_2d(&pt, poly2->rings[0]))
- {
- dl->distance=0.0;
- dl->p1.x=pt.x;
- dl->p1.y=pt.y;
- dl->p2.x=pt.x;
- dl->p2.y=pt.y;
- return LW_TRUE;
- }
-
- getPoint2d_p(poly2->rings[0], 0, &pt);
- if (pt_in_ring_2d(&pt, poly1->rings[0]))
- {
- dl->distance=0.0;
- dl->p1.x=pt.x;
- dl->p1.y=pt.y;
- dl->p2.x=pt.x;
- dl->p2.y=pt.y;
- return LW_TRUE;
- }
-
-
- lwerror("Unspecified error in function lw_dist2d_poly_poly");
- return LW_FALSE;
-}
-
-/**
-
- * search all the segments of pointarray to see which one is closest to p1
- * Returns minimum distance between point and pointarray
- */
-int
-lw_dist2d_pt_ptarray(POINT2D *p, POINTARRAY *pa,DISTPTS *dl)
-{
- int t;
- POINT2D start, end;
- int twist = dl->twisted;
-
- LWDEBUG(2, "lw_dist2d_pt_ptarray is called");
-
- getPoint2d_p(pa, 0, &start);
-
- for (t=1; t<pa->npoints; t++)
- {
- dl->twisted=twist;
- getPoint2d_p(pa, t, &end);
- if (!lw_dist2d_pt_seg(p, &start, &end,dl)) return LW_FALSE;
-
- if (dl->distance<=dl->tolerance && dl->mode == DIST_MIN) return LW_TRUE; /*just a check if the answer is already given*/
- start = end;
- }
-
- return LW_TRUE;
-}
-
-/**
- * Brute force.
- * Test line-ring distance against each ring.
- * If there's an intersection (distance==0) then return 0 (crosses boundary).
- * Otherwise, test to see if any point is inside outer rings of polygon,
- * but not in inner rings.
- * If so, return 0 (line inside polygon),
- * otherwise return min distance to a ring (could be outside
- * polygon or inside a hole)
- */
-
-int
-lw_dist2d_ptarray_poly(POINTARRAY *pa, LWPOLY *poly, DISTPTS *dl)
-{
- POINT2D pt;
- int i;
-
- LWDEBUGF(2, "lw_dist2d_ptarray_poly called (%d rings)", poly->nrings);
-
- getPoint2d_p(pa, 0, &pt);
- if ( !pt_in_ring_2d(&pt, poly->rings[0]))
- {
- return lw_dist2d_ptarray_ptarray(pa,poly->rings[0],dl);
- }
-
- for (i=1; i<poly->nrings; i++)
- {
- if (!lw_dist2d_ptarray_ptarray(pa, poly->rings[i], dl)) return LW_FALSE;
-
- LWDEBUGF(3, " distance from ring %d: %f, mindist: %f",
- i, dl->distance, dl->tolerance);
- if (dl->distance<=dl->tolerance && dl->mode == DIST_MIN) return LW_TRUE; /*just a check if the answer is already given*/
- }
-
- /*
- * No intersection, have to check if a point is
- * inside polygon
- */
- getPoint2d_p(pa, 0, &pt);
-
- /*
- * Outside outer ring, so min distance to a ring
- * is the actual min distance
-
- if ( ! pt_in_ring_2d(&pt, poly->rings[0]) )
- {
- return ;
- } */
-
- /*
- * Its in the outer ring.
- * Have to check if its inside a hole
- */
- for (i=1; i<poly->nrings; i++)
- {
- if ( pt_in_ring_2d(&pt, poly->rings[i]) )
- {
- /*
- * Its inside a hole, then the actual
- * distance is the min ring distance
- */
- return LW_TRUE;
- }
- }
- if (dl->mode == DIST_MIN)
- {
- dl->distance=0.0;
- dl->p1.x=pt.x;
- dl->p1.y=pt.y;
- dl->p2.x=pt.x;
- dl->p2.y=pt.y;
- }
- return LW_TRUE; /* Not in hole, so inside polygon */
-}
-
-
-
-/**
-
-test each segment of l1 against each segment of l2.
-*/
-int
-lw_dist2d_ptarray_ptarray(POINTARRAY *l1, POINTARRAY *l2,DISTPTS *dl)
-{
- int t,u;
- POINT2D start, end;
- POINT2D start2, end2;
- int twist = dl->twisted;
-
- LWDEBUGF(2, "lw_dist2d_ptarray_ptarray called (points: %d-%d)",l1->npoints, l2->npoints);
-
- if (dl->mode == DIST_MAX)/*If we are searching for maxdistance we go straight to point-point calculation since the maxdistance have to be between two vertexes*/
- {
- for (t=0; t<l1->npoints; t++) /*for each segment in L1 */
- {
- getPoint2d_p(l1, t, &start);
- for (u=0; u<l2->npoints; u++) /*for each segment in L2 */
- {
- getPoint2d_p(l2, u, &start2);
- lw_dist2d_pt_pt(&start,&start2,dl);
- LWDEBUGF(4, "maxdist_ptarray_ptarray; seg %i * seg %i, dist = %g\n",t,u,dl->distance);
- LWDEBUGF(3, " seg%d-seg%d dist: %f, mindist: %f",
- t, u, dl->distance, dl->tolerance);
- }
- }
- }
- else
- {
- getPoint2d_p(l1, 0, &start);
- for (t=1; t<l1->npoints; t++) /*for each segment in L1 */
- {
- getPoint2d_p(l1, t, &end);
- getPoint2d_p(l2, 0, &start2);
- for (u=1; u<l2->npoints; u++) /*for each segment in L2 */
- {
- getPoint2d_p(l2, u, &end2);
- dl->twisted=twist;
- lw_dist2d_seg_seg(&start, &end, &start2, &end2,dl);
- LWDEBUGF(4, "mindist_ptarray_ptarray; seg %i * seg %i, dist = %g\n",t,u,dl->distance);
- LWDEBUGF(3, " seg%d-seg%d dist: %f, mindist: %f",
- t, u, dl->distance, dl->tolerance);
- if (dl->distance<=dl->tolerance && dl->mode == DIST_MIN) return LW_TRUE; /*just a check if the answer is already given*/
- start2 = end2;
- }
- start = end;
- }
- }
- return LW_TRUE;
-}
-
-/**
-
-Finds the shortest distance between two segments.
-This function is changed so it is not doing any comparasion of distance
-but just sending every possible combination further to lw_dist2d_pt_seg
-*/
-int
-lw_dist2d_seg_seg(POINT2D *A, POINT2D *B, POINT2D *C, POINT2D *D, DISTPTS *dl)
-{
- double s_top, s_bot,s;
- double r_top, r_bot,r;
-
- LWDEBUGF(2, "lw_dist2d_seg_seg [%g,%g]->[%g,%g] by [%g,%g]->[%g,%g]",
- A->x,A->y,B->x,B->y, C->x,C->y, D->x, D->y);
-
- /*A and B are the same point */
- if ( ( A->x == B->x) && (A->y == B->y) )
- {
- return lw_dist2d_pt_seg(A,C,D,dl);
- }
- /*U and V are the same point */
-
- if ( ( C->x == D->x) && (C->y == D->y) )
- {
- dl->twisted= ((dl->twisted) * (-1));
- return lw_dist2d_pt_seg(D,A,B,dl);
- }
- /* AB and CD are line segments */
- /* from comp.graphics.algo
-
- Solving the above for r and s yields
- (Ay-Cy)(Dx-Cx)-(Ax-Cx)(Dy-Cy)
- r = ----------------------------- (eqn 1)
- (Bx-Ax)(Dy-Cy)-(By-Ay)(Dx-Cx)
-
- (Ay-Cy)(Bx-Ax)-(Ax-Cx)(By-Ay)
- s = ----------------------------- (eqn 2)
- (Bx-Ax)(Dy-Cy)-(By-Ay)(Dx-Cx)
- Let P be the position vector of the intersection point, then
- P=A+r(B-A) or
- Px=Ax+r(Bx-Ax)
- Py=Ay+r(By-Ay)
- By examining the values of r & s, you can also determine some other limiting conditions:
- If 0<=r<=1 & 0<=s<=1, intersection exists
- r<0 or r>1 or s<0 or s>1 line segments do not intersect
- If the denominator in eqn 1 is zero, AB & CD are parallel
- If the numerator in eqn 1 is also zero, AB & CD are collinear.
-
- */
- r_top = (A->y-C->y)*(D->x-C->x) - (A->x-C->x)*(D->y-C->y) ;
- r_bot = (B->x-A->x)*(D->y-C->y) - (B->y-A->y)*(D->x-C->x) ;
-
- s_top = (A->y-C->y)*(B->x-A->x) - (A->x-C->x)*(B->y-A->y);
- s_bot = (B->x-A->x)*(D->y-C->y) - (B->y-A->y)*(D->x-C->x);
-
- if ( (r_bot==0) || (s_bot == 0) )
- {
- if ((lw_dist2d_pt_seg(A,C,D,dl)) && (lw_dist2d_pt_seg(B,C,D,dl)))
- {
- dl->twisted= ((dl->twisted) * (-1)); /*here we change the order of inputted geometrys and that we notice by changing sign on dl->twisted*/
- return ((lw_dist2d_pt_seg(C,A,B,dl)) && (lw_dist2d_pt_seg(D,A,B,dl))); /*if all is successful we return true*/
- }
- else
- {
- return LW_FALSE; /* if any of the calls to lw_dist2d_pt_seg goes wrong we return false*/
- }
- }
-
- s = s_top/s_bot;
- r= r_top/r_bot;
-
- if (((r<0) || (r>1) || (s<0) || (s>1)) || (dl->mode == DIST_MAX))
- {
- if ((lw_dist2d_pt_seg(A,C,D,dl)) && (lw_dist2d_pt_seg(B,C,D,dl)))
- {
- dl->twisted= ((dl->twisted) * (-1)); /*here we change the order of inputted geometrys and that we notice by changing sign on dl->twisted*/
- return ((lw_dist2d_pt_seg(C,A,B,dl)) && (lw_dist2d_pt_seg(D,A,B,dl))); /*if all is successful we return true*/
- }
- else
- {
- return LW_FALSE; /* if any of the calls to lw_dist2d_pt_seg goes wrong we return false*/
- }
- }
- else
- {
- if (dl->mode == DIST_MIN) /*If there is intersection we identify the intersection point and return it but only if we are looking for mindistance*/
- {
- POINT2D theP;
-
- if (((A->x==C->x)&&(A->y==C->y))||((A->x==D->x)&&(A->y==D->y)))
- {
- theP.x = A->x;
- theP.y = A->y;
- }
- else if (((B->x==C->x)&&(B->y==C->y))||((B->x==D->x)&&(B->y==D->y)))
- {
- theP.x = B->x;
- theP.y = B->y;
- }
- else
- {
- theP.x = A->x+r*(B->x-A->x);
- theP.y = A->y+r*(B->y-A->y);
- }
- dl->distance=0.0;
- dl->p1=theP;
- dl->p2=theP;
- }
- return LW_TRUE;
-
- }
- lwerror("unspecified error in function lw_dist2d_seg_seg");
- return LW_FALSE; /*If we have come here something is wrong*/
-}
-
-
-/*------------------------------------------------------------------------------------------------------------
-End of Brute force functions
---------------------------------------------------------------------------------------------------------------*/
-
-
-/*------------------------------------------------------------------------------------------------------------
-New faster distance calculations
---------------------------------------------------------------------------------------------------------------*/
-
-/**
-
-The new faster calculation comparing pointarray to another pointarray
-the arrays can come from both polygons and linestrings.
-The naming is not good but comes from that it compares a
-chosen selection of the points not all of them
-*/
-int
-lw_dist2d_fast_ptarray_ptarray(POINTARRAY *l1, POINTARRAY *l2,DISTPTS *dl, GBOX *box1, GBOX *box2)
-{
- /*here we define two lists to hold our calculated "z"-values and the order number in the geometry*/
-
- double k, thevalue;
- float deltaX, deltaY, c1m, c2m;
- POINT2D theP,c1, c2;
- float min1X, max1X, max1Y, min1Y,min2X, max2X, max2Y, min2Y;
- int t;
- int n1 = l1->npoints;
- int n2 = l2->npoints;
-
- LISTSTRUCT *list1, *list2;
- list1 = (LISTSTRUCT*)lwalloc(sizeof(LISTSTRUCT)*n1);
- list2 = (LISTSTRUCT*)lwalloc(sizeof(LISTSTRUCT)*n2);
-
- LWDEBUG(2, "lw_dist2d_fast_ptarray_ptarray is called");
-
- max1X = box1->xmax;
- min1X = box1->xmin;
- max1Y = box1->ymax;
- min1Y = box1->ymin;
- max2X = box2->xmax;
- min2X = box2->xmin;
- max2Y = box2->ymax;
- min2Y = box2->ymin;
- /*we want the center of the bboxes, and calculate the slope between the centerpoints*/
- c1.x = min1X + (max1X-min1X)/2;
- c1.y = min1Y + (max1Y-min1Y)/2;
- c2.x = min2X + (max2X-min2X)/2;
- c2.y = min2Y + (max2Y-min2Y)/2;
-
- deltaX=(c2.x-c1.x);
- deltaY=(c2.y-c1.y);
-
-
- /*Here we calculate where the line perpendicular to the center-center line crosses the axes for each vertex
- if the center-center line is vertical the perpendicular line will be horizontal and we find it's crossing the Y-axes with z = y-kx */
- if ((deltaX*deltaX)<(deltaY*deltaY)) /*North or South*/
- {
- k = -deltaX/deltaY;
- for (t=0; t<n1; t++) /*for each segment in L1 */
- {
- getPoint2d_p(l1, t, &theP);
- thevalue = theP.y-(k*theP.x);
- list1[t].themeasure=thevalue;
- list1[t].pnr=t;
-
- }
- for (t=0; t<n2; t++) /*for each segment in L2*/
- {
- getPoint2d_p(l2, t, &theP);
- thevalue = theP.y-(k*theP.x);
- list2[t].themeasure=thevalue;
- list2[t].pnr=t;
-
- }
- c1m = c1.y-(k*c1.x);
- c2m = c2.y-(k*c2.x);
- }
-
-
- /*if the center-center line is horizontal the perpendicular line will be vertical. To eliminate problems with deviding by zero we are here mirroring the coordinate-system
- and we find it's crossing the X-axes with z = x-(1/k)y */
- else /*West or East*/
- {
- k = -deltaY/deltaX;
- for (t=0; t<n1; t++) /*for each segment in L1 */
- {
- getPoint2d_p(l1, t, &theP);
- thevalue = theP.x-(k*theP.y);
- list1[t].themeasure=thevalue;
- list1[t].pnr=t;
- /* lwnotice("l1 %d, measure=%f",t,thevalue ); */
- }
- for (t=0; t<n2; t++) /*for each segment in L2*/
- {
- getPoint2d_p(l2, t, &theP);
-
- thevalue = theP.x-(k*theP.y);
- list2[t].themeasure=thevalue;
- list2[t].pnr=t;
- /* lwnotice("l2 %d, measure=%f",t,thevalue ); */
- }
- c1m = c1.x-(k*c1.y);
- c2m = c2.x-(k*c2.y);
- }
-
- /*we sort our lists by the calculated values*/
- qsort(list1, n1, sizeof(LISTSTRUCT), struct_cmp_by_measure);
- qsort(list2, n2, sizeof(LISTSTRUCT), struct_cmp_by_measure);
-
- if (c1m < c2m)
- {
- if (!lw_dist2d_pre_seg_seg(l1,l2,list1,list2,k,dl))
- {
- lwfree(list1);
- lwfree(list2);
- return LW_FALSE;
- }
- }
- else
- {
- dl->twisted= ((dl->twisted) * (-1));
- if (!lw_dist2d_pre_seg_seg(l2,l1,list2,list1,k,dl))
- {
- lwfree(list1);
- lwfree(list2);
- return LW_FALSE;
- }
- }
- lwfree(list1);
- lwfree(list2);
- return LW_TRUE;
-}
-
-int
-struct_cmp_by_measure(const void *a, const void *b)
-{
- LISTSTRUCT *ia = (LISTSTRUCT*)a;
- LISTSTRUCT *ib = (LISTSTRUCT*)b;
- return ( ia->themeasure>ib->themeasure ) ? 1 : -1;
-}
-
-/**
- preparation before lw_dist2d_seg_seg.
-*/
-int
-lw_dist2d_pre_seg_seg(POINTARRAY *l1, POINTARRAY *l2,LISTSTRUCT *list1, LISTSTRUCT *list2,double k, DISTPTS *dl)
-{
- POINT2D p1, p2, p3, p4, p01, p02;
- int pnr1,pnr2,pnr3,pnr4, n1, n2, i, u, r, twist;
- double maxmeasure;
- n1= l1->npoints;
- n2 = l2->npoints;
-
- LWDEBUG(2, "lw_dist2d_pre_seg_seg is called");
-
- getPoint2d_p(l1, list1[0].pnr, &p1);
- getPoint2d_p(l2, list2[0].pnr, &p3);
- lw_dist2d_pt_pt(&p1, &p3,dl);
- maxmeasure = sqrt(dl->distance*dl->distance + (dl->distance*dl->distance*k*k));
- twist = dl->twisted; /*to keep the incomming order between iterations*/
- for (i =(n1-1); i>=0; --i)
- {
- /*we break this iteration when we have checked every
- point closer to our perpendicular "checkline" than
- our shortest found distance*/
- if (((list2[0].themeasure-list1[i].themeasure)) > maxmeasure) break;
- for (r=-1; r<=1; r +=2) /*because we are not iterating in the original pointorder we have to check the segment before and after every point*/
- {
- pnr1 = list1[i].pnr;
- getPoint2d_p(l1, pnr1, &p1);
- if (pnr1+r<0)
- {
- getPoint2d_p(l1, (n1-1), &p01);
- if (( p1.x == p01.x) && (p1.y == p01.y)) pnr2 = (n1-1);
- else pnr2 = pnr1; /* if it is a line and the last and first point is not the same we avoid the edge between start and end this way*/
- }
-
- else if (pnr1+r>(n1-1))
- {
- getPoint2d_p(l1, 0, &p01);
- if (( p1.x == p01.x) && (p1.y == p01.y)) pnr2 = 0;
- else pnr2 = pnr1; /* if it is a line and the last and first point is not the same we avoid the edge between start and end this way*/
- }
- else pnr2 = pnr1+r;
-
-
- getPoint2d_p(l1, pnr2, &p2);
- for (u=0; u<n2; ++u)
- {
- if (((list2[u].themeasure-list1[i].themeasure)) >= maxmeasure) break;
- pnr3 = list2[u].pnr;
- getPoint2d_p(l2, pnr3, &p3);
- if (pnr3==0)
- {
- getPoint2d_p(l2, (n2-1), &p02);
- if (( p3.x == p02.x) && (p3.y == p02.y)) pnr4 = (n2-1);
- else pnr4 = pnr3; /* if it is a line and the last and first point is not the same we avoid the edge between start and end this way*/
- }
- else pnr4 = pnr3-1;
-
- getPoint2d_p(l2, pnr4, &p4);
- dl->twisted=twist;
- if (!lw_dist2d_selected_seg_seg(&p1, &p2, &p3, &p4, dl)) return LW_FALSE;
-
- if (pnr3>=(n2-1))
- {
- getPoint2d_p(l2, 0, &p02);
- if (( p3.x == p02.x) && (p3.y == p02.y)) pnr4 = 0;
- else pnr4 = pnr3; /* if it is a line and the last and first point is not the same we avoid the edge between start and end this way*/
- }
-
- else pnr4 = pnr3+1;
-
- getPoint2d_p(l2, pnr4, &p4);
- dl->twisted=twist; /*we reset the "twist" for each iteration*/
- if (!lw_dist2d_selected_seg_seg(&p1, &p2, &p3, &p4, dl)) return LW_FALSE;
-
- maxmeasure = sqrt(dl->distance*dl->distance + (dl->distance*dl->distance*k*k));/*here we "translate" the found mindistance so it can be compared to our "z"-values*/
- }
- }
- }
-
- return LW_TRUE;
-}
-
-
-/**
- This is the same function as lw_dist2d_seg_seg but
- without any calculations to determine intersection since we
- already know they do not intersect
-*/
-int
-lw_dist2d_selected_seg_seg(POINT2D *A, POINT2D *B, POINT2D *C, POINT2D *D, DISTPTS *dl)
-{
- LWDEBUGF(2, "lw_dist2d_selected_seg_seg [%g,%g]->[%g,%g] by [%g,%g]->[%g,%g]",
- A->x,A->y,B->x,B->y, C->x,C->y, D->x, D->y);
-
- /*A and B are the same point */
- if ( ( A->x == B->x) && (A->y == B->y) )
- {
- return lw_dist2d_pt_seg(A,C,D,dl);
- }
- /*U and V are the same point */
-
- if ( ( C->x == D->x) && (C->y == D->y) )
- {
- dl->twisted= ((dl->twisted) * (-1));
- return lw_dist2d_pt_seg(D,A,B,dl);
- }
-
- if ((lw_dist2d_pt_seg(A,C,D,dl)) && (lw_dist2d_pt_seg(B,C,D,dl)))
- {
- dl->twisted= ((dl->twisted) * (-1)); /*here we change the order of inputted geometrys and that we notice by changing sign on dl->twisted*/
- return ((lw_dist2d_pt_seg(C,A,B,dl)) && (lw_dist2d_pt_seg(D,A,B,dl))); /*if all is successful we return true*/
- }
- else
- {
- return LW_FALSE; /* if any of the calls to lw_dist2d_pt_seg goes wrong we return false*/
- }
-}
-
-/*------------------------------------------------------------------------------------------------------------
-End of New faster distance calculations
---------------------------------------------------------------------------------------------------------------*/
-
-
-/*------------------------------------------------------------------------------------------------------------
-Functions in common for Brute force and new calculation
---------------------------------------------------------------------------------------------------------------*/
-
-/**
- * pt_in_ring_2d(): crossing number test for a point in a polygon
- * input: p = a point,
- * pa = vertex points of a ring V[n+1] with V[n]=V[0]
- * returns: 0 = outside, 1 = inside
- *
- * Our polygons have first and last point the same,
- *
- */
-int
-pt_in_ring_2d(const POINT2D *p, const POINTARRAY *ring)
-{
- int cn = 0; /* the crossing number counter */
- int i;
- POINT2D v1, v2;
-
- POINT2D first, last;
-
- getPoint2d_p(ring, 0, &first);
- getPoint2d_p(ring, ring->npoints-1, &last);
- if ( memcmp(&first, &last, sizeof(POINT2D)) )
- {
- lwerror("pt_in_ring_2d: V[n] != V[0] (%g %g != %g %g)",
- first.x, first.y, last.x, last.y);
- return LW_FALSE;
-
- }
-
- LWDEBUGF(2, "pt_in_ring_2d called with point: %g %g", p->x, p->y);
- /* printPA(ring); */
-
- /* loop through all edges of the polygon */
- getPoint2d_p(ring, 0, &v1);
- for (i=0; i<ring->npoints-1; i++)
- {
- double vt;
- getPoint2d_p(ring, i+1, &v2);
-
- /* edge from vertex i to vertex i+1 */
- if
- (
- /* an upward crossing */
- ((v1.y <= p->y) && (v2.y > p->y))
- /* a downward crossing */
- || ((v1.y > p->y) && (v2.y <= p->y))
- )
- {
-
- vt = (double)(p->y - v1.y) / (v2.y - v1.y);
-
- /* P.x <intersect */
- if (p->x < v1.x + vt * (v2.x - v1.x))
- {
- /* a valid crossing of y=p.y right of p.x */
- ++cn;
- }
- }
- v1 = v2;
- }
-
- LWDEBUGF(3, "pt_in_ring_2d returning %d", cn&1);
-
- return (cn&1); /* 0 if even (out), and 1 if odd (in) */
-}
-
-
-/**
-
-lw_dist2d_comp from p to line A->B
-This one is now sending every occation to lw_dist2d_pt_pt
-Before it was handling occations where r was between 0 and 1 internally
-and just returning the distance without identifying the points.
-To get this points it was nessecary to change and it also showed to be about 10%faster.
-*/
-int
-lw_dist2d_pt_seg(POINT2D *p, POINT2D *A, POINT2D *B, DISTPTS *dl)
-{
- POINT2D c;
- double r;
- /*if start==end, then use pt distance */
- if ( ( A->x == B->x) && (A->y == B->y) )
- {
- return lw_dist2d_pt_pt(p,A,dl);
- }
- /*
- * otherwise, we use comp.graphics.algorithms
- * Frequently Asked Questions method
- *
- * (1) AC dot AB
- * r = ---------
- * ||AB||^2
- * r has the following meaning:
- * r=0 P = A
- * r=1 P = B
- * r<0 P is on the backward extension of AB
- * r>1 P is on the forward extension of AB
- * 0<r<1 P is interior to AB
- */
-
- r = ( (p->x-A->x) * (B->x-A->x) + (p->y-A->y) * (B->y-A->y) )/( (B->x-A->x)*(B->x-A->x) +(B->y-A->y)*(B->y-A->y) );
-
- /*This is for finding the maxdistance.
- the maxdistance have to be between two vertexes,
- compared to mindistance which can be between
- tvo vertexes vertex.*/
- if (dl->mode == DIST_MAX)
- {
- if (r>=0.5)
- {
- return lw_dist2d_pt_pt(p,A,dl);
- }
- if (r<0.5)
- {
- return lw_dist2d_pt_pt(p,B,dl);
- }
- }
-
- if (r<0) /*If p projected on the line is outside point A*/
- {
- return lw_dist2d_pt_pt(p,A,dl);
- }
- if (r>=1) /*If p projected on the line is outside point B or on point B*/
- {
- return lw_dist2d_pt_pt(p,B,dl);
- }
-
- /*If the point p is on the segment this is a more robust way to find out that*/
- if (( ((A->y-p->y)*(B->x-A->x)==(A->x-p->x)*(B->y-A->y) ) ) && (dl->mode == DIST_MIN))
- {
- dl->distance = 0.0;
- dl->p1 = *p;
- dl->p2 = *p;
- }
-
- /*If the projection of point p on the segment is between A and B
- then we find that "point on segment" and send it to lw_dist2d_pt_pt*/
- c.x=A->x + r * (B->x-A->x);
- c.y=A->y + r * (B->y-A->y);
-
- return lw_dist2d_pt_pt(p,&c,dl);
-}
-
-
-/**
-
-Compares incomming points and
-stores the points closest to each other
-or most far away from each other
-depending on dl->mode (max or min)
-*/
-int
-lw_dist2d_pt_pt(POINT2D *thep1, POINT2D *thep2,DISTPTS *dl)
-{
- double hside = thep2->x - thep1->x;
- double vside = thep2->y - thep1->y;
- double dist = sqrt ( hside*hside + vside*vside );
-
- if (((dl->distance - dist)*(dl->mode))>0) /*multiplication with mode to handle mindistance (mode=1) and maxdistance (mode = (-1)*/
- {
- dl->distance = dist;
-
- if (dl->twisted>0) /*To get the points in right order. twisted is updated between 1 and (-1) every time the order is changed earlier in the chain*/
- {
- dl->p1 = *thep1;
- dl->p2 = *thep2;
- }
- else
- {
- dl->p1 = *thep2;
- dl->p2 = *thep1;
- }
- }
- return LW_TRUE;
-}
-
-
-
-
-/*------------------------------------------------------------------------------------------------------------
-End of Functions in common for Brute force and new calculation
---------------------------------------------------------------------------------------------------------------*/
-
-
-/*Mixed functions*/
-
-
-/**
-
- true if point is in poly (and not in its holes)
- It's not used by postgis but since I don't know what else
- can be affectes in the world I don't dare removing it.
- */
-int
-pt_in_poly_2d(const POINT2D *p, const LWPOLY *poly)
-{
- int i;
-
- /* Not in outer ring */
- if ( ! pt_in_ring_2d(p, poly->rings[0]) ) return 0;
-
- /* Check holes */
- for (i=1; i<poly->nrings; i++)
- {
- /* Inside a hole */
- if ( pt_in_ring_2d(p, poly->rings[i]) ) return 0;
- }
-
- return 1; /* In outer ring, not in holes */
-}
-
-
-/**
-The old function nessecary for ptarray_segmentize2d in ptarray.c
-*/
-double
-distance2d_pt_pt(const POINT2D *p1, const POINT2D *p2)
-{
- double hside = p2->x - p1->x;
- double vside = p2->y - p1->y;
-
- return sqrt ( hside*hside + vside*vside );
-
- /* the above is more readable
- return sqrt(
- (p2->x-p1->x) * (p2->x-p1->x) + (p2->y-p1->y) * (p2->y-p1->y)
- ); */
-}
-
-
-
-/**
-
-The old function nessecary for ptarray_segmentize2d in ptarray.c
-*/
-double
-distance2d_pt_seg(const POINT2D *p, const POINT2D *A, const POINT2D *B)
-{
- double r,s;
-
- /*if start==end, then use pt distance */
- if ( ( A->x == B->x) && (A->y == B->y) )
- return distance2d_pt_pt(p,A);
-
- /*
- * otherwise, we use comp.graphics.algorithms
- * Frequently Asked Questions method
- *
- * (1) AC dot AB
- * r = ---------
- * ||AB||^2
- * r has the following meaning:
- * r=0 P = A
- * r=1 P = B
- * r<0 P is on the backward extension of AB
- * r>1 P is on the forward extension of AB
- * 0<r<1 P is interior to AB
- */
-
- r = ( (p->x-A->x) * (B->x-A->x) + (p->y-A->y) * (B->y-A->y) )/( (B->x-A->x)*(B->x-A->x) +(B->y-A->y)*(B->y-A->y) );
-
- if (r<0) return distance2d_pt_pt(p,A);
- if (r>1) return distance2d_pt_pt(p,B);
-
-
- /*
- * (2)
- * (Ay-Cy)(Bx-Ax)-(Ax-Cx)(By-Ay)
- * s = -----------------------------
- * L^2
- *
- * Then the distance from C to P = |s|*L.
- *
- */
-
- s = ( (A->y-p->y)*(B->x-A->x)- (A->x-p->x)*(B->y-A->y) ) /
- ( (B->x-A->x)*(B->x-A->x) +(B->y-A->y)*(B->y-A->y) );
-
- return FP_ABS(s) * sqrt(
- (B->x-A->x)*(B->x-A->x) + (B->y-A->y)*(B->y-A->y)
- );
-}
-
-
-
-int
-lwgeom_pt_inside_circle(POINT2D *p, double cx, double cy, double rad)
-{
- POINT2D center;
-
- center.x = cx;
- center.y = cy;
-
- if ( distance2d_pt_pt(p, ¢er) < rad ) return 1;
- else return 0;
-
-}
-
-/**
- * Compute the azimuth of segment AB in radians.
- * Return 0 on exception (same point), 1 otherwise.
- */
-int
-azimuth_pt_pt(const POINT2D *A, const POINT2D *B, double *d)
-{
- if ( A->x == B->x )
- {
- if ( A->y < B->y ) *d=0.0;
- else if ( A->y > B->y ) *d=M_PI;
- else return 0;
- return 1;
- }
-
- if ( A->y == B->y )
- {
- if ( A->x < B->x ) *d=M_PI/2;
- else if ( A->x > B->x ) *d=M_PI+(M_PI/2);
- else return 0;
- return 1;
- }
-
- if ( A->x < B->x )
- {
- if ( A->y < B->y )
- {
- *d=atan(fabs(A->x - B->x) / fabs(A->y - B->y) );
- }
- else /* ( A->y > B->y ) - equality case handled above */
- {
- *d=atan(fabs(A->y - B->y) / fabs(A->x - B->x) )
- + (M_PI/2);
- }
- }
-
- else /* ( A->x > B->x ) - equality case handled above */
- {
- if ( A->y > B->y )
- {
- *d=atan(fabs(A->x - B->x) / fabs(A->y - B->y) )
- + M_PI;
- }
- else /* ( A->y < B->y ) - equality case handled above */
- {
- *d=atan(fabs(A->y - B->y) / fabs(A->x - B->x) )
- + (M_PI+(M_PI/2));
- }
- }
-
- return 1;
-}
-
-
--- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -\r
---\r
--- $Id$\r
---\r
--- PostGIS - Spatial Types for PostgreSQL\r
--- http://postgis.refractions.net\r
--- Copyright 2001-2003 Refractions Research Inc.\r
---\r
--- This is free software; you can redistribute and/or modify it under\r
--- the terms of the GNU General Public Licence. See the COPYING file.\r
---\r
--- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -\r
---\r
--- WARNING: Any change in this file must be evaluated for compatibility.\r
--- Changes cleanly handled by postgis_upgrade.sql are fine,\r
--- other changes will require a bump in Major version.\r
--- Currently only function replaceble by CREATE OR REPLACE\r
--- are cleanly handled.\r
---\r
--- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -\r
-\r
-#include "sqldefines.h"\r
-\r
-SET client_min_messages TO warning;\r
-\r
--- INSTALL VERSION: POSTGIS_LIB_VERSION\r
-\r
-BEGIN;\r
-\r
--------------------------------------------------------------------\r
--- SPHEROID TYPE\r
--------------------------------------------------------------------\r
-CREATE OR REPLACE FUNCTION spheroid_in(cstring)\r
- RETURNS spheroid\r
- AS 'MODULE_PATHNAME','ellipsoid_in'\r
- LANGUAGE 'C' IMMUTABLE STRICT;\r
-\r
-CREATE OR REPLACE FUNCTION spheroid_out(spheroid)\r
- RETURNS cstring\r
- AS 'MODULE_PATHNAME','ellipsoid_out'\r
- LANGUAGE 'C' IMMUTABLE STRICT;\r
-\r
-CREATE TYPE spheroid (\r
- alignment = double,\r
- internallength = 65,\r
- input = spheroid_in,\r
- output = spheroid_out\r
-);\r
-\r
--------------------------------------------------------------------\r
--- GEOMETRY TYPE (lwgeom)\r
--------------------------------------------------------------------\r
-CREATE OR REPLACE FUNCTION geometry_in(cstring)\r
- RETURNS geometry\r
- AS 'MODULE_PATHNAME','LWGEOM_in'\r
- LANGUAGE 'C' IMMUTABLE STRICT;\r
-\r
-CREATE OR REPLACE FUNCTION geometry_out(geometry)\r
- RETURNS cstring\r
- AS 'MODULE_PATHNAME','LWGEOM_out'\r
- LANGUAGE 'C' IMMUTABLE STRICT;\r
-\r
--- Availability: 2.0.0\r
-CREATE OR REPLACE FUNCTION geometry_typmod_in(cstring[])\r
- RETURNS integer\r
- AS 'MODULE_PATHNAME','geometry_typmod_in'\r
- LANGUAGE 'C' IMMUTABLE STRICT; \r
-\r
--- Availability: 2.0.0\r
-CREATE OR REPLACE FUNCTION geometry_typmod_out(integer)\r
- RETURNS cstring\r
- AS 'MODULE_PATHNAME','postgis_typmod_out'\r
- LANGUAGE 'C' IMMUTABLE STRICT; \r
-\r
-CREATE OR REPLACE FUNCTION geometry_analyze(internal)\r
- RETURNS bool\r
- AS 'MODULE_PATHNAME', 'geometry_analyze_2d'\r
- LANGUAGE 'C' VOLATILE STRICT;\r
-\r
-CREATE OR REPLACE FUNCTION geometry_recv(internal)\r
- RETURNS geometry\r
- AS 'MODULE_PATHNAME','LWGEOM_recv'\r
- LANGUAGE 'C' IMMUTABLE STRICT;\r
-\r
-CREATE OR REPLACE FUNCTION geometry_send(geometry)\r
- RETURNS bytea\r
- AS 'MODULE_PATHNAME','LWGEOM_send'\r
- LANGUAGE 'C' IMMUTABLE STRICT;\r
-\r
-CREATE TYPE geometry (\r
- internallength = variable,\r
- input = geometry_in,\r
- output = geometry_out,\r
- send = geometry_send,\r
- receive = geometry_recv,\r
- typmod_in = geometry_typmod_in,\r
- typmod_out = geometry_typmod_out,\r
- delimiter = ':',\r
- alignment = double,\r
- analyze = geometry_analyze,\r
- storage = main\r
-);\r
-\r
-\r
--- Availability: 2.0.0\r
--- Special cast for enforcing the typmod restrictions\r
-CREATE OR REPLACE FUNCTION geometry(geometry, integer, boolean)\r
- RETURNS geometry\r
- AS 'MODULE_PATHNAME','geometry_enforce_typmod'\r
- LANGUAGE 'C' IMMUTABLE STRICT; \r
-\r
--- Availability: 2.0.0\r
-CREATE CAST (geometry AS geometry) WITH FUNCTION geometry(geometry, integer, boolean) AS IMPLICIT;\r
-\r
-\r
--------------------------------------------------------------------\r
--- BOX3D TYPE\r
--- Point coordinate data access\r
--------------------------------------------\r
--- PostGIS equivalent function: X(geometry)\r
-CREATE OR REPLACE FUNCTION ST_X(geometry)\r
- RETURNS float8\r
- AS 'MODULE_PATHNAME','LWGEOM_x_point'\r
- LANGUAGE 'C' IMMUTABLE STRICT;\r
-\r
--- PostGIS equivalent function: Y(geometry)\r
-CREATE OR REPLACE FUNCTION ST_Y(geometry)\r
- RETURNS float8\r
- AS 'MODULE_PATHNAME','LWGEOM_y_point'\r
- LANGUAGE 'C' IMMUTABLE STRICT;\r
-\r
--- Availability: 1.2.2\r
-CREATE OR REPLACE FUNCTION ST_Z(geometry)\r
- RETURNS float8\r
- AS 'MODULE_PATHNAME','LWGEOM_z_point'\r
- LANGUAGE 'C' IMMUTABLE STRICT;\r
-\r
--- Availability: 1.2.2\r
-CREATE OR REPLACE FUNCTION ST_M(geometry)\r
- RETURNS float8\r
- AS 'MODULE_PATHNAME','LWGEOM_m_point'\r
- LANGUAGE 'C' IMMUTABLE STRICT;\r
-\r
--------------------------------------------\r
--------------------------------------------------------------------\r
-\r
-CREATE OR REPLACE FUNCTION box3d_in(cstring)\r
- RETURNS box3d\r
- AS 'MODULE_PATHNAME', 'BOX3D_in'\r
- LANGUAGE 'C' IMMUTABLE STRICT;\r
-\r
-CREATE OR REPLACE FUNCTION box3d_out(box3d)\r
- RETURNS cstring\r
- AS 'MODULE_PATHNAME', 'BOX3D_out'\r
- LANGUAGE 'C' IMMUTABLE STRICT;\r
-\r
-CREATE TYPE box3d (\r
- alignment = double,\r
- internallength = 48,\r
- input = box3d_in,\r
- output = box3d_out\r
-);\r
-\r
------------------------------------------------------------------------\r
--- BOX2D\r
------------------------------------------------------------------------\r
-\r
-CREATE OR REPLACE FUNCTION box2d_in(cstring)\r
- RETURNS box2d\r
- AS 'MODULE_PATHNAME','BOX2D_in'\r
- LANGUAGE 'C' IMMUTABLE STRICT;\r
-\r
-CREATE OR REPLACE FUNCTION box2d_out(box2d)\r
- RETURNS cstring\r
- AS 'MODULE_PATHNAME','BOX2D_out'\r
- LANGUAGE 'C' IMMUTABLE STRICT;\r
-\r
-CREATE TYPE box2d (\r
- internallength = 65,\r
- input = box2d_in,\r
- output = box2d_out,\r
- storage = plain\r
-);\r
-\r
--------------------------------------------------------------------\r
--- BOX2DF TYPE (INTERNAL ONLY)\r
--------------------------------------------------------------------\r
---\r
--- Box2Df type is used by the GiST index bindings. \r
--- In/out functions are stubs, as all access should be internal.\r
----\r
--- Availability: 2.0.0\r
-CREATE OR REPLACE FUNCTION box2df_in(cstring)\r
- RETURNS box2df\r
- AS 'MODULE_PATHNAME','box2df_in'\r
- LANGUAGE 'C' IMMUTABLE STRICT; \r
-\r
--- Availability: 2.0.0\r
-CREATE OR REPLACE FUNCTION box2df_out(box2df)\r
- RETURNS cstring\r
- AS 'MODULE_PATHNAME','box2df_out'\r
- LANGUAGE 'C' IMMUTABLE STRICT; \r
-\r
--- Availability: 2.0.0\r
-CREATE TYPE box2df (\r
- internallength = 16,\r
- input = box2df_in,\r
- output = box2df_out,\r
- storage = plain,\r
- alignment = double\r
-);\r
-\r
-\r
--------------------------------------------------------------------\r
--- GIDX TYPE (INTERNAL ONLY)\r
--------------------------------------------------------------------\r
---\r
--- GIDX type is used by the N-D and GEOGRAPHY GiST index bindings. \r
--- In/out functions are stubs, as all access should be internal.\r
----\r
-\r
--- Availability: 1.5.0\r
-CREATE OR REPLACE FUNCTION gidx_in(cstring)\r
- RETURNS gidx\r
- AS 'MODULE_PATHNAME','gidx_in'\r
- LANGUAGE 'C' IMMUTABLE STRICT; \r
-\r
--- Availability: 1.5.0\r
-CREATE OR REPLACE FUNCTION gidx_out(gidx)\r
- RETURNS cstring\r
- AS 'MODULE_PATHNAME','gidx_out'\r
- LANGUAGE 'C' IMMUTABLE STRICT; \r
-\r
--- Availability: 1.5.0\r
-CREATE TYPE gidx (\r
- internallength = variable,\r
- input = gidx_in,\r
- output = gidx_out,\r
- storage = plain,\r
- alignment = double\r
-);\r
-\r
--------------------------------------------------------------------\r
--- BTREE indexes\r
--------------------------------------------------------------------\r
-CREATE OR REPLACE FUNCTION geometry_lt(geom1 geometry, geom2 geometry)\r
- RETURNS bool\r
- AS 'MODULE_PATHNAME', 'lwgeom_lt'\r
- LANGUAGE 'C' IMMUTABLE STRICT;\r
-\r
-CREATE OR REPLACE FUNCTION geometry_le(geom1 geometry, geom2 geometry)\r
- RETURNS bool\r
- AS 'MODULE_PATHNAME', 'lwgeom_le'\r
- LANGUAGE 'C' IMMUTABLE STRICT;\r
-\r
-CREATE OR REPLACE FUNCTION geometry_gt(geom1 geometry, geom2 geometry)\r
- RETURNS bool\r
- AS 'MODULE_PATHNAME', 'lwgeom_gt'\r
- LANGUAGE 'C' IMMUTABLE STRICT;\r
-\r
-CREATE OR REPLACE FUNCTION geometry_ge(geom1 geometry, geom2 geometry)\r
- RETURNS bool\r
- AS 'MODULE_PATHNAME', 'lwgeom_ge'\r
- LANGUAGE 'C' IMMUTABLE STRICT;\r
-\r
-CREATE OR REPLACE FUNCTION geometry_eq(geom1 geometry, geom2 geometry)\r
- RETURNS bool\r
- AS 'MODULE_PATHNAME', 'lwgeom_eq'\r
- LANGUAGE 'C' IMMUTABLE STRICT;\r
-\r
-CREATE OR REPLACE FUNCTION geometry_cmp(geom1 geometry, geom2 geometry)\r
- RETURNS integer\r
- AS 'MODULE_PATHNAME', 'lwgeom_cmp'\r
- LANGUAGE 'C' IMMUTABLE STRICT;\r
-\r
---\r
--- Sorting operators for Btree\r
---\r
-\r
-CREATE OPERATOR < (\r
- LEFTARG = geometry, RIGHTARG = geometry, PROCEDURE = geometry_lt,\r
- COMMUTATOR = '>', NEGATOR = '>=',\r
- RESTRICT = contsel, JOIN = contjoinsel\r
-);\r
-\r
-CREATE OPERATOR <= (\r
- LEFTARG = geometry, RIGHTARG = geometry, PROCEDURE = geometry_le,\r
- COMMUTATOR = '>=', NEGATOR = '>',\r
- RESTRICT = contsel, JOIN = contjoinsel\r
-);\r
-\r
-CREATE OPERATOR = (\r
- LEFTARG = geometry, RIGHTARG = geometry, PROCEDURE = geometry_eq,\r
- COMMUTATOR = '=', -- we might implement a faster negator here\r
- RESTRICT = contsel, JOIN = contjoinsel\r
-);\r
-\r
-CREATE OPERATOR >= (\r
- LEFTARG = geometry, RIGHTARG = geometry, PROCEDURE = geometry_ge,\r
- COMMUTATOR = '<=', NEGATOR = '<',\r
- RESTRICT = contsel, JOIN = contjoinsel\r
-);\r
-CREATE OPERATOR > (\r
- LEFTARG = geometry, RIGHTARG = geometry, PROCEDURE = geometry_gt,\r
- COMMUTATOR = '<', NEGATOR = '<=',\r
- RESTRICT = contsel, JOIN = contjoinsel\r
-);\r
-\r
-\r
-CREATE OPERATOR CLASS btree_geometry_ops\r
- DEFAULT FOR TYPE geometry USING btree AS\r
- OPERATOR 1 < ,\r
- OPERATOR 2 <= ,\r
- OPERATOR 3 = ,\r
- OPERATOR 4 >= ,\r
- OPERATOR 5 > ,\r
- FUNCTION 1 geometry_cmp (geom1 geometry, geom2 geometry);\r
-\r
-\r
------------------------------------------------------------------------------\r
--- GiST 2D GEOMETRY-over-GSERIALIZED INDEX\r
------------------------------------------------------------------------------\r
-\r
--- ---------- ---------- ---------- ---------- ---------- ---------- ----------\r
--- GiST Support Functions\r
--- ---------- ---------- ---------- ---------- ---------- ---------- ----------\r
-\r
--- Availability: 2.0.0\r
-CREATE OR REPLACE FUNCTION geometry_gist_distance_2d(internal,geometry,int4) \r
- RETURNS float8 \r
- AS 'MODULE_PATHNAME' ,'gserialized_gist_distance_2d'\r
- LANGUAGE 'C';\r
-\r
--- Availability: 2.0.0\r
-CREATE OR REPLACE FUNCTION geometry_gist_consistent_2d(internal,geometry,int4) \r
- RETURNS bool \r
- AS 'MODULE_PATHNAME' ,'gserialized_gist_consistent_2d'\r
- LANGUAGE 'C';\r
-\r
--- Availability: 2.0.0\r
-CREATE OR REPLACE FUNCTION geometry_gist_compress_2d(internal) \r
- RETURNS internal \r
- AS 'MODULE_PATHNAME','gserialized_gist_compress_2d'\r
- LANGUAGE 'C';\r
-\r
--- Availability: 2.0.0\r
-CREATE OR REPLACE FUNCTION geometry_gist_penalty_2d(internal,internal,internal) \r
- RETURNS internal \r
- AS 'MODULE_PATHNAME' ,'gserialized_gist_penalty_2d'\r
- LANGUAGE 'C';\r
-\r
--- Availability: 2.0.0\r
-CREATE OR REPLACE FUNCTION geometry_gist_picksplit_2d(internal, internal) \r
- RETURNS internal \r
- AS 'MODULE_PATHNAME' ,'gserialized_gist_picksplit_2d'\r
- LANGUAGE 'C';\r
-\r
--- Availability: 2.0.0\r
-CREATE OR REPLACE FUNCTION geometry_gist_union_2d(bytea, internal) \r
- RETURNS internal \r
- AS 'MODULE_PATHNAME' ,'gserialized_gist_union_2d'\r
- LANGUAGE 'C';\r
-\r
--- Availability: 2.0.0\r
-CREATE OR REPLACE FUNCTION geometry_gist_same_2d(geom1 geometry, geom2 geometry, internal) \r
- RETURNS internal \r
- AS 'MODULE_PATHNAME' ,'gserialized_gist_same_2d'\r
- LANGUAGE 'C';\r
-\r
--- Availability: 2.0.0\r
-CREATE OR REPLACE FUNCTION geometry_gist_decompress_2d(internal) \r
- RETURNS internal \r
- AS 'MODULE_PATHNAME' ,'gserialized_gist_decompress_2d'\r
- LANGUAGE 'C';\r
-\r
--- Availability: 2.0.0\r
-CREATE OR REPLACE FUNCTION geometry_gist_sel_2d (internal, oid, internal, int4)\r
- RETURNS float8\r
- AS 'MODULE_PATHNAME', 'geometry_gist_sel_2d'\r
- LANGUAGE 'C';\r
-\r
--- Availability: 2.0.0\r
-CREATE OR REPLACE FUNCTION geometry_gist_joinsel_2d(internal, oid, internal, smallint)\r
- RETURNS float8\r
- AS 'MODULE_PATHNAME', 'geometry_gist_joinsel_2d'\r
- LANGUAGE 'C';\r
-\r
------------------------------------------------------------------------------\r
--- GEOMETRY Operators\r
------------------------------------------------------------------------------\r
-\r
--- ---------- ---------- ---------- ---------- ---------- ---------- ----------\r
--- 2D GEOMETRY Operators\r
--- ---------- ---------- ---------- ---------- ---------- ---------- ----------\r
-\r
--- Availability: 2.0.0\r
-CREATE OR REPLACE FUNCTION geometry_overlaps(geom1 geometry, geom2 geometry) \r
- RETURNS boolean \r
- AS 'MODULE_PATHNAME' ,'gserialized_overlaps_2d'\r
- LANGUAGE 'C' IMMUTABLE STRICT;\r
-\r
-CREATE OPERATOR && (\r
- LEFTARG = geometry, RIGHTARG = geometry, PROCEDURE = geometry_overlaps,\r
- COMMUTATOR = '&&'\r
--- ,RESTRICT = contsel, JOIN = contjoinsel\r
- ,RESTRICT = geometry_gist_sel_2d, JOIN = geometry_gist_joinsel_2d \r
-);\r
-\r
--- Availability: 2.0.0\r
-CREATE OR REPLACE FUNCTION geometry_same(geom1 geometry, geom2 geometry) \r
- RETURNS boolean \r
- AS 'MODULE_PATHNAME' ,'gserialized_same_2d'\r
- LANGUAGE 'C' IMMUTABLE STRICT;\r
-\r
-CREATE OPERATOR ~= (\r
- LEFTARG = geometry, RIGHTARG = geometry, PROCEDURE = geometry_same,\r
- RESTRICT = contsel, JOIN = contjoinsel\r
-);\r
-\r
--- Availability: 2.0.0\r
-CREATE OR REPLACE FUNCTION geometry_distance_centroid(geom1 geometry, geom2 geometry) \r
- RETURNS float8 \r
- AS 'MODULE_PATHNAME' ,'gserialized_distance_centroid_2d'\r
- LANGUAGE 'C' IMMUTABLE STRICT;\r
-\r
--- Availability: 2.0.0\r
-CREATE OR REPLACE FUNCTION geometry_distance_box(geom1 geometry, geom2 geometry) \r
- RETURNS float8 \r
- AS 'MODULE_PATHNAME' ,'gserialized_distance_box_2d'\r
- LANGUAGE 'C' IMMUTABLE STRICT;\r
-\r
-#if POSTGIS_PGSQL_VERSION >= 91\r
-CREATE OPERATOR <-> (\r
- LEFTARG = geometry, RIGHTARG = geometry, PROCEDURE = geometry_distance_centroid,\r
- COMMUTATOR = '<->'\r
-);\r
-\r
-CREATE OPERATOR <#> (\r
- LEFTARG = geometry, RIGHTARG = geometry, PROCEDURE = geometry_distance_box,\r
- COMMUTATOR = '<#>'\r
-);\r
-#endif\r
-\r
--- Availability: 2.0.0\r
-CREATE OR REPLACE FUNCTION geometry_contains(geom1 geometry, geom2 geometry)\r
- RETURNS bool\r
- AS 'MODULE_PATHNAME', 'gserialized_contains_2d'\r
- LANGUAGE 'C' IMMUTABLE STRICT;\r
-\r
--- Availability: 2.0.0\r
-CREATE OR REPLACE FUNCTION geometry_within(geom1 geometry, geom2 geometry)\r
- RETURNS bool\r
- AS 'MODULE_PATHNAME', 'gserialized_within_2d'\r
- LANGUAGE 'C' IMMUTABLE STRICT;\r
-\r
-CREATE OPERATOR @ (\r
- LEFTARG = geometry, RIGHTARG = geometry, PROCEDURE = geometry_within,\r
- COMMUTATOR = '~',\r
- RESTRICT = contsel, JOIN = contjoinsel\r
-);\r
-\r
-CREATE OPERATOR ~ (\r
- LEFTARG = geometry, RIGHTARG = geometry, PROCEDURE = geometry_contains,\r
- COMMUTATOR = '@',\r
- RESTRICT = contsel, JOIN = contjoinsel\r
-);\r
-\r
--- Availability: 2.0.0\r
-CREATE OR REPLACE FUNCTION geometry_left(geom1 geometry, geom2 geometry)\r
- RETURNS bool\r
- AS 'MODULE_PATHNAME', 'gserialized_left_2d'\r
- LANGUAGE 'C' IMMUTABLE STRICT;\r
-\r
-CREATE OPERATOR << (\r
- LEFTARG = geometry, RIGHTARG = geometry, PROCEDURE = geometry_left,\r
- COMMUTATOR = '>>',\r
- RESTRICT = positionsel, JOIN = positionjoinsel\r
-);\r
-\r
--- Availability: 2.0.0\r
-CREATE OR REPLACE FUNCTION geometry_overleft(geom1 geometry, geom2 geometry)\r
- RETURNS bool\r
- AS 'MODULE_PATHNAME', 'gserialized_overleft_2d'\r
- LANGUAGE 'C' IMMUTABLE STRICT;\r
-\r
-CREATE OPERATOR &< (\r
- LEFTARG = geometry, RIGHTARG = geometry, PROCEDURE = geometry_overleft,\r
- COMMUTATOR = '&>',\r
- RESTRICT = positionsel, JOIN = positionjoinsel\r
-);\r
-\r
--- Availability: 2.0.0\r
-CREATE OR REPLACE FUNCTION geometry_below(geom1 geometry, geom2 geometry)\r
- RETURNS bool\r
- AS 'MODULE_PATHNAME', 'gserialized_below_2d'\r
- LANGUAGE 'C' IMMUTABLE STRICT;\r
-\r
-CREATE OPERATOR <<| (\r
- LEFTARG = geometry, RIGHTARG = geometry, PROCEDURE = geometry_below,\r
- COMMUTATOR = '|>>',\r
- RESTRICT = positionsel, JOIN = positionjoinsel\r
-);\r
-\r
--- Availability: 2.0.0\r
-CREATE OR REPLACE FUNCTION geometry_overbelow(geom1 geometry, geom2 geometry)\r
- RETURNS bool\r
- AS 'MODULE_PATHNAME', 'gserialized_overbelow_2d'\r
- LANGUAGE 'C' IMMUTABLE STRICT;\r
-\r
-CREATE OPERATOR &<| (\r
- LEFTARG = geometry, RIGHTARG = geometry, PROCEDURE = geometry_overbelow,\r
- COMMUTATOR = '|&>',\r
- RESTRICT = positionsel, JOIN = positionjoinsel\r
-);\r
-\r
--- Availability: 2.0.0\r
-CREATE OR REPLACE FUNCTION geometry_overright(geom1 geometry, geom2 geometry)\r
- RETURNS bool\r
- AS 'MODULE_PATHNAME', 'gserialized_overright_2d'\r
- LANGUAGE 'C' IMMUTABLE STRICT;\r
-\r
-CREATE OPERATOR &> (\r
- LEFTARG = geometry, RIGHTARG = geometry, PROCEDURE = geometry_overright,\r
- COMMUTATOR = '&<',\r
- RESTRICT = positionsel, JOIN = positionjoinsel\r
-);\r
-\r
--- Availability: 2.0.0\r
-CREATE OR REPLACE FUNCTION geometry_right(geom1 geometry, geom2 geometry)\r
- RETURNS bool\r
- AS 'MODULE_PATHNAME', 'gserialized_right_2d'\r
- LANGUAGE 'C' IMMUTABLE STRICT;\r
-\r
-CREATE OPERATOR >> (\r
- LEFTARG = geometry, RIGHTARG = geometry, PROCEDURE = geometry_right,\r
- COMMUTATOR = '<<',\r
- RESTRICT = positionsel, JOIN = positionjoinsel\r
-);\r
-\r
--- Availability: 2.0.0\r
-CREATE OR REPLACE FUNCTION geometry_overabove(geom1 geometry, geom2 geometry)\r
- RETURNS bool\r
- AS 'MODULE_PATHNAME', 'gserialized_overabove_2d'\r
- LANGUAGE 'C' IMMUTABLE STRICT;\r
-\r
-CREATE OPERATOR |&> (\r
- LEFTARG = geometry, RIGHTARG = geometry, PROCEDURE = geometry_overabove,\r
- COMMUTATOR = '&<|',\r
- RESTRICT = positionsel, JOIN = positionjoinsel\r
-);\r
-\r
--- Availability: 2.0.0\r
-CREATE OR REPLACE FUNCTION geometry_above(geom1 geometry, geom2 geometry)\r
- RETURNS bool\r
- AS 'MODULE_PATHNAME', 'gserialized_above_2d'\r
- LANGUAGE 'C' IMMUTABLE STRICT;\r
-\r
-CREATE OPERATOR |>> (\r
- LEFTARG = geometry, RIGHTARG = geometry, PROCEDURE = geometry_above,\r
- COMMUTATOR = '<<|',\r
- RESTRICT = positionsel, JOIN = positionjoinsel\r
-);\r
-\r
--- Availability: 2.0.0\r
-CREATE OPERATOR CLASS gist_geometry_ops_2d\r
- DEFAULT FOR TYPE geometry USING GIST AS\r
- STORAGE box2df,\r
- OPERATOR 1 << ,\r
- OPERATOR 2 &< ,\r
- OPERATOR 3 && ,\r
- OPERATOR 4 &> ,\r
- OPERATOR 5 >> ,\r
- OPERATOR 6 ~= ,\r
- OPERATOR 7 ~ ,\r
- OPERATOR 8 @ ,\r
- OPERATOR 9 &<| ,\r
- OPERATOR 10 <<| ,\r
- OPERATOR 11 |>> ,\r
- OPERATOR 12 |&> ,\r
-#if POSTGIS_PGSQL_VERSION >= 91\r
- OPERATOR 13 <-> FOR ORDER BY pg_catalog.float_ops,\r
- OPERATOR 14 <#> FOR ORDER BY pg_catalog.float_ops,\r
- FUNCTION 8 geometry_gist_distance_2d (internal, geometry, int4),\r
-#endif\r
- FUNCTION 1 geometry_gist_consistent_2d (internal, geometry, int4),\r
- FUNCTION 2 geometry_gist_union_2d (bytea, internal),\r
- FUNCTION 3 geometry_gist_compress_2d (internal),\r
- FUNCTION 4 geometry_gist_decompress_2d (internal),\r
- FUNCTION 5 geometry_gist_penalty_2d (internal, internal, internal),\r
- FUNCTION 6 geometry_gist_picksplit_2d (internal, internal),\r
- FUNCTION 7 geometry_gist_same_2d (geom1 geometry, geom2 geometry, internal);\r
-\r
-\r
------------------------------------------------------------------------------\r
--- GiST ND GEOMETRY-over-GSERIALIZED\r
------------------------------------------------------------------------------\r
-\r
--- ---------- ---------- ---------- ---------- ---------- ---------- ----------\r
--- GiST Support Functions\r
--- ---------- ---------- ---------- ---------- ---------- ---------- ----------\r
-\r
--- Availability: 2.0.0\r
-CREATE OR REPLACE FUNCTION geometry_gist_consistent_nd(internal,geometry,int4) \r
- RETURNS bool \r
- AS 'MODULE_PATHNAME' ,'gserialized_gist_consistent'\r
- LANGUAGE 'C';\r
-\r
--- Availability: 2.0.0\r
-CREATE OR REPLACE FUNCTION geometry_gist_compress_nd(internal) \r
- RETURNS internal \r
- AS 'MODULE_PATHNAME','gserialized_gist_compress'\r
- LANGUAGE 'C';\r
-\r
--- Availability: 2.0.0\r
-CREATE OR REPLACE FUNCTION geometry_gist_penalty_nd(internal,internal,internal) \r
- RETURNS internal \r
- AS 'MODULE_PATHNAME' ,'gserialized_gist_penalty'\r
- LANGUAGE 'C';\r
-\r
--- Availability: 2.0.0\r
-CREATE OR REPLACE FUNCTION geometry_gist_picksplit_nd(internal, internal) \r
- RETURNS internal \r
- AS 'MODULE_PATHNAME' ,'gserialized_gist_picksplit'\r
- LANGUAGE 'C';\r
-\r
--- Availability: 2.0.0\r
-CREATE OR REPLACE FUNCTION geometry_gist_union_nd(bytea, internal) \r
- RETURNS internal \r
- AS 'MODULE_PATHNAME' ,'gserialized_gist_union'\r
- LANGUAGE 'C';\r
-\r
--- Availability: 2.0.0\r
-CREATE OR REPLACE FUNCTION geometry_gist_same_nd(geometry, geometry, internal) \r
- RETURNS internal \r
- AS 'MODULE_PATHNAME' ,'gserialized_gist_same'\r
- LANGUAGE 'C';\r
-\r
--- Availability: 2.0.0\r
-CREATE OR REPLACE FUNCTION geometry_gist_decompress_nd(internal) \r
- RETURNS internal \r
- AS 'MODULE_PATHNAME' ,'gserialized_gist_decompress'\r
- LANGUAGE 'C';\r
-\r
--- Availability: 2.0.0\r
---CREATE OR REPLACE FUNCTION geometry_gist_selectivity_nd (internal, oid, internal, int4)\r
--- RETURNS float8\r
--- AS 'MODULE_PATHNAME', 'geometry_gist_selectivity_nd'\r
--- LANGUAGE 'C';\r
-\r
--- Availability: 2.0.0\r
---CREATE OR REPLACE FUNCTION geography_gist_join_selectivity_nd(internal, oid, internal, smallint)\r
--- RETURNS float8\r
--- AS 'MODULE_PATHNAME', 'geometry_gist_join_selectivity_nd'\r
--- LANGUAGE 'C';\r
-\r
--- ---------- ---------- ---------- ---------- ---------- ---------- ----------\r
--- N-D GEOMETRY Operators\r
--- ---------- ---------- ---------- ---------- ---------- ---------- ----------\r
-\r
--- Availability: 2.0.0\r
-CREATE OR REPLACE FUNCTION geometry_overlaps_nd(geometry, geometry) \r
- RETURNS boolean \r
- AS 'MODULE_PATHNAME' ,'gserialized_overlaps'\r
- LANGUAGE 'C' IMMUTABLE STRICT;\r
-\r
--- Availability: 2.0.0\r
-CREATE OPERATOR &&& (\r
- LEFTARG = geometry, RIGHTARG = geometry, PROCEDURE = geometry_overlaps_nd,\r
- COMMUTATOR = '&&&'\r
- ,RESTRICT = contsel, JOIN = contjoinsel\r
--- ,RESTRICT = geometry_gist_selectivity_nd \r
--- ,JOIN = geometry_gist_join_selectivity_nd\r
-);\r
-\r
--- Availability: 2.0.0\r
-CREATE OPERATOR CLASS gist_geometry_ops_nd\r
- FOR TYPE geometry USING GIST AS\r
- STORAGE gidx,\r
- OPERATOR 3 &&& ,\r
--- OPERATOR 6 ~= ,\r
--- OPERATOR 7 ~ ,\r
--- OPERATOR 8 @ ,\r
- FUNCTION 1 geometry_gist_consistent_nd (internal, geometry, int4),\r
- FUNCTION 2 geometry_gist_union_nd (bytea, internal),\r
- FUNCTION 3 geometry_gist_compress_nd (internal),\r
- FUNCTION 4 geometry_gist_decompress_nd (internal),\r
- FUNCTION 5 geometry_gist_penalty_nd (internal, internal, internal),\r
- FUNCTION 6 geometry_gist_picksplit_nd (internal, internal),\r
- FUNCTION 7 geometry_gist_same_nd (geometry, geometry, internal);\r
-\r
-\r
------------------------------------------------------------------------------\r
--- Affine transforms\r
------------------------------------------------------------------------------\r
-\r
--- Availability: 1.2.2\r
-CREATE OR REPLACE FUNCTION ST_Affine(geometry,float8,float8,float8,float8,float8,float8,float8,float8,float8,float8,float8,float8)\r
- RETURNS geometry\r
- AS 'MODULE_PATHNAME', 'LWGEOM_affine'\r
- LANGUAGE 'C' IMMUTABLE STRICT;\r
-\r
--- Availability: 1.2.2\r
-CREATE OR REPLACE FUNCTION ST_Affine(geometry,float8,float8,float8,float8,float8,float8)\r
- RETURNS geometry\r
- AS 'SELECT ST_Affine($1, $2, $3, 0, $4, $5, 0, 0, 0, 1, $6, $7, 0)'\r
- LANGUAGE 'SQL' IMMUTABLE STRICT;\r
-\r
--- Availability: 1.2.2\r
-CREATE OR REPLACE FUNCTION ST_Rotate(geometry,float8)\r
- RETURNS geometry\r
- AS 'SELECT ST_Affine($1, cos($2), -sin($2), 0, sin($2), cos($2), 0, 0, 0, 1, 0, 0, 0)'\r
- LANGUAGE 'SQL' IMMUTABLE STRICT;\r
-\r
--- Availability: 2.0.0\r
-CREATE OR REPLACE FUNCTION ST_Rotate(geometry,float8,float8,float8)\r
- RETURNS geometry\r
- AS 'SELECT ST_Affine($1, cos($2), -sin($2), 0, sin($2), cos($2), 0, 0, 0, 1, $3 - cos($2) * $3 + sin($2) * $4, $4 - sin($2) * $3 - cos($2) * $4, 0)'\r
- LANGUAGE 'SQL' IMMUTABLE STRICT;\r
-\r
--- Availability: 2.0.0\r
-CREATE OR REPLACE FUNCTION ST_Rotate(geometry,float8,geometry)\r
- RETURNS geometry\r
- AS 'SELECT ST_Affine($1, cos($2), -sin($2), 0, sin($2), cos($2), 0, 0, 0, 1, ST_X($3) - cos($2) * ST_X($3) + sin($2) * ST_Y($3), ST_Y($3) - sin($2) * ST_X($3) - cos($2) * ST_Y($3), 0)'\r
- LANGUAGE 'sql' IMMUTABLE STRICT;\r
-\r
--- Availability: 1.2.2\r
-CREATE OR REPLACE FUNCTION ST_RotateZ(geometry,float8)\r
- RETURNS geometry\r
- AS 'SELECT ST_Rotate($1, $2)'\r
- LANGUAGE 'SQL' IMMUTABLE STRICT;\r
-\r
--- Availability: 1.2.2\r
-CREATE OR REPLACE FUNCTION ST_RotateX(geometry,float8)\r
- RETURNS geometry\r
- AS 'SELECT ST_Affine($1, 1, 0, 0, 0, cos($2), -sin($2), 0, sin($2), cos($2), 0, 0, 0)'\r
- LANGUAGE 'SQL' IMMUTABLE STRICT;\r
-\r
--- Availability: 1.2.2\r
-CREATE OR REPLACE FUNCTION ST_RotateY(geometry,float8)\r
- RETURNS geometry\r
- AS 'SELECT ST_Affine($1, cos($2), 0, sin($2), 0, 1, 0, -sin($2), 0, cos($2), 0, 0, 0)'\r
- LANGUAGE 'SQL' IMMUTABLE STRICT;\r
-\r
--- Availability: 1.2.2\r
-CREATE OR REPLACE FUNCTION ST_Translate(geometry,float8,float8,float8)\r
- RETURNS geometry\r
- AS 'SELECT ST_Affine($1, 1, 0, 0, 0, 1, 0, 0, 0, 1, $2, $3, $4)'\r
- LANGUAGE 'SQL' IMMUTABLE STRICT;\r
-\r
--- Availability: 1.2.2\r
-CREATE OR REPLACE FUNCTION ST_Translate(geometry,float8,float8)\r
- RETURNS geometry\r
- AS 'SELECT ST_Translate($1, $2, $3, 0)'\r
- LANGUAGE 'SQL' IMMUTABLE STRICT;\r
-\r
--- Availability: 1.2.2\r
-CREATE OR REPLACE FUNCTION ST_Scale(geometry,float8,float8,float8)\r
- RETURNS geometry\r
- AS 'SELECT ST_Affine($1, $2, 0, 0, 0, $3, 0, 0, 0, $4, 0, 0, 0)'\r
- LANGUAGE 'SQL' IMMUTABLE STRICT;\r
-\r
--- Availability: 1.2.2\r
-CREATE OR REPLACE FUNCTION ST_Scale(geometry,float8,float8)\r
- RETURNS geometry\r
- AS 'SELECT ST_Scale($1, $2, $3, 1)'\r
- LANGUAGE 'SQL' IMMUTABLE STRICT;\r
-\r
--- Availability: 1.2.2\r
-CREATE OR REPLACE FUNCTION ST_Transscale(geometry,float8,float8,float8,float8)\r
- RETURNS geometry\r
- AS 'SELECT ST_Affine($1, $4, 0, 0, 0, $5, 0,\r
- 0, 0, 1, $2 * $4, $3 * $5, 0)'\r
- LANGUAGE 'SQL' IMMUTABLE STRICT;\r
-\r
--- Availability: 1.2.2\r
-CREATE OR REPLACE FUNCTION ST_Shift_Longitude(geometry)\r
- RETURNS geometry\r
- AS 'MODULE_PATHNAME', 'LWGEOM_longitude_shift'\r
- LANGUAGE 'C' IMMUTABLE STRICT;\r
-\r
------------------------------------------------------------------------------\r
--- BOX3D FUNCTIONS\r
------------------------------------------------------------------------------\r
-\r
--- Availability: 1.2.2\r
-CREATE OR REPLACE FUNCTION ST_XMin(box3d)\r
- RETURNS FLOAT8\r
- AS 'MODULE_PATHNAME','BOX3D_xmin'\r
- LANGUAGE 'C' IMMUTABLE STRICT;\r
-\r
--- Availability: 1.2.2\r
-CREATE OR REPLACE FUNCTION ST_YMin(box3d)\r
- RETURNS FLOAT8\r
- AS 'MODULE_PATHNAME','BOX3D_ymin'\r
- LANGUAGE 'C' IMMUTABLE STRICT;\r
-\r
--- Availability: 1.2.2\r
-CREATE OR REPLACE FUNCTION ST_ZMin(box3d)\r
- RETURNS FLOAT8\r
- AS 'MODULE_PATHNAME','BOX3D_zmin'\r
- LANGUAGE 'C' IMMUTABLE STRICT;\r
-\r
--- Availability: 1.2.2\r
-CREATE OR REPLACE FUNCTION ST_XMax(box3d)\r
- RETURNS FLOAT8\r
- AS 'MODULE_PATHNAME','BOX3D_xmax'\r
- LANGUAGE 'C' IMMUTABLE STRICT;\r
-\r
--- Availability: 1.2.2\r
-CREATE OR REPLACE FUNCTION ST_YMax(box3d)\r
- RETURNS FLOAT8\r
- AS 'MODULE_PATHNAME','BOX3D_ymax'\r
- LANGUAGE 'C' IMMUTABLE STRICT;\r
-\r
--- Availability: 1.2.2\r
-CREATE OR REPLACE FUNCTION ST_ZMax(box3d)\r
- RETURNS FLOAT8\r
- AS 'MODULE_PATHNAME','BOX3D_zmax'\r
- LANGUAGE 'C' IMMUTABLE STRICT;\r
-\r
------------------------------------------------------------------------------\r
--- BOX2D FUNCTIONS\r
------------------------------------------------------------------------------\r
-\r
--- Availability: 1.2.2\r
-CREATE OR REPLACE FUNCTION ST_expand(box2d,float8)\r
- RETURNS box2d\r
- AS 'MODULE_PATHNAME', 'BOX2D_expand'\r
- LANGUAGE 'C' IMMUTABLE STRICT;\r
-\r
--- Availability: 1.5.0\r
-CREATE OR REPLACE FUNCTION postgis_getbbox(geometry)\r
- RETURNS box2d\r
- AS 'MODULE_PATHNAME','LWGEOM_to_BOX2D'\r
- LANGUAGE 'C' IMMUTABLE STRICT;\r
-\r
--- Availability: 1.2.2\r
-CREATE OR REPLACE FUNCTION ST_MakeBox2d(geom1 geometry, geom2 geometry)\r
- RETURNS box2d\r
- AS 'MODULE_PATHNAME', 'BOX2D_construct'\r
- LANGUAGE 'C' IMMUTABLE STRICT;\r
-\r
-\r
--- Availability: 1.2.2\r
-CREATE OR REPLACE FUNCTION ST_Combine_BBox(box2d,geometry)\r
- RETURNS box2d\r
- AS 'MODULE_PATHNAME', 'BOX2D_combine'\r
- LANGUAGE 'C' IMMUTABLE;\r
-\r
------------------------------------------------------------------------\r
--- ESTIMATED_EXTENT( <schema name>, <table name>, <column name> )\r
------------------------------------------------------------------------\r
--- Availability: 1.2.2\r
-CREATE OR REPLACE FUNCTION ST_estimated_extent(text,text,text) RETURNS box2d AS\r
- 'MODULE_PATHNAME', 'geometry_estimated_extent'\r
- LANGUAGE 'C' IMMUTABLE STRICT SECURITY DEFINER;\r
-\r
------------------------------------------------------------------------\r
--- ESTIMATED_EXTENT( <table name>, <column name> )\r
------------------------------------------------------------------------\r
--- Availability: 1.2.2\r
-CREATE OR REPLACE FUNCTION ST_estimated_extent(text,text) RETURNS box2d AS\r
- 'MODULE_PATHNAME', 'geometry_estimated_extent'\r
- LANGUAGE 'C' IMMUTABLE STRICT SECURITY DEFINER;\r
-\r
------------------------------------------------------------------------\r
--- FIND_EXTENT( <schema name>, <table name>, <column name> )\r
------------------------------------------------------------------------\r
--- Availability: 1.2.2\r
-CREATE OR REPLACE FUNCTION ST_find_extent(text,text,text) RETURNS box2d AS\r
-$$\r
-DECLARE\r
- schemaname alias for $1;\r
- tablename alias for $2;\r
- columnname alias for $3;\r
- myrec RECORD;\r
-\r
-BEGIN\r
- FOR myrec IN EXECUTE 'SELECT ST_Extent("' || columnname || '") As extent FROM "' || schemaname || '"."' || tablename || '"' LOOP\r
- return myrec.extent;\r
- END LOOP;\r
-END;\r
-$$\r
-LANGUAGE 'plpgsql' IMMUTABLE STRICT;\r
-\r
-\r
------------------------------------------------------------------------\r
--- FIND_EXTENT( <table name>, <column name> )\r
------------------------------------------------------------------------\r
--- Availability: 1.2.2\r
-CREATE OR REPLACE FUNCTION ST_find_extent(text,text) RETURNS box2d AS\r
-$$\r
-DECLARE\r
- tablename alias for $1;\r
- columnname alias for $2;\r
- myrec RECORD;\r
-\r
-BEGIN\r
- FOR myrec IN EXECUTE 'SELECT ST_Extent("' || columnname || '") As extent FROM "' || tablename || '"' LOOP\r
- return myrec.extent;\r
- END LOOP;\r
-END;\r
-$$\r
-LANGUAGE 'plpgsql' IMMUTABLE STRICT;\r
-\r
-\r
--------------------------------------------\r
--- other lwgeom functions\r
--------------------------------------------\r
--- Availability: 1.5.0\r
-CREATE OR REPLACE FUNCTION postgis_addbbox(geometry)\r
- RETURNS geometry\r
- AS 'MODULE_PATHNAME','LWGEOM_addBBOX'\r
- LANGUAGE 'C' IMMUTABLE STRICT;\r
-\r
--- Availability: 1.5.0\r
-CREATE OR REPLACE FUNCTION postgis_dropbbox(geometry)\r
- RETURNS geometry\r
- AS 'MODULE_PATHNAME','LWGEOM_dropBBOX'\r
- LANGUAGE 'C' IMMUTABLE STRICT;\r
-\r
--- Availability: 1.5.0\r
-CREATE OR REPLACE FUNCTION postgis_hasbbox(geometry)\r
- RETURNS bool\r
- AS 'MODULE_PATHNAME', 'LWGEOM_hasBBOX'\r
- LANGUAGE 'C' IMMUTABLE STRICT;\r
-\r
-\r
-------------------------------------------------------------------------\r
--- DEBUG\r
-------------------------------------------------------------------------\r
--- Availability: 1.2.2\r
-CREATE OR REPLACE FUNCTION ST_mem_size(geometry)\r
- RETURNS int4\r
- AS 'MODULE_PATHNAME', 'LWGEOM_mem_size'\r
- LANGUAGE 'C' IMMUTABLE STRICT;\r
-\r
--- Availability: 1.2.2\r
-CREATE OR REPLACE FUNCTION ST_summary(geometry)\r
- RETURNS text\r
- AS 'MODULE_PATHNAME', 'LWGEOM_summary'\r
- LANGUAGE 'C' IMMUTABLE STRICT;\r
-\r
--- Availability: 1.2.2\r
-CREATE OR REPLACE FUNCTION ST_Npoints(geometry)\r
- RETURNS int4\r
- AS 'MODULE_PATHNAME', 'LWGEOM_npoints'\r
- LANGUAGE 'C' IMMUTABLE STRICT;\r
-\r
--- Availability: 1.2.2\r
-CREATE OR REPLACE FUNCTION ST_nrings(geometry)\r
- RETURNS int4\r
- AS 'MODULE_PATHNAME', 'LWGEOM_nrings'\r
- LANGUAGE 'C' IMMUTABLE STRICT;\r
-\r
-------------------------------------------------------------------------\r
--- Measures\r
-------------------------------------------------------------------------\r
--- Availability: 2.0.0\r
-CREATE OR REPLACE FUNCTION ST_3DLength(geometry)\r
- RETURNS FLOAT8\r
- AS 'MODULE_PATHNAME', 'LWGEOM_length_linestring'\r
- LANGUAGE 'C' IMMUTABLE STRICT;\r
-\r
--- Availability: 1.2.2\r
-CREATE OR REPLACE FUNCTION ST_Length2d(geometry)\r
- RETURNS FLOAT8\r
- AS 'MODULE_PATHNAME', 'LWGEOM_length2d_linestring'\r
- LANGUAGE 'C' IMMUTABLE STRICT;\r
-\r
--- PostGIS equivalent function: length2d(geometry)\r
-CREATE OR REPLACE FUNCTION ST_Length(geometry)\r
- RETURNS FLOAT8\r
- AS 'MODULE_PATHNAME', 'LWGEOM_length2d_linestring'\r
- LANGUAGE 'C' IMMUTABLE STRICT;\r
-\r
--- this is a fake (for back-compatibility)\r
--- uses 3d if 3d is available, 2d otherwise\r
--- Availability: 2.0.0\r
-CREATE OR REPLACE FUNCTION ST_3DLength_spheroid(geometry, spheroid)\r
- RETURNS FLOAT8\r
- AS 'MODULE_PATHNAME','LWGEOM_length_ellipsoid_linestring'\r
- LANGUAGE 'C' IMMUTABLE STRICT\r
- COST 100;\r
-\r
--- Availability: 1.2.2\r
-CREATE OR REPLACE FUNCTION ST_length_spheroid(geometry, spheroid)\r
- RETURNS FLOAT8\r
- AS 'MODULE_PATHNAME','LWGEOM_length_ellipsoid_linestring'\r
- LANGUAGE 'C' IMMUTABLE STRICT\r
- COST 100;\r
-\r
--- Availability: 1.2.2\r
-CREATE OR REPLACE FUNCTION ST_length2d_spheroid(geometry, spheroid)\r
- RETURNS FLOAT8\r
- AS 'MODULE_PATHNAME','LWGEOM_length2d_ellipsoid'\r
- LANGUAGE 'C' IMMUTABLE STRICT\r
- COST 100;\r
-\r
--- Availability: 2.0.0\r
-CREATE OR REPLACE FUNCTION ST_3DPerimeter(geometry)\r
- RETURNS FLOAT8\r
- AS 'MODULE_PATHNAME', 'LWGEOM_perimeter_poly'\r
- LANGUAGE 'C' IMMUTABLE STRICT;\r
-\r
--- Availability: 1.2.2\r
-CREATE OR REPLACE FUNCTION ST_perimeter2d(geometry)\r
- RETURNS FLOAT8\r
- AS 'MODULE_PATHNAME', 'LWGEOM_perimeter2d_poly'\r
- LANGUAGE 'C' IMMUTABLE STRICT;\r
-\r
--- PostGIS equivalent function: perimeter2d(geometry)\r
-CREATE OR REPLACE FUNCTION ST_Perimeter(geometry)\r
- RETURNS FLOAT8\r
- AS 'MODULE_PATHNAME', 'LWGEOM_perimeter2d_poly'\r
- LANGUAGE 'C' IMMUTABLE STRICT;\r
-\r
--- Availability: 1.2.2\r
--- Deprecation in 1.3.4\r
-CREATE OR REPLACE FUNCTION ST_area2d(geometry)\r
- RETURNS FLOAT8\r
- AS 'MODULE_PATHNAME', 'LWGEOM_area_polygon'\r
- LANGUAGE 'C' IMMUTABLE STRICT;\r
-\r
--- PostGIS equivalent function: area(geometry)\r
-CREATE OR REPLACE FUNCTION ST_Area(geometry)\r
- RETURNS FLOAT8\r
- AS 'MODULE_PATHNAME','LWGEOM_area_polygon'\r
- LANGUAGE 'C' IMMUTABLE STRICT;\r
-\r
--- Availability: 1.2.2\r
-CREATE OR REPLACE FUNCTION ST_distance_spheroid(geom1 geometry, geom2 geometry,spheroid)\r
- RETURNS FLOAT8\r
- AS 'MODULE_PATHNAME','LWGEOM_distance_ellipsoid'\r
- LANGUAGE 'C' IMMUTABLE STRICT\r
- COST 100;\r
-\r
--- Minimum distance. 2d only.\r
-\r
--- PostGIS equivalent function: distance(geom1 geometry, geom2 geometry)\r
-CREATE OR REPLACE FUNCTION ST_Distance(geom1 geometry, geom2 geometry)\r
- RETURNS float8\r
- AS 'MODULE_PATHNAME', 'LWGEOM_mindistance2d'\r
- LANGUAGE 'C' IMMUTABLE STRICT\r
- COST 100;\r
-\r
--- Availability: 1.2.2\r
-CREATE OR REPLACE FUNCTION ST_point_inside_circle(geometry,float8,float8,float8)\r
- RETURNS bool\r
- AS 'MODULE_PATHNAME', 'LWGEOM_inside_circle_point'\r
- LANGUAGE 'C' IMMUTABLE STRICT;\r
-\r
--- Availability: 1.2.2\r
-CREATE OR REPLACE FUNCTION ST_azimuth(geom1 geometry, geom2 geometry)\r
- RETURNS float8\r
- AS 'MODULE_PATHNAME', 'LWGEOM_azimuth'\r
- LANGUAGE 'C' IMMUTABLE STRICT;\r
-\r
-------------------------------------------------------------------------\r
--- MISC\r
-------------------------------------------------------------------------\r
--- Availability: 1.2.2\r
-CREATE OR REPLACE FUNCTION ST_force_2d(geometry)\r
- RETURNS geometry\r
- AS 'MODULE_PATHNAME', 'LWGEOM_force_2d'\r
- LANGUAGE 'C' IMMUTABLE STRICT;\r
-\r
--- Availability: 1.2.2\r
-CREATE OR REPLACE FUNCTION ST_force_3dz(geometry)\r
- RETURNS geometry\r
- AS 'MODULE_PATHNAME', 'LWGEOM_force_3dz'\r
- LANGUAGE 'C' IMMUTABLE STRICT;\r
-\r
-\r
--- Availability: 1.2.2\r
-CREATE OR REPLACE FUNCTION ST_force_3d(geometry)\r
- RETURNS geometry\r
- AS 'MODULE_PATHNAME', 'LWGEOM_force_3dz'\r
- LANGUAGE 'C' IMMUTABLE STRICT;\r
-\r
--- Availability: 1.2.2\r
-CREATE OR REPLACE FUNCTION ST_force_3dm(geometry)\r
- RETURNS geometry\r
- AS 'MODULE_PATHNAME', 'LWGEOM_force_3dm'\r
- LANGUAGE 'C' IMMUTABLE STRICT;\r
-\r
--- Availability: 1.2.2\r
-CREATE OR REPLACE FUNCTION ST_force_4d(geometry)\r
- RETURNS geometry\r
- AS 'MODULE_PATHNAME', 'LWGEOM_force_4d'\r
- LANGUAGE 'C' IMMUTABLE STRICT;\r
-\r
--- Availability: 1.2.2\r
-CREATE OR REPLACE FUNCTION ST_force_collection(geometry)\r
- RETURNS geometry\r
- AS 'MODULE_PATHNAME', 'LWGEOM_force_collection'\r
- LANGUAGE 'C' IMMUTABLE STRICT;\r
-\r
--- Availability: 1.5.0\r
-CREATE OR REPLACE FUNCTION ST_CollectionExtract(geometry, integer)\r
- RETURNS geometry\r
- AS 'MODULE_PATHNAME', 'ST_CollectionExtract'\r
- LANGUAGE 'C' IMMUTABLE STRICT;\r
-\r
--- Availability: 2.0.0\r
-CREATE OR REPLACE FUNCTION ST_CollectionHomogenize(geometry)\r
- RETURNS geometry\r
- AS 'MODULE_PATHNAME', 'ST_CollectionHomogenize'\r
- LANGUAGE 'C' IMMUTABLE STRICT;\r
-\r
--- Availability: 1.2.2\r
-CREATE OR REPLACE FUNCTION ST_Multi(geometry)\r
- RETURNS geometry\r
- AS 'MODULE_PATHNAME', 'LWGEOM_force_multi'\r
- LANGUAGE 'C' IMMUTABLE STRICT;\r
-\r
--- Availability: 1.2.2\r
-CREATE OR REPLACE FUNCTION ST_Expand(box3d,float8)\r
- RETURNS box3d\r
- AS 'MODULE_PATHNAME', 'BOX3D_expand'\r
- LANGUAGE 'C' IMMUTABLE STRICT;\r
-\r
--- Availability: 1.2.2\r
-CREATE OR REPLACE FUNCTION ST_Expand(geometry,float8)\r
- RETURNS geometry\r
- AS 'MODULE_PATHNAME', 'LWGEOM_expand'\r
- LANGUAGE 'C' IMMUTABLE STRICT;\r
-\r
--- PostGIS equivalent function: envelope(geometry)\r
-CREATE OR REPLACE FUNCTION ST_Envelope(geometry)\r
- RETURNS geometry\r
- AS 'MODULE_PATHNAME', 'LWGEOM_envelope'\r
- LANGUAGE 'C' IMMUTABLE STRICT;\r
-\r
--- Availability: 1.2.2\r
-CREATE OR REPLACE FUNCTION ST_Reverse(geometry)\r
- RETURNS geometry\r
- AS 'MODULE_PATHNAME', 'LWGEOM_reverse'\r
- LANGUAGE 'C' IMMUTABLE STRICT;\r
-\r
--- Availability: 1.2.2\r
-CREATE OR REPLACE FUNCTION ST_ForceRHR(geometry)\r
- RETURNS geometry\r
- AS 'MODULE_PATHNAME', 'LWGEOM_force_clockwise_poly'\r
- LANGUAGE 'C' IMMUTABLE STRICT;\r
-\r
--- Availability: 1.5.0\r
-CREATE OR REPLACE FUNCTION postgis_noop(geometry)\r
- RETURNS geometry\r
- AS 'MODULE_PATHNAME', 'LWGEOM_noop'\r
- LANGUAGE 'C' VOLATILE STRICT;\r
- \r
--- Deprecation in 1.5.0\r
-CREATE OR REPLACE FUNCTION ST_zmflag(geometry)\r
- RETURNS smallint\r
- AS 'MODULE_PATHNAME', 'LWGEOM_zmflag'\r
- LANGUAGE 'C' IMMUTABLE STRICT;\r
-\r
--- Availability: 1.2.2\r
-CREATE OR REPLACE FUNCTION ST_NDims(geometry)\r
- RETURNS smallint\r
- AS 'MODULE_PATHNAME', 'LWGEOM_ndims'\r
- LANGUAGE 'C' IMMUTABLE STRICT;\r
-\r
--- Availability: 1.2.2\r
-CREATE OR REPLACE FUNCTION ST_AsEWKT(geometry)\r
- RETURNS TEXT\r
- AS 'MODULE_PATHNAME','LWGEOM_asEWKT'\r
- LANGUAGE 'C' IMMUTABLE STRICT;\r
-\r
--- Availability: 1.2.2\r
-CREATE OR REPLACE FUNCTION ST_AsEWKB(geometry)\r
- RETURNS BYTEA\r
- AS 'MODULE_PATHNAME','WKBFromLWGEOM'\r
- LANGUAGE 'C' IMMUTABLE STRICT;\r
-\r
--- Availability: 1.2.2\r
-CREATE OR REPLACE FUNCTION ST_AsHEXEWKB(geometry)\r
- RETURNS TEXT\r
- AS 'MODULE_PATHNAME','LWGEOM_asHEXEWKB'\r
- LANGUAGE 'C' IMMUTABLE STRICT;\r
-\r
--- Availability: 1.2.2\r
-CREATE OR REPLACE FUNCTION ST_AsHEXEWKB(geometry, text)\r
- RETURNS TEXT\r
- AS 'MODULE_PATHNAME','LWGEOM_asHEXEWKB'\r
- LANGUAGE 'C' IMMUTABLE STRICT;\r
-\r
--- Availability: 1.2.2\r
-CREATE OR REPLACE FUNCTION ST_AsEWKB(geometry,text)\r
- RETURNS bytea\r
- AS 'MODULE_PATHNAME','WKBFromLWGEOM'\r
- LANGUAGE 'C' IMMUTABLE STRICT;\r
-\r
--- Availability: 2.0.0\r
-CREATE OR REPLACE FUNCTION ST_AsLatLonText(geometry, text)\r
- RETURNS text\r
- AS 'MODULE_PATHNAME','LWGEOM_to_latlon'\r
- LANGUAGE 'C' IMMUTABLE STRICT;\r
-\r
--- Availability: 2.0.0\r
-CREATE OR REPLACE FUNCTION ST_AsLatLonText(geometry)\r
- RETURNS text\r
- AS $$ SELECT ST_AsLatLonText($1, '') $$\r
- LANGUAGE 'SQL' IMMUTABLE STRICT;\r
-\r
--- Deprecation in 1.2.3\r
-CREATE OR REPLACE FUNCTION GeomFromEWKB(bytea)\r
- RETURNS geometry\r
- AS 'MODULE_PATHNAME','LWGEOMFromWKB'\r
- LANGUAGE 'C' IMMUTABLE STRICT;\r
-\r
--- Availability: 1.2.2\r
-CREATE OR REPLACE FUNCTION ST_GeomFromEWKB(bytea)\r
- RETURNS geometry\r
- AS 'MODULE_PATHNAME','LWGEOMFromWKB'\r
- LANGUAGE 'C' IMMUTABLE STRICT;\r
-\r
--- Deprecation in 1.2.3\r
-CREATE OR REPLACE FUNCTION GeomFromEWKT(text)\r
- RETURNS geometry\r
- AS 'MODULE_PATHNAME','parse_WKT_lwgeom'\r
- LANGUAGE 'C' IMMUTABLE STRICT;\r
-\r
--- Availability: 1.2.2\r
-CREATE OR REPLACE FUNCTION ST_GeomFromEWKT(text)\r
- RETURNS geometry\r
- AS 'MODULE_PATHNAME','parse_WKT_lwgeom'\r
- LANGUAGE 'C' IMMUTABLE STRICT;\r
-\r
--- Availability: 1.5.0\r
-CREATE OR REPLACE FUNCTION postgis_cache_bbox()\r
- RETURNS trigger\r
- AS 'MODULE_PATHNAME', 'cache_bbox'\r
- LANGUAGE 'C';\r
-\r
-------------------------------------------------------------------------\r
--- CONSTRUCTORS\r
-------------------------------------------------------------------------\r
-\r
--- Availability: 1.2.2\r
-CREATE OR REPLACE FUNCTION ST_MakePoint(float8, float8)\r
- RETURNS geometry\r
- AS 'MODULE_PATHNAME', 'LWGEOM_makepoint'\r
- LANGUAGE 'C' IMMUTABLE STRICT;\r
-\r
--- Availability: 1.2.2\r
-CREATE OR REPLACE FUNCTION ST_MakePoint(float8, float8, float8)\r
- RETURNS geometry\r
- AS 'MODULE_PATHNAME', 'LWGEOM_makepoint'\r
- LANGUAGE 'C' IMMUTABLE STRICT;\r
-\r
--- Availability: 1.2.2\r
-CREATE OR REPLACE FUNCTION ST_MakePoint(float8, float8, float8, float8)\r
- RETURNS geometry\r
- AS 'MODULE_PATHNAME', 'LWGEOM_makepoint'\r
- LANGUAGE 'C' IMMUTABLE STRICT;\r
-\r
--- Availability: 1.3.4\r
-CREATE OR REPLACE FUNCTION ST_MakePointM(float8, float8, float8)\r
- RETURNS geometry\r
- AS 'MODULE_PATHNAME', 'LWGEOM_makepoint3dm'\r
- LANGUAGE 'C' IMMUTABLE STRICT;\r
-\r
--- Availability: 2.0.0\r
-CREATE OR REPLACE FUNCTION ST_3DMakeBox(geom1 geometry, geom2 geometry)\r
- RETURNS box3d\r
- AS 'MODULE_PATHNAME', 'BOX3D_construct'\r
- LANGUAGE 'C' IMMUTABLE STRICT;\r
-\r
--- Availability: 1.4.0\r
-CREATE OR REPLACE FUNCTION ST_MakeLine (geometry[])\r
- RETURNS geometry\r
- AS 'MODULE_PATHNAME', 'LWGEOM_makeline_garray'\r
- LANGUAGE 'C' IMMUTABLE STRICT;\r
-\r
--- Availability: 1.2.2\r
-CREATE OR REPLACE FUNCTION ST_LineFromMultiPoint(geometry)\r
- RETURNS geometry\r
- AS 'MODULE_PATHNAME', 'LWGEOM_line_from_mpoint'\r
- LANGUAGE 'C' IMMUTABLE STRICT;\r
- \r
--- Availability: 1.2.2\r
-CREATE OR REPLACE FUNCTION ST_MakeLine(geom1 geometry, geom2 geometry)\r
- RETURNS geometry\r
- AS 'MODULE_PATHNAME', 'LWGEOM_makeline'\r
- LANGUAGE 'C' IMMUTABLE STRICT;\r
-\r
--- Availability: 1.2.2\r
-CREATE OR REPLACE FUNCTION ST_AddPoint(geom1 geometry, geom2 geometry)\r
- RETURNS geometry\r
- AS 'MODULE_PATHNAME', 'LWGEOM_addpoint'\r
- LANGUAGE 'C' IMMUTABLE STRICT;\r
-\r
--- Availability: 1.2.2\r
-CREATE OR REPLACE FUNCTION ST_AddPoint(geom1 geometry, geom2 geometry, integer)\r
- RETURNS geometry\r
- AS 'MODULE_PATHNAME', 'LWGEOM_addpoint'\r
- LANGUAGE 'C' IMMUTABLE STRICT;\r
-\r
--- Availability: 1.2.2\r
-CREATE OR REPLACE FUNCTION ST_RemovePoint(geometry, integer)\r
- RETURNS geometry\r
- AS 'MODULE_PATHNAME', 'LWGEOM_removepoint'\r
- LANGUAGE 'C' IMMUTABLE STRICT;\r
-\r
--- Availability: 1.2.2\r
-CREATE OR REPLACE FUNCTION ST_SetPoint(geometry, integer, geometry)\r
- RETURNS geometry\r
- AS 'MODULE_PATHNAME', 'LWGEOM_setpoint_linestring'\r
- LANGUAGE 'C' IMMUTABLE STRICT;\r
-\r
--- Availability: 1.5.0\r
--- Availability: 2.0.0 - made srid optional\r
-CREATE OR REPLACE FUNCTION ST_MakeEnvelope(float8, float8, float8, float8, integer DEFAULT 0)\r
- RETURNS geometry\r
- AS 'MODULE_PATHNAME', 'ST_MakeEnvelope'\r
- LANGUAGE 'C' IMMUTABLE STRICT;\r
-\r
--- Availability: 1.2.2\r
-CREATE OR REPLACE FUNCTION ST_MakePolygon(geometry, geometry[])\r
- RETURNS geometry\r
- AS 'MODULE_PATHNAME', 'LWGEOM_makepoly'\r
- LANGUAGE 'C' IMMUTABLE STRICT;\r
-\r
--- Availability: 1.2.2\r
-CREATE OR REPLACE FUNCTION ST_MakePolygon(geometry)\r
- RETURNS geometry\r
- AS 'MODULE_PATHNAME', 'LWGEOM_makepoly'\r
- LANGUAGE 'C' IMMUTABLE STRICT;\r
-\r
--- Availability: 1.2.2\r
-CREATE OR REPLACE FUNCTION ST_BuildArea(geometry)\r
- RETURNS geometry\r
- AS 'MODULE_PATHNAME', 'ST_BuildArea'\r
- LANGUAGE 'C' IMMUTABLE STRICT\r
- COST 100;\r
-\r
--- Availability: 1.4.0\r
-CREATE OR REPLACE FUNCTION ST_Polygonize (geometry[])\r
- RETURNS geometry\r
- AS 'MODULE_PATHNAME', 'polygonize_garray'\r
- LANGUAGE 'C' IMMUTABLE STRICT\r
- COST 100;\r
-\r
--- Availability: 1.2.2\r
-CREATE OR REPLACE FUNCTION ST_LineMerge(geometry)\r
- RETURNS geometry\r
- AS 'MODULE_PATHNAME', 'linemerge'\r
- LANGUAGE 'C' IMMUTABLE STRICT\r
- COST 100;\r
-\r
-\r
-CREATE TYPE geometry_dump AS (path integer[], geom geometry);\r
-\r
--- Availability: 1.2.2\r
-CREATE OR REPLACE FUNCTION ST_Dump(geometry)\r
- RETURNS SETOF geometry_dump\r
- AS 'MODULE_PATHNAME', 'LWGEOM_dump'\r
- LANGUAGE 'C' IMMUTABLE STRICT;\r
-\r
--- Availability: 1.2.2\r
-CREATE OR REPLACE FUNCTION ST_DumpRings(geometry)\r
- RETURNS SETOF geometry_dump\r
- AS 'MODULE_PATHNAME', 'LWGEOM_dump_rings'\r
- LANGUAGE 'C' IMMUTABLE STRICT;\r
-\r
------------------------------------------------------------------------\r
--- _ST_DumpPoints()\r
------------------------------------------------------------------------\r
--- A helper function for ST_DumpPoints(geom)\r
--- Availability: 1.5.0\r
-CREATE OR REPLACE FUNCTION _ST_DumpPoints(the_geom geometry, cur_path integer[]) RETURNS SETOF geometry_dump AS $$\r
-DECLARE\r
- tmp geometry_dump;\r
- tmp2 geometry_dump;\r
- nb_points integer;\r
- nb_geom integer;\r
- i integer;\r
- j integer;\r
- g geometry;\r
- \r
-BEGIN\r
- \r
- RAISE DEBUG '%,%', cur_path, ST_GeometryType(the_geom);\r
-\r
- -- Special case collections : iterate and return the DumpPoints of the geometries\r
-\r
- IF (ST_IsCollection(the_geom)) THEN\r
- \r
- i = 1;\r
- FOR tmp2 IN SELECT (ST_Dump(the_geom)).* LOOP\r
-\r
- FOR tmp IN SELECT * FROM _ST_DumpPoints(tmp2.geom, cur_path || tmp2.path) LOOP\r
- RETURN NEXT tmp;\r
- END LOOP;\r
- i = i + 1;\r
- \r
- END LOOP;\r
-\r
- RETURN;\r
- END IF;\r
- \r
-\r
- -- Special case (POLYGON) : return the points of the rings of a polygon\r
- IF (ST_GeometryType(the_geom) = 'ST_Polygon') THEN\r
-\r
- FOR tmp IN SELECT * FROM _ST_DumpPoints(ST_ExteriorRing(the_geom), cur_path || ARRAY[1]) LOOP\r
- RETURN NEXT tmp;\r
- END LOOP;\r
- \r
- j := ST_NumInteriorRings(the_geom);\r
- FOR i IN 1..j LOOP\r
- FOR tmp IN SELECT * FROM _ST_DumpPoints(ST_InteriorRingN(the_geom, i), cur_path || ARRAY[i+1]) LOOP\r
- RETURN NEXT tmp;\r
- END LOOP;\r
- END LOOP;\r
- \r
- RETURN;\r
- END IF;\r
-\r
- -- Special case (TRIANGLE) : return the points of the external rings of a TRIANGLE\r
- IF (ST_GeometryType(the_geom) = 'ST_Triangle') THEN\r
-\r
- FOR tmp IN SELECT * FROM _ST_DumpPoints(ST_ExteriorRing(the_geom), cur_path || ARRAY[1]) LOOP\r
- RETURN NEXT tmp;\r
- END LOOP;\r
- \r
- RETURN;\r
- END IF;\r
-\r
- \r
- -- Special case (POINT) : return the point\r
- IF (ST_GeometryType(the_geom) = 'ST_Point') THEN\r
-\r
- tmp.path = cur_path || ARRAY[1];\r
- tmp.geom = the_geom;\r
-\r
- RETURN NEXT tmp;\r
- RETURN;\r
-\r
- END IF;\r
-\r
-\r
- -- Use ST_NumPoints rather than ST_NPoints to have a NULL value if the_geom isn't\r
- -- a LINESTRING, CIRCULARSTRING.\r
- SELECT ST_NumPoints(the_geom) INTO nb_points;\r
-\r
- -- This should never happen\r
- IF (nb_points IS NULL) THEN\r
- RAISE EXCEPTION 'Unexpected error while dumping geometry %', ST_AsText(the_geom);\r
- END IF;\r
-\r
- FOR i IN 1..nb_points LOOP\r
- tmp.path = cur_path || ARRAY[i];\r
- tmp.geom := ST_PointN(the_geom, i);\r
- RETURN NEXT tmp;\r
- END LOOP;\r
- \r
-END\r
-$$ LANGUAGE plpgsql;\r
-\r
------------------------------------------------------------------------\r
--- ST_DumpPoints()\r
------------------------------------------------------------------------\r
--- This function mimicks that of ST_Dump for collections, but this function \r
--- that returns a path and all the points that make up a particular geometry.\r
--- This current implementation in plpgsql does not scale very well at all.\r
--- and should be ported to C at some point.\r
--- Availability: 1.5.0\r
-CREATE OR REPLACE FUNCTION ST_DumpPoints(geometry) RETURNS SETOF geometry_dump AS $$\r
- SELECT * FROM _ST_DumpPoints($1, NULL);\r
-$$ LANGUAGE SQL STRICT;\r
-\r
-\r
-\r
--------------------------------------------------------------------\r
--- SPATIAL_REF_SYS\r
--------------------------------------------------------------------\r
-CREATE TABLE spatial_ref_sys (\r
- srid integer not null primary key\r
- check (srid > 0 and srid <= SRID_USR_MAX),\r
- auth_name varchar(256),\r
- auth_srid integer,\r
- srtext varchar(2048),\r
- proj4text varchar(2048)\r
-);\r
-\r
-\r
------------------------------------------------------------------------\r
--- POPULATE_GEOMETRY_COLUMNS()\r
------------------------------------------------------------------------\r
--- Truncates and refills the geometry_columns table from all tables and\r
--- views in the database that contain geometry columns. This function\r
--- is a simple wrapper for populate_geometry_columns(oid). In essence,\r
--- this function ensures every geometry column in the database has the\r
--- appropriate spatial contraints (for tables) and exists in the\r
--- geometry_columns table.\r
--- Availability: 1.4.0\r
--- Revised: 2.0.0 -- no longer deletes from geometry_columns\r
--- Has new use_typmod option that defaults to true. \r
--- If use typmod is set to false will use old constraint behavior.\r
--- Will only touch table missing typmod or geometry constraints\r
------------------------------------------------------------------------\r
-CREATE OR REPLACE FUNCTION populate_geometry_columns(use_typmod boolean DEFAULT true)\r
- RETURNS text AS\r
-$$\r
-DECLARE\r
- inserted integer;\r
- oldcount integer;\r
- probed integer;\r
- stale integer;\r
- gcs RECORD;\r
- gc RECORD;\r
- gsrid integer;\r
- gndims integer;\r
- gtype text;\r
- query text;\r
- gc_is_valid boolean;\r
-\r
-BEGIN\r
- SELECT count(*) INTO oldcount FROM geometry_columns;\r
- inserted := 0;\r
-\r
- -- Count the number of geometry columns in all tables and views\r
- SELECT count(DISTINCT c.oid) INTO probed\r
- FROM pg_class c,\r
- pg_attribute a,\r
- pg_type t,\r
- pg_namespace n\r
- WHERE (c.relkind = 'r' OR c.relkind = 'v')\r
- AND t.typname = 'geometry'\r
- AND a.attisdropped = false\r
- AND a.atttypid = t.oid\r
- AND a.attrelid = c.oid\r
- AND c.relnamespace = n.oid\r
- AND n.nspname NOT ILIKE 'pg_temp%' AND c.relname != 'raster_columns' ;\r
-\r
- -- Iterate through all non-dropped geometry columns\r
- RAISE DEBUG 'Processing Tables.....';\r
-\r
- FOR gcs IN\r
- SELECT DISTINCT ON (c.oid) c.oid, n.nspname, c.relname\r
- FROM pg_class c,\r
- pg_attribute a,\r
- pg_type t,\r
- pg_namespace n\r
- WHERE c.relkind = 'r'\r
- AND t.typname = 'geometry'\r
- AND a.attisdropped = false\r
- AND a.atttypid = t.oid\r
- AND a.attrelid = c.oid\r
- AND c.relnamespace = n.oid\r
- AND n.nspname NOT ILIKE 'pg_temp%' AND c.relname != 'raster_columns' \r
- LOOP\r
-\r
- inserted := inserted + populate_geometry_columns(gcs.oid, use_typmod);\r
- END LOOP;\r
-\r
- IF oldcount > inserted THEN\r
- stale = oldcount-inserted;\r
- ELSE\r
- stale = 0;\r
- END IF;\r
-\r
- RETURN 'probed:' ||probed|| ' inserted:'||inserted;\r
-END\r
-\r
-$$\r
-LANGUAGE 'plpgsql' VOLATILE;\r
-\r
------------------------------------------------------------------------\r
--- POPULATE_GEOMETRY_COLUMNS(tbl_oid oid)\r
------------------------------------------------------------------------\r
--- DELETEs from and reINSERTs into the geometry_columns table all entries\r
--- associated with the oid of a particular table or view.\r
---\r
--- If the provided oid is for a table, this function tries to determine\r
--- the srid, dimension, and geometry type of the all geometries\r
--- in the table, adding contraints as necessary to the table. If\r
--- successful, an appropriate row is inserted into the geometry_columns\r
--- table, otherwise, the exception is caught and an error notice is\r
--- raised describing the problem. (This is so the wrapper function\r
--- populate_geometry_columns() can apply spatial constraints to all\r
--- geometry columns across an entire database at once without erroring\r
--- out)\r
---\r
--- If the provided oid is for a view, as with a table oid, this function\r
--- tries to determine the srid, dimension, and type of all the geometries\r
--- in the view, inserting appropriate entries into the geometry_columns\r
--- table.\r
--- Availability: 1.4.0\r
------------------------------------------------------------------------\r
-CREATE OR REPLACE FUNCTION populate_geometry_columns(tbl_oid oid, use_typmod boolean DEFAULT true)\r
- RETURNS integer AS\r
-$$\r
-DECLARE\r
- gcs RECORD;\r
- gc RECORD;\r
- gc_old RECORD;\r
- gsrid integer;\r
- gndims integer;\r
- gtype text;\r
- query text;\r
- gc_is_valid boolean;\r
- inserted integer;\r
- constraint_successful boolean := false;\r
-\r
-BEGIN\r
- inserted := 0;\r
-\r
- -- Iterate through all geometry columns in this table\r
- FOR gcs IN\r
- SELECT n.nspname, c.relname, a.attname\r
- FROM pg_class c,\r
- pg_attribute a,\r
- pg_type t,\r
- pg_namespace n\r
- WHERE c.relkind = 'r'\r
- AND t.typname = 'geometry'\r
- AND a.attisdropped = false\r
- AND a.atttypid = t.oid\r
- AND a.attrelid = c.oid\r
- AND c.relnamespace = n.oid\r
- AND n.nspname NOT ILIKE 'pg_temp%'\r
- AND c.oid = tbl_oid\r
- LOOP\r
-\r
- RAISE DEBUG 'Processing table %.%.%', gcs.nspname, gcs.relname, gcs.attname;\r
- \r
- gc_is_valid := true;\r
- -- Find the srid, coord_dimension, and type of current geometry\r
- -- in geometry_columns -- which is now a view\r
- \r
- SELECT type, srid, coord_dimension INTO gc_old \r
- FROM geometry_columns \r
- WHERE f_table_schema = gcs.nspname AND f_table_name = gcs.relname AND f_geometry_column = gcs.attname; \r
- \r
- IF upper(gc_old.type) = 'GEOMETRY' THEN\r
- -- This is an unconstrained geometry we need to do something\r
- -- We need to figure out what to set the type by inspecting the data\r
- EXECUTE 'SELECT st_srid(' || quote_ident(gcs.attname) || ') As srid, GeometryType(' || quote_ident(gcs.attname) || ') As type, ST_NDims(' || quote_ident(gcs.attname) || ') As dims ' ||\r
- ' FROM ONLY ' || quote_ident(gcs.nspname) || '.' || quote_ident(gcs.relname) || \r
- ' WHERE ' || quote_ident(gcs.attname) || ' IS NOT NULL LIMIT 1;'\r
- INTO gc;\r
- IF gc IS NULL THEN -- there is no data so we can not determine geometry type\r
- RAISE WARNING 'No data in table %.%, so no information to determine geometry type and srid', gcs.nspname, gcs.relname;\r
- RETURN 0;\r
- END IF;\r
- gsrid := gc.srid; gtype := gc.type; gndims := gc.dims;\r
- \r
- IF use_typmod THEN\r
- BEGIN\r
- EXECUTE 'ALTER TABLE ' || quote_ident(gcs.nspname) || '.' || quote_ident(gcs.relname) || ' ALTER COLUMN ' || quote_ident(gcs.attname) || \r
- ' TYPE geometry(' || postgis_type_name(gtype, gndims, true) || ', ' || gsrid::text || ') ';\r
- inserted := inserted + 1;\r
- EXCEPTION\r
- WHEN invalid_parameter_value THEN\r
- RAISE WARNING 'Could not convert ''%'' in ''%.%'' to use typmod with srid %, type: % ', quote_ident(gcs.attname), quote_ident(gcs.nspname), quote_ident(gcs.relname), gsrid, postgis_type_name(gtype, gndims, true);\r
- gc_is_valid := false;\r
- END;\r
- \r
- ELSE\r
- -- Try to apply srid check to column\r
- constraint_successful = false;\r
- IF (gsrid > 0 AND postgis_constraint_srid(gcs.nspname, gcs.relname,gcs.attname) IS NULL ) THEN\r
- BEGIN\r
- EXECUTE 'ALTER TABLE ONLY ' || quote_ident(gcs.nspname) || '.' || quote_ident(gcs.relname) || \r
- ' ADD CONSTRAINT ' || quote_ident('enforce_srid_' || gcs.attname) || \r
- ' CHECK (st_srid(' || quote_ident(gcs.attname) || ') = ' || gsrid || ')';\r
- constraint_successful := true;\r
- EXCEPTION\r
- WHEN check_violation THEN\r
- RAISE WARNING 'Not inserting ''%'' in ''%.%'' into geometry_columns: could not apply constraint CHECK (st_srid(%) = %)', quote_ident(gcs.attname), quote_ident(gcs.nspname), quote_ident(gcs.relname), quote_ident(gcs.attname), gsrid;\r
- gc_is_valid := false;\r
- END;\r
- END IF;\r
- \r
- -- Try to apply ndims check to column\r
- IF (gndims IS NOT NULL AND postgis_constraint_dims(gcs.nspname, gcs.relname,gcs.attname) IS NULL ) THEN\r
- BEGIN\r
- EXECUTE 'ALTER TABLE ONLY ' || quote_ident(gcs.nspname) || '.' || quote_ident(gcs.relname) || '\r
- ADD CONSTRAINT ' || quote_ident('enforce_dims_' || gcs.attname) || '\r
- CHECK (st_ndims(' || quote_ident(gcs.attname) || ') = '||gndims||')';\r
- constraint_successful := true;\r
- EXCEPTION\r
- WHEN check_violation THEN\r
- RAISE WARNING 'Not inserting ''%'' in ''%.%'' into geometry_columns: could not apply constraint CHECK (st_ndims(%) = %)', quote_ident(gcs.attname), quote_ident(gcs.nspname), quote_ident(gcs.relname), quote_ident(gcs.attname), gndims;\r
- gc_is_valid := false;\r
- END;\r
- END IF;\r
- \r
- -- Try to apply geometrytype check to column\r
- IF (gtype IS NOT NULL AND postgis_constraint_type(gcs.nspname, gcs.relname,gcs.attname) IS NULL ) THEN\r
- BEGIN\r
- EXECUTE 'ALTER TABLE ONLY ' || quote_ident(gcs.nspname) || '.' || quote_ident(gcs.relname) || '\r
- ADD CONSTRAINT ' || quote_ident('enforce_geotype_' || gcs.attname) || '\r
- CHECK ((geometrytype(' || quote_ident(gcs.attname) || ') = ' || quote_literal(gtype) || ') OR (' || quote_ident(gcs.attname) || ' IS NULL))';\r
- constraint_successful := true;\r
- EXCEPTION\r
- WHEN check_violation THEN\r
- -- No geometry check can be applied. This column contains a number of geometry types.\r
- RAISE WARNING 'Could not add geometry type check (%) to table column: %.%.%', gtype, quote_ident(gcs.nspname),quote_ident(gcs.relname),quote_ident(gcs.attname);\r
- END;\r
- END IF;\r
- --only count if we were successful in applying at least one constraint\r
- IF constraint_successful THEN\r
- inserted := inserted + 1;\r
- END IF;\r
- END IF; \r
- END IF;\r
-\r
- END LOOP;\r
-\r
- RETURN inserted;\r
-END\r
-\r
-$$\r
-LANGUAGE 'plpgsql' VOLATILE;\r
-\r
------------------------------------------------------------------------\r
--- ADDGEOMETRYCOLUMN\r
--- <catalogue>, <schema>, <table>, <column>, <srid>, <type>, <dim>\r
------------------------------------------------------------------------\r
---\r
--- Type can be one of GEOMETRY, GEOMETRYCOLLECTION, POINT, MULTIPOINT, POLYGON,\r
--- MULTIPOLYGON, LINESTRING, or MULTILINESTRING.\r
---\r
--- Geometry types (except GEOMETRY) are checked for consistency using a CHECK constraint.\r
--- Uses an ALTER TABLE command to add the geometry column to the table.\r
--- Addes a row to geometry_columns.\r
--- Addes a constraint on the table that all the geometries MUST have the same\r
--- SRID. Checks the coord_dimension to make sure its between 0 and 3.\r
--- Should also check the precision grid (future expansion).\r
---\r
------------------------------------------------------------------------\r
-CREATE OR REPLACE FUNCTION AddGeometryColumn(catalog_name varchar,schema_name varchar,table_name varchar,column_name varchar,new_srid_in integer,new_type varchar,new_dim integer, use_typmod boolean DEFAULT true)\r
- RETURNS text\r
- AS\r
-$$\r
-DECLARE\r
- rec RECORD;\r
- sr varchar;\r
- real_schema name;\r
- sql text;\r
- new_srid integer;\r
-\r
-BEGIN\r
-\r
- -- Verify geometry type\r
- IF (postgis_type_name(new_type,new_dim) IS NULL )\r
- THEN\r
- RAISE EXCEPTION 'Invalid type name "%(%)" - valid ones are:\r
- POINT, MULTIPOINT,\r
- LINESTRING, MULTILINESTRING,\r
- POLYGON, MULTIPOLYGON,\r
- CIRCULARSTRING, COMPOUNDCURVE, MULTICURVE,\r
- CURVEPOLYGON, MULTISURFACE,\r
- GEOMETRY, GEOMETRYCOLLECTION,\r
- POINTM, MULTIPOINTM,\r
- LINESTRINGM, MULTILINESTRINGM,\r
- POLYGONM, MULTIPOLYGONM,\r
- CIRCULARSTRINGM, COMPOUNDCURVEM, MULTICURVEM\r
- CURVEPOLYGONM, MULTISURFACEM, TRIANGLE, TRIANGLEM,\r
- POLYHEDRALSURFACE, POLYHEDRALSURFACEM, TIN, TINM\r
- or GEOMETRYCOLLECTIONM', new_type, new_dim;\r
- RETURN 'fail';\r
- END IF;\r
-\r
-\r
- -- Verify dimension\r
- IF ( (new_dim >4) OR (new_dim <0) ) THEN\r
- RAISE EXCEPTION 'invalid dimension';\r
- RETURN 'fail';\r
- END IF;\r
-\r
- IF ( (new_type LIKE '%M') AND (new_dim!=3) ) THEN\r
- RAISE EXCEPTION 'TypeM needs 3 dimensions';\r
- RETURN 'fail';\r
- END IF;\r
-\r
-\r
- -- Verify SRID\r
- IF ( new_srid_in > 0 ) THEN\r
- IF new_srid_in > SRID_USR_MAX THEN\r
- RAISE EXCEPTION 'AddGeometryColumn() - SRID must be <= %', SRID_USR_MAX;\r
- END IF;\r
- new_srid := new_srid_in;\r
- SELECT SRID INTO sr FROM spatial_ref_sys WHERE SRID = new_srid;\r
- IF NOT FOUND THEN\r
- RAISE EXCEPTION 'AddGeometryColumn() - invalid SRID';\r
- RETURN 'fail';\r
- END IF;\r
- ELSE\r
- new_srid := ST_SRID('POINT EMPTY'::geometry);\r
- IF ( new_srid_in != new_srid ) THEN\r
- RAISE NOTICE 'SRID value % converted to the officially unknown SRID value %', new_srid_in, new_srid;\r
- END IF;\r
- END IF;\r
-\r
-\r
- -- Verify schema\r
- IF ( schema_name IS NOT NULL AND schema_name != '' ) THEN\r
- sql := 'SELECT nspname FROM pg_namespace ' ||\r
- 'WHERE text(nspname) = ' || quote_literal(schema_name) ||\r
- 'LIMIT 1';\r
- RAISE DEBUG '%', sql;\r
- EXECUTE sql INTO real_schema;\r
-\r
- IF ( real_schema IS NULL ) THEN\r
- RAISE EXCEPTION 'Schema % is not a valid schemaname', quote_literal(schema_name);\r
- RETURN 'fail';\r
- END IF;\r
- END IF;\r
-\r
- IF ( real_schema IS NULL ) THEN\r
- RAISE DEBUG 'Detecting schema';\r
- sql := 'SELECT n.nspname AS schemaname ' ||\r
- 'FROM pg_catalog.pg_class c ' ||\r
- 'JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace ' ||\r
- 'WHERE c.relkind = ' || quote_literal('r') ||\r
- ' AND n.nspname NOT IN (' || quote_literal('pg_catalog') || ', ' || quote_literal('pg_toast') || ')' ||\r
- ' AND pg_catalog.pg_table_is_visible(c.oid)' ||\r
- ' AND c.relname = ' || quote_literal(table_name);\r
- RAISE DEBUG '%', sql;\r
- EXECUTE sql INTO real_schema;\r
-\r
- IF ( real_schema IS NULL ) THEN\r
- RAISE EXCEPTION 'Table % does not occur in the search_path', quote_literal(table_name);\r
- RETURN 'fail';\r
- END IF;\r
- END IF;\r
-\r
-\r
- -- Add geometry column to table\r
- IF use_typmod THEN\r
- sql := 'ALTER TABLE ' ||\r
- quote_ident(real_schema) || '.' || quote_ident(table_name)\r
- || ' ADD COLUMN ' || quote_ident(column_name) ||\r
- ' geometry(' || postgis_type_name(new_type, new_dim) || ', ' || new_srid::text || ')';\r
- RAISE DEBUG '%', sql;\r
- ELSE\r
- sql := 'ALTER TABLE ' ||\r
- quote_ident(real_schema) || '.' || quote_ident(table_name)\r
- || ' ADD COLUMN ' || quote_ident(column_name) ||\r
- ' geometry ';\r
- RAISE DEBUG '%', sql;\r
- END IF;\r
- EXECUTE sql;\r
-\r
- IF NOT use_typmod THEN\r
- -- Add table CHECKs\r
- sql := 'ALTER TABLE ' ||\r
- quote_ident(real_schema) || '.' || quote_ident(table_name)\r
- || ' ADD CONSTRAINT '\r
- || quote_ident('enforce_srid_' || column_name)\r
- || ' CHECK (st_srid(' || quote_ident(column_name) ||\r
- ') = ' || new_srid::text || ')' ;\r
- RAISE DEBUG '%', sql;\r
- EXECUTE sql;\r
- \r
- sql := 'ALTER TABLE ' ||\r
- quote_ident(real_schema) || '.' || quote_ident(table_name)\r
- || ' ADD CONSTRAINT '\r
- || quote_ident('enforce_dims_' || column_name)\r
- || ' CHECK (st_ndims(' || quote_ident(column_name) ||\r
- ') = ' || new_dim::text || ')' ;\r
- RAISE DEBUG '%', sql;\r
- EXECUTE sql;\r
- \r
- IF ( NOT (new_type = 'GEOMETRY')) THEN\r
- sql := 'ALTER TABLE ' ||\r
- quote_ident(real_schema) || '.' || quote_ident(table_name) || ' ADD CONSTRAINT ' ||\r
- quote_ident('enforce_geotype_' || column_name) ||\r
- ' CHECK (GeometryType(' ||\r
- quote_ident(column_name) || ')=' ||\r
- quote_literal(new_type) || ' OR (' ||\r
- quote_ident(column_name) || ') is null)';\r
- RAISE DEBUG '%', sql;\r
- EXECUTE sql;\r
- END IF;\r
- END IF;\r
-\r
- RETURN\r
- real_schema || '.' ||\r
- table_name || '.' || column_name ||\r
- ' SRID:' || new_srid::text ||\r
- ' TYPE:' || new_type ||\r
- ' DIMS:' || new_dim::text || ' ';\r
-END;\r
-$$\r
-LANGUAGE 'plpgsql' VOLATILE STRICT;\r
-\r
-----------------------------------------------------------------------------\r
--- ADDGEOMETRYCOLUMN ( <schema>, <table>, <column>, <srid>, <type>, <dim> )\r
-----------------------------------------------------------------------------\r
---\r
--- This is a wrapper to the real AddGeometryColumn, for use\r
--- when catalogue is undefined\r
---\r
-----------------------------------------------------------------------------\r
-CREATE OR REPLACE FUNCTION AddGeometryColumn(schema_name varchar,table_name varchar,column_name varchar,new_srid integer,new_type varchar,new_dim integer, use_typmod boolean DEFAULT true) RETURNS text AS $$\r
-DECLARE\r
- ret text;\r
-BEGIN\r
- SELECT AddGeometryColumn('',$1,$2,$3,$4,$5,$6,$7) into ret;\r
- RETURN ret;\r
-END;\r
-$$\r
-LANGUAGE 'plpgsql' STABLE STRICT;\r
-\r
-----------------------------------------------------------------------------\r
--- ADDGEOMETRYCOLUMN ( <table>, <column>, <srid>, <type>, <dim> )\r
-----------------------------------------------------------------------------\r
---\r
--- This is a wrapper to the real AddGeometryColumn, for use\r
--- when catalogue and schema are undefined\r
---\r
-----------------------------------------------------------------------------\r
-CREATE OR REPLACE FUNCTION AddGeometryColumn(table_name varchar,column_name varchar,new_srid integer,new_type varchar,new_dim integer, use_typmod boolean DEFAULT true) RETURNS text AS $$\r
-DECLARE\r
- ret text;\r
-BEGIN\r
- SELECT AddGeometryColumn('','',$1,$2,$3,$4,$5, $6) into ret;\r
- RETURN ret;\r
-END;\r
-$$\r
-LANGUAGE 'plpgsql' VOLATILE STRICT;\r
-\r
------------------------------------------------------------------------\r
--- DROPGEOMETRYCOLUMN\r
--- <catalogue>, <schema>, <table>, <column>\r
------------------------------------------------------------------------\r
---\r
--- Removes geometry column reference from geometry_columns table.\r
--- Drops the column with pgsql >= 73.\r
--- Make some silly enforcements on it for pgsql < 73\r
---\r
------------------------------------------------------------------------\r
-CREATE OR REPLACE FUNCTION DropGeometryColumn(catalog_name varchar, schema_name varchar,table_name varchar,column_name varchar)\r
- RETURNS text\r
- AS\r
-$$\r
-DECLARE\r
- myrec RECORD;\r
- okay boolean;\r
- real_schema name;\r
-\r
-BEGIN\r
-\r
-\r
- -- Find, check or fix schema_name\r
- IF ( schema_name != '' ) THEN\r
- okay = false;\r
-\r
- FOR myrec IN SELECT nspname FROM pg_namespace WHERE text(nspname) = schema_name LOOP\r
- okay := true;\r
- END LOOP;\r
-\r
- IF ( okay <> true ) THEN\r
- RAISE NOTICE 'Invalid schema name - using current_schema()';\r
- SELECT current_schema() into real_schema;\r
- ELSE\r
- real_schema = schema_name;\r
- END IF;\r
- ELSE\r
- SELECT current_schema() into real_schema;\r
- END IF;\r
-\r
- -- Find out if the column is in the geometry_columns table\r
- okay = false;\r
- FOR myrec IN SELECT * from geometry_columns where f_table_schema = text(real_schema) and f_table_name = table_name and f_geometry_column = column_name LOOP\r
- okay := true;\r
- END LOOP;\r
- IF (okay <> true) THEN\r
- RAISE EXCEPTION 'column not found in geometry_columns table';\r
- RETURN false;\r
- END IF;\r
-\r
- -- Remove table column\r
- EXECUTE 'ALTER TABLE ' || quote_ident(real_schema) || '.' ||\r
- quote_ident(table_name) || ' DROP COLUMN ' ||\r
- quote_ident(column_name);\r
-\r
- RETURN real_schema || '.' || table_name || '.' || column_name ||' effectively removed.';\r
-\r
-END;\r
-$$\r
-LANGUAGE 'plpgsql' VOLATILE STRICT;\r
-\r
------------------------------------------------------------------------\r
--- DROPGEOMETRYCOLUMN\r
--- <schema>, <table>, <column>\r
------------------------------------------------------------------------\r
---\r
--- This is a wrapper to the real DropGeometryColumn, for use\r
--- when catalogue is undefined\r
---\r
------------------------------------------------------------------------\r
-CREATE OR REPLACE FUNCTION DropGeometryColumn(schema_name varchar, table_name varchar,column_name varchar)\r
- RETURNS text\r
- AS\r
-$$\r
-DECLARE\r
- ret text;\r
-BEGIN\r
- SELECT DropGeometryColumn('',$1,$2,$3) into ret;\r
- RETURN ret;\r
-END;\r
-$$\r
-LANGUAGE 'plpgsql' VOLATILE STRICT;\r
-\r
------------------------------------------------------------------------\r
--- DROPGEOMETRYCOLUMN\r
--- <table>, <column>\r
------------------------------------------------------------------------\r
---\r
--- This is a wrapper to the real DropGeometryColumn, for use\r
--- when catalogue and schema is undefined.\r
---\r
------------------------------------------------------------------------\r
-CREATE OR REPLACE FUNCTION DropGeometryColumn(table_name varchar, column_name varchar)\r
- RETURNS text\r
- AS\r
-$$\r
-DECLARE\r
- ret text;\r
-BEGIN\r
- SELECT DropGeometryColumn('','',$1,$2) into ret;\r
- RETURN ret;\r
-END;\r
-$$\r
-LANGUAGE 'plpgsql' VOLATILE STRICT;\r
-\r
------------------------------------------------------------------------\r
--- DROPGEOMETRYTABLE\r
--- <catalogue>, <schema>, <table>\r
------------------------------------------------------------------------\r
---\r
--- Drop a table and all its references in geometry_columns\r
---\r
------------------------------------------------------------------------\r
-CREATE OR REPLACE FUNCTION DropGeometryTable(catalog_name varchar, schema_name varchar, table_name varchar)\r
- RETURNS text\r
- AS\r
-$$\r
-DECLARE\r
- real_schema name;\r
-\r
-BEGIN\r
-\r
- IF ( schema_name = '' ) THEN\r
- SELECT current_schema() into real_schema;\r
- ELSE\r
- real_schema = schema_name;\r
- END IF;\r
-\r
- -- TODO: Should we warn if table doesn't exist probably instead just saying dropped\r
- -- Remove table\r
- EXECUTE 'DROP TABLE IF EXISTS '\r
- || quote_ident(real_schema) || '.' ||\r
- quote_ident(table_name) || ' RESTRICT';\r
-\r
- RETURN\r
- real_schema || '.' ||\r
- table_name ||' dropped.';\r
-\r
-END;\r
-$$\r
-LANGUAGE 'plpgsql' VOLATILE STRICT;\r
-\r
------------------------------------------------------------------------\r
--- DROPGEOMETRYTABLE\r
--- <schema>, <table>\r
------------------------------------------------------------------------\r
---\r
--- Drop a table and all its references in geometry_columns\r
---\r
------------------------------------------------------------------------\r
-CREATE OR REPLACE FUNCTION DropGeometryTable(schema_name varchar, table_name varchar) RETURNS text AS\r
-$$ SELECT DropGeometryTable('',$1,$2) $$\r
-LANGUAGE 'sql' VOLATILE STRICT;\r
-\r
------------------------------------------------------------------------\r
--- DROPGEOMETRYTABLE\r
--- <table>\r
------------------------------------------------------------------------\r
---\r
--- Drop a table and all its references in geometry_columns\r
--- For PG>=73 use current_schema()\r
---\r
------------------------------------------------------------------------\r
-CREATE OR REPLACE FUNCTION DropGeometryTable(table_name varchar) RETURNS text AS\r
-$$ SELECT DropGeometryTable('','',$1) $$\r
-LANGUAGE 'sql' VOLATILE STRICT;\r
-\r
------------------------------------------------------------------------\r
--- UPDATEGEOMETRYSRID\r
--- <catalogue>, <schema>, <table>, <column>, <srid>\r
------------------------------------------------------------------------\r
---\r
--- Change SRID of all features in a spatially-enabled table\r
---\r
------------------------------------------------------------------------\r
-CREATE OR REPLACE FUNCTION UpdateGeometrySRID(catalogn_name varchar,schema_name varchar,table_name varchar,column_name varchar,new_srid_in integer)\r
- RETURNS text\r
- AS\r
-$$\r
-DECLARE\r
- myrec RECORD;\r
- okay boolean;\r
- cname varchar;\r
- real_schema name;\r
- unknown_srid integer;\r
- new_srid integer := new_srid_in;\r
-\r
-BEGIN\r
-\r
-\r
- -- Find, check or fix schema_name\r
- IF ( schema_name != '' ) THEN\r
- okay = false;\r
-\r
- FOR myrec IN SELECT nspname FROM pg_namespace WHERE text(nspname) = schema_name LOOP\r
- okay := true;\r
- END LOOP;\r
-\r
- IF ( okay <> true ) THEN\r
- RAISE EXCEPTION 'Invalid schema name';\r
- ELSE\r
- real_schema = schema_name;\r
- END IF;\r
- ELSE\r
- SELECT INTO real_schema current_schema()::text;\r
- END IF;\r
-\r
- -- Ensure that column_name is in geometry_columns\r
- okay = false;\r
- FOR myrec IN SELECT type, coord_dimension FROM geometry_columns WHERE f_table_schema = text(real_schema) and f_table_name = table_name and f_geometry_column = column_name LOOP\r
- okay := true;\r
- END LOOP;\r
- IF (NOT okay) THEN\r
- RAISE EXCEPTION 'column not found in geometry_columns table';\r
- RETURN false;\r
- END IF;\r
-\r
- -- Ensure that new_srid is valid\r
- IF ( new_srid > 0 ) THEN\r
- IF ( SELECT count(*) = 0 from spatial_ref_sys where srid = new_srid ) THEN\r
- RAISE EXCEPTION 'invalid SRID: % not found in spatial_ref_sys', new_srid;\r
- RETURN false;\r
- END IF;\r
- ELSE\r
- unknown_srid := ST_SRID('POINT EMPTY'::geometry);\r
- IF ( new_srid != unknown_srid ) THEN\r
- new_srid := unknown_srid;\r
- RAISE NOTICE 'SRID value % converted to the officially unknown SRID value %', new_srid_in, new_srid;\r
- END IF;\r
- END IF;\r
-\r
- IF postgis_constraint_srid(schema_name, table_name, column_name) IS NOT NULL THEN \r
- -- srid was enforced with constraints before, keep it that way.\r
- -- Make up constraint name\r
- cname = 'enforce_srid_' || column_name;\r
- \r
- -- Drop enforce_srid constraint\r
- EXECUTE 'ALTER TABLE ' || quote_ident(real_schema) ||\r
- '.' || quote_ident(table_name) ||\r
- ' DROP constraint ' || quote_ident(cname);\r
- \r
- -- Update geometries SRID\r
- EXECUTE 'UPDATE ' || quote_ident(real_schema) ||\r
- '.' || quote_ident(table_name) ||\r
- ' SET ' || quote_ident(column_name) ||\r
- ' = ST_SetSRID(' || quote_ident(column_name) ||\r
- ', ' || new_srid::text || ')';\r
- \r
- -- Reset enforce_srid constraint\r
- EXECUTE 'ALTER TABLE ' || quote_ident(real_schema) ||\r
- '.' || quote_ident(table_name) ||\r
- ' ADD constraint ' || quote_ident(cname) ||\r
- ' CHECK (st_srid(' || quote_ident(column_name) ||\r
- ') = ' || new_srid::text || ')';\r
- ELSE \r
- -- We will use typmod to enforce if no srid constraints\r
- -- We are using postgis_type_name to lookup the new name \r
- -- (in case Paul changes his mind and flips geometry_columns to return old upper case name) \r
- EXECUTE 'ALTER TABLE ' || quote_ident(real_schema) || '.' || quote_ident(table_name) || \r
- ' ALTER COLUMN ' || quote_ident(column_name) || ' TYPE geometry(' || postgis_type_name(myrec.type, myrec.coord_dimension, true) || ', ' || new_srid::text || ') USING ST_SetSRID(' || quote_ident(column_name) || ',' || new_srid::text || ');' ;\r
- END IF;\r
-\r
- RETURN real_schema || '.' || table_name || '.' || column_name ||' SRID changed to ' || new_srid::text;\r
-\r
-END;\r
-$$\r
-LANGUAGE 'plpgsql' VOLATILE STRICT;\r
-\r
------------------------------------------------------------------------\r
--- UPDATEGEOMETRYSRID\r
--- <schema>, <table>, <column>, <srid>\r
------------------------------------------------------------------------\r
-CREATE OR REPLACE FUNCTION UpdateGeometrySRID(varchar,varchar,varchar,integer)\r
- RETURNS text\r
- AS $$\r
-DECLARE\r
- ret text;\r
-BEGIN\r
- SELECT UpdateGeometrySRID('',$1,$2,$3,$4) into ret;\r
- RETURN ret;\r
-END;\r
-$$\r
-LANGUAGE 'plpgsql' VOLATILE STRICT;\r
-\r
------------------------------------------------------------------------\r
--- UPDATEGEOMETRYSRID\r
--- <table>, <column>, <srid>\r
------------------------------------------------------------------------\r
-CREATE OR REPLACE FUNCTION UpdateGeometrySRID(varchar,varchar,integer)\r
- RETURNS text\r
- AS $$\r
-DECLARE\r
- ret text;\r
-BEGIN\r
- SELECT UpdateGeometrySRID('','',$1,$2,$3) into ret;\r
- RETURN ret;\r
-END;\r
-$$\r
-LANGUAGE 'plpgsql' VOLATILE STRICT;\r
-\r
------------------------------------------------------------------------\r
--- FIND_SRID( <schema>, <table>, <geom col> )\r
------------------------------------------------------------------------\r
-CREATE OR REPLACE FUNCTION find_srid(varchar,varchar,varchar) RETURNS int4 AS\r
-$$\r
-DECLARE\r
- schem text;\r
- tabl text;\r
- sr int4;\r
-BEGIN\r
- IF $1 IS NULL THEN\r
- RAISE EXCEPTION 'find_srid() - schema is NULL!';\r
- END IF;\r
- IF $2 IS NULL THEN\r
- RAISE EXCEPTION 'find_srid() - table name is NULL!';\r
- END IF;\r
- IF $3 IS NULL THEN\r
- RAISE EXCEPTION 'find_srid() - column name is NULL!';\r
- END IF;\r
- schem = $1;\r
- tabl = $2;\r
--- if the table contains a . and the schema is empty\r
--- split the table into a schema and a table\r
--- otherwise drop through to default behavior\r
- IF ( schem = '' and tabl LIKE '%.%' ) THEN\r
- schem = substr(tabl,1,strpos(tabl,'.')-1);\r
- tabl = substr(tabl,length(schem)+2);\r
- ELSE\r
- schem = schem || '%';\r
- END IF;\r
-\r
- select SRID into sr from geometry_columns where f_table_schema like schem and f_table_name = tabl and f_geometry_column = $3;\r
- IF NOT FOUND THEN\r
- RAISE EXCEPTION 'find_srid() - couldnt find the corresponding SRID - is the geometry registered in the GEOMETRY_COLUMNS table? Is there an uppercase/lowercase missmatch?';\r
- END IF;\r
- return sr;\r
-END;\r
-$$\r
-LANGUAGE 'plpgsql' IMMUTABLE STRICT;\r
-\r
-\r
----------------------------------------------------------------\r
--- PROJ support\r
----------------------------------------------------------------\r
-\r
-CREATE OR REPLACE FUNCTION get_proj4_from_srid(integer) RETURNS text AS\r
-$$\r
-BEGIN\r
- RETURN proj4text::text FROM spatial_ref_sys WHERE srid= $1;\r
-END;\r
-$$\r
-LANGUAGE 'plpgsql' IMMUTABLE STRICT;\r
-\r
-CREATE OR REPLACE FUNCTION postgis_transform_geometry(geometry,text,text,int)\r
- RETURNS geometry\r
- AS 'MODULE_PATHNAME','transform_geom'\r
- LANGUAGE 'C' IMMUTABLE STRICT;\r
-\r
--- PostGIS equivalent of old function: transform(geometry,integer)\r
-CREATE OR REPLACE FUNCTION ST_Transform(geometry,integer)\r
- RETURNS geometry\r
- AS 'MODULE_PATHNAME','transform'\r
- LANGUAGE 'C' IMMUTABLE STRICT;\r
-\r
-\r
------------------------------------------------------------------------\r
--- POSTGIS_VERSION()\r
------------------------------------------------------------------------\r
-\r
-CREATE OR REPLACE FUNCTION postgis_version() RETURNS text\r
- AS 'MODULE_PATHNAME'\r
- LANGUAGE 'C' IMMUTABLE;\r
-\r
-CREATE OR REPLACE FUNCTION postgis_proj_version() RETURNS text\r
- AS 'MODULE_PATHNAME'\r
- LANGUAGE 'C' IMMUTABLE;\r
-\r
---\r
--- IMPORTANT:\r
--- Starting at 1.1.0 this function is used by postgis_proc_upgrade.pl\r
--- to extract version of postgis being installed.\r
--- Do not modify this w/out also changing postgis_proc_upgrade.pl\r
---\r
-CREATE OR REPLACE FUNCTION postgis_scripts_installed() RETURNS text\r
- AS _POSTGIS_SQL_SELECT_POSTGIS_SCRIPTS_VERSION\r
- LANGUAGE 'sql' IMMUTABLE;\r
-\r
-CREATE OR REPLACE FUNCTION postgis_lib_version() RETURNS text\r
- AS 'MODULE_PATHNAME'\r
- LANGUAGE 'C' IMMUTABLE; -- a new lib will require a new session\r
-\r
--- NOTE: starting at 1.1.0 this is the same of postgis_lib_version()\r
-CREATE OR REPLACE FUNCTION postgis_scripts_released() RETURNS text\r
- AS 'MODULE_PATHNAME'\r
- LANGUAGE 'C' IMMUTABLE;\r
-\r
-CREATE OR REPLACE FUNCTION postgis_uses_stats() RETURNS bool\r
- AS 'MODULE_PATHNAME'\r
- LANGUAGE 'C' IMMUTABLE;\r
-\r
-CREATE OR REPLACE FUNCTION postgis_geos_version() RETURNS text\r
- AS 'MODULE_PATHNAME'\r
- LANGUAGE 'C' IMMUTABLE;\r
-\r
-CREATE OR REPLACE FUNCTION postgis_svn_version() RETURNS text\r
- AS 'MODULE_PATHNAME'\r
- LANGUAGE 'C' IMMUTABLE;\r
-\r
-CREATE OR REPLACE FUNCTION postgis_libxml_version() RETURNS text\r
- AS 'MODULE_PATHNAME'\r
- LANGUAGE 'C' IMMUTABLE;\r
-\r
-CREATE OR REPLACE FUNCTION postgis_scripts_build_date() RETURNS text\r
- AS _POSTGIS_SQL_SELECT_POSTGIS_BUILD_DATE\r
- LANGUAGE 'sql' IMMUTABLE;\r
-\r
-CREATE OR REPLACE FUNCTION postgis_lib_build_date() RETURNS text\r
- AS 'MODULE_PATHNAME'\r
- LANGUAGE 'C' IMMUTABLE;\r
-\r
-CREATE OR REPLACE FUNCTION postgis_full_version() RETURNS text\r
-AS $$\r
-DECLARE\r
- libver text;\r
- svnver text;\r
- projver text;\r
- geosver text;\r
- gdalver text;\r
- libxmlver text;\r
- usestats bool;\r
- dbproc text;\r
- relproc text;\r
- fullver text;\r
-BEGIN\r
- SELECT postgis_lib_version() INTO libver;\r
- SELECT postgis_proj_version() INTO projver;\r
- SELECT postgis_geos_version() INTO geosver;\r
- BEGIN\r
- SELECT postgis_gdal_version() INTO gdalver;\r
- EXCEPTION\r
- WHEN undefined_function THEN\r
- gdalver := NULL;\r
- RAISE NOTICE 'Function postgis_gdal_version() not found. Is raster support enabled and rtpostgis.sql installed?';\r
- END;\r
- SELECT postgis_libxml_version() INTO libxmlver;\r
- SELECT postgis_uses_stats() INTO usestats;\r
- SELECT postgis_scripts_installed() INTO dbproc;\r
- SELECT postgis_scripts_released() INTO relproc;\r
- select postgis_svn_version() INTO svnver;\r
-\r
- fullver = 'POSTGIS="' || libver || '"';\r
-\r
- IF geosver IS NOT NULL THEN\r
- fullver = fullver || ' GEOS="' || geosver || '"';\r
- END IF;\r
-\r
- IF projver IS NOT NULL THEN\r
- fullver = fullver || ' PROJ="' || projver || '"';\r
- END IF;\r
-\r
- IF gdalver IS NOT NULL THEN\r
- fullver = fullver || ' GDAL="' || gdalver || '"';\r
- END IF;\r
-\r
- IF libxmlver IS NOT NULL THEN\r
- fullver = fullver || ' LIBXML="' || libxmlver || '"';\r
- END IF;\r
-\r
- IF svnver IS NOT NULL THEN\r
- fullver = fullver || ' SVN_REVISION=' || svnver;\r
- END IF;\r
- \r
- IF usestats THEN\r
- fullver = fullver || ' USE_STATS';\r
- END IF;\r
-\r
- -- fullver = fullver || ' DBPROC="' || dbproc || '"';\r
- -- fullver = fullver || ' RELPROC="' || relproc || '"';\r
-\r
- IF dbproc != relproc THEN\r
- fullver = fullver || ' (procs from ' || dbproc || ' need upgrade)';\r
- END IF;\r
-\r
- RETURN fullver;\r
-END\r
-$$\r
-LANGUAGE 'plpgsql' IMMUTABLE;\r
-\r
----------------------------------------------------------------\r
--- CASTS\r
----------------------------------------------------------------\r
- \r
-CREATE OR REPLACE FUNCTION box2d(geometry)\r
- RETURNS box2d\r
- AS 'MODULE_PATHNAME','LWGEOM_to_BOX2D'\r
- LANGUAGE 'C' IMMUTABLE STRICT;\r
-\r
-CREATE OR REPLACE FUNCTION box3d(geometry)\r
- RETURNS box3d\r
- AS 'MODULE_PATHNAME','LWGEOM_to_BOX3D'\r
- LANGUAGE 'C' IMMUTABLE STRICT;\r
-\r
-CREATE OR REPLACE FUNCTION box(geometry)\r
- RETURNS box\r
- AS 'MODULE_PATHNAME','LWGEOM_to_BOX'\r
- LANGUAGE 'C' IMMUTABLE STRICT;\r
-\r
-CREATE OR REPLACE FUNCTION box2d(box3d)\r
- RETURNS box2d\r
- AS 'MODULE_PATHNAME','BOX3D_to_BOX2D'\r
- LANGUAGE 'C' IMMUTABLE STRICT;\r
-\r
-CREATE OR REPLACE FUNCTION box3d(box2d)\r
- RETURNS box3d\r
- AS 'MODULE_PATHNAME','BOX2D_to_BOX3D'\r
- LANGUAGE 'C' IMMUTABLE STRICT;\r
-\r
-CREATE OR REPLACE FUNCTION box(box3d)\r
- RETURNS box\r
- AS 'MODULE_PATHNAME','BOX3D_to_BOX'\r
- LANGUAGE 'C' IMMUTABLE STRICT;\r
-\r
-CREATE OR REPLACE FUNCTION text(geometry)\r
- RETURNS text\r
- AS 'MODULE_PATHNAME','LWGEOM_to_text'\r
- LANGUAGE 'C' IMMUTABLE STRICT;\r
-\r
--- this is kept for backward-compatibility\r
--- Deprecation in 1.2.3\r
-CREATE OR REPLACE FUNCTION box3dtobox(box3d)\r
- RETURNS box\r
- AS 'SELECT box($1)'\r
- LANGUAGE 'SQL' IMMUTABLE STRICT;\r
-\r
-CREATE OR REPLACE FUNCTION geometry(box2d)\r
- RETURNS geometry\r
- AS 'MODULE_PATHNAME','BOX2D_to_LWGEOM'\r
- LANGUAGE 'C' IMMUTABLE STRICT;\r
-\r
-CREATE OR REPLACE FUNCTION geometry(box3d)\r
- RETURNS geometry\r
- AS 'MODULE_PATHNAME','BOX3D_to_LWGEOM'\r
- LANGUAGE 'C' IMMUTABLE STRICT;\r
-\r
-CREATE OR REPLACE FUNCTION geometry(text)\r
- RETURNS geometry\r
- AS 'MODULE_PATHNAME','parse_WKT_lwgeom'\r
- LANGUAGE 'C' IMMUTABLE STRICT;\r
-\r
-CREATE OR REPLACE FUNCTION geometry(bytea)\r
- RETURNS geometry\r
- AS 'MODULE_PATHNAME','LWGEOM_from_bytea'\r
- LANGUAGE 'C' IMMUTABLE STRICT;\r
-\r
-CREATE OR REPLACE FUNCTION bytea(geometry)\r
- RETURNS bytea\r
- AS 'MODULE_PATHNAME','LWGEOM_to_bytea'\r
- LANGUAGE 'C' IMMUTABLE STRICT;\r
-\r
--- 7.3+ explicit casting definitions\r
-CREATE CAST (geometry AS box2d) WITH FUNCTION box2d(geometry) AS IMPLICIT;\r
-CREATE CAST (geometry AS box3d) WITH FUNCTION box3d(geometry) AS IMPLICIT;\r
-CREATE CAST (geometry AS box) WITH FUNCTION box(geometry) AS IMPLICIT;\r
-CREATE CAST (box3d AS box2d) WITH FUNCTION box2d(box3d) AS IMPLICIT;\r
-CREATE CAST (box2d AS box3d) WITH FUNCTION box3d(box2d) AS IMPLICIT;\r
-CREATE CAST (box2d AS geometry) WITH FUNCTION geometry(box2d) AS IMPLICIT;\r
-CREATE CAST (box3d AS box) WITH FUNCTION box(box3d) AS IMPLICIT;\r
-CREATE CAST (box3d AS geometry) WITH FUNCTION geometry(box3d) AS IMPLICIT;\r
-CREATE CAST (text AS geometry) WITH FUNCTION geometry(text) AS IMPLICIT;\r
-CREATE CAST (geometry AS text) WITH FUNCTION text(geometry) AS IMPLICIT;\r
-CREATE CAST (bytea AS geometry) WITH FUNCTION geometry(bytea) AS IMPLICIT;\r
-CREATE CAST (geometry AS bytea) WITH FUNCTION bytea(geometry) AS IMPLICIT;\r
-\r
-\r
----------------------------------------------------------------\r
--- Algorithms\r
----------------------------------------------------------------\r
-\r
--- Availability: 1.2.2\r
-CREATE OR REPLACE FUNCTION ST_Simplify(geometry, float8)\r
- RETURNS geometry\r
- AS 'MODULE_PATHNAME', 'LWGEOM_simplify2d'\r
- LANGUAGE 'C' IMMUTABLE STRICT;\r
-\r
--- ST_SnapToGrid(input, xoff, yoff, xsize, ysize)\r
--- Availability: 1.2.2\r
-CREATE OR REPLACE FUNCTION ST_SnapToGrid(geometry, float8, float8, float8, float8)\r
- RETURNS geometry\r
- AS 'MODULE_PATHNAME', 'LWGEOM_snaptogrid'\r
- LANGUAGE 'C' IMMUTABLE STRICT;\r
-\r
--- ST_SnapToGrid(input, xsize, ysize) # offsets=0\r
--- Availability: 1.2.2\r
-CREATE OR REPLACE FUNCTION ST_SnapToGrid(geometry, float8, float8)\r
- RETURNS geometry\r
- AS 'SELECT ST_SnapToGrid($1, 0, 0, $2, $3)'\r
- LANGUAGE 'SQL' IMMUTABLE STRICT;\r
-\r
--- ST_SnapToGrid(input, size) # xsize=ysize=size, offsets=0\r
--- Availability: 1.2.2\r
-CREATE OR REPLACE FUNCTION ST_SnapToGrid(geometry, float8)\r
- RETURNS geometry\r
- AS 'SELECT ST_SnapToGrid($1, 0, 0, $2, $2)'\r
- LANGUAGE 'SQL' IMMUTABLE STRICT;\r
-\r
--- ST_SnapToGrid(input, point_offsets, xsize, ysize, zsize, msize)\r
--- Availability: 1.2.2\r
-CREATE OR REPLACE FUNCTION ST_SnapToGrid(geom1 geometry, geom2 geometry, float8, float8, float8, float8)\r
- RETURNS geometry\r
- AS 'MODULE_PATHNAME', 'LWGEOM_snaptogrid_pointoff'\r
- LANGUAGE 'C' IMMUTABLE STRICT;\r
-\r
--- Availability: 1.2.2\r
-CREATE OR REPLACE FUNCTION ST_Segmentize(geometry, float8)\r
- RETURNS geometry\r
- AS 'MODULE_PATHNAME', 'LWGEOM_segmentize2d'\r
- LANGUAGE 'C' IMMUTABLE STRICT;\r
-\r
----------------------------------------------------------------\r
--- LRS\r
----------------------------------------------------------------\r
-\r
--- Availability: 1.2.2\r
-CREATE OR REPLACE FUNCTION ST_line_interpolate_point(geometry, float8)\r
- RETURNS geometry\r
- AS 'MODULE_PATHNAME', 'LWGEOM_line_interpolate_point'\r
- LANGUAGE 'C' IMMUTABLE STRICT;\r
-\r
--- Availability: 1.2.2\r
-CREATE OR REPLACE FUNCTION ST_line_substring(geometry, float8, float8)\r
- RETURNS geometry\r
- AS 'MODULE_PATHNAME', 'LWGEOM_line_substring'\r
- LANGUAGE 'C' IMMUTABLE STRICT;\r
-\r
--- Availability: 1.2.2\r
-CREATE OR REPLACE FUNCTION ST_line_locate_point(geom1 geometry, geom2 geometry)\r
- RETURNS float8\r
- AS 'MODULE_PATHNAME', 'LWGEOM_line_locate_point'\r
- LANGUAGE 'C' IMMUTABLE STRICT;\r
-\r
--- Availability: 1.2.2\r
-CREATE OR REPLACE FUNCTION ST_locate_between_measures(geometry, float8, float8)\r
- RETURNS geometry\r
- AS 'MODULE_PATHNAME', 'LWGEOM_locate_between_m'\r
- LANGUAGE 'C' IMMUTABLE STRICT;\r
-\r
-\r
--- Availability: 1.2.2\r
-CREATE OR REPLACE FUNCTION ST_locate_along_measure(geometry, float8)\r
- RETURNS geometry\r
- AS $$ SELECT ST_locate_between_measures($1, $2, $2) $$\r
- LANGUAGE 'sql' IMMUTABLE STRICT;\r
-\r
--- Availability: 1.5.0\r
-CREATE OR REPLACE FUNCTION ST_AddMeasure(geometry, float8, float8) \r
- RETURNS geometry \r
- AS 'MODULE_PATHNAME', 'ST_AddMeasure' \r
- LANGUAGE 'C' IMMUTABLE STRICT;\r
- \r
----------------------------------------------------------------\r
--- GEOS\r
----------------------------------------------------------------\r
-\r
--- PostGIS equivalent function: intersection(geom1 geometry, geom2 geometry)\r
-CREATE OR REPLACE FUNCTION ST_Intersection(geom1 geometry, geom2 geometry)\r
- RETURNS geometry\r
- AS 'MODULE_PATHNAME','intersection'\r
- LANGUAGE 'C' IMMUTABLE STRICT\r
- COST 100;\r
-\r
--- PostGIS equivalent function: buffer(geometry,float8)\r
-CREATE OR REPLACE FUNCTION ST_Buffer(geometry,float8)\r
- RETURNS geometry\r
- AS 'MODULE_PATHNAME','buffer'\r
- LANGUAGE 'C' IMMUTABLE STRICT\r
- COST 100;\r
-\r
--- Availability: 1.5.0 - requires GEOS-3.2 or higher\r
-CREATE OR REPLACE FUNCTION _ST_Buffer(geometry,float8,cstring)\r
- RETURNS geometry\r
- AS 'MODULE_PATHNAME','buffer'\r
- LANGUAGE 'C' IMMUTABLE STRICT\r
- COST 100;\r
-\r
--- Availability: 1.2.2\r
-CREATE OR REPLACE FUNCTION ST_Buffer(geometry,float8,integer)\r
- RETURNS geometry\r
- AS $$ SELECT _ST_Buffer($1, $2,\r
- CAST('quad_segs='||CAST($3 AS text) as cstring))\r
- $$\r
- LANGUAGE 'SQL' IMMUTABLE STRICT;\r
-\r
--- Availability: 1.5.0\r
-CREATE OR REPLACE FUNCTION ST_Buffer(geometry,float8,text)\r
- RETURNS geometry\r
- AS $$ SELECT _ST_Buffer($1, $2,\r
- CAST( regexp_replace($3, '^[0123456789]+$',\r
- 'quad_segs='||$3) AS cstring)\r
- )\r
- $$\r
- LANGUAGE 'SQL' IMMUTABLE STRICT;\r
-\r
--- Availability: 2.0.0 - requires GEOS-3.2 or higher\r
-CREATE OR REPLACE FUNCTION ST_OffsetCurve(line geometry, distance float8, params text DEFAULT '')\r
- RETURNS geometry\r
- AS 'MODULE_PATHNAME','ST_OffsetCurve'\r
- LANGUAGE 'C' IMMUTABLE STRICT\r
- COST 100;\r
-\r
--- PostGIS equivalent function: convexhull(geometry)\r
-CREATE OR REPLACE FUNCTION ST_ConvexHull(geometry)\r
- RETURNS geometry\r
- AS 'MODULE_PATHNAME','convexhull'\r
- LANGUAGE 'C' IMMUTABLE STRICT\r
- COST 100;\r
-\r
--- Only accepts LINESTRING as parameters.\r
--- Availability: 1.4.0\r
-CREATE OR REPLACE FUNCTION _ST_LineCrossingDirection(geom1 geometry, geom2 geometry)\r
- RETURNS integer\r
- AS 'MODULE_PATHNAME', 'ST_LineCrossingDirection'\r
- LANGUAGE 'C' IMMUTABLE STRICT\r
- COST 100;\r
-\r
--- Availability: 1.4.0\r
-CREATE OR REPLACE FUNCTION ST_LineCrossingDirection(geom1 geometry, geom2 geometry)\r
- RETURNS integer AS\r
- $$ SELECT CASE WHEN NOT $1 && $2 THEN 0 ELSE _ST_LineCrossingDirection($1,$2) END $$\r
- LANGUAGE 'sql' IMMUTABLE;\r
-\r
--- Requires GEOS >= 3.0.0\r
--- Availability: 1.3.3\r
-CREATE OR REPLACE FUNCTION ST_SimplifyPreserveTopology(geometry, float8)\r
- RETURNS geometry\r
- AS 'MODULE_PATHNAME','topologypreservesimplify'\r
- LANGUAGE 'C' IMMUTABLE STRICT\r
- COST 100;\r
-\r
--- Requires GEOS >= 3.1.0\r
--- Availability: 1.4.0\r
-CREATE OR REPLACE FUNCTION ST_IsValidReason(geometry)\r
- RETURNS text\r
- AS 'MODULE_PATHNAME', 'isvalidreason'\r
- LANGUAGE 'C' IMMUTABLE STRICT\r
- COST 100;\r
-\r
--- Availability: 2.0.0\r
-CREATE TYPE valid_detail AS (valid bool, reason varchar, location geometry);\r
-\r
--- Requires GEOS >= 3.3.0\r
--- Availability: 2.0.0\r
-CREATE OR REPLACE FUNCTION ST_IsValidDetail(geometry)\r
- RETURNS valid_detail\r
- AS 'MODULE_PATHNAME', 'isvaliddetail'\r
- LANGUAGE 'C' IMMUTABLE STRICT\r
- COST 100;\r
-\r
--- Requires GEOS >= 3.3.0\r
--- Availability: 2.0.0\r
-CREATE OR REPLACE FUNCTION ST_IsValidDetail(geometry, int4)\r
- RETURNS valid_detail\r
- AS 'MODULE_PATHNAME', 'isvaliddetail'\r
- LANGUAGE 'C' IMMUTABLE STRICT\r
- COST 100;\r
-\r
--- Requires GEOS >= 3.3.0\r
--- Availability: 2.0.0\r
-CREATE OR REPLACE FUNCTION ST_IsValidReason(geometry, int4)\r
- RETURNS text\r
- AS $$\r
-SELECT CASE WHEN valid THEN 'Valid Geometry' ELSE reason END FROM (\r
- SELECT (ST_isValidDetail($1, $2)).*\r
-) foo\r
- $$\r
- LANGUAGE 'sql' IMMUTABLE STRICT\r
- COST 100;\r
-\r
--- Requires GEOS >= 3.3.0\r
--- Availability: 2.0.0\r
-CREATE OR REPLACE FUNCTION ST_IsValid(geometry, int4)\r
- RETURNS boolean\r
- AS 'SELECT (ST_isValidDetail($1, $2)).valid'\r
- LANGUAGE 'sql' IMMUTABLE STRICT\r
- COST 100;\r
-\r
-\r
--- Requires GEOS >= 3.2.0\r
--- Availability: 1.5.0\r
-CREATE OR REPLACE FUNCTION ST_HausdorffDistance(geom1 geometry, geom2 geometry)\r
- RETURNS FLOAT8\r
- AS 'MODULE_PATHNAME', 'hausdorffdistance'\r
- LANGUAGE 'C' IMMUTABLE STRICT\r
- COST 100;\r
-\r
--- Requires GEOS >= 3.2.0\r
--- Availability: 1.5.0\r
-CREATE OR REPLACE FUNCTION ST_HausdorffDistance(geom1 geometry, geom2 geometry, float8)\r
- RETURNS FLOAT8\r
- AS 'MODULE_PATHNAME', 'hausdorffdistancedensify'\r
- LANGUAGE 'C' IMMUTABLE STRICT\r
- COST 100;\r
-\r
--- PostGIS equivalent function: difference(geom1 geometry, geom2 geometry)\r
-CREATE OR REPLACE FUNCTION ST_Difference(geom1 geometry, geom2 geometry)\r
- RETURNS geometry\r
- AS 'MODULE_PATHNAME','difference'\r
- LANGUAGE 'C' IMMUTABLE STRICT;\r
-\r
--- PostGIS equivalent function: boundary(geometry)\r
-CREATE OR REPLACE FUNCTION ST_Boundary(geometry)\r
- RETURNS geometry\r
- AS 'MODULE_PATHNAME','boundary'\r
- LANGUAGE 'C' IMMUTABLE STRICT;\r
-\r
--- PostGIS equivalent function: symdifference(geom1 geometry, geom2 geometry)\r
-CREATE OR REPLACE FUNCTION ST_SymDifference(geom1 geometry, geom2 geometry)\r
- RETURNS geometry\r
- AS 'MODULE_PATHNAME','symdifference'\r
- LANGUAGE 'C' IMMUTABLE STRICT;\r
-\r
--- Availability: 1.2.2\r
-CREATE OR REPLACE FUNCTION ST_symmetricdifference(geom1 geometry, geom2 geometry)\r
- RETURNS geometry\r
- AS 'MODULE_PATHNAME','symdifference'\r
- LANGUAGE 'C' IMMUTABLE STRICT;\r
-\r
--- PostGIS equivalent function: GeomUnion(geom1 geometry, geom2 geometry)\r
-CREATE OR REPLACE FUNCTION ST_Union(geom1 geometry, geom2 geometry)\r
- RETURNS geometry\r
- AS 'MODULE_PATHNAME','geomunion'\r
- LANGUAGE 'C' IMMUTABLE STRICT;\r
-\r
--- Availability: 2.0.0\r
--- Requires: GEOS-3.3.0\r
-CREATE OR REPLACE FUNCTION ST_UnaryUnion(geometry)\r
- RETURNS geometry\r
- AS 'MODULE_PATHNAME','ST_UnaryUnion'\r
- LANGUAGE 'C' IMMUTABLE STRICT;\r
-\r
--- ST_RemoveRepeatedPoints(in geometry)\r
---\r
--- Removes duplicate vertices in input.\r
--- Only checks consecutive points for lineal and polygonal geoms.\r
--- Checks all points for multipoint geoms.\r
---\r
--- Availability: 2.0.0\r
-CREATE OR REPLACE FUNCTION ST_RemoveRepeatedPoints(geometry)\r
- RETURNS geometry\r
- AS 'MODULE_PATHNAME', 'ST_RemoveRepeatedPoints'\r
- LANGUAGE 'C' IMMUTABLE STRICT\r
- COST 100;\r
-\r
---------------------------------------------------------------------------------\r
--- ST_CleanGeometry / ST_MakeValid\r
---------------------------------------------------------------------------------\r
-\r
--- ST_MakeValid(in geometry)\r
---\r
--- Try to make the input valid maintaining the boundary profile.\r
--- May return a collection.\r
--- May return a geometry with inferior dimensions (dimensional collapses).\r
--- May return NULL if can't handle input.\r
---\r
--- Requires: GEOS-3.3.0\r
--- Availability: 2.0.0\r
-CREATE OR REPLACE FUNCTION ST_MakeValid(geometry)\r
- RETURNS geometry\r
- AS 'MODULE_PATHNAME', 'ST_MakeValid'\r
- LANGUAGE 'C' IMMUTABLE STRICT\r
- COST 100;\r
-\r
--- ST_CleanGeometry(in geometry)\r
---\r
--- Make input:\r
--- - Simple (lineal components)\r
--- - Valid (polygonal components)\r
--- - Obeying the RHR (if polygonal)\r
--- - Simplified of consecutive duplicated points \r
--- Ensuring:\r
--- - No input vertexes are discarded (except consecutive repeated ones)\r
--- - Output geometry type matches input\r
---\r
--- Returns NULL on failure.\r
--- \r
--- Requires: GEOS-3.3.0\r
--- Availability: 2.0.0\r
-CREATE OR REPLACE FUNCTION ST_CleanGeometry(geometry)\r
- RETURNS geometry\r
- AS 'MODULE_PATHNAME', 'ST_CleanGeometry'\r
- LANGUAGE 'C' IMMUTABLE STRICT\r
- COST 100;\r
-\r
---------------------------------------------------------------------------------\r
--- ST_Split\r
---------------------------------------------------------------------------------\r
-\r
--- ST_Split(in geometry, blade geometry)\r
---\r
--- Split a geometry in parts after cutting it with given blade.\r
--- Returns a collection containing all parts.\r
---\r
--- Note that multi-part geometries will be returned exploded,\r
--- no matter relation to blade.\r
--- \r
--- Availability: 2.0.0\r
---\r
-CREATE OR REPLACE FUNCTION ST_Split(geom1 geometry, geom2 geometry)\r
- RETURNS geometry\r
- AS 'MODULE_PATHNAME', 'ST_Split'\r
- LANGUAGE 'C' IMMUTABLE STRICT\r
- COST 100;\r
-\r
---------------------------------------------------------------------------------\r
--- ST_SharedPaths\r
---------------------------------------------------------------------------------\r
-\r
--- ST_SharedPaths(lineal1 geometry, lineal1 geometry)\r
---\r
--- Returns a collection containing paths shared by the two\r
--- input geometries. Those going in the same direction are\r
--- in the first element of the collection, those going in the\r
--- opposite direction are in the second element.\r
---\r
--- The paths themselves are given in the direction of the\r
--- first geometry.\r
--- \r
--- Availability: 2.0.0\r
--- Requires GEOS >= 3.3.0\r
---\r
-CREATE OR REPLACE FUNCTION ST_SharedPaths(geom1 geometry, geom2 geometry)\r
- RETURNS geometry\r
- AS 'MODULE_PATHNAME', 'ST_SharedPaths'\r
- LANGUAGE 'C' IMMUTABLE STRICT\r
- COST 100;\r
-\r
---------------------------------------------------------------------------------\r
--- ST_Snap\r
---------------------------------------------------------------------------------\r
-\r
--- ST_Snap(g1 geometry, g2 geometry, tolerance float8)\r
---\r
--- Snap first geometry against second.\r
---\r
--- Availability: 2.0.0\r
--- Requires GEOS >= 3.3.0\r
---\r
-CREATE OR REPLACE FUNCTION ST_Snap(geom1 geometry, geom2 geometry, float8)\r
- RETURNS geometry\r
- AS 'MODULE_PATHNAME', 'ST_Snap'\r
- LANGUAGE 'C' IMMUTABLE STRICT\r
- COST 100;\r
-\r
---------------------------------------------------------------------------------\r
--- ST_RelateMatch\r
---------------------------------------------------------------------------------\r
-\r
--- ST_RelateMatch(matrix text, pattern text)\r
---\r
--- Returns true if pattern 'pattern' matches DE9 intersection matrix 'matrix'\r
---\r
--- Availability: 2.0.0\r
--- Requires GEOS >= 3.3.0\r
---\r
-CREATE OR REPLACE FUNCTION ST_RelateMatch(text, text)\r
- RETURNS bool\r
- AS 'MODULE_PATHNAME', 'ST_RelateMatch'\r
- LANGUAGE 'C' IMMUTABLE STRICT\r
- COST 100;\r
-\r
---------------------------------------------------------------------------------\r
--- ST_Node\r
---------------------------------------------------------------------------------\r
-\r
--- ST_Node(in geometry)\r
---\r
--- Fully node lines in input using the least set of nodes while\r
--- preserving each of the input ones.\r
--- Returns a linestring or a multilinestring containing all parts.\r
---\r
--- Availability: 2.0.0\r
--- Requires GEOS >= 3.3.0\r
---\r
-CREATE OR REPLACE FUNCTION ST_Node(g geometry)\r
- RETURNS geometry\r
- AS 'MODULE_PATHNAME', 'ST_Node'\r
- LANGUAGE 'C' IMMUTABLE STRICT\r
- COST 100;\r
-\r
-\r
---------------------------------------------------------------------------------\r
--- Aggregates and their supporting functions\r
---------------------------------------------------------------------------------\r
-\r
-------------------------------------------------------------------------\r
--- Availability: 1.2.2\r
-CREATE OR REPLACE FUNCTION ST_Combine_BBox(box3d,geometry)\r
- RETURNS box3d\r
- AS 'MODULE_PATHNAME', 'BOX3D_combine'\r
- LANGUAGE 'C' IMMUTABLE;\r
-\r
--- Availability: 1.2.2\r
-CREATE AGGREGATE ST_Extent(\r
- sfunc = ST_combine_bbox,\r
- finalfunc = box2d,\r
- basetype = geometry,\r
- stype = box3d\r
- );\r
-\r
--- Availability: 2.0.0\r
-CREATE AGGREGATE ST_3DExtent(\r
- sfunc = ST_combine_bbox,\r
- basetype = geometry,\r
- stype = box3d\r
- );\r
-\r
--- Availability: 1.2.2\r
-CREATE OR REPLACE FUNCTION ST_Collect(geom1 geometry, geom2 geometry)\r
- RETURNS geometry\r
- AS 'MODULE_PATHNAME', 'LWGEOM_collect'\r
- LANGUAGE 'C' IMMUTABLE;\r
-\r
--- Availability: 1.2.2\r
-CREATE AGGREGATE ST_MemCollect(\r
- sfunc = ST_collect,\r
- basetype = geometry,\r
- stype = geometry\r
- );\r
-\r
--- Availability: 1.2.2\r
-CREATE OR REPLACE FUNCTION ST_Collect(geometry[])\r
- RETURNS geometry\r
- AS 'MODULE_PATHNAME', 'LWGEOM_collect_garray'\r
- LANGUAGE 'C' IMMUTABLE STRICT;\r
-\r
--- Availability: 1.2.2\r
-CREATE AGGREGATE ST_MemUnion (\r
- basetype = geometry,\r
- sfunc = ST_Union,\r
- stype = geometry\r
- );\r
-\r
---\r
--- pgis_abs\r
--- Container type to hold the ArrayBuildState pointer as it passes through\r
--- the geometry array accumulation aggregate.\r
---\r
-CREATE OR REPLACE FUNCTION pgis_abs_in(cstring)\r
- RETURNS pgis_abs\r
- AS 'MODULE_PATHNAME'\r
- LANGUAGE 'C' IMMUTABLE STRICT;\r
-\r
-CREATE OR REPLACE FUNCTION pgis_abs_out(pgis_abs)\r
- RETURNS cstring\r
- AS 'MODULE_PATHNAME'\r
- LANGUAGE 'C' IMMUTABLE STRICT;\r
-\r
-CREATE TYPE pgis_abs (\r
- internallength = 8,\r
- input = pgis_abs_in,\r
- output = pgis_abs_out,\r
- alignment = double\r
-);\r
-\r
--- Availability: 1.4.0\r
-CREATE OR REPLACE FUNCTION pgis_geometry_accum_transfn(pgis_abs, geometry)\r
- RETURNS pgis_abs\r
- AS 'MODULE_PATHNAME'\r
- LANGUAGE 'C';\r
-\r
--- Availability: 1.4.0\r
-CREATE OR REPLACE FUNCTION pgis_geometry_accum_finalfn(pgis_abs)\r
- RETURNS geometry[]\r
- AS 'MODULE_PATHNAME'\r
- LANGUAGE 'C';\r
-\r
--- Availability: 1.4.0\r
-CREATE OR REPLACE FUNCTION pgis_geometry_union_finalfn(pgis_abs)\r
- RETURNS geometry\r
- AS 'MODULE_PATHNAME'\r
- LANGUAGE 'C';\r
-\r
--- Availability: 1.4.0\r
-CREATE OR REPLACE FUNCTION pgis_geometry_collect_finalfn(pgis_abs)\r
- RETURNS geometry\r
- AS 'MODULE_PATHNAME'\r
- LANGUAGE 'C';\r
-\r
--- Availability: 1.4.0\r
-CREATE OR REPLACE FUNCTION pgis_geometry_polygonize_finalfn(pgis_abs)\r
- RETURNS geometry\r
- AS 'MODULE_PATHNAME'\r
- LANGUAGE 'C';\r
-\r
--- Availability: 1.4.0\r
-CREATE OR REPLACE FUNCTION pgis_geometry_makeline_finalfn(pgis_abs)\r
- RETURNS geometry\r
- AS 'MODULE_PATHNAME'\r
- LANGUAGE 'C';\r
-\r
--- Availability: 1.2.2\r
-CREATE AGGREGATE ST_Accum (\r
- sfunc = pgis_geometry_accum_transfn,\r
- basetype = geometry,\r
- stype = pgis_abs,\r
- finalfunc = pgis_geometry_accum_finalfn\r
- );\r
-\r
--- Availability: 1.4.0\r
-CREATE OR REPLACE FUNCTION ST_Union (geometry[])\r
- RETURNS geometry\r
- AS 'MODULE_PATHNAME','pgis_union_geometry_array'\r
- LANGUAGE 'C' IMMUTABLE STRICT;\r
-\r
--- Availability: 1.2.2\r
-CREATE AGGREGATE ST_Union (\r
- basetype = geometry,\r
- sfunc = pgis_geometry_accum_transfn,\r
- stype = pgis_abs,\r
- finalfunc = pgis_geometry_union_finalfn\r
- );\r
-\r
--- Availability: 1.2.2\r
-CREATE AGGREGATE ST_Collect (\r
- BASETYPE = geometry,\r
- SFUNC = pgis_geometry_accum_transfn,\r
- STYPE = pgis_abs,\r
- FINALFUNC = pgis_geometry_collect_finalfn\r
- );\r
-\r
--- Availability: 1.2.2\r
-CREATE AGGREGATE ST_Polygonize (\r
- BASETYPE = geometry,\r
- SFUNC = pgis_geometry_accum_transfn,\r
- STYPE = pgis_abs,\r
- FINALFUNC = pgis_geometry_polygonize_finalfn\r
- );\r
-\r
--- Availability: 1.2.2\r
-CREATE AGGREGATE ST_MakeLine (\r
- BASETYPE = geometry,\r
- SFUNC = pgis_geometry_accum_transfn,\r
- STYPE = pgis_abs,\r
- FINALFUNC = pgis_geometry_makeline_finalfn\r
- );\r
-\r
-\r
-\r
---------------------------------------------------------------------------------\r
-\r
--- Availability: 1.2.2\r
-CREATE OR REPLACE FUNCTION ST_Relate(geom1 geometry, geom2 geometry)\r
- RETURNS text\r
- AS 'MODULE_PATHNAME','relate_full'\r
- LANGUAGE 'C' IMMUTABLE STRICT;\r
-\r
--- Availability: 2.0.0\r
--- Requires GEOS >= 3.3.0\r
-CREATE OR REPLACE FUNCTION ST_Relate(geom1 geometry, geom2 geometry, int4)\r
- RETURNS text\r
- AS 'MODULE_PATHNAME','relate_full'\r
- LANGUAGE 'C' IMMUTABLE STRICT;\r
-\r
--- PostGIS equivalent function: relate(geom1 geometry, geom2 geometry,text)\r
-CREATE OR REPLACE FUNCTION ST_Relate(geom1 geometry, geom2 geometry,text)\r
- RETURNS boolean\r
- AS 'MODULE_PATHNAME','relate_pattern'\r
- LANGUAGE 'C' IMMUTABLE STRICT;\r
-\r
--- PostGIS equivalent function: disjoint(geom1 geometry, geom2 geometry)\r
-CREATE OR REPLACE FUNCTION ST_Disjoint(geom1 geometry, geom2 geometry)\r
- RETURNS boolean\r
- AS 'MODULE_PATHNAME','disjoint'\r
- LANGUAGE 'C' IMMUTABLE STRICT;\r
-\r
--- PostGIS equivalent function: touches(geom1 geometry, geom2 geometry)\r
-CREATE OR REPLACE FUNCTION _ST_Touches(geom1 geometry, geom2 geometry)\r
- RETURNS boolean\r
- AS 'MODULE_PATHNAME','touches'\r
- LANGUAGE 'C' IMMUTABLE STRICT\r
- COST 100;\r
-\r
--- Availability: 1.2.2\r
--- Inlines index magic\r
-CREATE OR REPLACE FUNCTION ST_Touches(geom1 geometry, geom2 geometry)\r
- RETURNS boolean\r
- AS 'SELECT $1 && $2 AND _ST_Touches($1,$2)'\r
- LANGUAGE 'SQL' IMMUTABLE;\r
-\r
--- Availability: 1.3.4\r
-CREATE OR REPLACE FUNCTION _ST_DWithin(geom1 geometry, geom2 geometry,float8)\r
- RETURNS boolean\r
- AS 'MODULE_PATHNAME', 'LWGEOM_dwithin'\r
- LANGUAGE 'C' IMMUTABLE STRICT\r
- COST 100;\r
-\r
--- Availability: 1.2.2\r
-CREATE OR REPLACE FUNCTION ST_DWithin(geom1 geometry, geom2 geometry, float8)\r
- RETURNS boolean\r
- AS 'SELECT $1 && ST_Expand($2,$3) AND $2 && ST_Expand($1,$3) AND _ST_DWithin($1, $2, $3)'\r
- LANGUAGE 'SQL' IMMUTABLE;\r
-\r
--- PostGIS equivalent function: intersects(geom1 geometry, geom2 geometry)\r
-CREATE OR REPLACE FUNCTION _ST_Intersects(geom1 geometry, geom2 geometry)\r
- RETURNS boolean\r
- AS 'MODULE_PATHNAME','intersects'\r
- LANGUAGE 'C' IMMUTABLE STRICT\r
- COST 100;\r
-\r
--- Availability: 1.2.2\r
--- Inlines index magic\r
-CREATE OR REPLACE FUNCTION ST_Intersects(geom1 geometry, geom2 geometry)\r
- RETURNS boolean\r
- AS 'SELECT $1 && $2 AND _ST_Intersects($1,$2)'\r
- LANGUAGE 'SQL' IMMUTABLE;\r
- \r
--- PostGIS equivalent function: crosses(geom1 geometry, geom2 geometry)\r
-CREATE OR REPLACE FUNCTION _ST_Crosses(geom1 geometry, geom2 geometry)\r
- RETURNS boolean\r
- AS 'MODULE_PATHNAME','crosses'\r
- LANGUAGE 'C' IMMUTABLE STRICT\r
- COST 100;\r
-\r
--- Availability: 1.2.2\r
--- Inlines index magic\r
-CREATE OR REPLACE FUNCTION ST_Crosses(geom1 geometry, geom2 geometry)\r
- RETURNS boolean\r
- AS 'SELECT $1 && $2 AND _ST_Crosses($1,$2)'\r
- LANGUAGE 'SQL' IMMUTABLE;\r
-\r
--- PostGIS equivalent function: contains(geom1 geometry, geom2 geometry)\r
-CREATE OR REPLACE FUNCTION _ST_Contains(geom1 geometry, geom2 geometry)\r
- RETURNS boolean\r
- AS 'MODULE_PATHNAME','contains'\r
- LANGUAGE 'C' IMMUTABLE STRICT\r
- COST 100;\r
-\r
--- Availability: 1.2.2\r
--- Inlines index magic\r
-CREATE OR REPLACE FUNCTION ST_Contains(geom1 geometry, geom2 geometry)\r
- RETURNS boolean\r
- AS 'SELECT $1 && $2 AND _ST_Contains($1,$2)'\r
- LANGUAGE 'SQL' IMMUTABLE;\r
-\r
--- Availability: 1.2.2\r
-CREATE OR REPLACE FUNCTION _ST_CoveredBy(geom1 geometry, geom2 geometry)\r
- RETURNS boolean\r
- AS 'MODULE_PATHNAME', 'coveredby'\r
- LANGUAGE 'C' IMMUTABLE STRICT\r
- COST 100;\r
-\r
--- Availability: 1.2.2\r
-CREATE OR REPLACE FUNCTION ST_CoveredBy(geom1 geometry, geom2 geometry)\r
- RETURNS boolean\r
- AS 'SELECT $1 && $2 AND _ST_CoveredBy($1,$2)'\r
- LANGUAGE 'SQL' IMMUTABLE;\r
-\r
--- Availability: 1.2.2\r
-CREATE OR REPLACE FUNCTION _ST_Covers(geom1 geometry, geom2 geometry)\r
- RETURNS boolean\r
- AS 'MODULE_PATHNAME', 'covers'\r
- LANGUAGE 'C' IMMUTABLE STRICT\r
- COST 100;\r
-\r
--- Availability: 1.2.2\r
--- Inlines index magic\r
-CREATE OR REPLACE FUNCTION ST_Covers(geom1 geometry, geom2 geometry)\r
- RETURNS boolean\r
- AS 'SELECT $1 && $2 AND _ST_Covers($1,$2)'\r
- LANGUAGE 'SQL' IMMUTABLE;\r
-\r
--- Availability: 1.4.0\r
-CREATE OR REPLACE FUNCTION _ST_ContainsProperly(geom1 geometry, geom2 geometry)\r
- RETURNS boolean\r
- AS 'MODULE_PATHNAME','containsproperly'\r
- LANGUAGE 'C' IMMUTABLE STRICT\r
- COST 100;\r
-\r
--- Availability: 1.4.0\r
--- Inlines index magic\r
-CREATE OR REPLACE FUNCTION ST_ContainsProperly(geom1 geometry, geom2 geometry)\r
- RETURNS boolean\r
- AS 'SELECT $1 && $2 AND _ST_ContainsProperly($1,$2)'\r
- LANGUAGE 'SQL' IMMUTABLE;\r
-\r
--- PostGIS equivalent function: overlaps(geom1 geometry, geom2 geometry)\r
-CREATE OR REPLACE FUNCTION _ST_Overlaps(geom1 geometry, geom2 geometry)\r
- RETURNS boolean\r
- AS 'MODULE_PATHNAME','overlaps'\r
- LANGUAGE 'C' IMMUTABLE STRICT\r
- COST 100;\r
-\r
--- PostGIS equivalent function: within(geom1 geometry, geom2 geometry)\r
-CREATE OR REPLACE FUNCTION _ST_Within(geom1 geometry, geom2 geometry)\r
- RETURNS boolean\r
- AS 'SELECT _ST_Contains($2,$1)'\r
- LANGUAGE 'SQL' IMMUTABLE;\r
-\r
--- Availability: 1.2.2\r
--- Inlines index magic\r
-CREATE OR REPLACE FUNCTION ST_Within(geom1 geometry, geom2 geometry)\r
- RETURNS boolean\r
- AS 'SELECT $1 && $2 AND _ST_Contains($2,$1)'\r
- LANGUAGE 'SQL' IMMUTABLE;\r
-\r
--- Availability: 1.2.2\r
--- Inlines index magic\r
-CREATE OR REPLACE FUNCTION ST_Overlaps(geom1 geometry, geom2 geometry)\r
- RETURNS boolean\r
- AS 'SELECT $1 && $2 AND _ST_Overlaps($1,$2)'\r
- LANGUAGE 'SQL' IMMUTABLE;\r
-\r
--- PostGIS equivalent function: IsValid(geometry)\r
--- TODO: change null returns to true\r
-CREATE OR REPLACE FUNCTION ST_IsValid(geometry)\r
- RETURNS boolean\r
- AS 'MODULE_PATHNAME', 'isvalid'\r
- LANGUAGE 'C' IMMUTABLE STRICT\r
- COST 100;\r
-\r
--- PostGIS equivalent function: Centroid(geometry)\r
-CREATE OR REPLACE FUNCTION ST_Centroid(geometry)\r
- RETURNS geometry\r
- AS 'MODULE_PATHNAME', 'centroid'\r
- LANGUAGE 'C' IMMUTABLE STRICT;\r
- \r
--- PostGIS equivalent function: IsRing(geometry)\r
-CREATE OR REPLACE FUNCTION ST_IsRing(geometry)\r
- RETURNS boolean\r
- AS 'MODULE_PATHNAME', 'isring'\r
- LANGUAGE 'C' IMMUTABLE STRICT;\r
-\r
--- PostGIS equivalent function: PointOnSurface(geometry)\r
-CREATE OR REPLACE FUNCTION ST_PointOnSurface(geometry)\r
- RETURNS geometry\r
- AS 'MODULE_PATHNAME', 'pointonsurface'\r
- LANGUAGE 'C' IMMUTABLE STRICT\r
- COST 100;\r
-\r
--- PostGIS equivalent function: IsSimple(geometry)\r
-CREATE OR REPLACE FUNCTION ST_IsSimple(geometry)\r
- RETURNS boolean\r
- AS 'MODULE_PATHNAME', 'issimple'\r
- LANGUAGE 'C' IMMUTABLE STRICT;\r
-\r
--- Availability: 2.0.0\r
-CREATE OR REPLACE FUNCTION ST_IsCollection(geometry)\r
- RETURNS boolean\r
- AS 'MODULE_PATHNAME', 'ST_IsCollection'\r
- LANGUAGE 'C' IMMUTABLE STRICT;\r
-\r
--- Availability: 1.5.0\r
-CREATE OR REPLACE FUNCTION _ST_Equals(geom1 geometry, geom2 geometry)\r
- RETURNS boolean\r
- AS 'MODULE_PATHNAME','ST_Equals'\r
- LANGUAGE 'C' IMMUTABLE STRICT\r
- COST 100;\r
-\r
--- Availability: 1.2.1\r
-CREATE OR REPLACE FUNCTION ST_Equals(geom1 geometry, geom2 geometry)\r
- RETURNS boolean\r
- AS 'SELECT $1 ~= $2 AND _ST_Equals($1,$2)'\r
- LANGUAGE 'SQL' IMMUTABLE;\r
-\r
--- Deprecation in 1.2.3 \r
--- TODO: drop in 2.0.0 ! \r
-CREATE OR REPLACE FUNCTION Equals(geom1 geometry, geom2 geometry) \r
- RETURNS boolean \r
- AS 'MODULE_PATHNAME','ST_Equals' \r
- LANGUAGE 'C' IMMUTABLE STRICT;\r
-\r
------------------------------------------------------------------------\r
--- GML & KML INPUT\r
------------------------------------------------------------------------\r
-CREATE OR REPLACE FUNCTION _ST_GeomFromGML(text, int4)\r
- RETURNS geometry\r
- AS 'MODULE_PATHNAME','geom_from_gml'\r
- LANGUAGE 'C' IMMUTABLE;\r
-\r
--- Availability: 2.0.0\r
-CREATE OR REPLACE FUNCTION ST_GeomFromGML(text, int4)\r
- RETURNS geometry\r
- AS 'MODULE_PATHNAME','geom_from_gml'\r
- LANGUAGE 'C' IMMUTABLE STRICT;\r
-\r
--- Availability: 1.5.0\r
-CREATE OR REPLACE FUNCTION ST_GeomFromGML(text)\r
- RETURNS geometry\r
- AS 'SELECT _ST_GeomFromGML($1, 0)'\r
- LANGUAGE 'SQL' IMMUTABLE STRICT;\r
-\r
--- Availability: 1.5.0\r
-CREATE OR REPLACE FUNCTION ST_GMLToSQL(text)\r
- RETURNS geometry\r
- AS 'SELECT _ST_GeomFromGML($1, 0)'\r
- LANGUAGE 'SQL' IMMUTABLE STRICT;\r
-\r
--- Availability: 2.0.0\r
-CREATE OR REPLACE FUNCTION ST_GMLToSQL(text, int4)\r
- RETURNS geometry\r
- AS 'MODULE_PATHNAME','geom_from_gml'\r
- LANGUAGE 'C' IMMUTABLE STRICT;\r
-\r
--- Availability: 1.5.0\r
-CREATE OR REPLACE FUNCTION ST_GeomFromKML(text)\r
- RETURNS geometry\r
- AS 'MODULE_PATHNAME','geom_from_kml'\r
- LANGUAGE 'C' IMMUTABLE STRICT;\r
-\r
------------------------------------------------------------------------\r
--- GEOJSON INPUT\r
------------------------------------------------------------------------\r
--- Availability: 2.0.0\r
-CREATE OR REPLACE FUNCTION ST_GeomFromGeoJson(text)\r
- RETURNS geometry\r
- AS 'MODULE_PATHNAME','geom_from_geojson'\r
- LANGUAGE 'C' IMMUTABLE STRICT;\r
-\r
------------------------------------------------------------------------\r
--- SVG OUTPUT\r
------------------------------------------------------------------------\r
--- Availability: 1.2.2\r
--- Changed: 2.0.0 changed to use default args and allow calling by named args\r
-CREATE OR REPLACE FUNCTION ST_AsSVG(geom geometry,rel int4 DEFAULT 0,maxdecimaldigits int4 DEFAULT 15)\r
- RETURNS TEXT\r
- AS 'MODULE_PATHNAME','LWGEOM_asSVG'\r
- LANGUAGE 'C' IMMUTABLE STRICT;\r
-\r
------------------------------------------------------------------------\r
--- GML OUTPUT\r
------------------------------------------------------------------------\r
--- _ST_AsGML(version, geom, precision, option, prefix)\r
-CREATE OR REPLACE FUNCTION _ST_AsGML(int4, geometry, int4, int4, text)\r
- RETURNS TEXT\r
- AS 'MODULE_PATHNAME','LWGEOM_asGML'\r
- LANGUAGE 'C' IMMUTABLE;\r
-\r
--- ST_AsGML(version, geom) / precision=15 \r
--- Availability: 1.3.2\r
--- ST_AsGML(version, geom, precision)\r
--- Availability: 1.3.2\r
-\r
--- ST_AsGML (geom, precision, option) / version=2\r
--- Availability: 1.4.0\r
--- Changed: 2.0.0 to have default args\r
-CREATE OR REPLACE FUNCTION ST_AsGML(geom geometry, maxdecimaldigits int4 DEFAULT 15, options int4 DEFAULT 0)\r
- RETURNS TEXT\r
- AS $$ SELECT _ST_AsGML(2, $1, $2, $3, null); $$\r
- LANGUAGE 'SQL' IMMUTABLE STRICT;\r
-\r
--- ST_AsGML(version, geom, precision, option)\r
--- Availability: 1.4.0\r
--- ST_AsGML(version, geom, precision, option, prefix)\r
--- Availability: 2.0.0\r
--- Changed: 2.0.0 to use default and named args\r
-CREATE OR REPLACE FUNCTION ST_AsGML(version int4, geom geometry, maxdecimaldigits int4 DEFAULT 15, options int4 DEFAULT 0, nprefix text DEFAULT null)\r
- RETURNS TEXT\r
- AS $$ SELECT _ST_AsGML($1, $2, $3, $4,$5); $$\r
- LANGUAGE 'SQL' IMMUTABLE;\r
-\r
------------------------------------------------------------------------\r
--- KML OUTPUT\r
------------------------------------------------------------------------\r
--- _ST_AsKML(version, geom, precision, nprefix)\r
-CREATE OR REPLACE FUNCTION _ST_AsKML(int4,geometry, int4, text)\r
- RETURNS TEXT\r
- AS 'MODULE_PATHNAME','LWGEOM_asKML'\r
- LANGUAGE 'C' IMMUTABLE;\r
-\r
--- Availability: 1.2.2\r
--- Changed: 2.0.0 to use default args and allow named args\r
-CREATE OR REPLACE FUNCTION ST_AsKML(geom geometry, maxdecimaldigits int4 DEFAULT 15)\r
- RETURNS TEXT\r
- AS $$ SELECT _ST_AsKML(2, ST_Transform($1,4326), $2, null); $$\r
- LANGUAGE 'SQL' IMMUTABLE STRICT;\r
-\r
--- ST_AsKML(version, geom, precision, text)\r
--- Availability: 2.0.0\r
--- Changed: 2.0.0 allows default args and got rid of other permutations\r
-CREATE OR REPLACE FUNCTION ST_AsKML(version int4, geom geometry, maxdecimaldigits int4 DEFAULT 15, nprefix text DEFAULT null)\r
- RETURNS TEXT\r
- AS $$ SELECT _ST_AsKML($1, ST_Transform($2,4326), $3, $4); $$\r
- LANGUAGE 'SQL' IMMUTABLE;\r
-\r
-\r
------------------------------------------------------------------------\r
--- GEOJSON OUTPUT\r
--- Availability: 1.3.4\r
------------------------------------------------------------------------\r
--- _ST_AsGeoJson(version, geom, precision, options)\r
-CREATE OR REPLACE FUNCTION _ST_AsGeoJson(int4, geometry, int4, int4)\r
- RETURNS TEXT\r
- AS 'MODULE_PATHNAME','LWGEOM_asGeoJson'\r
- LANGUAGE 'C' IMMUTABLE STRICT;\r
-\r
--- ST_AsGeoJson(geom, precision, options) / version=1\r
--- Changed 2.0.0 to use default args and named args\r
-CREATE OR REPLACE FUNCTION ST_AsGeoJson(geom geometry, maxdecimaldigits int4 DEFAULT 15, options int4 DEFAULT 0)\r
- RETURNS TEXT\r
- AS $$ SELECT _ST_AsGeoJson(1, $1, $2, $3); $$\r
- LANGUAGE 'SQL' IMMUTABLE STRICT;\r
-\r
--- ST_AsGeoJson(version, geom, precision,options)\r
--- Changed 2.0.0 to use default args and named args\r
-CREATE OR REPLACE FUNCTION ST_AsGeoJson(gj_version int4, geom geometry, maxdecimaldigits int4 DEFAULT 15, options int4 DEFAULT 0)\r
- RETURNS TEXT\r
- AS $$ SELECT _ST_AsGeoJson($1, $2, $3, $4); $$\r
- LANGUAGE 'SQL' IMMUTABLE STRICT;\r
-\r
-------------------------------------------------------------------------\r
--- GeoHash (geohash.org)\r
-------------------------------------------------------------------------\r
-\r
--- Availability 1.4.0\r
--- Changed 2.0.0 to use default args and named args\r
-CREATE OR REPLACE FUNCTION ST_GeoHash(geom geometry, maxchars int4 DEFAULT 0)\r
- RETURNS TEXT\r
- AS 'MODULE_PATHNAME', 'ST_GeoHash'\r
- LANGUAGE 'C' IMMUTABLE STRICT;\r
-\r
-------------------------------------------------------------------------\r
--- OGC defined\r
-------------------------------------------------------------------------\r
--- PostGIS equivalent function: NumPoints(geometry)\r
-CREATE OR REPLACE FUNCTION ST_NumPoints(geometry)\r
- RETURNS int4\r
- AS 'MODULE_PATHNAME', 'LWGEOM_numpoints_linestring'\r
- LANGUAGE 'C' IMMUTABLE STRICT;\r
-\r
--- PostGIS equivalent function: NumGeometries(geometry)\r
-CREATE OR REPLACE FUNCTION ST_NumGeometries(geometry)\r
- RETURNS int4\r
- AS 'MODULE_PATHNAME', 'LWGEOM_numgeometries_collection'\r
- LANGUAGE 'C' IMMUTABLE STRICT;\r
-\r
--- PostGIS equivalent function: GeometryN(geometry)\r
-CREATE OR REPLACE FUNCTION ST_GeometryN(geometry,integer)\r
- RETURNS geometry\r
- AS 'MODULE_PATHNAME', 'LWGEOM_geometryn_collection'\r
- LANGUAGE 'C' IMMUTABLE STRICT;\r
-\r
--- PostGIS equivalent function: Dimension(geometry)\r
-CREATE OR REPLACE FUNCTION ST_Dimension(geometry)\r
- RETURNS int4\r
- AS 'MODULE_PATHNAME', 'LWGEOM_dimension'\r
- LANGUAGE 'C' IMMUTABLE STRICT;\r
-\r
--- PostGIS equivalent function: ExteriorRing(geometry)\r
-CREATE OR REPLACE FUNCTION ST_ExteriorRing(geometry)\r
- RETURNS geometry\r
- AS 'MODULE_PATHNAME','LWGEOM_exteriorring_polygon'\r
- LANGUAGE 'C' IMMUTABLE STRICT;\r
-\r
--- PostGIS equivalent function: NumInteriorRings(geometry)\r
-CREATE OR REPLACE FUNCTION ST_NumInteriorRings(geometry)\r
- RETURNS integer\r
- AS 'MODULE_PATHNAME','LWGEOM_numinteriorrings_polygon'\r
- LANGUAGE 'C' IMMUTABLE STRICT;\r
-\r
--- Availability: 1.2.2\r
-CREATE OR REPLACE FUNCTION ST_NumInteriorRing(geometry)\r
- RETURNS integer\r
- AS 'MODULE_PATHNAME','LWGEOM_numinteriorrings_polygon'\r
- LANGUAGE 'C' IMMUTABLE STRICT;\r
-\r
--- PostGIS equivalent function: InteriorRingN(geometry)\r
-CREATE OR REPLACE FUNCTION ST_InteriorRingN(geometry,integer)\r
- RETURNS geometry\r
- AS 'MODULE_PATHNAME','LWGEOM_interiorringn_polygon'\r
- LANGUAGE 'C' IMMUTABLE STRICT;\r
-\r
--- Deprecation in 1.2.3 -- this should not be deprecated (2011-01-04 robe)\r
-CREATE OR REPLACE FUNCTION GeometryType(geometry)\r
- RETURNS text\r
- AS 'MODULE_PATHNAME', 'LWGEOM_getTYPE'\r
- LANGUAGE 'C' IMMUTABLE STRICT;\r
-\r
--- Not quite equivalent to GeometryType\r
-CREATE OR REPLACE FUNCTION ST_GeometryType(geometry)\r
- RETURNS text\r
- AS 'MODULE_PATHNAME', 'geometry_geometrytype'\r
- LANGUAGE 'C' IMMUTABLE STRICT;\r
-\r
--- PostGIS equivalent function: PointN(geometry,integer)\r
-CREATE OR REPLACE FUNCTION ST_PointN(geometry,integer)\r
- RETURNS geometry\r
- AS 'MODULE_PATHNAME','LWGEOM_pointn_linestring'\r
- LANGUAGE 'C' IMMUTABLE STRICT;\r
-\r
--- Availability: 2.0.0\r
-CREATE OR REPLACE FUNCTION ST_NumPatches(geometry)\r
- RETURNS int4\r
- AS '\r
- SELECT CASE WHEN ST_GeometryType($1) = ''ST_PolyhedralSurface''\r
- THEN ST_NumGeometries($1)\r
- ELSE NULL END\r
- '\r
- LANGUAGE 'SQL' IMMUTABLE STRICT;\r
-\r
--- Availability: 2.0.0\r
-CREATE OR REPLACE FUNCTION ST_PatchN(geometry, integer)\r
- RETURNS geometry\r
- AS '\r
- SELECT CASE WHEN ST_GeometryType($1) = ''ST_PolyhedralSurface''\r
- THEN ST_GeometryN($1, $2)\r
- ELSE NULL END\r
- '\r
- LANGUAGE 'SQL' IMMUTABLE STRICT;\r
-\r
--- PostGIS equivalent function of old StartPoint(geometry))\r
-CREATE OR REPLACE FUNCTION ST_StartPoint(geometry)\r
- RETURNS geometry\r
- AS 'MODULE_PATHNAME', 'LWGEOM_startpoint_linestring'\r
- LANGUAGE 'C' IMMUTABLE STRICT;\r
-\r
--- PostGIS equivalent function of old EndPoint(geometry)\r
-CREATE OR REPLACE FUNCTION ST_EndPoint(geometry)\r
- RETURNS geometry\r
- AS 'MODULE_PATHNAME', 'LWGEOM_endpoint_linestring'\r
- LANGUAGE 'C' IMMUTABLE STRICT;\r
-\r
--- PostGIS equivalent function: IsClosed(geometry)\r
-CREATE OR REPLACE FUNCTION ST_IsClosed(geometry)\r
- RETURNS boolean\r
- AS 'MODULE_PATHNAME', 'LWGEOM_isclosed'\r
- LANGUAGE 'C' IMMUTABLE STRICT;\r
-\r
--- PostGIS equivalent function: IsEmpty(geometry)\r
-CREATE OR REPLACE FUNCTION ST_IsEmpty(geometry)\r
- RETURNS boolean\r
- AS 'MODULE_PATHNAME', 'LWGEOM_isempty'\r
- LANGUAGE 'C' IMMUTABLE STRICT;\r
-\r
-CREATE OR REPLACE FUNCTION ST_SRID(geometry)\r
- RETURNS int4\r
- AS 'MODULE_PATHNAME','LWGEOM_get_srid'\r
- LANGUAGE 'C' IMMUTABLE STRICT;\r
-\r
--- Availability: 1.2.2\r
-CREATE OR REPLACE FUNCTION ST_SetSRID(geometry,int4)\r
- RETURNS geometry\r
- AS 'MODULE_PATHNAME','LWGEOM_set_srid'\r
- LANGUAGE 'C' IMMUTABLE STRICT;\r
- \r
--- Availability: 1.2.2\r
-CREATE OR REPLACE FUNCTION ST_AsBinary(geometry,text)\r
- RETURNS bytea\r
- AS 'MODULE_PATHNAME','LWGEOM_asBinary'\r
- LANGUAGE 'C' IMMUTABLE STRICT;\r
- \r
--- PostGIS equivalent of old function: AsBinary(geometry)\r
-CREATE OR REPLACE FUNCTION ST_AsBinary(geometry)\r
- RETURNS bytea\r
- AS 'MODULE_PATHNAME','LWGEOM_asBinary'\r
- LANGUAGE 'C' IMMUTABLE STRICT;\r
- \r
--- PostGIS equivalent function: AsText(geometry)\r
-CREATE OR REPLACE FUNCTION ST_AsText(geometry)\r
- RETURNS TEXT\r
- AS 'MODULE_PATHNAME','LWGEOM_asText'\r
- LANGUAGE 'C' IMMUTABLE STRICT;\r
-\r
--- Availability: 1.2.2\r
-CREATE OR REPLACE FUNCTION ST_GeometryFromText(text)\r
- RETURNS geometry\r
- AS 'MODULE_PATHNAME','LWGEOM_from_text'\r
- LANGUAGE 'C' IMMUTABLE STRICT;\r
-\r
--- Availability: 1.2.2\r
-CREATE OR REPLACE FUNCTION ST_GeometryFromText(text, int4)\r
- RETURNS geometry\r
- AS 'MODULE_PATHNAME','LWGEOM_from_text'\r
- LANGUAGE 'C' IMMUTABLE STRICT;\r
-\r
--- Availability: 1.2.2\r
-CREATE OR REPLACE FUNCTION ST_GeomFromText(text)\r
- RETURNS geometry\r
- AS 'MODULE_PATHNAME','LWGEOM_from_text'\r
- LANGUAGE 'C' IMMUTABLE STRICT;\r
-\r
--- PostGIS equivalent function: ST_GeometryFromText(text, int4)\r
-CREATE OR REPLACE FUNCTION ST_GeomFromText(text, int4)\r
- RETURNS geometry\r
- AS 'MODULE_PATHNAME','LWGEOM_from_text'\r
- LANGUAGE 'C' IMMUTABLE STRICT;\r
- \r
--- PostGIS equivalent function: ST_GeometryFromText(text)\r
--- SQL/MM alias for ST_GeomFromText\r
-CREATE OR REPLACE FUNCTION ST_WKTToSQL(text)\r
- RETURNS geometry\r
- AS 'MODULE_PATHNAME','LWGEOM_from_text'\r
- LANGUAGE 'C' IMMUTABLE STRICT; \r
-\r
--- Availability: 1.2.2\r
-CREATE OR REPLACE FUNCTION ST_PointFromText(text)\r
- RETURNS geometry\r
- AS '\r
- SELECT CASE WHEN geometrytype(ST_GeomFromText($1)) = ''POINT''\r
- THEN ST_GeomFromText($1)\r
- ELSE NULL END\r
- '\r
- LANGUAGE 'SQL' IMMUTABLE STRICT;\r
-\r
-\r
--- PostGIS equivalent function: PointFromText(text, int4)\r
--- TODO: improve this ... by not duplicating constructor time.\r
-CREATE OR REPLACE FUNCTION ST_PointFromText(text, int4)\r
- RETURNS geometry\r
- AS '\r
- SELECT CASE WHEN geometrytype(ST_GeomFromText($1, $2)) = ''POINT''\r
- THEN ST_GeomFromText($1, $2)\r
- ELSE NULL END\r
- '\r
- LANGUAGE 'SQL' IMMUTABLE STRICT;\r
-\r
--- Availability: 1.2.2\r
-CREATE OR REPLACE FUNCTION ST_LineFromText(text)\r
- RETURNS geometry\r
- AS '\r
- SELECT CASE WHEN geometrytype(ST_GeomFromText($1)) = ''LINESTRING''\r
- THEN ST_GeomFromText($1)\r
- ELSE NULL END\r
- '\r
- LANGUAGE 'SQL' IMMUTABLE STRICT;\r
-\r
--- PostGIS equivalent function: LineFromText(text, int4)\r
-CREATE OR REPLACE FUNCTION ST_LineFromText(text, int4)\r
- RETURNS geometry\r
- AS '\r
- SELECT CASE WHEN geometrytype(ST_GeomFromText($1, $2)) = ''LINESTRING''\r
- THEN ST_GeomFromText($1,$2)\r
- ELSE NULL END\r
- '\r
- LANGUAGE 'SQL' IMMUTABLE STRICT;\r
-\r
--- Availability: 1.2.2\r
-CREATE OR REPLACE FUNCTION ST_PolyFromText(text)\r
- RETURNS geometry\r
- AS '\r
- SELECT CASE WHEN geometrytype(ST_GeomFromText($1)) = ''POLYGON''\r
- THEN ST_GeomFromText($1)\r
- ELSE NULL END\r
- '\r
- LANGUAGE 'SQL' IMMUTABLE STRICT;\r
-\r
--- PostGIS equivalent function: ST_PolygonFromText(text, int4)\r
-CREATE OR REPLACE FUNCTION ST_PolyFromText(text, int4)\r
- RETURNS geometry\r
- AS '\r
- SELECT CASE WHEN geometrytype(ST_GeomFromText($1, $2)) = ''POLYGON''\r
- THEN ST_GeomFromText($1, $2)\r
- ELSE NULL END\r
- '\r
- LANGUAGE 'SQL' IMMUTABLE STRICT;\r
-\r
--- Availability: 1.2.2\r
-CREATE OR REPLACE FUNCTION ST_PolygonFromText(text, int4)\r
- RETURNS geometry\r
- AS 'SELECT ST_PolyFromText($1, $2)'\r
- LANGUAGE 'SQL' IMMUTABLE STRICT;\r
-\r
--- Availability: 1.2.2\r
-CREATE OR REPLACE FUNCTION ST_PolygonFromText(text)\r
- RETURNS geometry\r
- AS 'SELECT ST_PolyFromText($1)'\r
- LANGUAGE 'SQL' IMMUTABLE STRICT;\r
-\r
--- PostGIS equivalent function: MLineFromText(text, int4)\r
-CREATE OR REPLACE FUNCTION ST_MLineFromText(text, int4)\r
- RETURNS geometry\r
- AS '\r
- SELECT CASE\r
- WHEN geometrytype(ST_GeomFromText($1, $2)) = ''MULTILINESTRING''\r
- THEN ST_GeomFromText($1,$2)\r
- ELSE NULL END\r
- '\r
- LANGUAGE 'SQL' IMMUTABLE STRICT;\r
-\r
--- Availability: 1.2.2\r
-CREATE OR REPLACE FUNCTION ST_MLineFromText(text)\r
- RETURNS geometry\r
- AS '\r
- SELECT CASE WHEN geometrytype(ST_GeomFromText($1)) = ''MULTILINESTRING''\r
- THEN ST_GeomFromText($1)\r
- ELSE NULL END\r
- '\r
- LANGUAGE 'SQL' IMMUTABLE STRICT;\r
-\r
-\r
--- Availability: 1.2.2\r
-CREATE OR REPLACE FUNCTION ST_MultiLineStringFromText(text)\r
- RETURNS geometry\r
- AS 'SELECT ST_MLineFromText($1)'\r
- LANGUAGE 'SQL' IMMUTABLE STRICT;\r
-\r
--- Availability: 1.2.2\r
-CREATE OR REPLACE FUNCTION ST_MultiLineStringFromText(text, int4)\r
- RETURNS geometry\r
- AS 'SELECT ST_MLineFromText($1, $2)'\r
- LANGUAGE 'SQL' IMMUTABLE STRICT;\r
-\r
--- PostGIS equivalent function: MPointFromText(text, int4)\r
-CREATE OR REPLACE FUNCTION ST_MPointFromText(text, int4)\r
- RETURNS geometry\r
- AS '\r
- SELECT CASE WHEN geometrytype(ST_GeomFromText($1, $2)) = ''MULTIPOINT''\r
- THEN ST_GeomFromText($1, $2)\r
- ELSE NULL END\r
- '\r
- LANGUAGE 'SQL' IMMUTABLE STRICT;\r
-\r
--- Availability: 1.2.2\r
-CREATE OR REPLACE FUNCTION ST_MPointFromText(text)\r
- RETURNS geometry\r
- AS '\r
- SELECT CASE WHEN geometrytype(ST_GeomFromText($1)) = ''MULTIPOINT''\r
- THEN ST_GeomFromText($1)\r
- ELSE NULL END\r
- '\r
- LANGUAGE 'SQL' IMMUTABLE STRICT;\r
-\r
--- Availability: 1.2.2\r
-CREATE OR REPLACE FUNCTION ST_MultiPointFromText(text)\r
- RETURNS geometry\r
- AS 'SELECT ST_MPointFromText($1)'\r
- LANGUAGE 'SQL' IMMUTABLE STRICT;\r
-\r
--- Availability: 1.2.2\r
-CREATE OR REPLACE FUNCTION ST_MultiPointFromText(text)\r
- RETURNS geometry\r
- AS 'SELECT ST_MPointFromText($1)'\r
- LANGUAGE 'SQL' IMMUTABLE STRICT;\r
-\r
--- PostGIS equivalent function: MPolyFromText(text, int4)\r
-CREATE OR REPLACE FUNCTION ST_MPolyFromText(text, int4)\r
- RETURNS geometry\r
- AS '\r
- SELECT CASE WHEN geometrytype(ST_GeomFromText($1, $2)) = ''MULTIPOLYGON''\r
- THEN ST_GeomFromText($1,$2)\r
- ELSE NULL END\r
- '\r
- LANGUAGE 'SQL' IMMUTABLE STRICT;\r
-\r
---Availability: 1.2.2\r
-CREATE OR REPLACE FUNCTION ST_MPolyFromText(text)\r
- RETURNS geometry\r
- AS '\r
- SELECT CASE WHEN geometrytype(ST_GeomFromText($1)) = ''MULTIPOLYGON''\r
- THEN ST_GeomFromText($1)\r
- ELSE NULL END\r
- '\r
- LANGUAGE 'SQL' IMMUTABLE STRICT;\r
-\r
--- Availability: 1.2.2\r
-CREATE OR REPLACE FUNCTION ST_MultiPolygonFromText(text, int4)\r
- RETURNS geometry\r
- AS 'SELECT ST_MPolyFromText($1, $2)'\r
- LANGUAGE 'SQL' IMMUTABLE STRICT;\r
-\r
--- Availability: 1.2.2\r
-CREATE OR REPLACE FUNCTION ST_MultiPolygonFromText(text)\r
- RETURNS geometry\r
- AS 'SELECT ST_MPolyFromText($1)'\r
- LANGUAGE 'SQL' IMMUTABLE STRICT;\r
-\r
--- Availability: 1.2.2\r
-CREATE OR REPLACE FUNCTION ST_GeomCollFromText(text, int4)\r
- RETURNS geometry\r
- AS '\r
- SELECT CASE\r
- WHEN geometrytype(ST_GeomFromText($1, $2)) = ''GEOMETRYCOLLECTION''\r
- THEN ST_GeomFromText($1,$2)\r
- ELSE NULL END\r
- '\r
- LANGUAGE 'SQL' IMMUTABLE STRICT;\r
-\r
--- Availability: 1.2.2\r
-CREATE OR REPLACE FUNCTION ST_GeomCollFromText(text)\r
- RETURNS geometry\r
- AS '\r
- SELECT CASE\r
- WHEN geometrytype(ST_GeomFromText($1)) = ''GEOMETRYCOLLECTION''\r
- THEN ST_GeomFromText($1)\r
- ELSE NULL END\r
- '\r
- LANGUAGE 'SQL' IMMUTABLE STRICT;\r
-\r
--- Availability: 1.2.2\r
-CREATE OR REPLACE FUNCTION ST_GeomFromWKB(bytea)\r
- RETURNS geometry\r
- AS 'MODULE_PATHNAME','LWGEOM_from_WKB'\r
- LANGUAGE 'C' IMMUTABLE STRICT;\r
-\r
--- PostGIS equivalent function: GeomFromWKB(bytea, int)\r
-CREATE OR REPLACE FUNCTION ST_GeomFromWKB(bytea, int)\r
- RETURNS geometry\r
- AS 'SELECT ST_SetSRID(ST_GeomFromWKB($1), $2)'\r
- LANGUAGE 'SQL' IMMUTABLE STRICT;\r
-\r
--- PostGIS equivalent function: PointFromWKB(bytea, int)\r
-CREATE OR REPLACE FUNCTION ST_PointFromWKB(bytea, int)\r
- RETURNS geometry\r
- AS '\r
- SELECT CASE WHEN geometrytype(ST_GeomFromWKB($1, $2)) = ''POINT''\r
- THEN ST_GeomFromWKB($1, $2)\r
- ELSE NULL END\r
- '\r
- LANGUAGE 'SQL' IMMUTABLE STRICT;\r
-\r
--- Availability: 1.2.2\r
-CREATE OR REPLACE FUNCTION ST_PointFromWKB(bytea)\r
- RETURNS geometry\r
- AS '\r
- SELECT CASE WHEN geometrytype(ST_GeomFromWKB($1)) = ''POINT''\r
- THEN ST_GeomFromWKB($1)\r
- ELSE NULL END\r
- '\r
- LANGUAGE 'SQL' IMMUTABLE STRICT;\r
-\r
--- PostGIS equivalent function: LineFromWKB(bytea, int)\r
-CREATE OR REPLACE FUNCTION ST_LineFromWKB(bytea, int)\r
- RETURNS geometry\r
- AS '\r
- SELECT CASE WHEN geometrytype(ST_GeomFromWKB($1, $2)) = ''LINESTRING''\r
- THEN ST_GeomFromWKB($1, $2)\r
- ELSE NULL END\r
- '\r
- LANGUAGE 'SQL' IMMUTABLE STRICT;\r
-\r
--- Availability: 1.2.2\r
-CREATE OR REPLACE FUNCTION ST_LineFromWKB(bytea)\r
- RETURNS geometry\r
- AS '\r
- SELECT CASE WHEN geometrytype(ST_GeomFromWKB($1)) = ''LINESTRING''\r
- THEN ST_GeomFromWKB($1)\r
- ELSE NULL END\r
- '\r
- LANGUAGE 'SQL' IMMUTABLE STRICT;\r
-\r
--- Availability: 1.2.2\r
-CREATE OR REPLACE FUNCTION ST_LinestringFromWKB(bytea, int)\r
- RETURNS geometry\r
- AS '\r
- SELECT CASE WHEN geometrytype(ST_GeomFromWKB($1, $2)) = ''LINESTRING''\r
- THEN ST_GeomFromWKB($1, $2)\r
- ELSE NULL END\r
- '\r
- LANGUAGE 'SQL' IMMUTABLE STRICT;\r
-\r
--- Availability: 1.2.2\r
-CREATE OR REPLACE FUNCTION ST_LinestringFromWKB(bytea)\r
- RETURNS geometry\r
- AS '\r
- SELECT CASE WHEN geometrytype(ST_GeomFromWKB($1)) = ''LINESTRING''\r
- THEN ST_GeomFromWKB($1)\r
- ELSE NULL END\r
- '\r
- LANGUAGE 'SQL' IMMUTABLE STRICT;\r
-\r
--- PostGIS equivalent function: PolyFromWKB(text, int)\r
-CREATE OR REPLACE FUNCTION ST_PolyFromWKB(bytea, int)\r
- RETURNS geometry\r
- AS '\r
- SELECT CASE WHEN geometrytype(ST_GeomFromWKB($1, $2)) = ''POLYGON''\r
- THEN ST_GeomFromWKB($1, $2)\r
- ELSE NULL END\r
- '\r
- LANGUAGE 'SQL' IMMUTABLE STRICT;\r
-\r
--- Availability: 1.2.2\r
-CREATE OR REPLACE FUNCTION ST_PolyFromWKB(bytea)\r
- RETURNS geometry\r
- AS '\r
- SELECT CASE WHEN geometrytype(ST_GeomFromWKB($1)) = ''POLYGON''\r
- THEN ST_GeomFromWKB($1)\r
- ELSE NULL END\r
- '\r
- LANGUAGE 'SQL' IMMUTABLE STRICT;\r
-\r
--- Availability: 1.2.2\r
-CREATE OR REPLACE FUNCTION ST_PolygonFromWKB(bytea, int)\r
- RETURNS geometry\r
- AS '\r
- SELECT CASE WHEN geometrytype(ST_GeomFromWKB($1,$2)) = ''POLYGON''\r
- THEN ST_GeomFromWKB($1, $2)\r
- ELSE NULL END\r
- '\r
- LANGUAGE 'SQL' IMMUTABLE STRICT;\r
-\r
--- Availability: 1.2.2\r
-CREATE OR REPLACE FUNCTION ST_PolygonFromWKB(bytea)\r
- RETURNS geometry\r
- AS '\r
- SELECT CASE WHEN geometrytype(ST_GeomFromWKB($1)) = ''POLYGON''\r
- THEN ST_GeomFromWKB($1)\r
- ELSE NULL END\r
- '\r
- LANGUAGE 'SQL' IMMUTABLE STRICT;\r
-\r
--- PostGIS equivalent function: MPointFromWKB(text, int)\r
-CREATE OR REPLACE FUNCTION ST_MPointFromWKB(bytea, int)\r
- RETURNS geometry\r
- AS '\r
- SELECT CASE WHEN geometrytype(ST_GeomFromWKB($1, $2)) = ''MULTIPOINT''\r
- THEN ST_GeomFromWKB($1, $2)\r
- ELSE NULL END\r
- '\r
- LANGUAGE 'SQL' IMMUTABLE STRICT;\r
-\r
-\r
--- Availability: 1.2.2\r
-CREATE OR REPLACE FUNCTION ST_MPointFromWKB(bytea)\r
- RETURNS geometry\r
- AS '\r
- SELECT CASE WHEN geometrytype(ST_GeomFromWKB($1)) = ''MULTIPOINT''\r
- THEN ST_GeomFromWKB($1)\r
- ELSE NULL END\r
- '\r
- LANGUAGE 'SQL' IMMUTABLE STRICT;\r
-\r
--- Availability: 1.2.2\r
-CREATE OR REPLACE FUNCTION ST_MultiPointFromWKB(bytea, int)\r
- RETURNS geometry\r
- AS '\r
- SELECT CASE WHEN geometrytype(ST_GeomFromWKB($1,$2)) = ''MULTIPOINT''\r
- THEN ST_GeomFromWKB($1, $2)\r
- ELSE NULL END\r
- '\r
- LANGUAGE 'SQL' IMMUTABLE STRICT;\r
-\r
--- Availability: 1.2.2\r
-CREATE OR REPLACE FUNCTION ST_MultiPointFromWKB(bytea)\r
- RETURNS geometry\r
- AS '\r
- SELECT CASE WHEN geometrytype(ST_GeomFromWKB($1)) = ''MULTIPOINT''\r
- THEN ST_GeomFromWKB($1)\r
- ELSE NULL END\r
- '\r
- LANGUAGE 'SQL' IMMUTABLE STRICT;\r
-\r
--- Availability: 1.2.2\r
-CREATE OR REPLACE FUNCTION ST_MultiLineFromWKB(bytea)\r
- RETURNS geometry\r
- AS '\r
- SELECT CASE WHEN geometrytype(ST_GeomFromWKB($1)) = ''MULTILINESTRING''\r
- THEN ST_GeomFromWKB($1)\r
- ELSE NULL END\r
- '\r
- LANGUAGE 'SQL' IMMUTABLE STRICT;\r
-\r
--- PostGIS equivalent function: MLineFromWKB(text, int)\r
-CREATE OR REPLACE FUNCTION ST_MLineFromWKB(bytea, int)\r
- RETURNS geometry\r
- AS '\r
- SELECT CASE WHEN geometrytype(ST_GeomFromWKB($1, $2)) = ''MULTILINESTRING''\r
- THEN ST_GeomFromWKB($1, $2)\r
- ELSE NULL END\r
- '\r
- LANGUAGE 'SQL' IMMUTABLE STRICT;\r
-\r
--- Availability: 1.2.2\r
-CREATE OR REPLACE FUNCTION ST_MLineFromWKB(bytea)\r
- RETURNS geometry\r
- AS '\r
- SELECT CASE WHEN geometrytype(ST_GeomFromWKB($1)) = ''MULTILINESTRING''\r
- THEN ST_GeomFromWKB($1)\r
- ELSE NULL END\r
- '\r
- LANGUAGE 'SQL' IMMUTABLE STRICT;\r
-\r
--- Availability: 1.2.2\r
--- PostGIS equivalent function: MPolyFromWKB(bytea, int)\r
-CREATE OR REPLACE FUNCTION ST_MPolyFromWKB(bytea, int)\r
- RETURNS geometry\r
- AS '\r
- SELECT CASE WHEN geometrytype(ST_GeomFromWKB($1, $2)) = ''MULTIPOLYGON''\r
- THEN ST_GeomFromWKB($1, $2)\r
- ELSE NULL END\r
- '\r
- LANGUAGE 'SQL' IMMUTABLE STRICT;\r
-\r
--- Availability: 1.2.2\r
-CREATE OR REPLACE FUNCTION ST_MPolyFromWKB(bytea)\r
- RETURNS geometry\r
- AS '\r
- SELECT CASE WHEN geometrytype(ST_GeomFromWKB($1)) = ''MULTIPOLYGON''\r
- THEN ST_GeomFromWKB($1)\r
- ELSE NULL END\r
- '\r
- LANGUAGE 'SQL' IMMUTABLE STRICT;\r
-\r
--- Availability: 1.2.2\r
-CREATE OR REPLACE FUNCTION ST_MultiPolyFromWKB(bytea, int)\r
- RETURNS geometry\r
- AS '\r
- SELECT CASE WHEN geometrytype(ST_GeomFromWKB($1, $2)) = ''MULTIPOLYGON''\r
- THEN ST_GeomFromWKB($1, $2)\r
- ELSE NULL END\r
- '\r
- LANGUAGE 'SQL' IMMUTABLE STRICT;\r
-\r
-\r
--- Availability: 1.2.2\r
-CREATE OR REPLACE FUNCTION ST_MultiPolyFromWKB(bytea)\r
- RETURNS geometry\r
- AS '\r
- SELECT CASE WHEN geometrytype(ST_GeomFromWKB($1)) = ''MULTIPOLYGON''\r
- THEN ST_GeomFromWKB($1)\r
- ELSE NULL END\r
- '\r
- LANGUAGE 'SQL' IMMUTABLE STRICT;\r
-\r
--- Availability: 1.2.2\r
-CREATE OR REPLACE FUNCTION ST_GeomCollFromWKB(bytea, int)\r
- RETURNS geometry\r
- AS '\r
- SELECT CASE\r
- WHEN geometrytype(ST_GeomFromWKB($1, $2)) = ''GEOMETRYCOLLECTION''\r
- THEN ST_GeomFromWKB($1, $2)\r
- ELSE NULL END\r
- '\r
- LANGUAGE 'SQL' IMMUTABLE STRICT;\r
-\r
-\r
--- Availability: 1.2.2\r
-CREATE OR REPLACE FUNCTION ST_GeomCollFromWKB(bytea)\r
- RETURNS geometry\r
- AS '\r
- SELECT CASE\r
- WHEN geometrytype(ST_GeomFromWKB($1)) = ''GEOMETRYCOLLECTION''\r
- THEN ST_GeomFromWKB($1)\r
- ELSE NULL END\r
- '\r
- LANGUAGE 'SQL' IMMUTABLE STRICT;\r
-\r
---New functions\r
-\r
--- Maximum distance between linestrings.\r
-\r
--- Availability: 1.5.0\r
-CREATE OR REPLACE FUNCTION _ST_MaxDistance(geom1 geometry, geom2 geometry)\r
- RETURNS float8\r
- AS 'MODULE_PATHNAME', 'LWGEOM_maxdistance2d_linestring'\r
- LANGUAGE 'C' IMMUTABLE STRICT; \r
- \r
--- Availability: 1.5.0\r
-CREATE OR REPLACE FUNCTION ST_MaxDistance(geom1 geometry, geom2 geometry)\r
- RETURNS float8\r
- AS 'SELECT _ST_MaxDistance(ST_ConvexHull($1), ST_ConvexHull($2))'\r
- LANGUAGE 'SQL' IMMUTABLE STRICT; \r
-\r
-CREATE OR REPLACE FUNCTION ST_ClosestPoint(geom1 geometry, geom2 geometry)\r
- RETURNS geometry\r
- AS 'MODULE_PATHNAME', 'LWGEOM_closestpoint'\r
- LANGUAGE 'C' IMMUTABLE STRICT;\r
-\r
-CREATE OR REPLACE FUNCTION ST_ShortestLine(geom1 geometry, geom2 geometry)\r
- RETURNS geometry\r
- AS 'MODULE_PATHNAME', 'LWGEOM_shortestline2d'\r
- LANGUAGE 'C' IMMUTABLE STRICT;\r
-\r
-CREATE OR REPLACE FUNCTION _ST_LongestLine(geom1 geometry, geom2 geometry)\r
- RETURNS geometry\r
- AS 'MODULE_PATHNAME', 'LWGEOM_longestline2d'\r
- LANGUAGE 'C' IMMUTABLE STRICT;\r
-\r
-CREATE OR REPLACE FUNCTION ST_LongestLine(geom1 geometry, geom2 geometry)\r
- RETURNS geometry\r
- AS 'SELECT _ST_LongestLine(ST_ConvexHull($1), ST_ConvexHull($2))'\r
- LANGUAGE 'SQL' IMMUTABLE STRICT; \r
-\r
-CREATE OR REPLACE FUNCTION _ST_DFullyWithin(geom1 geometry, geom2 geometry,float8)\r
- RETURNS boolean\r
- AS 'MODULE_PATHNAME', 'LWGEOM_dfullywithin'\r
- LANGUAGE 'C' IMMUTABLE STRICT; \r
-\r
-CREATE OR REPLACE FUNCTION ST_DFullyWithin(geom1 geometry, geom2 geometry, float8)\r
- RETURNS boolean\r
- AS 'SELECT $1 && ST_Expand($2,$3) AND $2 && ST_Expand($1,$3) AND _ST_DFullyWithin(ST_ConvexHull($1), ST_ConvexHull($2), $3)'\r
- LANGUAGE 'SQL' IMMUTABLE; \r
- \r
-CREATE OR REPLACE FUNCTION ST_FlipCoordinates(geometry)\r
- RETURNS geometry\r
- AS 'MODULE_PATHNAME', 'ST_FlipCoordinates'\r
- LANGUAGE 'C' IMMUTABLE STRICT; \r
-\r
---\r
--- SFSQL 1.1\r
---\r
--- BdPolyFromText(multiLineStringTaggedText String, SRID Integer): Polygon\r
---\r
--- Construct a Polygon given an arbitrary\r
--- collection of closed linestrings as a\r
--- MultiLineString text representation.\r
---\r
--- This is a PLPGSQL function rather then an SQL function\r
--- To avoid double call of BuildArea (one to get GeometryType\r
--- and another to actual return, in a CASE WHEN construct).\r
--- Also, we profit from plpgsql to RAISE exceptions.\r
---\r
-\r
--- Availability: 1.2.2\r
-CREATE OR REPLACE FUNCTION ST_BdPolyFromText(text, integer)\r
-RETURNS geometry\r
-AS $$\r
-DECLARE\r
- geomtext alias for $1;\r
- srid alias for $2;\r
- mline geometry;\r
- geom geometry;\r
-BEGIN\r
- mline := ST_MultiLineStringFromText(geomtext, srid);\r
-\r
- IF mline IS NULL\r
- THEN\r
- RAISE EXCEPTION 'Input is not a MultiLinestring';\r
- END IF;\r
-\r
- geom := ST_BuildArea(mline);\r
-\r
- IF GeometryType(geom) != 'POLYGON'\r
- THEN\r
- RAISE EXCEPTION 'Input returns more then a single polygon, try using BdMPolyFromText instead';\r
- END IF;\r
-\r
- RETURN geom;\r
-END;\r
-$$\r
-LANGUAGE 'plpgsql' IMMUTABLE STRICT;\r
-\r
---\r
--- SFSQL 1.1\r
---\r
--- BdMPolyFromText(multiLineStringTaggedText String, SRID Integer): MultiPolygon\r
---\r
--- Construct a MultiPolygon given an arbitrary\r
--- collection of closed linestrings as a\r
--- MultiLineString text representation.\r
---\r
--- This is a PLPGSQL function rather then an SQL function\r
--- To raise an exception in case of invalid input.\r
---\r
-\r
--- Availability: 1.2.2\r
-CREATE OR REPLACE FUNCTION ST_BdMPolyFromText(text, integer)\r
-RETURNS geometry\r
-AS $$\r
-DECLARE\r
- geomtext alias for $1;\r
- srid alias for $2;\r
- mline geometry;\r
- geom geometry;\r
-BEGIN\r
- mline := ST_MultiLineStringFromText(geomtext, srid);\r
-\r
- IF mline IS NULL\r
- THEN\r
- RAISE EXCEPTION 'Input is not a MultiLinestring';\r
- END IF;\r
-\r
- geom := ST_Multi(ST_BuildArea(mline));\r
-\r
- RETURN geom;\r
-END;\r
-$$\r
-LANGUAGE 'plpgsql' IMMUTABLE STRICT;\r
-\r
-#include "long_xact.sql.in.c"\r
-#include "geography.sql.in.c"\r
-\r
-\r
-\r
--- Availability: 1.2.2\r
-CREATE OR REPLACE FUNCTION ST_distance_sphere(geom1 geometry, geom2 geometry)\r
- RETURNS FLOAT8\r
- AS $$\r
- select st_distance(geography($1),geography($2),false)\r
- $$\r
- LANGUAGE 'SQL' IMMUTABLE STRICT\r
- COST 300;\r
-\r
--- Availability: 1.2.2\r
-CREATE OR REPLACE FUNCTION ST_distance_sphere(geom1 geometry, geom2 geometry)\r
- RETURNS FLOAT8\r
- AS $$\r
- select st_distance(geography($1),geography($2),false)\r
- $$\r
- LANGUAGE 'SQL' IMMUTABLE STRICT\r
- COST 300;\r
-\r
-\r
----------------------------------------------------------------\r
--- GEOMETRY_COLUMNS view support functions\r
----------------------------------------------------------------\r
--- New helper function so we can keep list of valid geometry types in one place --\r
--- Maps old names to pramsey beautiful names but can take old name or new name as input\r
--- By default returns new name but can be overridden to return old name for old constraint like support\r
-CREATE OR REPLACE FUNCTION postgis_type_name(geomname varchar, coord_dimension integer, use_new_name boolean DEFAULT true) \r
- RETURNS varchar\r
-AS\r
-$$\r
- SELECT CASE WHEN $3 THEN new_name ELSE old_name END As geomname\r
- FROM \r
- ( VALUES\r
- ('GEOMETRY', 'Geometry', 2) ,\r
- ('GEOMETRY', 'GeometryZ', 3) ,\r
- ('GEOMETRY', 'GeometryZM', 4) ,\r
- ('GEOMETRYCOLLECTION', 'GeometryCollection', 2) ,\r
- ('GEOMETRYCOLLECTION', 'GeometryCollectionZ', 3) ,\r
- ('GEOMETRYCOLLECTIONM', 'GeometryCollectionM', 3) ,\r
- ('GEOMETRYCOLLECTION', 'GeometryCollectionZM', 4) ,\r
- \r
- ('POINT', 'Point',2) ,\r
- ('POINTM','PointM',3) ,\r
- ('POINT', 'PointZ',3) ,\r
- ('POINT', 'PointZM',4) ,\r
- \r
- ('MULTIPOINT','MultiPoint',2) ,\r
- ('MULTIPOINT','MultiPointZ',3) ,\r
- ('MULTIPOINTM','MultiPointM',3) ,\r
- ('MULTIPOINT','MultiPointZM',4) ,\r
- \r
- ('POLYGON', 'Polygon',2) ,\r
- ('POLYGON', 'PolygonZ',3) ,\r
- ('POLYGONM', 'PolygonM',3) ,\r
- ('POLYGON', 'PolygonZM',4) ,\r
- \r
- ('MULTIPOLYGON', 'MultiPolygon',2) ,\r
- ('MULTIPOLYGON', 'MultiPolygonZ',3) ,\r
- ('MULTIPOLYGONM', 'MultiPolygonM',3) ,\r
- ('MULTIPOLYGON', 'MultiPolygonZM',4) ,\r
- \r
- ('MULTILINESTRING', 'MultiLineString',2) ,\r
- ('MULTILINESTRING', 'MultiLineStringZ',3) ,\r
- ('MULTILINESTRINGM', 'MultiLineStringM',3) ,\r
- ('MULTILINESTRING', 'MultiLineStringZM',4) ,\r
- \r
- ('LINESTRING', 'LineString',2) ,\r
- ('LINESTRING', 'LineStringZ',3) ,\r
- ('LINESTRINGM', 'LineStringM',3) ,\r
- ('LINESTRING', 'LineStringZM',4) ,\r
- \r
- ('CIRCULARSTRING', 'CircularString',2) ,\r
- ('CIRCULARSTRING', 'CircularStringZ',3) ,\r
- ('CIRCULARSTRINGM', 'CircularStringM',3) ,\r
- ('CIRCULARSTRING', 'CircularStringZM',4) ,\r
- \r
- ('COMPOUNDCURVE', 'CompoundCurve',2) ,\r
- ('COMPOUNDCURVE', 'CompoundCurveZ',3) ,\r
- ('COMPOUNDCURVEM', 'CompoundCurveM',3) ,\r
- ('COMPOUNDCURVE', 'CompoundCurveZM',4) ,\r
- \r
- ('CURVEPOLYGON', 'CurvePolygon',2) ,\r
- ('CURVEPOLYGON', 'CurvePolygonZ',3) ,\r
- ('CURVEPOLYGONM', 'CurvePolygonM',3) ,\r
- ('CURVEPOLYGON', 'CurvePolygonZM',4) ,\r
- \r
- ('MULTICURVE', 'MultiCurve',2 ) ,\r
- ('MULTICURVE', 'MultiCurveZ',3 ) ,\r
- ('MULTICURVEM', 'MultiCurveM',3 ) ,\r
- ('MULTICURVE', 'MultiCurveZM',4 ) ,\r
- \r
- ('MULTISURFACE', 'MultiSurface', 2) ,\r
- ('MULTISURFACE', 'MultiSurfaceZ', 3) ,\r
- ('MULTISURFACEM', 'MultiSurfaceM', 3) ,\r
- ('MULTISURFACE', 'MultiSurfaceZM', 4) ,\r
- \r
- ('POLYHEDRALSURFACE', 'PolyhedralSurface',2) ,\r
- ('POLYHEDRALSURFACE', 'PolyhedralSurfaceZ',3) ,\r
- ('POLYHEDRALSURFACEM', 'PolyhedralSurfaceM',3) ,\r
- ('POLYHEDRALSURFACE', 'PolyhedralSurfaceZM',4) ,\r
- \r
- ('TRIANGLE', 'Triangle',2) ,\r
- ('TRIANGLE', 'TriangleZ',3) ,\r
- ('TRIANGLEM', 'TriangleM',3) ,\r
- ('TRIANGLE', 'TriangleZM',4) ,\r
-\r
- ('TIN', 'Tin', 2),\r
- ('TIN', 'TinZ', 3),\r
- ('TIN', 'TinM', 3),\r
- ('TIN', 'TinZM', 4) )\r
- As g(old_name, new_name, coord_dimension)\r
- WHERE (upper(old_name) = upper($1) OR upper(new_name) = upper($1))\r
- AND coord_dimension = $2;\r
-$$\r
-language 'sql' IMMUTABLE STRICT COST 200;\r
-\r
-CREATE OR REPLACE FUNCTION postgis_constraint_srid(geomschema text, geomtable text, geomcolumn text) RETURNS integer AS\r
-$$\r
-SELECT replace(replace(split_part(s.consrc, ' = ', 2), ')', ''), '(', '')::integer\r
- FROM pg_class c, pg_namespace n, pg_attribute a, pg_constraint s\r
- WHERE n.nspname = $1\r
- AND c.relname = $2\r
- AND a.attname = $3\r
- AND a.attrelid = c.oid\r
- AND s.connamespace = n.oid\r
- AND s.conrelid = c.oid\r
- AND a.attnum = ANY (s.conkey)\r
- AND s.consrc LIKE '%srid(% = %';\r
-$$\r
-LANGUAGE 'sql' STABLE STRICT;\r
-\r
-CREATE OR REPLACE FUNCTION postgis_constraint_dims(geomschema text, geomtable text, geomcolumn text) RETURNS integer AS\r
-$$\r
-SELECT replace(split_part(s.consrc, ' = ', 2), ')', '')::integer\r
- FROM pg_class c, pg_namespace n, pg_attribute a, pg_constraint s\r
- WHERE n.nspname = $1\r
- AND c.relname = $2\r
- AND a.attname = $3\r
- AND a.attrelid = c.oid\r
- AND s.connamespace = n.oid\r
- AND s.conrelid = c.oid\r
- AND a.attnum = ANY (s.conkey)\r
- AND s.consrc LIKE '%ndims(% = %';\r
-$$\r
-LANGUAGE 'sql' STABLE STRICT;\r
-\r
--- support function to pull out geometry type from constraint check\r
--- will return pretty name instead of ugly name\r
-CREATE OR REPLACE FUNCTION postgis_constraint_type(geomschema text, geomtable text, geomcolumn text) RETURNS varchar AS\r
-$$\r
-SELECT replace(split_part(s.consrc, '''', 2), ')', '')::varchar \r
- FROM pg_class c, pg_namespace n, pg_attribute a, pg_constraint s\r
- WHERE n.nspname = $1\r
- AND c.relname = $2\r
- AND a.attname = $3\r
- AND a.attrelid = c.oid\r
- AND s.connamespace = n.oid\r
- AND s.conrelid = c.oid\r
- AND a.attnum = ANY (s.conkey)\r
- AND s.consrc LIKE '%geometrytype(% = %';\r
-$$\r
-LANGUAGE 'sql' STABLE STRICT;\r
-\r
-CREATE OR REPLACE VIEW geometry_columns AS \r
- SELECT current_database()::varchar(256) AS f_table_catalog, \r
- n.nspname::varchar(256) AS f_table_schema, \r
- c.relname::varchar(256) AS f_table_name, \r
- a.attname::varchar(256) AS f_geometry_column, \r
- COALESCE(NULLIF(postgis_typmod_dims(a.atttypmod),2),\r
- postgis_constraint_dims(n.nspname, c.relname, a.attname),\r
- 2) AS coord_dimension, \r
- COALESCE(NULLIF(postgis_typmod_srid(a.atttypmod),0),\r
- postgis_constraint_srid(n.nspname, c.relname, a.attname),\r
- 0) AS srid, \r
- -- force to be uppercase with no ZM so is backwards compatible\r
- -- with old geometry_columns\r
- replace(\r
- replace(\r
- COALESCE(\r
- NULLIF(upper(postgis_typmod_type(a.atttypmod)::text), 'GEOMETRY'),\r
- postgis_constraint_type(n.nspname, c.relname, a.attname),\r
- 'GEOMETRY'\r
- ), 'ZM', ''\r
- ), 'Z', ''\r
- )::varchar(30) AS type\r
- FROM pg_class c, pg_attribute a, pg_type t, pg_namespace n\r
- WHERE t.typname = 'geometry'::name \r
- AND a.attisdropped = false \r
- AND a.atttypid = t.oid \r
- AND a.attrelid = c.oid \r
- AND c.relnamespace = n.oid \r
- AND (c.relkind = 'r'::"char" OR c.relkind = 'v'::"char")\r
- AND NOT pg_is_other_temp_schema(c.relnamespace)\r
- AND NOT ( n.nspname = 'public' AND c.relname = 'raster_columns' );\r
-\r
--- TODO: support RETURNING and raise a WARNING\r
-CREATE OR REPLACE RULE geometry_columns_insert AS\r
- ON INSERT TO geometry_columns\r
- DO INSTEAD NOTHING;\r
-\r
--- TODO: raise a WARNING\r
-CREATE OR REPLACE RULE geometry_columns_update AS\r
- ON UPDATE TO geometry_columns\r
- DO INSTEAD NOTHING;\r
-\r
--- TODO: raise a WARNING\r
-CREATE OR REPLACE RULE geometry_columns_delete AS\r
- ON DELETE TO geometry_columns\r
- DO INSTEAD NOTHING;\r
-\r
-\r
----------------------------------------------------------------\r
--- 3D-functions\r
----------------------------------------------------------------\r
-\r
-CREATE OR REPLACE FUNCTION ST_3DDistance(geom1 geometry, geom2 geometry)\r
- RETURNS float8\r
- AS 'MODULE_PATHNAME', 'LWGEOM_mindistance3d'\r
- LANGUAGE 'C' IMMUTABLE STRICT\r
- COST 100;\r
- \r
-CREATE OR REPLACE FUNCTION ST_3DMaxDistance(geom1 geometry, geom2 geometry)\r
- RETURNS float8\r
- AS 'MODULE_PATHNAME', 'LWGEOM_maxdistance3d'\r
- LANGUAGE 'C' IMMUTABLE STRICT\r
- COST 100; \r
-\r
-CREATE OR REPLACE FUNCTION ST_3DClosestPoint(geom1 geometry, geom2 geometry)\r
- RETURNS geometry\r
- AS 'MODULE_PATHNAME', 'LWGEOM_closestpoint3d'\r
- LANGUAGE 'C' IMMUTABLE STRICT\r
- COST 100;\r
-\r
-CREATE OR REPLACE FUNCTION ST_3DShortestLine(geom1 geometry, geom2 geometry)\r
- RETURNS geometry\r
- AS 'MODULE_PATHNAME', 'LWGEOM_shortestline3d'\r
- LANGUAGE 'C' IMMUTABLE STRICT\r
- COST 100;\r
-\r
-CREATE OR REPLACE FUNCTION ST_3DLongestLine(geom1 geometry, geom2 geometry)\r
- RETURNS geometry\r
- AS 'MODULE_PATHNAME', 'LWGEOM_longestline3d'\r
- LANGUAGE 'C' IMMUTABLE STRICT\r
- COST 100;\r
- \r
-CREATE OR REPLACE FUNCTION _ST_3DDWithin(geom1 geometry, geom2 geometry,float8)\r
- RETURNS boolean\r
- AS 'MODULE_PATHNAME', 'LWGEOM_dwithin3d'\r
- LANGUAGE 'C' IMMUTABLE STRICT\r
- COST 100;\r
- \r
-CREATE OR REPLACE FUNCTION ST_3DDWithin(geom1 geometry, geom2 geometry,float8)\r
- RETURNS boolean\r
- AS 'SELECT $1 && ST_Expand($2,$3) AND $2 && ST_Expand($1,$3) AND _ST_3DDWithin($1, $2, $3)'\r
- LANGUAGE 'SQL' IMMUTABLE\r
- COST 100;\r
- \r
-CREATE OR REPLACE FUNCTION _ST_3DDFullyWithin(geom1 geometry, geom2 geometry,float8)\r
- RETURNS boolean\r
- AS 'MODULE_PATHNAME', 'LWGEOM_dfullywithin3d'\r
- LANGUAGE 'C' IMMUTABLE STRICT\r
- COST 100;\r
- \r
-CREATE OR REPLACE FUNCTION ST_3DDFullyWithin(geom1 geometry, geom2 geometry,float8)\r
- RETURNS boolean\r
- AS 'SELECT $1 && ST_Expand($2,$3) AND $2 && ST_Expand($1,$3) AND _ST_3DDFullyWithin($1, $2, $3)'\r
- LANGUAGE 'SQL' IMMUTABLE\r
- COST 100;\r
- \r
-CREATE OR REPLACE FUNCTION ST_3DIntersects(geom1 geometry, geom2 geometry)\r
- RETURNS boolean\r
- AS 'SELECT $1 && $2 AND _ST_3DDWithin($1, $2, 0.0)'\r
- LANGUAGE 'SQL' IMMUTABLE\r
- COST 100;\r
- \r
- \r
----------------------------------------------------------------\r
--- SQL-MM\r
----------------------------------------------------------------\r
--- PostGIS equivalent function: ST_ndims(geometry)\r
-CREATE OR REPLACE FUNCTION ST_CoordDim(Geometry geometry)\r
- RETURNS smallint\r
- AS 'MODULE_PATHNAME', 'LWGEOM_ndims'\r
- LANGUAGE 'C' IMMUTABLE STRICT; \r
---\r
--- SQL-MM\r
---\r
--- ST_CurveToLine(Geometry geometry, SegmentsPerQuarter integer)\r
---\r
--- Converts a given geometry to a linear geometry. Each curveed\r
--- geometry or segment is converted into a linear approximation using\r
--- the given number of segments per quarter circle.\r
-CREATE OR REPLACE FUNCTION ST_CurveToLine(geometry, integer)\r
- RETURNS geometry\r
- AS 'MODULE_PATHNAME', 'LWGEOM_curve_segmentize'\r
- LANGUAGE 'C' IMMUTABLE STRICT;\r
---\r
--- SQL-MM\r
---\r
--- ST_CurveToLine(Geometry geometry, SegmentsPerQuarter integer)\r
---\r
--- Converts a given geometry to a linear geometry. Each curveed\r
--- geometry or segment is converted into a linear approximation using\r
--- the default value of 32 segments per quarter circle\r
-CREATE OR REPLACE FUNCTION ST_CurveToLine(geometry)\r
- RETURNS geometry AS 'SELECT ST_CurveToLine($1, 32)'\r
- LANGUAGE 'SQL' IMMUTABLE STRICT;\r
-\r
-CREATE OR REPLACE FUNCTION ST_HasArc(Geometry geometry)\r
- RETURNS boolean\r
- AS 'MODULE_PATHNAME', 'LWGEOM_has_arc'\r
- LANGUAGE 'C' IMMUTABLE STRICT;\r
-\r
-CREATE OR REPLACE FUNCTION ST_LineToCurve(Geometry geometry)\r
- RETURNS geometry\r
- AS 'MODULE_PATHNAME', 'LWGEOM_line_desegmentize'\r
- LANGUAGE 'C' IMMUTABLE STRICT;\r
- \r
--- Availability: 1.5.0\r
-CREATE OR REPLACE FUNCTION _ST_OrderingEquals(GeometryA geometry, GeometryB geometry)\r
- RETURNS boolean\r
- AS 'MODULE_PATHNAME', 'LWGEOM_same'\r
- LANGUAGE 'C' IMMUTABLE STRICT\r
- COST 100;\r
-\r
--- Availability: 1.3.0\r
-CREATE OR REPLACE FUNCTION ST_OrderingEquals(GeometryA geometry, GeometryB geometry)\r
- RETURNS boolean\r
- AS $$ \r
- SELECT $1 ~= $2 AND _ST_OrderingEquals($1, $2)\r
- $$ \r
- LANGUAGE 'SQL' IMMUTABLE STRICT; \r
- \r
--------------------------------------------------------------------------------\r
--- SQL/MM - SQL Functions on type ST_Point\r
--------------------------------------------------------------------------------\r
-\r
--- PostGIS equivalent function: ST_MakePoint(XCoordinate float8,YCoordinate float8)\r
-CREATE OR REPLACE FUNCTION ST_Point(float8, float8)\r
- RETURNS geometry\r
- AS 'MODULE_PATHNAME', 'LWGEOM_makepoint'\r
- LANGUAGE 'C' IMMUTABLE STRICT; \r
- \r
--- PostGIS equivalent function: ST_MakePolygon(Geometry geometry)\r
-CREATE OR REPLACE FUNCTION ST_Polygon(geometry, int)\r
- RETURNS geometry\r
- AS $$ \r
- SELECT ST_SetSRID(ST_MakePolygon($1), $2)\r
- $$ \r
- LANGUAGE 'SQL' IMMUTABLE STRICT; \r
- \r
--- PostGIS equivalent function: GeomFromWKB(WKB bytea))\r
--- Note: Defaults to an SRID=-1, not 0 as per SQL/MM specs.\r
-CREATE OR REPLACE FUNCTION ST_WKBToSQL(WKB bytea)\r
- RETURNS geometry\r
- AS 'MODULE_PATHNAME','LWGEOM_from_WKB'\r
- LANGUAGE 'C' IMMUTABLE STRICT; \r
- \r
----\r
--- Linear referencing functions\r
----\r
--- Availability: 2.0.0\r
-CREATE OR REPLACE FUNCTION ST_LocateBetween(Geometry geometry, FromMeasure float8, ToMeasure float8, LeftRightOffset float8 default 0.0)\r
- RETURNS geometry\r
- AS 'MODULE_PATHNAME', 'ST_LocateBetween'\r
- LANGUAGE 'C' IMMUTABLE STRICT;\r
- \r
--- Availability: 2.0.0\r
-CREATE OR REPLACE FUNCTION ST_LocateAlong(Geometry geometry, Measure float8, LeftRightOffset float8 default 0.0)\r
- RETURNS geometry\r
- AS 'MODULE_PATHNAME', 'ST_LocateAlong'\r
- LANGUAGE 'C' IMMUTABLE STRICT;\r
-\r
--- Only accepts LINESTRING as parameters.\r
--- Availability: 1.4.0\r
-CREATE OR REPLACE FUNCTION ST_LocateBetweenElevations(Geometry geometry, FromElevation float8, ToElevation float8)\r
- RETURNS geometry\r
- AS 'MODULE_PATHNAME', 'ST_LocateBetweenElevations'\r
- LANGUAGE 'C' IMMUTABLE STRICT;\r
-\r
--- Availability: 2.0.0\r
-CREATE OR REPLACE FUNCTION ST_InterpolatePoint(Line geometry, Point geometry)\r
- RETURNS float8\r
- AS 'MODULE_PATHNAME', 'ST_InterpolatePoint'\r
- LANGUAGE 'C' IMMUTABLE STRICT;\r
-\r
----------------------------------------------------------------\r
--- END\r
----------------------------------------------------------------\r
-\r
-\r
----------------------------------------------------------------\r
--- USER CONTRIBUTED\r
----------------------------------------------------------------\r
-\r
------------------------------------------------------------------------\r
--- ST_MinimumBoundingCircle(inputgeom geometry, segs_per_quarter integer)\r
------------------------------------------------------------------------\r
--- Returns the smallest circle polygon that can fully contain a geometry\r
--- Defaults to 48 segs per quarter to approximate a circle\r
--- Contributed by Bruce Rindahl\r
--- Availability: 1.4.0\r
------------------------------------------------------------------------\r
-CREATE OR REPLACE FUNCTION ST_MinimumBoundingCircle(inputgeom geometry, segs_per_quarter integer DEFAULT 48)\r
- RETURNS geometry AS\r
-$BODY$\r
- DECLARE\r
- hull GEOMETRY;\r
- ring GEOMETRY;\r
- center GEOMETRY;\r
- radius DOUBLE PRECISION;\r
- dist DOUBLE PRECISION;\r
- d DOUBLE PRECISION;\r
- idx1 integer;\r
- idx2 integer;\r
- l1 GEOMETRY;\r
- l2 GEOMETRY;\r
- p1 GEOMETRY;\r
- p2 GEOMETRY;\r
- a1 DOUBLE PRECISION;\r
- a2 DOUBLE PRECISION;\r
-\r
-\r
- BEGIN\r
-\r
- -- First compute the ConvexHull of the geometry\r
- hull = ST_ConvexHull(inputgeom);\r
- --A point really has no MBC\r
- IF ST_GeometryType(hull) = 'ST_Point' THEN\r
- RETURN hull;\r
- END IF;\r
- -- convert the hull perimeter to a linestring so we can manipulate individual points\r
- --If its already a linestring force it to a closed linestring\r
- ring = CASE WHEN ST_GeometryType(hull) = 'ST_LineString' THEN ST_AddPoint(hull, ST_StartPoint(hull)) ELSE ST_ExteriorRing(hull) END;\r
-\r
- dist = 0;\r
- -- Brute Force - check every pair\r
- FOR i in 1 .. (ST_NumPoints(ring)-2)\r
- LOOP\r
- FOR j in i .. (ST_NumPoints(ring)-1)\r
- LOOP\r
- d = ST_Distance(ST_PointN(ring,i),ST_PointN(ring,j));\r
- -- Check the distance and update if larger\r
- IF (d > dist) THEN\r
- dist = d;\r
- idx1 = i;\r
- idx2 = j;\r
- END IF;\r
- END LOOP;\r
- END LOOP;\r
-\r
- -- We now have the diameter of the convex hull. The following line returns it if desired.\r
- -- RETURN ST_MakeLine(ST_PointN(ring,idx1),ST_PointN(ring,idx2));\r
-\r
- -- Now for the Minimum Bounding Circle. Since we know the two points furthest from each\r
- -- other, the MBC must go through those two points. Start with those points as a diameter of a circle.\r
-\r
- -- The radius is half the distance between them and the center is midway between them\r
- radius = ST_Distance(ST_PointN(ring,idx1),ST_PointN(ring,idx2)) / 2.0;\r
- center = ST_Line_interpolate_point(ST_MakeLine(ST_PointN(ring,idx1),ST_PointN(ring,idx2)),0.5);\r
-\r
- -- Loop through each vertex and check if the distance from the center to the point\r
- -- is greater than the current radius.\r
- FOR k in 1 .. (ST_NumPoints(ring)-1)\r
- LOOP\r
- IF(k <> idx1 and k <> idx2) THEN\r
- dist = ST_Distance(center,ST_PointN(ring,k));\r
- IF (dist > radius) THEN\r
- -- We have to expand the circle. The new circle must pass trhough\r
- -- three points - the two original diameters and this point.\r
-\r
- -- Draw a line from the first diameter to this point\r
- l1 = ST_Makeline(ST_PointN(ring,idx1),ST_PointN(ring,k));\r
- -- Compute the midpoint\r
- p1 = ST_line_interpolate_point(l1,0.5);\r
- -- Rotate the line 90 degrees around the midpoint (perpendicular bisector)\r
- l1 = ST_Rotate(l1,pi()/2,p1);\r
- -- Compute the azimuth of the bisector\r
- a1 = ST_Azimuth(ST_PointN(l1,1),ST_PointN(l1,2));\r
- -- Extend the line in each direction the new computed distance to insure they will intersect\r
- l1 = ST_AddPoint(l1,ST_Makepoint(ST_X(ST_PointN(l1,2))+sin(a1)*dist,ST_Y(ST_PointN(l1,2))+cos(a1)*dist),-1);\r
- l1 = ST_AddPoint(l1,ST_Makepoint(ST_X(ST_PointN(l1,1))-sin(a1)*dist,ST_Y(ST_PointN(l1,1))-cos(a1)*dist),0);\r
-\r
- -- Repeat for the line from the point to the other diameter point\r
- l2 = ST_Makeline(ST_PointN(ring,idx2),ST_PointN(ring,k));\r
- p2 = ST_Line_interpolate_point(l2,0.5);\r
- l2 = ST_Rotate(l2,pi()/2,p2);\r
- a2 = ST_Azimuth(ST_PointN(l2,1),ST_PointN(l2,2));\r
- l2 = ST_AddPoint(l2,ST_Makepoint(ST_X(ST_PointN(l2,2))+sin(a2)*dist,ST_Y(ST_PointN(l2,2))+cos(a2)*dist),-1);\r
- l2 = ST_AddPoint(l2,ST_Makepoint(ST_X(ST_PointN(l2,1))-sin(a2)*dist,ST_Y(ST_PointN(l2,1))-cos(a2)*dist),0);\r
-\r
- -- The new center is the intersection of the two bisectors\r
- center = ST_Intersection(l1,l2);\r
- -- The new radius is the distance to any of the three points\r
- radius = ST_Distance(center,ST_PointN(ring,idx1));\r
- END IF;\r
- END IF;\r
- END LOOP;\r
- --DONE!! Return the MBC via the buffer command\r
- RETURN ST_Buffer(center,radius,segs_per_quarter);\r
-\r
- END;\r
-$BODY$\r
- LANGUAGE 'plpgsql' IMMUTABLE STRICT;\r
-\r
- \r
--- ST_ConcaveHull and Helper functions starts here --\r
------------------------------------------------------------------------\r
--- Contributed by Regina Obe and Leo Hsu\r
--- Availability: 2.0.0\r
------------------------------------------------------------------------\r
-CREATE OR REPLACE FUNCTION _st_concavehull(param_inputgeom geometry)\r
- RETURNS geometry AS\r
-$$\r
- DECLARE \r
- vexhull GEOMETRY;\r
- var_resultgeom geometry;\r
- var_inputgeom geometry;\r
- vexring GEOMETRY;\r
- cavering GEOMETRY;\r
- cavept geometry[];\r
- seglength double precision;\r
- var_tempgeom geometry;\r
- scale_factor integer := 1;\r
- i integer;\r
- \r
- BEGIN\r
-\r
- -- First compute the ConvexHull of the geometry\r
- vexhull := ST_ConvexHull(param_inputgeom);\r
- var_inputgeom := param_inputgeom;\r
- --A point really has no concave hull\r
- IF ST_GeometryType(vexhull) = 'ST_Point' OR ST_GeometryType(vexHull) = 'ST_LineString' THEN\r
- RETURN vexhull;\r
- END IF;\r
-\r
- -- convert the hull perimeter to a linestring so we can manipulate individual points\r
- vexring := CASE WHEN ST_GeometryType(vexhull) = 'ST_LineString' THEN vexhull ELSE ST_ExteriorRing(vexhull) END;\r
- IF abs(ST_X(ST_PointN(vexring,1))) < 1 THEN --scale the geometry to prevent stupid precision errors - not sure it works so make low for now\r
- scale_factor := 100;\r
- vexring := ST_Scale(vexring, scale_factor,scale_factor);\r
- var_inputgeom := ST_Scale(var_inputgeom, scale_factor, scale_factor);\r
- --RAISE NOTICE 'Scaling';\r
- END IF;\r
- seglength := ST_Length(vexring)/least(ST_NPoints(vexring)*2,1000) ;\r
-\r
- vexring := ST_Segmentize(vexring, seglength);\r
- -- find the point on the original geom that is closest to each point of the convex hull and make a new linestring out of it.\r
- cavering := ST_Collect(\r
- ARRAY(\r
-\r
- SELECT \r
- ST_ClosestPoint(var_inputgeom, pt ) As the_geom\r
- FROM (\r
- SELECT ST_PointN(vexring, n ) As pt, n\r
- FROM \r
- generate_series(1, ST_NPoints(vexring) ) As n\r
- ) As pt\r
- \r
- )\r
- )\r
- ; \r
- \r
-\r
- var_resultgeom := ST_MakeLine(geom) \r
- FROM ST_Dump(cavering) As foo;\r
-\r
- IF ST_IsSimple(var_resultgeom) THEN\r
- var_resultgeom := ST_MakePolygon(var_resultgeom);\r
- --RAISE NOTICE 'is Simple: %', var_resultgeom;\r
- ELSE /** will not result in a valid polygon -- just return convex hull **/\r
- --RAISE NOTICE 'is not Simple: %', var_resultgeom;\r
- var_resultgeom := ST_ConvexHull(var_resultgeom);\r
- END IF;\r
- \r
- IF scale_factor > 1 THEN -- scale the result back\r
- var_resultgeom := ST_Scale(var_resultgeom, 1/scale_factor, 1/scale_factor);\r
- END IF;\r
- RETURN var_resultgeom;\r
- \r
- END;\r
-$$\r
- LANGUAGE plpgsql IMMUTABLE STRICT;\r
- \r
-CREATE OR REPLACE FUNCTION ST_ConcaveHull(param_geom geometry, param_pctconvex float, param_allow_holes boolean DEFAULT false) RETURNS geometry AS\r
-$$\r
- DECLARE\r
- var_convhull geometry := ST_ConvexHull(param_geom);\r
- var_param_geom geometry := param_geom;\r
- var_initarea float := ST_Area(var_convhull);\r
- var_newarea float := var_initarea;\r
- var_div integer := 6; /** this is the 1/var_div is the percent increase we will allow per triangle to keep speed decent **/\r
- var_tempgeom geometry;\r
- var_tempgeom2 geometry;\r
- var_cent geometry;\r
- var_geoms geometry[4]; /** We will cut the current geometry into 4 triangular quadrants along the centroid/extent **/\r
- var_enline geometry;\r
- var_resultgeom geometry;\r
- var_atempgeoms geometry[];\r
- var_buf float := 1; /**tolerance so that geometries that are right on the extent don't get accidentally clipped off **/\r
- BEGIN\r
- -- We start with convex hull as our base\r
- var_resultgeom := var_convhull;\r
- \r
- IF param_pctconvex = 1 THEN\r
- return var_resultgeom;\r
- ELSIF ST_GeometryType(var_param_geom) = 'ST_Polygon' THEN -- it is as concave as it is going to get\r
- IF param_allow_holes THEN -- leave the holes\r
- RETURN var_param_geom;\r
- ELSE -- remove the holes\r
- var_resultgeom := ST_MakePolygon(ST_ExteriorRing(var_param_geom));\r
- RETURN var_resultgeom;\r
- END IF;\r
- END IF;\r
- IF ST_Dimension(var_resultgeom) > 1 AND param_pctconvex BETWEEN 0 and 0.98 THEN\r
- -- get linestring that forms envelope of geometry\r
- var_enline := ST_Boundary(ST_Envelope(var_param_geom));\r
- var_buf := ST_Length(var_enline)/1000.0;\r
- IF ST_GeometryType(var_param_geom) = 'ST_MultiPoint' AND ST_NumGeometries(var_param_geom) BETWEEN 4 and 200 THEN\r
- -- we make polygons out of points since they are easier to cave in. \r
- -- Note we limit to between 4 and 200 points because this process is slow and gets quadratically slow\r
- var_buf := sqrt(ST_Area(var_convhull)*0.8/(ST_NumGeometries(var_param_geom)*ST_NumGeometries(var_param_geom)));\r
- var_atempgeoms := ARRAY(SELECT geom FROM ST_DumpPoints(var_param_geom));\r
- -- 5 and 10 and just fudge factors\r
- var_tempgeom := ST_Union(ARRAY(SELECT geom\r
- FROM (\r
- -- fuse near neighbors together\r
- SELECT DISTINCT ON (i) i, ST_Distance(var_atempgeoms[i],var_atempgeoms[j]), ST_Buffer(ST_MakeLine(var_atempgeoms[i], var_atempgeoms[j]) , var_buf*5, 'quad_segs=3') As geom\r
- FROM generate_series(1,array_upper(var_atempgeoms, 1)) As i\r
- INNER JOIN generate_series(1,array_upper(var_atempgeoms, 1)) As j \r
- ON (\r
- NOT ST_Intersects(var_atempgeoms[i],var_atempgeoms[j])\r
- AND ST_DWithin(var_atempgeoms[i],var_atempgeoms[j], var_buf*10)\r
- )\r
- UNION ALL\r
- -- catch the ones with no near neighbors\r
- SELECT i, 0, ST_Buffer(var_atempgeoms[i] , var_buf*10, 'quad_segs=3') As geom\r
- FROM generate_series(1,array_upper(var_atempgeoms, 1)) As i\r
- LEFT JOIN generate_series(ceiling(array_upper(var_atempgeoms,1)/2)::integer,array_upper(var_atempgeoms, 1)) As j \r
- ON (\r
- NOT ST_Intersects(var_atempgeoms[i],var_atempgeoms[j])\r
- AND ST_DWithin(var_atempgeoms[i],var_atempgeoms[j], var_buf*10) \r
- )\r
- WHERE j IS NULL\r
- ORDER BY 1, 2\r
- ) As foo ) );\r
- IF ST_IsValid(var_tempgeom) AND ST_GeometryType(var_tempgeom) = 'ST_Polygon' THEN\r
- var_tempgeom := ST_Intersection(var_tempgeom, var_convhull);\r
- IF param_allow_holes THEN\r
- var_param_geom := var_tempgeom;\r
- ELSE\r
- var_param_geom := ST_MakePolygon(ST_ExteriorRing(var_tempgeom));\r
- END IF;\r
- return var_param_geom;\r
- ELSIF ST_IsValid(var_tempgeom) THEN\r
- var_param_geom := ST_Intersection(var_tempgeom, var_convhull); \r
- END IF;\r
- END IF;\r
-\r
- IF ST_GeometryType(var_param_geom) = 'ST_Polygon' THEN\r
- IF NOT param_allow_holes THEN\r
- var_param_geom := ST_MakePolygon(ST_ExteriorRing(var_param_geom));\r
- END IF;\r
- return var_param_geom;\r
- END IF;\r
- var_cent := ST_Centroid(var_param_geom);\r
- IF (ST_XMax(var_enline) - ST_XMin(var_enline) ) > var_buf AND (ST_YMax(var_enline) - ST_YMin(var_enline) ) > var_buf THEN\r
- IF ST_Dwithin(ST_Centroid(var_convhull) , ST_Centroid(ST_Envelope(var_param_geom)), var_buf/2) THEN\r
- -- If the geometric dimension is > 1 and the object is symettric (cutting at centroid will not work -- offset a bit)\r
- var_cent := ST_Translate(var_cent, (ST_XMax(var_enline) - ST_XMin(var_enline))/1000, (ST_YMAX(var_enline) - ST_YMin(var_enline))/1000);\r
- ELSE\r
- -- uses closest point on geometry to centroid. I can't explain why we are doing this\r
- var_cent := ST_ClosestPoint(var_param_geom,var_cent);\r
- END IF;\r
- IF ST_DWithin(var_cent, var_enline,var_buf) THEN\r
- var_cent := ST_centroid(ST_Envelope(var_param_geom));\r
- END IF;\r
- -- break envelope into 4 triangles about the centroid of the geometry and returned the clipped geometry in each quadrant\r
- FOR i in 1 .. 4 LOOP\r
- var_geoms[i] := ST_MakePolygon(ST_MakeLine(ARRAY[ST_PointN(var_enline,i), ST_PointN(var_enline,i+1), var_cent, ST_PointN(var_enline,i)]));\r
- var_geoms[i] := ST_Intersection(var_param_geom, ST_Buffer(var_geoms[i],var_buf));\r
- IF ST_IsValid(var_geoms[i]) THEN \r
- \r
- ELSE\r
- var_geoms[i] := ST_BuildArea(ST_MakeLine(ARRAY[ST_PointN(var_enline,i), ST_PointN(var_enline,i+1), var_cent, ST_PointN(var_enline,i)]));\r
- END IF; \r
- END LOOP;\r
- var_tempgeom := ST_Union(ARRAY[ST_ConvexHull(var_geoms[1]), ST_ConvexHull(var_geoms[2]) , ST_ConvexHull(var_geoms[3]), ST_ConvexHull(var_geoms[4])]); \r
- --RAISE NOTICE 'Curr vex % ', ST_AsText(var_tempgeom);\r
- IF ST_Area(var_tempgeom) <= var_newarea AND ST_IsValid(var_tempgeom) THEN --AND ST_GeometryType(var_tempgeom) ILIKE '%Polygon'\r
- \r
- var_tempgeom := ST_Buffer(ST_ConcaveHull(var_geoms[1],least(param_pctconvex + param_pctconvex/var_div),true),var_buf, 'quad_segs=2');\r
- FOR i IN 1 .. 4 LOOP\r
- var_geoms[i] := ST_Buffer(ST_ConcaveHull(var_geoms[i],least(param_pctconvex + param_pctconvex/var_div),true), var_buf, 'quad_segs=2');\r
- IF ST_IsValid(var_geoms[i]) Then\r
- var_tempgeom := ST_Union(var_tempgeom, var_geoms[i]);\r
- ELSE\r
- RAISE NOTICE 'Not valid % %', i, ST_AsText(var_tempgeom);\r
- var_tempgeom := ST_Union(var_tempgeom, ST_ConvexHull(var_geoms[i]));\r
- END IF; \r
- END LOOP;\r
-\r
- --RAISE NOTICE 'Curr concave % ', ST_AsText(var_tempgeom);\r
- IF ST_IsValid(var_tempgeom) THEN\r
- var_resultgeom := var_tempgeom;\r
- END IF;\r
- var_newarea := ST_Area(var_resultgeom);\r
- ELSIF ST_IsValid(var_tempgeom) THEN\r
- var_resultgeom := var_tempgeom;\r
- END IF;\r
-\r
- IF ST_NumGeometries(var_resultgeom) > 1 THEN\r
- var_tempgeom := _ST_ConcaveHull(var_resultgeom);\r
- IF ST_IsValid(var_tempgeom) AND ST_GeometryType(var_tempgeom) ILIKE 'ST_Polygon' THEN\r
- var_resultgeom := var_tempgeom;\r
- ELSE\r
- var_resultgeom := ST_Buffer(var_tempgeom,var_buf, 'quad_segs=2');\r
- END IF;\r
- END IF;\r
- IF param_allow_holes = false THEN \r
- -- only keep exterior ring since we do not want holes\r
- var_resultgeom := ST_MakePolygon(ST_ExteriorRing(var_resultgeom));\r
- END IF;\r
- ELSE\r
- var_resultgeom := ST_Buffer(var_resultgeom,var_buf);\r
- END IF;\r
- var_resultgeom := ST_Intersection(var_resultgeom, ST_ConvexHull(var_param_geom));\r
- ELSE\r
- -- dimensions are too small to cut\r
- var_resultgeom := _ST_ConcaveHull(var_param_geom);\r
- END IF;\r
- RETURN var_resultgeom;\r
- END;\r
-$$\r
-LANGUAGE 'plpgsql' IMMUTABLE STRICT;\r
--- ST_ConcaveHull and Helper functions end here --\r
-\r
------------------------------------------------------------------------\r
--- X3D OUTPUT\r
------------------------------------------------------------------------\r
--- _ST_AsX3D(version, geom, precision, option, attribs)\r
-CREATE OR REPLACE FUNCTION _ST_AsX3D(int4, geometry, int4, int4, text)\r
- RETURNS TEXT\r
- AS 'MODULE_PATHNAME','LWGEOM_asX3D'\r
- LANGUAGE 'C' IMMUTABLE;\r
- \r
--- ST_AsX3D(geom, precision, options)\r
-CREATE OR REPLACE FUNCTION ST_AsX3D(geom geometry, maxdecimaldigits integer DEFAULT 15, options integer DEFAULT 0)\r
- RETURNS TEXT\r
- AS $$SELECT _ST_AsX3D(3,$1,$2,$3,'');$$\r
- LANGUAGE 'sql' IMMUTABLE;\r
-\r
-COMMIT;\r
-\r
-#include "postgis_drop.sql.in.c"\r
projects / postgis / commitdiff