capi/geos_ts_c.cpp

   1 /************************************************************************
   2  *
   3  * $Id$
   4  *
   5  * C-Wrapper for GEOS library
   6  *
   7  * Copyright (C) 2010 Sandro Santilli <strk@keybit.net>
   8  * Copyright (C) 2005-2006 Refractions Research Inc.
   9  *
  10  * This is free software; you can redistribute and/or modify it under
  11  * the terms of the GNU Lesser General Public Licence as published
  12  * by the Free Software Foundation.
  13  * See the COPYING file for more information.
  14  *
  15  * Author: Sandro Santilli <strk@refractions.net>
  16  *    Thread Safety modifications: Chuck Thibert <charles.thibert@ingres.com>
  17  *
  18  ***********************************************************************/
  19
  20 #include <geos/platform.h>  // for FINITE
  21 #include <geos/geom/Geometry.h>
  22 #include <geos/geom/prep/PreparedGeometry.h>
  23 #include <geos/geom/prep/PreparedGeometryFactory.h>
  24 #include <geos/geom/GeometryCollection.h>
  25 #include <geos/geom/Polygon.h>
  26 #include <geos/geom/Point.h>
  27 #include <geos/geom/MultiPoint.h>
  28 #include <geos/geom/MultiLineString.h>
  29 #include <geos/geom/MultiPolygon.h>
  30 #include <geos/geom/LinearRing.h>
  31 #include <geos/geom/LineString.h>
  32 #include <geos/geom/PrecisionModel.h>
  33 #include <geos/geom/GeometryFactory.h>
  34 #include <geos/geom/CoordinateSequenceFactory.h>
  35 #include <geos/geom/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/simplify/DouglasPeuckerSimplifier.h>
  45 #include <geos/simplify/TopologyPreservingSimplifier.h>
  46 #include <geos/operation/valid/IsValidOp.h>
  47 #include <geos/operation/polygonize/Polygonizer.h>
  48 #include <geos/operation/linemerge/LineMerger.h>
  49 #include <geos/operation/overlay/OverlayOp.h>
  50 #include <geos/operation/union/CascadedPolygonUnion.h>
  51 #include <geos/operation/buffer/BufferOp.h>
  52 #include <geos/operation/buffer/BufferParameters.h>
  53 #include <geos/operation/buffer/BufferBuilder.h>
  54 #include <geos/linearref/LengthIndexedLine.h>
  55 #include <geos/geom/BinaryOp.h>
  56 #include <geos/util/IllegalArgumentException.h>
  57 #include <geos/util/UniqueCoordinateArrayFilter.h>
  58 #include <geos/util/Machine.h>
  59 #include <geos/version.h>
  60
  61 // This should go away
  62 #include <cmath> // finite
  63 #include <cstddef>
  64 #include <cstdio>
  65 #include <cstdlib>
  66 #include <cstring>
  67 #include <fstream>
  68 #include <iostream>
  69 #include <sstream>
  70 #include <string>
  71 #include <memory>
  72
  73 #ifdef _MSC_VER
  74 #pragma warning(disable : 4099)
  75 #endif
  76
  77 // Some extra magic to make type declarations in geos_c.h work -
  78 // for cross-checking of types in header.
  79 #define GEOSGeometry geos::geom::Geometry
  80 #define GEOSPreparedGeometry geos::geom::prep::PreparedGeometry
  81 #define GEOSCoordSequence geos::geom::CoordinateSequence
  82 #define GEOSSTRtree geos::index::strtree::STRtree
  83 #define GEOSWKTReader_t geos::io::WKTReader
  84 #define GEOSWKTWriter_t geos::io::WKTWriter
  85 #define GEOSWKBReader_t geos::io::WKBReader
  86 #define GEOSWKBWriter_t geos::io::WKBWriter
  87
  88 #include "geos_c.h"
  89
  90 // Intentional, to allow non-standard C elements like C99 functions to be
  91 // imported through C++ headers of C library, like <cmath>.
  92 using namespace std;
  93
  94 /// Define this if you want operations triggering Exceptions to
  95 /// be printed.
  96 /// (will use the NOTIFY channel - only implemented for GEOSUnion so far)
  97 ///
  98 #undef VERBOSE_EXCEPTIONS
  99
 100 #include <geos/export.h>
 101
 102
 103 // import the most frequently used definitions globally
 104 using geos::geom::Geometry;
 105 using geos::geom::LineString;
 106 using geos::geom::Polygon;
 107 using geos::geom::CoordinateSequence;
 108 using geos::geom::GeometryFactory;
 109
 110 using geos::io::WKTReader;
 111 using geos::io::WKTWriter;
 112 using geos::io::WKBReader;
 113 using geos::io::WKBWriter;
 114
 115 using geos::operation::overlay::OverlayOp;
 116 using geos::operation::overlay::overlayOp;
 117 using geos::operation::geounion::CascadedPolygonUnion;
 118
 119 using geos::algorithm::distance::DiscreteHausdorffDistance;
 120
 121 typedef std::auto_ptr<Geometry> GeomAutoPtr;
 122
 123 typedef struct GEOSContextHandleInternal
 124 {
 125     const GeometryFactory *geomFactory;
 126     GEOSMessageHandler NOTICE_MESSAGE;
 127     GEOSMessageHandler ERROR_MESSAGE;
 128     int WKBOutputDims;
 129     int WKBByteOrder;
 130     int initialized;
 131 } GEOSContextHandleInternal_t;
 132
 133 // CAPI_ItemVisitor is used internally by the CAPI STRtree
 134 // wrappers. It's defined here just to keep it out of the
 135 // extern "C" block.
 136 class CAPI_ItemVisitor : public geos::index::ItemVisitor {
 137     GEOSQueryCallback callback;
 138     void *userdata;
 139   public:
 140     CAPI_ItemVisitor (GEOSQueryCallback cb, void *ud)
 141         : ItemVisitor(), callback(cb), userdata(ud) {};
 142     void visitItem (void *item) { callback(item, userdata); };
 143 };
 144
 145
 146 //## PROTOTYPES #############################################
 147
 148 extern "C" const char GEOS_DLL *GEOSjtsport();
 149 extern "C" char GEOS_DLL *GEOSasText(Geometry *g1);
 150
 151 extern "C" {
 152
 153 char* gstrdup_s(const char* str, const std::size_t size)
 154 {
 155     char* out = static_cast<char*>(std::malloc(size + 1));
 156     if (0 != out)
 157     {
 158         // as no strlen call necessary, memcpy may be faster than strcpy
 159         std::memcpy(out, str, size + 1);
 160     }
 161
 162     assert(0 != out);
 163     return out;
 164 }
 165
 166 char* gstrdup(std::string const& str)
 167 {
 168     return gstrdup_s(str.c_str(), str.size());
 169 }
 170
 171
 172 GEOSContextHandle_t
 173 initGEOS_r(GEOSMessageHandler nf, GEOSMessageHandler ef)
 174 {
 175     GEOSContextHandleInternal_t *handle = 0;
 176     void *extHandle = 0;
 177
 178     extHandle = std::malloc(sizeof(GEOSContextHandleInternal_t));
 179     if (0 != extHandle)
 180     {
 181         handle = static_cast<GEOSContextHandleInternal_t*>(extHandle);
 182         handle->NOTICE_MESSAGE = nf;
 183         handle->ERROR_MESSAGE = ef;
 184         handle->geomFactory = GeometryFactory::getDefaultInstance();
 185         handle->WKBOutputDims = 2;
 186         handle->WKBByteOrder = getMachineByteOrder();
 187         handle->initialized = 1;
 188     }
 189
 190     return static_cast<GEOSContextHandle_t>(extHandle);
 191 }
 192
 193 GEOSMessageHandler
 194 GEOSContext_setNoticeHandler_r(GEOSContextHandle_t extHandle, GEOSMessageHandler nf)
 195 {
 196     GEOSMessageHandler f;
 197     GEOSContextHandleInternal_t *handle = 0;
 198     handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
 199     if ( 0 == handle->initialized )
 200     {
 201         return NULL;
 202     }
 203
 204     f = handle->NOTICE_MESSAGE;
 205     handle->NOTICE_MESSAGE = nf;
 206
 207     return f;
 208 }
 209
 210 GEOSMessageHandler
 211 GEOSContext_setErrorHandler_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->ERROR_MESSAGE;
 222     handle->ERROR_MESSAGE = nf;
 223
 224     return f;
 225 }
 226
 227 void
 228 finishGEOS_r(GEOSContextHandle_t extHandle)
 229 {
 230     // Fix up freeing handle w.r.t. malloc above
 231     std::free(extHandle);
 232     extHandle = NULL;
 233 }
 234
 235 void
 236 GEOSFree_r (GEOSContextHandle_t extHandle, void* buffer)
 237 {
 238     assert(0 != extHandle);
 239
 240     std::free(buffer);
 241 }
 242
 243 //-----------------------------------------------------------
 244 // relate()-related functions
 245 //  return 0 = false, 1 = true, 2 = error occured
 246 //-----------------------------------------------------------
 247
 248 char
 249 GEOSDisjoint_r(GEOSContextHandle_t extHandle, const Geometry *g1, const Geometry *g2)
 250 {
 251     if ( 0 == extHandle )
 252     {
 253         return 2;
 254     }
 255
 256     GEOSContextHandleInternal_t *handle = 0;
 257     handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
 258     if ( handle->initialized == 0 )
 259     {
 260         return 2;
 261     }
 262
 263     try
 264     {
 265         bool result = g1->disjoint(g2);
 266         return result;
 267     }
 268
 269     // TODO: mloskot is going to replace these double-catch block
 270     // with a macro to remove redundant code in this and
 271     // following functions.
 272     catch (const std::exception &e)
 273     {
 274         handle->ERROR_MESSAGE("%s", e.what());
 275     }
 276     catch (...)
 277     {
 278         handle->ERROR_MESSAGE("Unknown exception thrown");
 279     }
 280
 281     return 2;
 282 }
 283
 284 char
 285 GEOSTouches_r(GEOSContextHandle_t extHandle, const Geometry *g1, const Geometry *g2)
 286 {
 287     if ( 0 == extHandle )
 288     {
 289         return 2;
 290     }
 291
 292     GEOSContextHandleInternal_t *handle = 0;
 293     handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
 294     if ( 0 == handle->initialized )
 295     {
 296         return 2;
 297     }
 298
 299     try
 300     {
 301         bool result = g1->touches(g2);
 302         return result;
 303     }
 304     catch (const std::exception &e)
 305     {
 306         handle->ERROR_MESSAGE("%s", e.what());
 307     }
 308     catch (...)
 309     {
 310         handle->ERROR_MESSAGE("Unknown exception thrown");
 311     }
 312
 313     return 2;
 314 }
 315
 316 char
 317 GEOSIntersects_r(GEOSContextHandle_t extHandle, const Geometry *g1, const Geometry *g2)
 318 {
 319     if ( 0 == extHandle )
 320     {
 321         return 2;
 322     }
 323
 324     GEOSContextHandleInternal_t *handle = 0;
 325     handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
 326     if ( 0 == handle->initialized )
 327     {
 328         return 2;
 329     }
 330
 331     try
 332     {
 333         bool result = g1->intersects(g2);
 334         return result;
 335     }
 336     catch (const std::exception &e)
 337     {
 338         handle->ERROR_MESSAGE("%s", e.what());
 339     }
 340     catch (...)
 341     {
 342         handle->ERROR_MESSAGE("Unknown exception thrown");
 343     }
 344
 345     return 2;
 346 }
 347
 348 char
 349 GEOSCrosses_r(GEOSContextHandle_t extHandle, const Geometry *g1, const Geometry *g2)
 350 {
 351     if ( 0 == extHandle )
 352     {
 353         return 2;
 354     }
 355
 356     GEOSContextHandleInternal_t *handle = 0;
 357     handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
 358     if ( 0 == handle->initialized )
 359     {
 360         return 2;
 361     }
 362
 363     try
 364     {
 365         bool result = g1->crosses(g2);
 366         return result;
 367     }
 368     catch (const std::exception &e)
 369     {
 370         handle->ERROR_MESSAGE("%s", e.what());
 371     }
 372     catch (...)
 373     {
 374         handle->ERROR_MESSAGE("Unknown exception thrown");
 375     }
 376
 377     return 2;
 378 }
 379
 380 char
 381 GEOSWithin_r(GEOSContextHandle_t extHandle, const Geometry *g1, const Geometry *g2)
 382 {
 383     if ( 0 == extHandle )
 384     {
 385         return 2;
 386     }
 387
 388     GEOSContextHandleInternal_t *handle = 0;
 389     handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
 390     if ( 0 == handle->initialized )
 391     {
 392         return 2;
 393     }
 394
 395     try
 396     {
 397         bool result = g1->within(g2);
 398         return result;
 399     }
 400     catch (const std::exception &e)
 401     {
 402         handle->ERROR_MESSAGE("%s", e.what());
 403     }
 404     catch (...)
 405     {
 406         handle->ERROR_MESSAGE("Unknown exception thrown");
 407     }
 408
 409     return 2;
 410 }
 411
 412 // call g1->contains(g2)
 413 // returns 0 = false
 414 //         1 = true
 415 //         2 = error was trapped
 416 char
 417 GEOSContains_r(GEOSContextHandle_t extHandle, const Geometry *g1, const Geometry *g2)
 418 {
 419     if ( 0 == extHandle )
 420     {
 421         return 2;
 422     }
 423
 424     GEOSContextHandleInternal_t *handle = 0;
 425     handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
 426     if ( 0 == handle->initialized )
 427     {
 428         return 2;
 429     }
 430
 431     try
 432     {
 433         bool result = g1->contains(g2);
 434         return result;
 435     }
 436     catch (const std::exception &e)
 437     {
 438         handle->ERROR_MESSAGE("%s", e.what());
 439     }
 440     catch (...)
 441     {
 442         handle->ERROR_MESSAGE("Unknown exception thrown");
 443     }
 444
 445     return 2;
 446 }
 447
 448 char
 449 GEOSOverlaps_r(GEOSContextHandle_t extHandle, const Geometry *g1, const Geometry *g2)
 450 {
 451     if ( 0 == extHandle )
 452     {
 453         return 2;
 454     }
 455
 456     GEOSContextHandleInternal_t *handle = 0;
 457     handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
 458     if ( 0 == handle->initialized )
 459     {
 460         return 2;
 461     }
 462
 463     try
 464     {
 465         bool result = g1->overlaps(g2);
 466         return result;
 467     }
 468     catch (const std::exception &e)
 469     {
 470         handle->ERROR_MESSAGE("%s", e.what());
 471     }
 472     catch (...)
 473     {
 474         handle->ERROR_MESSAGE("Unknown exception thrown");
 475     }
 476
 477     return 2;
 478 }
 479
 480
 481 //-------------------------------------------------------------------
 482 // low-level relate functions
 483 //------------------------------------------------------------------
 484
 485 char
 486 GEOSRelatePattern_r(GEOSContextHandle_t extHandle, const Geometry *g1, const Geometry *g2, const char *pat)
 487 {
 488     if ( 0 == extHandle )
 489     {
 490         return 2;
 491     }
 492
 493     GEOSContextHandleInternal_t *handle = 0;
 494     handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
 495     if ( 0 == handle->initialized )
 496     {
 497         return 2;
 498     }
 499
 500     try
 501     {
 502         std::string s(pat);
 503         bool result = g1->relate(g2, s);
 504         return result;
 505     }
 506     catch (const std::exception &e)
 507     {
 508         handle->ERROR_MESSAGE("%s", e.what());
 509     }
 510     catch (...)
 511     {
 512         handle->ERROR_MESSAGE("Unknown exception thrown");
 513     }
 514
 515     return 2;
 516 }
 517
 518 char *
 519 GEOSRelate_r(GEOSContextHandle_t extHandle, const Geometry *g1, const Geometry *g2)
 520 {
 521     if ( 0 == extHandle )
 522     {
 523         return NULL;
 524     }
 525
 526     GEOSContextHandleInternal_t *handle = 0;
 527     handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
 528     if ( 0 == handle->initialized )
 529     {
 530         return NULL;
 531     }
 532
 533     try
 534     {
 535         using geos::geom::IntersectionMatrix;
 536
 537         IntersectionMatrix* im = g1->relate(g2);
 538         if (0 == im)
 539         {
 540             return 0;
 541         }
 542
 543         char *result = gstrdup(im->toString());
 544
 545         delete im;
 546         im = 0;
 547
 548         return result;
 549     }
 550     catch (const std::exception &e)
 551     {
 552         handle->ERROR_MESSAGE("%s", e.what());
 553     }
 554     catch (...)
 555     {
 556         handle->ERROR_MESSAGE("Unknown exception thrown");
 557     }
 558
 559     return NULL;
 560 }
 561
 562
 563
 564 //-----------------------------------------------------------------
 565 // isValid
 566 //-----------------------------------------------------------------
 567
 568
 569 char
 570 GEOSisValid_r(GEOSContextHandle_t extHandle, const Geometry *g1)
 571 {
 572     if ( 0 == extHandle )
 573     {
 574         return 2;
 575     }
 576
 577     GEOSContextHandleInternal_t *handle = 0;
 578     handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
 579     if ( 0 == handle->initialized )
 580     {
 581         return 2;
 582     }
 583
 584     try
 585     {
 586         using geos::operation::valid::IsValidOp;
 587         using geos::operation::valid::TopologyValidationError;
 588
 589         IsValidOp ivo(g1);
 590         bool valid = ivo.isValid();
 591         if (!valid)
 592         {
 593             TopologyValidationError *err = ivo.getValidationError();
 594             if ( err )
 595             {
 596                 handle->NOTICE_MESSAGE("%s", err->toString().c_str());
 597             }
 598         }
 599         return valid;
 600     }
 601     catch (const std::exception &e)
 602     {
 603         handle->ERROR_MESSAGE("%s", e.what());
 604     }
 605     catch (...)
 606     {
 607         handle->ERROR_MESSAGE("Unknown exception thrown");
 608     }
 609
 610     return 2;
 611 }
 612
 613 char *
 614 GEOSisValidReason_r(GEOSContextHandle_t extHandle, const Geometry *g1)
 615 {
 616     if ( 0 == extHandle )
 617     {
 618         return NULL;
 619     }
 620
 621     GEOSContextHandleInternal_t *handle = 0;
 622     handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
 623     if ( 0 == handle->initialized )
 624     {
 625         return NULL;
 626     }
 627
 628     try
 629     {
 630         using geos::operation::valid::IsValidOp;
 631         using geos::operation::valid::TopologyValidationError;
 632
 633         char* result = 0;
 634         char const* const validstr = "Valid Geometry";
 635
 636         IsValidOp ivo(g1);
 637         bool isvalid = ivo.isValid();
 638         if ( ! isvalid )
 639         {
 640             TopologyValidationError *err = ivo.getValidationError();
 641             if (0 != err)
 642             {
 643                 const std::string errloc = err->getCoordinate().toString();
 644                 std::string errmsg(err->getMessage());
 645                 errmsg += "[" + errloc + "]";
 646                 result = gstrdup(errmsg);
 647             }
 648         }
 649         else
 650         {
 651             result = gstrdup(std::string(validstr));
 652         }
 653
 654         return result;
 655     }
 656     catch (const std::exception &e)
 657     {
 658         handle->ERROR_MESSAGE("%s", e.what());
 659     }
 660     catch (...)
 661     {
 662         handle->ERROR_MESSAGE("Unknown exception thrown");
 663     }
 664
 665     return 0;
 666 }
 667
 668 char
 669 GEOSisValidDetail_r(GEOSContextHandle_t extHandle, const Geometry *g,
 670         char** reason, const Geometry ** location)
 671 {
 672     if ( 0 == extHandle )
 673     {
 674         return 0;
 675     }
 676
 677     GEOSContextHandleInternal_t *handle = 0;
 678     handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
 679     if ( 0 == handle->initialized )
 680     {
 681         return 0;
 682     }
 683
 684     try
 685     {
 686         using geos::operation::valid::IsValidOp;
 687         using geos::operation::valid::TopologyValidationError;
 688
 689         IsValidOp ivo(g);
 690         bool isvalid = ivo.isValid();
 691         if ( ! isvalid )
 692         {
 693             TopologyValidationError *err = ivo.getValidationError();
 694             if (0 != err)
 695             {
 696                 *location = handle->geomFactory->createPoint(err->getCoordinate());
 697                 std::string errmsg(err->getMessage());
 698                 *reason = gstrdup(errmsg);
 699             }
 700             else {
 701                 /* is it ever possible for getValidationError to be 0 ? */
 702             }
 703             return 0; /* invalid */
 704         }
 705
 706         *location = 0;
 707         *reason = 0;
 708         return 1; /* valid */
 709
 710     }
 711     catch (const std::exception &e)
 712     {
 713         handle->ERROR_MESSAGE("%s", e.what());
 714     }
 715     catch (...)
 716     {
 717         handle->ERROR_MESSAGE("Unknown exception thrown");
 718     }
 719
 720     return 2; /* exception */
 721 }
 722
 723 //-----------------------------------------------------------------
 724 // general purpose
 725 //-----------------------------------------------------------------
 726
 727 char
 728 GEOSEquals_r(GEOSContextHandle_t extHandle, const Geometry *g1, const Geometry *g2)
 729 {
 730     if ( 0 == extHandle )
 731     {
 732         return 2;
 733     }
 734
 735     GEOSContextHandleInternal_t *handle = 0;
 736     handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
 737     if ( 0 == handle->initialized )
 738     {
 739         return 2;
 740     }
 741
 742     try
 743     {
 744         bool result = g1->equals(g2);
 745         return result;
 746     }
 747     catch (const std::exception &e)
 748     {
 749         handle->ERROR_MESSAGE("%s", e.what());
 750     }
 751     catch (...)
 752     {
 753         handle->ERROR_MESSAGE("Unknown exception thrown");
 754     }
 755
 756     return 2;
 757 }
 758
 759 char
 760 GEOSEqualsExact_r(GEOSContextHandle_t extHandle, const Geometry *g1, const Geometry *g2, double tolerance)
 761 {
 762     if ( 0 == extHandle )
 763     {
 764         return 2;
 765     }
 766
 767     GEOSContextHandleInternal_t *handle = 0;
 768     handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
 769     if ( 0 == handle->initialized )
 770     {
 771         return 2;
 772     }
 773
 774     try
 775     {
 776         bool result = g1->equalsExact(g2, tolerance);
 777         return result;
 778     }
 779     catch (const std::exception &e)
 780     {
 781         handle->ERROR_MESSAGE("%s", e.what());
 782     }
 783     catch (...)
 784     {
 785         handle->ERROR_MESSAGE("Unknown exception thrown");
 786     }
 787
 788     return 2;
 789 }
 790
 791 int
 792 GEOSDistance_r(GEOSContextHandle_t extHandle, const Geometry *g1, const Geometry *g2, double *dist)
 793 {
 794     assert(0 != dist);
 795
 796     if ( 0 == extHandle )
 797     {
 798         return 0;
 799     }
 800
 801     GEOSContextHandleInternal_t *handle = 0;
 802     handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
 803     if ( 0 == handle->initialized )
 804     {
 805         return 0;
 806     }
 807
 808     try
 809     {
 810         *dist = g1->distance(g2);
 811         return 1;
 812     }
 813     catch (const std::exception &e)
 814     {
 815         handle->ERROR_MESSAGE("%s", e.what());
 816     }
 817     catch (...)
 818     {
 819         handle->ERROR_MESSAGE("Unknown exception thrown");
 820     }
 821
 822     return 0;
 823 }
 824
 825 int
 826 GEOSHausdorffDistance_r(GEOSContextHandle_t extHandle, const Geometry *g1, const Geometry *g2, double *dist)
 827 {
 828     assert(0 != dist);
 829
 830     if ( 0 == extHandle )
 831     {
 832         return 0;
 833     }
 834
 835     GEOSContextHandleInternal_t *handle = 0;
 836     handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
 837     if ( 0 == handle->initialized )
 838     {
 839         return 0;
 840     }
 841
 842     try
 843     {
 844         *dist = DiscreteHausdorffDistance::distance(*g1, *g2);
 845         return 1;
 846     }
 847     catch (const std::exception &e)
 848     {
 849         handle->ERROR_MESSAGE("%s", e.what());
 850     }
 851     catch (...)
 852     {
 853         handle->ERROR_MESSAGE("Unknown exception thrown");
 854     }
 855
 856     return 0;
 857 }
 858
 859 int
 860 GEOSHausdorffDistanceDensify_r(GEOSContextHandle_t extHandle, const Geometry *g1, const Geometry *g2, double densifyFrac, double *dist)
 861 {
 862     assert(0 != dist);
 863
 864     if ( 0 == extHandle )
 865     {
 866         return 0;
 867     }
 868
 869     GEOSContextHandleInternal_t *handle = 0;
 870     handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
 871     if ( 0 == handle->initialized )
 872     {
 873         return 0;
 874     }
 875
 876     try
 877     {
 878         *dist = DiscreteHausdorffDistance::distance(*g1, *g2, densifyFrac);
 879         return 1;
 880     }
 881     catch (const std::exception &e)
 882     {
 883         handle->ERROR_MESSAGE("%s", e.what());
 884     }
 885     catch (...)
 886     {
 887         handle->ERROR_MESSAGE("Unknown exception thrown");
 888     }
 889
 890     return 0;
 891 }
 892
 893 int
 894 GEOSArea_r(GEOSContextHandle_t extHandle, const Geometry *g, double *area)
 895 {
 896     assert(0 != area);
 897
 898     if ( 0 == extHandle )
 899     {
 900         return 0;
 901     }
 902
 903     GEOSContextHandleInternal_t *handle = 0;
 904     handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
 905     if ( 0 == handle->initialized )
 906     {
 907         return 0;
 908     }
 909
 910     try
 911     {
 912         *area = g->getArea();
 913         return 1;
 914     }
 915     catch (const std::exception &e)
 916     {
 917         handle->ERROR_MESSAGE("%s", e.what());
 918     }
 919     catch (...)
 920     {
 921         handle->ERROR_MESSAGE("Unknown exception thrown");
 922     }
 923
 924     return 0;
 925 }
 926
 927 int
 928 GEOSLength_r(GEOSContextHandle_t extHandle, const Geometry *g, double *length)
 929 {
 930     assert(0 != length);
 931
 932     if ( 0 == extHandle )
 933     {
 934         return 2;
 935     }
 936
 937     GEOSContextHandleInternal_t *handle = 0;
 938     handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
 939     if ( 0 == handle->initialized )
 940     {
 941         return 0;
 942     }
 943
 944     try
 945     {
 946         *length = g->getLength();
 947         return 1;
 948     }
 949     catch (const std::exception &e)
 950     {
 951         handle->ERROR_MESSAGE("%s", e.what());
 952     }
 953     catch (...)
 954     {
 955         handle->ERROR_MESSAGE("Unknown exception thrown");
 956     }
 957
 958     return 0;
 959 }
 960
 961 Geometry *
 962 GEOSGeomFromWKT_r(GEOSContextHandle_t extHandle, const char *wkt)
 963 {
 964     if ( 0 == extHandle )
 965     {
 966         return NULL;
 967     }
 968
 969     GEOSContextHandleInternal_t *handle = 0;
 970     handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
 971     if ( 0 == handle->initialized )
 972     {
 973         return NULL;
 974     }
 975
 976     try
 977     {
 978         const std::string wktstring(wkt);
 979         WKTReader r(static_cast<GeometryFactory const*>(handle->geomFactory));
 980
 981         Geometry *g = r.read(wktstring);
 982         return g;
 983     }
 984     catch (const std::exception &e)
 985     {
 986         handle->ERROR_MESSAGE("%s", e.what());
 987     }
 988     catch (...)
 989     {
 990         handle->ERROR_MESSAGE("Unknown exception thrown");
 991     }
 992
 993     return NULL;
 994 }
 995
 996 char *
 997 GEOSGeomToWKT_r(GEOSContextHandle_t extHandle, const Geometry *g1)
 998 {
 999     if ( 0 == extHandle )
1000     {
1001         return NULL;
1002     }
1003
1004     GEOSContextHandleInternal_t *handle = 0;
1005     handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
1006     if ( 0 == handle->initialized )
1007     {
1008         return NULL;
1009     }
1010
1011     try
1012     {
1013
1014         char *result = gstrdup(g1->toString());
1015         return result;
1016     }
1017     catch (const std::exception &e)
1018     {
1019         handle->ERROR_MESSAGE("%s", e.what());
1020     }
1021     catch (...)
1022     {
1023         handle->ERROR_MESSAGE("Unknown exception thrown");
1024     }
1025     return NULL;
1026 }
1027
1028 // Remember to free the result!
1029 unsigned char *
1030 GEOSGeomToWKB_buf_r(GEOSContextHandle_t extHandle, const Geometry *g, size_t *size)
1031 {
1032     assert(0 != size);
1033
1034     if ( 0 == extHandle )
1035     {
1036         return NULL;
1037     }
1038
1039     GEOSContextHandleInternal_t *handle = 0;
1040     handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
1041     if ( 0 == handle->initialized )
1042     {
1043         return NULL;
1044     }
1045
1046     using geos::io::WKBWriter;
1047     try
1048     {
1049         int byteOrder = static_cast<int>(handle->WKBByteOrder);
1050         WKBWriter w(handle->WKBOutputDims, byteOrder);
1051         std::ostringstream os(std::ios_base::binary);
1052         w.write(*g, os);
1053         std::string wkbstring(os.str());
1054         const std::size_t len = wkbstring.length();
1055
1056         unsigned char* result = 0;
1057         result = static_cast<unsigned char*>(std::malloc(len));
1058         if (0 != result)
1059         {
1060             std::memcpy(result, wkbstring.c_str(), len);
1061             *size = len;
1062         }
1063         return result;
1064     }
1065     catch (const std::exception &e)
1066     {
1067         handle->ERROR_MESSAGE("%s", e.what());
1068     }
1069     catch (...)
1070     {
1071         handle->ERROR_MESSAGE("Unknown exception thrown");
1072     }
1073
1074     return NULL;
1075 }
1076
1077 Geometry *
1078 GEOSGeomFromWKB_buf_r(GEOSContextHandle_t extHandle, const unsigned char *wkb, size_t size)
1079 {
1080     if ( 0 == extHandle )
1081     {
1082         return NULL;
1083     }
1084
1085     GEOSContextHandleInternal_t *handle = 0;
1086     handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
1087     if ( 0 == handle->initialized )
1088     {
1089         return NULL;
1090     }
1091
1092     using geos::io::WKBReader;
1093     try
1094     {
1095         std::string wkbstring(reinterpret_cast<const char*>(wkb), size); // make it binary !
1096         WKBReader r(*(static_cast<GeometryFactory const*>(handle->geomFactory)));
1097         std::istringstream is(std::ios_base::binary);
1098         is.str(wkbstring);
1099         is.seekg(0, std::ios::beg); // rewind reader pointer
1100         Geometry *g = r.read(is);
1101         return g;
1102     }
1103     catch (const std::exception &e)
1104     {
1105         handle->ERROR_MESSAGE("%s", e.what());
1106     }
1107     catch (...)
1108     {
1109         handle->ERROR_MESSAGE("Unknown exception thrown");
1110     }
1111
1112     return NULL;
1113 }
1114
1115 /* Read/write wkb hex values.  Returned geometries are
1116    owned by the caller.*/
1117 unsigned char *
1118 GEOSGeomToHEX_buf_r(GEOSContextHandle_t extHandle, const Geometry *g, size_t *size)
1119 {
1120     if ( 0 == extHandle )
1121     {
1122         return NULL;
1123     }
1124
1125     GEOSContextHandleInternal_t *handle = 0;
1126     handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
1127     if ( 0 == handle->initialized )
1128     {
1129         return NULL;
1130     }
1131
1132     using geos::io::WKBWriter;
1133     try
1134     {
1135         int byteOrder = static_cast<int>(handle->WKBByteOrder);
1136         WKBWriter w(handle->WKBOutputDims, byteOrder);
1137         std::ostringstream os(std::ios_base::binary);
1138         w.writeHEX(*g, os);
1139         std::string hexstring(os.str());
1140
1141         char *result = gstrdup(hexstring);
1142         if (0 != result)
1143         {
1144             *size = hexstring.length();
1145         }
1146
1147         return reinterpret_cast<unsigned char*>(result);
1148     }
1149     catch (const std::exception &e)
1150     {
1151         handle->ERROR_MESSAGE("%s", e.what());
1152     }
1153     catch (...)
1154     {
1155         handle->ERROR_MESSAGE("Unknown exception thrown");
1156     }
1157
1158     return NULL;
1159 }
1160
1161 Geometry *
1162 GEOSGeomFromHEX_buf_r(GEOSContextHandle_t extHandle, const unsigned char *hex, size_t size)
1163 {
1164     if ( 0 == extHandle )
1165     {
1166         return NULL;
1167     }
1168
1169     GEOSContextHandleInternal_t *handle = 0;
1170     handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
1171     if ( 0 == handle->initialized )
1172     {
1173         return NULL;
1174     }
1175
1176     using geos::io::WKBReader;
1177     try
1178     {
1179         std::string hexstring(reinterpret_cast<const char*>(hex), size);
1180         WKBReader r(*(static_cast<GeometryFactory const*>(handle->geomFactory)));
1181         std::istringstream is(std::ios_base::binary);
1182         is.str(hexstring);
1183         is.seekg(0, std::ios::beg); // rewind reader pointer
1184
1185         Geometry *g = r.readHEX(is);
1186         return g;
1187     }
1188     catch (const std::exception &e)
1189     {
1190         handle->ERROR_MESSAGE("%s", e.what());
1191     }
1192     catch (...)
1193     {
1194         handle->ERROR_MESSAGE("Unknown exception thrown");
1195     }
1196
1197     return NULL;
1198 }
1199
1200 char
1201 GEOSisEmpty_r(GEOSContextHandle_t extHandle, const Geometry *g1)
1202 {
1203     if ( 0 == extHandle )
1204     {
1205         return 2;
1206     }
1207
1208     GEOSContextHandleInternal_t *handle = 0;
1209     handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
1210     if ( 0 == handle->initialized )
1211     {
1212         return 2;
1213     }
1214
1215     try
1216     {
1217         return g1->isEmpty();
1218     }
1219     catch (const std::exception &e)
1220     {
1221         handle->ERROR_MESSAGE("%s", e.what());
1222     }
1223     catch (...)
1224     {
1225         handle->ERROR_MESSAGE("Unknown exception thrown");
1226     }
1227
1228     return 2;
1229 }
1230
1231 char
1232 GEOSisSimple_r(GEOSContextHandle_t extHandle, const Geometry *g1)
1233 {
1234     if ( 0 == extHandle )
1235     {
1236         return 2;
1237     }
1238
1239     GEOSContextHandleInternal_t *handle = 0;
1240     handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
1241     if ( 0 == handle->initialized )
1242     {
1243         return 2;
1244     }
1245
1246     try
1247     {
1248         return g1->isSimple();
1249     }
1250     catch (const std::exception &e)
1251     {
1252         handle->ERROR_MESSAGE("%s", e.what());
1253         return 2;
1254     }
1255
1256     catch (...)
1257     {
1258         handle->ERROR_MESSAGE("Unknown exception thrown");
1259         return 2;
1260     }
1261 }
1262
1263 char
1264 GEOSisRing_r(GEOSContextHandle_t extHandle, const Geometry *g)
1265 {
1266     if ( 0 == extHandle )
1267     {
1268         return 2;
1269     }
1270
1271     GEOSContextHandleInternal_t *handle = 0;
1272     handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
1273     if ( 0 == handle->initialized )
1274     {
1275         return 2;
1276     }
1277
1278     try
1279     {
1280         const LineString *ls = dynamic_cast<const LineString *>(g);
1281         if ( ls ) {
1282             return (ls->isRing());
1283         } else {
1284             return 0;
1285         }
1286     }
1287     catch (const std::exception &e)
1288     {
1289         handle->ERROR_MESSAGE("%s", e.what());
1290         return 2;
1291     }
1292
1293     catch (...)
1294     {
1295         handle->ERROR_MESSAGE("Unknown exception thrown");
1296         return 2;
1297     }
1298 }
1299
1300
1301
1302 //free the result of this
1303 char *
1304 GEOSGeomType_r(GEOSContextHandle_t extHandle, const Geometry *g1)
1305 {
1306     if ( 0 == extHandle )
1307     {
1308         return NULL;
1309     }
1310
1311     GEOSContextHandleInternal_t *handle = 0;
1312     handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
1313     if ( 0 == handle->initialized )
1314     {
1315         return NULL;
1316     }
1317
1318     try
1319     {
1320         std::string s = g1->getGeometryType();
1321
1322         char *result = gstrdup(s);
1323         return result;
1324     }
1325     catch (const std::exception &e)
1326     {
1327         handle->ERROR_MESSAGE("%s", e.what());
1328     }
1329     catch (...)
1330     {
1331         handle->ERROR_MESSAGE("Unknown exception thrown");
1332     }
1333
1334     return NULL;
1335 }
1336
1337 // Return postgis geometry type index
1338 int
1339 GEOSGeomTypeId_r(GEOSContextHandle_t extHandle, const Geometry *g1)
1340 {
1341     if ( 0 == extHandle )
1342     {
1343         return -1;
1344     }
1345
1346     GEOSContextHandleInternal_t *handle = 0;
1347     handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
1348     if ( 0 == handle->initialized )
1349     {
1350         return -1;
1351     }
1352
1353     try
1354     {
1355         return g1->getGeometryTypeId();
1356     }
1357     catch (const std::exception &e)
1358     {
1359         handle->ERROR_MESSAGE("%s", e.what());
1360     }
1361     catch (...)
1362     {
1363         handle->ERROR_MESSAGE("Unknown exception thrown");
1364     }
1365
1366     return -1;
1367 }
1368
1369 //-------------------------------------------------------------------
1370 // GEOS functions that return geometries
1371 //-------------------------------------------------------------------
1372
1373 Geometry *
1374 GEOSEnvelope_r(GEOSContextHandle_t extHandle, const Geometry *g1)
1375 {
1376     if ( 0 == extHandle )
1377     {
1378         return NULL;
1379     }
1380
1381     GEOSContextHandleInternal_t *handle = 0;
1382     handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
1383     if ( 0 == handle->initialized )
1384     {
1385         return NULL;
1386     }
1387
1388     try
1389     {
1390         Geometry *g3 = g1->getEnvelope();
1391         return g3;
1392     }
1393     catch (const std::exception &e)
1394     {
1395         handle->ERROR_MESSAGE("%s", e.what());
1396     }
1397     catch (...)
1398     {
1399         handle->ERROR_MESSAGE("Unknown exception thrown");
1400     }
1401
1402     return NULL;
1403 }
1404
1405 Geometry *
1406 GEOSIntersection_r(GEOSContextHandle_t extHandle, const Geometry *g1, const Geometry *g2)
1407 {
1408     if ( 0 == extHandle )
1409     {
1410         return NULL;
1411     }
1412
1413     GEOSContextHandleInternal_t *handle = 0;
1414     handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
1415     if ( 0 == handle->initialized )
1416     {
1417         return NULL;
1418     }
1419
1420     try
1421     {
1422         GeomAutoPtr g3(BinaryOp(g1, g2, overlayOp(OverlayOp::opINTERSECTION)));
1423         return g3.release();
1424
1425         // XXX: old version
1426         //Geometry *g3 = g1->intersection(g2);
1427         //return g3;
1428     }
1429     catch (const std::exception &e)
1430     {
1431         handle->ERROR_MESSAGE("%s", e.what());
1432     }
1433     catch (...)
1434     {
1435         handle->ERROR_MESSAGE("Unknown exception thrown");
1436     }
1437
1438     return NULL;
1439 }
1440
1441 Geometry *
1442 GEOSBuffer_r(GEOSContextHandle_t extHandle, const Geometry *g1, double width, int quadrantsegments)
1443 {
1444     if ( 0 == extHandle )
1445     {
1446         return NULL;
1447     }
1448
1449     GEOSContextHandleInternal_t *handle = 0;
1450     handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
1451     if ( 0 == handle->initialized )
1452     {
1453         return NULL;
1454     }
1455
1456     try
1457     {
1458         Geometry *g3 = g1->buffer(width, quadrantsegments);
1459         return g3;
1460     }
1461     catch (const std::exception &e)
1462     {
1463         handle->ERROR_MESSAGE("%s", e.what());
1464     }
1465     catch (...)
1466     {
1467         handle->ERROR_MESSAGE("Unknown exception thrown");
1468     }
1469
1470     return NULL;
1471 }
1472
1473 Geometry *
1474 GEOSBufferWithStyle_r(GEOSContextHandle_t extHandle, const Geometry *g1, double width, int quadsegs, int endCapStyle, int joinStyle, double mitreLimit)
1475 {
1476     using geos::operation::buffer::BufferParameters;
1477     using geos::operation::buffer::BufferOp;
1478     using geos::util::IllegalArgumentException;
1479
1480     if ( 0 == extHandle )
1481     {
1482         return NULL;
1483     }
1484
1485     GEOSContextHandleInternal_t *handle = 0;
1486     handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
1487     if ( 0 == handle->initialized )
1488     {
1489         return NULL;
1490     }
1491
1492     try
1493     {
1494         BufferParameters bp;
1495         bp.setQuadrantSegments(quadsegs);
1496
1497         if ( endCapStyle > BufferParameters::CAP_SQUARE )
1498         {
1499                 throw IllegalArgumentException("Invalid buffer endCap style");
1500         }
1501         bp.setEndCapStyle(
1502                 static_cast<BufferParameters::EndCapStyle>(endCapStyle)
1503         );
1504
1505         if ( joinStyle > BufferParameters::JOIN_BEVEL )
1506         {
1507                 throw IllegalArgumentException("Invalid buffer join style");
1508         }
1509         bp.setJoinStyle(
1510                 static_cast<BufferParameters::JoinStyle>(joinStyle)
1511         );
1512         bp.setMitreLimit(mitreLimit);
1513         BufferOp op(g1, bp);
1514         Geometry *g3 = op.getResultGeometry(width);
1515         return g3;
1516     }
1517     catch (const std::exception &e)
1518     {
1519         handle->ERROR_MESSAGE("%s", e.what());
1520     }
1521     catch (...)
1522     {
1523         handle->ERROR_MESSAGE("Unknown exception thrown");
1524     }
1525
1526     return NULL;
1527 }
1528
1529 Geometry *
1530 GEOSSingleSidedBuffer_r(GEOSContextHandle_t extHandle, const Geometry *g1, double width, int quadsegs, int joinStyle, double mitreLimit, int leftSide)
1531 {
1532     using geos::operation::buffer::BufferParameters;
1533     using geos::operation::buffer::BufferBuilder;
1534     using geos::operation::buffer::BufferOp;
1535     using geos::util::IllegalArgumentException;
1536
1537     if ( 0 == extHandle )
1538     {
1539         return NULL;
1540     }
1541
1542     GEOSContextHandleInternal_t *handle = 0;
1543     handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
1544     if ( 0 == handle->initialized )
1545     {
1546         return NULL;
1547     }
1548
1549     try
1550     {
1551         BufferParameters bp;
1552         bp.setEndCapStyle( BufferParameters::CAP_FLAT );
1553         bp.setQuadrantSegments(quadsegs);
1554
1555         if ( joinStyle > BufferParameters::JOIN_BEVEL )
1556         {
1557             throw IllegalArgumentException("Invalid buffer join style");
1558         }
1559         bp.setJoinStyle(
1560             static_cast<BufferParameters::JoinStyle>(joinStyle)
1561             );
1562         bp.setMitreLimit(mitreLimit);
1563
1564         bool isLeftSide = leftSide == 0 ? false : true;
1565         BufferBuilder bufBuilder (bp);
1566         Geometry *g3 = bufBuilder.bufferLineSingleSided(g1, width, isLeftSide);
1567
1568         return g3;
1569     }
1570     catch (const std::exception &e)
1571     {
1572         handle->ERROR_MESSAGE("%s", e.what());
1573     }
1574     catch (...)
1575     {
1576         handle->ERROR_MESSAGE("Unknown exception thrown");
1577     }
1578
1579     return NULL;
1580 }
1581
1582 Geometry *
1583 GEOSConvexHull_r(GEOSContextHandle_t extHandle, const Geometry *g1)
1584 {
1585     if ( 0 == extHandle )
1586     {
1587         return NULL;
1588     }
1589
1590     GEOSContextHandleInternal_t *handle = 0;
1591     handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
1592     if ( 0 == handle->initialized )
1593     {
1594         return NULL;
1595     }
1596
1597     try
1598     {
1599         Geometry *g3 = g1->convexHull();
1600         return g3;
1601     }
1602     catch (const std::exception &e)
1603     {
1604         handle->ERROR_MESSAGE("%s", e.what());
1605     }
1606     catch (...)
1607     {
1608         handle->ERROR_MESSAGE("Unknown exception thrown");
1609     }
1610
1611     return NULL;
1612 }
1613
1614 Geometry *
1615 GEOSDifference_r(GEOSContextHandle_t extHandle, const Geometry *g1, const Geometry *g2)
1616 {
1617     if ( 0 == extHandle )
1618     {
1619         return NULL;
1620     }
1621
1622     GEOSContextHandleInternal_t *handle = 0;
1623     handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
1624     if ( 0 == handle->initialized )
1625     {
1626         return NULL;
1627     }
1628
1629     try
1630     {
1631         GeomAutoPtr g3(BinaryOp(g1, g2, overlayOp(OverlayOp::opDIFFERENCE)));
1632         return g3.release();
1633
1634         // XXX: old version
1635         //Geometry *g3 = g1->difference(g2);
1636         //return g3;
1637     }
1638     catch (const std::exception &e)
1639     {
1640         handle->ERROR_MESSAGE("%s", e.what());
1641     }
1642     catch (...)
1643     {
1644         handle->ERROR_MESSAGE("Unknown exception thrown");
1645     }
1646
1647     return NULL;
1648 }
1649
1650 Geometry *
1651 GEOSBoundary_r(GEOSContextHandle_t extHandle, const Geometry *g1)
1652 {
1653     if ( 0 == extHandle )
1654     {
1655         return NULL;
1656     }
1657
1658     GEOSContextHandleInternal_t *handle = 0;
1659     handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
1660     if ( 0 == handle->initialized )
1661     {
1662         return NULL;
1663     }
1664
1665     try
1666     {
1667         Geometry *g3 = g1->getBoundary();
1668         return g3;
1669     }
1670     catch (const std::exception &e)
1671     {
1672         handle->ERROR_MESSAGE("%s", e.what());
1673     }
1674     catch (...)
1675     {
1676         handle->ERROR_MESSAGE("Unknown exception thrown");
1677     }
1678
1679     return NULL;
1680 }
1681
1682 Geometry *
1683 GEOSSymDifference_r(GEOSContextHandle_t extHandle, const Geometry *g1, const Geometry *g2)
1684 {
1685     if ( 0 == extHandle )
1686     {
1687         return NULL;
1688     }
1689
1690     GEOSContextHandleInternal_t *handle = 0;
1691     handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
1692     if ( 0 == handle->initialized )
1693     {
1694         return NULL;
1695     }
1696
1697     try
1698     {
1699         GeomAutoPtr g3 = BinaryOp(g1, g2, overlayOp(OverlayOp::opSYMDIFFERENCE));
1700         return g3.release();
1701         //Geometry *g3 = g1->symDifference(g2);
1702         //return g3;
1703     }
1704     catch (const std::exception &e)
1705     {
1706         handle->ERROR_MESSAGE("%s", e.what());
1707         return NULL;
1708     }
1709
1710     catch (...)
1711     {
1712         handle->ERROR_MESSAGE("Unknown exception thrown");
1713         return NULL;
1714     }
1715 }
1716
1717 Geometry *
1718 GEOSUnion_r(GEOSContextHandle_t extHandle, const Geometry *g1, const Geometry *g2)
1719 {
1720     if ( 0 == extHandle )
1721     {
1722         return NULL;
1723     }
1724
1725     GEOSContextHandleInternal_t *handle = 0;
1726     handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
1727     if ( 0 == handle->initialized )
1728     {
1729         return NULL;
1730     }
1731
1732     try
1733     {
1734         GeomAutoPtr g3 = BinaryOp(g1, g2, overlayOp(OverlayOp::opUNION));
1735         return g3.release();
1736
1737         // XXX: old version
1738         //Geometry *g3 = g1->Union(g2);
1739         //return g3;
1740     }
1741     catch (const std::exception &e)
1742     {
1743 #if VERBOSE_EXCEPTIONS
1744         std::ostringstream s;
1745         s << "Exception on GEOSUnion with following inputs:" << std::endl;
1746         s << "A: "<<g1->toString() << std::endl;
1747         s << "B: "<<g2->toString() << std::endl;
1748         handle->NOTICE_MESSAGE("%s", s.str().c_str());
1749 #endif // VERBOSE_EXCEPTIONS
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 Geometry *
1761 GEOSUnionCascaded_r(GEOSContextHandle_t extHandle, const Geometry *g1)
1762 {
1763     if ( 0 == extHandle )
1764     {
1765         return NULL;
1766     }
1767
1768     GEOSContextHandleInternal_t *handle = 0;
1769     handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
1770     if ( 0 == handle->initialized )
1771     {
1772         return NULL;
1773     }
1774
1775     try
1776     {
1777         const geos::geom::MultiPolygon *p = dynamic_cast<const geos::geom::MultiPolygon *>(g1);
1778         if ( ! p )
1779         {
1780             handle->ERROR_MESSAGE("Invalid argument (must be a MultiPolygon)");
1781             return NULL;
1782         }
1783
1784         using geos::operation::geounion::CascadedPolygonUnion;
1785         return CascadedPolygonUnion::Union(p);
1786     }
1787     catch (const std::exception &e)
1788     {
1789         handle->ERROR_MESSAGE("%s", e.what());
1790     }
1791     catch (...)
1792     {
1793         handle->ERROR_MESSAGE("Unknown exception thrown");
1794     }
1795
1796     return NULL;
1797 }
1798
1799 Geometry *
1800 GEOSPointOnSurface_r(GEOSContextHandle_t extHandle, const Geometry *g1)
1801 {
1802     if ( 0 == extHandle )
1803     {
1804         return NULL;
1805     }
1806
1807     GEOSContextHandleInternal_t *handle = 0;
1808     handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
1809     if ( 0 == handle->initialized )
1810     {
1811         return NULL;
1812     }
1813
1814     try
1815     {
1816         Geometry *ret = g1->getInteriorPoint();
1817         if ( ! ret )
1818         {
1819             const GeometryFactory* gf = handle->geomFactory;
1820             // return an empty collection
1821             return gf->createGeometryCollection();
1822         }
1823         return ret;
1824     }
1825     catch (const std::exception &e)
1826     {
1827         handle->ERROR_MESSAGE("%s", e.what());
1828     }
1829     catch (...)
1830     {
1831         handle->ERROR_MESSAGE("Unknown exception thrown");
1832     }
1833
1834     return NULL;
1835 }
1836
1837 //-------------------------------------------------------------------
1838 // memory management functions
1839 //------------------------------------------------------------------
1840
1841 void
1842 GEOSGeom_destroy_r(GEOSContextHandle_t extHandle, Geometry *a)
1843 {
1844     GEOSContextHandleInternal_t *handle = 0;
1845
1846     // FIXME: mloskot: Does this try-catch around delete means that
1847     // destructors in GEOS may throw? If it does, this is a serious
1848     // violation of "never throw an exception from a destructor" principle
1849
1850     try
1851     {
1852         delete a;
1853     }
1854     catch (const std::exception &e)
1855     {
1856         if ( 0 == extHandle )
1857         {
1858             return;
1859         }
1860
1861         handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
1862         if ( 0 == handle->initialized )
1863         {
1864             return;
1865         }
1866
1867         handle->ERROR_MESSAGE("%s", e.what());
1868     }
1869     catch (...)
1870     {
1871         if ( 0 == extHandle )
1872         {
1873             return;
1874         }
1875
1876         handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
1877         if ( 0 == handle->initialized )
1878         {
1879             return;
1880         }
1881
1882         handle->ERROR_MESSAGE("Unknown exception thrown");
1883     }
1884 }
1885
1886 void
1887 GEOSSetSRID_r(GEOSContextHandle_t extHandle, Geometry *g, int srid)
1888 {
1889     assert(0 != g);
1890
1891     if ( 0 == extHandle )
1892     {
1893         return;
1894     }
1895
1896     GEOSContextHandleInternal_t *handle = 0;
1897     handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
1898     if ( 0 == handle->initialized )
1899     {
1900         return;
1901     }
1902
1903     g->setSRID(srid);
1904 }
1905
1906
1907 int
1908 GEOSGetNumCoordinates_r(GEOSContextHandle_t extHandle, const Geometry *g)
1909 {
1910     assert(0 != g);
1911
1912     if ( 0 == extHandle )
1913     {
1914         return -1;
1915     }
1916
1917     GEOSContextHandleInternal_t *handle = 0;
1918     handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
1919     if ( 0 == handle->initialized )
1920     {
1921         return -1;
1922     }
1923
1924     try
1925     {
1926         return static_cast<int>(g->getNumPoints());
1927     }
1928     catch (const std::exception &e)
1929     {
1930         handle->ERROR_MESSAGE("%s", e.what());
1931     }
1932     catch (...)
1933     {
1934         handle->ERROR_MESSAGE("Unknown exception thrown");
1935     }
1936
1937     return -1;
1938 }
1939
1940 /*
1941  * Return -1 on exception, 0 otherwise.
1942  * Converts Geometry to normal form (or canonical form).
1943  */
1944 int
1945 GEOSNormalize_r(GEOSContextHandle_t extHandle, Geometry *g)
1946 {
1947     assert(0 != g);
1948
1949     if ( 0 == extHandle )
1950     {
1951         return -1;
1952     }
1953
1954     GEOSContextHandleInternal_t *handle = 0;
1955     handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
1956     if ( 0 == handle->initialized )
1957     {
1958         return -1;
1959     }
1960
1961     try
1962     {
1963         g->normalize();
1964         return 0; // SUCCESS
1965     }
1966     catch (const std::exception &e)
1967     {
1968         handle->ERROR_MESSAGE("%s", e.what());
1969     }
1970     catch (...)
1971     {
1972         handle->ERROR_MESSAGE("Unknown exception thrown");
1973     }
1974
1975     return -1;
1976 }
1977
1978 int
1979 GEOSGetNumInteriorRings_r(GEOSContextHandle_t extHandle, const Geometry *g1)
1980 {
1981     if ( 0 == extHandle )
1982     {
1983         return -1;
1984     }
1985
1986     GEOSContextHandleInternal_t *handle = 0;
1987     handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
1988     if ( 0 == handle->initialized )
1989     {
1990         return -1;
1991     }
1992
1993     try
1994     {
1995         const Polygon *p = dynamic_cast<const Polygon *>(g1);
1996         if ( ! p )
1997         {
1998             handle->ERROR_MESSAGE("Argument is not a Polygon");
1999             return -1;
2000         }
2001         return static_cast<int>(p->getNumInteriorRing());
2002     }
2003     catch (const std::exception &e)
2004     {
2005         handle->ERROR_MESSAGE("%s", e.what());
2006     }
2007     catch (...)
2008     {
2009         handle->ERROR_MESSAGE("Unknown exception thrown");
2010     }
2011
2012     return -1;
2013 }
2014
2015
2016 // returns -1 on error and 1 for non-multi geometries
2017 int
2018 GEOSGetNumGeometries_r(GEOSContextHandle_t extHandle, const Geometry *g1)
2019 {
2020     if ( 0 == extHandle )
2021     {
2022         return -1;
2023     }
2024
2025     GEOSContextHandleInternal_t *handle = 0;
2026     handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
2027     if ( 0 == handle->initialized )
2028     {
2029         return -1;
2030     }
2031
2032     try
2033     {
2034         return static_cast<int>(g1->getNumGeometries());
2035     }
2036     catch (const std::exception &e)
2037     {
2038         handle->ERROR_MESSAGE("%s", e.what());
2039     }
2040     catch (...)
2041     {
2042         handle->ERROR_MESSAGE("Unknown exception thrown");
2043     }
2044
2045     return -1;
2046 }
2047
2048
2049 /*
2050  * Call only on GEOMETRYCOLLECTION or MULTI*.
2051  * Return a pointer to the internal Geometry.
2052  */
2053 const Geometry *
2054 GEOSGetGeometryN_r(GEOSContextHandle_t extHandle, const Geometry *g1, int n)
2055 {
2056     if ( 0 == extHandle )
2057     {
2058         return NULL;
2059     }
2060
2061     GEOSContextHandleInternal_t *handle = 0;
2062     handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
2063     if ( 0 == handle->initialized )
2064     {
2065         return NULL;
2066     }
2067
2068     try
2069     {
2070         using geos::geom::GeometryCollection;
2071         const GeometryCollection *gc = dynamic_cast<const GeometryCollection *>(g1);
2072         if ( ! gc )
2073         {
2074             handle->ERROR_MESSAGE("Argument is not a GeometryCollection");
2075             return NULL;
2076         }
2077         return gc->getGeometryN(n);
2078     }
2079     catch (const std::exception &e)
2080     {
2081         handle->ERROR_MESSAGE("%s", e.what());
2082     }
2083     catch (...)
2084     {
2085         handle->ERROR_MESSAGE("Unknown exception thrown");
2086     }
2087
2088     return NULL;
2089 }
2090
2091
2092 /*
2093  * Call only on polygon
2094  * Return a copy of the internal Geometry.
2095  */
2096 const Geometry *
2097 GEOSGetExteriorRing_r(GEOSContextHandle_t extHandle, const Geometry *g1)
2098 {
2099     if ( 0 == extHandle )
2100     {
2101         return NULL;
2102     }
2103
2104     GEOSContextHandleInternal_t *handle = 0;
2105     handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
2106     if ( 0 == handle->initialized )
2107     {
2108         return NULL;
2109     }
2110
2111     try
2112     {
2113         const Polygon *p = dynamic_cast<const Polygon *>(g1);
2114         if ( ! p )
2115         {
2116             handle->ERROR_MESSAGE("Invalid argument (must be a Polygon)");
2117             return NULL;
2118         }
2119         return p->getExteriorRing();
2120     }
2121     catch (const std::exception &e)
2122     {
2123         handle->ERROR_MESSAGE("%s", e.what());
2124     }
2125     catch (...)
2126     {
2127         handle->ERROR_MESSAGE("Unknown exception thrown");
2128     }
2129
2130     return NULL;
2131 }
2132
2133 /*
2134  * Call only on polygon
2135  * Return a pointer to internal storage, do not destroy it.
2136  */
2137 const Geometry *
2138 GEOSGetInteriorRingN_r(GEOSContextHandle_t extHandle, const Geometry *g1, int n)
2139 {
2140     if ( 0 == extHandle )
2141     {
2142         return NULL;
2143     }
2144
2145     GEOSContextHandleInternal_t *handle = 0;
2146     handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
2147     if ( 0 == handle->initialized )
2148     {
2149         return NULL;
2150     }
2151
2152     try
2153     {
2154         const Polygon *p = dynamic_cast<const Polygon *>(g1);
2155         if ( ! p )
2156         {
2157             handle->ERROR_MESSAGE("Invalid argument (must be a Polygon)");
2158             return NULL;
2159         }
2160         return p->getInteriorRingN(n);
2161     }
2162     catch (const std::exception &e)
2163     {
2164         handle->ERROR_MESSAGE("%s", e.what());
2165     }
2166     catch (...)
2167     {
2168         handle->ERROR_MESSAGE("Unknown exception thrown");
2169     }
2170
2171     return NULL;
2172 }
2173
2174 Geometry *
2175 GEOSGetCentroid_r(GEOSContextHandle_t extHandle, const Geometry *g)
2176 {
2177     if ( 0 == extHandle )
2178     {
2179         return NULL;
2180     }
2181
2182     GEOSContextHandleInternal_t *handle = 0;
2183     handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
2184     if ( 0 == handle->initialized )
2185     {
2186         return NULL;
2187     }
2188
2189     try
2190     {
2191         Geometry *ret = g->getCentroid();
2192         if (0 == ret)
2193         {
2194             const GeometryFactory *gf = handle->geomFactory;
2195             return gf->createGeometryCollection();
2196         }
2197         return ret;
2198     }
2199     catch (const std::exception &e)
2200     {
2201         handle->ERROR_MESSAGE("%s", e.what());
2202     }
2203     catch (...)
2204     {
2205         handle->ERROR_MESSAGE("Unknown exception thrown");
2206     }
2207
2208     return NULL;
2209 }
2210
2211 Geometry *
2212 GEOSGeom_createEmptyCollection_r(GEOSContextHandle_t extHandle, int type)
2213 {
2214     if ( 0 == extHandle )
2215     {
2216         return NULL;
2217     }
2218
2219     GEOSContextHandleInternal_t *handle = 0;
2220     handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
2221     if ( 0 == handle->initialized )
2222     {
2223         return NULL;
2224     }
2225
2226 #ifdef GEOS_DEBUG
2227     char buf[256];
2228     sprintf(buf, "createCollection: requested type %d, ngeoms: %d",
2229             type, ngeoms);
2230     handle->NOTICE_MESSAGE("%s", buf);// TODO: Can handle->NOTICE_MESSAGE format that directly?
2231 #endif
2232
2233     try
2234     {
2235         const GeometryFactory* gf = handle->geomFactory;
2236
2237         Geometry *g = 0;
2238         switch (type)
2239         {
2240             case GEOS_GEOMETRYCOLLECTION:
2241                 g = gf->createGeometryCollection();
2242                 break;
2243             case GEOS_MULTIPOINT:
2244                 g = gf->createMultiPoint();
2245                 break;
2246             case GEOS_MULTILINESTRING:
2247                 g = gf->createMultiLineString();
2248                 break;
2249             case GEOS_MULTIPOLYGON:
2250                 g = gf->createMultiPolygon();
2251                 break;
2252             default:
2253                 handle->ERROR_MESSAGE("Unsupported type request for GEOSGeom_createEmptyCollection_r");
2254                 g = 0;
2255
2256         }
2257
2258         return g;
2259     }
2260     catch (const std::exception &e)
2261     {
2262         handle->ERROR_MESSAGE("%s", e.what());
2263     }
2264     catch (...)
2265     {
2266         handle->ERROR_MESSAGE("Unknown exception thrown");
2267     }
2268
2269     return 0;
2270 }
2271
2272 Geometry *
2273 GEOSGeom_createCollection_r(GEOSContextHandle_t extHandle, int type, Geometry **geoms, unsigned int ngeoms)
2274 {
2275     if ( 0 == extHandle )
2276     {
2277         return NULL;
2278     }
2279
2280     GEOSContextHandleInternal_t *handle = 0;
2281     handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
2282     if ( 0 == handle->initialized )
2283     {
2284         return NULL;
2285     }
2286
2287 #ifdef GEOS_DEBUG
2288     char buf[256];
2289     sprintf(buf, "PostGIS2GEOS_collection: requested type %d, ngeoms: %d",
2290             type, ngeoms);
2291     handle->NOTICE_MESSAGE("%s", buf);// TODO: Can handle->NOTICE_MESSAGE format that directly?
2292 #endif
2293
2294     try
2295     {
2296         const GeometryFactory* gf = handle->geomFactory;
2297         std::vector<Geometry*>* vgeoms = new std::vector<Geometry*>(geoms, geoms + ngeoms);
2298
2299         Geometry *g = 0;
2300         switch (type)
2301         {
2302             case GEOS_GEOMETRYCOLLECTION:
2303                 g = gf->createGeometryCollection(vgeoms);
2304                 break;
2305             case GEOS_MULTIPOINT:
2306                 g = gf->createMultiPoint(vgeoms);
2307                 break;
2308             case GEOS_MULTILINESTRING:
2309                 g = gf->createMultiLineString(vgeoms);
2310                 break;
2311             case GEOS_MULTIPOLYGON:
2312                 g = gf->createMultiPolygon(vgeoms);
2313                 break;
2314             default:
2315                 handle->ERROR_MESSAGE("Unsupported type request for PostGIS2GEOS_collection");
2316                 g = 0;
2317
2318         }
2319
2320         return g;
2321     }
2322     catch (const std::exception &e)
2323     {
2324         handle->ERROR_MESSAGE("%s", e.what());
2325     }
2326     catch (...)
2327     {
2328         handle->ERROR_MESSAGE("Unknown exception thrown");
2329     }
2330
2331     return 0;
2332 }
2333
2334 Geometry *
2335 GEOSPolygonize_r(GEOSContextHandle_t extHandle, const Geometry * const * g, unsigned int ngeoms)
2336 {
2337     if ( 0 == extHandle )
2338     {
2339         return 0;
2340     }
2341
2342     GEOSContextHandleInternal_t *handle = 0;
2343     handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
2344     if ( 0 == handle->initialized )
2345     {
2346         return 0;
2347     }
2348
2349     Geometry *out = 0;
2350
2351     try
2352     {
2353         // Polygonize
2354         using geos::operation::polygonize::Polygonizer;
2355         Polygonizer plgnzr;
2356         for (std::size_t i = 0; i < ngeoms; ++i)
2357         {
2358             plgnzr.add(g[i]);
2359         }
2360
2361 #if GEOS_DEBUG
2362         handle->NOTICE_MESSAGE("geometry vector added to polygonizer");
2363 #endif
2364
2365         std::vector<Polygon*> *polys = plgnzr.getPolygons();
2366         assert(0 != polys);
2367
2368 #if GEOS_DEBUG
2369         handle->NOTICE_MESSAGE("output polygons got");
2370 #endif
2371
2372         // We need a vector of Geometry pointers, not Polygon pointers.
2373         // STL vector doesn't allow transparent upcast of this
2374         // nature, so we explicitly convert.
2375         // (it's just a waste of processor and memory, btw)
2376         //
2377         // XXX mloskot: Why not to extent GeometryFactory to accept
2378         // vector of polygons or extend Polygonizer to return list of Geometry*
2379         // or add a wrapper which semantic is similar to:
2380         // std::vector<as_polygon<Geometry*> >
2381         std::vector<Geometry*> *polyvec = new std::vector<Geometry *>(polys->size());
2382
2383         for (std::size_t i = 0; i < polys->size(); ++i)
2384         {
2385             (*polyvec)[i] = (*polys)[i];
2386         }
2387         delete polys;
2388         polys = 0;
2389
2390         const GeometryFactory *gf = handle->geomFactory;
2391
2392         // The below takes ownership of the passed vector,
2393         // so we must *not* delete it
2394         out = gf->createGeometryCollection(polyvec);
2395     }
2396     catch (const std::exception &e)
2397     {
2398         handle->ERROR_MESSAGE("%s", e.what());
2399     }
2400     catch (...)
2401     {
2402         handle->ERROR_MESSAGE("Unknown exception thrown");
2403     }
2404
2405     return out;
2406 }
2407
2408 Geometry *
2409 GEOSPolygonizer_getCutEdges_r(GEOSContextHandle_t extHandle, const Geometry * const * g, unsigned int ngeoms)
2410 {
2411     if ( 0 == extHandle )
2412     {
2413         return 0;
2414     }
2415
2416     GEOSContextHandleInternal_t *handle = 0;
2417     handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
2418     if ( 0 == handle->initialized )
2419     {
2420         return 0;
2421     }
2422
2423     Geometry *out = 0;
2424
2425     try
2426     {
2427         // Polygonize
2428         using geos::operation::polygonize::Polygonizer;
2429         Polygonizer plgnzr;
2430         for (std::size_t i = 0; i < ngeoms; ++i)
2431         {
2432             plgnzr.add(g[i]);
2433         }
2434
2435 #if GEOS_DEBUG
2436         handle->NOTICE_MESSAGE("geometry vector added to polygonizer");
2437 #endif
2438
2439         std::vector<const LineString *>* lines = plgnzr.getCutEdges();
2440         assert(0 != lines);
2441
2442 #if GEOS_DEBUG
2443         handle->NOTICE_MESSAGE("output polygons got");
2444 #endif
2445
2446         // We need a vector of Geometry pointers, not Polygon pointers.
2447         // STL vector doesn't allow transparent upcast of this
2448         // nature, so we explicitly convert.
2449         // (it's just a waste of processor and memory, btw)
2450         // XXX mloskot: See comment for GEOSPolygonize_r
2451         std::vector<Geometry*> *linevec = new std::vector<Geometry *>(lines->size());
2452
2453         for (std::size_t i = 0; i < lines->size(); ++i)
2454         {
2455             (*linevec)[i] = (*lines)[i]->clone();
2456         }
2457         // FIXME mloskot: Who deallocates vector pointed by lines* ?
2458
2459         const GeometryFactory *gf = handle->geomFactory;
2460
2461         // The below takes ownership of the passed vector,
2462         // so we must *not* delete it
2463         out = gf->createGeometryCollection(linevec);
2464     }
2465     catch (const std::exception &e)
2466     {
2467         handle->ERROR_MESSAGE("%s", e.what());
2468     }
2469     catch (...)
2470     {
2471         handle->ERROR_MESSAGE("Unknown exception thrown");
2472     }
2473
2474     return out;
2475 }
2476
2477 Geometry *
2478 GEOSLineMerge_r(GEOSContextHandle_t extHandle, const Geometry *g)
2479 {
2480     if ( 0 == extHandle )
2481     {
2482         return 0;
2483     }
2484
2485     GEOSContextHandleInternal_t *handle = 0;
2486     handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
2487     if ( 0 == handle->initialized )
2488     {
2489         return 0;
2490     }
2491
2492     Geometry *out = 0;
2493
2494     try
2495     {
2496         using geos::operation::linemerge::LineMerger;
2497         LineMerger lmrgr;
2498         lmrgr.add(g);
2499
2500         std::vector<LineString *>* lines = lmrgr.getMergedLineStrings();
2501         assert(0 != lines);
2502
2503 #if GEOS_DEBUG
2504         handle->NOTICE_MESSAGE("output lines got");
2505 #endif
2506
2507         std::vector<Geometry *>*geoms = new std::vector<Geometry *>(lines->size());
2508         for (std::vector<Geometry *>::size_type i = 0; i < lines->size(); ++i)
2509         {
2510             (*geoms)[i] = (*lines)[i];
2511         }
2512         delete lines;
2513         lines = 0;
2514
2515         const GeometryFactory *gf = handle->geomFactory;
2516         out = gf->buildGeometry(geoms);
2517
2518         // XXX: old version
2519         //out = gf->createGeometryCollection(geoms);
2520     }
2521     catch (const std::exception &e)
2522     {
2523         handle->ERROR_MESSAGE("%s", e.what());
2524     }
2525     catch (...)
2526     {
2527         handle->ERROR_MESSAGE("Unknown exception thrown");
2528     }
2529
2530     return out;
2531 }
2532
2533 int
2534 GEOSGetSRID_r(GEOSContextHandle_t extHandle, const Geometry *g)
2535 {
2536     assert(0 != g);
2537
2538     if ( 0 == extHandle )
2539     {
2540         return 0;
2541     }
2542
2543     GEOSContextHandleInternal_t *handle = 0;
2544     handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
2545     if ( 0 == handle->initialized )
2546     {
2547         return 0;
2548     }
2549
2550     try
2551     {
2552         return g->getSRID();
2553     }
2554     catch (const std::exception &e)
2555     {
2556         handle->ERROR_MESSAGE("%s", e.what());
2557     }
2558     catch (...)
2559     {
2560         handle->ERROR_MESSAGE("Unknown exception thrown");
2561     }
2562
2563     return 0;
2564 }
2565
2566 const char* GEOSversion()
2567 {
2568     return GEOS_CAPI_VERSION;
2569 }
2570
2571 const char* GEOSjtsport()
2572 {
2573     return GEOS_JTS_PORT;
2574 }
2575
2576 char
2577 GEOSHasZ_r(GEOSContextHandle_t extHandle, const Geometry *g)
2578 {
2579     assert(0 != g);
2580
2581     if ( 0 == extHandle )
2582     {
2583         return -1;
2584     }
2585
2586     GEOSContextHandleInternal_t *handle = 0;
2587     handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
2588     if ( 0 == handle->initialized )
2589     {
2590         return -1;
2591     }
2592
2593     if (g->isEmpty())
2594     {
2595         return false;
2596     }
2597     assert(0 != g->getCoordinate());
2598
2599     double az = g->getCoordinate()->z;
2600     //handle->ERROR_MESSAGE("ZCoord: %g", az);
2601
2602     return static_cast<char>(FINITE(az));
2603 }
2604
2605 int
2606 GEOS_getWKBOutputDims_r(GEOSContextHandle_t extHandle)
2607 {
2608     if ( 0 == extHandle )
2609     {
2610         return -1;
2611     }
2612
2613     GEOSContextHandleInternal_t *handle = 0;
2614     handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
2615     if ( 0 == handle->initialized )
2616     {
2617         return -1;
2618     }
2619
2620     return handle->WKBOutputDims;
2621 }
2622
2623 int
2624 GEOS_setWKBOutputDims_r(GEOSContextHandle_t extHandle, int newdims)
2625 {
2626     if ( 0 == extHandle )
2627     {
2628         return -1;
2629     }
2630
2631     GEOSContextHandleInternal_t *handle = 0;
2632     handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
2633     if ( 0 == handle->initialized )
2634     {
2635         return -1;
2636     }
2637
2638     if ( newdims < 2 || newdims > 3 )
2639     {
2640         handle->ERROR_MESSAGE("WKB output dimensions out of range 2..3");
2641     }
2642
2643     const int olddims = handle->WKBOutputDims;
2644     handle->WKBOutputDims = newdims;
2645
2646     return olddims;
2647 }
2648
2649 int
2650 GEOS_getWKBByteOrder_r(GEOSContextHandle_t extHandle)
2651 {
2652     if ( 0 == extHandle )
2653     {
2654         return -1;
2655     }
2656
2657     GEOSContextHandleInternal_t *handle = 0;
2658     handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
2659     if ( 0 == handle->initialized )
2660     {
2661         return -1;
2662     }
2663
2664     return handle->WKBByteOrder;
2665 }
2666
2667 int
2668 GEOS_setWKBByteOrder_r(GEOSContextHandle_t extHandle, int byteOrder)
2669 {
2670     if ( 0 == extHandle )
2671     {
2672         return -1;
2673     }
2674
2675     GEOSContextHandleInternal_t *handle = 0;
2676     handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
2677     if ( 0 == handle->initialized )
2678     {
2679         return -1;
2680     }
2681
2682     const int oldByteOrder = handle->WKBByteOrder;
2683     handle->WKBByteOrder = byteOrder;
2684
2685     return oldByteOrder;
2686 }
2687
2688
2689 CoordinateSequence *
2690 GEOSCoordSeq_create_r(GEOSContextHandle_t extHandle, unsigned int size, unsigned int dims)
2691 {
2692     if ( 0 == extHandle )
2693     {
2694         return NULL;
2695     }
2696
2697     GEOSContextHandleInternal_t *handle = 0;
2698     handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
2699     if ( 0 == handle->initialized )
2700     {
2701         return NULL;
2702     }
2703
2704     try
2705     {
2706         const GeometryFactory *gf = handle->geomFactory;
2707         return gf->getCoordinateSequenceFactory()->create(size, dims);
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 int
2722 GEOSCoordSeq_setOrdinate_r(GEOSContextHandle_t extHandle, CoordinateSequence *cs,
2723                            unsigned int idx, unsigned int dim, double val)
2724 {
2725     assert(0 != cs);
2726     if ( 0 == extHandle )
2727     {
2728         return 0;
2729     }
2730
2731     GEOSContextHandleInternal_t *handle = 0;
2732     handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
2733     if ( 0 == handle->initialized )
2734     {
2735         return 0;
2736     }
2737
2738     try
2739     {
2740         cs->setOrdinate(static_cast<int>(idx), static_cast<int>(dim), val);
2741         return 1;
2742     }
2743     catch (const std::exception &e)
2744     {
2745         handle->ERROR_MESSAGE("%s", e.what());
2746     }
2747     catch (...)
2748     {
2749         handle->ERROR_MESSAGE("Unknown exception thrown");
2750     }
2751
2752     return 0;
2753 }
2754
2755 int
2756 GEOSCoordSeq_setX_r(GEOSContextHandle_t extHandle, CoordinateSequence *s, unsigned int idx, double val)
2757 {
2758     return GEOSCoordSeq_setOrdinate_r(extHandle, s, idx, 0, val);
2759 }
2760
2761 int
2762 GEOSCoordSeq_setY_r(GEOSContextHandle_t extHandle, CoordinateSequence *s, unsigned int idx, double val)
2763 {
2764     return GEOSCoordSeq_setOrdinate_r(extHandle, s, idx, 1, val);
2765 }
2766
2767 int
2768 GEOSCoordSeq_setZ_r(GEOSContextHandle_t extHandle, CoordinateSequence *s, unsigned int idx, double val)
2769 {
2770     return GEOSCoordSeq_setOrdinate_r(extHandle, s, idx, 2, val);
2771 }
2772
2773 CoordinateSequence *
2774 GEOSCoordSeq_clone_r(GEOSContextHandle_t extHandle, const CoordinateSequence *cs)
2775 {
2776     assert(0 != cs);
2777
2778     if ( 0 == extHandle )
2779     {
2780         return NULL;
2781     }
2782
2783     GEOSContextHandleInternal_t *handle = 0;
2784     handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
2785     if ( 0 == handle->initialized )
2786     {
2787         return NULL;
2788     }
2789
2790     try
2791     {
2792         return cs->clone();
2793     }
2794     catch (const std::exception &e)
2795     {
2796         handle->ERROR_MESSAGE("%s", e.what());
2797     }
2798     catch (...)
2799     {
2800         handle->ERROR_MESSAGE("Unknown exception thrown");
2801     }
2802
2803     return NULL;
2804 }
2805
2806 int
2807 GEOSCoordSeq_getOrdinate_r(GEOSContextHandle_t extHandle, const CoordinateSequence *cs,
2808                            unsigned int idx, unsigned int dim, double *val)
2809 {
2810     assert(0 != cs);
2811     assert(0 != val);
2812
2813     if ( 0 == extHandle )
2814     {
2815         return 0;
2816     }
2817
2818     GEOSContextHandleInternal_t *handle = 0;
2819     handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
2820     if ( 0 == handle->initialized )
2821     {
2822         return 0;
2823     }
2824
2825     try
2826     {
2827         double d = cs->getOrdinate(static_cast<int>(idx), static_cast<int>(dim));
2828         *val = d;
2829
2830         return 1;
2831     }
2832     catch (const std::exception &e)
2833     {
2834         handle->ERROR_MESSAGE("%s", e.what());
2835     }
2836     catch (...)
2837     {
2838         handle->ERROR_MESSAGE("Unknown exception thrown");
2839     }
2840
2841     return 0;
2842 }
2843
2844 int
2845 GEOSCoordSeq_getX_r(GEOSContextHandle_t extHandle, const CoordinateSequence *s, unsigned int idx, double *val)
2846 {
2847     return GEOSCoordSeq_getOrdinate_r(extHandle, s, idx, 0, val);
2848 }
2849
2850 int
2851 GEOSCoordSeq_getY_r(GEOSContextHandle_t extHandle, const CoordinateSequence *s, unsigned int idx, double *val)
2852 {
2853     return GEOSCoordSeq_getOrdinate_r(extHandle, s, idx, 1, val);
2854 }
2855
2856 int
2857 GEOSCoordSeq_getZ_r(GEOSContextHandle_t extHandle, const CoordinateSequence *s, unsigned int idx, double *val)
2858 {
2859     return GEOSCoordSeq_getOrdinate_r(extHandle, s, idx, 2, val);
2860 }
2861
2862 int
2863 GEOSCoordSeq_getSize_r(GEOSContextHandle_t extHandle, const CoordinateSequence *cs, unsigned int *size)
2864 {
2865     assert(0 != cs);
2866     assert(0 != size);
2867
2868     if ( 0 == extHandle )
2869     {
2870         return 0;
2871     }
2872
2873     GEOSContextHandleInternal_t *handle = 0;
2874     handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
2875     if ( 0 == handle->initialized )
2876     {
2877         return 0;
2878     }
2879
2880     try
2881     {
2882         const std::size_t sz = cs->getSize();
2883         *size = static_cast<unsigned int>(sz);
2884         return 1;
2885     }
2886     catch (const std::exception &e)
2887     {
2888         handle->ERROR_MESSAGE("%s", e.what());
2889     }
2890     catch (...)
2891     {
2892         handle->ERROR_MESSAGE("Unknown exception thrown");
2893     }
2894
2895     return 0;
2896 }
2897
2898 int
2899 GEOSCoordSeq_getDimensions_r(GEOSContextHandle_t extHandle, const CoordinateSequence *cs, unsigned int *dims)
2900 {
2901     assert(0 != cs);
2902     assert(0 != dims);
2903
2904     if ( 0 == extHandle )
2905     {
2906         return 0;
2907     }
2908
2909     GEOSContextHandleInternal_t *handle = 0;
2910     handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
2911     if ( 0 == handle->initialized )
2912     {
2913         return 0;
2914     }
2915
2916     try
2917     {
2918         const std::size_t dim = cs->getDimension();
2919         *dims = static_cast<unsigned int>(dim);
2920
2921         return 1;
2922     }
2923     catch (const std::exception &e)
2924     {
2925         handle->ERROR_MESSAGE("%s", e.what());
2926     }
2927
2928     catch (...)
2929     {
2930         handle->ERROR_MESSAGE("Unknown exception thrown");
2931     }
2932
2933     return 0;
2934 }
2935
2936 void
2937 GEOSCoordSeq_destroy_r(GEOSContextHandle_t extHandle, CoordinateSequence *s)
2938 {
2939     GEOSContextHandleInternal_t *handle = 0;
2940
2941     try
2942     {
2943         delete s;
2944     }
2945     catch (const std::exception &e)
2946     {
2947         if ( 0 == extHandle )
2948         {
2949             return;
2950         }
2951
2952         handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
2953         if ( 0 == handle->initialized )
2954         {
2955             return;
2956         }
2957
2958         handle->ERROR_MESSAGE("%s", e.what());
2959     }
2960     catch (...)
2961     {
2962         if ( 0 == extHandle )
2963         {
2964             return;
2965         }
2966
2967         handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
2968         if ( 0 == handle->initialized )
2969         {
2970             return;
2971         }
2972
2973         handle->ERROR_MESSAGE("Unknown exception thrown");
2974     }
2975 }
2976
2977 const CoordinateSequence *
2978 GEOSGeom_getCoordSeq_r(GEOSContextHandle_t extHandle, const Geometry *g)
2979 {
2980     if ( 0 == extHandle )
2981     {
2982         return 0;
2983     }
2984
2985     GEOSContextHandleInternal_t *handle = 0;
2986     handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
2987     if ( 0 == handle->initialized )
2988     {
2989         return 0;
2990     }
2991
2992     try
2993     {
2994         using geos::geom::Point;
2995
2996         const LineString *ls = dynamic_cast<const LineString *>(g);
2997         if ( ls )
2998         {
2999             return ls->getCoordinatesRO();
3000         }
3001
3002         const Point *p = dynamic_cast<const Point *>(g);
3003         if ( p )
3004         {
3005             return p->getCoordinatesRO();
3006         }
3007
3008         handle->ERROR_MESSAGE("Geometry must be a Point or LineString");
3009         return 0;
3010     }
3011     catch (const std::exception &e)
3012     {
3013         handle->ERROR_MESSAGE("%s", e.what());
3014     }
3015     catch (...)
3016     {
3017         handle->ERROR_MESSAGE("Unknown exception thrown");
3018     }
3019
3020     return 0;
3021 }
3022
3023 Geometry *
3024 GEOSGeom_createEmptyPoint_r(GEOSContextHandle_t extHandle)
3025 {
3026     if ( 0 == extHandle )
3027     {
3028         return NULL;
3029     }
3030
3031     GEOSContextHandleInternal_t *handle = 0;
3032     handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
3033     if ( 0 == handle->initialized )
3034     {
3035         return NULL;
3036     }
3037
3038     try
3039     {
3040         const GeometryFactory *gf = handle->geomFactory;
3041         return gf->createPoint();
3042     }
3043     catch (const std::exception &e)
3044     {
3045         handle->ERROR_MESSAGE("%s", e.what());
3046     }
3047     catch (...)
3048     {
3049         handle->ERROR_MESSAGE("Unknown exception thrown");
3050     }
3051
3052     return NULL;
3053 }
3054
3055 Geometry *
3056 GEOSGeom_createPoint_r(GEOSContextHandle_t extHandle, CoordinateSequence *cs)
3057 {
3058     if ( 0 == extHandle )
3059     {
3060         return 0;
3061     }
3062
3063     GEOSContextHandleInternal_t *handle = 0;
3064     handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
3065     if ( 0 == handle->initialized )
3066     {
3067         return 0;
3068     }
3069
3070     try
3071     {
3072         const GeometryFactory *gf = handle->geomFactory;
3073         return gf->createPoint(cs);
3074     }
3075     catch (const std::exception &e)
3076     {
3077         handle->ERROR_MESSAGE("%s", e.what());
3078     }
3079     catch (...)
3080     {
3081         handle->ERROR_MESSAGE("Unknown exception thrown");
3082     }
3083
3084     return 0;
3085 }
3086
3087 Geometry *
3088 GEOSGeom_createLinearRing_r(GEOSContextHandle_t extHandle, CoordinateSequence *cs)
3089 {
3090     if ( 0 == extHandle )
3091     {
3092         return NULL;
3093     }
3094
3095     GEOSContextHandleInternal_t *handle = 0;
3096     handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
3097     if ( 0 == handle->initialized )
3098     {
3099         return NULL;
3100     }
3101
3102     try
3103     {
3104         const GeometryFactory *gf = handle->geomFactory;
3105
3106         return gf->createLinearRing(cs);
3107     }
3108     catch (const std::exception &e)
3109     {
3110         handle->ERROR_MESSAGE("%s", e.what());
3111     }
3112     catch (...)
3113     {
3114         handle->ERROR_MESSAGE("Unknown exception thrown");
3115     }
3116
3117     return NULL;
3118 }
3119
3120 Geometry *
3121 GEOSGeom_createEmptyLineString_r(GEOSContextHandle_t extHandle)
3122 {
3123     if ( 0 == extHandle )
3124     {
3125         return NULL;
3126     }
3127
3128     GEOSContextHandleInternal_t *handle = 0;
3129     handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
3130     if ( 0 == handle->initialized )
3131     {
3132         return NULL;
3133     }
3134
3135     try
3136     {
3137         const GeometryFactory *gf = handle->geomFactory;
3138
3139         return gf->createLineString();
3140     }
3141     catch (const std::exception &e)
3142     {
3143         handle->ERROR_MESSAGE("%s", e.what());
3144     }
3145     catch (...)
3146     {
3147         handle->ERROR_MESSAGE("Unknown exception thrown");
3148     }
3149
3150     return NULL;
3151 }
3152
3153 Geometry *
3154 GEOSGeom_createLineString_r(GEOSContextHandle_t extHandle, CoordinateSequence *cs)
3155 {
3156     if ( 0 == extHandle )
3157     {
3158         return NULL;
3159     }
3160
3161     GEOSContextHandleInternal_t *handle = 0;
3162     handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
3163     if ( 0 == handle->initialized )
3164     {
3165         return NULL;
3166     }
3167
3168     try
3169     {
3170         const GeometryFactory *gf = handle->geomFactory;
3171
3172         return gf->createLineString(cs);
3173     }
3174     catch (const std::exception &e)
3175     {
3176         handle->ERROR_MESSAGE("%s", e.what());
3177     }
3178     catch (...)
3179     {
3180         handle->ERROR_MESSAGE("Unknown exception thrown");
3181     }
3182
3183     return NULL;
3184 }
3185
3186 Geometry *
3187 GEOSGeom_createEmptyPolygon_r(GEOSContextHandle_t extHandle)
3188 {
3189     if ( 0 == extHandle )
3190     {
3191         return NULL;
3192     }
3193
3194     GEOSContextHandleInternal_t *handle = 0;
3195     handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
3196     if ( 0 == handle->initialized )
3197     {
3198         return NULL;
3199     }
3200
3201     try
3202     {
3203         const GeometryFactory *gf = handle->geomFactory;
3204         return gf->createPolygon();
3205     }
3206     catch (const std::exception &e)
3207     {
3208         handle->ERROR_MESSAGE("%s", e.what());
3209     }
3210     catch (...)
3211     {
3212         handle->ERROR_MESSAGE("Unknown exception thrown");
3213     }
3214
3215     return NULL;
3216 }
3217
3218 Geometry *
3219 GEOSGeom_createPolygon_r(GEOSContextHandle_t extHandle, Geometry *shell, Geometry **holes, unsigned int nholes)
3220 {
3221     // FIXME: holes must be non-nullptr or may be nullptr?
3222     //assert(0 != holes);
3223
3224     if ( 0 == extHandle )
3225     {
3226         return NULL;
3227     }
3228
3229     GEOSContextHandleInternal_t *handle = 0;
3230     handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
3231     if ( 0 == handle->initialized )
3232     {
3233         return NULL;
3234     }
3235
3236     try
3237     {
3238         using geos::geom::LinearRing;
3239
3240         std::vector<Geometry *> *vholes = new std::vector<Geometry *>(holes, holes + nholes);
3241
3242         LinearRing *nshell = dynamic_cast<LinearRing *>(shell);
3243         if ( ! nshell )
3244         {
3245             handle->ERROR_MESSAGE("Shell is not a LinearRing");
3246             return NULL;
3247         }
3248         const GeometryFactory *gf = handle->geomFactory;
3249
3250         return gf->createPolygon(nshell, vholes);
3251     }
3252     catch (const std::exception &e)
3253     {
3254         handle->ERROR_MESSAGE("%s", e.what());
3255     }
3256     catch (...)
3257     {
3258         handle->ERROR_MESSAGE("Unknown exception thrown");
3259     }
3260
3261     return NULL;
3262 }
3263
3264 Geometry *
3265 GEOSGeom_clone_r(GEOSContextHandle_t extHandle, const Geometry *g)
3266 {
3267     assert(0 != g);
3268
3269     if ( 0 == extHandle )
3270     {
3271         return NULL;
3272     }
3273
3274     GEOSContextHandleInternal_t *handle = 0;
3275     handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
3276     if ( 0 == handle->initialized )
3277     {
3278         return NULL;
3279     }
3280
3281     try
3282     {
3283         return g->clone();
3284     }
3285     catch (const std::exception &e)
3286     {
3287         handle->ERROR_MESSAGE("%s", e.what());
3288     }
3289     catch (...)
3290     {
3291         handle->ERROR_MESSAGE("Unknown exception thrown");
3292     }
3293
3294     return NULL;
3295 }
3296
3297 int
3298 GEOSGeom_getDimensions_r(GEOSContextHandle_t extHandle, const Geometry *g)
3299 {
3300     if ( 0 == extHandle )
3301     {
3302         return 0;
3303     }
3304
3305     GEOSContextHandleInternal_t *handle = 0;
3306     handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
3307     if ( 0 == handle->initialized )
3308     {
3309         return 0;
3310     }
3311
3312     try
3313     {
3314         using geos::geom::Point;
3315         using geos::geom::GeometryCollection;
3316
3317         if ( g->isEmpty() )
3318         {
3319                 return 0;
3320         }
3321
3322         std::size_t dim = 0;
3323         const LineString *ls = dynamic_cast<const LineString *>(g);
3324         if ( ls )
3325         {
3326             dim = ls->getCoordinatesRO()->getDimension();
3327             return static_cast<int>(dim);
3328         }
3329
3330         const Point *p = dynamic_cast<const Point *>(g);
3331         if ( p )
3332         {
3333             dim = p->getCoordinatesRO()->getDimension();
3334             return static_cast<int>(dim);
3335         }
3336
3337         const Polygon *poly = dynamic_cast<const Polygon *>(g);
3338         if ( poly )
3339         {
3340             return GEOSGeom_getDimensions_r(extHandle, poly->getExteriorRing());
3341         }
3342
3343         const GeometryCollection *coll = dynamic_cast<const GeometryCollection *>(g);
3344         if ( coll )
3345         {
3346             return GEOSGeom_getDimensions_r(extHandle, coll->getGeometryN(0));
3347         }
3348
3349         handle->ERROR_MESSAGE("Unknown geometry type");
3350         return 0;
3351     }
3352     catch (const std::exception &e)
3353     {
3354         handle->ERROR_MESSAGE("%s", e.what());
3355     }
3356     catch (...)
3357     {
3358         handle->ERROR_MESSAGE("Unknown exception thrown");
3359     }
3360
3361     return 0;
3362 }
3363
3364 Geometry *
3365 GEOSSimplify_r(GEOSContextHandle_t extHandle, const Geometry *g1, double tolerance)
3366 {
3367     if ( 0 == extHandle )
3368     {
3369         return NULL;
3370     }
3371
3372     GEOSContextHandleInternal_t *handle = 0;
3373     handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
3374     if ( 0 == handle->initialized )
3375     {
3376         return NULL;
3377     }
3378
3379     try
3380     {
3381         using namespace geos::simplify;
3382         Geometry::AutoPtr g(DouglasPeuckerSimplifier::simplify(g1, tolerance));
3383         return g.release();
3384     }
3385     catch (const std::exception &e)
3386     {
3387         handle->ERROR_MESSAGE("%s", e.what());
3388     }
3389     catch (...)
3390     {
3391         handle->ERROR_MESSAGE("Unknown exception thrown");
3392     }
3393
3394     return NULL;
3395 }
3396
3397 Geometry *
3398 GEOSTopologyPreserveSimplify_r(GEOSContextHandle_t extHandle, const Geometry *g1, double tolerance)
3399 {
3400     if ( 0 == extHandle )
3401     {
3402         return NULL;
3403     }
3404
3405     GEOSContextHandleInternal_t *handle = 0;
3406     handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
3407     if ( 0 == handle->initialized )
3408     {
3409         return NULL;
3410     }
3411
3412     try
3413     {
3414         using namespace geos::simplify;
3415         Geometry::AutoPtr g(TopologyPreservingSimplifier::simplify(g1, tolerance));
3416         return g.release();
3417     }
3418     catch (const std::exception &e)
3419     {
3420         handle->ERROR_MESSAGE("%s", e.what());
3421     }
3422     catch (...)
3423     {
3424         handle->ERROR_MESSAGE("Unknown exception thrown");
3425     }
3426
3427     return NULL;
3428 }
3429
3430
3431 /* WKT Reader */
3432 WKTReader *
3433 GEOSWKTReader_create_r(GEOSContextHandle_t extHandle)
3434 {
3435     if ( 0 == extHandle )
3436     {
3437         return NULL;
3438     }
3439
3440     GEOSContextHandleInternal_t *handle = 0;
3441     handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
3442     if ( 0 == handle->initialized )
3443     {
3444         return NULL;
3445     }
3446
3447     try
3448     {
3449         using geos::io::WKTReader;
3450         return new WKTReader((GeometryFactory*)handle->geomFactory);
3451     }
3452     catch (const std::exception &e)
3453     {
3454         handle->ERROR_MESSAGE("%s", e.what());
3455     }
3456     catch (...)
3457     {
3458         handle->ERROR_MESSAGE("Unknown exception thrown");
3459     }
3460
3461     return NULL;
3462 }
3463
3464 void
3465 GEOSWKTReader_destroy_r(GEOSContextHandle_t extHandle, WKTReader *reader)
3466 {
3467     GEOSContextHandleInternal_t *handle = 0;
3468
3469     try
3470     {
3471         delete reader;
3472     }
3473     catch (const std::exception &e)
3474     {
3475         if ( 0 == extHandle )
3476         {
3477             return;
3478         }
3479
3480         handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
3481         if ( 0 == handle->initialized )
3482         {
3483             return;
3484         }
3485
3486         handle->ERROR_MESSAGE("%s", e.what());
3487     }
3488     catch (...)
3489     {
3490         if ( 0 == extHandle )
3491         {
3492             return;
3493         }
3494
3495         handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
3496         if ( 0 == handle->initialized )
3497         {
3498             return;
3499         }
3500
3501         handle->ERROR_MESSAGE("Unknown exception thrown");
3502     }
3503 }
3504
3505
3506 Geometry*
3507 GEOSWKTReader_read_r(GEOSContextHandle_t extHandle, WKTReader *reader, const char *wkt)
3508 {
3509     assert(0 != reader);
3510
3511     if ( 0 == extHandle )
3512     {
3513         return 0;
3514     }
3515
3516     GEOSContextHandleInternal_t *handle = 0;
3517     handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
3518     if ( 0 == handle->initialized )
3519     {
3520         return 0;
3521     }
3522
3523     try
3524     {
3525         const std::string wktstring(wkt);
3526         Geometry *g = reader->read(wktstring);
3527         return g;
3528     }
3529     catch (const std::exception &e)
3530     {
3531         handle->ERROR_MESSAGE("%s", e.what());
3532     }
3533     catch (...)
3534     {
3535         handle->ERROR_MESSAGE("Unknown exception thrown");
3536     }
3537
3538     return 0;
3539 }
3540
3541 /* WKT Writer */
3542 WKTWriter *
3543 GEOSWKTWriter_create_r(GEOSContextHandle_t extHandle)
3544 {
3545     if ( 0 == extHandle )
3546     {
3547         return 0;
3548     }
3549
3550     GEOSContextHandleInternal_t *handle = 0;
3551     handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
3552     if ( 0 == handle->initialized )
3553     {
3554         return 0;
3555     }
3556
3557     try
3558     {
3559         using geos::io::WKTWriter;
3560         return new WKTWriter();
3561     }
3562     catch (const std::exception &e)
3563     {
3564         handle->ERROR_MESSAGE("%s", e.what());
3565     }
3566     catch (...)
3567     {
3568         handle->ERROR_MESSAGE("Unknown exception thrown");
3569     }
3570
3571     return 0;
3572 }
3573
3574 void
3575 GEOSWKTWriter_destroy_r(GEOSContextHandle_t extHandle, WKTWriter *Writer)
3576 {
3577
3578     GEOSContextHandleInternal_t *handle = 0;
3579
3580     try
3581     {
3582         delete Writer;
3583     }
3584     catch (const std::exception &e)
3585     {
3586         if ( 0 == extHandle )
3587         {
3588             return;
3589         }
3590
3591         handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
3592         if ( 0 == handle->initialized )
3593         {
3594             return;
3595         }
3596
3597         handle->ERROR_MESSAGE("%s", e.what());
3598     }
3599     catch (...)
3600     {
3601         if ( 0 == extHandle )
3602         {
3603             return;
3604         }
3605
3606         handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
3607         if ( 0 == handle->initialized )
3608         {
3609             return;
3610         }
3611
3612         handle->ERROR_MESSAGE("Unknown exception thrown");
3613     }
3614 }
3615
3616
3617 char*
3618 GEOSWKTWriter_write_r(GEOSContextHandle_t extHandle, WKTWriter *writer, const Geometry *geom)
3619 {
3620     assert(0 != writer);
3621
3622     if ( 0 == extHandle )
3623     {
3624         return NULL;
3625     }
3626
3627     GEOSContextHandleInternal_t *handle = 0;
3628     handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
3629     if ( 0 == handle->initialized )
3630     {
3631         return NULL;
3632     }
3633
3634     try
3635     {
3636         std::string sgeom(writer->write(geom));
3637         char *result = gstrdup(sgeom);
3638         return result;
3639     }
3640     catch (const std::exception &e)
3641     {
3642         handle->ERROR_MESSAGE("%s", e.what());
3643     }
3644     catch (...)
3645     {
3646         handle->ERROR_MESSAGE("Unknown exception thrown");
3647     }
3648
3649     return NULL;
3650 }
3651
3652 /* WKB Reader */
3653 WKBReader *
3654 GEOSWKBReader_create_r(GEOSContextHandle_t extHandle)
3655 {
3656     if ( 0 == extHandle )
3657     {
3658         return NULL;
3659     }
3660
3661     GEOSContextHandleInternal_t *handle = 0;
3662     handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
3663     if ( 0 == handle->initialized )
3664     {
3665         return NULL;
3666     }
3667
3668     using geos::io::WKBReader;
3669     try
3670     {
3671         return new WKBReader(*(GeometryFactory*)handle->geomFactory);
3672     }
3673     catch (const std::exception &e)
3674     {
3675         handle->ERROR_MESSAGE("%s", e.what());
3676     }
3677     catch (...)
3678     {
3679         handle->ERROR_MESSAGE("Unknown exception thrown");
3680     }
3681
3682     return NULL;
3683 }
3684
3685 void
3686 GEOSWKBReader_destroy_r(GEOSContextHandle_t extHandle, WKBReader *reader)
3687 {
3688     GEOSContextHandleInternal_t *handle = 0;
3689
3690     try
3691     {
3692         delete reader;
3693     }
3694     catch (const std::exception &e)
3695     {
3696         if ( 0 == extHandle )
3697         {
3698             return;
3699         }
3700
3701         handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
3702         if ( 0 == handle->initialized )
3703         {
3704             return;
3705         }
3706
3707         handle->ERROR_MESSAGE("%s", e.what());
3708     }
3709     catch (...)
3710     {
3711         if ( 0 == extHandle )
3712         {
3713             return;
3714         }
3715
3716         handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
3717         if ( 0 == handle->initialized )
3718         {
3719             return;
3720         }
3721
3722         handle->ERROR_MESSAGE("Unknown exception thrown");
3723     }
3724 }
3725
3726
3727 Geometry*
3728 GEOSWKBReader_read_r(GEOSContextHandle_t extHandle, WKBReader *reader, const unsigned char *wkb, size_t size)
3729 {
3730     assert(0 != reader);
3731     assert(0 != wkb);
3732
3733     if ( 0 == extHandle )
3734     {
3735         return 0;
3736     }
3737
3738     GEOSContextHandleInternal_t *handle = 0;
3739     handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
3740     if ( 0 == handle->initialized )
3741     {
3742         return 0;
3743     }
3744
3745     try
3746     {
3747         std::string wkbstring(reinterpret_cast<const char*>(wkb), size); // make it binary !
3748         std::istringstream is(std::ios_base::binary);
3749         is.str(wkbstring);
3750         is.seekg(0, std::ios::beg); // rewind reader pointer
3751
3752         Geometry *g = reader->read(is);
3753         return g;
3754     }
3755     catch (const std::exception &e)
3756     {
3757         handle->ERROR_MESSAGE("%s", e.what());
3758     }
3759     catch (...)
3760     {
3761         handle->ERROR_MESSAGE("Unknown exception thrown");
3762     }
3763
3764     return 0;
3765 }
3766
3767 Geometry*
3768 GEOSWKBReader_readHEX_r(GEOSContextHandle_t extHandle, WKBReader *reader, const unsigned char *hex, size_t size)
3769 {
3770     assert(0 != reader);
3771     assert(0 != hex);
3772
3773     if ( 0 == extHandle )
3774     {
3775         return 0;
3776     }
3777
3778     GEOSContextHandleInternal_t *handle = 0;
3779     handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
3780     if ( 0 == handle->initialized )
3781     {
3782         return 0;
3783     }
3784
3785     try
3786     {
3787         std::string hexstring(reinterpret_cast<const char*>(hex), size);
3788         std::istringstream is(std::ios_base::binary);
3789         is.str(hexstring);
3790         is.seekg(0, std::ios::beg); // rewind reader pointer
3791
3792         Geometry *g = reader->readHEX(is);
3793         return g;
3794     }
3795     catch (const std::exception &e)
3796     {
3797         handle->ERROR_MESSAGE("%s", e.what());
3798     }
3799     catch (...)
3800     {
3801         handle->ERROR_MESSAGE("Unknown exception thrown");
3802     }
3803
3804     return 0;
3805 }
3806
3807 /* WKB Writer */
3808 WKBWriter *
3809 GEOSWKBWriter_create_r(GEOSContextHandle_t extHandle)
3810 {
3811     if ( 0 == extHandle )
3812     {
3813         return NULL;
3814     }
3815
3816     GEOSContextHandleInternal_t *handle = 0;
3817     handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
3818     if ( 0 == handle->initialized )
3819     {
3820         return NULL;
3821     }
3822
3823     try
3824     {
3825         using geos::io::WKBWriter;
3826         return new WKBWriter();
3827     }
3828     catch (const std::exception &e)
3829     {
3830         handle->ERROR_MESSAGE("%s", e.what());
3831     }
3832     catch (...)
3833     {
3834         handle->ERROR_MESSAGE("Unknown exception thrown");
3835     }
3836
3837     return NULL;
3838 }
3839
3840 void
3841 GEOSWKBWriter_destroy_r(GEOSContextHandle_t extHandle, WKBWriter *Writer)
3842 {
3843     GEOSContextHandleInternal_t *handle = 0;
3844
3845     try
3846     {
3847         delete Writer;
3848     }
3849     catch (const std::exception &e)
3850     {
3851         if ( 0 == extHandle )
3852         {
3853             return;
3854         }
3855
3856         handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
3857         if ( 0 == handle->initialized )
3858         {
3859             return;
3860         }
3861
3862         handle->ERROR_MESSAGE("%s", e.what());
3863     }
3864     catch (...)
3865     {
3866         if ( 0 == extHandle )
3867         {
3868             return;
3869         }
3870
3871         handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
3872         if ( 0 == handle->initialized )
3873         {
3874             return;
3875         }
3876
3877         handle->ERROR_MESSAGE("Unknown exception thrown");
3878     }
3879 }
3880
3881
3882 /* The caller owns the result */
3883 unsigned char*
3884 GEOSWKBWriter_write_r(GEOSContextHandle_t extHandle, WKBWriter *writer, const Geometry *geom, size_t *size)
3885 {
3886     assert(0 != writer);
3887     assert(0 != geom);
3888     assert(0 != size);
3889
3890     if ( 0 == extHandle )
3891     {
3892         return NULL;
3893     }
3894
3895     GEOSContextHandleInternal_t *handle = 0;
3896     handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
3897     if ( 0 == handle->initialized )
3898     {
3899         return NULL;
3900     }
3901
3902     try
3903     {
3904         std::ostringstream os(std::ios_base::binary);
3905         writer->write(*geom, os);
3906         std::string wkbstring(os.str());
3907         const std::size_t len = wkbstring.length();
3908
3909         unsigned char *result = NULL;
3910         result = (unsigned char*) std::malloc(len);
3911         std::memcpy(result, wkbstring.c_str(), len);
3912         *size = len;
3913         return result;
3914     }
3915     catch (const std::exception &e)
3916     {
3917         handle->ERROR_MESSAGE("%s", e.what());
3918     }
3919     catch (...)
3920     {
3921         handle->ERROR_MESSAGE("Unknown exception thrown");
3922     }
3923     return NULL;
3924 }
3925
3926 /* The caller owns the result */
3927 unsigned char*
3928 GEOSWKBWriter_writeHEX_r(GEOSContextHandle_t extHandle, WKBWriter *writer, const Geometry *geom, size_t *size)
3929 {
3930     assert(0 != writer);
3931     assert(0 != geom);
3932     assert(0 != size);
3933
3934     if ( 0 == extHandle )
3935     {
3936         return NULL;
3937     }
3938
3939     GEOSContextHandleInternal_t *handle = 0;
3940     handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
3941     if ( 0 == handle->initialized )
3942     {
3943         return NULL;
3944     }
3945
3946     try
3947     {
3948         std::ostringstream os(std::ios_base::binary);
3949         writer->writeHEX(*geom, os);
3950         std::string wkbstring(os.str());
3951         const std::size_t len = wkbstring.length();
3952
3953         unsigned char *result = NULL;
3954         result = (unsigned char*) std::malloc(len);
3955         std::memcpy(result, wkbstring.c_str(), len);
3956         *size = len;
3957         return result;
3958     }
3959     catch (const std::exception &e)
3960     {
3961         handle->ERROR_MESSAGE("%s", e.what());
3962     }
3963     catch (...)
3964     {
3965         handle->ERROR_MESSAGE("Unknown exception thrown");
3966     }
3967
3968     return NULL;
3969 }
3970
3971 int
3972 GEOSWKBWriter_getOutputDimension_r(GEOSContextHandle_t extHandle, const GEOSWKBWriter* writer)
3973 {
3974     assert(0 != writer);
3975
3976     if ( 0 == extHandle )
3977     {
3978         return 0;
3979     }
3980
3981     int ret = 0;
3982
3983     GEOSContextHandleInternal_t *handle = 0;
3984     handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
3985     if ( 0 != handle->initialized )
3986     {
3987         try
3988         {
3989             ret = writer->getOutputDimension();
3990         }
3991         catch (...)
3992         {
3993             handle->ERROR_MESSAGE("Unknown exception thrown");
3994         }
3995     }
3996
3997     return ret;
3998 }
3999
4000 void
4001 GEOSWKBWriter_setOutputDimension_r(GEOSContextHandle_t extHandle, GEOSWKBWriter* writer, int newDimension)
4002 {
4003     assert(0 != writer);
4004
4005     if ( 0 == extHandle )
4006     {
4007         return;
4008     }
4009
4010     GEOSContextHandleInternal_t *handle = 0;
4011     handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
4012     if ( 0 != handle->initialized )
4013     {
4014         try
4015         {
4016             writer->setOutputDimension(newDimension);
4017         }
4018         catch (...)
4019         {
4020             handle->ERROR_MESSAGE("Unknown exception thrown");
4021         }
4022     }
4023 }
4024
4025 int
4026 GEOSWKBWriter_getByteOrder_r(GEOSContextHandle_t extHandle, const GEOSWKBWriter* writer)
4027 {
4028     assert(0 != writer);
4029
4030     if ( 0 == extHandle )
4031     {
4032         return 0;
4033     }
4034
4035     int ret = 0;
4036
4037     GEOSContextHandleInternal_t *handle = 0;
4038     handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
4039     if ( 0 != handle->initialized )
4040     {
4041         try
4042         {
4043             ret = writer->getByteOrder();
4044         }
4045
4046         catch (...)
4047         {
4048             handle->ERROR_MESSAGE("Unknown exception thrown");
4049         }
4050     }
4051
4052     return ret;
4053 }
4054
4055 void
4056 GEOSWKBWriter_setByteOrder_r(GEOSContextHandle_t extHandle, GEOSWKBWriter* writer, int newByteOrder)
4057 {
4058     assert(0 != writer);
4059
4060     if ( 0 == extHandle )
4061     {
4062         return;
4063     }
4064
4065     GEOSContextHandleInternal_t *handle = 0;
4066     handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
4067     if ( 0 != handle->initialized )
4068     {
4069         try
4070         {
4071             writer->setByteOrder(newByteOrder);
4072         }
4073         catch (...)
4074         {
4075             handle->ERROR_MESSAGE("Unknown exception thrown");
4076         }
4077     }
4078 }
4079
4080 char
4081 GEOSWKBWriter_getIncludeSRID_r(GEOSContextHandle_t extHandle, const GEOSWKBWriter* writer)
4082 {
4083     assert(0 != writer);
4084
4085     if ( 0 == extHandle )
4086     {
4087         return -1;
4088     }
4089
4090     int ret = -1;
4091
4092     GEOSContextHandleInternal_t *handle = 0;
4093     handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
4094     if ( 0 != handle->initialized )
4095     {
4096         try
4097         {
4098             int srid = writer->getIncludeSRID();
4099             ret = static_cast<char>(srid);
4100         }
4101         catch (...)
4102         {
4103             handle->ERROR_MESSAGE("Unknown exception thrown");
4104         }
4105     }
4106
4107     return static_cast<char>(ret);
4108 }
4109
4110 void
4111 GEOSWKBWriter_setIncludeSRID_r(GEOSContextHandle_t extHandle, GEOSWKBWriter* writer, const char newIncludeSRID)
4112 {
4113     assert(0 != writer);
4114
4115     if ( 0 == extHandle )
4116     {
4117         return;
4118     }
4119
4120     GEOSContextHandleInternal_t *handle = 0;
4121     handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
4122     if ( 0 != handle->initialized )
4123     {
4124         try
4125         {
4126             writer->setIncludeSRID(newIncludeSRID);
4127         }
4128         catch (...)
4129         {
4130             handle->ERROR_MESSAGE("Unknown exception thrown");
4131         }
4132     }
4133 }
4134
4135
4136 //-----------------------------------------------------------------
4137 // Prepared Geometry
4138 //-----------------------------------------------------------------
4139
4140 const geos::geom::prep::PreparedGeometry*
4141 GEOSPrepare_r(GEOSContextHandle_t extHandle, const Geometry *g)
4142 {
4143     if ( 0 == extHandle )
4144     {
4145         return 0;
4146     }
4147
4148     GEOSContextHandleInternal_t *handle = 0;
4149     handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
4150     if ( 0 == handle->initialized )
4151     {
4152         return 0;
4153     }
4154
4155     const geos::geom::prep::PreparedGeometry* prep = 0;
4156
4157     try
4158     {
4159         prep = geos::geom::prep::PreparedGeometryFactory::prepare(g);
4160     }
4161     catch (const std::exception &e)
4162     {
4163         handle->ERROR_MESSAGE("%s", e.what());
4164     }
4165     catch (...)
4166     {
4167         handle->ERROR_MESSAGE("Unknown exception thrown");
4168     }
4169
4170     return prep;
4171 }
4172
4173 void
4174 GEOSPreparedGeom_destroy_r(GEOSContextHandle_t extHandle, const geos::geom::prep::PreparedGeometry *a)
4175 {
4176     GEOSContextHandleInternal_t *handle = 0;
4177
4178     try
4179     {
4180         delete a;
4181     }
4182     catch (const std::exception &e)
4183     {
4184         if ( 0 == extHandle )
4185         {
4186             return;
4187         }
4188
4189         handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
4190         if ( 0 == handle->initialized )
4191         {
4192             return;
4193         }
4194
4195         handle->ERROR_MESSAGE("%s", e.what());
4196     }
4197     catch (...)
4198     {
4199         if ( 0 == extHandle )
4200         {
4201             return;
4202         }
4203
4204         handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
4205         if ( 0 == handle->initialized )
4206         {
4207             return;
4208         }
4209
4210         handle->ERROR_MESSAGE("Unknown exception thrown");
4211     }
4212 }
4213
4214 char
4215 GEOSPreparedContains_r(GEOSContextHandle_t extHandle,
4216         const geos::geom::prep::PreparedGeometry *pg, const Geometry *g)
4217 {
4218     assert(0 != pg);
4219     assert(0 != g);
4220
4221     if ( 0 == extHandle )
4222     {
4223         return 2;
4224     }
4225
4226     GEOSContextHandleInternal_t *handle = 0;
4227     handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
4228     if ( 0 == handle->initialized )
4229     {
4230         return 2;
4231     }
4232
4233     try
4234     {
4235         bool result = pg->contains(g);
4236         return result;
4237     }
4238     catch (const std::exception &e)
4239     {
4240         handle->ERROR_MESSAGE("%s", e.what());
4241     }
4242     catch (...)
4243     {
4244         handle->ERROR_MESSAGE("Unknown exception thrown");
4245     }
4246
4247     return 2;
4248 }
4249
4250 char
4251 GEOSPreparedContainsProperly_r(GEOSContextHandle_t extHandle,
4252         const geos::geom::prep::PreparedGeometry *pg, const Geometry *g)
4253 {
4254     assert(0 != pg);
4255     assert(0 != g);
4256
4257     if ( 0 == extHandle )
4258     {
4259         return 2;
4260     }
4261
4262     GEOSContextHandleInternal_t *handle = 0;
4263     handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
4264     if ( 0 == handle->initialized )
4265     {
4266         return 2;
4267     }
4268
4269     try
4270     {
4271         bool result = pg->containsProperly(g);
4272         return result;
4273     }
4274     catch (const std::exception &e)
4275     {
4276         handle->ERROR_MESSAGE("%s", e.what());
4277     }
4278     catch (...)
4279     {
4280         handle->ERROR_MESSAGE("Unknown exception thrown");
4281     }
4282
4283     return 2;
4284 }
4285
4286 char
4287 GEOSPreparedCovers_r(GEOSContextHandle_t extHandle,
4288         const geos::geom::prep::PreparedGeometry *pg, const Geometry *g)
4289 {
4290     assert(0 != pg);
4291     assert(0 != g);
4292
4293     if ( 0 == extHandle )
4294     {
4295         return 2;
4296     }
4297
4298     GEOSContextHandleInternal_t *handle = 0;
4299     handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
4300     if ( 0 == handle->initialized )
4301     {
4302         return 2;
4303     }
4304
4305     try
4306     {
4307         bool result = pg->covers(g);
4308         return result;
4309     }
4310     catch (const std::exception &e)
4311     {
4312         handle->ERROR_MESSAGE("%s", e.what());
4313     }
4314     catch (...)
4315     {
4316         handle->ERROR_MESSAGE("Unknown exception thrown");
4317     }
4318
4319     return 2;
4320 }
4321
4322 char
4323 GEOSPreparedIntersects_r(GEOSContextHandle_t extHandle,
4324         const geos::geom::prep::PreparedGeometry *pg, const Geometry *g)
4325 {
4326     assert(0 != pg);
4327     assert(0 != g);
4328
4329     if ( 0 == extHandle )
4330     {
4331         return 2;
4332     }
4333
4334     GEOSContextHandleInternal_t *handle = 0;
4335     handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
4336     if ( 0 == handle->initialized )
4337     {
4338         return 2;
4339     }
4340
4341     try
4342     {
4343         bool result = pg->intersects(g);
4344         return result;
4345     }
4346     catch (const std::exception &e)
4347     {
4348         handle->ERROR_MESSAGE("%s", e.what());
4349     }
4350     catch (...)
4351     {
4352         handle->ERROR_MESSAGE("Unknown exception thrown");
4353     }
4354
4355     return 2;
4356 }
4357
4358 //-----------------------------------------------------------------
4359 // STRtree
4360 //-----------------------------------------------------------------
4361
4362 geos::index::strtree::STRtree *
4363 GEOSSTRtree_create_r(GEOSContextHandle_t extHandle,
4364                                   size_t nodeCapacity)
4365 {
4366     if ( 0 == extHandle )
4367     {
4368         return 0;
4369     }
4370
4371     GEOSContextHandleInternal_t *handle = 0;
4372     handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
4373     if ( 0 == handle->initialized )
4374     {
4375         return 0;
4376     }
4377
4378     geos::index::strtree::STRtree *tree = 0;
4379
4380     try
4381     {
4382         tree = new geos::index::strtree::STRtree(nodeCapacity);
4383     }
4384     catch (const std::exception &e)
4385     {
4386         handle->ERROR_MESSAGE("%s", e.what());
4387     }
4388     catch (...)
4389     {
4390         handle->ERROR_MESSAGE("Unknown exception thrown");
4391     }
4392
4393     return tree;
4394 }
4395
4396 void
4397 GEOSSTRtree_insert_r(GEOSContextHandle_t extHandle,
4398                      geos::index::strtree::STRtree *tree,
4399                      const geos::geom::Geometry *g,
4400                      void *item)
4401 {
4402     GEOSContextHandleInternal_t *handle = 0;
4403     assert(tree != 0);
4404     assert(g != 0);
4405
4406     try
4407     {
4408         tree->insert(g->getEnvelopeInternal(), item);
4409     }
4410     catch (const std::exception &e)
4411     {
4412         if ( 0 == extHandle )
4413         {
4414             return;
4415         }
4416
4417         handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
4418         if ( 0 == handle->initialized )
4419         {
4420             return;
4421         }
4422
4423         handle->ERROR_MESSAGE("%s", e.what());
4424     }
4425     catch (...)
4426     {
4427         if ( 0 == extHandle )
4428         {
4429             return;
4430         }
4431
4432         handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
4433         if ( 0 == handle->initialized )
4434         {
4435             return;
4436         }
4437
4438         handle->ERROR_MESSAGE("Unknown exception thrown");
4439     }
4440 }
4441
4442 void
4443 GEOSSTRtree_query_r(GEOSContextHandle_t extHandle,
4444                     geos::index::strtree::STRtree *tree,
4445                     const geos::geom::Geometry *g,
4446                     GEOSQueryCallback callback,
4447                     void *userdata)
4448 {
4449     GEOSContextHandleInternal_t *handle = 0;
4450     assert(tree != 0);
4451     assert(g != 0);
4452     assert(callback != 0);
4453
4454     try
4455     {
4456         CAPI_ItemVisitor visitor(callback, userdata);
4457         tree->query(g->getEnvelopeInternal(), visitor);
4458     }
4459     catch (const std::exception &e)
4460     {
4461         if ( 0 == extHandle )
4462         {
4463             return;
4464         }
4465
4466         handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
4467         if ( 0 == handle->initialized )
4468         {
4469             return;
4470         }
4471
4472         handle->ERROR_MESSAGE("%s", e.what());
4473     }
4474     catch (...)
4475     {
4476         if ( 0 == extHandle )
4477         {
4478             return;
4479         }
4480
4481         handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
4482         if ( 0 == handle->initialized )
4483         {
4484             return;
4485         }
4486
4487         handle->ERROR_MESSAGE("Unknown exception thrown");
4488     }
4489 }
4490
4491 void
4492 GEOSSTRtree_iterate_r(GEOSContextHandle_t extHandle,
4493                     geos::index::strtree::STRtree *tree,
4494                     GEOSQueryCallback callback,
4495                     void *userdata)
4496 {
4497     GEOSContextHandleInternal_t *handle = 0;
4498     assert(tree != 0);
4499     assert(callback != 0);
4500
4501     try
4502     {
4503         CAPI_ItemVisitor visitor(callback, userdata);
4504         tree->iterate(visitor);
4505     }
4506     catch (const std::exception &e)
4507     {
4508         if ( 0 == extHandle )
4509         {
4510             return;
4511         }
4512
4513         handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
4514         if ( 0 == handle->initialized )
4515         {
4516             return;
4517         }
4518
4519         handle->ERROR_MESSAGE("%s", e.what());
4520     }
4521     catch (...)
4522     {
4523         if ( 0 == extHandle )
4524         {
4525             return;
4526         }
4527
4528         handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
4529         if ( 0 == handle->initialized )
4530         {
4531             return;
4532         }
4533
4534         handle->ERROR_MESSAGE("Unknown exception thrown");
4535     }
4536 }
4537
4538 char
4539 GEOSSTRtree_remove_r(GEOSContextHandle_t extHandle,
4540                      geos::index::strtree::STRtree *tree,
4541                      const geos::geom::Geometry *g,
4542                      void *item)
4543 {
4544     assert(0 != tree);
4545     assert(0 != g);
4546
4547     if ( 0 == extHandle )
4548     {
4549         return 2;
4550     }
4551
4552     GEOSContextHandleInternal_t *handle = 0;
4553     handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
4554     if ( 0 == handle->initialized )
4555     {
4556         return 2;
4557     }
4558
4559     try
4560     {
4561         bool result = tree->remove(g->getEnvelopeInternal(), item);
4562         return result;
4563     }
4564     catch (const std::exception &e)
4565     {
4566         handle->ERROR_MESSAGE("%s", e.what());
4567     }
4568     catch (...)
4569     {
4570         handle->ERROR_MESSAGE("Unknown exception thrown");
4571     }
4572
4573     return 2;
4574 }
4575
4576 void
4577 GEOSSTRtree_destroy_r(GEOSContextHandle_t extHandle,
4578                       geos::index::strtree::STRtree *tree)
4579 {
4580     GEOSContextHandleInternal_t *handle = 0;
4581
4582     try
4583     {
4584         delete tree;
4585     }
4586     catch (const std::exception &e)
4587     {
4588         if ( 0 == extHandle )
4589         {
4590             return;
4591         }
4592
4593         handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
4594         if ( 0 == handle->initialized )
4595         {
4596             return;
4597         }
4598
4599         handle->ERROR_MESSAGE("%s", e.what());
4600     }
4601     catch (...)
4602     {
4603         if ( 0 == extHandle )
4604         {
4605             return;
4606         }
4607
4608         handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
4609         if ( 0 == handle->initialized )
4610         {
4611             return;
4612         }
4613
4614         handle->ERROR_MESSAGE("Unknown exception thrown");
4615     }
4616 }
4617
4618 double
4619 GEOSProject_r(GEOSContextHandle_t extHandle,
4620               const Geometry *g,
4621               const Geometry *p)
4622 {
4623
4624     const geos::geom::Point* point = dynamic_cast<const geos::geom::Point*>(p);
4625     if (!point) {
4626         if ( 0 == extHandle )
4627         {
4628             return -1.0;
4629         }
4630         GEOSContextHandleInternal_t *handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
4631         if ( 0 == handle->initialized )
4632         {
4633             return -1.0;
4634         }
4635
4636         handle->ERROR_MESSAGE("third argument of GEOSProject_r must be Point*");
4637         return -1.0;
4638     }
4639     const geos::geom::Coordinate* inputPt = p->getCoordinate();
4640     return geos::linearref::LengthIndexedLine(g).project(*inputPt);
4641 }
4642
4643
4644 Geometry*
4645 GEOSInterpolate_r(GEOSContextHandle_t extHandle, const Geometry *g, double d)
4646 {
4647     geos::linearref::LengthIndexedLine lil(g);
4648     geos::geom::Coordinate coord = lil.extractPoint(d);
4649     GEOSContextHandleInternal_t *handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
4650     const GeometryFactory *gf = handle->geomFactory;
4651     Geometry* point = gf->createPoint(coord);
4652     return point;
4653 }
4654
4655
4656 double
4657 GEOSProjectNormalized_r(GEOSContextHandle_t extHandle, const Geometry *g,
4658                         const Geometry *p)
4659 {
4660
4661     double length;
4662     GEOSLength_r(extHandle, g, &length);
4663     return GEOSProject_r(extHandle, g, p) / length;
4664 }
4665
4666
4667 Geometry*
4668 GEOSInterpolateNormalized_r(GEOSContextHandle_t extHandle, const Geometry *g,
4669                             double d)
4670 {
4671     double length;
4672     GEOSLength_r(extHandle, g, &length);
4673     return GEOSInterpolate_r(extHandle, g, d * length);
4674 }
4675
4676 GEOSGeometry*
4677 GEOSGeom_extractUniquePoints_r(GEOSContextHandle_t extHandle,
4678                               const GEOSGeometry* g)
4679 {
4680     if ( 0 == extHandle ) return 0;
4681     GEOSContextHandleInternal_t *handle = 0;
4682     handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
4683     if ( handle->initialized == 0 ) return 0;
4684
4685     using namespace geos::geom;
4686     using namespace geos::util;
4687     using namespace std;
4688
4689     try
4690     {
4691
4692     /* 1: extract points */
4693     vector<const Coordinate*> coords;
4694     UniqueCoordinateArrayFilter filter(coords);
4695     g->apply_ro(&filter);
4696
4697     /* 2: for each point, create a geometry and put into a vector */
4698     vector<Geometry*>* points = new vector<Geometry*>();
4699     points->reserve(coords.size());
4700     const GeometryFactory* factory = g->getFactory();
4701     for (vector<const Coordinate*>::iterator it=coords.begin(),
4702                                              itE=coords.end();
4703                                              it != itE; ++it)
4704     {
4705         Geometry* point = factory->createPoint(*(*it));
4706         points->push_back(point);
4707     }
4708
4709     /* 3: create a multipoint */
4710     return factory->createMultiPoint(points);
4711
4712     }
4713     catch (const std::exception &e)
4714     {
4715         handle->ERROR_MESSAGE("%s", e.what());
4716         return 0;
4717     }
4718     catch (...)
4719     {
4720         handle->ERROR_MESSAGE("Unknown exception thrown");
4721         return 0;
4722     }
4723 }
4724
4725
4726 } /* extern "C" */
4727