capi/geos_ts_c.cpp

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