capi/geos_c.cpp

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