capi/geos_c.cpp

   1 /************************************************************************
   2  *
   3  *
   4  * C-Wrapper for GEOS library
   5  *
   6  * Copyright (C) 2010 2011 Sandro Santilli <strk@keybit.net>
   7  * Copyright (C) 2005-2006 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@keybit.net>
  15  *
  16  ***********************************************************************/
  17
  18 #include <geos/geom/prep/PreparedGeometryFactory.h>
  19 #include <geos/index/strtree/STRtree.h>
  20 #include <geos/io/WKTReader.h>
  21 #include <geos/io/WKBReader.h>
  22 #include <geos/io/WKTWriter.h>
  23 #include <geos/io/WKBWriter.h>
  24 #include <geos/io/CLocalizer.h>
  25 #include <geos/operation/overlay/OverlayOp.h>
  26 #include <geos/operation/union/CascadedPolygonUnion.h>
  27 #include <geos/algorithm/distance/DiscreteHausdorffDistance.h>
  28 #include <geos/util/Interrupt.h>
  29
  30 #include <stdexcept>
  31 #include <new>
  32
  33 #ifdef _MSC_VER
  34 #pragma warning(disable : 4099)
  35 #endif
  36
  37 // Some extra magic to make type declarations in geos_c.h work - for cross-checking of types in header.
  38 #define GEOSGeometry geos::geom::Geometry
  39 #define GEOSPreparedGeometry geos::geom::prep::PreparedGeometry
  40 #define GEOSCoordSequence geos::geom::CoordinateSequence
  41 #define GEOSSTRtree geos::index::strtree::STRtree
  42 #define GEOSWKTReader_t geos::io::WKTReader
  43 #define GEOSWKTWriter_t geos::io::WKTWriter
  44 #define GEOSWKBReader_t geos::io::WKBReader
  45 #define GEOSWKBWriter_t geos::io::WKBWriter
  46 typedef struct GEOSBufParams_t GEOSBufferParams;
  47
  48 #include "geos_c.h"
  49
  50 /// Define this if you want operations triggering Exceptions to
  51 /// be printed (will use the NOTIFY channel - only implemented for GEOSUnion so far)
  52 ///
  53 #undef VERBOSE_EXCEPTIONS
  54
  55 #include <geos/export.h>
  56
  57 /*
  58 #if defined(_MSC_VER)
  59 #  define GEOS_DLL     __declspec(dllexport)
  60 #else
  61 #  define GEOS_DLL
  62 #endif
  63 */
  64
  65 // import the most frequently used definitions globally
  66 using geos::geom::Geometry;
  67 using geos::geom::LineString;
  68 using geos::geom::Polygon;
  69 using geos::geom::CoordinateSequence;
  70 using geos::geom::GeometryFactory;
  71
  72 using geos::io::WKTReader;
  73 using geos::io::WKTWriter;
  74 using geos::io::WKBReader;
  75 using geos::io::WKBWriter;
  76 using geos::io::CLocalizer;
  77
  78 using geos::index::strtree::STRtree;
  79
  80 using geos::operation::overlay::OverlayOp;
  81 using geos::operation::overlay::overlayOp;
  82 using geos::operation::geounion::CascadedPolygonUnion;
  83
  84 typedef std::auto_ptr<Geometry> GeomAutoPtr;
  85
  86 //## GLOBALS ################################################
  87
  88 // NOTE: SRID will have to be changed after geometry creation
  89 GEOSContextHandle_t handle = NULL;
  90
  91 extern "C" {
  92
  93 void
  94 initGEOS (GEOSMessageHandler nf, GEOSMessageHandler ef)
  95 {
  96     if ( ! handle )
  97     {
  98         handle = initGEOS_r( nf, ef );
  99     }
 100     else
 101     {
 102         GEOSContext_setNoticeHandler_r(handle, nf);
 103         GEOSContext_setErrorHandler_r(handle, ef);
 104     }
 105
 106     geos::util::Interrupt::cancel();
 107 }
 108
 109 void
 110 finishGEOS ()
 111 {
 112     if (handle != NULL) {
 113         finishGEOS_r( handle );
 114         handle = NULL;
 115     }
 116 }
 117
 118 GEOSInterruptCallback*
 119 GEOS_interruptRegisterCallback(GEOSInterruptCallback* cb)
 120 {
 121   return geos::util::Interrupt::registerCallback(cb);
 122 }
 123
 124 void
 125 GEOS_interruptRequest()
 126 {
 127   geos::util::Interrupt::request();
 128 }
 129
 130 void
 131 GEOS_interruptCancel()
 132 {
 133   geos::util::Interrupt::cancel();
 134 }
 135
 136 void
 137 GEOSFree (void* buffer)
 138 {
 139     GEOSFree_r( handle, buffer );
 140 }
 141
 142 /****************************************************************
 143 ** relate()-related functions
 144 ** return 0 = false, 1 = true, 2 = error occured
 145 **
 146 */
 147 char
 148 GEOSDisjoint(const Geometry *g1, const Geometry *g2)
 149 {
 150     return GEOSDisjoint_r( handle, g1, g2 );
 151 }
 152
 153 char
 154 GEOSTouches(const Geometry *g1, const Geometry *g2)
 155 {
 156     return GEOSTouches_r( handle, g1, g2 );
 157 }
 158
 159 char
 160 GEOSIntersects(const Geometry *g1, const Geometry *g2)
 161 {
 162     return GEOSIntersects_r( handle, g1, g2 );
 163 }
 164
 165 char
 166 GEOSCrosses(const Geometry *g1, const Geometry *g2)
 167 {
 168     return GEOSCrosses_r( handle, g1, g2 );
 169 }
 170
 171 char
 172 GEOSWithin(const Geometry *g1, const Geometry *g2)
 173 {
 174     return GEOSWithin_r( handle, g1, g2 );
 175 }
 176
 177 // call g1->contains(g2)
 178 // returns 0 = false
 179 //         1 = true
 180 //         2 = error was trapped
 181 char
 182 GEOSContains(const Geometry *g1, const Geometry *g2)
 183 {
 184     return GEOSContains_r( handle, g1, g2 );
 185 }
 186
 187 char
 188 GEOSOverlaps(const Geometry *g1, const Geometry *g2)
 189 {
 190     return GEOSOverlaps_r( handle, g1, g2 );
 191 }
 192
 193 char
 194 GEOSCovers(const Geometry *g1, const Geometry *g2)
 195 {
 196     return GEOSCovers_r( handle, g1, g2 );
 197 }
 198
 199 char
 200 GEOSCoveredBy(const Geometry *g1, const Geometry *g2)
 201 {
 202     return GEOSCoveredBy_r( handle, g1, g2 );
 203 }
 204
 205
 206 //-------------------------------------------------------------------
 207 // low-level relate functions
 208 //------------------------------------------------------------------
 209
 210 char
 211 GEOSRelatePattern(const Geometry *g1, const Geometry *g2, const char *pat)
 212 {
 213     return GEOSRelatePattern_r( handle, g1, g2, pat );
 214 }
 215
 216 char
 217 GEOSRelatePatternMatch(const char *mat, const char *pat)
 218 {
 219     return GEOSRelatePatternMatch_r( handle, mat, pat );
 220 }
 221
 222 char *
 223 GEOSRelate(const Geometry *g1, const Geometry *g2)
 224 {
 225     return GEOSRelate_r( handle, g1, g2 );
 226 }
 227
 228 char *
 229 GEOSRelateBoundaryNodeRule(const Geometry *g1, const Geometry *g2, int bnr)
 230 {
 231     return GEOSRelateBoundaryNodeRule_r( handle, g1, g2, bnr );
 232 }
 233
 234
 235 //-----------------------------------------------------------------
 236 // isValid
 237 //-----------------------------------------------------------------
 238
 239
 240 char
 241 GEOSisValid(const Geometry *g1)
 242 {
 243     return GEOSisValid_r( handle, g1 );
 244 }
 245
 246 char *
 247 GEOSisValidReason(const Geometry *g1)
 248 {
 249     return GEOSisValidReason_r( handle, g1 );
 250 }
 251
 252 char
 253 GEOSisValidDetail(const Geometry *g, int flags,
 254         char** reason, Geometry ** location)
 255 {
 256     return GEOSisValidDetail_r( handle, g, flags, reason, location );
 257 }
 258
 259 //-----------------------------------------------------------------
 260 // general purpose
 261 //-----------------------------------------------------------------
 262
 263 char
 264 GEOSEquals(const Geometry *g1, const Geometry *g2)
 265 {
 266     return GEOSEquals_r( handle, g1, g2 );
 267 }
 268
 269 char
 270 GEOSEqualsExact(const Geometry *g1, const Geometry *g2, double tolerance)
 271 {
 272     return GEOSEqualsExact_r( handle, g1, g2, tolerance );
 273 }
 274
 275 int
 276 GEOSDistance(const Geometry *g1, const Geometry *g2, double *dist)
 277 {
 278     return GEOSDistance_r( handle, g1, g2, dist );
 279 }
 280
 281 int
 282 GEOSHausdorffDistance(const Geometry *g1, const Geometry *g2, double *dist)
 283 {
 284     return GEOSHausdorffDistance_r( handle, g1, g2, dist );
 285 }
 286
 287 int
 288 GEOSHausdorffDistanceDensify(const Geometry *g1, const Geometry *g2, double densifyFrac, double *dist)
 289 {
 290     return GEOSHausdorffDistanceDensify_r( handle, g1, g2, densifyFrac, dist );
 291 }
 292
 293 int
 294 GEOSArea(const Geometry *g, double *area)
 295 {
 296     return GEOSArea_r( handle, g, area );
 297 }
 298
 299 int
 300 GEOSLength(const Geometry *g, double *length)
 301 {
 302     return GEOSLength_r( handle, g, length );
 303 }
 304
 305 Geometry *
 306 GEOSGeomFromWKT(const char *wkt)
 307 {
 308     return GEOSGeomFromWKT_r( handle, wkt );
 309 }
 310
 311 char *
 312 GEOSGeomToWKT(const Geometry *g1)
 313 {
 314     return GEOSGeomToWKT_r( handle, g1 );
 315 }
 316
 317 // Remember to free the result!
 318 unsigned char *
 319 GEOSGeomToWKB_buf(const Geometry *g, size_t *size)
 320 {
 321     return GEOSGeomToWKB_buf_r( handle, g, size );
 322 }
 323
 324 Geometry *
 325 GEOSGeomFromWKB_buf(const unsigned char *wkb, size_t size)
 326 {
 327     return GEOSGeomFromWKB_buf_r( handle, wkb, size );
 328 }
 329
 330 /* Read/write wkb hex values.  Returned geometries are
 331    owned by the caller.*/
 332 unsigned char *
 333 GEOSGeomToHEX_buf(const Geometry *g, size_t *size)
 334 {
 335     return GEOSGeomToHEX_buf_r( handle, g, size );
 336 }
 337
 338 Geometry *
 339 GEOSGeomFromHEX_buf(const unsigned char *hex, size_t size)
 340 {
 341     return GEOSGeomFromHEX_buf_r( handle, hex, size );
 342 }
 343
 344 char
 345 GEOSisEmpty(const Geometry *g1)
 346 {
 347     return GEOSisEmpty_r( handle, g1 );
 348 }
 349
 350 char
 351 GEOSisSimple(const Geometry *g1)
 352 {
 353     return GEOSisSimple_r( handle, g1 );
 354 }
 355
 356 char
 357 GEOSisRing(const Geometry *g)
 358 {
 359     return GEOSisRing_r( handle, g );
 360 }
 361
 362
 363
 364 //free the result of this
 365 char *
 366 GEOSGeomType(const Geometry *g1)
 367 {
 368     return GEOSGeomType_r( handle, g1 );
 369 }
 370
 371 // Return postgis geometry type index
 372 int
 373 GEOSGeomTypeId(const Geometry *g1)
 374 {
 375     return GEOSGeomTypeId_r( handle, g1 );
 376 }
 377
 378
 379
 380
 381 //-------------------------------------------------------------------
 382 // GEOS functions that return geometries
 383 //-------------------------------------------------------------------
 384
 385 Geometry *
 386 GEOSEnvelope(const Geometry *g1)
 387 {
 388     return GEOSEnvelope_r( handle, g1 );
 389 }
 390
 391 Geometry *
 392 GEOSIntersection(const Geometry *g1, const Geometry *g2)
 393 {
 394     return GEOSIntersection_r( handle, g1, g2 );
 395 }
 396
 397 Geometry *
 398 GEOSBuffer(const Geometry *g1, double width, int quadrantsegments)
 399 {
 400     return GEOSBuffer_r( handle, g1, width, quadrantsegments );
 401 }
 402
 403 Geometry *
 404 GEOSBufferWithStyle(const Geometry *g1, double width, int quadsegs,
 405         int endCapStyle, int joinStyle, double mitreLimit)
 406 {
 407     return GEOSBufferWithStyle_r( handle, g1, width, quadsegs, endCapStyle,
 408                                joinStyle, mitreLimit );
 409 }
 410
 411 Geometry *
 412 GEOSSingleSidedBuffer(const Geometry *g1, double width, int quadsegs,
 413         int joinStyle, double mitreLimit, int leftSide)
 414 {
 415     return GEOSSingleSidedBuffer_r( handle, g1, width, quadsegs,
 416                                joinStyle, mitreLimit, leftSide );
 417 }
 418
 419 Geometry *
 420 GEOSOffsetCurve(const Geometry *g1, double width, int quadsegs,
 421         int joinStyle, double mitreLimit)
 422 {
 423     return GEOSOffsetCurve_r( handle, g1, width, quadsegs,
 424                                joinStyle, mitreLimit );
 425 }
 426
 427 Geometry *
 428 GEOSConvexHull(const Geometry *g1)
 429 {
 430     return GEOSConvexHull_r( handle, g1 );
 431 }
 432
 433 Geometry *
 434 GEOSDifference(const Geometry *g1, const Geometry *g2)
 435 {
 436     return GEOSDifference_r( handle, g1, g2 );
 437 }
 438
 439 Geometry *
 440 GEOSBoundary(const Geometry *g1)
 441 {
 442     return GEOSBoundary_r( handle, g1 );
 443 }
 444
 445 Geometry *
 446 GEOSSymDifference(const Geometry *g1, const Geometry *g2)
 447 {
 448     return GEOSSymDifference_r( handle, g1, g2 );
 449 }
 450
 451 Geometry *
 452 GEOSUnion(const Geometry *g1, const Geometry *g2)
 453 {
 454     return GEOSUnion_r( handle, g1, g2 );
 455 }
 456
 457 Geometry *
 458 GEOSUnaryUnion(const Geometry *g1)
 459 {
 460     return GEOSUnaryUnion_r( handle, g1);
 461 }
 462
 463 Geometry *
 464 GEOSNode(const Geometry *g)
 465 {
 466     return GEOSNode_r( handle, g );
 467 }
 468
 469 Geometry *
 470 GEOSUnionCascaded(const Geometry *g1)
 471 {
 472         return GEOSUnionCascaded_r( handle, g1 );
 473 }
 474
 475 Geometry *
 476 GEOSPointOnSurface(const Geometry *g1)
 477 {
 478     return GEOSPointOnSurface_r( handle, g1 );
 479 }
 480
 481
 482
 483
 484
 485 //-------------------------------------------------------------------
 486 // memory management functions
 487 //------------------------------------------------------------------
 488
 489
 490 void
 491 GEOSGeom_destroy(Geometry *a)
 492 {
 493     return GEOSGeom_destroy_r( handle, a );
 494 }
 495
 496
 497 int
 498 GEOSGetNumCoordinates(const Geometry *g1)
 499 {
 500     return GEOSGetNumCoordinates_r( handle, g1 );
 501 }
 502
 503 /*
 504  * Return -1 on exception, 0 otherwise.
 505  * Converts Geometry to normal form (or canonical form).
 506  */
 507 int
 508 GEOSNormalize(Geometry *g1)
 509 {
 510     return GEOSNormalize_r( handle, g1 );
 511 }
 512
 513 int
 514 GEOSGetNumInteriorRings(const Geometry *g1)
 515 {
 516     return GEOSGetNumInteriorRings_r( handle, g1 );
 517 }
 518
 519
 520 // returns -1 on error and 1 for non-multi geometries
 521 int
 522 GEOSGetNumGeometries(const Geometry *g1)
 523 {
 524     return GEOSGetNumGeometries_r( handle, g1 );
 525 }
 526
 527
 528 /*
 529  * Call only on GEOMETRYCOLLECTION or MULTI*.
 530  * Return a pointer to the internal Geometry.
 531  */
 532 const Geometry *
 533 GEOSGetGeometryN(const Geometry *g1, int n)
 534 {
 535     return GEOSGetGeometryN_r( handle, g1, n );
 536 }
 537
 538 /*
 539  * Call only on LINESTRING
 540  * Returns NULL on exception
 541  */
 542 Geometry *
 543 GEOSGeomGetPointN(const Geometry *g1, int n)
 544 {
 545         return GEOSGeomGetPointN_r(handle, g1, n);
 546 }
 547
 548 /*
 549  * Call only on LINESTRING
 550  */
 551 Geometry *
 552 GEOSGeomGetStartPoint(const Geometry *g1)
 553 {
 554         return GEOSGeomGetStartPoint_r(handle, g1);
 555 }
 556
 557 /*
 558  * Call only on LINESTRING
 559  */
 560 Geometry *
 561 GEOSGeomGetEndPoint(const Geometry *g1)
 562 {
 563         return GEOSGeomGetEndPoint_r(handle, g1);
 564 }
 565
 566 /*
 567  * Call only on LINESTRING
 568  * return 2 on exception, 1 on true, 0 on false
 569  */
 570 char
 571 GEOSisClosed(const Geometry *g1)
 572 {
 573         return GEOSisClosed_r(handle, g1);
 574 }
 575
 576 /*
 577  * Call only on LINESTRING
 578  * returns 0 on exception, otherwise 1
 579  */
 580 int
 581 GEOSGeomGetLength(const Geometry *g1, double *length)
 582 {
 583         return GEOSGeomGetLength_r(handle, g1, length);
 584 }
 585
 586 /*
 587  * Call only on LINESTRING
 588  * returns -1 on exception
 589  */
 590 int
 591 GEOSGeomGetNumPoints(const Geometry *g1)
 592 {
 593         return GEOSGeomGetNumPoints_r(handle, g1);
 594 }
 595
 596 /*
 597  * For POINT
 598  * returns 0 on exception, otherwise 1
 599  */
 600 int
 601 GEOSGeomGetX(const Geometry *g1, double *x)
 602 {
 603         return GEOSGeomGetX_r(handle, g1, x);
 604 }
 605
 606 /*
 607  * For POINT
 608  * returns 0 on exception, otherwise 1
 609  */
 610 int
 611 GEOSGeomGetY(const Geometry *g1, double *y)
 612 {
 613         return GEOSGeomGetY_r(handle, g1, y);
 614 }
 615
 616 /*
 617  * Call only on polygon
 618  * Return a copy of the internal Geometry.
 619  */
 620 const Geometry *
 621 GEOSGetExteriorRing(const Geometry *g1)
 622 {
 623     return GEOSGetExteriorRing_r( handle, g1 );
 624 }
 625
 626 /*
 627  * Call only on polygon
 628  * Return a pointer to internal storage, do not destroy it.
 629  */
 630 const Geometry *
 631 GEOSGetInteriorRingN(const Geometry *g1, int n)
 632 {
 633     return GEOSGetInteriorRingN_r( handle, g1, n );
 634 }
 635
 636 Geometry *
 637 GEOSGetCentroid(const Geometry *g)
 638 {
 639     return GEOSGetCentroid_r( handle, g );
 640 }
 641
 642 Geometry *
 643 GEOSGeom_createCollection(int type, Geometry **geoms, unsigned int ngeoms)
 644 {
 645     return GEOSGeom_createCollection_r( handle, type, geoms, ngeoms );
 646 }
 647
 648 Geometry *
 649 GEOSPolygonize(const Geometry * const * g, unsigned int ngeoms)
 650 {
 651     return GEOSPolygonize_r( handle, g, ngeoms );
 652 }
 653
 654 Geometry *
 655 GEOSPolygonizer_getCutEdges(const Geometry * const * g, unsigned int ngeoms)
 656 {
 657     return GEOSPolygonizer_getCutEdges_r( handle, g, ngeoms );
 658 }
 659
 660 GEOSGeometry *
 661 GEOSPolygonize_full(const GEOSGeometry* input,
 662         GEOSGeometry** cuts, GEOSGeometry** dangles, GEOSGeometry** invalid)
 663 {
 664     return GEOSPolygonize_full_r(handle, input, cuts, dangles, invalid );
 665 }
 666
 667 Geometry *
 668 GEOSLineMerge(const Geometry *g)
 669 {
 670     return GEOSLineMerge_r( handle, g );
 671 }
 672
 673 int
 674 GEOSGetSRID(const Geometry *g)
 675 {
 676     return GEOSGetSRID_r( handle, g );
 677 }
 678
 679 void
 680 GEOSSetSRID(Geometry *g, int srid)
 681 {
 682     return GEOSSetSRID_r( handle, g, srid );
 683 }
 684
 685 char
 686 GEOSHasZ(const Geometry *g)
 687 {
 688     return GEOSHasZ_r( handle, g );
 689 }
 690
 691 int
 692 GEOS_getWKBOutputDims()
 693 {
 694     return GEOS_getWKBOutputDims_r( handle );
 695 }
 696
 697 int
 698 GEOS_setWKBOutputDims(int newdims)
 699 {
 700     return GEOS_setWKBOutputDims_r( handle, newdims );
 701 }
 702
 703 int
 704 GEOS_getWKBByteOrder()
 705 {
 706         return GEOS_getWKBByteOrder_r( handle );
 707 }
 708
 709 int
 710 GEOS_setWKBByteOrder(int byteOrder)
 711 {
 712         return GEOS_setWKBByteOrder_r( handle, byteOrder );
 713 }
 714
 715
 716 CoordinateSequence *
 717 GEOSCoordSeq_create(unsigned int size, unsigned int dims)
 718 {
 719     return GEOSCoordSeq_create_r( handle, size, dims );
 720 }
 721
 722 int
 723 GEOSCoordSeq_setOrdinate(CoordinateSequence *s, unsigned int idx, unsigned int dim, double val)
 724 {
 725     return GEOSCoordSeq_setOrdinate_r( handle, s, idx, dim, val );
 726 }
 727
 728 int
 729 GEOSCoordSeq_setX(CoordinateSequence *s, unsigned int idx, double val)
 730 {
 731         return GEOSCoordSeq_setOrdinate(s, idx, 0, val);
 732 }
 733
 734 int
 735 GEOSCoordSeq_setY(CoordinateSequence *s, unsigned int idx, double val)
 736 {
 737         return GEOSCoordSeq_setOrdinate(s, idx, 1, val);
 738 }
 739
 740 int
 741 GEOSCoordSeq_setZ(CoordinateSequence *s, unsigned int idx, double val)
 742 {
 743         return GEOSCoordSeq_setOrdinate(s, idx, 2, val);
 744 }
 745
 746 CoordinateSequence *
 747 GEOSCoordSeq_clone(const CoordinateSequence *s)
 748 {
 749     return GEOSCoordSeq_clone_r( handle, s );
 750 }
 751
 752 int
 753 GEOSCoordSeq_getOrdinate(const CoordinateSequence *s, unsigned int idx, unsigned int dim, double *val)
 754 {
 755     return GEOSCoordSeq_getOrdinate_r( handle, s, idx, dim, val );
 756 }
 757
 758 int
 759 GEOSCoordSeq_getX(const CoordinateSequence *s, unsigned int idx, double *val)
 760 {
 761         return GEOSCoordSeq_getOrdinate(s, idx, 0, val);
 762 }
 763
 764 int
 765 GEOSCoordSeq_getY(const CoordinateSequence *s, unsigned int idx, double *val)
 766 {
 767         return GEOSCoordSeq_getOrdinate(s, idx, 1, val);
 768 }
 769
 770 int
 771 GEOSCoordSeq_getZ(const CoordinateSequence *s, unsigned int idx, double *val)
 772 {
 773         return GEOSCoordSeq_getOrdinate(s, idx, 2, val);
 774 }
 775
 776 int
 777 GEOSCoordSeq_getSize(const CoordinateSequence *s, unsigned int *size)
 778 {
 779     return GEOSCoordSeq_getSize_r( handle, s, size );
 780 }
 781
 782 int
 783 GEOSCoordSeq_getDimensions(const CoordinateSequence *s, unsigned int *dims)
 784 {
 785     return GEOSCoordSeq_getDimensions_r( handle, s, dims );
 786 }
 787
 788 void
 789 GEOSCoordSeq_destroy(CoordinateSequence *s)
 790 {
 791     return GEOSCoordSeq_destroy_r( handle, s );
 792 }
 793
 794 const CoordinateSequence *
 795 GEOSGeom_getCoordSeq(const Geometry *g)
 796 {
 797     return GEOSGeom_getCoordSeq_r( handle, g );
 798 }
 799
 800 Geometry *
 801 GEOSGeom_createPoint(CoordinateSequence *cs)
 802 {
 803     return GEOSGeom_createPoint_r( handle, cs );
 804 }
 805
 806 Geometry *
 807 GEOSGeom_createLinearRing(CoordinateSequence *cs)
 808 {
 809     return GEOSGeom_createLinearRing_r( handle, cs );
 810 }
 811
 812 Geometry *
 813 GEOSGeom_createLineString(CoordinateSequence *cs)
 814 {
 815     return GEOSGeom_createLineString_r( handle, cs );
 816 }
 817
 818 Geometry *
 819 GEOSGeom_createPolygon(Geometry *shell, Geometry **holes, unsigned int nholes)
 820 {
 821     return GEOSGeom_createPolygon_r( handle, shell, holes, nholes );
 822 }
 823
 824 Geometry *
 825 GEOSGeom_clone(const Geometry *g)
 826 {
 827     return GEOSGeom_clone_r( handle, g );
 828 }
 829
 830 int
 831 GEOSGeom_getDimensions(const Geometry *g)
 832 {
 833     return GEOSGeom_getDimensions_r( handle, g );
 834 }
 835
 836 int
 837 GEOSGeom_getCoordinateDimension(const Geometry *g)
 838 {
 839     return GEOSGeom_getCoordinateDimension_r( handle, g );
 840 }
 841
 842 Geometry *
 843 GEOSSimplify(const Geometry *g1, double tolerance)
 844 {
 845     return GEOSSimplify_r( handle, g1, tolerance );
 846 }
 847
 848 Geometry *
 849 GEOSTopologyPreserveSimplify(const Geometry *g1, double tolerance)
 850 {
 851     return GEOSTopologyPreserveSimplify_r( handle, g1, tolerance );
 852 }
 853
 854
 855 /* WKT Reader */
 856 WKTReader *
 857 GEOSWKTReader_create()
 858 {
 859     return GEOSWKTReader_create_r( handle );
 860 }
 861
 862 void
 863 GEOSWKTReader_destroy(WKTReader *reader)
 864 {
 865     GEOSWKTReader_destroy_r( handle, reader );
 866 }
 867
 868
 869 Geometry*
 870 GEOSWKTReader_read(WKTReader *reader, const char *wkt)
 871 {
 872     return GEOSWKTReader_read_r( handle, reader, wkt );
 873 }
 874
 875 /* WKT Writer */
 876 WKTWriter *
 877 GEOSWKTWriter_create()
 878 {
 879     return GEOSWKTWriter_create_r( handle );
 880 }
 881
 882 void
 883 GEOSWKTWriter_destroy(WKTWriter *Writer)
 884 {
 885     GEOSWKTWriter_destroy_r( handle, Writer );
 886 }
 887
 888 char*
 889 GEOSWKTWriter_write(WKTWriter *writer, const Geometry *geom)
 890 {
 891     return GEOSWKTWriter_write_r( handle, writer, geom );
 892 }
 893
 894 void
 895 GEOSWKTWriter_setTrim(WKTWriter *writer, char trim)
 896 {
 897         GEOSWKTWriter_setTrim_r(handle, writer, trim);
 898 }
 899
 900 void
 901 GEOSWKTWriter_setRoundingPrecision(WKTWriter *writer, int precision)
 902 {
 903         return GEOSWKTWriter_setRoundingPrecision_r(handle, writer, precision);
 904 }
 905
 906 void
 907 GEOSWKTWriter_setOutputDimension(WKTWriter *writer, int dim)
 908 {
 909         GEOSWKTWriter_setOutputDimension_r(handle, writer, dim);
 910 }
 911
 912 int
 913 GEOSWKTWriter_getOutputDimension(WKTWriter *writer)
 914 {
 915         return GEOSWKTWriter_getOutputDimension_r(handle, writer);
 916 }
 917
 918 void
 919 GEOSWKTWriter_setOld3D(WKTWriter *writer, int useOld3D)
 920 {
 921         GEOSWKTWriter_setOld3D_r(handle, writer, useOld3D);
 922 }
 923
 924 /* WKB Reader */
 925 WKBReader *
 926 GEOSWKBReader_create()
 927 {
 928     return GEOSWKBReader_create_r( handle );
 929 }
 930
 931 void
 932 GEOSWKBReader_destroy(WKBReader *reader)
 933 {
 934     GEOSWKBReader_destroy_r( handle, reader );
 935 }
 936
 937
 938 Geometry*
 939 GEOSWKBReader_read(WKBReader *reader, const unsigned char *wkb, size_t size)
 940 {
 941     return GEOSWKBReader_read_r( handle, reader, wkb, size );
 942 }
 943
 944 Geometry*
 945 GEOSWKBReader_readHEX(WKBReader *reader, const unsigned char *hex, size_t size)
 946 {
 947     return GEOSWKBReader_readHEX_r( handle, reader, hex, size );
 948 }
 949
 950 /* WKB Writer */
 951 WKBWriter *
 952 GEOSWKBWriter_create()
 953 {
 954     return GEOSWKBWriter_create_r( handle );
 955 }
 956
 957 void
 958 GEOSWKBWriter_destroy(WKBWriter *Writer)
 959 {
 960     GEOSWKBWriter_destroy_r( handle, Writer );
 961 }
 962
 963
 964 /* The caller owns the result */
 965 unsigned char*
 966 GEOSWKBWriter_write(WKBWriter *writer, const Geometry *geom, size_t *size)
 967 {
 968     return GEOSWKBWriter_write_r( handle, writer, geom, size );
 969 }
 970
 971 /* The caller owns the result */
 972 unsigned char*
 973 GEOSWKBWriter_writeHEX(WKBWriter *writer, const Geometry *geom, size_t *size)
 974 {
 975     return GEOSWKBWriter_writeHEX_r( handle, writer, geom, size );
 976 }
 977
 978 int
 979 GEOSWKBWriter_getOutputDimension(const GEOSWKBWriter* writer)
 980 {
 981     return GEOSWKBWriter_getOutputDimension_r( handle, writer );
 982 }
 983
 984 void
 985 GEOSWKBWriter_setOutputDimension(GEOSWKBWriter* writer, int newDimension)
 986 {
 987     GEOSWKBWriter_setOutputDimension_r( handle, writer, newDimension );
 988 }
 989
 990 int
 991 GEOSWKBWriter_getByteOrder(const GEOSWKBWriter* writer)
 992 {
 993     return GEOSWKBWriter_getByteOrder_r( handle, writer );
 994 }
 995
 996 void
 997 GEOSWKBWriter_setByteOrder(GEOSWKBWriter* writer, int newByteOrder)
 998 {
 999     GEOSWKBWriter_setByteOrder_r( handle, writer, newByteOrder );
1000 }
1001
1002 char
1003 GEOSWKBWriter_getIncludeSRID(const GEOSWKBWriter* writer)
1004 {
1005     return GEOSWKBWriter_getIncludeSRID_r( handle, writer );
1006 }
1007
1008 void
1009 GEOSWKBWriter_setIncludeSRID(GEOSWKBWriter* writer, const char newIncludeSRID)
1010 {
1011     GEOSWKBWriter_setIncludeSRID_r( handle, writer, newIncludeSRID );
1012 }
1013
1014
1015 //-----------------------------------------------------------------
1016 // Prepared Geometry
1017 //-----------------------------------------------------------------
1018
1019 const geos::geom::prep::PreparedGeometry*
1020 GEOSPrepare(const Geometry *g)
1021 {
1022     return GEOSPrepare_r( handle, g );
1023 }
1024
1025 void
1026 GEOSPreparedGeom_destroy(const geos::geom::prep::PreparedGeometry *a)
1027 {
1028     GEOSPreparedGeom_destroy_r( handle, a );
1029 }
1030
1031 char
1032 GEOSPreparedContains(const geos::geom::prep::PreparedGeometry *pg1, const Geometry *g2)
1033 {
1034     return GEOSPreparedContains_r( handle, pg1, g2 );
1035 }
1036
1037 char
1038 GEOSPreparedContainsProperly(const geos::geom::prep::PreparedGeometry *pg1, const Geometry *g2)
1039 {
1040     return GEOSPreparedContainsProperly_r( handle, pg1, g2 );
1041 }
1042
1043 char
1044 GEOSPreparedCoveredBy(const geos::geom::prep::PreparedGeometry *pg1, const Geometry *g2)
1045 {
1046     return GEOSPreparedCoveredBy_r( handle, pg1, g2 );
1047 }
1048
1049 char
1050 GEOSPreparedCovers(const geos::geom::prep::PreparedGeometry *pg1, const Geometry *g2)
1051 {
1052     return GEOSPreparedCovers_r( handle, pg1, g2 );
1053 }
1054
1055 char
1056 GEOSPreparedCrosses(const geos::geom::prep::PreparedGeometry *pg1, const Geometry *g2)
1057 {
1058     return GEOSPreparedCrosses_r( handle, pg1, g2 );
1059 }
1060
1061 char
1062 GEOSPreparedDisjoint(const geos::geom::prep::PreparedGeometry *pg1, const Geometry *g2)
1063 {
1064     return GEOSPreparedDisjoint_r( handle, pg1, g2 );
1065 }
1066
1067 char
1068 GEOSPreparedIntersects(const geos::geom::prep::PreparedGeometry *pg1, const Geometry *g2)
1069 {
1070     return GEOSPreparedIntersects_r( handle, pg1, g2 );
1071 }
1072
1073 char
1074 GEOSPreparedOverlaps(const geos::geom::prep::PreparedGeometry *pg1, const Geometry *g2)
1075 {
1076     return GEOSPreparedOverlaps_r( handle, pg1, g2 );
1077 }
1078
1079 char
1080 GEOSPreparedTouches(const geos::geom::prep::PreparedGeometry *pg1, const Geometry *g2)
1081 {
1082     return GEOSPreparedTouches_r( handle, pg1, g2 );
1083 }
1084
1085 char
1086 GEOSPreparedWithin(const geos::geom::prep::PreparedGeometry *pg1, const Geometry *g2)
1087 {
1088     return GEOSPreparedWithin_r( handle, pg1, g2 );
1089 }
1090
1091 STRtree *
1092 GEOSSTRtree_create (size_t nodeCapacity)
1093 {
1094     return GEOSSTRtree_create_r( handle, nodeCapacity );
1095 }
1096
1097 void
1098 GEOSSTRtree_insert (geos::index::strtree::STRtree *tree,
1099                     const geos::geom::Geometry *g,
1100                     void *item)
1101 {
1102     GEOSSTRtree_insert_r( handle, tree, g, item );
1103 }
1104
1105 void
1106 GEOSSTRtree_query (geos::index::strtree::STRtree *tree,
1107                    const geos::geom::Geometry *g,
1108                    GEOSQueryCallback cb,
1109                    void *userdata)
1110 {
1111     GEOSSTRtree_query_r( handle, tree, g, cb, userdata );
1112 }
1113
1114 void
1115 GEOSSTRtree_iterate(geos::index::strtree::STRtree *tree,
1116                     GEOSQueryCallback callback,
1117                     void *userdata)
1118 {
1119     GEOSSTRtree_iterate_r( handle, tree, callback, userdata );
1120 }
1121
1122 char
1123 GEOSSTRtree_remove (geos::index::strtree::STRtree *tree,
1124                     const geos::geom::Geometry *g,
1125                     void *item)
1126 {
1127     return GEOSSTRtree_remove_r( handle, tree, g, item );
1128 }
1129
1130 void
1131 GEOSSTRtree_destroy (geos::index::strtree::STRtree *tree)
1132 {
1133     GEOSSTRtree_destroy_r( handle, tree );
1134 }
1135
1136 double
1137 GEOSProject (const geos::geom::Geometry *g,
1138              const geos::geom::Geometry *p)
1139 {
1140     return GEOSProject_r (handle, g, p);
1141 }
1142
1143 geos::geom::Geometry *
1144 GEOSInterpolate (const geos::geom::Geometry *g,
1145                  double d)
1146 {
1147     return GEOSInterpolate_r(handle, g, d);
1148 }
1149
1150 double
1151 GEOSProjectNormalized (const geos::geom::Geometry *g,
1152                        const geos::geom::Geometry *p)
1153 {
1154     return GEOSProjectNormalized_r (handle, g, p);
1155 }
1156
1157 geos::geom::Geometry *
1158 GEOSInterpolateNormalized (const geos::geom::Geometry *g,
1159                            double d)
1160 {
1161     return GEOSInterpolateNormalized_r(handle, g, d);
1162 }
1163
1164 geos::geom::Geometry *
1165 GEOSGeom_extractUniquePoints (const geos::geom::Geometry *g)
1166 {
1167     return GEOSGeom_extractUniquePoints_r(handle, g);
1168 }
1169
1170 geos::geom::Geometry *
1171 GEOSGeom_createEmptyCollection(int type)
1172 {
1173     return GEOSGeom_createEmptyCollection_r(handle, type);
1174 }
1175
1176 geos::geom::Geometry *
1177 GEOSGeom_createEmptyPoint()
1178 {
1179     return GEOSGeom_createEmptyPoint_r(handle);
1180 }
1181
1182 geos::geom::Geometry *
1183 GEOSGeom_createEmptyLineString()
1184 {
1185     return GEOSGeom_createEmptyLineString_r(handle);
1186 }
1187
1188 geos::geom::Geometry *
1189 GEOSGeom_createEmptyPolygon()
1190 {
1191     return GEOSGeom_createEmptyPolygon_r(handle);
1192 }
1193
1194 int
1195 GEOSOrientationIndex(double Ax, double Ay, double Bx, double By,
1196         double Px, double Py)
1197 {
1198     return GEOSOrientationIndex_r(handle, Ax, Ay, Bx, By, Px, Py);
1199 }
1200
1201 GEOSGeometry *
1202 GEOSSharedPaths(const GEOSGeometry* g1, const GEOSGeometry* g2)
1203 {
1204     return GEOSSharedPaths_r(handle, g1, g2);
1205 }
1206
1207 GEOSGeometry *
1208 GEOSSnap(const GEOSGeometry* g1, const GEOSGeometry* g2, double tolerance)
1209 {
1210   return GEOSSnap_r(handle, g1, g2, tolerance);
1211 }
1212
1213 GEOSBufferParams*
1214 GEOSBufferParams_create()
1215 {
1216   return GEOSBufferParams_create_r(handle);
1217 }
1218
1219 void
1220 GEOSBufferParams_destroy(GEOSBufferParams* p)
1221 {
1222   return GEOSBufferParams_destroy_r(handle, p);
1223 }
1224
1225 int
1226 GEOSBufferParams_setEndCapStyle(GEOSBufferParams* p, int style)
1227 {
1228   return GEOSBufferParams_setEndCapStyle_r(handle, p, style);
1229 }
1230
1231 int
1232 GEOSBufferParams_setJoinStyle(GEOSBufferParams* p, int joinStyle)
1233 {
1234   return GEOSBufferParams_setJoinStyle_r(handle, p, joinStyle);
1235 }
1236
1237 int
1238 GEOSBufferParams_setMitreLimit(GEOSBufferParams* p, double l)
1239 {
1240   return GEOSBufferParams_setMitreLimit_r(handle, p, l);
1241 }
1242
1243 int
1244 GEOSBufferParams_setQuadrantSegments(GEOSBufferParams* p, int joinStyle)
1245 {
1246   return GEOSBufferParams_setQuadrantSegments_r(handle, p, joinStyle);
1247 }
1248
1249 int
1250 GEOSBufferParams_setSingleSided(GEOSBufferParams* p, int singleSided)
1251 {
1252   return GEOSBufferParams_setSingleSided_r(handle, p, singleSided);
1253 }
1254
1255 Geometry*
1256 GEOSBufferWithParams(const Geometry* g, const GEOSBufferParams* p, double w)
1257 {
1258   return GEOSBufferWithParams_r(handle, g, p, w);
1259 }
1260
1261 Geometry *
1262 GEOSDelaunayTriangulation(const Geometry *g, double tolerance, int onlyEdges)
1263 {
1264   return GEOSDelaunayTriangulation_r(handle, g, tolerance, onlyEdges);
1265 }
1266
1267 } /* extern "C" */