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 *g)
 242 {
 243     return GEOSisValid_r( handle, g );
 244 }
 245
 246 char *
 247 GEOSisValidReason(const Geometry *g)
 248 {
 249     return GEOSisValidReason_r( handle, g );
 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 CoordinateSequence *
 306 GEOSNearestPoints(const Geometry *g1, const Geometry *g2)
 307 {
 308     return GEOSNearestPoints_r( handle, g1, g2 );
 309 }
 310
 311 Geometry *
 312 GEOSGeomFromWKT(const char *wkt)
 313 {
 314     return GEOSGeomFromWKT_r( handle, wkt );
 315 }
 316
 317 char *
 318 GEOSGeomToWKT(const Geometry *g)
 319 {
 320     return GEOSGeomToWKT_r( handle, g );
 321 }
 322
 323 // Remember to free the result!
 324 unsigned char *
 325 GEOSGeomToWKB_buf(const Geometry *g, size_t *size)
 326 {
 327     return GEOSGeomToWKB_buf_r( handle, g, size );
 328 }
 329
 330 Geometry *
 331 GEOSGeomFromWKB_buf(const unsigned char *wkb, size_t size)
 332 {
 333     return GEOSGeomFromWKB_buf_r( handle, wkb, size );
 334 }
 335
 336 /* Read/write wkb hex values.  Returned geometries are
 337    owned by the caller.*/
 338 unsigned char *
 339 GEOSGeomToHEX_buf(const Geometry *g, size_t *size)
 340 {
 341     return GEOSGeomToHEX_buf_r( handle, g, size );
 342 }
 343
 344 Geometry *
 345 GEOSGeomFromHEX_buf(const unsigned char *hex, size_t size)
 346 {
 347     return GEOSGeomFromHEX_buf_r( handle, hex, size );
 348 }
 349
 350 char
 351 GEOSisEmpty(const Geometry *g)
 352 {
 353     return GEOSisEmpty_r( handle, g );
 354 }
 355
 356 char
 357 GEOSisSimple(const Geometry *g)
 358 {
 359     return GEOSisSimple_r( handle, g );
 360 }
 361
 362 char
 363 GEOSisRing(const Geometry *g)
 364 {
 365     return GEOSisRing_r( handle, g );
 366 }
 367
 368
 369
 370 //free the result of this
 371 char *
 372 GEOSGeomType(const Geometry *g)
 373 {
 374     return GEOSGeomType_r( handle, g );
 375 }
 376
 377 // Return postgis geometry type index
 378 int
 379 GEOSGeomTypeId(const Geometry *g)
 380 {
 381     return GEOSGeomTypeId_r( handle, g );
 382 }
 383
 384
 385
 386
 387 //-------------------------------------------------------------------
 388 // GEOS functions that return geometries
 389 //-------------------------------------------------------------------
 390
 391 Geometry *
 392 GEOSEnvelope(const Geometry *g)
 393 {
 394     return GEOSEnvelope_r( handle, g );
 395 }
 396
 397 Geometry *
 398 GEOSIntersection(const Geometry *g1, const Geometry *g2)
 399 {
 400     return GEOSIntersection_r( handle, g1, g2 );
 401 }
 402
 403 Geometry *
 404 GEOSBuffer(const Geometry *g, double width, int quadrantsegments)
 405 {
 406     return GEOSBuffer_r( handle, g, width, quadrantsegments );
 407 }
 408
 409 Geometry *
 410 GEOSBufferWithStyle(const Geometry *g, double width, int quadsegs,
 411         int endCapStyle, int joinStyle, double mitreLimit)
 412 {
 413     return GEOSBufferWithStyle_r( handle, g, width, quadsegs, endCapStyle,
 414                                joinStyle, mitreLimit );
 415 }
 416
 417 Geometry *
 418 GEOSSingleSidedBuffer(const Geometry *g, double width, int quadsegs,
 419         int joinStyle, double mitreLimit, int leftSide)
 420 {
 421     return GEOSSingleSidedBuffer_r( handle, g, width, quadsegs,
 422                                joinStyle, mitreLimit, leftSide );
 423 }
 424
 425 Geometry *
 426 GEOSOffsetCurve(const Geometry *g, double width, int quadsegs,
 427         int joinStyle, double mitreLimit)
 428 {
 429     return GEOSOffsetCurve_r( handle, g, width, quadsegs,
 430                                joinStyle, mitreLimit );
 431 }
 432
 433 Geometry *
 434 GEOSConvexHull(const Geometry *g)
 435 {
 436     return GEOSConvexHull_r( handle, g );
 437 }
 438
 439 Geometry *
 440 GEOSMinimumRotatedRectangle(const Geometry *g)
 441 {
 442     return GEOSMinimumRotatedRectangle_r( handle, g );
 443 }
 444
 445 Geometry *
 446 GEOSMinimumDiameter(const Geometry *g)
 447 {
 448     return GEOSMinimumDiameter_r( handle, g );
 449 }
 450
 451 Geometry *
 452 GEOSDifference(const Geometry *g1, const Geometry *g2)
 453 {
 454     return GEOSDifference_r( handle, g1, g2 );
 455 }
 456
 457 Geometry *
 458 GEOSBoundary(const Geometry *g)
 459 {
 460     return GEOSBoundary_r( handle, g );
 461 }
 462
 463 Geometry *
 464 GEOSSymDifference(const Geometry *g1, const Geometry *g2)
 465 {
 466     return GEOSSymDifference_r( handle, g1, g2 );
 467 }
 468
 469 Geometry *
 470 GEOSUnion(const Geometry *g1, const Geometry *g2)
 471 {
 472     return GEOSUnion_r( handle, g1, g2 );
 473 }
 474
 475 Geometry *
 476 GEOSUnaryUnion(const Geometry *g)
 477 {
 478     return GEOSUnaryUnion_r( handle, g);
 479 }
 480
 481 Geometry *
 482 GEOSNode(const Geometry *g)
 483 {
 484     return GEOSNode_r( handle, g );
 485 }
 486
 487 Geometry *
 488 GEOSUnionCascaded(const Geometry *g)
 489 {
 490         return GEOSUnionCascaded_r( handle, g );
 491 }
 492
 493 Geometry *
 494 GEOSPointOnSurface(const Geometry *g)
 495 {
 496     return GEOSPointOnSurface_r( handle, g );
 497 }
 498
 499
 500 Geometry *
 501 GEOSClipByRect(const Geometry *g, double xmin, double ymin, double xmax, double ymax)
 502 {
 503     return GEOSClipByRect_r( handle, g, xmin, ymin, xmax, ymax );
 504 }
 505
 506
 507
 508 //-------------------------------------------------------------------
 509 // memory management functions
 510 //------------------------------------------------------------------
 511
 512
 513 void
 514 GEOSGeom_destroy(Geometry *a)
 515 {
 516     return GEOSGeom_destroy_r( handle, a );
 517 }
 518
 519
 520 int
 521 GEOSGetNumCoordinates(const Geometry *g)
 522 {
 523     return GEOSGetNumCoordinates_r( handle, g );
 524 }
 525
 526 /*
 527  * Return -1 on exception, 0 otherwise.
 528  * Converts Geometry to normal form (or canonical form).
 529  */
 530 int
 531 GEOSNormalize(Geometry *g)
 532 {
 533     return GEOSNormalize_r( handle, g );
 534 }
 535
 536 int
 537 GEOSGetNumInteriorRings(const Geometry *g)
 538 {
 539     return GEOSGetNumInteriorRings_r( handle, g );
 540 }
 541
 542
 543 // returns -1 on error and 1 for non-multi geometries
 544 int
 545 GEOSGetNumGeometries(const Geometry *g)
 546 {
 547     return GEOSGetNumGeometries_r( handle, g );
 548 }
 549
 550
 551 /*
 552  * Call only on GEOMETRYCOLLECTION or MULTI*.
 553  * Return a pointer to the internal Geometry.
 554  */
 555 const Geometry *
 556 GEOSGetGeometryN(const Geometry *g, int n)
 557 {
 558     return GEOSGetGeometryN_r( handle, g, n );
 559 }
 560
 561 /*
 562  * Call only on LINESTRING
 563  * Returns NULL on exception
 564  */
 565 Geometry *
 566 GEOSGeomGetPointN(const Geometry *g, int n)
 567 {
 568         return GEOSGeomGetPointN_r(handle, g, n);
 569 }
 570
 571 /*
 572  * Call only on LINESTRING
 573  */
 574 Geometry *
 575 GEOSGeomGetStartPoint(const Geometry *g)
 576 {
 577         return GEOSGeomGetStartPoint_r(handle, g);
 578 }
 579
 580 /*
 581  * Call only on LINESTRING
 582  */
 583 Geometry *
 584 GEOSGeomGetEndPoint(const Geometry *g)
 585 {
 586         return GEOSGeomGetEndPoint_r(handle, g);
 587 }
 588
 589 /*
 590  * Call only on LINESTRING
 591  * return 2 on exception, 1 on true, 0 on false
 592  */
 593 char
 594 GEOSisClosed(const Geometry *g)
 595 {
 596         return GEOSisClosed_r(handle, g);
 597 }
 598
 599 /*
 600  * Call only on LINESTRING
 601  * returns 0 on exception, otherwise 1
 602  */
 603 int
 604 GEOSGeomGetLength(const Geometry *g, double *length)
 605 {
 606         return GEOSGeomGetLength_r(handle, g, length);
 607 }
 608
 609 /*
 610  * Call only on LINESTRING
 611  * returns -1 on exception
 612  */
 613 int
 614 GEOSGeomGetNumPoints(const Geometry *g)
 615 {
 616         return GEOSGeomGetNumPoints_r(handle, g);
 617 }
 618
 619 /*
 620  * For POINT
 621  * returns 0 on exception, otherwise 1
 622  */
 623 int
 624 GEOSGeomGetX(const Geometry *g, double *x)
 625 {
 626         return GEOSGeomGetX_r(handle, g, x);
 627 }
 628
 629 /*
 630  * For POINT
 631  * returns 0 on exception, otherwise 1
 632  */
 633 int
 634 GEOSGeomGetY(const Geometry *g, double *y)
 635 {
 636         return GEOSGeomGetY_r(handle, g, y);
 637 }
 638
 639 /*
 640  * Call only on polygon
 641  * Return a copy of the internal Geometry.
 642  */
 643 const Geometry *
 644 GEOSGetExteriorRing(const Geometry *g)
 645 {
 646     return GEOSGetExteriorRing_r( handle, g );
 647 }
 648
 649 /*
 650  * Call only on polygon
 651  * Return a pointer to internal storage, do not destroy it.
 652  */
 653 const Geometry *
 654 GEOSGetInteriorRingN(const Geometry *g, int n)
 655 {
 656     return GEOSGetInteriorRingN_r( handle, g, n );
 657 }
 658
 659 Geometry *
 660 GEOSGetCentroid(const Geometry *g)
 661 {
 662     return GEOSGetCentroid_r( handle, g );
 663 }
 664
 665 Geometry *
 666 GEOSGeom_createCollection(int type, Geometry **geoms, unsigned int ngeoms)
 667 {
 668     return GEOSGeom_createCollection_r( handle, type, geoms, ngeoms );
 669 }
 670
 671 Geometry *
 672 GEOSPolygonize(const Geometry * const * g, unsigned int ngeoms)
 673 {
 674     return GEOSPolygonize_r( handle, g, ngeoms );
 675 }
 676
 677 Geometry *
 678 GEOSPolygonizer_getCutEdges(const Geometry * const * g, unsigned int ngeoms)
 679 {
 680     return GEOSPolygonizer_getCutEdges_r( handle, g, ngeoms );
 681 }
 682
 683 GEOSGeometry *
 684 GEOSPolygonize_full(const GEOSGeometry* input,
 685         GEOSGeometry** cuts, GEOSGeometry** dangles, GEOSGeometry** invalid)
 686 {
 687     return GEOSPolygonize_full_r(handle, input, cuts, dangles, invalid );
 688 }
 689
 690 Geometry *
 691 GEOSLineMerge(const Geometry *g)
 692 {
 693     return GEOSLineMerge_r( handle, g );
 694 }
 695
 696 int
 697 GEOSGetSRID(const Geometry *g)
 698 {
 699     return GEOSGetSRID_r( handle, g );
 700 }
 701
 702 void
 703 GEOSSetSRID(Geometry *g, int srid)
 704 {
 705     return GEOSSetSRID_r( handle, g, srid );
 706 }
 707
 708 char
 709 GEOSHasZ(const Geometry *g)
 710 {
 711     return GEOSHasZ_r( handle, g );
 712 }
 713
 714 int
 715 GEOS_getWKBOutputDims()
 716 {
 717     return GEOS_getWKBOutputDims_r( handle );
 718 }
 719
 720 int
 721 GEOS_setWKBOutputDims(int newdims)
 722 {
 723     return GEOS_setWKBOutputDims_r( handle, newdims );
 724 }
 725
 726 int
 727 GEOS_getWKBByteOrder()
 728 {
 729         return GEOS_getWKBByteOrder_r( handle );
 730 }
 731
 732 int
 733 GEOS_setWKBByteOrder(int byteOrder)
 734 {
 735         return GEOS_setWKBByteOrder_r( handle, byteOrder );
 736 }
 737
 738
 739 CoordinateSequence *
 740 GEOSCoordSeq_create(unsigned int size, unsigned int dims)
 741 {
 742     return GEOSCoordSeq_create_r( handle, size, dims );
 743 }
 744
 745 int
 746 GEOSCoordSeq_setOrdinate(CoordinateSequence *s, unsigned int idx, unsigned int dim, double val)
 747 {
 748     return GEOSCoordSeq_setOrdinate_r( handle, s, idx, dim, val );
 749 }
 750
 751 int
 752 GEOSCoordSeq_setX(CoordinateSequence *s, unsigned int idx, double val)
 753 {
 754         return GEOSCoordSeq_setOrdinate(s, idx, 0, val);
 755 }
 756
 757 int
 758 GEOSCoordSeq_setY(CoordinateSequence *s, unsigned int idx, double val)
 759 {
 760         return GEOSCoordSeq_setOrdinate(s, idx, 1, val);
 761 }
 762
 763 int
 764 GEOSCoordSeq_setZ(CoordinateSequence *s, unsigned int idx, double val)
 765 {
 766         return GEOSCoordSeq_setOrdinate(s, idx, 2, val);
 767 }
 768
 769 CoordinateSequence *
 770 GEOSCoordSeq_clone(const CoordinateSequence *s)
 771 {
 772     return GEOSCoordSeq_clone_r( handle, s );
 773 }
 774
 775 int
 776 GEOSCoordSeq_getOrdinate(const CoordinateSequence *s, unsigned int idx, unsigned int dim, double *val)
 777 {
 778     return GEOSCoordSeq_getOrdinate_r( handle, s, idx, dim, val );
 779 }
 780
 781 int
 782 GEOSCoordSeq_getX(const CoordinateSequence *s, unsigned int idx, double *val)
 783 {
 784         return GEOSCoordSeq_getOrdinate(s, idx, 0, val);
 785 }
 786
 787 int
 788 GEOSCoordSeq_getY(const CoordinateSequence *s, unsigned int idx, double *val)
 789 {
 790         return GEOSCoordSeq_getOrdinate(s, idx, 1, val);
 791 }
 792
 793 int
 794 GEOSCoordSeq_getZ(const CoordinateSequence *s, unsigned int idx, double *val)
 795 {
 796         return GEOSCoordSeq_getOrdinate(s, idx, 2, val);
 797 }
 798
 799 int
 800 GEOSCoordSeq_getSize(const CoordinateSequence *s, unsigned int *size)
 801 {
 802     return GEOSCoordSeq_getSize_r( handle, s, size );
 803 }
 804
 805 int
 806 GEOSCoordSeq_getDimensions(const CoordinateSequence *s, unsigned int *dims)
 807 {
 808     return GEOSCoordSeq_getDimensions_r( handle, s, dims );
 809 }
 810
 811 void
 812 GEOSCoordSeq_destroy(CoordinateSequence *s)
 813 {
 814     return GEOSCoordSeq_destroy_r( handle, s );
 815 }
 816
 817 const CoordinateSequence *
 818 GEOSGeom_getCoordSeq(const Geometry *g)
 819 {
 820     return GEOSGeom_getCoordSeq_r( handle, g );
 821 }
 822
 823 Geometry *
 824 GEOSGeom_createPoint(CoordinateSequence *cs)
 825 {
 826     return GEOSGeom_createPoint_r( handle, cs );
 827 }
 828
 829 Geometry *
 830 GEOSGeom_createLinearRing(CoordinateSequence *cs)
 831 {
 832     return GEOSGeom_createLinearRing_r( handle, cs );
 833 }
 834
 835 Geometry *
 836 GEOSGeom_createLineString(CoordinateSequence *cs)
 837 {
 838     return GEOSGeom_createLineString_r( handle, cs );
 839 }
 840
 841 Geometry *
 842 GEOSGeom_createPolygon(Geometry *shell, Geometry **holes, unsigned int nholes)
 843 {
 844     return GEOSGeom_createPolygon_r( handle, shell, holes, nholes );
 845 }
 846
 847 Geometry *
 848 GEOSGeom_clone(const Geometry *g)
 849 {
 850     return GEOSGeom_clone_r( handle, g );
 851 }
 852
 853 GEOSGeometry *
 854 GEOSGeom_setPrecision(const GEOSGeometry *g, double gridSize, int flags)
 855 {
 856         return GEOSGeom_setPrecision_r(handle, g, gridSize, flags);
 857 }
 858
 859 double
 860 GEOSGeom_getPrecision(const GEOSGeometry *g)
 861 {
 862         return GEOSGeom_getPrecision_r(handle, g);
 863 }
 864
 865 int
 866 GEOSGeom_getDimensions(const Geometry *g)
 867 {
 868     return GEOSGeom_getDimensions_r( handle, g );
 869 }
 870
 871 int
 872 GEOSGeom_getCoordinateDimension(const Geometry *g)
 873 {
 874     return GEOSGeom_getCoordinateDimension_r( handle, g );
 875 }
 876
 877 Geometry *
 878 GEOSSimplify(const Geometry *g, double tolerance)
 879 {
 880     return GEOSSimplify_r( handle, g, tolerance );
 881 }
 882
 883 Geometry *
 884 GEOSTopologyPreserveSimplify(const Geometry *g, double tolerance)
 885 {
 886     return GEOSTopologyPreserveSimplify_r( handle, g, tolerance );
 887 }
 888
 889
 890 /* WKT Reader */
 891 WKTReader *
 892 GEOSWKTReader_create()
 893 {
 894     return GEOSWKTReader_create_r( handle );
 895 }
 896
 897 void
 898 GEOSWKTReader_destroy(WKTReader *reader)
 899 {
 900     GEOSWKTReader_destroy_r( handle, reader );
 901 }
 902
 903
 904 Geometry*
 905 GEOSWKTReader_read(WKTReader *reader, const char *wkt)
 906 {
 907     return GEOSWKTReader_read_r( handle, reader, wkt );
 908 }
 909
 910 /* WKT Writer */
 911 WKTWriter *
 912 GEOSWKTWriter_create()
 913 {
 914     return GEOSWKTWriter_create_r( handle );
 915 }
 916
 917 void
 918 GEOSWKTWriter_destroy(WKTWriter *Writer)
 919 {
 920     GEOSWKTWriter_destroy_r( handle, Writer );
 921 }
 922
 923 char*
 924 GEOSWKTWriter_write(WKTWriter *writer, const Geometry *geom)
 925 {
 926     return GEOSWKTWriter_write_r( handle, writer, geom );
 927 }
 928
 929 void
 930 GEOSWKTWriter_setTrim(WKTWriter *writer, char trim)
 931 {
 932         GEOSWKTWriter_setTrim_r(handle, writer, trim);
 933 }
 934
 935 void
 936 GEOSWKTWriter_setRoundingPrecision(WKTWriter *writer, int precision)
 937 {
 938         return GEOSWKTWriter_setRoundingPrecision_r(handle, writer, precision);
 939 }
 940
 941 void
 942 GEOSWKTWriter_setOutputDimension(WKTWriter *writer, int dim)
 943 {
 944         GEOSWKTWriter_setOutputDimension_r(handle, writer, dim);
 945 }
 946
 947 int
 948 GEOSWKTWriter_getOutputDimension(WKTWriter *writer)
 949 {
 950         return GEOSWKTWriter_getOutputDimension_r(handle, writer);
 951 }
 952
 953 void
 954 GEOSWKTWriter_setOld3D(WKTWriter *writer, int useOld3D)
 955 {
 956         GEOSWKTWriter_setOld3D_r(handle, writer, useOld3D);
 957 }
 958
 959 /* WKB Reader */
 960 WKBReader *
 961 GEOSWKBReader_create()
 962 {
 963     return GEOSWKBReader_create_r( handle );
 964 }
 965
 966 void
 967 GEOSWKBReader_destroy(WKBReader *reader)
 968 {
 969     GEOSWKBReader_destroy_r( handle, reader );
 970 }
 971
 972
 973 Geometry*
 974 GEOSWKBReader_read(WKBReader *reader, const unsigned char *wkb, size_t size)
 975 {
 976     return GEOSWKBReader_read_r( handle, reader, wkb, size );
 977 }
 978
 979 Geometry*
 980 GEOSWKBReader_readHEX(WKBReader *reader, const unsigned char *hex, size_t size)
 981 {
 982     return GEOSWKBReader_readHEX_r( handle, reader, hex, size );
 983 }
 984
 985 /* WKB Writer */
 986 WKBWriter *
 987 GEOSWKBWriter_create()
 988 {
 989     return GEOSWKBWriter_create_r( handle );
 990 }
 991
 992 void
 993 GEOSWKBWriter_destroy(WKBWriter *Writer)
 994 {
 995     GEOSWKBWriter_destroy_r( handle, Writer );
 996 }
 997
 998
 999 /* The caller owns the result */
1000 unsigned char*
1001 GEOSWKBWriter_write(WKBWriter *writer, const Geometry *geom, size_t *size)
1002 {
1003     return GEOSWKBWriter_write_r( handle, writer, geom, size );
1004 }
1005
1006 /* The caller owns the result */
1007 unsigned char*
1008 GEOSWKBWriter_writeHEX(WKBWriter *writer, const Geometry *geom, size_t *size)
1009 {
1010     return GEOSWKBWriter_writeHEX_r( handle, writer, geom, size );
1011 }
1012
1013 int
1014 GEOSWKBWriter_getOutputDimension(const GEOSWKBWriter* writer)
1015 {
1016     return GEOSWKBWriter_getOutputDimension_r( handle, writer );
1017 }
1018
1019 void
1020 GEOSWKBWriter_setOutputDimension(GEOSWKBWriter* writer, int newDimension)
1021 {
1022     GEOSWKBWriter_setOutputDimension_r( handle, writer, newDimension );
1023 }
1024
1025 int
1026 GEOSWKBWriter_getByteOrder(const GEOSWKBWriter* writer)
1027 {
1028     return GEOSWKBWriter_getByteOrder_r( handle, writer );
1029 }
1030
1031 void
1032 GEOSWKBWriter_setByteOrder(GEOSWKBWriter* writer, int newByteOrder)
1033 {
1034     GEOSWKBWriter_setByteOrder_r( handle, writer, newByteOrder );
1035 }
1036
1037 char
1038 GEOSWKBWriter_getIncludeSRID(const GEOSWKBWriter* writer)
1039 {
1040     return GEOSWKBWriter_getIncludeSRID_r( handle, writer );
1041 }
1042
1043 void
1044 GEOSWKBWriter_setIncludeSRID(GEOSWKBWriter* writer, const char newIncludeSRID)
1045 {
1046     GEOSWKBWriter_setIncludeSRID_r( handle, writer, newIncludeSRID );
1047 }
1048
1049
1050 //-----------------------------------------------------------------
1051 // Prepared Geometry
1052 //-----------------------------------------------------------------
1053
1054 const geos::geom::prep::PreparedGeometry*
1055 GEOSPrepare(const Geometry *g)
1056 {
1057     return GEOSPrepare_r( handle, g );
1058 }
1059
1060 void
1061 GEOSPreparedGeom_destroy(const geos::geom::prep::PreparedGeometry *a)
1062 {
1063     GEOSPreparedGeom_destroy_r( handle, a );
1064 }
1065
1066 char
1067 GEOSPreparedContains(const geos::geom::prep::PreparedGeometry *pg1, const Geometry *g2)
1068 {
1069     return GEOSPreparedContains_r( handle, pg1, g2 );
1070 }
1071
1072 char
1073 GEOSPreparedContainsProperly(const geos::geom::prep::PreparedGeometry *pg1, const Geometry *g2)
1074 {
1075     return GEOSPreparedContainsProperly_r( handle, pg1, g2 );
1076 }
1077
1078 char
1079 GEOSPreparedCoveredBy(const geos::geom::prep::PreparedGeometry *pg1, const Geometry *g2)
1080 {
1081     return GEOSPreparedCoveredBy_r( handle, pg1, g2 );
1082 }
1083
1084 char
1085 GEOSPreparedCovers(const geos::geom::prep::PreparedGeometry *pg1, const Geometry *g2)
1086 {
1087     return GEOSPreparedCovers_r( handle, pg1, g2 );
1088 }
1089
1090 char
1091 GEOSPreparedCrosses(const geos::geom::prep::PreparedGeometry *pg1, const Geometry *g2)
1092 {
1093     return GEOSPreparedCrosses_r( handle, pg1, g2 );
1094 }
1095
1096 char
1097 GEOSPreparedDisjoint(const geos::geom::prep::PreparedGeometry *pg1, const Geometry *g2)
1098 {
1099     return GEOSPreparedDisjoint_r( handle, pg1, g2 );
1100 }
1101
1102 char
1103 GEOSPreparedIntersects(const geos::geom::prep::PreparedGeometry *pg1, const Geometry *g2)
1104 {
1105     return GEOSPreparedIntersects_r( handle, pg1, g2 );
1106 }
1107
1108 char
1109 GEOSPreparedOverlaps(const geos::geom::prep::PreparedGeometry *pg1, const Geometry *g2)
1110 {
1111     return GEOSPreparedOverlaps_r( handle, pg1, g2 );
1112 }
1113
1114 char
1115 GEOSPreparedTouches(const geos::geom::prep::PreparedGeometry *pg1, const Geometry *g2)
1116 {
1117     return GEOSPreparedTouches_r( handle, pg1, g2 );
1118 }
1119
1120 char
1121 GEOSPreparedWithin(const geos::geom::prep::PreparedGeometry *pg1, const Geometry *g2)
1122 {
1123     return GEOSPreparedWithin_r( handle, pg1, g2 );
1124 }
1125
1126 STRtree *
1127 GEOSSTRtree_create (size_t nodeCapacity)
1128 {
1129     return GEOSSTRtree_create_r( handle, nodeCapacity );
1130 }
1131
1132 void
1133 GEOSSTRtree_insert (geos::index::strtree::STRtree *tree,
1134                     const geos::geom::Geometry *g,
1135                     void *item)
1136 {
1137     GEOSSTRtree_insert_r( handle, tree, g, item );
1138 }
1139
1140 void
1141 GEOSSTRtree_query (geos::index::strtree::STRtree *tree,
1142                    const geos::geom::Geometry *g,
1143                    GEOSQueryCallback cb,
1144                    void *userdata)
1145 {
1146     GEOSSTRtree_query_r( handle, tree, g, cb, userdata );
1147 }
1148
1149 void
1150 GEOSSTRtree_iterate(geos::index::strtree::STRtree *tree,
1151                     GEOSQueryCallback callback,
1152                     void *userdata)
1153 {
1154     GEOSSTRtree_iterate_r( handle, tree, callback, userdata );
1155 }
1156
1157 char
1158 GEOSSTRtree_remove (geos::index::strtree::STRtree *tree,
1159                     const geos::geom::Geometry *g,
1160                     void *item)
1161 {
1162     return GEOSSTRtree_remove_r( handle, tree, g, item );
1163 }
1164
1165 void
1166 GEOSSTRtree_destroy (geos::index::strtree::STRtree *tree)
1167 {
1168     GEOSSTRtree_destroy_r( handle, tree );
1169 }
1170
1171 double
1172 GEOSProject (const geos::geom::Geometry *g,
1173              const geos::geom::Geometry *p)
1174 {
1175     return GEOSProject_r (handle, g, p);
1176 }
1177
1178 geos::geom::Geometry *
1179 GEOSInterpolate (const geos::geom::Geometry *g,
1180                  double d)
1181 {
1182     return GEOSInterpolate_r(handle, g, d);
1183 }
1184
1185 double
1186 GEOSProjectNormalized (const geos::geom::Geometry *g,
1187                        const geos::geom::Geometry *p)
1188 {
1189     return GEOSProjectNormalized_r (handle, g, p);
1190 }
1191
1192 geos::geom::Geometry *
1193 GEOSInterpolateNormalized (const geos::geom::Geometry *g,
1194                            double d)
1195 {
1196     return GEOSInterpolateNormalized_r(handle, g, d);
1197 }
1198
1199 geos::geom::Geometry *
1200 GEOSGeom_extractUniquePoints (const geos::geom::Geometry *g)
1201 {
1202     return GEOSGeom_extractUniquePoints_r(handle, g);
1203 }
1204
1205 geos::geom::Geometry *
1206 GEOSGeom_createEmptyCollection(int type)
1207 {
1208     return GEOSGeom_createEmptyCollection_r(handle, type);
1209 }
1210
1211 geos::geom::Geometry *
1212 GEOSGeom_createEmptyPoint()
1213 {
1214     return GEOSGeom_createEmptyPoint_r(handle);
1215 }
1216
1217 geos::geom::Geometry *
1218 GEOSGeom_createEmptyLineString()
1219 {
1220     return GEOSGeom_createEmptyLineString_r(handle);
1221 }
1222
1223 geos::geom::Geometry *
1224 GEOSGeom_createEmptyPolygon()
1225 {
1226     return GEOSGeom_createEmptyPolygon_r(handle);
1227 }
1228
1229 int
1230 GEOSOrientationIndex(double Ax, double Ay, double Bx, double By,
1231         double Px, double Py)
1232 {
1233     return GEOSOrientationIndex_r(handle, Ax, Ay, Bx, By, Px, Py);
1234 }
1235
1236 GEOSGeometry *
1237 GEOSSharedPaths(const GEOSGeometry* g1, const GEOSGeometry* g2)
1238 {
1239     return GEOSSharedPaths_r(handle, g1, g2);
1240 }
1241
1242 GEOSGeometry *
1243 GEOSSnap(const GEOSGeometry* g1, const GEOSGeometry* g2, double tolerance)
1244 {
1245   return GEOSSnap_r(handle, g1, g2, tolerance);
1246 }
1247
1248 GEOSBufferParams*
1249 GEOSBufferParams_create()
1250 {
1251   return GEOSBufferParams_create_r(handle);
1252 }
1253
1254 void
1255 GEOSBufferParams_destroy(GEOSBufferParams* p)
1256 {
1257   return GEOSBufferParams_destroy_r(handle, p);
1258 }
1259
1260 int
1261 GEOSBufferParams_setEndCapStyle(GEOSBufferParams* p, int style)
1262 {
1263   return GEOSBufferParams_setEndCapStyle_r(handle, p, style);
1264 }
1265
1266 int
1267 GEOSBufferParams_setJoinStyle(GEOSBufferParams* p, int joinStyle)
1268 {
1269   return GEOSBufferParams_setJoinStyle_r(handle, p, joinStyle);
1270 }
1271
1272 int
1273 GEOSBufferParams_setMitreLimit(GEOSBufferParams* p, double l)
1274 {
1275   return GEOSBufferParams_setMitreLimit_r(handle, p, l);
1276 }
1277
1278 int
1279 GEOSBufferParams_setQuadrantSegments(GEOSBufferParams* p, int joinStyle)
1280 {
1281   return GEOSBufferParams_setQuadrantSegments_r(handle, p, joinStyle);
1282 }
1283
1284 int
1285 GEOSBufferParams_setSingleSided(GEOSBufferParams* p, int singleSided)
1286 {
1287   return GEOSBufferParams_setSingleSided_r(handle, p, singleSided);
1288 }
1289
1290 Geometry*
1291 GEOSBufferWithParams(const Geometry* g, const GEOSBufferParams* p, double w)
1292 {
1293   return GEOSBufferWithParams_r(handle, g, p, w);
1294 }
1295
1296 Geometry *
1297 GEOSDelaunayTriangulation(const Geometry *g, double tolerance, int onlyEdges)
1298 {
1299   return GEOSDelaunayTriangulation_r(handle, g, tolerance, onlyEdges);
1300 }
1301
1302 Geometry*
1303 GEOSVoronoiDiagram(const Geometry *g, const Geometry *env, double tolerance, int onlyEdges)
1304 {
1305   return GEOSVoronoiDiagram_r(handle, g, env, tolerance, onlyEdges);
1306 }
1307
1308 } /* extern "C" */