capi/geos_c.cpp

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