capi/geos_ts_c.cpp

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