734 lines
25 KiB
Python
734 lines
25 KiB
Python
import random
|
|
|
|
import numpy as np
|
|
import pandas as pd
|
|
import pyproj
|
|
import pytest
|
|
from shapely.geometry import Point, Polygon, LineString
|
|
|
|
from geopandas import GeoSeries, GeoDataFrame, points_from_xy, datasets, read_file
|
|
from geopandas.array import from_shapely, from_wkb, from_wkt, GeometryArray
|
|
from geopandas.testing import assert_geodataframe_equal
|
|
|
|
|
|
def _create_df(x, y=None, crs=None):
|
|
y = y or x
|
|
x = np.asarray(x)
|
|
y = np.asarray(y)
|
|
|
|
return GeoDataFrame(
|
|
{"geometry": points_from_xy(x, y), "value1": x + y, "value2": x * y}, crs=crs
|
|
)
|
|
|
|
|
|
def df_epsg26918():
|
|
# EPSG:26918
|
|
# Center coordinates
|
|
# -1683723.64 6689139.23
|
|
return _create_df(
|
|
x=range(-1683723, -1683723 + 10, 1),
|
|
y=range(6689139, 6689139 + 10, 1),
|
|
crs="epsg:26918",
|
|
)
|
|
|
|
|
|
def test_to_crs_transform():
|
|
df = df_epsg26918()
|
|
lonlat = df.to_crs(epsg=4326)
|
|
utm = lonlat.to_crs(epsg=26918)
|
|
assert_geodataframe_equal(df, utm, check_less_precise=True)
|
|
|
|
|
|
def test_to_crs_transform__missing_data():
|
|
# https://github.com/geopandas/geopandas/issues/1573
|
|
df = df_epsg26918()
|
|
df.loc[3, "geometry"] = None
|
|
lonlat = df.to_crs(epsg=4326)
|
|
utm = lonlat.to_crs(epsg=26918)
|
|
assert_geodataframe_equal(df, utm, check_less_precise=True)
|
|
|
|
|
|
def test_to_crs_transform__empty_data():
|
|
df = df_epsg26918().iloc[:0]
|
|
lonlat = df.to_crs(epsg=4326)
|
|
utm = lonlat.to_crs(epsg=26918)
|
|
assert_geodataframe_equal(df, utm, check_less_precise=True)
|
|
|
|
|
|
def test_to_crs_inplace():
|
|
df = df_epsg26918()
|
|
lonlat = df.to_crs(epsg=4326)
|
|
df.to_crs(epsg=4326, inplace=True)
|
|
assert_geodataframe_equal(df, lonlat, check_less_precise=True)
|
|
|
|
|
|
def test_to_crs_geo_column_name():
|
|
# Test to_crs() with different geometry column name (GH#339)
|
|
df = df_epsg26918()
|
|
df = df.rename(columns={"geometry": "geom"})
|
|
df.set_geometry("geom", inplace=True)
|
|
lonlat = df.to_crs(epsg=4326)
|
|
utm = lonlat.to_crs(epsg=26918)
|
|
assert lonlat.geometry.name == "geom"
|
|
assert utm.geometry.name == "geom"
|
|
assert_geodataframe_equal(df, utm, check_less_precise=True)
|
|
|
|
|
|
def test_to_crs_dimension_z():
|
|
# preserve z dimension
|
|
arr = points_from_xy([1, 2], [2, 3], [3, 4], crs=4326)
|
|
assert arr.has_z.all()
|
|
result = arr.to_crs(epsg=3857)
|
|
assert result.has_z.all()
|
|
|
|
|
|
def test_to_crs_dimension_mixed():
|
|
s = GeoSeries([Point(1, 2), LineString([(1, 2, 3), (4, 5, 6)])], crs=2056)
|
|
result = s.to_crs(epsg=4326)
|
|
assert not result[0].is_empty
|
|
assert result.has_z.tolist() == [False, True]
|
|
roundtrip = result.to_crs(epsg=2056)
|
|
# TODO replace with assert_geoseries_equal once we expose tolerance keyword
|
|
# assert_geoseries_equal(roundtrip, s, check_less_precise=True)
|
|
for a, b in zip(roundtrip, s):
|
|
np.testing.assert_allclose(a.coords[:], b.coords[:], atol=0.01)
|
|
|
|
|
|
# -----------------------------------------------------------------------------
|
|
# Test different supported formats for CRS specification
|
|
|
|
|
|
@pytest.fixture(
|
|
params=[
|
|
4326,
|
|
"epsg:4326",
|
|
pytest.param(
|
|
{"init": "epsg:4326"},
|
|
),
|
|
"+proj=longlat +ellps=WGS84 +datum=WGS84 +no_defs",
|
|
{"proj": "latlong", "ellps": "WGS84", "datum": "WGS84", "no_defs": True},
|
|
],
|
|
ids=["epsg_number", "epsg_string", "epsg_dict", "proj4_string", "proj4_dict"],
|
|
)
|
|
def epsg4326(request):
|
|
if isinstance(request.param, int):
|
|
return {"epsg": request.param}
|
|
return {"crs": request.param}
|
|
|
|
|
|
@pytest.fixture(
|
|
params=[
|
|
26918,
|
|
"epsg:26918",
|
|
pytest.param(
|
|
{"init": "epsg:26918", "no_defs": True},
|
|
),
|
|
"+proj=utm +zone=18 +ellps=GRS80 +datum=NAD83 +units=m +no_defs ",
|
|
{"proj": "utm", "zone": 18, "datum": "NAD83", "units": "m", "no_defs": True},
|
|
],
|
|
ids=["epsg_number", "epsg_string", "epsg_dict", "proj4_string", "proj4_dict"],
|
|
)
|
|
def epsg26918(request):
|
|
if isinstance(request.param, int):
|
|
return {"epsg": request.param}
|
|
return {"crs": request.param}
|
|
|
|
|
|
@pytest.mark.filterwarnings("ignore:'\\+init:DeprecationWarning")
|
|
@pytest.mark.filterwarnings("ignore:'\\+init:FutureWarning")
|
|
def test_transform2(epsg4326, epsg26918):
|
|
# with PROJ >= 7, the transformation using EPSG code vs proj4 string is
|
|
# slightly different due to use of grid files or not -> turn off network
|
|
# to not use grid files at all for this test
|
|
pyproj.network.set_network_enabled(False)
|
|
|
|
df = df_epsg26918()
|
|
lonlat = df.to_crs(**epsg4326)
|
|
utm = lonlat.to_crs(**epsg26918)
|
|
# can't check for CRS equality, as the formats differ although representing
|
|
# the same CRS
|
|
assert_geodataframe_equal(df, utm, check_less_precise=True, check_crs=False)
|
|
|
|
|
|
def test_crs_axis_order__always_xy():
|
|
df = GeoDataFrame(geometry=[Point(-1683723, 6689139)], crs="epsg:26918")
|
|
lonlat = df.to_crs("epsg:4326")
|
|
test_lonlat = GeoDataFrame(
|
|
geometry=[Point(-110.1399901, 55.1350011)], crs="epsg:4326"
|
|
)
|
|
assert_geodataframe_equal(lonlat, test_lonlat, check_less_precise=True)
|
|
|
|
|
|
def test_skip_exact_same():
|
|
df = df_epsg26918()
|
|
utm = df.to_crs(df.crs)
|
|
assert_geodataframe_equal(df, utm, check_less_precise=True)
|
|
|
|
|
|
# Test CRS on GeometryArray level
|
|
class TestGeometryArrayCRS:
|
|
def setup_method(self):
|
|
self.osgb = pyproj.CRS(27700)
|
|
self.wgs = pyproj.CRS(4326)
|
|
|
|
self.geoms = [Point(0, 0), Point(1, 1)]
|
|
self.polys = [
|
|
Polygon([(random.random(), random.random()) for i in range(3)])
|
|
for _ in range(10)
|
|
]
|
|
self.arr = from_shapely(self.polys, crs=27700)
|
|
|
|
def test_array(self):
|
|
arr = from_shapely(self.geoms)
|
|
arr.crs = 27700
|
|
assert arr.crs == self.osgb
|
|
|
|
arr = from_shapely(self.geoms, crs=27700)
|
|
assert arr.crs == self.osgb
|
|
|
|
arr = GeometryArray(arr)
|
|
assert arr.crs == self.osgb
|
|
|
|
arr = GeometryArray(arr, crs=4326)
|
|
assert arr.crs == self.wgs
|
|
|
|
def test_series(self):
|
|
s = GeoSeries(crs=27700)
|
|
assert s.crs == self.osgb
|
|
assert s.values.crs == self.osgb
|
|
|
|
arr = from_shapely(self.geoms)
|
|
s = GeoSeries(arr, crs=27700)
|
|
assert s.crs == self.osgb
|
|
assert s.values.crs == self.osgb
|
|
|
|
# manually change CRS
|
|
s.crs = 4326
|
|
assert s.crs == self.wgs
|
|
assert s.values.crs == self.wgs
|
|
|
|
s = GeoSeries(self.geoms, crs=27700)
|
|
assert s.crs == self.osgb
|
|
assert s.values.crs == self.osgb
|
|
|
|
arr = from_shapely(self.geoms, crs=27700)
|
|
s = GeoSeries(arr)
|
|
assert s.crs == self.osgb
|
|
assert s.values.crs == self.osgb
|
|
|
|
with pytest.raises(
|
|
ValueError,
|
|
match="CRS mismatch between CRS of the passed geometries and 'crs'",
|
|
):
|
|
s = GeoSeries(arr, crs=4326)
|
|
assert s.crs == self.osgb
|
|
|
|
def test_dataframe(self):
|
|
arr = from_shapely(self.geoms, crs=27700)
|
|
df = GeoDataFrame(geometry=arr)
|
|
assert df.crs == self.osgb
|
|
assert df.geometry.crs == self.osgb
|
|
assert df.geometry.values.crs == self.osgb
|
|
|
|
arr = from_shapely(self.geoms)
|
|
s = GeoSeries(arr, crs=27700)
|
|
df = GeoDataFrame(geometry=s)
|
|
assert df.crs == self.osgb
|
|
assert df.geometry.crs == self.osgb
|
|
assert df.geometry.values.crs == self.osgb
|
|
|
|
# different passed CRS than array CRS is now an error
|
|
match_str = "CRS mismatch between CRS of the passed geometries and 'crs'"
|
|
with pytest.raises(ValueError, match=match_str):
|
|
df = GeoDataFrame(geometry=s, crs=4326)
|
|
with pytest.raises(ValueError, match=match_str):
|
|
GeoDataFrame(geometry=s, crs=4326)
|
|
with pytest.raises(ValueError, match=match_str):
|
|
GeoDataFrame({"data": [1, 2], "geometry": s}, crs=4326)
|
|
with pytest.raises(ValueError, match=match_str):
|
|
GeoDataFrame(df, crs=4326).crs
|
|
|
|
# manually change CRS
|
|
arr = from_shapely(self.geoms)
|
|
s = GeoSeries(arr, crs=27700)
|
|
df = GeoDataFrame(geometry=s)
|
|
df.crs = 4326
|
|
assert df.crs == self.wgs
|
|
assert df.geometry.crs == self.wgs
|
|
assert df.geometry.values.crs == self.wgs
|
|
|
|
with pytest.raises(ValueError, match="Assigning CRS to a GeoDataFrame without"):
|
|
GeoDataFrame(self.geoms, columns=["geom"], crs=27700)
|
|
with pytest.raises(ValueError, match="Assigning CRS to a GeoDataFrame without"):
|
|
GeoDataFrame(crs=27700)
|
|
|
|
df = GeoDataFrame(self.geoms, columns=["geom"])
|
|
df = df.set_geometry("geom", crs=27700)
|
|
assert df.crs == self.osgb
|
|
assert df.geometry.crs == self.osgb
|
|
assert df.geometry.values.crs == self.osgb
|
|
assert df.geom.crs == self.osgb
|
|
assert df.geom.values.crs == self.osgb
|
|
|
|
df = GeoDataFrame(geometry=self.geoms, crs=27700)
|
|
assert df.crs == self.osgb
|
|
assert df.geometry.crs == self.osgb
|
|
assert df.geometry.values.crs == self.osgb
|
|
|
|
# new geometry with set CRS has priority over GDF CRS
|
|
df = GeoDataFrame(geometry=self.geoms, crs=27700)
|
|
df = df.set_geometry(self.geoms, crs=4326)
|
|
assert df.crs == self.wgs
|
|
assert df.geometry.crs == self.wgs
|
|
assert df.geometry.values.crs == self.wgs
|
|
|
|
arr = from_shapely(self.geoms)
|
|
s = GeoSeries(arr, crs=27700)
|
|
df = GeoDataFrame()
|
|
df = df.set_geometry(s)
|
|
assert df._geometry_column_name == "geometry"
|
|
assert df.crs == self.osgb
|
|
assert df.geometry.crs == self.osgb
|
|
assert df.geometry.values.crs == self.osgb
|
|
|
|
arr = from_shapely(self.geoms, crs=27700)
|
|
df = GeoDataFrame()
|
|
df = df.set_geometry(arr)
|
|
assert df.crs == self.osgb
|
|
assert df.geometry.crs == self.osgb
|
|
assert df.geometry.values.crs == self.osgb
|
|
|
|
arr = from_shapely(self.geoms)
|
|
df = GeoDataFrame({"col1": [1, 2], "geometry": arr}, crs=4326)
|
|
assert df.crs == self.wgs
|
|
assert df.geometry.crs == self.wgs
|
|
assert df.geometry.values.crs == self.wgs
|
|
|
|
arr = from_shapely(self.geoms, crs=4326)
|
|
df = GeoDataFrame({"col1": [1, 2], "geometry": arr})
|
|
assert df.crs == self.wgs
|
|
assert df.geometry.crs == self.wgs
|
|
assert df.geometry.values.crs == self.wgs
|
|
|
|
# geometry column name None on init
|
|
df = GeoDataFrame({"geometry": [0, 1]})
|
|
with pytest.raises(
|
|
ValueError,
|
|
match="Assigning CRS to a GeoDataFrame without a geometry",
|
|
):
|
|
df.crs = 27700
|
|
|
|
# geometry column without geometry
|
|
df = GeoDataFrame({"geometry": [Point(0, 1)]}).assign(geometry=[0])
|
|
with pytest.raises(
|
|
ValueError,
|
|
match="Assigning CRS to a GeoDataFrame without an active geometry",
|
|
):
|
|
df.crs = 27700
|
|
with pytest.raises(
|
|
AttributeError,
|
|
match="The CRS attribute of a GeoDataFrame without an active",
|
|
):
|
|
assert df.crs == self.osgb
|
|
|
|
def test_dataframe_getitem_without_geometry_column(self):
|
|
df = GeoDataFrame({"col": range(10)}, geometry=self.arr)
|
|
df["geom2"] = df.geometry.centroid
|
|
subset = df[["col", "geom2"]]
|
|
with pytest.raises(
|
|
AttributeError,
|
|
match="The CRS attribute of a GeoDataFrame without an active",
|
|
):
|
|
assert subset.crs == self.osgb
|
|
|
|
def test_dataframe_setitem(self):
|
|
# new geometry CRS has priority over GDF CRS
|
|
arr = from_shapely(self.geoms)
|
|
s = GeoSeries(arr, crs=27700)
|
|
df = GeoDataFrame()
|
|
with pytest.warns(
|
|
FutureWarning, match="You are adding a column named 'geometry'"
|
|
):
|
|
df["geometry"] = s
|
|
assert df.crs == self.osgb
|
|
assert df.geometry.crs == self.osgb
|
|
assert df.geometry.values.crs == self.osgb
|
|
|
|
arr = from_shapely(self.geoms, crs=27700)
|
|
df = GeoDataFrame()
|
|
with pytest.warns(
|
|
FutureWarning, match="You are adding a column named 'geometry'"
|
|
):
|
|
df["geometry"] = arr
|
|
assert df.crs == self.osgb
|
|
assert df.geometry.crs == self.osgb
|
|
assert df.geometry.values.crs == self.osgb
|
|
|
|
# test to_crs case (GH1960)
|
|
arr = from_shapely(self.geoms)
|
|
df = GeoDataFrame({"col1": [1, 2], "geometry": arr}, crs=4326)
|
|
df["geometry"] = df["geometry"].to_crs(27700)
|
|
assert df.crs == self.osgb
|
|
assert df.geometry.crs == self.osgb
|
|
assert df.geometry.values.crs == self.osgb
|
|
|
|
# test changing geometry crs not in the geometry column doesn't change the crs
|
|
arr = from_shapely(self.geoms)
|
|
df = GeoDataFrame(
|
|
{"col1": [1, 2], "geometry": arr, "other_geom": arr}, crs=4326
|
|
)
|
|
df["other_geom"] = from_shapely(self.geoms, crs=27700)
|
|
assert df.crs == self.wgs
|
|
assert df.geometry.crs == self.wgs
|
|
assert df["geometry"].crs == self.wgs
|
|
assert df["other_geom"].crs == self.osgb
|
|
|
|
def test_dataframe_setitem_without_geometry_column(self):
|
|
arr = from_shapely(self.geoms)
|
|
df = GeoDataFrame({"col1": [1, 2], "geometry": arr}, crs=4326)
|
|
|
|
# override geometry with non geometry
|
|
with pytest.warns(UserWarning):
|
|
df["geometry"] = 1
|
|
|
|
# assigning a list of geometry object doesn't have cached access to 4326
|
|
df["geometry"] = self.geoms
|
|
assert df.crs is None
|
|
|
|
@pytest.mark.parametrize(
|
|
"scalar", [None, Point(0, 0), LineString([(0, 0), (1, 1)])]
|
|
)
|
|
def test_scalar(self, scalar):
|
|
df = GeoDataFrame()
|
|
with pytest.warns(
|
|
FutureWarning, match="You are adding a column named 'geometry'"
|
|
):
|
|
df["geometry"] = scalar
|
|
df.crs = 4326
|
|
assert df.crs == self.wgs
|
|
assert df.geometry.crs == self.wgs
|
|
assert df.geometry.values.crs == self.wgs
|
|
|
|
@pytest.mark.filterwarnings("ignore:Accessing CRS")
|
|
def test_crs_with_no_geom_fails(self):
|
|
with pytest.raises(ValueError, match="Assigning CRS to a GeoDataFrame without"):
|
|
df = GeoDataFrame()
|
|
df.crs = 4326
|
|
|
|
def test_read_file(self):
|
|
nybb_filename = datasets.get_path("nybb")
|
|
df = read_file(nybb_filename)
|
|
assert df.crs == pyproj.CRS(2263)
|
|
assert df.geometry.crs == pyproj.CRS(2263)
|
|
assert df.geometry.values.crs == pyproj.CRS(2263)
|
|
|
|
def test_multiple_geoms(self):
|
|
arr = from_shapely(self.geoms, crs=27700)
|
|
s = GeoSeries(self.geoms, crs=4326)
|
|
df = GeoDataFrame(s, geometry=arr, columns=["col1"])
|
|
assert df.crs == self.osgb
|
|
assert df.geometry.crs == self.osgb
|
|
assert df.geometry.values.crs == self.osgb
|
|
assert df.col1.crs == self.wgs
|
|
assert df.col1.values.crs == self.wgs
|
|
|
|
def test_multiple_geoms_set_geom(self):
|
|
arr = from_shapely(self.geoms, crs=27700)
|
|
s = GeoSeries(self.geoms, crs=4326)
|
|
df = GeoDataFrame(s, geometry=arr, columns=["col1"])
|
|
df = df.set_geometry("col1")
|
|
assert df.crs == self.wgs
|
|
assert df.geometry.crs == self.wgs
|
|
assert df.geometry.values.crs == self.wgs
|
|
assert df["geometry"].crs == self.osgb
|
|
assert df["geometry"].values.crs == self.osgb
|
|
|
|
def test_assign_cols(self):
|
|
arr = from_shapely(self.geoms, crs=27700)
|
|
s = GeoSeries(self.geoms, crs=4326)
|
|
df = GeoDataFrame(s, geometry=arr, columns=["col1"])
|
|
df["geom2"] = s
|
|
df["geom3"] = s.values
|
|
df["geom4"] = from_shapely(self.geoms)
|
|
assert df.crs == self.osgb
|
|
assert df.geometry.crs == self.osgb
|
|
assert df.geometry.values.crs == self.osgb
|
|
assert df.geom2.crs == self.wgs
|
|
assert df.geom2.values.crs == self.wgs
|
|
assert df.geom3.crs == self.wgs
|
|
assert df.geom3.values.crs == self.wgs
|
|
assert df.geom4.crs is None
|
|
assert df.geom4.values.crs is None
|
|
|
|
def test_copy(self):
|
|
arr = from_shapely(self.geoms, crs=27700)
|
|
s = GeoSeries(self.geoms, crs=4326)
|
|
df = GeoDataFrame(s, geometry=arr, columns=["col1"])
|
|
|
|
arr_copy = arr.copy()
|
|
assert arr_copy.crs == arr.crs
|
|
|
|
s_copy = s.copy()
|
|
assert s_copy.crs == s.crs
|
|
assert s_copy.values.crs == s.values.crs
|
|
|
|
df_copy = df.copy()
|
|
assert df_copy.crs == df.crs
|
|
assert df_copy.geometry.crs == df.geometry.crs
|
|
assert df_copy.geometry.values.crs == df.geometry.values.crs
|
|
assert df_copy.col1.crs == df.col1.crs
|
|
assert df_copy.col1.values.crs == df.col1.values.crs
|
|
|
|
def test_rename(self):
|
|
arr = from_shapely(self.geoms, crs=27700)
|
|
s = GeoSeries(self.geoms, crs=4326)
|
|
df = GeoDataFrame(s, geometry=arr, columns=["col1"])
|
|
df = df.rename(columns={"geometry": "geom"}).set_geometry("geom")
|
|
assert df.crs == self.osgb
|
|
assert df.geometry.crs == self.osgb
|
|
assert df.geometry.values.crs == self.osgb
|
|
|
|
df = df.rename_geometry("geom2")
|
|
assert df.crs == self.osgb
|
|
assert df.geometry.crs == self.osgb
|
|
assert df.geometry.values.crs == self.osgb
|
|
|
|
df = df.rename(columns={"col1": "column1"})
|
|
assert df.column1.crs == self.wgs
|
|
assert df.column1.values.crs == self.wgs
|
|
|
|
def test_geoseries_to_crs(self):
|
|
s = GeoSeries(self.geoms, crs=27700)
|
|
s = s.to_crs(4326)
|
|
assert s.crs == self.wgs
|
|
assert s.values.crs == self.wgs
|
|
|
|
df = GeoDataFrame(geometry=s)
|
|
assert df.crs == self.wgs
|
|
df = df.to_crs(27700)
|
|
assert df.crs == self.osgb
|
|
assert df.geometry.crs == self.osgb
|
|
assert df.geometry.values.crs == self.osgb
|
|
|
|
# make sure that only active geometry is transformed
|
|
arr = from_shapely(self.geoms, crs=4326)
|
|
df["col1"] = arr
|
|
df = df.to_crs(3857)
|
|
assert df.col1.crs == self.wgs
|
|
assert df.col1.values.crs == self.wgs
|
|
|
|
def test_array_to_crs(self):
|
|
arr = from_shapely(self.geoms, crs=27700)
|
|
arr = arr.to_crs(4326)
|
|
assert arr.crs == self.wgs
|
|
|
|
def test_from_shapely(self):
|
|
arr = from_shapely(self.geoms, crs=27700)
|
|
assert arr.crs == self.osgb
|
|
|
|
def test_from_wkb(self):
|
|
L_wkb = [p.wkb for p in self.geoms]
|
|
arr = from_wkb(L_wkb, crs=27700)
|
|
assert arr.crs == self.osgb
|
|
|
|
def test_from_wkt(self):
|
|
L_wkt = [p.wkt for p in self.geoms]
|
|
arr = from_wkt(L_wkt, crs=27700)
|
|
assert arr.crs == self.osgb
|
|
|
|
def test_points_from_xy(self):
|
|
df = pd.DataFrame([{"x": x, "y": x, "z": x} for x in range(10)])
|
|
arr = points_from_xy(df["x"], df["y"], crs=27700)
|
|
assert arr.crs == self.osgb
|
|
|
|
# setting CRS in GeoSeries should not set it in passed array without CRS
|
|
def test_original(self):
|
|
arr = from_shapely(self.geoms)
|
|
s = GeoSeries(arr, crs=27700)
|
|
assert arr.crs is None
|
|
assert s.crs == self.osgb
|
|
|
|
def test_ops(self):
|
|
arr = self.arr
|
|
bound = arr.boundary
|
|
assert bound.crs == self.osgb
|
|
|
|
cent = arr.centroid
|
|
assert cent.crs == self.osgb
|
|
|
|
hull = arr.convex_hull
|
|
assert hull.crs == self.osgb
|
|
|
|
envelope = arr.envelope
|
|
assert envelope.crs == self.osgb
|
|
|
|
exterior = arr.exterior
|
|
assert exterior.crs == self.osgb
|
|
|
|
representative_point = arr.representative_point()
|
|
assert representative_point.crs == self.osgb
|
|
|
|
def test_binary_ops(self):
|
|
arr = self.arr
|
|
quads = []
|
|
while len(quads) < 10:
|
|
geom = Polygon([(random.random(), random.random()) for i in range(4)])
|
|
if geom.is_valid:
|
|
quads.append(geom)
|
|
|
|
arr2 = from_shapely(quads, crs=27700)
|
|
|
|
difference = arr.difference(arr2)
|
|
assert difference.crs == self.osgb
|
|
|
|
intersection = arr.intersection(arr2)
|
|
assert intersection.crs == self.osgb
|
|
|
|
symmetric_difference = arr.symmetric_difference(arr2)
|
|
assert symmetric_difference.crs == self.osgb
|
|
|
|
union = arr.union(arr2)
|
|
assert union.crs == self.osgb
|
|
|
|
def test_other(self):
|
|
arr = self.arr
|
|
|
|
buffer = arr.buffer(5)
|
|
assert buffer.crs == self.osgb
|
|
|
|
interpolate = arr.exterior.interpolate(0.1)
|
|
assert interpolate.crs == self.osgb
|
|
|
|
simplify = arr.simplify(5)
|
|
assert simplify.crs == self.osgb
|
|
|
|
@pytest.mark.parametrize(
|
|
"attr, arg",
|
|
[
|
|
("affine_transform", ([0, 1, 1, 0, 0, 0],)),
|
|
("translate", ()),
|
|
("rotate", (10,)),
|
|
("scale", ()),
|
|
("skew", ()),
|
|
],
|
|
)
|
|
def test_affinity_methods(self, attr, arg):
|
|
result = getattr(self.arr, attr)(*arg)
|
|
|
|
assert result.crs == self.osgb
|
|
|
|
def test_slice(self):
|
|
s = GeoSeries(self.arr, crs=27700)
|
|
assert s.iloc[1:].values.crs == self.osgb
|
|
|
|
df = GeoDataFrame({"col1": self.arr}, geometry=s)
|
|
assert df.iloc[1:].geometry.values.crs == self.osgb
|
|
assert df.iloc[1:].col1.values.crs == self.osgb
|
|
|
|
def test_concat(self):
|
|
s = GeoSeries(self.arr, crs=27700)
|
|
assert pd.concat([s, s]).values.crs == self.osgb
|
|
|
|
df = GeoDataFrame({"col1": from_shapely(self.geoms, crs=4326)}, geometry=s)
|
|
assert pd.concat([df, df]).geometry.values.crs == self.osgb
|
|
assert pd.concat([df, df]).col1.values.crs == self.wgs
|
|
|
|
def test_merge(self):
|
|
arr = from_shapely(self.geoms, crs=27700)
|
|
s = GeoSeries(self.geoms, crs=4326)
|
|
df = GeoDataFrame({"col1": s}, geometry=arr)
|
|
df2 = GeoDataFrame({"col2": s}, geometry=arr).rename_geometry("geom")
|
|
merged = df.merge(df2, left_index=True, right_index=True)
|
|
assert merged.col1.values.crs == self.wgs
|
|
assert merged.geometry.values.crs == self.osgb
|
|
assert merged.col2.values.crs == self.wgs
|
|
assert merged.geom.values.crs == self.osgb
|
|
assert merged.crs == self.osgb
|
|
|
|
# make sure that geometry column from list has CRS (__setitem__)
|
|
def test_setitem_geometry(self):
|
|
arr = from_shapely(self.geoms, crs=27700)
|
|
df = GeoDataFrame({"col1": [0, 1]}, geometry=arr)
|
|
|
|
df["geometry"] = list(df.geometry)
|
|
assert df.geometry.values.crs == self.osgb
|
|
|
|
df2 = GeoDataFrame({"col1": [0, 1]}, geometry=arr)
|
|
df2["geometry"] = from_shapely(self.geoms, crs=4326)
|
|
assert df2.geometry.values.crs == self.wgs
|
|
|
|
def test_astype(self):
|
|
arr = from_shapely(self.geoms, crs=27700)
|
|
df = GeoDataFrame({"col1": [0, 1]}, geometry=arr)
|
|
df2 = df.astype({"col1": str})
|
|
assert df2.crs == self.osgb
|
|
|
|
def test_apply(self):
|
|
s = GeoSeries(self.arr)
|
|
assert s.crs == 27700
|
|
|
|
# apply preserves the CRS if the result is a GeoSeries
|
|
result = s.apply(lambda x: x.centroid)
|
|
assert result.crs == 27700
|
|
|
|
def test_apply_geodataframe(self):
|
|
df = GeoDataFrame({"col1": [0, 1]}, geometry=self.geoms, crs=27700)
|
|
assert df.crs == 27700
|
|
|
|
# apply preserves the CRS if the result is a GeoDataFrame
|
|
result = df.apply(lambda col: col, axis=0)
|
|
assert result.crs == 27700
|
|
result = df.apply(lambda row: row, axis=1)
|
|
assert result.crs == 27700
|
|
|
|
|
|
class TestSetCRS:
|
|
@pytest.mark.parametrize(
|
|
"constructor",
|
|
[
|
|
lambda geoms, crs: GeoSeries(geoms, crs=crs),
|
|
lambda geoms, crs: GeoDataFrame(geometry=geoms, crs=crs),
|
|
],
|
|
ids=["geoseries", "geodataframe"],
|
|
)
|
|
def test_set_crs(self, constructor):
|
|
naive = constructor([Point(0, 0), Point(1, 1)], crs=None)
|
|
assert naive.crs is None
|
|
|
|
# by default returns a copy
|
|
result = naive.set_crs(crs="EPSG:4326")
|
|
assert result.crs == "EPSG:4326"
|
|
assert naive.crs is None
|
|
|
|
result = naive.set_crs(epsg=4326)
|
|
assert result.crs == "EPSG:4326"
|
|
assert naive.crs is None
|
|
|
|
# with inplace=True
|
|
result = naive.set_crs(crs="EPSG:4326", inplace=True)
|
|
assert result is naive
|
|
assert result.crs == naive.crs == "EPSG:4326"
|
|
|
|
# raise for non-naive when crs would be overridden
|
|
non_naive = constructor([Point(0, 0), Point(1, 1)], crs="EPSG:4326")
|
|
assert non_naive.crs == "EPSG:4326"
|
|
with pytest.raises(ValueError, match="already has a CRS"):
|
|
non_naive.set_crs("EPSG:3857")
|
|
|
|
# allow for equal crs
|
|
result = non_naive.set_crs("EPSG:4326")
|
|
assert result.crs == "EPSG:4326"
|
|
|
|
# replace with allow_override=True
|
|
result = non_naive.set_crs("EPSG:3857", allow_override=True)
|
|
assert non_naive.crs == "EPSG:4326"
|
|
assert result.crs == "EPSG:3857"
|
|
|
|
result = non_naive.set_crs("EPSG:3857", allow_override=True, inplace=True)
|
|
assert non_naive.crs == "EPSG:3857"
|
|
assert result.crs == "EPSG:3857"
|
|
|
|
# raise error when no crs is passed
|
|
with pytest.raises(ValueError):
|
|
naive.set_crs(crs=None, epsg=None)
|