GEOS  3.9.0dev
geos_c.h
1 /************************************************************************
2  *
3  *
4  * C-Wrapper for GEOS library
5  *
6  * Copyright (C) 2010 2011 Sandro Santilli <strk@kbt.io>
7  * Copyright (C) 2005 Refractions Research Inc.
8  *
9  * This is free software; you can redistribute and/or modify it under
10  * the terms of the GNU Lesser General Public Licence as published
11  * by the Free Software Foundation.
12  * See the COPYING file for more information.
13  *
14  * Author: Sandro Santilli <strk@kbt.io>
15  *
16  ***********************************************************************
17  *
18  * GENERAL NOTES:
19  *
20  * - Remember to call initGEOS() before any use of this library's
21  * functions, and call finishGEOS() when done.
22  *
23  * - Currently you have to explicitly GEOSGeom_destroy() all
24  * GEOSGeom objects to avoid memory leaks, and GEOSFree()
25  * all returned char * (unless const).
26  *
27  * - Functions ending with _r are thread safe; see details in RFC 3
28  * http://trac.osgeo.org/geos/wiki/RFC3.
29  * To avoid using by accident non _r functions,
30  * define GEOS_USE_ONLY_R_API before including geos_c.h
31  *
32  ***********************************************************************/
33 
34 #ifndef GEOS_C_H_INCLUDED
35 #define GEOS_C_H_INCLUDED
36 
37 #ifndef __cplusplus
38 # include <stddef.h> /* for size_t definition */
39 #else
40 # include <cstddef>
41 using std::size_t;
42 #endif
43 
44 #ifdef __cplusplus
45 extern "C" {
46 #endif
47 
48 /************************************************************************
49  *
50  * Version
51  *
52  ***********************************************************************/
53 
54 #ifndef GEOS_VERSION_MAJOR
55 #define GEOS_VERSION_MAJOR 3
56 #endif
57 #ifndef GEOS_VERSION_MINOR
58 #define GEOS_VERSION_MINOR 9
59 #endif
60 #ifndef GEOS_VERSION_PATCH
61 #define GEOS_VERSION_PATCH 0dev
62 #endif
63 #ifndef GEOS_VERSION
64 #define GEOS_VERSION "3.9.0dev"
65 #endif
66 #ifndef GEOS_JTS_PORT
67 #define GEOS_JTS_PORT "1.16.0"
68 #endif
69 
70 #define GEOS_CAPI_VERSION_MAJOR 1
71 #define GEOS_CAPI_VERSION_MINOR 14
72 #define GEOS_CAPI_VERSION_PATCH 0
73 #define GEOS_CAPI_VERSION "3.9.0dev-CAPI-1.14.0"
74 
75 #define GEOS_CAPI_FIRST_INTERFACE GEOS_CAPI_VERSION_MAJOR
76 #define GEOS_CAPI_LAST_INTERFACE (GEOS_CAPI_VERSION_MAJOR+GEOS_CAPI_VERSION_MINOR)
77 
78 
79 /************************************************************************
80  *
81  * (Abstract) type definitions
82  *
83  ************************************************************************/
84 
85 typedef struct GEOSContextHandle_HS *GEOSContextHandle_t;
86 
87 typedef void (*GEOSMessageHandler)(const char *fmt, ...);
88 
89 /*
90  * A GEOS message handler function.
91  *
92  * @param message the message contents
93  * @param userdata the user data pointer that was passed to GEOS when registering this message handler.
94  *
95  *
96  * @see GEOSContext_setErrorMessageHandler
97  * @see GEOSContext_setNoticeMessageHandler
98  */
99 typedef void (*GEOSMessageHandler_r)(const char *message, void *userdata);
100 
101 /* When we're included by geos_c.cpp, those are #defined to the original
102  * JTS definitions via preprocessor. We don't touch them to allow the
103  * compiler to cross-check the declarations. However, for all "normal"
104  * C-API users, we need to define them as "opaque" struct pointers, as
105  * those clients don't have access to the original C++ headers, by design.
106  */
107 #ifndef GEOSGeometry
108 typedef struct GEOSGeom_t GEOSGeometry;
109 typedef struct GEOSPrepGeom_t GEOSPreparedGeometry;
110 typedef struct GEOSCoordSeq_t GEOSCoordSequence;
111 typedef struct GEOSSTRtree_t GEOSSTRtree;
112 typedef struct GEOSBufParams_t GEOSBufferParams;
113 #endif
114 
115 /* Those are compatibility definitions for source compatibility
116  * with GEOS 2.X clients relying on that type.
117  */
118 typedef GEOSGeometry* GEOSGeom;
119 typedef GEOSCoordSequence* GEOSCoordSeq;
120 
121 /* Supported geometry types
122  * This was renamed from GEOSGeomTypeId in GEOS 2.2.X, which might
123  * break compatibility, this issue is still under investigation.
124  */
125 
126 enum GEOSGeomTypes {
127  GEOS_POINT,
130  GEOS_POLYGON,
135 };
136 
137 /* Byte orders exposed via the C API */
138 enum GEOSByteOrders {
139  GEOS_WKB_XDR = 0, /* Big Endian */
140  GEOS_WKB_NDR = 1 /* Little Endian */
141 };
142 
143 typedef void (*GEOSQueryCallback)(void *item, void *userdata);
144 typedef int (*GEOSDistanceCallback)(const void *item1, const void* item2, double* distance, void* userdata);
145 
146 /************************************************************************
147  *
148  * Initialization, cleanup, version
149  *
150  ***********************************************************************/
151 
152 #include <geos/export.h>
153 
154 /*
155  * Register an interruption checking callback
156  *
157  * The callback will be invoked _before_ checking for
158  * interruption, so can be used to request it.
159  */
160 typedef void (GEOSInterruptCallback)();
161 extern GEOSInterruptCallback GEOS_DLL *GEOS_interruptRegisterCallback(GEOSInterruptCallback* cb);
162 /* Request safe interruption of operations */
163 extern void GEOS_DLL GEOS_interruptRequest();
164 /* Cancel a pending interruption request */
165 extern void GEOS_DLL GEOS_interruptCancel();
166 
167 /*
168  * @deprecated in 3.5.0
169  * initialize using GEOS_init_r() and set the message handlers using
170  * GEOSContext_setNoticeHandler_r and/or GEOSContext_setErrorHandler_r
171  */
172 extern GEOSContextHandle_t GEOS_DLL initGEOS_r(
173  GEOSMessageHandler notice_function,
174  GEOSMessageHandler error_function);
175 /*
176  * @deprecated in 3.5.0 replaced by GEOS_finish_r.
177  */
178 extern void GEOS_DLL finishGEOS_r(GEOSContextHandle_t handle);
179 
180 extern GEOSContextHandle_t GEOS_DLL GEOS_init_r();
181 extern void GEOS_DLL GEOS_finish_r(GEOSContextHandle_t handle);
182 
183 
184 extern GEOSMessageHandler GEOS_DLL GEOSContext_setNoticeHandler_r(GEOSContextHandle_t extHandle,
185  GEOSMessageHandler nf);
186 extern GEOSMessageHandler GEOS_DLL GEOSContext_setErrorHandler_r(GEOSContextHandle_t extHandle,
187  GEOSMessageHandler ef);
188 
189 /*
190  * Sets a notice message handler on the given GEOS context.
191  *
192  * @param extHandle the GEOS context
193  * @param nf the message handler
194  * @param userData optional user data pointer that will be passed to the message handler
195  *
196  * @return the previously configured message handler or NULL if no message handler was configured
197  */
198 extern GEOSMessageHandler_r GEOS_DLL GEOSContext_setNoticeMessageHandler_r(GEOSContextHandle_t extHandle,
199  GEOSMessageHandler_r nf,
200  void *userData);
201 
202 /*
203  * Sets an error message handler on the given GEOS context.
204  *
205  * @param extHandle the GEOS context
206  * @param ef the message handler
207  * @param userData optional user data pointer that will be passed to the message handler
208  *
209  * @return the previously configured message handler or NULL if no message handler was configured
210  */
211 extern GEOSMessageHandler_r GEOS_DLL GEOSContext_setErrorMessageHandler_r(GEOSContextHandle_t extHandle,
212  GEOSMessageHandler_r ef,
213  void *userData);
214 
215 extern const char GEOS_DLL *GEOSversion();
216 
217 
218 /************************************************************************
219  *
220  * NOTE - These functions are DEPRECATED. Please use the new Reader and
221  * writer APIS!
222  *
223  ***********************************************************************/
224 
225 extern GEOSGeometry GEOS_DLL *GEOSGeomFromWKT_r(GEOSContextHandle_t handle,
226  const char *wkt);
227 extern char GEOS_DLL *GEOSGeomToWKT_r(GEOSContextHandle_t handle,
228  const GEOSGeometry* g);
229 
230 /*
231  * Specify whether output WKB should be 2d or 3d.
232  * Return previously set number of dimensions.
233  */
234 
235 extern int GEOS_DLL GEOS_getWKBOutputDims_r(GEOSContextHandle_t handle);
236 extern int GEOS_DLL GEOS_setWKBOutputDims_r(GEOSContextHandle_t handle,
237  int newDims);
238 
239 /*
240  * Specify whether the WKB byte order is big or little endian.
241  * The return value is the previous byte order.
242  */
243 
244 extern int GEOS_DLL GEOS_getWKBByteOrder_r(GEOSContextHandle_t handle);
245 extern int GEOS_DLL GEOS_setWKBByteOrder_r(GEOSContextHandle_t handle,
246  int byteOrder);
247 
248 extern GEOSGeometry GEOS_DLL *GEOSGeomFromWKB_buf_r(GEOSContextHandle_t handle,
249  const unsigned char *wkb,
250  size_t size);
251 extern unsigned char GEOS_DLL *GEOSGeomToWKB_buf_r(GEOSContextHandle_t handle,
252  const GEOSGeometry* g,
253  size_t *size);
254 
255 extern GEOSGeometry GEOS_DLL *GEOSGeomFromHEX_buf_r(GEOSContextHandle_t handle,
256  const unsigned char *hex,
257  size_t size);
258 extern unsigned char GEOS_DLL *GEOSGeomToHEX_buf_r(GEOSContextHandle_t handle,
259  const GEOSGeometry* g,
260  size_t *size);
261 
262 /************************************************************************
263  *
264  * Coordinate Sequence functions
265  *
266  ***********************************************************************/
267 
268 /*
269  * Create a Coordinate sequence with ``size'' coordinates
270  * of ``dims'' dimensions.
271  * Return NULL on exception.
272  */
273 extern GEOSCoordSequence GEOS_DLL *GEOSCoordSeq_create_r(
274  GEOSContextHandle_t handle,
275  unsigned int size,
276  unsigned int dims);
277 
278 /*
279  * Clone a Coordinate Sequence.
280  * Return NULL on exception.
281  */
282 extern GEOSCoordSequence GEOS_DLL *GEOSCoordSeq_clone_r(
283  GEOSContextHandle_t handle,
284  const GEOSCoordSequence* s);
285 
286 /*
287  * Destroy a Coordinate Sequence.
288  */
289 extern void GEOS_DLL GEOSCoordSeq_destroy_r(GEOSContextHandle_t handle,
290  GEOSCoordSequence* s);
291 
292 /*
293  * Set ordinate values in a Coordinate Sequence.
294  * Return 0 on exception.
295  */
296 extern int GEOS_DLL GEOSCoordSeq_setX_r(GEOSContextHandle_t handle,
297  GEOSCoordSequence* s, unsigned int idx,
298  double val);
299 extern int GEOS_DLL GEOSCoordSeq_setY_r(GEOSContextHandle_t handle,
300  GEOSCoordSequence* s, unsigned int idx,
301  double val);
302 extern int GEOS_DLL GEOSCoordSeq_setZ_r(GEOSContextHandle_t handle,
303  GEOSCoordSequence* s, unsigned int idx,
304  double val);
305 extern int GEOS_DLL GEOSCoordSeq_setXY_r(GEOSContextHandle_t handle,
306  GEOSCoordSequence* s, unsigned int idx,
307  double x, double y);
308 extern int GEOS_DLL GEOSCoordSeq_setXYZ_r(GEOSContextHandle_t handle,
309  GEOSCoordSequence* s, unsigned int idx,
310  double x, double y, double z);
311 
312 extern int GEOS_DLL GEOSCoordSeq_setOrdinate_r(GEOSContextHandle_t handle,
313  GEOSCoordSequence* s,
314  unsigned int idx,
315  unsigned int dim, double val);
316 
317 /*
318  * Get ordinate values from a Coordinate Sequence.
319  * Return 0 on exception.
320  */
321 extern int GEOS_DLL GEOSCoordSeq_getX_r(GEOSContextHandle_t handle,
322  const GEOSCoordSequence* s,
323  unsigned int idx, double *val);
324 extern int GEOS_DLL GEOSCoordSeq_getY_r(GEOSContextHandle_t handle,
325  const GEOSCoordSequence* s,
326  unsigned int idx, double *val);
327 extern int GEOS_DLL GEOSCoordSeq_getZ_r(GEOSContextHandle_t handle,
328  const GEOSCoordSequence* s,
329  unsigned int idx, double *val);
330 extern int GEOS_DLL GEOSCoordSeq_getXY_r(GEOSContextHandle_t handle,
331  const GEOSCoordSequence* s,
332  unsigned int idx, double *x, double *y);
333 extern int GEOS_DLL GEOSCoordSeq_getXYZ_r(GEOSContextHandle_t handle,
334  const GEOSCoordSequence* s,
335  unsigned int idx, double *x, double *y, double *z);
336 extern int GEOS_DLL GEOSCoordSeq_getOrdinate_r(GEOSContextHandle_t handle,
337  const GEOSCoordSequence* s,
338  unsigned int idx,
339  unsigned int dim, double *val);
340 /*
341  * Get size and dimensions info from a Coordinate Sequence.
342  * Return 0 on exception.
343  */
344 extern int GEOS_DLL GEOSCoordSeq_getSize_r(GEOSContextHandle_t handle,
345  const GEOSCoordSequence* s,
346  unsigned int *size);
347 extern int GEOS_DLL GEOSCoordSeq_getDimensions_r(GEOSContextHandle_t handle,
348  const GEOSCoordSequence* s,
349  unsigned int *dims);
350 /*
351  * Check orientation of a CoordinateSequence and set 'is_ccw' to 1
352  * if it has counter-clockwise orientation, 0 otherwise.
353  * Return 0 on exception, 1 on success.
354  */
355 extern int GEOS_DLL GEOSCoordSeq_isCCW_r(GEOSContextHandle_t handle,
356  const GEOSCoordSequence* s,
357  char* is_ccw);
358 
359 /************************************************************************
360  *
361  * Linear referencing functions -- there are more, but these are
362  * probably sufficient for most purposes
363  *
364  ***********************************************************************/
365 
366 /*
367  * GEOSGeometry ownership is retained by caller
368  */
369 
370 
371 /* Return distance of point 'p' projected on 'g' from origin
372  * of 'g'. Geometry 'g' must be a lineal geometry */
373 extern double GEOS_DLL GEOSProject_r(GEOSContextHandle_t handle,
374  const GEOSGeometry *g,
375  const GEOSGeometry *p);
376 
377 /* Return closest point to given distance within geometry
378  * Geometry must be a LineString */
379 extern GEOSGeometry GEOS_DLL *GEOSInterpolate_r(GEOSContextHandle_t handle,
380  const GEOSGeometry *g,
381  double d);
382 
383 extern double GEOS_DLL GEOSProjectNormalized_r(GEOSContextHandle_t handle,
384  const GEOSGeometry *g,
385  const GEOSGeometry *p);
386 
387 extern GEOSGeometry GEOS_DLL *GEOSInterpolateNormalized_r(
388  GEOSContextHandle_t handle,
389  const GEOSGeometry *g,
390  double d);
391 
392 /************************************************************************
393  *
394  * Buffer related functions
395  *
396  ***********************************************************************/
397 
398 
399 /* @return NULL on exception */
400 extern GEOSGeometry GEOS_DLL *GEOSBuffer_r(GEOSContextHandle_t handle,
401  const GEOSGeometry* g,
402  double width, int quadsegs);
403 
404 enum GEOSBufCapStyles {
405  GEOSBUF_CAP_ROUND=1,
406  GEOSBUF_CAP_FLAT=2,
407  GEOSBUF_CAP_SQUARE=3
408 };
409 
410 enum GEOSBufJoinStyles {
411  GEOSBUF_JOIN_ROUND=1,
412  GEOSBUF_JOIN_MITRE=2,
413  GEOSBUF_JOIN_BEVEL=3
414 };
415 
416 /* @return 0 on exception */
417 extern GEOSBufferParams GEOS_DLL *GEOSBufferParams_create_r(
418  GEOSContextHandle_t handle);
419 extern void GEOS_DLL GEOSBufferParams_destroy_r(
420  GEOSContextHandle_t handle,
421  GEOSBufferParams* parms);
422 
423 /* @return 0 on exception */
424 extern int GEOS_DLL GEOSBufferParams_setEndCapStyle_r(
425  GEOSContextHandle_t handle,
426  GEOSBufferParams* p,
427  int style);
428 
429 /* @return 0 on exception */
430 extern int GEOS_DLL GEOSBufferParams_setJoinStyle_r(
431  GEOSContextHandle_t handle,
432  GEOSBufferParams* p,
433  int joinStyle);
434 
435 /* @return 0 on exception */
436 extern int GEOS_DLL GEOSBufferParams_setMitreLimit_r(
437  GEOSContextHandle_t handle,
438  GEOSBufferParams* p,
439  double mitreLimit);
440 
441 /* @return 0 on exception */
442 extern int GEOS_DLL GEOSBufferParams_setQuadrantSegments_r(
443  GEOSContextHandle_t handle,
444  GEOSBufferParams* p,
445  int quadSegs);
446 
447 /* @param singleSided: 1 for single sided, 0 otherwise */
448 /* @return 0 on exception */
449 extern int GEOS_DLL GEOSBufferParams_setSingleSided_r(
450  GEOSContextHandle_t handle,
451  GEOSBufferParams* p,
452  int singleSided);
453 
454 /* @return NULL on exception */
455 extern GEOSGeometry GEOS_DLL *GEOSBufferWithParams_r(
456  GEOSContextHandle_t handle,
457  const GEOSGeometry* g,
458  const GEOSBufferParams* p,
459  double width);
460 
461 /* These functions return NULL on exception. */
462 extern GEOSGeometry GEOS_DLL *GEOSBufferWithStyle_r(GEOSContextHandle_t handle,
463  const GEOSGeometry* g, double width, int quadsegs, int endCapStyle,
464  int joinStyle, double mitreLimit);
465 
466 /* These functions return NULL on exception. Only LINESTRINGs are accepted. */
467 /* @deprecated in 3.3.0: use GEOSOffsetCurve instead */
468 extern GEOSGeometry GEOS_DLL *GEOSSingleSidedBuffer_r(
469  GEOSContextHandle_t handle,
470  const GEOSGeometry* g, double width, int quadsegs,
471  int joinStyle, double mitreLimit, int leftSide);
472 
473 /*
474  * Only LINESTRINGs are accepted.
475  * @param width : offset distance.
476  * negative for right side offset.
477  * positive for left side offset.
478  * @return NULL on exception
479  */
480 extern GEOSGeometry GEOS_DLL *GEOSOffsetCurve_r(GEOSContextHandle_t handle,
481  const GEOSGeometry* g, double width, int quadsegs,
482  int joinStyle, double mitreLimit);
483 
484 
485 /************************************************************************
486  *
487  * Geometry Constructors.
488  * GEOSCoordSequence* arguments will become ownership of the returned object.
489  * All functions return NULL on exception.
490  *
491  ***********************************************************************/
492 
493 extern GEOSGeometry GEOS_DLL *GEOSGeom_createPoint_r(
494  GEOSContextHandle_t handle,
495  GEOSCoordSequence* s);
496 extern GEOSGeometry GEOS_DLL *GEOSGeom_createPointFromXY_r(
497  GEOSContextHandle_t handle,
498  double x,
499  double y);
500 extern GEOSGeometry GEOS_DLL *GEOSGeom_createEmptyPoint_r(
501  GEOSContextHandle_t handle);
502 extern GEOSGeometry GEOS_DLL *GEOSGeom_createLinearRing_r(
503  GEOSContextHandle_t handle,
504  GEOSCoordSequence* s);
505 extern GEOSGeometry GEOS_DLL *GEOSGeom_createLineString_r(
506  GEOSContextHandle_t handle,
507  GEOSCoordSequence* s);
508 extern GEOSGeometry GEOS_DLL *GEOSGeom_createEmptyLineString_r(
509  GEOSContextHandle_t handle);
510 
511 /*
512  * Second argument is an array of GEOSGeometry* objects.
513  * The caller remains owner of the array, but pointed-to
514  * objects become ownership of the returned GEOSGeometry.
515  */
516 extern GEOSGeometry GEOS_DLL *GEOSGeom_createEmptyPolygon_r(
517  GEOSContextHandle_t handle);
518 extern GEOSGeometry GEOS_DLL *GEOSGeom_createPolygon_r(
519  GEOSContextHandle_t handle,
520  GEOSGeometry* shell,
521  GEOSGeometry** holes,
522  unsigned int nholes);
523 extern GEOSGeometry GEOS_DLL *GEOSGeom_createCollection_r(
524  GEOSContextHandle_t handle, int type,
525  GEOSGeometry* *geoms,
526  unsigned int ngeoms);
527 extern GEOSGeometry GEOS_DLL *GEOSGeom_createEmptyCollection_r(
528  GEOSContextHandle_t handle, int type);
529 
530 extern GEOSGeometry GEOS_DLL *GEOSGeom_clone_r(GEOSContextHandle_t handle,
531  const GEOSGeometry* g);
532 
533 /************************************************************************
534  *
535  * Memory management
536  *
537  ***********************************************************************/
538 
539 extern void GEOS_DLL GEOSGeom_destroy_r(GEOSContextHandle_t handle,
540  GEOSGeometry* g);
541 
542 /************************************************************************
543  *
544  * Topology operations - return NULL on exception.
545  *
546  ***********************************************************************/
547 
548 extern GEOSGeometry GEOS_DLL *GEOSEnvelope_r(GEOSContextHandle_t handle,
549  const GEOSGeometry* g);
550 extern GEOSGeometry GEOS_DLL *GEOSIntersection_r(GEOSContextHandle_t handle,
551  const GEOSGeometry* g1,
552  const GEOSGeometry* g2);
553 extern GEOSGeometry GEOS_DLL *GEOSConvexHull_r(GEOSContextHandle_t handle,
554  const GEOSGeometry* g);
555 
556 /* Returns the minimum rotated rectangular POLYGON which encloses the input geometry. The rectangle
557  * has width equal to the minimum diameter, and a longer length. If the convex hill of the input is
558  * degenerate (a line or point) a LINESTRING or POINT is returned. The minimum rotated rectangle can
559  * be used as an extremely generalized representation for the given geometry.
560  */
561 extern GEOSGeometry GEOS_DLL *GEOSMinimumRotatedRectangle_r(GEOSContextHandle_t handle,
562  const GEOSGeometry* g);
563 
564 /* Returns a LINESTRING geometry which represents the minimum diameter of the geometry.
565  * The minimum diameter is defined to be the width of the smallest band that
566  * contains the geometry, where a band is a strip of the plane defined
567  * by two parallel lines. This can be thought of as the smallest hole that the geometry
568  * can be moved through, with a single rotation.
569  */
570 extern GEOSGeometry GEOS_DLL *GEOSMinimumWidth_r(GEOSContextHandle_t handle,
571  const GEOSGeometry* g);
572 
573 extern GEOSGeometry GEOS_DLL *GEOSMinimumClearanceLine_r(GEOSContextHandle_t handle,
574  const GEOSGeometry* g);
575 
576 extern int GEOS_DLL GEOSMinimumClearance_r(GEOSContextHandle_t handle,
577  const GEOSGeometry* g,
578  double* distance);
579 
580 extern GEOSGeometry GEOS_DLL *GEOSDifference_r(GEOSContextHandle_t handle,
581  const GEOSGeometry* g1,
582  const GEOSGeometry* g2);
583 extern GEOSGeometry GEOS_DLL *GEOSSymDifference_r(GEOSContextHandle_t handle,
584  const GEOSGeometry* g1,
585  const GEOSGeometry* g2);
586 extern GEOSGeometry GEOS_DLL *GEOSBoundary_r(GEOSContextHandle_t handle,
587  const GEOSGeometry* g);
588 extern GEOSGeometry GEOS_DLL *GEOSUnion_r(GEOSContextHandle_t handle,
589  const GEOSGeometry* g1,
590  const GEOSGeometry* g2);
591 extern GEOSGeometry GEOS_DLL *GEOSUnaryUnion_r(GEOSContextHandle_t handle,
592  const GEOSGeometry* g);
593 /* GEOSCoverageUnion is an optimized union algorithm for polygonal inputs that are correctly
594  * noded and do not overlap. It will not generate an error (return NULL) for inputs that
595  * do not satisfy this constraint. */
596 extern GEOSGeometry GEOS_DLL *GEOSCoverageUnion_r(GEOSContextHandle_t handle,
597  const GEOSGeometry* g);
598 /* @deprecated in 3.3.0: use GEOSUnaryUnion_r instead */
599 extern GEOSGeometry GEOS_DLL *GEOSUnionCascaded_r(GEOSContextHandle_t handle,
600  const GEOSGeometry* g);
601 extern GEOSGeometry GEOS_DLL *GEOSPointOnSurface_r(GEOSContextHandle_t handle,
602  const GEOSGeometry* g);
603 extern GEOSGeometry GEOS_DLL *GEOSGetCentroid_r(GEOSContextHandle_t handle,
604  const GEOSGeometry* g);
605 extern GEOSGeometry GEOS_DLL *GEOSMinimumBoundingCircle_r(GEOSContextHandle_t handle,
606  const GEOSGeometry* g, double* radius,
607  GEOSGeometry** center);
608 extern GEOSGeometry GEOS_DLL *GEOSNode_r(GEOSContextHandle_t handle,
609  const GEOSGeometry* g);
610 /* Fast, non-robust intersection between an arbitrary geometry and
611  * a rectangle. The returned geometry may be invalid. */
612 extern GEOSGeometry GEOS_DLL *GEOSClipByRect_r(GEOSContextHandle_t handle,
613  const GEOSGeometry* g,
614  double xmin, double ymin,
615  double xmax, double ymax);
616 
617 /*
618  * all arguments remain ownership of the caller
619  * (both Geometries and pointers)
620  */
621 /*
622  * Polygonizes a set of Geometries which contain linework that
623  * represents the edges of a planar graph.
624  *
625  * All types of Geometry are accepted as input; the constituent
626  * linework is extracted as the edges to be polygonized.
627  *
628  * The edges must be correctly noded; that is, they must only meet
629  * at their endpoints. Polygonization will accept incorrectly noded
630  * input but will not form polygons from non-noded edges, and reports
631  * them as errors.
632  *
633  * The Polygonizer reports the follow kinds of errors:
634  *
635  * - Dangles - edges which have one or both ends which are
636  * not incident on another edge endpoint
637  * - Cut Edges - edges which are connected at both ends but
638  * which do not form part of a polygon
639  * - Invalid Ring Lines - edges which form rings which are invalid
640  * (e.g. the component lines contain a self-intersection)
641  *
642  * Errors are reported to output parameters "cuts", "dangles" and
643  * "invalid" (if not-null). Formed polygons are returned as a
644  * collection. NULL is returned on exception. All returned
645  * geometries must be destroyed by caller.
646  *
647  * The GEOSPolygonize_valid_r variant allows extracting only polygons
648  * which form a valid polygonal result. The set of extracted polygons
649  * is guaranteed to be edge-disjoint. This is useful when it is known
650  * that the input lines form a valid polygonal geometry (which may
651  * include holes or nested polygons).
652  */
653 
654 extern GEOSGeometry GEOS_DLL *GEOSPolygonize_r(GEOSContextHandle_t handle,
655  const GEOSGeometry *const geoms[],
656  unsigned int ngeoms);
657 extern GEOSGeometry GEOS_DLL *GEOSPolygonize_valid_r(GEOSContextHandle_t handle,
658  const GEOSGeometry *const geoms[],
659  unsigned int ngems);
660 extern GEOSGeometry GEOS_DLL *GEOSPolygonizer_getCutEdges_r(
661  GEOSContextHandle_t handle,
662  const GEOSGeometry * const geoms[],
663  unsigned int ngeoms);
664 extern GEOSGeometry GEOS_DLL *GEOSPolygonize_full_r(GEOSContextHandle_t handle,
665  const GEOSGeometry* input, GEOSGeometry** cuts,
666  GEOSGeometry** dangles, GEOSGeometry** invalidRings);
667 
668 extern GEOSGeometry GEOS_DLL *GEOSBuildArea_r(
669  GEOSContextHandle_t handle,
670  const GEOSGeometry* g);
671 
672 extern GEOSGeometry GEOS_DLL *GEOSLineMerge_r(GEOSContextHandle_t handle,
673  const GEOSGeometry* g);
674 extern GEOSGeometry GEOS_DLL *GEOSReverse_r(GEOSContextHandle_t handle,
675  const GEOSGeometry* g);
676 extern GEOSGeometry GEOS_DLL *GEOSSimplify_r(GEOSContextHandle_t handle,
677  const GEOSGeometry* g,
678  double tolerance);
679 extern GEOSGeometry GEOS_DLL *GEOSTopologyPreserveSimplify_r(
680  GEOSContextHandle_t handle,
681  const GEOSGeometry* g, double tolerance);
682 
683 /*
684  * Return all distinct vertices of input geometry as a MULTIPOINT.
685  * Note that only 2 dimensions of the vertices are considered when
686  * testing for equality.
687  */
688 extern GEOSGeometry GEOS_DLL *GEOSGeom_extractUniquePoints_r(
689  GEOSContextHandle_t handle,
690  const GEOSGeometry* g);
691 
692 /*
693  * Find paths shared between the two given lineal geometries.
694  *
695  * Returns a GEOMETRYCOLLECTION having two elements:
696  * - first element is a MULTILINESTRING containing shared paths
697  * having the _same_ direction on both inputs
698  * - second element is a MULTILINESTRING containing shared paths
699  * having the _opposite_ direction on the two inputs
700  *
701  * Returns NULL on exception
702  */
703 extern GEOSGeometry GEOS_DLL *GEOSSharedPaths_r(GEOSContextHandle_t handle,
704  const GEOSGeometry* g1, const GEOSGeometry* g2);
705 
706 /*
707  * Snap first geometry on to second with given tolerance
708  * Returns a newly allocated geometry, or NULL on exception
709  */
710 extern GEOSGeometry GEOS_DLL *GEOSSnap_r(GEOSContextHandle_t handle,
711  const GEOSGeometry* g1, const GEOSGeometry* g2, double tolerance);
712 
713 /*
714  * Return a Delaunay triangulation of the vertex of the given geometry
715  *
716  * @param g the input geometry whose vertex will be used as "sites"
717  * @param tolerance optional snapping tolerance to use for improved robustness
718  * @param onlyEdges if non-zero will return a MULTILINESTRING, otherwise it will
719  * return a GEOMETRYCOLLECTION containing triangular POLYGONs.
720  *
721  * @return a newly allocated geometry, or NULL on exception
722  */
723 extern GEOSGeometry GEOS_DLL * GEOSDelaunayTriangulation_r(
724  GEOSContextHandle_t handle,
725  const GEOSGeometry *g,
726  double tolerance,
727  int onlyEdges);
728 
729 /*
730  * Returns the Voronoi polygons of a set of Vertices given as input
731  *
732  * @param g the input geometry whose vertex will be used as sites.
733  * @param tolerance snapping tolerance to use for improved robustness
734  * @param onlyEdges whether to return only edges of the Voronoi cells
735  * @param env clipping envelope for the returned diagram, automatically
736  * determined if NULL.
737  * The diagram will be clipped to the larger
738  * of this envelope or an envelope surrounding the sites.
739  *
740  * @return a newly allocated geometry, or NULL on exception.
741  */
742 extern GEOSGeometry GEOS_DLL * GEOSVoronoiDiagram_r(
743  GEOSContextHandle_t extHandle,
744  const GEOSGeometry *g,
745  const GEOSGeometry *env,
746  double tolerance,
747  int onlyEdges);
748 
749 /*
750  * Computes the coordinate where two line segments intersect, if any
751  *
752  * @param ax0 x-coordinate of first point in first segment
753  * @param ay0 y-coordinate of first point in first segment
754  * @param ax1 x-coordinate of second point in first segment
755  * @param ay1 y-coordinate of second point in first segment
756  * @param bx0 x-coordinate of first point in second segment
757  * @param by0 y-coordinate of first point in second segment
758  * @param bx1 x-coordinate of second point in second segment
759  * @param by1 y-coordinate of second point in second segment
760  * @param cx x-coordinate of intersection point
761  * @param cy y-coordinate of intersection point
762  *
763  * @return 0 on error, 1 on success, -1 if segments do not intersect
764  */
765 
766 extern int GEOS_DLL GEOSSegmentIntersection_r(
767  GEOSContextHandle_t extHandle,
768  double ax0, double ay0,
769  double ax1, double ay1,
770  double bx0, double by0,
771  double bx1, double by1,
772  double* cx, double* cy);
773 
774 /************************************************************************
775  *
776  * Binary predicates - return 2 on exception, 1 on true, 0 on false
777  *
778  ***********************************************************************/
779 
780 extern char GEOS_DLL GEOSDisjoint_r(GEOSContextHandle_t handle,
781  const GEOSGeometry* g1,
782  const GEOSGeometry* g2);
783 extern char GEOS_DLL GEOSTouches_r(GEOSContextHandle_t handle,
784  const GEOSGeometry* g1,
785  const GEOSGeometry* g2);
786 extern char GEOS_DLL GEOSIntersects_r(GEOSContextHandle_t handle,
787  const GEOSGeometry* g1,
788  const GEOSGeometry* g2);
789 extern char GEOS_DLL GEOSCrosses_r(GEOSContextHandle_t handle,
790  const GEOSGeometry* g1,
791  const GEOSGeometry* g2);
792 extern char GEOS_DLL GEOSWithin_r(GEOSContextHandle_t handle,
793  const GEOSGeometry* g1,
794  const GEOSGeometry* g2);
795 extern char GEOS_DLL GEOSContains_r(GEOSContextHandle_t handle,
796  const GEOSGeometry* g1,
797  const GEOSGeometry* g2);
798 extern char GEOS_DLL GEOSOverlaps_r(GEOSContextHandle_t handle,
799  const GEOSGeometry* g1,
800  const GEOSGeometry* g2);
801 extern char GEOS_DLL GEOSEquals_r(GEOSContextHandle_t handle,
802  const GEOSGeometry* g1,
803  const GEOSGeometry* g2);
804 extern char GEOS_DLL GEOSEqualsExact_r(GEOSContextHandle_t handle,
805  const GEOSGeometry* g1,
806  const GEOSGeometry* g2,
807  double tolerance);
808 extern char GEOS_DLL GEOSCovers_r(GEOSContextHandle_t handle,
809  const GEOSGeometry* g1,
810  const GEOSGeometry* g2);
811 extern char GEOS_DLL GEOSCoveredBy_r(GEOSContextHandle_t handle,
812  const GEOSGeometry* g1,
813  const GEOSGeometry* g2);
814 
815 /************************************************************************
816  *
817  * Prepared Geometry Binary predicates - return 2 on exception, 1 on true, 0 on false
818  *
819  ***********************************************************************/
820 
821 /*
822  * GEOSGeometry ownership is retained by caller
823  */
824 extern const GEOSPreparedGeometry GEOS_DLL *GEOSPrepare_r(
825  GEOSContextHandle_t handle,
826  const GEOSGeometry* g);
827 
828 extern void GEOS_DLL GEOSPreparedGeom_destroy_r(GEOSContextHandle_t handle,
829  const GEOSPreparedGeometry* g);
830 
831 extern char GEOS_DLL GEOSPreparedContains_r(GEOSContextHandle_t handle,
832  const GEOSPreparedGeometry* pg1,
833  const GEOSGeometry* g2);
834 extern char GEOS_DLL GEOSPreparedContainsProperly_r(GEOSContextHandle_t handle,
835  const GEOSPreparedGeometry* pg1,
836  const GEOSGeometry* g2);
837 extern char GEOS_DLL GEOSPreparedCoveredBy_r(GEOSContextHandle_t handle,
838  const GEOSPreparedGeometry* pg1,
839  const GEOSGeometry* g2);
840 extern char GEOS_DLL GEOSPreparedCovers_r(GEOSContextHandle_t handle,
841  const GEOSPreparedGeometry* pg1,
842  const GEOSGeometry* g2);
843 extern char GEOS_DLL GEOSPreparedCrosses_r(GEOSContextHandle_t handle,
844  const GEOSPreparedGeometry* pg1,
845  const GEOSGeometry* g2);
846 extern char GEOS_DLL GEOSPreparedDisjoint_r(GEOSContextHandle_t handle,
847  const GEOSPreparedGeometry* pg1,
848  const GEOSGeometry* g2);
849 extern char GEOS_DLL GEOSPreparedIntersects_r(GEOSContextHandle_t handle,
850  const GEOSPreparedGeometry* pg1,
851  const GEOSGeometry* g2);
852 extern char GEOS_DLL GEOSPreparedOverlaps_r(GEOSContextHandle_t handle,
853  const GEOSPreparedGeometry* pg1,
854  const GEOSGeometry* g2);
855 extern char GEOS_DLL GEOSPreparedTouches_r(GEOSContextHandle_t handle,
856  const GEOSPreparedGeometry* pg1,
857  const GEOSGeometry* g2);
858 extern char GEOS_DLL GEOSPreparedWithin_r(GEOSContextHandle_t handle,
859  const GEOSPreparedGeometry* pg1,
860  const GEOSGeometry* g2);
861 
862 /************************************************************************
863  *
864  * STRtree functions
865  *
866  ***********************************************************************/
867 
868 /*
869  * GEOSGeometry ownership is retained by caller
870  */
871 
872 extern GEOSSTRtree GEOS_DLL *GEOSSTRtree_create_r(
873  GEOSContextHandle_t handle,
874  size_t nodeCapacity);
875 extern void GEOS_DLL GEOSSTRtree_insert_r(GEOSContextHandle_t handle,
876  GEOSSTRtree *tree,
877  const GEOSGeometry *g,
878  void *item);
879 extern void GEOS_DLL GEOSSTRtree_query_r(GEOSContextHandle_t handle,
880  GEOSSTRtree *tree,
881  const GEOSGeometry *g,
882  GEOSQueryCallback callback,
883  void *userdata);
884 
885 extern const GEOSGeometry GEOS_DLL *GEOSSTRtree_nearest_r(GEOSContextHandle_t handle,
886  GEOSSTRtree *tree,
887  const GEOSGeometry* geom);
888 
889 
890 extern const void GEOS_DLL *GEOSSTRtree_nearest_generic_r(GEOSContextHandle_t handle,
891  GEOSSTRtree *tree,
892  const void* item,
893  const GEOSGeometry* itemEnvelope,
894  GEOSDistanceCallback distancefn,
895  void* userdata);
896 
897 extern void GEOS_DLL GEOSSTRtree_iterate_r(GEOSContextHandle_t handle,
898  GEOSSTRtree *tree,
899  GEOSQueryCallback callback,
900  void *userdata);
901 extern char GEOS_DLL GEOSSTRtree_remove_r(GEOSContextHandle_t handle,
902  GEOSSTRtree *tree,
903  const GEOSGeometry *g,
904  void *item);
905 extern void GEOS_DLL GEOSSTRtree_destroy_r(GEOSContextHandle_t handle,
906  GEOSSTRtree *tree);
907 
908 
909 /************************************************************************
910  *
911  * Unary predicate - return 2 on exception, 1 on true, 0 on false
912  *
913  ***********************************************************************/
914 
915 extern char GEOS_DLL GEOSisEmpty_r(GEOSContextHandle_t handle,
916  const GEOSGeometry* g);
917 extern char GEOS_DLL GEOSisSimple_r(GEOSContextHandle_t handle,
918  const GEOSGeometry* g);
919 extern char GEOS_DLL GEOSisRing_r(GEOSContextHandle_t handle,
920  const GEOSGeometry* g);
921 extern char GEOS_DLL GEOSHasZ_r(GEOSContextHandle_t handle,
922  const GEOSGeometry* g);
923 extern char GEOS_DLL GEOSisClosed_r(GEOSContextHandle_t handle,
924  const GEOSGeometry *g);
925 
926 /************************************************************************
927  *
928  * Dimensionally Extended 9 Intersection Model related
929  *
930  ***********************************************************************/
931 
932 /* These are for use with GEOSRelateBoundaryNodeRule (flags param) */
933 enum GEOSRelateBoundaryNodeRules {
934  /* MOD2 and OGC are the same rule, and is the default
935  * used by GEOSRelatePattern
936  */
937  GEOSRELATE_BNR_MOD2=1,
938  GEOSRELATE_BNR_OGC=1,
939  GEOSRELATE_BNR_ENDPOINT=2,
940  GEOSRELATE_BNR_MULTIVALENT_ENDPOINT=3,
941  GEOSRELATE_BNR_MONOVALENT_ENDPOINT=4
942 };
943 
944 /* return 2 on exception, 1 on true, 0 on false */
945 extern char GEOS_DLL GEOSRelatePattern_r(GEOSContextHandle_t handle,
946  const GEOSGeometry* g1,
947  const GEOSGeometry* g2,
948  const char *pat);
949 
950 /* return NULL on exception, a string to GEOSFree otherwise */
951 extern char GEOS_DLL *GEOSRelate_r(GEOSContextHandle_t handle,
952  const GEOSGeometry* g1,
953  const GEOSGeometry* g2);
954 
955 /* return 2 on exception, 1 on true, 0 on false */
956 extern char GEOS_DLL GEOSRelatePatternMatch_r(GEOSContextHandle_t handle,
957  const char *mat,
958  const char *pat);
959 
960 /* return NULL on exception, a string to GEOSFree otherwise */
961 extern char GEOS_DLL *GEOSRelateBoundaryNodeRule_r(GEOSContextHandle_t handle,
962  const GEOSGeometry* g1,
963  const GEOSGeometry* g2,
964  int bnr);
965 
966 /************************************************************************
967  *
968  * Validity checking
969  *
970  ***********************************************************************/
971 
972 /* These are for use with GEOSisValidDetail (flags param) */
973 enum GEOSValidFlags {
974  GEOSVALID_ALLOW_SELFTOUCHING_RING_FORMING_HOLE=1
975 };
976 
977 /* return 2 on exception, 1 on true, 0 on false */
978 extern char GEOS_DLL GEOSisValid_r(GEOSContextHandle_t handle,
979  const GEOSGeometry* g);
980 
981 /* return NULL on exception, a string to GEOSFree otherwise */
982 extern char GEOS_DLL *GEOSisValidReason_r(GEOSContextHandle_t handle,
983  const GEOSGeometry* g);
984 
985 /*
986  * Caller has the responsibility to destroy 'reason' (GEOSFree)
987  * and 'location' (GEOSGeom_destroy) params
988  * return 2 on exception, 1 when valid, 0 when invalid
989  */
990 extern char GEOS_DLL GEOSisValidDetail_r(GEOSContextHandle_t handle,
991  const GEOSGeometry* g,
992  int flags,
993  char** reason,
994  GEOSGeometry** location);
995 
996 extern GEOSGeometry GEOS_DLL *GEOSMakeValid_r(GEOSContextHandle_t handle,
997  const GEOSGeometry* g);
998 
999 /************************************************************************
1000  *
1001  * Geometry info
1002  *
1003  ***********************************************************************/
1004 
1005 /* Return NULL on exception, result must be freed by caller. */
1006 extern char GEOS_DLL *GEOSGeomType_r(GEOSContextHandle_t handle,
1007  const GEOSGeometry* g);
1008 
1009 /* Return -1 on exception */
1010 extern int GEOS_DLL GEOSGeomTypeId_r(GEOSContextHandle_t handle,
1011  const GEOSGeometry* g);
1012 
1013 /* Return 0 on exception */
1014 extern int GEOS_DLL GEOSGetSRID_r(GEOSContextHandle_t handle,
1015  const GEOSGeometry* g);
1016 
1017 extern void GEOS_DLL GEOSSetSRID_r(GEOSContextHandle_t handle,
1018  GEOSGeometry* g, int SRID);
1019 
1020 extern void GEOS_DLL *GEOSGeom_getUserData_r(GEOSContextHandle_t handle,
1021 const GEOSGeometry* g);
1022 
1023 extern void GEOS_DLL GEOSGeom_setUserData_r(GEOSContextHandle_t handle,
1024  GEOSGeometry* g, void* userData);
1025 
1026 /* May be called on all geometries in GEOS 3.x, returns -1 on error and 1
1027  * for non-multi geometries. Older GEOS versions only accept
1028  * GeometryCollections or Multi* geometries here, and are likely to crash
1029  * when fed simple geometries, so beware if you need compatibility with
1030  * old GEOS versions.
1031  */
1032 extern int GEOS_DLL GEOSGetNumGeometries_r(GEOSContextHandle_t handle,
1033  const GEOSGeometry* g);
1034 
1035 /*
1036  * Return NULL on exception.
1037  * Returned object is a pointer to internal storage:
1038  * it must NOT be destroyed directly.
1039  * Up to GEOS 3.2.0 the input geometry must be a Collection, in
1040  * later version it doesn't matter (getGeometryN(0) for a single will
1041  * return the input).
1042  */
1043 extern const GEOSGeometry GEOS_DLL *GEOSGetGeometryN_r(
1044  GEOSContextHandle_t handle,
1045  const GEOSGeometry* g, int n);
1046 
1047 /* Return -1 on exception */
1048 extern int GEOS_DLL GEOSNormalize_r(GEOSContextHandle_t handle,
1049  GEOSGeometry* g);
1050 
1053 #define GEOS_PREC_NO_TOPO (1<<0)
1054 
1057 #define GEOS_PREC_KEEP_COLLAPSED (1<<1)
1058 
1074 extern GEOSGeometry GEOS_DLL *GEOSGeom_setPrecision_r(
1075  GEOSContextHandle_t handle,
1076  const GEOSGeometry *g,
1077  double gridSize, int flags);
1078 
1085 extern double GEOS_DLL GEOSGeom_getPrecision_r(
1086  GEOSContextHandle_t handle,
1087  const GEOSGeometry *g);
1088 
1089 /* Return -1 on exception */
1090 extern int GEOS_DLL GEOSGetNumInteriorRings_r(GEOSContextHandle_t handle,
1091  const GEOSGeometry* g);
1092 
1093 /* Return -1 on exception, Geometry must be a LineString. */
1094 extern int GEOS_DLL GEOSGeomGetNumPoints_r(GEOSContextHandle_t handle,
1095  const GEOSGeometry* g);
1096 
1097 /* Return 0 on exception, otherwise 1, Geometry must be a Point. */
1098 extern int GEOS_DLL GEOSGeomGetX_r(GEOSContextHandle_t handle, const GEOSGeometry *g, double *x);
1099 extern int GEOS_DLL GEOSGeomGetY_r(GEOSContextHandle_t handle, const GEOSGeometry *g, double *y);
1100 extern int GEOS_DLL GEOSGeomGetZ_r(GEOSContextHandle_t handle, const GEOSGeometry *g, double *z);
1101 
1102 /*
1103  * Return NULL on exception, Geometry must be a Polygon.
1104  * Returned object is a pointer to internal storage:
1105  * it must NOT be destroyed directly.
1106  */
1107 extern const GEOSGeometry GEOS_DLL *GEOSGetInteriorRingN_r(
1108  GEOSContextHandle_t handle,
1109  const GEOSGeometry* g, int n);
1110 
1111 /*
1112  * Return NULL on exception, Geometry must be a Polygon.
1113  * Returned object is a pointer to internal storage:
1114  * it must NOT be destroyed directly.
1115  */
1116 extern const GEOSGeometry GEOS_DLL *GEOSGetExteriorRing_r(
1117  GEOSContextHandle_t handle,
1118  const GEOSGeometry* g);
1119 
1120 /* Return -1 on exception */
1121 extern int GEOS_DLL GEOSGetNumCoordinates_r(GEOSContextHandle_t handle,
1122  const GEOSGeometry* g);
1123 
1124 /*
1125  * Return NULL on exception.
1126  * Geometry must be a LineString, LinearRing or Point.
1127  */
1128 extern const GEOSCoordSequence GEOS_DLL *GEOSGeom_getCoordSeq_r(
1129  GEOSContextHandle_t handle,
1130  const GEOSGeometry* g);
1131 
1132 /*
1133  * Return 0 on exception (or empty geometry)
1134  */
1135 extern int GEOS_DLL GEOSGeom_getDimensions_r(GEOSContextHandle_t handle,
1136  const GEOSGeometry* g);
1137 
1138 /*
1139  * Return 2 or 3.
1140  */
1141 extern int GEOS_DLL GEOSGeom_getCoordinateDimension_r(GEOSContextHandle_t handle,
1142  const GEOSGeometry* g);
1143 /*
1144  * Return 0 on exception
1145  */
1146 extern int GEOS_DLL GEOSGeom_getXMin_r(GEOSContextHandle_t handle, const GEOSGeometry* g, double* value);
1147 extern int GEOS_DLL GEOSGeom_getYMin_r(GEOSContextHandle_t handle, const GEOSGeometry* g, double* value);
1148 extern int GEOS_DLL GEOSGeom_getXMax_r(GEOSContextHandle_t handle, const GEOSGeometry* g, double* value);
1149 extern int GEOS_DLL GEOSGeom_getYMax_r(GEOSContextHandle_t handle, const GEOSGeometry* g, double* value);
1150 
1151 /*
1152  * Return NULL on exception.
1153  * Must be LineString and must be freed by called.
1154  */
1155 extern GEOSGeometry GEOS_DLL *GEOSGeomGetPointN_r(GEOSContextHandle_t handle, const GEOSGeometry *g, int n);
1156 extern GEOSGeometry GEOS_DLL *GEOSGeomGetStartPoint_r(GEOSContextHandle_t handle, const GEOSGeometry *g);
1157 extern GEOSGeometry GEOS_DLL *GEOSGeomGetEndPoint_r(GEOSContextHandle_t handle, const GEOSGeometry *g);
1158 
1159 /************************************************************************
1160  *
1161  * Misc functions
1162  *
1163  ***********************************************************************/
1164 
1165 /* Return 0 on exception, 1 otherwise */
1166 extern int GEOS_DLL GEOSArea_r(GEOSContextHandle_t handle,
1167  const GEOSGeometry* g, double *area);
1168 extern int GEOS_DLL GEOSLength_r(GEOSContextHandle_t handle,
1169  const GEOSGeometry* g, double *length);
1170 extern int GEOS_DLL GEOSDistance_r(GEOSContextHandle_t handle,
1171  const GEOSGeometry* g1,
1172  const GEOSGeometry* g2, double *dist);
1173 extern int GEOS_DLL GEOSDistanceIndexed_r(GEOSContextHandle_t handle,
1174  const GEOSGeometry* g1,
1175  const GEOSGeometry* g2, double *dist);
1176 extern int GEOS_DLL GEOSHausdorffDistance_r(GEOSContextHandle_t handle,
1177  const GEOSGeometry *g1,
1178  const GEOSGeometry *g2,
1179  double *dist);
1180 extern int GEOS_DLL GEOSHausdorffDistanceDensify_r(GEOSContextHandle_t handle,
1181  const GEOSGeometry *g1,
1182  const GEOSGeometry *g2,
1183  double densifyFrac, double *dist);
1184 extern int GEOS_DLL GEOSFrechetDistance_r(GEOSContextHandle_t handle,
1185  const GEOSGeometry *g1,
1186  const GEOSGeometry *g2,
1187  double *dist);
1188 extern int GEOS_DLL GEOSFrechetDistanceDensify_r(GEOSContextHandle_t handle,
1189  const GEOSGeometry *g1,
1190  const GEOSGeometry *g2,
1191  double densifyFrac, double *dist);
1192 extern int GEOS_DLL GEOSGeomGetLength_r(GEOSContextHandle_t handle,
1193  const GEOSGeometry *g, double *length);
1194 
1195 /* Return 0 on exception, the closest points of the two geometries otherwise.
1196  * The first point comes from g1 geometry and the second point comes from g2.
1197  */
1198 extern GEOSCoordSequence GEOS_DLL *GEOSNearestPoints_r(
1199  GEOSContextHandle_t handle, const GEOSGeometry* g1, const GEOSGeometry* g2);
1200 
1201 
1202 /************************************************************************
1203  *
1204  * Algorithms
1205  *
1206  ***********************************************************************/
1207 
1208 /* Walking from A to B:
1209  * return -1 if reaching P takes a counter-clockwise (left) turn
1210  * return 1 if reaching P takes a clockwise (right) turn
1211  * return 0 if P is collinear with A-B
1212  *
1213  * On exceptions, return 2.
1214  *
1215  */
1216 extern int GEOS_DLL GEOSOrientationIndex_r(GEOSContextHandle_t handle,
1217  double Ax, double Ay, double Bx, double By, double Px, double Py);
1218 
1219 
1220 /************************************************************************
1221  *
1222  * Reader and Writer APIs
1223  *
1224  ***********************************************************************/
1225 
1226 typedef struct GEOSWKTReader_t GEOSWKTReader;
1227 typedef struct GEOSWKTWriter_t GEOSWKTWriter;
1228 typedef struct GEOSWKBReader_t GEOSWKBReader;
1229 typedef struct GEOSWKBWriter_t GEOSWKBWriter;
1230 
1231 
1232 /* WKT Reader */
1233 extern GEOSWKTReader GEOS_DLL *GEOSWKTReader_create_r(
1234  GEOSContextHandle_t handle);
1235 extern void GEOS_DLL GEOSWKTReader_destroy_r(GEOSContextHandle_t handle,
1236  GEOSWKTReader* reader);
1237 extern GEOSGeometry GEOS_DLL *GEOSWKTReader_read_r(GEOSContextHandle_t handle,
1238  GEOSWKTReader* reader,
1239  const char *wkt);
1240 
1241 /* WKT Writer */
1242 extern GEOSWKTWriter GEOS_DLL *GEOSWKTWriter_create_r(
1243  GEOSContextHandle_t handle);
1244 extern void GEOS_DLL GEOSWKTWriter_destroy_r(GEOSContextHandle_t handle,
1245  GEOSWKTWriter* writer);
1246 extern char GEOS_DLL *GEOSWKTWriter_write_r(GEOSContextHandle_t handle,
1247  GEOSWKTWriter* writer,
1248  const GEOSGeometry* g);
1249 extern void GEOS_DLL GEOSWKTWriter_setTrim_r(GEOSContextHandle_t handle,
1250  GEOSWKTWriter *writer,
1251  char trim);
1252 extern void GEOS_DLL GEOSWKTWriter_setRoundingPrecision_r(GEOSContextHandle_t handle,
1253  GEOSWKTWriter *writer,
1254  int precision);
1255 extern void GEOS_DLL GEOSWKTWriter_setOutputDimension_r(GEOSContextHandle_t handle,
1256  GEOSWKTWriter *writer,
1257  int dim);
1258 extern int GEOS_DLL GEOSWKTWriter_getOutputDimension_r(GEOSContextHandle_t handle,
1259  GEOSWKTWriter *writer);
1260 extern void GEOS_DLL GEOSWKTWriter_setOld3D_r(GEOSContextHandle_t handle,
1261  GEOSWKTWriter *writer,
1262  int useOld3D);
1263 
1264 /* WKB Reader */
1265 extern GEOSWKBReader GEOS_DLL *GEOSWKBReader_create_r(
1266  GEOSContextHandle_t handle);
1267 extern void GEOS_DLL GEOSWKBReader_destroy_r(GEOSContextHandle_t handle,
1268  GEOSWKBReader* reader);
1269 extern GEOSGeometry GEOS_DLL *GEOSWKBReader_read_r(GEOSContextHandle_t handle,
1270  GEOSWKBReader* reader,
1271  const unsigned char *wkb,
1272  size_t size);
1273 extern GEOSGeometry GEOS_DLL *GEOSWKBReader_readHEX_r(
1274  GEOSContextHandle_t handle,
1275  GEOSWKBReader* reader,
1276  const unsigned char *hex,
1277  size_t size);
1278 
1279 /* WKB Writer */
1280 extern GEOSWKBWriter GEOS_DLL *GEOSWKBWriter_create_r(
1281  GEOSContextHandle_t handle);
1282 extern void GEOS_DLL GEOSWKBWriter_destroy_r(GEOSContextHandle_t handle,
1283  GEOSWKBWriter* writer);
1284 
1285 /* The caller owns the results for these two methods! */
1286 extern unsigned char GEOS_DLL *GEOSWKBWriter_write_r(
1287  GEOSContextHandle_t handle,
1288  GEOSWKBWriter* writer,
1289  const GEOSGeometry* g,
1290  size_t *size);
1291 extern unsigned char GEOS_DLL *GEOSWKBWriter_writeHEX_r(
1292  GEOSContextHandle_t handle,
1293  GEOSWKBWriter* writer,
1294  const GEOSGeometry* g,
1295  size_t *size);
1296 
1297 /*
1298  * Specify whether output WKB should be 2d or 3d.
1299  * Return previously set number of dimensions.
1300  */
1301 extern int GEOS_DLL GEOSWKBWriter_getOutputDimension_r(
1302  GEOSContextHandle_t handle,
1303  const GEOSWKBWriter* writer);
1304 extern void GEOS_DLL GEOSWKBWriter_setOutputDimension_r(
1305  GEOSContextHandle_t handle,
1306  GEOSWKBWriter* writer, int newDimension);
1307 
1308 /*
1309  * Specify whether the WKB byte order is big or little endian.
1310  * The return value is the previous byte order.
1311  */
1312 extern int GEOS_DLL GEOSWKBWriter_getByteOrder_r(GEOSContextHandle_t handle,
1313  const GEOSWKBWriter* writer);
1314 extern void GEOS_DLL GEOSWKBWriter_setByteOrder_r(GEOSContextHandle_t handle,
1315  GEOSWKBWriter* writer,
1316  int byteOrder);
1317 
1318 /*
1319  * Specify whether SRID values should be output.
1320  */
1321 extern char GEOS_DLL GEOSWKBWriter_getIncludeSRID_r(GEOSContextHandle_t handle,
1322  const GEOSWKBWriter* writer);
1323 extern void GEOS_DLL GEOSWKBWriter_setIncludeSRID_r(GEOSContextHandle_t handle,
1324  GEOSWKBWriter* writer, const char writeSRID);
1325 
1326 
1327 /*
1328  * Free buffers returned by stuff like GEOSWKBWriter_write(),
1329  * GEOSWKBWriter_writeHEX() and GEOSWKTWriter_write().
1330  */
1331 extern void GEOS_DLL GEOSFree_r(GEOSContextHandle_t handle, void *buffer);
1332 
1333 
1334 /* External code to GEOS can define GEOS_USE_ONLY_R_API to avoid the */
1335 /* non _r API to be available */
1336 #ifndef GEOS_USE_ONLY_R_API
1337 
1338 /************************************************************************
1339  *
1340  * Initialization, cleanup, version
1341  *
1342  ***********************************************************************/
1343 
1344 extern void GEOS_DLL initGEOS(GEOSMessageHandler notice_function,
1345  GEOSMessageHandler error_function);
1346 extern void GEOS_DLL finishGEOS(void);
1347 
1348 /************************************************************************
1349  *
1350  * NOTE - These functions are DEPRECATED. Please use the new Reader and
1351  * writer APIS!
1352  *
1353  ***********************************************************************/
1354 
1355 extern GEOSGeometry GEOS_DLL *GEOSGeomFromWKT(const char *wkt);
1356 extern char GEOS_DLL *GEOSGeomToWKT(const GEOSGeometry* g);
1357 
1358 /*
1359  * Specify whether output WKB should be 2d or 3d.
1360  * Return previously set number of dimensions.
1361  */
1362 extern int GEOS_DLL GEOS_getWKBOutputDims();
1363 extern int GEOS_DLL GEOS_setWKBOutputDims(int newDims);
1364 
1365 /*
1366  * Specify whether the WKB byte order is big or little endian.
1367  * The return value is the previous byte order.
1368  */
1369 extern int GEOS_DLL GEOS_getWKBByteOrder();
1370 extern int GEOS_DLL GEOS_setWKBByteOrder(int byteOrder);
1371 
1372 extern GEOSGeometry GEOS_DLL *GEOSGeomFromWKB_buf(const unsigned char *wkb, size_t size);
1373 extern unsigned char GEOS_DLL *GEOSGeomToWKB_buf(const GEOSGeometry* g, size_t *size);
1374 
1375 extern GEOSGeometry GEOS_DLL *GEOSGeomFromHEX_buf(const unsigned char *hex, size_t size);
1376 extern unsigned char GEOS_DLL *GEOSGeomToHEX_buf(const GEOSGeometry* g, size_t *size);
1377 
1378 /************************************************************************
1379  *
1380  * Coordinate Sequence functions
1381  *
1382  ***********************************************************************/
1383 
1384 /*
1385  * Create a Coordinate sequence with ``size'' coordinates
1386  * of ``dims'' dimensions.
1387  * Return NULL on exception.
1388  */
1389 extern GEOSCoordSequence GEOS_DLL *GEOSCoordSeq_create(unsigned int size, unsigned int dims);
1390 
1391 /*
1392  * Clone a Coordinate Sequence.
1393  * Return NULL on exception.
1394  */
1395 extern GEOSCoordSequence GEOS_DLL *GEOSCoordSeq_clone(const GEOSCoordSequence* s);
1396 
1397 /*
1398  * Destroy a Coordinate Sequence.
1399  */
1400 extern void GEOS_DLL GEOSCoordSeq_destroy(GEOSCoordSequence* s);
1401 
1402 /*
1403  * Set ordinate values in a Coordinate Sequence.
1404  * Return 0 on exception.
1405  */
1406 extern int GEOS_DLL GEOSCoordSeq_setX(GEOSCoordSequence* s,
1407  unsigned int idx, double val);
1408 extern int GEOS_DLL GEOSCoordSeq_setY(GEOSCoordSequence* s,
1409  unsigned int idx, double val);
1410 extern int GEOS_DLL GEOSCoordSeq_setZ(GEOSCoordSequence* s,
1411  unsigned int idx, double val);
1412 extern int GEOS_DLL GEOSCoordSeq_setXY(GEOSCoordSequence* s,
1413  unsigned int idx, double x, double y);
1414 extern int GEOS_DLL GEOSCoordSeq_setXYZ(GEOSCoordSequence* s,
1415  unsigned int idx, double x, double y, double z);
1416 extern int GEOS_DLL GEOSCoordSeq_setOrdinate(GEOSCoordSequence* s,
1417  unsigned int idx, unsigned int dim, double val);
1418 
1419 /*
1420  * Get ordinate values from a Coordinate Sequence.
1421  * Return 0 on exception.
1422  */
1423 extern int GEOS_DLL GEOSCoordSeq_getX(const GEOSCoordSequence* s,
1424  unsigned int idx, double *val);
1425 extern int GEOS_DLL GEOSCoordSeq_getY(const GEOSCoordSequence* s,
1426  unsigned int idx, double *val);
1427 extern int GEOS_DLL GEOSCoordSeq_getZ(const GEOSCoordSequence* s,
1428  unsigned int idx, double *val);
1429 extern int GEOS_DLL GEOSCoordSeq_getXY(const GEOSCoordSequence* s,
1430  unsigned int idx, double *x, double *y);
1431 extern int GEOS_DLL GEOSCoordSeq_getXYZ(const GEOSCoordSequence* s,
1432  unsigned int idx, double *x, double *y, double *z);
1433 extern int GEOS_DLL GEOSCoordSeq_getOrdinate(const GEOSCoordSequence* s,
1434  unsigned int idx, unsigned int dim, double *val);
1435 /*
1436  * Get size and dimensions info from a Coordinate Sequence.
1437  * Return 0 on exception.
1438  */
1439 extern int GEOS_DLL GEOSCoordSeq_getSize(const GEOSCoordSequence* s,
1440  unsigned int *size);
1441 extern int GEOS_DLL GEOSCoordSeq_getDimensions(const GEOSCoordSequence* s,
1442  unsigned int *dims);
1443 
1444 /*
1445  * Check orientation of a CoordinateSequence and set 'is_ccw' to 1
1446  * if it has counter-clockwise orientation, 0 otherwise.
1447  * Return 0 on exception, 1 on success.
1448  */
1449 extern int GEOS_DLL GEOSCoordSeq_isCCW(const GEOSCoordSequence* s, char* is_ccw);
1450 
1451 /************************************************************************
1452  *
1453  * Linear referencing functions -- there are more, but these are
1454  * probably sufficient for most purposes
1455  *
1456  ***********************************************************************/
1457 
1458 /*
1459  * GEOSGeometry ownership is retained by caller
1460  */
1461 
1462 
1463 /* Return distance of point 'p' projected on 'g' from origin
1464  * of 'g'. Geometry 'g' must be a lineal geometry */
1465 extern double GEOS_DLL GEOSProject(const GEOSGeometry *g,
1466  const GEOSGeometry* p);
1467 
1468 /* Return closest point to given distance within geometry
1469  * Geometry must be a LineString */
1470 extern GEOSGeometry GEOS_DLL *GEOSInterpolate(const GEOSGeometry *g,
1471  double d);
1472 
1473 extern double GEOS_DLL GEOSProjectNormalized(const GEOSGeometry *g,
1474  const GEOSGeometry* p);
1475 
1476 extern GEOSGeometry GEOS_DLL *GEOSInterpolateNormalized(const GEOSGeometry *g,
1477  double d);
1478 
1479 /************************************************************************
1480  *
1481  * Buffer related functions
1482  *
1483  ***********************************************************************/
1484 
1485 
1486 /* @return NULL on exception */
1487 extern GEOSGeometry GEOS_DLL *GEOSBuffer(const GEOSGeometry* g,
1488  double width, int quadsegs);
1489 
1490 /* @return 0 on exception */
1491 extern GEOSBufferParams GEOS_DLL *GEOSBufferParams_create();
1492 extern void GEOS_DLL GEOSBufferParams_destroy(GEOSBufferParams* parms);
1493 
1494 /* @return 0 on exception */
1495 extern int GEOS_DLL GEOSBufferParams_setEndCapStyle(
1496  GEOSBufferParams* p,
1497  int style);
1498 
1499 /* @return 0 on exception */
1500 extern int GEOS_DLL GEOSBufferParams_setJoinStyle(
1501  GEOSBufferParams* p,
1502  int joinStyle);
1503 
1504 /* @return 0 on exception */
1505 extern int GEOS_DLL GEOSBufferParams_setMitreLimit(
1506  GEOSBufferParams* p,
1507  double mitreLimit);
1508 
1509 /* @return 0 on exception */
1510 extern int GEOS_DLL GEOSBufferParams_setQuadrantSegments(
1511  GEOSBufferParams* p,
1512  int quadSegs);
1513 
1514 /* @param singleSided: 1 for single sided, 0 otherwise */
1515 /* @return 0 on exception */
1516 extern int GEOS_DLL GEOSBufferParams_setSingleSided(
1517  GEOSBufferParams* p,
1518  int singleSided);
1519 
1520 /* @return NULL on exception */
1521 extern GEOSGeometry GEOS_DLL *GEOSBufferWithParams(
1522  const GEOSGeometry* g,
1523  const GEOSBufferParams* p,
1524  double width);
1525 
1526 /* These functions return NULL on exception. */
1527 extern GEOSGeometry GEOS_DLL *GEOSBufferWithStyle(const GEOSGeometry* g,
1528  double width, int quadsegs, int endCapStyle, int joinStyle,
1529  double mitreLimit);
1530 
1531 /* These functions return NULL on exception. Only LINESTRINGs are accepted. */
1532 /* @deprecated in 3.3.0: use GEOSOffsetCurve instead */
1533 extern GEOSGeometry GEOS_DLL *GEOSSingleSidedBuffer(const GEOSGeometry* g,
1534  double width, int quadsegs, int joinStyle, double mitreLimit,
1535  int leftSide);
1536 
1537 /*
1538  * Only LINESTRINGs are accepted.
1539  * @param width : offset distance.
1540  * negative for right side offset.
1541  * positive for left side offset.
1542  * @return NULL on exception
1543  */
1544 extern GEOSGeometry GEOS_DLL *GEOSOffsetCurve(const GEOSGeometry* g,
1545  double width, int quadsegs, int joinStyle, double mitreLimit);
1546 
1547 /************************************************************************
1548  *
1549  * Geometry Constructors.
1550  * GEOSCoordSequence* arguments will become ownership of the returned object.
1551  * All functions return NULL on exception.
1552  *
1553  ***********************************************************************/
1554 
1555 extern GEOSGeometry GEOS_DLL *GEOSGeom_createPoint(GEOSCoordSequence* s);
1556 extern GEOSGeometry GEOS_DLL *GEOSGeom_createPointFromXY(double x, double y);
1557 extern GEOSGeometry GEOS_DLL *GEOSGeom_createEmptyPoint();
1558 extern GEOSGeometry GEOS_DLL *GEOSGeom_createLinearRing(GEOSCoordSequence* s);
1559 extern GEOSGeometry GEOS_DLL *GEOSGeom_createLineString(GEOSCoordSequence* s);
1560 extern GEOSGeometry GEOS_DLL *GEOSGeom_createEmptyLineString();
1561 
1562 /*
1563  * Second argument is an array of GEOSGeometry* objects.
1564  * The caller remains owner of the array, but pointed-to
1565  * objects become ownership of the returned GEOSGeometry.
1566  */
1567 extern GEOSGeometry GEOS_DLL *GEOSGeom_createEmptyPolygon();
1568 extern GEOSGeometry GEOS_DLL *GEOSGeom_createPolygon(GEOSGeometry* shell,
1569  GEOSGeometry** holes, unsigned int nholes);
1570 extern GEOSGeometry GEOS_DLL *GEOSGeom_createCollection(int type,
1571  GEOSGeometry* *geoms, unsigned int ngeoms);
1572 extern GEOSGeometry GEOS_DLL *GEOSGeom_createEmptyCollection(int type);
1573 
1574 extern GEOSGeometry GEOS_DLL *GEOSGeom_clone(const GEOSGeometry* g);
1575 
1576 /************************************************************************
1577  *
1578  * Memory management
1579  *
1580  ***********************************************************************/
1581 
1582 extern void GEOS_DLL GEOSGeom_destroy(GEOSGeometry* g);
1583 
1584 /************************************************************************
1585  *
1586  * Topology operations - return NULL on exception.
1587  *
1588  ***********************************************************************/
1589 
1590 extern GEOSGeometry GEOS_DLL *GEOSEnvelope(const GEOSGeometry* g);
1591 extern GEOSGeometry GEOS_DLL *GEOSIntersection(const GEOSGeometry* g1, const GEOSGeometry* g2);
1592 extern GEOSGeometry GEOS_DLL *GEOSConvexHull(const GEOSGeometry* g);
1593 
1594 /* Returns the minimum rotated rectangular POLYGON which encloses the input geometry. The rectangle
1595  * has width equal to the minimum diameter, and a longer length. If the convex hill of the input is
1596  * degenerate (a line or point) a LINESTRING or POINT is returned. The minimum rotated rectangle can
1597  * be used as an extremely generalized representation for the given geometry.
1598  */
1599 extern GEOSGeometry GEOS_DLL *GEOSMinimumRotatedRectangle(const GEOSGeometry* g);
1600 
1601 /* Returns a LINESTRING geometry which represents the minimum diameter of the geometry.
1602  * The minimum diameter is defined to be the width of the smallest band that
1603  * contains the geometry, where a band is a strip of the plane defined
1604  * by two parallel lines. This can be thought of as the smallest hole that the geometry
1605  * can be moved through, with a single rotation.
1606  */
1607 extern GEOSGeometry GEOS_DLL *GEOSMinimumWidth(const GEOSGeometry* g);
1608 
1609 /* Computes the minimum clearance of a geometry. The minimum clearance is the smallest amount by which
1610  * a vertex could be move to produce an invalid polygon, a non-simple linestring, or a multipoint with
1611  * repeated points. If a geometry has a minimum clearance of 'eps', it can be said that:
1612  *
1613  * - No two distinct vertices in the geometry are separated by less than 'eps'
1614  * - No vertex is closer than 'eps' to a line segment of which it is not an endpoint.
1615  *
1616  * If the minimum clearance cannot be defined for a geometry (such as with a single point, or a multipoint
1617  * whose points are identical, a value of Infinity will be calculated.
1618  *
1619  * @param g the input geometry
1620  * @param d a double to which the result can be stored
1621  *
1622  * @return 0 if no exception occurred
1623  * 2 if an exception occurred
1624  */
1625 extern int GEOS_DLL GEOSMinimumClearance(const GEOSGeometry* g, double* d);
1626 
1627 /* Returns a LineString whose endpoints define the minimum clearance of a geometry.
1628  * If the geometry has no minimum clearance, an empty LineString will be returned.
1629  *
1630  * @param g the input geometry
1631  * @return a LineString, or NULL if an exception occurred.
1632  */
1633 extern GEOSGeometry GEOS_DLL *GEOSMinimumClearanceLine(const GEOSGeometry* g);
1634 
1635 extern GEOSGeometry GEOS_DLL *GEOSDifference(const GEOSGeometry* g1, const GEOSGeometry* g2);
1636 extern GEOSGeometry GEOS_DLL *GEOSSymDifference(const GEOSGeometry* g1, const GEOSGeometry* g2);
1637 extern GEOSGeometry GEOS_DLL *GEOSBoundary(const GEOSGeometry* g);
1638 extern GEOSGeometry GEOS_DLL *GEOSUnion(const GEOSGeometry* g1, const GEOSGeometry* g2);
1639 extern GEOSGeometry GEOS_DLL *GEOSUnaryUnion(const GEOSGeometry* g);
1640 
1641 /* GEOSCoverageUnion is an optimized union algorithm for polygonal inputs that are correctly
1642  * noded and do not overlap. It will not generate an error (return NULL) for inputs that
1643  * do not satisfy this constraint. */
1644 extern GEOSGeometry GEOS_DLL *GEOSCoverageUnion(const GEOSGeometry *g);
1645 
1646 /* @deprecated in 3.3.0: use GEOSUnaryUnion instead */
1647 extern GEOSGeometry GEOS_DLL *GEOSUnionCascaded(const GEOSGeometry* g);
1648 
1649 extern GEOSGeometry GEOS_DLL *GEOSPointOnSurface(const GEOSGeometry* g);
1650 extern GEOSGeometry GEOS_DLL *GEOSGetCentroid(const GEOSGeometry* g);
1651 extern GEOSGeometry GEOS_DLL *GEOSMinimumBoundingCircle(const GEOSGeometry* g, double* radius, GEOSGeometry** center);
1652 extern GEOSGeometry GEOS_DLL *GEOSNode(const GEOSGeometry* g);
1653 extern GEOSGeometry GEOS_DLL *GEOSClipByRect(const GEOSGeometry* g, double xmin, double ymin, double xmax, double ymax);
1654 
1655 /*
1656  * all arguments remain ownership of the caller
1657  * (both Geometries and pointers)
1658  */
1659 extern GEOSGeometry GEOS_DLL *GEOSPolygonize(const GEOSGeometry * const geoms[], unsigned int ngeoms);
1660 extern GEOSGeometry GEOS_DLL *GEOSPolygonize_valid(const GEOSGeometry * const geoms[], unsigned int ngeoms);
1661 extern GEOSGeometry GEOS_DLL *GEOSPolygonizer_getCutEdges(const GEOSGeometry * const geoms[], unsigned int ngeoms);
1662 extern GEOSGeometry GEOS_DLL *GEOSPolygonize_full(const GEOSGeometry* input,
1663  GEOSGeometry** cuts, GEOSGeometry** dangles, GEOSGeometry** invalid);
1664 
1665 extern GEOSGeometry GEOS_DLL *GEOSBuildArea(const GEOSGeometry* g);
1666 
1667 extern GEOSGeometry GEOS_DLL *GEOSLineMerge(const GEOSGeometry* g);
1668 extern GEOSGeometry GEOS_DLL *GEOSReverse(const GEOSGeometry* g);
1669 extern GEOSGeometry GEOS_DLL *GEOSSimplify(const GEOSGeometry* g, double tolerance);
1670 extern GEOSGeometry GEOS_DLL *GEOSTopologyPreserveSimplify(const GEOSGeometry* g,
1671  double tolerance);
1672 
1673 /*
1674  * Return all distinct vertices of input geometry as a MULTIPOINT.
1675  * Note that only 2 dimensions of the vertices are considered when
1676  * testing for equality.
1677  */
1678 extern GEOSGeometry GEOS_DLL *GEOSGeom_extractUniquePoints(
1679  const GEOSGeometry* g);
1680 
1681 /*
1682  * Find paths shared between the two given lineal geometries.
1683  *
1684  * Returns a GEOMETRYCOLLECTION having two elements:
1685  * - first element is a MULTILINESTRING containing shared paths
1686  * having the _same_ direction on both inputs
1687  * - second element is a MULTILINESTRING containing shared paths
1688  * having the _opposite_ direction on the two inputs
1689  *
1690  * Returns NULL on exception
1691  */
1692 extern GEOSGeometry GEOS_DLL *GEOSSharedPaths(const GEOSGeometry* g1,
1693  const GEOSGeometry* g2);
1694 
1695 /*
1696  * Snap first geometry on to second with given tolerance
1697  * Returns a newly allocated geometry, or NULL on exception
1698  */
1699 extern GEOSGeometry GEOS_DLL *GEOSSnap(const GEOSGeometry* g1,
1700  const GEOSGeometry* g2, double tolerance);
1701 
1702 /*
1703  * Return a Delaunay triangulation of the vertex of the given geometry
1704  *
1705  * @param g the input geometry whose vertex will be used as "sites"
1706  * @param tolerance optional snapping tolerance to use for improved robustness
1707  * @param onlyEdges if non-zero will return a MULTILINESTRING, otherwise it will
1708  * return a GEOMETRYCOLLECTION containing triangular POLYGONs.
1709  *
1710  * @return a newly allocated geometry, or NULL on exception
1711  */
1712 extern GEOSGeometry GEOS_DLL * GEOSDelaunayTriangulation(
1713  const GEOSGeometry *g,
1714  double tolerance,
1715  int onlyEdges);
1716 
1717 /*
1718  * Returns the Voronoi polygons of a set of Vertices given as input
1719  *
1720  * @param g the input geometry whose vertex will be used as sites.
1721  * @param tolerance snapping tolerance to use for improved robustness
1722  * @param onlyEdges whether to return only edges of the voronoi cells
1723  * @param env clipping envelope for the returned diagram, automatically
1724  * determined if NULL.
1725  * The diagram will be clipped to the larger
1726  * of this envelope or an envelope surrounding the sites.
1727  *
1728  * @return a newly allocated geometry, or NULL on exception.
1729  */
1730 extern GEOSGeometry GEOS_DLL * GEOSVoronoiDiagram(
1731  const GEOSGeometry *g,
1732  const GEOSGeometry *env,
1733  double tolerance,
1734  int onlyEdges);
1735 /*
1736  * Computes the coordinate where two line segments intersect, if any
1737  *
1738  * @param ax0 x-coordinate of first point in first segment
1739  * @param ay0 y-coordinate of first point in first segment
1740  * @param ax1 x-coordinate of second point in first segment
1741  * @param ay1 y-coordinate of second point in first segment
1742  * @param bx0 x-coordinate of first point in second segment
1743  * @param by0 y-coordinate of first point in second segment
1744  * @param bx1 x-coordinate of second point in second segment
1745  * @param by1 y-coordinate of second point in second segment
1746  * @param cx x-coordinate of intersection point
1747  * @param cy y-coordinate of intersection point
1748  *
1749  * @return 0 on error, 1 on success, -1 if segments do not intersect
1750  */
1751 
1752 extern int GEOS_DLL GEOSSegmentIntersection(
1753  double ax0, double ay0,
1754  double ax1, double ay1,
1755  double bx0, double by0,
1756  double bx1, double by1,
1757  double* cx, double* cy);
1758 
1759 /************************************************************************
1760  *
1761  * Binary predicates - return 2 on exception, 1 on true, 0 on false
1762  *
1763  ***********************************************************************/
1764 
1765 extern char GEOS_DLL GEOSDisjoint(const GEOSGeometry* g1, const GEOSGeometry* g2);
1766 extern char GEOS_DLL GEOSTouches(const GEOSGeometry* g1, const GEOSGeometry* g2);
1767 extern char GEOS_DLL GEOSIntersects(const GEOSGeometry* g1, const GEOSGeometry* g2);
1768 extern char GEOS_DLL GEOSCrosses(const GEOSGeometry* g1, const GEOSGeometry* g2);
1769 extern char GEOS_DLL GEOSWithin(const GEOSGeometry* g1, const GEOSGeometry* g2);
1770 extern char GEOS_DLL GEOSContains(const GEOSGeometry* g1, const GEOSGeometry* g2);
1771 extern char GEOS_DLL GEOSOverlaps(const GEOSGeometry* g1, const GEOSGeometry* g2);
1772 extern char GEOS_DLL GEOSEquals(const GEOSGeometry* g1, const GEOSGeometry* g2);
1773 extern char GEOS_DLL GEOSCovers(const GEOSGeometry* g1, const GEOSGeometry* g2);
1774 extern char GEOS_DLL GEOSCoveredBy(const GEOSGeometry* g1, const GEOSGeometry* g2);
1775 
1784 extern char GEOS_DLL GEOSEqualsExact(const GEOSGeometry* g1, const GEOSGeometry* g2, double tolerance);
1785 
1786 /************************************************************************
1787  *
1788  * Prepared Geometry Binary predicates - return 2 on exception, 1 on true, 0 on false
1789  *
1790  ***********************************************************************/
1791 
1792 /*
1793  * GEOSGeometry ownership is retained by caller
1794  */
1795 extern const GEOSPreparedGeometry GEOS_DLL *GEOSPrepare(const GEOSGeometry* g);
1796 
1797 extern void GEOS_DLL GEOSPreparedGeom_destroy(const GEOSPreparedGeometry* g);
1798 
1799 extern char GEOS_DLL GEOSPreparedContains(const GEOSPreparedGeometry* pg1, const GEOSGeometry* g2);
1800 extern char GEOS_DLL GEOSPreparedContainsProperly(const GEOSPreparedGeometry* pg1, const GEOSGeometry* g2);
1801 extern char GEOS_DLL GEOSPreparedCoveredBy(const GEOSPreparedGeometry* pg1, const GEOSGeometry* g2);
1802 extern char GEOS_DLL GEOSPreparedCovers(const GEOSPreparedGeometry* pg1, const GEOSGeometry* g2);
1803 extern char GEOS_DLL GEOSPreparedCrosses(const GEOSPreparedGeometry* pg1, const GEOSGeometry* g2);
1804 extern char GEOS_DLL GEOSPreparedDisjoint(const GEOSPreparedGeometry* pg1, const GEOSGeometry* g2);
1805 extern char GEOS_DLL GEOSPreparedIntersects(const GEOSPreparedGeometry* pg1, const GEOSGeometry* g2);
1806 extern char GEOS_DLL GEOSPreparedOverlaps(const GEOSPreparedGeometry* pg1, const GEOSGeometry* g2);
1807 extern char GEOS_DLL GEOSPreparedTouches(const GEOSPreparedGeometry* pg1, const GEOSGeometry* g2);
1808 extern char GEOS_DLL GEOSPreparedWithin(const GEOSPreparedGeometry* pg1, const GEOSGeometry* g2);
1809 
1810 /************************************************************************
1811  *
1812  * STRtree functions
1813  *
1814  ***********************************************************************/
1815 
1816 /*
1817  * GEOSGeometry ownership is retained by caller
1818  */
1819 
1820 /*
1821  * Create a new R-tree using the Sort-Tile-Recursive algorithm (STRtree) for two-dimensional
1822  * spatial data.
1823  *
1824  * @param nodeCapacity the maximum number of child nodes that a node may have. The minimum
1825  * recommended capacity value is 4. If unsure, use a default node capacity of 10.
1826  * @return a pointer to the created tree
1827  */
1828 extern GEOSSTRtree GEOS_DLL *GEOSSTRtree_create(size_t nodeCapacity);
1829 
1830 /*
1831  * Insert an item into an STRtree
1832  *
1833  * @param tree the STRtree in which the item should be inserted
1834  * @param g a GEOSGeometry whose envelope corresponds to the extent of 'item'
1835  * @param item the item to insert into the tree
1836  */
1837 extern void GEOS_DLL GEOSSTRtree_insert(GEOSSTRtree *tree,
1838  const GEOSGeometry *g,
1839  void *item);
1840 
1841 /*
1842  * Query an STRtree for items intersecting a specified envelope
1843  *
1844  * @param tree the STRtree to search
1845  * @param g a GEOSGeomety from which a query envelope will be extracted
1846  * @param callback a function to be executed for each item in the tree whose envelope intersects
1847  * the envelope of 'g'. The callback function should take two parameters: a void
1848  * pointer representing the located item in the tree, and a void userdata pointer.
1849  * @param userdata an optional pointer to pe passed to 'callback' as an argument
1850  */
1851 extern void GEOS_DLL GEOSSTRtree_query(GEOSSTRtree *tree,
1852  const GEOSGeometry *g,
1853  GEOSQueryCallback callback,
1854  void *userdata);
1855 /*
1856  * Returns the nearest item in the STRtree to the supplied GEOSGeometry.
1857  * All items in the tree MUST be of type GEOSGeometry. If this is not the case, use
1858  * GEOSSTRtree_nearest_generic instead.
1859 *
1860  * @param tree the STRtree to search
1861  * @param geom the geometry with which the tree should be queried
1862  * @return a const pointer to the nearest GEOSGeometry in the tree to 'geom', or NULL in
1863  * case of exception
1864  */
1865 extern const GEOSGeometry GEOS_DLL *GEOSSTRtree_nearest(GEOSSTRtree *tree, const GEOSGeometry* geom);
1866 
1867 /*
1868  * Returns the nearest item in the STRtree to the supplied item
1869  *
1870  * @param tree the STRtree to search
1871  * @param item the item with which the tree should be queried
1872  * @param itemEnvelope a GEOSGeometry having the bounding box of 'item'
1873  * @param distancefn a function that can compute the distance between two items
1874  * in the STRtree. The function should return zero in case of error,
1875  * and should store the computed distance to the location pointed to by
1876  * the 'distance' argument. The computed distance between two items
1877  * must not exceed the Cartesian distance between their envelopes.
1878  * @param userdata optional pointer to arbitrary data; will be passed to distancefn
1879  * each time it is called.
1880  * @return a const pointer to the nearest item in the tree to 'item', or NULL in
1881  * case of exception
1882  */
1883 extern const void GEOS_DLL *GEOSSTRtree_nearest_generic(GEOSSTRtree *tree,
1884  const void* item,
1885  const GEOSGeometry* itemEnvelope,
1886  GEOSDistanceCallback distancefn,
1887  void* userdata);
1888 /*
1889  * Iterates over all items in the STRtree
1890  *
1891  * @param tree the STRtree over which to iterate
1892  * @param callback a function to be executed for each item in the tree.
1893  */
1894 extern void GEOS_DLL GEOSSTRtree_iterate(GEOSSTRtree *tree,
1895  GEOSQueryCallback callback,
1896  void *userdata);
1897 
1898 /*
1899  * Removes an item from the STRtree
1900  *
1901  * @param tree the STRtree from which to remove an item
1902  * @param g the envelope of the item to remove
1903  * @param the item to remove
1904  * @return 0 if the item was not removed;
1905  * 1 if the item was removed;
1906  * 2 if an exception occurred
1907  */
1908 extern char GEOS_DLL GEOSSTRtree_remove(GEOSSTRtree *tree,
1909  const GEOSGeometry *g,
1910  void *item);
1911 extern void GEOS_DLL GEOSSTRtree_destroy(GEOSSTRtree *tree);
1912 
1913 
1914 /************************************************************************
1915  *
1916  * Unary predicate - return 2 on exception, 1 on true, 0 on false
1917  *
1918  ***********************************************************************/
1919 
1920 extern char GEOS_DLL GEOSisEmpty(const GEOSGeometry* g);
1921 extern char GEOS_DLL GEOSisSimple(const GEOSGeometry* g);
1922 extern char GEOS_DLL GEOSisRing(const GEOSGeometry* g);
1923 extern char GEOS_DLL GEOSHasZ(const GEOSGeometry* g);
1924 extern char GEOS_DLL GEOSisClosed(const GEOSGeometry *g);
1925 
1926 /************************************************************************
1927  *
1928  * Dimensionally Extended 9 Intersection Model related
1929  *
1930  ***********************************************************************/
1931 
1932 /* return 2 on exception, 1 on true, 0 on false */
1933 extern char GEOS_DLL GEOSRelatePattern(const GEOSGeometry* g1, const GEOSGeometry* g2, const char *pat);
1934 
1935 /* return NULL on exception, a string to GEOSFree otherwise */
1936 extern char GEOS_DLL *GEOSRelate(const GEOSGeometry* g1, const GEOSGeometry* g2);
1937 
1938 /* return 2 on exception, 1 on true, 0 on false */
1939 extern char GEOS_DLL GEOSRelatePatternMatch(const char *mat, const char *pat);
1940 
1941 /* return NULL on exception, a string to GEOSFree otherwise */
1942 extern char GEOS_DLL *GEOSRelateBoundaryNodeRule(const GEOSGeometry* g1,
1943  const GEOSGeometry* g2,
1944  int bnr);
1945 
1946 /************************************************************************
1947  *
1948  * Validity checking
1949  *
1950  ***********************************************************************/
1951 
1952 /* return 2 on exception, 1 on true, 0 on false */
1953 extern char GEOS_DLL GEOSisValid(const GEOSGeometry* g);
1954 
1955 /* return NULL on exception, a string to GEOSFree otherwise */
1956 extern char GEOS_DLL *GEOSisValidReason(const GEOSGeometry *g);
1957 /*
1958  * Caller has the responsibility to destroy 'reason' (GEOSFree)
1959  * and 'location' (GEOSGeom_destroy) params
1960  * return 2 on exception, 1 when valid, 0 when invalid
1961  * Use enum GEOSValidFlags values for the flags param.
1962  */
1963 extern char GEOS_DLL GEOSisValidDetail(const GEOSGeometry* g,
1964  int flags,
1965  char** reason, GEOSGeometry** location);
1966 
1967 extern GEOSGeometry GEOS_DLL *GEOSMakeValid(const GEOSGeometry* g);
1968 
1969 /************************************************************************
1970  *
1971  * Geometry info
1972  *
1973  ***********************************************************************/
1974 
1975 /* Return NULL on exception, result must be freed by caller. */
1976 extern char GEOS_DLL *GEOSGeomType(const GEOSGeometry* g);
1977 
1978 /* Return -1 on exception */
1979 extern int GEOS_DLL GEOSGeomTypeId(const GEOSGeometry* g);
1980 
1981 /* Return 0 on exception */
1982 extern int GEOS_DLL GEOSGetSRID(const GEOSGeometry* g);
1983 
1984 extern void GEOS_DLL GEOSSetSRID(GEOSGeometry* g, int SRID);
1985 
1986 extern void GEOS_DLL *GEOSGeom_getUserData(const GEOSGeometry* g);
1987 
1988 extern void GEOS_DLL GEOSGeom_setUserData(GEOSGeometry* g, void* userData);
1989 
1990 
1991 /* May be called on all geometries in GEOS 3.x, returns -1 on error and 1
1992  * for non-multi geometries. Older GEOS versions only accept
1993  * GeometryCollections or Multi* geometries here, and are likely to crash
1994  * when fed simple geometries, so beware if you need compatibility with
1995  * old GEOS versions.
1996  */
1997 extern int GEOS_DLL GEOSGetNumGeometries(const GEOSGeometry* g);
1998 
1999 /*
2000  * Return NULL on exception.
2001  * Returned object is a pointer to internal storage:
2002  * it must NOT be destroyed directly.
2003  * Up to GEOS 3.2.0 the input geometry must be a Collection, in
2004  * later version it doesn't matter (getGeometryN(0) for a single will
2005  * return the input).
2006  */
2007 extern const GEOSGeometry GEOS_DLL *GEOSGetGeometryN(const GEOSGeometry* g, int n);
2008 
2009 /* Return -1 on exception */
2010 extern int GEOS_DLL GEOSNormalize(GEOSGeometry* g);
2011 
2012 /* Return NULL on exception */
2013 extern GEOSGeometry GEOS_DLL *GEOSGeom_setPrecision(
2014  const GEOSGeometry *g, double gridSize, int flags);
2015 
2016 /* Return -1 on exception */
2017 extern double GEOS_DLL GEOSGeom_getPrecision(const GEOSGeometry *g);
2018 
2019 /* Return -1 on exception */
2020 extern int GEOS_DLL GEOSGetNumInteriorRings(const GEOSGeometry* g);
2021 
2022 /* Return -1 on exception, Geometry must be a LineString. */
2023 extern int GEOS_DLL GEOSGeomGetNumPoints(const GEOSGeometry* g);
2024 
2025 /* Return 0 on exception, otherwise 1, Geometry must be a Point. */
2026 extern int GEOS_DLL GEOSGeomGetX(const GEOSGeometry *g, double *x);
2027 extern int GEOS_DLL GEOSGeomGetY(const GEOSGeometry *g, double *y);
2028 extern int GEOS_DLL GEOSGeomGetZ(const GEOSGeometry *g, double *z);
2029 
2030 /*
2031  * Return NULL on exception, Geometry must be a Polygon.
2032  * Returned object is a pointer to internal storage:
2033  * it must NOT be destroyed directly.
2034  */
2035 extern const GEOSGeometry GEOS_DLL *GEOSGetInteriorRingN(const GEOSGeometry* g, int n);
2036 
2037 /*
2038  * Return NULL on exception, Geometry must be a Polygon.
2039  * Returned object is a pointer to internal storage:
2040  * it must NOT be destroyed directly.
2041  */
2042 extern const GEOSGeometry GEOS_DLL *GEOSGetExteriorRing(const GEOSGeometry* g);
2043 
2044 /* Return -1 on exception */
2045 extern int GEOS_DLL GEOSGetNumCoordinates(const GEOSGeometry* g);
2046 
2047 /*
2048  * Return NULL on exception.
2049  * Geometry must be a LineString, LinearRing or Point.
2050  */
2051 extern const GEOSCoordSequence GEOS_DLL *GEOSGeom_getCoordSeq(const GEOSGeometry* g);
2052 
2053 /*
2054  * Return 0 on exception (or empty geometry)
2055  */
2056 extern int GEOS_DLL GEOSGeom_getDimensions(const GEOSGeometry* g);
2057 
2058 /*
2059  * Return 2 or 3.
2060  */
2061 extern int GEOS_DLL GEOSGeom_getCoordinateDimension(const GEOSGeometry* g);
2062 
2063 /*
2064  * Return 0 on exception
2065  */
2066 extern int GEOS_DLL GEOSGeom_getXMin(const GEOSGeometry* g, double* value);
2067 extern int GEOS_DLL GEOSGeom_getYMin(const GEOSGeometry* g, double* value);
2068 extern int GEOS_DLL GEOSGeom_getXMax(const GEOSGeometry* g, double* value);
2069 extern int GEOS_DLL GEOSGeom_getYMax(const GEOSGeometry* g, double* value);
2070 
2071 /*
2072  * Return NULL on exception.
2073  * Must be LineString and must be freed by called.
2074  */
2075 extern GEOSGeometry GEOS_DLL *GEOSGeomGetPointN(const GEOSGeometry *g, int n);
2076 extern GEOSGeometry GEOS_DLL *GEOSGeomGetStartPoint(const GEOSGeometry *g);
2077 extern GEOSGeometry GEOS_DLL *GEOSGeomGetEndPoint(const GEOSGeometry *g);
2078 
2079 /************************************************************************
2080  *
2081  * Misc functions
2082  *
2083  ***********************************************************************/
2084 
2085 /* Return 0 on exception, 1 otherwise */
2086 extern int GEOS_DLL GEOSArea(const GEOSGeometry* g, double *area);
2087 extern int GEOS_DLL GEOSLength(const GEOSGeometry* g, double *length);
2088 extern int GEOS_DLL GEOSDistance(const GEOSGeometry* g1, const GEOSGeometry* g2,
2089  double *dist);
2090 extern int GEOS_DLL GEOSDistanceIndexed(const GEOSGeometry* g1, const GEOSGeometry* g2,
2091  double *dist);
2092 extern int GEOS_DLL GEOSHausdorffDistance(const GEOSGeometry *g1,
2093  const GEOSGeometry *g2, double *dist);
2094 extern int GEOS_DLL GEOSHausdorffDistanceDensify(const GEOSGeometry *g1,
2095  const GEOSGeometry *g2, double densifyFrac, double *dist);
2096 extern int GEOS_DLL GEOSFrechetDistance(const GEOSGeometry *g1,
2097  const GEOSGeometry *g2, double *dist);
2098 extern int GEOS_DLL GEOSFrechetDistanceDensify(const GEOSGeometry *g1,
2099  const GEOSGeometry *g2, double densifyFrac, double *dist);
2100 extern int GEOS_DLL GEOSGeomGetLength(const GEOSGeometry *g, double *length);
2101 
2102 /* Return 0 on exception, the closest points of the two geometries otherwise.
2103  * The first point comes from g1 geometry and the second point comes from g2.
2104  */
2105 extern GEOSCoordSequence GEOS_DLL *GEOSNearestPoints(
2106  const GEOSGeometry* g1, const GEOSGeometry* g2);
2107 
2108 
2109 /************************************************************************
2110  *
2111  * Algorithms
2112  *
2113  ***********************************************************************/
2114 
2115 /* Walking from A to B:
2116  * return -1 if reaching P takes a counter-clockwise (left) turn
2117  * return 1 if reaching P takes a clockwise (right) turn
2118  * return 0 if P is collinear with A-B
2119  *
2120  * On exceptions, return 2.
2121  *
2122  */
2123 extern int GEOS_DLL GEOSOrientationIndex(double Ax, double Ay, double Bx, double By,
2124  double Px, double Py);
2125 
2126 /************************************************************************
2127  *
2128  * Reader and Writer APIs
2129  *
2130  ***********************************************************************/
2131 
2132 /* WKT Reader */
2133 extern GEOSWKTReader GEOS_DLL *GEOSWKTReader_create();
2134 extern void GEOS_DLL GEOSWKTReader_destroy(GEOSWKTReader* reader);
2135 extern GEOSGeometry GEOS_DLL *GEOSWKTReader_read(GEOSWKTReader* reader, const char *wkt);
2136 
2137 /* WKT Writer */
2138 extern GEOSWKTWriter GEOS_DLL *GEOSWKTWriter_create();
2139 extern void GEOS_DLL GEOSWKTWriter_destroy(GEOSWKTWriter* writer);
2140 extern char GEOS_DLL *GEOSWKTWriter_write(GEOSWKTWriter* writer, const GEOSGeometry* g);
2141 extern void GEOS_DLL GEOSWKTWriter_setTrim(GEOSWKTWriter *writer, char trim);
2142 extern void GEOS_DLL GEOSWKTWriter_setRoundingPrecision(GEOSWKTWriter *writer, int precision);
2143 extern void GEOS_DLL GEOSWKTWriter_setOutputDimension(GEOSWKTWriter *writer, int dim);
2144 extern int GEOS_DLL GEOSWKTWriter_getOutputDimension(GEOSWKTWriter *writer);
2145 extern void GEOS_DLL GEOSWKTWriter_setOld3D(GEOSWKTWriter *writer, int useOld3D);
2146 
2147 /* WKB Reader */
2148 extern GEOSWKBReader GEOS_DLL *GEOSWKBReader_create();
2149 extern void GEOS_DLL GEOSWKBReader_destroy(GEOSWKBReader* reader);
2150 extern GEOSGeometry GEOS_DLL *GEOSWKBReader_read(GEOSWKBReader* reader, const unsigned char *wkb, size_t size);
2151 extern GEOSGeometry GEOS_DLL *GEOSWKBReader_readHEX(GEOSWKBReader* reader, const unsigned char *hex, size_t size);
2152 
2153 /* WKB Writer */
2154 extern GEOSWKBWriter GEOS_DLL *GEOSWKBWriter_create();
2155 extern void GEOS_DLL GEOSWKBWriter_destroy(GEOSWKBWriter* writer);
2156 
2157 /* The caller owns the results for these two methods! */
2158 extern unsigned char GEOS_DLL *GEOSWKBWriter_write(GEOSWKBWriter* writer, const GEOSGeometry* g, size_t *size);
2159 extern unsigned char GEOS_DLL *GEOSWKBWriter_writeHEX(GEOSWKBWriter* writer, const GEOSGeometry* g, size_t *size);
2160 
2161 /*
2162  * Specify whether output WKB should be 2d or 3d.
2163  * Return previously set number of dimensions.
2164  */
2165 extern int GEOS_DLL GEOSWKBWriter_getOutputDimension(const GEOSWKBWriter* writer);
2166 extern void GEOS_DLL GEOSWKBWriter_setOutputDimension(GEOSWKBWriter* writer, int newDimension);
2167 
2168 /*
2169  * Specify whether the WKB byte order is big or little endian.
2170  * The return value is the previous byte order.
2171  */
2172 extern int GEOS_DLL GEOSWKBWriter_getByteOrder(const GEOSWKBWriter* writer);
2173 extern void GEOS_DLL GEOSWKBWriter_setByteOrder(GEOSWKBWriter* writer, int byteOrder);
2174 
2175 /*
2176  * Specify whether SRID values should be output.
2177  */
2178 extern char GEOS_DLL GEOSWKBWriter_getIncludeSRID(const GEOSWKBWriter* writer);
2179 extern void GEOS_DLL GEOSWKBWriter_setIncludeSRID(GEOSWKBWriter* writer, const char writeSRID);
2180 
2181 /*
2182  * Free buffers returned by stuff like GEOSWKBWriter_write(),
2183  * GEOSWKBWriter_writeHEX() and GEOSWKTWriter_write().
2184  */
2185 extern void GEOS_DLL GEOSFree(void *buffer);
2186 
2187 #endif /* #ifndef GEOS_USE_ONLY_R_API */
2188 
2189 
2190 #ifdef __cplusplus
2191 } // extern "C"
2192 #endif
2193 
2194 #endif /* #ifndef GEOS_C_H_INCLUDED */
a linestring
Definition: Geometry.h:79
a collection of heterogeneus geometries
Definition: Geometry.h:91
a collection of linestrings
Definition: Geometry.h:87
a collection of points
Definition: Geometry.h:85
a polygon
Definition: Geometry.h:83
a linear ring (linestring with 1st point == last point)
Definition: Geometry.h:81
a point
Definition: Geometry.h:77
a collection of polygons
Definition: Geometry.h:89