capi/geos_ts_c.cpp

   1 /************************************************************************
   2  *
   3  *
   4  * C-Wrapper for GEOS library
   5  *
   6  * Copyright (C) 2010-2012 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  * Thread Safety modifications: Chuck Thibert <charles.thibert@ingres.com>
  16  *
  17  ***********************************************************************/
  18
  19 #include <geos/platform.h>  // for FINITE
  20 #include <geos/geom/Geometry.h>
  21 #include <geos/geom/prep/PreparedGeometry.h>
  22 #include <geos/geom/prep/PreparedGeometryFactory.h>
  23 #include <geos/geom/GeometryCollection.h>
  24 #include <geos/geom/Polygon.h>
  25 #include <geos/geom/Point.h>
  26 #include <geos/geom/MultiPoint.h>
  27 #include <geos/geom/MultiLineString.h>
  28 #include <geos/geom/MultiPolygon.h>
  29 #include <geos/geom/LinearRing.h>
  30 #include <geos/geom/LineString.h>
  31 #include <geos/geom/PrecisionModel.h>
  32 #include <geos/geom/GeometryFactory.h>
  33 #include <geos/geom/CoordinateSequenceFactory.h>
  34 #include <geos/geom/Coordinate.h>
  35 #include <geos/geom/IntersectionMatrix.h>
  36 #include <geos/geom/Envelope.h>
  37 #include <geos/index/strtree/STRtree.h>
  38 #include <geos/index/ItemVisitor.h>
  39 #include <geos/io/WKTReader.h>
  40 #include <geos/io/WKBReader.h>
  41 #include <geos/io/WKTWriter.h>
  42 #include <geos/io/WKBWriter.h>
  43 #include <geos/algorithm/distance/DiscreteHausdorffDistance.h>
  44 #include <geos/algorithm/CGAlgorithms.h>
  45 #include <geos/algorithm/BoundaryNodeRule.h>
  46 #include <geos/simplify/DouglasPeuckerSimplifier.h>
  47 #include <geos/simplify/TopologyPreservingSimplifier.h>
  48 #include <geos/noding/GeometryNoder.h>
  49 #include <geos/operation/valid/IsValidOp.h>
  50 #include <geos/operation/polygonize/Polygonizer.h>
  51 #include <geos/operation/linemerge/LineMerger.h>
  52 #include <geos/operation/overlay/OverlayOp.h>
  53 #include <geos/operation/overlay/snap/GeometrySnapper.h>
  54 #include <geos/operation/union/CascadedPolygonUnion.h>
  55 #include <geos/operation/buffer/BufferOp.h>
  56 #include <geos/operation/buffer/BufferParameters.h>
  57 #include <geos/operation/buffer/BufferBuilder.h>
  58 #include <geos/operation/relate/RelateOp.h>
  59 #include <geos/operation/sharedpaths/SharedPathsOp.h>
  60 #include <geos/linearref/LengthIndexedLine.h>
  61 #include <geos/triangulate/DelaunayTriangulationBuilder.h>
  62 #include <geos/util/IllegalArgumentException.h>
  63 #include <geos/util/Interrupt.h>
  64 #include <geos/util/UniqueCoordinateArrayFilter.h>
  65 #include <geos/util/Machine.h>
  66 #include <geos/version.h>
  67
  68 // This should go away
  69 #include <cmath> // finite
  70 #include <cstddef>
  71 #include <cstdio>
  72 #include <cstdlib>
  73 #include <cstring>
  74 #include <fstream>
  75 #include <iostream>
  76 #include <sstream>
  77 #include <string>
  78 #include <memory>
  79
  80 #ifdef _MSC_VER
  81 #pragma warning(disable : 4099)
  82 #endif
  83
  84 // Some extra magic to make type declarations in geos_c.h work -
  85 // for cross-checking of types in header.
  86 #define GEOSGeometry geos::geom::Geometry
  87 #define GEOSPreparedGeometry geos::geom::prep::PreparedGeometry
  88 #define GEOSCoordSequence geos::geom::CoordinateSequence
  89 #define GEOSBufferParams geos::operation::buffer::BufferParameters
  90 #define GEOSSTRtree geos::index::strtree::STRtree
  91 #define GEOSWKTReader_t geos::io::WKTReader
  92 #define GEOSWKTWriter_t geos::io::WKTWriter
  93 #define GEOSWKBReader_t geos::io::WKBReader
  94 #define GEOSWKBWriter_t geos::io::WKBWriter
  95
  96 #include "geos_c.h"
  97 #include "../geos_svn_revision.h"
  98
  99 // Intentional, to allow non-standard C elements like C99 functions to be
 100 // imported through C++ headers of C library, like <cmath>.
 101 using namespace std;
 102
 103 /// Define this if you want operations triggering Exceptions to
 104 /// be printed.
 105 /// (will use the NOTIFY channel - only implemented for GEOSUnion so far)
 106 ///
 107 #undef VERBOSE_EXCEPTIONS
 108
 109 #include <geos/export.h>
 110
 111
 112 // import the most frequently used definitions globally
 113 using geos::geom::Geometry;
 114 using geos::geom::LineString;
 115 using geos::geom::Polygon;
 116 using geos::geom::CoordinateSequence;
 117 using geos::geom::GeometryFactory;
 118
 119 using geos::io::WKTReader;
 120 using geos::io::WKTWriter;
 121 using geos::io::WKBReader;
 122 using geos::io::WKBWriter;
 123
 124 using geos::operation::overlay::OverlayOp;
 125 using geos::operation::overlay::overlayOp;
 126 using geos::operation::geounion::CascadedPolygonUnion;
 127 using geos::operation::buffer::BufferParameters;
 128 using geos::operation::buffer::BufferBuilder;
 129 using geos::util::IllegalArgumentException;
 130 using geos::algorithm::distance::DiscreteHausdorffDistance;
 131
 132 typedef std::auto_ptr<Geometry> GeomAutoPtr;
 133
 134 typedef struct GEOSContextHandleInternal
 135 {
 136     const GeometryFactory *geomFactory;
 137     GEOSMessageHandler NOTICE_MESSAGE;
 138     GEOSMessageHandler ERROR_MESSAGE;
 139     int WKBOutputDims;
 140     int WKBByteOrder;
 141     int initialized;
 142 } GEOSContextHandleInternal_t;
 143
 144 // CAPI_ItemVisitor is used internally by the CAPI STRtree
 145 // wrappers. It's defined here just to keep it out of the
 146 // extern "C" block.
 147 class CAPI_ItemVisitor : public geos::index::ItemVisitor {
 148     GEOSQueryCallback callback;
 149     void *userdata;
 150   public:
 151     CAPI_ItemVisitor (GEOSQueryCallback cb, void *ud)
 152         : ItemVisitor(), callback(cb), userdata(ud) {}
 153     void visitItem (void *item) { callback(item, userdata); }
 154 };
 155
 156
 157 //## PROTOTYPES #############################################
 158
 159 extern "C" const char GEOS_DLL *GEOSjtsport();
 160 extern "C" char GEOS_DLL *GEOSasText(Geometry *g1);
 161
 162
 163 namespace { // anonymous
 164
 165 char* gstrdup_s(const char* str, const std::size_t size)
 166 {
 167     char* out = static_cast<char*>(malloc(size + 1));
 168     if (0 != out)
 169     {
 170         // as no strlen call necessary, memcpy may be faster than strcpy
 171         std::memcpy(out, str, size + 1);
 172     }
 173
 174     assert(0 != out);
 175
 176     // we haven't been checking allocation before ticket #371
 177     if (0 == out)
 178     {
 179         throw(std::runtime_error("Failed to allocate memory for duplicate string"));
 180     }
 181
 182     return out;
 183 }
 184
 185 char* gstrdup(std::string const& str)
 186 {
 187     return gstrdup_s(str.c_str(), str.size());
 188 }
 189
 190 } // namespace anonymous
 191
 192 extern "C" {
 193
 194 GEOSContextHandle_t
 195 initGEOS_r(GEOSMessageHandler nf, GEOSMessageHandler ef)
 196 {
 197     GEOSContextHandleInternal_t *handle = 0;
 198     void *extHandle = 0;
 199
 200     extHandle = malloc(sizeof(GEOSContextHandleInternal_t));
 201     if (0 != extHandle)
 202     {
 203         handle = static_cast<GEOSContextHandleInternal_t*>(extHandle);
 204         handle->NOTICE_MESSAGE = nf;
 205         handle->ERROR_MESSAGE = ef;
 206         handle->geomFactory = GeometryFactory::getDefaultInstance();
 207         handle->WKBOutputDims = 2;
 208         handle->WKBByteOrder = getMachineByteOrder();
 209         handle->initialized = 1;
 210     }
 211
 212     geos::util::Interrupt::cancel();
 213
 214     return static_cast<GEOSContextHandle_t>(extHandle);
 215 }
 216
 217 GEOSMessageHandler
 218 GEOSContext_setNoticeHandler_r(GEOSContextHandle_t extHandle, GEOSMessageHandler nf)
 219 {
 220     GEOSMessageHandler f;
 221     GEOSContextHandleInternal_t *handle = 0;
 222     handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
 223     if ( 0 == handle->initialized )
 224     {
 225         return NULL;
 226     }
 227
 228     f = handle->NOTICE_MESSAGE;
 229     handle->NOTICE_MESSAGE = nf;
 230
 231     return f;
 232 }
 233
 234 GEOSMessageHandler
 235 GEOSContext_setErrorHandler_r(GEOSContextHandle_t extHandle, GEOSMessageHandler nf)
 236 {
 237     GEOSMessageHandler f;
 238     GEOSContextHandleInternal_t *handle = 0;
 239     handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
 240     if ( 0 == handle->initialized )
 241     {
 242         return NULL;
 243     }
 244
 245     f = handle->ERROR_MESSAGE;
 246     handle->ERROR_MESSAGE = nf;
 247
 248     return f;
 249 }
 250
 251 void
 252 finishGEOS_r(GEOSContextHandle_t extHandle)
 253 {
 254     // Fix up freeing handle w.r.t. malloc above
 255     free(extHandle);
 256     extHandle = NULL;
 257 }
 258
 259 void
 260 GEOSFree_r (GEOSContextHandle_t extHandle, void* buffer)
 261 {
 262     assert(0 != extHandle);
 263
 264     free(buffer);
 265 }
 266
 267 //-----------------------------------------------------------
 268 // relate()-related functions
 269 //  return 0 = false, 1 = true, 2 = error occured
 270 //-----------------------------------------------------------
 271
 272 char
 273 GEOSDisjoint_r(GEOSContextHandle_t extHandle, const Geometry *g1, const Geometry *g2)
 274 {
 275     if ( 0 == extHandle )
 276     {
 277         return 2;
 278     }
 279
 280     GEOSContextHandleInternal_t *handle = 0;
 281     handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
 282     if ( handle->initialized == 0 )
 283     {
 284         return 2;
 285     }
 286
 287     try
 288     {
 289         bool result = g1->disjoint(g2);
 290         return result;
 291     }
 292
 293     // TODO: mloskot is going to replace these double-catch block
 294     // with a macro to remove redundant code in this and
 295     // following functions.
 296     catch (const std::exception &e)
 297     {
 298         handle->ERROR_MESSAGE("%s", e.what());
 299     }
 300     catch (...)
 301     {
 302         handle->ERROR_MESSAGE("Unknown exception thrown");
 303     }
 304
 305     return 2;
 306 }
 307
 308 char
 309 GEOSTouches_r(GEOSContextHandle_t extHandle, const Geometry *g1, const Geometry *g2)
 310 {
 311     if ( 0 == extHandle )
 312     {
 313         return 2;
 314     }
 315
 316     GEOSContextHandleInternal_t *handle = 0;
 317     handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
 318     if ( 0 == handle->initialized )
 319     {
 320         return 2;
 321     }
 322
 323     try
 324     {
 325         bool result = g1->touches(g2);
 326         return result;
 327     }
 328     catch (const std::exception &e)
 329     {
 330         handle->ERROR_MESSAGE("%s", e.what());
 331     }
 332     catch (...)
 333     {
 334         handle->ERROR_MESSAGE("Unknown exception thrown");
 335     }
 336
 337     return 2;
 338 }
 339
 340 char
 341 GEOSIntersects_r(GEOSContextHandle_t extHandle, const Geometry *g1, const Geometry *g2)
 342 {
 343     if ( 0 == extHandle )
 344     {
 345         return 2;
 346     }
 347
 348     GEOSContextHandleInternal_t *handle = 0;
 349     handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
 350     if ( 0 == handle->initialized )
 351     {
 352         return 2;
 353     }
 354
 355     try
 356     {
 357         bool result = g1->intersects(g2);
 358         return result;
 359     }
 360     catch (const std::exception &e)
 361     {
 362         handle->ERROR_MESSAGE("%s", e.what());
 363     }
 364     catch (...)
 365     {
 366         handle->ERROR_MESSAGE("Unknown exception thrown");
 367     }
 368
 369     return 2;
 370 }
 371
 372 char
 373 GEOSCrosses_r(GEOSContextHandle_t extHandle, const Geometry *g1, const Geometry *g2)
 374 {
 375     if ( 0 == extHandle )
 376     {
 377         return 2;
 378     }
 379
 380     GEOSContextHandleInternal_t *handle = 0;
 381     handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
 382     if ( 0 == handle->initialized )
 383     {
 384         return 2;
 385     }
 386
 387     try
 388     {
 389         bool result = g1->crosses(g2);
 390         return result;
 391     }
 392     catch (const std::exception &e)
 393     {
 394         handle->ERROR_MESSAGE("%s", e.what());
 395     }
 396     catch (...)
 397     {
 398         handle->ERROR_MESSAGE("Unknown exception thrown");
 399     }
 400
 401     return 2;
 402 }
 403
 404 char
 405 GEOSWithin_r(GEOSContextHandle_t extHandle, const Geometry *g1, const Geometry *g2)
 406 {
 407     if ( 0 == extHandle )
 408     {
 409         return 2;
 410     }
 411
 412     GEOSContextHandleInternal_t *handle = 0;
 413     handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
 414     if ( 0 == handle->initialized )
 415     {
 416         return 2;
 417     }
 418
 419     try
 420     {
 421         bool result = g1->within(g2);
 422         return result;
 423     }
 424     catch (const std::exception &e)
 425     {
 426         handle->ERROR_MESSAGE("%s", e.what());
 427     }
 428     catch (...)
 429     {
 430         handle->ERROR_MESSAGE("Unknown exception thrown");
 431     }
 432
 433     return 2;
 434 }
 435
 436 // call g1->contains(g2)
 437 // returns 0 = false
 438 //         1 = true
 439 //         2 = error was trapped
 440 char
 441 GEOSContains_r(GEOSContextHandle_t extHandle, const Geometry *g1, const Geometry *g2)
 442 {
 443     if ( 0 == extHandle )
 444     {
 445         return 2;
 446     }
 447
 448     GEOSContextHandleInternal_t *handle = 0;
 449     handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
 450     if ( 0 == handle->initialized )
 451     {
 452         return 2;
 453     }
 454
 455     try
 456     {
 457         bool result = g1->contains(g2);
 458         return result;
 459     }
 460     catch (const std::exception &e)
 461     {
 462         handle->ERROR_MESSAGE("%s", e.what());
 463     }
 464     catch (...)
 465     {
 466         handle->ERROR_MESSAGE("Unknown exception thrown");
 467     }
 468
 469     return 2;
 470 }
 471
 472 char
 473 GEOSOverlaps_r(GEOSContextHandle_t extHandle, const Geometry *g1, const Geometry *g2)
 474 {
 475     if ( 0 == extHandle )
 476     {
 477         return 2;
 478     }
 479
 480     GEOSContextHandleInternal_t *handle = 0;
 481     handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
 482     if ( 0 == handle->initialized )
 483     {
 484         return 2;
 485     }
 486
 487     try
 488     {
 489         bool result = g1->overlaps(g2);
 490         return result;
 491     }
 492     catch (const std::exception &e)
 493     {
 494         handle->ERROR_MESSAGE("%s", e.what());
 495     }
 496     catch (...)
 497     {
 498         handle->ERROR_MESSAGE("Unknown exception thrown");
 499     }
 500
 501     return 2;
 502 }
 503
 504 char
 505 GEOSCovers_r(GEOSContextHandle_t extHandle, const Geometry *g1, const Geometry *g2)
 506 {
 507     if ( 0 == extHandle )
 508     {
 509         return 2;
 510     }
 511
 512     GEOSContextHandleInternal_t *handle = 0;
 513     handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
 514     if ( 0 == handle->initialized )
 515     {
 516         return 2;
 517     }
 518
 519     try
 520     {
 521         bool result = g1->covers(g2);
 522         return result;
 523     }
 524     catch (const std::exception &e)
 525     {
 526         handle->ERROR_MESSAGE("%s", e.what());
 527     }
 528     catch (...)
 529     {
 530         handle->ERROR_MESSAGE("Unknown exception thrown");
 531     }
 532
 533     return 2;
 534 }
 535
 536 char
 537 GEOSCoveredBy_r(GEOSContextHandle_t extHandle, const Geometry *g1, const Geometry *g2)
 538 {
 539     if ( 0 == extHandle )
 540     {
 541         return 2;
 542     }
 543
 544     GEOSContextHandleInternal_t *handle = 0;
 545     handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
 546     if ( 0 == handle->initialized )
 547     {
 548         return 2;
 549     }
 550
 551     try
 552     {
 553         bool result = g1->coveredBy(g2);
 554         return result;
 555     }
 556     catch (const std::exception &e)
 557     {
 558         handle->ERROR_MESSAGE("%s", e.what());
 559     }
 560     catch (...)
 561     {
 562         handle->ERROR_MESSAGE("Unknown exception thrown");
 563     }
 564
 565     return 2;
 566 }
 567
 568
 569 //-------------------------------------------------------------------
 570 // low-level relate functions
 571 //------------------------------------------------------------------
 572
 573 char
 574 GEOSRelatePattern_r(GEOSContextHandle_t extHandle, const Geometry *g1, const Geometry *g2, const char *pat)
 575 {
 576     if ( 0 == extHandle )
 577     {
 578         return 2;
 579     }
 580
 581     GEOSContextHandleInternal_t *handle = 0;
 582     handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
 583     if ( 0 == handle->initialized )
 584     {
 585         return 2;
 586     }
 587
 588     try
 589     {
 590         std::string s(pat);
 591         bool result = g1->relate(g2, s);
 592         return result;
 593     }
 594     catch (const std::exception &e)
 595     {
 596         handle->ERROR_MESSAGE("%s", e.what());
 597     }
 598     catch (...)
 599     {
 600         handle->ERROR_MESSAGE("Unknown exception thrown");
 601     }
 602
 603     return 2;
 604 }
 605
 606 char
 607 GEOSRelatePatternMatch_r(GEOSContextHandle_t extHandle, const char *mat,
 608                            const char *pat)
 609 {
 610     if ( 0 == extHandle )
 611     {
 612         return 2;
 613     }
 614
 615     GEOSContextHandleInternal_t *handle = 0;
 616     handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
 617     if ( 0 == handle->initialized )
 618     {
 619         return 2;
 620     }
 621
 622     try
 623     {
 624         using geos::geom::IntersectionMatrix;
 625
 626         std::string m(mat);
 627         std::string p(pat);
 628         IntersectionMatrix im(m);
 629
 630         bool result = im.matches(p);
 631         return result;
 632     }
 633     catch (const std::exception &e)
 634     {
 635         handle->ERROR_MESSAGE("%s", e.what());
 636     }
 637     catch (...)
 638     {
 639         handle->ERROR_MESSAGE("Unknown exception thrown");
 640     }
 641
 642     return 2;
 643 }
 644
 645 char *
 646 GEOSRelate_r(GEOSContextHandle_t extHandle, const Geometry *g1, const Geometry *g2)
 647 {
 648     if ( 0 == extHandle )
 649     {
 650         return NULL;
 651     }
 652
 653     GEOSContextHandleInternal_t *handle = 0;
 654     handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
 655     if ( 0 == handle->initialized )
 656     {
 657         return NULL;
 658     }
 659
 660     try
 661     {
 662         using geos::geom::IntersectionMatrix;
 663
 664         IntersectionMatrix* im = g1->relate(g2);
 665         if (0 == im)
 666         {
 667             return 0;
 668         }
 669
 670         char *result = gstrdup(im->toString());
 671
 672         delete im;
 673         im = 0;
 674
 675         return result;
 676     }
 677     catch (const std::exception &e)
 678     {
 679         handle->ERROR_MESSAGE("%s", e.what());
 680     }
 681     catch (...)
 682     {
 683         handle->ERROR_MESSAGE("Unknown exception thrown");
 684     }
 685
 686     return NULL;
 687 }
 688
 689 char *
 690 GEOSRelateBoundaryNodeRule_r(GEOSContextHandle_t extHandle, const Geometry *g1, const Geometry *g2, int bnr)
 691 {
 692     if ( 0 == extHandle )
 693     {
 694         return NULL;
 695     }
 696
 697     GEOSContextHandleInternal_t *handle = 0;
 698     handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
 699     if ( 0 == handle->initialized )
 700     {
 701         return NULL;
 702     }
 703
 704     try
 705     {
 706         using geos::operation::relate::RelateOp;
 707         using geos::geom::IntersectionMatrix;
 708         using geos::algorithm::BoundaryNodeRule;
 709
 710         IntersectionMatrix* im;
 711         switch (bnr) {
 712           case GEOSRELATE_BNR_MOD2: /* same as OGC */
 713             im = RelateOp::relate(g1, g2,
 714                 BoundaryNodeRule::getBoundaryRuleMod2());
 715             break;
 716           case GEOSRELATE_BNR_ENDPOINT:
 717             im = RelateOp::relate(g1, g2,
 718                 BoundaryNodeRule::getBoundaryEndPoint());
 719             break;
 720           case GEOSRELATE_BNR_MULTIVALENT_ENDPOINT:
 721             im = RelateOp::relate(g1, g2,
 722                 BoundaryNodeRule::getBoundaryMultivalentEndPoint());
 723             break;
 724           case GEOSRELATE_BNR_MONOVALENT_ENDPOINT:
 725             im = RelateOp::relate(g1, g2,
 726                 BoundaryNodeRule::getBoundaryMonovalentEndPoint());
 727             break;
 728           default:
 729             handle->ERROR_MESSAGE("Invalid boundary node rule %d", bnr);
 730             return 0;
 731             break;
 732         }
 733
 734         if (0 == im) return 0;
 735
 736         char *result = gstrdup(im->toString());
 737
 738         delete im;
 739         im = 0;
 740
 741         return result;
 742     }
 743     catch (const std::exception &e)
 744     {
 745         handle->ERROR_MESSAGE("%s", e.what());
 746     }
 747     catch (...)
 748     {
 749         handle->ERROR_MESSAGE("Unknown exception thrown");
 750     }
 751
 752     return NULL;
 753 }
 754
 755
 756
 757 //-----------------------------------------------------------------
 758 // isValid
 759 //-----------------------------------------------------------------
 760
 761
 762 char
 763 GEOSisValid_r(GEOSContextHandle_t extHandle, const Geometry *g1)
 764 {
 765     if ( 0 == extHandle )
 766     {
 767         return 2;
 768     }
 769
 770     GEOSContextHandleInternal_t *handle = 0;
 771     handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
 772     if ( 0 == handle->initialized )
 773     {
 774         return 2;
 775     }
 776
 777     try
 778     {
 779         using geos::operation::valid::IsValidOp;
 780         using geos::operation::valid::TopologyValidationError;
 781
 782         IsValidOp ivo(g1);
 783         TopologyValidationError *err = ivo.getValidationError();
 784         if ( err )
 785         {
 786            handle->NOTICE_MESSAGE("%s", err->toString().c_str());
 787            return 0;
 788         }
 789         else
 790         {
 791            return 1;
 792         }
 793     }
 794     catch (const std::exception &e)
 795     {
 796         handle->ERROR_MESSAGE("%s", e.what());
 797     }
 798     catch (...)
 799     {
 800         handle->ERROR_MESSAGE("Unknown exception thrown");
 801     }
 802
 803     return 2;
 804 }
 805
 806 char *
 807 GEOSisValidReason_r(GEOSContextHandle_t extHandle, const Geometry *g1)
 808 {
 809     if ( 0 == extHandle )
 810     {
 811         return NULL;
 812     }
 813
 814     GEOSContextHandleInternal_t *handle = 0;
 815     handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
 816     if ( 0 == handle->initialized )
 817     {
 818         return NULL;
 819     }
 820
 821     try
 822     {
 823         using geos::operation::valid::IsValidOp;
 824         using geos::operation::valid::TopologyValidationError;
 825
 826         char* result = 0;
 827         char const* const validstr = "Valid Geometry";
 828
 829         IsValidOp ivo(g1);
 830         TopologyValidationError *err = ivo.getValidationError();
 831         if (0 != err)
 832         {
 833             std::ostringstream ss;
 834             ss.precision(15);
 835             ss << err->getCoordinate();
 836             const std::string errloc = ss.str();
 837             std::string errmsg(err->getMessage());
 838             errmsg += "[" + errloc + "]";
 839             result = gstrdup(errmsg);
 840         }
 841         else
 842         {
 843             result = gstrdup(std::string(validstr));
 844         }
 845
 846         return result;
 847     }
 848     catch (const std::exception &e)
 849     {
 850         handle->ERROR_MESSAGE("%s", e.what());
 851     }
 852     catch (...)
 853     {
 854         handle->ERROR_MESSAGE("Unknown exception thrown");
 855     }
 856
 857     return 0;
 858 }
 859
 860 char
 861 GEOSisValidDetail_r(GEOSContextHandle_t extHandle, const Geometry *g,
 862         int flags, char** reason, Geometry ** location)
 863 {
 864     if ( 0 == extHandle )
 865     {
 866         return 0;
 867     }
 868
 869     GEOSContextHandleInternal_t *handle = 0;
 870     handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
 871     if ( 0 == handle->initialized )
 872     {
 873         return 0;
 874     }
 875
 876     try
 877     {
 878         using geos::operation::valid::IsValidOp;
 879         using geos::operation::valid::TopologyValidationError;
 880
 881         IsValidOp ivo(g);
 882         if ( flags & GEOSVALID_ALLOW_SELFTOUCHING_RING_FORMING_HOLE ) {
 883                 ivo.setSelfTouchingRingFormingHoleValid(true);
 884         }
 885         TopologyValidationError *err = ivo.getValidationError();
 886         if (0 != err)
 887         {
 888           if ( location ) {
 889             *location = handle->geomFactory->createPoint(err->getCoordinate());
 890           }
 891           if ( reason ) {
 892             std::string errmsg(err->getMessage());
 893             *reason = gstrdup(errmsg);
 894           }
 895           return 0;
 896         }
 897
 898         if ( location ) *location = 0;
 899         if ( reason ) *reason = 0;
 900         return 1; /* valid */
 901
 902     }
 903     catch (const std::exception &e)
 904     {
 905         handle->ERROR_MESSAGE("%s", e.what());
 906     }
 907     catch (...)
 908     {
 909         handle->ERROR_MESSAGE("Unknown exception thrown");
 910     }
 911
 912     return 2; /* exception */
 913 }
 914
 915 //-----------------------------------------------------------------
 916 // general purpose
 917 //-----------------------------------------------------------------
 918
 919 char
 920 GEOSEquals_r(GEOSContextHandle_t extHandle, const Geometry *g1, const Geometry *g2)
 921 {
 922     if ( 0 == extHandle )
 923     {
 924         return 2;
 925     }
 926
 927     GEOSContextHandleInternal_t *handle = 0;
 928     handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
 929     if ( 0 == handle->initialized )
 930     {
 931         return 2;
 932     }
 933
 934     try
 935     {
 936         bool result = g1->equals(g2);
 937         return result;
 938     }
 939     catch (const std::exception &e)
 940     {
 941         handle->ERROR_MESSAGE("%s", e.what());
 942     }
 943     catch (...)
 944     {
 945         handle->ERROR_MESSAGE("Unknown exception thrown");
 946     }
 947
 948     return 2;
 949 }
 950
 951 char
 952 GEOSEqualsExact_r(GEOSContextHandle_t extHandle, const Geometry *g1, const Geometry *g2, double tolerance)
 953 {
 954     if ( 0 == extHandle )
 955     {
 956         return 2;
 957     }
 958
 959     GEOSContextHandleInternal_t *handle = 0;
 960     handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
 961     if ( 0 == handle->initialized )
 962     {
 963         return 2;
 964     }
 965
 966     try
 967     {
 968         bool result = g1->equalsExact(g2, tolerance);
 969         return result;
 970     }
 971     catch (const std::exception &e)
 972     {
 973         handle->ERROR_MESSAGE("%s", e.what());
 974     }
 975     catch (...)
 976     {
 977         handle->ERROR_MESSAGE("Unknown exception thrown");
 978     }
 979
 980     return 2;
 981 }
 982
 983 int
 984 GEOSDistance_r(GEOSContextHandle_t extHandle, const Geometry *g1, const Geometry *g2, double *dist)
 985 {
 986     assert(0 != dist);
 987
 988     if ( 0 == extHandle )
 989     {
 990         return 0;
 991     }
 992
 993     GEOSContextHandleInternal_t *handle = 0;
 994     handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
 995     if ( 0 == handle->initialized )
 996     {
 997         return 0;
 998     }
 999
1000     try
1001     {
1002         *dist = g1->distance(g2);
1003         return 1;
1004     }
1005     catch (const std::exception &e)
1006     {
1007         handle->ERROR_MESSAGE("%s", e.what());
1008     }
1009     catch (...)
1010     {
1011         handle->ERROR_MESSAGE("Unknown exception thrown");
1012     }
1013
1014     return 0;
1015 }
1016
1017 int
1018 GEOSHausdorffDistance_r(GEOSContextHandle_t extHandle, const Geometry *g1, const Geometry *g2, double *dist)
1019 {
1020     assert(0 != dist);
1021
1022     if ( 0 == extHandle )
1023     {
1024         return 0;
1025     }
1026
1027     GEOSContextHandleInternal_t *handle = 0;
1028     handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
1029     if ( 0 == handle->initialized )
1030     {
1031         return 0;
1032     }
1033
1034     try
1035     {
1036         *dist = DiscreteHausdorffDistance::distance(*g1, *g2);
1037         return 1;
1038     }
1039     catch (const std::exception &e)
1040     {
1041         handle->ERROR_MESSAGE("%s", e.what());
1042     }
1043     catch (...)
1044     {
1045         handle->ERROR_MESSAGE("Unknown exception thrown");
1046     }
1047
1048     return 0;
1049 }
1050
1051 int
1052 GEOSHausdorffDistanceDensify_r(GEOSContextHandle_t extHandle, const Geometry *g1, const Geometry *g2, double densifyFrac, double *dist)
1053 {
1054     assert(0 != dist);
1055
1056     if ( 0 == extHandle )
1057     {
1058         return 0;
1059     }
1060
1061     GEOSContextHandleInternal_t *handle = 0;
1062     handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
1063     if ( 0 == handle->initialized )
1064     {
1065         return 0;
1066     }
1067
1068     try
1069     {
1070         *dist = DiscreteHausdorffDistance::distance(*g1, *g2, densifyFrac);
1071         return 1;
1072     }
1073     catch (const std::exception &e)
1074     {
1075         handle->ERROR_MESSAGE("%s", e.what());
1076     }
1077     catch (...)
1078     {
1079         handle->ERROR_MESSAGE("Unknown exception thrown");
1080     }
1081
1082     return 0;
1083 }
1084
1085 int
1086 GEOSArea_r(GEOSContextHandle_t extHandle, const Geometry *g, double *area)
1087 {
1088     assert(0 != area);
1089
1090     if ( 0 == extHandle )
1091     {
1092         return 0;
1093     }
1094
1095     GEOSContextHandleInternal_t *handle = 0;
1096     handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
1097     if ( 0 == handle->initialized )
1098     {
1099         return 0;
1100     }
1101
1102     try
1103     {
1104         *area = g->getArea();
1105         return 1;
1106     }
1107     catch (const std::exception &e)
1108     {
1109         handle->ERROR_MESSAGE("%s", e.what());
1110     }
1111     catch (...)
1112     {
1113         handle->ERROR_MESSAGE("Unknown exception thrown");
1114     }
1115
1116     return 0;
1117 }
1118
1119 int
1120 GEOSLength_r(GEOSContextHandle_t extHandle, const Geometry *g, double *length)
1121 {
1122     assert(0 != length);
1123
1124     if ( 0 == extHandle )
1125     {
1126         return 2;
1127     }
1128
1129     GEOSContextHandleInternal_t *handle = 0;
1130     handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
1131     if ( 0 == handle->initialized )
1132     {
1133         return 0;
1134     }
1135
1136     try
1137     {
1138         *length = g->getLength();
1139         return 1;
1140     }
1141     catch (const std::exception &e)
1142     {
1143         handle->ERROR_MESSAGE("%s", e.what());
1144     }
1145     catch (...)
1146     {
1147         handle->ERROR_MESSAGE("Unknown exception thrown");
1148     }
1149
1150     return 0;
1151 }
1152
1153 Geometry *
1154 GEOSGeomFromWKT_r(GEOSContextHandle_t extHandle, const char *wkt)
1155 {
1156     if ( 0 == extHandle )
1157     {
1158         return NULL;
1159     }
1160
1161     GEOSContextHandleInternal_t *handle = 0;
1162     handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
1163     if ( 0 == handle->initialized )
1164     {
1165         return NULL;
1166     }
1167
1168     try
1169     {
1170         const std::string wktstring(wkt);
1171         WKTReader r(static_cast<GeometryFactory const*>(handle->geomFactory));
1172
1173         Geometry *g = r.read(wktstring);
1174         return g;
1175     }
1176     catch (const std::exception &e)
1177     {
1178         handle->ERROR_MESSAGE("%s", e.what());
1179     }
1180     catch (...)
1181     {
1182         handle->ERROR_MESSAGE("Unknown exception thrown");
1183     }
1184
1185     return NULL;
1186 }
1187
1188 char *
1189 GEOSGeomToWKT_r(GEOSContextHandle_t extHandle, const Geometry *g1)
1190 {
1191     if ( 0 == extHandle )
1192     {
1193         return NULL;
1194     }
1195
1196     GEOSContextHandleInternal_t *handle = 0;
1197     handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
1198     if ( 0 == handle->initialized )
1199     {
1200         return NULL;
1201     }
1202
1203     try
1204     {
1205
1206         char *result = gstrdup(g1->toString());
1207         return result;
1208     }
1209     catch (const std::exception &e)
1210     {
1211         handle->ERROR_MESSAGE("%s", e.what());
1212     }
1213     catch (...)
1214     {
1215         handle->ERROR_MESSAGE("Unknown exception thrown");
1216     }
1217     return NULL;
1218 }
1219
1220 // Remember to free the result!
1221 unsigned char *
1222 GEOSGeomToWKB_buf_r(GEOSContextHandle_t extHandle, const Geometry *g, size_t *size)
1223 {
1224     assert(0 != size);
1225
1226     if ( 0 == extHandle )
1227     {
1228         return NULL;
1229     }
1230
1231     GEOSContextHandleInternal_t *handle = 0;
1232     handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
1233     if ( 0 == handle->initialized )
1234     {
1235         return NULL;
1236     }
1237
1238     using geos::io::WKBWriter;
1239     try
1240     {
1241         int byteOrder = handle->WKBByteOrder;
1242         WKBWriter w(handle->WKBOutputDims, byteOrder);
1243         std::ostringstream os(std::ios_base::binary);
1244         w.write(*g, os);
1245         std::string wkbstring(os.str());
1246         const std::size_t len = wkbstring.length();
1247
1248         unsigned char* result = 0;
1249         result = static_cast<unsigned char*>(malloc(len));
1250         if (0 != result)
1251         {
1252             std::memcpy(result, wkbstring.c_str(), len);
1253             *size = len;
1254         }
1255         return result;
1256     }
1257     catch (const std::exception &e)
1258     {
1259         handle->ERROR_MESSAGE("%s", e.what());
1260     }
1261     catch (...)
1262     {
1263         handle->ERROR_MESSAGE("Unknown exception thrown");
1264     }
1265
1266     return NULL;
1267 }
1268
1269 Geometry *
1270 GEOSGeomFromWKB_buf_r(GEOSContextHandle_t extHandle, const unsigned char *wkb, size_t size)
1271 {
1272     if ( 0 == extHandle )
1273     {
1274         return NULL;
1275     }
1276
1277     GEOSContextHandleInternal_t *handle = 0;
1278     handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
1279     if ( 0 == handle->initialized )
1280     {
1281         return NULL;
1282     }
1283
1284     using geos::io::WKBReader;
1285     try
1286     {
1287         std::string wkbstring(reinterpret_cast<const char*>(wkb), size); // make it binary !
1288         WKBReader r(*(static_cast<GeometryFactory const*>(handle->geomFactory)));
1289         std::istringstream is(std::ios_base::binary);
1290         is.str(wkbstring);
1291         is.seekg(0, std::ios::beg); // rewind reader pointer
1292         Geometry *g = r.read(is);
1293         return g;
1294     }
1295     catch (const std::exception &e)
1296     {
1297         handle->ERROR_MESSAGE("%s", e.what());
1298     }
1299     catch (...)
1300     {
1301         handle->ERROR_MESSAGE("Unknown exception thrown");
1302     }
1303
1304     return NULL;
1305 }
1306
1307 /* Read/write wkb hex values.  Returned geometries are
1308    owned by the caller.*/
1309 unsigned char *
1310 GEOSGeomToHEX_buf_r(GEOSContextHandle_t extHandle, const Geometry *g, size_t *size)
1311 {
1312     if ( 0 == extHandle )
1313     {
1314         return NULL;
1315     }
1316
1317     GEOSContextHandleInternal_t *handle = 0;
1318     handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
1319     if ( 0 == handle->initialized )
1320     {
1321         return NULL;
1322     }
1323
1324     using geos::io::WKBWriter;
1325     try
1326     {
1327         int byteOrder = handle->WKBByteOrder;
1328         WKBWriter w(handle->WKBOutputDims, byteOrder);
1329         std::ostringstream os(std::ios_base::binary);
1330         w.writeHEX(*g, os);
1331         std::string hexstring(os.str());
1332
1333         char *result = gstrdup(hexstring);
1334         if (0 != result)
1335         {
1336             *size = hexstring.length();
1337         }
1338
1339         return reinterpret_cast<unsigned char*>(result);
1340     }
1341     catch (const std::exception &e)
1342     {
1343         handle->ERROR_MESSAGE("%s", e.what());
1344     }
1345     catch (...)
1346     {
1347         handle->ERROR_MESSAGE("Unknown exception thrown");
1348     }
1349
1350     return NULL;
1351 }
1352
1353 Geometry *
1354 GEOSGeomFromHEX_buf_r(GEOSContextHandle_t extHandle, const unsigned char *hex, size_t size)
1355 {
1356     if ( 0 == extHandle )
1357     {
1358         return NULL;
1359     }
1360
1361     GEOSContextHandleInternal_t *handle = 0;
1362     handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
1363     if ( 0 == handle->initialized )
1364     {
1365         return NULL;
1366     }
1367
1368     using geos::io::WKBReader;
1369     try
1370     {
1371         std::string hexstring(reinterpret_cast<const char*>(hex), size);
1372         WKBReader r(*(static_cast<GeometryFactory const*>(handle->geomFactory)));
1373         std::istringstream is(std::ios_base::binary);
1374         is.str(hexstring);
1375         is.seekg(0, std::ios::beg); // rewind reader pointer
1376
1377         Geometry *g = r.readHEX(is);
1378         return g;
1379     }
1380     catch (const std::exception &e)
1381     {
1382         handle->ERROR_MESSAGE("%s", e.what());
1383     }
1384     catch (...)
1385     {
1386         handle->ERROR_MESSAGE("Unknown exception thrown");
1387     }
1388
1389     return NULL;
1390 }
1391
1392 char
1393 GEOSisEmpty_r(GEOSContextHandle_t extHandle, const Geometry *g1)
1394 {
1395     if ( 0 == extHandle )
1396     {
1397         return 2;
1398     }
1399
1400     GEOSContextHandleInternal_t *handle = 0;
1401     handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
1402     if ( 0 == handle->initialized )
1403     {
1404         return 2;
1405     }
1406
1407     try
1408     {
1409         return g1->isEmpty();
1410     }
1411     catch (const std::exception &e)
1412     {
1413         handle->ERROR_MESSAGE("%s", e.what());
1414     }
1415     catch (...)
1416     {
1417         handle->ERROR_MESSAGE("Unknown exception thrown");
1418     }
1419
1420     return 2;
1421 }
1422
1423 char
1424 GEOSisSimple_r(GEOSContextHandle_t extHandle, const Geometry *g1)
1425 {
1426     if ( 0 == extHandle )
1427     {
1428         return 2;
1429     }
1430
1431     GEOSContextHandleInternal_t *handle = 0;
1432     handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
1433     if ( 0 == handle->initialized )
1434     {
1435         return 2;
1436     }
1437
1438     try
1439     {
1440         return g1->isSimple();
1441     }
1442     catch (const std::exception &e)
1443     {
1444         handle->ERROR_MESSAGE("%s", e.what());
1445         return 2;
1446     }
1447
1448     catch (...)
1449     {
1450         handle->ERROR_MESSAGE("Unknown exception thrown");
1451         return 2;
1452     }
1453 }
1454
1455 char
1456 GEOSisRing_r(GEOSContextHandle_t extHandle, const Geometry *g)
1457 {
1458     if ( 0 == extHandle )
1459     {
1460         return 2;
1461     }
1462
1463     GEOSContextHandleInternal_t *handle = 0;
1464     handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
1465     if ( 0 == handle->initialized )
1466     {
1467         return 2;
1468     }
1469
1470     try
1471     {
1472         const LineString *ls = dynamic_cast<const LineString *>(g);
1473         if ( ls ) {
1474             return (ls->isRing());
1475         } else {
1476             return 0;
1477         }
1478     }
1479     catch (const std::exception &e)
1480     {
1481         handle->ERROR_MESSAGE("%s", e.what());
1482         return 2;
1483     }
1484
1485     catch (...)
1486     {
1487         handle->ERROR_MESSAGE("Unknown exception thrown");
1488         return 2;
1489     }
1490 }
1491
1492
1493
1494 //free the result of this
1495 char *
1496 GEOSGeomType_r(GEOSContextHandle_t extHandle, const Geometry *g1)
1497 {
1498     if ( 0 == extHandle )
1499     {
1500         return NULL;
1501     }
1502
1503     GEOSContextHandleInternal_t *handle = 0;
1504     handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
1505     if ( 0 == handle->initialized )
1506     {
1507         return NULL;
1508     }
1509
1510     try
1511     {
1512         std::string s = g1->getGeometryType();
1513
1514         char *result = gstrdup(s);
1515         return result;
1516     }
1517     catch (const std::exception &e)
1518     {
1519         handle->ERROR_MESSAGE("%s", e.what());
1520     }
1521     catch (...)
1522     {
1523         handle->ERROR_MESSAGE("Unknown exception thrown");
1524     }
1525
1526     return NULL;
1527 }
1528
1529 // Return postgis geometry type index
1530 int
1531 GEOSGeomTypeId_r(GEOSContextHandle_t extHandle, const Geometry *g1)
1532 {
1533     if ( 0 == extHandle )
1534     {
1535         return -1;
1536     }
1537
1538     GEOSContextHandleInternal_t *handle = 0;
1539     handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
1540     if ( 0 == handle->initialized )
1541     {
1542         return -1;
1543     }
1544
1545     try
1546     {
1547         return g1->getGeometryTypeId();
1548     }
1549     catch (const std::exception &e)
1550     {
1551         handle->ERROR_MESSAGE("%s", e.what());
1552     }
1553     catch (...)
1554     {
1555         handle->ERROR_MESSAGE("Unknown exception thrown");
1556     }
1557
1558     return -1;
1559 }
1560
1561 //-------------------------------------------------------------------
1562 // GEOS functions that return geometries
1563 //-------------------------------------------------------------------
1564
1565 Geometry *
1566 GEOSEnvelope_r(GEOSContextHandle_t extHandle, const Geometry *g1)
1567 {
1568     if ( 0 == extHandle )
1569     {
1570         return NULL;
1571     }
1572
1573     GEOSContextHandleInternal_t *handle = 0;
1574     handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
1575     if ( 0 == handle->initialized )
1576     {
1577         return NULL;
1578     }
1579
1580     try
1581     {
1582         Geometry *g3 = g1->getEnvelope();
1583         return g3;
1584     }
1585     catch (const std::exception &e)
1586     {
1587         handle->ERROR_MESSAGE("%s", e.what());
1588     }
1589     catch (...)
1590     {
1591         handle->ERROR_MESSAGE("Unknown exception thrown");
1592     }
1593
1594     return NULL;
1595 }
1596
1597 Geometry *
1598 GEOSIntersection_r(GEOSContextHandle_t extHandle, const Geometry *g1, const Geometry *g2)
1599 {
1600     if ( 0 == extHandle )
1601     {
1602         return NULL;
1603     }
1604
1605     GEOSContextHandleInternal_t *handle = 0;
1606     handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
1607     if ( 0 == handle->initialized )
1608     {
1609         return NULL;
1610     }
1611
1612     try
1613     {
1614         return g1->intersection(g2);
1615     }
1616     catch (const std::exception &e)
1617     {
1618         handle->ERROR_MESSAGE("%s", e.what());
1619     }
1620     catch (...)
1621     {
1622         handle->ERROR_MESSAGE("Unknown exception thrown");
1623     }
1624
1625     return NULL;
1626 }
1627
1628 Geometry *
1629 GEOSBuffer_r(GEOSContextHandle_t extHandle, const Geometry *g1, double width, int quadrantsegments)
1630 {
1631     if ( 0 == extHandle )
1632     {
1633         return NULL;
1634     }
1635
1636     GEOSContextHandleInternal_t *handle = 0;
1637     handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
1638     if ( 0 == handle->initialized )
1639     {
1640         return NULL;
1641     }
1642
1643     try
1644     {
1645         Geometry *g3 = g1->buffer(width, quadrantsegments);
1646         return g3;
1647     }
1648     catch (const std::exception &e)
1649     {
1650         handle->ERROR_MESSAGE("%s", e.what());
1651     }
1652     catch (...)
1653     {
1654         handle->ERROR_MESSAGE("Unknown exception thrown");
1655     }
1656
1657     return NULL;
1658 }
1659
1660 Geometry *
1661 GEOSBufferWithStyle_r(GEOSContextHandle_t extHandle, const Geometry *g1, double width, int quadsegs, int endCapStyle, int joinStyle, double mitreLimit)
1662 {
1663     using geos::operation::buffer::BufferParameters;
1664     using geos::operation::buffer::BufferOp;
1665     using geos::util::IllegalArgumentException;
1666
1667     if ( 0 == extHandle )
1668     {
1669         return NULL;
1670     }
1671
1672     GEOSContextHandleInternal_t *handle = 0;
1673     handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
1674     if ( 0 == handle->initialized )
1675     {
1676         return NULL;
1677     }
1678
1679     try
1680     {
1681         BufferParameters bp;
1682         bp.setQuadrantSegments(quadsegs);
1683
1684         if ( endCapStyle > BufferParameters::CAP_SQUARE )
1685         {
1686                 throw IllegalArgumentException("Invalid buffer endCap style");
1687         }
1688         bp.setEndCapStyle(
1689                 static_cast<BufferParameters::EndCapStyle>(endCapStyle)
1690         );
1691
1692         if ( joinStyle > BufferParameters::JOIN_BEVEL )
1693         {
1694                 throw IllegalArgumentException("Invalid buffer join style");
1695         }
1696         bp.setJoinStyle(
1697                 static_cast<BufferParameters::JoinStyle>(joinStyle)
1698         );
1699         bp.setMitreLimit(mitreLimit);
1700         BufferOp op(g1, bp);
1701         Geometry *g3 = op.getResultGeometry(width);
1702         return g3;
1703     }
1704     catch (const std::exception &e)
1705     {
1706         handle->ERROR_MESSAGE("%s", e.what());
1707     }
1708     catch (...)
1709     {
1710         handle->ERROR_MESSAGE("Unknown exception thrown");
1711     }
1712
1713     return NULL;
1714 }
1715
1716 Geometry *
1717 GEOSOffsetCurve_r(GEOSContextHandle_t extHandle, const Geometry *g1, double width, int quadsegs, int joinStyle, double mitreLimit)
1718 {
1719     if ( 0 == extHandle ) return NULL;
1720
1721     GEOSContextHandleInternal_t *handle = 0;
1722     handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
1723     if ( 0 == handle->initialized ) return NULL;
1724
1725     try
1726     {
1727         BufferParameters bp;
1728         bp.setEndCapStyle( BufferParameters::CAP_FLAT );
1729         bp.setQuadrantSegments(quadsegs);
1730
1731         if ( joinStyle > BufferParameters::JOIN_BEVEL )
1732         {
1733             throw IllegalArgumentException("Invalid buffer join style");
1734         }
1735         bp.setJoinStyle(
1736             static_cast<BufferParameters::JoinStyle>(joinStyle)
1737             );
1738         bp.setMitreLimit(mitreLimit);
1739
1740         bool isLeftSide = true;
1741         if ( width < 0 ) {
1742           isLeftSide = false;
1743           width = -width;
1744         }
1745         BufferBuilder bufBuilder (bp);
1746         Geometry *g3 = bufBuilder.bufferLineSingleSided(g1, width, isLeftSide);
1747
1748         return g3;
1749     }
1750     catch (const std::exception &e)
1751     {
1752         handle->ERROR_MESSAGE("%s", e.what());
1753     }
1754     catch (...)
1755     {
1756         handle->ERROR_MESSAGE("Unknown exception thrown");
1757     }
1758
1759     return NULL;
1760 }
1761
1762 /* @deprecated in 3.3.0 */
1763 Geometry *
1764 GEOSSingleSidedBuffer_r(GEOSContextHandle_t extHandle, const Geometry *g1, double width, int quadsegs, int joinStyle, double mitreLimit, int leftSide)
1765 {
1766     if ( 0 == extHandle ) return NULL;
1767
1768     GEOSContextHandleInternal_t *handle = 0;
1769     handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
1770     if ( 0 == handle->initialized ) return NULL;
1771
1772     try
1773     {
1774         BufferParameters bp;
1775         bp.setEndCapStyle( BufferParameters::CAP_FLAT );
1776         bp.setQuadrantSegments(quadsegs);
1777
1778         if ( joinStyle > BufferParameters::JOIN_BEVEL )
1779         {
1780             throw IllegalArgumentException("Invalid buffer join style");
1781         }
1782         bp.setJoinStyle(
1783             static_cast<BufferParameters::JoinStyle>(joinStyle)
1784             );
1785         bp.setMitreLimit(mitreLimit);
1786
1787         bool isLeftSide = leftSide == 0 ? false : true;
1788         BufferBuilder bufBuilder (bp);
1789         Geometry *g3 = bufBuilder.bufferLineSingleSided(g1, width, isLeftSide);
1790
1791         return g3;
1792     }
1793     catch (const std::exception &e)
1794     {
1795         handle->ERROR_MESSAGE("%s", e.what());
1796     }
1797     catch (...)
1798     {
1799         handle->ERROR_MESSAGE("Unknown exception thrown");
1800     }
1801
1802     return NULL;
1803 }
1804
1805 Geometry *
1806 GEOSConvexHull_r(GEOSContextHandle_t extHandle, const Geometry *g1)
1807 {
1808     if ( 0 == extHandle )
1809     {
1810         return NULL;
1811     }
1812
1813     GEOSContextHandleInternal_t *handle = 0;
1814     handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
1815     if ( 0 == handle->initialized )
1816     {
1817         return NULL;
1818     }
1819
1820     try
1821     {
1822         Geometry *g3 = g1->convexHull();
1823         return g3;
1824     }
1825     catch (const std::exception &e)
1826     {
1827         handle->ERROR_MESSAGE("%s", e.what());
1828     }
1829     catch (...)
1830     {
1831         handle->ERROR_MESSAGE("Unknown exception thrown");
1832     }
1833
1834     return NULL;
1835 }
1836
1837 Geometry *
1838 GEOSDifference_r(GEOSContextHandle_t extHandle, const Geometry *g1, const Geometry *g2)
1839 {
1840     if ( 0 == extHandle )
1841     {
1842         return NULL;
1843     }
1844
1845     GEOSContextHandleInternal_t *handle = 0;
1846     handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
1847     if ( 0 == handle->initialized )
1848     {
1849         return NULL;
1850     }
1851
1852     try
1853     {
1854         return g1->difference(g2);
1855     }
1856     catch (const std::exception &e)
1857     {
1858         handle->ERROR_MESSAGE("%s", e.what());
1859     }
1860     catch (...)
1861     {
1862         handle->ERROR_MESSAGE("Unknown exception thrown");
1863     }
1864
1865     return NULL;
1866 }
1867
1868 Geometry *
1869 GEOSBoundary_r(GEOSContextHandle_t extHandle, const Geometry *g1)
1870 {
1871     if ( 0 == extHandle )
1872     {
1873         return NULL;
1874     }
1875
1876     GEOSContextHandleInternal_t *handle = 0;
1877     handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
1878     if ( 0 == handle->initialized )
1879     {
1880         return NULL;
1881     }
1882
1883     try
1884     {
1885         Geometry *g3 = g1->getBoundary();
1886         return g3;
1887     }
1888     catch (const std::exception &e)
1889     {
1890         handle->ERROR_MESSAGE("%s", e.what());
1891     }
1892     catch (...)
1893     {
1894         handle->ERROR_MESSAGE("Unknown exception thrown");
1895     }
1896
1897     return NULL;
1898 }
1899
1900 Geometry *
1901 GEOSSymDifference_r(GEOSContextHandle_t extHandle, const Geometry *g1, const Geometry *g2)
1902 {
1903     if ( 0 == extHandle )
1904     {
1905         return NULL;
1906     }
1907
1908     GEOSContextHandleInternal_t *handle = 0;
1909     handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
1910     if ( 0 == handle->initialized )
1911     {
1912         return NULL;
1913     }
1914
1915     try
1916     {
1917         return g1->symDifference(g2);
1918     }
1919     catch (const std::exception &e)
1920     {
1921         handle->ERROR_MESSAGE("%s", e.what());
1922         return NULL;
1923     }
1924
1925     catch (...)
1926     {
1927         handle->ERROR_MESSAGE("Unknown exception thrown");
1928         return NULL;
1929     }
1930 }
1931
1932 Geometry *
1933 GEOSUnion_r(GEOSContextHandle_t extHandle, const Geometry *g1, const Geometry *g2)
1934 {
1935     if ( 0 == extHandle )
1936     {
1937         return NULL;
1938     }
1939
1940     GEOSContextHandleInternal_t *handle = 0;
1941     handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
1942     if ( 0 == handle->initialized )
1943     {
1944         return NULL;
1945     }
1946
1947     try
1948     {
1949         return g1->Union(g2);
1950     }
1951     catch (const std::exception &e)
1952     {
1953 #if VERBOSE_EXCEPTIONS
1954         std::ostringstream s;
1955         s << "Exception on GEOSUnion with following inputs:" << std::endl;
1956         s << "A: "<<g1->toString() << std::endl;
1957         s << "B: "<<g2->toString() << std::endl;
1958         handle->NOTICE_MESSAGE("%s", s.str().c_str());
1959 #endif // VERBOSE_EXCEPTIONS
1960         handle->ERROR_MESSAGE("%s", e.what());
1961     }
1962     catch (...)
1963     {
1964         handle->ERROR_MESSAGE("Unknown exception thrown");
1965     }
1966
1967     return NULL;
1968 }
1969
1970 Geometry *
1971 GEOSUnaryUnion_r(GEOSContextHandle_t extHandle, const Geometry *g)
1972 {
1973     if ( 0 == extHandle )
1974     {
1975         return NULL;
1976     }
1977
1978     GEOSContextHandleInternal_t *handle = 0;
1979     handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
1980     if ( 0 == handle->initialized )
1981     {
1982         return NULL;
1983     }
1984
1985     try
1986     {
1987         GeomAutoPtr g3 ( g->Union() );
1988         return g3.release();
1989     }
1990     catch (const std::exception &e)
1991     {
1992 #if VERBOSE_EXCEPTIONS
1993         std::ostringstream s;
1994         s << "Exception on GEOSUnaryUnion with following inputs:" << std::endl;
1995         s << "A: "<<g1->toString() << std::endl;
1996         s << "B: "<<g2->toString() << std::endl;
1997         handle->NOTICE_MESSAGE("%s", s.str().c_str());
1998 #endif // VERBOSE_EXCEPTIONS
1999         handle->ERROR_MESSAGE("%s", e.what());
2000     }
2001     catch (...)
2002     {
2003         handle->ERROR_MESSAGE("Unknown exception thrown");
2004     }
2005
2006     return NULL;
2007 }
2008
2009 Geometry *
2010 GEOSNode_r(GEOSContextHandle_t extHandle, const Geometry *g)
2011 {
2012     if ( 0 == extHandle )
2013     {
2014         return NULL;
2015     }
2016
2017     GEOSContextHandleInternal_t *handle = 0;
2018     handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
2019     if ( 0 == handle->initialized )
2020     {
2021         return NULL;
2022     }
2023
2024     try
2025     {
2026         std::auto_ptr<Geometry> g3 = geos::noding::GeometryNoder::node(*g);
2027         return g3.release();
2028     }
2029     catch (const std::exception &e)
2030     {
2031 #if VERBOSE_EXCEPTIONS
2032         std::ostringstream s;
2033         s << "Exception on GEOSUnaryUnion with following inputs:" << std::endl;
2034         s << "A: "<<g1->toString() << std::endl;
2035         s << "B: "<<g2->toString() << std::endl;
2036         handle->NOTICE_MESSAGE("%s", s.str().c_str());
2037 #endif // VERBOSE_EXCEPTIONS
2038         handle->ERROR_MESSAGE("%s", e.what());
2039     }
2040     catch (...)
2041     {
2042         handle->ERROR_MESSAGE("Unknown exception thrown");
2043     }
2044
2045     return NULL;
2046 }
2047
2048 Geometry *
2049 GEOSUnionCascaded_r(GEOSContextHandle_t extHandle, const Geometry *g1)
2050 {
2051     if ( 0 == extHandle )
2052     {
2053         return NULL;
2054     }
2055
2056     GEOSContextHandleInternal_t *handle = 0;
2057     handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
2058     if ( 0 == handle->initialized )
2059     {
2060         return NULL;
2061     }
2062
2063     try
2064     {
2065         const geos::geom::MultiPolygon *p = dynamic_cast<const geos::geom::MultiPolygon *>(g1);
2066         if ( ! p )
2067         {
2068             handle->ERROR_MESSAGE("Invalid argument (must be a MultiPolygon)");
2069             return NULL;
2070         }
2071
2072         using geos::operation::geounion::CascadedPolygonUnion;
2073         return CascadedPolygonUnion::Union(p);
2074     }
2075     catch (const std::exception &e)
2076     {
2077         handle->ERROR_MESSAGE("%s", e.what());
2078     }
2079     catch (...)
2080     {
2081         handle->ERROR_MESSAGE("Unknown exception thrown");
2082     }
2083
2084     return NULL;
2085 }
2086
2087 Geometry *
2088 GEOSPointOnSurface_r(GEOSContextHandle_t extHandle, const Geometry *g1)
2089 {
2090     if ( 0 == extHandle )
2091     {
2092         return NULL;
2093     }
2094
2095     GEOSContextHandleInternal_t *handle = 0;
2096     handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
2097     if ( 0 == handle->initialized )
2098     {
2099         return NULL;
2100     }
2101
2102     try
2103     {
2104         Geometry *ret = g1->getInteriorPoint();
2105         if ( ! ret )
2106         {
2107             const GeometryFactory* gf = handle->geomFactory;
2108             // return an empty point
2109             return gf->createPoint();
2110         }
2111         return ret;
2112     }
2113     catch (const std::exception &e)
2114     {
2115         handle->ERROR_MESSAGE("%s", e.what());
2116     }
2117     catch (...)
2118     {
2119         handle->ERROR_MESSAGE("Unknown exception thrown");
2120     }
2121
2122     return NULL;
2123 }
2124
2125 //-------------------------------------------------------------------
2126 // memory management functions
2127 //------------------------------------------------------------------
2128
2129 void
2130 GEOSGeom_destroy_r(GEOSContextHandle_t extHandle, Geometry *a)
2131 {
2132     GEOSContextHandleInternal_t *handle = 0;
2133
2134     // FIXME: mloskot: Does this try-catch around delete means that
2135     // destructors in GEOS may throw? If it does, this is a serious
2136     // violation of "never throw an exception from a destructor" principle
2137
2138     try
2139     {
2140         delete a;
2141     }
2142     catch (const std::exception &e)
2143     {
2144         if ( 0 == extHandle )
2145         {
2146             return;
2147         }
2148
2149         handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
2150         if ( 0 == handle->initialized )
2151         {
2152             return;
2153         }
2154
2155         handle->ERROR_MESSAGE("%s", e.what());
2156     }
2157     catch (...)
2158     {
2159         if ( 0 == extHandle )
2160         {
2161             return;
2162         }
2163
2164         handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
2165         if ( 0 == handle->initialized )
2166         {
2167             return;
2168         }
2169
2170         handle->ERROR_MESSAGE("Unknown exception thrown");
2171     }
2172 }
2173
2174 void
2175 GEOSSetSRID_r(GEOSContextHandle_t extHandle, Geometry *g, int srid)
2176 {
2177     assert(0 != g);
2178
2179     if ( 0 == extHandle )
2180     {
2181         return;
2182     }
2183
2184     GEOSContextHandleInternal_t *handle = 0;
2185     handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
2186     if ( 0 == handle->initialized )
2187     {
2188         return;
2189     }
2190
2191     g->setSRID(srid);
2192 }
2193
2194
2195 int
2196 GEOSGetNumCoordinates_r(GEOSContextHandle_t extHandle, const Geometry *g)
2197 {
2198     assert(0 != g);
2199
2200     if ( 0 == extHandle )
2201     {
2202         return -1;
2203     }
2204
2205     GEOSContextHandleInternal_t *handle = 0;
2206     handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
2207     if ( 0 == handle->initialized )
2208     {
2209         return -1;
2210     }
2211
2212     try
2213     {
2214         return static_cast<int>(g->getNumPoints());
2215     }
2216     catch (const std::exception &e)
2217     {
2218         handle->ERROR_MESSAGE("%s", e.what());
2219     }
2220     catch (...)
2221     {
2222         handle->ERROR_MESSAGE("Unknown exception thrown");
2223     }
2224
2225     return -1;
2226 }
2227
2228 /*
2229  * Return -1 on exception, 0 otherwise.
2230  * Converts Geometry to normal form (or canonical form).
2231  */
2232 int
2233 GEOSNormalize_r(GEOSContextHandle_t extHandle, Geometry *g)
2234 {
2235     assert(0 != g);
2236
2237     if ( 0 == extHandle )
2238     {
2239         return -1;
2240     }
2241
2242     GEOSContextHandleInternal_t *handle = 0;
2243     handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
2244     if ( 0 == handle->initialized )
2245     {
2246         return -1;
2247     }
2248
2249     try
2250     {
2251         g->normalize();
2252         return 0; // SUCCESS
2253     }
2254     catch (const std::exception &e)
2255     {
2256         handle->ERROR_MESSAGE("%s", e.what());
2257     }
2258     catch (...)
2259     {
2260         handle->ERROR_MESSAGE("Unknown exception thrown");
2261     }
2262
2263     return -1;
2264 }
2265
2266 int
2267 GEOSGetNumInteriorRings_r(GEOSContextHandle_t extHandle, const Geometry *g1)
2268 {
2269     if ( 0 == extHandle )
2270     {
2271         return -1;
2272     }
2273
2274     GEOSContextHandleInternal_t *handle = 0;
2275     handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
2276     if ( 0 == handle->initialized )
2277     {
2278         return -1;
2279     }
2280
2281     try
2282     {
2283         const Polygon *p = dynamic_cast<const Polygon *>(g1);
2284         if ( ! p )
2285         {
2286             handle->ERROR_MESSAGE("Argument is not a Polygon");
2287             return -1;
2288         }
2289         return static_cast<int>(p->getNumInteriorRing());
2290     }
2291     catch (const std::exception &e)
2292     {
2293         handle->ERROR_MESSAGE("%s", e.what());
2294     }
2295     catch (...)
2296     {
2297         handle->ERROR_MESSAGE("Unknown exception thrown");
2298     }
2299
2300     return -1;
2301 }
2302
2303
2304 // returns -1 on error and 1 for non-multi geometries
2305 int
2306 GEOSGetNumGeometries_r(GEOSContextHandle_t extHandle, const Geometry *g1)
2307 {
2308     if ( 0 == extHandle )
2309     {
2310         return -1;
2311     }
2312
2313     GEOSContextHandleInternal_t *handle = 0;
2314     handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
2315     if ( 0 == handle->initialized )
2316     {
2317         return -1;
2318     }
2319
2320     try
2321     {
2322         return static_cast<int>(g1->getNumGeometries());
2323     }
2324     catch (const std::exception &e)
2325     {
2326         handle->ERROR_MESSAGE("%s", e.what());
2327     }
2328     catch (...)
2329     {
2330         handle->ERROR_MESSAGE("Unknown exception thrown");
2331     }
2332
2333     return -1;
2334 }
2335
2336
2337 /*
2338  * Call only on GEOMETRYCOLLECTION or MULTI*.
2339  * Return a pointer to the internal Geometry.
2340  */
2341 const Geometry *
2342 GEOSGetGeometryN_r(GEOSContextHandle_t extHandle, const Geometry *g1, int n)
2343 {
2344     if ( 0 == extHandle )
2345     {
2346         return NULL;
2347     }
2348
2349     GEOSContextHandleInternal_t *handle = 0;
2350     handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
2351     if ( 0 == handle->initialized )
2352     {
2353         return NULL;
2354     }
2355
2356     try
2357     {
2358         return g1->getGeometryN(n);
2359     }
2360     catch (const std::exception &e)
2361     {
2362         handle->ERROR_MESSAGE("%s", e.what());
2363     }
2364     catch (...)
2365     {
2366         handle->ERROR_MESSAGE("Unknown exception thrown");
2367     }
2368
2369     return NULL;
2370 }
2371
2372 /*
2373  * Call only on LINESTRING
2374  * Returns NULL on exception
2375  */
2376 Geometry *
2377 GEOSGeomGetPointN_r(GEOSContextHandle_t extHandle, const Geometry *g1, int n)
2378 {
2379     if ( 0 == extHandle )
2380     {
2381         return NULL;
2382     }
2383
2384     GEOSContextHandleInternal_t *handle = 0;
2385     handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
2386     if ( 0 == handle->initialized )
2387     {
2388         return NULL;
2389     }
2390
2391     try
2392     {
2393         using geos::geom::LineString;
2394         const LineString *ls = dynamic_cast<const LineString *>(g1);
2395         if ( ! ls )
2396         {
2397                 handle->ERROR_MESSAGE("Argument is not a LineString");
2398                 return NULL;
2399         }
2400         return ls->getPointN(n);
2401     }
2402     catch (const std::exception &e)
2403     {
2404         handle->ERROR_MESSAGE("%s", e.what());
2405     }
2406     catch (...)
2407     {
2408         handle->ERROR_MESSAGE("Unknown exception thrown");
2409     }
2410
2411     return NULL;
2412 }
2413
2414 /*
2415  * Call only on LINESTRING
2416  */
2417 Geometry *
2418 GEOSGeomGetStartPoint_r(GEOSContextHandle_t extHandle, const Geometry *g1)
2419 {
2420     if ( 0 == extHandle )
2421     {
2422         return NULL;
2423     }
2424
2425     GEOSContextHandleInternal_t *handle = 0;
2426     handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
2427     if ( 0 == handle->initialized )
2428     {
2429         return NULL;
2430     }
2431
2432     try
2433     {
2434         using geos::geom::LineString;
2435         const LineString *ls = dynamic_cast<const LineString *>(g1);
2436         if ( ! ls )
2437         {
2438                 handle->ERROR_MESSAGE("Argument is not a LineString");
2439                 return NULL;
2440         }
2441         return ls->getStartPoint();
2442     }
2443     catch (const std::exception &e)
2444     {
2445         handle->ERROR_MESSAGE("%s", e.what());
2446     }
2447     catch (...)
2448     {
2449         handle->ERROR_MESSAGE("Unknown exception thrown");
2450     }
2451
2452     return NULL;
2453 }
2454
2455 /*
2456  * Call only on LINESTRING
2457  */
2458 Geometry *
2459 GEOSGeomGetEndPoint_r(GEOSContextHandle_t extHandle, const Geometry *g1)
2460 {
2461     if ( 0 == extHandle )
2462     {
2463         return NULL;
2464     }
2465
2466     GEOSContextHandleInternal_t *handle = 0;
2467     handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
2468     if ( 0 == handle->initialized )
2469     {
2470         return NULL;
2471     }
2472
2473     try
2474     {
2475         using geos::geom::LineString;
2476         const LineString *ls = dynamic_cast<const LineString *>(g1);
2477         if ( ! ls )
2478         {
2479                 handle->ERROR_MESSAGE("Argument is not a LineString");
2480                 return NULL;
2481         }
2482         return ls->getEndPoint();
2483     }
2484     catch (const std::exception &e)
2485     {
2486         handle->ERROR_MESSAGE("%s", e.what());
2487     }
2488     catch (...)
2489     {
2490         handle->ERROR_MESSAGE("Unknown exception thrown");
2491     }
2492
2493     return NULL;
2494 }
2495
2496 /*
2497  * Call only on LINESTRING
2498  * return 2 on exception, 1 on true, 0 on false
2499  */
2500 char
2501 GEOSisClosed_r(GEOSContextHandle_t extHandle, const Geometry *g1)
2502 {
2503     if ( 0 == extHandle )
2504     {
2505         return 2;
2506     }
2507
2508     GEOSContextHandleInternal_t *handle = 0;
2509     handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
2510     if ( 0 == handle->initialized )
2511     {
2512         return 2;
2513     }
2514
2515     try
2516     {
2517         using geos::geom::LineString;
2518         const LineString *ls = dynamic_cast<const LineString *>(g1);
2519         if ( ! ls )
2520         {
2521                 handle->ERROR_MESSAGE("Argument is not a LineString");
2522                 return 2;
2523         }
2524         return ls->isClosed();
2525     }
2526     catch (const std::exception &e)
2527     {
2528         handle->ERROR_MESSAGE("%s", e.what());
2529     }
2530     catch (...)
2531     {
2532         handle->ERROR_MESSAGE("Unknown exception thrown");
2533     }
2534
2535     return 2;
2536 }
2537
2538 /*
2539  * Call only on LINESTRING
2540  * return 0 on exception, otherwise 1
2541  */
2542 int
2543 GEOSGeomGetLength_r(GEOSContextHandle_t extHandle, const Geometry *g1, double *length)
2544 {
2545     if ( 0 == extHandle )
2546     {
2547         return 0;
2548     }
2549
2550     GEOSContextHandleInternal_t *handle = 0;
2551     handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
2552     if ( 0 == handle->initialized )
2553     {
2554         return 0;
2555     }
2556
2557     try
2558     {
2559         using geos::geom::LineString;
2560         const LineString *ls = dynamic_cast<const LineString *>(g1);
2561         if ( ! ls )
2562         {
2563                 handle->ERROR_MESSAGE("Argument is not a LineString");
2564                 return 0;
2565         }
2566         *length = ls->getLength();
2567         return 1;
2568     }
2569     catch (const std::exception &e)
2570     {
2571         handle->ERROR_MESSAGE("%s", e.what());
2572     }
2573     catch (...)
2574     {
2575         handle->ERROR_MESSAGE("Unknown exception thrown");
2576     }
2577
2578     return 0;
2579 }
2580
2581 /*
2582  * Call only on LINESTRING
2583  */
2584 int
2585 GEOSGeomGetNumPoints_r(GEOSContextHandle_t extHandle, const Geometry *g1)
2586 {
2587     if ( 0 == extHandle )
2588     {
2589         return -1;
2590     }
2591
2592     GEOSContextHandleInternal_t *handle = 0;
2593     handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
2594     if ( 0 == handle->initialized )
2595     {
2596         return -1;
2597     }
2598
2599     try
2600     {
2601         using geos::geom::LineString;
2602                 const LineString *ls = dynamic_cast<const LineString *>(g1);
2603                 if ( ! ls )
2604                 {
2605                         handle->ERROR_MESSAGE("Argument is not a LineString");
2606                         return -1;
2607                 }
2608                 return static_cast<int>(ls->getNumPoints());
2609     }
2610     catch (const std::exception &e)
2611     {
2612         handle->ERROR_MESSAGE("%s", e.what());
2613     }
2614     catch (...)
2615     {
2616         handle->ERROR_MESSAGE("Unknown exception thrown");
2617     }
2618
2619     return -1;
2620 }
2621
2622 /*
2623  * For POINT
2624  * returns 0 on exception, otherwise 1
2625  */
2626 int
2627 GEOSGeomGetX_r(GEOSContextHandle_t extHandle, const Geometry *g1, double *x)
2628 {
2629     if ( 0 == extHandle )
2630     {
2631         return 0;
2632     }
2633
2634     GEOSContextHandleInternal_t *handle = 0;
2635     handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
2636     if ( 0 == handle->initialized )
2637     {
2638         return 0;
2639     }
2640
2641     try
2642     {
2643         using geos::geom::Point;
2644         const Point *po = dynamic_cast<const Point *>(g1);
2645         if ( ! po )
2646         {
2647                 handle->ERROR_MESSAGE("Argument is not a Point");
2648                 return 0;
2649         }
2650         *x = po->getX();
2651         return 1;
2652     }
2653     catch (const std::exception &e)
2654     {
2655         handle->ERROR_MESSAGE("%s", e.what());
2656     }
2657     catch (...)
2658     {
2659         handle->ERROR_MESSAGE("Unknown exception thrown");
2660     }
2661
2662     return 0;
2663 }
2664
2665 /*
2666  * For POINT
2667  * returns 0 on exception, otherwise 1
2668  */
2669 int
2670 GEOSGeomGetY_r(GEOSContextHandle_t extHandle, const Geometry *g1, double *y)
2671 {
2672     if ( 0 == extHandle )
2673     {
2674         return 0;
2675     }
2676
2677     GEOSContextHandleInternal_t *handle = 0;
2678     handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
2679     if ( 0 == handle->initialized )
2680     {
2681         return 0;
2682     }
2683
2684     try
2685     {
2686         using geos::geom::Point;
2687         const Point *po = dynamic_cast<const Point *>(g1);
2688         if ( ! po )
2689         {
2690                 handle->ERROR_MESSAGE("Argument is not a Point");
2691                 return 0;
2692         }
2693         *y = po->getY();
2694         return 1;
2695     }
2696     catch (const std::exception &e)
2697     {
2698         handle->ERROR_MESSAGE("%s", e.what());
2699     }
2700     catch (...)
2701     {
2702         handle->ERROR_MESSAGE("Unknown exception thrown");
2703     }
2704
2705     return 0;
2706 }
2707
2708 /*
2709  * Call only on polygon
2710  * Return a copy of the internal Geometry.
2711  */
2712 const Geometry *
2713 GEOSGetExteriorRing_r(GEOSContextHandle_t extHandle, const Geometry *g1)
2714 {
2715     if ( 0 == extHandle )
2716     {
2717         return NULL;
2718     }
2719
2720     GEOSContextHandleInternal_t *handle = 0;
2721     handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
2722     if ( 0 == handle->initialized )
2723     {
2724         return NULL;
2725     }
2726
2727     try
2728     {
2729         const Polygon *p = dynamic_cast<const Polygon *>(g1);
2730         if ( ! p )
2731         {
2732             handle->ERROR_MESSAGE("Invalid argument (must be a Polygon)");
2733             return NULL;
2734         }
2735         return p->getExteriorRing();
2736     }
2737     catch (const std::exception &e)
2738     {
2739         handle->ERROR_MESSAGE("%s", e.what());
2740     }
2741     catch (...)
2742     {
2743         handle->ERROR_MESSAGE("Unknown exception thrown");
2744     }
2745
2746     return NULL;
2747 }
2748
2749 /*
2750  * Call only on polygon
2751  * Return a pointer to internal storage, do not destroy it.
2752  */
2753 const Geometry *
2754 GEOSGetInteriorRingN_r(GEOSContextHandle_t extHandle, const Geometry *g1, int n)
2755 {
2756     if ( 0 == extHandle )
2757     {
2758         return NULL;
2759     }
2760
2761     GEOSContextHandleInternal_t *handle = 0;
2762     handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
2763     if ( 0 == handle->initialized )
2764     {
2765         return NULL;
2766     }
2767
2768     try
2769     {
2770         const Polygon *p = dynamic_cast<const Polygon *>(g1);
2771         if ( ! p )
2772         {
2773             handle->ERROR_MESSAGE("Invalid argument (must be a Polygon)");
2774             return NULL;
2775         }
2776         return p->getInteriorRingN(n);
2777     }
2778     catch (const std::exception &e)
2779     {
2780         handle->ERROR_MESSAGE("%s", e.what());
2781     }
2782     catch (...)
2783     {
2784         handle->ERROR_MESSAGE("Unknown exception thrown");
2785     }
2786
2787     return NULL;
2788 }
2789
2790 Geometry *
2791 GEOSGetCentroid_r(GEOSContextHandle_t extHandle, const Geometry *g)
2792 {
2793     if ( 0 == extHandle )
2794     {
2795         return NULL;
2796     }
2797
2798     GEOSContextHandleInternal_t *handle = 0;
2799     handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
2800     if ( 0 == handle->initialized )
2801     {
2802         return NULL;
2803     }
2804
2805     try
2806     {
2807         Geometry *ret = g->getCentroid();
2808         if (0 == ret)
2809         {
2810             const GeometryFactory *gf = handle->geomFactory;
2811             return gf->createPoint();
2812         }
2813         return ret;
2814     }
2815     catch (const std::exception &e)
2816     {
2817         handle->ERROR_MESSAGE("%s", e.what());
2818     }
2819     catch (...)
2820     {
2821         handle->ERROR_MESSAGE("Unknown exception thrown");
2822     }
2823
2824     return NULL;
2825 }
2826
2827 Geometry *
2828 GEOSGeom_createEmptyCollection_r(GEOSContextHandle_t extHandle, int type)
2829 {
2830     if ( 0 == extHandle )
2831     {
2832         return NULL;
2833     }
2834
2835     GEOSContextHandleInternal_t *handle = 0;
2836     handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
2837     if ( 0 == handle->initialized )
2838     {
2839         return NULL;
2840     }
2841
2842 #ifdef GEOS_DEBUG
2843     char buf[256];
2844     sprintf(buf, "createCollection: requested type %d, ngeoms: %d",
2845             type, ngeoms);
2846     handle->NOTICE_MESSAGE("%s", buf);// TODO: Can handle->NOTICE_MESSAGE format that directly?
2847 #endif
2848
2849     try
2850     {
2851         const GeometryFactory* gf = handle->geomFactory;
2852
2853         Geometry *g = 0;
2854         switch (type)
2855         {
2856             case GEOS_GEOMETRYCOLLECTION:
2857                 g = gf->createGeometryCollection();
2858                 break;
2859             case GEOS_MULTIPOINT:
2860                 g = gf->createMultiPoint();
2861                 break;
2862             case GEOS_MULTILINESTRING:
2863                 g = gf->createMultiLineString();
2864                 break;
2865             case GEOS_MULTIPOLYGON:
2866                 g = gf->createMultiPolygon();
2867                 break;
2868             default:
2869                 handle->ERROR_MESSAGE("Unsupported type request for GEOSGeom_createEmptyCollection_r");
2870                 g = 0;
2871
2872         }
2873
2874         return g;
2875     }
2876     catch (const std::exception &e)
2877     {
2878         handle->ERROR_MESSAGE("%s", e.what());
2879     }
2880     catch (...)
2881     {
2882         handle->ERROR_MESSAGE("Unknown exception thrown");
2883     }
2884
2885     return 0;
2886 }
2887
2888 Geometry *
2889 GEOSGeom_createCollection_r(GEOSContextHandle_t extHandle, int type, Geometry **geoms, unsigned int ngeoms)
2890 {
2891     if ( 0 == extHandle )
2892     {
2893         return NULL;
2894     }
2895
2896     GEOSContextHandleInternal_t *handle = 0;
2897     handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
2898     if ( 0 == handle->initialized )
2899     {
2900         return NULL;
2901     }
2902
2903 #ifdef GEOS_DEBUG
2904     char buf[256];
2905     sprintf(buf, "PostGIS2GEOS_collection: requested type %d, ngeoms: %d",
2906             type, ngeoms);
2907     handle->NOTICE_MESSAGE("%s", buf);// TODO: Can handle->NOTICE_MESSAGE format that directly?
2908 #endif
2909
2910     try
2911     {
2912         const GeometryFactory* gf = handle->geomFactory;
2913         std::vector<Geometry*>* vgeoms = new std::vector<Geometry*>(geoms, geoms + ngeoms);
2914
2915         Geometry *g = 0;
2916         switch (type)
2917         {
2918             case GEOS_GEOMETRYCOLLECTION:
2919                 g = gf->createGeometryCollection(vgeoms);
2920                 break;
2921             case GEOS_MULTIPOINT:
2922                 g = gf->createMultiPoint(vgeoms);
2923                 break;
2924             case GEOS_MULTILINESTRING:
2925                 g = gf->createMultiLineString(vgeoms);
2926                 break;
2927             case GEOS_MULTIPOLYGON:
2928                 g = gf->createMultiPolygon(vgeoms);
2929                 break;
2930             default:
2931                 handle->ERROR_MESSAGE("Unsupported type request for PostGIS2GEOS_collection");
2932                 g = 0;
2933
2934         }
2935
2936         return g;
2937     }
2938     catch (const std::exception &e)
2939     {
2940         handle->ERROR_MESSAGE("%s", e.what());
2941     }
2942     catch (...)
2943     {
2944         handle->ERROR_MESSAGE("Unknown exception thrown");
2945     }
2946
2947     return 0;
2948 }
2949
2950 Geometry *
2951 GEOSPolygonize_r(GEOSContextHandle_t extHandle, const Geometry * const * g, unsigned int ngeoms)
2952 {
2953     if ( 0 == extHandle )
2954     {
2955         return 0;
2956     }
2957
2958     GEOSContextHandleInternal_t *handle = 0;
2959     handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
2960     if ( 0 == handle->initialized )
2961     {
2962         return 0;
2963     }
2964
2965     Geometry *out = 0;
2966
2967     try
2968     {
2969         // Polygonize
2970         using geos::operation::polygonize::Polygonizer;
2971         Polygonizer plgnzr;
2972         for (std::size_t i = 0; i < ngeoms; ++i)
2973         {
2974             plgnzr.add(g[i]);
2975         }
2976
2977 #if GEOS_DEBUG
2978         handle->NOTICE_MESSAGE("geometry vector added to polygonizer");
2979 #endif
2980
2981         std::vector<Polygon*> *polys = plgnzr.getPolygons();
2982         assert(0 != polys);
2983
2984 #if GEOS_DEBUG
2985         handle->NOTICE_MESSAGE("output polygons got");
2986 #endif
2987
2988         // We need a vector of Geometry pointers, not Polygon pointers.
2989         // STL vector doesn't allow transparent upcast of this
2990         // nature, so we explicitly convert.
2991         // (it's just a waste of processor and memory, btw)
2992         //
2993         // XXX mloskot: Why not to extent GeometryFactory to accept
2994         // vector of polygons or extend Polygonizer to return list of Geometry*
2995         // or add a wrapper which semantic is similar to:
2996         // std::vector<as_polygon<Geometry*> >
2997         std::vector<Geometry*> *polyvec = new std::vector<Geometry *>(polys->size());
2998
2999         for (std::size_t i = 0; i < polys->size(); ++i)
3000         {
3001             (*polyvec)[i] = (*polys)[i];
3002         }
3003         delete polys;
3004         polys = 0;
3005
3006         const GeometryFactory *gf = handle->geomFactory;
3007
3008         // The below takes ownership of the passed vector,
3009         // so we must *not* delete it
3010         out = gf->createGeometryCollection(polyvec);
3011     }
3012     catch (const std::exception &e)
3013     {
3014         handle->ERROR_MESSAGE("%s", e.what());
3015     }
3016     catch (...)
3017     {
3018         handle->ERROR_MESSAGE("Unknown exception thrown");
3019     }
3020
3021     return out;
3022 }
3023
3024 Geometry *
3025 GEOSPolygonizer_getCutEdges_r(GEOSContextHandle_t extHandle, const Geometry * const * g, unsigned int ngeoms)
3026 {
3027     if ( 0 == extHandle )
3028     {
3029         return 0;
3030     }
3031
3032     GEOSContextHandleInternal_t *handle = 0;
3033     handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
3034     if ( 0 == handle->initialized )
3035     {
3036         return 0;
3037     }
3038
3039     Geometry *out = 0;
3040
3041     try
3042     {
3043         // Polygonize
3044         using geos::operation::polygonize::Polygonizer;
3045         Polygonizer plgnzr;
3046         for (std::size_t i = 0; i < ngeoms; ++i)
3047         {
3048             plgnzr.add(g[i]);
3049         }
3050
3051 #if GEOS_DEBUG
3052         handle->NOTICE_MESSAGE("geometry vector added to polygonizer");
3053 #endif
3054
3055         const std::vector<const LineString *>& lines = plgnzr.getCutEdges();
3056
3057 #if GEOS_DEBUG
3058         handle->NOTICE_MESSAGE("output polygons got");
3059 #endif
3060
3061         // We need a vector of Geometry pointers, not Polygon pointers.
3062         // STL vector doesn't allow transparent upcast of this
3063         // nature, so we explicitly convert.
3064         // (it's just a waste of processor and memory, btw)
3065         // XXX mloskot: See comment for GEOSPolygonize_r
3066         std::vector<Geometry*> *linevec = new std::vector<Geometry *>(lines.size());
3067
3068         for (std::size_t i = 0, n=lines.size(); i < n; ++i)
3069         {
3070             (*linevec)[i] = lines[i]->clone();
3071         }
3072
3073         const GeometryFactory *gf = handle->geomFactory;
3074
3075         // The below takes ownership of the passed vector,
3076         // so we must *not* delete it
3077         out = gf->createGeometryCollection(linevec);
3078     }
3079     catch (const std::exception &e)
3080     {
3081         handle->ERROR_MESSAGE("%s", e.what());
3082     }
3083     catch (...)
3084     {
3085         handle->ERROR_MESSAGE("Unknown exception thrown");
3086     }
3087
3088     return out;
3089 }
3090
3091 Geometry *
3092 GEOSPolygonize_full_r(GEOSContextHandle_t extHandle, const Geometry* g,
3093         Geometry** cuts, Geometry** dangles, Geometry** invalid)
3094 {
3095     if ( 0 == extHandle )
3096     {
3097         return 0;
3098     }
3099
3100     GEOSContextHandleInternal_t *handle = 0;
3101     handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
3102     if ( 0 == handle->initialized )
3103     {
3104         return 0;
3105     }
3106
3107     try
3108     {
3109         // Polygonize
3110         using geos::operation::polygonize::Polygonizer;
3111         Polygonizer plgnzr;
3112         for (std::size_t i = 0; i <g->getNumGeometries(); ++i)
3113         {
3114             plgnzr.add(g->getGeometryN(i));
3115         }
3116
3117 #if GEOS_DEBUG
3118         handle->NOTICE_MESSAGE("geometry vector added to polygonizer");
3119 #endif
3120         const GeometryFactory *gf = handle->geomFactory;
3121
3122         if ( cuts ) {
3123
3124                 const std::vector<const LineString *>& lines = plgnzr.getCutEdges();
3125                 std::vector<Geometry*> *linevec = new std::vector<Geometry *>(lines.size());
3126                 for (std::size_t i = 0, n=lines.size(); i < n; ++i)
3127                 {
3128                     (*linevec)[i] = lines[i]->clone();
3129                 }
3130
3131                 // The below takes ownership of the passed vector,
3132                 // so we must *not* delete it
3133                 *cuts = gf->createGeometryCollection(linevec);
3134         }
3135
3136         if ( dangles ) {
3137
3138                 const std::vector<const LineString *>& lines = plgnzr.getDangles();
3139                 std::vector<Geometry*> *linevec = new std::vector<Geometry *>(lines.size());
3140                 for (std::size_t i = 0, n=lines.size(); i < n; ++i)
3141                 {
3142                     (*linevec)[i] = lines[i]->clone();
3143                 }
3144
3145                 // The below takes ownership of the passed vector,
3146                 // so we must *not* delete it
3147                 *dangles = gf->createGeometryCollection(linevec);
3148         }
3149
3150         if ( invalid ) {
3151
3152                 const std::vector<LineString *>& lines = plgnzr.getInvalidRingLines();
3153                 std::vector<Geometry*> *linevec = new std::vector<Geometry *>(lines.size());
3154                 for (std::size_t i = 0, n=lines.size(); i < n; ++i)
3155                 {
3156                     (*linevec)[i] = lines[i]->clone();
3157                 }
3158
3159                 // The below takes ownership of the passed vector,
3160                 // so we must *not* delete it
3161                 *invalid = gf->createGeometryCollection(linevec);
3162         }
3163
3164         std::vector<Polygon*> *polys = plgnzr.getPolygons();
3165         std::vector<Geometry*> *polyvec = new std::vector<Geometry *>(polys->size());
3166         for (std::size_t i = 0; i < polys->size(); ++i)
3167         {
3168             (*polyvec)[i] = (*polys)[i];
3169         }
3170         delete polys;
3171
3172         return gf->createGeometryCollection(polyvec);
3173
3174     }
3175     catch (const std::exception &e)
3176     {
3177         handle->ERROR_MESSAGE("%s", e.what());
3178         return 0;
3179     }
3180     catch (...)
3181     {
3182         handle->ERROR_MESSAGE("Unknown exception thrown");
3183         return 0;
3184     }
3185 }
3186
3187 Geometry *
3188 GEOSLineMerge_r(GEOSContextHandle_t extHandle, const Geometry *g)
3189 {
3190     if ( 0 == extHandle )
3191     {
3192         return 0;
3193     }
3194
3195     GEOSContextHandleInternal_t *handle = 0;
3196     handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
3197     if ( 0 == handle->initialized )
3198     {
3199         return 0;
3200     }
3201
3202     Geometry *out = 0;
3203
3204     try
3205     {
3206         using geos::operation::linemerge::LineMerger;
3207         LineMerger lmrgr;
3208         lmrgr.add(g);
3209
3210         std::vector<LineString *>* lines = lmrgr.getMergedLineStrings();
3211         assert(0 != lines);
3212
3213 #if GEOS_DEBUG
3214         handle->NOTICE_MESSAGE("output lines got");
3215 #endif
3216
3217         std::vector<Geometry *>*geoms = new std::vector<Geometry *>(lines->size());
3218         for (std::vector<Geometry *>::size_type i = 0; i < lines->size(); ++i)
3219         {
3220             (*geoms)[i] = (*lines)[i];
3221         }
3222         delete lines;
3223         lines = 0;
3224
3225         const GeometryFactory *gf = handle->geomFactory;
3226         out = gf->buildGeometry(geoms);
3227
3228         // XXX: old version
3229         //out = gf->createGeometryCollection(geoms);
3230     }
3231     catch (const std::exception &e)
3232     {
3233         handle->ERROR_MESSAGE("%s", e.what());
3234     }
3235     catch (...)
3236     {
3237         handle->ERROR_MESSAGE("Unknown exception thrown");
3238     }
3239
3240     return out;
3241 }
3242
3243 int
3244 GEOSGetSRID_r(GEOSContextHandle_t extHandle, const Geometry *g)
3245 {
3246     assert(0 != g);
3247
3248     if ( 0 == extHandle )
3249     {
3250         return 0;
3251     }
3252
3253     GEOSContextHandleInternal_t *handle = 0;
3254     handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
3255     if ( 0 == handle->initialized )
3256     {
3257         return 0;
3258     }
3259
3260     try
3261     {
3262         return g->getSRID();
3263     }
3264     catch (const std::exception &e)
3265     {
3266         handle->ERROR_MESSAGE("%s", e.what());
3267     }
3268     catch (...)
3269     {
3270         handle->ERROR_MESSAGE("Unknown exception thrown");
3271     }
3272
3273     return 0;
3274 }
3275
3276 const char* GEOSversion()
3277 {
3278   static char version[256];
3279   sprintf(version, "%s r%d", GEOS_CAPI_VERSION, GEOS_SVN_REVISION);
3280   return version;
3281 }
3282
3283 const char* GEOSjtsport()
3284 {
3285     return GEOS_JTS_PORT;
3286 }
3287
3288 char
3289 GEOSHasZ_r(GEOSContextHandle_t extHandle, const Geometry *g)
3290 {
3291     assert(0 != g);
3292
3293     if ( 0 == extHandle )
3294     {
3295         return -1;
3296     }
3297
3298     GEOSContextHandleInternal_t *handle = 0;
3299     handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
3300     if ( 0 == handle->initialized )
3301     {
3302         return -1;
3303     }
3304
3305     if (g->isEmpty())
3306     {
3307         return false;
3308     }
3309     assert(0 != g->getCoordinate());
3310
3311     double az = g->getCoordinate()->z;
3312     //handle->ERROR_MESSAGE("ZCoord: %g", az);
3313
3314     return static_cast<char>(FINITE(az));
3315 }
3316
3317 int
3318 GEOS_getWKBOutputDims_r(GEOSContextHandle_t extHandle)
3319 {
3320     if ( 0 == extHandle )
3321     {
3322         return -1;
3323     }
3324
3325     GEOSContextHandleInternal_t *handle = 0;
3326     handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
3327     if ( 0 == handle->initialized )
3328     {
3329         return -1;
3330     }
3331
3332     return handle->WKBOutputDims;
3333 }
3334
3335 int
3336 GEOS_setWKBOutputDims_r(GEOSContextHandle_t extHandle, int newdims)
3337 {
3338     if ( 0 == extHandle )
3339     {
3340         return -1;
3341     }
3342
3343     GEOSContextHandleInternal_t *handle = 0;
3344     handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
3345     if ( 0 == handle->initialized )
3346     {
3347         return -1;
3348     }
3349
3350     if ( newdims < 2 || newdims > 3 )
3351     {
3352         handle->ERROR_MESSAGE("WKB output dimensions out of range 2..3");
3353     }
3354
3355     const int olddims = handle->WKBOutputDims;
3356     handle->WKBOutputDims = newdims;
3357
3358     return olddims;
3359 }
3360
3361 int
3362 GEOS_getWKBByteOrder_r(GEOSContextHandle_t extHandle)
3363 {
3364     if ( 0 == extHandle )
3365     {
3366         return -1;
3367     }
3368
3369     GEOSContextHandleInternal_t *handle = 0;
3370     handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
3371     if ( 0 == handle->initialized )
3372     {
3373         return -1;
3374     }
3375
3376     return handle->WKBByteOrder;
3377 }
3378
3379 int
3380 GEOS_setWKBByteOrder_r(GEOSContextHandle_t extHandle, int byteOrder)
3381 {
3382     if ( 0 == extHandle )
3383     {
3384         return -1;
3385     }
3386
3387     GEOSContextHandleInternal_t *handle = 0;
3388     handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
3389     if ( 0 == handle->initialized )
3390     {
3391         return -1;
3392     }
3393
3394     const int oldByteOrder = handle->WKBByteOrder;
3395     handle->WKBByteOrder = byteOrder;
3396
3397     return oldByteOrder;
3398 }
3399
3400
3401 CoordinateSequence *
3402 GEOSCoordSeq_create_r(GEOSContextHandle_t extHandle, unsigned int size, unsigned int dims)
3403 {
3404     if ( 0 == extHandle )
3405     {
3406         return NULL;
3407     }
3408
3409     GEOSContextHandleInternal_t *handle = 0;
3410     handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
3411     if ( 0 == handle->initialized )
3412     {
3413         return NULL;
3414     }
3415
3416     try
3417     {
3418         const GeometryFactory *gf = handle->geomFactory;
3419         return gf->getCoordinateSequenceFactory()->create(size, dims);
3420     }
3421     catch (const std::exception &e)
3422     {
3423         handle->ERROR_MESSAGE("%s", e.what());
3424     }
3425     catch (...)
3426     {
3427         handle->ERROR_MESSAGE("Unknown exception thrown");
3428     }
3429
3430     return NULL;
3431 }
3432
3433 int
3434 GEOSCoordSeq_setOrdinate_r(GEOSContextHandle_t extHandle, CoordinateSequence *cs,
3435                            unsigned int idx, unsigned int dim, double val)
3436 {
3437     assert(0 != cs);
3438     if ( 0 == extHandle )
3439     {
3440         return 0;
3441     }
3442
3443     GEOSContextHandleInternal_t *handle = 0;
3444     handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
3445     if ( 0 == handle->initialized )
3446     {
3447         return 0;
3448     }
3449
3450     try
3451     {
3452         cs->setOrdinate(idx, dim, val);
3453         return 1;
3454     }
3455     catch (const std::exception &e)
3456     {
3457         handle->ERROR_MESSAGE("%s", e.what());
3458     }
3459     catch (...)
3460     {
3461         handle->ERROR_MESSAGE("Unknown exception thrown");
3462     }
3463
3464     return 0;
3465 }
3466
3467 int
3468 GEOSCoordSeq_setX_r(GEOSContextHandle_t extHandle, CoordinateSequence *s, unsigned int idx, double val)
3469 {
3470     return GEOSCoordSeq_setOrdinate_r(extHandle, s, idx, 0, val);
3471 }
3472
3473 int
3474 GEOSCoordSeq_setY_r(GEOSContextHandle_t extHandle, CoordinateSequence *s, unsigned int idx, double val)
3475 {
3476     return GEOSCoordSeq_setOrdinate_r(extHandle, s, idx, 1, val);
3477 }
3478
3479 int
3480 GEOSCoordSeq_setZ_r(GEOSContextHandle_t extHandle, CoordinateSequence *s, unsigned int idx, double val)
3481 {
3482     return GEOSCoordSeq_setOrdinate_r(extHandle, s, idx, 2, val);
3483 }
3484
3485 CoordinateSequence *
3486 GEOSCoordSeq_clone_r(GEOSContextHandle_t extHandle, const CoordinateSequence *cs)
3487 {
3488     assert(0 != cs);
3489
3490     if ( 0 == extHandle )
3491     {
3492         return NULL;
3493     }
3494
3495     GEOSContextHandleInternal_t *handle = 0;
3496     handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
3497     if ( 0 == handle->initialized )
3498     {
3499         return NULL;
3500     }
3501
3502     try
3503     {
3504         return cs->clone();
3505     }
3506     catch (const std::exception &e)
3507     {
3508         handle->ERROR_MESSAGE("%s", e.what());
3509     }
3510     catch (...)
3511     {
3512         handle->ERROR_MESSAGE("Unknown exception thrown");
3513     }
3514
3515     return NULL;
3516 }
3517
3518 int
3519 GEOSCoordSeq_getOrdinate_r(GEOSContextHandle_t extHandle, const CoordinateSequence *cs,
3520                            unsigned int idx, unsigned int dim, double *val)
3521 {
3522     assert(0 != cs);
3523     assert(0 != val);
3524
3525     if ( 0 == extHandle )
3526     {
3527         return 0;
3528     }
3529
3530     GEOSContextHandleInternal_t *handle = 0;
3531     handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
3532     if ( 0 == handle->initialized )
3533     {
3534         return 0;
3535     }
3536
3537     try
3538     {
3539         double d = cs->getOrdinate(idx, dim);
3540         *val = d;
3541
3542         return 1;
3543     }
3544     catch (const std::exception &e)
3545     {
3546         handle->ERROR_MESSAGE("%s", e.what());
3547     }
3548     catch (...)
3549     {
3550         handle->ERROR_MESSAGE("Unknown exception thrown");
3551     }
3552
3553     return 0;
3554 }
3555
3556 int
3557 GEOSCoordSeq_getX_r(GEOSContextHandle_t extHandle, const CoordinateSequence *s, unsigned int idx, double *val)
3558 {
3559     return GEOSCoordSeq_getOrdinate_r(extHandle, s, idx, 0, val);
3560 }
3561
3562 int
3563 GEOSCoordSeq_getY_r(GEOSContextHandle_t extHandle, const CoordinateSequence *s, unsigned int idx, double *val)
3564 {
3565     return GEOSCoordSeq_getOrdinate_r(extHandle, s, idx, 1, val);
3566 }
3567
3568 int
3569 GEOSCoordSeq_getZ_r(GEOSContextHandle_t extHandle, const CoordinateSequence *s, unsigned int idx, double *val)
3570 {
3571     return GEOSCoordSeq_getOrdinate_r(extHandle, s, idx, 2, val);
3572 }
3573
3574 int
3575 GEOSCoordSeq_getSize_r(GEOSContextHandle_t extHandle, const CoordinateSequence *cs, unsigned int *size)
3576 {
3577     assert(0 != cs);
3578     assert(0 != size);
3579
3580     if ( 0 == extHandle )
3581     {
3582         return 0;
3583     }
3584
3585     GEOSContextHandleInternal_t *handle = 0;
3586     handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
3587     if ( 0 == handle->initialized )
3588     {
3589         return 0;
3590     }
3591
3592     try
3593     {
3594         const std::size_t sz = cs->getSize();
3595         *size = static_cast<unsigned int>(sz);
3596         return 1;
3597     }
3598     catch (const std::exception &e)
3599     {
3600         handle->ERROR_MESSAGE("%s", e.what());
3601     }
3602     catch (...)
3603     {
3604         handle->ERROR_MESSAGE("Unknown exception thrown");
3605     }
3606
3607     return 0;
3608 }
3609
3610 int
3611 GEOSCoordSeq_getDimensions_r(GEOSContextHandle_t extHandle, const CoordinateSequence *cs, unsigned int *dims)
3612 {
3613     assert(0 != cs);
3614     assert(0 != dims);
3615
3616     if ( 0 == extHandle )
3617     {
3618         return 0;
3619     }
3620
3621     GEOSContextHandleInternal_t *handle = 0;
3622     handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
3623     if ( 0 == handle->initialized )
3624     {
3625         return 0;
3626     }
3627
3628     try
3629     {
3630         const std::size_t dim = cs->getDimension();
3631         *dims = static_cast<unsigned int>(dim);
3632
3633         return 1;
3634     }
3635     catch (const std::exception &e)
3636     {
3637         handle->ERROR_MESSAGE("%s", e.what());
3638     }
3639
3640     catch (...)
3641     {
3642         handle->ERROR_MESSAGE("Unknown exception thrown");
3643     }
3644
3645     return 0;
3646 }
3647
3648 void
3649 GEOSCoordSeq_destroy_r(GEOSContextHandle_t extHandle, CoordinateSequence *s)
3650 {
3651     GEOSContextHandleInternal_t *handle = 0;
3652
3653     try
3654     {
3655         delete s;
3656     }
3657     catch (const std::exception &e)
3658     {
3659         if ( 0 == extHandle )
3660         {
3661             return;
3662         }
3663
3664         handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
3665         if ( 0 == handle->initialized )
3666         {
3667             return;
3668         }
3669
3670         handle->ERROR_MESSAGE("%s", e.what());
3671     }
3672     catch (...)
3673     {
3674         if ( 0 == extHandle )
3675         {
3676             return;
3677         }
3678
3679         handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
3680         if ( 0 == handle->initialized )
3681         {
3682             return;
3683         }
3684
3685         handle->ERROR_MESSAGE("Unknown exception thrown");
3686     }
3687 }
3688
3689 const CoordinateSequence *
3690 GEOSGeom_getCoordSeq_r(GEOSContextHandle_t extHandle, const Geometry *g)
3691 {
3692     if ( 0 == extHandle )
3693     {
3694         return 0;
3695     }
3696
3697     GEOSContextHandleInternal_t *handle = 0;
3698     handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
3699     if ( 0 == handle->initialized )
3700     {
3701         return 0;
3702     }
3703
3704     try
3705     {
3706         using geos::geom::Point;
3707
3708         const LineString *ls = dynamic_cast<const LineString *>(g);
3709         if ( ls )
3710         {
3711             return ls->getCoordinatesRO();
3712         }
3713
3714         const Point *p = dynamic_cast<const Point *>(g);
3715         if ( p )
3716         {
3717             return p->getCoordinatesRO();
3718         }
3719
3720         handle->ERROR_MESSAGE("Geometry must be a Point or LineString");
3721         return 0;
3722     }
3723     catch (const std::exception &e)
3724     {
3725         handle->ERROR_MESSAGE("%s", e.what());
3726     }
3727     catch (...)
3728     {
3729         handle->ERROR_MESSAGE("Unknown exception thrown");
3730     }
3731
3732     return 0;
3733 }
3734
3735 Geometry *
3736 GEOSGeom_createEmptyPoint_r(GEOSContextHandle_t extHandle)
3737 {
3738     if ( 0 == extHandle )
3739     {
3740         return NULL;
3741     }
3742
3743     GEOSContextHandleInternal_t *handle = 0;
3744     handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
3745     if ( 0 == handle->initialized )
3746     {
3747         return NULL;
3748     }
3749
3750     try
3751     {
3752         const GeometryFactory *gf = handle->geomFactory;
3753         return gf->createPoint();
3754     }
3755     catch (const std::exception &e)
3756     {
3757         handle->ERROR_MESSAGE("%s", e.what());
3758     }
3759     catch (...)
3760     {
3761         handle->ERROR_MESSAGE("Unknown exception thrown");
3762     }
3763
3764     return NULL;
3765 }
3766
3767 Geometry *
3768 GEOSGeom_createPoint_r(GEOSContextHandle_t extHandle, CoordinateSequence *cs)
3769 {
3770     if ( 0 == extHandle )
3771     {
3772         return 0;
3773     }
3774
3775     GEOSContextHandleInternal_t *handle = 0;
3776     handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
3777     if ( 0 == handle->initialized )
3778     {
3779         return 0;
3780     }
3781
3782     try
3783     {
3784         const GeometryFactory *gf = handle->geomFactory;
3785         return gf->createPoint(cs);
3786     }
3787     catch (const std::exception &e)
3788     {
3789         handle->ERROR_MESSAGE("%s", e.what());
3790     }
3791     catch (...)
3792     {
3793         handle->ERROR_MESSAGE("Unknown exception thrown");
3794     }
3795
3796     return 0;
3797 }
3798
3799 Geometry *
3800 GEOSGeom_createLinearRing_r(GEOSContextHandle_t extHandle, CoordinateSequence *cs)
3801 {
3802     if ( 0 == extHandle )
3803     {
3804         return NULL;
3805     }
3806
3807     GEOSContextHandleInternal_t *handle = 0;
3808     handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
3809     if ( 0 == handle->initialized )
3810     {
3811         return NULL;
3812     }
3813
3814     try
3815     {
3816         const GeometryFactory *gf = handle->geomFactory;
3817
3818         return gf->createLinearRing(cs);
3819     }
3820     catch (const std::exception &e)
3821     {
3822         handle->ERROR_MESSAGE("%s", e.what());
3823     }
3824     catch (...)
3825     {
3826         handle->ERROR_MESSAGE("Unknown exception thrown");
3827     }
3828
3829     return NULL;
3830 }
3831
3832 Geometry *
3833 GEOSGeom_createEmptyLineString_r(GEOSContextHandle_t extHandle)
3834 {
3835     if ( 0 == extHandle )
3836     {
3837         return NULL;
3838     }
3839
3840     GEOSContextHandleInternal_t *handle = 0;
3841     handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
3842     if ( 0 == handle->initialized )
3843     {
3844         return NULL;
3845     }
3846
3847     try
3848     {
3849         const GeometryFactory *gf = handle->geomFactory;
3850
3851         return gf->createLineString();
3852     }
3853     catch (const std::exception &e)
3854     {
3855         handle->ERROR_MESSAGE("%s", e.what());
3856     }
3857     catch (...)
3858     {
3859         handle->ERROR_MESSAGE("Unknown exception thrown");
3860     }
3861
3862     return NULL;
3863 }
3864
3865 Geometry *
3866 GEOSGeom_createLineString_r(GEOSContextHandle_t extHandle, CoordinateSequence *cs)
3867 {
3868     if ( 0 == extHandle )
3869     {
3870         return NULL;
3871     }
3872
3873     GEOSContextHandleInternal_t *handle = 0;
3874     handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
3875     if ( 0 == handle->initialized )
3876     {
3877         return NULL;
3878     }
3879
3880     try
3881     {
3882         const GeometryFactory *gf = handle->geomFactory;
3883
3884         return gf->createLineString(cs);
3885     }
3886     catch (const std::exception &e)
3887     {
3888         handle->ERROR_MESSAGE("%s", e.what());
3889     }
3890     catch (...)
3891     {
3892         handle->ERROR_MESSAGE("Unknown exception thrown");
3893     }
3894
3895     return NULL;
3896 }
3897
3898 Geometry *
3899 GEOSGeom_createEmptyPolygon_r(GEOSContextHandle_t extHandle)
3900 {
3901     if ( 0 == extHandle )
3902     {
3903         return NULL;
3904     }
3905
3906     GEOSContextHandleInternal_t *handle = 0;
3907     handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
3908     if ( 0 == handle->initialized )
3909     {
3910         return NULL;
3911     }
3912
3913     try
3914     {
3915         const GeometryFactory *gf = handle->geomFactory;
3916         return gf->createPolygon();
3917     }
3918     catch (const std::exception &e)
3919     {
3920         handle->ERROR_MESSAGE("%s", e.what());
3921     }
3922     catch (...)
3923     {
3924         handle->ERROR_MESSAGE("Unknown exception thrown");
3925     }
3926
3927     return NULL;
3928 }
3929
3930 Geometry *
3931 GEOSGeom_createPolygon_r(GEOSContextHandle_t extHandle, Geometry *shell, Geometry **holes, unsigned int nholes)
3932 {
3933     // FIXME: holes must be non-nullptr or may be nullptr?
3934     //assert(0 != holes);
3935
3936     if ( 0 == extHandle )
3937     {
3938         return NULL;
3939     }
3940
3941     GEOSContextHandleInternal_t *handle = 0;
3942     handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
3943     if ( 0 == handle->initialized )
3944     {
3945         return NULL;
3946     }
3947
3948     try
3949     {
3950         using geos::geom::LinearRing;
3951
3952         std::vector<Geometry *> *vholes = new std::vector<Geometry *>(holes, holes + nholes);
3953
3954         LinearRing *nshell = dynamic_cast<LinearRing *>(shell);
3955         if ( ! nshell )
3956         {
3957             handle->ERROR_MESSAGE("Shell is not a LinearRing");
3958             return NULL;
3959         }
3960         const GeometryFactory *gf = handle->geomFactory;
3961
3962         return gf->createPolygon(nshell, vholes);
3963     }
3964     catch (const std::exception &e)
3965     {
3966         handle->ERROR_MESSAGE("%s", e.what());
3967     }
3968     catch (...)
3969     {
3970         handle->ERROR_MESSAGE("Unknown exception thrown");
3971     }
3972
3973     return NULL;
3974 }
3975
3976 Geometry *
3977 GEOSGeom_clone_r(GEOSContextHandle_t extHandle, const Geometry *g)
3978 {
3979     assert(0 != g);
3980
3981     if ( 0 == extHandle )
3982     {
3983         return NULL;
3984     }
3985
3986     GEOSContextHandleInternal_t *handle = 0;
3987     handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
3988     if ( 0 == handle->initialized )
3989     {
3990         return NULL;
3991     }
3992
3993     try
3994     {
3995         return g->clone();
3996     }
3997     catch (const std::exception &e)
3998     {
3999         handle->ERROR_MESSAGE("%s", e.what());
4000     }
4001     catch (...)
4002     {
4003         handle->ERROR_MESSAGE("Unknown exception thrown");
4004     }
4005
4006     return NULL;
4007 }
4008
4009 int
4010 GEOSGeom_getDimensions_r(GEOSContextHandle_t extHandle, const Geometry *g)
4011 {
4012     if ( 0 == extHandle )
4013     {
4014         return 0;
4015     }
4016
4017     GEOSContextHandleInternal_t *handle = 0;
4018     handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
4019     if ( 0 == handle->initialized )
4020     {
4021         return 0;
4022     }
4023
4024     try
4025     {
4026         return (int) g->getDimension();
4027     }
4028     catch (const std::exception &e)
4029     {
4030         handle->ERROR_MESSAGE("%s", e.what());
4031     }
4032     catch (...)
4033     {
4034         handle->ERROR_MESSAGE("Unknown exception thrown");
4035     }
4036
4037     return 0;
4038 }
4039
4040 int
4041 GEOSGeom_getCoordinateDimension_r(GEOSContextHandle_t extHandle, const Geometry *g)
4042 {
4043     if ( 0 == extHandle )
4044     {
4045         return 0;
4046     }
4047
4048     GEOSContextHandleInternal_t *handle = 0;
4049     handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
4050     if ( 0 == handle->initialized )
4051     {
4052         return 0;
4053     }
4054
4055     try
4056     {
4057         return g->getCoordinateDimension();
4058     }
4059     catch (const std::exception &e)
4060     {
4061         handle->ERROR_MESSAGE("%s", e.what());
4062     }
4063     catch (...)
4064     {
4065         handle->ERROR_MESSAGE("Unknown exception thrown");
4066     }
4067
4068     return 0;
4069 }
4070
4071 Geometry *
4072 GEOSSimplify_r(GEOSContextHandle_t extHandle, const Geometry *g1, double tolerance)
4073 {
4074     if ( 0 == extHandle )
4075     {
4076         return NULL;
4077     }
4078
4079     GEOSContextHandleInternal_t *handle = 0;
4080     handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
4081     if ( 0 == handle->initialized )
4082     {
4083         return NULL;
4084     }
4085
4086     try
4087     {
4088         using namespace geos::simplify;
4089         Geometry::AutoPtr g(DouglasPeuckerSimplifier::simplify(g1, tolerance));
4090         return g.release();
4091     }
4092     catch (const std::exception &e)
4093     {
4094         handle->ERROR_MESSAGE("%s", e.what());
4095     }
4096     catch (...)
4097     {
4098         handle->ERROR_MESSAGE("Unknown exception thrown");
4099     }
4100
4101     return NULL;
4102 }
4103
4104 Geometry *
4105 GEOSTopologyPreserveSimplify_r(GEOSContextHandle_t extHandle, const Geometry *g1, double tolerance)
4106 {
4107     if ( 0 == extHandle )
4108     {
4109         return NULL;
4110     }
4111
4112     GEOSContextHandleInternal_t *handle = 0;
4113     handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
4114     if ( 0 == handle->initialized )
4115     {
4116         return NULL;
4117     }
4118
4119     try
4120     {
4121         using namespace geos::simplify;
4122         Geometry::AutoPtr g(TopologyPreservingSimplifier::simplify(g1, tolerance));
4123         return g.release();
4124     }
4125     catch (const std::exception &e)
4126     {
4127         handle->ERROR_MESSAGE("%s", e.what());
4128     }
4129     catch (...)
4130     {
4131         handle->ERROR_MESSAGE("Unknown exception thrown");
4132     }
4133
4134     return NULL;
4135 }
4136
4137
4138 /* WKT Reader */
4139 WKTReader *
4140 GEOSWKTReader_create_r(GEOSContextHandle_t extHandle)
4141 {
4142     if ( 0 == extHandle )
4143     {
4144         return NULL;
4145     }
4146
4147     GEOSContextHandleInternal_t *handle = 0;
4148     handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
4149     if ( 0 == handle->initialized )
4150     {
4151         return NULL;
4152     }
4153
4154     try
4155     {
4156         using geos::io::WKTReader;
4157         return new WKTReader((GeometryFactory*)handle->geomFactory);
4158     }
4159     catch (const std::exception &e)
4160     {
4161         handle->ERROR_MESSAGE("%s", e.what());
4162     }
4163     catch (...)
4164     {
4165         handle->ERROR_MESSAGE("Unknown exception thrown");
4166     }
4167
4168     return NULL;
4169 }
4170
4171 void
4172 GEOSWKTReader_destroy_r(GEOSContextHandle_t extHandle, WKTReader *reader)
4173 {
4174     GEOSContextHandleInternal_t *handle = 0;
4175
4176     try
4177     {
4178         delete reader;
4179     }
4180     catch (const std::exception &e)
4181     {
4182         if ( 0 == extHandle )
4183         {
4184             return;
4185         }
4186
4187         handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
4188         if ( 0 == handle->initialized )
4189         {
4190             return;
4191         }
4192
4193         handle->ERROR_MESSAGE("%s", e.what());
4194     }
4195     catch (...)
4196     {
4197         if ( 0 == extHandle )
4198         {
4199             return;
4200         }
4201
4202         handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
4203         if ( 0 == handle->initialized )
4204         {
4205             return;
4206         }
4207
4208         handle->ERROR_MESSAGE("Unknown exception thrown");
4209     }
4210 }
4211
4212
4213 Geometry*
4214 GEOSWKTReader_read_r(GEOSContextHandle_t extHandle, WKTReader *reader, const char *wkt)
4215 {
4216     assert(0 != reader);
4217
4218     if ( 0 == extHandle )
4219     {
4220         return 0;
4221     }
4222
4223     GEOSContextHandleInternal_t *handle = 0;
4224     handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
4225     if ( 0 == handle->initialized )
4226     {
4227         return 0;
4228     }
4229
4230     try
4231     {
4232         const std::string wktstring(wkt);
4233         Geometry *g = reader->read(wktstring);
4234         return g;
4235     }
4236     catch (const std::exception &e)
4237     {
4238         handle->ERROR_MESSAGE("%s", e.what());
4239     }
4240     catch (...)
4241     {
4242         handle->ERROR_MESSAGE("Unknown exception thrown");
4243     }
4244
4245     return 0;
4246 }
4247
4248 /* WKT Writer */
4249 WKTWriter *
4250 GEOSWKTWriter_create_r(GEOSContextHandle_t extHandle)
4251 {
4252     if ( 0 == extHandle )
4253     {
4254         return 0;
4255     }
4256
4257     GEOSContextHandleInternal_t *handle = 0;
4258     handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
4259     if ( 0 == handle->initialized )
4260     {
4261         return 0;
4262     }
4263
4264     try
4265     {
4266         using geos::io::WKTWriter;
4267         return new WKTWriter();
4268     }
4269     catch (const std::exception &e)
4270     {
4271         handle->ERROR_MESSAGE("%s", e.what());
4272     }
4273     catch (...)
4274     {
4275         handle->ERROR_MESSAGE("Unknown exception thrown");
4276     }
4277
4278     return 0;
4279 }
4280
4281 void
4282 GEOSWKTWriter_destroy_r(GEOSContextHandle_t extHandle, WKTWriter *Writer)
4283 {
4284
4285     GEOSContextHandleInternal_t *handle = 0;
4286
4287     try
4288     {
4289         delete Writer;
4290     }
4291     catch (const std::exception &e)
4292     {
4293         if ( 0 == extHandle )
4294         {
4295             return;
4296         }
4297
4298         handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
4299         if ( 0 == handle->initialized )
4300         {
4301             return;
4302         }
4303
4304         handle->ERROR_MESSAGE("%s", e.what());
4305     }
4306     catch (...)
4307     {
4308         if ( 0 == extHandle )
4309         {
4310             return;
4311         }
4312
4313         handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
4314         if ( 0 == handle->initialized )
4315         {
4316             return;
4317         }
4318
4319         handle->ERROR_MESSAGE("Unknown exception thrown");
4320     }
4321 }
4322
4323
4324 char*
4325 GEOSWKTWriter_write_r(GEOSContextHandle_t extHandle, WKTWriter *writer, const Geometry *geom)
4326 {
4327     assert(0 != writer);
4328
4329     if ( 0 == extHandle )
4330     {
4331         return NULL;
4332     }
4333
4334     GEOSContextHandleInternal_t *handle = 0;
4335     handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
4336     if ( 0 == handle->initialized )
4337     {
4338         return NULL;
4339     }
4340
4341     try
4342     {
4343         std::string sgeom(writer->write(geom));
4344         char *result = gstrdup(sgeom);
4345         return result;
4346     }
4347     catch (const std::exception &e)
4348     {
4349         handle->ERROR_MESSAGE("%s", e.what());
4350     }
4351     catch (...)
4352     {
4353         handle->ERROR_MESSAGE("Unknown exception thrown");
4354     }
4355
4356     return NULL;
4357 }
4358
4359 void
4360 GEOSWKTWriter_setTrim_r(GEOSContextHandle_t extHandle, WKTWriter *writer, char trim)
4361 {
4362     assert(0 != writer);
4363
4364     if ( 0 == extHandle )
4365     {
4366         return;
4367     }
4368
4369     GEOSContextHandleInternal_t *handle = 0;
4370     handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
4371     if ( 0 == handle->initialized )
4372     {
4373         return;
4374     }
4375
4376     writer->setTrim(0 != trim);
4377 }
4378
4379 void
4380 GEOSWKTWriter_setRoundingPrecision_r(GEOSContextHandle_t extHandle, WKTWriter *writer, int precision)
4381 {
4382     assert(0 != writer);
4383
4384     if ( 0 == extHandle )
4385     {
4386         return;
4387     }
4388
4389     GEOSContextHandleInternal_t *handle = 0;
4390     handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
4391     if ( 0 == handle->initialized )
4392     {
4393         return;
4394     }
4395
4396     writer->setRoundingPrecision(precision);
4397 }
4398
4399 void
4400 GEOSWKTWriter_setOutputDimension_r(GEOSContextHandle_t extHandle, WKTWriter *writer, int dim)
4401 {
4402     assert(0 != writer);
4403
4404     if ( 0 == extHandle )
4405     {
4406         return;
4407     }
4408
4409     GEOSContextHandleInternal_t *handle = 0;
4410     handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
4411     if ( 0 == handle->initialized )
4412     {
4413         return;
4414     }
4415
4416     try
4417     {
4418         writer->setOutputDimension(dim);
4419     }
4420     catch (const std::exception &e)
4421     {
4422         handle->ERROR_MESSAGE("%s", e.what());
4423     }
4424     catch (...)
4425     {
4426         handle->ERROR_MESSAGE("Unknown exception thrown");
4427     }
4428 }
4429
4430 int
4431 GEOSWKTWriter_getOutputDimension_r(GEOSContextHandle_t extHandle, WKTWriter *writer)
4432 {
4433     assert(0 != writer);
4434
4435     if ( 0 == extHandle )
4436     {
4437         return -1;
4438     }
4439
4440     GEOSContextHandleInternal_t *handle = 0;
4441     handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
4442     if ( 0 == handle->initialized )
4443     {
4444         return -1;
4445     }
4446
4447     int  dim = -1;
4448
4449     try
4450     {
4451         dim = writer->getOutputDimension();
4452     }
4453     catch (const std::exception &e)
4454     {
4455         handle->ERROR_MESSAGE("%s", e.what());
4456     }
4457     catch (...)
4458     {
4459         handle->ERROR_MESSAGE("Unknown exception thrown");
4460     }
4461
4462     return dim;
4463 }
4464
4465 void
4466 GEOSWKTWriter_setOld3D_r(GEOSContextHandle_t extHandle, WKTWriter *writer, int useOld3D)
4467 {
4468     assert(0 != writer);
4469
4470     if ( 0 == extHandle )
4471     {
4472         return;
4473     }
4474
4475     GEOSContextHandleInternal_t *handle = 0;
4476     handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
4477     if ( 0 == handle->initialized )
4478     {
4479         return;
4480     }
4481
4482     writer->setOld3D(0 != useOld3D);
4483 }
4484
4485 /* WKB Reader */
4486 WKBReader *
4487 GEOSWKBReader_create_r(GEOSContextHandle_t extHandle)
4488 {
4489     if ( 0 == extHandle )
4490     {
4491         return NULL;
4492     }
4493
4494     GEOSContextHandleInternal_t *handle = 0;
4495     handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
4496     if ( 0 == handle->initialized )
4497     {
4498         return NULL;
4499     }
4500
4501     using geos::io::WKBReader;
4502     try
4503     {
4504         return new WKBReader(*(GeometryFactory*)handle->geomFactory);
4505     }
4506     catch (const std::exception &e)
4507     {
4508         handle->ERROR_MESSAGE("%s", e.what());
4509     }
4510     catch (...)
4511     {
4512         handle->ERROR_MESSAGE("Unknown exception thrown");
4513     }
4514
4515     return NULL;
4516 }
4517
4518 void
4519 GEOSWKBReader_destroy_r(GEOSContextHandle_t extHandle, WKBReader *reader)
4520 {
4521     GEOSContextHandleInternal_t *handle = 0;
4522
4523     try
4524     {
4525         delete reader;
4526     }
4527     catch (const std::exception &e)
4528     {
4529         if ( 0 == extHandle )
4530         {
4531             return;
4532         }
4533
4534         handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
4535         if ( 0 == handle->initialized )
4536         {
4537             return;
4538         }
4539
4540         handle->ERROR_MESSAGE("%s", e.what());
4541     }
4542     catch (...)
4543     {
4544         if ( 0 == extHandle )
4545         {
4546             return;
4547         }
4548
4549         handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
4550         if ( 0 == handle->initialized )
4551         {
4552             return;
4553         }
4554
4555         handle->ERROR_MESSAGE("Unknown exception thrown");
4556     }
4557 }
4558
4559 struct membuf : public std::streambuf
4560 {
4561   membuf(char* s, std::size_t n)
4562   {
4563     setg(s, s, s + n);
4564   }
4565 };
4566
4567 Geometry*
4568 GEOSWKBReader_read_r(GEOSContextHandle_t extHandle, WKBReader *reader, const unsigned char *wkb, size_t size)
4569 {
4570     assert(0 != reader);
4571     assert(0 != wkb);
4572
4573     if ( 0 == extHandle )
4574     {
4575         return 0;
4576     }
4577
4578     GEOSContextHandleInternal_t *handle = 0;
4579     handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
4580     if ( 0 == handle->initialized )
4581     {
4582         return 0;
4583     }
4584
4585     try
4586     {
4587         //std::string wkbstring(reinterpret_cast<const char*>(wkb), size); // make it binary !
4588         //std::istringstream is(std::ios_base::binary);
4589         //is.str(wkbstring);
4590         //is.seekg(0, std::ios::beg); // rewind reader pointer
4591
4592         // http://stackoverflow.com/questions/2079912/simpler-way-to-create-a-c-memorystream-from-char-size-t-without-copying-t
4593         membuf mb((char*)wkb, size);
4594         istream is(&mb);
4595
4596         Geometry *g = reader->read(is);
4597         return g;
4598     }
4599     catch (const std::exception &e)
4600     {
4601         handle->ERROR_MESSAGE("%s", e.what());
4602     }
4603     catch (...)
4604     {
4605         handle->ERROR_MESSAGE("Unknown exception thrown");
4606     }
4607
4608     return 0;
4609 }
4610
4611 Geometry*
4612 GEOSWKBReader_readHEX_r(GEOSContextHandle_t extHandle, WKBReader *reader, const unsigned char *hex, size_t size)
4613 {
4614     assert(0 != reader);
4615     assert(0 != hex);
4616
4617     if ( 0 == extHandle )
4618     {
4619         return 0;
4620     }
4621
4622     GEOSContextHandleInternal_t *handle = 0;
4623     handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
4624     if ( 0 == handle->initialized )
4625     {
4626         return 0;
4627     }
4628
4629     try
4630     {
4631         std::string hexstring(reinterpret_cast<const char*>(hex), size);
4632         std::istringstream is(std::ios_base::binary);
4633         is.str(hexstring);
4634         is.seekg(0, std::ios::beg); // rewind reader pointer
4635
4636         Geometry *g = reader->readHEX(is);
4637         return g;
4638     }
4639     catch (const std::exception &e)
4640     {
4641         handle->ERROR_MESSAGE("%s", e.what());
4642     }
4643     catch (...)
4644     {
4645         handle->ERROR_MESSAGE("Unknown exception thrown");
4646     }
4647
4648     return 0;
4649 }
4650
4651 /* WKB Writer */
4652 WKBWriter *
4653 GEOSWKBWriter_create_r(GEOSContextHandle_t extHandle)
4654 {
4655     if ( 0 == extHandle )
4656     {
4657         return NULL;
4658     }
4659
4660     GEOSContextHandleInternal_t *handle = 0;
4661     handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
4662     if ( 0 == handle->initialized )
4663     {
4664         return NULL;
4665     }
4666
4667     try
4668     {
4669         using geos::io::WKBWriter;
4670         return new WKBWriter();
4671     }
4672     catch (const std::exception &e)
4673     {
4674         handle->ERROR_MESSAGE("%s", e.what());
4675     }
4676     catch (...)
4677     {
4678         handle->ERROR_MESSAGE("Unknown exception thrown");
4679     }
4680
4681     return NULL;
4682 }
4683
4684 void
4685 GEOSWKBWriter_destroy_r(GEOSContextHandle_t extHandle, WKBWriter *Writer)
4686 {
4687     GEOSContextHandleInternal_t *handle = 0;
4688
4689     try
4690     {
4691         delete Writer;
4692     }
4693     catch (const std::exception &e)
4694     {
4695         if ( 0 == extHandle )
4696         {
4697             return;
4698         }
4699
4700         handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
4701         if ( 0 == handle->initialized )
4702         {
4703             return;
4704         }
4705
4706         handle->ERROR_MESSAGE("%s", e.what());
4707     }
4708     catch (...)
4709     {
4710         if ( 0 == extHandle )
4711         {
4712             return;
4713         }
4714
4715         handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
4716         if ( 0 == handle->initialized )
4717         {
4718             return;
4719         }
4720
4721         handle->ERROR_MESSAGE("Unknown exception thrown");
4722     }
4723 }
4724
4725
4726 /* The caller owns the result */
4727 unsigned char*
4728 GEOSWKBWriter_write_r(GEOSContextHandle_t extHandle, WKBWriter *writer, const Geometry *geom, size_t *size)
4729 {
4730     assert(0 != writer);
4731     assert(0 != geom);
4732     assert(0 != size);
4733
4734     if ( 0 == extHandle )
4735     {
4736         return NULL;
4737     }
4738
4739     GEOSContextHandleInternal_t *handle = 0;
4740     handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
4741     if ( 0 == handle->initialized )
4742     {
4743         return NULL;
4744     }
4745
4746     try
4747     {
4748         std::ostringstream os(std::ios_base::binary);
4749         writer->write(*geom, os);
4750
4751         const std::string& wkbstring = os.str();
4752         const std::size_t len = wkbstring.length();
4753
4754         unsigned char *result = NULL;
4755         result = (unsigned char*) malloc(len);
4756         std::memcpy(result, wkbstring.c_str(), len);
4757         *size = len;
4758         return result;
4759     }
4760     catch (const std::exception &e)
4761     {
4762         handle->ERROR_MESSAGE("%s", e.what());
4763     }
4764     catch (...)
4765     {
4766         handle->ERROR_MESSAGE("Unknown exception thrown");
4767     }
4768     return NULL;
4769 }
4770
4771 /* The caller owns the result */
4772 unsigned char*
4773 GEOSWKBWriter_writeHEX_r(GEOSContextHandle_t extHandle, WKBWriter *writer, const Geometry *geom, size_t *size)
4774 {
4775     assert(0 != writer);
4776     assert(0 != geom);
4777     assert(0 != size);
4778
4779     if ( 0 == extHandle )
4780     {
4781         return NULL;
4782     }
4783
4784     GEOSContextHandleInternal_t *handle = 0;
4785     handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
4786     if ( 0 == handle->initialized )
4787     {
4788         return NULL;
4789     }
4790
4791     try
4792     {
4793         std::ostringstream os(std::ios_base::binary);
4794         writer->writeHEX(*geom, os);
4795         std::string wkbstring(os.str());
4796         const std::size_t len = wkbstring.length();
4797
4798         unsigned char *result = NULL;
4799         result = (unsigned char*) malloc(len);
4800         std::memcpy(result, wkbstring.c_str(), len);
4801         *size = len;
4802         return result;
4803     }
4804     catch (const std::exception &e)
4805     {
4806         handle->ERROR_MESSAGE("%s", e.what());
4807     }
4808     catch (...)
4809     {
4810         handle->ERROR_MESSAGE("Unknown exception thrown");
4811     }
4812
4813     return NULL;
4814 }
4815
4816 int
4817 GEOSWKBWriter_getOutputDimension_r(GEOSContextHandle_t extHandle, const GEOSWKBWriter* writer)
4818 {
4819     assert(0 != writer);
4820
4821     if ( 0 == extHandle )
4822     {
4823         return 0;
4824     }
4825
4826     int ret = 0;
4827
4828     GEOSContextHandleInternal_t *handle = 0;
4829     handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
4830     if ( 0 != handle->initialized )
4831     {
4832         try
4833         {
4834             ret = writer->getOutputDimension();
4835         }
4836         catch (...)
4837         {
4838             handle->ERROR_MESSAGE("Unknown exception thrown");
4839         }
4840     }
4841
4842     return ret;
4843 }
4844
4845 void
4846 GEOSWKBWriter_setOutputDimension_r(GEOSContextHandle_t extHandle, GEOSWKBWriter* writer, int newDimension)
4847 {
4848     assert(0 != writer);
4849
4850     if ( 0 == extHandle )
4851     {
4852         return;
4853     }
4854
4855     GEOSContextHandleInternal_t *handle = 0;
4856     handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
4857     if ( 0 != handle->initialized )
4858     {
4859         try
4860         {
4861             writer->setOutputDimension(newDimension);
4862         }
4863         catch (const std::exception &e)
4864         {
4865             handle->ERROR_MESSAGE("%s", e.what());
4866         }
4867         catch (...)
4868         {
4869             handle->ERROR_MESSAGE("Unknown exception thrown");
4870         }
4871     }
4872 }
4873
4874 int
4875 GEOSWKBWriter_getByteOrder_r(GEOSContextHandle_t extHandle, const GEOSWKBWriter* writer)
4876 {
4877     assert(0 != writer);
4878
4879     if ( 0 == extHandle )
4880     {
4881         return 0;
4882     }
4883
4884     int ret = 0;
4885
4886     GEOSContextHandleInternal_t *handle = 0;
4887     handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
4888     if ( 0 != handle->initialized )
4889     {
4890         try
4891         {
4892             ret = writer->getByteOrder();
4893         }
4894
4895         catch (...)
4896         {
4897             handle->ERROR_MESSAGE("Unknown exception thrown");
4898         }
4899     }
4900
4901     return ret;
4902 }
4903
4904 void
4905 GEOSWKBWriter_setByteOrder_r(GEOSContextHandle_t extHandle, GEOSWKBWriter* writer, int newByteOrder)
4906 {
4907     assert(0 != writer);
4908
4909     if ( 0 == extHandle )
4910     {
4911         return;
4912     }
4913
4914     GEOSContextHandleInternal_t *handle = 0;
4915     handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
4916     if ( 0 != handle->initialized )
4917     {
4918         try
4919         {
4920             writer->setByteOrder(newByteOrder);
4921         }
4922         catch (const std::exception &e)
4923         {
4924             handle->ERROR_MESSAGE("%s", e.what());
4925         }
4926         catch (...)
4927         {
4928             handle->ERROR_MESSAGE("Unknown exception thrown");
4929         }
4930     }
4931 }
4932
4933 char
4934 GEOSWKBWriter_getIncludeSRID_r(GEOSContextHandle_t extHandle, const GEOSWKBWriter* writer)
4935 {
4936     assert(0 != writer);
4937
4938     if ( 0 == extHandle )
4939     {
4940         return -1;
4941     }
4942
4943     int ret = -1;
4944
4945     GEOSContextHandleInternal_t *handle = 0;
4946     handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
4947     if ( 0 != handle->initialized )
4948     {
4949         try
4950         {
4951             int srid = writer->getIncludeSRID();
4952             ret = srid;
4953         }
4954         catch (...)
4955         {
4956             handle->ERROR_MESSAGE("Unknown exception thrown");
4957         }
4958     }
4959
4960     return static_cast<char>(ret);
4961 }
4962
4963 void
4964 GEOSWKBWriter_setIncludeSRID_r(GEOSContextHandle_t extHandle, GEOSWKBWriter* writer, const char newIncludeSRID)
4965 {
4966     assert(0 != writer);
4967
4968     if ( 0 == extHandle )
4969     {
4970         return;
4971     }
4972
4973     GEOSContextHandleInternal_t *handle = 0;
4974     handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
4975     if ( 0 != handle->initialized )
4976     {
4977         try
4978         {
4979             writer->setIncludeSRID(newIncludeSRID);
4980         }
4981         catch (...)
4982         {
4983             handle->ERROR_MESSAGE("Unknown exception thrown");
4984         }
4985     }
4986 }
4987
4988
4989 //-----------------------------------------------------------------
4990 // Prepared Geometry
4991 //-----------------------------------------------------------------
4992
4993 const geos::geom::prep::PreparedGeometry*
4994 GEOSPrepare_r(GEOSContextHandle_t extHandle, const Geometry *g)
4995 {
4996     if ( 0 == extHandle )
4997     {
4998         return 0;
4999     }
5000
5001     GEOSContextHandleInternal_t *handle = 0;
5002     handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
5003     if ( 0 == handle->initialized )
5004     {
5005         return 0;
5006     }
5007
5008     const geos::geom::prep::PreparedGeometry* prep = 0;
5009
5010     try
5011     {
5012         prep = geos::geom::prep::PreparedGeometryFactory::prepare(g);
5013     }
5014     catch (const std::exception &e)
5015     {
5016         handle->ERROR_MESSAGE("%s", e.what());
5017     }
5018     catch (...)
5019     {
5020         handle->ERROR_MESSAGE("Unknown exception thrown");
5021     }
5022
5023     return prep;
5024 }
5025
5026 void
5027 GEOSPreparedGeom_destroy_r(GEOSContextHandle_t extHandle, const geos::geom::prep::PreparedGeometry *a)
5028 {
5029     GEOSContextHandleInternal_t *handle = 0;
5030
5031     try
5032     {
5033         delete a;
5034     }
5035     catch (const std::exception &e)
5036     {
5037         if ( 0 == extHandle )
5038         {
5039             return;
5040         }
5041
5042         handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
5043         if ( 0 == handle->initialized )
5044         {
5045             return;
5046         }
5047
5048         handle->ERROR_MESSAGE("%s", e.what());
5049     }
5050     catch (...)
5051     {
5052         if ( 0 == extHandle )
5053         {
5054             return;
5055         }
5056
5057         handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
5058         if ( 0 == handle->initialized )
5059         {
5060             return;
5061         }
5062
5063         handle->ERROR_MESSAGE("Unknown exception thrown");
5064     }
5065 }
5066
5067 char
5068 GEOSPreparedContains_r(GEOSContextHandle_t extHandle,
5069         const geos::geom::prep::PreparedGeometry *pg, const Geometry *g)
5070 {
5071     assert(0 != pg);
5072     assert(0 != g);
5073
5074     if ( 0 == extHandle )
5075     {
5076         return 2;
5077     }
5078
5079     GEOSContextHandleInternal_t *handle = 0;
5080     handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
5081     if ( 0 == handle->initialized )
5082     {
5083         return 2;
5084     }
5085
5086     try
5087     {
5088         bool result = pg->contains(g);
5089         return result;
5090     }
5091     catch (const std::exception &e)
5092     {
5093         handle->ERROR_MESSAGE("%s", e.what());
5094     }
5095     catch (...)
5096     {
5097         handle->ERROR_MESSAGE("Unknown exception thrown");
5098     }
5099
5100     return 2;
5101 }
5102
5103 char
5104 GEOSPreparedContainsProperly_r(GEOSContextHandle_t extHandle,
5105         const geos::geom::prep::PreparedGeometry *pg, const Geometry *g)
5106 {
5107     assert(0 != pg);
5108     assert(0 != g);
5109
5110     if ( 0 == extHandle )
5111     {
5112         return 2;
5113     }
5114
5115     GEOSContextHandleInternal_t *handle = 0;
5116     handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
5117     if ( 0 == handle->initialized )
5118     {
5119         return 2;
5120     }
5121
5122     try
5123     {
5124         bool result = pg->containsProperly(g);
5125         return result;
5126     }
5127     catch (const std::exception &e)
5128     {
5129         handle->ERROR_MESSAGE("%s", e.what());
5130     }
5131     catch (...)
5132     {
5133         handle->ERROR_MESSAGE("Unknown exception thrown");
5134     }
5135
5136     return 2;
5137 }
5138
5139 char
5140 GEOSPreparedCoveredBy_r(GEOSContextHandle_t extHandle,
5141         const geos::geom::prep::PreparedGeometry *pg, const Geometry *g)
5142 {
5143     assert(0 != pg);
5144     assert(0 != g);
5145
5146     if ( 0 == extHandle )
5147     {
5148         return 2;
5149     }
5150
5151     GEOSContextHandleInternal_t *handle = 0;
5152     handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
5153     if ( 0 == handle->initialized )
5154     {
5155         return 2;
5156     }
5157
5158     try
5159     {
5160         bool result = pg->coveredBy(g);
5161         return result;
5162     }
5163     catch (const std::exception &e)
5164     {
5165         handle->ERROR_MESSAGE("%s", e.what());
5166     }
5167     catch (...)
5168     {
5169         handle->ERROR_MESSAGE("Unknown exception thrown");
5170     }
5171
5172     return 2;
5173 }
5174
5175 char
5176 GEOSPreparedCovers_r(GEOSContextHandle_t extHandle,
5177         const geos::geom::prep::PreparedGeometry *pg, const Geometry *g)
5178 {
5179     assert(0 != pg);
5180     assert(0 != g);
5181
5182     if ( 0 == extHandle )
5183     {
5184         return 2;
5185     }
5186
5187     GEOSContextHandleInternal_t *handle = 0;
5188     handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
5189     if ( 0 == handle->initialized )
5190     {
5191         return 2;
5192     }
5193
5194     try
5195     {
5196         bool result = pg->covers(g);
5197         return result;
5198     }
5199     catch (const std::exception &e)
5200     {
5201         handle->ERROR_MESSAGE("%s", e.what());
5202     }
5203     catch (...)
5204     {
5205         handle->ERROR_MESSAGE("Unknown exception thrown");
5206     }
5207
5208     return 2;
5209 }
5210
5211 char
5212 GEOSPreparedCrosses_r(GEOSContextHandle_t extHandle,
5213         const geos::geom::prep::PreparedGeometry *pg, const Geometry *g)
5214 {
5215     assert(0 != pg);
5216     assert(0 != g);
5217
5218     if ( 0 == extHandle )
5219     {
5220         return 2;
5221     }
5222
5223     GEOSContextHandleInternal_t *handle = 0;
5224     handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
5225     if ( 0 == handle->initialized )
5226     {
5227         return 2;
5228     }
5229
5230     try
5231     {
5232         bool result = pg->crosses(g);
5233         return result;
5234     }
5235     catch (const std::exception &e)
5236     {
5237         handle->ERROR_MESSAGE("%s", e.what());
5238     }
5239     catch (...)
5240     {
5241         handle->ERROR_MESSAGE("Unknown exception thrown");
5242     }
5243
5244     return 2;
5245 }
5246
5247 char
5248 GEOSPreparedDisjoint_r(GEOSContextHandle_t extHandle,
5249         const geos::geom::prep::PreparedGeometry *pg, const Geometry *g)
5250 {
5251     assert(0 != pg);
5252     assert(0 != g);
5253
5254     if ( 0 == extHandle )
5255     {
5256         return 2;
5257     }
5258
5259     GEOSContextHandleInternal_t *handle = 0;
5260     handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
5261     if ( 0 == handle->initialized )
5262     {
5263         return 2;
5264     }
5265
5266     try
5267     {
5268         bool result = pg->disjoint(g);
5269         return result;
5270     }
5271     catch (const std::exception &e)
5272     {
5273         handle->ERROR_MESSAGE("%s", e.what());
5274     }
5275     catch (...)
5276     {
5277         handle->ERROR_MESSAGE("Unknown exception thrown");
5278     }
5279
5280     return 2;
5281 }
5282
5283 char
5284 GEOSPreparedIntersects_r(GEOSContextHandle_t extHandle,
5285         const geos::geom::prep::PreparedGeometry *pg, const Geometry *g)
5286 {
5287     assert(0 != pg);
5288     assert(0 != g);
5289
5290     if ( 0 == extHandle )
5291     {
5292         return 2;
5293     }
5294
5295     GEOSContextHandleInternal_t *handle = 0;
5296     handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
5297     if ( 0 == handle->initialized )
5298     {
5299         return 2;
5300     }
5301
5302     try
5303     {
5304         bool result = pg->intersects(g);
5305         return result;
5306     }
5307     catch (const std::exception &e)
5308     {
5309         handle->ERROR_MESSAGE("%s", e.what());
5310     }
5311     catch (...)
5312     {
5313         handle->ERROR_MESSAGE("Unknown exception thrown");
5314     }
5315
5316     return 2;
5317 }
5318
5319 char
5320 GEOSPreparedOverlaps_r(GEOSContextHandle_t extHandle,
5321         const geos::geom::prep::PreparedGeometry *pg, const Geometry *g)
5322 {
5323     assert(0 != pg);
5324     assert(0 != g);
5325
5326     if ( 0 == extHandle )
5327     {
5328         return 2;
5329     }
5330
5331     GEOSContextHandleInternal_t *handle = 0;
5332     handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
5333     if ( 0 == handle->initialized )
5334     {
5335         return 2;
5336     }
5337
5338     try
5339     {
5340         bool result = pg->overlaps(g);
5341         return result;
5342     }
5343     catch (const std::exception &e)
5344     {
5345         handle->ERROR_MESSAGE("%s", e.what());
5346     }
5347     catch (...)
5348     {
5349         handle->ERROR_MESSAGE("Unknown exception thrown");
5350     }
5351
5352     return 2;
5353 }
5354
5355 char
5356 GEOSPreparedTouches_r(GEOSContextHandle_t extHandle,
5357         const geos::geom::prep::PreparedGeometry *pg, const Geometry *g)
5358 {
5359     assert(0 != pg);
5360     assert(0 != g);
5361
5362     if ( 0 == extHandle )
5363     {
5364         return 2;
5365     }
5366
5367     GEOSContextHandleInternal_t *handle = 0;
5368     handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
5369     if ( 0 == handle->initialized )
5370     {
5371         return 2;
5372     }
5373
5374     try
5375     {
5376         bool result = pg->touches(g);
5377         return result;
5378     }
5379     catch (const std::exception &e)
5380     {
5381         handle->ERROR_MESSAGE("%s", e.what());
5382     }
5383     catch (...)
5384     {
5385         handle->ERROR_MESSAGE("Unknown exception thrown");
5386     }
5387
5388     return 2;
5389 }
5390
5391 char
5392 GEOSPreparedWithin_r(GEOSContextHandle_t extHandle,
5393         const geos::geom::prep::PreparedGeometry *pg, const Geometry *g)
5394 {
5395     assert(0 != pg);
5396     assert(0 != g);
5397
5398     if ( 0 == extHandle )
5399     {
5400         return 2;
5401     }
5402
5403     GEOSContextHandleInternal_t *handle = 0;
5404     handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
5405     if ( 0 == handle->initialized )
5406     {
5407         return 2;
5408     }
5409
5410     try
5411     {
5412         bool result = pg->within(g);
5413         return result;
5414     }
5415     catch (const std::exception &e)
5416     {
5417         handle->ERROR_MESSAGE("%s", e.what());
5418     }
5419     catch (...)
5420     {
5421         handle->ERROR_MESSAGE("Unknown exception thrown");
5422     }
5423
5424     return 2;
5425 }
5426
5427 //-----------------------------------------------------------------
5428 // STRtree
5429 //-----------------------------------------------------------------
5430
5431 geos::index::strtree::STRtree *
5432 GEOSSTRtree_create_r(GEOSContextHandle_t extHandle,
5433                                   size_t nodeCapacity)
5434 {
5435     if ( 0 == extHandle )
5436     {
5437         return 0;
5438     }
5439
5440     GEOSContextHandleInternal_t *handle = 0;
5441     handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
5442     if ( 0 == handle->initialized )
5443     {
5444         return 0;
5445     }
5446
5447     geos::index::strtree::STRtree *tree = 0;
5448
5449     try
5450     {
5451         tree = new geos::index::strtree::STRtree(nodeCapacity);
5452     }
5453     catch (const std::exception &e)
5454     {
5455         handle->ERROR_MESSAGE("%s", e.what());
5456     }
5457     catch (...)
5458     {
5459         handle->ERROR_MESSAGE("Unknown exception thrown");
5460     }
5461
5462     return tree;
5463 }
5464
5465 void
5466 GEOSSTRtree_insert_r(GEOSContextHandle_t extHandle,
5467                      geos::index::strtree::STRtree *tree,
5468                      const geos::geom::Geometry *g,
5469                      void *item)
5470 {
5471     GEOSContextHandleInternal_t *handle = 0;
5472     assert(tree != 0);
5473     assert(g != 0);
5474
5475     try
5476     {
5477         tree->insert(g->getEnvelopeInternal(), item);
5478     }
5479     catch (const std::exception &e)
5480     {
5481         if ( 0 == extHandle )
5482         {
5483             return;
5484         }
5485
5486         handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
5487         if ( 0 == handle->initialized )
5488         {
5489             return;
5490         }
5491
5492         handle->ERROR_MESSAGE("%s", e.what());
5493     }
5494     catch (...)
5495     {
5496         if ( 0 == extHandle )
5497         {
5498             return;
5499         }
5500
5501         handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
5502         if ( 0 == handle->initialized )
5503         {
5504             return;
5505         }
5506
5507         handle->ERROR_MESSAGE("Unknown exception thrown");
5508     }
5509 }
5510
5511 void
5512 GEOSSTRtree_query_r(GEOSContextHandle_t extHandle,
5513                     geos::index::strtree::STRtree *tree,
5514                     const geos::geom::Geometry *g,
5515                     GEOSQueryCallback callback,
5516                     void *userdata)
5517 {
5518     GEOSContextHandleInternal_t *handle = 0;
5519     assert(tree != 0);
5520     assert(g != 0);
5521     assert(callback != 0);
5522
5523     try
5524     {
5525         CAPI_ItemVisitor visitor(callback, userdata);
5526         tree->query(g->getEnvelopeInternal(), visitor);
5527     }
5528     catch (const std::exception &e)
5529     {
5530         if ( 0 == extHandle )
5531         {
5532             return;
5533         }
5534
5535         handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
5536         if ( 0 == handle->initialized )
5537         {
5538             return;
5539         }
5540
5541         handle->ERROR_MESSAGE("%s", e.what());
5542     }
5543     catch (...)
5544     {
5545         if ( 0 == extHandle )
5546         {
5547             return;
5548         }
5549
5550         handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
5551         if ( 0 == handle->initialized )
5552         {
5553             return;
5554         }
5555
5556         handle->ERROR_MESSAGE("Unknown exception thrown");
5557     }
5558 }
5559
5560 void
5561 GEOSSTRtree_iterate_r(GEOSContextHandle_t extHandle,
5562                     geos::index::strtree::STRtree *tree,
5563                     GEOSQueryCallback callback,
5564                     void *userdata)
5565 {
5566     GEOSContextHandleInternal_t *handle = 0;
5567     assert(tree != 0);
5568     assert(callback != 0);
5569
5570     try
5571     {
5572         CAPI_ItemVisitor visitor(callback, userdata);
5573         tree->iterate(visitor);
5574     }
5575     catch (const std::exception &e)
5576     {
5577         if ( 0 == extHandle )
5578         {
5579             return;
5580         }
5581
5582         handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
5583         if ( 0 == handle->initialized )
5584         {
5585             return;
5586         }
5587
5588         handle->ERROR_MESSAGE("%s", e.what());
5589     }
5590     catch (...)
5591     {
5592         if ( 0 == extHandle )
5593         {
5594             return;
5595         }
5596
5597         handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
5598         if ( 0 == handle->initialized )
5599         {
5600             return;
5601         }
5602
5603         handle->ERROR_MESSAGE("Unknown exception thrown");
5604     }
5605 }
5606
5607 char
5608 GEOSSTRtree_remove_r(GEOSContextHandle_t extHandle,
5609                      geos::index::strtree::STRtree *tree,
5610                      const geos::geom::Geometry *g,
5611                      void *item)
5612 {
5613     assert(0 != tree);
5614     assert(0 != g);
5615
5616     if ( 0 == extHandle )
5617     {
5618         return 2;
5619     }
5620
5621     GEOSContextHandleInternal_t *handle = 0;
5622     handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
5623     if ( 0 == handle->initialized )
5624     {
5625         return 2;
5626     }
5627
5628     try
5629     {
5630         bool result = tree->remove(g->getEnvelopeInternal(), item);
5631         return result;
5632     }
5633     catch (const std::exception &e)
5634     {
5635         handle->ERROR_MESSAGE("%s", e.what());
5636     }
5637     catch (...)
5638     {
5639         handle->ERROR_MESSAGE("Unknown exception thrown");
5640     }
5641
5642     return 2;
5643 }
5644
5645 void
5646 GEOSSTRtree_destroy_r(GEOSContextHandle_t extHandle,
5647                       geos::index::strtree::STRtree *tree)
5648 {
5649     GEOSContextHandleInternal_t *handle = 0;
5650
5651     try
5652     {
5653         delete tree;
5654     }
5655     catch (const std::exception &e)
5656     {
5657         if ( 0 == extHandle )
5658         {
5659             return;
5660         }
5661
5662         handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
5663         if ( 0 == handle->initialized )
5664         {
5665             return;
5666         }
5667
5668         handle->ERROR_MESSAGE("%s", e.what());
5669     }
5670     catch (...)
5671     {
5672         if ( 0 == extHandle )
5673         {
5674             return;
5675         }
5676
5677         handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
5678         if ( 0 == handle->initialized )
5679         {
5680             return;
5681         }
5682
5683         handle->ERROR_MESSAGE("Unknown exception thrown");
5684     }
5685 }
5686
5687 double
5688 GEOSProject_r(GEOSContextHandle_t extHandle,
5689               const Geometry *g,
5690               const Geometry *p)
5691 {
5692     if ( 0 == extHandle ) return -1.0;
5693     GEOSContextHandleInternal_t *handle =
5694         reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
5695     if ( handle->initialized == 0 ) return -1.0;
5696
5697     const geos::geom::Point* point = dynamic_cast<const geos::geom::Point*>(p);
5698     if (!point) {
5699         handle->ERROR_MESSAGE("third argument of GEOSProject_r must be Point*");
5700         return -1.0;
5701     }
5702
5703     const geos::geom::Coordinate* inputPt = p->getCoordinate();
5704
5705     try {
5706         return geos::linearref::LengthIndexedLine(g).project(*inputPt);
5707     } catch (const std::exception &e) {
5708         handle->ERROR_MESSAGE("%s", e.what());
5709         return -1.0;
5710     } catch (...) {
5711         handle->ERROR_MESSAGE("Unknown exception thrown");
5712         return -1.0;
5713     }
5714 }
5715
5716
5717 Geometry*
5718 GEOSInterpolate_r(GEOSContextHandle_t extHandle, const Geometry *g, double d)
5719 {
5720     if ( 0 == extHandle ) return 0;
5721     GEOSContextHandleInternal_t *handle =
5722         reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
5723     if ( handle->initialized == 0 ) return 0;
5724
5725     try {
5726         geos::linearref::LengthIndexedLine lil(g);
5727         geos::geom::Coordinate coord = lil.extractPoint(d);
5728         const GeometryFactory *gf = handle->geomFactory;
5729         Geometry* point = gf->createPoint(coord);
5730         return point;
5731     } catch (const std::exception &e) {
5732         handle->ERROR_MESSAGE("%s", e.what());
5733         return 0;
5734     } catch (...) {
5735         handle->ERROR_MESSAGE("Unknown exception thrown");
5736         return 0;
5737     }
5738 }
5739
5740
5741 double
5742 GEOSProjectNormalized_r(GEOSContextHandle_t extHandle, const Geometry *g,
5743                         const Geometry *p)
5744 {
5745
5746     double length;
5747     GEOSLength_r(extHandle, g, &length);
5748     return GEOSProject_r(extHandle, g, p) / length;
5749 }
5750
5751
5752 Geometry*
5753 GEOSInterpolateNormalized_r(GEOSContextHandle_t extHandle, const Geometry *g,
5754                             double d)
5755 {
5756     double length;
5757     GEOSLength_r(extHandle, g, &length);
5758     return GEOSInterpolate_r(extHandle, g, d * length);
5759 }
5760
5761 GEOSGeometry*
5762 GEOSGeom_extractUniquePoints_r(GEOSContextHandle_t extHandle,
5763                               const GEOSGeometry* g)
5764 {
5765     if ( 0 == extHandle ) return 0;
5766     GEOSContextHandleInternal_t *handle = 0;
5767     handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
5768     if ( handle->initialized == 0 ) return 0;
5769
5770     using namespace geos::geom;
5771     using namespace geos::util;
5772
5773     try
5774     {
5775
5776     /* 1: extract points */
5777     std::vector<const Coordinate*> coords;
5778     UniqueCoordinateArrayFilter filter(coords);
5779     g->apply_ro(&filter);
5780
5781     /* 2: for each point, create a geometry and put into a vector */
5782     std::vector<Geometry*>* points = new std::vector<Geometry*>();
5783     points->reserve(coords.size());
5784     const GeometryFactory* factory = g->getFactory();
5785     for (std::vector<const Coordinate*>::iterator it=coords.begin(),
5786                                              itE=coords.end();
5787                                              it != itE; ++it)
5788     {
5789         Geometry* point = factory->createPoint(*(*it));
5790         points->push_back(point);
5791     }
5792
5793     /* 3: create a multipoint */
5794     return factory->createMultiPoint(points);
5795
5796     }
5797     catch (const std::exception &e)
5798     {
5799         handle->ERROR_MESSAGE("%s", e.what());
5800         return 0;
5801     }
5802     catch (...)
5803     {
5804         handle->ERROR_MESSAGE("Unknown exception thrown");
5805         return 0;
5806     }
5807 }
5808
5809 int GEOSOrientationIndex_r(GEOSContextHandle_t extHandle,
5810         double Ax, double Ay, double Bx, double By, double Px, double Py)
5811 {
5812     GEOSContextHandleInternal_t *handle = 0;
5813
5814     using geos::geom::Coordinate;
5815     using geos::algorithm::CGAlgorithms;
5816
5817     if ( 0 == extHandle )
5818     {
5819         return 2;
5820     }
5821
5822     handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
5823     if ( 0 == handle->initialized )
5824     {
5825         return 2;
5826     }
5827
5828     try
5829     {
5830         Coordinate A(Ax, Ay);
5831         Coordinate B(Bx, By);
5832         Coordinate P(Px, Py);
5833         return CGAlgorithms::orientationIndex(A, B, P);
5834     }
5835     catch (const std::exception &e)
5836     {
5837         handle->ERROR_MESSAGE("%s", e.what());
5838         return 2;
5839     }
5840     catch (...)
5841     {
5842         handle->ERROR_MESSAGE("Unknown exception thrown");
5843         return 2;
5844     }
5845 }
5846
5847 GEOSGeometry *
5848 GEOSSharedPaths_r(GEOSContextHandle_t extHandle, const GEOSGeometry* g1, const GEOSGeometry* g2)
5849 {
5850     using namespace geos::operation::sharedpaths;
5851
5852     if ( 0 == extHandle ) return 0;
5853     GEOSContextHandleInternal_t *handle =
5854       reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
5855     if ( handle->initialized == 0 ) return 0;
5856
5857     SharedPathsOp::PathList forw, back;
5858     try {
5859       SharedPathsOp::sharedPathsOp(*g1, *g2, forw, back);
5860     }
5861     catch (const std::exception &e)
5862     {
5863         SharedPathsOp::clearEdges(forw);
5864         SharedPathsOp::clearEdges(back);
5865         handle->ERROR_MESSAGE("%s", e.what());
5866         return 0;
5867     }
5868     catch (...)
5869     {
5870         SharedPathsOp::clearEdges(forw);
5871         SharedPathsOp::clearEdges(back);
5872         handle->ERROR_MESSAGE("Unknown exception thrown");
5873         return 0;
5874     }
5875
5876     // Now forw and back have the geoms we want to use to construct
5877     // our output GeometryCollections...
5878
5879     const GeometryFactory* factory = g1->getFactory();
5880     size_t count;
5881
5882     std::auto_ptr< std::vector<Geometry*> > out1(
5883       new std::vector<Geometry*>()
5884     );
5885     count = forw.size();
5886     out1->reserve(count);
5887     for (size_t i=0; i<count; ++i) {
5888         out1->push_back(forw[i]);
5889     }
5890     std::auto_ptr<Geometry> out1g (
5891       factory->createMultiLineString(out1.release())
5892     );
5893
5894     std::auto_ptr< std::vector<Geometry*> > out2(
5895       new std::vector<Geometry*>()
5896     );
5897     count = back.size();
5898     out2->reserve(count);
5899     for (size_t i=0; i<count; ++i) {
5900         out2->push_back(back[i]);
5901     }
5902     std::auto_ptr<Geometry> out2g (
5903       factory->createMultiLineString(out2.release())
5904     );
5905
5906     std::auto_ptr< std::vector<Geometry*> > out(
5907       new std::vector<Geometry*>()
5908     );
5909     out->reserve(2);
5910     out->push_back(out1g.release());
5911     out->push_back(out2g.release());
5912
5913     std::auto_ptr<Geometry> outg (
5914       factory->createGeometryCollection(out.release())
5915     );
5916
5917     return outg.release();
5918
5919 }
5920
5921 GEOSGeometry *
5922 GEOSSnap_r(GEOSContextHandle_t extHandle, const GEOSGeometry* g1,
5923            const GEOSGeometry* g2, double tolerance)
5924 {
5925     using namespace geos::operation::overlay::snap;
5926
5927     if ( 0 == extHandle ) return 0;
5928     GEOSContextHandleInternal_t *handle =
5929       reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
5930     if ( handle->initialized == 0 ) return 0;
5931
5932     try{
5933       GeometrySnapper snapper( *g1 );
5934       std::auto_ptr<Geometry> ret = snapper.snapTo(*g2, tolerance);
5935       return ret.release();
5936     }
5937     catch (const std::exception &e)
5938     {
5939         handle->ERROR_MESSAGE("%s", e.what());
5940         return 0;
5941     }
5942     catch (...)
5943     {
5944         handle->ERROR_MESSAGE("Unknown exception thrown");
5945         return 0;
5946     }
5947 }
5948
5949 BufferParameters *
5950 GEOSBufferParams_create_r(GEOSContextHandle_t extHandle)
5951 {
5952     if ( 0 == extHandle ) return NULL;
5953
5954     GEOSContextHandleInternal_t *handle = 0;
5955     handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
5956     if ( 0 == handle->initialized ) return NULL;
5957
5958     try
5959     {
5960         BufferParameters *p = new BufferParameters();
5961         return p;
5962     }
5963     catch (const std::exception &e)
5964     {
5965         handle->ERROR_MESSAGE("%s", e.what());
5966     }
5967     catch (...)
5968     {
5969         handle->ERROR_MESSAGE("Unknown exception thrown");
5970     }
5971
5972     return 0;
5973 }
5974
5975 void
5976 GEOSBufferParams_destroy_r(GEOSContextHandle_t extHandle, BufferParameters* p)
5977 {
5978   (void)extHandle;
5979   delete p;
5980 }
5981
5982 int
5983 GEOSBufferParams_setEndCapStyle_r(GEOSContextHandle_t extHandle,
5984   GEOSBufferParams* p, int style)
5985 {
5986     if ( 0 == extHandle ) return 0;
5987
5988     GEOSContextHandleInternal_t *handle = 0;
5989     handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
5990     if ( 0 == handle->initialized ) return 0;
5991
5992     try
5993     {
5994         if ( style > BufferParameters::CAP_SQUARE )
5995         {
5996                 throw IllegalArgumentException("Invalid buffer endCap style");
5997         }
5998         p->setEndCapStyle(static_cast<BufferParameters::EndCapStyle>(style));
5999         return 1;
6000     }
6001     catch (const std::exception &e)
6002     {
6003         handle->ERROR_MESSAGE("%s", e.what());
6004     }
6005     catch (...)
6006     {
6007         handle->ERROR_MESSAGE("Unknown exception thrown");
6008     }
6009
6010     return 0;
6011 }
6012
6013 int
6014 GEOSBufferParams_setJoinStyle_r(GEOSContextHandle_t extHandle,
6015   GEOSBufferParams* p, int style)
6016 {
6017     if ( 0 == extHandle ) return 0;
6018
6019     GEOSContextHandleInternal_t *handle = 0;
6020     handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
6021     if ( 0 == handle->initialized ) return 0;
6022
6023     try
6024     {
6025         if ( style > BufferParameters::JOIN_BEVEL ) {
6026                 throw IllegalArgumentException("Invalid buffer join style");
6027         }
6028         p->setJoinStyle(static_cast<BufferParameters::JoinStyle>(style));
6029         return 1;
6030     }
6031     catch (const std::exception &e)
6032     {
6033         handle->ERROR_MESSAGE("%s", e.what());
6034     }
6035     catch (...)
6036     {
6037         handle->ERROR_MESSAGE("Unknown exception thrown");
6038     }
6039
6040     return 0;
6041 }
6042
6043 int
6044 GEOSBufferParams_setMitreLimit_r(GEOSContextHandle_t extHandle,
6045   GEOSBufferParams* p, double limit)
6046 {
6047     if ( 0 == extHandle ) return 0;
6048
6049     GEOSContextHandleInternal_t *handle = 0;
6050     handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
6051     if ( 0 == handle->initialized ) return 0;
6052
6053     try
6054     {
6055         p->setMitreLimit(limit);
6056         return 1;
6057     }
6058     catch (const std::exception &e)
6059     {
6060         handle->ERROR_MESSAGE("%s", e.what());
6061     }
6062     catch (...)
6063     {
6064         handle->ERROR_MESSAGE("Unknown exception thrown");
6065     }
6066
6067     return 0;
6068 }
6069
6070 int
6071 GEOSBufferParams_setQuadrantSegments_r(GEOSContextHandle_t extHandle,
6072   GEOSBufferParams* p, int segs)
6073 {
6074     if ( 0 == extHandle ) return 0;
6075
6076     GEOSContextHandleInternal_t *handle = 0;
6077     handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
6078     if ( 0 == handle->initialized ) return 0;
6079
6080     try
6081     {
6082         p->setQuadrantSegments(segs);
6083         return 1;
6084     }
6085     catch (const std::exception &e)
6086     {
6087         handle->ERROR_MESSAGE("%s", e.what());
6088     }
6089     catch (...)
6090     {
6091         handle->ERROR_MESSAGE("Unknown exception thrown");
6092     }
6093
6094     return 0;
6095 }
6096
6097 int
6098 GEOSBufferParams_setSingleSided_r(GEOSContextHandle_t extHandle,
6099   GEOSBufferParams* p, int ss)
6100 {
6101     if ( 0 == extHandle ) return 0;
6102
6103     GEOSContextHandleInternal_t *handle = 0;
6104     handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
6105     if ( 0 == handle->initialized ) return 0;
6106
6107     try
6108     {
6109         p->setSingleSided( (ss != 0) );
6110         return 1;
6111     }
6112     catch (const std::exception &e)
6113     {
6114         handle->ERROR_MESSAGE("%s", e.what());
6115     }
6116     catch (...)
6117     {
6118         handle->ERROR_MESSAGE("Unknown exception thrown");
6119     }
6120
6121     return 0;
6122 }
6123
6124 Geometry *
6125 GEOSBufferWithParams_r(GEOSContextHandle_t extHandle, const Geometry *g1, const BufferParameters* bp, double width)
6126 {
6127     using geos::operation::buffer::BufferOp;
6128
6129     if ( 0 == extHandle ) return NULL;
6130
6131     GEOSContextHandleInternal_t *handle = 0;
6132     handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
6133     if ( 0 == handle->initialized ) return NULL;
6134
6135     try
6136     {
6137         BufferOp op(g1, *bp);
6138         Geometry *g3 = op.getResultGeometry(width);
6139         return g3;
6140     }
6141     catch (const std::exception &e)
6142     {
6143         handle->ERROR_MESSAGE("%s", e.what());
6144     }
6145     catch (...)
6146     {
6147         handle->ERROR_MESSAGE("Unknown exception thrown");
6148     }
6149
6150     return NULL;
6151 }
6152
6153 Geometry *
6154 GEOSDelaunayTriangulation_r(GEOSContextHandle_t extHandle, const Geometry *g1, double tolerance, int onlyEdges)
6155 {
6156     if ( 0 == extHandle ) return NULL;
6157
6158     GEOSContextHandleInternal_t *handle = 0;
6159     handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
6160     if ( 0 == handle->initialized ) return NULL;
6161
6162     using geos::triangulate::DelaunayTriangulationBuilder;
6163
6164     try
6165     {
6166       DelaunayTriangulationBuilder builder;
6167       builder.setTolerance(tolerance);
6168       builder.setSites(*g1);
6169
6170       if ( onlyEdges ) return builder.getEdges( *g1->getFactory() ).release();
6171       else return builder.getTriangles( *g1->getFactory() ).release();
6172
6173     }
6174     catch (const std::exception &e)
6175     {
6176         handle->ERROR_MESSAGE("%s", e.what());
6177     }
6178     catch (...)
6179     {
6180         handle->ERROR_MESSAGE("Unknown exception thrown");
6181     }
6182
6183     return NULL;
6184 }
6185
6186 } /* extern "C" */
6187