\i%DSrSSKrSSKJrJr SSKJrJrJ r J r SSK J r J r SSKJr SSKJrJr SS /r\S :rS rS rS rSrSrSrSrSSjrSrSrSrSr Sr!Sr"SSjr#g)a+Provides a conversion to / from a ragged array representation of geometries. A ragged (or "jagged") array is an irregular array of arrays of which each element can have a different length. As a result, such an array cannot be represented as a standard, rectangular nD array. The coordinates of geometries can be represented as arrays of arrays of coordinate pairs (possibly multiple levels of nesting, depending on the geometry type). Geometries, as a ragged array of coordinates, can be efficiently represented as contiguous arrays of coordinates provided that there is another data structure that keeps track of which range of coordinate values corresponds to a given geometry. This can be done using offsets, counts, or indices. This module currently implements offsets into the coordinates array. This is the ragged array representation defined by the the Apache Arrow project as "variable size list array" (https://arrow.apache.org/docs/format/Columnar.html#variable-size-list-layout). See for example https://cfconventions.org/Data/cf-conventions/cf-conventions-1.9/cf-conventions.html#representations-features for different options. The exact usage of the Arrow list array with varying degrees of nesting for the different geometry types is defined by the GeoArrow project: https://github.com/geoarrow/geoarrow N)creation geos_version) GeometryType get_parts get_rings get_type_id)_from_ragged_array_multi_linear_from_ragged_array_multipolygon)get_coordinates)is_empty is_missingfrom_ragged_arrayto_ragged_array) rc4[XUS9n[U5[U5-nUR5(a_[R "U5SnU[R "[U55- n[R"X5[RSS9nUS4$)N include_z include_mraxis) r r r anynpnonzeroarangeleninsertnan)arrrrcoordsemptiesindicess X/var/www/html/kml_chatgpt/mouzaenv/lib/python3.13/site-packages/shapely/_ragged_array.py_get_arrays_pointr%3sw S KFsmjo-G{{}}**W%a(BIIc'l336BFF; 2:cR[U5S:a[RnO[Rn[R"[R "U5R US9SS5n[U5US-:wa+[R"USUS-[U5- 4SUSS9nU$)Nidtyperconstant)constant_values)rrint64int32rbincountcumsumpad)r#nr)offsetss r$_indices_to_offsetsr5Bs 7|j ii G,33%3@!QGG 7|q1u&&  AG $ % #BK   Nr&c`[USS9up4[U[U55n[XUS9nXe44$)NT return_indexrrr5rr )r rr_ part_indicesr4r!s r$_get_arrays_multipointr<Ws9$7OA!,C9GS KF : r&cN[USXS9up4[U[U55nX544$)NTr8rr)r r5r)r rrr!r#r4s r$_get_arrays_linestringr?cs2% $)OF"'3s84G : r&c[USS9up4[U[U55n[USXS9upg[U[U55nXhU44$NTr7r>r9) r rrarr_flatr;offsets2r!r#offsets1s r$_get_arrays_multilinestringrEmV&s>H"<S:H&tyOF#7CM:H h' ''r&c[USS9up4[U[U55n[USXS9upg[U[U55nXhU44$rA)rr5rr ) r rrrB ring_indicesrCr!r#rDs r$_get_arrays_polygonrI|rFr&c[USS9up4[U[U55n[USS9upg[U[U55n[ USXS9up[U [U55n XX44$rA)rr5rrr ) r rrrBr;offsets3 arr_flat2rHrCr!r#rDs r$_get_arrays_multipolygonrMsw&s>H"<S:H(tDI"<X?H& OF#7C N;H h1 11r&c SSKJnJn [R"U5nUc)[R "U"U[ U5)55nUc7[(a*[R "U"U[ U5)55nOSn[R"[U55nXUS:nXU4n[U5S:Xa[US5nU[R:Xa [U6upGOU[R:Xa [U6upGOU[R :Xa [#U6upGOU[R$:Xa ['U6upGOU[R(:Xa [+U6upGOU[R,:Xa [/U6upGOg[1SUR2S35e[U5S:XGa [5U5[R[R$1:Xa[R$n['U6upO[5U5[R[R(1:Xa[R(n[+U6upO[5U5[R [R,1:Xa[R,n[/U6upOf[1SUV s/sHn [U 5R2PM sn S 35e[1SUV s/sHn [U 5R2PM sn S 35eXxU 4$s sn fs sn f) azConvert geometries to a ragged array representation. This function converts an array of geometries to a ragged array (i.e. irregular array of arrays) of coordinates, represented in memory using a single contiguous array of the coordinates, and up to 3 offset arrays that keep track where each sub-array starts and ends. This follows the in-memory layout of the variable size list arrays defined by Apache Arrow, as specified for geometries by the GeoArrow project: https://github.com/geoarrow/geoarrow. Parameters ---------- geometries : array_like Array of geometries (1-dimensional). include_z, include_m : bool, default None If both are False, return XY (2D) geometries. If both are True, return XYZM (4D) geometries. If either is True, return either XYZ or XYM (3D) geometries. If a geometry has no Z or M dimension, extra coordinate data will be NaN. By default, will infer the dimensionality from the input geometries. Note that this inference can be unreliable with empty geometries (for a guaranteed result, it is recommended to specify the keyword). .. 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. Returns ------- tuple of (geometry_type, coords, offsets) geometry_type : GeometryType The type of the input geometries (required information for roundtrip). coords : np.ndarray Contiguous array of shape (n, 2), (n, 3), or (n, 4) of all coordinates of all input geometries. offsets: tuple of np.ndarray Offset arrays that make it possible to reconstruct the geometries from the flat coordinates array. The number of offset arrays depends on the geometry type. See https://github.com/geoarrow/geoarrow/blob/main/format.md for details. Uses int32 dtype offsets if possible, otherwise int64 for large inputs (coordinates > 32GB). Notes ----- Mixed singular and multi geometry types of the same basic type are allowed (e.g., Point and MultiPoint) and all singular types will be treated as multi types. GeometryCollections and other mixed geometry types are not supported. See Also -------- from_ragged_array Examples -------- Consider a Polygon with one hole (interior ring): >>> import shapely >>> from shapely import Polygon >>> polygon = Polygon( ... [(0, 0), (10, 0), (10, 10), (0, 10)], ... holes=[[(2, 2), (3, 2), (2, 3)]] ... ) >>> polygon This polygon can be thought of as a list of rings (first ring is the exterior ring, subsequent rings are the interior rings), and each ring as a list of coordinate pairs. This is very similar to how GeoJSON represents the coordinates: >>> import json >>> json.loads(shapely.to_geojson(polygon))["coordinates"] [[[0.0, 0.0], [10.0, 0.0], [10.0, 10.0], [0.0, 10.0], [0.0, 0.0]], [[2.0, 2.0], [3.0, 2.0], [2.0, 3.0], [2.0, 2.0]]] This function will return a similar list of lists of lists, but using a single contiguous array of coordinates, and multiple arrays of offsets: >>> geometry_type, coords, offsets = shapely.to_ragged_array([polygon]) >>> geometry_type >>> coords array([[ 0., 0.], [10., 0.], [10., 10.], [ 0., 10.], [ 0., 0.], [ 2., 2.], [ 3., 2.], [ 2., 3.], [ 2., 2.]]) >>> offsets (array([0, 5, 9], dtype=int32), array([0, 2], dtype=int32)) As an example how to interpret the offsets: the i-th ring in the coordinates is represented by ``offsets[0][i]`` to ``offsets[0][i+1]``: >>> exterior_ring_start, exterior_ring_end = offsets[0][0], offsets[0][1] >>> coords[exterior_ring_start:exterior_ring_end] array([[ 0., 0.], [10., 0.], [10., 10.], [ 0., 10.], [ 0., 0.]]) r)has_mhas_zFr*Geometry type  is not supportedz,Geometry type combination is not supported ())shapelyrOrPrasarrayrr _geos_ge_312uniquerrrPOINTr% LINESTRINGr?POLYGONrI MULTIPOINTr<MULTILINESTRINGrE MULTIPOLYGONrM ValueErrornameset) geometriesrrrOrP geom_typesget_arrays_argstypr!r4ts r$rrsj%J'JFF5Xj-A,A!BCD  <uZ*1E0E%FGHII;z23J!O,J Y6O :!:a=) ,$$ $/AOFG L++ +4oFOFG L(( (1?COFG L++ +4oFOFG L00 09?KOFG L-- -6HOFG~chhZ7HIJ J ZA  z?|11<3J3JK K))C4oFOFG _!8!8,:V:V W W..C9?KOFG _!5!5|7P7P Q Q++C6HOFG3=>:a\!_)):>?qB   /9:z!a%%z:;1 >   ? ;s K7 K< c[R"U5n[R"U5R SS9nUR 5(a3[R "S[RS9R5X'U$)Nr*r geom_type) rpointsrisnanallremptyrrYitem)r!resultr"s r$_point_from_flatcoordsrpPs_ __V $Fhhv"""*G{{}}"..l6H6HINNP Mr&c[U5(aXSSn[R"U5n[R"U5n[R "[R "[U55U5n[R"[U5S- [S9n[R"X$US9n[R"S[RS9R5XSS:H'U$Nrr*r()r#outrh) rrrjrdiffrepeatrrmobject multipointsrr\rn)r!r4rjmultipoint_partsmultipoint_indicesros r$_multipoint_from_flatcoordsrz\s 7|| % __V $Fwww'299S1A-B#CEUV XXc'lQ&f 5F  ! !&& QF$,NN \,,% df q ! Mr&c[U5(aXSSn[R"U5n[R"[R"[U55U5n[R "[U5S- [ S9n[R"XUS9n[R "S[RS9R5XBS:H'U$rr) rrrtrurrmrvr linestringsrrZrn)r!r4 linestring_nlinestring_indicesros r$_linestring_from_flatcoordsros 7|| %777#L299S->#?N XXc'lQ&f 5F  ! !&& QF ( \,,! df 1  Mr&c[R"USS9n[R"USS9n[XU[RS9nU$Nr.r() geometry_type)rrVr rr]r!rDrCros r$!_multilinestrings_from_flatcoordsr~sBzz('2Hzz('2H-(,2N2NF Mr&c[R"USS9n[R"USS9n[XU[RS9nU$r)rrVr rr[rs r$_polygon_from_flatcoordsrsBzz('2Hzz('2H-(,2F2FF Mr&c[R"USS9n[R"USS9n[R"USS9n[XX#5nU$)Nr.r()rrVr )r!rDrCrKros r$_multipolygons_from_flatcoordsrsEzz('2Hzz('2Hzz('2H-Vx RF Mr&c2[R"USS9nU[R:Xa(Ub[ U5S:Xd [ S5e[ U5$Uc [ S5eU[R:Xa [U/UQ76$U[R:Xa [U/UQ76$U[R:Xa [U/UQ76$U[R:Xa [U/UQ76$U[R:Xa [!U/UQ76$[ SUR"S35e)aCreate geometries from a contiguous array of coordinates and offset arrays. This function creates geometries from the ragged array representation as returned by ``to_ragged_array``. This follows the in-memory layout of the variable size list arrays defined by Apache Arrow, as specified for geometries by the GeoArrow project: https://github.com/geoarrow/geoarrow. See :func:`to_ragged_array` for more details. Parameters ---------- geometry_type : GeometryType The type of geometry to create. coords : np.ndarray Contiguous array of shape (n, 2) or (n, 3) of all coordinates for the geometries. offsets: tuple of np.ndarray Offset arrays that allow to reconstruct the geometries based on the flat coordinates array. The number of offset arrays depends on the geometry type. See https://github.com/geoarrow/geoarrow/blob/main/format.md for details. Returns ------- np.ndarray Array of geometries (1-dimensional). See Also -------- to_ragged_array float64r(rz8'offsets' should not be provided for geometry type PointzA'offsets' must be provided for any geometry type except for PointrQrR)rrVrrYrr_rprZrr[rr\rzr]rr^rr`)rr!r4s r$rrsFZZi 0F ***3w<1#4WX X%f-- O   ///*6-*<*<)==NOPPr&)NN)N)$__doc__numpyrrUrrshapely._geometryrrrrshapely._geometry_helpersr r shapely.coordinatesr shapely.predicatesr r __all__rWr%r5r<r?rErIrMrrprzrrrrrrr&r$rs4* 03  1 2z) *  ( (2(k b &   :Qr&