478 lines
17 KiB
Python
478 lines
17 KiB
Python
import numpy as np
|
|
import pytest
|
|
|
|
import shapely
|
|
from shapely import Geometry, GeometryCollection, Polygon
|
|
from shapely.testing import assert_geometries_equal
|
|
from shapely.tests.common import all_types, empty, ignore_invalid, point, polygon
|
|
|
|
pytestmark = pytest.mark.filterwarnings(
|
|
"ignore:The symmetric_difference_all function:DeprecationWarning"
|
|
)
|
|
|
|
# fixed-precision operations raise GEOS exceptions on mixed dimension geometry
|
|
# collections
|
|
all_single_types = np.array(all_types)[
|
|
~shapely.is_empty(all_types)
|
|
& (shapely.get_type_id(all_types) != shapely.GeometryType.GEOMETRYCOLLECTION)
|
|
]
|
|
|
|
SET_OPERATIONS = (
|
|
shapely.difference,
|
|
shapely.intersection,
|
|
shapely.symmetric_difference,
|
|
shapely.union,
|
|
# shapely.coverage_union is tested separately
|
|
)
|
|
|
|
REDUCE_SET_OPERATIONS = (
|
|
(shapely.intersection_all, shapely.intersection),
|
|
(shapely.symmetric_difference_all, shapely.symmetric_difference),
|
|
(shapely.union_all, shapely.union),
|
|
# shapely.coverage_union_all, shapely.coverage_union) is tested separately
|
|
)
|
|
|
|
# operations that support fixed precision
|
|
REDUCE_SET_OPERATIONS_PREC = ((shapely.union_all, shapely.union),)
|
|
|
|
if shapely.geos_version >= (3, 12, 0):
|
|
SET_OPERATIONS += (shapely.disjoint_subset_union,)
|
|
REDUCE_SET_OPERATIONS += (
|
|
(shapely.disjoint_subset_union_all, shapely.disjoint_subset_union),
|
|
)
|
|
|
|
reduce_test_data = [
|
|
shapely.box(0, 0, 5, 5),
|
|
shapely.box(2, 2, 7, 7),
|
|
shapely.box(4, 4, 9, 9),
|
|
shapely.box(5, 5, 10, 10),
|
|
]
|
|
|
|
non_polygon_types = np.array(all_types)[
|
|
~shapely.is_empty(all_types) & (shapely.get_dimensions(all_types) != 2)
|
|
]
|
|
|
|
|
|
@pytest.mark.parametrize("a", all_types)
|
|
@pytest.mark.parametrize("func", SET_OPERATIONS)
|
|
def test_set_operation_array(a, func):
|
|
if (
|
|
func is shapely.difference
|
|
and a.geom_type == "GeometryCollection"
|
|
and shapely.get_num_geometries(a) == 2
|
|
and shapely.geos_version == (3, 9, 5)
|
|
):
|
|
pytest.xfail("GEOS 3.9.5 crashes with mixed collection")
|
|
actual = func(a, point)
|
|
assert isinstance(actual, Geometry)
|
|
|
|
actual = func([a, a], point)
|
|
assert actual.shape == (2,)
|
|
assert isinstance(actual[0], Geometry)
|
|
|
|
|
|
@pytest.mark.parametrize("func", SET_OPERATIONS)
|
|
def test_set_operation_prec_nonscalar_grid_size(func):
|
|
if func is shapely.disjoint_subset_union:
|
|
pytest.skip("disjoint_subset_union does not support grid_size")
|
|
with pytest.raises(
|
|
ValueError, match="grid_size parameter only accepts scalar values"
|
|
):
|
|
func(point, point, grid_size=[1])
|
|
|
|
|
|
@pytest.mark.parametrize("a", all_single_types)
|
|
@pytest.mark.parametrize("func", SET_OPERATIONS)
|
|
@pytest.mark.parametrize("grid_size", [0, 1, 2])
|
|
def test_set_operation_prec_array(a, func, grid_size):
|
|
if func is shapely.disjoint_subset_union:
|
|
pytest.skip("disjoint_subset_union does not support grid_size")
|
|
actual = func([a, a], point, grid_size=grid_size)
|
|
assert actual.shape == (2,)
|
|
assert isinstance(actual[0], Geometry)
|
|
|
|
# results should match the operation when the precision is previously set
|
|
# to same grid_size
|
|
b = shapely.set_precision(a, grid_size=grid_size)
|
|
point2 = shapely.set_precision(point, grid_size=grid_size)
|
|
expected = func([b, b], point2)
|
|
|
|
assert shapely.equals(shapely.normalize(actual), shapely.normalize(expected)).all()
|
|
|
|
|
|
@pytest.mark.parametrize("n", range(1, 5))
|
|
@pytest.mark.parametrize("func, related_func", REDUCE_SET_OPERATIONS)
|
|
def test_set_operation_reduce_1dim(n, func, related_func):
|
|
actual = func(reduce_test_data[:n])
|
|
# perform the reduction in a python loop and compare
|
|
expected = reduce_test_data[0]
|
|
for i in range(1, n):
|
|
expected = related_func(expected, reduce_test_data[i])
|
|
assert shapely.equals(actual, expected)
|
|
|
|
|
|
@pytest.mark.parametrize("func, related_func", REDUCE_SET_OPERATIONS)
|
|
def test_set_operation_reduce_single_geom(func, related_func):
|
|
geom = shapely.Point(1, 1)
|
|
actual = func([geom, None, None])
|
|
assert shapely.equals(actual, geom)
|
|
|
|
|
|
@pytest.mark.parametrize("func, related_func", REDUCE_SET_OPERATIONS)
|
|
def test_set_operation_reduce_axis(func, related_func):
|
|
data = [[point] * 2] * 3 # shape = (3, 2)
|
|
actual = func(data, axis=None) # default
|
|
assert isinstance(actual, Geometry) # scalar output
|
|
actual = func(data, axis=0)
|
|
assert actual.shape == (2,)
|
|
actual = func(data, axis=1)
|
|
assert actual.shape == (3,)
|
|
actual = func(data, axis=-1)
|
|
assert actual.shape == (3,)
|
|
|
|
|
|
@pytest.mark.parametrize("func, related_func", REDUCE_SET_OPERATIONS)
|
|
def test_set_operation_reduce_empty(func, related_func):
|
|
assert func(np.empty((0,), dtype=object)) == empty
|
|
arr_empty_2D = np.empty((0, 2), dtype=object)
|
|
assert func(arr_empty_2D) == empty
|
|
assert func(arr_empty_2D, axis=0).tolist() == [empty] * 2
|
|
assert func(arr_empty_2D, axis=1).tolist() == []
|
|
|
|
|
|
@pytest.mark.parametrize("none_position", range(3))
|
|
@pytest.mark.parametrize("func, related_func", REDUCE_SET_OPERATIONS)
|
|
def test_set_operation_reduce_one_none(func, related_func, none_position):
|
|
# API change: before, intersection_all and symmetric_difference_all returned
|
|
# None if any input geometry was None.
|
|
# The new behaviour is to ignore None values.
|
|
test_data = reduce_test_data[:2]
|
|
test_data.insert(none_position, None)
|
|
actual = func(test_data)
|
|
expected = related_func(reduce_test_data[0], reduce_test_data[1])
|
|
assert_geometries_equal(actual, expected)
|
|
|
|
|
|
@pytest.mark.parametrize("none_position", range(3))
|
|
@pytest.mark.parametrize("func, related_func", REDUCE_SET_OPERATIONS)
|
|
def test_set_operation_reduce_two_none(func, related_func, none_position):
|
|
test_data = reduce_test_data[:2]
|
|
test_data.insert(none_position, None)
|
|
test_data.insert(none_position, None)
|
|
actual = func(test_data)
|
|
expected = related_func(reduce_test_data[0], reduce_test_data[1])
|
|
assert_geometries_equal(actual, expected)
|
|
|
|
|
|
@pytest.mark.parametrize("func, related_func", REDUCE_SET_OPERATIONS)
|
|
def test_set_operation_reduce_some_none_len2(func, related_func):
|
|
# in a previous implementation, this would take a different code path
|
|
# and return wrong result
|
|
assert func([empty, None]) == empty
|
|
|
|
|
|
@pytest.mark.parametrize("n", range(1, 3))
|
|
@pytest.mark.parametrize("func, related_func", REDUCE_SET_OPERATIONS)
|
|
def test_set_operation_reduce_all_none(n, func, related_func):
|
|
assert_geometries_equal(func([None] * n), GeometryCollection([]))
|
|
|
|
|
|
@pytest.mark.parametrize("n", range(1, 3))
|
|
@pytest.mark.parametrize("func, related_func", REDUCE_SET_OPERATIONS)
|
|
def test_set_operation_reduce_all_none_arr(n, func, related_func):
|
|
assert func([[None] * n] * 2, axis=1).tolist() == [empty, empty]
|
|
assert func([[None] * 2] * n, axis=0).tolist() == [empty, empty]
|
|
|
|
|
|
@pytest.mark.parametrize("func, related_func", REDUCE_SET_OPERATIONS_PREC)
|
|
def test_set_operation_prec_reduce_nonscalar_grid_size(func, related_func):
|
|
with pytest.raises(
|
|
ValueError, match="grid_size parameter only accepts scalar values"
|
|
):
|
|
func([point, point], grid_size=[1])
|
|
|
|
|
|
@pytest.mark.parametrize("func, related_func", REDUCE_SET_OPERATIONS_PREC)
|
|
def test_set_operation_prec_reduce_grid_size_nan(func, related_func):
|
|
actual = func([point, point], grid_size=np.nan)
|
|
assert actual is None
|
|
|
|
|
|
@pytest.mark.parametrize("n", range(1, 5))
|
|
@pytest.mark.parametrize("func, related_func", REDUCE_SET_OPERATIONS_PREC)
|
|
@pytest.mark.parametrize("grid_size", [0, 1])
|
|
def test_set_operation_prec_reduce_1dim(n, func, related_func, grid_size):
|
|
actual = func(reduce_test_data[:n], grid_size=grid_size)
|
|
# perform the reduction in a python loop and compare
|
|
expected = reduce_test_data[0]
|
|
for i in range(1, n):
|
|
expected = related_func(expected, reduce_test_data[i], grid_size=grid_size)
|
|
|
|
assert shapely.equals(actual, expected)
|
|
|
|
|
|
@pytest.mark.parametrize("func, related_func", REDUCE_SET_OPERATIONS_PREC)
|
|
def test_set_operation_prec_reduce_axis(func, related_func):
|
|
data = [[point] * 2] * 3 # shape = (3, 2)
|
|
actual = func(data, grid_size=1, axis=None) # default
|
|
assert isinstance(actual, Geometry) # scalar output
|
|
actual = func(data, grid_size=1, axis=0)
|
|
assert actual.shape == (2,)
|
|
actual = func(data, grid_size=1, axis=1)
|
|
assert actual.shape == (3,)
|
|
actual = func(data, grid_size=1, axis=-1)
|
|
assert actual.shape == (3,)
|
|
|
|
|
|
@pytest.mark.parametrize("none_position", range(3))
|
|
@pytest.mark.parametrize("func, related_func", REDUCE_SET_OPERATIONS_PREC)
|
|
def test_set_operation_prec_reduce_one_none(func, related_func, none_position):
|
|
test_data = reduce_test_data[:2]
|
|
test_data.insert(none_position, None)
|
|
actual = func(test_data, grid_size=1)
|
|
expected = related_func(reduce_test_data[0], reduce_test_data[1], grid_size=1)
|
|
assert_geometries_equal(actual, expected)
|
|
|
|
|
|
@pytest.mark.parametrize("none_position", range(3))
|
|
@pytest.mark.parametrize("func, related_func", REDUCE_SET_OPERATIONS_PREC)
|
|
def test_set_operation_prec_reduce_two_none(func, related_func, none_position):
|
|
test_data = reduce_test_data[:2]
|
|
test_data.insert(none_position, None)
|
|
test_data.insert(none_position, None)
|
|
actual = func(test_data, grid_size=1)
|
|
expected = related_func(reduce_test_data[0], reduce_test_data[1], grid_size=1)
|
|
assert_geometries_equal(actual, expected)
|
|
|
|
|
|
@pytest.mark.parametrize("n", range(1, 3))
|
|
@pytest.mark.parametrize("func, related_func", REDUCE_SET_OPERATIONS_PREC)
|
|
def test_set_operation_prec_reduce_all_none(n, func, related_func):
|
|
assert_geometries_equal(func([None] * n, grid_size=1), GeometryCollection([]))
|
|
|
|
|
|
@pytest.mark.parametrize("n", range(1, 4))
|
|
def test_coverage_union_reduce_1dim(n):
|
|
"""
|
|
This is tested separately from other set operations as it expects only
|
|
non-overlapping polygons
|
|
"""
|
|
test_data = [
|
|
shapely.box(0, 0, 1, 1),
|
|
shapely.box(1, 0, 2, 1),
|
|
shapely.box(2, 0, 3, 1),
|
|
]
|
|
actual = shapely.coverage_union_all(test_data[:n])
|
|
# perform the reduction in a python loop and compare
|
|
expected = test_data[0]
|
|
for i in range(1, n):
|
|
expected = shapely.coverage_union(expected, test_data[i])
|
|
assert_geometries_equal(actual, expected, normalize=True)
|
|
|
|
|
|
def test_coverage_union_reduce_axis():
|
|
# shape = (3, 2), all polygons - none of them overlapping
|
|
data = [[shapely.box(i, j, i + 1, j + 1) for i in range(2)] for j in range(3)]
|
|
actual = shapely.coverage_union_all(data, axis=None) # default
|
|
assert isinstance(actual, Geometry)
|
|
actual = shapely.coverage_union_all(data, axis=0)
|
|
assert actual.shape == (2,)
|
|
actual = shapely.coverage_union_all(data, axis=1)
|
|
assert actual.shape == (3,)
|
|
actual = shapely.coverage_union_all(data, axis=-1)
|
|
assert actual.shape == (3,)
|
|
|
|
|
|
def test_coverage_union_overlapping_inputs():
|
|
polygon = Polygon([(1, 1), (1, 0), (0, 0), (0, 1), (1, 1)])
|
|
other = Polygon([(1, 0), (0.9, 1), (2, 1), (2, 0), (1, 0)])
|
|
|
|
if shapely.geos_version >= (3, 12, 0):
|
|
# Return mostly unchanged output
|
|
result = shapely.coverage_union(polygon, other)
|
|
expected = shapely.multipolygons([polygon, other])
|
|
assert_geometries_equal(result, expected, normalize=True)
|
|
else:
|
|
# Overlapping polygons raise an error
|
|
with pytest.raises(
|
|
shapely.GEOSException,
|
|
match="CoverageUnion cannot process incorrectly noded inputs.",
|
|
):
|
|
shapely.coverage_union(polygon, other)
|
|
|
|
|
|
@pytest.mark.parametrize(
|
|
"geom_1, geom_2",
|
|
# All possible polygon, non_polygon combinations
|
|
[[polygon, non_polygon] for non_polygon in non_polygon_types]
|
|
# All possible non_polygon, non_polygon combinations
|
|
+ [
|
|
[non_polygon_1, non_polygon_2]
|
|
for non_polygon_1 in non_polygon_types
|
|
for non_polygon_2 in non_polygon_types
|
|
],
|
|
)
|
|
def test_coverage_union_non_polygon_inputs(geom_1, geom_2):
|
|
if shapely.geos_version >= (3, 12, 0):
|
|
|
|
def effective_geom_types(geom):
|
|
if hasattr(geom, "geoms") and not geom.is_empty:
|
|
gts = set()
|
|
for part in geom.geoms:
|
|
gts |= effective_geom_types(part)
|
|
return gts
|
|
return {geom.geom_type.lstrip("Multi").replace("LinearRing", "LineString")}
|
|
|
|
geom_types_1 = effective_geom_types(geom_1)
|
|
geom_types_2 = effective_geom_types(geom_2)
|
|
if len(geom_types_1) == 1 and geom_types_1 == geom_types_2:
|
|
with ignore_invalid():
|
|
# these show "invalid value encountered in coverage_union"
|
|
result = shapely.coverage_union(geom_1, geom_2)
|
|
assert geom_types_1 == effective_geom_types(result)
|
|
else:
|
|
with pytest.raises(
|
|
shapely.GEOSException, match="Overlay input is mixed-dimension"
|
|
):
|
|
shapely.coverage_union(geom_1, geom_2)
|
|
else:
|
|
# Non polygon geometries raise an error
|
|
with pytest.raises(
|
|
shapely.GEOSException, match="Unhandled geometry type in CoverageUnion."
|
|
):
|
|
shapely.coverage_union(geom_1, geom_2)
|
|
|
|
|
|
@pytest.mark.parametrize(
|
|
"geom,grid_size,expected",
|
|
[
|
|
# floating point precision, expect no change
|
|
(
|
|
[shapely.box(0.1, 0.1, 5, 5), shapely.box(0, 0.2, 5.1, 10)],
|
|
0,
|
|
Polygon(
|
|
(
|
|
(0, 0.2),
|
|
(0, 10),
|
|
(5.1, 10),
|
|
(5.1, 0.2),
|
|
(5, 0.2),
|
|
(5, 0.1),
|
|
(0.1, 0.1),
|
|
(0.1, 0.2),
|
|
(0, 0.2),
|
|
)
|
|
),
|
|
),
|
|
# grid_size is at effective precision, expect no change
|
|
(
|
|
[shapely.box(0.1, 0.1, 5, 5), shapely.box(0, 0.2, 5.1, 10)],
|
|
0.1,
|
|
Polygon(
|
|
(
|
|
(0, 0.2),
|
|
(0, 10),
|
|
(5.1, 10),
|
|
(5.1, 0.2),
|
|
(5, 0.2),
|
|
(5, 0.1),
|
|
(0.1, 0.1),
|
|
(0.1, 0.2),
|
|
(0, 0.2),
|
|
)
|
|
),
|
|
),
|
|
# grid_size forces rounding to nearest integer
|
|
(
|
|
[shapely.box(0.1, 0.1, 5, 5), shapely.box(0, 0.2, 5.1, 10)],
|
|
1,
|
|
Polygon([(0, 5), (0, 10), (5, 10), (5, 5), (5, 0), (0, 0), (0, 5)]),
|
|
),
|
|
# grid_size much larger than effective precision causes rounding to nearest
|
|
# multiple of 10
|
|
(
|
|
[shapely.box(0.1, 0.1, 5, 5), shapely.box(0, 0.2, 5.1, 10)],
|
|
10,
|
|
Polygon([(0, 10), (10, 10), (10, 0), (0, 0), (0, 10)]),
|
|
),
|
|
# grid_size is so large that polygons collapse to empty
|
|
(
|
|
[shapely.box(0.1, 0.1, 5, 5), shapely.box(0, 0.2, 5.1, 10)],
|
|
100,
|
|
Polygon(),
|
|
),
|
|
],
|
|
)
|
|
def test_union_all_prec(geom, grid_size, expected):
|
|
actual = shapely.union_all(geom, grid_size=grid_size)
|
|
assert shapely.equals(actual, expected)
|
|
|
|
|
|
def test_uary_union_alias():
|
|
geoms = [shapely.box(0.1, 0.1, 5, 5), shapely.box(0, 0.2, 5.1, 10)]
|
|
actual = shapely.unary_union(geoms, grid_size=1)
|
|
expected = shapely.union_all(geoms, grid_size=1)
|
|
assert shapely.equals(actual, expected)
|
|
|
|
|
|
def test_difference_deprecate_positional():
|
|
with pytest.deprecated_call(
|
|
match="positional argument `grid_size` for `difference` is deprecated"
|
|
):
|
|
shapely.difference(point, point, None)
|
|
|
|
|
|
def test_intersection_deprecate_positional():
|
|
with pytest.deprecated_call(
|
|
match="positional argument `grid_size` for `intersection` is deprecated"
|
|
):
|
|
shapely.intersection(point, point, None)
|
|
|
|
|
|
def test_intersection_all_deprecate_positional():
|
|
with pytest.deprecated_call(
|
|
match="positional argument `axis` for `intersection_all` is deprecated"
|
|
):
|
|
shapely.intersection_all([point, point], None)
|
|
|
|
|
|
def test_symmetric_difference_deprecate_positional():
|
|
with pytest.deprecated_call(
|
|
match="positional argument `grid_size` for `symmetric_difference` is deprecated"
|
|
):
|
|
shapely.symmetric_difference(point, point, None)
|
|
|
|
|
|
def test_symmetric_difference_all_deprecate_positional():
|
|
with pytest.deprecated_call(
|
|
match="positional argument `axis` for `symmetric_difference_all` is deprecated"
|
|
):
|
|
shapely.symmetric_difference_all([point, point], None)
|
|
|
|
|
|
def test_union_deprecate_positional():
|
|
with pytest.deprecated_call(
|
|
match="positional argument `grid_size` for `union` is deprecated"
|
|
):
|
|
shapely.union(point, point, None)
|
|
|
|
|
|
def test_union_all_deprecate_positional():
|
|
with pytest.deprecated_call(
|
|
match="positional argument `grid_size` for `union_all` is deprecated"
|
|
):
|
|
shapely.union_all([point, point], None)
|
|
with pytest.deprecated_call(
|
|
match="positional arguments `grid_size` and `axis` for `union_all` "
|
|
"are deprecated"
|
|
):
|
|
shapely.union_all([point, point], None, None)
|
|
|
|
|
|
def test_coverage_union_all_deprecate_positional():
|
|
data = [shapely.box(0, 0, 1, 1), shapely.box(1, 0, 2, 1)]
|
|
with pytest.deprecated_call(
|
|
match="positional argument `axis` for `coverage_union_all` is deprecated"
|
|
):
|
|
shapely.coverage_union_all(data, None)
|