1pub const GEOS_VERSION_MAJOR: u32 = 3;
4pub const GEOS_VERSION_MINOR: u32 = 6;
5pub const GEOS_VERSION_PATCH: u32 = 5;
6pub const GEOS_CAPI_VERSION_MAJOR: u32 = 1;
7pub const GEOS_CAPI_VERSION_MINOR: u32 = 10;
8pub const GEOS_CAPI_VERSION_PATCH: u32 = 5;
9pub const GEOS_PREC_NO_TOPO: u32 = 1;
10pub const GEOS_PREC_KEEP_COLLAPSED: u32 = 2;
11pub type wchar_t = libc::c_int;
12pub type max_align_t = u128;
13#[repr(C)]
14#[derive(Debug, Copy, Clone)]
15pub struct GEOSContextHandle_HS {
16 _unused: [u8; 0],
17}
18pub type GEOSContextHandle_t = *mut GEOSContextHandle_HS;
19pub type GEOSMessageHandler =
20 ::std::option::Option<unsafe extern "C" fn(fmt: *const libc::c_char, ...)>;
21pub type GEOSMessageHandler_r = ::std::option::Option<
22 unsafe extern "C" fn(message: *const libc::c_char, userdata: *mut libc::c_void),
23>;
24#[repr(C)]
25#[derive(Debug, Copy, Clone)]
26pub struct GEOSGeom_t {
27 _unused: [u8; 0],
28}
29pub type GEOSGeometry = GEOSGeom_t;
30#[repr(C)]
31#[derive(Debug, Copy, Clone)]
32pub struct GEOSPrepGeom_t {
33 _unused: [u8; 0],
34}
35pub type GEOSPreparedGeometry = GEOSPrepGeom_t;
36#[repr(C)]
37#[derive(Debug, Copy, Clone)]
38pub struct GEOSCoordSeq_t {
39 _unused: [u8; 0],
40}
41pub type GEOSCoordSequence = GEOSCoordSeq_t;
42#[repr(C)]
43#[derive(Debug, Copy, Clone)]
44pub struct GEOSSTRtree_t {
45 _unused: [u8; 0],
46}
47pub type GEOSSTRtree = GEOSSTRtree_t;
48#[repr(C)]
49#[derive(Debug, Copy, Clone)]
50pub struct GEOSBufParams_t {
51 _unused: [u8; 0],
52}
53pub type GEOSBufferParams = GEOSBufParams_t;
54pub type GEOSGeom = *mut GEOSGeometry;
55pub type GEOSCoordSeq = *mut GEOSCoordSequence;
56pub const GEOSGeomTypes_GEOS_POINT: GEOSGeomTypes = 0;
57pub const GEOSGeomTypes_GEOS_LINESTRING: GEOSGeomTypes = 1;
58pub const GEOSGeomTypes_GEOS_LINEARRING: GEOSGeomTypes = 2;
59pub const GEOSGeomTypes_GEOS_POLYGON: GEOSGeomTypes = 3;
60pub const GEOSGeomTypes_GEOS_MULTIPOINT: GEOSGeomTypes = 4;
61pub const GEOSGeomTypes_GEOS_MULTILINESTRING: GEOSGeomTypes = 5;
62pub const GEOSGeomTypes_GEOS_MULTIPOLYGON: GEOSGeomTypes = 6;
63pub const GEOSGeomTypes_GEOS_GEOMETRYCOLLECTION: GEOSGeomTypes = 7;
64pub type GEOSGeomTypes = libc::c_uint;
65pub const GEOSByteOrders_GEOS_WKB_XDR: GEOSByteOrders = 0;
66pub const GEOSByteOrders_GEOS_WKB_NDR: GEOSByteOrders = 1;
67pub type GEOSByteOrders = libc::c_uint;
68pub type GEOSQueryCallback = ::std::option::Option<
69 unsafe extern "C" fn(item: *mut libc::c_void, userdata: *mut libc::c_void),
70>;
71pub type GEOSDistanceCallback = ::std::option::Option<
72 unsafe extern "C" fn(
73 item1: *const libc::c_void,
74 item2: *const libc::c_void,
75 distance: *mut libc::c_double,
76 userdata: *mut libc::c_void,
77 ) -> libc::c_int,
78>;
79pub type GEOSInterruptCallback = ::std::option::Option<unsafe extern "C" fn()>;
80extern "C" {
81 pub fn GEOS_interruptRegisterCallback(cb: GEOSInterruptCallback) -> GEOSInterruptCallback;
82}
83extern "C" {
84 pub fn GEOS_interruptRequest();
85}
86extern "C" {
87 pub fn GEOS_interruptCancel();
88}
89extern "C" {
90 pub fn GEOS_init_r() -> GEOSContextHandle_t;
91}
92extern "C" {
93 pub fn GEOS_finish_r(handle: GEOSContextHandle_t);
94}
95extern "C" {
96 pub fn GEOSContext_setNoticeHandler_r(
97 extHandle: GEOSContextHandle_t,
98 nf: GEOSMessageHandler,
99 ) -> GEOSMessageHandler;
100}
101extern "C" {
102 pub fn GEOSContext_setErrorHandler_r(
103 extHandle: GEOSContextHandle_t,
104 ef: GEOSMessageHandler,
105 ) -> GEOSMessageHandler;
106}
107extern "C" {
108 pub fn GEOSContext_setNoticeMessageHandler_r(
109 extHandle: GEOSContextHandle_t,
110 nf: GEOSMessageHandler_r,
111 userData: *mut libc::c_void,
112 ) -> GEOSMessageHandler_r;
113}
114extern "C" {
115 pub fn GEOSContext_setErrorMessageHandler_r(
116 extHandle: GEOSContextHandle_t,
117 ef: GEOSMessageHandler_r,
118 userData: *mut libc::c_void,
119 ) -> GEOSMessageHandler_r;
120}
121extern "C" {
122 pub fn GEOSversion() -> *const libc::c_char;
123}
124extern "C" {
125 pub fn GEOS_getWKBOutputDims_r(handle: GEOSContextHandle_t) -> libc::c_int;
126}
127extern "C" {
128 pub fn GEOS_setWKBOutputDims_r(
129 handle: GEOSContextHandle_t,
130 newDims: libc::c_int,
131 ) -> libc::c_int;
132}
133extern "C" {
134 pub fn GEOS_getWKBByteOrder_r(handle: GEOSContextHandle_t) -> libc::c_int;
135}
136extern "C" {
137 pub fn GEOS_setWKBByteOrder_r(
138 handle: GEOSContextHandle_t,
139 byteOrder: libc::c_int,
140 ) -> libc::c_int;
141}
142extern "C" {
143 pub fn GEOSGeomFromWKB_buf_r(
144 handle: GEOSContextHandle_t,
145 wkb: *const libc::c_uchar,
146 size: usize,
147 ) -> *mut GEOSGeometry;
148}
149extern "C" {
150 pub fn GEOSGeomToWKB_buf_r(
151 handle: GEOSContextHandle_t,
152 g: *const GEOSGeometry,
153 size: *mut usize,
154 ) -> *mut libc::c_uchar;
155}
156extern "C" {
157 pub fn GEOSGeomFromHEX_buf_r(
158 handle: GEOSContextHandle_t,
159 hex: *const libc::c_uchar,
160 size: usize,
161 ) -> *mut GEOSGeometry;
162}
163extern "C" {
164 pub fn GEOSGeomToHEX_buf_r(
165 handle: GEOSContextHandle_t,
166 g: *const GEOSGeometry,
167 size: *mut usize,
168 ) -> *mut libc::c_uchar;
169}
170extern "C" {
171 pub fn GEOSCoordSeq_create_r(
172 handle: GEOSContextHandle_t,
173 size: libc::c_uint,
174 dims: libc::c_uint,
175 ) -> *mut GEOSCoordSequence;
176}
177extern "C" {
178 pub fn GEOSCoordSeq_clone_r(
179 handle: GEOSContextHandle_t,
180 s: *const GEOSCoordSequence,
181 ) -> *mut GEOSCoordSequence;
182}
183extern "C" {
184 pub fn GEOSCoordSeq_destroy_r(handle: GEOSContextHandle_t, s: *mut GEOSCoordSequence);
185}
186extern "C" {
187 pub fn GEOSCoordSeq_setX_r(
188 handle: GEOSContextHandle_t,
189 s: *mut GEOSCoordSequence,
190 idx: libc::c_uint,
191 val: libc::c_double,
192 ) -> libc::c_int;
193}
194extern "C" {
195 pub fn GEOSCoordSeq_setY_r(
196 handle: GEOSContextHandle_t,
197 s: *mut GEOSCoordSequence,
198 idx: libc::c_uint,
199 val: libc::c_double,
200 ) -> libc::c_int;
201}
202extern "C" {
203 pub fn GEOSCoordSeq_setZ_r(
204 handle: GEOSContextHandle_t,
205 s: *mut GEOSCoordSequence,
206 idx: libc::c_uint,
207 val: libc::c_double,
208 ) -> libc::c_int;
209}
210extern "C" {
211 pub fn GEOSCoordSeq_setOrdinate_r(
212 handle: GEOSContextHandle_t,
213 s: *mut GEOSCoordSequence,
214 idx: libc::c_uint,
215 dim: libc::c_uint,
216 val: libc::c_double,
217 ) -> libc::c_int;
218}
219extern "C" {
220 pub fn GEOSCoordSeq_getX_r(
221 handle: GEOSContextHandle_t,
222 s: *const GEOSCoordSequence,
223 idx: libc::c_uint,
224 val: *mut libc::c_double,
225 ) -> libc::c_int;
226}
227extern "C" {
228 pub fn GEOSCoordSeq_getY_r(
229 handle: GEOSContextHandle_t,
230 s: *const GEOSCoordSequence,
231 idx: libc::c_uint,
232 val: *mut libc::c_double,
233 ) -> libc::c_int;
234}
235extern "C" {
236 pub fn GEOSCoordSeq_getZ_r(
237 handle: GEOSContextHandle_t,
238 s: *const GEOSCoordSequence,
239 idx: libc::c_uint,
240 val: *mut libc::c_double,
241 ) -> libc::c_int;
242}
243extern "C" {
244 pub fn GEOSCoordSeq_getOrdinate_r(
245 handle: GEOSContextHandle_t,
246 s: *const GEOSCoordSequence,
247 idx: libc::c_uint,
248 dim: libc::c_uint,
249 val: *mut libc::c_double,
250 ) -> libc::c_int;
251}
252extern "C" {
253 pub fn GEOSCoordSeq_getSize_r(
254 handle: GEOSContextHandle_t,
255 s: *const GEOSCoordSequence,
256 size: *mut libc::c_uint,
257 ) -> libc::c_int;
258}
259extern "C" {
260 pub fn GEOSCoordSeq_getDimensions_r(
261 handle: GEOSContextHandle_t,
262 s: *const GEOSCoordSequence,
263 dims: *mut libc::c_uint,
264 ) -> libc::c_int;
265}
266extern "C" {
267 pub fn GEOSProject_r(
268 handle: GEOSContextHandle_t,
269 g: *const GEOSGeometry,
270 p: *const GEOSGeometry,
271 ) -> libc::c_double;
272}
273extern "C" {
274 pub fn GEOSInterpolate_r(
275 handle: GEOSContextHandle_t,
276 g: *const GEOSGeometry,
277 d: libc::c_double,
278 ) -> *mut GEOSGeometry;
279}
280extern "C" {
281 pub fn GEOSProjectNormalized_r(
282 handle: GEOSContextHandle_t,
283 g: *const GEOSGeometry,
284 p: *const GEOSGeometry,
285 ) -> libc::c_double;
286}
287extern "C" {
288 pub fn GEOSInterpolateNormalized_r(
289 handle: GEOSContextHandle_t,
290 g: *const GEOSGeometry,
291 d: libc::c_double,
292 ) -> *mut GEOSGeometry;
293}
294extern "C" {
295 pub fn GEOSBuffer_r(
296 handle: GEOSContextHandle_t,
297 g: *const GEOSGeometry,
298 width: libc::c_double,
299 quadsegs: libc::c_int,
300 ) -> *mut GEOSGeometry;
301}
302pub const GEOSBufCapStyles_GEOSBUF_CAP_ROUND: GEOSBufCapStyles = 1;
303pub const GEOSBufCapStyles_GEOSBUF_CAP_FLAT: GEOSBufCapStyles = 2;
304pub const GEOSBufCapStyles_GEOSBUF_CAP_SQUARE: GEOSBufCapStyles = 3;
305pub type GEOSBufCapStyles = libc::c_uint;
306pub const GEOSBufJoinStyles_GEOSBUF_JOIN_ROUND: GEOSBufJoinStyles = 1;
307pub const GEOSBufJoinStyles_GEOSBUF_JOIN_MITRE: GEOSBufJoinStyles = 2;
308pub const GEOSBufJoinStyles_GEOSBUF_JOIN_BEVEL: GEOSBufJoinStyles = 3;
309pub type GEOSBufJoinStyles = libc::c_uint;
310extern "C" {
311 pub fn GEOSBufferParams_create_r(handle: GEOSContextHandle_t) -> *mut GEOSBufferParams;
312}
313extern "C" {
314 pub fn GEOSBufferParams_destroy_r(handle: GEOSContextHandle_t, parms: *mut GEOSBufferParams);
315}
316extern "C" {
317 pub fn GEOSBufferParams_setEndCapStyle_r(
318 handle: GEOSContextHandle_t,
319 p: *mut GEOSBufferParams,
320 style: libc::c_int,
321 ) -> libc::c_int;
322}
323extern "C" {
324 pub fn GEOSBufferParams_setJoinStyle_r(
325 handle: GEOSContextHandle_t,
326 p: *mut GEOSBufferParams,
327 joinStyle: libc::c_int,
328 ) -> libc::c_int;
329}
330extern "C" {
331 pub fn GEOSBufferParams_setMitreLimit_r(
332 handle: GEOSContextHandle_t,
333 p: *mut GEOSBufferParams,
334 mitreLimit: libc::c_double,
335 ) -> libc::c_int;
336}
337extern "C" {
338 pub fn GEOSBufferParams_setQuadrantSegments_r(
339 handle: GEOSContextHandle_t,
340 p: *mut GEOSBufferParams,
341 quadSegs: libc::c_int,
342 ) -> libc::c_int;
343}
344extern "C" {
345 pub fn GEOSBufferParams_setSingleSided_r(
346 handle: GEOSContextHandle_t,
347 p: *mut GEOSBufferParams,
348 singleSided: libc::c_int,
349 ) -> libc::c_int;
350}
351extern "C" {
352 pub fn GEOSBufferWithParams_r(
353 handle: GEOSContextHandle_t,
354 g: *const GEOSGeometry,
355 p: *const GEOSBufferParams,
356 width: libc::c_double,
357 ) -> *mut GEOSGeometry;
358}
359extern "C" {
360 pub fn GEOSBufferWithStyle_r(
361 handle: GEOSContextHandle_t,
362 g: *const GEOSGeometry,
363 width: libc::c_double,
364 quadsegs: libc::c_int,
365 endCapStyle: libc::c_int,
366 joinStyle: libc::c_int,
367 mitreLimit: libc::c_double,
368 ) -> *mut GEOSGeometry;
369}
370extern "C" {
371 pub fn GEOSOffsetCurve_r(
372 handle: GEOSContextHandle_t,
373 g: *const GEOSGeometry,
374 width: libc::c_double,
375 quadsegs: libc::c_int,
376 joinStyle: libc::c_int,
377 mitreLimit: libc::c_double,
378 ) -> *mut GEOSGeometry;
379}
380extern "C" {
381 pub fn GEOSGeom_createPoint_r(
382 handle: GEOSContextHandle_t,
383 s: *mut GEOSCoordSequence,
384 ) -> *mut GEOSGeometry;
385}
386extern "C" {
387 pub fn GEOSGeom_createEmptyPoint_r(handle: GEOSContextHandle_t) -> *mut GEOSGeometry;
388}
389extern "C" {
390 pub fn GEOSGeom_createLinearRing_r(
391 handle: GEOSContextHandle_t,
392 s: *mut GEOSCoordSequence,
393 ) -> *mut GEOSGeometry;
394}
395extern "C" {
396 pub fn GEOSGeom_createLineString_r(
397 handle: GEOSContextHandle_t,
398 s: *mut GEOSCoordSequence,
399 ) -> *mut GEOSGeometry;
400}
401extern "C" {
402 pub fn GEOSGeom_createEmptyLineString_r(handle: GEOSContextHandle_t) -> *mut GEOSGeometry;
403}
404extern "C" {
405 pub fn GEOSGeom_createEmptyPolygon_r(handle: GEOSContextHandle_t) -> *mut GEOSGeometry;
406}
407extern "C" {
408 pub fn GEOSGeom_createPolygon_r(
409 handle: GEOSContextHandle_t,
410 shell: *mut GEOSGeometry,
411 holes: *mut *mut GEOSGeometry,
412 nholes: libc::c_uint,
413 ) -> *mut GEOSGeometry;
414}
415extern "C" {
416 pub fn GEOSGeom_createCollection_r(
417 handle: GEOSContextHandle_t,
418 type_: libc::c_int,
419 geoms: *mut *mut GEOSGeometry,
420 ngeoms: libc::c_uint,
421 ) -> *mut GEOSGeometry;
422}
423extern "C" {
424 pub fn GEOSGeom_createEmptyCollection_r(
425 handle: GEOSContextHandle_t,
426 type_: libc::c_int,
427 ) -> *mut GEOSGeometry;
428}
429extern "C" {
430 pub fn GEOSGeom_clone_r(
431 handle: GEOSContextHandle_t,
432 g: *const GEOSGeometry,
433 ) -> *mut GEOSGeometry;
434}
435extern "C" {
436 pub fn GEOSGeom_destroy_r(handle: GEOSContextHandle_t, g: *mut GEOSGeometry);
437}
438extern "C" {
439 pub fn GEOSEnvelope_r(handle: GEOSContextHandle_t, g: *const GEOSGeometry)
440 -> *mut GEOSGeometry;
441}
442extern "C" {
443 pub fn GEOSIntersection_r(
444 handle: GEOSContextHandle_t,
445 g1: *const GEOSGeometry,
446 g2: *const GEOSGeometry,
447 ) -> *mut GEOSGeometry;
448}
449extern "C" {
450 pub fn GEOSConvexHull_r(
451 handle: GEOSContextHandle_t,
452 g: *const GEOSGeometry,
453 ) -> *mut GEOSGeometry;
454}
455extern "C" {
456 pub fn GEOSMinimumRotatedRectangle_r(
457 handle: GEOSContextHandle_t,
458 g: *const GEOSGeometry,
459 ) -> *mut GEOSGeometry;
460}
461extern "C" {
462 pub fn GEOSMinimumWidth_r(
463 handle: GEOSContextHandle_t,
464 g: *const GEOSGeometry,
465 ) -> *mut GEOSGeometry;
466}
467extern "C" {
468 pub fn GEOSMinimumClearanceLine_r(
469 handle: GEOSContextHandle_t,
470 g: *const GEOSGeometry,
471 ) -> *mut GEOSGeometry;
472}
473extern "C" {
474 pub fn GEOSMinimumClearance_r(
475 handle: GEOSContextHandle_t,
476 g: *const GEOSGeometry,
477 distance: *mut libc::c_double,
478 ) -> libc::c_int;
479}
480extern "C" {
481 pub fn GEOSDifference_r(
482 handle: GEOSContextHandle_t,
483 g1: *const GEOSGeometry,
484 g2: *const GEOSGeometry,
485 ) -> *mut GEOSGeometry;
486}
487extern "C" {
488 pub fn GEOSSymDifference_r(
489 handle: GEOSContextHandle_t,
490 g1: *const GEOSGeometry,
491 g2: *const GEOSGeometry,
492 ) -> *mut GEOSGeometry;
493}
494extern "C" {
495 pub fn GEOSBoundary_r(handle: GEOSContextHandle_t, g: *const GEOSGeometry)
496 -> *mut GEOSGeometry;
497}
498extern "C" {
499 pub fn GEOSUnion_r(
500 handle: GEOSContextHandle_t,
501 g1: *const GEOSGeometry,
502 g2: *const GEOSGeometry,
503 ) -> *mut GEOSGeometry;
504}
505extern "C" {
506 pub fn GEOSUnaryUnion_r(
507 handle: GEOSContextHandle_t,
508 g: *const GEOSGeometry,
509 ) -> *mut GEOSGeometry;
510}
511extern "C" {
512 pub fn GEOSPointOnSurface_r(
513 handle: GEOSContextHandle_t,
514 g: *const GEOSGeometry,
515 ) -> *mut GEOSGeometry;
516}
517extern "C" {
518 pub fn GEOSGetCentroid_r(
519 handle: GEOSContextHandle_t,
520 g: *const GEOSGeometry,
521 ) -> *mut GEOSGeometry;
522}
523extern "C" {
524 pub fn GEOSNode_r(handle: GEOSContextHandle_t, g: *const GEOSGeometry) -> *mut GEOSGeometry;
525}
526extern "C" {
527 pub fn GEOSClipByRect_r(
528 handle: GEOSContextHandle_t,
529 g: *const GEOSGeometry,
530 xmin: libc::c_double,
531 ymin: libc::c_double,
532 xmax: libc::c_double,
533 ymax: libc::c_double,
534 ) -> *mut GEOSGeometry;
535}
536extern "C" {
537 pub fn GEOSPolygonize_r(
538 handle: GEOSContextHandle_t,
539 geoms: *const *const GEOSGeometry,
540 ngeoms: libc::c_uint,
541 ) -> *mut GEOSGeometry;
542}
543extern "C" {
544 pub fn GEOSPolygonizer_getCutEdges_r(
545 handle: GEOSContextHandle_t,
546 geoms: *const *const GEOSGeometry,
547 ngeoms: libc::c_uint,
548 ) -> *mut GEOSGeometry;
549}
550extern "C" {
551 pub fn GEOSPolygonize_full_r(
552 handle: GEOSContextHandle_t,
553 input: *const GEOSGeometry,
554 cuts: *mut *mut GEOSGeometry,
555 dangles: *mut *mut GEOSGeometry,
556 invalidRings: *mut *mut GEOSGeometry,
557 ) -> *mut GEOSGeometry;
558}
559extern "C" {
560 pub fn GEOSLineMerge_r(
561 handle: GEOSContextHandle_t,
562 g: *const GEOSGeometry,
563 ) -> *mut GEOSGeometry;
564}
565extern "C" {
566 pub fn GEOSSimplify_r(
567 handle: GEOSContextHandle_t,
568 g: *const GEOSGeometry,
569 tolerance: libc::c_double,
570 ) -> *mut GEOSGeometry;
571}
572extern "C" {
573 pub fn GEOSTopologyPreserveSimplify_r(
574 handle: GEOSContextHandle_t,
575 g: *const GEOSGeometry,
576 tolerance: libc::c_double,
577 ) -> *mut GEOSGeometry;
578}
579extern "C" {
580 pub fn GEOSGeom_extractUniquePoints_r(
581 handle: GEOSContextHandle_t,
582 g: *const GEOSGeometry,
583 ) -> *mut GEOSGeometry;
584}
585extern "C" {
586 pub fn GEOSSharedPaths_r(
587 handle: GEOSContextHandle_t,
588 g1: *const GEOSGeometry,
589 g2: *const GEOSGeometry,
590 ) -> *mut GEOSGeometry;
591}
592extern "C" {
593 pub fn GEOSSnap_r(
594 handle: GEOSContextHandle_t,
595 g1: *const GEOSGeometry,
596 g2: *const GEOSGeometry,
597 tolerance: libc::c_double,
598 ) -> *mut GEOSGeometry;
599}
600extern "C" {
601 pub fn GEOSDelaunayTriangulation_r(
602 handle: GEOSContextHandle_t,
603 g: *const GEOSGeometry,
604 tolerance: libc::c_double,
605 onlyEdges: libc::c_int,
606 ) -> *mut GEOSGeometry;
607}
608extern "C" {
609 pub fn GEOSVoronoiDiagram_r(
610 extHandle: GEOSContextHandle_t,
611 g: *const GEOSGeometry,
612 env: *const GEOSGeometry,
613 tolerance: libc::c_double,
614 onlyEdges: libc::c_int,
615 ) -> *mut GEOSGeometry;
616}
617extern "C" {
618 pub fn GEOSDisjoint_r(
619 handle: GEOSContextHandle_t,
620 g1: *const GEOSGeometry,
621 g2: *const GEOSGeometry,
622 ) -> libc::c_char;
623}
624extern "C" {
625 pub fn GEOSTouches_r(
626 handle: GEOSContextHandle_t,
627 g1: *const GEOSGeometry,
628 g2: *const GEOSGeometry,
629 ) -> libc::c_char;
630}
631extern "C" {
632 pub fn GEOSIntersects_r(
633 handle: GEOSContextHandle_t,
634 g1: *const GEOSGeometry,
635 g2: *const GEOSGeometry,
636 ) -> libc::c_char;
637}
638extern "C" {
639 pub fn GEOSCrosses_r(
640 handle: GEOSContextHandle_t,
641 g1: *const GEOSGeometry,
642 g2: *const GEOSGeometry,
643 ) -> libc::c_char;
644}
645extern "C" {
646 pub fn GEOSWithin_r(
647 handle: GEOSContextHandle_t,
648 g1: *const GEOSGeometry,
649 g2: *const GEOSGeometry,
650 ) -> libc::c_char;
651}
652extern "C" {
653 pub fn GEOSContains_r(
654 handle: GEOSContextHandle_t,
655 g1: *const GEOSGeometry,
656 g2: *const GEOSGeometry,
657 ) -> libc::c_char;
658}
659extern "C" {
660 pub fn GEOSOverlaps_r(
661 handle: GEOSContextHandle_t,
662 g1: *const GEOSGeometry,
663 g2: *const GEOSGeometry,
664 ) -> libc::c_char;
665}
666extern "C" {
667 pub fn GEOSEquals_r(
668 handle: GEOSContextHandle_t,
669 g1: *const GEOSGeometry,
670 g2: *const GEOSGeometry,
671 ) -> libc::c_char;
672}
673extern "C" {
674 pub fn GEOSEqualsExact_r(
675 handle: GEOSContextHandle_t,
676 g1: *const GEOSGeometry,
677 g2: *const GEOSGeometry,
678 tolerance: libc::c_double,
679 ) -> libc::c_char;
680}
681extern "C" {
682 pub fn GEOSCovers_r(
683 handle: GEOSContextHandle_t,
684 g1: *const GEOSGeometry,
685 g2: *const GEOSGeometry,
686 ) -> libc::c_char;
687}
688extern "C" {
689 pub fn GEOSCoveredBy_r(
690 handle: GEOSContextHandle_t,
691 g1: *const GEOSGeometry,
692 g2: *const GEOSGeometry,
693 ) -> libc::c_char;
694}
695extern "C" {
696 pub fn GEOSPrepare_r(
697 handle: GEOSContextHandle_t,
698 g: *const GEOSGeometry,
699 ) -> *const GEOSPreparedGeometry;
700}
701extern "C" {
702 pub fn GEOSPreparedGeom_destroy_r(handle: GEOSContextHandle_t, g: *const GEOSPreparedGeometry);
703}
704extern "C" {
705 pub fn GEOSPreparedContains_r(
706 handle: GEOSContextHandle_t,
707 pg1: *const GEOSPreparedGeometry,
708 g2: *const GEOSGeometry,
709 ) -> libc::c_char;
710}
711extern "C" {
712 pub fn GEOSPreparedContainsProperly_r(
713 handle: GEOSContextHandle_t,
714 pg1: *const GEOSPreparedGeometry,
715 g2: *const GEOSGeometry,
716 ) -> libc::c_char;
717}
718extern "C" {
719 pub fn GEOSPreparedCoveredBy_r(
720 handle: GEOSContextHandle_t,
721 pg1: *const GEOSPreparedGeometry,
722 g2: *const GEOSGeometry,
723 ) -> libc::c_char;
724}
725extern "C" {
726 pub fn GEOSPreparedCovers_r(
727 handle: GEOSContextHandle_t,
728 pg1: *const GEOSPreparedGeometry,
729 g2: *const GEOSGeometry,
730 ) -> libc::c_char;
731}
732extern "C" {
733 pub fn GEOSPreparedCrosses_r(
734 handle: GEOSContextHandle_t,
735 pg1: *const GEOSPreparedGeometry,
736 g2: *const GEOSGeometry,
737 ) -> libc::c_char;
738}
739extern "C" {
740 pub fn GEOSPreparedDisjoint_r(
741 handle: GEOSContextHandle_t,
742 pg1: *const GEOSPreparedGeometry,
743 g2: *const GEOSGeometry,
744 ) -> libc::c_char;
745}
746extern "C" {
747 pub fn GEOSPreparedIntersects_r(
748 handle: GEOSContextHandle_t,
749 pg1: *const GEOSPreparedGeometry,
750 g2: *const GEOSGeometry,
751 ) -> libc::c_char;
752}
753extern "C" {
754 pub fn GEOSPreparedOverlaps_r(
755 handle: GEOSContextHandle_t,
756 pg1: *const GEOSPreparedGeometry,
757 g2: *const GEOSGeometry,
758 ) -> libc::c_char;
759}
760extern "C" {
761 pub fn GEOSPreparedTouches_r(
762 handle: GEOSContextHandle_t,
763 pg1: *const GEOSPreparedGeometry,
764 g2: *const GEOSGeometry,
765 ) -> libc::c_char;
766}
767extern "C" {
768 pub fn GEOSPreparedWithin_r(
769 handle: GEOSContextHandle_t,
770 pg1: *const GEOSPreparedGeometry,
771 g2: *const GEOSGeometry,
772 ) -> libc::c_char;
773}
774extern "C" {
775 pub fn GEOSSTRtree_create_r(
776 handle: GEOSContextHandle_t,
777 nodeCapacity: usize,
778 ) -> *mut GEOSSTRtree;
779}
780extern "C" {
781 pub fn GEOSSTRtree_insert_r(
782 handle: GEOSContextHandle_t,
783 tree: *mut GEOSSTRtree,
784 g: *const GEOSGeometry,
785 item: *mut libc::c_void,
786 );
787}
788extern "C" {
789 pub fn GEOSSTRtree_query_r(
790 handle: GEOSContextHandle_t,
791 tree: *mut GEOSSTRtree,
792 g: *const GEOSGeometry,
793 callback: GEOSQueryCallback,
794 userdata: *mut libc::c_void,
795 );
796}
797extern "C" {
798 pub fn GEOSSTRtree_nearest_r(
799 handle: GEOSContextHandle_t,
800 tree: *mut GEOSSTRtree,
801 geom: *const GEOSGeometry,
802 ) -> *const GEOSGeometry;
803}
804extern "C" {
805 pub fn GEOSSTRtree_nearest_generic_r(
806 handle: GEOSContextHandle_t,
807 tree: *mut GEOSSTRtree,
808 item: *const libc::c_void,
809 itemEnvelope: *const GEOSGeometry,
810 distancefn: GEOSDistanceCallback,
811 userdata: *mut libc::c_void,
812 ) -> *const libc::c_void;
813}
814extern "C" {
815 pub fn GEOSSTRtree_iterate_r(
816 handle: GEOSContextHandle_t,
817 tree: *mut GEOSSTRtree,
818 callback: GEOSQueryCallback,
819 userdata: *mut libc::c_void,
820 );
821}
822extern "C" {
823 pub fn GEOSSTRtree_remove_r(
824 handle: GEOSContextHandle_t,
825 tree: *mut GEOSSTRtree,
826 g: *const GEOSGeometry,
827 item: *mut libc::c_void,
828 ) -> libc::c_char;
829}
830extern "C" {
831 pub fn GEOSSTRtree_destroy_r(handle: GEOSContextHandle_t, tree: *mut GEOSSTRtree);
832}
833extern "C" {
834 pub fn GEOSisEmpty_r(handle: GEOSContextHandle_t, g: *const GEOSGeometry) -> libc::c_char;
835}
836extern "C" {
837 pub fn GEOSisSimple_r(handle: GEOSContextHandle_t, g: *const GEOSGeometry) -> libc::c_char;
838}
839extern "C" {
840 pub fn GEOSisRing_r(handle: GEOSContextHandle_t, g: *const GEOSGeometry) -> libc::c_char;
841}
842extern "C" {
843 pub fn GEOSHasZ_r(handle: GEOSContextHandle_t, g: *const GEOSGeometry) -> libc::c_char;
844}
845extern "C" {
846 pub fn GEOSisClosed_r(handle: GEOSContextHandle_t, g: *const GEOSGeometry) -> libc::c_char;
847}
848pub const GEOSRelateBoundaryNodeRules_GEOSRELATE_BNR_MOD2: GEOSRelateBoundaryNodeRules = 1;
849pub const GEOSRelateBoundaryNodeRules_GEOSRELATE_BNR_OGC: GEOSRelateBoundaryNodeRules = 1;
850pub const GEOSRelateBoundaryNodeRules_GEOSRELATE_BNR_ENDPOINT: GEOSRelateBoundaryNodeRules = 2;
851pub const GEOSRelateBoundaryNodeRules_GEOSRELATE_BNR_MULTIVALENT_ENDPOINT:
852 GEOSRelateBoundaryNodeRules = 3;
853pub const GEOSRelateBoundaryNodeRules_GEOSRELATE_BNR_MONOVALENT_ENDPOINT:
854 GEOSRelateBoundaryNodeRules = 4;
855pub type GEOSRelateBoundaryNodeRules = libc::c_uint;
856extern "C" {
857 pub fn GEOSRelatePattern_r(
858 handle: GEOSContextHandle_t,
859 g1: *const GEOSGeometry,
860 g2: *const GEOSGeometry,
861 pat: *const libc::c_char,
862 ) -> libc::c_char;
863}
864extern "C" {
865 pub fn GEOSRelate_r(
866 handle: GEOSContextHandle_t,
867 g1: *const GEOSGeometry,
868 g2: *const GEOSGeometry,
869 ) -> *mut libc::c_char;
870}
871extern "C" {
872 pub fn GEOSRelatePatternMatch_r(
873 handle: GEOSContextHandle_t,
874 mat: *const libc::c_char,
875 pat: *const libc::c_char,
876 ) -> libc::c_char;
877}
878extern "C" {
879 pub fn GEOSRelateBoundaryNodeRule_r(
880 handle: GEOSContextHandle_t,
881 g1: *const GEOSGeometry,
882 g2: *const GEOSGeometry,
883 bnr: libc::c_int,
884 ) -> *mut libc::c_char;
885}
886pub const GEOSValidFlags_GEOSVALID_ALLOW_SELFTOUCHING_RING_FORMING_HOLE: GEOSValidFlags = 1;
887pub type GEOSValidFlags = libc::c_uint;
888extern "C" {
889 pub fn GEOSisValid_r(handle: GEOSContextHandle_t, g: *const GEOSGeometry) -> libc::c_char;
890}
891extern "C" {
892 pub fn GEOSisValidReason_r(
893 handle: GEOSContextHandle_t,
894 g: *const GEOSGeometry,
895 ) -> *mut libc::c_char;
896}
897extern "C" {
898 pub fn GEOSisValidDetail_r(
899 handle: GEOSContextHandle_t,
900 g: *const GEOSGeometry,
901 flags: libc::c_int,
902 reason: *mut *mut libc::c_char,
903 location: *mut *mut GEOSGeometry,
904 ) -> libc::c_char;
905}
906extern "C" {
907 pub fn GEOSGeomType_r(handle: GEOSContextHandle_t, g: *const GEOSGeometry)
908 -> *mut libc::c_char;
909}
910extern "C" {
911 pub fn GEOSGeomTypeId_r(handle: GEOSContextHandle_t, g: *const GEOSGeometry) -> libc::c_int;
912}
913extern "C" {
914 pub fn GEOSGetSRID_r(handle: GEOSContextHandle_t, g: *const GEOSGeometry) -> libc::c_int;
915}
916extern "C" {
917 pub fn GEOSSetSRID_r(handle: GEOSContextHandle_t, g: *mut GEOSGeometry, SRID: libc::c_int);
918}
919extern "C" {
920 pub fn GEOSGeom_getUserData_r(
921 handle: GEOSContextHandle_t,
922 g: *const GEOSGeometry,
923 ) -> *mut libc::c_void;
924}
925extern "C" {
926 pub fn GEOSGeom_setUserData_r(
927 handle: GEOSContextHandle_t,
928 g: *mut GEOSGeometry,
929 userData: *mut libc::c_void,
930 );
931}
932extern "C" {
933 pub fn GEOSGetNumGeometries_r(
934 handle: GEOSContextHandle_t,
935 g: *const GEOSGeometry,
936 ) -> libc::c_int;
937}
938extern "C" {
939 pub fn GEOSGetGeometryN_r(
940 handle: GEOSContextHandle_t,
941 g: *const GEOSGeometry,
942 n: libc::c_int,
943 ) -> *const GEOSGeometry;
944}
945extern "C" {
946 pub fn GEOSNormalize_r(handle: GEOSContextHandle_t, g: *mut GEOSGeometry) -> libc::c_int;
947}
948extern "C" {
949 pub fn GEOSGeom_setPrecision_r(
950 handle: GEOSContextHandle_t,
951 g: *const GEOSGeometry,
952 gridSize: libc::c_double,
953 flags: libc::c_int,
954 ) -> *mut GEOSGeometry;
955}
956extern "C" {
957 pub fn GEOSGeom_getPrecision_r(
958 handle: GEOSContextHandle_t,
959 g: *const GEOSGeometry,
960 ) -> libc::c_double;
961}
962extern "C" {
963 pub fn GEOSGetNumInteriorRings_r(
964 handle: GEOSContextHandle_t,
965 g: *const GEOSGeometry,
966 ) -> libc::c_int;
967}
968extern "C" {
969 pub fn GEOSGeomGetNumPoints_r(
970 handle: GEOSContextHandle_t,
971 g: *const GEOSGeometry,
972 ) -> libc::c_int;
973}
974extern "C" {
975 pub fn GEOSGeomGetX_r(
976 handle: GEOSContextHandle_t,
977 g: *const GEOSGeometry,
978 x: *mut libc::c_double,
979 ) -> libc::c_int;
980}
981extern "C" {
982 pub fn GEOSGeomGetY_r(
983 handle: GEOSContextHandle_t,
984 g: *const GEOSGeometry,
985 y: *mut libc::c_double,
986 ) -> libc::c_int;
987}
988extern "C" {
989 pub fn GEOSGetInteriorRingN_r(
990 handle: GEOSContextHandle_t,
991 g: *const GEOSGeometry,
992 n: libc::c_int,
993 ) -> *const GEOSGeometry;
994}
995extern "C" {
996 pub fn GEOSGetExteriorRing_r(
997 handle: GEOSContextHandle_t,
998 g: *const GEOSGeometry,
999 ) -> *const GEOSGeometry;
1000}
1001extern "C" {
1002 pub fn GEOSGetNumCoordinates_r(
1003 handle: GEOSContextHandle_t,
1004 g: *const GEOSGeometry,
1005 ) -> libc::c_int;
1006}
1007extern "C" {
1008 pub fn GEOSGeom_getCoordSeq_r(
1009 handle: GEOSContextHandle_t,
1010 g: *const GEOSGeometry,
1011 ) -> *const GEOSCoordSequence;
1012}
1013extern "C" {
1014 pub fn GEOSGeom_getDimensions_r(
1015 handle: GEOSContextHandle_t,
1016 g: *const GEOSGeometry,
1017 ) -> libc::c_int;
1018}
1019extern "C" {
1020 pub fn GEOSGeom_getCoordinateDimension_r(
1021 handle: GEOSContextHandle_t,
1022 g: *const GEOSGeometry,
1023 ) -> libc::c_int;
1024}
1025extern "C" {
1026 pub fn GEOSGeomGetPointN_r(
1027 handle: GEOSContextHandle_t,
1028 g: *const GEOSGeometry,
1029 n: libc::c_int,
1030 ) -> *mut GEOSGeometry;
1031}
1032extern "C" {
1033 pub fn GEOSGeomGetStartPoint_r(
1034 handle: GEOSContextHandle_t,
1035 g: *const GEOSGeometry,
1036 ) -> *mut GEOSGeometry;
1037}
1038extern "C" {
1039 pub fn GEOSGeomGetEndPoint_r(
1040 handle: GEOSContextHandle_t,
1041 g: *const GEOSGeometry,
1042 ) -> *mut GEOSGeometry;
1043}
1044extern "C" {
1045 pub fn GEOSArea_r(
1046 handle: GEOSContextHandle_t,
1047 g: *const GEOSGeometry,
1048 area: *mut libc::c_double,
1049 ) -> libc::c_int;
1050}
1051extern "C" {
1052 pub fn GEOSLength_r(
1053 handle: GEOSContextHandle_t,
1054 g: *const GEOSGeometry,
1055 length: *mut libc::c_double,
1056 ) -> libc::c_int;
1057}
1058extern "C" {
1059 pub fn GEOSDistance_r(
1060 handle: GEOSContextHandle_t,
1061 g1: *const GEOSGeometry,
1062 g2: *const GEOSGeometry,
1063 dist: *mut libc::c_double,
1064 ) -> libc::c_int;
1065}
1066extern "C" {
1067 pub fn GEOSHausdorffDistance_r(
1068 handle: GEOSContextHandle_t,
1069 g1: *const GEOSGeometry,
1070 g2: *const GEOSGeometry,
1071 dist: *mut libc::c_double,
1072 ) -> libc::c_int;
1073}
1074extern "C" {
1075 pub fn GEOSHausdorffDistanceDensify_r(
1076 handle: GEOSContextHandle_t,
1077 g1: *const GEOSGeometry,
1078 g2: *const GEOSGeometry,
1079 densifyFrac: libc::c_double,
1080 dist: *mut libc::c_double,
1081 ) -> libc::c_int;
1082}
1083extern "C" {
1084 pub fn GEOSGeomGetLength_r(
1085 handle: GEOSContextHandle_t,
1086 g: *const GEOSGeometry,
1087 length: *mut libc::c_double,
1088 ) -> libc::c_int;
1089}
1090extern "C" {
1091 pub fn GEOSNearestPoints_r(
1092 handle: GEOSContextHandle_t,
1093 g1: *const GEOSGeometry,
1094 g2: *const GEOSGeometry,
1095 ) -> *mut GEOSCoordSequence;
1096}
1097extern "C" {
1098 pub fn GEOSOrientationIndex_r(
1099 handle: GEOSContextHandle_t,
1100 Ax: libc::c_double,
1101 Ay: libc::c_double,
1102 Bx: libc::c_double,
1103 By: libc::c_double,
1104 Px: libc::c_double,
1105 Py: libc::c_double,
1106 ) -> libc::c_int;
1107}
1108#[repr(C)]
1109#[derive(Debug, Copy, Clone)]
1110pub struct GEOSWKTReader_t {
1111 _unused: [u8; 0],
1112}
1113pub type GEOSWKTReader = GEOSWKTReader_t;
1114#[repr(C)]
1115#[derive(Debug, Copy, Clone)]
1116pub struct GEOSWKTWriter_t {
1117 _unused: [u8; 0],
1118}
1119pub type GEOSWKTWriter = GEOSWKTWriter_t;
1120#[repr(C)]
1121#[derive(Debug, Copy, Clone)]
1122pub struct GEOSWKBReader_t {
1123 _unused: [u8; 0],
1124}
1125pub type GEOSWKBReader = GEOSWKBReader_t;
1126#[repr(C)]
1127#[derive(Debug, Copy, Clone)]
1128pub struct GEOSWKBWriter_t {
1129 _unused: [u8; 0],
1130}
1131pub type GEOSWKBWriter = GEOSWKBWriter_t;
1132extern "C" {
1133 pub fn GEOSWKTReader_create_r(handle: GEOSContextHandle_t) -> *mut GEOSWKTReader;
1134}
1135extern "C" {
1136 pub fn GEOSWKTReader_destroy_r(handle: GEOSContextHandle_t, reader: *mut GEOSWKTReader);
1137}
1138extern "C" {
1139 pub fn GEOSWKTReader_read_r(
1140 handle: GEOSContextHandle_t,
1141 reader: *mut GEOSWKTReader,
1142 wkt: *const libc::c_char,
1143 ) -> *mut GEOSGeometry;
1144}
1145extern "C" {
1146 pub fn GEOSWKTWriter_create_r(handle: GEOSContextHandle_t) -> *mut GEOSWKTWriter;
1147}
1148extern "C" {
1149 pub fn GEOSWKTWriter_destroy_r(handle: GEOSContextHandle_t, writer: *mut GEOSWKTWriter);
1150}
1151extern "C" {
1152 pub fn GEOSWKTWriter_write_r(
1153 handle: GEOSContextHandle_t,
1154 writer: *mut GEOSWKTWriter,
1155 g: *const GEOSGeometry,
1156 ) -> *mut libc::c_char;
1157}
1158extern "C" {
1159 pub fn GEOSWKTWriter_setTrim_r(
1160 handle: GEOSContextHandle_t,
1161 writer: *mut GEOSWKTWriter,
1162 trim: libc::c_char,
1163 );
1164}
1165extern "C" {
1166 pub fn GEOSWKTWriter_setRoundingPrecision_r(
1167 handle: GEOSContextHandle_t,
1168 writer: *mut GEOSWKTWriter,
1169 precision: libc::c_int,
1170 );
1171}
1172extern "C" {
1173 pub fn GEOSWKTWriter_setOutputDimension_r(
1174 handle: GEOSContextHandle_t,
1175 writer: *mut GEOSWKTWriter,
1176 dim: libc::c_int,
1177 );
1178}
1179extern "C" {
1180 pub fn GEOSWKTWriter_getOutputDimension_r(
1181 handle: GEOSContextHandle_t,
1182 writer: *mut GEOSWKTWriter,
1183 ) -> libc::c_int;
1184}
1185extern "C" {
1186 pub fn GEOSWKTWriter_setOld3D_r(
1187 handle: GEOSContextHandle_t,
1188 writer: *mut GEOSWKTWriter,
1189 useOld3D: libc::c_int,
1190 );
1191}
1192extern "C" {
1193 pub fn GEOSWKBReader_create_r(handle: GEOSContextHandle_t) -> *mut GEOSWKBReader;
1194}
1195extern "C" {
1196 pub fn GEOSWKBReader_destroy_r(handle: GEOSContextHandle_t, reader: *mut GEOSWKBReader);
1197}
1198extern "C" {
1199 pub fn GEOSWKBReader_read_r(
1200 handle: GEOSContextHandle_t,
1201 reader: *mut GEOSWKBReader,
1202 wkb: *const libc::c_uchar,
1203 size: usize,
1204 ) -> *mut GEOSGeometry;
1205}
1206extern "C" {
1207 pub fn GEOSWKBReader_readHEX_r(
1208 handle: GEOSContextHandle_t,
1209 reader: *mut GEOSWKBReader,
1210 hex: *const libc::c_uchar,
1211 size: usize,
1212 ) -> *mut GEOSGeometry;
1213}
1214extern "C" {
1215 pub fn GEOSWKBWriter_create_r(handle: GEOSContextHandle_t) -> *mut GEOSWKBWriter;
1216}
1217extern "C" {
1218 pub fn GEOSWKBWriter_destroy_r(handle: GEOSContextHandle_t, writer: *mut GEOSWKBWriter);
1219}
1220extern "C" {
1221 pub fn GEOSWKBWriter_write_r(
1222 handle: GEOSContextHandle_t,
1223 writer: *mut GEOSWKBWriter,
1224 g: *const GEOSGeometry,
1225 size: *mut usize,
1226 ) -> *mut libc::c_uchar;
1227}
1228extern "C" {
1229 pub fn GEOSWKBWriter_writeHEX_r(
1230 handle: GEOSContextHandle_t,
1231 writer: *mut GEOSWKBWriter,
1232 g: *const GEOSGeometry,
1233 size: *mut usize,
1234 ) -> *mut libc::c_uchar;
1235}
1236extern "C" {
1237 pub fn GEOSWKBWriter_getOutputDimension_r(
1238 handle: GEOSContextHandle_t,
1239 writer: *const GEOSWKBWriter,
1240 ) -> libc::c_int;
1241}
1242extern "C" {
1243 pub fn GEOSWKBWriter_setOutputDimension_r(
1244 handle: GEOSContextHandle_t,
1245 writer: *mut GEOSWKBWriter,
1246 newDimension: libc::c_int,
1247 );
1248}
1249extern "C" {
1250 pub fn GEOSWKBWriter_getByteOrder_r(
1251 handle: GEOSContextHandle_t,
1252 writer: *const GEOSWKBWriter,
1253 ) -> libc::c_int;
1254}
1255extern "C" {
1256 pub fn GEOSWKBWriter_setByteOrder_r(
1257 handle: GEOSContextHandle_t,
1258 writer: *mut GEOSWKBWriter,
1259 byteOrder: libc::c_int,
1260 );
1261}
1262extern "C" {
1263 pub fn GEOSWKBWriter_getIncludeSRID_r(
1264 handle: GEOSContextHandle_t,
1265 writer: *const GEOSWKBWriter,
1266 ) -> libc::c_char;
1267}
1268extern "C" {
1269 pub fn GEOSWKBWriter_setIncludeSRID_r(
1270 handle: GEOSContextHandle_t,
1271 writer: *mut GEOSWKBWriter,
1272 writeSRID: libc::c_char,
1273 );
1274}
1275extern "C" {
1276 pub fn GEOSFree_r(handle: GEOSContextHandle_t, buffer: *mut libc::c_void);
1277}
1278extern "C" {
1279 pub fn GEOS_getWKBOutputDims() -> libc::c_int;
1280}
1281extern "C" {
1282 pub fn GEOS_setWKBOutputDims(newDims: libc::c_int) -> libc::c_int;
1283}
1284extern "C" {
1285 pub fn GEOS_getWKBByteOrder() -> libc::c_int;
1286}
1287extern "C" {
1288 pub fn GEOS_setWKBByteOrder(byteOrder: libc::c_int) -> libc::c_int;
1289}
1290extern "C" {
1291 pub fn GEOSGeomFromWKB_buf(wkb: *const libc::c_uchar, size: usize) -> *mut GEOSGeometry;
1292}
1293extern "C" {
1294 pub fn GEOSGeomToWKB_buf(g: *const GEOSGeometry, size: *mut usize) -> *mut libc::c_uchar;
1295}
1296extern "C" {
1297 pub fn GEOSGeomFromHEX_buf(hex: *const libc::c_uchar, size: usize) -> *mut GEOSGeometry;
1298}
1299extern "C" {
1300 pub fn GEOSGeomToHEX_buf(g: *const GEOSGeometry, size: *mut usize) -> *mut libc::c_uchar;
1301}
1302extern "C" {
1303 pub fn GEOSCoordSeq_create(size: libc::c_uint, dims: libc::c_uint) -> *mut GEOSCoordSequence;
1304}
1305extern "C" {
1306 pub fn GEOSCoordSeq_clone(s: *const GEOSCoordSequence) -> *mut GEOSCoordSequence;
1307}
1308extern "C" {
1309 pub fn GEOSCoordSeq_destroy(s: *mut GEOSCoordSequence);
1310}
1311extern "C" {
1312 pub fn GEOSCoordSeq_setX(
1313 s: *mut GEOSCoordSequence,
1314 idx: libc::c_uint,
1315 val: libc::c_double,
1316 ) -> libc::c_int;
1317}
1318extern "C" {
1319 pub fn GEOSCoordSeq_setY(
1320 s: *mut GEOSCoordSequence,
1321 idx: libc::c_uint,
1322 val: libc::c_double,
1323 ) -> libc::c_int;
1324}
1325extern "C" {
1326 pub fn GEOSCoordSeq_setZ(
1327 s: *mut GEOSCoordSequence,
1328 idx: libc::c_uint,
1329 val: libc::c_double,
1330 ) -> libc::c_int;
1331}
1332extern "C" {
1333 pub fn GEOSCoordSeq_setOrdinate(
1334 s: *mut GEOSCoordSequence,
1335 idx: libc::c_uint,
1336 dim: libc::c_uint,
1337 val: libc::c_double,
1338 ) -> libc::c_int;
1339}
1340extern "C" {
1341 pub fn GEOSCoordSeq_getX(
1342 s: *const GEOSCoordSequence,
1343 idx: libc::c_uint,
1344 val: *mut libc::c_double,
1345 ) -> libc::c_int;
1346}
1347extern "C" {
1348 pub fn GEOSCoordSeq_getY(
1349 s: *const GEOSCoordSequence,
1350 idx: libc::c_uint,
1351 val: *mut libc::c_double,
1352 ) -> libc::c_int;
1353}
1354extern "C" {
1355 pub fn GEOSCoordSeq_getZ(
1356 s: *const GEOSCoordSequence,
1357 idx: libc::c_uint,
1358 val: *mut libc::c_double,
1359 ) -> libc::c_int;
1360}
1361extern "C" {
1362 pub fn GEOSCoordSeq_getOrdinate(
1363 s: *const GEOSCoordSequence,
1364 idx: libc::c_uint,
1365 dim: libc::c_uint,
1366 val: *mut libc::c_double,
1367 ) -> libc::c_int;
1368}
1369extern "C" {
1370 pub fn GEOSCoordSeq_getSize(
1371 s: *const GEOSCoordSequence,
1372 size: *mut libc::c_uint,
1373 ) -> libc::c_int;
1374}
1375extern "C" {
1376 pub fn GEOSCoordSeq_getDimensions(
1377 s: *const GEOSCoordSequence,
1378 dims: *mut libc::c_uint,
1379 ) -> libc::c_int;
1380}
1381extern "C" {
1382 pub fn GEOSProject(g: *const GEOSGeometry, p: *const GEOSGeometry) -> libc::c_double;
1383}
1384extern "C" {
1385 pub fn GEOSInterpolate(g: *const GEOSGeometry, d: libc::c_double) -> *mut GEOSGeometry;
1386}
1387extern "C" {
1388 pub fn GEOSProjectNormalized(g: *const GEOSGeometry, p: *const GEOSGeometry) -> libc::c_double;
1389}
1390extern "C" {
1391 pub fn GEOSInterpolateNormalized(
1392 g: *const GEOSGeometry,
1393 d: libc::c_double,
1394 ) -> *mut GEOSGeometry;
1395}
1396extern "C" {
1397 pub fn GEOSBuffer(
1398 g: *const GEOSGeometry,
1399 width: libc::c_double,
1400 quadsegs: libc::c_int,
1401 ) -> *mut GEOSGeometry;
1402}
1403extern "C" {
1404 pub fn GEOSBufferParams_create() -> *mut GEOSBufferParams;
1405}
1406extern "C" {
1407 pub fn GEOSBufferParams_destroy(parms: *mut GEOSBufferParams);
1408}
1409extern "C" {
1410 pub fn GEOSBufferParams_setEndCapStyle(
1411 p: *mut GEOSBufferParams,
1412 style: libc::c_int,
1413 ) -> libc::c_int;
1414}
1415extern "C" {
1416 pub fn GEOSBufferParams_setJoinStyle(
1417 p: *mut GEOSBufferParams,
1418 joinStyle: libc::c_int,
1419 ) -> libc::c_int;
1420}
1421extern "C" {
1422 pub fn GEOSBufferParams_setMitreLimit(
1423 p: *mut GEOSBufferParams,
1424 mitreLimit: libc::c_double,
1425 ) -> libc::c_int;
1426}
1427extern "C" {
1428 pub fn GEOSBufferParams_setQuadrantSegments(
1429 p: *mut GEOSBufferParams,
1430 quadSegs: libc::c_int,
1431 ) -> libc::c_int;
1432}
1433extern "C" {
1434 pub fn GEOSBufferParams_setSingleSided(
1435 p: *mut GEOSBufferParams,
1436 singleSided: libc::c_int,
1437 ) -> libc::c_int;
1438}
1439extern "C" {
1440 pub fn GEOSBufferWithParams(
1441 g: *const GEOSGeometry,
1442 p: *const GEOSBufferParams,
1443 width: libc::c_double,
1444 ) -> *mut GEOSGeometry;
1445}
1446extern "C" {
1447 pub fn GEOSBufferWithStyle(
1448 g: *const GEOSGeometry,
1449 width: libc::c_double,
1450 quadsegs: libc::c_int,
1451 endCapStyle: libc::c_int,
1452 joinStyle: libc::c_int,
1453 mitreLimit: libc::c_double,
1454 ) -> *mut GEOSGeometry;
1455}
1456extern "C" {
1457 pub fn GEOSOffsetCurve(
1458 g: *const GEOSGeometry,
1459 width: libc::c_double,
1460 quadsegs: libc::c_int,
1461 joinStyle: libc::c_int,
1462 mitreLimit: libc::c_double,
1463 ) -> *mut GEOSGeometry;
1464}
1465extern "C" {
1466 pub fn GEOSGeom_createPoint(s: *mut GEOSCoordSequence) -> *mut GEOSGeometry;
1467}
1468extern "C" {
1469 pub fn GEOSGeom_createEmptyPoint() -> *mut GEOSGeometry;
1470}
1471extern "C" {
1472 pub fn GEOSGeom_createLinearRing(s: *mut GEOSCoordSequence) -> *mut GEOSGeometry;
1473}
1474extern "C" {
1475 pub fn GEOSGeom_createLineString(s: *mut GEOSCoordSequence) -> *mut GEOSGeometry;
1476}
1477extern "C" {
1478 pub fn GEOSGeom_createEmptyLineString() -> *mut GEOSGeometry;
1479}
1480extern "C" {
1481 pub fn GEOSGeom_createEmptyPolygon() -> *mut GEOSGeometry;
1482}
1483extern "C" {
1484 pub fn GEOSGeom_createPolygon(
1485 shell: *mut GEOSGeometry,
1486 holes: *mut *mut GEOSGeometry,
1487 nholes: libc::c_uint,
1488 ) -> *mut GEOSGeometry;
1489}
1490extern "C" {
1491 pub fn GEOSGeom_createCollection(
1492 type_: libc::c_int,
1493 geoms: *mut *mut GEOSGeometry,
1494 ngeoms: libc::c_uint,
1495 ) -> *mut GEOSGeometry;
1496}
1497extern "C" {
1498 pub fn GEOSGeom_createEmptyCollection(type_: libc::c_int) -> *mut GEOSGeometry;
1499}
1500extern "C" {
1501 pub fn GEOSGeom_clone(g: *const GEOSGeometry) -> *mut GEOSGeometry;
1502}
1503extern "C" {
1504 pub fn GEOSGeom_destroy(g: *mut GEOSGeometry);
1505}
1506extern "C" {
1507 pub fn GEOSEnvelope(g: *const GEOSGeometry) -> *mut GEOSGeometry;
1508}
1509extern "C" {
1510 pub fn GEOSIntersection(g1: *const GEOSGeometry, g2: *const GEOSGeometry) -> *mut GEOSGeometry;
1511}
1512extern "C" {
1513 pub fn GEOSConvexHull(g: *const GEOSGeometry) -> *mut GEOSGeometry;
1514}
1515extern "C" {
1516 pub fn GEOSMinimumRotatedRectangle(g: *const GEOSGeometry) -> *mut GEOSGeometry;
1517}
1518extern "C" {
1519 pub fn GEOSMinimumWidth(g: *const GEOSGeometry) -> *mut GEOSGeometry;
1520}
1521extern "C" {
1522 pub fn GEOSMinimumClearance(g: *const GEOSGeometry, d: *mut libc::c_double) -> libc::c_int;
1523}
1524extern "C" {
1525 pub fn GEOSMinimumClearanceLine(g: *const GEOSGeometry) -> *mut GEOSGeometry;
1526}
1527extern "C" {
1528 pub fn GEOSDifference(g1: *const GEOSGeometry, g2: *const GEOSGeometry) -> *mut GEOSGeometry;
1529}
1530extern "C" {
1531 pub fn GEOSSymDifference(g1: *const GEOSGeometry, g2: *const GEOSGeometry)
1532 -> *mut GEOSGeometry;
1533}
1534extern "C" {
1535 pub fn GEOSBoundary(g: *const GEOSGeometry) -> *mut GEOSGeometry;
1536}
1537extern "C" {
1538 pub fn GEOSUnion(g1: *const GEOSGeometry, g2: *const GEOSGeometry) -> *mut GEOSGeometry;
1539}
1540extern "C" {
1541 pub fn GEOSUnaryUnion(g: *const GEOSGeometry) -> *mut GEOSGeometry;
1542}
1543extern "C" {
1544 pub fn GEOSPointOnSurface(g: *const GEOSGeometry) -> *mut GEOSGeometry;
1545}
1546extern "C" {
1547 pub fn GEOSGetCentroid(g: *const GEOSGeometry) -> *mut GEOSGeometry;
1548}
1549extern "C" {
1550 pub fn GEOSNode(g: *const GEOSGeometry) -> *mut GEOSGeometry;
1551}
1552extern "C" {
1553 pub fn GEOSClipByRect(
1554 g: *const GEOSGeometry,
1555 xmin: libc::c_double,
1556 ymin: libc::c_double,
1557 xmax: libc::c_double,
1558 ymax: libc::c_double,
1559 ) -> *mut GEOSGeometry;
1560}
1561extern "C" {
1562 pub fn GEOSPolygonize(
1563 geoms: *const *const GEOSGeometry,
1564 ngeoms: libc::c_uint,
1565 ) -> *mut GEOSGeometry;
1566}
1567extern "C" {
1568 pub fn GEOSPolygonizer_getCutEdges(
1569 geoms: *const *const GEOSGeometry,
1570 ngeoms: libc::c_uint,
1571 ) -> *mut GEOSGeometry;
1572}
1573extern "C" {
1574 pub fn GEOSPolygonize_full(
1575 input: *const GEOSGeometry,
1576 cuts: *mut *mut GEOSGeometry,
1577 dangles: *mut *mut GEOSGeometry,
1578 invalid: *mut *mut GEOSGeometry,
1579 ) -> *mut GEOSGeometry;
1580}
1581extern "C" {
1582 pub fn GEOSLineMerge(g: *const GEOSGeometry) -> *mut GEOSGeometry;
1583}
1584extern "C" {
1585 pub fn GEOSSimplify(g: *const GEOSGeometry, tolerance: libc::c_double) -> *mut GEOSGeometry;
1586}
1587extern "C" {
1588 pub fn GEOSTopologyPreserveSimplify(
1589 g: *const GEOSGeometry,
1590 tolerance: libc::c_double,
1591 ) -> *mut GEOSGeometry;
1592}
1593extern "C" {
1594 pub fn GEOSGeom_extractUniquePoints(g: *const GEOSGeometry) -> *mut GEOSGeometry;
1595}
1596extern "C" {
1597 pub fn GEOSSharedPaths(g1: *const GEOSGeometry, g2: *const GEOSGeometry) -> *mut GEOSGeometry;
1598}
1599extern "C" {
1600 pub fn GEOSSnap(
1601 g1: *const GEOSGeometry,
1602 g2: *const GEOSGeometry,
1603 tolerance: libc::c_double,
1604 ) -> *mut GEOSGeometry;
1605}
1606extern "C" {
1607 pub fn GEOSDelaunayTriangulation(
1608 g: *const GEOSGeometry,
1609 tolerance: libc::c_double,
1610 onlyEdges: libc::c_int,
1611 ) -> *mut GEOSGeometry;
1612}
1613extern "C" {
1614 pub fn GEOSVoronoiDiagram(
1615 g: *const GEOSGeometry,
1616 env: *const GEOSGeometry,
1617 tolerance: libc::c_double,
1618 onlyEdges: libc::c_int,
1619 ) -> *mut GEOSGeometry;
1620}
1621extern "C" {
1622 pub fn GEOSDisjoint(g1: *const GEOSGeometry, g2: *const GEOSGeometry) -> libc::c_char;
1623}
1624extern "C" {
1625 pub fn GEOSTouches(g1: *const GEOSGeometry, g2: *const GEOSGeometry) -> libc::c_char;
1626}
1627extern "C" {
1628 pub fn GEOSIntersects(g1: *const GEOSGeometry, g2: *const GEOSGeometry) -> libc::c_char;
1629}
1630extern "C" {
1631 pub fn GEOSCrosses(g1: *const GEOSGeometry, g2: *const GEOSGeometry) -> libc::c_char;
1632}
1633extern "C" {
1634 pub fn GEOSWithin(g1: *const GEOSGeometry, g2: *const GEOSGeometry) -> libc::c_char;
1635}
1636extern "C" {
1637 pub fn GEOSContains(g1: *const GEOSGeometry, g2: *const GEOSGeometry) -> libc::c_char;
1638}
1639extern "C" {
1640 pub fn GEOSOverlaps(g1: *const GEOSGeometry, g2: *const GEOSGeometry) -> libc::c_char;
1641}
1642extern "C" {
1643 pub fn GEOSEquals(g1: *const GEOSGeometry, g2: *const GEOSGeometry) -> libc::c_char;
1644}
1645extern "C" {
1646 pub fn GEOSCovers(g1: *const GEOSGeometry, g2: *const GEOSGeometry) -> libc::c_char;
1647}
1648extern "C" {
1649 pub fn GEOSCoveredBy(g1: *const GEOSGeometry, g2: *const GEOSGeometry) -> libc::c_char;
1650}
1651extern "C" {
1652 pub fn GEOSEqualsExact(
1653 g1: *const GEOSGeometry,
1654 g2: *const GEOSGeometry,
1655 tolerance: libc::c_double,
1656 ) -> libc::c_char;
1657}
1658extern "C" {
1659 pub fn GEOSPrepare(g: *const GEOSGeometry) -> *const GEOSPreparedGeometry;
1660}
1661extern "C" {
1662 pub fn GEOSPreparedGeom_destroy(g: *const GEOSPreparedGeometry);
1663}
1664extern "C" {
1665 pub fn GEOSPreparedContains(
1666 pg1: *const GEOSPreparedGeometry,
1667 g2: *const GEOSGeometry,
1668 ) -> libc::c_char;
1669}
1670extern "C" {
1671 pub fn GEOSPreparedContainsProperly(
1672 pg1: *const GEOSPreparedGeometry,
1673 g2: *const GEOSGeometry,
1674 ) -> libc::c_char;
1675}
1676extern "C" {
1677 pub fn GEOSPreparedCoveredBy(
1678 pg1: *const GEOSPreparedGeometry,
1679 g2: *const GEOSGeometry,
1680 ) -> libc::c_char;
1681}
1682extern "C" {
1683 pub fn GEOSPreparedCovers(
1684 pg1: *const GEOSPreparedGeometry,
1685 g2: *const GEOSGeometry,
1686 ) -> libc::c_char;
1687}
1688extern "C" {
1689 pub fn GEOSPreparedCrosses(
1690 pg1: *const GEOSPreparedGeometry,
1691 g2: *const GEOSGeometry,
1692 ) -> libc::c_char;
1693}
1694extern "C" {
1695 pub fn GEOSPreparedDisjoint(
1696 pg1: *const GEOSPreparedGeometry,
1697 g2: *const GEOSGeometry,
1698 ) -> libc::c_char;
1699}
1700extern "C" {
1701 pub fn GEOSPreparedIntersects(
1702 pg1: *const GEOSPreparedGeometry,
1703 g2: *const GEOSGeometry,
1704 ) -> libc::c_char;
1705}
1706extern "C" {
1707 pub fn GEOSPreparedOverlaps(
1708 pg1: *const GEOSPreparedGeometry,
1709 g2: *const GEOSGeometry,
1710 ) -> libc::c_char;
1711}
1712extern "C" {
1713 pub fn GEOSPreparedTouches(
1714 pg1: *const GEOSPreparedGeometry,
1715 g2: *const GEOSGeometry,
1716 ) -> libc::c_char;
1717}
1718extern "C" {
1719 pub fn GEOSPreparedWithin(
1720 pg1: *const GEOSPreparedGeometry,
1721 g2: *const GEOSGeometry,
1722 ) -> libc::c_char;
1723}
1724extern "C" {
1725 pub fn GEOSSTRtree_create(nodeCapacity: usize) -> *mut GEOSSTRtree;
1726}
1727extern "C" {
1728 pub fn GEOSSTRtree_insert(
1729 tree: *mut GEOSSTRtree,
1730 g: *const GEOSGeometry,
1731 item: *mut libc::c_void,
1732 );
1733}
1734extern "C" {
1735 pub fn GEOSSTRtree_query(
1736 tree: *mut GEOSSTRtree,
1737 g: *const GEOSGeometry,
1738 callback: GEOSQueryCallback,
1739 userdata: *mut libc::c_void,
1740 );
1741}
1742extern "C" {
1743 pub fn GEOSSTRtree_nearest(
1744 tree: *mut GEOSSTRtree,
1745 geom: *const GEOSGeometry,
1746 ) -> *const GEOSGeometry;
1747}
1748extern "C" {
1749 pub fn GEOSSTRtree_nearest_generic(
1750 tree: *mut GEOSSTRtree,
1751 item: *const libc::c_void,
1752 itemEnvelope: *const GEOSGeometry,
1753 distancefn: GEOSDistanceCallback,
1754 userdata: *mut libc::c_void,
1755 ) -> *const libc::c_void;
1756}
1757extern "C" {
1758 pub fn GEOSSTRtree_iterate(
1759 tree: *mut GEOSSTRtree,
1760 callback: GEOSQueryCallback,
1761 userdata: *mut libc::c_void,
1762 );
1763}
1764extern "C" {
1765 pub fn GEOSSTRtree_remove(
1766 tree: *mut GEOSSTRtree,
1767 g: *const GEOSGeometry,
1768 item: *mut libc::c_void,
1769 ) -> libc::c_char;
1770}
1771extern "C" {
1772 pub fn GEOSSTRtree_destroy(tree: *mut GEOSSTRtree);
1773}
1774extern "C" {
1775 pub fn GEOSisEmpty(g: *const GEOSGeometry) -> libc::c_char;
1776}
1777extern "C" {
1778 pub fn GEOSisSimple(g: *const GEOSGeometry) -> libc::c_char;
1779}
1780extern "C" {
1781 pub fn GEOSisRing(g: *const GEOSGeometry) -> libc::c_char;
1782}
1783extern "C" {
1784 pub fn GEOSHasZ(g: *const GEOSGeometry) -> libc::c_char;
1785}
1786extern "C" {
1787 pub fn GEOSisClosed(g: *const GEOSGeometry) -> libc::c_char;
1788}
1789extern "C" {
1790 pub fn GEOSRelatePattern(
1791 g1: *const GEOSGeometry,
1792 g2: *const GEOSGeometry,
1793 pat: *const libc::c_char,
1794 ) -> libc::c_char;
1795}
1796extern "C" {
1797 pub fn GEOSRelate(g1: *const GEOSGeometry, g2: *const GEOSGeometry) -> *mut libc::c_char;
1798}
1799extern "C" {
1800 pub fn GEOSRelatePatternMatch(
1801 mat: *const libc::c_char,
1802 pat: *const libc::c_char,
1803 ) -> libc::c_char;
1804}
1805extern "C" {
1806 pub fn GEOSRelateBoundaryNodeRule(
1807 g1: *const GEOSGeometry,
1808 g2: *const GEOSGeometry,
1809 bnr: libc::c_int,
1810 ) -> *mut libc::c_char;
1811}
1812extern "C" {
1813 pub fn GEOSisValid(g: *const GEOSGeometry) -> libc::c_char;
1814}
1815extern "C" {
1816 pub fn GEOSisValidReason(g: *const GEOSGeometry) -> *mut libc::c_char;
1817}
1818extern "C" {
1819 pub fn GEOSisValidDetail(
1820 g: *const GEOSGeometry,
1821 flags: libc::c_int,
1822 reason: *mut *mut libc::c_char,
1823 location: *mut *mut GEOSGeometry,
1824 ) -> libc::c_char;
1825}
1826extern "C" {
1827 pub fn GEOSGeomType(g: *const GEOSGeometry) -> *mut libc::c_char;
1828}
1829extern "C" {
1830 pub fn GEOSGeomTypeId(g: *const GEOSGeometry) -> libc::c_int;
1831}
1832extern "C" {
1833 pub fn GEOSGetSRID(g: *const GEOSGeometry) -> libc::c_int;
1834}
1835extern "C" {
1836 pub fn GEOSSetSRID(g: *mut GEOSGeometry, SRID: libc::c_int);
1837}
1838extern "C" {
1839 pub fn GEOSGeom_getUserData(g: *const GEOSGeometry) -> *mut libc::c_void;
1840}
1841extern "C" {
1842 pub fn GEOSGeom_setUserData(g: *mut GEOSGeometry, userData: *mut libc::c_void);
1843}
1844extern "C" {
1845 pub fn GEOSGetNumGeometries(g: *const GEOSGeometry) -> libc::c_int;
1846}
1847extern "C" {
1848 pub fn GEOSGetGeometryN(g: *const GEOSGeometry, n: libc::c_int) -> *const GEOSGeometry;
1849}
1850extern "C" {
1851 pub fn GEOSNormalize(g: *mut GEOSGeometry) -> libc::c_int;
1852}
1853extern "C" {
1854 pub fn GEOSGeom_setPrecision(
1855 g: *const GEOSGeometry,
1856 gridSize: libc::c_double,
1857 flags: libc::c_int,
1858 ) -> *mut GEOSGeometry;
1859}
1860extern "C" {
1861 pub fn GEOSGeom_getPrecision(g: *const GEOSGeometry) -> libc::c_double;
1862}
1863extern "C" {
1864 pub fn GEOSGetNumInteriorRings(g: *const GEOSGeometry) -> libc::c_int;
1865}
1866extern "C" {
1867 pub fn GEOSGeomGetNumPoints(g: *const GEOSGeometry) -> libc::c_int;
1868}
1869extern "C" {
1870 pub fn GEOSGeomGetX(g: *const GEOSGeometry, x: *mut libc::c_double) -> libc::c_int;
1871}
1872extern "C" {
1873 pub fn GEOSGeomGetY(g: *const GEOSGeometry, y: *mut libc::c_double) -> libc::c_int;
1874}
1875extern "C" {
1876 pub fn GEOSGetInteriorRingN(g: *const GEOSGeometry, n: libc::c_int) -> *const GEOSGeometry;
1877}
1878extern "C" {
1879 pub fn GEOSGetExteriorRing(g: *const GEOSGeometry) -> *const GEOSGeometry;
1880}
1881extern "C" {
1882 pub fn GEOSGetNumCoordinates(g: *const GEOSGeometry) -> libc::c_int;
1883}
1884extern "C" {
1885 pub fn GEOSGeom_getCoordSeq(g: *const GEOSGeometry) -> *const GEOSCoordSequence;
1886}
1887extern "C" {
1888 pub fn GEOSGeom_getDimensions(g: *const GEOSGeometry) -> libc::c_int;
1889}
1890extern "C" {
1891 pub fn GEOSGeom_getCoordinateDimension(g: *const GEOSGeometry) -> libc::c_int;
1892}
1893extern "C" {
1894 pub fn GEOSGeomGetPointN(g: *const GEOSGeometry, n: libc::c_int) -> *mut GEOSGeometry;
1895}
1896extern "C" {
1897 pub fn GEOSGeomGetStartPoint(g: *const GEOSGeometry) -> *mut GEOSGeometry;
1898}
1899extern "C" {
1900 pub fn GEOSGeomGetEndPoint(g: *const GEOSGeometry) -> *mut GEOSGeometry;
1901}
1902extern "C" {
1903 pub fn GEOSArea(g: *const GEOSGeometry, area: *mut libc::c_double) -> libc::c_int;
1904}
1905extern "C" {
1906 pub fn GEOSLength(g: *const GEOSGeometry, length: *mut libc::c_double) -> libc::c_int;
1907}
1908extern "C" {
1909 pub fn GEOSDistance(
1910 g1: *const GEOSGeometry,
1911 g2: *const GEOSGeometry,
1912 dist: *mut libc::c_double,
1913 ) -> libc::c_int;
1914}
1915extern "C" {
1916 pub fn GEOSHausdorffDistance(
1917 g1: *const GEOSGeometry,
1918 g2: *const GEOSGeometry,
1919 dist: *mut libc::c_double,
1920 ) -> libc::c_int;
1921}
1922extern "C" {
1923 pub fn GEOSHausdorffDistanceDensify(
1924 g1: *const GEOSGeometry,
1925 g2: *const GEOSGeometry,
1926 densifyFrac: libc::c_double,
1927 dist: *mut libc::c_double,
1928 ) -> libc::c_int;
1929}
1930extern "C" {
1931 pub fn GEOSGeomGetLength(g: *const GEOSGeometry, length: *mut libc::c_double) -> libc::c_int;
1932}
1933extern "C" {
1934 pub fn GEOSNearestPoints(
1935 g1: *const GEOSGeometry,
1936 g2: *const GEOSGeometry,
1937 ) -> *mut GEOSCoordSequence;
1938}
1939extern "C" {
1940 pub fn GEOSOrientationIndex(
1941 Ax: libc::c_double,
1942 Ay: libc::c_double,
1943 Bx: libc::c_double,
1944 By: libc::c_double,
1945 Px: libc::c_double,
1946 Py: libc::c_double,
1947 ) -> libc::c_int;
1948}
1949extern "C" {
1950 pub fn GEOSWKTReader_create() -> *mut GEOSWKTReader;
1951}
1952extern "C" {
1953 pub fn GEOSWKTReader_destroy(reader: *mut GEOSWKTReader);
1954}
1955extern "C" {
1956 pub fn GEOSWKTReader_read(
1957 reader: *mut GEOSWKTReader,
1958 wkt: *const libc::c_char,
1959 ) -> *mut GEOSGeometry;
1960}
1961extern "C" {
1962 pub fn GEOSWKTWriter_create() -> *mut GEOSWKTWriter;
1963}
1964extern "C" {
1965 pub fn GEOSWKTWriter_destroy(writer: *mut GEOSWKTWriter);
1966}
1967extern "C" {
1968 pub fn GEOSWKTWriter_write(
1969 writer: *mut GEOSWKTWriter,
1970 g: *const GEOSGeometry,
1971 ) -> *mut libc::c_char;
1972}
1973extern "C" {
1974 pub fn GEOSWKTWriter_setTrim(writer: *mut GEOSWKTWriter, trim: libc::c_char);
1975}
1976extern "C" {
1977 pub fn GEOSWKTWriter_setRoundingPrecision(writer: *mut GEOSWKTWriter, precision: libc::c_int);
1978}
1979extern "C" {
1980 pub fn GEOSWKTWriter_setOutputDimension(writer: *mut GEOSWKTWriter, dim: libc::c_int);
1981}
1982extern "C" {
1983 pub fn GEOSWKTWriter_getOutputDimension(writer: *mut GEOSWKTWriter) -> libc::c_int;
1984}
1985extern "C" {
1986 pub fn GEOSWKTWriter_setOld3D(writer: *mut GEOSWKTWriter, useOld3D: libc::c_int);
1987}
1988extern "C" {
1989 pub fn GEOSWKBReader_create() -> *mut GEOSWKBReader;
1990}
1991extern "C" {
1992 pub fn GEOSWKBReader_destroy(reader: *mut GEOSWKBReader);
1993}
1994extern "C" {
1995 pub fn GEOSWKBReader_read(
1996 reader: *mut GEOSWKBReader,
1997 wkb: *const libc::c_uchar,
1998 size: usize,
1999 ) -> *mut GEOSGeometry;
2000}
2001extern "C" {
2002 pub fn GEOSWKBReader_readHEX(
2003 reader: *mut GEOSWKBReader,
2004 hex: *const libc::c_uchar,
2005 size: usize,
2006 ) -> *mut GEOSGeometry;
2007}
2008extern "C" {
2009 pub fn GEOSWKBWriter_create() -> *mut GEOSWKBWriter;
2010}
2011extern "C" {
2012 pub fn GEOSWKBWriter_destroy(writer: *mut GEOSWKBWriter);
2013}
2014extern "C" {
2015 pub fn GEOSWKBWriter_write(
2016 writer: *mut GEOSWKBWriter,
2017 g: *const GEOSGeometry,
2018 size: *mut usize,
2019 ) -> *mut libc::c_uchar;
2020}
2021extern "C" {
2022 pub fn GEOSWKBWriter_writeHEX(
2023 writer: *mut GEOSWKBWriter,
2024 g: *const GEOSGeometry,
2025 size: *mut usize,
2026 ) -> *mut libc::c_uchar;
2027}
2028extern "C" {
2029 pub fn GEOSWKBWriter_getOutputDimension(writer: *const GEOSWKBWriter) -> libc::c_int;
2030}
2031extern "C" {
2032 pub fn GEOSWKBWriter_setOutputDimension(writer: *mut GEOSWKBWriter, newDimension: libc::c_int);
2033}
2034extern "C" {
2035 pub fn GEOSWKBWriter_getByteOrder(writer: *const GEOSWKBWriter) -> libc::c_int;
2036}
2037extern "C" {
2038 pub fn GEOSWKBWriter_setByteOrder(writer: *mut GEOSWKBWriter, byteOrder: libc::c_int);
2039}
2040extern "C" {
2041 pub fn GEOSWKBWriter_getIncludeSRID(writer: *const GEOSWKBWriter) -> libc::c_char;
2042}
2043extern "C" {
2044 pub fn GEOSWKBWriter_setIncludeSRID(writer: *mut GEOSWKBWriter, writeSRID: libc::c_char);
2045}
2046extern "C" {
2047 pub fn GEOSFree(buffer: *mut libc::c_void);
2048}