GEOS  3.4.2
geos_c.h
00001 /************************************************************************
00002  *
00003  *
00004  * C-Wrapper for GEOS library
00005  *
00006  * Copyright (C) 2010 2011 Sandro Santilli <strk@keybit.net>
00007  * Copyright (C) 2005 Refractions Research Inc.
00008  *
00009  * This is free software; you can redistribute and/or modify it under
00010  * the terms of the GNU Lesser General Public Licence as published
00011  * by the Free Software Foundation.
00012  * See the COPYING file for more information.
00013  *
00014  * Author: Sandro Santilli <strk@keybit.net>
00015  *
00016  ***********************************************************************
00017  *
00018  * GENERAL NOTES:
00019  *
00020  *      - Remember to call initGEOS() before any use of this library's
00021  *        functions, and call finishGEOS() when done.
00022  *
00023  *      - Currently you have to explicitly GEOSGeom_destroy() all
00024  *        GEOSGeom objects to avoid memory leaks, and to GEOSFree()
00025  *        all returned char * (unless const).
00026  *
00027  *      - Functions ending with _r are thread safe; see details in RFC 3
00028  *        http://trac.osgeo.org/geos/wiki/RFC3
00029  *
00030  ***********************************************************************/
00031 
00032 #ifndef GEOS_C_H_INCLUDED
00033 #define GEOS_C_H_INCLUDED
00034 
00035 #ifndef __cplusplus
00036 # include <stddef.h> /* for size_t definition */
00037 #else
00038 # include <cstddef>
00039 using std::size_t;
00040 #endif
00041 
00042 #ifdef __cplusplus
00043 extern "C" {
00044 #endif
00045 
00046 /************************************************************************
00047  *
00048  * Version
00049  *
00050  ***********************************************************************/
00051 
00052 /*
00053  * Following 'ifdef' hack fixes problem with generating geos_c.h on Windows,
00054  * when building with Visual C++ compiler.
00055  *
00056  */
00057 #if defined(_MSC_VER)
00058 #include <geos/version.h>
00059 #define GEOS_CAPI_VERSION_MAJOR 1
00060 #define GEOS_CAPI_VERSION_MINOR 8
00061 #define GEOS_CAPI_VERSION_PATCH 2
00062 #define GEOS_CAPI_VERSION "3.4.2-CAPI-1.8.2"
00063 #else
00064 #ifndef GEOS_VERSION_MAJOR
00065 #define GEOS_VERSION_MAJOR 3
00066 #endif
00067 #ifndef GEOS_VERSION_MINOR
00068 #define GEOS_VERSION_MINOR 4
00069 #endif
00070 #ifndef GEOS_VERSION_PATCH
00071 #define GEOS_VERSION_PATCH 2
00072 #endif
00073 #ifndef GEOS_VERSION
00074 #define GEOS_VERSION "3.4.2"
00075 #endif
00076 #ifndef GEOS_JTS_PORT
00077 #define GEOS_JTS_PORT "1.12.0"
00078 #endif
00079 
00080 #define GEOS_CAPI_VERSION_MAJOR 1
00081 #define GEOS_CAPI_VERSION_MINOR 8
00082 #define GEOS_CAPI_VERSION_PATCH 2
00083 #define GEOS_CAPI_VERSION "3.4.2-CAPI-1.8.2"
00084 #endif
00085 
00086 #define GEOS_CAPI_FIRST_INTERFACE GEOS_CAPI_VERSION_MAJOR
00087 #define GEOS_CAPI_LAST_INTERFACE (GEOS_CAPI_VERSION_MAJOR+GEOS_CAPI_VERSION_MINOR)
00088 
00089 /************************************************************************
00090  *
00091  * (Abstract) type definitions
00092  *
00093  ************************************************************************/
00094 
00095 typedef void (*GEOSMessageHandler)(const char *fmt, ...);
00096 
00097 /* When we're included by geos_c.cpp, those are #defined to the original
00098  * JTS definitions via preprocessor. We don't touch them to allow the
00099  * compiler to cross-check the declarations. However, for all "normal"
00100  * C-API users, we need to define them as "opaque" struct pointers, as
00101  * those clients don't have access to the original C++ headers, by design.
00102  */
00103 #ifndef GEOSGeometry
00104 typedef struct GEOSGeom_t GEOSGeometry;
00105 typedef struct GEOSPrepGeom_t GEOSPreparedGeometry;
00106 typedef struct GEOSCoordSeq_t GEOSCoordSequence;
00107 typedef struct GEOSSTRtree_t GEOSSTRtree;
00108 typedef struct GEOSBufParams_t GEOSBufferParams;
00109 #endif
00110 
00111 /* Those are compatibility definitions for source compatibility
00112  * with GEOS 2.X clients relying on that type.
00113  */
00114 typedef GEOSGeometry* GEOSGeom;
00115 typedef GEOSCoordSequence* GEOSCoordSeq;
00116 
00117 /* Supported geometry types
00118  * This was renamed from GEOSGeomTypeId in GEOS 2.2.X, which might
00119  * break compatibility, this issue is still under investigation.
00120  */
00121 
00122 enum GEOSGeomTypes {
00123     GEOS_POINT,
00124     GEOS_LINESTRING,
00125     GEOS_LINEARRING,
00126     GEOS_POLYGON,
00127     GEOS_MULTIPOINT,
00128     GEOS_MULTILINESTRING,
00129     GEOS_MULTIPOLYGON,
00130     GEOS_GEOMETRYCOLLECTION
00131 };
00132 
00133 /* Byte oders exposed via the c api */
00134 enum GEOSByteOrders {
00135     GEOS_WKB_XDR = 0, /* Big Endian */
00136     GEOS_WKB_NDR = 1 /* Little Endian */
00137 };
00138 
00139 typedef struct GEOSContextHandle_HS *GEOSContextHandle_t;
00140 
00141 typedef void (*GEOSQueryCallback)(void *item, void *userdata);
00142 
00143 /************************************************************************
00144  *
00145  * Initialization, cleanup, version
00146  *
00147  ***********************************************************************/
00148 
00149 #include <geos/export.h>
00150 
00151 extern void GEOS_DLL initGEOS(GEOSMessageHandler notice_function,
00152         GEOSMessageHandler error_function);
00153 extern void GEOS_DLL finishGEOS(void);
00154 
00155 /*
00156  * Register an interruption checking callback
00157  *
00158  * The callback will be invoked _before_ checking for
00159  * interruption, so can be used to request it.
00160  */
00161 typedef void (GEOSInterruptCallback)();
00162 extern GEOSInterruptCallback GEOS_DLL *GEOS_interruptRegisterCallback(GEOSInterruptCallback* cb);
00163 /* Request safe interruption of operations */
00164 extern void GEOS_DLL GEOS_interruptRequest();
00165 /* Cancel a pending interruption request */
00166 extern void GEOS_DLL GEOS_interruptCancel();
00167 
00168 
00169 extern GEOSContextHandle_t GEOS_DLL initGEOS_r(
00170                                     GEOSMessageHandler notice_function,
00171                                     GEOSMessageHandler error_function);
00172 extern void GEOS_DLL finishGEOS_r(GEOSContextHandle_t handle);
00173 
00174 extern GEOSMessageHandler GEOS_DLL GEOSContext_setNoticeHandler_r(GEOSContextHandle_t extHandle,
00175                                                                   GEOSMessageHandler nf);
00176 extern GEOSMessageHandler GEOS_DLL GEOSContext_setErrorHandler_r(GEOSContextHandle_t extHandle,
00177                                                                  GEOSMessageHandler ef);
00178 
00179 extern const char GEOS_DLL *GEOSversion();
00180 
00181 
00182 /************************************************************************
00183  *
00184  * NOTE - These functions are DEPRECATED.  Please use the new Reader and
00185  * writer APIS!
00186  *
00187  ***********************************************************************/
00188 
00189 extern GEOSGeometry GEOS_DLL *GEOSGeomFromWKT(const char *wkt);
00190 extern char GEOS_DLL *GEOSGeomToWKT(const GEOSGeometry* g);
00191 
00192 extern GEOSGeometry GEOS_DLL *GEOSGeomFromWKT_r(GEOSContextHandle_t handle,
00193                                                 const char *wkt);
00194 extern char GEOS_DLL *GEOSGeomToWKT_r(GEOSContextHandle_t handle,
00195                                       const GEOSGeometry* g);
00196 
00197 /*
00198  * Specify whether output WKB should be 2d or 3d.
00199  * Return previously set number of dimensions.
00200  */
00201 extern int GEOS_DLL GEOS_getWKBOutputDims();
00202 extern int GEOS_DLL GEOS_setWKBOutputDims(int newDims);
00203 
00204 extern int GEOS_DLL GEOS_getWKBOutputDims_r(GEOSContextHandle_t handle);
00205 extern int GEOS_DLL GEOS_setWKBOutputDims_r(GEOSContextHandle_t handle,
00206                                             int newDims);
00207 
00208 /*
00209  * Specify whether the WKB byte order is big or little endian.
00210  * The return value is the previous byte order.
00211  */
00212 extern int GEOS_DLL GEOS_getWKBByteOrder();
00213 extern int GEOS_DLL GEOS_setWKBByteOrder(int byteOrder);
00214 
00215 extern GEOSGeometry GEOS_DLL *GEOSGeomFromWKB_buf(const unsigned char *wkb, size_t size);
00216 extern unsigned char GEOS_DLL *GEOSGeomToWKB_buf(const GEOSGeometry* g, size_t *size);
00217 
00218 extern GEOSGeometry GEOS_DLL *GEOSGeomFromHEX_buf(const unsigned char *hex, size_t size);
00219 extern unsigned char GEOS_DLL *GEOSGeomToHEX_buf(const GEOSGeometry* g, size_t *size);
00220 
00221 extern int GEOS_DLL GEOS_getWKBByteOrder_r(GEOSContextHandle_t handle);
00222 extern int GEOS_DLL GEOS_setWKBByteOrder_r(GEOSContextHandle_t handle,
00223                                            int byteOrder);
00224 
00225 extern GEOSGeometry GEOS_DLL *GEOSGeomFromWKB_buf_r(GEOSContextHandle_t handle,
00226                                                     const unsigned char *wkb,
00227                                                     size_t size);
00228 extern unsigned char GEOS_DLL *GEOSGeomToWKB_buf_r(GEOSContextHandle_t handle,
00229                                                    const GEOSGeometry* g,
00230                                                    size_t *size);
00231 
00232 extern GEOSGeometry GEOS_DLL *GEOSGeomFromHEX_buf_r(GEOSContextHandle_t handle,
00233                                                     const unsigned char *hex,
00234                                                     size_t size);
00235 extern unsigned char GEOS_DLL *GEOSGeomToHEX_buf_r(GEOSContextHandle_t handle,
00236                                                    const GEOSGeometry* g,
00237                                                    size_t *size);
00238 
00239 /************************************************************************
00240  *
00241  * Coordinate Sequence functions
00242  *
00243  ***********************************************************************/
00244 
00245 /*
00246  * Create a Coordinate sequence with ``size'' coordinates
00247  * of ``dims'' dimensions.
00248  * Return NULL on exception.
00249  */
00250 extern GEOSCoordSequence GEOS_DLL *GEOSCoordSeq_create(unsigned int size, unsigned int dims);
00251 
00252 extern GEOSCoordSequence GEOS_DLL *GEOSCoordSeq_create_r(
00253                                                 GEOSContextHandle_t handle,
00254                                                 unsigned int size,
00255                                                 unsigned int dims);
00256 
00257 /*
00258  * Clone a Coordinate Sequence.
00259  * Return NULL on exception.
00260  */
00261 extern GEOSCoordSequence GEOS_DLL *GEOSCoordSeq_clone(const GEOSCoordSequence* s);
00262 
00263 extern GEOSCoordSequence GEOS_DLL *GEOSCoordSeq_clone_r(
00264                                                 GEOSContextHandle_t handle,
00265                                                 const GEOSCoordSequence* s);
00266 
00267 /*
00268  * Destroy a Coordinate Sequence.
00269  */
00270 extern void GEOS_DLL GEOSCoordSeq_destroy(GEOSCoordSequence* s);
00271 
00272 extern void GEOS_DLL GEOSCoordSeq_destroy_r(GEOSContextHandle_t handle,
00273                                             GEOSCoordSequence* s);
00274 
00275 /*
00276  * Set ordinate values in a Coordinate Sequence.
00277  * Return 0 on exception.
00278  */
00279 extern int GEOS_DLL GEOSCoordSeq_setX(GEOSCoordSequence* s,
00280         unsigned int idx, double val);
00281 extern int GEOS_DLL GEOSCoordSeq_setY(GEOSCoordSequence* s,
00282         unsigned int idx, double val);
00283 extern int GEOS_DLL GEOSCoordSeq_setZ(GEOSCoordSequence* s,
00284         unsigned int idx, double val);
00285 extern int GEOS_DLL GEOSCoordSeq_setOrdinate(GEOSCoordSequence* s,
00286         unsigned int idx, unsigned int dim, double val);
00287 
00288 extern int GEOS_DLL GEOSCoordSeq_setX_r(GEOSContextHandle_t handle,
00289                                         GEOSCoordSequence* s, unsigned int idx,
00290                                         double val);
00291 extern int GEOS_DLL GEOSCoordSeq_setY_r(GEOSContextHandle_t handle,
00292                                         GEOSCoordSequence* s, unsigned int idx,
00293                                         double val);
00294 extern int GEOS_DLL GEOSCoordSeq_setZ_r(GEOSContextHandle_t handle,
00295                                         GEOSCoordSequence* s, unsigned int idx,
00296                                         double val);
00297 extern int GEOS_DLL GEOSCoordSeq_setOrdinate_r(GEOSContextHandle_t handle,
00298                                                GEOSCoordSequence* s,
00299                                                unsigned int idx,
00300                                                unsigned int dim, double val);
00301 
00302 /*
00303  * Get ordinate values from a Coordinate Sequence.
00304  * Return 0 on exception.
00305  */
00306 extern int GEOS_DLL GEOSCoordSeq_getX(const GEOSCoordSequence* s,
00307         unsigned int idx, double *val);
00308 extern int GEOS_DLL GEOSCoordSeq_getY(const GEOSCoordSequence* s,
00309         unsigned int idx, double *val);
00310 extern int GEOS_DLL GEOSCoordSeq_getZ(const GEOSCoordSequence* s,
00311         unsigned int idx, double *val);
00312 extern int GEOS_DLL GEOSCoordSeq_getOrdinate(const GEOSCoordSequence* s,
00313         unsigned int idx, unsigned int dim, double *val);
00314 
00315 extern int GEOS_DLL GEOSCoordSeq_getX_r(GEOSContextHandle_t handle,
00316                                         const GEOSCoordSequence* s,
00317                                         unsigned int idx, double *val);
00318 extern int GEOS_DLL GEOSCoordSeq_getY_r(GEOSContextHandle_t handle,
00319                                         const GEOSCoordSequence* s,
00320                                         unsigned int idx, double *val);
00321 extern int GEOS_DLL GEOSCoordSeq_getZ_r(GEOSContextHandle_t handle,
00322                                         const GEOSCoordSequence* s,
00323                                         unsigned int idx, double *val);
00324 extern int GEOS_DLL GEOSCoordSeq_getOrdinate_r(GEOSContextHandle_t handle,
00325                                                const GEOSCoordSequence* s,
00326                                                unsigned int idx,
00327                                                unsigned int dim, double *val);
00328 /*
00329  * Get size and dimensions info from a Coordinate Sequence.
00330  * Return 0 on exception.
00331  */
00332 extern int GEOS_DLL GEOSCoordSeq_getSize(const GEOSCoordSequence* s,
00333         unsigned int *size);
00334 extern int GEOS_DLL GEOSCoordSeq_getDimensions(const GEOSCoordSequence* s,
00335         unsigned int *dims);
00336 
00337 extern int GEOS_DLL GEOSCoordSeq_getSize_r(GEOSContextHandle_t handle,
00338                                            const GEOSCoordSequence* s,
00339                                            unsigned int *size);
00340 extern int GEOS_DLL GEOSCoordSeq_getDimensions_r(GEOSContextHandle_t handle,
00341                                                  const GEOSCoordSequence* s,
00342                                                  unsigned int *dims);
00343 
00344 /************************************************************************
00345  *
00346  *  Linear referencing functions -- there are more, but these are
00347  *  probably sufficient for most purposes
00348  *
00349  ***********************************************************************/
00350 
00351 /*
00352  * GEOSGeometry ownership is retained by caller
00353  */
00354 
00355 
00356 /* Return distance of point 'p' projected on 'g' from origin
00357  * of 'g'. Geometry 'g' must be a lineal geometry */
00358 extern double GEOS_DLL GEOSProject(const GEOSGeometry *g,
00359                                    const GEOSGeometry* p);
00360 extern double GEOS_DLL GEOSProject_r(GEOSContextHandle_t handle,
00361                                      const GEOSGeometry *g,
00362                                      const GEOSGeometry *p);
00363 
00364 /* Return closest point to given distance within geometry
00365  * Geometry must be a LineString */
00366 extern GEOSGeometry GEOS_DLL *GEOSInterpolate(const GEOSGeometry *g,
00367                                               double d);
00368 extern GEOSGeometry GEOS_DLL *GEOSInterpolate_r(GEOSContextHandle_t handle,
00369                                                 const GEOSGeometry *g,
00370                                                 double d);
00371 
00372 extern double GEOS_DLL GEOSProjectNormalized(const GEOSGeometry *g,
00373                                              const GEOSGeometry* p);
00374 extern double GEOS_DLL GEOSProjectNormalized_r(GEOSContextHandle_t handle,
00375                                                const GEOSGeometry *g,
00376                                                const GEOSGeometry *p);
00377 
00378 extern GEOSGeometry GEOS_DLL *GEOSInterpolateNormalized(const GEOSGeometry *g,
00379                                                         double d);
00380 extern GEOSGeometry GEOS_DLL *GEOSInterpolateNormalized_r(
00381                                                 GEOSContextHandle_t handle,
00382                                                 const GEOSGeometry *g,
00383                                                 double d);
00384 
00385 /************************************************************************
00386  *
00387  * Buffer related functions
00388  *
00389  ***********************************************************************/
00390 
00391 
00392 /* @return NULL on exception */
00393 extern GEOSGeometry GEOS_DLL *GEOSBuffer(const GEOSGeometry* g,
00394         double width, int quadsegs);
00395 extern GEOSGeometry GEOS_DLL *GEOSBuffer_r(GEOSContextHandle_t handle,
00396                                            const GEOSGeometry* g,
00397                                            double width, int quadsegs);
00398 
00399 enum GEOSBufCapStyles {
00400         GEOSBUF_CAP_ROUND=1,
00401         GEOSBUF_CAP_FLAT=2,
00402         GEOSBUF_CAP_SQUARE=3
00403 };
00404 
00405 enum GEOSBufJoinStyles {
00406         GEOSBUF_JOIN_ROUND=1,
00407         GEOSBUF_JOIN_MITRE=2,
00408         GEOSBUF_JOIN_BEVEL=3
00409 };
00410 
00411 /* @return 0 on exception */
00412 extern GEOSBufferParams GEOS_DLL *GEOSBufferParams_create();
00413 extern GEOSBufferParams GEOS_DLL *GEOSBufferParams_create_r(
00414                                               GEOSContextHandle_t handle);
00415 extern void GEOS_DLL GEOSBufferParams_destroy(GEOSBufferParams* parms);
00416 extern void GEOS_DLL GEOSBufferParams_destroy_r(
00417                                               GEOSContextHandle_t handle,
00418                                               GEOSBufferParams* parms);
00419 
00420 /* @return 0 on exception */
00421 extern int GEOS_DLL GEOSBufferParams_setEndCapStyle(
00422                                               GEOSBufferParams* p,
00423                                               int style);
00424 extern int GEOS_DLL GEOSBufferParams_setEndCapStyle_r(
00425                                               GEOSContextHandle_t handle,
00426                                               GEOSBufferParams* p,
00427                                               int style);
00428 
00429 /* @return 0 on exception */
00430 extern int GEOS_DLL GEOSBufferParams_setJoinStyle(
00431                                               GEOSBufferParams* p,
00432                                               int joinStyle);
00433 extern int GEOS_DLL GEOSBufferParams_setJoinStyle_r(
00434                                               GEOSContextHandle_t handle,
00435                                               GEOSBufferParams* p,
00436                                               int joinStyle);
00437 
00438 /* @return 0 on exception */
00439 extern int GEOS_DLL GEOSBufferParams_setMitreLimit(
00440                                               GEOSBufferParams* p,
00441                                               double mitreLimit);
00442 extern int GEOS_DLL GEOSBufferParams_setMitreLimit_r(
00443                                               GEOSContextHandle_t handle,
00444                                               GEOSBufferParams* p,
00445                                               double mitreLimit);
00446 
00447 /* @return 0 on exception */
00448 extern int GEOS_DLL GEOSBufferParams_setQuadrantSegments(
00449                                               GEOSBufferParams* p,
00450                                               int quadSegs);
00451 extern int GEOS_DLL GEOSBufferParams_setQuadrantSegments_r(
00452                                               GEOSContextHandle_t handle,
00453                                               GEOSBufferParams* p,
00454                                               int quadSegs);
00455 
00456 /* @param singleSided: 1 for single sided, 0 otherwise */
00457 /* @return 0 on exception */
00458 extern int GEOS_DLL GEOSBufferParams_setSingleSided(
00459                                               GEOSBufferParams* p,
00460                                               int singleSided);
00461 extern int GEOS_DLL GEOSBufferParams_setSingleSided_r(
00462                                               GEOSContextHandle_t handle,
00463                                               GEOSBufferParams* p,
00464                                               int singleSided);
00465 
00466 /* @return NULL on exception */
00467 extern GEOSGeometry GEOS_DLL *GEOSBufferWithParams(
00468                                               const GEOSGeometry* g,
00469                                               const GEOSBufferParams* p,
00470                                               double width);
00471 extern GEOSGeometry GEOS_DLL *GEOSBufferWithParams_r(
00472                                               GEOSContextHandle_t handle,
00473                                               const GEOSGeometry* g,
00474                                               const GEOSBufferParams* p,
00475                                               double width);
00476 
00477 /* These functions return NULL on exception. */
00478 extern GEOSGeometry GEOS_DLL *GEOSBufferWithStyle(const GEOSGeometry* g,
00479         double width, int quadsegs, int endCapStyle, int joinStyle,
00480         double mitreLimit);
00481 extern GEOSGeometry GEOS_DLL *GEOSBufferWithStyle_r(GEOSContextHandle_t handle,
00482         const GEOSGeometry* g, double width, int quadsegs, int endCapStyle,
00483         int joinStyle, double mitreLimit);
00484 
00485 /* These functions return NULL on exception. Only LINESTRINGs are accepted. */
00486 /* @deprecated in 3.3.0: use GEOSOffsetCurve instead */
00487 extern GEOSGeometry GEOS_DLL *GEOSSingleSidedBuffer(const GEOSGeometry* g,
00488         double width, int quadsegs, int joinStyle, double mitreLimit,
00489         int leftSide);
00490 extern GEOSGeometry GEOS_DLL *GEOSSingleSidedBuffer_r(
00491         GEOSContextHandle_t handle,
00492         const GEOSGeometry* g, double width, int quadsegs,
00493         int joinStyle, double mitreLimit, int leftSide);
00494 
00495 /*
00496  * Only LINESTRINGs are accepted.
00497  * @param width : offset distance.
00498  *                negative for right side offset.
00499  *                positive for left side offset.
00500  * @return NULL on exception
00501  */
00502 extern GEOSGeometry GEOS_DLL *GEOSOffsetCurve(const GEOSGeometry* g,
00503         double width, int quadsegs, int joinStyle, double mitreLimit);
00504 extern GEOSGeometry GEOS_DLL *GEOSOffsetCurve_r(GEOSContextHandle_t handle,
00505         const GEOSGeometry* g, double width, int quadsegs,
00506         int joinStyle, double mitreLimit);
00507 
00508 
00509 /************************************************************************
00510  *
00511  * Geometry Constructors.
00512  * GEOSCoordSequence* arguments will become ownership of the returned object.
00513  * All functions return NULL on exception.
00514  *
00515  ***********************************************************************/
00516 
00517 extern GEOSGeometry GEOS_DLL *GEOSGeom_createPoint(GEOSCoordSequence* s);
00518 extern GEOSGeometry GEOS_DLL *GEOSGeom_createEmptyPoint();
00519 extern GEOSGeometry GEOS_DLL *GEOSGeom_createLinearRing(GEOSCoordSequence* s);
00520 extern GEOSGeometry GEOS_DLL *GEOSGeom_createLineString(GEOSCoordSequence* s);
00521 extern GEOSGeometry GEOS_DLL *GEOSGeom_createEmptyLineString();
00522 
00523 extern GEOSGeometry GEOS_DLL *GEOSGeom_createPoint_r(
00524                                        GEOSContextHandle_t handle,
00525                                        GEOSCoordSequence* s);
00526 extern GEOSGeometry GEOS_DLL *GEOSGeom_createEmptyPoint_r(
00527                                        GEOSContextHandle_t handle);
00528 extern GEOSGeometry GEOS_DLL *GEOSGeom_createLinearRing_r(
00529                                        GEOSContextHandle_t handle,
00530                                        GEOSCoordSequence* s);
00531 extern GEOSGeometry GEOS_DLL *GEOSGeom_createLineString_r(
00532                                        GEOSContextHandle_t handle,
00533                                        GEOSCoordSequence* s);
00534 extern GEOSGeometry GEOS_DLL *GEOSGeom_createEmptyLineString_r(
00535                                        GEOSContextHandle_t handle);
00536 
00537 /*
00538  * Second argument is an array of GEOSGeometry* objects.
00539  * The caller remains owner of the array, but pointed-to
00540  * objects become ownership of the returned GEOSGeometry.
00541  */
00542 extern GEOSGeometry GEOS_DLL *GEOSGeom_createEmptyPolygon();
00543 extern GEOSGeometry GEOS_DLL *GEOSGeom_createPolygon(GEOSGeometry* shell,
00544         GEOSGeometry** holes, unsigned int nholes);
00545 extern GEOSGeometry GEOS_DLL *GEOSGeom_createCollection(int type,
00546         GEOSGeometry* *geoms, unsigned int ngeoms);
00547 extern GEOSGeometry GEOS_DLL *GEOSGeom_createEmptyCollection(int type);
00548 
00549 extern GEOSGeometry GEOS_DLL *GEOSGeom_createEmptyPolygon_r(
00550                                        GEOSContextHandle_t handle);
00551 extern GEOSGeometry GEOS_DLL *GEOSGeom_createPolygon_r(
00552                                        GEOSContextHandle_t handle,
00553                                        GEOSGeometry* shell,
00554                                        GEOSGeometry** holes,
00555                                        unsigned int nholes);
00556 extern GEOSGeometry GEOS_DLL *GEOSGeom_createCollection_r(
00557                                        GEOSContextHandle_t handle, int type,
00558                                        GEOSGeometry* *geoms,
00559                                        unsigned int ngeoms);
00560 extern GEOSGeometry GEOS_DLL *GEOSGeom_createEmptyCollection_r(
00561                                        GEOSContextHandle_t handle, int type);
00562 
00563 extern GEOSGeometry GEOS_DLL *GEOSGeom_clone(const GEOSGeometry* g);
00564 
00565 extern GEOSGeometry GEOS_DLL *GEOSGeom_clone_r(GEOSContextHandle_t handle,
00566                                                const GEOSGeometry* g);
00567 
00568 /************************************************************************
00569  *
00570  * Memory management
00571  *
00572  ***********************************************************************/
00573 
00574 extern void GEOS_DLL GEOSGeom_destroy(GEOSGeometry* g);
00575 
00576 extern void GEOS_DLL GEOSGeom_destroy_r(GEOSContextHandle_t handle,
00577                                         GEOSGeometry* g);
00578 
00579 /************************************************************************
00580  *
00581  * Topology operations - return NULL on exception.
00582  *
00583  ***********************************************************************/
00584 
00585 extern GEOSGeometry GEOS_DLL *GEOSEnvelope(const GEOSGeometry* g);
00586 extern GEOSGeometry GEOS_DLL *GEOSIntersection(const GEOSGeometry* g1, const GEOSGeometry* g2);
00587 extern GEOSGeometry GEOS_DLL *GEOSConvexHull(const GEOSGeometry* g);
00588 extern GEOSGeometry GEOS_DLL *GEOSDifference(const GEOSGeometry* g1, const GEOSGeometry* g2);
00589 extern GEOSGeometry GEOS_DLL *GEOSSymDifference(const GEOSGeometry* g1, const GEOSGeometry* g2);
00590 extern GEOSGeometry GEOS_DLL *GEOSBoundary(const GEOSGeometry* g);
00591 extern GEOSGeometry GEOS_DLL *GEOSUnion(const GEOSGeometry* g1, const GEOSGeometry* g2);
00592 extern GEOSGeometry GEOS_DLL *GEOSUnaryUnion(const GEOSGeometry* g);
00593 
00594 /* @deprecated in 3.3.0: use GEOSUnaryUnion instead */
00595 extern GEOSGeometry GEOS_DLL *GEOSUnionCascaded(const GEOSGeometry* g);
00596 extern GEOSGeometry GEOS_DLL *GEOSPointOnSurface(const GEOSGeometry* g);
00597 extern GEOSGeometry GEOS_DLL *GEOSGetCentroid(const GEOSGeometry* g);
00598 extern GEOSGeometry GEOS_DLL *GEOSNode(const GEOSGeometry* g);
00599 
00600 extern GEOSGeometry GEOS_DLL *GEOSEnvelope_r(GEOSContextHandle_t handle,
00601                                              const GEOSGeometry* g);
00602 extern GEOSGeometry GEOS_DLL *GEOSIntersection_r(GEOSContextHandle_t handle,
00603                                                  const GEOSGeometry* g1,
00604                                                  const GEOSGeometry* g2);
00605 extern GEOSGeometry GEOS_DLL *GEOSConvexHull_r(GEOSContextHandle_t handle,
00606                                                const GEOSGeometry* g);
00607 extern GEOSGeometry GEOS_DLL *GEOSDifference_r(GEOSContextHandle_t handle,
00608                                                const GEOSGeometry* g1,
00609                                                const GEOSGeometry* g2);
00610 extern GEOSGeometry GEOS_DLL *GEOSSymDifference_r(GEOSContextHandle_t handle,
00611                                                   const GEOSGeometry* g1,
00612                                                   const GEOSGeometry* g2);
00613 extern GEOSGeometry GEOS_DLL *GEOSBoundary_r(GEOSContextHandle_t handle,
00614                                              const GEOSGeometry* g);
00615 extern GEOSGeometry GEOS_DLL *GEOSUnion_r(GEOSContextHandle_t handle,
00616                                           const GEOSGeometry* g1,
00617                                           const GEOSGeometry* g2);
00618 extern GEOSGeometry GEOS_DLL *GEOSUnaryUnion_r(GEOSContextHandle_t handle,
00619                                           const GEOSGeometry* g);
00620 extern GEOSGeometry GEOS_DLL *GEOSUnionCascaded_r(GEOSContextHandle_t handle,
00621                                                   const GEOSGeometry* g);
00622 extern GEOSGeometry GEOS_DLL *GEOSPointOnSurface_r(GEOSContextHandle_t handle,
00623                                                    const GEOSGeometry* g);
00624 extern GEOSGeometry GEOS_DLL *GEOSGetCentroid_r(GEOSContextHandle_t handle,
00625                                                 const GEOSGeometry* g);
00626 extern GEOSGeometry GEOS_DLL *GEOSNode_r(GEOSContextHandle_t handle,
00627                                          const GEOSGeometry* g);
00628 
00629 /*
00630  * all arguments remain ownership of the caller
00631  * (both Geometries and pointers)
00632  */
00633 extern GEOSGeometry GEOS_DLL *GEOSPolygonize(const GEOSGeometry * const geoms[], unsigned int ngeoms);
00634 extern GEOSGeometry GEOS_DLL *GEOSPolygonizer_getCutEdges(const GEOSGeometry * const geoms[], unsigned int ngeoms);
00635 /*
00636  * Polygonizes a set of Geometries which contain linework that
00637  * represents the edges of a planar graph.
00638  *
00639  * Any dimension of Geometry is handled - the constituent linework
00640  * is extracted to form the edges.
00641  *
00642  * The edges must be correctly noded; that is, they must only meet
00643  * at their endpoints.
00644  * The Polygonizer will still run on incorrectly noded input
00645  * but will not form polygons from incorrectly noded edges.
00646  *
00647  * The Polygonizer reports the follow kinds of errors:
00648  *
00649  * - Dangles - edges which have one or both ends which are
00650  *   not incident on another edge endpoint
00651  * - Cut Edges - edges which are connected at both ends but
00652  *   which do not form part of polygon
00653  * - Invalid Ring Lines - edges which form rings which are invalid
00654  *   (e.g. the component lines contain a self-intersection)
00655  *
00656  * Errors are reported to output parameters "cuts", "dangles" and
00657  * "invalid" (if not-null). Formed polygons are returned as a
00658  * collection. NULL is returned on exception. All returned
00659  * geometries must be destroyed by caller.
00660  *
00661  */
00662 extern GEOSGeometry GEOS_DLL *GEOSPolygonize_full(const GEOSGeometry* input,
00663         GEOSGeometry** cuts, GEOSGeometry** dangles, GEOSGeometry** invalid);
00664 
00665 extern GEOSGeometry GEOS_DLL *GEOSLineMerge(const GEOSGeometry* g);
00666 extern GEOSGeometry GEOS_DLL *GEOSSimplify(const GEOSGeometry* g, double tolerance);
00667 extern GEOSGeometry GEOS_DLL *GEOSTopologyPreserveSimplify(const GEOSGeometry* g,
00668         double tolerance);
00669 
00670 extern GEOSGeometry GEOS_DLL *GEOSPolygonize_r(GEOSContextHandle_t handle,
00671                               const GEOSGeometry *const geoms[],
00672                               unsigned int ngeoms);
00673 extern GEOSGeometry GEOS_DLL *GEOSPolygonizer_getCutEdges_r(
00674                               GEOSContextHandle_t handle,
00675                               const GEOSGeometry * const geoms[],
00676                               unsigned int ngeoms);
00677 extern GEOSGeometry GEOS_DLL *GEOSPolygonize_full_r(GEOSContextHandle_t handle,
00678                               const GEOSGeometry* input, GEOSGeometry** cuts,
00679                               GEOSGeometry** dangles, GEOSGeometry** invalidRings);
00680 
00681 extern GEOSGeometry GEOS_DLL *GEOSLineMerge_r(GEOSContextHandle_t handle,
00682                                               const GEOSGeometry* g);
00683 extern GEOSGeometry GEOS_DLL *GEOSSimplify_r(GEOSContextHandle_t handle,
00684                                              const GEOSGeometry* g,
00685                                              double tolerance);
00686 extern GEOSGeometry GEOS_DLL *GEOSTopologyPreserveSimplify_r(
00687                               GEOSContextHandle_t handle,
00688                               const GEOSGeometry* g, double tolerance);
00689 
00690 /*
00691  * Return all distinct vertices of input geometry as a MULTIPOINT.
00692  * Note that only 2 dimensions of the vertices are considered when
00693  * testing for equality.
00694  */
00695 extern GEOSGeometry GEOS_DLL *GEOSGeom_extractUniquePoints(
00696                               const GEOSGeometry* g);
00697 extern GEOSGeometry GEOS_DLL *GEOSGeom_extractUniquePoints_r(
00698                               GEOSContextHandle_t handle,
00699                               const GEOSGeometry* g);
00700 
00701 /*
00702  * Find paths shared between the two given lineal geometries.
00703  *
00704  * Returns a GEOMETRYCOLLECTION having two elements:
00705  * - first element is a MULTILINESTRING containing shared paths
00706  *   having the _same_ direction on both inputs
00707  * - second element is a MULTILINESTRING containing shared paths
00708  *   having the _opposite_ direction on the two inputs
00709  *
00710  * Returns NULL on exception
00711  */
00712 extern GEOSGeometry GEOS_DLL *GEOSSharedPaths(const GEOSGeometry* g1,
00713   const GEOSGeometry* g2);
00714 extern GEOSGeometry GEOS_DLL *GEOSSharedPaths_r(GEOSContextHandle_t handle,
00715   const GEOSGeometry* g1, const GEOSGeometry* g2);
00716 
00717 /*
00718  * Snap first geometry on to second with given tolerance
00719  * Returns a newly allocated geometry, or NULL on exception
00720  */
00721 extern GEOSGeometry GEOS_DLL *GEOSSnap(const GEOSGeometry* g1,
00722   const GEOSGeometry* g2, double tolerance);
00723 extern GEOSGeometry GEOS_DLL *GEOSSnap_r(GEOSContextHandle_t handle,
00724   const GEOSGeometry* g1, const GEOSGeometry* g2, double tolerance);
00725 
00726 /*
00727  * Return a Delaunay triangulation of the vertex of the given geometry
00728  *
00729  * @param g the input geometry whose vertex will be used as "sites"
00730  * @param tolerance optional snapping tolerance to use for improved robustness
00731  * @param onlyEdges if non-zero will return a MULTILINESTRING, otherwise it will
00732  *                  return a GEOMETRYCOLLECTION containing triangular POLYGONs.
00733  *
00734  * @return  a newly allocated geometry, or NULL on exception
00735  */
00736 extern GEOSGeometry GEOS_DLL * GEOSDelaunayTriangulation(
00737                                   const GEOSGeometry *g,
00738                                   double tolerance,
00739                                   int onlyEdges);
00740 
00741 extern GEOSGeometry GEOS_DLL * GEOSDelaunayTriangulation_r(
00742                                   GEOSContextHandle_t handle,
00743                                   const GEOSGeometry *g,
00744                                   double tolerance,
00745                                   int onlyEdges);
00746 
00747 /************************************************************************
00748  *
00749  *  Binary predicates - return 2 on exception, 1 on true, 0 on false
00750  *
00751  ***********************************************************************/
00752 
00753 extern char GEOS_DLL GEOSDisjoint(const GEOSGeometry* g1, const GEOSGeometry* g2);
00754 extern char GEOS_DLL GEOSTouches(const GEOSGeometry* g1, const GEOSGeometry* g2);
00755 extern char GEOS_DLL GEOSIntersects(const GEOSGeometry* g1, const GEOSGeometry* g2);
00756 extern char GEOS_DLL GEOSCrosses(const GEOSGeometry* g1, const GEOSGeometry* g2);
00757 extern char GEOS_DLL GEOSWithin(const GEOSGeometry* g1, const GEOSGeometry* g2);
00758 extern char GEOS_DLL GEOSContains(const GEOSGeometry* g1, const GEOSGeometry* g2);
00759 extern char GEOS_DLL GEOSOverlaps(const GEOSGeometry* g1, const GEOSGeometry* g2);
00760 extern char GEOS_DLL GEOSEquals(const GEOSGeometry* g1, const GEOSGeometry* g2);
00761 extern char GEOS_DLL GEOSEqualsExact(const GEOSGeometry* g1, const GEOSGeometry* g2, double tolerance);
00762 extern char GEOS_DLL GEOSCovers(const GEOSGeometry* g1, const GEOSGeometry* g2);
00763 extern char GEOS_DLL GEOSCoveredBy(const GEOSGeometry* g1, const GEOSGeometry* g2);
00764 
00765 extern char GEOS_DLL GEOSDisjoint_r(GEOSContextHandle_t handle,
00766                                     const GEOSGeometry* g1,
00767                                     const GEOSGeometry* g2);
00768 extern char GEOS_DLL GEOSTouches_r(GEOSContextHandle_t handle,
00769                                    const GEOSGeometry* g1,
00770                                    const GEOSGeometry* g2);
00771 extern char GEOS_DLL GEOSIntersects_r(GEOSContextHandle_t handle,
00772                                       const GEOSGeometry* g1,
00773                                       const GEOSGeometry* g2);
00774 extern char GEOS_DLL GEOSCrosses_r(GEOSContextHandle_t handle,
00775                                    const GEOSGeometry* g1,
00776                                    const GEOSGeometry* g2);
00777 extern char GEOS_DLL GEOSWithin_r(GEOSContextHandle_t handle,
00778                                   const GEOSGeometry* g1,
00779                                   const GEOSGeometry* g2);
00780 extern char GEOS_DLL GEOSContains_r(GEOSContextHandle_t handle,
00781                                     const GEOSGeometry* g1,
00782                                     const GEOSGeometry* g2);
00783 extern char GEOS_DLL GEOSOverlaps_r(GEOSContextHandle_t handle,
00784                                     const GEOSGeometry* g1,
00785                                     const GEOSGeometry* g2);
00786 extern char GEOS_DLL GEOSEquals_r(GEOSContextHandle_t handle,
00787                                   const GEOSGeometry* g1,
00788                                   const GEOSGeometry* g2);
00789 extern char GEOS_DLL GEOSEqualsExact_r(GEOSContextHandle_t handle,
00790                                        const GEOSGeometry* g1,
00791                                        const GEOSGeometry* g2,
00792                                        double tolerance);
00793 extern char GEOS_DLL GEOSCovers_r(GEOSContextHandle_t handle,
00794                                   const GEOSGeometry* g1,
00795                                   const GEOSGeometry* g2);
00796 extern char GEOS_DLL GEOSCoveredBy_r(GEOSContextHandle_t handle,
00797                                   const GEOSGeometry* g1,
00798                                   const GEOSGeometry* g2);
00799 
00800 /************************************************************************
00801  *
00802  *  Prepared Geometry Binary predicates - return 2 on exception, 1 on true, 0 on false
00803  *
00804  ***********************************************************************/
00805 
00806 /*
00807  * GEOSGeometry ownership is retained by caller
00808  */
00809 extern const GEOSPreparedGeometry GEOS_DLL *GEOSPrepare(const GEOSGeometry* g);
00810 
00811 extern void GEOS_DLL GEOSPreparedGeom_destroy(const GEOSPreparedGeometry* g);
00812 
00813 extern char GEOS_DLL GEOSPreparedContains(const GEOSPreparedGeometry* pg1, const GEOSGeometry* g2);
00814 extern char GEOS_DLL GEOSPreparedContainsProperly(const GEOSPreparedGeometry* pg1, const GEOSGeometry* g2);
00815 extern char GEOS_DLL GEOSPreparedCoveredBy(const GEOSPreparedGeometry* pg1, const GEOSGeometry* g2);
00816 extern char GEOS_DLL GEOSPreparedCovers(const GEOSPreparedGeometry* pg1, const GEOSGeometry* g2);
00817 extern char GEOS_DLL GEOSPreparedCrosses(const GEOSPreparedGeometry* pg1, const GEOSGeometry* g2);
00818 extern char GEOS_DLL GEOSPreparedDisjoint(const GEOSPreparedGeometry* pg1, const GEOSGeometry* g2);
00819 extern char GEOS_DLL GEOSPreparedIntersects(const GEOSPreparedGeometry* pg1, const GEOSGeometry* g2);
00820 extern char GEOS_DLL GEOSPreparedOverlaps(const GEOSPreparedGeometry* pg1, const GEOSGeometry* g2);
00821 extern char GEOS_DLL GEOSPreparedTouches(const GEOSPreparedGeometry* pg1, const GEOSGeometry* g2);
00822 extern char GEOS_DLL GEOSPreparedWithin(const GEOSPreparedGeometry* pg1, const GEOSGeometry* g2);
00823 
00824 /*
00825  * GEOSGeometry ownership is retained by caller
00826  */
00827 extern const GEOSPreparedGeometry GEOS_DLL *GEOSPrepare_r(
00828                                             GEOSContextHandle_t handle,
00829                                             const GEOSGeometry* g);
00830 
00831 extern void GEOS_DLL GEOSPreparedGeom_destroy_r(GEOSContextHandle_t handle,
00832                                                 const GEOSPreparedGeometry* g);
00833 
00834 extern char GEOS_DLL GEOSPreparedContains_r(GEOSContextHandle_t handle,
00835                                             const GEOSPreparedGeometry* pg1,
00836                                             const GEOSGeometry* g2);
00837 extern char GEOS_DLL GEOSPreparedContainsProperly_r(GEOSContextHandle_t handle,
00838                                          const GEOSPreparedGeometry* pg1,
00839                                          const GEOSGeometry* g2);
00840 extern char GEOS_DLL GEOSPreparedCoveredBy_r(GEOSContextHandle_t handle,
00841                                           const GEOSPreparedGeometry* pg1,
00842                                           const GEOSGeometry* g2);
00843 extern char GEOS_DLL GEOSPreparedCovers_r(GEOSContextHandle_t handle,
00844                                           const GEOSPreparedGeometry* pg1,
00845                                           const GEOSGeometry* g2);
00846 extern char GEOS_DLL GEOSPreparedCrosses_r(GEOSContextHandle_t handle,
00847                                           const GEOSPreparedGeometry* pg1,
00848                                           const GEOSGeometry* g2);
00849 extern char GEOS_DLL GEOSPreparedDisjoint_r(GEOSContextHandle_t handle,
00850                                           const GEOSPreparedGeometry* pg1,
00851                                           const GEOSGeometry* g2);
00852 extern char GEOS_DLL GEOSPreparedIntersects_r(GEOSContextHandle_t handle,
00853                                               const GEOSPreparedGeometry* pg1,
00854                                               const GEOSGeometry* g2);
00855 extern char GEOS_DLL GEOSPreparedOverlaps_r(GEOSContextHandle_t handle,
00856                                           const GEOSPreparedGeometry* pg1,
00857                                           const GEOSGeometry* g2);
00858 extern char GEOS_DLL GEOSPreparedTouches_r(GEOSContextHandle_t handle,
00859                                           const GEOSPreparedGeometry* pg1,
00860                                           const GEOSGeometry* g2);
00861 extern char GEOS_DLL GEOSPreparedWithin_r(GEOSContextHandle_t handle,
00862                                           const GEOSPreparedGeometry* pg1,
00863                                           const GEOSGeometry* g2);
00864 
00865 /************************************************************************
00866  *
00867  *  STRtree functions
00868  *
00869  ***********************************************************************/
00870 
00871 /*
00872  * GEOSGeometry ownership is retained by caller
00873  */
00874 
00875 extern GEOSSTRtree GEOS_DLL *GEOSSTRtree_create(size_t nodeCapacity);
00876 extern void GEOS_DLL GEOSSTRtree_insert(GEOSSTRtree *tree,
00877                                         const GEOSGeometry *g,
00878                                         void *item);
00879 extern void GEOS_DLL GEOSSTRtree_query(GEOSSTRtree *tree,
00880                                        const GEOSGeometry *g,
00881                                        GEOSQueryCallback callback,
00882                                        void *userdata);
00883 extern void GEOS_DLL GEOSSTRtree_iterate(GEOSSTRtree *tree,
00884                                        GEOSQueryCallback callback,
00885                                        void *userdata);
00886 extern char GEOS_DLL GEOSSTRtree_remove(GEOSSTRtree *tree,
00887                                         const GEOSGeometry *g,
00888                                         void *item);
00889 extern void GEOS_DLL GEOSSTRtree_destroy(GEOSSTRtree *tree);
00890 
00891 
00892 extern GEOSSTRtree GEOS_DLL *GEOSSTRtree_create_r(
00893                                     GEOSContextHandle_t handle,
00894                                     size_t nodeCapacity);
00895 extern void GEOS_DLL GEOSSTRtree_insert_r(GEOSContextHandle_t handle,
00896                                           GEOSSTRtree *tree,
00897                                           const GEOSGeometry *g,
00898                                           void *item);
00899 extern void GEOS_DLL GEOSSTRtree_query_r(GEOSContextHandle_t handle,
00900                                          GEOSSTRtree *tree,
00901                                          const GEOSGeometry *g,
00902                                          GEOSQueryCallback callback,
00903                                          void *userdata);
00904 extern void GEOS_DLL GEOSSTRtree_iterate_r(GEOSContextHandle_t handle,
00905                                        GEOSSTRtree *tree,
00906                                        GEOSQueryCallback callback,
00907                                        void *userdata);
00908 extern char GEOS_DLL GEOSSTRtree_remove_r(GEOSContextHandle_t handle,
00909                                           GEOSSTRtree *tree,
00910                                           const GEOSGeometry *g,
00911                                           void *item);
00912 extern void GEOS_DLL GEOSSTRtree_destroy_r(GEOSContextHandle_t handle,
00913                                            GEOSSTRtree *tree);
00914 
00915 
00916 /************************************************************************
00917  *
00918  *  Unary predicate - return 2 on exception, 1 on true, 0 on false
00919  *
00920  ***********************************************************************/
00921 
00922 extern char GEOS_DLL GEOSisEmpty(const GEOSGeometry* g);
00923 extern char GEOS_DLL GEOSisSimple(const GEOSGeometry* g);
00924 extern char GEOS_DLL GEOSisRing(const GEOSGeometry* g);
00925 extern char GEOS_DLL GEOSHasZ(const GEOSGeometry* g);
00926 extern char GEOS_DLL GEOSisClosed(const GEOSGeometry *g);
00927 
00928 extern char GEOS_DLL GEOSisEmpty_r(GEOSContextHandle_t handle,
00929                                    const GEOSGeometry* g);
00930 extern char GEOS_DLL GEOSisSimple_r(GEOSContextHandle_t handle,
00931                                     const GEOSGeometry* g);
00932 extern char GEOS_DLL GEOSisRing_r(GEOSContextHandle_t handle,
00933                                   const GEOSGeometry* g);
00934 extern char GEOS_DLL GEOSHasZ_r(GEOSContextHandle_t handle,
00935                                 const GEOSGeometry* g);
00936 extern char GEOS_DLL GEOSisClosed_r(GEOSContextHandle_t handle,
00937                                 const GEOSGeometry *g);
00938 
00939 /************************************************************************
00940  *
00941  *  Dimensionally Extended 9 Intersection Model related
00942  *
00943  ***********************************************************************/
00944 
00945 /* These are for use with GEOSRelateBoundaryNodeRule (flags param) */
00946 enum GEOSRelateBoundaryNodeRules {
00947         /* MOD2 and OGC are the same rule, and is the default
00948          * used by GEOSRelatePattern
00949          */
00950         GEOSRELATE_BNR_MOD2=1,
00951         GEOSRELATE_BNR_OGC=1,
00952         GEOSRELATE_BNR_ENDPOINT=2,
00953         GEOSRELATE_BNR_MULTIVALENT_ENDPOINT=3,
00954         GEOSRELATE_BNR_MONOVALENT_ENDPOINT=4
00955 };
00956 
00957 /* return 2 on exception, 1 on true, 0 on false */
00958 extern char GEOS_DLL GEOSRelatePattern(const GEOSGeometry* g1, const GEOSGeometry* g2, const char *pat);
00959 extern char GEOS_DLL GEOSRelatePattern_r(GEOSContextHandle_t handle,
00960                                          const GEOSGeometry* g1,
00961                                          const GEOSGeometry* g2,
00962                                          const char *pat);
00963 
00964 /* return NULL on exception, a string to GEOSFree otherwise */
00965 extern char GEOS_DLL *GEOSRelate(const GEOSGeometry* g1, const GEOSGeometry* g2);
00966 extern char GEOS_DLL *GEOSRelate_r(GEOSContextHandle_t handle,
00967                                    const GEOSGeometry* g1,
00968                                    const GEOSGeometry* g2);
00969 
00970 /* return 2 on exception, 1 on true, 0 on false */
00971 extern char GEOS_DLL GEOSRelatePatternMatch(const char *mat, const char *pat);
00972 extern char GEOS_DLL GEOSRelatePatternMatch_r(GEOSContextHandle_t handle,
00973                                          const char *mat,
00974                                          const char *pat);
00975 
00976 /* return NULL on exception, a string to GEOSFree otherwise */
00977 extern char GEOS_DLL *GEOSRelateBoundaryNodeRule(const GEOSGeometry* g1,
00978                                                  const GEOSGeometry* g2,
00979                                                  int bnr);
00980 extern char GEOS_DLL *GEOSRelateBoundaryNodeRule_r(GEOSContextHandle_t handle,
00981                                                    const GEOSGeometry* g1,
00982                                                    const GEOSGeometry* g2,
00983                                                    int bnr);
00984 
00985 /************************************************************************
00986  *
00987  *  Validity checking
00988  *
00989  ***********************************************************************/
00990 
00991 /* These are for use with GEOSisValidDetail (flags param) */
00992 enum GEOSValidFlags {
00993         GEOSVALID_ALLOW_SELFTOUCHING_RING_FORMING_HOLE=1
00994 };
00995 
00996 /* return 2 on exception, 1 on true, 0 on false */
00997 extern char GEOS_DLL GEOSisValid(const GEOSGeometry* g);
00998 extern char GEOS_DLL GEOSisValid_r(GEOSContextHandle_t handle,
00999                                    const GEOSGeometry* g);
01000 
01001 /* return NULL on exception, a string to GEOSFree otherwise */
01002 extern char GEOS_DLL *GEOSisValidReason(const GEOSGeometry *g);
01003 extern char GEOS_DLL *GEOSisValidReason_r(GEOSContextHandle_t handle,
01004                                          const GEOSGeometry* g);
01005 
01006 /*
01007  * Caller has the responsibility to destroy 'reason' (GEOSFree)
01008  * and 'location' (GEOSGeom_destroy) params
01009  * return 2 on exception, 1 when valid, 0 when invalid
01010  */
01011 extern char GEOS_DLL GEOSisValidDetail(const GEOSGeometry* g,
01012                                        int flags,
01013                                        char** reason, GEOSGeometry** location);
01014 extern char GEOS_DLL GEOSisValidDetail_r(GEOSContextHandle_t handle,
01015                                          const GEOSGeometry* g,
01016                                          int flags,
01017                                          char** reason,
01018                                          GEOSGeometry** location);
01019 
01020 /************************************************************************
01021  *
01022  *  Geometry info
01023  *
01024  ***********************************************************************/
01025 
01026 /* Return NULL on exception, result must be freed by caller. */
01027 extern char GEOS_DLL *GEOSGeomType(const GEOSGeometry* g);
01028 
01029 extern char GEOS_DLL *GEOSGeomType_r(GEOSContextHandle_t handle,
01030                                      const GEOSGeometry* g);
01031 
01032 /* Return -1 on exception */
01033 extern int GEOS_DLL GEOSGeomTypeId(const GEOSGeometry* g);
01034 
01035 extern int GEOS_DLL GEOSGeomTypeId_r(GEOSContextHandle_t handle,
01036                                      const GEOSGeometry* g);
01037 
01038 /* Return 0 on exception */
01039 extern int GEOS_DLL GEOSGetSRID(const GEOSGeometry* g);
01040 extern int GEOS_DLL GEOSGetSRID_r(GEOSContextHandle_t handle,
01041                                   const GEOSGeometry* g);
01042 
01043 extern void GEOS_DLL GEOSSetSRID(GEOSGeometry* g, int SRID);
01044 extern void GEOS_DLL GEOSSetSRID_r(GEOSContextHandle_t handle,
01045                                    GEOSGeometry* g, int SRID);
01046 
01047 /* May be called on all geometries in GEOS 3.x, returns -1 on error and 1
01048  * for non-multi geometries. Older GEOS versions only accept
01049  * GeometryCollections or Multi* geometries here, and are likely to crash
01050  * when fed simple geometries, so beware if you need compatibility with
01051  * old GEOS versions.
01052  */
01053 extern int GEOS_DLL GEOSGetNumGeometries(const GEOSGeometry* g);
01054 
01055 extern int GEOS_DLL GEOSGetNumGeometries_r(GEOSContextHandle_t handle,
01056                                            const GEOSGeometry* g);
01057 
01058 /*
01059  * Return NULL on exception.
01060  * Returned object is a pointer to internal storage:
01061  * it must NOT be destroyed directly.
01062  * Up to GEOS 3.2.0 the input geometry must be a Collection, in
01063  * later version it doesn't matter (getGeometryN(0) for a single will
01064  * return the input).
01065  */
01066 extern const GEOSGeometry GEOS_DLL *GEOSGetGeometryN(const GEOSGeometry* g, int n);
01067 
01068 extern const GEOSGeometry GEOS_DLL *GEOSGetGeometryN_r(
01069                                     GEOSContextHandle_t handle,
01070                                     const GEOSGeometry* g, int n);
01071 
01072 /* Return -1 on exception */
01073 extern int GEOS_DLL GEOSNormalize(GEOSGeometry* g);
01074 
01075 extern int GEOS_DLL GEOSNormalize_r(GEOSContextHandle_t handle,
01076                                     GEOSGeometry* g);
01077 
01078 /* Return -1 on exception */
01079 extern int GEOS_DLL GEOSGetNumInteriorRings(const GEOSGeometry* g);
01080 
01081 extern int GEOS_DLL GEOSGetNumInteriorRings_r(GEOSContextHandle_t handle,
01082                                               const GEOSGeometry* g);
01083 
01084 /* Return -1 on exception, Geometry must be a LineString. */
01085 extern int GEOS_DLL GEOSGeomGetNumPoints(const GEOSGeometry* g);
01086 
01087 extern int GEOS_DLL GEOSGeomGetNumPoints_r(GEOSContextHandle_t handle,
01088                                        const GEOSGeometry* g);
01089 
01090 /* Return -1 on exception, Geometry must be a Point. */
01091 extern int GEOS_DLL GEOSGeomGetX(const GEOSGeometry *g, double *x);
01092 extern int GEOS_DLL GEOSGeomGetY(const GEOSGeometry *g, double *y);
01093 
01094 extern int GEOS_DLL GEOSGeomGetX_r(GEOSContextHandle_t handle, const GEOSGeometry *g, double *x);
01095 extern int GEOS_DLL GEOSGeomGetY_r(GEOSContextHandle_t handle, const GEOSGeometry *g, double *y);
01096 
01097 /*
01098  * Return NULL on exception, Geometry must be a Polygon.
01099  * Returned object is a pointer to internal storage:
01100  * it must NOT be destroyed directly.
01101  */
01102 extern const GEOSGeometry GEOS_DLL *GEOSGetInteriorRingN(const GEOSGeometry* g, int n);
01103 
01104 extern const GEOSGeometry GEOS_DLL *GEOSGetInteriorRingN_r(
01105                                     GEOSContextHandle_t handle,
01106                                     const GEOSGeometry* g, int n);
01107 
01108 /*
01109  * Return NULL on exception, Geometry must be a Polygon.
01110  * Returned object is a pointer to internal storage:
01111  * it must NOT be destroyed directly.
01112  */
01113 extern const GEOSGeometry GEOS_DLL *GEOSGetExteriorRing(const GEOSGeometry* g);
01114 
01115 extern const GEOSGeometry GEOS_DLL *GEOSGetExteriorRing_r(
01116                                     GEOSContextHandle_t handle,
01117                                     const GEOSGeometry* g);
01118 
01119 /* Return -1 on exception */
01120 extern int GEOS_DLL GEOSGetNumCoordinates(const GEOSGeometry* g);
01121 
01122 extern int GEOS_DLL GEOSGetNumCoordinates_r(GEOSContextHandle_t handle,
01123                                             const GEOSGeometry* g);
01124 
01125 /*
01126  * Return NULL on exception.
01127  * Geometry must be a LineString, LinearRing or Point.
01128  */
01129 extern const GEOSCoordSequence GEOS_DLL *GEOSGeom_getCoordSeq(const GEOSGeometry* g);
01130 
01131 extern const GEOSCoordSequence GEOS_DLL *GEOSGeom_getCoordSeq_r(
01132                                          GEOSContextHandle_t handle,
01133                                          const GEOSGeometry* g);
01134 
01135 /*
01136  * Return 0 on exception (or empty geometry)
01137  */
01138 extern int GEOS_DLL GEOSGeom_getDimensions(const GEOSGeometry* g);
01139 
01140 extern int GEOS_DLL GEOSGeom_getDimensions_r(GEOSContextHandle_t handle,
01141                                              const GEOSGeometry* g);
01142 
01143 /*
01144  * Return 2 or 3.
01145  */
01146 extern int GEOS_DLL GEOSGeom_getCoordinateDimension(const GEOSGeometry* g);
01147 
01148 extern int GEOS_DLL GEOSGeom_getCoordinateDimension_r(GEOSContextHandle_t handle,
01149                                                       const GEOSGeometry* g);
01150 
01151 /*
01152  * Return NULL on exception.
01153  * Must be LineString and must be freed by called.
01154  */
01155 extern GEOSGeometry GEOS_DLL *GEOSGeomGetPointN(const GEOSGeometry *g, int n);
01156 extern GEOSGeometry GEOS_DLL *GEOSGeomGetStartPoint(const GEOSGeometry *g);
01157 extern GEOSGeometry GEOS_DLL *GEOSGeomGetEndPoint(const GEOSGeometry *g);
01158 
01159 extern GEOSGeometry GEOS_DLL *GEOSGeomGetPointN_r(GEOSContextHandle_t handle, const GEOSGeometry *g, int n);
01160 extern GEOSGeometry GEOS_DLL *GEOSGeomGetStartPoint_r(GEOSContextHandle_t handle, const GEOSGeometry *g);
01161 extern GEOSGeometry GEOS_DLL *GEOSGeomGetEndPoint_r(GEOSContextHandle_t handle, const GEOSGeometry *g);
01162 
01163 /************************************************************************
01164  *
01165  *  Misc functions
01166  *
01167  ***********************************************************************/
01168 
01169 /* Return 0 on exception, 1 otherwise */
01170 extern int GEOS_DLL GEOSArea(const GEOSGeometry* g, double *area);
01171 extern int GEOS_DLL GEOSLength(const GEOSGeometry* g, double *length);
01172 extern int GEOS_DLL GEOSDistance(const GEOSGeometry* g1, const GEOSGeometry* g2,
01173         double *dist);
01174 extern int GEOS_DLL GEOSHausdorffDistance(const GEOSGeometry *g1,
01175         const GEOSGeometry *g2, double *dist);
01176 extern int GEOS_DLL GEOSHausdorffDistanceDensify(const GEOSGeometry *g1,
01177         const GEOSGeometry *g2, double densifyFrac, double *dist);
01178 extern int GEOS_DLL GEOSGeomGetLength(const GEOSGeometry *g, double *length);
01179 
01180 extern int GEOS_DLL GEOSArea_r(GEOSContextHandle_t handle,
01181                                const GEOSGeometry* g, double *area);
01182 extern int GEOS_DLL GEOSLength_r(GEOSContextHandle_t handle,
01183                                  const GEOSGeometry* g, double *length);
01184 extern int GEOS_DLL GEOSDistance_r(GEOSContextHandle_t handle,
01185                                    const GEOSGeometry* g1,
01186                                    const GEOSGeometry* g2, double *dist);
01187 extern int GEOS_DLL GEOSHausdorffDistance_r(GEOSContextHandle_t handle,
01188                                    const GEOSGeometry *g1,
01189                                    const GEOSGeometry *g2,
01190                                    double *dist);
01191 extern int GEOS_DLL GEOSHausdorffDistanceDensify_r(GEOSContextHandle_t handle,
01192                                    const GEOSGeometry *g1,
01193                                    const GEOSGeometry *g2,
01194                                    double densifyFrac, double *dist);
01195 extern int GEOS_DLL GEOSGeomGetLength_r(GEOSContextHandle_t handle,
01196                                    const GEOSGeometry *g, double *length);
01197 
01198 /* Return 0 on exception, the closest points of the two geometries otherwise.
01199  * The first point comes from g1 geometry and the second point comes from g2.
01200  */
01201 extern GEOSCoordSequence GEOS_DLL *GEOSNearestPoints(
01202   const GEOSGeometry* g1, const GEOSGeometry* g2);
01203 extern GEOSCoordSequence GEOS_DLL *GEOSNearestPoints_r(
01204   GEOSContextHandle_t handle, const GEOSGeometry* g1, const GEOSGeometry* g2);
01205 
01206 
01207 /************************************************************************
01208  *
01209  * Algorithms
01210  *
01211  ***********************************************************************/
01212 
01213 /* Walking from A to B:
01214  *  return -1 if reaching P takes a counter-clockwise (left) turn
01215  *  return  1 if reaching P takes a clockwise (right) turn
01216  *  return  0 if P is collinear with A-B
01217  *
01218  * On exceptions, return 2.
01219  *
01220  */
01221 extern int GEOS_DLL GEOSOrientationIndex(double Ax, double Ay, double Bx, double By,
01222         double Px, double Py);
01223 extern int GEOS_DLL GEOSOrientationIndex_r(GEOSContextHandle_t handle,
01224         double Ax, double Ay, double Bx, double By, double Px, double Py);
01225 
01226 
01227 /************************************************************************
01228  *
01229  * Reader and Writer APIs
01230  *
01231  ***********************************************************************/
01232 
01233 typedef struct GEOSWKTReader_t GEOSWKTReader;
01234 typedef struct GEOSWKTWriter_t GEOSWKTWriter;
01235 typedef struct GEOSWKBReader_t GEOSWKBReader;
01236 typedef struct GEOSWKBWriter_t GEOSWKBWriter;
01237 
01238 
01239 /* WKT Reader */
01240 extern GEOSWKTReader GEOS_DLL *GEOSWKTReader_create();
01241 extern void GEOS_DLL GEOSWKTReader_destroy(GEOSWKTReader* reader);
01242 extern GEOSGeometry GEOS_DLL *GEOSWKTReader_read(GEOSWKTReader* reader, const char *wkt);
01243 
01244 extern GEOSWKTReader GEOS_DLL *GEOSWKTReader_create_r(
01245                                              GEOSContextHandle_t handle);
01246 extern void GEOS_DLL GEOSWKTReader_destroy_r(GEOSContextHandle_t handle,
01247                                              GEOSWKTReader* reader);
01248 extern GEOSGeometry GEOS_DLL *GEOSWKTReader_read_r(GEOSContextHandle_t handle,
01249                                                    GEOSWKTReader* reader,
01250                                                    const char *wkt);
01251 
01252 /* WKT Writer */
01253 extern GEOSWKTWriter GEOS_DLL *GEOSWKTWriter_create();
01254 extern void GEOS_DLL GEOSWKTWriter_destroy(GEOSWKTWriter* writer);
01255 extern char GEOS_DLL *GEOSWKTWriter_write(GEOSWKTWriter* writer, const GEOSGeometry* g);
01256 extern void GEOS_DLL GEOSWKTWriter_setTrim(GEOSWKTWriter *writer, char trim);
01257 extern void GEOS_DLL GEOSWKTWriter_setRoundingPrecision(GEOSWKTWriter *writer, int precision);
01258 extern void GEOS_DLL GEOSWKTWriter_setOutputDimension(GEOSWKTWriter *writer, int dim);
01259 extern int  GEOS_DLL GEOSWKTWriter_getOutputDimension(GEOSWKTWriter *writer);
01260 extern void GEOS_DLL GEOSWKTWriter_setOld3D(GEOSWKTWriter *writer, int useOld3D);
01261 
01262 extern GEOSWKTWriter GEOS_DLL *GEOSWKTWriter_create_r(
01263                                              GEOSContextHandle_t handle);
01264 extern void GEOS_DLL GEOSWKTWriter_destroy_r(GEOSContextHandle_t handle,
01265                                              GEOSWKTWriter* writer);
01266 extern char GEOS_DLL *GEOSWKTWriter_write_r(GEOSContextHandle_t handle,
01267                                             GEOSWKTWriter* writer,
01268                                             const GEOSGeometry* g);
01269 extern void GEOS_DLL GEOSWKTWriter_setTrim_r(GEOSContextHandle_t handle,
01270                                             GEOSWKTWriter *writer,
01271                                             char trim);
01272 extern void GEOS_DLL GEOSWKTWriter_setRoundingPrecision_r(GEOSContextHandle_t handle,
01273                                             GEOSWKTWriter *writer,
01274                                             int precision);
01275 extern void GEOS_DLL GEOSWKTWriter_setOutputDimension_r(GEOSContextHandle_t handle,
01276                                                         GEOSWKTWriter *writer,
01277                                                         int dim);
01278 extern int  GEOS_DLL GEOSWKTWriter_getOutputDimension_r(GEOSContextHandle_t handle,
01279                                                         GEOSWKTWriter *writer);
01280 extern void GEOS_DLL GEOSWKTWriter_setOld3D_r(GEOSContextHandle_t handle,
01281                                               GEOSWKTWriter *writer,
01282                                               int useOld3D);
01283 
01284 /* WKB Reader */
01285 extern GEOSWKBReader GEOS_DLL *GEOSWKBReader_create();
01286 extern void GEOS_DLL GEOSWKBReader_destroy(GEOSWKBReader* reader);
01287 extern GEOSGeometry GEOS_DLL *GEOSWKBReader_read(GEOSWKBReader* reader, const unsigned char *wkb, size_t size);
01288 extern GEOSGeometry GEOS_DLL *GEOSWKBReader_readHEX(GEOSWKBReader* reader, const unsigned char *hex, size_t size);
01289 
01290 extern GEOSWKBReader GEOS_DLL *GEOSWKBReader_create_r(
01291                                              GEOSContextHandle_t handle);
01292 extern void GEOS_DLL GEOSWKBReader_destroy_r(GEOSContextHandle_t handle,
01293                                              GEOSWKBReader* reader);
01294 extern GEOSGeometry GEOS_DLL *GEOSWKBReader_read_r(GEOSContextHandle_t handle,
01295                                                    GEOSWKBReader* reader,
01296                                                    const unsigned char *wkb,
01297                                                    size_t size);
01298 extern GEOSGeometry GEOS_DLL *GEOSWKBReader_readHEX_r(
01299                                             GEOSContextHandle_t handle,
01300                                             GEOSWKBReader* reader,
01301                                             const unsigned char *hex,
01302                                             size_t size);
01303 
01304 /* WKB Writer */
01305 extern GEOSWKBWriter GEOS_DLL *GEOSWKBWriter_create();
01306 extern void GEOS_DLL GEOSWKBWriter_destroy(GEOSWKBWriter* writer);
01307 
01308 extern GEOSWKBWriter GEOS_DLL *GEOSWKBWriter_create_r(
01309                                              GEOSContextHandle_t handle);
01310 extern void GEOS_DLL GEOSWKBWriter_destroy_r(GEOSContextHandle_t handle,
01311                                              GEOSWKBWriter* writer);
01312 
01313 /* The caller owns the results for these two methods! */
01314 extern unsigned char GEOS_DLL *GEOSWKBWriter_write(GEOSWKBWriter* writer, const GEOSGeometry* g, size_t *size);
01315 extern unsigned char GEOS_DLL *GEOSWKBWriter_writeHEX(GEOSWKBWriter* writer, const GEOSGeometry* g, size_t *size);
01316 
01317 extern unsigned char GEOS_DLL *GEOSWKBWriter_write_r(
01318                                              GEOSContextHandle_t handle,
01319                                              GEOSWKBWriter* writer,
01320                                              const GEOSGeometry* g,
01321                                              size_t *size);
01322 extern unsigned char GEOS_DLL *GEOSWKBWriter_writeHEX_r(
01323                                              GEOSContextHandle_t handle,
01324                                              GEOSWKBWriter* writer,
01325                                              const GEOSGeometry* g,
01326                                              size_t *size);
01327 
01328 /*
01329  * Specify whether output WKB should be 2d or 3d.
01330  * Return previously set number of dimensions.
01331  */
01332 extern int GEOS_DLL GEOSWKBWriter_getOutputDimension(const GEOSWKBWriter* writer);
01333 extern void GEOS_DLL GEOSWKBWriter_setOutputDimension(GEOSWKBWriter* writer, int newDimension);
01334 
01335 extern int GEOS_DLL GEOSWKBWriter_getOutputDimension_r(
01336                                   GEOSContextHandle_t handle,
01337                                   const GEOSWKBWriter* writer);
01338 extern void GEOS_DLL GEOSWKBWriter_setOutputDimension_r(
01339                                    GEOSContextHandle_t handle,
01340                                    GEOSWKBWriter* writer, int newDimension);
01341 
01342 /*
01343  * Specify whether the WKB byte order is big or little endian.
01344  * The return value is the previous byte order.
01345  */
01346 extern int GEOS_DLL GEOSWKBWriter_getByteOrder(const GEOSWKBWriter* writer);
01347 extern void GEOS_DLL GEOSWKBWriter_setByteOrder(GEOSWKBWriter* writer, int byteOrder);
01348 
01349 extern int GEOS_DLL GEOSWKBWriter_getByteOrder_r(GEOSContextHandle_t handle,
01350                                                  const GEOSWKBWriter* writer);
01351 extern void GEOS_DLL GEOSWKBWriter_setByteOrder_r(GEOSContextHandle_t handle,
01352                                                   GEOSWKBWriter* writer,
01353                                                   int byteOrder);
01354 
01355 /*
01356  * Specify whether SRID values should be output.
01357  */
01358 extern char GEOS_DLL GEOSWKBWriter_getIncludeSRID(const GEOSWKBWriter* writer);
01359 extern void GEOS_DLL GEOSWKBWriter_setIncludeSRID(GEOSWKBWriter* writer, const char writeSRID);
01360 
01361 extern char GEOS_DLL GEOSWKBWriter_getIncludeSRID_r(GEOSContextHandle_t handle,
01362                                    const GEOSWKBWriter* writer);
01363 extern void GEOS_DLL GEOSWKBWriter_setIncludeSRID_r(GEOSContextHandle_t handle,
01364                                    GEOSWKBWriter* writer, const char writeSRID);
01365 
01366 
01367 /*
01368  * Free buffers returned by stuff like GEOSWKBWriter_write(),
01369  * GEOSWKBWriter_writeHEX() and GEOSWKTWriter_write().
01370  */
01371 extern void GEOS_DLL GEOSFree(void *buffer);
01372 extern void GEOS_DLL GEOSFree_r(GEOSContextHandle_t handle, void *buffer);
01373 
01374 #ifdef __cplusplus
01375 } // extern "C"
01376 #endif
01377 
01378 #endif /* #ifndef GEOS_C_H_INCLUDED */