ChSSKJr SSKrSSKrSSKrSSKJrJr SSKrSSK r SSK J r J r SSK rSSKJrJr SSKJr SSKrSSKJrJrJrJrJr SSKJrJr SS KJr SS K J!r! S S K"J#r#J$r$ S S K%J&r& \$(aSSK'J(r( OSSK'J)r( \RT(a SSK+r+SSK,J-r- SSK.r.SSK/r0SSK1J2r2 SSK3J4r4J5r5 SSSjjr6Sr7"SS\\ 5r8SSSjjr9\9\ l:g)) annotationsN)AnyLiteral) DataFrameSeries)mappingshape) BaseGeometry) GeometryArray GeometryDtype from_shapelyto_wkbto_wkt) GeoPandasBaseis_geometry_type_explore) GeoSeries) HAS_PYPROJ PANDAS_GE_30)doc)Accessor)CachedAccessor)IterableCRS)PARQUET_GEOMETRY_ENCODINGSSUPPORTED_VERSIONS_LITERALc[U5(ao[U[5(a [U5nURc@Ub=UR 5n[U[ 5(aXlU$XRlU$[U[5(a<[[R"U5US9n[X RURS9$[XS9nU$)z Ensure the data is of geometry dtype or converted to it. If input is a (Geo)Series, output is a GeoSeries, otherwise output is GeometryArray. If the input is a GeometryDtype with a set CRS, `crs` is ignored. crs)indexname) r isinstancerrr"copyr arrayr npasarrayr#r$)datar"outs iC:\Users\julio\OneDrive\Documentos\Trabajo\Ideas Frescas\venv\Lib\site-packages\geopandas/geodataframe.py_ensure_geometryr-.s dF # #T?D 88 99;D$ .. "%  dF # #rzz$/S9CS C Ct-CJzCRS mismatch between CRS of the passed geometries and 'crs'. Use 'GeoDataFrame.set_crs(crs, allow_override=True)' to overwrite CRS or 'GeoDataFrame.to_crs(crs)' to reproject geometries. c.^\rSrSrSrS/r\RS/-r\"\5r Sr SESSS.SFU4Sjjjjr U4Sjr SGS jr S r\"\ \S S 9r\R$SHSIS jj5r\R$SHSJSjj5rSKSLSjjr\R$SMSNSjj5r\R$SMSOSjj5rSPSQSjjr\SRSj5r\SSSj5r\R.STSj5rSTU4Sjjr\SUSVSjj5r\SWSj5r\SUSXSjj5r\SYSZSjj5r\SUS[Sjj5rS\S]Sjjr\S^Sj5r S_S`Sjjr!S_SaS jjr"SPSbS!jjr#ScS"jr$SS#SSS$.SdS%jjr%SeSfS&jjr&SgShS'jjr'SgSiS(jjr(\R$SjSkS)jj5r)\R$SjSlS*jj5r)SmSnS+jjr)\R$SHSoS,jj5r*\R$SHSpS-jj5r*SqSrS.jjr*SsStS/jjr+U4S0jr,STS1jr-U4S2jr.\/"\0R 5SuSvU4S3jjj5r1\/"\0R 5SwSxU4S4jjj5r2\SyS5j5r3\SzS6j5r4SzS7jr5\S{S8j5r6S{S9jr7SES|U4S:jjjr8S}S~S;jjr9SSU4S<jjjr:SSS=jjr;\<"S>\=R|R~5r@\/"\A5SS?j5rBSSS@jjrCSSSAjjrDSSSBjjrESSSCjjrFSDrGU=rH$) GeoDataFrameSaA GeoDataFrame object is a pandas.DataFrame that has one or more columns containing geometry. In addition to the standard DataFrame constructor arguments, GeoDataFrame also accepts the following keyword arguments: Parameters ---------- crs : value (optional) Coordinate Reference System of the geometry objects. Can be anything accepted by :meth:`pyproj.CRS.from_user_input() `, such as an authority string (eg "EPSG:4326") or a WKT string. geometry : str or array-like (optional) Value to use as the active geometry column. If str, treated as column name to use. If array-like, it will be added as new column named 'geometry' on the GeoDataFrame and set as the active geometry column. Note that if ``geometry`` is a (Geo)Series with a name, the name will not be used, a column named "geometry" will still be added. To preserve the name, you can use :meth:`~GeoDataFrame.rename_geometry` to update the geometry column name. Examples -------- Constructing GeoDataFrame from a dictionary. >>> from shapely.geometry import Point >>> d = {'col1': ['name1', 'name2'], 'geometry': [Point(1, 2), Point(2, 1)]} >>> gdf = geopandas.GeoDataFrame(d, crs="EPSG:4326") >>> gdf col1 geometry 0 name1 POINT (1 2) 1 name2 POINT (2 1) Notice that the inferred dtype of 'geometry' columns is geometry. >>> gdf.dtypes col1 object geometry geometry dtype: object Constructing GeoDataFrame from a pandas DataFrame with a column of WKT geometries: >>> import pandas as pd >>> d = {'col1': ['name1', 'name2'], 'wkt': ['POINT (1 2)', 'POINT (2 1)']} >>> df = pd.DataFrame(d) >>> gs = geopandas.GeoSeries.from_wkt(df['wkt']) >>> gdf = geopandas.GeoDataFrame(df, geometry=gs, crs="EPSG:4326") >>> gdf col1 wkt geometry 0 name1 POINT (1 2) POINT (1 2) 1 name2 POINT (2 1) POINT (2 1) See Also -------- GeoSeries : Series object designed to store shapely geometry objects _geometry_column_namegeometryNr3r"c>URS5c9[U[5(a$[U[5(dUR SS9 UcSU;a[ R "/SS9US'[TU] "U/UQ70UD6 UcH[U[5(a3URUl UbURU:wa[[5eUGcMURRS:XGa2SUR;Ga!URS:HR5S:a [S 5e[!USR"S 5(aQUSR"R(a3U(a,USR"RU:Xd[[5eUSR$nUS:XdRUS :XdL['U5S :XaUS :Xd7UR((dEUSR+5R-5(a[/USR"U5US'SnUb[!US 5(a7UR(a&U(aURU:Xd[[5e[U[ R25(a!UR4S;aUR7S5nUR9USUS9 UcU(a [S5egg![0a Nf=f)Nr&T)r&columnsstrdtyperr3zYGeoDataFrame does not support multiple columns using the geometry column name 'geometry'.r"objectrfloat)r3N)inplacer"zAssigning CRS to a GeoDataFrame without a geometry column is not supported. Supply geometry using the 'geometry=' keyword argument, or by providing a DataFrame with column name 'geometry')getr%rr0updatepdIndexsuper__init__r2r" ValueErrorcrs_mismatch_errorr6nlevelssumhasattrvaluesr9lenemptyisnaallr- TypeErrorrr$rename set_geometry)selfr*r3r"argskwargs geom_dtype __class__s r,rBGeoDataFrame.__init__s JJv  &4++t\22 MMtM $  >)-)C)CD &488s? !344   $$)dll*  *//1A5 AZ(//77$++//Z(//33s: !344j)//Jj()INzW'<j)9)>)>)@)D)D)F)F*'7Z8H8O8OQT'UD$ *H  %((LL + !344(BII..8==I4 $??:6   h#  >  J !$ 3!sK KKc^>US:Xa[RXU5 g[TU]X5 g)Nr3)r: __setattr__rA)rPattrvalrTs r,rWGeoDataFrame.__setattr__s( :    t3 / G  *r.cURU;anURcSnOSURS3n[URURS:H5n[ U5S:a USUS3- nOUS- n[ U5eXR$) NzqYou are calling a geospatial method on the GeoDataFrame, but the active geometry column to use has not been set. zZYou are calling a geospatial method on the GeoDataFrame, but the active geometry column ('z') is not present. r3rz, There are columns with geometry data type (z), and you can either set one as the active geometry with df.set_geometry("name") or access the column as a GeoSeries (df["name"]) and call the method directly on it.z There are no existing columns with geometry data type. You can add a geometry column as the active geometry column with df.set_geometry. )r2listr6dtypesrIAttributeError)rPmsggeo_colss r, _get_geometryGeoDataFrame._get_geometrys  % %T 1))1O 88<8R8R7ST'' DLL )BCDH8}q CH:NQQ( !% %..//r.c[RRRU5(d [ S5eUR 5 UR USS9 g)Nz1Must use a list-like to set the geometry propertyTr<)r?apitypes is_list_likerC%_persist_old_default_geometry_colnamerO)rPcols r, _set_geometryGeoDataFrame._set_geometry"sFvv||((--PQ Q 224 #t,r.zGeometry data for GeoDataFrame)fgetfsetrcgNrPridropr<r"s r,rOGeoDataFrame.set_geometry,r.cgrorprqs r,rOrs5r.cU(aUnO+[(aURSS9nOUR5nURnUcSn[U[[ -[ R-[-5(aTU(aSn[R"U[SS9 [U[5(aURb URnUnO[US5(aURS :a [S 5eXQn[U["5(a [S 5eS n USLa[R"U [SS9 U(aXQ [R"U [SS9 OUnU(d [%USS5n['XS9n[U[(5(aXHR*lOXHlXelXU'U(dU$g![ a [S U35ef=f)a` Set the GeoDataFrame geometry using either an existing column or the specified input. By default yields a new object. The original geometry column is replaced with the input. Parameters ---------- col : column label or array-like An existing column name or values to set as the new geometry column. If values (array-like, (Geo)Series) are passed, then if they are named (Series) the new geometry column will have the corresponding name, otherwise the existing geometry column will be replaced. If there is no existing geometry column, the new geometry column will use the default name "geometry". drop : boolean, default False When specifying a named Series or an existing column name for `col`, controls if the previous geometry column should be dropped from the result. The default of False keeps both the old and new geometry column. .. deprecated:: 1.0.0 inplace : boolean, default False Modify the GeoDataFrame in place (do not create a new object) crs : pyproj.CRS, optional Coordinate system to use. The value can be anything accepted by :meth:`pyproj.CRS.from_user_input() `, such as an authority string (eg "EPSG:4326") or a WKT string. If passed, overrides both DataFrame and col's crs. Otherwise, tries to get crs from passed col values or DataFrame. Examples -------- >>> from shapely.geometry import Point >>> d = {'col1': ['name1', 'name2'], 'geometry': [Point(1, 2), Point(2, 1)]} >>> gdf = geopandas.GeoDataFrame(d, crs="EPSG:4326") >>> gdf col1 geometry 0 name1 POINT (1 2) 1 name2 POINT (2 1) Passing an array: >>> df1 = gdf.set_geometry([Point(0,0), Point(1,1)]) >>> df1 col1 geometry 0 name1 POINT (0 0) 1 name2 POINT (1 1) Using existing column: >>> gdf["buffered"] = gdf.buffer(2) >>> df2 = gdf.set_geometry("buffered") >>> df2.geometry 0 POLYGON ((3 2, 2.99037 1.80397, 2.96157 1.6098... 1 POLYGON ((4 1, 3.99037 0.80397, 3.96157 0.6098... Name: buffered, dtype: geometry Returns ------- GeoDataFrame See Also -------- GeoDataFrame.rename_geometry : rename an active geometry column FdeepNr3zThe `drop` keyword argument is deprecated and has no effect when `col` is an array-like value. You should stop passing `drop` to `set_geometry` when this is the case.category stacklevelndimrz(Must pass array with one dimension only.zUnknown column znGeoDataFrame does not support setting the geometry column where the column name is shared by multiple columns.aThe `drop` keyword argument is deprecated and in future the only supported behaviour will match drop=False. To silence this warning and adopt the future behaviour, stop providing `drop` as a keyword to `set_geometry`. To replicate the `drop=True` behaviour you should update your code to `geo_col_name = gdf.active_geometry_name; gdf.set_geometry(new_geo_col).drop(columns=geo_col_name).rename_geometry(geo_col_name)`.r"r!)rr&r2r%rr\r(ndarrayr warningswarn FutureWarningr$rGr~rCKeyErrorrgetattrr-rr'r") rPrirrr<r"framegeo_column_namer_levelgiven_colname_drop_msgs r,rOrs>sT E| u - 44  "(O c6D=2::5 E F F<  cMaH#v&&388+?"%((E S& ! !chhlGH H : %++ E H #u} **  J ** #&%-C!0 eY ' '!KKOI'6#!&oLi : ?3%!899 :s <GGcgrorprPrir<s r,rename_geometryGeoDataFrame.rename_geometrys r.cgrorprs r,rrs r.cURRnXR;a[SUS35eU(dUR X10S9R XS9$UR X10US9 UR XS9 g)aRename the GeoDataFrame geometry column to the specified name. By default yields a new object. The original geometry column is replaced with the input. Parameters ---------- col : new geometry column label inplace : boolean, default False Modify the GeoDataFrame in place (do not create a new object) Examples -------- >>> from shapely.geometry import Point >>> d = {'col1': ['name1', 'name2'], 'geometry': [Point(1, 2), Point(2, 1)]} >>> df = geopandas.GeoDataFrame(d, crs="EPSG:4326") >>> df1 = df.rename_geometry('geom1') >>> df1.geometry.name 'geom1' >>> df.rename_geometry('geom1', inplace=True) >>> df.geometry.name 'geom1' See Also -------- GeoDataFrame.set_geometry : set the active geometry z Column named z already exists)r6rd)r6r<N)r3r$r6rCrNrO)rPrir< geometry_cols r,rrs<}})) ,, }SEAB B{{L+>{?LLM KK 3WK E   c  3r.cUR$)aReturn the name of the active geometry column. Returns a name if a GeoDataFrame has an active geometry column set, otherwise returns None. The return type is usually a string, but may be an integer, tuple or other hashable, depending on the contents of the dataframe columns. You can also access the active geometry column using the ``.geometry`` property. You can set a GeoSeries to be an active geometry using the :meth:`~GeoDataFrame.set_geometry` method. Returns ------- str or other index label supported by pandas name of an active geometry column or None See Also -------- GeoDataFrame.set_geometry : set the active geometry )r2rPs r,active_geometry_name!GeoDataFrame.active_geometry_names,)))r.cbURR$![a [S5ef=f)a2 The Coordinate Reference System (CRS) represented as a ``pyproj.CRS`` object. Returns None if the CRS is not set, and to set the value it :getter: Returns a ``pyproj.CRS`` or None. When setting, the value can be anything accepted by :meth:`pyproj.CRS.from_user_input() `, such as an authority string (eg "EPSG:4326") or a WKT string. Examples -------- >>> gdf.crs # doctest: +SKIP Name: WGS 84 Axis Info [ellipsoidal]: - Lat[north]: Geodetic latitude (degree) - Lon[east]: Geodetic longitude (degree) Area of Use: - name: World - bounds: (-180.0, -90.0, 180.0, 90.0) Datum: World Geodetic System 1984 - Ellipsoid: WGS 84 - Prime Meridian: Greenwich See Also -------- GeoDataFrame.set_crs : assign CRS GeoDataFrame.to_crs : re-project to another CRS zThe CRS attribute of a GeoDataFrame without an active geometry column is not defined. Use GeoDataFrame.set_geometry to set the active geometry column.)r3r"r^rs r,r"GeoDataFrame.crs+s9B ==$$ $  5  s.cURc [S5e[URRS5(aBUR b[ R"SS[S9 XRRlg[S5e)zSet the value of the crs.NzAssigning CRS to a GeoDataFrame without a geometry column is not supported. Use GeoDataFrame.set_geometry to set the active geometry column.r"zOverriding the CRS of a GeoDataFrame that already has CRS. This unsafe behavior will be deprecated in future versions. Use GeoDataFrame.set_crs method insteadrz)r}r|zAssigning CRS to a GeoDataFrame without an active geometry column is not supported. Use GeoDataFrame.set_geometry to set the active geometry column.) r2rCrGr3rHr"rrDeprecationWarning)rPvalues r,r"rUs  % % -#  4=='' / /xx# > !/ (-MM $. r.c>Sn[U[5(aeSU;aSU;aURSS5nOURSS5nUb[(d [ S5eUbSSKJn UR"U5n[TU]%U5 Ub)URRRcX l ggg![a gf=f)Nr"_crszxUnpickling a GeoDataFrame with CRS requires the 'pyproj' package, but it is not installed or does not import correctly. rr)r%dictpopr ImportErrorpyprojrfrom_user_inputrA __setstate__r3rHr" Exception)rPstater"rrTs r,rGeoDataFrame.__setstate__qs eT " "~&"5iit,ii-zz!M&))#. U#  ==''++3"H4   s*B;; CCc >[R"U40UD6nU"XRUS9$)a*Construct GeoDataFrame from dict of array-like or dicts by overriding DataFrame.from_dict method with geometry and crs. Parameters ---------- data : dict Of the form {field : array-like} or {field : dict}. geometry : str or array (optional) If str, column to use as geometry. If array, will be set as 'geometry' column on GeoDataFrame. crs : str or dict (optional) Coordinate reference system to set on the resulting frame. kwargs : key-word arguments These arguments are passed to DataFrame.from_dict Returns ------- GeoDataFrame r4)r from_dict)clsr*r3r"rR dataframes r,rGeoDataFrame.from_dicts&8''77 9S99r.c X[RRR"U40UD6$)aAlternate constructor to create a ``GeoDataFrame`` from a file. It is recommended to use :func:`geopandas.read_file` instead. Can load a ``GeoDataFrame`` from a file in any format recognized by `pyogrio`. See http://pyogrio.readthedocs.io/ for details. Parameters ---------- filename : str File path or file handle to read from. Depending on which kwargs are included, the content of filename may vary. See :func:`pyogrio.read_dataframe` for usage details. kwargs : key-word arguments These arguments are passed to :func:`pyogrio.read_dataframe`, and can be used to access multi-layer data, data stored within archives (zip files), etc. Examples -------- >>> import geodatasets >>> path = geodatasets.get_path('nybb') >>> gdf = geopandas.GeoDataFrame.from_file(path) >>> gdf # doctest: +SKIP BoroCode BoroName Shape_Leng Shape_Area geometry 0 5 Staten Island 330470.010332 1.623820e+09 MULTIPOLYGON (((970217.022 145643.332, 970227.... 1 4 Queens 896344.047763 3.045213e+09 MULTIPOLYGON (((1029606.077 156073.814, 102957... 2 3 Brooklyn 741080.523166 1.937479e+09 MULTIPOLYGON (((1021176.479 151374.797, 102100... 3 1 Manhattan 359299.096471 6.364715e+08 MULTIPOLYGON (((981219.056 188655.316, 980940.... 4 2 Bronx 464392.991824 1.186925e+09 MULTIPOLYGON (((1012821.806 229228.265, 101278... The recommended method of reading files is :func:`geopandas.read_file`: >>> gdf = geopandas.read_file(path) See Also -------- read_file : read file to GeoDataFrame GeoDataFrame.to_file : write GeoDataFrame to file ) geopandasiofile _read_file)rfilenamerRs r, from_fileGeoDataFrame.from_files%b||  ++H???r.c[US5(a URnOUn[U[5(aUR S5S:XaUSnOUn/nUHhn[US5(a URnSUS(a[ US5OS0nUSn U c0n UR U 5 URU5 Mj U"XcUS9$) a Alternate constructor to create GeoDataFrame from an iterable of features or a feature collection. Parameters ---------- features - Iterable of features, where each element must be a feature dictionary or implement the __geo_interface__. - Feature collection, where the 'features' key contains an iterable of features. - Object holding a feature collection that implements the ``__geo_interface__``. crs : str or dict (optional) Coordinate reference system to set on the resulting frame. columns : list of column names, optional Optionally specify the column names to include in the output frame. This does not overwrite the property names of the input, but can ensure a consistent output format. Returns ------- GeoDataFrame Notes ----- For more information about the ``__geo_interface__``, see https://gist.github.com/sgillies/2217756 Examples -------- >>> feature_coll = { ... "type": "FeatureCollection", ... "features": [ ... { ... "id": "0", ... "type": "Feature", ... "properties": {"col1": "name1"}, ... "geometry": {"type": "Point", "coordinates": (1.0, 2.0)}, ... "bbox": (1.0, 2.0, 1.0, 2.0), ... }, ... { ... "id": "1", ... "type": "Feature", ... "properties": {"col1": "name2"}, ... "geometry": {"type": "Point", "coordinates": (2.0, 1.0)}, ... "bbox": (2.0, 1.0, 2.0, 1.0), ... }, ... ], ... "bbox": (1.0, 1.0, 2.0, 2.0), ... } >>> df = geopandas.GeoDataFrame.from_features(feature_coll) >>> df geometry col1 0 POINT (1 2) name1 1 POINT (2 1) name2 __geo_interface__typeFeatureCollectionfeaturesr3N properties)r6r")rGrr%rr=r r>append) rrr"r6fs features_lstrowsfeaturerowrs r, from_featuresGeoDataFrame.from_featuress~ 80 1 1++BB b$  BFF6N6I$Ij>L#L#Gw 344!33'*:ME'*"56SWC!.J! JJz " KK $4c22r.Tc d[RRRUUUUUUUUU S9 n U $)ab Alternate constructor to create a ``GeoDataFrame`` from a sql query containing a geometry column in WKB representation. Parameters ---------- sql : string con : sqlalchemy.engine.Connection or sqlalchemy.engine.Engine geom_col : string, default 'geom' column name to convert to shapely geometries crs : optional Coordinate reference system to use for the returned GeoDataFrame index_col : string or list of strings, optional, default: None Column(s) to set as index(MultiIndex) coerce_float : boolean, default True Attempt to convert values of non-string, non-numeric objects (like decimal.Decimal) to floating point, useful for SQL result sets parse_dates : list or dict, default None - List of column names to parse as dates. - Dict of ``{column_name: format string}`` where format string is strftime compatible in case of parsing string times, or is one of (D, s, ns, ms, us) in case of parsing integer timestamps. - Dict of ``{column_name: arg dict}``, where the arg dict corresponds to the keyword arguments of :func:`pandas.to_datetime`. Especially useful with databases without native Datetime support, such as SQLite. params : list, tuple or dict, optional, default None List of parameters to pass to execute method. chunksize : int, default None If specified, return an iterator where chunksize is the number of rows to include in each chunk. Examples -------- PostGIS >>> from sqlalchemy import create_engine # doctest: +SKIP >>> db_connection_url = "postgresql://myusername:mypassword@myhost:5432/mydb" >>> con = create_engine(db_connection_url) # doctest: +SKIP >>> sql = "SELECT geom, highway FROM roads" >>> df = geopandas.GeoDataFrame.from_postgis(sql, con) # doctest: +SKIP SpatiaLite >>> sql = "SELECT ST_Binary(geom) AS geom, highway FROM roads" >>> df = geopandas.GeoDataFrame.from_postgis(sql, con) # doctest: +SKIP The recommended method of reading from PostGIS is :func:`geopandas.read_postgis`: >>> df = geopandas.read_postgis(sql, con) # doctest: +SKIP See Also -------- geopandas.read_postgis : read PostGIS database to GeoDataFrame )geom_colr" index_col coerce_float parse_datesparams chunksize)rrsql _read_postgis) rrconrr"rrrrrdfs r, from_postgisGeoDataFrame.from_postgis:sFJ\\   + +  %#,   r.cSSKJn U"XUS9$)a6 Construct a GeoDataFrame from a Arrow table object based on GeoArrow extension types. See https://geoarrow.org/ for details on the GeoArrow specification. This functions accepts any tabular Arrow object implementing the `Arrow PyCapsule Protocol`_ (i.e. having an ``__arrow_c_array__`` or ``__arrow_c_stream__`` method). .. _Arrow PyCapsule Protocol: https://arrow.apache.org/docs/format/CDataInterface/PyCapsuleInterface.html .. versionadded:: 1.0 Parameters ---------- table : pyarrow.Table or Arrow-compatible table Any tabular object implementing the Arrow PyCapsule Protocol (i.e. has an ``__arrow_c_array__`` or ``__arrow_c_stream__`` method). This table should have at least one column with a geoarrow geometry type. geometry : str, default None The name of the geometry column to set as the active geometry column. If None, the first geometry column found will be used. to_pandas_kwargs : dict, optional Arguments passed to the `pa.Table.to_pandas` method for non-geometry columns. This can be used to control the behavior of the conversion of the non-geometry columns to a pandas DataFrame. For example, you can use this to control the dtype conversion of the columns. By default, the `to_pandas` method is called with no additional arguments. Returns ------- GeoDataFrame r)arrow_to_geopandas)r3to_pandas_kwargs)geopandas.io._geoarrowr)rtabler3rrs r, from_arrowGeoDataFrame.from_arrowsP >! 7G  r.c U(a,UR(aURSS9nO [S5eUnURXUS9nURbvURR S5(dVURR 5n/SQn Ub USU ;a[ R"SS S 9 OUupS U S U 3n S S U 0S.US'[R"U40UD6$)aReturn a GeoJSON representation of the ``GeoDataFrame`` as a string. Parameters ---------- na : {'null', 'drop', 'keep'}, default 'null' Indicates how to output missing (NaN) values in the GeoDataFrame. See below. show_bbox : bool, optional, default: False Include bbox (bounds) in the geojson drop_id : bool, default: False Whether to retain the index of the GeoDataFrame as the id property in the generated GeoJSON. Default is False, but may want True if the index is just arbitrary row numbers. to_wgs84: bool, optional, default: False If the CRS is set on the active geometry column it is exported as WGS84 (EPSG:4326) to meet the `2016 GeoJSON specification `_. Set to True to force re-projection and set to False to ignore CRS. False by default. Notes ----- The remaining *kwargs* are passed to json.dumps(). Missing (NaN) values in the GeoDataFrame can be represented as follows: - ``null``: output the missing entries as JSON null. - ``drop``: remove the property from the feature. This applies to each feature individually so that features may have different properties. - ``keep``: output the missing entries as NaN. If the GeoDataFrame has a defined CRS, its definition will be included in the output unless it is equal to WGS84 (default GeoJSON CRS) or not possible to represent in the URN OGC format, or unless ``to_wgs84=True`` is specified. Examples -------- >>> from shapely.geometry import Point >>> d = {'col1': ['name1', 'name2'], 'geometry': [Point(1, 2), Point(2, 1)]} >>> gdf = geopandas.GeoDataFrame(d, crs="EPSG:3857") >>> gdf col1 geometry 0 name1 POINT (1 2) 1 name2 POINT (2 1) >>> gdf.to_json() '{"type": "FeatureCollection", "features": [{"id": "0", "type": "Feature", "properties": {"col1": "name1"}, "geometry": {"type": "Point", "coordinates": [1.0, 2.0]}}, {"id": "1", "type": "Feature", "properties": {"col1": "name2"}, "geometry": {"type": "Point", "coordinates": [2.0, 1.0]}}], "crs": {"type": "name", "properties": {"name": "urn:ogc:def:crs:EPSG::3857"}}}' Alternatively, you can write GeoJSON to file: >>> gdf.to_file(path, driver="GeoJSON") # doctest: +SKIP See Also -------- GeoDataFrame.to_file : write GeoDataFrame to file i)epsgz7CRS is not set. Cannot re-project to WGS84 (EPSG:4326).na show_bboxdrop_idz epsg:4326)EDCSEPSGOGCSIUCUMrzjGeoDataFrame's CRS is not representable in URN OGC format. Resulting JSON will contain no CRS information.rzr}zurn:ogc:def:crs:z::r$)rrr") r"to_crsrC to_geo_dictequals to_authorityrrjsondumps) rPrrrto_wgs84rRrgeo auth_crsdefallowed_authorities authoritycodeogc_crss r,to_jsonGeoDataFrame.to_jsonsL xx[[d[+ MBnnnI 66 bffmmK&@&@((//1K"G "k!n>> from shapely.geometry import Point >>> d = {'col1': ['name1', 'name2'], 'geometry': [Point(1, 2), Point(2, 1)]} >>> gdf = geopandas.GeoDataFrame(d, crs="EPSG:4326") >>> gdf col1 geometry 0 name1 POINT (1 2) 1 name2 POINT (2 1) >>> gdf.__geo_interface__ {'type': 'FeatureCollection', 'features': [{'id': '0', 'type': 'Feature', 'properties': {'col1': 'name1'}, 'geometry': {'type': 'Point', 'coordinates': (1.0, 2.0)}, 'bbox': (1.0, 2.0, 1.0, 2.0)}, {'id': '1', 'type': 'Feature', 'properties': {'col1': 'name2'}, 'geometry': {'type': 'Point', 'coordinates': (2.0, 1.0)}, 'bbox': (2.0, 1.0, 2.0, 1.0)}], 'bbox': (1.0, 1.0, 2.0, 2.0)} nullTFr)rrs r,rGeoDataFrame.__geo_interface__s>6T5IIr.c ## US;a[SU35eURU;a[SURS35e[R"UR 5n[R"XR5nUR R(d [S5eUR RUR5n[U5S:GaXnUR[5n[R"U5RnUS:XaSXx'[UR5HupXYn WS :Xa1Xn [!XjU 5V VVs0sHupnU(aMX_M nnn nO[#[!Xj55nU(a0nOS [%XI50nS US 'UUS 'U (a ['U 5OSUS'U(aU (a U R(OSUS'Uv M g[!XE5Haunn U(a0nO S [%U50nS US '0US 'U (a ['U 5OSUS'U(aU (a U R(OSUS'Uv Mc gs snnn f7f)aReturn an iterator that yields feature dictionaries that comply with __geo_interface__. Parameters ---------- na : str, optional Options are {'null', 'drop', 'keep'}, default 'null'. Indicates how to output missing (NaN) values in the GeoDataFrame - null: output the missing entries as JSON null - drop: remove the property from the feature. This applies to each feature individually so that features may have different properties - keep: output the missing entries as NaN show_bbox : bool, optional Include bbox (bounds) in the geojson. Default False. drop_id : bool, default: False Whether to retain the index of the GeoDataFrame as the id property in the generated GeoJSON. Default is False, but may want True if the index is just arbitrary row numbers. Examples -------- >>> from shapely.geometry import Point >>> d = {'col1': ['name1', 'name2'], 'geometry': [Point(1, 2), Point(2, 1)]} >>> gdf = geopandas.GeoDataFrame(d, crs="EPSG:4326") >>> gdf col1 geometry 0 name1 POINT (1 2) 1 name2 POINT (2 1) >>> feature = next(gdf.iterfeatures()) >>> feature {'id': '0', 'type': 'Feature', 'properties': {'col1': 'name1'}, 'geometry': {'type': 'Point', 'coordinates': (1.0, 2.0)}} )rrrkeepzUnknown na method z*No geometry data set (expected in column 'z').z4GeoDataFrame cannot contain duplicated column names.rrNrridFeaturerrr3bbox)rCr2r^r(r)r#r6 is_uniquerrrIastyper:r?rKrH enumerateziprr7rbounds)rPrrrids geometriesproperties_colsrna_maskirgeom na_mask_rowkvproperties_itemsrfids r, iterfeaturesGeoDataFrame.iterfeatures@s6N - -1"67 7  % %T 1 ../s4  jj$ZZ%?%? @A ||%%ST T,,++D,F,FG  ! #"3O(//7Jggo.55GV|&* ##J$5$56!}<")*K),O+(N((NHA"!(N%($ (,C,E'F$ G#S[1G"+(8 %7;gdm #59dkktGFO 378!1 T G#SX.G"+(* %7;gdm #59dkktGFO 2/(sEI#I *I 0C3I#c S[URXUS95S.nU(a&[URR 55US'U$)aReturn a python feature collection representation of the GeoDataFrame as a dictionary with a list of features based on the ``__geo_interface__`` GeoJSON-like specification. Parameters ---------- na : str, optional Options are {'null', 'drop', 'keep'}, default 'null'. Indicates how to output missing (NaN) values in the GeoDataFrame - null: output the missing entries as JSON null - drop: remove the property from the feature. This applies to each feature individually so that features may have different properties - keep: output the missing entries as NaN show_bbox : bool, optional Include bbox (bounds) in the geojson. Default False. drop_id : bool, default: False Whether to retain the index of the GeoDataFrame as the id property in the generated dictionary. Default is False, but may want True if the index is just arbitrary row numbers. Examples -------- >>> from shapely.geometry import Point >>> d = {'col1': ['name1', 'name2'], 'geometry': [Point(1, 2), Point(2, 1)]} >>> gdf = geopandas.GeoDataFrame(d) >>> gdf col1 geometry 0 name1 POINT (1 2) 1 name2 POINT (2 1) >>> gdf.to_geo_dict() {'type': 'FeatureCollection', 'features': [{'id': '0', 'type': 'Feature', 'properties': {'col1': 'name1'}, 'geometry': {'type': 'Point', 'coordinates': (1.0, 2.0)}}, {'id': '1', 'type': 'Feature', 'properties': {'col1': 'name2'}, 'geometry': {'type': 'Point', 'coordinates': (2.0, 1.0)}}]} See Also -------- GeoDataFrame.to_json : return a GeoDataFrame as a GeoJSON string rr)rrr)r\rtuple total_boundstolist)rPrrrrs r,rGeoDataFrame.to_geo_dictsQ^(!!Rg!N   1 1 8 8 :;CK r.c [UR55nURURS:HHn[ X4R 4SU0UD6X4'M! U$)aX Encode all geometry columns in the GeoDataFrame to WKB. Parameters ---------- hex : bool If true, export the WKB as a hexadecimal string. The default is to return a binary bytes object. kwargs Additional keyword args will be passed to :func:`shapely.to_wkb`. Returns ------- DataFrame geometry columns are encoded to WKB r3hex)rr&r6r]rrH)rPrrRrris r,rGeoDataFrame.to_wkbsU$tyy{ #::bii:56CRW^^???BG7 r.c [UR55nURURS:HHn[ X#R 40UD6X#'M U$)z Encode all geometry columns in the GeoDataFrame to WKT. Parameters ---------- kwargs Keyword args will be passed to :func:`shapely.to_wkt`. Returns ------- DataFrame geometry columns are encoded to WKT r3)rr&r6r]rrH)rPrRrris r,rGeoDataFrame.to_wktsPtyy{ #::bii:56CRW^^6v6BG7 r.WKBr#geometry_encoding interleaved include_zc:SSKJnJn U"UUUUUS9upxU"U5$)a4 Encode a GeoDataFrame to GeoArrow format. See https://geoarrow.org/ for details on the GeoArrow specification. This function returns a generic Arrow data object implementing the `Arrow PyCapsule Protocol`_ (i.e. having an ``__arrow_c_stream__`` method). This object can then be consumed by your Arrow implementation of choice that supports this protocol. .. _Arrow PyCapsule Protocol: https://arrow.apache.org/docs/format/CDataInterface/PyCapsuleInterface.html .. versionadded:: 1.0 Parameters ---------- index : bool, default None If ``True``, always include the dataframe's index(es) as columns in the file output. If ``False``, the index(es) will not be written to the file. If ``None``, the index(ex) will be included as columns in the file output except `RangeIndex` which is stored as metadata only. geometry_encoding : {'WKB', 'geoarrow' }, default 'WKB' The GeoArrow encoding to use for the data conversion. interleaved : bool, default True Only relevant for 'geoarrow' encoding. If True, the geometries' coordinates are interleaved in a single fixed size list array. If False, the coordinates are stored as separate arrays in a struct type. include_z : bool, default None Only relevant for 'geoarrow' encoding (for WKB, the dimensionality of the individial geometries is preserved). If False, return 2D geometries. If True, include the third dimension in the output (if a geometry has no third dimension, the z-coordinates 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). Returns ------- ArrowTable A generic Arrow table object with geometry columns encoded to GeoArrow. Examples -------- >>> from shapely.geometry import Point >>> data = {'col1': ['name1', 'name2'], 'geometry': [Point(1, 2), Point(2, 1)]} >>> gdf = geopandas.GeoDataFrame(data) >>> gdf col1 geometry 0 name1 POINT (1 2) 1 name2 POINT (2 1) >>> arrow_table = gdf.to_arrow() >>> arrow_table The returned data object needs to be consumed by a library implementing the Arrow PyCapsule Protocol. For example, wrapping the data as a pyarrow.Table (requires pyarrow >= 14.0): >>> import pyarrow as pa >>> table = pa.table(arrow_table) >>> table pyarrow.Table col1: string geometry: binary ---- col1: [["name1","name2"]] geometry: [[0101000000000000000000F03F0000000000000040,01010000000000000000000040000000000000F03F]] r) ArrowTablegeopandas_to_arrowr)rrr) rPr#rrrrrr_s r,to_arrowGeoDataFrame.to_arrows1d J% /#  %  r.c URSS5nUS;a[SU<S35eSSKJn U "UU4UUUUUS.UD6 g ) a%Write a GeoDataFrame to the Parquet format. By default, all geometry columns present are serialized to WKB format in the file. Requires 'pyarrow'. .. versionadded:: 0.8 Parameters ---------- path : str, path object index : bool, default None If ``True``, always include the dataframe's index(es) as columns in the file output. If ``False``, the index(es) will not be written to the file. If ``None``, the index(ex) will be included as columns in the file output except `RangeIndex` which is stored as metadata only. compression : {'snappy', 'gzip', 'brotli', 'lz4', 'zstd', None}, default 'snappy' Name of the compression to use. Use ``None`` for no compression. geometry_encoding : {'WKB', 'geoarrow'}, default 'WKB' The encoding to use for the geometry columns. Defaults to "WKB" for maximum interoperability. Specify "geoarrow" to use one of the native GeoArrow-based single-geometry type encodings. Note: the "geoarrow" option is part of the newer GeoParquet 1.1 specification, should be considered as experimental, and may not be supported by all readers. write_covering_bbox : bool, default False Writes the bounding box column for each row entry with column name 'bbox'. Writing a bbox column can be computationally expensive, but allows you to specify a `bbox` in : func:`read_parquet` for filtered reading. Note: this bbox column is part of the newer GeoParquet 1.1 specification and should be considered as experimental. While writing the column is backwards compatible, using it for filtering may not be supported by all readers. schema_version : {'0.1.0', '0.4.0', '1.0.0', '1.1.0', None} GeoParquet specification version; if not provided, will default to latest supported stable version (1.0.0). kwargs Additional keyword arguments passed to :func:`pyarrow.parquet.write_table`. Examples -------- >>> gdf.to_parquet('data.parquet') # doctest: +SKIP See Also -------- GeoDataFrame.to_feather : write GeoDataFrame to feather GeoDataFrame.to_file : write GeoDataFrame to file engineauto)rpyarrowzDGeoPandas only supports using pyarrow as the engine for to_parquet: z passed instead.r) _to_parquet) compressionrr#schema_versionwrite_covering_bboxN)rrCgeopandas.io.arrowr!) rPpathr#r"rr$r#rRrr!s r, to_parquetGeoDataFrame.to_parquetsspBHf- , ,%j(8:  3   $/) 3  r.c ,SSKJn U"UU4UUUS.UD6 g)aWrite a GeoDataFrame to the Feather format. Any geometry columns present are serialized to WKB format in the file. Requires 'pyarrow' >= 0.17. .. versionadded:: 0.8 Parameters ---------- path : str, path object index : bool, default None If ``True``, always include the dataframe's index(es) as columns in the file output. If ``False``, the index(es) will not be written to the file. If ``None``, the index(ex) will be included as columns in the file output except `RangeIndex` which is stored as metadata only. compression : {'zstd', 'lz4', 'uncompressed'}, optional Name of the compression to use. Use ``"uncompressed"`` for no compression. By default uses LZ4 if available, otherwise uncompressed. schema_version : {'0.1.0', '0.4.0', '1.0.0', None} GeoParquet specification version; if not provided will default to latest supported version. kwargs Additional keyword arguments passed to :func:`pyarrow.feather.write_feather`. Examples -------- >>> gdf.to_feather('data.feather') # doctest: +SKIP See Also -------- GeoDataFrame.to_parquet : write GeoDataFrame to parquet GeoDataFrame.to_file : write GeoDataFrame to file r) _to_feather)r#r"r#N)r%r*)rPr&r#r"r#rRr*s r, to_featherGeoDataFrame.to_feathers0X 3   #)    r.c &SSKJn U"XX#U40UD6 g)aWrite the ``GeoDataFrame`` to a file. By default, an ESRI shapefile is written, but any OGR data source supported by Pyogrio or Fiona can be written. A dictionary of supported OGR providers is available via: >>> import pyogrio >>> pyogrio.list_drivers() # doctest: +SKIP Parameters ---------- filename : string File path or file handle to write to. The path may specify a GDAL VSI scheme. driver : string, default None The OGR format driver used to write the vector file. If not specified, it attempts to infer it from the file extension. If no extension is specified, it saves ESRI Shapefile to a folder. schema : dict, default None If specified, the schema dictionary is passed to Fiona to better control how the file is written. If None, GeoPandas will determine the schema based on each column's dtype. Not supported for the "pyogrio" engine. index : bool, default None If True, write index into one or more columns (for MultiIndex). Default None writes the index into one or more columns only if the index is named, is a MultiIndex, or has a non-integer data type. If False, no index is written. .. versionadded:: 0.7 Previously the index was not written. mode : string, default 'w' The write mode, 'w' to overwrite the existing file and 'a' to append. Not all drivers support appending. The drivers that support appending are listed in fiona.supported_drivers or https://github.com/Toblerity/Fiona/blob/master/fiona/drvsupport.py crs : pyproj.CRS, default None If specified, the CRS is passed to Fiona to better control how the file is written. If None, GeoPandas will determine the crs based on crs df attribute. The value can be anything accepted by :meth:`pyproj.CRS.from_user_input() `, such as an authority string (eg "EPSG:4326") or a WKT string. The keyword is not supported for the "pyogrio" engine. engine : str, "pyogrio" or "fiona" The underlying library that is used to write the file. Currently, the supported options are "pyogrio" and "fiona". Defaults to "pyogrio" if installed, otherwise tries "fiona". metadata : dict[str, str], default None Optional metadata to be stored in the file. Keys and values must be strings. Supported only for "GPKG" driver. **kwargs : Keyword args to be passed to the engine, and can be used to write to multi-layer data, store data within archives (zip files), etc. In case of the "pyogrio" engine, the keyword arguments are passed to `pyogrio.write_dataframe`. In case of the "fiona" engine, the keyword arguments are passed to fiona.open`. For more information on possible keywords, type: ``import pyogrio; help(pyogrio.write_dataframe)``. Notes ----- The format drivers will attempt to detect the encoding of your data, but may fail. In this case, the proper encoding can be specified explicitly by using the encoding keyword parameter, e.g. ``encoding='utf-8'``. See Also -------- GeoSeries.to_file GeoDataFrame.to_postgis : write GeoDataFrame to PostGIS database GeoDataFrame.to_parquet : write GeoDataFrame to parquet GeoDataFrame.to_feather : write GeoDataFrame to feather Examples -------- >>> gdf.to_file('dataframe.shp') # doctest: +SKIP >>> gdf.to_file('dataframe.gpkg', driver='GPKG', layer='name') # doctest: +SKIP >>> gdf.to_file('dataframe.geojson', driver='GeoJSON') # doctest: +SKIP With selected drivers you can also append to a file with `mode="a"`: >>> gdf.to_file('dataframe.shp', mode="a") # doctest: +SKIP Using the engine-specific keyword arguments it is possible to e.g. create a spatialite file with a custom layer name: >>> gdf.to_file( ... 'dataframe.sqlite', driver='SQLite', spatialite=True, layer='test' ... ) # doctest: +SKIP r)_to_fileN)geopandas.io.filer.)rPrdriverschemar#rRr.s r,to_fileGeoDataFrame.to_filesH /A&Ar.cgrorprPr"rr<allow_overrides r,set_crsGeoDataFrame.set_crsgrtr.cgrorpr5s r,r7r8prvr.czU(dUR5nOUnURRXUSS9UlU$)u Set the Coordinate Reference System (CRS) of the ``GeoDataFrame``. If there are multiple geometry columns within the GeoDataFrame, only the CRS of the active geometry column is set. Pass ``None`` to remove CRS from the active geometry column. Notes ----- The underlying geometries are not transformed to this CRS. To transform the geometries to a new CRS, use the ``to_crs`` method. Parameters ---------- crs : pyproj.CRS | None, optional The value can be anything accepted by :meth:`pyproj.CRS.from_user_input() `, such as an authority string (eg "EPSG:4326") or a WKT string. epsg : int, optional EPSG code specifying the projection. inplace : bool, default False If True, the CRS of the GeoDataFrame will be changed in place (while still returning the result) instead of making a copy of the GeoDataFrame. allow_override : bool, default False If the the GeoDataFrame already has a CRS, allow to replace the existing CRS, even when both are not equal. Examples -------- >>> from shapely.geometry import Point >>> d = {'col1': ['name1', 'name2'], 'geometry': [Point(1, 2), Point(2, 1)]} >>> gdf = geopandas.GeoDataFrame(d) >>> gdf col1 geometry 0 name1 POINT (1 2) 1 name2 POINT (2 1) Setting CRS to a GeoDataFrame without one: >>> gdf.crs is None True >>> gdf = gdf.set_crs('epsg:3857') >>> gdf.crs # doctest: +SKIP Name: WGS 84 / Pseudo-Mercator Axis Info [cartesian]: - X[east]: Easting (metre) - Y[north]: Northing (metre) Area of Use: - name: World - 85°S to 85°N - bounds: (-180.0, -85.06, 180.0, 85.06) Coordinate Operation: - name: Popular Visualisation Pseudo-Mercator - method: Popular Visualisation Pseudo Mercator Datum: World Geodetic System 1984 - Ellipsoid: WGS 84 - Prime Meridian: Greenwich Overriding existing CRS: >>> gdf = gdf.set_crs(4326, allow_override=True) Without ``allow_override=True``, ``set_crs`` returns an error if you try to override CRS. See Also -------- GeoDataFrame.to_crs : re-project to another CRS T)r"rr6r<)r&r3r7)rPr"rr<r6rs r,r7r8ysA`BBkk))~t*   r.cgrorprPr"rr<s r,rGeoDataFrame.to_crss r.cgrorpr<s r,rr=s r.cU(aUnOUR5nURRXS9nXTlU(dU$g)u Transform geometries to a new coordinate reference system. Transform all geometries in an active geometry column to a different coordinate reference system. The ``crs`` attribute on the current GeoSeries must be set. Either ``crs`` or ``epsg`` may be specified for output. This method will transform all points in all objects. It has no notion of projecting entire geometries. All segments joining points are assumed to be lines in the current projection, not geodesics. Objects crossing the dateline (or other projection boundary) will have undesirable behavior. Parameters ---------- crs : pyproj.CRS, optional if `epsg` is specified The value can be anything accepted by :meth:`pyproj.CRS.from_user_input() `, such as an authority string (eg "EPSG:4326") or a WKT string. epsg : int, optional if `crs` is specified EPSG code specifying output projection. inplace : bool, optional, default: False Whether to return a new GeoDataFrame or do the transformation in place. Returns ------- GeoDataFrame Examples -------- >>> from shapely.geometry import Point >>> d = {'col1': ['name1', 'name2'], 'geometry': [Point(1, 2), Point(2, 1)]} >>> gdf = geopandas.GeoDataFrame(d, crs=4326) >>> gdf col1 geometry 0 name1 POINT (1 2) 1 name2 POINT (2 1) >>> gdf.crs # doctest: +SKIP Name: WGS 84 Axis Info [ellipsoidal]: - Lat[north]: Geodetic latitude (degree) - Lon[east]: Geodetic longitude (degree) Area of Use: - name: World - bounds: (-180.0, -90.0, 180.0, 90.0) Datum: World Geodetic System 1984 - Ellipsoid: WGS 84 - Prime Meridian: Greenwich >>> gdf = gdf.to_crs(3857) >>> gdf col1 geometry 0 name1 POINT (111319.491 222684.209) 1 name2 POINT (222638.982 111325.143) >>> gdf.crs # doctest: +SKIP Name: WGS 84 / Pseudo-Mercator Axis Info [cartesian]: - X[east]: Easting (metre) - Y[north]: Northing (metre) Area of Use: - name: World - 85°S to 85°N - bounds: (-180.0, -85.06, 180.0, 85.06) Coordinate Operation: - name: Popular Visualisation Pseudo-Mercator - method: Popular Visualisation Pseudo Mercator Datum: World Geodetic System 1984 - Ellipsoid: WGS 84 - Prime Meridian: Greenwich See Also -------- GeoDataFrame.set_crs : assign CRS without re-projection )r"rN)r&r3r)rPr"rr<rrs r,rr=sAb BB{{!!c!5 Ir.c4URRUS9$)uMReturn the estimated UTM CRS based on the bounds of the dataset. .. versionadded:: 0.9 Parameters ---------- datum_name : str, optional The name of the datum to use in the query. Default is WGS 84. Returns ------- pyproj.CRS Examples -------- >>> import geodatasets >>> df = geopandas.read_file( ... geodatasets.get_path("geoda.chicago_health") ... ) >>> df.estimate_utm_crs() # doctest: +SKIP Name: WGS 84 / UTM zone 16N Axis Info [cartesian]: - E[east]: Easting (metre) - N[north]: Northing (metre) Area of Use: - name: Between 90°W and 84°W, northern hemisphere between equator and 84°N... - bounds: (-90.0, 0.0, -84.0, 84.0) Coordinate Operation: - name: UTM zone 16N - method: Transverse Mercator Datum: World Geodetic System 1984 ensemble - Ellipsoid: WGS 84 - Prime Meridian: Greenwich ) datum_name)r3estimate_utm_crs)rPrAs r,rBGeoDataFrame.estimate_utm_crs<sH}}---DDr.c>[TU]U5n[RRR U5(aUS:Xa[ UR[R5(a`[ U[5(aK[U5(d;URRU5nURSS2U4RSS9nURn[ U[5(a,[ UR[ 5(a ["UlU$[ U[&5(aIUR(S:HR+5S:a[-U5UlXB;aXBlU$[&UlU$)z If the result is a column containing only 'geometry', return a GeoSeries. If it's a DataFrame with any columns of GeometryDtype, return a GeoDataFrame. Nr6axisr3r)rA __getitem__r?rerf is_scalarr%r6 MultiIndexrrget_locilocsqueezer2r9r rrTrr]rFr)rPkeyresultlocgeo_colrTs r,rHGeoDataFrame.__getitem__bs% $S) FFLL " "3 ' 'r 4<<7766**$V,,,,&&s+CYYq#v&..I.>F,, ff % %*V\\=*Q*Q(F   * * +002Q6#': $3:0 $-  r.cURc5SUR;a$Sn[R"U[SS9 SUlggg)z`Persist the default geometry column name of 'geometry' temporarily for backwards compatibility. Nr3aYou are adding a column named 'geometry' to a GeoDataFrame constructed without an active geometry column. Currently, this automatically sets the active geometry column to 'geometry' but in the future that will no longer happen. Instead, either provide geometry to the GeoDataFrame constructor (GeoDataFrame(... geometry=GeoSeries()) or use `set_geometry('geometry')` to explicitly set the active geometry column.r{)r2r6rrr)rPr_s r,rh2GeoDataFrame._persist_old_default_geometry_colnamesI  % % -*DLL2P@  MM# ! D)3D &3Q -r.cx>[RRRU5(dXR:XdUS:XaURc[RRR U5(d[ U[5(aU/URS-n[USS5n[ U[R[R-5(aSn[X#S9nUS:XaUR5 ["TU]IX5 g![a [R "SSS9 N1f=f) zzOverridden to preserve CRS of GeometryArray. Important for cases like df['geometry'] = [geom... for geom in df.geometry] r3Nrr"r!z*Geometry column does not contain geometry.rzr)r?rerfrgr2rIr%r r rrrr-rhrMrrrA __setitem__)rPrNrr"rTs r,rWGeoDataFrame.__setitem__s vv||((-- -- -z!d&@&@&Hvv||%%e,, 5,0O0O$**Q-/$t,C#ryy2<<788 A(8*$>>@ C'  @  s( DD98D9c>[TU]US9n[U5[RLa![U5UlUR UlU$)Nrx)rAr&rr?rrTr2)rPrycopiedrTs r,r&GeoDataFrame.copysB4( <2<< '#DzF +/+E+EF ( r.c V>[TU]"U4X#XES.UD6n[U[5(alURUR ;aRUR UR5nURb'URcURURSS9 U$[U[5(aAURS:Xa1UR5R5(d[U5nU$U$![a U$f=f![[R R"4a U$f=f)N)rGraw result_typerQTrdr:)rAapplyr%rr2r6rOr"r7rMrr9rKrLr-shapelyerrorsGeometryTypeError) rPfuncrGr]r^rQrRrOrTs r,r_GeoDataFrame.applys!  + LR  vy ) )**fnn< ;,,T-G-GH88'FJJ,>NN488TN:  ' 'FLLH,D;;=$$&&-f5F  v #   # "7>>#C#CD s$C/ D/ C=<C=$D('D(cU"U0UD6nURS:Hn[U5S:XdUR5S:Xa[R"U5nU$)zA flexible constructor for GeoDataFrame._constructor, which falls back to returning a DataFrame (if a certain operation does not preserve the geometry column). r3r)r]rIrFr?r)rrQrRrgeometry_cols_masks r,'_geodataframe_constructor_with_fallback4GeoDataFrame._geodataframe_constructor_with_fallbacksT$ !& !YY*4 ! "a '+=+A+A+Cq+Hb!B r.cUR$ro)rgrs r, _constructorGeoDataFrame._constructors;;;r.c[SUR55(d.UR[RR X55$UR X5nUR S:HR5S:XaSUlU$)Nc3V# UHn[UR[5v M! g7fro)r%r9r ).0blocks r, 5GeoDataFrame._constructor_from_mgr..sRze:ekk=99zs')r3r) anyblocksrgr?r _from_mgrr6rFr2)rPmgraxesgdfs r,_constructor_from_mgr"GeoDataFrame._constructor_from_mgrswRszzRRR?? &&s1 nnS' KK: % * * , 1(2C % r.c^U4SjnU$)Nc>[R"U0UD6nURRTR5n[ U5(aU(d [ U5nU$)aA specialized (Geo)Series constructor which can fall back to a Series if a certain operation does not produce geometries. Note: - We only return a GeoSeries if the data is actually of geometry dtype (and so we don't try to convert geometry objects such as the normal GeoSeries(..) constructor does with `_ensure_geometry`). - When we get here from obtaining a row or column from a GeoDataFrame, the goal is to only return a GeoSeries for a geometry column, and not return a GeoSeries for a row that happened to come from a DataFrame with only geometry dtype columns (and thus could have a geometry dtype). Therefore, we don't return a GeoSeries if we are sure we are in a row selection case (by checking the identity of the index) )r?rr#is_r6rr)rQrRsrs is_row_proxyrPs r, _geodataframe_constructor_slicedJGeoDataFrame._constructor_sliced.._geodataframe_constructor_sliced sI"))T,V,C99==6L$$\nJr.rp)rPrs` r,_constructor_sliced GeoDataFrame._constructor_sliceds .0/r.c URRUR5n[URSR [ 5(aU(d[R"X5$[R"X5$)Nr) r#r|r6r%rsr9r rrtr)rPrurvr~s r,_constructor_sliced_from_mgr)GeoDataFrame._constructor_sliced_from_mgr#sWyy}}T\\2 cjjm))= 9 9,&&s1 1**r.c >[TU]"U4SU0UD6nUS:Xa@URH.n[R X[ UR US55 M0 U$US:XaURH1n[R X[ URSUS55 M3 URRS:Xa+URUR:HR5S:dTURRS:aSURRS5UR:HR5S:a[SURS35eU$US :XaSUl SUlU$) z&Propagate metadata from other to self.methodmergeNconcatrrzRConcat operation has resulted in multiple columns using the geometry column name 'zF'. Please ensure this column from the first DataFrame is not repeated.unstack)rA __finalize__ _metadatar:rWrleftobjsr6rEr2rFget_level_valuesrCr)rPotherrrRr$rTs r,rGeoDataFrame.__finalize__*sWw#EC&CFC W ""4wuzz4/NO'8 3x ""4wuzz!}dD/QR' $$)\\T%?%??DDFJ $$q(LL11!48R8RR#% !1151K1K0LM   y *.D &DI r.c  \^^ Uc!Uc[R"[U5SS9nUUUUUS.n URURR SS9n U R "S 0U D6R"U40U D6n U RR5U lU U4SjnUR "S SS0U D6URR RU5n[U5"XRR URS 9nURU 5nU(dUR5nU$) a Dissolve geometries within `groupby` into single observation. This is accomplished by applying the `union_all` method to all geometries within a groupself. Observations associated with each `groupby` group will be aggregated using the `aggfunc`. Parameters ---------- by : str or list-like, default None Column(s) whose values define the groups to be dissolved. If None, the entire GeoDataFrame is considered as a single group. If a list-like object is provided, the values in the list are treated as categorical labels, and polygons will be combined based on the equality of these categorical labels. aggfunc : function or string, default "first" Aggregation function for manipulation of data associated with each group. Passed to pandas `groupby.agg` method. Accepted combinations are: - function - string function name - list of functions and/or function names, e.g. [np.sum, 'mean'] - dict of axis labels -> functions, function names or list of such. as_index : boolean, default True If true, groupby columns become index of result. level : int or str or sequence of int or sequence of str, default None If the axis is a MultiIndex (hierarchical), group by a particular level or levels. sort : bool, default True Sort group keys. Get better performance by turning this off. Note this does not influence the order of observations within each group. Groupby preserves the order of rows within each group. observed : bool, default False This only applies if any of the groupers are Categoricals. If True: only show observed values for categorical groupers. If False: show all values for categorical groupers. dropna : bool, default True If True, and if group keys contain NA values, NA values together with row/column will be dropped. If False, NA values will also be treated as the key in groups. method : str (default ``"unary"``) The method to use for the union. Options are: * ``"unary"``: use the unary union algorithm. This option is the most robust but can be slow for large numbers of geometries (default). * ``"coverage"``: use the coverage union algorithm. This option is optimized for non-overlapping polygons and can be significantly faster than the unary union algorithm. However, it can produce invalid geometries if the polygons overlap. * ``"disjoint_subset:``: use the disjoint subset union algorithm. This option is optimized for inputs that can be divided into subsets that do not intersect. If there is only one such subset, performance can be expected to be worse than ``"unary"``. Requires Shapely >= 2.1. grid_size : float, default None When grid size is specified, a fixed-precision space is used to perform the union operations. This can be useful when unioning geometries that are not perfectly snapped or to avoid geometries not being unioned because of `robustness issues `_. The inputs are first snapped to a grid of the given size. When a line segment of a geometry is within tolerance off a vertex of another geometry, this vertex will be inserted in the line segment. Finally, the result vertices are computed on the same grid. Is only supported for ``method`` ``"unary"``. If None, the highest precision of the inputs will be used. Defaults to None. .. versionadded:: 1.1.0 **kwargs : Keyword arguments to be passed to the pandas `DataFrameGroupby.agg` method which is used by `dissolve`. In particular, `numeric_only` may be supplied, which will be required in pandas 2.0 for certain aggfuncs. .. versionadded:: 0.13.0 Returns ------- GeoDataFrame Examples -------- >>> from shapely.geometry import Point >>> d = { ... "col1": ["name1", "name2", "name1"], ... "geometry": [Point(1, 2), Point(2, 1), Point(0, 1)], ... } >>> gdf = geopandas.GeoDataFrame(d, crs=4326) >>> gdf col1 geometry 0 name1 POINT (1 2) 1 name2 POINT (2 1) 2 name1 POINT (0 1) >>> dissolved = gdf.dissolve('col1') >>> dissolved # doctest: +SKIP geometry col1 name1 MULTIPOINT ((0 1), (1 2)) name2 POINT (2 1) See Also -------- GeoDataFrame.explode : explode multi-part geometries into single geometries int64r8)byrsortobserveddropnar)labelsrGc(>URTTS9nU$)N)r grid_size) union_all)ro merged_geomrrs r,merge_geometries/GeoDataFrame.dissolve..merge_geometriess//9/MK r. group_keysFr4rp)r(zerosrIrrr3r$groupbyaggr6 to_flat_indexrr"join reset_index)rPraggfuncas_indexrrrrrrrRgroupby_kwargsr*aggregated_datargaggregated_geometry aggregateds `` r,dissolveGeoDataFrame.dissolvePsp :%-#d)73B   yy 2 2y;,,88< #//1Jr.c >UcURRn[XR[5(d[ TU]"U4SU0UD6$URRSS9R SS9nURURSS9RURRS55nURXeR'URUR5RU5nU(aURSSS9 U$U(aRUR!URR[#[%URR&S- 555SS 9nU$) u Explode multi-part geometries into multiple single geometries. Each row containing a multi-part geometry will be split into multiple rows with single geometries, thereby increasing the vertical size of the GeoDataFrame. Parameters ---------- column : string, default None Column to explode. In the case of a geometry column, multi-part geometries are converted to single-part. If None, the active geometry column is used. ignore_index : bool, default False If True, the resulting index will be labelled 0, 1, …, n - 1, ignoring `index_parts`. index_parts : boolean, default False If True, the resulting index will be a multi-index (original index with an additional level indicating the multiple geometries: a new zero-based index for each single part geometry per multi-part geometry). Returns ------- GeoDataFrame Exploded geodataframe with each single geometry as a separate entry in the geodataframe. Examples -------- >>> from shapely.geometry import MultiPoint >>> d = { ... "col1": ["name1", "name2"], ... "geometry": [ ... MultiPoint([(1, 2), (3, 4)]), ... MultiPoint([(2, 1), (0, 0)]), ... ], ... } >>> gdf = geopandas.GeoDataFrame(d, crs=4326) >>> gdf col1 geometry 0 name1 MULTIPOINT ((1 2), (3 4)) 1 name2 MULTIPOINT ((2 1), (0 0)) >>> exploded = gdf.explode(index_parts=True) >>> exploded col1 geometry 0 0 name1 POINT (1 2) 1 name1 POINT (3 4) 1 0 name2 POINT (2 1) 1 name2 POINT (0 0) >>> exploded = gdf.explode(index_parts=False) >>> exploded col1 geometry 0 name1 POINT (1 2) 0 name1 POINT (3 4) 1 name2 POINT (2 1) 1 name2 POINT (0 0) >>> exploded = gdf.explode(ignore_index=True) >>> exploded col1 geometry 0 name1 POINT (1 2) 1 name1 POINT (3 4) 2 name2 POINT (2 1) 3 name2 POINT (0 0) See Also -------- GeoDataFrame.dissolve : dissolve geometries into a single observation. ignore_indexT)rr) index_partsrrF)r<rr)r)r3r$r%r9r rAexploderrrr2taker# droplevelrHrOr set_indexr\rangerE)rPcolumnrrrR exploded_geomrrTs r,rGeoDataFrame.explodesLb >]]''F$,,,m<<7?6O OO O 11t1<DDQUDV YYt11Y : ? ?    ) )" - "/!5!5   __T77 8 E Ed K  NN4dN 3 ##--}22::Q>?@ B r.c ^[RRRXX#XEXgU5 g)a  Upload GeoDataFrame into PostGIS database. This method requires SQLAlchemy and GeoAlchemy2, and a PostgreSQL Python driver (psycopg or psycopg2) to be installed. It is also possible to use :meth:`~GeoDataFrame.to_file` to write to a database. Especially for file geodatabases like GeoPackage or SpatiaLite this can be easier. Parameters ---------- name : str Name of the target table. con : sqlalchemy.engine.Connection or sqlalchemy.engine.Engine Active connection to the PostGIS database. if_exists : {'fail', 'replace', 'append'}, default 'fail' How to behave if the table already exists: - fail: Raise a ValueError. - replace: Drop the table before inserting new values. - append: Insert new values to the existing table. schema : string, optional Specify the schema. If None, use default schema: 'public'. index : bool, default False Write DataFrame index as a column. Uses *index_label* as the column name in the table. index_label : string or sequence, default None Column label for index column(s). If None is given (default) and index is True, then the index names are used. chunksize : int, optional Rows will be written in batches of this size at a time. By default, all rows will be written at once. dtype : dict of column name to SQL type, default None Specifying the datatype for columns. The keys should be the column names and the values should be the SQLAlchemy types. Examples -------- >>> from sqlalchemy import create_engine >>> engine = create_engine("postgresql://myusername:mypassword@myhost:5432/mydatabase") # doctest: +SKIP >>> gdf.to_postgis("my_table", engine) # doctest: +SKIP See Also -------- GeoDataFrame.to_file : write GeoDataFrame to file read_postgis : read PostGIS database to GeoDataFrame N)rrr_write_postgis) rPr$rr1 if_existsr# index_labelrr9s r, to_postgisGeoDataFrame.to_postgis[ s(~  '' Y{u r.plotc [U/UQ70UD6$ror)rPrQrRs r,exploreGeoDataFrame.explore s.t.v..r.c <[R"SUUUUUUS.UD6$)a Spatial join of two GeoDataFrames. See the User Guide page :doc:`../../user_guide/mergingdata` for details. Parameters ---------- df : GeoDataFrame how : string, default 'inner' The type of join: * 'left': use keys from left_df; retain only left_df geometry column * 'right': use keys from right_df; retain only right_df geometry column * 'inner': use intersection of keys from both dfs; retain only left_df geometry column predicate : string, default 'intersects' Binary predicate. Valid values are determined by the spatial index used. You can check the valid values in left_df or right_df as ``left_df.sindex.valid_query_predicates`` or ``right_df.sindex.valid_query_predicates`` lsuffix : string, default 'left' Suffix to apply to overlapping column names (left GeoDataFrame). rsuffix : string, default 'right' Suffix to apply to overlapping column names (right GeoDataFrame). distance : number or array_like, optional Distance(s) around each input geometry within which to query the tree for the 'dwithin' predicate. If array_like, must be one-dimesional with length equal to length of left GeoDataFrame. Required if ``predicate='dwithin'``. on_attribute : string, list or tuple Column name(s) to join on as an additional join restriction on top of the spatial predicate. These must be found in both DataFrames. If set, observations are joined only if the predicate applies and values in specified columns match. Examples -------- >>> import geodatasets >>> chicago = geopandas.read_file( ... geodatasets.get_path("geoda.chicago_commpop") ... ) >>> groceries = geopandas.read_file( ... geodatasets.get_path("geoda.groceries") ... ).to_crs(chicago.crs) >>> chicago.head() # doctest: +SKIP community ... geometry 0 DOUGLAS ... MULTIPOLYGON (((-87.60914 41.84469, -87.60915 ... 1 OAKLAND ... MULTIPOLYGON (((-87.59215 41.81693, -87.59231 ... 2 FULLER PARK ... MULTIPOLYGON (((-87.62880 41.80189, -87.62879 ... 3 GRAND BOULEVARD ... MULTIPOLYGON (((-87.60671 41.81681, -87.60670 ... 4 KENWOOD ... MULTIPOLYGON (((-87.59215 41.81693, -87.59215 ... [5 rows x 9 columns] >>> groceries.head() # doctest: +SKIP OBJECTID Ycoord ... Category geometry 0 16 41.973266 ... NaN MULTIPOINT ((-87.65661 41.97321)) 1 18 41.696367 ... NaN MULTIPOINT ((-87.68136 41.69713)) 2 22 41.868634 ... NaN MULTIPOINT ((-87.63918 41.86847)) 3 23 41.877590 ... new MULTIPOINT ((-87.65495 41.87783)) 4 27 41.737696 ... NaN MULTIPOINT ((-87.62715 41.73623)) [5 rows x 8 columns] >>> groceries_w_communities = groceries.sjoin(chicago) >>> groceries_w_communities[["OBJECTID", "community", "geometry"]].head() OBJECTID community geometry 0 16 UPTOWN MULTIPOINT ((-87.65661 41.97321)) 1 18 MORGAN PARK MULTIPOINT ((-87.68136 41.69713)) 2 22 NEAR WEST SIDE MULTIPOINT ((-87.63918 41.86847)) 3 23 NEAR WEST SIDE MULTIPOINT ((-87.65495 41.87783)) 4 27 CHATHAM MULTIPOINT ((-87.62715 41.73623)) Notes ----- Every operation in GeoPandas is planar, i.e. the potential third dimension is not taken into account. See Also -------- GeoDataFrame.sjoin_nearest : nearest neighbor join sjoin : equivalent top-level function )left_dfright_dfhow predicatelsuffixrsuffixrp)rsjoin)rPrrrrrrRs r,rGeoDataFrame.sjoin s7x     r.c 8[R"UUUUUUUUS9$)a Spatial join of two GeoDataFrames based on the distance between their geometries. Results will include multiple output records for a single input record where there are multiple equidistant nearest or intersected neighbors. See the User Guide page https://geopandas.readthedocs.io/en/latest/docs/user_guide/mergingdata.html for more details. Parameters ---------- right : GeoDataFrame how : string, default 'inner' The type of join: * 'left': use keys from left_df; retain only left_df geometry column * 'right': use keys from right_df; retain only right_df geometry column * 'inner': use intersection of keys from both dfs; retain only left_df geometry column max_distance : float, default None Maximum distance within which to query for nearest geometry. Must be greater than 0. The max_distance used to search for nearest items in the tree may have a significant impact on performance by reducing the number of input geometries that are evaluated for nearest items in the tree. lsuffix : string, default 'left' Suffix to apply to overlapping column names (left GeoDataFrame). rsuffix : string, default 'right' Suffix to apply to overlapping column names (right GeoDataFrame). distance_col : string, default None If set, save the distances computed between matching geometries under a column of this name in the joined GeoDataFrame. exclusive : bool, optional, default False If True, the nearest geometries that are equal to the input geometry will not be returned, default False. Examples -------- >>> import geodatasets >>> groceries = geopandas.read_file( ... geodatasets.get_path("geoda.groceries") ... ) >>> chicago = geopandas.read_file( ... geodatasets.get_path("geoda.chicago_health") ... ).to_crs(groceries.crs) >>> chicago.head() # doctest: +SKIP ComAreaID ... geometry 0 35 ... POLYGON ((-87.60914 41.84469, -87.60915 41.844... 1 36 ... POLYGON ((-87.59215 41.81693, -87.59231 41.816... 2 37 ... POLYGON ((-87.62880 41.80189, -87.62879 41.801... 3 38 ... POLYGON ((-87.60671 41.81681, -87.60670 41.816... 4 39 ... POLYGON ((-87.59215 41.81693, -87.59215 41.816... [5 rows x 87 columns] >>> groceries.head() # doctest: +SKIP OBJECTID Ycoord ... Category geometry 0 16 41.973266 ... NaN MULTIPOINT ((-87.65661 41.97321)) 1 18 41.696367 ... NaN MULTIPOINT ((-87.68136 41.69713)) 2 22 41.868634 ... NaN MULTIPOINT ((-87.63918 41.86847)) 3 23 41.877590 ... new MULTIPOINT ((-87.65495 41.87783)) 4 27 41.737696 ... NaN MULTIPOINT ((-87.62715 41.73623)) [5 rows x 8 columns] >>> groceries_w_communities = groceries.sjoin_nearest(chicago) >>> groceries_w_communities[["Chain", "community", "geometry"]].head(2) Chain community geometry 0 VIET HOA PLAZA UPTOWN MULTIPOINT ((1168268.672 1933554.35)) 1 COUNTY FAIR FOODS MORGAN PARK MULTIPOINT ((1162302.618 1832900.224)) To include the distances: >>> groceries_w_communities = groceries.sjoin_nearest(chicago, distance_col="distances") >>> groceries_w_communities[["Chain", "community", "distances"]].head(2) Chain community distances 0 VIET HOA PLAZA UPTOWN 0.0 1 COUNTY FAIR FOODS MORGAN PARK 0.0 In the following example, we get multiple groceries for Uptown because all results are equidistant (in this case zero because they intersect). In fact, we get 4 results in total: >>> chicago_w_groceries = groceries.sjoin_nearest(chicago, distance_col="distances", how="right") >>> uptown_results = chicago_w_groceries[chicago_w_groceries["community"] == "UPTOWN"] >>> uptown_results[["Chain", "community"]] Chain community 30 VIET HOA PLAZA UPTOWN 30 JEWEL OSCO UPTOWN 30 TARGET UPTOWN 30 Mariano's UPTOWN See Also -------- GeoDataFrame.sjoin : binary predicate joins sjoin_nearest : equivalent top-level function Notes ----- Since this join relies on distances, results will be inaccurate if your geometries are in a geographic CRS. Every operation in GeoPandas is planar, i.e. the potential third dimension is not taken into account. )r max_distancerr distance_col exclusive)r sjoin_nearest)rPrightrrrrrrs r,rGeoDataFrame.sjoin_nearest s0v&&  %%  r.c,[R"XX#S9$)aClip points, lines, or polygon geometries to the mask extent. Both layers must be in the same Coordinate Reference System (CRS). The GeoDataFrame will be clipped to the full extent of the ``mask`` object. If there are multiple polygons in mask, data from the GeoDataFrame will be clipped to the total boundary of all polygons in mask. Parameters ---------- mask : GeoDataFrame, GeoSeries, (Multi)Polygon, list-like Polygon vector layer used to clip the GeoDataFrame. The mask's geometry is dissolved into one geometric feature and intersected with GeoDataFrame. If the mask is list-like with four elements ``(minx, miny, maxx, maxy)``, ``clip`` will use a faster rectangle clipping (:meth:`~GeoSeries.clip_by_rect`), possibly leading to slightly different results. keep_geom_type : boolean, default False If True, return only geometries of original type in case of intersection resulting in multiple geometry types or GeometryCollections. If False, return all resulting geometries (potentially mixed types). sort : boolean, default False If True, the order of rows in the clipped GeoDataFrame will be preserved at small performance cost. If False the order of rows in the clipped GeoDataFrame will be random. Returns ------- GeoDataFrame Vector data (points, lines, polygons) from the GeoDataFrame clipped to polygon boundary from mask. See Also -------- clip : equivalent top-level function Examples -------- Clip points (grocery stores) with polygons (the Near West Side community): >>> import geodatasets >>> chicago = geopandas.read_file( ... geodatasets.get_path("geoda.chicago_health") ... ) >>> near_west_side = chicago[chicago["community"] == "NEAR WEST SIDE"] >>> groceries = geopandas.read_file( ... geodatasets.get_path("geoda.groceries") ... ).to_crs(chicago.crs) >>> groceries.shape (148, 8) >>> nws_groceries = groceries.clip(near_west_side) >>> nws_groceries.shape (7, 8) )maskkeep_geom_typer)rclip)rPrrrs r,rGeoDataFrame.clip sv~~dnXXr.c.[R"XX#US9$)aPerform spatial overlay between GeoDataFrames. Currently only supports data GeoDataFrames with uniform geometry types, i.e. containing only (Multi)Polygons, or only (Multi)Points, or a combination of (Multi)LineString and LinearRing shapes. Implements several methods that are all effectively subsets of the union. See the User Guide page :doc:`../../user_guide/set_operations` for details. Parameters ---------- right : GeoDataFrame how : string Method of spatial overlay: 'intersection', 'union', 'identity', 'symmetric_difference' or 'difference'. keep_geom_type : bool If True, return only geometries of the same geometry type the GeoDataFrame has, if False, return all resulting geometries. Default is None, which will set keep_geom_type to True but warn upon dropping geometries. make_valid : bool, default True If True, any invalid input geometries are corrected with a call to make_valid(), if False, a `ValueError` is raised if any input geometries are invalid. Returns ------- df : GeoDataFrame GeoDataFrame with new set of polygons and attributes resulting from the overlay Examples -------- >>> from shapely.geometry import Polygon >>> polys1 = geopandas.GeoSeries([Polygon([(0,0), (2,0), (2,2), (0,2)]), ... Polygon([(2,2), (4,2), (4,4), (2,4)])]) >>> polys2 = geopandas.GeoSeries([Polygon([(1,1), (3,1), (3,3), (1,3)]), ... Polygon([(3,3), (5,3), (5,5), (3,5)])]) >>> df1 = geopandas.GeoDataFrame({'geometry': polys1, 'df1_data':[1,2]}) >>> df2 = geopandas.GeoDataFrame({'geometry': polys2, 'df2_data':[1,2]}) >>> df1.overlay(df2, how='union') df1_data df2_data geometry 0 1.0 1.0 POLYGON ((2 2, 2 1, 1 1, 1 2, 2 2)) 1 2.0 1.0 POLYGON ((2 2, 2 3, 3 3, 3 2, 2 2)) 2 2.0 2.0 POLYGON ((4 4, 4 3, 3 3, 3 4, 4 4)) 3 1.0 NaN POLYGON ((2 0, 0 0, 0 2, 1 2, 1 1, 2 1, 2 0)) 4 2.0 NaN MULTIPOLYGON (((3 4, 3 3, 2 3, 2 4, 3 4)), ((4... 5 NaN 1.0 MULTIPOLYGON (((2 3, 2 2, 1 2, 1 3, 2 3)), ((3... 6 NaN 2.0 POLYGON ((3 5, 5 5, 5 3, 4 3, 4 4, 3 4, 3 5)) >>> df1.overlay(df2, how='intersection') df1_data df2_data geometry 0 1 1 POLYGON ((2 2, 2 1, 1 1, 1 2, 2 2)) 1 2 1 POLYGON ((2 2, 2 3, 3 3, 3 2, 2 2)) 2 2 2 POLYGON ((4 4, 4 3, 3 3, 3 4, 4 4)) >>> df1.overlay(df2, how='symmetric_difference') df1_data df2_data geometry 0 1.0 NaN POLYGON ((2 0, 0 0, 0 2, 1 2, 1 1, 2 1, 2 0)) 1 2.0 NaN MULTIPOLYGON (((3 4, 3 3, 2 3, 2 4, 3 4)), ((4... 2 NaN 1.0 MULTIPOLYGON (((2 3, 2 2, 1 2, 1 3, 2 3)), ((3... 3 NaN 2.0 POLYGON ((3 5, 5 5, 5 3, 4 3, 4 4, 3 4, 3 5)) >>> df1.overlay(df2, how='difference') geometry df1_data 0 POLYGON ((2 0, 0 0, 0 2, 1 2, 1 1, 2 1, 2 0)) 1 1 MULTIPOLYGON (((3 4, 3 3, 2 3, 2 4, 3 4)), ((4... 2 >>> df1.overlay(df2, how='identity') df1_data df2_data geometry 0 1 1.0 POLYGON ((2 2, 2 1, 1 1, 1 2, 2 2)) 1 2 1.0 POLYGON ((2 2, 2 3, 3 3, 3 2, 2 2)) 2 2 2.0 POLYGON ((4 4, 4 3, 3 3, 3 4, 4 4)) 3 1 NaN POLYGON ((2 0, 0 0, 0 2, 1 2, 1 1, 2 1, 2 0)) 4 2 NaN MULTIPOLYGON (((3 4, 3 3, 2 3, 2 4, 3 4)), ((4... See Also -------- GeoDataFrame.sjoin : spatial join overlay : equivalent top-level function Notes ----- Every operation in GeoPandas is planar, i.e. the potential third dimension is not taken into account. )rr make_valid)roverlay)rPrrrrs r,rGeoDataFrame.overlay s@  SJ  r.)rr2r"ro)r3 Any | Noner"r)returnr)...)rr bool | Noner< Literal[True]r"rrNonerrrr<Literal[False]r"rrr0NFN)rrrr<boolr"rrGeoDataFrame | None).)rir7r<rrr)rir7r<rrr0)F)rir7r<rrr)rr)rr)rr)NN)r*rr"rrr0)ros.PathLike | typing.IOrr0)r"rr6zIterable[str] | Nonerr0)rNNTNNN)rzstr | sqlalchemy.textrr7r"rrzstr | list[str] | Nonerrrzlist | dict | Nonerzlist | tuple | dict | Noner int | Nonerr0)r3 str | Noner dict | None)rFFF) rzLiteral['null', 'drop', 'keep']rrrrrrrr7)rr)rFF)rr7rrrrrztyping.Generator[dict])rrrrrrrr)rrr pd.DataFrame)rr)r#rrrrrrr)NsnappyrFN)r&rr#rr"r7rrr$rr#!SUPPORTED_VERSIONS_LITERAL | Nonerr)NNN)r&z os.PathLiker#rr"rr#r)rrr0rr1rr#r)....) r"rrrr<rr6rrr) r"rrrr<rr6rrr0)NNFF) r"rrrr<rr6rrr)r"rrrr<rrr0)r"rrrr<rrr)NNF)r"rrrr<rrr)zWGS 84)rAr7rr)T)ryrrr0)rFNrp)r]r)rzpd.DataFrame | GeoDataFrame)rzDataFrame | GeoDataFrame)rzSeries | GeoSeries)rrrzGeoDataFrame | GeoSeries) NfirstTNTFTunaryN)rrrrrrrrrrrz/Literal['unary', 'coverage', 'disjoint_subset']r float | Nonerr0)NFF)rrrrrrrzGeoDataFrame | DataFrame)NfailFNNN)r$r7r1rrz$Literal['fail', 'replace', 'append']r#rrzIterable[str] | str | Nonerrrr)rz folium.Map)inner intersectsrr) rr0r!Literal['left', 'right', 'inner']rr7rr7rr7rr0)rNrrNF)rr0rrrrrr7rr7rrrrrr0)FF)rrrrrr0) intersectionNT)rr0rzRLiteral['intersection', 'union', 'identity', 'symmetric_difference', 'difference']rrrr)I__name__ __module__ __qualname____firstlineno____doc__rr_internal_namesset_internal_names_setr2rBrWrarjpropertyr3typingoverloadrOrrr"setterr classmethodrrrrrrrrrrrrr'r+r2r7rrBrHrhrWrr?r&r_rgrjrxrrrrrrrrplottingGeoplotAccessorrrrrrrr__static_attributes__ __classcell__)rTs@r,r0r0Ssf 9v))I//:,>Oo. d $ d d  ddL+0>-  4TH __ !$       __ "%      ! \\ \  \  \| __"%     __#&     '4R**.''R ZZ6< :: :  ::<0@0@dOSV3&V38LV3 V3V3p ,0!*.-1 $P "P P  P * PP(P+PP PPdQU+ (+ CN+ + ^/5 b) +b)b) b)  b) b)HJJBJOjj+/jBFj jZQV88268IM8 8t42"8= !% [![!6 [!  [!  [!@"#8=$)<@S %S S  S 6 S " S :S  S p""&<@ 5 5 5  5 : 5 t""! fB)fBfB fB  fBP __!$"        __"%"       $ W WW W  W  Wr __"%      __!$      X XX X  Xt$EL>4&(B    % %%N $ << 004++/$'$ !$$PBI"&[ [ [  [[[@[ [ [@""! kkk k " kkb":@26 $A A  A 8 A  A 0A A  A F FI..>> ?D]// 29% d d /d  d  d  d  d R29%)#'D D /D # D  D  D !D D  D N@E;Y$(;Y8<;Y ;YD &*b b  b $ b b b r.r0c^U(a [S5e[U5nURXSUS9$)NzGCan't do inplace setting when converting from DataFrame to GeoDataFrameF)rrr<r")rCr0rO)rPrirrr<r"gfs r,_dataframe_set_geometryr 2 s8 U   d B ??35c? BBr.ro)r"rrzGeoSeries | GeometryArrayrr); __future__rrrrrrnumpyr(pandasr?rrshapely.errorsr`shapely.geometryrr shapely.geometry.baser rgeopandas.arrayr r r rrgeopandas.baserrgeopandas.explorergeopandas.geoseriesr_compatrr _decoratorrpandas.core.accessorrr TYPE_CHECKINGoscollections.abcrfoliumsqlalchemy.text sqlalchemyrrr%rrr-rDr0r rOrpr.r,rs" $+.VV:&)--?  ( <;\+ =)\+ DW# C  C C  C  C 1 r.