1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
|
/*-------------------------------------------------------------------------
*
* geo_decls.h - Declarations for various 2D constructs.
*
*
* Copyright (c) 1994, Regents of the University of California
*
* $Id: geo_decls.h,v 1.9 1997/09/07 05:02:34 momjian 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 GEO_DECLS_H
#define GEO_DECLS_H
#include "access/attnum.h"
/*#ifndef FmgrIncluded -- seems like always included. (it's FMgrIncluded) AY */
/*--------------------------------------------------------------------
* 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 FPnzero(A) (A != 0)
#define FPeq(A,B) (A == B)
#define FPne(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.
*-------------------------------------------------------------------*/
#define PALLOC(SIZE) palloc(SIZE)
#define PFREE(P) pfree(P)
#define PALLOCTYPE(TYPE) (TYPE *) PALLOC(sizeof(TYPE))
/*#endif !FmgrIncluded */
/*---------------------------------------------------------------------
* Point - (x,y)
*-------------------------------------------------------------------*/
typedef struct
{
double x,
y;
} Point;
/*---------------------------------------------------------------------
* LSEG - A straight line, specified by endpoints.
*-------------------------------------------------------------------*/
typedef struct
{
Point p[2];
double m; /* precomputed to save time, not in tuple */
} LSEG;
/*---------------------------------------------------------------------
* PATH - Specified by vertex points.
*-------------------------------------------------------------------*/
typedef struct
{
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 */
} 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.
*-------------------------------------------------------------------*/
typedef struct
{
double A,
B,
C;
double m;
} LINE;
/*---------------------------------------------------------------------
* BOX - Specified by two corner points, which are
* sorted to save calculation time later.
*-------------------------------------------------------------------*/
typedef struct
{
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.
*-------------------------------------------------------------------*/
typedef struct
{
int32 size; /* XXX varlena */
int32 npts;
BOX boundbox;
Point p[1]; /* 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
*/
/* public point routines */
extern Point *point_in(char *str);
extern char *point_out(Point * pt);
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_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);
/* public lseg routines */
extern LSEG *lseg_in(char *str);
extern char *lseg_out(LSEG * ls);
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 Point *lseg_center(LSEG * lseg);
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 double *dist_ppath(Point * pt, PATH * path);
extern double *dist_pb(Point * pt, BOX * box);
extern double *dist_sl(LSEG * lseg, LINE * line);
extern double *dist_sb(LSEG * lseg, BOX * box);
extern double *dist_lb(LINE * line, BOX * box);
extern Point *close_pl(Point * pt, LINE * line);
extern Point *close_ps(Point * pt, LSEG * lseg);
extern Point *close_pb(Point * pt, BOX * box);
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 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);
/* public box routines */
extern BOX *box_in(char *str);
extern char *box_out(BOX * box);
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_width(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_dt(BOX * box1, BOX * box2);
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);
/* private line routines */
extern double *line_distance(LINE * l1, LINE * l2);
/* public path routines */
extern PATH *path_in(char *str);
extern char *path_out(PATH * path);
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);
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 bool path_contain_pt(PATH * path, Point * p);
extern bool pt_contained_path(Point * p, PATH * path);
extern Point *path_center(PATH * path);
extern POLYGON *path_poly(PATH * path);
extern PATH *upgradepath(PATH * path);
extern bool isoldpath(PATH * path);
/* public polygon routines */
extern POLYGON *poly_in(char *s);
extern char *poly_out(POLYGON * poly);
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 bool poly_contain_pt(POLYGON * poly, Point * p);
extern bool pt_contained_poly(Point * p, POLYGON * poly);
extern double *poly_distance(POLYGON * polya, POLYGON * polyb);
extern int4 poly_npoints(POLYGON * poly);
extern Point *poly_center(POLYGON * poly);
extern BOX *poly_box(POLYGON * poly);
extern PATH *poly_path(POLYGON * poly);
extern POLYGON *box_poly(BOX * box);
extern POLYGON *upgradepoly(POLYGON * poly);
extern POLYGON *revertpoly(POLYGON * poly);
/* private polygon routines */
/* public circle routines */
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 bool circle_contain_pt(CIRCLE * circle, Point * point);
extern bool pt_contained_circle(Point * point, CIRCLE * circle);
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_diameter(CIRCLE * circle);
extern double *circle_radius(CIRCLE * circle);
extern double *circle_distance(CIRCLE * circle1, CIRCLE * circle2);
extern double *dist_pc(Point * point, CIRCLE * circle);
extern double *dist_cpoly(CIRCLE * circle, POLYGON * poly);
extern Point *circle_center(CIRCLE * circle);
extern CIRCLE *circle(Point * center, float8 * radius);
extern CIRCLE *box_circle(BOX * box);
extern BOX *circle_box(CIRCLE * circle);
extern CIRCLE *poly_circle(POLYGON * poly);
extern POLYGON *circle_poly(int npts, CIRCLE * circle);
/* private routines */
extern double *circle_area(CIRCLE * circle);
extern double circle_dt(CIRCLE * circle1, CIRCLE * circle2);
/* geo_selfuncs.c */
extern float64
areasel(Oid opid, Oid relid, AttrNumber attno,
char *value, int32 flag);
extern float64
areajoinsel(Oid opid, Oid relid, AttrNumber attno,
char *value, int32 flag);
#endif /* GEO_DECLS_H */
|
