1 /************************************************************************ 2 * 3 * 4 * C-Wrapper for GEOS library 5 * 6 * Copyright (C) 2010 2011 Sandro Santilli <strk@kbt.io> 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@kbt.io> 15 * 16 ***********************************************************************/ 17 18 #include <geos/geom/prep/PreparedGeometryFactory.h> 19 #include <geos/index/strtree/STRtree.h> 20 #include <geos/io/WKTReader.h> 21 #include <geos/io/WKBReader.h> 22 #include <geos/io/WKTWriter.h> 23 #include <geos/io/WKBWriter.h> 24 #include <geos/util/Interrupt.h> 25 26 #include <stdexcept> 27 #include <new> 28 29 #ifdef _MSC_VER 30 #pragma warning(disable : 4099) 31 #endif 32 33 // Some extra magic to make type declarations in geos_c.h work - for cross-checking of types in header. 34 #define GEOSGeometry geos::geom::Geometry 35 #define GEOSPreparedGeometry geos::geom::prep::PreparedGeometry 36 #define GEOSCoordSequence geos::geom::CoordinateSequence 37 #define GEOSSTRtree geos::index::strtree::STRtree 38 #define GEOSWKTReader geos::io::WKTReader 39 #define GEOSWKTWriter geos::io::WKTWriter 40 #define GEOSWKBReader geos::io::WKBReader 41 #define GEOSWKBWriter geos::io::WKBWriter 42 typedef struct GEOSBufParams_t GEOSBufferParams; 43 44 #include "geos_c.h" 45 46 /// Define this if you want operations triggering Exceptions to 47 /// be printed (will use the NOTIFY channel - only implemented for GEOSUnion so far) 48 /// 49 #undef VERBOSE_EXCEPTIONS 50 51 #include <geos/export.h> 52 53 /* 54 #if defined(_MSC_VER) 55 # define GEOS_DLL __declspec(dllexport) 56 #else 57 # define GEOS_DLL 58 #endif 59 */ 60 61 // import the most frequently used definitions globally 62 using geos::geom::Geometry; 63 using geos::geom::LineString; 64 using geos::geom::Polygon; 65 using geos::geom::CoordinateSequence; 66 using geos::geom::GeometryFactory; 67 68 using geos::io::WKTReader; 69 using geos::io::WKTWriter; 70 using geos::io::WKBReader; 71 using geos::io::WKBWriter; 72 73 74 75 typedef std::unique_ptr<Geometry> GeomPtr; 76 77 //## GLOBALS ################################################ 78 79 // NOTE: SRID will have to be changed after geometry creation 80 GEOSContextHandle_t handle = NULL; 81 82 extern "C" { 83 84 void initGEOS(GEOSMessageHandler nf,GEOSMessageHandler ef)85 initGEOS(GEOSMessageHandler nf, GEOSMessageHandler ef) 86 { 87 if(! handle) { 88 handle = initGEOS_r(nf, ef); 89 } 90 else { 91 GEOSContext_setNoticeHandler_r(handle, nf); 92 GEOSContext_setErrorHandler_r(handle, ef); 93 } 94 95 geos::util::Interrupt::cancel(); 96 } 97 98 void finishGEOS()99 finishGEOS() 100 { 101 if(handle != NULL) { 102 finishGEOS_r(handle); 103 handle = NULL; 104 } 105 } 106 107 GEOSInterruptCallback* GEOS_interruptRegisterCallback(GEOSInterruptCallback * cb)108 GEOS_interruptRegisterCallback(GEOSInterruptCallback* cb) 109 { 110 return geos::util::Interrupt::registerCallback(cb); 111 } 112 113 void GEOS_interruptRequest()114 GEOS_interruptRequest() 115 { 116 geos::util::Interrupt::request(); 117 } 118 119 void GEOS_interruptCancel()120 GEOS_interruptCancel() 121 { 122 geos::util::Interrupt::cancel(); 123 } 124 125 void GEOSFree(void * buffer)126 GEOSFree(void* buffer) 127 { 128 GEOSFree_r(handle, buffer); 129 } 130 131 /**************************************************************** 132 ** relate()-related functions 133 ** return 0 = false, 1 = true, 2 = error occured 134 ** 135 */ 136 char GEOSDisjoint(const Geometry * g1,const Geometry * g2)137 GEOSDisjoint(const Geometry* g1, const Geometry* g2) 138 { 139 return GEOSDisjoint_r(handle, g1, g2); 140 } 141 142 char GEOSTouches(const Geometry * g1,const Geometry * g2)143 GEOSTouches(const Geometry* g1, const Geometry* g2) 144 { 145 return GEOSTouches_r(handle, g1, g2); 146 } 147 148 char GEOSIntersects(const Geometry * g1,const Geometry * g2)149 GEOSIntersects(const Geometry* g1, const Geometry* g2) 150 { 151 return GEOSIntersects_r(handle, g1, g2); 152 } 153 154 char GEOSCrosses(const Geometry * g1,const Geometry * g2)155 GEOSCrosses(const Geometry* g1, const Geometry* g2) 156 { 157 return GEOSCrosses_r(handle, g1, g2); 158 } 159 160 char GEOSWithin(const Geometry * g1,const Geometry * g2)161 GEOSWithin(const Geometry* g1, const Geometry* g2) 162 { 163 return GEOSWithin_r(handle, g1, g2); 164 } 165 166 // call g1->contains(g2) 167 // returns 0 = false 168 // 1 = true 169 // 2 = error was trapped 170 char GEOSContains(const Geometry * g1,const Geometry * g2)171 GEOSContains(const Geometry* g1, const Geometry* g2) 172 { 173 return GEOSContains_r(handle, g1, g2); 174 } 175 176 char GEOSOverlaps(const Geometry * g1,const Geometry * g2)177 GEOSOverlaps(const Geometry* g1, const Geometry* g2) 178 { 179 return GEOSOverlaps_r(handle, g1, g2); 180 } 181 182 char GEOSCovers(const Geometry * g1,const Geometry * g2)183 GEOSCovers(const Geometry* g1, const Geometry* g2) 184 { 185 return GEOSCovers_r(handle, g1, g2); 186 } 187 188 char GEOSCoveredBy(const Geometry * g1,const Geometry * g2)189 GEOSCoveredBy(const Geometry* g1, const Geometry* g2) 190 { 191 return GEOSCoveredBy_r(handle, g1, g2); 192 } 193 194 195 //------------------------------------------------------------------- 196 // low-level relate functions 197 //------------------------------------------------------------------ 198 199 char GEOSRelatePattern(const Geometry * g1,const Geometry * g2,const char * pat)200 GEOSRelatePattern(const Geometry* g1, const Geometry* g2, const char* pat) 201 { 202 return GEOSRelatePattern_r(handle, g1, g2, pat); 203 } 204 205 char GEOSRelatePatternMatch(const char * mat,const char * pat)206 GEOSRelatePatternMatch(const char* mat, const char* pat) 207 { 208 return GEOSRelatePatternMatch_r(handle, mat, pat); 209 } 210 211 char* GEOSRelate(const Geometry * g1,const Geometry * g2)212 GEOSRelate(const Geometry* g1, const Geometry* g2) 213 { 214 return GEOSRelate_r(handle, g1, g2); 215 } 216 217 char* GEOSRelateBoundaryNodeRule(const Geometry * g1,const Geometry * g2,int bnr)218 GEOSRelateBoundaryNodeRule(const Geometry* g1, const Geometry* g2, int bnr) 219 { 220 return GEOSRelateBoundaryNodeRule_r(handle, g1, g2, bnr); 221 } 222 223 224 //----------------------------------------------------------------- 225 // isValid 226 //----------------------------------------------------------------- 227 228 229 char GEOSisValid(const Geometry * g)230 GEOSisValid(const Geometry* g) 231 { 232 return GEOSisValid_r(handle, g); 233 } 234 235 char* GEOSisValidReason(const Geometry * g)236 GEOSisValidReason(const Geometry* g) 237 { 238 return GEOSisValidReason_r(handle, g); 239 } 240 241 char GEOSisValidDetail(const Geometry * g,int flags,char ** reason,Geometry ** location)242 GEOSisValidDetail(const Geometry* g, int flags, 243 char** reason, Geometry** location) 244 { 245 return GEOSisValidDetail_r(handle, g, flags, reason, location); 246 } 247 248 //----------------------------------------------------------------- 249 // general purpose 250 //----------------------------------------------------------------- 251 252 char GEOSEquals(const Geometry * g1,const Geometry * g2)253 GEOSEquals(const Geometry* g1, const Geometry* g2) 254 { 255 return GEOSEquals_r(handle, g1, g2); 256 } 257 258 char GEOSEqualsExact(const Geometry * g1,const Geometry * g2,double tolerance)259 GEOSEqualsExact(const Geometry* g1, const Geometry* g2, double tolerance) 260 { 261 return GEOSEqualsExact_r(handle, g1, g2, tolerance); 262 } 263 264 int GEOSDistance(const Geometry * g1,const Geometry * g2,double * dist)265 GEOSDistance(const Geometry* g1, const Geometry* g2, double* dist) 266 { 267 return GEOSDistance_r(handle, g1, g2, dist); 268 } 269 270 int GEOSDistanceIndexed(const Geometry * g1,const Geometry * g2,double * dist)271 GEOSDistanceIndexed(const Geometry* g1, const Geometry* g2, double* dist) 272 { 273 return GEOSDistanceIndexed_r(handle, g1, g2, dist); 274 } 275 276 int GEOSHausdorffDistance(const Geometry * g1,const Geometry * g2,double * dist)277 GEOSHausdorffDistance(const Geometry* g1, const Geometry* g2, double* dist) 278 { 279 return GEOSHausdorffDistance_r(handle, g1, g2, dist); 280 } 281 282 int GEOSHausdorffDistanceDensify(const Geometry * g1,const Geometry * g2,double densifyFrac,double * dist)283 GEOSHausdorffDistanceDensify(const Geometry* g1, const Geometry* g2, double densifyFrac, double* dist) 284 { 285 return GEOSHausdorffDistanceDensify_r(handle, g1, g2, densifyFrac, dist); 286 } 287 288 int GEOSFrechetDistance(const Geometry * g1,const Geometry * g2,double * dist)289 GEOSFrechetDistance(const Geometry* g1, const Geometry* g2, double* dist) 290 { 291 return GEOSFrechetDistance_r(handle, g1, g2, dist); 292 } 293 294 int GEOSFrechetDistanceDensify(const Geometry * g1,const Geometry * g2,double densifyFrac,double * dist)295 GEOSFrechetDistanceDensify(const Geometry* g1, const Geometry* g2, double densifyFrac, double* dist) 296 { 297 return GEOSFrechetDistanceDensify_r(handle, g1, g2, densifyFrac, dist); 298 } 299 300 int GEOSArea(const Geometry * g,double * area)301 GEOSArea(const Geometry* g, double* area) 302 { 303 return GEOSArea_r(handle, g, area); 304 } 305 306 int GEOSLength(const Geometry * g,double * length)307 GEOSLength(const Geometry* g, double* length) 308 { 309 return GEOSLength_r(handle, g, length); 310 } 311 312 CoordinateSequence* GEOSNearestPoints(const Geometry * g1,const Geometry * g2)313 GEOSNearestPoints(const Geometry* g1, const Geometry* g2) 314 { 315 return GEOSNearestPoints_r(handle, g1, g2); 316 } 317 318 Geometry* GEOSGeomFromWKT(const char * wkt)319 GEOSGeomFromWKT(const char* wkt) 320 { 321 return GEOSGeomFromWKT_r(handle, wkt); 322 } 323 324 char* GEOSGeomToWKT(const Geometry * g)325 GEOSGeomToWKT(const Geometry* g) 326 { 327 return GEOSGeomToWKT_r(handle, g); 328 } 329 330 // Remember to free the result! 331 unsigned char* GEOSGeomToWKB_buf(const Geometry * g,size_t * size)332 GEOSGeomToWKB_buf(const Geometry* g, size_t* size) 333 { 334 return GEOSGeomToWKB_buf_r(handle, g, size); 335 } 336 337 Geometry* GEOSGeomFromWKB_buf(const unsigned char * wkb,size_t size)338 GEOSGeomFromWKB_buf(const unsigned char* wkb, size_t size) 339 { 340 return GEOSGeomFromWKB_buf_r(handle, wkb, size); 341 } 342 343 /* Read/write wkb hex values. Returned geometries are 344 owned by the caller.*/ 345 unsigned char* GEOSGeomToHEX_buf(const Geometry * g,size_t * size)346 GEOSGeomToHEX_buf(const Geometry* g, size_t* size) 347 { 348 return GEOSGeomToHEX_buf_r(handle, g, size); 349 } 350 351 Geometry* GEOSGeomFromHEX_buf(const unsigned char * hex,size_t size)352 GEOSGeomFromHEX_buf(const unsigned char* hex, size_t size) 353 { 354 return GEOSGeomFromHEX_buf_r(handle, hex, size); 355 } 356 357 char GEOSisEmpty(const Geometry * g)358 GEOSisEmpty(const Geometry* g) 359 { 360 return GEOSisEmpty_r(handle, g); 361 } 362 363 char GEOSisSimple(const Geometry * g)364 GEOSisSimple(const Geometry* g) 365 { 366 return GEOSisSimple_r(handle, g); 367 } 368 369 char GEOSisRing(const Geometry * g)370 GEOSisRing(const Geometry* g) 371 { 372 return GEOSisRing_r(handle, g); 373 } 374 375 376 377 //free the result of this 378 char* GEOSGeomType(const Geometry * g)379 GEOSGeomType(const Geometry* g) 380 { 381 return GEOSGeomType_r(handle, g); 382 } 383 384 // Return postgis geometry type index 385 int GEOSGeomTypeId(const Geometry * g)386 GEOSGeomTypeId(const Geometry* g) 387 { 388 return GEOSGeomTypeId_r(handle, g); 389 } 390 391 392 393 394 //------------------------------------------------------------------- 395 // GEOS functions that return geometries 396 //------------------------------------------------------------------- 397 398 Geometry* GEOSEnvelope(const Geometry * g)399 GEOSEnvelope(const Geometry* g) 400 { 401 return GEOSEnvelope_r(handle, g); 402 } 403 404 Geometry* GEOSIntersection(const Geometry * g1,const Geometry * g2)405 GEOSIntersection(const Geometry* g1, const Geometry* g2) 406 { 407 return GEOSIntersection_r(handle, g1, g2); 408 } 409 410 Geometry* GEOSIntersectionPrec(const Geometry * g1,const Geometry * g2,double gridSize)411 GEOSIntersectionPrec(const Geometry* g1, const Geometry* g2, double gridSize) 412 { 413 return GEOSIntersectionPrec_r(handle, g1, g2, gridSize); 414 } 415 416 Geometry* GEOSBuffer(const Geometry * g,double width,int quadrantsegments)417 GEOSBuffer(const Geometry* g, double width, int quadrantsegments) 418 { 419 return GEOSBuffer_r(handle, g, width, quadrantsegments); 420 } 421 422 Geometry* GEOSBufferWithStyle(const Geometry * g,double width,int quadsegs,int endCapStyle,int joinStyle,double mitreLimit)423 GEOSBufferWithStyle(const Geometry* g, double width, int quadsegs, 424 int endCapStyle, int joinStyle, double mitreLimit) 425 { 426 return GEOSBufferWithStyle_r(handle, g, width, quadsegs, endCapStyle, 427 joinStyle, mitreLimit); 428 } 429 430 Geometry* GEOSSingleSidedBuffer(const Geometry * g,double width,int quadsegs,int joinStyle,double mitreLimit,int leftSide)431 GEOSSingleSidedBuffer(const Geometry* g, double width, int quadsegs, 432 int joinStyle, double mitreLimit, int leftSide) 433 { 434 return GEOSSingleSidedBuffer_r(handle, g, width, quadsegs, 435 joinStyle, mitreLimit, leftSide); 436 } 437 438 Geometry* GEOSOffsetCurve(const Geometry * g,double width,int quadsegs,int joinStyle,double mitreLimit)439 GEOSOffsetCurve(const Geometry* g, double width, int quadsegs, 440 int joinStyle, double mitreLimit) 441 { 442 return GEOSOffsetCurve_r(handle, g, width, quadsegs, 443 joinStyle, mitreLimit); 444 } 445 446 Geometry* GEOSConvexHull(const Geometry * g)447 GEOSConvexHull(const Geometry* g) 448 { 449 return GEOSConvexHull_r(handle, g); 450 } 451 452 Geometry* GEOSMinimumRotatedRectangle(const Geometry * g)453 GEOSMinimumRotatedRectangle(const Geometry* g) 454 { 455 return GEOSMinimumRotatedRectangle_r(handle, g); 456 } 457 458 Geometry* GEOSMaximumInscribedCircle(const Geometry * g,double tolerance)459 GEOSMaximumInscribedCircle(const Geometry* g, double tolerance) 460 { 461 return GEOSMaximumInscribedCircle_r(handle, g, tolerance); 462 } 463 464 Geometry* GEOSLargestEmptyCircle(const Geometry * g,const Geometry * boundary,double tolerance)465 GEOSLargestEmptyCircle(const Geometry* g, const Geometry* boundary, double tolerance) 466 { 467 return GEOSLargestEmptyCircle_r(handle, g, boundary, tolerance); 468 } 469 470 Geometry* GEOSMinimumWidth(const Geometry * g)471 GEOSMinimumWidth(const Geometry* g) 472 { 473 return GEOSMinimumWidth_r(handle, g); 474 } 475 476 Geometry* GEOSMinimumClearanceLine(const Geometry * g)477 GEOSMinimumClearanceLine(const Geometry* g) 478 { 479 return GEOSMinimumClearanceLine_r(handle, g); 480 } 481 482 int GEOSMinimumClearance(const Geometry * g,double * d)483 GEOSMinimumClearance(const Geometry* g, double* d) 484 { 485 return GEOSMinimumClearance_r(handle, g, d); 486 } 487 488 Geometry* GEOSDifference(const Geometry * g1,const Geometry * g2)489 GEOSDifference(const Geometry* g1, const Geometry* g2) 490 { 491 return GEOSDifference_r(handle, g1, g2); 492 } 493 494 Geometry* GEOSDifferencePrec(const Geometry * g1,const Geometry * g2,double gridSize)495 GEOSDifferencePrec(const Geometry* g1, const Geometry* g2, double gridSize) 496 { 497 return GEOSDifferencePrec_r(handle, g1, g2, gridSize); 498 } 499 500 Geometry* GEOSBoundary(const Geometry * g)501 GEOSBoundary(const Geometry* g) 502 { 503 return GEOSBoundary_r(handle, g); 504 } 505 506 Geometry* GEOSSymDifference(const Geometry * g1,const Geometry * g2)507 GEOSSymDifference(const Geometry* g1, const Geometry* g2) 508 { 509 return GEOSSymDifference_r(handle, g1, g2); 510 } 511 512 Geometry* GEOSSymDifferencePrec(const Geometry * g1,const Geometry * g2,double gridSize)513 GEOSSymDifferencePrec(const Geometry* g1, const Geometry* g2, double gridSize) 514 { 515 return GEOSSymDifferencePrec_r(handle, g1, g2, gridSize); 516 } 517 518 Geometry* GEOSUnion(const Geometry * g1,const Geometry * g2)519 GEOSUnion(const Geometry* g1, const Geometry* g2) 520 { 521 return GEOSUnion_r(handle, g1, g2); 522 } 523 524 Geometry* GEOSUnionPrec(const Geometry * g1,const Geometry * g2,double gridSize)525 GEOSUnionPrec(const Geometry* g1, const Geometry* g2, double gridSize) 526 { 527 return GEOSUnionPrec_r(handle, g1, g2, gridSize); 528 } 529 530 Geometry* GEOSUnaryUnion(const Geometry * g)531 GEOSUnaryUnion(const Geometry* g) 532 { 533 return GEOSUnaryUnion_r(handle, g); 534 } 535 536 Geometry* GEOSUnaryUnionPrec(const Geometry * g,double gridSize)537 GEOSUnaryUnionPrec(const Geometry* g, double gridSize) 538 { 539 return GEOSUnaryUnionPrec_r(handle, g, gridSize); 540 } 541 542 Geometry* GEOSCoverageUnion(const Geometry * g)543 GEOSCoverageUnion(const Geometry* g) 544 { 545 return GEOSCoverageUnion_r(handle, g); 546 } 547 548 Geometry* GEOSNode(const Geometry * g)549 GEOSNode(const Geometry* g) 550 { 551 return GEOSNode_r(handle, g); 552 } 553 554 Geometry* GEOSUnionCascaded(const Geometry * g)555 GEOSUnionCascaded(const Geometry* g) 556 { 557 return GEOSUnionCascaded_r(handle, g); 558 } 559 560 Geometry* GEOSPointOnSurface(const Geometry * g)561 GEOSPointOnSurface(const Geometry* g) 562 { 563 return GEOSPointOnSurface_r(handle, g); 564 } 565 566 567 Geometry* GEOSClipByRect(const Geometry * g,double xmin,double ymin,double xmax,double ymax)568 GEOSClipByRect(const Geometry* g, double xmin, double ymin, double xmax, double ymax) 569 { 570 return GEOSClipByRect_r(handle, g, xmin, ymin, xmax, ymax); 571 } 572 573 574 575 //------------------------------------------------------------------- 576 // memory management functions 577 //------------------------------------------------------------------ 578 579 580 void GEOSGeom_destroy(Geometry * a)581 GEOSGeom_destroy(Geometry* a) 582 { 583 return GEOSGeom_destroy_r(handle, a); 584 } 585 586 587 int GEOSGetNumCoordinates(const Geometry * g)588 GEOSGetNumCoordinates(const Geometry* g) 589 { 590 return GEOSGetNumCoordinates_r(handle, g); 591 } 592 593 /* 594 * Return -1 on exception, 0 otherwise. 595 * Converts Geometry to normal form (or canonical form). 596 */ 597 int GEOSNormalize(Geometry * g)598 GEOSNormalize(Geometry* g) 599 { 600 return GEOSNormalize_r(handle, g); 601 } 602 603 int GEOSGetNumInteriorRings(const Geometry * g)604 GEOSGetNumInteriorRings(const Geometry* g) 605 { 606 return GEOSGetNumInteriorRings_r(handle, g); 607 } 608 609 610 // returns -1 on error and 1 for non-multi geometries 611 int GEOSGetNumGeometries(const Geometry * g)612 GEOSGetNumGeometries(const Geometry* g) 613 { 614 return GEOSGetNumGeometries_r(handle, g); 615 } 616 617 618 /* 619 * Call only on GEOMETRYCOLLECTION or MULTI*. 620 * Return a pointer to the internal Geometry. 621 */ 622 const Geometry* GEOSGetGeometryN(const Geometry * g,int n)623 GEOSGetGeometryN(const Geometry* g, int n) 624 { 625 return GEOSGetGeometryN_r(handle, g, n); 626 } 627 628 /* 629 * Call only on LINESTRING 630 * Returns NULL on exception 631 */ 632 Geometry* GEOSGeomGetPointN(const Geometry * g,int n)633 GEOSGeomGetPointN(const Geometry* g, int n) 634 { 635 return GEOSGeomGetPointN_r(handle, g, n); 636 } 637 638 /* 639 * Call only on LINESTRING 640 */ 641 Geometry* GEOSGeomGetStartPoint(const Geometry * g)642 GEOSGeomGetStartPoint(const Geometry* g) 643 { 644 return GEOSGeomGetStartPoint_r(handle, g); 645 } 646 647 /* 648 * Call only on LINESTRING 649 */ 650 Geometry* GEOSGeomGetEndPoint(const Geometry * g)651 GEOSGeomGetEndPoint(const Geometry* g) 652 { 653 return GEOSGeomGetEndPoint_r(handle, g); 654 } 655 656 /* 657 * Call only on LINESTRING 658 * return 2 on exception, 1 on true, 0 on false 659 */ 660 char GEOSisClosed(const Geometry * g)661 GEOSisClosed(const Geometry* g) 662 { 663 return GEOSisClosed_r(handle, g); 664 } 665 666 /* 667 * Call only on LINESTRING 668 * returns 0 on exception, otherwise 1 669 */ 670 int GEOSGeomGetLength(const Geometry * g,double * length)671 GEOSGeomGetLength(const Geometry* g, double* length) 672 { 673 return GEOSGeomGetLength_r(handle, g, length); 674 } 675 676 /* 677 * Call only on LINESTRING 678 * returns -1 on exception 679 */ 680 int GEOSGeomGetNumPoints(const Geometry * g)681 GEOSGeomGetNumPoints(const Geometry* g) 682 { 683 return GEOSGeomGetNumPoints_r(handle, g); 684 } 685 686 /* 687 * For POINT 688 * returns 0 on exception, otherwise 1 689 */ 690 int GEOSGeomGetX(const Geometry * g,double * x)691 GEOSGeomGetX(const Geometry* g, double* x) 692 { 693 return GEOSGeomGetX_r(handle, g, x); 694 } 695 696 /* 697 * For POINT 698 * returns 0 on exception, otherwise 1 699 */ 700 int GEOSGeomGetY(const Geometry * g,double * y)701 GEOSGeomGetY(const Geometry* g, double* y) 702 { 703 return GEOSGeomGetY_r(handle, g, y); 704 } 705 706 /* 707 * For POINT 708 * returns 0 on exception, otherwise 1 709 */ 710 int GEOSGeomGetZ(const Geometry * g1,double * z)711 GEOSGeomGetZ(const Geometry* g1, double* z) 712 { 713 return GEOSGeomGetZ_r(handle, g1, z); 714 } 715 716 /* 717 * Call only on polygon 718 * Return a copy of the internal Geometry. 719 */ 720 const Geometry* GEOSGetExteriorRing(const Geometry * g)721 GEOSGetExteriorRing(const Geometry* g) 722 { 723 return GEOSGetExteriorRing_r(handle, g); 724 } 725 726 /* 727 * Call only on polygon 728 * Return a pointer to internal storage, do not destroy it. 729 */ 730 const Geometry* GEOSGetInteriorRingN(const Geometry * g,int n)731 GEOSGetInteriorRingN(const Geometry* g, int n) 732 { 733 return GEOSGetInteriorRingN_r(handle, g, n); 734 } 735 736 Geometry* GEOSGetCentroid(const Geometry * g)737 GEOSGetCentroid(const Geometry* g) 738 { 739 return GEOSGetCentroid_r(handle, g); 740 } 741 742 Geometry* GEOSMinimumBoundingCircle(const Geometry * g,double * radius,Geometry ** center)743 GEOSMinimumBoundingCircle(const Geometry* g, double* radius, Geometry** center) 744 { 745 return GEOSMinimumBoundingCircle_r(handle, g, radius, center); 746 } 747 748 Geometry* GEOSGeom_createCollection(int type,Geometry ** geoms,unsigned int ngeoms)749 GEOSGeom_createCollection(int type, Geometry** geoms, unsigned int ngeoms) 750 { 751 return GEOSGeom_createCollection_r(handle, type, geoms, ngeoms); 752 } 753 754 Geometry* GEOSPolygonize(const Geometry * const * g,unsigned int ngeoms)755 GEOSPolygonize(const Geometry* const* g, unsigned int ngeoms) 756 { 757 return GEOSPolygonize_r(handle, g, ngeoms); 758 } 759 760 Geometry* GEOSPolygonize_valid(const Geometry * const * g,unsigned int ngeoms)761 GEOSPolygonize_valid(const Geometry* const* g, unsigned int ngeoms) 762 { 763 return GEOSPolygonize_valid_r(handle, g, ngeoms); 764 } 765 766 Geometry* GEOSPolygonizer_getCutEdges(const Geometry * const * g,unsigned int ngeoms)767 GEOSPolygonizer_getCutEdges(const Geometry* const* g, unsigned int ngeoms) 768 { 769 return GEOSPolygonizer_getCutEdges_r(handle, g, ngeoms); 770 } 771 772 GEOSGeometry* GEOSPolygonize_full(const GEOSGeometry * input,GEOSGeometry ** cuts,GEOSGeometry ** dangles,GEOSGeometry ** invalid)773 GEOSPolygonize_full(const GEOSGeometry* input, 774 GEOSGeometry** cuts, GEOSGeometry** dangles, GEOSGeometry** invalid) 775 { 776 return GEOSPolygonize_full_r(handle, input, cuts, dangles, invalid); 777 } 778 779 Geometry* GEOSBuildArea(const Geometry * g)780 GEOSBuildArea(const Geometry* g) 781 { 782 return GEOSBuildArea_r(handle, g); 783 } 784 785 Geometry* GEOSMakeValid(const Geometry * g)786 GEOSMakeValid(const Geometry* g) 787 { 788 return GEOSMakeValid_r(handle, g); 789 } 790 791 Geometry* GEOSLineMerge(const Geometry * g)792 GEOSLineMerge(const Geometry* g) 793 { 794 return GEOSLineMerge_r(handle, g); 795 } 796 797 Geometry* GEOSReverse(const Geometry * g)798 GEOSReverse(const Geometry* g) 799 { 800 return GEOSReverse_r(handle, g); 801 } 802 803 int GEOSGetSRID(const Geometry * g)804 GEOSGetSRID(const Geometry* g) 805 { 806 return GEOSGetSRID_r(handle, g); 807 } 808 809 void GEOSSetSRID(Geometry * g,int srid)810 GEOSSetSRID(Geometry* g, int srid) 811 { 812 return GEOSSetSRID_r(handle, g, srid); 813 } 814 815 void* GEOSGeom_getUserData(const Geometry * g)816 GEOSGeom_getUserData(const Geometry* g) 817 { 818 return GEOSGeom_getUserData_r(handle, g); 819 } 820 821 void GEOSGeom_setUserData(Geometry * g,void * userData)822 GEOSGeom_setUserData(Geometry* g, void* userData) 823 { 824 return GEOSGeom_setUserData_r(handle, g, userData); 825 } 826 827 char GEOSHasZ(const Geometry * g)828 GEOSHasZ(const Geometry* g) 829 { 830 return GEOSHasZ_r(handle, g); 831 } 832 833 int GEOS_getWKBOutputDims()834 GEOS_getWKBOutputDims() 835 { 836 return GEOS_getWKBOutputDims_r(handle); 837 } 838 839 int GEOS_setWKBOutputDims(int newdims)840 GEOS_setWKBOutputDims(int newdims) 841 { 842 return GEOS_setWKBOutputDims_r(handle, newdims); 843 } 844 845 int GEOS_getWKBByteOrder()846 GEOS_getWKBByteOrder() 847 { 848 return GEOS_getWKBByteOrder_r(handle); 849 } 850 851 int GEOS_setWKBByteOrder(int byteOrder)852 GEOS_setWKBByteOrder(int byteOrder) 853 { 854 return GEOS_setWKBByteOrder_r(handle, byteOrder); 855 } 856 857 858 CoordinateSequence* GEOSCoordSeq_create(unsigned int size,unsigned int dims)859 GEOSCoordSeq_create(unsigned int size, unsigned int dims) 860 { 861 return GEOSCoordSeq_create_r(handle, size, dims); 862 } 863 864 int GEOSCoordSeq_setOrdinate(CoordinateSequence * s,unsigned int idx,unsigned int dim,double val)865 GEOSCoordSeq_setOrdinate(CoordinateSequence* s, unsigned int idx, unsigned int dim, double val) 866 { 867 return GEOSCoordSeq_setOrdinate_r(handle, s, idx, dim, val); 868 } 869 870 int GEOSCoordSeq_setX(CoordinateSequence * s,unsigned int idx,double val)871 GEOSCoordSeq_setX(CoordinateSequence* s, unsigned int idx, double val) 872 { 873 return GEOSCoordSeq_setOrdinate(s, idx, 0, val); 874 } 875 876 int GEOSCoordSeq_setY(CoordinateSequence * s,unsigned int idx,double val)877 GEOSCoordSeq_setY(CoordinateSequence* s, unsigned int idx, double val) 878 { 879 return GEOSCoordSeq_setOrdinate(s, idx, 1, val); 880 } 881 882 int GEOSCoordSeq_setZ(CoordinateSequence * s,unsigned int idx,double val)883 GEOSCoordSeq_setZ(CoordinateSequence* s, unsigned int idx, double val) 884 { 885 return GEOSCoordSeq_setOrdinate(s, idx, 2, val); 886 } 887 888 int GEOSCoordSeq_setXY(CoordinateSequence * s,unsigned int idx,double x,double y)889 GEOSCoordSeq_setXY(CoordinateSequence* s, unsigned int idx, double x, double y) 890 { 891 return GEOSCoordSeq_setXY_r(handle, s, idx, x, y); 892 } 893 894 int GEOSCoordSeq_setXYZ(CoordinateSequence * s,unsigned int idx,double x,double y,double z)895 GEOSCoordSeq_setXYZ(CoordinateSequence* s, unsigned int idx, double x, double y, double z) 896 { 897 return GEOSCoordSeq_setXYZ_r(handle, s, idx, x, y, z); 898 } 899 900 CoordinateSequence* GEOSCoordSeq_clone(const CoordinateSequence * s)901 GEOSCoordSeq_clone(const CoordinateSequence* s) 902 { 903 return GEOSCoordSeq_clone_r(handle, s); 904 } 905 906 int GEOSCoordSeq_getOrdinate(const CoordinateSequence * s,unsigned int idx,unsigned int dim,double * val)907 GEOSCoordSeq_getOrdinate(const CoordinateSequence* s, unsigned int idx, unsigned int dim, double* val) 908 { 909 return GEOSCoordSeq_getOrdinate_r(handle, s, idx, dim, val); 910 } 911 912 int GEOSCoordSeq_getX(const CoordinateSequence * s,unsigned int idx,double * val)913 GEOSCoordSeq_getX(const CoordinateSequence* s, unsigned int idx, double* val) 914 { 915 return GEOSCoordSeq_getOrdinate(s, idx, 0, val); 916 } 917 918 int GEOSCoordSeq_getY(const CoordinateSequence * s,unsigned int idx,double * val)919 GEOSCoordSeq_getY(const CoordinateSequence* s, unsigned int idx, double* val) 920 { 921 return GEOSCoordSeq_getOrdinate(s, idx, 1, val); 922 } 923 924 int GEOSCoordSeq_getZ(const CoordinateSequence * s,unsigned int idx,double * val)925 GEOSCoordSeq_getZ(const CoordinateSequence* s, unsigned int idx, double* val) 926 { 927 return GEOSCoordSeq_getOrdinate(s, idx, 2, val); 928 } 929 930 int GEOSCoordSeq_getXY(const CoordinateSequence * s,unsigned int idx,double * x,double * y)931 GEOSCoordSeq_getXY(const CoordinateSequence* s, unsigned int idx, double* x, double* y) 932 { 933 return GEOSCoordSeq_getXY_r(handle, s, idx, x, y); 934 } 935 936 int GEOSCoordSeq_getXYZ(const CoordinateSequence * s,unsigned int idx,double * x,double * y,double * z)937 GEOSCoordSeq_getXYZ(const CoordinateSequence* s, unsigned int idx, double* x, double* y, double* z) 938 { 939 return GEOSCoordSeq_getXYZ_r(handle, s, idx, x, y, z); 940 } 941 942 int GEOSCoordSeq_getSize(const CoordinateSequence * s,unsigned int * size)943 GEOSCoordSeq_getSize(const CoordinateSequence* s, unsigned int* size) 944 { 945 return GEOSCoordSeq_getSize_r(handle, s, size); 946 } 947 948 int GEOSCoordSeq_getDimensions(const CoordinateSequence * s,unsigned int * dims)949 GEOSCoordSeq_getDimensions(const CoordinateSequence* s, unsigned int* dims) 950 { 951 return GEOSCoordSeq_getDimensions_r(handle, s, dims); 952 } 953 954 int GEOSCoordSeq_isCCW(const CoordinateSequence * s,char * is_ccw)955 GEOSCoordSeq_isCCW(const CoordinateSequence* s, char* is_ccw) 956 { 957 return GEOSCoordSeq_isCCW_r(handle, s, is_ccw); 958 } 959 960 void GEOSCoordSeq_destroy(CoordinateSequence * s)961 GEOSCoordSeq_destroy(CoordinateSequence* s) 962 { 963 return GEOSCoordSeq_destroy_r(handle, s); 964 } 965 966 const CoordinateSequence* GEOSGeom_getCoordSeq(const Geometry * g)967 GEOSGeom_getCoordSeq(const Geometry* g) 968 { 969 return GEOSGeom_getCoordSeq_r(handle, g); 970 } 971 972 Geometry* GEOSGeom_createPoint(CoordinateSequence * cs)973 GEOSGeom_createPoint(CoordinateSequence* cs) 974 { 975 return GEOSGeom_createPoint_r(handle, cs); 976 } 977 978 Geometry* GEOSGeom_createPointFromXY(double x,double y)979 GEOSGeom_createPointFromXY(double x, double y) 980 { 981 return GEOSGeom_createPointFromXY_r(handle, x, y); 982 } 983 984 Geometry* GEOSGeom_createLinearRing(CoordinateSequence * cs)985 GEOSGeom_createLinearRing(CoordinateSequence* cs) 986 { 987 return GEOSGeom_createLinearRing_r(handle, cs); 988 } 989 990 Geometry* GEOSGeom_createLineString(CoordinateSequence * cs)991 GEOSGeom_createLineString(CoordinateSequence* cs) 992 { 993 return GEOSGeom_createLineString_r(handle, cs); 994 } 995 996 Geometry* GEOSGeom_createPolygon(Geometry * shell,Geometry ** holes,unsigned int nholes)997 GEOSGeom_createPolygon(Geometry* shell, Geometry** holes, unsigned int nholes) 998 { 999 return GEOSGeom_createPolygon_r(handle, shell, holes, nholes); 1000 } 1001 1002 Geometry* GEOSGeom_clone(const Geometry * g)1003 GEOSGeom_clone(const Geometry* g) 1004 { 1005 return GEOSGeom_clone_r(handle, g); 1006 } 1007 1008 GEOSGeometry* GEOSGeom_setPrecision(const GEOSGeometry * g,double gridSize,int flags)1009 GEOSGeom_setPrecision(const GEOSGeometry* g, double gridSize, int flags) 1010 { 1011 return GEOSGeom_setPrecision_r(handle, g, gridSize, flags); 1012 } 1013 1014 double GEOSGeom_getPrecision(const GEOSGeometry * g)1015 GEOSGeom_getPrecision(const GEOSGeometry* g) 1016 { 1017 return GEOSGeom_getPrecision_r(handle, g); 1018 } 1019 1020 int GEOSGeom_getDimensions(const Geometry * g)1021 GEOSGeom_getDimensions(const Geometry* g) 1022 { 1023 return GEOSGeom_getDimensions_r(handle, g); 1024 } 1025 1026 int GEOSGeom_getCoordinateDimension(const Geometry * g)1027 GEOSGeom_getCoordinateDimension(const Geometry* g) 1028 { 1029 return GEOSGeom_getCoordinateDimension_r(handle, g); 1030 } 1031 GEOSGeom_getXMin(const GEOSGeometry * g,double * value)1032 int GEOS_DLL GEOSGeom_getXMin(const GEOSGeometry* g, double* value) 1033 { 1034 return GEOSGeom_getXMin_r(handle, g, value); 1035 } 1036 GEOSGeom_getYMin(const GEOSGeometry * g,double * value)1037 int GEOS_DLL GEOSGeom_getYMin(const GEOSGeometry* g, double* value) 1038 { 1039 return GEOSGeom_getYMin_r(handle, g, value); 1040 } 1041 GEOSGeom_getXMax(const GEOSGeometry * g,double * value)1042 int GEOS_DLL GEOSGeom_getXMax(const GEOSGeometry* g, double* value) 1043 { 1044 return GEOSGeom_getXMax_r(handle, g, value); 1045 } 1046 GEOSGeom_getYMax(const GEOSGeometry * g,double * value)1047 int GEOS_DLL GEOSGeom_getYMax(const GEOSGeometry* g, double* value) 1048 { 1049 return GEOSGeom_getYMax_r(handle, g, value); 1050 } 1051 1052 Geometry* GEOSSimplify(const Geometry * g,double tolerance)1053 GEOSSimplify(const Geometry* g, double tolerance) 1054 { 1055 return GEOSSimplify_r(handle, g, tolerance); 1056 } 1057 1058 Geometry* GEOSTopologyPreserveSimplify(const Geometry * g,double tolerance)1059 GEOSTopologyPreserveSimplify(const Geometry* g, double tolerance) 1060 { 1061 return GEOSTopologyPreserveSimplify_r(handle, g, tolerance); 1062 } 1063 1064 1065 /* WKT Reader */ 1066 WKTReader* GEOSWKTReader_create()1067 GEOSWKTReader_create() 1068 { 1069 return GEOSWKTReader_create_r(handle); 1070 } 1071 1072 void GEOSWKTReader_destroy(WKTReader * reader)1073 GEOSWKTReader_destroy(WKTReader* reader) 1074 { 1075 GEOSWKTReader_destroy_r(handle, reader); 1076 } 1077 1078 1079 Geometry* GEOSWKTReader_read(WKTReader * reader,const char * wkt)1080 GEOSWKTReader_read(WKTReader* reader, const char* wkt) 1081 { 1082 return GEOSWKTReader_read_r(handle, reader, wkt); 1083 } 1084 1085 /* WKT Writer */ 1086 WKTWriter* GEOSWKTWriter_create()1087 GEOSWKTWriter_create() 1088 { 1089 return GEOSWKTWriter_create_r(handle); 1090 } 1091 1092 void GEOSWKTWriter_destroy(WKTWriter * Writer)1093 GEOSWKTWriter_destroy(WKTWriter* Writer) 1094 { 1095 GEOSWKTWriter_destroy_r(handle, Writer); 1096 } 1097 1098 char* GEOSWKTWriter_write(WKTWriter * writer,const Geometry * geom)1099 GEOSWKTWriter_write(WKTWriter* writer, const Geometry* geom) 1100 { 1101 return GEOSWKTWriter_write_r(handle, writer, geom); 1102 } 1103 1104 void GEOSWKTWriter_setTrim(WKTWriter * writer,char trim)1105 GEOSWKTWriter_setTrim(WKTWriter* writer, char trim) 1106 { 1107 GEOSWKTWriter_setTrim_r(handle, writer, trim); 1108 } 1109 1110 void GEOSWKTWriter_setRoundingPrecision(WKTWriter * writer,int precision)1111 GEOSWKTWriter_setRoundingPrecision(WKTWriter* writer, int precision) 1112 { 1113 return GEOSWKTWriter_setRoundingPrecision_r(handle, writer, precision); 1114 } 1115 1116 void GEOSWKTWriter_setOutputDimension(WKTWriter * writer,int dim)1117 GEOSWKTWriter_setOutputDimension(WKTWriter* writer, int dim) 1118 { 1119 GEOSWKTWriter_setOutputDimension_r(handle, writer, dim); 1120 } 1121 1122 int GEOSWKTWriter_getOutputDimension(WKTWriter * writer)1123 GEOSWKTWriter_getOutputDimension(WKTWriter* writer) 1124 { 1125 return GEOSWKTWriter_getOutputDimension_r(handle, writer); 1126 } 1127 1128 void GEOSWKTWriter_setOld3D(WKTWriter * writer,int useOld3D)1129 GEOSWKTWriter_setOld3D(WKTWriter* writer, int useOld3D) 1130 { 1131 GEOSWKTWriter_setOld3D_r(handle, writer, useOld3D); 1132 } 1133 1134 /* WKB Reader */ 1135 WKBReader* GEOSWKBReader_create()1136 GEOSWKBReader_create() 1137 { 1138 return GEOSWKBReader_create_r(handle); 1139 } 1140 1141 void GEOSWKBReader_destroy(WKBReader * reader)1142 GEOSWKBReader_destroy(WKBReader* reader) 1143 { 1144 GEOSWKBReader_destroy_r(handle, reader); 1145 } 1146 1147 1148 Geometry* GEOSWKBReader_read(WKBReader * reader,const unsigned char * wkb,size_t size)1149 GEOSWKBReader_read(WKBReader* reader, const unsigned char* wkb, size_t size) 1150 { 1151 return GEOSWKBReader_read_r(handle, reader, wkb, size); 1152 } 1153 1154 Geometry* GEOSWKBReader_readHEX(WKBReader * reader,const unsigned char * hex,size_t size)1155 GEOSWKBReader_readHEX(WKBReader* reader, const unsigned char* hex, size_t size) 1156 { 1157 return GEOSWKBReader_readHEX_r(handle, reader, hex, size); 1158 } 1159 1160 /* WKB Writer */ 1161 WKBWriter* GEOSWKBWriter_create()1162 GEOSWKBWriter_create() 1163 { 1164 return GEOSWKBWriter_create_r(handle); 1165 } 1166 1167 void GEOSWKBWriter_destroy(WKBWriter * Writer)1168 GEOSWKBWriter_destroy(WKBWriter* Writer) 1169 { 1170 GEOSWKBWriter_destroy_r(handle, Writer); 1171 } 1172 1173 1174 /* The caller owns the result */ 1175 unsigned char* GEOSWKBWriter_write(WKBWriter * writer,const Geometry * geom,size_t * size)1176 GEOSWKBWriter_write(WKBWriter* writer, const Geometry* geom, size_t* size) 1177 { 1178 return GEOSWKBWriter_write_r(handle, writer, geom, size); 1179 } 1180 1181 /* The caller owns the result */ 1182 unsigned char* GEOSWKBWriter_writeHEX(WKBWriter * writer,const Geometry * geom,size_t * size)1183 GEOSWKBWriter_writeHEX(WKBWriter* writer, const Geometry* geom, size_t* size) 1184 { 1185 return GEOSWKBWriter_writeHEX_r(handle, writer, geom, size); 1186 } 1187 1188 int GEOSWKBWriter_getOutputDimension(const GEOSWKBWriter * writer)1189 GEOSWKBWriter_getOutputDimension(const GEOSWKBWriter* writer) 1190 { 1191 return GEOSWKBWriter_getOutputDimension_r(handle, writer); 1192 } 1193 1194 void GEOSWKBWriter_setOutputDimension(GEOSWKBWriter * writer,int newDimension)1195 GEOSWKBWriter_setOutputDimension(GEOSWKBWriter* writer, int newDimension) 1196 { 1197 GEOSWKBWriter_setOutputDimension_r(handle, writer, newDimension); 1198 } 1199 1200 int GEOSWKBWriter_getByteOrder(const GEOSWKBWriter * writer)1201 GEOSWKBWriter_getByteOrder(const GEOSWKBWriter* writer) 1202 { 1203 return GEOSWKBWriter_getByteOrder_r(handle, writer); 1204 } 1205 1206 void GEOSWKBWriter_setByteOrder(GEOSWKBWriter * writer,int newByteOrder)1207 GEOSWKBWriter_setByteOrder(GEOSWKBWriter* writer, int newByteOrder) 1208 { 1209 GEOSWKBWriter_setByteOrder_r(handle, writer, newByteOrder); 1210 } 1211 1212 char GEOSWKBWriter_getIncludeSRID(const GEOSWKBWriter * writer)1213 GEOSWKBWriter_getIncludeSRID(const GEOSWKBWriter* writer) 1214 { 1215 return GEOSWKBWriter_getIncludeSRID_r(handle, writer); 1216 } 1217 1218 void GEOSWKBWriter_setIncludeSRID(GEOSWKBWriter * writer,const char newIncludeSRID)1219 GEOSWKBWriter_setIncludeSRID(GEOSWKBWriter* writer, const char newIncludeSRID) 1220 { 1221 GEOSWKBWriter_setIncludeSRID_r(handle, writer, newIncludeSRID); 1222 } 1223 1224 1225 //----------------------------------------------------------------- 1226 // Prepared Geometry 1227 //----------------------------------------------------------------- 1228 1229 const geos::geom::prep::PreparedGeometry* GEOSPrepare(const Geometry * g)1230 GEOSPrepare(const Geometry* g) 1231 { 1232 return GEOSPrepare_r(handle, g); 1233 } 1234 1235 void GEOSPreparedGeom_destroy(const geos::geom::prep::PreparedGeometry * a)1236 GEOSPreparedGeom_destroy(const geos::geom::prep::PreparedGeometry* a) 1237 { 1238 GEOSPreparedGeom_destroy_r(handle, a); 1239 } 1240 1241 char GEOSPreparedContains(const geos::geom::prep::PreparedGeometry * pg1,const Geometry * g2)1242 GEOSPreparedContains(const geos::geom::prep::PreparedGeometry* pg1, const Geometry* g2) 1243 { 1244 return GEOSPreparedContains_r(handle, pg1, g2); 1245 } 1246 1247 char GEOSPreparedContainsProperly(const geos::geom::prep::PreparedGeometry * pg1,const Geometry * g2)1248 GEOSPreparedContainsProperly(const geos::geom::prep::PreparedGeometry* pg1, const Geometry* g2) 1249 { 1250 return GEOSPreparedContainsProperly_r(handle, pg1, g2); 1251 } 1252 1253 char GEOSPreparedCoveredBy(const geos::geom::prep::PreparedGeometry * pg1,const Geometry * g2)1254 GEOSPreparedCoveredBy(const geos::geom::prep::PreparedGeometry* pg1, const Geometry* g2) 1255 { 1256 return GEOSPreparedCoveredBy_r(handle, pg1, g2); 1257 } 1258 1259 char GEOSPreparedCovers(const geos::geom::prep::PreparedGeometry * pg1,const Geometry * g2)1260 GEOSPreparedCovers(const geos::geom::prep::PreparedGeometry* pg1, const Geometry* g2) 1261 { 1262 return GEOSPreparedCovers_r(handle, pg1, g2); 1263 } 1264 1265 char GEOSPreparedCrosses(const geos::geom::prep::PreparedGeometry * pg1,const Geometry * g2)1266 GEOSPreparedCrosses(const geos::geom::prep::PreparedGeometry* pg1, const Geometry* g2) 1267 { 1268 return GEOSPreparedCrosses_r(handle, pg1, g2); 1269 } 1270 1271 char GEOSPreparedDisjoint(const geos::geom::prep::PreparedGeometry * pg1,const Geometry * g2)1272 GEOSPreparedDisjoint(const geos::geom::prep::PreparedGeometry* pg1, const Geometry* g2) 1273 { 1274 return GEOSPreparedDisjoint_r(handle, pg1, g2); 1275 } 1276 1277 char GEOSPreparedIntersects(const geos::geom::prep::PreparedGeometry * pg1,const Geometry * g2)1278 GEOSPreparedIntersects(const geos::geom::prep::PreparedGeometry* pg1, const Geometry* g2) 1279 { 1280 return GEOSPreparedIntersects_r(handle, pg1, g2); 1281 } 1282 1283 char GEOSPreparedOverlaps(const geos::geom::prep::PreparedGeometry * pg1,const Geometry * g2)1284 GEOSPreparedOverlaps(const geos::geom::prep::PreparedGeometry* pg1, const Geometry* g2) 1285 { 1286 return GEOSPreparedOverlaps_r(handle, pg1, g2); 1287 } 1288 1289 char GEOSPreparedTouches(const geos::geom::prep::PreparedGeometry * pg1,const Geometry * g2)1290 GEOSPreparedTouches(const geos::geom::prep::PreparedGeometry* pg1, const Geometry* g2) 1291 { 1292 return GEOSPreparedTouches_r(handle, pg1, g2); 1293 } 1294 1295 char GEOSPreparedWithin(const geos::geom::prep::PreparedGeometry * pg1,const Geometry * g2)1296 GEOSPreparedWithin(const geos::geom::prep::PreparedGeometry* pg1, const Geometry* g2) 1297 { 1298 return GEOSPreparedWithin_r(handle, pg1, g2); 1299 } 1300 1301 CoordinateSequence* GEOSPreparedNearestPoints(const geos::geom::prep::PreparedGeometry * g1,const Geometry * g2)1302 GEOSPreparedNearestPoints(const geos::geom::prep::PreparedGeometry* g1, const Geometry* g2) 1303 { 1304 return GEOSPreparedNearestPoints_r(handle, g1, g2); 1305 } 1306 1307 int GEOSPreparedDistance(const geos::geom::prep::PreparedGeometry * g1,const Geometry * g2,double * dist)1308 GEOSPreparedDistance(const geos::geom::prep::PreparedGeometry* g1, const Geometry* g2, double *dist) 1309 { 1310 return GEOSPreparedDistance_r(handle, g1, g2, dist); 1311 } 1312 1313 GEOSSTRtree* GEOSSTRtree_create(size_t nodeCapacity)1314 GEOSSTRtree_create(size_t nodeCapacity) 1315 { 1316 return GEOSSTRtree_create_r(handle, nodeCapacity); 1317 } 1318 1319 void GEOSSTRtree_insert(GEOSSTRtree * tree,const geos::geom::Geometry * g,void * item)1320 GEOSSTRtree_insert(GEOSSTRtree* tree, 1321 const geos::geom::Geometry* g, 1322 void* item) 1323 { 1324 GEOSSTRtree_insert_r(handle, tree, g, item); 1325 } 1326 1327 void GEOSSTRtree_query(GEOSSTRtree * tree,const geos::geom::Geometry * g,GEOSQueryCallback cb,void * userdata)1328 GEOSSTRtree_query(GEOSSTRtree* tree, 1329 const geos::geom::Geometry* g, 1330 GEOSQueryCallback cb, 1331 void* userdata) 1332 { 1333 GEOSSTRtree_query_r(handle, tree, g, cb, userdata); 1334 } 1335 1336 const GEOSGeometry* GEOSSTRtree_nearest(GEOSSTRtree * tree,const geos::geom::Geometry * g)1337 GEOSSTRtree_nearest(GEOSSTRtree* tree, 1338 const geos::geom::Geometry* g) 1339 { 1340 return GEOSSTRtree_nearest_r(handle, tree, g); 1341 } 1342 GEOSSTRtree_nearest_generic(GEOSSTRtree * tree,const void * item,const GEOSGeometry * itemEnvelope,GEOSDistanceCallback distancefn,void * userdata)1343 const void* GEOSSTRtree_nearest_generic(GEOSSTRtree* tree, 1344 const void* item, 1345 const GEOSGeometry* itemEnvelope, 1346 GEOSDistanceCallback distancefn, 1347 void* userdata) 1348 { 1349 return GEOSSTRtree_nearest_generic_r(handle, tree, item, itemEnvelope, distancefn, userdata); 1350 } 1351 1352 void GEOSSTRtree_iterate(GEOSSTRtree * tree,GEOSQueryCallback callback,void * userdata)1353 GEOSSTRtree_iterate(GEOSSTRtree* tree, 1354 GEOSQueryCallback callback, 1355 void* userdata) 1356 { 1357 GEOSSTRtree_iterate_r(handle, tree, callback, userdata); 1358 } 1359 1360 char GEOSSTRtree_remove(GEOSSTRtree * tree,const geos::geom::Geometry * g,void * item)1361 GEOSSTRtree_remove(GEOSSTRtree* tree, 1362 const geos::geom::Geometry* g, 1363 void* item) 1364 { 1365 return GEOSSTRtree_remove_r(handle, tree, g, item); 1366 } 1367 1368 void GEOSSTRtree_destroy(GEOSSTRtree * tree)1369 GEOSSTRtree_destroy(GEOSSTRtree* tree) 1370 { 1371 GEOSSTRtree_destroy_r(handle, tree); 1372 } 1373 1374 double GEOSProject(const geos::geom::Geometry * g,const geos::geom::Geometry * p)1375 GEOSProject(const geos::geom::Geometry* g, 1376 const geos::geom::Geometry* p) 1377 { 1378 return GEOSProject_r(handle, g, p); 1379 } 1380 1381 geos::geom::Geometry* GEOSInterpolate(const geos::geom::Geometry * g,double d)1382 GEOSInterpolate(const geos::geom::Geometry* g, 1383 double d) 1384 { 1385 return GEOSInterpolate_r(handle, g, d); 1386 } 1387 1388 double GEOSProjectNormalized(const geos::geom::Geometry * g,const geos::geom::Geometry * p)1389 GEOSProjectNormalized(const geos::geom::Geometry* g, 1390 const geos::geom::Geometry* p) 1391 { 1392 return GEOSProjectNormalized_r(handle, g, p); 1393 } 1394 1395 geos::geom::Geometry* GEOSInterpolateNormalized(const geos::geom::Geometry * g,double d)1396 GEOSInterpolateNormalized(const geos::geom::Geometry* g, 1397 double d) 1398 { 1399 return GEOSInterpolateNormalized_r(handle, g, d); 1400 } 1401 1402 geos::geom::Geometry* GEOSGeom_extractUniquePoints(const geos::geom::Geometry * g)1403 GEOSGeom_extractUniquePoints(const geos::geom::Geometry* g) 1404 { 1405 return GEOSGeom_extractUniquePoints_r(handle, g); 1406 } 1407 1408 geos::geom::Geometry* GEOSGeom_createEmptyCollection(int type)1409 GEOSGeom_createEmptyCollection(int type) 1410 { 1411 return GEOSGeom_createEmptyCollection_r(handle, type); 1412 } 1413 1414 geos::geom::Geometry* GEOSGeom_createEmptyPoint()1415 GEOSGeom_createEmptyPoint() 1416 { 1417 return GEOSGeom_createEmptyPoint_r(handle); 1418 } 1419 1420 geos::geom::Geometry* GEOSGeom_createEmptyLineString()1421 GEOSGeom_createEmptyLineString() 1422 { 1423 return GEOSGeom_createEmptyLineString_r(handle); 1424 } 1425 1426 geos::geom::Geometry* GEOSGeom_createEmptyPolygon()1427 GEOSGeom_createEmptyPolygon() 1428 { 1429 return GEOSGeom_createEmptyPolygon_r(handle); 1430 } 1431 1432 int GEOSOrientationIndex(double Ax,double Ay,double Bx,double By,double Px,double Py)1433 GEOSOrientationIndex(double Ax, double Ay, double Bx, double By, 1434 double Px, double Py) 1435 { 1436 return GEOSOrientationIndex_r(handle, Ax, Ay, Bx, By, Px, Py); 1437 } 1438 1439 GEOSGeometry* GEOSSharedPaths(const GEOSGeometry * g1,const GEOSGeometry * g2)1440 GEOSSharedPaths(const GEOSGeometry* g1, const GEOSGeometry* g2) 1441 { 1442 return GEOSSharedPaths_r(handle, g1, g2); 1443 } 1444 1445 GEOSGeometry* GEOSSnap(const GEOSGeometry * g1,const GEOSGeometry * g2,double tolerance)1446 GEOSSnap(const GEOSGeometry* g1, const GEOSGeometry* g2, double tolerance) 1447 { 1448 return GEOSSnap_r(handle, g1, g2, tolerance); 1449 } 1450 1451 GEOSBufferParams* GEOSBufferParams_create()1452 GEOSBufferParams_create() 1453 { 1454 return GEOSBufferParams_create_r(handle); 1455 } 1456 1457 void GEOSBufferParams_destroy(GEOSBufferParams * p)1458 GEOSBufferParams_destroy(GEOSBufferParams* p) 1459 { 1460 return GEOSBufferParams_destroy_r(handle, p); 1461 } 1462 1463 int GEOSBufferParams_setEndCapStyle(GEOSBufferParams * p,int style)1464 GEOSBufferParams_setEndCapStyle(GEOSBufferParams* p, int style) 1465 { 1466 return GEOSBufferParams_setEndCapStyle_r(handle, p, style); 1467 } 1468 1469 int GEOSBufferParams_setJoinStyle(GEOSBufferParams * p,int joinStyle)1470 GEOSBufferParams_setJoinStyle(GEOSBufferParams* p, int joinStyle) 1471 { 1472 return GEOSBufferParams_setJoinStyle_r(handle, p, joinStyle); 1473 } 1474 1475 int GEOSBufferParams_setMitreLimit(GEOSBufferParams * p,double l)1476 GEOSBufferParams_setMitreLimit(GEOSBufferParams* p, double l) 1477 { 1478 return GEOSBufferParams_setMitreLimit_r(handle, p, l); 1479 } 1480 1481 int GEOSBufferParams_setQuadrantSegments(GEOSBufferParams * p,int joinStyle)1482 GEOSBufferParams_setQuadrantSegments(GEOSBufferParams* p, int joinStyle) 1483 { 1484 return GEOSBufferParams_setQuadrantSegments_r(handle, p, joinStyle); 1485 } 1486 1487 int GEOSBufferParams_setSingleSided(GEOSBufferParams * p,int singleSided)1488 GEOSBufferParams_setSingleSided(GEOSBufferParams* p, int singleSided) 1489 { 1490 return GEOSBufferParams_setSingleSided_r(handle, p, singleSided); 1491 } 1492 1493 Geometry* GEOSBufferWithParams(const Geometry * g,const GEOSBufferParams * p,double w)1494 GEOSBufferWithParams(const Geometry* g, const GEOSBufferParams* p, double w) 1495 { 1496 return GEOSBufferWithParams_r(handle, g, p, w); 1497 } 1498 1499 Geometry* GEOSDelaunayTriangulation(const Geometry * g,double tolerance,int onlyEdges)1500 GEOSDelaunayTriangulation(const Geometry* g, double tolerance, int onlyEdges) 1501 { 1502 return GEOSDelaunayTriangulation_r(handle, g, tolerance, onlyEdges); 1503 } 1504 1505 Geometry* GEOSVoronoiDiagram(const Geometry * g,const Geometry * env,double tolerance,int onlyEdges)1506 GEOSVoronoiDiagram(const Geometry* g, const Geometry* env, double tolerance, int onlyEdges) 1507 { 1508 return GEOSVoronoiDiagram_r(handle, g, env, tolerance, onlyEdges); 1509 } 1510 1511 int GEOSSegmentIntersection(double ax0,double ay0,double ax1,double ay1,double bx0,double by0,double bx1,double by1,double * cx,double * cy)1512 GEOSSegmentIntersection(double ax0, double ay0, double ax1, double ay1, 1513 double bx0, double by0, double bx1, double by1, 1514 double* cx, double* cy) 1515 { 1516 return GEOSSegmentIntersection_r(handle, 1517 ax0, ay0, ax1, ay1, 1518 bx0, by0, bx1, by1, 1519 cx, cy); 1520 } 1521 1522 } /* extern "C" */ 1523