\i; SrSSKrSSKJrJr SSKJr SSKJ r J r SSK J r SSK Jr /SQr\"S SS S S S .5r\"SS S S.5rSSjrSSjr\ "S5SSj5rSSjrSSjr\ "S5SSj5rg)z.Input/output functions for Shapely geometries.N) geos_versionlib) ParamEnum)from_ragged_arrayto_ragged_array) requires_geos)UnsupportedGEOSVersionError) from_geojsonrfrom_wkbfrom_wkt to_geojsonrto_wkbto_wktDecodingErrorOptions)ignorewarnraisefixWKBFlavorOptions)extendedisoc ,[R"U5(d [S5e[R"U5(d [S5eUc[S:aSOSnO&[R"U5(d [S5e[R"U5(d [S5e[R "U[R "U5[R"U5[R "U5[R"U540UD6$)adConvert to the Well-Known Text (WKT) representation of a Geometry. The Well-known Text format is defined in the `OGC Simple Features Specification for SQL `__. The following limitations apply to WKT serialization: - only simple empty geometries can be 3D, empty collections are always 2D Parameters ---------- geometry : Geometry or array_like Geometry or geometries to convert to WKT. rounding_precision : int, default 6 The rounding precision when writing the WKT string. Set to a value of -1 to indicate the full precision. trim : bool, default True If True, trim unnecessary decimals (trailing zeros). If False, use fixed-precision number formatting. output_dimension : int, default None The output dimension for the WKT string. Supported values are 2, 3 and 4 for GEOS 3.12+. Default None will automatically choose 3 or 4, depending on the version of GEOS. Specifying 3 means that up to 3 dimensions will be written but 2D geometries will still be represented as 2D in the WKT string. old_3d : bool, default False Enable old style 3D/4D WKT generation. By default, new style 3D/4D WKT (ie. "POINT Z (10 20 30)") is returned, but with ``old_3d=True`` the WKT will be formatted in the style "POINT (10 20 30)". **kwargs See :ref:`NumPy ufunc docs ` for other keyword arguments. Examples -------- >>> import shapely >>> from shapely import Point >>> shapely.to_wkt(Point(0, 0)) 'POINT (0 0)' >>> shapely.to_wkt(Point(0, 0), rounding_precision=3, trim=False) 'POINT (0.000 0.000)' >>> shapely.to_wkt(Point(0, 0), rounding_precision=-1, trim=False) 'POINT (0.0000000000000000 0.0000000000000000)' >>> shapely.to_wkt(Point(1, 2, 3), trim=True) 'POINT Z (1 2 3)' >>> shapely.to_wkt(Point(1, 2, 3), trim=True, output_dimension=2) 'POINT (1 2)' >>> shapely.to_wkt(Point(1, 2, 3), trim=True, old_3d=True) 'POINT (1 2 3)' Notes ----- The defaults differ from the default of some GEOS versions. To mimic this for versions before GEOS 3.12, use:: shapely.to_wkt(geometry, rounding_precision=-1, trim=False, output_dimension=2) z-rounding_precision only accepts scalar valuesztrim only accepts scalar valuesr rr+output_dimension only accepts scalar valuesz!old_3d only accepts scalar values)npisscalar TypeErrorrrrintcbool_)geometryrounding_precisiontrimoutput_dimensionold_3dkwargss M/var/www/html/kml_chatgpt/mouzaenv/lib/python3.13/site-packages/shapely/io.pyrr"sB ;;) * *GHH ;;t  9:: ,z 91q [[) * *EFF ;;v  ;<< :: "#   !      c F[R"U5(d [S5eUc[S:aSOSnO&[R"U5(d [S5e[R"U5(d [S5e[R"U5(d [S5e[R"U5(d [S5e[RS :aUS :Xa [ S 5eUS :XaU(a [ S 5e[RU5n[R"U[R"U5[R"U5[R"U5[R"U5[R"U540UD6$) abConvert to the Well-Known Binary (WKB) representation of a Geometry. The Well-Known Binary format is defined in the `OGC Simple Features Specification for SQL `__. The following limitations apply to WKB serialization: - linearrings will be converted to linestrings - a point with only NaN coordinates is converted to an empty point Parameters ---------- geometry : Geometry or array_like Geometry or geometries to convert to WKB. hex : bool, default False If true, export the WKB as a hexadecimal string. The default is to return a binary bytes object. output_dimension : int, default None The output dimension for the WKB. Supported values are 2, 3 and 4 for GEOS 3.12+. Default None will automatically choose 3 or 4, depending on the version of GEOS. Specifying 3 means that up to 3 dimensions will be written but 2D geometries will still be represented as 2D in the WKB representation. byte_order : int, default -1 Defaults to native machine byte order (-1). Use 0 to force big endian and 1 for little endian. include_srid : bool, default False If True, the SRID is be included in WKB (this is an extension to the OGC WKB specification). Not allowed when flavor is "iso". flavor : {"iso", "extended"}, default "extended" Which flavor of WKB will be returned. The flavor determines how extra dimensionality is encoded with the type number, and whether SRID can be included in the WKB. ISO flavor is "more standard" for 3D output, and does not support SRID embedding. Both flavors are equivalent when ``output_dimension=2`` (or with 2D geometries) and ``include_srid=False``. The `from_wkb` function can read both flavors. **kwargs See :ref:`NumPy ufunc docs ` for other keyword arguments. Examples -------- >>> import shapely >>> from shapely import Point >>> point = Point(1, 1) >>> shapely.to_wkb(point, byte_order=1) b'\x01\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf0?\x00\x00\x00\x00\x00\x00\xf0?' >>> shapely.to_wkb(point, hex=True, byte_order=1) '0101000000000000000000F03F000000000000F03F' zhex only accepts scalar valuesrrrrz%byte_order only accepts scalar valuesz'include_srid only accepts scalar valuesz!flavor only accepts scalar values)r rrz.The "iso" option requires at least GEOS 3.10.0z:flavor="iso" and include_srid=True cannot be used together) r r!r"rrr ValueErrorr get_valuerr$r#)r%hexr( byte_order include_sridflavorr*s r+rrxsFx ;;s  899 ,z 91q [[) * *EFF ;;z " "?@@ ;;| $ $ABB ;;v  ;<< *$5) <  <UVV  ' ' /F ::    !        r,z3.10.0c UcSnO7[R"U5(d [S5eUS:a [S5e[R "U[R "U540UD6$)aConvert to the GeoJSON representation of a Geometry. The GeoJSON format is defined in the `RFC 7946 `__. NaN (not-a-number) coordinates will be written as 'null'. The following are currently unsupported: - Geometries of type LINEARRING: these are output as 'null'. - Three-dimensional geometries: the third dimension is ignored. Parameters ---------- geometry : str, bytes or array_like Geometry or geometries to convert to GeoJSON. indent : int, optional If indent is a non-negative integer, then GeoJSON will be formatted. An indent level of 0 will only insert newlines. None (the default) selects the most compact representation. **kwargs See :ref:`NumPy ufunc docs ` for other keyword arguments. Examples -------- >>> import shapely >>> from shapely import Point >>> point = Point(1, 1) >>> shapely.to_geojson(point) '{"type":"Point","coordinates":[1.0,1.0]}' >>> print(shapely.to_geojson(point, indent=2)) { "type": "Point", "coordinates": [ 1.0, 1.0 ] } z!indent only accepts scalar valuesrzindent cannot be negative)r r!r"r/rr r#)r%indentr*s r+r r s[V~ [[ ;<< !455 >>(BGGFO >v >>r,c [R"U5(d [S5e[R"[R U55n[ R"X40UD6$)aCreate geometries from the Well-Known Text (WKT) representation. The Well-known Text format is defined in the `OGC Simple Features Specification for SQL `__. Parameters ---------- geometry : str or array_like The WKT string(s) to convert. on_invalid : {"raise", "warn", "ignore", "fix"}, default "raise" Indicates what to do when an invalid WKT string is encountered. Note that the validations involved are very basic, e.g. the minimum number of points for the geometry type. For a thorough check, use :func:`is_valid` after conversion to geometries. Valid options are: - raise: an exception will be raised if any input geometry is invalid. - warn: a warning will be raised and invalid WKT geometries will be returned as ``None``. - ignore: invalid geometries will be returned as ``None`` without a warning. - fix: an effort is made to fix invalid input geometries (currently just unclosed rings). If this is not possible, they are returned as ``None`` without a warning. Requires GEOS >= 3.11. .. versionadded:: 2.1.0 **kwargs See :ref:`NumPy ufunc docs ` for other keyword arguments. Examples -------- >>> import shapely >>> shapely.from_wkt('POINT (0 0)') %on_invalid only accepts scalar values)r r!r"uint8rr0rr r% on_invalidr*invalid_handlers r+r r sNH ;;z " "?@@hh3==jIJO << `__. Parameters ---------- geometry : str or array_like The WKB byte object(s) to convert. on_invalid : {"raise", "warn", "ignore", "fix"}, default "raise" Indicates what to do when an invalid WKB is encountered. Note that the validations involved are very basic, e.g. the minimum number of points for the geometry type. For a thorough check, use :func:`is_valid` after conversion to geometries. Valid options are: - raise: an exception will be raised if any input geometry is invalid. - warn: a warning will be raised and invalid WKT geometries will be returned as ``None``. - ignore: invalid geometries will be returned as ``None`` without a warning. - fix: an effort is made to fix invalid input geometries (currently just unclosed rings). If this is not possible, they are returned as ``None`` without a warning. Requires GEOS >= 3.11. .. versionadded:: 2.1.0 **kwargs See :ref:`NumPy ufunc docs ` for other keyword arguments. Examples -------- >>> import shapely >>> shapely.from_wkb(b'\x01\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf0?\x00\x00\x00\x00\x00\x00\xf0?') r9dtype) r r!r"r:rr0asarrayobjectrr r;s r+r r 4s`H ;;z " "?@@hh3==jIJO zz(&1H << `__. The following are currently unsupported: - Three-dimensional geometries: the third dimension is ignored. - Geometries having 'null' in the coordinates. Parameters ---------- geometry : str, bytes or array_like The GeoJSON string or byte object(s) to convert. on_invalid : {"raise", "warn", "ignore"}, default "raise" - raise: an exception will be raised if an input GeoJSON is invalid. - warn: a warning will be raised and invalid input geometries will be returned as ``None``. - ignore: invalid input geometries will be returned as ``None`` without a warning. **kwargs See :ref:`NumPy ufunc docs ` for other keyword arguments. See Also -------- get_parts Examples -------- >>> import shapely >>> shapely.from_geojson('{"type": "Point","coordinates": [1, 2]}') r9r?) r r!r"r:rr0rArBrr r;s r+r r dsbT ;;z " "?@@hh3==jIJO zz(&1H   H @ @@r,)TNF)FNr6Fr)N)r)__doc__numpyr shapelyrr shapely._enumrshapely._ragged_arrayrrshapely.decoratorsrshapely.errorsr __all__rrrrr r r r r,r+rNs4%#E,6 !q!aJ/a1JK    Sp   Xvx1?1?h)=X-=`x3A3Ar,