1475 lines
52 KiB
Python
1475 lines
52 KiB
Python
import json
|
|
import os
|
|
import shutil
|
|
import tempfile
|
|
|
|
import numpy as np
|
|
import pandas as pd
|
|
|
|
from pyproj import CRS
|
|
from pyproj.exceptions import CRSError
|
|
from shapely.geometry import Point, Polygon
|
|
|
|
import geopandas
|
|
import geopandas._compat as compat
|
|
from geopandas import GeoDataFrame, GeoSeries, points_from_xy, read_file
|
|
from geopandas.array import GeometryArray, GeometryDtype, from_shapely
|
|
from geopandas._compat import ignore_shapely2_warnings
|
|
|
|
from geopandas.testing import assert_geodataframe_equal, assert_geoseries_equal
|
|
from geopandas.tests.util import PACKAGE_DIR, validate_boro_df
|
|
from pandas.testing import assert_frame_equal, assert_index_equal, assert_series_equal
|
|
import pytest
|
|
|
|
|
|
TEST_NEAREST = compat.USE_SHAPELY_20 or (compat.PYGEOS_GE_010 and compat.USE_PYGEOS)
|
|
|
|
|
|
@pytest.fixture
|
|
def dfs(request):
|
|
s1 = GeoSeries(
|
|
[
|
|
Polygon([(0, 0), (2, 0), (2, 2), (0, 2)]),
|
|
Polygon([(2, 2), (4, 2), (4, 4), (2, 4)]),
|
|
]
|
|
)
|
|
s2 = GeoSeries(
|
|
[
|
|
Polygon([(1, 1), (3, 1), (3, 3), (1, 3)]),
|
|
Polygon([(3, 3), (5, 3), (5, 5), (3, 5)]),
|
|
]
|
|
)
|
|
df1 = GeoDataFrame({"col1": [1, 2], "geometry": s1})
|
|
df2 = GeoDataFrame({"col2": [1, 2], "geometry": s2})
|
|
return df1, df2
|
|
|
|
|
|
@pytest.fixture(
|
|
params=["union", "intersection", "difference", "symmetric_difference", "identity"]
|
|
)
|
|
def how(request):
|
|
return request.param
|
|
|
|
|
|
class TestDataFrame:
|
|
def setup_method(self):
|
|
N = 10
|
|
|
|
nybb_filename = geopandas.datasets.get_path("nybb")
|
|
self.df = read_file(nybb_filename)
|
|
self.tempdir = tempfile.mkdtemp()
|
|
self.crs = "epsg:4326"
|
|
self.df2 = GeoDataFrame(
|
|
[
|
|
{"geometry": Point(x, y), "value1": x + y, "value2": x * y}
|
|
for x, y in zip(range(N), range(N))
|
|
],
|
|
crs=self.crs,
|
|
)
|
|
self.df3 = read_file(
|
|
os.path.join(PACKAGE_DIR, "geopandas", "tests", "data", "null_geom.geojson")
|
|
)
|
|
|
|
def teardown_method(self):
|
|
shutil.rmtree(self.tempdir)
|
|
|
|
def test_df_init(self):
|
|
assert type(self.df2) is GeoDataFrame
|
|
assert self.df2.crs == self.crs
|
|
|
|
def test_different_geo_colname(self):
|
|
data = {
|
|
"A": range(5),
|
|
"B": range(-5, 0),
|
|
"location": [Point(x, y) for x, y in zip(range(5), range(5))],
|
|
}
|
|
df = GeoDataFrame(data, crs=self.crs, geometry="location")
|
|
locs = GeoSeries(data["location"], crs=self.crs)
|
|
assert_geoseries_equal(df.geometry, locs)
|
|
assert "geometry" not in df
|
|
assert df.geometry.name == "location"
|
|
# internal implementation detail
|
|
assert df._geometry_column_name == "location"
|
|
|
|
geom2 = [Point(x, y) for x, y in zip(range(5, 10), range(5))]
|
|
with pytest.raises(CRSError):
|
|
df.set_geometry(geom2, crs="dummy_crs")
|
|
|
|
@pytest.mark.filterwarnings("ignore:Geometry is in a geographic CRS")
|
|
def test_geo_getitem(self):
|
|
data = {
|
|
"A": range(5),
|
|
"B": range(-5, 0),
|
|
"location": [Point(x, y) for x, y in zip(range(5), range(5))],
|
|
}
|
|
df = GeoDataFrame(data, crs=self.crs, geometry="location")
|
|
assert isinstance(df.geometry, GeoSeries)
|
|
df["geometry"] = df["A"]
|
|
assert isinstance(df.geometry, GeoSeries)
|
|
assert df.geometry[0] == data["location"][0]
|
|
# good if this changed in the future
|
|
assert not isinstance(df["geometry"], GeoSeries)
|
|
assert isinstance(df["location"], GeoSeries)
|
|
|
|
df["buff"] = df.buffer(1)
|
|
assert isinstance(df["buff"], GeoSeries)
|
|
|
|
df["array"] = from_shapely([Point(x, y) for x, y in zip(range(5), range(5))])
|
|
assert isinstance(df["array"], GeoSeries)
|
|
|
|
data["geometry"] = [Point(x + 1, y - 1) for x, y in zip(range(5), range(5))]
|
|
df = GeoDataFrame(data, crs=self.crs)
|
|
assert isinstance(df.geometry, GeoSeries)
|
|
assert isinstance(df["geometry"], GeoSeries)
|
|
# good if this changed in the future
|
|
assert not isinstance(df["location"], GeoSeries)
|
|
|
|
def test_getitem_no_geometry(self):
|
|
res = self.df2[["value1", "value2"]]
|
|
assert isinstance(res, pd.DataFrame)
|
|
assert not isinstance(res, GeoDataFrame)
|
|
|
|
# with different name
|
|
df = self.df2.copy()
|
|
df = df.rename(columns={"geometry": "geom"}).set_geometry("geom")
|
|
assert isinstance(df, GeoDataFrame)
|
|
res = df[["value1", "value2"]]
|
|
assert isinstance(res, pd.DataFrame)
|
|
assert not isinstance(res, GeoDataFrame)
|
|
|
|
df["geometry"] = np.arange(len(df))
|
|
res = df[["value1", "value2", "geometry"]]
|
|
assert isinstance(res, pd.DataFrame)
|
|
assert not isinstance(res, GeoDataFrame)
|
|
|
|
def test_geo_setitem(self):
|
|
data = {
|
|
"A": range(5),
|
|
"B": np.arange(5.0),
|
|
"geometry": [Point(x, y) for x, y in zip(range(5), range(5))],
|
|
}
|
|
df = GeoDataFrame(data)
|
|
s = GeoSeries([Point(x, y + 1) for x, y in zip(range(5), range(5))])
|
|
|
|
# setting geometry column
|
|
for vals in [s, s.values]:
|
|
df["geometry"] = vals
|
|
assert_geoseries_equal(df["geometry"], s)
|
|
assert_geoseries_equal(df.geometry, s)
|
|
|
|
# non-aligned values
|
|
s2 = GeoSeries([Point(x, y + 1) for x, y in zip(range(6), range(6))])
|
|
df["geometry"] = s2
|
|
assert_geoseries_equal(df["geometry"], s)
|
|
assert_geoseries_equal(df.geometry, s)
|
|
|
|
# setting other column with geometry values -> preserve geometry type
|
|
for vals in [s, s.values]:
|
|
df["other_geom"] = vals
|
|
assert isinstance(df["other_geom"].values, GeometryArray)
|
|
|
|
# overwriting existing non-geometry column -> preserve geometry type
|
|
data = {
|
|
"A": range(5),
|
|
"B": np.arange(5.0),
|
|
"other_geom": range(5),
|
|
"geometry": [Point(x, y) for x, y in zip(range(5), range(5))],
|
|
}
|
|
df = GeoDataFrame(data)
|
|
for vals in [s, s.values]:
|
|
df["other_geom"] = vals
|
|
assert isinstance(df["other_geom"].values, GeometryArray)
|
|
|
|
def test_geometry_property(self):
|
|
assert_geoseries_equal(
|
|
self.df.geometry,
|
|
self.df["geometry"],
|
|
check_dtype=True,
|
|
check_index_type=True,
|
|
)
|
|
|
|
df = self.df.copy()
|
|
new_geom = [
|
|
Point(x, y) for x, y in zip(range(len(self.df)), range(len(self.df)))
|
|
]
|
|
df.geometry = new_geom
|
|
|
|
new_geom = GeoSeries(new_geom, index=df.index, crs=df.crs)
|
|
assert_geoseries_equal(df.geometry, new_geom)
|
|
assert_geoseries_equal(df["geometry"], new_geom)
|
|
|
|
# new crs
|
|
gs = new_geom.to_crs(crs="epsg:3857")
|
|
df.geometry = gs
|
|
assert df.crs == "epsg:3857"
|
|
|
|
def test_geometry_property_errors(self):
|
|
with pytest.raises(AttributeError):
|
|
df = self.df.copy()
|
|
del df["geometry"]
|
|
df.geometry
|
|
|
|
# list-like error
|
|
with pytest.raises(ValueError):
|
|
df = self.df2.copy()
|
|
df.geometry = "value1"
|
|
|
|
# list-like error
|
|
with pytest.raises(ValueError):
|
|
df = self.df.copy()
|
|
df.geometry = "apple"
|
|
|
|
# non-geometry error
|
|
with pytest.raises(TypeError):
|
|
df = self.df.copy()
|
|
df.geometry = list(range(df.shape[0]))
|
|
|
|
with pytest.raises(KeyError):
|
|
df = self.df.copy()
|
|
del df["geometry"]
|
|
df["geometry"]
|
|
|
|
# ndim error
|
|
with pytest.raises(ValueError):
|
|
df = self.df.copy()
|
|
df.geometry = df
|
|
|
|
def test_rename_geometry(self):
|
|
assert self.df.geometry.name == "geometry"
|
|
df2 = self.df.rename_geometry("new_name")
|
|
assert df2.geometry.name == "new_name"
|
|
df2 = self.df.rename_geometry("new_name", inplace=True)
|
|
assert df2 is None
|
|
assert self.df.geometry.name == "new_name"
|
|
|
|
# existing column error
|
|
msg = "Column named Shape_Area already exists"
|
|
with pytest.raises(ValueError, match=msg):
|
|
df2 = self.df.rename_geometry("Shape_Area")
|
|
with pytest.raises(ValueError, match=msg):
|
|
self.df.rename_geometry("Shape_Area", inplace=True)
|
|
|
|
def test_set_geometry(self):
|
|
geom = GeoSeries([Point(x, y) for x, y in zip(range(5), range(5))])
|
|
original_geom = self.df.geometry
|
|
|
|
df2 = self.df.set_geometry(geom)
|
|
assert self.df is not df2
|
|
assert_geoseries_equal(df2.geometry, geom, check_crs=False)
|
|
assert_geoseries_equal(self.df.geometry, original_geom)
|
|
assert_geoseries_equal(self.df["geometry"], self.df.geometry)
|
|
# unknown column
|
|
with pytest.raises(ValueError):
|
|
self.df.set_geometry("nonexistent-column")
|
|
|
|
# ndim error
|
|
with pytest.raises(ValueError):
|
|
self.df.set_geometry(self.df)
|
|
|
|
# new crs - setting should default to GeoSeries' crs
|
|
gs = GeoSeries(geom, crs="epsg:3857")
|
|
new_df = self.df.set_geometry(gs)
|
|
assert new_df.crs == "epsg:3857"
|
|
|
|
# explicit crs overrides self and dataframe
|
|
new_df = self.df.set_geometry(gs, crs="epsg:26909")
|
|
assert new_df.crs == "epsg:26909"
|
|
assert new_df.geometry.crs == "epsg:26909"
|
|
|
|
# Series should use dataframe's
|
|
new_df = self.df.set_geometry(geom.values)
|
|
assert new_df.crs == self.df.crs
|
|
assert new_df.geometry.crs == self.df.crs
|
|
|
|
def test_set_geometry_col(self):
|
|
g = self.df.geometry
|
|
g_simplified = g.simplify(100)
|
|
self.df["simplified_geometry"] = g_simplified
|
|
df2 = self.df.set_geometry("simplified_geometry")
|
|
|
|
# Drop is false by default
|
|
assert "simplified_geometry" in df2
|
|
assert_geoseries_equal(df2.geometry, g_simplified)
|
|
|
|
# If True, drops column and renames to geometry
|
|
df3 = self.df.set_geometry("simplified_geometry", drop=True)
|
|
assert "simplified_geometry" not in df3
|
|
assert_geoseries_equal(df3.geometry, g_simplified)
|
|
|
|
def test_set_geometry_inplace(self):
|
|
geom = [Point(x, y) for x, y in zip(range(5), range(5))]
|
|
ret = self.df.set_geometry(geom, inplace=True)
|
|
assert ret is None
|
|
geom = GeoSeries(geom, index=self.df.index, crs=self.df.crs)
|
|
assert_geoseries_equal(self.df.geometry, geom)
|
|
|
|
def test_set_geometry_series(self):
|
|
# Test when setting geometry with a Series that
|
|
# alignment will occur
|
|
#
|
|
# Reverse the index order
|
|
# Set the Series to be Point(i,i) where i is the index
|
|
self.df.index = range(len(self.df) - 1, -1, -1)
|
|
|
|
d = {}
|
|
for i in range(len(self.df)):
|
|
d[i] = Point(i, i)
|
|
g = GeoSeries(d)
|
|
# At this point, the DataFrame index is [4,3,2,1,0] and the
|
|
# GeoSeries index is [0,1,2,3,4]. Make sure set_geometry aligns
|
|
# them to match indexes
|
|
df = self.df.set_geometry(g)
|
|
|
|
for i, r in df.iterrows():
|
|
assert i == r["geometry"].x
|
|
assert i == r["geometry"].y
|
|
|
|
def test_set_geometry_empty(self):
|
|
df = pd.DataFrame(columns=["a", "geometry"], index=pd.DatetimeIndex([]))
|
|
result = df.set_geometry("geometry")
|
|
assert isinstance(result, GeoDataFrame)
|
|
assert isinstance(result.index, pd.DatetimeIndex)
|
|
|
|
def test_set_geometry_np_int(self):
|
|
self.df.loc[:, 0] = self.df.geometry
|
|
df = self.df.set_geometry(np.int64(0))
|
|
assert df.geometry.name == 0
|
|
|
|
def test_get_geometry_invalid(self):
|
|
df = GeoDataFrame()
|
|
# no column "geometry" ever added
|
|
df["geom"] = self.df.geometry
|
|
msg_geo_col_none = "active geometry column to use has not been set. "
|
|
|
|
with pytest.raises(AttributeError, match=msg_geo_col_none):
|
|
df.geometry
|
|
# "geometry" originally present but dropped (but still a gdf)
|
|
col_subset_drop_geometry = ["BoroCode", "BoroName", "geom2"]
|
|
df2 = self.df.copy().assign(geom2=self.df.geometry)[col_subset_drop_geometry]
|
|
with pytest.raises(AttributeError, match="is not present."):
|
|
df2.geometry
|
|
|
|
msg_other_geo_cols_present = "There are columns with geometry data type"
|
|
msg_no_other_geo_cols = "There are no existing columns with geometry data type"
|
|
with pytest.raises(AttributeError, match=msg_other_geo_cols_present):
|
|
df2.geometry
|
|
|
|
with pytest.raises(AttributeError, match=msg_no_other_geo_cols):
|
|
GeoDataFrame().geometry
|
|
|
|
def test_get_geometry_geometry_inactive(self):
|
|
# https://github.com/geopandas/geopandas/issues/2574
|
|
df = self.df.assign(geom2=self.df.geometry).set_geometry("geom2")
|
|
df = df.loc[:, ["BoroName", "geometry"]]
|
|
assert df._geometry_column_name == "geom2"
|
|
msg_geo_col_missing = "is not present. "
|
|
# Check that df.geometry raises if active geometry column is missing,
|
|
# it should not fall back to column named "geometry"
|
|
with pytest.raises(AttributeError, match=msg_geo_col_missing):
|
|
df.geometry
|
|
|
|
def test_align(self):
|
|
df = self.df2
|
|
|
|
res1, res2 = df.align(df)
|
|
assert_geodataframe_equal(res1, df)
|
|
assert_geodataframe_equal(res2, df)
|
|
|
|
res1, res2 = df.align(df.copy())
|
|
assert_geodataframe_equal(res1, df)
|
|
assert_geodataframe_equal(res2, df)
|
|
|
|
# assert crs is / is not preserved on mixed dataframes
|
|
df_nocrs = df.copy()
|
|
df_nocrs.crs = None
|
|
res1, res2 = df.align(df_nocrs)
|
|
assert_geodataframe_equal(res1, df)
|
|
assert res1.crs is not None
|
|
assert_geodataframe_equal(res2, df_nocrs)
|
|
assert res2.crs is None
|
|
|
|
# mixed GeoDataFrame / DataFrame
|
|
df_nogeom = pd.DataFrame(df.drop("geometry", axis=1))
|
|
res1, res2 = df.align(df_nogeom, axis=0)
|
|
assert_geodataframe_equal(res1, df)
|
|
assert type(res2) == pd.DataFrame
|
|
assert_frame_equal(res2, df_nogeom)
|
|
|
|
# same as above but now with actual alignment
|
|
df1 = df.iloc[1:].copy()
|
|
df2 = df.iloc[:-1].copy()
|
|
|
|
exp1 = df.copy()
|
|
exp1.iloc[0] = np.nan
|
|
exp2 = df.copy()
|
|
exp2.iloc[-1] = np.nan
|
|
res1, res2 = df1.align(df2)
|
|
assert_geodataframe_equal(res1, exp1)
|
|
assert_geodataframe_equal(res2, exp2)
|
|
|
|
df2_nocrs = df2.copy()
|
|
df2_nocrs.crs = None
|
|
exp2_nocrs = exp2.copy()
|
|
exp2_nocrs.crs = None
|
|
res1, res2 = df1.align(df2_nocrs)
|
|
assert_geodataframe_equal(res1, exp1)
|
|
assert res1.crs is not None
|
|
assert_geodataframe_equal(res2, exp2_nocrs)
|
|
assert res2.crs is None
|
|
|
|
df2_nogeom = pd.DataFrame(df2.drop("geometry", axis=1))
|
|
exp2_nogeom = pd.DataFrame(exp2.drop("geometry", axis=1))
|
|
res1, res2 = df1.align(df2_nogeom, axis=0)
|
|
assert_geodataframe_equal(res1, exp1)
|
|
assert type(res2) == pd.DataFrame
|
|
assert_frame_equal(res2, exp2_nogeom)
|
|
|
|
def test_to_json(self):
|
|
text = self.df.to_json(to_wgs84=True)
|
|
data = json.loads(text)
|
|
assert data["type"] == "FeatureCollection"
|
|
assert len(data["features"]) == 5
|
|
assert "id" in data["features"][0].keys()
|
|
|
|
# check it converts to WGS84
|
|
coord = data["features"][0]["geometry"]["coordinates"][0][0][0]
|
|
np.testing.assert_allclose(coord, [-74.0505080640324, 40.5664220341941])
|
|
|
|
def test_to_json_wgs84_false(self):
|
|
text = self.df.to_json()
|
|
data = json.loads(text)
|
|
# check it doesn't convert to WGS84
|
|
coord = data["features"][0]["geometry"]["coordinates"][0][0][0]
|
|
assert coord == [970217.0223999023, 145643.33221435547]
|
|
|
|
def test_to_json_no_crs(self):
|
|
self.df.crs = None
|
|
with pytest.raises(ValueError, match="CRS is not set"):
|
|
self.df.to_json(to_wgs84=True)
|
|
|
|
@pytest.mark.filterwarnings(
|
|
"ignore:Geometry column does not contain geometry:UserWarning"
|
|
)
|
|
def test_to_json_geom_col(self):
|
|
df = self.df.copy()
|
|
df["geom"] = df["geometry"]
|
|
df["geometry"] = np.arange(len(df))
|
|
df.set_geometry("geom", inplace=True)
|
|
|
|
text = df.to_json()
|
|
data = json.loads(text)
|
|
assert data["type"] == "FeatureCollection"
|
|
assert len(data["features"]) == 5
|
|
|
|
def test_to_json_only_geom_column(self):
|
|
text = self.df[["geometry"]].to_json()
|
|
data = json.loads(text)
|
|
assert len(data["features"]) == 5
|
|
assert "id" in data["features"][0].keys()
|
|
|
|
def test_to_json_na(self):
|
|
# Set a value as nan and make sure it's written
|
|
self.df.loc[self.df["BoroName"] == "Queens", "Shape_Area"] = np.nan
|
|
|
|
text = self.df.to_json()
|
|
data = json.loads(text)
|
|
assert len(data["features"]) == 5
|
|
for f in data["features"]:
|
|
props = f["properties"]
|
|
assert len(props) == 4
|
|
if props["BoroName"] == "Queens":
|
|
assert props["Shape_Area"] is None
|
|
|
|
def test_to_json_bad_na(self):
|
|
# Check that a bad na argument raises error
|
|
with pytest.raises(ValueError):
|
|
self.df.to_json(na="garbage")
|
|
|
|
def test_to_json_dropna(self):
|
|
self.df.loc[self.df["BoroName"] == "Queens", "Shape_Area"] = np.nan
|
|
self.df.loc[self.df["BoroName"] == "Bronx", "Shape_Leng"] = np.nan
|
|
|
|
text = self.df.to_json(na="drop")
|
|
data = json.loads(text)
|
|
assert len(data["features"]) == 5
|
|
for f in data["features"]:
|
|
props = f["properties"]
|
|
if props["BoroName"] == "Queens":
|
|
assert len(props) == 3
|
|
assert "Shape_Area" not in props
|
|
# Just make sure setting it to nan in a different row
|
|
# doesn't affect this one
|
|
assert "Shape_Leng" in props
|
|
elif props["BoroName"] == "Bronx":
|
|
assert len(props) == 3
|
|
assert "Shape_Leng" not in props
|
|
assert "Shape_Area" in props
|
|
else:
|
|
assert len(props) == 4
|
|
|
|
def test_to_json_keepna(self):
|
|
self.df.loc[self.df["BoroName"] == "Queens", "Shape_Area"] = np.nan
|
|
self.df.loc[self.df["BoroName"] == "Bronx", "Shape_Leng"] = np.nan
|
|
|
|
text = self.df.to_json(na="keep")
|
|
data = json.loads(text)
|
|
assert len(data["features"]) == 5
|
|
for f in data["features"]:
|
|
props = f["properties"]
|
|
assert len(props) == 4
|
|
if props["BoroName"] == "Queens":
|
|
assert np.isnan(props["Shape_Area"])
|
|
# Just make sure setting it to nan in a different row
|
|
# doesn't affect this one
|
|
assert "Shape_Leng" in props
|
|
elif props["BoroName"] == "Bronx":
|
|
assert np.isnan(props["Shape_Leng"])
|
|
assert "Shape_Area" in props
|
|
|
|
def test_to_json_drop_id(self):
|
|
text = self.df.to_json(drop_id=True)
|
|
data = json.loads(text)
|
|
assert len(data["features"]) == 5
|
|
for f in data["features"]:
|
|
assert "id" not in f.keys()
|
|
|
|
def test_to_json_drop_id_only_geom_column(self):
|
|
text = self.df[["geometry"]].to_json(drop_id=True)
|
|
data = json.loads(text)
|
|
assert len(data["features"]) == 5
|
|
for f in data["features"]:
|
|
assert "id" not in f.keys()
|
|
|
|
def test_to_json_with_duplicate_columns(self):
|
|
df = GeoDataFrame(
|
|
data=[[1, 2, 3]], columns=["a", "b", "a"], geometry=[Point(1, 1)]
|
|
)
|
|
with pytest.raises(
|
|
ValueError, match="GeoDataFrame cannot contain duplicated column names."
|
|
):
|
|
df.to_json()
|
|
|
|
def test_copy(self):
|
|
df2 = self.df.copy()
|
|
assert type(df2) is GeoDataFrame
|
|
assert self.df.crs == df2.crs
|
|
|
|
def test_empty_copy(self):
|
|
# https://github.com/geopandas/geopandas/issues/2765
|
|
df = GeoDataFrame()
|
|
df2 = df.copy()
|
|
assert type(df2) is GeoDataFrame
|
|
df3 = df.copy(deep=True)
|
|
assert type(df3) is GeoDataFrame
|
|
|
|
def test_no_geom_copy(self):
|
|
df = GeoDataFrame(pd.DataFrame({"a": [1, 2, 3]}))
|
|
assert type(df) is GeoDataFrame
|
|
assert type(df.copy()) is GeoDataFrame
|
|
|
|
def test_bool_index(self):
|
|
# Find boros with 'B' in their name
|
|
df = self.df[self.df["BoroName"].str.contains("B")]
|
|
assert len(df) == 2
|
|
boros = df["BoroName"].values
|
|
assert "Brooklyn" in boros
|
|
assert "Bronx" in boros
|
|
assert type(df) is GeoDataFrame
|
|
|
|
def test_coord_slice_points(self):
|
|
assert self.df2.cx[-2:-1, -2:-1].empty
|
|
assert_frame_equal(self.df2, self.df2.cx[:, :])
|
|
assert_frame_equal(self.df2.loc[5:], self.df2.cx[5:, :])
|
|
assert_frame_equal(self.df2.loc[5:], self.df2.cx[:, 5:])
|
|
assert_frame_equal(self.df2.loc[5:], self.df2.cx[5:, 5:])
|
|
|
|
def test_from_dict(self):
|
|
data = {"A": [1], "geometry": [Point(0.0, 0.0)]}
|
|
df = GeoDataFrame.from_dict(data, crs=3857)
|
|
assert df.crs == "epsg:3857"
|
|
assert df._geometry_column_name == "geometry"
|
|
|
|
data = {"B": [1], "location": [Point(0.0, 0.0)]}
|
|
df = GeoDataFrame.from_dict(data, geometry="location")
|
|
assert df._geometry_column_name == "location"
|
|
|
|
def test_from_features(self):
|
|
fiona = pytest.importorskip("fiona")
|
|
nybb_filename = geopandas.datasets.get_path("nybb")
|
|
with fiona.open(nybb_filename) as f:
|
|
features = list(f)
|
|
crs = f.crs_wkt
|
|
|
|
df = GeoDataFrame.from_features(features, crs=crs)
|
|
validate_boro_df(df, case_sensitive=True)
|
|
assert df.crs == crs
|
|
|
|
def test_from_features_unaligned_properties(self):
|
|
p1 = Point(1, 1)
|
|
f1 = {
|
|
"type": "Feature",
|
|
"properties": {"a": 0},
|
|
"geometry": p1.__geo_interface__,
|
|
}
|
|
|
|
p2 = Point(2, 2)
|
|
f2 = {
|
|
"type": "Feature",
|
|
"properties": {"b": 1},
|
|
"geometry": p2.__geo_interface__,
|
|
}
|
|
|
|
p3 = Point(3, 3)
|
|
f3 = {
|
|
"type": "Feature",
|
|
"properties": None,
|
|
"geometry": p3.__geo_interface__,
|
|
}
|
|
|
|
df = GeoDataFrame.from_features([f1, f2, f3])
|
|
|
|
result = df[["a", "b"]]
|
|
expected = pd.DataFrame.from_dict(
|
|
[{"a": 0, "b": np.nan}, {"a": np.nan, "b": 1}, {"a": np.nan, "b": np.nan}]
|
|
)
|
|
assert_frame_equal(expected, result)
|
|
|
|
def test_from_features_empty_properties(self):
|
|
geojson_properties_object = """{
|
|
"type": "FeatureCollection",
|
|
"features": [
|
|
{
|
|
"type": "Feature",
|
|
"properties": {},
|
|
"geometry": {
|
|
"type": "Polygon",
|
|
"coordinates": [
|
|
[
|
|
[
|
|
11.3456529378891,
|
|
46.49461446367692
|
|
],
|
|
[
|
|
11.345674395561216,
|
|
46.494097442978195
|
|
],
|
|
[
|
|
11.346918940544128,
|
|
46.49385370294394
|
|
],
|
|
[
|
|
11.347616314888,
|
|
46.4938352377453
|
|
],
|
|
[
|
|
11.347514390945435,
|
|
46.49466985846028
|
|
],
|
|
[
|
|
11.3456529378891,
|
|
46.49461446367692
|
|
]
|
|
]
|
|
]
|
|
}
|
|
}
|
|
]
|
|
}"""
|
|
|
|
geojson_properties_null = """{
|
|
"type": "FeatureCollection",
|
|
"features": [
|
|
{
|
|
"type": "Feature",
|
|
"properties": null,
|
|
"geometry": {
|
|
"type": "Polygon",
|
|
"coordinates": [
|
|
[
|
|
[
|
|
11.3456529378891,
|
|
46.49461446367692
|
|
],
|
|
[
|
|
11.345674395561216,
|
|
46.494097442978195
|
|
],
|
|
[
|
|
11.346918940544128,
|
|
46.49385370294394
|
|
],
|
|
[
|
|
11.347616314888,
|
|
46.4938352377453
|
|
],
|
|
[
|
|
11.347514390945435,
|
|
46.49466985846028
|
|
],
|
|
[
|
|
11.3456529378891,
|
|
46.49461446367692
|
|
]
|
|
]
|
|
]
|
|
}
|
|
}
|
|
]
|
|
}"""
|
|
|
|
# geoJSON with empty properties
|
|
gjson_po = json.loads(geojson_properties_object)
|
|
gdf1 = GeoDataFrame.from_features(gjson_po)
|
|
|
|
# geoJSON with null properties
|
|
gjson_null = json.loads(geojson_properties_null)
|
|
gdf2 = GeoDataFrame.from_features(gjson_null)
|
|
|
|
assert_frame_equal(gdf1, gdf2)
|
|
|
|
def test_from_features_geom_interface_feature(self):
|
|
class Placemark(object):
|
|
def __init__(self, geom, val):
|
|
self.__geo_interface__ = {
|
|
"type": "Feature",
|
|
"properties": {"a": val},
|
|
"geometry": geom.__geo_interface__,
|
|
}
|
|
|
|
p1 = Point(1, 1)
|
|
f1 = Placemark(p1, 0)
|
|
p2 = Point(3, 3)
|
|
f2 = Placemark(p2, 0)
|
|
df = GeoDataFrame.from_features([f1, f2])
|
|
assert sorted(df.columns) == ["a", "geometry"]
|
|
assert df.geometry.tolist() == [p1, p2]
|
|
|
|
def test_from_feature_collection(self):
|
|
data = {
|
|
"name": ["a", "b", "c"],
|
|
"lat": [45, 46, 47.5],
|
|
"lon": [-120, -121.2, -122.9],
|
|
}
|
|
|
|
df = pd.DataFrame(data)
|
|
geometry = [Point(xy) for xy in zip(df["lon"], df["lat"])]
|
|
gdf = GeoDataFrame(df, geometry=geometry)
|
|
# from_features returns sorted columns
|
|
expected = gdf[["geometry", "name", "lat", "lon"]]
|
|
|
|
# test FeatureCollection
|
|
res = GeoDataFrame.from_features(gdf.__geo_interface__)
|
|
assert_frame_equal(res, expected)
|
|
|
|
# test list of Features
|
|
res = GeoDataFrame.from_features(gdf.__geo_interface__["features"])
|
|
assert_frame_equal(res, expected)
|
|
|
|
# test __geo_interface__ attribute (a GeoDataFrame has one)
|
|
res = GeoDataFrame.from_features(gdf)
|
|
assert_frame_equal(res, expected)
|
|
|
|
def test_dataframe_to_geodataframe(self):
|
|
df = pd.DataFrame(
|
|
{"A": range(len(self.df)), "location": np.array(self.df.geometry)},
|
|
index=self.df.index,
|
|
)
|
|
gf = df.set_geometry("location", crs=self.df.crs)
|
|
assert isinstance(df, pd.DataFrame)
|
|
assert isinstance(gf, GeoDataFrame)
|
|
assert_geoseries_equal(gf.geometry, self.df.geometry)
|
|
assert gf.geometry.name == "location"
|
|
assert "geometry" not in gf
|
|
|
|
gf2 = df.set_geometry("location", crs=self.df.crs, drop=True)
|
|
assert isinstance(df, pd.DataFrame)
|
|
assert isinstance(gf2, GeoDataFrame)
|
|
assert gf2.geometry.name == "geometry"
|
|
assert "geometry" in gf2
|
|
assert "location" not in gf2
|
|
assert "location" in df
|
|
|
|
# should be a copy
|
|
df.loc[0, "A"] = 100
|
|
assert gf.loc[0, "A"] == 0
|
|
assert gf2.loc[0, "A"] == 0
|
|
|
|
with pytest.raises(ValueError):
|
|
df.set_geometry("location", inplace=True)
|
|
|
|
def test_dataframe_not_manipulated(self):
|
|
df = pd.DataFrame(
|
|
{
|
|
"A": range(len(self.df)),
|
|
"latitude": self.df.geometry.centroid.y,
|
|
"longitude": self.df.geometry.centroid.x,
|
|
},
|
|
index=self.df.index,
|
|
)
|
|
df_copy = df.copy()
|
|
gf = GeoDataFrame(
|
|
df,
|
|
geometry=points_from_xy(df["longitude"], df["latitude"]),
|
|
crs=self.df.crs,
|
|
)
|
|
assert type(df) == pd.DataFrame
|
|
assert "geometry" not in df
|
|
assert_frame_equal(df, df_copy)
|
|
assert isinstance(gf, GeoDataFrame)
|
|
assert hasattr(gf, "geometry")
|
|
|
|
# ensure mutating columns in gf doesn't update df
|
|
gf.loc[0, "A"] = 7
|
|
assert_frame_equal(df, df_copy)
|
|
gf["A"] = 3
|
|
assert_frame_equal(df, df_copy)
|
|
|
|
def test_geodataframe_geointerface(self):
|
|
assert self.df.__geo_interface__["type"] == "FeatureCollection"
|
|
assert len(self.df.__geo_interface__["features"]) == self.df.shape[0]
|
|
|
|
def test_geodataframe_iterfeatures(self):
|
|
df = self.df.iloc[:1].copy()
|
|
df.loc[0, "BoroName"] = np.nan
|
|
# when containing missing values
|
|
# null: output the missing entries as JSON null
|
|
result = list(df.iterfeatures(na="null"))[0]["properties"]
|
|
assert result["BoroName"] is None
|
|
# drop: remove the property from the feature.
|
|
result = list(df.iterfeatures(na="drop"))[0]["properties"]
|
|
assert "BoroName" not in result.keys()
|
|
# keep: output the missing entries as NaN
|
|
result = list(df.iterfeatures(na="keep"))[0]["properties"]
|
|
assert np.isnan(result["BoroName"])
|
|
|
|
# test for checking that the (non-null) features are python scalars and
|
|
# not numpy scalars
|
|
assert type(df.loc[0, "Shape_Leng"]) is np.float64
|
|
# null
|
|
result = list(df.iterfeatures(na="null"))[0]
|
|
assert type(result["properties"]["Shape_Leng"]) is float
|
|
# drop
|
|
result = list(df.iterfeatures(na="drop"))[0]
|
|
assert type(result["properties"]["Shape_Leng"]) is float
|
|
# keep
|
|
result = list(df.iterfeatures(na="keep"))[0]
|
|
assert type(result["properties"]["Shape_Leng"]) is float
|
|
|
|
# when only having numerical columns
|
|
df_only_numerical_cols = df[["Shape_Leng", "Shape_Area", "geometry"]]
|
|
assert type(df_only_numerical_cols.loc[0, "Shape_Leng"]) is np.float64
|
|
# null
|
|
result = list(df_only_numerical_cols.iterfeatures(na="null"))[0]
|
|
assert type(result["properties"]["Shape_Leng"]) is float
|
|
# drop
|
|
result = list(df_only_numerical_cols.iterfeatures(na="drop"))[0]
|
|
assert type(result["properties"]["Shape_Leng"]) is float
|
|
# keep
|
|
result = list(df_only_numerical_cols.iterfeatures(na="keep"))[0]
|
|
assert type(result["properties"]["Shape_Leng"]) is float
|
|
|
|
with pytest.raises(
|
|
ValueError, match="GeoDataFrame cannot contain duplicated column names."
|
|
):
|
|
df_with_duplicate_columns = df[
|
|
["Shape_Leng", "Shape_Leng", "Shape_Area", "geometry"]
|
|
]
|
|
list(df_with_duplicate_columns.iterfeatures())
|
|
|
|
# geometry not set
|
|
df = GeoDataFrame({"values": [0, 1], "geom": [Point(0, 1), Point(1, 0)]})
|
|
with pytest.raises(AttributeError):
|
|
list(df.iterfeatures())
|
|
|
|
def test_geodataframe_iterfeatures_non_scalars(self):
|
|
# When some features in geodataframe are non-scalar values
|
|
df = GeoDataFrame(
|
|
{"geometry": [Point(1, 2)], "non-scalar": [[1, 2]], "test_col": None}
|
|
)
|
|
# null
|
|
expected = {"non-scalar": [1, 2], "test_col": None}
|
|
result = list(df.iterfeatures(na="null"))[0].get("properties")
|
|
assert expected == result
|
|
# drop
|
|
expected = {"non-scalar": [1, 2]}
|
|
result = list(df.iterfeatures(na="drop"))[0].get("properties")
|
|
assert expected == result
|
|
# keep
|
|
expected = {"non-scalar": [1, 2], "test_col": None}
|
|
result = list(df.iterfeatures(na="keep"))[0].get("properties")
|
|
assert expected == result
|
|
|
|
def test_geodataframe_geojson_no_bbox(self):
|
|
geo = self.df._to_geo(na="null", show_bbox=False)
|
|
assert "bbox" not in geo.keys()
|
|
for feature in geo["features"]:
|
|
assert "bbox" not in feature.keys()
|
|
|
|
def test_geodataframe_geojson_bbox(self):
|
|
geo = self.df._to_geo(na="null", show_bbox=True)
|
|
assert "bbox" in geo.keys()
|
|
assert len(geo["bbox"]) == 4
|
|
assert isinstance(geo["bbox"], tuple)
|
|
for feature in geo["features"]:
|
|
assert "bbox" in feature.keys()
|
|
|
|
def test_pickle(self):
|
|
import pickle
|
|
|
|
df2 = pickle.loads(pickle.dumps(self.df))
|
|
assert_geodataframe_equal(self.df, df2)
|
|
|
|
def test_pickle_method(self):
|
|
filename = os.path.join(self.tempdir, "df.pkl")
|
|
self.df.to_pickle(filename)
|
|
unpickled = pd.read_pickle(filename)
|
|
assert_frame_equal(self.df, unpickled)
|
|
assert self.df.crs == unpickled.crs
|
|
|
|
def test_estimate_utm_crs(self):
|
|
assert self.df.estimate_utm_crs() == CRS("EPSG:32618")
|
|
assert self.df.estimate_utm_crs("NAD83") == CRS("EPSG:26918")
|
|
|
|
def test_to_wkb(self):
|
|
wkbs0 = [
|
|
(
|
|
b"\x01\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00"
|
|
b"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
|
|
), # POINT (0 0)
|
|
(
|
|
b"\x01\x01\x00\x00\x00\x00\x00\x00\x00\x00"
|
|
b"\x00\xf0?\x00\x00\x00\x00\x00\x00\xf0?"
|
|
), # POINT (1 1)
|
|
]
|
|
wkbs1 = [
|
|
(
|
|
b"\x01\x01\x00\x00\x00\x00\x00\x00\x00\x00"
|
|
b"\x00\x00@\x00\x00\x00\x00\x00\x00\x00@"
|
|
), # POINT (2 2)
|
|
(
|
|
b"\x01\x01\x00\x00\x00\x00\x00\x00\x00\x00"
|
|
b"\x00\x08@\x00\x00\x00\x00\x00\x00\x08@"
|
|
), # POINT (3 3)
|
|
]
|
|
gs0 = GeoSeries.from_wkb(wkbs0)
|
|
gs1 = GeoSeries.from_wkb(wkbs1)
|
|
gdf = GeoDataFrame({"geom_col0": gs0, "geom_col1": gs1})
|
|
|
|
expected_df = pd.DataFrame({"geom_col0": wkbs0, "geom_col1": wkbs1})
|
|
assert_frame_equal(expected_df, gdf.to_wkb())
|
|
|
|
def test_to_wkt(self):
|
|
wkts0 = ["POINT (0 0)", "POINT (1 1)"]
|
|
wkts1 = ["POINT (2 2)", "POINT (3 3)"]
|
|
gs0 = GeoSeries.from_wkt(wkts0)
|
|
gs1 = GeoSeries.from_wkt(wkts1)
|
|
gdf = GeoDataFrame({"gs0": gs0, "gs1": gs1})
|
|
|
|
expected_df = pd.DataFrame({"gs0": wkts0, "gs1": wkts1})
|
|
assert_frame_equal(expected_df, gdf.to_wkt())
|
|
|
|
@pytest.mark.parametrize("how", ["left", "inner", "right"])
|
|
@pytest.mark.parametrize("predicate", ["intersects", "within", "contains"])
|
|
@pytest.mark.skipif(
|
|
not (compat.USE_PYGEOS or compat.USE_SHAPELY_20 or compat.HAS_RTREE),
|
|
reason="sjoin needs `rtree` or `pygeos` dependency",
|
|
)
|
|
def test_sjoin(self, how, predicate):
|
|
"""
|
|
Basic test for availability of the GeoDataFrame method. Other
|
|
sjoin tests are located in /tools/tests/test_sjoin.py
|
|
"""
|
|
left = read_file(geopandas.datasets.get_path("naturalearth_cities"))
|
|
right = read_file(geopandas.datasets.get_path("naturalearth_lowres"))
|
|
|
|
expected = geopandas.sjoin(left, right, how=how, predicate=predicate)
|
|
result = left.sjoin(right, how=how, predicate=predicate)
|
|
assert_geodataframe_equal(result, expected)
|
|
|
|
@pytest.mark.parametrize("how", ["left", "inner", "right"])
|
|
@pytest.mark.parametrize("max_distance", [None, 1])
|
|
@pytest.mark.parametrize("distance_col", [None, "distance"])
|
|
@pytest.mark.skipif(
|
|
not TEST_NEAREST,
|
|
reason=(
|
|
"PyGEOS >= 0.10.0"
|
|
" must be installed and activated via the geopandas.compat module to"
|
|
" test sjoin_nearest"
|
|
),
|
|
)
|
|
def test_sjoin_nearest(self, how, max_distance, distance_col):
|
|
"""
|
|
Basic test for availability of the GeoDataFrame method. Other
|
|
sjoin tests are located in /tools/tests/test_sjoin.py
|
|
"""
|
|
left = read_file(geopandas.datasets.get_path("naturalearth_cities"))
|
|
right = read_file(geopandas.datasets.get_path("naturalearth_lowres"))
|
|
|
|
expected = geopandas.sjoin_nearest(
|
|
left, right, how=how, max_distance=max_distance, distance_col=distance_col
|
|
)
|
|
result = left.sjoin_nearest(
|
|
right, how=how, max_distance=max_distance, distance_col=distance_col
|
|
)
|
|
assert_geodataframe_equal(result, expected)
|
|
|
|
@pytest.mark.skip_no_sindex
|
|
def test_clip(self):
|
|
"""
|
|
Basic test for availability of the GeoDataFrame method. Other
|
|
clip tests are located in /tools/tests/test_clip.py
|
|
"""
|
|
left = read_file(geopandas.datasets.get_path("naturalearth_cities"))
|
|
world = read_file(geopandas.datasets.get_path("naturalearth_lowres"))
|
|
south_america = world[world["continent"] == "South America"]
|
|
|
|
expected = geopandas.clip(left, south_america)
|
|
result = left.clip(south_america)
|
|
assert_geodataframe_equal(result, expected)
|
|
|
|
@pytest.mark.skip_no_sindex
|
|
def test_overlay(self, dfs, how):
|
|
"""
|
|
Basic test for availability of the GeoDataFrame method. Other
|
|
overlay tests are located in tests/test_overlay.py
|
|
"""
|
|
df1, df2 = dfs
|
|
|
|
expected = geopandas.overlay(df1, df2, how=how)
|
|
result = df1.overlay(df2, how=how)
|
|
assert_geodataframe_equal(result, expected)
|
|
|
|
|
|
def check_geodataframe(df, geometry_column="geometry"):
|
|
assert isinstance(df, GeoDataFrame)
|
|
assert isinstance(df.geometry, GeoSeries)
|
|
assert isinstance(df[geometry_column], GeoSeries)
|
|
assert df._geometry_column_name == geometry_column
|
|
assert df.geometry.name == geometry_column
|
|
assert isinstance(df.geometry.values, GeometryArray)
|
|
assert isinstance(df.geometry.dtype, GeometryDtype)
|
|
|
|
|
|
class TestConstructor:
|
|
def test_dict(self):
|
|
data = {
|
|
"A": range(3),
|
|
"B": np.arange(3.0),
|
|
"geometry": [Point(x, x) for x in range(3)],
|
|
}
|
|
df = GeoDataFrame(data)
|
|
check_geodataframe(df)
|
|
|
|
# with specifying other kwargs
|
|
df = GeoDataFrame(data, index=list("abc"))
|
|
check_geodataframe(df)
|
|
assert_index_equal(df.index, pd.Index(list("abc")))
|
|
|
|
df = GeoDataFrame(data, columns=["B", "A", "geometry"])
|
|
check_geodataframe(df)
|
|
assert_index_equal(df.columns, pd.Index(["B", "A", "geometry"]))
|
|
|
|
df = GeoDataFrame(data, columns=["A", "geometry"])
|
|
check_geodataframe(df)
|
|
assert_index_equal(df.columns, pd.Index(["A", "geometry"]))
|
|
assert_series_equal(df["A"], pd.Series(range(3), name="A"))
|
|
|
|
def test_dict_of_series(self):
|
|
data = {
|
|
"A": pd.Series(range(3)),
|
|
"B": pd.Series(np.arange(3.0)),
|
|
"geometry": GeoSeries([Point(x, x) for x in range(3)]),
|
|
}
|
|
|
|
df = GeoDataFrame(data)
|
|
check_geodataframe(df)
|
|
|
|
df = GeoDataFrame(data, index=pd.Index([1, 2]))
|
|
check_geodataframe(df)
|
|
assert_index_equal(df.index, pd.Index([1, 2]))
|
|
assert df["A"].tolist() == [1, 2]
|
|
|
|
# one non-series -> length is not correct
|
|
data = {
|
|
"A": pd.Series(range(3)),
|
|
"B": np.arange(3.0),
|
|
"geometry": GeoSeries([Point(x, x) for x in range(3)]),
|
|
}
|
|
with pytest.raises(ValueError):
|
|
GeoDataFrame(data, index=[1, 2])
|
|
|
|
def test_dict_specified_geometry(self):
|
|
data = {
|
|
"A": range(3),
|
|
"B": np.arange(3.0),
|
|
"other_geom": [Point(x, x) for x in range(3)],
|
|
}
|
|
|
|
df = GeoDataFrame(data, geometry="other_geom")
|
|
check_geodataframe(df, "other_geom")
|
|
|
|
with pytest.raises(ValueError):
|
|
df = GeoDataFrame(data, geometry="geometry")
|
|
|
|
# when no geometry specified -> works but raises error once
|
|
# trying to access geometry
|
|
df = GeoDataFrame(data)
|
|
|
|
with pytest.raises(AttributeError):
|
|
_ = df.geometry
|
|
|
|
df = df.set_geometry("other_geom")
|
|
check_geodataframe(df, "other_geom")
|
|
|
|
# combined with custom args
|
|
df = GeoDataFrame(data, geometry="other_geom", columns=["B", "other_geom"])
|
|
check_geodataframe(df, "other_geom")
|
|
assert_index_equal(df.columns, pd.Index(["B", "other_geom"]))
|
|
assert_series_equal(df["B"], pd.Series(np.arange(3.0), name="B"))
|
|
|
|
df = GeoDataFrame(data, geometry="other_geom", columns=["other_geom", "A"])
|
|
check_geodataframe(df, "other_geom")
|
|
assert_index_equal(df.columns, pd.Index(["other_geom", "A"]))
|
|
assert_series_equal(df["A"], pd.Series(range(3), name="A"))
|
|
|
|
def test_array(self):
|
|
data = {
|
|
"A": range(3),
|
|
"B": np.arange(3.0),
|
|
"geometry": [Point(x, x) for x in range(3)],
|
|
}
|
|
with ignore_shapely2_warnings():
|
|
a = np.array([data["A"], data["B"], data["geometry"]], dtype=object).T
|
|
|
|
df = GeoDataFrame(a, columns=["A", "B", "geometry"])
|
|
check_geodataframe(df)
|
|
|
|
df = GeoDataFrame(a, columns=["A", "B", "other_geom"], geometry="other_geom")
|
|
check_geodataframe(df, "other_geom")
|
|
|
|
def test_from_frame(self):
|
|
data = {
|
|
"A": range(3),
|
|
"B": np.arange(3.0),
|
|
"geometry": [Point(x, x) for x in range(3)],
|
|
}
|
|
gpdf = GeoDataFrame(data)
|
|
with ignore_shapely2_warnings():
|
|
pddf = pd.DataFrame(data)
|
|
check_geodataframe(gpdf)
|
|
assert type(pddf) == pd.DataFrame
|
|
|
|
for df in [gpdf, pddf]:
|
|
res = GeoDataFrame(df)
|
|
check_geodataframe(res)
|
|
|
|
res = GeoDataFrame(df, index=pd.Index([0, 2]))
|
|
check_geodataframe(res)
|
|
assert_index_equal(res.index, pd.Index([0, 2]))
|
|
assert res["A"].tolist() == [0, 2]
|
|
|
|
res = GeoDataFrame(df, columns=["geometry", "B"])
|
|
check_geodataframe(res)
|
|
assert_index_equal(res.columns, pd.Index(["geometry", "B"]))
|
|
|
|
with pytest.raises(ValueError):
|
|
GeoDataFrame(df, geometry="other_geom")
|
|
|
|
def test_from_frame_specified_geometry(self):
|
|
data = {
|
|
"A": range(3),
|
|
"B": np.arange(3.0),
|
|
"other_geom": [Point(x, x) for x in range(3)],
|
|
}
|
|
|
|
gpdf = GeoDataFrame(data, geometry="other_geom")
|
|
check_geodataframe(gpdf, "other_geom")
|
|
with ignore_shapely2_warnings():
|
|
pddf = pd.DataFrame(data)
|
|
|
|
for df in [gpdf, pddf]:
|
|
res = GeoDataFrame(df, geometry="other_geom")
|
|
check_geodataframe(res, "other_geom")
|
|
|
|
# gdf from gdf should preserve active geometry column name
|
|
df = GeoDataFrame(gpdf)
|
|
check_geodataframe(df, "other_geom")
|
|
|
|
def test_only_geometry(self):
|
|
exp = GeoDataFrame(
|
|
{"geometry": [Point(x, x) for x in range(3)], "other": range(3)}
|
|
)[["geometry"]]
|
|
|
|
df = GeoDataFrame(geometry=[Point(x, x) for x in range(3)])
|
|
check_geodataframe(df)
|
|
assert_geodataframe_equal(df, exp)
|
|
|
|
df = GeoDataFrame({"geometry": [Point(x, x) for x in range(3)]})
|
|
check_geodataframe(df)
|
|
assert_geodataframe_equal(df, exp)
|
|
|
|
df = GeoDataFrame(
|
|
{"other_geom": [Point(x, x) for x in range(3)]}, geometry="other_geom"
|
|
)
|
|
check_geodataframe(df, "other_geom")
|
|
exp = exp.rename(columns={"geometry": "other_geom"}).set_geometry("other_geom")
|
|
assert_geodataframe_equal(df, exp)
|
|
|
|
def test_no_geometries(self):
|
|
# keeps GeoDataFrame class (no DataFrame)
|
|
data = {"A": range(3), "B": np.arange(3.0)}
|
|
df = GeoDataFrame(data)
|
|
assert type(df) == GeoDataFrame
|
|
|
|
gdf = GeoDataFrame({"x": [1]})
|
|
assert list(gdf.x) == [1]
|
|
|
|
def test_empty(self):
|
|
df = GeoDataFrame()
|
|
assert type(df) == GeoDataFrame
|
|
|
|
df = GeoDataFrame({"A": [], "B": []}, geometry=[])
|
|
assert type(df) == GeoDataFrame
|
|
|
|
def test_column_ordering(self):
|
|
geoms = [Point(1, 1), Point(2, 2), Point(3, 3)]
|
|
gs = GeoSeries(geoms)
|
|
gdf = GeoDataFrame(
|
|
{"a": [1, 2, 3], "geometry": gs},
|
|
columns=["geometry", "a"],
|
|
geometry="geometry",
|
|
)
|
|
check_geodataframe(gdf)
|
|
gdf.columns == ["geometry", "a"]
|
|
|
|
# with non-default index
|
|
gdf = GeoDataFrame(
|
|
{"a": [1, 2, 3], "geometry": gs},
|
|
columns=["geometry", "a"],
|
|
index=pd.Index([0, 0, 1]),
|
|
geometry="geometry",
|
|
)
|
|
check_geodataframe(gdf)
|
|
gdf.columns == ["geometry", "a"]
|
|
|
|
@pytest.mark.xfail
|
|
def test_preserve_series_name(self):
|
|
geoms = [Point(1, 1), Point(2, 2), Point(3, 3)]
|
|
gs = GeoSeries(geoms)
|
|
gdf = GeoDataFrame({"a": [1, 2, 3]}, geometry=gs)
|
|
|
|
check_geodataframe(gdf, geometry_column="geometry")
|
|
|
|
geoms = [Point(1, 1), Point(2, 2), Point(3, 3)]
|
|
gs = GeoSeries(geoms, name="my_geom")
|
|
gdf = GeoDataFrame({"a": [1, 2, 3]}, geometry=gs)
|
|
|
|
check_geodataframe(gdf, geometry_column="my_geom")
|
|
|
|
def test_overwrite_geometry(self):
|
|
# GH602
|
|
data = pd.DataFrame({"geometry": [1, 2, 3], "col1": [4, 5, 6]})
|
|
with ignore_shapely2_warnings():
|
|
geoms = pd.Series([Point(i, i) for i in range(3)])
|
|
# passed geometry kwarg should overwrite geometry column in data
|
|
res = GeoDataFrame(data, geometry=geoms)
|
|
assert_geoseries_equal(res.geometry, GeoSeries(geoms))
|
|
|
|
def test_repeat_geo_col(self):
|
|
df = pd.DataFrame(
|
|
[
|
|
{"geometry": Point(x, y), "geom": Point(x, y)}
|
|
for x, y in zip(range(3), range(3))
|
|
],
|
|
)
|
|
# explicitly prevent construction of gdf with repeat geometry column names
|
|
# two columns called "geometry", geom col inferred
|
|
df2 = df.rename(columns={"geom": "geometry"})
|
|
with pytest.raises(ValueError):
|
|
GeoDataFrame(df2)
|
|
# ensure case is caught when custom geom column name is used
|
|
# two columns called "geom", geom col explicit
|
|
df3 = df.rename(columns={"geometry": "geom"})
|
|
with pytest.raises(ValueError):
|
|
GeoDataFrame(df3, geometry="geom")
|
|
|
|
@pytest.mark.parametrize("dtype", ["geometry", "object"])
|
|
def test_multiindex_with_geometry_label(self, dtype):
|
|
# DataFrame with MultiIndex where "geometry" label corresponds to
|
|
# multiple columns
|
|
df = pd.DataFrame([[Point(0, 0), Point(1, 1)], [Point(2, 2), Point(3, 3)]])
|
|
df = df.astype(dtype)
|
|
df.columns = pd.MultiIndex.from_product([["geometry"], [0, 1]])
|
|
# don't error in constructor
|
|
gdf = GeoDataFrame(df)
|
|
with pytest.raises(AttributeError, match=".*geometry .* has not been set.*"):
|
|
gdf.geometry
|
|
res_gdf = gdf.set_geometry(("geometry", 0))
|
|
assert res_gdf.shape == gdf.shape
|
|
assert isinstance(res_gdf.geometry, GeoSeries)
|
|
|
|
def test_default_geo_colname_none(self):
|
|
match = "You are adding a column named 'geometry' to a GeoDataFrame"
|
|
gdf = GeoDataFrame({"a": [1, 2]})
|
|
|
|
gdf2 = gdf.copy()
|
|
geo_col = GeoSeries.from_xy([1, 3], [3, 3])
|
|
with pytest.warns(FutureWarning, match=match):
|
|
gdf2["geometry"] = geo_col
|
|
assert gdf2._geometry_column_name == "geometry"
|
|
gdf4 = gdf.copy()
|
|
with pytest.warns(FutureWarning, match=match):
|
|
gdf4.geometry = geo_col
|
|
assert gdf4._geometry_column_name == "geometry"
|
|
|
|
# geo col name should only change if we add geometry
|
|
gdf5 = gdf.copy()
|
|
with pytest.warns(
|
|
UserWarning, match="Geometry column does not contain geometry"
|
|
):
|
|
gdf5["geometry"] = "foo"
|
|
assert gdf5._geometry_column_name is None
|
|
gdf3 = gdf.copy().assign(geometry=geo_col)
|
|
assert gdf3._geometry_column_name == "geometry"
|
|
|
|
# Check that adding a GeoSeries to a column called "geometry" to a
|
|
# gdf without an active geometry column some time after the init does not
|
|
# warn / set the active geometry column
|
|
gdf6 = gdf.copy()
|
|
gdf6["geom2"] = geo_col
|
|
gdf6["geom3"] = geo_col
|
|
gdf6 = gdf6.set_geometry("geom2")
|
|
subset = gdf6[["a", "geom3"]] # this has a missing active geometry col
|
|
assert subset._geometry_column_name == "geom2"
|
|
subset["geometry"] = geo_col
|
|
# adding column called geometry shouldn't auto-set
|
|
assert subset._geometry_column_name == "geom2"
|
|
|
|
def test_multiindex_geometry_colname_2_level(self):
|
|
# GH1763 https://github.com/geopandas/geopandas/issues/1763
|
|
crs = "EPSG:4326"
|
|
df = pd.DataFrame(
|
|
[[1, 0], [0, 1]], columns=[["location", "location"], ["x", "y"]]
|
|
)
|
|
x_col = df["location", "x"]
|
|
y_col = df["location", "y"]
|
|
|
|
gdf = GeoDataFrame(df, crs=crs, geometry=points_from_xy(x_col, y_col))
|
|
assert gdf.crs == crs
|
|
assert gdf.geometry.crs == crs
|
|
assert gdf.geometry.dtype == "geometry"
|
|
assert gdf._geometry_column_name == "geometry"
|
|
assert gdf.geometry.name == "geometry"
|
|
|
|
def test_multiindex_geometry_colname_3_level(self):
|
|
# GH1763 https://github.com/geopandas/geopandas/issues/1763
|
|
# Note 3-level case uses different code paths in pandas, it is not redundant
|
|
crs = "EPSG:4326"
|
|
df = pd.DataFrame(
|
|
[[1, 0], [0, 1]],
|
|
columns=[
|
|
["foo", "foo"],
|
|
["location", "location"],
|
|
["x", "y"],
|
|
],
|
|
)
|
|
|
|
x_col = df["foo", "location", "x"]
|
|
y_col = df["foo", "location", "y"]
|
|
|
|
gdf = GeoDataFrame(df, crs=crs, geometry=points_from_xy(x_col, y_col))
|
|
assert gdf.crs == crs
|
|
assert gdf.geometry.crs == crs
|
|
assert gdf.geometry.dtype == "geometry"
|
|
assert gdf._geometry_column_name == "geometry"
|
|
assert gdf.geometry.name == "geometry"
|
|
|
|
def test_multiindex_geometry_colname_3_level_new_col(self):
|
|
crs = "EPSG:4326"
|
|
df = pd.DataFrame(
|
|
[[1, 0], [0, 1]],
|
|
columns=[
|
|
["foo", "foo"],
|
|
["location", "location"],
|
|
["x", "y"],
|
|
],
|
|
)
|
|
|
|
x_col = df["foo", "location", "x"]
|
|
y_col = df["foo", "location", "y"]
|
|
df["geometry"] = GeoSeries.from_xy(x_col, y_col)
|
|
df2 = df.copy()
|
|
gdf = df.set_geometry("geometry", crs=crs)
|
|
assert gdf.crs == crs
|
|
assert gdf._geometry_column_name == "geometry"
|
|
assert gdf.geometry.name == "geometry"
|
|
# test again setting with tuple col name
|
|
gdf = df2.set_geometry(("geometry", "", ""), crs=crs)
|
|
assert gdf.crs == crs
|
|
assert gdf._geometry_column_name == ("geometry", "", "")
|
|
assert gdf.geometry.name == ("geometry", "", "")
|
|
|
|
def test_assign_cols_using_index(self):
|
|
nybb_filename = geopandas.datasets.get_path("nybb")
|
|
df = read_file(nybb_filename)
|
|
other_df = pd.DataFrame({"foo": range(5), "bar": range(5)})
|
|
expected = pd.concat([df, other_df], axis=1)
|
|
df[other_df.columns] = other_df
|
|
assert_geodataframe_equal(df, expected)
|
|
|
|
|
|
def test_geodataframe_crs():
|
|
gdf = GeoDataFrame(columns=["geometry"])
|
|
gdf.crs = "IGNF:ETRS89UTM28"
|
|
assert gdf.crs.to_authority() == ("IGNF", "ETRS89UTM28")
|
|
|
|
|
|
def test_geodataframe_nocrs_json():
|
|
# no CRS, no crs field
|
|
gdf = GeoDataFrame(columns=["geometry"])
|
|
gdf_geojson = json.loads(gdf.to_json())
|
|
assert "crs" not in gdf_geojson
|
|
|
|
# WGS84, no crs field (default as per spec)
|
|
gdf.crs = 4326
|
|
gdf_geojson = json.loads(gdf.to_json())
|
|
assert "crs" not in gdf_geojson
|
|
|
|
|
|
def test_geodataframe_crs_json():
|
|
gdf = GeoDataFrame(columns=["geometry"])
|
|
gdf.crs = 25833
|
|
gdf_geojson = json.loads(gdf.to_json())
|
|
assert "crs" in gdf_geojson
|
|
assert gdf_geojson["crs"] == {
|
|
"type": "name",
|
|
"properties": {"name": "urn:ogc:def:crs:EPSG::25833"},
|
|
}
|
|
gdf_geointerface = gdf.__geo_interface__
|
|
assert "crs" not in gdf_geointerface
|
|
|
|
|
|
@pytest.mark.parametrize(
|
|
"crs",
|
|
["+proj=cea +lon_0=0 +lat_ts=45 +x_0=0 +y_0=0 +ellps=WGS84 +units=m", "IGNF:WGS84"],
|
|
)
|
|
def test_geodataframe_crs_nonrepresentable_json(crs):
|
|
gdf = GeoDataFrame(
|
|
[Point(1000, 1000)],
|
|
columns=["geometry"],
|
|
crs=crs,
|
|
)
|
|
with pytest.warns(
|
|
UserWarning, match="GeoDataFrame's CRS is not representable in URN OGC"
|
|
):
|
|
gdf_geojson = json.loads(gdf.to_json())
|
|
assert "crs" not in gdf_geojson
|
|
|
|
|
|
def test_geodataframe_crs_colname():
|
|
# https://github.com/geopandas/geopandas/issues/2942
|
|
gdf = GeoDataFrame({"crs": [1], "geometry": [Point(1, 1)]})
|
|
assert gdf.crs is None
|
|
assert gdf["crs"].iloc[0] == 1
|
|
assert getattr(gdf, "crs") is None
|