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