capi/geos_ts_c.cpp

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