/*-------------------------------------------------------------------------
*
- * geo-ops.c--
+ * geo_ops.c--
* 2D geometric operations
*
* Copyright (c) 1994, Regents of the University of California
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/utils/adt/geo_ops.c,v 1.2 1997/03/14 23:20:15 scrappy Exp $
+ * $Header: /cvsroot/pgsql/src/backend/utils/adt/geo_ops.c,v 1.3 1997/04/22 17:31:32 scrappy Exp $
*
*-------------------------------------------------------------------------
*/
#include <math.h>
-#include <float.h> /* faked on sunos */
+#include <float.h>
#include <stdio.h> /* for sprintf proto, etc. */
+#include <stdlib.h> /* for strtod, etc. */
#include <string.h>
+#include <ctype.h>
#include "postgres.h"
#include "utils/geo_decls.h"
#include "utils/palloc.h"
+#define OLD_FORMAT_IN 1
+#define OLD_FORMAT_OUT 0
+
+/*
+ * Delimiters for input and output strings.
+ * LDELIM, RDELIM, and DELIM are left, right, and separator delimiters, respectively.
+ * LDELIM_EP, RDELIM_EP are left and right delimiters for paths with endpoints.
+ */
+
#define LDELIM '('
#define RDELIM ')'
#define DELIM ','
-#define BOXNARGS 4
-#define LSEGNARGS 4
-#define POINTNARGS 2
+#define LDELIM_EP '['
+#define RDELIM_EP ']'
+#define LDELIM_C '<'
+#define RDELIM_C '>'
+
+/* Maximum number of output digits printed */
+#define P_MAXDIG DBL_DIG
+#define P_MAXLEN (2*(P_MAXDIG+7)+1)
+
+static int digits8 = P_MAXDIG;
+
+int geo_precision(int digits);
+
+int geo_precision(int digits)
+{
+ if (digits > P_MAXDIG) {
+ digits8 = P_MAXDIG;
+ } else if (digits > 0) {
+ digits8 = digits;
+ };
+ return digits8;
+}
+
+/*
+ * Geometric data types are composed of points.
+ * This code tries to support a common format throughout the data types,
+ * to allow for more predictable usage and data type conversion.
+ * The fundamental unit is the point. Other units are line segments,
+ * open paths, boxes, closed paths, and polygons (which should be considered
+ * non-intersecting closed paths).
+ *
+ * Data representation is as follows:
+ * point: (x,y)
+ * line segment: [(x1,y1),(x2,y2)]
+ * box: (x1,y1),(x2,y2)
+ * open path: [(x1,y1),...,(xn,yn)]
+ * closed path: ((x1,y1),...,(xn,yn))
+ * polygon: ((x1,y1),...,(xn,yn))
+ *
+ * For boxes, the points are opposite corners with the first point at the top right.
+ * For closed paths and polygons, the points should be reordered to allow
+ * fast and correct equality comparisons.
+ *
+ * XXX perhaps points in complex shapes should be reordered internally
+ * to allow faster internal operations, but should keep track of input order
+ * and restore that order for text output - tgl 97/01/16
+ */
+
+int pair_decode(char *str, float8 *x, float8 *y, char **s);
+int pair_encode(float8 x, float8 y, char *str);
+int pair_count(char *s, char delim);
+int path_decode(int opentype, int npts, char *str, int *isopen, char **ss, Point *p);
+
+char *path_encode( bool closed, int npts, Point *pt);
+
+int pair_decode(char *str, float8 *x, float8 *y, char **s)
+{
+ int has_delim;
+ char *cp;
+
+ if (!PointerIsValid((char *)str))
+ return(FALSE);
+
+ while (isspace( *str)) str++;
+ if ((has_delim = (*str == LDELIM))) str++;
+
+ while (isspace( *str)) str++;
+ *x = strtod( str, &cp);
+ if (cp <= str) return(FALSE);
+ while (isspace( *cp)) cp++;
+ if (*cp++ != DELIM) return(FALSE);
+ while (isspace( *cp)) cp++;
+ *y = strtod( cp, &str);
+ if (str <= cp) return(FALSE);
+ while (isspace( *str)) str++;
+ if (has_delim) {
+ if (*str != RDELIM) return(FALSE);
+ str++;
+ while (isspace( *str)) str++;
+ };
+ if (s != NULL) *s = str;
+
+ return(TRUE);
+}
+
+int pair_encode(float8 x, float8 y, char *str)
+{
+ (void) sprintf(str, "%.*g,%.*g", digits8, x, digits8, y);
+ return(TRUE);
+}
+
+int path_decode(int opentype, int npts, char *str, int *isopen, char **ss, Point *p)
+{
+ int depth = 0;
+ char *s, *cp;
+ int i;
+
+ s = str;
+ while (isspace( *s)) s++;
+ if ((*isopen = (*s == LDELIM_EP))) {
+ /* no open delimiter allowed? */
+ if (! opentype) return(FALSE);
+ depth++;
+ s++;
+ while (isspace( *s)) s++;
+
+ } else if (*s == LDELIM) {
+ cp = (s+1);
+ while (isspace( *cp)) cp++;
+ if (*cp == LDELIM) {
+ /* nested delimiters with only one point? */
+ if (npts <= 1) return(FALSE);
+ depth++;
+ s = cp;
+ } else if (strrchr( s, LDELIM) == s) {
+ depth++;
+ s = cp;
+ };
+ };
+
+ for (i = 0; i < npts; i++) {
+ if (! pair_decode( s, &(p->x), &(p->y), &s))
+ return(FALSE);
+
+ if (*s == DELIM) s++;
+ p++;
+ };
+
+ while (depth > 0) {
+ if ((*s == RDELIM)
+ || ((*s == RDELIM_EP) && (*isopen) && (depth == 1))) {
+ depth--;
+ s++;
+ while (isspace( *s)) s++;
+ } else {
+ return(FALSE);
+ };
+ };
+ *ss = s;
+
+ return(TRUE);
+} /* path_decode() */
+
+char *path_encode( bool closed, int npts, Point *pt)
+{
+ char *result;
+
+ char *cp;
+ int i;
+
+ if (!PointerIsValid(result = (char *)PALLOC(npts*(P_MAXLEN+3)+2)))
+ elog(WARN, "Memory allocation failed, can't output path", NULL);
+
+ cp = result;
+ switch (closed) {
+ case TRUE:
+ *cp++ = LDELIM;
+ break;
+ case FALSE:
+ *cp++ = LDELIM_EP;
+ break;
+ default:
+ break;
+ };
+
+ for (i = 0; i < npts; i++) {
+ *cp++ = LDELIM;
+ if (! pair_encode( pt->x, pt->y, cp))
+ elog (WARN, "Unable to format path", NULL);
+ cp += strlen(cp);
+ *cp++ = RDELIM;
+ *cp++ = DELIM;
+ pt++;
+ };
+ cp--;
+ switch (closed) {
+ case TRUE:
+ *cp++ = RDELIM;
+ break;
+ case FALSE:
+ *cp++ = RDELIM_EP;
+ break;
+ default:
+ break;
+ };
+ *cp = '\0';
+
+ return(result);
+} /* path_encode() */
+
+/*-------------------------------------------------------------
+ * pair_count - count the number of points
+ * allow the following notation:
+ * '((1,2),(3,4))'
+ * '(1,3,2,4)'
+ * require an odd number of delim characters in the string
+ *-------------------------------------------------------------*/
+int pair_count(char *s, char delim)
+{
+ int ndelim = 0;
+
+ while ((s = strchr( s, delim)) != NULL) {
+ ndelim++;
+ s++;
+ };
+ return((ndelim % 2)? ((ndelim+1)/2): -1);
+}
/***********************************************************************
**
/* box_in - convert a string to internal form.
*
- * str: input string "(f8, f8, f8, f8)"
+ * External format: (two corners of box)
+ * "(f8, f8), (f8, f8)"
+ * also supports the older style "(f8, f8, f8, f8)"
*/
BOX *box_in(char *str)
{
- double tmp;
- char *p, *coord[BOXNARGS];
- int i;
- BOX *result;
-
- if (str == NULL)
- elog (WARN," Bad (null) box external representation");
-
- if ((p = (char *)strchr(str, LDELIM)) == (char *)NULL)
+ BOX *box;
+
+ int isopen;
+ char *s;
+ double x, y;
+
+ if (!PointerIsValid((char *)str))
+ elog (WARN," Bad (null) box external representation",NULL);
+
+ if (!PointerIsValid(box = PALLOCTYPE(BOX)))
+ elog(WARN, "Memory allocation failed, can't input box '%s'",str);
+
+ if ((! path_decode(FALSE, 2, str, &isopen, &s, &(box->high)))
+ || (*s != '\0'))
elog (WARN, "Bad box external representation '%s'",str);
- for (i = 0, p = str; *p && i < BOXNARGS && *p != RDELIM; p++)
- if (*p == DELIM || (*p == LDELIM && !i))
- coord[i++] = p + 1;
- if (i < BOXNARGS - 1)
- elog (WARN, "Bad box external representation '%s'", str);
- result = PALLOCTYPE(BOX);
- result->xh = atof(coord[0]);
- result->yh = atof(coord[1]);
- result->xl = atof(coord[2]);
- result->yl = atof(coord[3]);
- if (result->xh < result->xl) {
- tmp = result->xh;
- result->xh = result->xl;
- result->xl = tmp;
- }
- if (result->yh < result->yl) {
- tmp = result->yh;
- result->yh = result->yl;
- result->yl = tmp;
- }
-
- return(result);
+
+ /* reorder corners if necessary... */
+ if (box->high.x < box->low.x) {
+ x = box->high.x;
+ box->high.x = box->low.x;
+ box->low.x = x;
+ };
+ if (box->high.y < box->low.y) {
+ y = box->high.y;
+ box->high.y = box->low.y;
+ box->low.y = y;
+ };
+
+ return(box);
}
/* box_out - convert a box to external form.
*/
char *box_out(BOX *box)
{
- char *result;
-
- if (box == NULL)
+#if OLD_FORMAT_OUT
+ char *result;
+
+ char *cp;
+#endif
+
+ if (!PointerIsValid((char *)box))
return(NULL);
- result = (char *)PALLOC(80);
- (void) sprintf(result, "(%G,%G,%G,%G)",
- box->xh, box->yh, box->xl, box->yl);
-
- return(result);
+
+#if OLD_FORMAT_OUT
+ if (!PointerIsValid(result = (char *)PALLOC(2*(P_MAXLEN+1)+2)))
+ elog(WARN, "Memory allocation failed, can't output box", NULL);
+
+ cp = result;
+ *cp++ = LDELIM;
+ if (! pair_encode( box->high.x, box->high.y, cp))
+ elog (WARN, "Unable to format box", NULL);
+ cp += strlen(cp);
+ *cp++ = DELIM;
+ if (! pair_encode( box->low.x, box->low.y, cp))
+ elog (WARN, "Unable to format box", NULL);
+ cp += strlen(cp);
+ *cp++ = RDELIM;
+ *cp = '\0';
+
+ return( result);
+#else
+ return( path_encode( -1, 2, (Point *) &(box->high)));
+#endif
}
*/
BOX *box_fill(BOX *result, double x1, double x2, double y1, double y2)
{
- double tmp;
-
- result->xh = x1;
- result->xl = x2;
- result->yh = y1;
- result->yl = y2;
- if (result->xh < result->xl) {
- tmp = result->xh;
- result->xh = result->xl;
- result->xl = tmp;
- }
- if (result->yh < result->yl) {
- tmp = result->yh;
- result->yh = result->yl;
- result->yl = tmp;
- }
+ if (x1 > x2) {
+ result->high.x = x1;
+ result->low.x = x2;
+ } else {
+ result->high.x = x2;
+ result->low.x = x1;
+ };
+ if (y1 > y2) {
+ result->high.y = y1;
+ result->low.y = y2;
+ } else {
+ result->high.y = y2;
+ result->low.y = y1;
+ };
return(result);
}
/* box_same - are two boxes identical?
*/
-long box_same(BOX *box1, BOX *box2)
+bool box_same(BOX *box1, BOX *box2)
{
- return((box1->xh == box2->xh && box1->xl == box2->xl) &&
- (box1->yh == box2->yh && box1->yl == box2->yl));
+ return((FPeq(box1->high.x,box2->high.x) && FPeq(box1->low.x,box2->low.x)) &&
+ (FPeq(box1->high.y,box2->high.y) && FPeq(box1->low.y,box2->low.y)));
}
/* box_overlap - does box1 overlap box2?
*/
-long box_overlap(BOX *box1, BOX *box2)
+bool box_overlap(BOX *box1, BOX *box2)
{
- return(((box1->xh >= box2->xh && box1->xl <= box2->xh) ||
- (box2->xh >= box1->xh && box2->xl <= box1->xh)) &&
- ((box1->yh >= box2->yh && box1->yl <= box2->yh) ||
- (box2->yh >= box1->yh && box2->yl <= box1->yh)) );
+ return(((FPge(box1->high.x,box2->high.x) && FPle(box1->low.x,box2->high.x)) ||
+ (FPge(box2->high.x,box1->high.x) && FPle(box2->low.x,box1->high.x))) &&
+ ((FPge(box1->high.y,box2->high.y) && FPle(box1->low.y,box2->high.y)) ||
+ (FPge(box2->high.y,box1->high.y) && FPle(box2->low.y,box1->high.y))) );
}
/* box_overleft - is the right edge of box1 to the left of
* This is "less than or equal" for the end of a time range,
* when time ranges are stored as rectangles.
*/
-long box_overleft(BOX *box1, BOX *box2)
+bool box_overleft(BOX *box1, BOX *box2)
{
- return(box1->xh <= box2->xh);
+ return(FPle(box1->high.x,box2->high.x));
}
/* box_left - is box1 strictly left of box2?
*/
-long box_left(BOX *box1, BOX *box2)
+bool box_left(BOX *box1, BOX *box2)
{
- return(box1->xh < box2->xl);
+ return(FPlt(box1->high.x,box2->low.x));
}
/* box_right - is box1 strictly right of box2?
*/
-long box_right(BOX *box1, BOX *box2)
+bool box_right(BOX *box1, BOX *box2)
{
- return(box1->xl > box2->xh);
+ return(FPgt(box1->low.x,box2->high.x));
}
/* box_overright - is the left edge of box1 to the right of
* This is "greater than or equal" for time ranges, when time ranges
* are stored as rectangles.
*/
-long box_overright(BOX *box1, BOX *box2)
+bool box_overright(BOX *box1, BOX *box2)
{
- return(box1->xl >= box2->xl);
+ return(box1->low.x >= box2->low.x);
}
/* box_contained - is box1 contained by box2?
*/
-long box_contained(BOX *box1, BOX *box2)
+bool box_contained(BOX *box1, BOX *box2)
{
- return((box1->xh <= box2->xh && box1->xl >= box2->xl &&
- box1->yh <= box2->yh && box1->yl >= box2->yl));
+ return((FPle(box1->high.x,box2->high.x) && FPge(box1->low.x,box2->low.x)) &&
+ (FPle(box1->high.y,box2->high.y) && FPge(box1->low.y,box2->low.y)));
}
/* box_contain - does box1 contain box2?
*/
-long box_contain(BOX *box1, BOX *box2)
+bool box_contain(BOX *box1, BOX *box2)
{
- return((box1->xh >= box2->xh && box1->xl <= box2->xl &&
- box1->yh >= box2->yh && box1->yl <= box2->yl));
+ return((FPge(box1->high.x,box2->high.x) && FPle(box1->low.x,box2->low.x) &&
+ FPge(box1->high.y,box2->high.y) && FPle(box1->low.y,box2->low.y)));
}
/* box_positionop -
- * is box1 entirely {above, below } box2?
+ * is box1 entirely {above,below} box2?
*/
-long box_below(BOX *box1, BOX *box2)
+bool box_below(BOX *box1, BOX *box2)
{
- return( box1->yh <= box2->yl );
+ return( FPle(box1->high.y,box2->low.y) );
}
-long box_above(BOX *box1, BOX *box2)
+bool box_above(BOX *box1, BOX *box2)
{
- return( box1->yl >= box2->yh );
+ return( FPge(box1->low.y,box2->high.y) );
}
/* box_relop - is area(box1) relop area(box2), within
* our accuracy constraint?
*/
-long box_lt(BOX *box1, BOX *box2)
+bool box_lt(BOX *box1, BOX *box2)
{
return( FPlt(box_ar(box1), box_ar(box2)) );
}
-long box_gt(BOX *box1, BOX *box2)
+bool box_gt(BOX *box1, BOX *box2)
{
return( FPgt(box_ar(box1), box_ar(box2)) );
}
-long box_eq(BOX *box1, BOX *box2)
+bool box_eq(BOX *box1, BOX *box2)
{
return( FPeq(box_ar(box1), box_ar(box2)) );
}
-long box_le(BOX *box1, BOX *box2)
+bool box_le(BOX *box1, BOX *box2)
{
return( FPle(box_ar(box1), box_ar(box2)) );
}
-long box_ge(BOX *box1, BOX *box2)
+bool box_ge(BOX *box1, BOX *box2)
{
return( FPge(box_ar(box1), box_ar(box2)) );
}
double *result;
result = PALLOCTYPE(double);
- *result = box->xh - box->xl;
+ *result = box->high.x - box->low.x;
return(result);
}
double *result;
result = PALLOCTYPE(double);
- *result = box->yh - box->yl;
+ *result = box->high.y - box->low.y;
return(result);
}
double *box_distance(BOX *box1, BOX *box2)
{
double *result;
- Point *box_center(), *a, *b;
+ Point *a, *b;
result = PALLOCTYPE(double);
a = box_center(box1);
Point *result;
result = PALLOCTYPE(Point);
- result->x = (box->xh + box->xl) / 2.0;
- result->y = (box->yh + box->yl) / 2.0;
+ result->x = (box->high.x + box->low.x) / 2.0;
+ result->y = (box->high.y + box->low.y) / 2.0;
return(result);
}
*/
double box_ln(BOX *box)
{
- return( box->xh - box->xl );
+ return( box->high.x - box->low.x );
}
*/
double box_ht(BOX *box)
{
- return( box->yh - box->yl );
+ return( box->high.y - box->low.y );
}
double box_dt(BOX *box1, BOX *box2)
{
double result;
- Point *box_center(),
- *a, *b;
+ Point *a, *b;
a = box_center(box1);
b = box_center(box2);
BOX *box_intersect(BOX *box1, BOX *box2)
{
BOX *result;
- long box_overlap();
-
+
if (! box_overlap(box1,box2))
return(NULL);
result = PALLOCTYPE(BOX);
- result->xh = Min(box1->xh, box2->xh);
- result->xl = Max(box1->xl, box2->xl);
- result->yh = Min(box1->yh, box2->yh);
- result->yl = Max(box1->yl, box2->yl);
+ result->high.x = Min(box1->high.x, box2->high.x);
+ result->low.x = Max(box1->low.x, box2->low.x);
+ result->high.y = Min(box1->high.y, box2->high.y);
+ result->low.y = Max(box1->low.y, box2->low.y);
return(result);
}
{
Point p1, p2;
- p1.x = box->xh;
- p1.y = box->yh;
- p2.x = box->xl;
- p2.y = box->yl;
+ p1.x = box->high.x;
+ p1.y = box->high.y;
+ p2.x = box->low.x;
+ p2.y = box->low.y;
return( lseg_construct( &p1, &p2 ) );
}
* Relative position routines.
*---------------------------------------------------------*/
-long line_intersect(LINE *l1, LINE *l2)
+bool line_intersect(LINE *l1, LINE *l2)
{
return( ! line_parallel(l1, l2) );
}
-long line_parallel(LINE *l1, LINE *l2)
+bool line_parallel(LINE *l1, LINE *l2)
{
return( FPeq(l1->m, l2->m) );
}
-long line_perp(LINE *l1, LINE *l2)
+bool line_perp(LINE *l1, LINE *l2)
{
if (l1->m)
return( FPeq(l2->m / l1->m, -1.0) );
return(1); /* both 0.0 */
}
-long line_vertical(LINE *line)
+bool line_vertical(LINE *line)
{
return( FPeq(line->A, -1.0) && FPzero(line->B) );
}
-long line_horizontal(LINE *line)
+bool line_horizontal(LINE *line)
{
return( FPzero(line->m) );
}
-long line_eq(LINE *l1, LINE *l2)
+bool line_eq(LINE *l1, LINE *l2)
{
double k;
**
***********************************************************************/
-#define PATHALLOCSIZE(N) \
- (long) ((unsigned) (sizeof(PATH) + \
- (((N)-1) > 0 ? ((N)-1) : 0) \
- * sizeof(Point)))
-
/*----------------------------------------------------------
* String to path / path to string conversion.
* External format:
+ * "((xcoord, ycoord),... )"
+ * "[(xcoord, ycoord),... ]"
+ * "(xcoord, ycoord),... "
+ * "[xcoord, ycoord,... ]"
+ * Also support older format:
* "(closed, npts, xcoord, ycoord,... )"
*---------------------------------------------------------*/
PATH *path_in(char *str)
{
- double coord;
- long field[2];
- char *s;
- int ct, i;
- PATH *result;
- long pathsize;
-
- if (str == NULL)
+ PATH *path;
+
+ int isopen;
+ char *s;
+ int npts;
+ int size;
+#if OLD_FORMAT_IN
+ int oldstyle = FALSE;
+ double x, y;
+#endif
+
+ if (!PointerIsValid((char *)str))
elog(WARN, "Bad (null) path external representation");
-
- /* read the path header information */
- for (i = 0, s = str; *s && i < 2 && *s != RDELIM; ++s)
- if (*s == DELIM || (*s == LDELIM && !i))
- field[i++] = atol(s + 1);
- if (i < 1)
- elog(WARN, "Bad path external representation '%s'", str);
- pathsize = PATHALLOCSIZE(field[1]);
- result = (PATH *)palloc(pathsize);
- result->length = pathsize;
- result->closed = field[0];
- result->npts = field[1];
-
- /* read the path points */
-
- ct = result->npts * 2; /* two coords for every point */
- for (i = 0;
- *s && i < ct && *s != RDELIM;
- ++s) {
- if (*s == ',') {
- coord = atof(s + 1);
- if (i % 2)
- (result->p[i/2]).y = coord;
- else
- (result->p[i/2]).x = coord;
- ++i;
- }
- }
- if (i % 2 || i < --ct) {
- PFREE(result);
+
+ if ((npts = pair_count(str, ',')) <= 0)
elog(WARN, "Bad path external representation '%s'", str);
- }
-
- return(result);
+
+#if OLD_FORMAT_IN
+ s = str;
+ while (isspace( *s)) s++;
+ /* identify old style format as having only one left delimiter in string... */
+ oldstyle = ((*s == LDELIM) && (strrchr( s, LDELIM) == s));
+
+ /* old-style format? then first two fields are closed flag and point count... */
+ if (oldstyle) {
+ s++;
+ if ((! pair_decode( s, &x, &y, &s)) || (*s++ != DELIM)
+ || ((x != 0) && (x != 1)) || (y <= 0))
+ elog (WARN, "Bad path external representation '%s'",str);
+ isopen = (x == 0);
+ npts = y;
+ };
+#endif
+
+ size = offsetof(PATH, p[0]) + (sizeof(path->p[0]) * npts);
+ if (!PointerIsValid(path = PALLOC(size)))
+ elog(WARN, "Memory allocation failed, can't input path '%s'",str);
+
+ path->size = size;
+ path->npts = npts;
+ if (oldstyle) path->closed = (! isopen);
+
+#if OLD_FORMAT_IN
+ if ((! path_decode(TRUE, npts, s, &isopen, &s, &(path->p[0])))
+ || ! (oldstyle? (*s++ == RDELIM): (*s == '\0')))
+#else
+ if ((! path_decode(TRUE, npts, s, &isopen, &s, &(path->p[0])))
+ || (*s != '\0'))
+#endif
+ elog (WARN, "Bad path external representation '%s'",str);
+
+#if OLD_FORMAT_IN
+ if (oldstyle) {
+ while (isspace( *s)) s++;
+ if (*s != '\0')
+ elog (WARN, "Bad path external representation '%s'",str);
+ };
+#endif
+
+ if (! oldstyle) path->closed = (! isopen);
+
+ return(path);
}
char *path_out(PATH *path)
{
- char buf[BUFSIZ + 20000], *result, *s;
- int i;
- char tmp[64];
-
- if (path == NULL)
- return(NULL);
- (void) sprintf(buf,"%c%d,%d", LDELIM,
- path->closed, path->npts);
- s = buf + strlen(buf);
- for (i = 0; i < path->npts; ++i) {
- (void) sprintf(tmp, ",%G,%G",
- path->p[i].x, path->p[i].y);
- (void) strcpy(s, tmp);
- s += strlen(tmp);
- }
- *s++ = RDELIM;
- *s = '\0';
- result = (char *)PALLOC(strlen(buf) + 1);
- (void) strcpy(result, buf);
-
+#if OLD_FORMAT_OUT
+ int i;
+ char *result, *cp;
+#endif
+
+ if (!PointerIsValid((char *)path))
+ return NULL;
+
+#if OLD_FORMAT_OUT
+ if (!PointerIsValid(result = (char *)PALLOC(path->npts*(P_MAXLEN+3)+2)))
+ elog(WARN, "Memory allocation failed, can't output path", NULL);
+
+ cp = result;
+ *cp++ = LDELIM;
+ if (! pair_encode( path->closed, path->npts, cp))
+ elog (WARN, "Unable to format path", NULL);
+ cp += strlen(cp);
+
+ for (i=0; i<path->npts; i++) {
+ *cp++ = DELIM;
+ if (! pair_encode( path->p[i].x, path->p[i].y, cp))
+ elog (WARN, "Unable to format path", NULL);
+ cp += strlen(cp);
+ };
+ *cp++ = RDELIM;
+ *cp = '\0';
return(result);
+#else
+ return( path_encode( path->closed, path->npts, (Point *) &(path->p[0])));
+#endif
}
* Better relops and access methods coming soon.
*---------------------------------------------------------*/
-long path_n_lt(PATH *p1, PATH *p2)
+bool path_n_lt(PATH *p1, PATH *p2)
{
return( (p1->npts < p2->npts ) );
}
-long path_n_gt(PATH *p1, PATH *p2)
+bool path_n_gt(PATH *p1, PATH *p2)
{
return( (p1->npts > p2->npts ) );
}
-long path_n_eq(PATH *p1, PATH *p2)
+bool path_n_eq(PATH *p1, PATH *p2)
{
return( (p1->npts == p2->npts) );
}
-long path_n_le(PATH *p1, PATH *p2)
+bool path_n_le(PATH *p1, PATH *p2)
{
return( (p1->npts <= p2->npts ) );
}
-long path_n_ge(PATH *p1, PATH *p2)
+bool path_n_ge(PATH *p1, PATH *p2)
{
return( (p1->npts >= p2->npts ) );
}
+
+/*----------------------------------------------------------
+ * Conversion operators.
+ *---------------------------------------------------------*/
+
+PATH *path_copy(PATH *path);
+
+bool
+path_isclosed( PATH *path)
+{
+ if (!PointerIsValid((char *)path))
+ return FALSE;
+
+ return(path->closed);
+} /* path_isclosed() */
+
+bool
+path_isopen( PATH *path)
+{
+ if (!PointerIsValid((char *)path))
+ return FALSE;
+
+ return(! path->closed);
+} /* path_isopen() */
+
+
+int4
+path_npoints( PATH *path)
+{
+ if (!PointerIsValid((char *)path))
+ return 0;
+
+ return(path->npts);
+} /* path_npoints() */
+
+PATH *
+path_close(PATH *path)
+{
+ PATH *result;
+
+ if (PointerIsValid((char *)result = path_copy(path)))
+ result->closed = TRUE;
+
+ return(result);
+} /* path_close() */
+
+PATH *
+path_open(PATH *path)
+{
+ PATH *result;
+
+ if (PointerIsValid((char *)result = path_copy(path)))
+ result->closed = FALSE;
+
+ return(result);
+} /* path_open() */
+
+
+PATH *
+path_copy(PATH *path)
+{
+ PATH *result;
+ int size;
+
+ if (!PointerIsValid((char *)path))
+ return NULL;
+
+ size = offsetof(PATH, p[0]) + (sizeof(path->p[0]) * path->npts);
+ if (!PointerIsValid(result = PALLOC(size)))
+ elog(WARN, "Memory allocation failed, can't copy path",NULL);
+
+ memmove((char *) result, (char *) path, size);
+ return(result);
+} /* path_copy() */
+
+
/* path_inter -
* Does p1 intersect p2 at any point?
* Use bounding boxes for a quick (O(n)) check, then do a
* O(n^2) iterative edge check.
*/
-long path_inter(PATH *p1, PATH *p2)
+bool path_inter(PATH *p1, PATH *p2)
{
BOX b1, b2;
int i, j;
LSEG seg1, seg2;
- b1.xh = b1.yh = b2.xh = b2.yh = (double)DBL_MAX;
- b1.xl = b1.yl = b2.xl = b2.yl = -(double)DBL_MAX;
- for (i = 0; i < p1->npts; ++i) {
- b1.xh = Max(p1->p[i].x, b1.xh);
- b1.yh = Max(p1->p[i].y, b1.yh);
- b1.xl = Min(p1->p[i].x, b1.xl);
- b1.yl = Min(p1->p[i].y, b1.yl);
+ b1.high.x = b1.low.x = p1->p[0].x;
+ b1.high.y = b1.low.y = p1->p[0].y;
+ for (i = 1; i < p1->npts; i++) {
+ b1.high.x = Max(p1->p[i].x, b1.high.x);
+ b1.high.y = Max(p1->p[i].y, b1.high.y);
+ b1.low.x = Min(p1->p[i].x, b1.low.x);
+ b1.low.y = Min(p1->p[i].y, b1.low.y);
}
- for (i = 0; i < p2->npts; ++i) {
- b2.xh = Max(p2->p[i].x, b2.xh);
- b2.yh = Max(p2->p[i].y, b2.yh);
- b2.xl = Min(p2->p[i].x, b2.xl);
- b2.yl = Min(p2->p[i].y, b2.yl);
+ b2.high.x = b2.low.x = p2->p[0].x;
+ b2.high.y = b2.low.y = p2->p[0].y;
+ for (i = 1; i < p2->npts; i++) {
+ b2.high.x = Max(p2->p[i].x, b2.high.x);
+ b2.high.y = Max(p2->p[i].y, b2.high.y);
+ b2.low.x = Min(p2->p[i].x, b2.low.x);
+ b2.low.y = Min(p2->p[i].y, b2.low.y);
}
if (! box_overlap(&b1, &b2))
return(0);
two paths, and finds the min distance between any two lsegs */
double *path_distance(PATH *p1, PATH *p2)
{
- double *min, *tmp;
+ double *min = NULL, *tmp;
int i,j;
LSEG seg1, seg2;
-
+
+/*
statlseg_construct(&seg1, &p1->p[0], &p1->p[1]);
statlseg_construct(&seg2, &p2->p[0], &p2->p[1]);
min = lseg_distance(&seg1, &seg2);
-
+*/
+
for (i = 0; i < p1->npts - 1; i++)
for (j = 0; j < p2->npts - 1; j++)
{
statlseg_construct(&seg1, &p1->p[i], &p1->p[i+1]);
statlseg_construct(&seg2, &p2->p[j], &p2->p[j+1]);
- if (*min < *(tmp = lseg_distance(&seg1, &seg2)))
- *min = *tmp;
- PFREE(tmp);
+ tmp = lseg_distance(&seg1, &seg2);
+ if ((min == NULL) || (*min < *tmp)) {
+ if (min != NULL) PFREE(min);
+ min = tmp;
+ } else {
+ PFREE(tmp);
+ };
}
-
+
return(min);
}
double *path_length(PATH *path)
{
- double *result;
+ double *result;
int ct, i;
result = PALLOCTYPE(double);
ct = path->npts - 1;
- for (i = 0; i < ct; ++i)
+ for (i = 0; i < ct; i++)
*result += point_dt(&path->p[i], &path->p[i+1]);
return(result);
double path_ln(PATH *path)
{
- double result;
+ double result;
int ct, i;
ct = path->npts - 1;
- for (result = i = 0; i < ct; ++i)
+ for (result = i = 0; i < ct; i++)
result += point_dt(&path->p[i], &path->p[i+1]);
return(result);
/*----------------------------------------------------------
* String to point, point to string conversion.
- * External form: "(x, y)"
+ * External format:
+ * "(x,y)"
+ * "x,y"
*---------------------------------------------------------*/
-Point *point_in(char *str)
+Point *
+point_in(char *str)
{
- char *coord[POINTNARGS], *p, *r;
- int i;
- Point *result;
+ Point *point;
+
+ double x, y;
+ char *s;
- if (str == NULL)
+ if (str == NULL) {
elog(WARN, "Bad (null) point external representation");
-
- if ((p = (char *)strchr(str, LDELIM)) == (char *)NULL)
- elog (WARN, "Bad point external representation '%s'",str);
- for (i = 0, p++; *p && i < POINTNARGS-1 && *p != RDELIM; p = r+1)
- if ((r = (char *)strchr(p, DELIM)) == (char *)NULL)
- elog (WARN, "Bad point external representation '%s'",str);
- else
- coord[i++] = p;
- if ((r = (char *)strchr(p, RDELIM)) == (char *)NULL)
- elog (WARN, "Bad point external representation '%s'",str);
- coord[i++] = p;
-
- if (i < POINTNARGS - 1)
- elog(WARN, "Bad point external representation '%s'",str);
- result = PALLOCTYPE(Point);
- result->x = atof(coord[0]);
- result->y = atof(coord[1]);
- return(result);
-}
+ return NULL;
+ }
+
+ if (! pair_decode( str, &x, &y, &s) || (strlen(s) > 0))
+ elog (WARN, "Bad point external representation '%s'",str);
-char *point_out(Point *pt)
+ if (!PointerIsValid(point = PALLOCTYPE(Point)))
+ elog (WARN, "Unable to allocate point storage for '%s'",str);
+
+ point->x = x;
+ point->y = y;
+
+ return(point);
+} /* point_in() */
+
+char *
+point_out(Point *pt)
{
- char *result;
-
- if (pt == NULL)
+ if (!PointerIsValid((char *)pt))
return(NULL);
- result = (char *)PALLOC(40);
- (void) sprintf(result, "(%G,%G)", pt->x, pt->y);
- return(result);
-}
+
+ return( path_encode( -1, 1, pt));
+} /* point_out() */
Point *point_construct(double x, double y)
{
- Point *result;
+ Point *result;
result = PALLOCTYPE(Point);
result->x = x;
Point *point_copy(Point *pt)
{
- Point *result;
+ Point *result;
result = PALLOCTYPE(Point);
result->x = pt->x;
* EPSILON = 0.0).
*---------------------------------------------------------*/
-long point_left(Point *pt1, Point *pt2)
+bool point_left(Point *pt1, Point *pt2)
{
return( FPlt(pt1->x, pt2->x) );
}
-long point_right(Point *pt1, Point *pt2)
+bool point_right(Point *pt1, Point *pt2)
{
return( FPgt(pt1->x, pt2->x) );
}
-long point_above(Point *pt1, Point *pt2)
+bool point_above(Point *pt1, Point *pt2)
{
return( FPgt(pt1->y, pt2->y) );
}
-long point_below(Point *pt1, Point *pt2)
+bool point_below(Point *pt1, Point *pt2)
{
return( FPlt(pt1->y, pt2->y) );
}
-long point_vert(Point *pt1, Point *pt2)
+bool point_vert(Point *pt1, Point *pt2)
{
return( FPeq( pt1->x, pt2->x ) );
}
-long point_horiz(Point *pt1, Point *pt2)
+bool point_horiz(Point *pt1, Point *pt2)
{
return( FPeq( pt1->y, pt2->y ) );
}
-long point_eq(Point *pt1, Point *pt2)
+bool point_eq(Point *pt1, Point *pt2)
{
return( point_horiz(pt1, pt2) && point_vert(pt1, pt2) );
}
* "Arithmetic" operators on points.
*---------------------------------------------------------*/
-long pointdist(Point *p1, Point *p2)
+int32 pointdist(Point *p1, Point *p2)
{
- long result;
+ int32 result;
result = point_dt(p1, p2);
return(result);
double *point_distance(Point *pt1, Point *pt2)
{
- double *result;
+ double *result;
result = PALLOCTYPE(double);
*result = HYPOT( pt1->x - pt2->x, pt1->y - pt2->y );
double *point_slope(Point *pt1, Point *pt2)
{
- double *result;
+ double *result;
result = PALLOCTYPE(double);
if (point_vert(pt1, pt2))
: (pt1->y - pt2->y) / (pt1->x - pt2->x) );
}
+
/***********************************************************************
**
** Routines for 2D line segments.
/*----------------------------------------------------------
* String to lseg, lseg to string conversion.
- * External form: "(id, info, x1, y1, x2, y2)"
+ * External forms: "[(x1, y1), (x2, y2)]"
+ * "(x1, y1), (x2, y2)"
+ * "x1, y1, x2, y2"
+ * closed form ok "((x1, y1), (x2, y2))"
+ * (old form) "(x1, y1, x2, y2)"
*---------------------------------------------------------*/
LSEG *lseg_in(char *str)
{
- char *coord[LSEGNARGS], *p;
- int i;
- LSEG *result;
-
- if (str == NULL)
- elog (WARN," Bad (null) box external representation");
-
- if ((p = (char *)strchr(str, LDELIM)) == (char *)NULL)
+ LSEG *lseg;
+
+ int isopen;
+ char *s;
+
+ if (!PointerIsValid((char *)str))
+ elog (WARN," Bad (null) lseg external representation",NULL);
+
+ if (!PointerIsValid(lseg = PALLOCTYPE(LSEG)))
+ elog(WARN, "Memory allocation failed, can't input lseg '%s'",str);
+
+ if ((! path_decode(TRUE, 2, str, &isopen, &s, &(lseg->p[0])))
+ || (*s != '\0'))
elog (WARN, "Bad lseg external representation '%s'",str);
- for (i = 0, p = str; *p && i < LSEGNARGS && *p != RDELIM; p++)
- if (*p == DELIM || (*p == LDELIM && !i))
- coord[i++] = p + 1;
- if (i < LSEGNARGS - 1)
- elog (WARN, "Bad lseg external representation '%s'", str);
- result = PALLOCTYPE(LSEG);
- result->p[0].x = atof(coord[0]);
- result->p[0].y = atof(coord[1]);
- result->p[1].x = atof(coord[2]);
- result->p[1].y = atof(coord[3]);
- result->m = point_sl(&result->p[0], &result->p[1]);
+
+ lseg->m = point_sl(&lseg->p[0], &lseg->p[1]);
- return(result);
+ return(lseg);
}
char *lseg_out(LSEG *ls)
{
- char *result;
-
- if (ls == NULL)
+ if (!PointerIsValid((char *)ls))
return(NULL);
- result = (char *)PALLOC(80);
- (void) sprintf(result, "(%G,%G,%G,%G)",
- ls->p[0].x, ls->p[0].y, ls->p[1].x, ls->p[1].y);
- return(result);
+
+ return( path_encode( FALSE, 2, (Point *) &(ls->p[0])));
}
result->p[0].y = pt1->y;
result->p[1].x = pt2->x;
result->p[1].y = pt2->y;
+
result->m = point_sl(pt1, pt2);
return(result);
lseg->p[0].y = pt1->y;
lseg->p[1].x = pt2->x;
lseg->p[1].y = pt2->y;
+
lseg->m = point_sl(pt1, pt2);
}
** find intersection of the two lines, and see if it falls on
** both segments.
*/
-long lseg_intersect(LSEG *l1, LSEG *l2)
+bool lseg_intersect(LSEG *l1, LSEG *l2)
{
LINE *ln;
Point *interpt;
- long retval;
+ bool retval;
ln = line_construct_pp(&l2->p[0], &l2->p[1]);
interpt = interpt_sl(l1, ln);
if (interpt != NULL && on_ps(interpt, l2)) /* interpt on l1 and l2 */
- retval = 1;
- else retval = 0;
+ retval = TRUE;
+ else retval = FALSE;
if (interpt != NULL) PFREE(interpt);
PFREE(ln);
return(retval);
}
-long lseg_parallel(LSEG *l1, LSEG *l2)
+bool lseg_parallel(LSEG *l1, LSEG *l2)
{
return( FPeq(l1->m, l2->m) );
}
-long lseg_perp(LSEG *l1, LSEG *l2)
+bool lseg_perp(LSEG *l1, LSEG *l2)
{
if (! FPzero(l1->m))
return( FPeq(l2->m / l1->m, -1.0) );
return(0); /* both 0.0 */
}
-long lseg_vertical(LSEG *lseg)
+bool lseg_vertical(LSEG *lseg)
{
return( FPeq(lseg->p[0].x, lseg->p[1].x) );
}
-long lseg_horizontal(LSEG *lseg)
+bool lseg_horizontal(LSEG *lseg)
{
return( FPeq(lseg->p[0].y, lseg->p[1].y) );
}
-long lseg_eq(LSEG *l1, LSEG *l2)
+bool lseg_eq(LSEG *l1, LSEG *l2)
{
return( FPeq(l1->p[0].x, l2->p[0].x) &&
FPeq(l1->p[1].y, l2->p[1].y) &&
*/
double *lseg_distance(LSEG *l1, LSEG *l2)
{
- double *d, *result;
+ double *result;
result = PALLOCTYPE(double);
- if (lseg_intersect(l1, l2)) {
- *result = 0.0;
- return(result);
- }
- *result = (double)DBL_MAX;
- d = dist_ps(&l1->p[0], l2);
- *result = Min(*result, *d);
- PFREE(d);
- d = dist_ps(&l1->p[1], l2);
- *result = Min(*result, *d);
- PFREE(d);
- d = dist_ps(&l2->p[0], l1);
- *result = Min(*result, *d);
- PFREE(d);
- d = dist_ps(&l2->p[1], l1);
- *result = Min(*result, *d);
- PFREE(d);
-
+ *result = lseg_dt( l1, l2);
+
return(result);
}
if (lseg_intersect(l1, l2))
return(0.0);
- result = (double)DBL_MAX;
+
d = dist_ps(&l1->p[0], l2);
- result = Min(result, *d);
+ result = *d;
PFREE(d);
d = dist_ps(&l1->p[1], l2);
result = Min(result, *d);
LSEG lseg;
switch (path->npts) {
+ /* no points in path? then result is undefined... */
case 0:
- result = PALLOCTYPE(double);
- *result = Abs((double) DBL_MAX); /* +infinity */
+ result = NULL;
break;
+ /* one point in path? then get distance between two points... */
case 1:
result = point_distance(pt, &path->p[0]);
break;
default:
+ /* make sure the path makes sense... */
+ Assert(path->npts > 1);
/*
* the distance from a point to a path is the smallest distance
* from the point to any of its constituent segments.
*/
- Assert(path->npts > 1);
result = PALLOCTYPE(double);
- for (i = 0; i < path->npts - 1; ++i) {
+ for (i = 0; i < path->npts - 1; i++) {
statlseg_construct(&lseg, &path->p[i], &path->p[i+1]);
tmp = dist_ps(pt, &lseg);
if (i == 0 || *tmp < *result)
tmp = close_pb(pt, box);
result = point_distance(tmp, pt);
-
PFREE(tmp);
+
return(result);
}
double *dist_sl(LSEG *lseg, LINE *line)
{
- double *result;
-
+ double *result, *d2;
+
if (inter_sl(lseg, line)) {
result = PALLOCTYPE(double);
*result = 0.0;
- } else /* parallel */
+
+ } else {
result = dist_pl(&lseg->p[0], line);
+ d2 = dist_pl(&lseg->p[1], line);
+ if (*d2 > *result) {
+ PFREE( result);
+ result = d2;
+ } else {
+ PFREE( d2);
+ };
+ };
return(result);
}
/* on_pl -
* Does the point satisfy the equation?
*/
-long on_pl(Point *pt, LINE *line)
+bool on_pl(Point *pt, LINE *line)
{
return( FPzero(line->A * pt->x + line->B * pt->y + line->C) );
}
/* on_ps -
* Determine colinearity by detecting a triangle inequality.
*/
-long on_ps(Point *pt, LSEG *lseg)
+bool on_ps(Point *pt, LSEG *lseg)
{
return( FPeq (point_dt(pt, &lseg->p[0]) + point_dt(pt, &lseg->p[1]),
point_dt(&lseg->p[0], &lseg->p[1])) );
}
-long on_pb(Point *pt, BOX *box)
+bool on_pb(Point *pt, BOX *box)
{
- return( pt->x <= box->xh && pt->x >= box->xl &&
- pt->y <= box->yh && pt->y >= box->yl );
+ return( pt->x <= box->high.x && pt->x >= box->low.x &&
+ pt->y <= box->high.y && pt->y >= box->low.y );
}
/* on_ppath -
*/
#define NEXT(A) ((A+1) % path->npts) /* cyclic "i+1" */
-long on_ppath(Point *pt, PATH *path)
+bool on_ppath(Point *pt, PATH *path)
{
int above, next, /* is the seg above the ray? */
inter, /* # of times path crosses ray */
}
-long on_sl(LSEG *lseg, LINE *line)
+bool on_sl(LSEG *lseg, LINE *line)
{
return( on_pl(&lseg->p[0], line) && on_pl(&lseg->p[1], line) );
}
-long on_sb(LSEG *lseg, BOX *box)
+bool on_sb(LSEG *lseg, BOX *box)
{
return( on_pb(&lseg->p[0], box) && on_pb(&lseg->p[1], box) );
}
* Whether one object intersects another.
*-------------------------------------------------------------------*/
-long inter_sl(LSEG *lseg, LINE *line)
+bool inter_sl(LSEG *lseg, LINE *line)
{
Point *tmp;
return(0);
}
-long inter_sb(LSEG *lseg, BOX *box)
+/* XXX segment and box should be able to intersect; tgl - 97/01/09 */
+
+bool inter_sb(LSEG *lseg, BOX *box)
{
return(0);
}
-long inter_lb(LINE *line, BOX *box)
+/* XXX line and box should be able to intersect; tgl - 97/01/09 */
+
+bool inter_lb(LINE *line, BOX *box)
{
return(0);
}
/*------------------------------------------------------------------
* The following routines define a data type and operator class for
- * POLYGONS .... Part of which (the polygon's bounding box is built on
+ * POLYGONS .... Part of which (the polygon's bounding box) is built on
* top of the BOX data type.
*
* make_bound_box - create the bounding box for the input polygon
*------------------------------------------------------------------*/
-/* Maximum number of output digits printed */
-#define P_MAXDIG 12
-
/*---------------------------------------------------------------------
* Make the smallest bounding box for the given polygon.
*---------------------------------------------------------------------*/
void make_bound_box(POLYGON *poly)
{
+ int i;
double x1,y1,x2,y2;
- int npts = poly->npts;
-
- if (npts > 0) {
- x1 = poly_min((double *)poly->pts, npts);
- x2 = poly_max((double *)poly->pts, npts);
- y1 = poly_min(((double *)poly->pts)+npts, npts),
- y2 = poly_max(((double *)poly->pts)+npts, npts);
+
+ if (poly->npts > 0) {
+ x2 = x1 = poly->p[0].x;
+ y2 = y1 = poly->p[0].y;
+ for (i = 1; i < poly->npts; i++) {
+ if (poly->p[i].x < x1) x1 = poly->p[i].x;
+ if (poly->p[i].x > x2) x2 = poly->p[i].x;
+ if (poly->p[i].y < y1) y1 = poly->p[i].y;
+ if (poly->p[i].y > y2) y2 = poly->p[i].y;
+ };
+
box_fill(&(poly->boundbox), x1, x2, y1, y2);
- }
+ } else {
+ elog (WARN, "Unable to create bounding box for empty polygon", NULL);
+ };
}
/*------------------------------------------------------------------
- * polygon_in - read in the polygon from a string specification
- * the string is of the form "(f8,f8,f8,f8,...,f8)"
+ * poly_in - read in the polygon from a string specification
+ *
+ * External format:
+ * "((x0,y0),...,(xn,yn))"
+ * "x0,y0,...,xn,yn"
+ * also supports the older style "(x1,...,xn,y1,...yn)"
*------------------------------------------------------------------*/
-POLYGON *poly_in(char *s)
+POLYGON *poly_in(char *str)
{
POLYGON *poly;
- long points;
- double *xp, *yp, strtod();
- int i, size;
-
- if((points = poly_pt_count(s, ',')) < 0)
- elog(WARN, "Bad polygon external representation '%s'", s);
-
- size = offsetof(POLYGON, pts[0]) + 2 * sizeof(double) * points;
- poly = (POLYGON *) PALLOC(size);
+ int npts;
+ int size;
+ int isopen;
+
+#if OLD_FORMAT_IN
+ char *s;
+ int oldstyle;
+ int oddcount;
+ int i;
+ double x1, x2;
+#endif
+
+ if (!PointerIsValid((char *)str))
+ elog (WARN," Bad (null) polygon external representation");
+
+ if ((npts = pair_count(str, ',')) <= 0)
+ elog(WARN, "Bad polygon external representation '%s'", str);
+
+ size = offsetof(POLYGON, p[0]) + (sizeof(poly->p[0]) * npts);
+ if (!PointerIsValid(poly = (POLYGON *) PALLOC(size)))
+ elog(WARN, "Memory allocation failed, can't input polygon '%s'",str);
+
memset((char *) poly, 0, size); /* zero any holes */
-
- if (!PointerIsValid(poly))
- elog(WARN, "Memory allocation failed, can't input polygon");
-
- poly->npts = points;
poly->size = size;
-
- /* Store all x coords followed by all y coords */
- xp = (double *) &(poly->pts[0]);
- yp = (double *) (poly->pts + points*sizeof(double));
-
- s++; /* skip LDELIM */
-
- for (i=0; i<points; i++,xp++,yp++)
- {
- *xp = strtod(s, &s);
- s++; /* skip delimiter */
- *yp = strtod(s, &s);
- s++; /* skip delimiter */
- }
+ poly->npts = npts;
+
+#if OLD_FORMAT_IN
+ s = str;
+ while (isspace( *s)) s++;
+ /* identify old style format as having only one left delimiter in string... */
+ oldstyle = ((*s == LDELIM) && (strrchr( s, LDELIM) == s));
+
+ if (oldstyle) {
+ s++;
+ while (isspace( *s)) s++;
+
+ for (i=0; i<npts/2; i++) {
+ if (! pair_decode( s, &x1, &x2, &s))
+ elog (WARN, "Bad polygon external representation '%s'",str);
+
+ if (*s == DELIM) s++;
+ poly->p[i*2].x = x1;
+ poly->p[i*2+1].x = x2;
+ };
+ oddcount = (npts % 2);
+ if (oddcount) {
+ if (! pair_decode( s, &x1, &x2, &s))
+ elog (WARN, "Bad polygon external representation '%s'",str);
+
+ if (*s == DELIM) s++;
+ poly->p[npts-1].x = x1;
+ poly->p[0].y = x2;
+ };
+ for (i=0; i<npts/2; i++) {
+ if (! pair_decode( s, &x1, &x2, &s))
+ elog (WARN, "Bad polygon external representation '%s'",str);
+
+ if (*s == DELIM) s++;
+ poly->p[i*2+oddcount].y = x1;
+ poly->p[i*2+1+oddcount].y = x2;
+ };
+
+ if (*s == RDELIM) {
+ s++;
+ while (isspace( *s)) s++;
+ if (*s != '\0')
+ elog(WARN, "Bad polygon external representation '%s'", str);
+
+ } else {
+ elog(WARN, "Bad polygon external representation '%s'", str);
+ };
+
+ } else {
+#endif
+ if ((! path_decode(FALSE, npts, str, &isopen, &s, &(poly->p[0])))
+ || (*s != '\0'))
+ elog (WARN, "Bad polygon external representation '%s'",str);
+
+#if OLD_FORMAT_IN
+ };
+#endif;
+
make_bound_box(poly);
- return (poly);
-}
-/*-------------------------------------------------------------
- * poly_pt_count - count the number of points specified in the
- * polygon.
- *-------------------------------------------------------------*/
-long poly_pt_count(char *s, char delim)
-{
- long total = 0;
-
- if (*s++ != LDELIM) /* no left delimeter */
- return (long) -1;
-
- while (*s && (*s != RDELIM))
- {
- while (*s && (*s != delim))
- s++;
- total++; /* found one */
- if (*s)
- s++; /* bump s past the delimiter */
- }
-
- /* if there was no right delimiter OR an odd number of points */
-
- if ((*(s-1) != RDELIM) || ((total%2) != 0))
- return (long) -1;
-
- return (total/2);
-}
+ return( poly);
+} /* poly_in() */
/*---------------------------------------------------------------
* poly_out - convert internal POLYGON representation to the
- * character string format "(f8,f8,f8,f8,...f8)"
+ * character string format "((f8,f8),...,(f8,f8))"
+ * also support old format "(f8,f8,...,f8,f8)"
*---------------------------------------------------------------*/
char *poly_out(POLYGON *poly)
{
+#if OLD_FORMAT_OUT
int i;
- double *xp, *yp;
- char *output, *outptr;
-
- /*-----------------------------------------------------
- * Get enough space for "(f8,f8,f8,f8,...,f8)"
- * which P_MAXDIG+1 for each coordinate plus 2
- * for parens and 1 for the null
- *-----------------------------------------------------*/
- output = (char *)PALLOC(2*(P_MAXDIG+1)*poly->npts + 3);
- outptr = output;
-
- if (!output)
- elog(WARN, "Memory allocation failed, can't output polygon");
-
- *outptr++ = LDELIM;
-
- xp = (double *) poly->pts;
- yp = (double *) (poly->pts + (poly->npts * sizeof(double)));
-
- sprintf(outptr, "%*g,%*g", P_MAXDIG, *xp++, P_MAXDIG, *yp++);
- outptr += (2*P_MAXDIG + 1);
-
- for (i=1; i<poly->npts; i++,xp++,yp++)
- {
- sprintf(outptr, ",%*g,%*g", P_MAXDIG, *xp, P_MAXDIG, *yp);
- outptr += 2*(P_MAXDIG + 1);
- }
- *outptr++ = RDELIM;
- *outptr = '\0';
- return (output);
-}
-
-/*-------------------------------------------------------
- * Find the largest coordinate out of n coordinates
- *-------------------------------------------------------*/
-double poly_max(double *coords, int ncoords)
-{
- double max;
-
- max = *coords++;
- ncoords--;
- while (ncoords--)
- {
- if (*coords > max)
- max = *coords;
- coords++;
- }
- return max;
+ char *result, *cp;
+#endif
+
+ if (!PointerIsValid((char *)poly))
+ return NULL;
+
+#if OLD_FORMAT_OUT
+ if (!PointerIsValid(result = (char *)PALLOC(poly->npts*(P_MAXLEN+3)+2)))
+ elog(WARN, "Memory allocation failed, can't output polygon", NULL);
+
+ cp = result;
+ *cp++ = LDELIM;
+
+ for (i=0; i<poly->npts; i++) {
+ if (! pair_encode( poly->p[i].x, poly->p[i].y, cp))
+ elog (WARN, "Unable to format polygon", NULL);
+ cp += strlen(cp);
+ *cp++ = DELIM;
+ };
+ *(cp-1) = RDELIM;
+ *cp = '\0';
+ return(result);
+#else
+ return( path_encode( TRUE, poly->npts, &(poly->p[0])));
+#endif
}
-/*-------------------------------------------------------
- * Find the smallest coordinate out of n coordinates
- *-------------------------------------------------------*/
-double poly_min(double *coords, int ncoords)
-{
- double min;
-
- min = *coords++;
- ncoords--;
- while (ncoords--)
- {
- if (*coords < min)
- min = *coords;
- coords++;
- }
- return min;
-}
/*-------------------------------------------------------
* Is polygon A strictly left of polygon B? i.e. is
* the right most point of A left of the left most point
* of B?
*-------------------------------------------------------*/
-long poly_left(POLYGON *polya, POLYGON *polyb)
+bool poly_left(POLYGON *polya, POLYGON *polyb)
{
- double right, left;
-
- if (polya->npts > 0)
- right = poly_max((double *)polya->pts, polya->npts);
- else
- right = polya->boundbox.xh;
- if (polyb->npts > 0)
- left = poly_min((double *)polyb->pts, polyb->npts);
- else
- left = polyb->boundbox.xl;
-
- return (right < left);
+ return (polya->boundbox.high.x < polyb->boundbox.low.x);
}
/*-------------------------------------------------------
* the left most point of A left of the right most point
* of B?
*-------------------------------------------------------*/
-long poly_overleft(POLYGON *polya, POLYGON *polyb)
+bool poly_overleft(POLYGON *polya, POLYGON *polyb)
{
- double left, right;
-
- if (polya->npts > 0)
- left = poly_min((double *)polya->pts, polya->npts);
- else
- left = polya->boundbox.xl;
- if (polyb->npts > 0)
- right = poly_max((double *)polyb->pts, polyb->npts);
- else
- right = polyb->boundbox.xh;
-
- return (left <= right);
+ return (polya->boundbox.low.x <= polyb->boundbox.high.x);
}
/*-------------------------------------------------------
* the left most point of A right of the right most point
* of B?
*-------------------------------------------------------*/
-long poly_right(POLYGON *polya, POLYGON *polyb)
+bool poly_right(POLYGON *polya, POLYGON *polyb)
{
- double right, left;
-
- if (polya->npts > 0)
- left = poly_min((double *)polya->pts, polya->npts);
- else
- left = polya->boundbox.xl;
- if (polyb->npts > 0)
- right = poly_max((double *)polyb->pts, polyb->npts);
- else
- right = polyb->boundbox.xh;
-
- return (left > right);
+ return( polya->boundbox.low.x > polyb->boundbox.high.x);
}
/*-------------------------------------------------------
* the right most point of A right of the left most point
* of B?
*-------------------------------------------------------*/
-long poly_overright(POLYGON *polya, POLYGON *polyb)
+bool poly_overright(POLYGON *polya, POLYGON *polyb)
{
- double right, left;
-
- if (polya->npts > 0)
- right = poly_max((double *)polya->pts, polya->npts);
- else
- right = polya->boundbox.xh;
- if (polyb->npts > 0)
- left = poly_min((double *)polyb->pts, polyb->npts);
- else
- left = polyb->boundbox.xl;
-
- return (right > left);
+ return( polya->boundbox.high.x > polyb->boundbox.low.x);
}
/*-------------------------------------------------------
* Is polygon A the same as polygon B? i.e. are all the
* points the same?
*-------------------------------------------------------*/
-long poly_same(POLYGON *polya, POLYGON *polyb)
+bool poly_same(POLYGON *polya, POLYGON *polyb)
{
int i;
- double *axp, *bxp; /* point to x coordinates for a and b */
-
if (polya->npts != polyb->npts)
- return 0;
-
- axp = (double *)polya->pts;
- bxp = (double *)polyb->pts;
-
- for (i=0; i<polya->npts; axp++, bxp++, i++)
- {
- if (*axp != *bxp)
- return 0;
- }
- return 1;
+ return FALSE;
+
+ for (i = 0; i < polya->npts; i++) {
+ if ((polya->p[i].x != polyb->p[i].x)
+ || (polya->p[i].y != polyb->p[i].y))
+ return FALSE;
+ };
+ return TRUE;
}
/*-----------------------------------------------------------------
* Determine if polygon A overlaps polygon B by determining if
* their bounding boxes overlap.
*-----------------------------------------------------------------*/
-long poly_overlap(POLYGON *polya, POLYGON *polyb)
+bool poly_overlap(POLYGON *polya, POLYGON *polyb)
{
return box_overlap(&(polya->boundbox), &(polyb->boundbox));
}
* Determine if polygon A contains polygon B by determining if A's
* bounding box contains B's bounding box.
*-----------------------------------------------------------------*/
-long poly_contain(POLYGON *polya, POLYGON *polyb)
+bool poly_contain(POLYGON *polya, POLYGON *polyb)
{
return box_contain(&(polya->boundbox), &(polyb->boundbox));
}
* Determine if polygon A is contained by polygon B by determining
* if A's bounding box is contained by B's bounding box.
*-----------------------------------------------------------------*/
-long poly_contained(POLYGON *polya, POLYGON *polyb)
+bool poly_contained(POLYGON *polya, POLYGON *polyb)
{
return box_contained(&(polya->boundbox), &(polyb->boundbox));
}
+
+
+/***********************************************************************
+ **
+ ** Routines for 2D points.
+ **
+ ***********************************************************************/
+
+Point *
+point(float8 *x, float8 *y)
+{
+ if (! (PointerIsValid(x) && PointerIsValid(y)))
+ return(NULL);
+
+ return(point_construct(*x, *y));
+} /* point() */
+
+
+Point *
+point_add(Point *p1, Point *p2)
+{
+ Point *result;
+
+ if (! (PointerIsValid(p1) && PointerIsValid(p2)))
+ return(NULL);
+
+ if (!PointerIsValid(result = PALLOCTYPE(Point)))
+ elog(WARN, "Memory allocation failed, can't add points",NULL);
+
+ result->x = (p1->x + p2->x);
+ result->y = (p1->y + p2->y);
+
+ return(result);
+} /* point_add() */
+
+Point *
+point_sub(Point *p1, Point *p2)
+{
+ Point *result;
+
+ if (! (PointerIsValid(p1) && PointerIsValid(p2)))
+ return(NULL);
+
+ if (!PointerIsValid(result = PALLOCTYPE(Point)))
+ elog(WARN, "Memory allocation failed, can't add points",NULL);
+
+ result->x = (p1->x - p2->x);
+ result->y = (p1->y - p2->y);
+
+ return(result);
+} /* point_sub() */
+
+Point *
+point_mul(Point *p1, Point *p2)
+{
+ Point *result;
+
+ if (! (PointerIsValid(p1) && PointerIsValid(p2)))
+ return(NULL);
+
+ if (!PointerIsValid(result = PALLOCTYPE(Point)))
+ elog(WARN, "Memory allocation failed, can't multiply points",NULL);
+
+ result->x = (p1->x*p2->x) - (p1->y*p2->y);
+ result->y = (p1->x*p2->y) + (p1->y*p2->x);
+
+ return(result);
+} /* point_mul() */
+
+Point *
+point_div(Point *p1, Point *p2)
+{
+ Point *result;
+ double div;
+
+ if (! (PointerIsValid(p1) && PointerIsValid(p2)))
+ return(NULL);
+
+ if (!PointerIsValid(result = PALLOCTYPE(Point)))
+ elog(WARN, "Memory allocation failed, can't multiply path",NULL);
+
+ div = (p2->x*p2->x) + (p2->y*p2->y);
+
+ result->x = ((p1->x*p2->x) + (p1->y*p2->y)) / div;
+ result->y = ((p2->x*p1->y) - (p2->y*p1->x)) / div;
+
+ return(result);
+} /* point_div() */
+
+
+/***********************************************************************
+ **
+ ** Routines for 2D boxes.
+ **
+ ***********************************************************************/
+
+BOX *
+box(Point *p1, Point *p2)
+{
+ BOX *result;
+
+ if (! (PointerIsValid(p1) && PointerIsValid(p2)))
+ return(NULL);
+
+ result = box_construct( p1->x, p2->x, p1->y, p2->y);
+
+ return(result);
+} /* box() */
+
+BOX *
+box_add(BOX *box, Point *p)
+{
+ BOX *result;
+
+ if (! (PointerIsValid(box) && PointerIsValid(p)))
+ return(NULL);
+
+ result = box_construct( (box->high.x + p->x), (box->low.x + p->x),
+ (box->high.y + p->y), (box->low.y + p->y));
+
+ return(result);
+} /* box_add() */
+
+BOX *
+box_sub(BOX *box, Point *p)
+{
+ BOX *result;
+
+ if (! (PointerIsValid(box) && PointerIsValid(p)))
+ return(NULL);
+
+ result = box_construct( (box->high.x - p->x), (box->low.x - p->x),
+ (box->high.y - p->y), (box->low.y - p->y));
+
+ return(result);
+} /* box_sub() */
+
+BOX *
+box_mul(BOX *box, Point *p)
+{
+ BOX *result;
+ Point *high, *low;
+
+ if (! (PointerIsValid(box) && PointerIsValid(p)))
+ return(NULL);
+
+ high = point_mul( &box->high, p);
+ low = point_mul( &box->low, p);
+
+ result = box_construct( high->x, low->x, high->y, low->y);
+ PFREE( high);
+ PFREE( low);
+
+ return(result);
+} /* box_mul() */
+
+BOX *
+box_div(BOX *box, Point *p)
+{
+ BOX *result;
+ Point *high, *low;
+
+ if (! (PointerIsValid(box) && PointerIsValid(p)))
+ return(NULL);
+
+ high = point_div( &box->high, p);
+ low = point_div( &box->low, p);
+
+ result = box_construct( high->x, low->x, high->y, low->y);
+ PFREE( high);
+ PFREE( low);
+
+ return(result);
+} /* box_div() */
+
+
+/***********************************************************************
+ **
+ ** Routines for 2D lines.
+ ** Lines are not intended to be used as ADTs per se,
+ ** but their ops are useful tools for other ADT ops. Thus,
+ ** there are few relops.
+ **
+ ***********************************************************************/
+
+
+/***********************************************************************
+ **
+ ** Routines for 2D paths.
+ **
+ ***********************************************************************/
+
+POLYGON *path_poly(PATH *path);
+
+/* path_add()
+ * Concatenate two paths (only if they are both open).
+ */
+PATH *
+path_add(PATH *p1, PATH *p2)
+{
+ PATH *result;
+ int size;
+ int i;
+
+ if (! (PointerIsValid(p1) && PointerIsValid(p2))
+ || p1->closed || p2->closed)
+ return(NULL);
+
+ size = offsetof(PATH, p[0]) + (sizeof(p1->p[0]) * (p1->npts+p2->npts));
+ if (!PointerIsValid(result = PALLOC(size)))
+ elog(WARN, "Memory allocation failed, can't add paths",NULL);
+
+ result->size = size;
+ result->npts = (p1->npts+p2->npts);
+ result->closed = p1->closed;
+
+ for (i=0; i<p1->npts; i++) {
+ result->p[i].x = p1->p[i].x;
+ result->p[i].y = p1->p[i].y;
+ };
+ for (i=0; i<p2->npts; i++) {
+ result->p[i+p1->npts].x = p2->p[i].x;
+ result->p[i+p1->npts].y = p2->p[i].y;
+ };
+
+ return(result);
+} /* path_add() */
+
+/* path_add_pt()
+ * Translation operator.
+ */
+PATH *
+path_add_pt(PATH *path, Point *point)
+{
+ PATH *result;
+ int i;
+
+ if (! (PointerIsValid(path) && PointerIsValid(point)))
+ return(NULL);
+
+ if (! PointerIsValid(result = path_copy(path)))
+ elog(WARN, "Memory allocation failed, can't add path",NULL);
+
+ for (i=0; i<path->npts; i++) {
+ result->p[i].x += point->x;
+ result->p[i].y += point->y;
+ };
+
+ return(result);
+} /* path_add_pt() */
+
+PATH *
+path_sub_pt(PATH *path, Point *point)
+{
+ PATH *result;
+ int i;
+
+ if (! (PointerIsValid(path) && PointerIsValid(point)))
+ return(NULL);
+
+ if (! PointerIsValid(result = path_copy(path)))
+ elog(WARN, "Memory allocation failed, can't subtract path",NULL);
+
+ for (i=0; i<path->npts; i++) {
+ result->p[i].x -= point->x;
+ result->p[i].y -= point->y;
+ };
+
+ return(result);
+} /* path_sub_pt() */
+
+
+/* path_mul_pt()
+ * Rotation and scaling operators.
+ */
+PATH *
+path_mul_pt(PATH *path, Point *point)
+{
+ PATH *result;
+ Point *p;
+ int i;
+
+ if (! (PointerIsValid(path) && PointerIsValid(point)))
+ return(NULL);
+
+ if (! PointerIsValid(result = path_copy(path)))
+ elog(WARN, "Memory allocation failed, can't multiply path",NULL);
+
+ for (i=0; i<path->npts; i++) {
+ p = point_mul( &path->p[i], point);
+ result->p[i].x = p->x;
+ result->p[i].y = p->y;
+ PFREE(p);
+ };
+
+ return(result);
+} /* path_mul_pt() */
+
+PATH *
+path_div_pt(PATH *path, Point *point)
+{
+ PATH *result;
+ Point *p;
+ int i;
+
+ if (! (PointerIsValid(path) && PointerIsValid(point)))
+ return(NULL);
+
+ if (! PointerIsValid(result = path_copy(path)))
+ elog(WARN, "Memory allocation failed, can't divide path",NULL);
+
+ for (i=0; i<path->npts; i++) {
+ p = point_div( &path->p[i], point);
+ result->p[i].x = p->x;
+ result->p[i].y = p->y;
+ PFREE(p);
+ };
+
+ return(result);
+} /* path_div_pt() */
+
+
+POLYGON *path_poly(PATH *path)
+{
+ POLYGON *poly;
+ int size;
+ int i;
+
+ if (!PointerIsValid(path))
+ return(NULL);
+
+ if (!path->closed)
+ elog(WARN, "Open path cannot be converted to polygon",NULL);
+
+ size = offsetof(POLYGON, p[0]) + (sizeof(poly->p[0]) * path->npts);
+ if (!PointerIsValid(poly = PALLOC(size)))
+ elog(WARN, "Memory allocation failed, can't convert path to polygon",NULL);
+
+ poly->size = size;
+ poly->npts = path->npts;
+
+ for (i=0; i<path->npts; i++) {
+ poly->p[i].x = path->p[i].x;
+ poly->p[i].y = path->p[i].y;
+ };
+
+ make_bound_box(poly);
+
+ return(poly);
+} /* path_polygon() */
+
+
+/***********************************************************************
+ **
+ ** Routines for 2D polygons.
+ **
+ ***********************************************************************/
+
+int4
+poly_npoints( POLYGON *poly)
+{
+ if (!PointerIsValid(poly))
+ return(0);
+
+ return(poly->npts);
+} /* poly_npoints() */
+
+BOX *
+poly_box(POLYGON *poly)
+{
+ BOX *box;
+
+ if (!PointerIsValid(poly) || (poly->npts < 1))
+ return(NULL);
+
+ box = box_copy( &poly->boundbox);
+
+ return(box);
+} /* poly_box() */
+
+POLYGON *
+box_poly(BOX *box)
+{
+ POLYGON *poly;
+ int size;
+
+ if (!PointerIsValid(box))
+ return(NULL);
+
+ size = offsetof(POLYGON, p[0]) + (sizeof(poly->p[0]) * 4);
+ if (!PointerIsValid(poly = PALLOC(size)))
+ elog(WARN, "Memory allocation failed, can't convert box to polygon",NULL);
+
+ poly->size = size;
+ poly->npts = 4;
+
+ poly->p[0].x = box->low.x;
+ poly->p[0].y = box->low.y;
+ poly->p[1].x = box->low.x;
+ poly->p[1].y = box->high.y;
+ poly->p[2].x = box->high.x;
+ poly->p[2].y = box->high.y;
+ poly->p[3].x = box->high.x;
+ poly->p[3].y = box->low.y;
+
+ box_fill( &poly->boundbox, box->high.x, box->low.x, box->high.y, box->low.y);
+
+ return(poly);
+} /* box_poly() */
+
+PATH *
+poly_path(POLYGON *poly)
+{
+ PATH *path;
+ int size;
+ int i;
+
+ if (!PointerIsValid(poly) || (poly->npts < 0))
+ return(NULL);
+
+ size = offsetof(PATH, p[0]) + (sizeof(path->p[0]) * poly->npts);
+ if (!PointerIsValid(path = PALLOC(size)))
+ elog(WARN, "Memory allocation failed, can't convert polygon to path",NULL);
+
+ path->size = size;
+ path->npts = poly->npts;
+ path->closed = TRUE;
+
+ for (i=0; i<poly->npts; i++) {
+ path->p[i].x = poly->p[i].x;
+ path->p[i].y = poly->p[i].y;
+ };
+
+ return(path);
+} /* poly_path() */
+
+
+/*-------------------------------------------------------------------------
+ *
+ * circle.c--
+ * 2D geometric operations
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ *
+ * IDENTIFICATION
+ * $Header: /cvsroot/pgsql/src/backend/utils/adt/geo_ops.c,v 1.3 1997/04/22 17:31:32 scrappy Exp $
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef PI
+#define PI 3.1415926536
+#endif
+
+int single_decode(char *str, float8 *x, char **ss);
+int single_encode(float8 x, char *str);
+
+int single_decode(char *str, float8 *x, char **s)
+{
+ char *cp;
+
+ if (!PointerIsValid(str))
+ return(FALSE);
+
+ while (isspace( *str)) str++;
+ *x = strtod( str, &cp);
+#ifdef GEODEBUG
+fprintf( stderr, "single_decode- (%x) try decoding %s to %g\n", (cp-str), str, *x);
+#endif
+ if (cp <= str) return(FALSE);
+ while (isspace( *cp)) cp++;
+
+ if (s != NULL) *s = cp;
+
+ return(TRUE);
+}
+
+int single_encode(float8 x, char *str)
+{
+ (void) sprintf(str, "%.*g", digits8, x);
+ return(TRUE);
+}
+
+
+/***********************************************************************
+ **
+ ** Routines for circles.
+ **
+ ***********************************************************************/
+
+/*----------------------------------------------------------
+ * Formatting and conversion routines.
+ *---------------------------------------------------------*/
+
+/* circle_in - convert a string to internal form.
+ *
+ * External format: (center and radius of circle)
+ * "((f8,f8)<f8>)"
+ * also supports quick entry style "(f8,f8,f8)"
+ */
+CIRCLE *circle_in(char *str)
+{
+ CIRCLE *circle;
+
+ char *s, *cp;
+ int depth = 0;
+
+ if (!PointerIsValid(str))
+ elog (WARN," Bad (null) circle external representation",NULL);
+
+ if (!PointerIsValid(circle = PALLOCTYPE(CIRCLE)))
+ elog(WARN, "Memory allocation failed, can't input circle '%s'",str);
+
+ s = str;
+ while (isspace( *s)) s++;
+ if ((*s == LDELIM_C) || (*s == LDELIM)) {
+ depth++;
+ cp = (s+1);
+ while (isspace( *cp)) cp++;
+ if (*cp == LDELIM) {
+ s = cp;
+ };
+ };
+
+ if (! pair_decode( s, &circle->center.x, &circle->center.y, &s))
+ elog (WARN, "Bad circle external representation '%s'",str);
+
+ if (*s == DELIM) s++;
+ while (isspace( *s)) s++;
+
+ if (! single_decode( s, &circle->radius, &s))
+ elog (WARN, "Bad circle external representation '%s'",str);
+
+ while (depth > 0) {
+ if ((*s == RDELIM)
+ || ((*s == RDELIM_C) && (depth == 1))) {
+ depth--;
+ s++;
+ while (isspace( *s)) s++;
+ } else {
+ elog (WARN, "Bad circle external representation '%s'",str);
+ };
+ };
+
+ if (*s != '\0')
+ elog (WARN, "Bad circle external representation '%s'",str);
+
+ return(circle);
+} /* circle_in() */
+
+/* circle_out - convert a circle to external form.
+ */
+char *circle_out(CIRCLE *circle)
+{
+ char *result;
+ char *cp;
+
+ if (!PointerIsValid(circle))
+ return(NULL);
+
+ if (!PointerIsValid(result = (char *)PALLOC(3*(P_MAXLEN+1)+3)))
+ elog(WARN, "Memory allocation failed, can't output circle", NULL);
+
+ cp = result;
+ *cp++ = LDELIM_C;
+ *cp++ = LDELIM;
+ if (! pair_encode( circle->center.x, circle->center.y, cp))
+ elog (WARN, "Unable to format circle", NULL);
+
+ cp += strlen(cp);
+ *cp++ = RDELIM;
+ *cp++ = DELIM;
+ if (! single_encode( circle->radius, cp))
+ elog (WARN, "Unable to format circle", NULL);
+
+ cp += strlen(cp);
+ *cp++ = RDELIM_C;
+ *cp = '\0';
+
+ return(result);
+} /* circle_out() */
+
+
+/*----------------------------------------------------------
+ * Relational operators for CIRCLEs.
+ * <, >, <=, >=, and == are based on circle area.
+ *---------------------------------------------------------*/
+
+/* circles identical?
+ */
+bool circle_same(CIRCLE *circle1, CIRCLE *circle2)
+{
+ return( FPeq(circle1->radius,circle2->radius)
+ && FPeq(circle1->center.x,circle2->center.x)
+ && FPeq(circle1->center.y,circle2->center.y));
+}
+
+/* circle_overlap - does circle1 overlap circle2?
+ */
+bool circle_overlap(CIRCLE *circle1, CIRCLE *circle2)
+{
+ return( FPle(point_dt(&circle1->center,&circle2->center),(circle1->radius+circle2->radius)));
+}
+
+/* circle_overleft - is the right edge of circle1 to the left of
+ * the right edge of circle2?
+ */
+bool circle_overleft(CIRCLE *circle1, CIRCLE *circle2)
+{
+ return( FPle((circle1->center.x+circle1->radius),(circle2->center.x+circle2->radius)));
+}
+
+/* circle_left - is circle1 strictly left of circle2?
+ */
+bool circle_left(CIRCLE *circle1, CIRCLE *circle2)
+{
+ return( FPle((circle1->center.x+circle1->radius),(circle2->center.x-circle2->radius)));
+}
+
+/* circle_right - is circle1 strictly right of circle2?
+ */
+bool circle_right(CIRCLE *circle1, CIRCLE *circle2)
+{
+ return( FPge((circle1->center.x-circle1->radius),(circle2->center.x+circle2->radius)));
+}
+
+/* circle_overright - is the left edge of circle1 to the right of
+ * the left edge of circle2?
+ */
+bool circle_overright(CIRCLE *circle1, CIRCLE *circle2)
+{
+ return( FPge((circle1->center.x-circle1->radius),(circle2->center.x-circle2->radius)));
+}
+
+/* circle_contained - is circle1 contained by circle2?
+ */
+bool circle_contained(CIRCLE *circle1, CIRCLE *circle2)
+{
+ return( FPle((point_dt(&circle1->center,&circle2->center)+circle1->radius),circle2->radius));
+}
+
+/* circle_contain - does circle1 contain circle2?
+ */
+bool circle_contain(CIRCLE *circle1, CIRCLE *circle2)
+{
+ return( FPle((point_dt(&circle1->center,&circle2->center)+circle2->radius),circle1->radius));
+}
+
+
+/* circle_positionop -
+ * is circle1 entirely {above,below} circle2?
+ */
+bool circle_below(CIRCLE *circle1, CIRCLE *circle2)
+{
+ return( FPle((circle1->center.y+circle1->radius),(circle2->center.y-circle2->radius)));
+}
+
+bool circle_above(CIRCLE *circle1, CIRCLE *circle2)
+{
+ return( FPge((circle1->center.y-circle1->radius),(circle2->center.y+circle2->radius)));
+}
+
+
+/* circle_relop - is area(circle1) relop area(circle2), within
+ * our accuracy constraint?
+ */
+bool circle_eq(CIRCLE *circle1, CIRCLE *circle2)
+{
+ return( FPeq(circle_ar(circle1), circle_ar(circle2)) );
+} /* circle_eq() */
+
+bool circle_ne(CIRCLE *circle1, CIRCLE *circle2)
+{
+ return( !circle_eq(circle1, circle2));
+} /* circle_ne() */
+
+bool circle_lt(CIRCLE *circle1, CIRCLE *circle2)
+{
+ return( FPlt(circle_ar(circle1), circle_ar(circle2)) );
+} /* circle_lt() */
+
+bool circle_gt(CIRCLE *circle1, CIRCLE *circle2)
+{
+ return( FPgt(circle_ar(circle1), circle_ar(circle2)) );
+} /* circle_gt() */
+
+bool circle_le(CIRCLE *circle1, CIRCLE *circle2)
+{
+ return( FPle(circle_ar(circle1), circle_ar(circle2)) );
+} /* circle_le() */
+
+bool circle_ge(CIRCLE *circle1, CIRCLE *circle2)
+{
+ return( FPge(circle_ar(circle1), circle_ar(circle2)) );
+} /* circle_ge() */
+
+
+/*----------------------------------------------------------
+ * "Arithmetic" operators on circles.
+ * circle_foo returns foo as an object (pointer) that
+ can be passed between languages.
+ * circle_xx is an internal routine which returns the
+ * actual value.
+ *---------------------------------------------------------*/
+
+CIRCLE *circle_copy(CIRCLE *circle);
+
+CIRCLE *
+circle_copy(CIRCLE *circle)
+{
+ CIRCLE *result;
+
+ if (!PointerIsValid(circle))
+ return NULL;
+
+ if (!PointerIsValid(result = PALLOCTYPE(CIRCLE)))
+ elog(WARN, "Memory allocation failed, can't copy circle",NULL);
+
+ memmove((char *) result, (char *) circle, sizeof(CIRCLE));
+ return(result);
+} /* circle_copy() */
+
+
+/* circle_add_pt()
+ * Translation operator.
+ */
+CIRCLE *
+circle_add_pt(CIRCLE *circle, Point *point)
+{
+ CIRCLE *result;
+
+ if (!PointerIsValid(circle) && !PointerIsValid(point))
+ return(NULL);
+
+ if (! PointerIsValid(result = circle_copy(circle)))
+ elog(WARN, "Memory allocation failed, can't add circle",NULL);
+
+ result->center.x += point->x;
+ result->center.y += point->y;
+
+ return(result);
+} /* circle_add_pt() */
+
+CIRCLE *
+circle_sub_pt(CIRCLE *circle, Point *point)
+{
+ CIRCLE *result;
+
+ if (!PointerIsValid(circle) && !PointerIsValid(point))
+ return(NULL);
+
+ if (! PointerIsValid(result = circle_copy(circle)))
+ elog(WARN, "Memory allocation failed, can't subtract circle",NULL);
+
+ result->center.x -= point->x;
+ result->center.y -= point->y;
+
+ return(result);
+} /* circle_sub_pt() */
+
+
+/* circle_mul_pt()
+ * Rotation and scaling operators.
+ */
+CIRCLE *
+circle_mul_pt(CIRCLE *circle, Point *point)
+{
+ CIRCLE *result;
+ Point *p;
+
+ if (!PointerIsValid(circle) && !PointerIsValid(point))
+ return(NULL);
+
+ if (! PointerIsValid(result = circle_copy(circle)))
+ elog(WARN, "Memory allocation failed, can't multiply circle",NULL);
+
+ p = point_mul( &circle->center, point);
+ result->center.x = p->x;
+ result->center.y = p->y;
+ PFREE(p);
+ result->radius *= HYPOT( point->x, point->y);
+
+ return(result);
+} /* circle_mul_pt() */
+
+CIRCLE *
+circle_div_pt(CIRCLE *circle, Point *point)
+{
+ CIRCLE *result;
+ Point *p;
+
+ if (!PointerIsValid(circle) && !PointerIsValid(point))
+ return(NULL);
+
+ if (! PointerIsValid(result = circle_copy(circle)))
+ elog(WARN, "Memory allocation failed, can't add circle",NULL);
+
+ p = point_div( &circle->center, point);
+ result->center.x = p->x;
+ result->center.y = p->y;
+ PFREE(p);
+ result->radius /= HYPOT( point->x, point->y);
+
+ return(result);
+} /* circle_div_pt() */
+
+
+/* circle_area - returns the area of the circle.
+ */
+double *circle_area(CIRCLE *circle)
+{
+ double *result;
+
+ result = PALLOCTYPE(double);
+ *result = circle_ar(circle);
+
+ return(result);
+}
+
+
+/* circle_diameter - returns the diameter of the circle.
+ */
+double *circle_diameter(CIRCLE *circle)
+{
+ double *result;
+
+ result = PALLOCTYPE(double);
+ *result = (2*circle->radius);
+
+ return(result);
+}
+
+
+/* circle_radius - returns the radius of the circle.
+ */
+double *circle_radius(CIRCLE *circle)
+{
+ double *result;
+
+ result = PALLOCTYPE(double);
+ *result = circle->radius;
+
+ return(result);
+}
+
+
+/* circle_distance - returns the distance between the
+ * center points of two circlees.
+ */
+double *circle_distance(CIRCLE *circle1, CIRCLE *circle2)
+{
+ double *result;
+
+ result = PALLOCTYPE(double);
+ *result = point_dt(&circle1->center,&circle2->center);
+
+ return(result);
+}
+
+
+/* circle_center - returns the center point of the circle.
+ */
+Point *circle_center(CIRCLE *circle)
+{
+ Point *result;
+
+ result = PALLOCTYPE(Point);
+ result->x = circle->center.x;
+ result->y = circle->center.y;
+
+ return(result);
+}
+
+
+/* circle_ar - returns the area of the circle.
+ */
+double circle_ar(CIRCLE *circle)
+{
+ return(PI*(circle->radius*circle->radius));
+}
+
+
+/* circle_dt - returns the distance between the
+ * center points of two circlees.
+ */
+double circle_dt(CIRCLE *circle1, CIRCLE *circle2)
+{
+ double result;
+
+ result = point_dt(&circle1->center,&circle2->center);
+
+ return(result);
+}
+
+
+/*----------------------------------------------------------
+ * Conversion operators.
+ *---------------------------------------------------------*/
+
+CIRCLE *circle(Point *center, float8 *radius)
+{
+ CIRCLE *result;
+
+ if (! (PointerIsValid(center) && PointerIsValid(radius)))
+ return(NULL);
+
+ if (!PointerIsValid(result = PALLOCTYPE(CIRCLE)))
+ elog(WARN, "Memory allocation failed, can't convert point to circle",NULL);
+
+ result->center.x = center->x;
+ result->center.y = center->y;
+ result->radius = *radius;
+
+ return(result);
+}
+
+POLYGON *circle_poly(int npts, CIRCLE *circle)
+{
+ POLYGON *poly;
+ int size;
+ int i;
+ double angle;
+
+ if (!PointerIsValid(circle))
+ return(NULL);
+
+ if (FPzero(circle->radius) || (npts <= 2))
+ elog (WARN, "Unable to convert circle to polygon", NULL);
+
+ size = offsetof(POLYGON, p[0]) + (sizeof(poly->p[0]) * npts);
+ if (!PointerIsValid(poly = (POLYGON *) PALLOC(size)))
+ elog(WARN, "Memory allocation failed, can't convert circle to polygon",NULL);
+
+ memset((char *) poly, 0, size); /* zero any holes */
+ poly->size = size;
+ poly->npts = npts;
+
+ for (i=0;i<npts;i++) {
+ angle = i*(2*PI/npts);
+ poly->p[i].x = circle->center.x - (circle->radius*cos(angle));
+ poly->p[i].y = circle->center.y + (circle->radius*sin(angle));
+ };
+
+ make_bound_box(poly);
+
+ return(poly);
+}
+
+/* poly_circle - convert polygon to circle
+ *
+ * XXX This algorithm should use weighted means of line segments
+ * rather than straight average values of points - tgl 97/01/21.
+ */
+CIRCLE *poly_circle(POLYGON *poly)
+{
+ CIRCLE *circle;
+ int i;
+
+ if (!PointerIsValid(poly))
+ return(NULL);
+
+ if (poly->npts <= 2)
+ elog (WARN, "Unable to convert polygon to circle", NULL);
+
+ if (!PointerIsValid(circle = PALLOCTYPE(CIRCLE)))
+ elog(WARN, "Memory allocation failed, can't convert polygon to circle",NULL);
+
+ circle->center.x = 0;
+ circle->center.y = 0;
+ circle->radius = 0;
+
+ for (i=0;i<poly->npts;i++) {
+ circle->center.x += poly->p[i].x;
+ circle->center.y += poly->p[i].y;
+ };
+ circle->center.x /= poly->npts;
+ circle->center.y /= poly->npts;
+
+ for (i=0;i<poly->npts;i++) {
+ circle->radius += point_dt( &poly->p[i], &circle->center);
+ };
+ circle->radius /= poly->npts;
+
+ if (FPzero(circle->radius))
+ elog (WARN, "Unable to convert polygon to circle", NULL);
+
+ return(circle);
+}
/*-------------------------------------------------------------------------
*
- * geo_decls.h--
- * Declarations for various 2D constructs.
+ * geo_decls.h - Declarations for various 2D constructs.
*
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: geo_decls.h,v 1.1 1997/03/14 23:33:27 scrappy Exp $
+ * $Id: geo_decls.h,v 1.2 1997/04/22 17:32:41 scrappy Exp $
*
* NOTE
* These routines do *not* use the float types from adt/.
*
* XXX These routines were not written by a numerical analyst.
+ * XXX I have made some attempt to flesh out the operators
+ * and data types. There are still some more to do. - tgl 97/04/19
*
*-------------------------------------------------------------------------
*/
/*#ifndef FmgrIncluded -- seems like always included. (it's FMgrIncluded) AY */
/*--------------------------------------------------------------------
- * Useful floating point utilities and constants.
+ * Useful floating point utilities and constants.
*-------------------------------------------------------------------*/
#define EPSILON 1.0E-06
+#ifdef EPSILON
#define FPzero(A) (fabs(A) <= EPSILON)
#define FPeq(A,B) (fabs((A) - (B)) <= EPSILON)
#define FPlt(A,B) ((B) - (A) > EPSILON)
#define FPle(A,B) ((A) - (B) <= EPSILON)
#define FPgt(A,B) ((A) - (B) > EPSILON)
#define FPge(A,B) ((B) - (A) <= EPSILON)
+#else
+#define FPzero(A) (A == 0)
+#define FPeq(A,B) (A == B)
+#define FPlt(A,B) (A < B)
+#define FPle(A,B) (A <= B)
+#define FPgt(A,B) (A > B)
+#define FPge(A,B) (A >= B)
+#endif
#define HYPOT(A, B) sqrt((A) * (A) + (B) * (B))
/*--------------------------------------------------------------------
- * Memory management.
+ * Memory management.
*-------------------------------------------------------------------*/
#define PALLOC(SIZE) palloc(SIZE)
/*#endif !FmgrIncluded */
/*---------------------------------------------------------------------
- * Point - (x,y)
+ * Point - (x,y)
*-------------------------------------------------------------------*/
typedef struct {
double x, y;
/*---------------------------------------------------------------------
- * LSEG - A straight line, specified by endpoints.
+ * LSEG - A straight line, specified by endpoints.
*-------------------------------------------------------------------*/
typedef struct {
Point p[2];
/*---------------------------------------------------------------------
- * PATH - Specified by vertex points.
+ * PATH - Specified by vertex points.
*-------------------------------------------------------------------*/
typedef struct {
- int32 length; /* XXX varlena */
+ int32 size; /* XXX varlena */
int32 npts;
int32 closed; /* is this a closed polygon? */
int32 dummy; /* padding to make it double align */
- Point p[1]; /* variable length array of POINTs */
+ Point p[0]; /* variable length array of POINTs */
} PATH;
/*---------------------------------------------------------------------
- * LINE - Specified by its general equation (Ax+By+C=0).
- * If there is a y-intercept, it is C, which
- * incidentally gives a freebie point on the line
- * (if B=0, then C is the x-intercept).
- * Slope m is precalculated to save time; if
- * the line is not vertical, m == A.
+ * LINE - Specified by its general equation (Ax+By+C=0).
+ * If there is a y-intercept, it is C, which
+ * incidentally gives a freebie point on the line
+ * (if B=0, then C is the x-intercept).
+ * Slope m is precalculated to save time; if
+ * the line is not vertical, m == A.
*-------------------------------------------------------------------*/
typedef struct {
double A, B, C;
/*---------------------------------------------------------------------
- * BOX - Specified by two corner points, which are
- * sorted to save calculation time later.
+ * BOX - Specified by two corner points, which are
+ * sorted to save calculation time later.
*-------------------------------------------------------------------*/
typedef struct {
- double xh, yh, xl, yl; /* high and low coords */
+ Point high, low; /* corner POINTs */
} BOX;
/*---------------------------------------------------------------------
- * POLYGON - Specified by an array of doubles defining the points,
- * keeping the number of points and the bounding box for
- * speed purposes.
+ * POLYGON - Specified by an array of doubles defining the points,
+ * keeping the number of points and the bounding box for
+ * speed purposes.
*-------------------------------------------------------------------*/
typedef struct {
int32 size; /* XXX varlena */
int32 npts;
BOX boundbox;
- char pts[1];
+ Point p[0]; /* variable length array of POINTs */
} POLYGON;
+/*---------------------------------------------------------------------
+ * CIRCLE - Specified by a center point and radius.
+ *-------------------------------------------------------------------*/
+typedef struct {
+ Point center;
+ double radius;
+} CIRCLE;
/*
* in geo_ops.h
extern BOX *box_construct(double x1, double x2, double y1, double y2);
extern BOX *box_fill(BOX *result, double x1, double x2, double y1, double y2);
extern BOX *box_copy(BOX *box);
-extern long box_same(BOX *box1, BOX *box2);
-extern long box_overlap(BOX *box1, BOX *box2);
-extern long box_overleft(BOX *box1, BOX *box2);
-extern long box_left(BOX *box1, BOX *box2);
-extern long box_right(BOX *box1, BOX *box2);
-extern long box_overright(BOX *box1, BOX *box2);
-extern long box_contained(BOX *box1, BOX *box2);
-extern long box_contain(BOX *box1, BOX *box2);
-extern long box_below(BOX *box1, BOX *box2);
-extern long box_above(BOX *box1, BOX *box2);
-extern long box_lt(BOX *box1, BOX *box2);
-extern long box_gt(BOX *box1, BOX *box2);
-extern long box_eq(BOX *box1, BOX *box2);
-extern long box_le(BOX *box1, BOX *box2);
-extern long box_ge(BOX *box1, BOX *box2);
+extern bool box_same(BOX *box1, BOX *box2);
+extern bool box_overlap(BOX *box1, BOX *box2);
+extern bool box_overleft(BOX *box1, BOX *box2);
+extern bool box_left(BOX *box1, BOX *box2);
+extern bool box_right(BOX *box1, BOX *box2);
+extern bool box_overright(BOX *box1, BOX *box2);
+extern bool box_contained(BOX *box1, BOX *box2);
+extern bool box_contain(BOX *box1, BOX *box2);
+extern bool box_below(BOX *box1, BOX *box2);
+extern bool box_above(BOX *box1, BOX *box2);
+extern bool box_lt(BOX *box1, BOX *box2);
+extern bool box_gt(BOX *box1, BOX *box2);
+extern bool box_eq(BOX *box1, BOX *box2);
+extern bool box_le(BOX *box1, BOX *box2);
+extern bool box_ge(BOX *box1, BOX *box2);
+extern Point *box_center(BOX *box);
extern double *box_area(BOX *box);
extern double *box_length(BOX *box);
extern double *box_height(BOX *box);
extern double *box_distance(BOX *box1, BOX *box2);
extern Point *box_center(BOX *box);
+extern BOX *box_intersect(BOX *box1, BOX *box2);
+extern LSEG *box_diagonal(BOX *box);
+
+/* private routines */
extern double box_ar(BOX *box);
extern double box_ln(BOX *box);
extern double box_ht(BOX *box);
extern double box_dt(BOX *box1, BOX *box2);
-extern BOX *box_intersect(BOX *box1, BOX *box2);
-extern LSEG *box_diagonal(BOX *box);
+
+extern BOX *box(Point *p1, Point *p2);
+extern BOX *box_add(BOX *box, Point *p);
+extern BOX *box_sub(BOX *box, Point *p);
+extern BOX *box_mul(BOX *box, Point *p);
+extern BOX *box_div(BOX *box, Point *p);
+
extern LINE *line_construct_pm(Point *pt, double m);
extern LINE *line_construct_pp(Point *pt1, Point *pt2);
-extern long line_intersect(LINE *l1, LINE *l2);
-extern long line_parallel(LINE *l1, LINE *l2);
-extern long line_perp(LINE *l1, LINE *l2);
-extern long line_vertical(LINE *line);
-extern long line_horizontal(LINE *line);
-extern long line_eq(LINE *l1, LINE *l2);
+extern bool line_intersect(LINE *l1, LINE *l2);
+extern bool line_parallel(LINE *l1, LINE *l2);
+extern bool line_perp(LINE *l1, LINE *l2);
+extern bool line_vertical(LINE *line);
+extern bool line_horizontal(LINE *line);
+extern bool line_eq(LINE *l1, LINE *l2);
extern double *line_distance(LINE *l1, LINE *l2);
extern Point *line_interpt(LINE *l1, LINE *l2);
+
extern PATH *path_in(char *str);
extern char *path_out(PATH *path);
-extern long path_n_lt(PATH *p1, PATH *p2);
-extern long path_n_gt(PATH *p1, PATH *p2);
-extern long path_n_eq(PATH *p1, PATH *p2);
-extern long path_n_le(PATH *p1, PATH *p2);
-extern long path_n_ge(PATH *p1, PATH *p2);
-extern long path_inter(PATH *p1, PATH *p2);
+extern bool path_n_lt(PATH *p1, PATH *p2);
+extern bool path_n_gt(PATH *p1, PATH *p2);
+extern bool path_n_eq(PATH *p1, PATH *p2);
+extern bool path_n_le(PATH *p1, PATH *p2);
+extern bool path_n_ge(PATH *p1, PATH *p2);
+extern bool path_inter(PATH *p1, PATH *p2);
extern double *path_distance(PATH *p1, PATH *p2);
extern double *path_length(PATH *path);
+
+/* private routines */
extern double path_ln(PATH *path);
+
+extern bool path_isclosed(PATH *path);
+extern bool path_isopen(PATH *path);
+extern int4 path_npoints(PATH *path);
+
+extern PATH *path_close(PATH *path);
+extern PATH *path_open(PATH *path);
+extern PATH *path_add(PATH *p1, PATH *p2);
+extern PATH *path_add_pt(PATH *path, Point *point);
+extern PATH *path_sub_pt(PATH *path, Point *point);
+extern PATH *path_mul_pt(PATH *path, Point *point);
+extern PATH *path_div_pt(PATH *path, Point *point);
+
+extern POLYGON *path_poly(PATH *path);
+
extern Point *point_in(char *str);
extern char *point_out(Point *pt);
extern Point *point_construct(double x, double y);
extern Point *point_copy(Point *pt);
-extern long point_left(Point *pt1, Point *pt2);
-extern long point_right(Point *pt1, Point *pt2);
-extern long point_above(Point *pt1, Point *pt2);
-extern long point_below(Point *pt1, Point *pt2);
-extern long point_vert(Point *pt1, Point *pt2);
-extern long point_horiz(Point *pt1, Point *pt2);
-extern long point_eq(Point *pt1, Point *pt2);
-extern long pointdist(Point *p1, Point *p2);
+extern bool point_left(Point *pt1, Point *pt2);
+extern bool point_right(Point *pt1, Point *pt2);
+extern bool point_above(Point *pt1, Point *pt2);
+extern bool point_below(Point *pt1, Point *pt2);
+extern bool point_vert(Point *pt1, Point *pt2);
+extern bool point_horiz(Point *pt1, Point *pt2);
+extern bool point_eq(Point *pt1, Point *pt2);
+extern int32 pointdist(Point *p1, Point *p2);
extern double *point_distance(Point *pt1, Point *pt2);
-extern double point_dt(Point *pt1, Point *pt2);
extern double *point_slope(Point *pt1, Point *pt2);
+
+/* private routines */
+extern double point_dt(Point *pt1, Point *pt2);
extern double point_sl(Point *pt1, Point *pt2);
+
+extern Point *point(float8 *x, float8 *y);
+extern Point *point_add(Point *p1, Point *p2);
+extern Point *point_sub(Point *p1, Point *p2);
+extern Point *point_mul(Point *p1, Point *p2);
+extern Point *point_div(Point *p1, Point *p2);
+
extern LSEG *lseg_in(char *str);
extern char *lseg_out(LSEG *ls);
-extern LSEG *lseg_construct(Point *pt1, Point *pt2);
-extern void statlseg_construct(LSEG *lseg, Point *pt1, Point *pt2);
-extern long lseg_intersect(LSEG *l1, LSEG *l2);
-extern long lseg_parallel(LSEG *l1, LSEG *l2);
-extern long lseg_perp(LSEG *l1, LSEG *l2);
-extern long lseg_vertical(LSEG *lseg);
-extern long lseg_horizontal(LSEG *lseg);
-extern long lseg_eq(LSEG *l1, LSEG *l2);
+extern bool lseg_intersect(LSEG *l1, LSEG *l2);
+extern bool lseg_parallel(LSEG *l1, LSEG *l2);
+extern bool lseg_perp(LSEG *l1, LSEG *l2);
+extern bool lseg_vertical(LSEG *lseg);
+extern bool lseg_horizontal(LSEG *lseg);
+extern bool lseg_eq(LSEG *l1, LSEG *l2);
extern double *lseg_distance(LSEG *l1, LSEG *l2);
-extern double lseg_dt(LSEG *l1, LSEG *l2);
extern Point *lseg_interpt(LSEG *l1, LSEG *l2);
extern double *dist_pl(Point *pt, LINE *line);
extern double *dist_ps(Point *pt, LSEG *lseg);
extern Point *close_sl(LSEG *lseg, LINE *line);
extern Point *close_sb(LSEG *lseg, BOX *box);
extern Point *close_lb(LINE *line, BOX *box);
-extern long on_pl(Point *pt, LINE *line);
-extern long on_ps(Point *pt, LSEG *lseg);
-extern long on_pb(Point *pt, BOX *box);
-extern long on_ppath(Point *pt, PATH *path);
-extern long on_sl(LSEG *lseg, LINE *line);
-extern long on_sb(LSEG *lseg, BOX *box);
-extern long inter_sl(LSEG *lseg, LINE *line);
-extern long inter_sb(LSEG *lseg, BOX *box);
-extern long inter_lb(LINE *line, BOX *box);
+extern bool on_pl(Point *pt, LINE *line);
+extern bool on_ps(Point *pt, LSEG *lseg);
+extern bool on_pb(Point *pt, BOX *box);
+extern bool on_ppath(Point *pt, PATH *path);
+extern bool on_sl(LSEG *lseg, LINE *line);
+extern bool on_sb(LSEG *lseg, BOX *box);
+extern bool inter_sl(LSEG *lseg, LINE *line);
+extern bool inter_sb(LSEG *lseg, BOX *box);
+extern bool inter_lb(LINE *line, BOX *box);
+
+/* private routines */
+extern LSEG *lseg_construct(Point *pt1, Point *pt2);
+extern void statlseg_construct(LSEG *lseg, Point *pt1, Point *pt2);
+extern double lseg_dt(LSEG *l1, LSEG *l2);
extern void make_bound_box(POLYGON *poly);
+
extern POLYGON *poly_in(char *s);
-extern long poly_pt_count(char *s, char delim);
extern char *poly_out(POLYGON *poly);
-extern double poly_max(double *coords, int ncoords);
-extern double poly_min(double *coords, int ncoords);
-extern long poly_left(POLYGON *polya, POLYGON *polyb);
-extern long poly_overleft(POLYGON *polya, POLYGON *polyb);
-extern long poly_right(POLYGON *polya, POLYGON *polyb);
-extern long poly_overright(POLYGON *polya, POLYGON *polyb);
-extern long poly_same(POLYGON *polya, POLYGON *polyb);
-extern long poly_overlap(POLYGON *polya, POLYGON *polyb);
-extern long poly_contain(POLYGON *polya, POLYGON *polyb);
-extern long poly_contained(POLYGON *polya, POLYGON *polyb);
+extern bool poly_left(POLYGON *polya, POLYGON *polyb);
+extern bool poly_overleft(POLYGON *polya, POLYGON *polyb);
+extern bool poly_right(POLYGON *polya, POLYGON *polyb);
+extern bool poly_overright(POLYGON *polya, POLYGON *polyb);
+extern bool poly_same(POLYGON *polya, POLYGON *polyb);
+extern bool poly_overlap(POLYGON *polya, POLYGON *polyb);
+extern bool poly_contain(POLYGON *polya, POLYGON *polyb);
+extern bool poly_contained(POLYGON *polya, POLYGON *polyb);
+
+extern int4 poly_npoints(POLYGON *poly);
+extern BOX *poly_box(POLYGON *poly);
+extern PATH *poly_path(POLYGON *poly);
+extern POLYGON *box_poly(BOX *box);
+
+extern CIRCLE *circle_in(char *str);
+extern char *circle_out(CIRCLE *circle);
+extern bool circle_same(CIRCLE *circle1, CIRCLE *circle2);
+extern bool circle_overlap(CIRCLE *circle1, CIRCLE *circle2);
+extern bool circle_overleft(CIRCLE *circle1, CIRCLE *circle2);
+extern bool circle_left(CIRCLE *circle1, CIRCLE *circle2);
+extern bool circle_right(CIRCLE *circle1, CIRCLE *circle2);
+extern bool circle_overright(CIRCLE *circle1, CIRCLE *circle2);
+extern bool circle_contained(CIRCLE *circle1, CIRCLE *circle2);
+extern bool circle_contain(CIRCLE *circle1, CIRCLE *circle2);
+extern bool circle_below(CIRCLE *circle1, CIRCLE *circle2);
+extern bool circle_above(CIRCLE *circle1, CIRCLE *circle2);
+
+extern bool circle_eq(CIRCLE *circle1, CIRCLE *circle2);
+extern bool circle_ne(CIRCLE *circle1, CIRCLE *circle2);
+extern bool circle_lt(CIRCLE *circle1, CIRCLE *circle2);
+extern bool circle_gt(CIRCLE *circle1, CIRCLE *circle2);
+extern bool circle_le(CIRCLE *circle1, CIRCLE *circle2);
+extern bool circle_ge(CIRCLE *circle1, CIRCLE *circle2);
+extern CIRCLE *circle_add_pt(CIRCLE *circle, Point *point);
+extern CIRCLE *circle_sub_pt(CIRCLE *circle, Point *point);
+extern CIRCLE *circle_mul_pt(CIRCLE *circle, Point *point);
+extern CIRCLE *circle_div_pt(CIRCLE *circle, Point *point);
+extern double *circle_area(CIRCLE *circle);
+extern double *circle_diameter(CIRCLE *circle);
+extern double *circle_radius(CIRCLE *circle);
+extern double *circle_distance(CIRCLE *circle1, CIRCLE *circle2);
+extern Point *circle_center(CIRCLE *circle);
+extern CIRCLE *circle(Point *center, float8 *radius);
+extern CIRCLE *poly_circle(POLYGON *poly);
+extern POLYGON *circle_poly(int npts, CIRCLE *circle);
+
+/* private routines */
+extern double circle_ar(CIRCLE *circle);
+extern double circle_dt(CIRCLE *circle1, CIRCLE *circle2);
/* geo_selfuncs.c */
extern float64 areasel(Oid opid, Oid relid, AttrNumber attno,
extern float64 contsel(Oid opid, Oid relid, AttrNumber attno,
char *value, int32 flag);
extern float64 contjoinsel(Oid opid, Oid relid, AttrNumber attno,
- char *value, int32 flag);
+ char *value, int32 flag);
#endif /* GEO_DECLS_H */
projects / postgresql / commitdiff