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