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