
    \i1                         S r SSKrSSKrSSKJr  SSKJr  / SQr\" S/\S9 SS	S
.S\	S-  S\	4S jjj5       r
S r\" SS/\S9SSS.S jj5       rS rg)z6Methods that operate on the coordinates of geometries.    N)lib)deprecate_positional)count_coordinatesget_coordinatesset_coordinates	transform	include_z)categoryFT)interleavedr   c                   [         R                  " U [         R                  S9nUcP  [        R                  " U5      n[         R
                  " U5      n[        XE   USUS9Xe'   [        XE)    USUS9Xe) '   GOSn[        R                  " XBUS5      nU(       a	  U" U5      n	O:[         R                  " U" UR                  6 [         R                  S9R                  n	[        U	[         R                  5      (       a  U	R                  S:w  a  [        S5      eU	R                   [         R                  :w  a  [        SU	R                    S35      eU	R"                  UR"                  :w  a  [        S	U	R"                   S35      e[        R$                  " XI5      nUR                  S
:X  a/  [        U [         R                  5      (       d  UR'                  5       $ U$ )a  Apply a function to the coordinates of a geometry.

With the default of ``include_z=False``, all returned geometries will be
two-dimensional; the third dimension will be discarded, if present.
When specifying ``include_z=True``, the returned geometries preserve
the dimensionality of the respective input geometries.

Parameters
----------
geometry : Geometry or array_like
    Geometry or geometries to transform.
transformation : function
    A function that transforms a (N, 2) or (N, 3) ndarray of float64 to
    another (N, 2) or (N, 3) ndarray of float64.
    The function may not change N.
include_z : bool, optional, default False
    If False, always return 2D geometries.
    If True, the data being passed to the
    transformation function will include the third dimension
    (if a geometry has no third dimension, the z-coordinates
    will be NaN). If None, will infer the dimensionality per
    input geometry using ``has_z``, which may result in 2 calls to
    the transformation function. Note that this inference
    can be unreliable with empty geometries or NaN coordinates: for a
    guaranteed result, it is recommended to specify ``include_z`` explicitly.
interleaved : bool, default True
    If set to False, the transformation function should accept 2 or 3 separate
    one-dimensional arrays (x, y and optional z) instead of a single
    two-dimensional array.

    .. versionadded:: 2.1.0

Notes
-----

.. deprecated:: 2.1.0
    A deprecation warning is shown if ``include_z`` is specified as a
    positional argument. This will need to be specified as a keyword
    argument in a future release.

See Also
--------
has_z

Examples
--------
>>> import shapely
>>> from shapely import LineString, Point
>>> shapely.transform(Point(0, 0), lambda x: x + 1)
<POINT (1 1)>
>>> shapely.transform(LineString([(2, 2), (4, 4)]), lambda x: x * [2, 3])
<LINESTRING (4 6, 8 12)>
>>> shapely.transform(None, lambda x: x) is None
True
>>> shapely.transform([Point(0, 0), None], lambda x: x).tolist()
[<POINT (0 0)>, None]

The presence of a third dimension can be automatically detected, or
controlled explicitly:

>>> shapely.transform(Point(0, 0, 0), lambda x: x + 1)
<POINT (1 1)>
>>> shapely.transform(Point(0, 0, 0), lambda x: x + 1, include_z=True)
<POINT Z (1 1 1)>
>>> shapely.transform(Point(0, 0, 0), lambda x: x + 1, include_z=None)
<POINT Z (1 1 1)>

With interleaved=False, the call signature of the transformation is different:

>>> shapely.transform(LineString([(1, 2), (3, 4)]), lambda x, y: (x + 1, y), interleaved=False)
<LINESTRING (2 2, 4 4)>

Or with a z coordinate:

>>> shapely.transform(Point(0, 0, 0), lambda x, y, z: (x + 1, y, z + 2), interleaved=False, include_z=True)
<POINT Z (1 0 2)>

Using pyproj >= 2.1, the following example will reproject Shapely geometries
from EPSG 4326 to EPSG 32618:

>>> from pyproj import Transformer
>>> transformer = Transformer.from_crs(4326, 32618, always_xy=True)
>>> shapely.transform(Point(-75, 50), transformer.transform, interleaved=False)
<POINT (500000 5538630.703)>

dtypeT)r	   r   F   zHThe provided transformation did not return a two-dimensional numpy arrayzHThe provided transformation returned an array with an unexpected dtype ()zHThe provided transformation returned an array with an unexpected shape (r   )nparrayobject_shapelyhas_z
empty_liker   r   r   asarrayTfloat64
isinstancendarrayndim
ValueErrorr   shaper   item)
geometrytransformationr	   r   geometry_arrr   result	include_mcoordinatesnew_coordinatess
             V/var/www/html/kml_chatgpt/mouzaenv/lib/python3.13/site-packages/shapely/coordinates.pyr   r      s   @ 88HBJJ7Ll+|,!4[
 # #	
v 	)),9eT,[9O jj.bjja  /2::66/:N:NRS:S    BJJ.)//03    K$5$55)//03  $$\C{{a
8RZZ @ @{{}M    c                 p    [         R                  " [        R                  " U [        R                  S95      $ )a  Count the number of coordinate pairs in a geometry array.

Parameters
----------
geometry : Geometry or array_like
    Geometry or geometries to count the coordinates of.

Examples
--------
>>> import shapely
>>> from shapely import LineString, Point
>>> shapely.count_coordinates(Point(0, 0))
1
>>> shapely.count_coordinates(LineString([(2, 2), (4, 2)]))
2
>>> shapely.count_coordinates(None)
0
>>> shapely.count_coordinates([Point(0, 0), None])
1

r   )r   r   r   r   r   )r    s    r'   r   r      s$    ,   HBJJ!GHHr(   return_index)r$   c                t    [         R                  " [        R                  " U [        R                  S9XU5      $ )ae	  Get coordinates from a geometry array as an array of floats.

The shape of the returned array is (N, 2), with N being the number of
coordinate pairs. The shape of the data may also be (N, 3) or (N, 4),
depending on ``include_z`` and ``include_m`` options.

Parameters
----------
geometry : Geometry or array_like
    Geometry or geometries to get the coordinates of.
include_z, include_m : bool, default False
    If both are False, return XY (2D) geometries.
    If both are True, return XYZM (4D) geometries.
    If either are True, return XYZ or XYM (3D) geometries.
    If a geometry has no Z or M dimension, extra coordinate data will be NaN.

    .. versionadded:: 2.1.0
        The ``include_m`` parameter was added to support XYM (3D) and
        XYZM (4D) geometries available with GEOS 3.12.0 or later.
        With older GEOS versions, M dimension coordinates will be NaN.

return_index : bool, default False
    If True, also return the index of each returned geometry as a separate
    ndarray of integers. For multidimensional arrays, this indexes into the
    flattened array (in C contiguous order).

Notes
-----

.. deprecated:: 2.1.0
    A deprecation warning is shown if ``include_z`` or ``return_index`` are
    specified as positional arguments. In a future release, these will
    need to be specified as keyword arguments.

Examples
--------
>>> import shapely
>>> from shapely import LineString, Point
>>> shapely.get_coordinates(Point(1, 2)).tolist()
[[1.0, 2.0]]
>>> shapely.get_coordinates(LineString([(2, 2), (4, 4)])).tolist()
[[2.0, 2.0], [4.0, 4.0]]
>>> shapely.get_coordinates(None)
array([], shape=(0, 2), dtype=float64)

By default the third dimension is ignored:

>>> shapely.get_coordinates(Point(1, 2, 3)).tolist()
[[1.0, 2.0]]
>>> shapely.get_coordinates(Point(1, 2, 3), include_z=True).tolist()
[[1.0, 2.0, 3.0]]

If geometries don't have Z or M dimension, these values will be NaN:

>>> pt = Point(1, 2)
>>> shapely.get_coordinates(pt, include_z=True).tolist()
[[1.0, 2.0, nan]]
>>> shapely.get_coordinates(pt, include_z=True, include_m=True).tolist()
[[1.0, 2.0, nan, nan]]

When ``return_index=True``, indexes are returned also:

>>> geometries = [LineString([(2, 2), (4, 4)]), Point(0, 0)]
>>> coordinates, index = shapely.get_coordinates(geometries, return_index=True)
>>> coordinates.tolist(), index.tolist()
([[2.0, 2.0], [4.0, 4.0], [0.0, 0.0]], [0, 0, 1])

r   )r   r   r   r   r   )r    r	   r*   r$   s       r'   r   r      s.    L 


82::.	l r(   c                 ~   [         R                  " U [         R                  S9n[         R                  " [         R                  " U5      5      R	                  [         R
                  5      nUR                  S:w  a  [        SUR                   S35      e[        R                  " U5      nUR                  S   U:w  d  UR                  S   S;  a  [        SUR                   35      e[        R                  " X!5        UR                  S:X  a/  [        U [         R                  5      (       d  UR                  5       $ U$ )	a  Adapts the coordinates of a geometry array in-place.

If the coordinates array has shape (N, 2), all returned geometries
will be two-dimensional, and the third dimension will be discarded,
if present. If the coordinates array has shape (N, 3), the returned
geometries preserve the dimensionality of the input geometries.

.. warning::

    The geometry array is modified in-place! If you do not want to
    modify the original array, you can do
    ``set_coordinates(arr.copy(), newcoords)``.

Parameters
----------
geometry : Geometry or array_like
    Geometry or geometries to set the coordinates of.
coordinates: array_like
    An array of coordinates to set.

See Also
--------
transform : Returns a copy of a geometry array with a function applied to its
    coordinates.

Examples
--------
>>> import shapely
>>> from shapely import LineString, Point
>>> shapely.set_coordinates(Point(0, 0), [[1, 1]])
<POINT (1 1)>
>>> shapely.set_coordinates(
...     [Point(0, 0), LineString([(0, 0), (0, 0)])],
...     [[1, 2], [3, 4], [5, 6]]
... ).tolist()
[<POINT (1 2)>, <LINESTRING (3 4, 5 6)>]
>>> shapely.set_coordinates([None, Point(0, 0)], [[1, 2]]).tolist()
[None, <POINT (1 2)>]

Third dimension of input geometry is discarded if coordinates array does
not include one:

>>> shapely.set_coordinates(Point(0, 0, 0), [[1, 1]])
<POINT (1 1)>
>>> shapely.set_coordinates(Point(0, 0, 0), [[1, 1, 1]])
<POINT Z (1 1 1)>

r   r   z5The coordinate array should have dimension of 2 (has r   r      >   r      z*The coordinate array has an invalid shape )r   r   r   
atleast_2dastyper   r   r   r   r   r   r   r   r   r   )r    r%   r"   n_coordss       r'   r   r     s   b ::hbjj9L--

; 78??

KK1CKDTDTCUUVW
 	
 $$\2H!(k.?.?.B&.P89J9J8KL
 	
 2Aj2::&F&F  ""r(   )F)FF)__doc__numpyr   r   r   shapely.decoratorsr   __all__DeprecationWarningboolr   r   r   r    r(   r'   <module>r9      s    <    3
R {m.@A #J
 J d{J
 J BJZID {N3>PQGPU G RGT?r(   