capi/geos_c.h.in

   1 /************************************************************************
   2  *
   3  * $Id$
   4  *
   5  * C-Wrapper for GEOS library
   6  *
   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@refractions.net>
  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 to GEOSFree()
  25  *        all returned char * (unless const).
  26  *
  27  ***********************************************************************/
  28
  29 #ifndef GEOS_C_H_INCLUDED
  30 #define GEOS_C_H_INCLUDED
  31
  32 #ifndef __cplusplus
  33 # include <stddef.h> /* for size_t definition */
  34 #else
  35 # include <cstddef>
  36 using std::size_t;
  37 #endif
  38
  39 #ifdef __cplusplus
  40 extern "C" {
  41 #endif
  42
  43 /************************************************************************
  44  *
  45  * Version
  46  *
  47  ***********************************************************************/
  48
  49 /*
  50  *  * Following 'ifdef' hack fixes problem with generating geos_c.h on Windows,
  51  *   * when building with Visual C++ compiler.
  52  *    */
  53 #if defined(_MSC_VER)
  54 #include <geos/version.h>
  55 #define GEOS_CAPI_VERSION_MAJOR 1
  56 #define GEOS_CAPI_VERSION_MINOR 5
  57 #define GEOS_CAPI_VERSION_PATCH 0
  58 #define GEOS_CAPI_VERSION "3.1.0-CAPI-1.5.0"
  59 #else
  60 #ifndef GEOS_VERSION_MAJOR
  61 #define GEOS_VERSION_MAJOR @VERSION_MAJOR@
  62 #endif
  63 #ifndef GEOS_VERSION_MINOR
  64 #define GEOS_VERSION_MINOR @VERSION_MINOR@
  65 #endif
  66 #ifndef GEOS_VERSION_PATCH
  67 #define GEOS_VERSION_PATCH @VERSION_PATCH@
  68 #endif
  69 #ifndef GEOS_VERSION
  70 #define GEOS_VERSION "@VERSION@"
  71 #endif
  72 #ifndef GEOS_JTS_PORT
  73 #define GEOS_JTS_PORT "@JTS_PORT@"
  74 #endif
  75
  76 #define GEOS_CAPI_VERSION_MAJOR @CAPI_VERSION_MAJOR@
  77 #define GEOS_CAPI_VERSION_MINOR @CAPI_VERSION_MINOR@
  78 #define GEOS_CAPI_VERSION_PATCH @CAPI_VERSION_PATCH@
  79 #define GEOS_CAPI_VERSION "@VERSION@-CAPI-@CAPI_VERSION@"
  80 #endif
  81
  82 #define GEOS_CAPI_FIRST_INTERFACE GEOS_CAPI_VERSION_MAJOR
  83 #define GEOS_CAPI_LAST_INTERFACE (GEOS_CAPI_VERSION_MAJOR+GEOS_CAPI_VERSION_MINOR)
  84
  85 /************************************************************************
  86  *
  87  * (Abstract) type definitions
  88  *
  89  ************************************************************************/
  90
  91 typedef void (*GEOSMessageHandler)(const char *fmt, ...);
  92
  93 /* When we're included by geos_c.cpp, those are #defined to the original
  94  * JTS definitions via preprocessor. We don't touch them to allow the
  95  * compiler to cross-check the declarations. However, for all "normal"
  96  * C-API users, we need to define them as "opaque" struct pointers, as
  97  * those clients don't have access to the original C++ headers, by design.
  98  */
  99 #ifndef GEOSGeometry
 100 typedef struct GEOSGeom_t GEOSGeometry;
 101 typedef struct GEOSPrepGeom_t GEOSPreparedGeometry;
 102 typedef struct GEOSCoordSeq_t GEOSCoordSequence;
 103 typedef struct GEOSSTRtree_t GEOSSTRtree;
 104 #endif
 105
 106 /* Those are compatibility definitions for source compatibility
 107  * with GEOS 2.X clients relying on that type.
 108  */
 109 typedef GEOSGeometry* GEOSGeom;
 110 typedef GEOSCoordSequence* GEOSCoordSeq;
 111
 112 /* Supported geometry types
 113  * This was renamed from GEOSGeomTypeId in GEOS 2.2.X, which might
 114  * break compatibility, this issue is still under investigation.
 115  */
 116
 117 enum GEOSGeomTypes {
 118     GEOS_POINT,
 119     GEOS_LINESTRING,
 120     GEOS_LINEARRING,
 121     GEOS_POLYGON,
 122     GEOS_MULTIPOINT,
 123     GEOS_MULTILINESTRING,
 124     GEOS_MULTIPOLYGON,
 125     GEOS_GEOMETRYCOLLECTION
 126 };
 127
 128 /* Byte oders exposed via the c api */
 129 enum GEOSByteOrders {
 130     GEOS_WKB_XDR = 0, /* Big Endian */
 131     GEOS_WKB_NDR = 1 /* Little Endian */
 132 };
 133
 134 typedef struct GEOSContextHandle_HS *GEOSContextHandle_t;
 135
 136 typedef void (*GEOSQueryCallback)(void *item, void *userdata);
 137
 138 /************************************************************************
 139  *
 140  * Initialization, cleanup, version
 141  *
 142  ***********************************************************************/
 143
 144 #include <geos/export.h>
 145
 146 extern void GEOS_DLL initGEOS(GEOSMessageHandler notice_function,
 147         GEOSMessageHandler error_function);
 148 extern void GEOS_DLL finishGEOS(void);
 149
 150 extern GEOSContextHandle_t GEOS_DLL initGEOS_r(
 151                                     GEOSMessageHandler notice_function,
 152                                     GEOSMessageHandler error_function);
 153 extern void GEOS_DLL finishGEOS_r(GEOSContextHandle_t handle);
 154
 155 extern const char GEOS_DLL *GEOSversion();
 156
 157
 158 /************************************************************************
 159  *
 160  * NOTE - These functions are DEPRECATED.  Please use the new Reader and
 161  * writer APIS!
 162  *
 163  ***********************************************************************/
 164
 165 extern GEOSGeometry GEOS_DLL *GEOSGeomFromWKT(const char *wkt);
 166 extern char GEOS_DLL *GEOSGeomToWKT(const GEOSGeometry* g);
 167
 168 extern GEOSGeometry GEOS_DLL *GEOSGeomFromWKT_r(GEOSContextHandle_t handle,
 169                                                 const char *wkt);
 170 extern char GEOS_DLL *GEOSGeomToWKT_r(GEOSContextHandle_t handle,
 171                                       const GEOSGeometry* g);
 172
 173 /*
 174  * Specify whether output WKB should be 2d or 3d.
 175  * Return previously set number of dimensions.
 176  */
 177 extern int GEOS_DLL GEOS_getWKBOutputDims();
 178 extern int GEOS_DLL GEOS_setWKBOutputDims(int newDims);
 179
 180 extern int GEOS_DLL GEOS_getWKBOutputDims_r(GEOSContextHandle_t handle);
 181 extern int GEOS_DLL GEOS_setWKBOutputDims_r(GEOSContextHandle_t handle,
 182                                             int newDims);
 183
 184 /*
 185  * Specify whether the WKB byte order is big or little endian.
 186  * The return value is the previous byte order.
 187  */
 188 extern int GEOS_DLL GEOS_getWKBByteOrder();
 189 extern int GEOS_DLL GEOS_setWKBByteOrder(int byteOrder);
 190
 191 extern GEOSGeometry GEOS_DLL *GEOSGeomFromWKB_buf(const unsigned char *wkb, size_t size);
 192 extern unsigned char GEOS_DLL *GEOSGeomToWKB_buf(const GEOSGeometry* g, size_t *size);
 193
 194 extern GEOSGeometry GEOS_DLL *GEOSGeomFromHEX_buf(const unsigned char *hex, size_t size);
 195 extern unsigned char GEOS_DLL *GEOSGeomToHEX_buf(const GEOSGeometry* g, size_t *size);
 196
 197 extern int GEOS_DLL GEOS_getWKBByteOrder_r(GEOSContextHandle_t handle);
 198 extern int GEOS_DLL GEOS_setWKBByteOrder_r(GEOSContextHandle_t handle,
 199                                            int byteOrder);
 200
 201 extern GEOSGeometry GEOS_DLL *GEOSGeomFromWKB_buf_r(GEOSContextHandle_t handle,
 202                                                     const unsigned char *wkb,
 203                                                     size_t size);
 204 extern unsigned char GEOS_DLL *GEOSGeomToWKB_buf_r(GEOSContextHandle_t handle,
 205                                                    const GEOSGeometry* g,
 206                                                    size_t *size);
 207
 208 extern GEOSGeometry GEOS_DLL *GEOSGeomFromHEX_buf_r(GEOSContextHandle_t handle,
 209                                                     const unsigned char *hex,
 210                                                     size_t size);
 211 extern unsigned char GEOS_DLL *GEOSGeomToHEX_buf_r(GEOSContextHandle_t handle,
 212                                                    const GEOSGeometry* g,
 213                                                    size_t *size);
 214
 215 /************************************************************************
 216  *
 217  * Coordinate Sequence functions
 218  *
 219  ***********************************************************************/
 220
 221 /*
 222  * Create a Coordinate sequence with ``size'' coordinates
 223  * of ``dims'' dimensions.
 224  * Return NULL on exception.
 225  */
 226 extern GEOSCoordSequence GEOS_DLL *GEOSCoordSeq_create(unsigned int size, unsigned int dims);
 227
 228 extern GEOSCoordSequence GEOS_DLL *GEOSCoordSeq_create_r(
 229                                                 GEOSContextHandle_t handle,
 230                                                 unsigned int size,
 231                                                 unsigned int dims);
 232
 233 /*
 234  * Clone a Coordinate Sequence.
 235  * Return NULL on exception.
 236  */
 237 extern GEOSCoordSequence GEOS_DLL *GEOSCoordSeq_clone(const GEOSCoordSequence* s);
 238
 239 extern GEOSCoordSequence GEOS_DLL *GEOSCoordSeq_clone_r(
 240                                                 GEOSContextHandle_t handle,
 241                                                 const GEOSCoordSequence* s);
 242
 243 /*
 244  * Destroy a Coordinate Sequence.
 245  */
 246 extern void GEOS_DLL GEOSCoordSeq_destroy(GEOSCoordSequence* s);
 247
 248 extern void GEOS_DLL GEOSCoordSeq_destroy_r(GEOSContextHandle_t handle,
 249                                             GEOSCoordSequence* s);
 250
 251 /*
 252  * Set ordinate values in a Coordinate Sequence.
 253  * Return 0 on exception.
 254  */
 255 extern int GEOS_DLL GEOSCoordSeq_setX(GEOSCoordSequence* s,
 256         unsigned int idx, double val);
 257 extern int GEOS_DLL GEOSCoordSeq_setY(GEOSCoordSequence* s,
 258         unsigned int idx, double val);
 259 extern int GEOS_DLL GEOSCoordSeq_setZ(GEOSCoordSequence* s,
 260         unsigned int idx, double val);
 261 extern int GEOS_DLL GEOSCoordSeq_setOrdinate(GEOSCoordSequence* s,
 262         unsigned int idx, unsigned int dim, double val);
 263
 264 extern int GEOS_DLL GEOSCoordSeq_setX_r(GEOSContextHandle_t handle,
 265                                         GEOSCoordSequence* s, unsigned int idx,
 266                                         double val);
 267 extern int GEOS_DLL GEOSCoordSeq_setY_r(GEOSContextHandle_t handle,
 268                                         GEOSCoordSequence* s, unsigned int idx,
 269                                         double val);
 270 extern int GEOS_DLL GEOSCoordSeq_setZ_r(GEOSContextHandle_t handle,
 271                                         GEOSCoordSequence* s, unsigned int idx,
 272                                         double val);
 273 extern int GEOS_DLL GEOSCoordSeq_setOrdinate_r(GEOSContextHandle_t handle,
 274                                                GEOSCoordSequence* s,
 275                                                unsigned int idx,
 276                                                unsigned int dim, double val);
 277
 278 /*
 279  * Get ordinate values from a Coordinate Sequence.
 280  * Return 0 on exception.
 281  */
 282 extern int GEOS_DLL GEOSCoordSeq_getX(const GEOSCoordSequence* s,
 283         unsigned int idx, double *val);
 284 extern int GEOS_DLL GEOSCoordSeq_getY(const GEOSCoordSequence* s,
 285         unsigned int idx, double *val);
 286 extern int GEOS_DLL GEOSCoordSeq_getZ(const GEOSCoordSequence* s,
 287         unsigned int idx, double *val);
 288 extern int GEOS_DLL GEOSCoordSeq_getOrdinate(const GEOSCoordSequence* s,
 289         unsigned int idx, unsigned int dim, double *val);
 290
 291 extern int GEOS_DLL GEOSCoordSeq_getX_r(GEOSContextHandle_t handle,
 292                                         const GEOSCoordSequence* s,
 293                                         unsigned int idx, double *val);
 294 extern int GEOS_DLL GEOSCoordSeq_getY_r(GEOSContextHandle_t handle,
 295                                         const GEOSCoordSequence* s,
 296                                         unsigned int idx, double *val);
 297 extern int GEOS_DLL GEOSCoordSeq_getZ_r(GEOSContextHandle_t handle,
 298                                         const GEOSCoordSequence* s,
 299                                         unsigned int idx, double *val);
 300 extern int GEOS_DLL GEOSCoordSeq_getOrdinate_r(GEOSContextHandle_t handle,
 301                                                const GEOSCoordSequence* s,
 302                                                unsigned int idx,
 303                                                unsigned int dim, double *val);
 304 /*
 305  * Get size and dimensions info from a Coordinate Sequence.
 306  * Return 0 on exception.
 307  */
 308 extern int GEOS_DLL GEOSCoordSeq_getSize(const GEOSCoordSequence* s,
 309         unsigned int *size);
 310 extern int GEOS_DLL GEOSCoordSeq_getDimensions(const GEOSCoordSequence* s,
 311         unsigned int *dims);
 312
 313 extern int GEOS_DLL GEOSCoordSeq_getSize_r(GEOSContextHandle_t handle,
 314                                            const GEOSCoordSequence* s,
 315                                            unsigned int *size);
 316 extern int GEOS_DLL GEOSCoordSeq_getDimensions_r(GEOSContextHandle_t handle,
 317                                                  const GEOSCoordSequence* s,
 318                                                  unsigned int *dims);
 319
 320 /************************************************************************
 321  *
 322  * Buffer related functions
 323  *
 324  ***********************************************************************/
 325
 326 enum GEOSBufCapStyles {
 327         GEOSBUF_CAP_ROUND=1,
 328         GEOSBUF_CAP_FLAT=2,
 329         GEOSBUF_CAP_SQUARE=3
 330 };
 331
 332 enum GEOSBufJoinStyles {
 333         GEOSBUF_JOIN_ROUND=1,
 334         GEOSBUF_JOIN_MITRE=2,
 335         GEOSBUF_JOIN_BEVEL=3
 336 };
 337
 338 /* These functions return NULL on exception. */
 339 extern GEOSGeometry GEOS_DLL *GEOSBuffer(const GEOSGeometry* g1,
 340         double width, int quadsegs);
 341 extern GEOSGeometry GEOS_DLL *GEOSBuffer_r(GEOSContextHandle_t handle,
 342                                            const GEOSGeometry* g1,
 343                                            double width, int quadsegs);
 344
 345 /* These functions return NULL on exception. */
 346 extern GEOSGeometry GEOS_DLL *GEOSBufferWithStyle(const GEOSGeometry* g1,
 347         double width, int quadsegs, int endCapStyle, int joinStyle,
 348         double mitreLimit);
 349 extern GEOSGeometry GEOS_DLL *GEOSBufferWithStyle_r(GEOSContextHandle_t handle,
 350         const GEOSGeometry* g1, double width, int quadsegs, int endCapStyle,
 351         int joinStyle, double mitreLimit);
 352
 353
 354 /************************************************************************
 355  *
 356  * Geometry Constructors.
 357  * GEOSCoordSequence* arguments will become ownership of the returned object.
 358  * All functions return NULL on exception.
 359  *
 360  ***********************************************************************/
 361
 362 extern GEOSGeometry GEOS_DLL *GEOSGeom_createPoint(GEOSCoordSequence* s);
 363 extern GEOSGeometry GEOS_DLL *GEOSGeom_createLinearRing(GEOSCoordSequence* s);
 364 extern GEOSGeometry GEOS_DLL *GEOSGeom_createLineString(GEOSCoordSequence* s);
 365
 366 extern GEOSGeometry GEOS_DLL *GEOSGeom_createPoint_r(
 367                                        GEOSContextHandle_t handle,
 368                                        GEOSCoordSequence* s);
 369 extern GEOSGeometry GEOS_DLL *GEOSGeom_createLinearRing_r(
 370                                        GEOSContextHandle_t handle,
 371                                        GEOSCoordSequence* s);
 372 extern GEOSGeometry GEOS_DLL *GEOSGeom_createLineString_r(
 373                                        GEOSContextHandle_t handle,
 374                                        GEOSCoordSequence* s);
 375
 376 /*
 377  * Second argument is an array of GEOSGeometry* objects.
 378  * The caller remains owner of the array, but pointed-to
 379  * objects become ownership of the returned GEOSGeometry.
 380  */
 381 extern GEOSGeometry GEOS_DLL *GEOSGeom_createPolygon(GEOSGeometry* shell,
 382         GEOSGeometry** holes, unsigned int nholes);
 383 extern GEOSGeometry GEOS_DLL *GEOSGeom_createCollection(int type,
 384         GEOSGeometry* *geoms, unsigned int ngeoms);
 385
 386 extern GEOSGeometry GEOS_DLL *GEOSGeom_createPolygon_r(
 387                                        GEOSContextHandle_t handle,
 388                                        GEOSGeometry* shell,
 389                                        GEOSGeometry** holes,
 390                                        unsigned int nholes);
 391 extern GEOSGeometry GEOS_DLL *GEOSGeom_createCollection_r(
 392                                        GEOSContextHandle_t handle, int type,
 393                                        GEOSGeometry* *geoms,
 394                                        unsigned int ngeoms);
 395
 396 extern GEOSGeometry GEOS_DLL *GEOSGeom_clone(const GEOSGeometry* g);
 397
 398 extern GEOSGeometry GEOS_DLL *GEOSGeom_clone_r(GEOSContextHandle_t handle,
 399                                                const GEOSGeometry* g);
 400
 401 /************************************************************************
 402  *
 403  * Memory management
 404  *
 405  ***********************************************************************/
 406
 407 extern void GEOS_DLL GEOSGeom_destroy(GEOSGeometry* g);
 408
 409 extern void GEOS_DLL GEOSGeom_destroy_r(GEOSContextHandle_t handle,
 410                                         GEOSGeometry* g);
 411
 412 /************************************************************************
 413  *
 414  * Topology operations - return NULL on exception.
 415  *
 416  ***********************************************************************/
 417
 418 extern GEOSGeometry GEOS_DLL *GEOSEnvelope(const GEOSGeometry* g1);
 419 extern GEOSGeometry GEOS_DLL *GEOSIntersection(const GEOSGeometry* g1, const GEOSGeometry* g2);
 420 extern GEOSGeometry GEOS_DLL *GEOSConvexHull(const GEOSGeometry* g1);
 421 extern GEOSGeometry GEOS_DLL *GEOSDifference(const GEOSGeometry* g1, const GEOSGeometry* g2);
 422 extern GEOSGeometry GEOS_DLL *GEOSSymDifference(const GEOSGeometry* g1,
 423         const GEOSGeometry* g2);
 424 extern GEOSGeometry GEOS_DLL *GEOSBoundary(const GEOSGeometry* g1);
 425 extern GEOSGeometry GEOS_DLL *GEOSUnion(const GEOSGeometry* g1, const GEOSGeometry* g2);
 426 extern GEOSGeometry GEOS_DLL *GEOSUnionCascaded(const GEOSGeometry* g1);
 427
 428 extern GEOSGeometry GEOS_DLL *GEOSPointOnSurface(const GEOSGeometry* g1);
 429 extern GEOSGeometry GEOS_DLL *GEOSGetCentroid(const GEOSGeometry* g);
 430 extern char GEOS_DLL *GEOSRelate(const GEOSGeometry* g1, const GEOSGeometry* g2);
 431
 432 extern GEOSGeometry GEOS_DLL *GEOSEnvelope_r(GEOSContextHandle_t handle,
 433                                              const GEOSGeometry* g1);
 434 extern GEOSGeometry GEOS_DLL *GEOSIntersection_r(GEOSContextHandle_t handle,
 435                                                  const GEOSGeometry* g1,
 436                                                  const GEOSGeometry* g2);
 437 extern GEOSGeometry GEOS_DLL *GEOSConvexHull_r(GEOSContextHandle_t handle,
 438                                                const GEOSGeometry* g1);
 439 extern GEOSGeometry GEOS_DLL *GEOSDifference_r(GEOSContextHandle_t handle,
 440                                                const GEOSGeometry* g1,
 441                                                const GEOSGeometry* g2);
 442 extern GEOSGeometry GEOS_DLL *GEOSSymDifference_r(GEOSContextHandle_t handle,
 443                                                   const GEOSGeometry* g1,
 444                                                   const GEOSGeometry* g2);
 445 extern GEOSGeometry GEOS_DLL *GEOSBoundary_r(GEOSContextHandle_t handle,
 446                                              const GEOSGeometry* g1);
 447 extern GEOSGeometry GEOS_DLL *GEOSUnion_r(GEOSContextHandle_t handle,
 448                                           const GEOSGeometry* g1,
 449                                           const GEOSGeometry* g2);
 450 extern GEOSGeometry GEOS_DLL *GEOSUnionCascaded_r(GEOSContextHandle_t handle, const GEOSGeometry* g1);
 451 extern GEOSGeometry GEOS_DLL *GEOSPointOnSurface_r(GEOSContextHandle_t handle,
 452                                                    const GEOSGeometry* g1);
 453 extern GEOSGeometry GEOS_DLL *GEOSGetCentroid_r(GEOSContextHandle_t handle,
 454                                                 const GEOSGeometry* g);
 455 extern char GEOS_DLL *GEOSRelate_r(GEOSContextHandle_t handle,
 456                                    const GEOSGeometry* g1,
 457                                    const GEOSGeometry* g2);
 458
 459 /*
 460  * all arguments remain ownership of the caller
 461  * (both Geometries and pointers)
 462  */
 463 extern GEOSGeometry GEOS_DLL *GEOSPolygonize(const GEOSGeometry * const geoms[], unsigned int ngeoms);
 464 extern GEOSGeometry GEOS_DLL *GEOSPolygonizer_getCutEdges(const GEOSGeometry * const geoms[], unsigned int ngeoms);
 465
 466 extern GEOSGeometry GEOS_DLL *GEOSLineMerge(const GEOSGeometry* g);
 467 extern GEOSGeometry GEOS_DLL *GEOSSimplify(const GEOSGeometry* g1, double tolerance);
 468 extern GEOSGeometry GEOS_DLL *GEOSTopologyPreserveSimplify(const GEOSGeometry* g1,
 469         double tolerance);
 470
 471 extern GEOSGeometry GEOS_DLL *GEOSPolygonize_r(GEOSContextHandle_t handle,
 472                               const GEOSGeometry *const geoms[],
 473                               unsigned int ngeoms);
 474 extern GEOSGeometry GEOS_DLL *GEOSPolygonizer_getCutEdges_r(
 475                               GEOSContextHandle_t handle,
 476                               const GEOSGeometry * const geoms[],
 477                               unsigned int ngeoms);
 478
 479 extern GEOSGeometry GEOS_DLL *GEOSLineMerge_r(GEOSContextHandle_t handle,
 480                                               const GEOSGeometry* g);
 481 extern GEOSGeometry GEOS_DLL *GEOSSimplify_r(GEOSContextHandle_t handle,
 482                                              const GEOSGeometry* g1,
 483                                              double tolerance);
 484 extern GEOSGeometry GEOS_DLL *GEOSTopologyPreserveSimplify_r(
 485                               GEOSContextHandle_t handle,
 486                               const GEOSGeometry* g1, double tolerance);
 487
 488 /************************************************************************
 489  *
 490  *  Binary predicates - return 2 on exception, 1 on true, 0 on false
 491  *
 492  ***********************************************************************/
 493
 494 extern char GEOS_DLL GEOSRelatePattern(const GEOSGeometry* g1, const GEOSGeometry* g2,
 495         const char *pat);
 496 extern char GEOS_DLL GEOSDisjoint(const GEOSGeometry* g1, const GEOSGeometry* g2);
 497 extern char GEOS_DLL GEOSTouches(const GEOSGeometry* g1, const GEOSGeometry* g2);
 498 extern char GEOS_DLL GEOSIntersects(const GEOSGeometry* g1, const GEOSGeometry* g2);
 499 extern char GEOS_DLL GEOSCrosses(const GEOSGeometry* g1, const GEOSGeometry* g2);
 500 extern char GEOS_DLL GEOSWithin(const GEOSGeometry* g1, const GEOSGeometry* g2);
 501 extern char GEOS_DLL GEOSContains(const GEOSGeometry* g1, const GEOSGeometry* g2);
 502 extern char GEOS_DLL GEOSOverlaps(const GEOSGeometry* g1, const GEOSGeometry* g2);
 503 extern char GEOS_DLL GEOSEquals(const GEOSGeometry* g1, const GEOSGeometry* g2);
 504 extern char GEOS_DLL GEOSEqualsExact(const GEOSGeometry* g1, const GEOSGeometry* g2, double tolerance);
 505
 506 extern char GEOS_DLL GEOSRelatePattern_r(GEOSContextHandle_t handle,
 507                                          const GEOSGeometry* g1,
 508                                          const GEOSGeometry* g2,
 509                                          const char *pat);
 510 extern char GEOS_DLL GEOSDisjoint_r(GEOSContextHandle_t handle,
 511                                     const GEOSGeometry* g1,
 512                                     const GEOSGeometry* g2);
 513 extern char GEOS_DLL GEOSTouches_r(GEOSContextHandle_t handle,
 514                                    const GEOSGeometry* g1,
 515                                    const GEOSGeometry* g2);
 516 extern char GEOS_DLL GEOSIntersects_r(GEOSContextHandle_t handle,
 517                                       const GEOSGeometry* g1,
 518                                       const GEOSGeometry* g2);
 519 extern char GEOS_DLL GEOSCrosses_r(GEOSContextHandle_t handle,
 520                                    const GEOSGeometry* g1,
 521                                    const GEOSGeometry* g2);
 522 extern char GEOS_DLL GEOSWithin_r(GEOSContextHandle_t handle,
 523                                   const GEOSGeometry* g1,
 524                                   const GEOSGeometry* g2);
 525 extern char GEOS_DLL GEOSContains_r(GEOSContextHandle_t handle,
 526                                     const GEOSGeometry* g1,
 527                                     const GEOSGeometry* g2);
 528 extern char GEOS_DLL GEOSOverlaps_r(GEOSContextHandle_t handle,
 529                                     const GEOSGeometry* g1,
 530                                     const GEOSGeometry* g2);
 531 extern char GEOS_DLL GEOSEquals_r(GEOSContextHandle_t handle,
 532                                   const GEOSGeometry* g1,
 533                                   const GEOSGeometry* g2);
 534 extern char GEOS_DLL GEOSEqualsExact_r(GEOSContextHandle_t handle,
 535                                        const GEOSGeometry* g1,
 536                                        const GEOSGeometry* g2,
 537                                        double tolerance);
 538
 539 /************************************************************************
 540  *
 541  *  Prepared Geometry Binary predicates - return 2 on exception, 1 on true, 0 on false
 542  *
 543  ***********************************************************************/
 544
 545 /*
 546  * GEOSGeometry ownership is retained by caller
 547  */
 548 extern const GEOSPreparedGeometry GEOS_DLL *GEOSPrepare(const GEOSGeometry* g);
 549
 550 extern void GEOS_DLL GEOSPreparedGeom_destroy(const GEOSPreparedGeometry* g);
 551
 552 extern char GEOS_DLL GEOSPreparedContains(const GEOSPreparedGeometry* pg1, const GEOSGeometry* g2);
 553 extern char GEOS_DLL GEOSPreparedContainsProperly(const GEOSPreparedGeometry* pg1, const GEOSGeometry* g2);
 554 extern char GEOS_DLL GEOSPreparedCovers(const GEOSPreparedGeometry* pg1, const GEOSGeometry* g2);
 555 extern char GEOS_DLL GEOSPreparedIntersects(const GEOSPreparedGeometry* pg1, const GEOSGeometry* g2);
 556
 557 /*
 558  * GEOSGeometry ownership is retained by caller
 559  */
 560 extern const GEOSPreparedGeometry GEOS_DLL *GEOSPrepare_r(
 561                                             GEOSContextHandle_t handle,
 562                                             const GEOSGeometry* g);
 563
 564 extern void GEOS_DLL GEOSPreparedGeom_destroy_r(GEOSContextHandle_t handle,
 565                                                 const GEOSPreparedGeometry* g);
 566
 567 extern char GEOS_DLL GEOSPreparedContains_r(GEOSContextHandle_t handle,
 568                                             const GEOSPreparedGeometry* pg1,
 569                                             const GEOSGeometry* g2);
 570 extern char GEOS_DLL GEOSPreparedContainsProperly_r(GEOSContextHandle_t handle,
 571                                          const GEOSPreparedGeometry* pg1,
 572                                          const GEOSGeometry* g2);
 573 extern char GEOS_DLL GEOSPreparedCovers_r(GEOSContextHandle_t handle,
 574                                           const GEOSPreparedGeometry* pg1,
 575                                           const GEOSGeometry* g2);
 576 extern char GEOS_DLL GEOSPreparedIntersects_r(GEOSContextHandle_t handle,
 577                                               const GEOSPreparedGeometry* pg1,
 578                                               const GEOSGeometry* g2);
 579
 580 /************************************************************************
 581  *
 582  *  STRtree functions
 583  *
 584  ***********************************************************************/
 585
 586 /*
 587  * GEOSGeometry ownership is retained by caller
 588  */
 589
 590 extern GEOSSTRtree GEOS_DLL *GEOSSTRtree_create(size_t nodeCapacity);
 591 extern void GEOS_DLL GEOSSTRtree_insert(GEOSSTRtree *tree,
 592                                         const GEOSGeometry *g,
 593                                         void *item);
 594 extern void GEOS_DLL GEOSSTRtree_query(GEOSSTRtree *tree,
 595                                        const GEOSGeometry *g,
 596                                        GEOSQueryCallback callback,
 597                                        void *userdata);
 598 extern void GEOS_DLL GEOSSTRtree_iterate(GEOSSTRtree *tree,
 599                                        GEOSQueryCallback callback,
 600                                        void *userdata);
 601 extern char GEOS_DLL GEOSSTRtree_remove(GEOSSTRtree *tree,
 602                                         const GEOSGeometry *g,
 603                                         void *item);
 604 extern void GEOS_DLL GEOSSTRtree_destroy(GEOSSTRtree *tree);
 605
 606
 607 extern GEOSSTRtree GEOS_DLL *GEOSSTRtree_create_r(
 608                                     GEOSContextHandle_t handle,
 609                                     size_t nodeCapacity);
 610 extern void GEOS_DLL GEOSSTRtree_insert_r(GEOSContextHandle_t handle,
 611                                           GEOSSTRtree *tree,
 612                                           const GEOSGeometry *g,
 613                                           void *item);
 614 extern void GEOS_DLL GEOSSTRtree_query_r(GEOSContextHandle_t handle,
 615                                          GEOSSTRtree *tree,
 616                                          const GEOSGeometry *g,
 617                                          GEOSQueryCallback callback,
 618                                          void *userdata);
 619 extern void GEOS_DLL GEOSSTRtree_iterate_r(GEOSContextHandle_t handle,
 620                                        GEOSSTRtree *tree,
 621                                        GEOSQueryCallback callback,
 622                                        void *userdata);
 623 extern char GEOS_DLL GEOSSTRtree_remove_r(GEOSContextHandle_t handle,
 624                                           GEOSSTRtree *tree,
 625                                           const GEOSGeometry *g,
 626                                           void *item);
 627 extern void GEOS_DLL GEOSSTRtree_destroy_r(GEOSContextHandle_t handle,
 628                                            GEOSSTRtree *tree);
 629
 630
 631 /************************************************************************
 632  *
 633  *  Unary predicate - return 2 on exception, 1 on true, 0 on false
 634  *
 635  ***********************************************************************/
 636
 637 extern char GEOS_DLL GEOSisEmpty(const GEOSGeometry* g1);
 638 extern char GEOS_DLL GEOSisValid(const GEOSGeometry* g1);
 639 extern char GEOS_DLL *GEOSisValidReason(const GEOSGeometry *g1);
 640 extern char GEOS_DLL GEOSisSimple(const GEOSGeometry* g1);
 641 extern char GEOS_DLL GEOSisRing(const GEOSGeometry* g1);
 642 extern char GEOS_DLL GEOSHasZ(const GEOSGeometry* g1);
 643
 644 extern char GEOS_DLL GEOSisEmpty_r(GEOSContextHandle_t handle,
 645                                    const GEOSGeometry* g1);
 646 extern char GEOS_DLL GEOSisValid_r(GEOSContextHandle_t handle,
 647                                    const GEOSGeometry* g1);
 648 extern char GEOS_DLL *GEOSisValidReason_r(GEOSContextHandle_t handle,
 649                                          const GEOSGeometry* g1);
 650 extern char GEOS_DLL GEOSisSimple_r(GEOSContextHandle_t handle,
 651                                     const GEOSGeometry* g1);
 652 extern char GEOS_DLL GEOSisRing_r(GEOSContextHandle_t handle,
 653                                   const GEOSGeometry* g1);
 654 extern char GEOS_DLL GEOSHasZ_r(GEOSContextHandle_t handle,
 655                                 const GEOSGeometry* g1);
 656
 657 /************************************************************************
 658  *
 659  *  Geometry info
 660  *
 661  ***********************************************************************/
 662
 663 /* Return NULL on exception, result must be freed by caller. */
 664 extern char GEOS_DLL *GEOSGeomType(const GEOSGeometry* g1);
 665
 666 extern char GEOS_DLL *GEOSGeomType_r(GEOSContextHandle_t handle,
 667                                      const GEOSGeometry* g1);
 668
 669 /* Return -1 on exception */
 670 extern int GEOS_DLL GEOSGeomTypeId(const GEOSGeometry* g1);
 671
 672 extern int GEOS_DLL GEOSGeomTypeId_r(GEOSContextHandle_t handle,
 673                                      const GEOSGeometry* g1);
 674
 675 /* Return 0 on exception */
 676 extern int GEOS_DLL GEOSGetSRID(const GEOSGeometry* g);
 677 extern int GEOS_DLL GEOSGetSRID_r(GEOSContextHandle_t handle,
 678                                   const GEOSGeometry* g);
 679
 680 extern void GEOS_DLL GEOSSetSRID(GEOSGeometry* g, int SRID);
 681 extern void GEOS_DLL GEOSSetSRID_r(GEOSContextHandle_t handle,
 682                                    GEOSGeometry* g, int SRID);
 683
 684 /* May be called on all geometries in GEOS 3.x, returns -1 on error and 1
 685  * for non-multi geometries. Older GEOS versions only accept
 686  * GeometryCollections or Multi* geometries here, and are likely to crash
 687  * when feeded simple geometries, so beware if you need compatibility with
 688  * old GEOS versions.
 689  */
 690 extern int GEOS_DLL GEOSGetNumGeometries(const GEOSGeometry* g);
 691
 692 extern int GEOS_DLL GEOSGetNumGeometries_r(GEOSContextHandle_t handle,
 693                                            const GEOSGeometry* g);
 694
 695 /*
 696  * Return NULL on exception, Geometry must be a Collection.
 697  * Returned object is a pointer to internal storage:
 698  * it must NOT be destroyed directly.
 699  */
 700 extern const GEOSGeometry GEOS_DLL *GEOSGetGeometryN(const GEOSGeometry* g, int n);
 701
 702 extern const GEOSGeometry GEOS_DLL *GEOSGetGeometryN_r(
 703                                     GEOSContextHandle_t handle,
 704                                     const GEOSGeometry* g, int n);
 705
 706 /* Return -1 on exception */
 707 extern int GEOS_DLL GEOSNormalize(GEOSGeometry* g1);
 708
 709 extern int GEOS_DLL GEOSNormalize_r(GEOSContextHandle_t handle,
 710                                     GEOSGeometry* g1);
 711
 712 /* Return -1 on exception */
 713 extern int GEOS_DLL GEOSGetNumInteriorRings(const GEOSGeometry* g1);
 714
 715 extern int GEOS_DLL GEOSGetNumInteriorRings_r(GEOSContextHandle_t handle,
 716                                               const GEOSGeometry* g1);
 717
 718 /*
 719  * Return NULL on exception, Geometry must be a Polygon.
 720  * Returned object is a pointer to internal storage:
 721  * it must NOT be destroyed directly.
 722  */
 723 extern const GEOSGeometry GEOS_DLL *GEOSGetInteriorRingN(const GEOSGeometry* g, int n);
 724
 725 extern const GEOSGeometry GEOS_DLL *GEOSGetInteriorRingN_r(
 726                                     GEOSContextHandle_t handle,
 727                                     const GEOSGeometry* g, int n);
 728
 729 /*
 730  * Return NULL on exception, Geometry must be a Polygon.
 731  * Returned object is a pointer to internal storage:
 732  * it must NOT be destroyed directly.
 733  */
 734 extern const GEOSGeometry GEOS_DLL *GEOSGetExteriorRing(const GEOSGeometry* g);
 735
 736 extern const GEOSGeometry GEOS_DLL *GEOSGetExteriorRing_r(
 737                                     GEOSContextHandle_t handle,
 738                                     const GEOSGeometry* g);
 739
 740 /* Return -1 on exception */
 741 extern int GEOS_DLL GEOSGetNumCoordinates(const GEOSGeometry* g1);
 742
 743 extern int GEOS_DLL GEOSGetNumCoordinates_r(GEOSContextHandle_t handle,
 744                                             const GEOSGeometry* g1);
 745
 746 /*
 747  * Return NULL on exception.
 748  * Geometry must be a LineString, LinearRing or Point.
 749  */
 750 extern const GEOSCoordSequence GEOS_DLL *GEOSGeom_getCoordSeq(const GEOSGeometry* g);
 751
 752 extern const GEOSCoordSequence GEOS_DLL *GEOSGeom_getCoordSeq_r(
 753                                          GEOSContextHandle_t handle,
 754                                          const GEOSGeometry* g);
 755
 756 /*
 757  * Return 0 on exception (or empty geometry)
 758  * See also GEOSCoordSeq_getDimensions
 759  */
 760 extern int GEOS_DLL GEOSGeom_getDimensions(const GEOSGeometry* g);
 761
 762 extern int GEOS_DLL GEOSGeom_getDimensions_r(GEOSContextHandle_t handle,
 763                                              const GEOSGeometry* g);
 764
 765 /************************************************************************
 766  *
 767  *  Misc functions
 768  *
 769  ***********************************************************************/
 770
 771 /* Return 0 on exception, 1 otherwise */
 772 extern int GEOS_DLL GEOSArea(const GEOSGeometry* g1, double *area);
 773 extern int GEOS_DLL GEOSLength(const GEOSGeometry* g1, double *length);
 774 extern int GEOS_DLL GEOSDistance(const GEOSGeometry* g1, const GEOSGeometry* g2,
 775         double *dist);
 776 extern int GEOS_DLL GEOSHausdorffDistance(const GEOSGeometry *g1,
 777         const GEOSGeometry *g2, double *dist);
 778 extern int GEOS_DLL GEOSHausdorffDistanceDensify(const GEOSGeometry *g1,
 779         const GEOSGeometry *g2, double densifyFrac, double *dist);
 780 extern int GEOS_DLL GEOSArea_r(GEOSContextHandle_t handle,
 781                                const GEOSGeometry* g1, double *area);
 782 extern int GEOS_DLL GEOSLength_r(GEOSContextHandle_t handle,
 783                                  const GEOSGeometry* g1, double *length);
 784 extern int GEOS_DLL GEOSDistance_r(GEOSContextHandle_t handle,
 785                                    const GEOSGeometry* g1,
 786                                    const GEOSGeometry* g2, double *dist);
 787 extern int GEOS_DLL GEOSHausdorffDistance_r(GEOSContextHandle_t handle,
 788                                    const GEOSGeometry *g1,
 789                                    const GEOSGeometry *g2,
 790                                    double *dist);
 791 extern int GEOS_DLL GEOSHausdorffDistanceDensify_r(GEOSContextHandle_t handle,
 792                                    const GEOSGeometry *g1,
 793                                    const GEOSGeometry *g2,
 794                                    double densifyFrac, double *dist);
 795
 796
 797 /************************************************************************
 798  *
 799  * Reader and Writer APIs
 800  *
 801  ***********************************************************************/
 802
 803 typedef struct GEOSWKTReader_t GEOSWKTReader;
 804 typedef struct GEOSWKTWriter_t GEOSWKTWriter;
 805 typedef struct GEOSWKBReader_t GEOSWKBReader;
 806 typedef struct GEOSWKBWriter_t GEOSWKBWriter;
 807
 808
 809 /* WKT Reader */
 810 extern GEOSWKTReader GEOS_DLL *GEOSWKTReader_create();
 811 extern void GEOS_DLL GEOSWKTReader_destroy(GEOSWKTReader* reader);
 812 extern GEOSGeometry GEOS_DLL *GEOSWKTReader_read(GEOSWKTReader* reader, const char *wkt);
 813
 814 extern GEOSWKTReader GEOS_DLL *GEOSWKTReader_create_r(
 815                                              GEOSContextHandle_t handle);
 816 extern void GEOS_DLL GEOSWKTReader_destroy_r(GEOSContextHandle_t handle,
 817                                              GEOSWKTReader* reader);
 818 extern GEOSGeometry GEOS_DLL *GEOSWKTReader_read_r(GEOSContextHandle_t handle,
 819                                                    GEOSWKTReader* reader,
 820                                                    const char *wkt);
 821
 822 /* WKT Writer */
 823 extern GEOSWKTWriter GEOS_DLL *GEOSWKTWriter_create();
 824 extern void GEOS_DLL GEOSWKTWriter_destroy(GEOSWKTWriter* writer);
 825 extern char GEOS_DLL *GEOSWKTWriter_write(GEOSWKTWriter* reader, const GEOSGeometry* g);
 826
 827 extern GEOSWKTWriter GEOS_DLL *GEOSWKTWriter_create_r(
 828                                              GEOSContextHandle_t handle);
 829 extern void GEOS_DLL GEOSWKTWriter_destroy_r(GEOSContextHandle_t handle,
 830                                              GEOSWKTWriter* writer);
 831 extern char GEOS_DLL *GEOSWKTWriter_write_r(GEOSContextHandle_t handle,
 832                                             GEOSWKTWriter* reader,
 833                                             const GEOSGeometry* g);
 834
 835 /* WKB Reader */
 836 extern GEOSWKBReader GEOS_DLL *GEOSWKBReader_create();
 837 extern void GEOS_DLL GEOSWKBReader_destroy(GEOSWKBReader* reader);
 838 extern GEOSGeometry GEOS_DLL *GEOSWKBReader_read(GEOSWKBReader* reader, const unsigned char *wkb, size_t size);
 839 extern GEOSGeometry GEOS_DLL *GEOSWKBReader_readHEX(GEOSWKBReader* reader, const unsigned char *hex, size_t size);
 840
 841 extern GEOSWKBReader GEOS_DLL *GEOSWKBReader_create_r(
 842                                              GEOSContextHandle_t handle);
 843 extern void GEOS_DLL GEOSWKBReader_destroy_r(GEOSContextHandle_t handle,
 844                                              GEOSWKBReader* reader);
 845 extern GEOSGeometry GEOS_DLL *GEOSWKBReader_read_r(GEOSContextHandle_t handle,
 846                                                    GEOSWKBReader* reader,
 847                                                    const unsigned char *wkb,
 848                                                    size_t size);
 849 extern GEOSGeometry GEOS_DLL *GEOSWKBReader_readHEX_r(
 850                                             GEOSContextHandle_t handle,
 851                                             GEOSWKBReader* reader,
 852                                             const unsigned char *hex,
 853                                             size_t size);
 854
 855 /* WKB Writer */
 856 extern GEOSWKBWriter GEOS_DLL *GEOSWKBWriter_create();
 857 extern void GEOS_DLL GEOSWKBWriter_destroy(GEOSWKBWriter* writer);
 858
 859 extern GEOSWKBWriter GEOS_DLL *GEOSWKBWriter_create_r(
 860                                              GEOSContextHandle_t handle);
 861 extern void GEOS_DLL GEOSWKBWriter_destroy_r(GEOSContextHandle_t handle,
 862                                              GEOSWKBWriter* writer);
 863
 864 /* The owner owns the results for these two methods! */
 865 extern unsigned char GEOS_DLL *GEOSWKBWriter_write(GEOSWKBWriter* writer, const GEOSGeometry* g, size_t *size);
 866 extern unsigned char GEOS_DLL *GEOSWKBWriter_writeHEX(GEOSWKBWriter* writer, const GEOSGeometry* g, size_t *size);
 867
 868 extern unsigned char GEOS_DLL *GEOSWKBWriter_write_r(
 869                                              GEOSContextHandle_t handle,
 870                                              GEOSWKBWriter* writer,
 871                                              const GEOSGeometry* g,
 872                                              size_t *size);
 873 extern unsigned char GEOS_DLL *GEOSWKBWriter_writeHEX_r(
 874                                              GEOSContextHandle_t handle,
 875                                              GEOSWKBWriter* writer,
 876                                              const GEOSGeometry* g,
 877                                              size_t *size);
 878
 879 /*
 880  * Specify whether output WKB should be 2d or 3d.
 881  * Return previously set number of dimensions.
 882  */
 883 extern int GEOS_DLL GEOSWKBWriter_getOutputDimension(const GEOSWKBWriter* writer);
 884 extern void GEOS_DLL GEOSWKBWriter_setOutputDimension(GEOSWKBWriter* writer, int newDimension);
 885
 886 extern int GEOS_DLL GEOSWKBWriter_getOutputDimension_r(
 887                                   GEOSContextHandle_t handle,
 888                                   const GEOSWKBWriter* writer);
 889 extern void GEOS_DLL GEOSWKBWriter_setOutputDimension_r(
 890                                    GEOSContextHandle_t handle,
 891                                    GEOSWKBWriter* writer, int newDimension);
 892
 893 /*
 894  * Specify whether the WKB byte order is big or little endian.
 895  * The return value is the previous byte order.
 896  */
 897 extern int GEOS_DLL GEOSWKBWriter_getByteOrder(const GEOSWKBWriter* writer);
 898 extern void GEOS_DLL GEOSWKBWriter_setByteOrder(GEOSWKBWriter* writer, int byteOrder);
 899
 900 extern int GEOS_DLL GEOSWKBWriter_getByteOrder_r(GEOSContextHandle_t handle,
 901                                                  const GEOSWKBWriter* writer);
 902 extern void GEOS_DLL GEOSWKBWriter_setByteOrder_r(GEOSContextHandle_t handle,
 903                                                   GEOSWKBWriter* writer,
 904                                                   int byteOrder);
 905
 906 /*
 907  * Specify whether SRID values should be output.
 908  */
 909 extern char GEOS_DLL GEOSWKBWriter_getIncludeSRID(const GEOSWKBWriter* writer);
 910 extern void GEOS_DLL GEOSWKBWriter_setIncludeSRID(GEOSWKBWriter* writer, const char writeSRID);
 911
 912 extern char GEOS_DLL GEOSWKBWriter_getIncludeSRID_r(GEOSContextHandle_t handle,
 913                                    const GEOSWKBWriter* writer);
 914 extern void GEOS_DLL GEOSWKBWriter_setIncludeSRID_r(GEOSContextHandle_t handle,
 915                                    GEOSWKBWriter* writer, const char writeSRID);
 916
 917
 918 /*
 919  * Free buffers returned by stuff like GEOSWKBWriter_write(),
 920  * GEOSWKBWriter_writeHEX() and GEOSWKTWriter_write().
 921  */
 922 extern void GEOS_DLL GEOSFree( void *buffer );
 923 extern void GEOS_DLL GEOSFree_r( GEOSContextHandle_t handle, void *buffer );
 924
 925 #ifdef __cplusplus
 926 } // extern "C"
 927 #endif
 928
 929 #endif /* #ifndef GEOS_C_H_INCLUDED */