250 lines
9.4 KiB
Python
250 lines
9.4 KiB
Python
import numpy as np
|
|
import pytest
|
|
|
|
import shapely
|
|
from shapely import (
|
|
Geometry,
|
|
LineString,
|
|
MultiPolygon,
|
|
Polygon,
|
|
)
|
|
from shapely.errors import UnsupportedGEOSVersionError
|
|
from shapely.testing import assert_geometries_equal
|
|
from shapely.tests.common import (
|
|
all_types,
|
|
all_types_z,
|
|
empty_line_string,
|
|
)
|
|
|
|
|
|
@pytest.mark.skipif(shapely.geos_version < (3, 12, 0), reason="requires >= 3.12")
|
|
@pytest.mark.parametrize("geometry", all_types + all_types_z)
|
|
def test_coverage_is_valid(geometry):
|
|
actual = shapely.coverage_is_valid([geometry])
|
|
assert actual.ndim == 0
|
|
assert actual.dtype == np.bool_
|
|
assert actual.item() is True
|
|
|
|
actual = shapely.coverage_invalid_edges([geometry])
|
|
expected = np.array([empty_line_string], dtype=object)
|
|
assert_geometries_equal(actual, expected)
|
|
|
|
|
|
@pytest.mark.skipif(shapely.geos_version < (3, 12, 0), reason="requires >= 3.12")
|
|
def test_coverage_is_valid_non_polygonal():
|
|
# non-polygonal geometries are ignored to validate the coverage
|
|
# (e.g. even if you have crossing linestrings)
|
|
geoms = [
|
|
LineString([(0, 0), (1, 1)]),
|
|
LineString([(1, 0), (0, 1)]),
|
|
Polygon([(0, 0), (0, 1), (1, 1), (1, 0), (0, 0)]),
|
|
]
|
|
assert shapely.coverage_is_valid(geoms)
|
|
assert (shapely.coverage_invalid_edges(geoms) == empty_line_string).all()
|
|
|
|
|
|
@pytest.mark.skipif(shapely.geos_version < (3, 12, 0), reason="requires >= 3.12")
|
|
def test_coverage_is_valid_polygonal():
|
|
# adjacent triangles
|
|
poly1 = Polygon([(0, 0), (1, 1), (1, 0), (0, 0)])
|
|
poly2 = Polygon([(0, 0), (1, 1), (0, 1), (0, 0)])
|
|
assert shapely.coverage_is_valid([poly1, poly2])
|
|
assert shapely.is_empty(shapely.coverage_invalid_edges([poly1, poly2])).all()
|
|
|
|
# shared egde but without identical vertices
|
|
poly2b = Polygon([(0, 0), (0.5, 0.5), (1, 1), (0, 1), (0, 0)])
|
|
assert not shapely.coverage_is_valid([poly1, poly2b])
|
|
result = shapely.coverage_invalid_edges([poly1, poly2b])
|
|
expected = [LineString([(0, 0), (1, 1)]), LineString([(0, 0), (0.5, 0.5), (1, 1)])]
|
|
assert_geometries_equal(result, expected)
|
|
|
|
# overlap
|
|
poly3 = Polygon([(0, 0), (1, 0), (1, 1), (0, 1), (0, 0)])
|
|
assert not shapely.coverage_is_valid([poly1, poly3])
|
|
result = shapely.coverage_invalid_edges([poly1, poly3])
|
|
assert not shapely.is_empty(result).any()
|
|
|
|
|
|
@pytest.mark.skipif(shapely.geos_version < (3, 12, 0), reason="requires >= 3.12")
|
|
def test_coverage_is_valid_gap_width():
|
|
# shared edge of boxes with multiple vertices
|
|
poly1 = shapely.from_wkt("POLYGON ((0 10, 10 10, 10 7, 10 3, 10 0, 0 0, 0 10))")
|
|
poly2 = shapely.from_wkt("POLYGON ((10 10, 20 10, 20 0, 10 0, 10 3, 10 7, 10 10))")
|
|
|
|
# extra vertex in middle of shared edge
|
|
poly2_extra = shapely.from_wkt(
|
|
"POLYGON ((10 10, 20 10, 20 0, 10 0, 10 3, 10 5, 10 7, 10 10))"
|
|
)
|
|
# extra vertex shifted -> gap of max 1 wide
|
|
poly2_shift = shapely.from_wkt(
|
|
"POLYGON ((10 10, 20 10, 20 0, 10 0, 10 3, 11 5, 10 7, 10 10))"
|
|
)
|
|
|
|
# valid coverage -> gap_width value does not matter
|
|
assert shapely.coverage_is_valid([poly1, poly2], gap_width=0.0)
|
|
assert shapely.coverage_is_valid([poly1, poly2], gap_width=2.0)
|
|
|
|
result = shapely.coverage_invalid_edges([poly1, poly2], gap_width=0.0)
|
|
assert_geometries_equal(result, [empty_line_string] * 2)
|
|
result = shapely.coverage_invalid_edges([poly1, poly2], gap_width=2.0)
|
|
assert_geometries_equal(result, [empty_line_string] * 2)
|
|
|
|
# invalid coverage -> gap_width value does not matter
|
|
assert not shapely.coverage_is_valid([poly1, poly2_extra], gap_width=0.0)
|
|
assert not shapely.coverage_is_valid([poly1, poly2_extra], gap_width=2.0)
|
|
|
|
expected = shapely.from_wkt(
|
|
["LINESTRING (10 7, 10 3)", "LINESTRING (10 3, 10 5, 10 7)"]
|
|
)
|
|
result = shapely.coverage_invalid_edges([poly1, poly2_extra], gap_width=0.0)
|
|
assert_geometries_equal(result, expected)
|
|
result = shapely.coverage_invalid_edges([poly1, poly2_extra], gap_width=2.0)
|
|
assert_geometries_equal(result, expected)
|
|
|
|
# coverage with gap of 1 unit wide
|
|
assert shapely.coverage_is_valid([poly1, poly2_shift], gap_width=0.0)
|
|
assert shapely.coverage_is_valid([poly1, poly2_shift], gap_width=0.5)
|
|
assert not shapely.coverage_is_valid([poly1, poly2_shift], gap_width=1.0)
|
|
assert not shapely.coverage_is_valid([poly1, poly2_shift], gap_width=1.5)
|
|
# TODO why this behaviour?
|
|
assert shapely.coverage_is_valid([poly1, poly2_shift], gap_width=2.0)
|
|
|
|
assert_geometries_equal(
|
|
shapely.coverage_invalid_edges([poly1, poly2_shift], gap_width=0.0),
|
|
[empty_line_string] * 2,
|
|
)
|
|
assert_geometries_equal(
|
|
shapely.coverage_invalid_edges([poly1, poly2_shift], gap_width=1.0),
|
|
shapely.from_wkt(["LINESTRING (10 7, 10 3)", "LINESTRING (10 3, 11 5, 10 7)"]),
|
|
)
|
|
|
|
|
|
@pytest.mark.skipif(shapely.geos_version < (3, 12, 0), reason="requires >= 3.12")
|
|
def test_coverage_invalid_edges_gufunc():
|
|
poly1 = shapely.from_wkt("POLYGON ((0 10, 10 10, 10 7, 10 3, 10 0, 0 0, 0 10))")
|
|
poly2 = shapely.from_wkt("POLYGON ((10 10, 20 10, 20 0, 10 0, 10 3, 10 7, 10 10))")
|
|
poly2_extra = shapely.from_wkt(
|
|
"POLYGON ((10 10, 20 10, 20 0, 10 0, 10 3, 10 5, 10 7, 10 10))"
|
|
)
|
|
poly3 = shapely.from_wkt("POLYGON ((20 10, 30 10, 30 7, 30 3, 30 0, 20 0, 20 10))")
|
|
|
|
arr = np.array([[poly1, poly2, poly3], [poly1, poly2_extra, poly3]])
|
|
result = shapely.lib.coverage_invalid_edges(arr, 0.0)
|
|
expected = shapely.from_wkt(
|
|
[
|
|
["LINESTRING EMPTY"] * 3,
|
|
[
|
|
"LINESTRING (10 7, 10 3)",
|
|
"LINESTRING (10 3, 10 5, 10 7)",
|
|
"LINESTRING EMPTY",
|
|
],
|
|
]
|
|
)
|
|
assert_geometries_equal(result, expected)
|
|
|
|
arr2 = np.array(arr, order="F")
|
|
result = shapely.lib.coverage_invalid_edges(arr2, 0.0)
|
|
assert_geometries_equal(result, expected)
|
|
|
|
|
|
@pytest.mark.skipif(shapely.geos_version < (3, 12, 0), reason="GEOS < 3.12")
|
|
@pytest.mark.parametrize("geometry", all_types)
|
|
def test_coverage_simplify_scalars(geometry):
|
|
if geometry.geom_type in ("Polygon", "MultiPolygon"):
|
|
actual = shapely.coverage_simplify(geometry, 0.0)
|
|
assert isinstance(actual, Geometry)
|
|
assert shapely.get_type_id(actual) == shapely.get_type_id(geometry)
|
|
assert actual.equals(geometry)
|
|
else:
|
|
with pytest.raises(TypeError, match="incorrect geometry type"):
|
|
shapely.coverage_simplify(geometry, 0.0)
|
|
|
|
|
|
@pytest.mark.skipif(shapely.geos_version < (3, 12, 0), reason="GEOS < 3.12")
|
|
@pytest.mark.parametrize("geometry", all_types)
|
|
def test_coverage_simplify_geom_types(geometry):
|
|
if geometry.geom_type in ("Polygon", "MultiPolygon"):
|
|
actual = shapely.coverage_simplify([geometry, geometry], 0.0)
|
|
assert isinstance(actual, np.ndarray)
|
|
assert actual.shape == (2,)
|
|
assert (shapely.get_type_id(actual) == shapely.get_type_id(geometry)).all()
|
|
else:
|
|
with pytest.raises(TypeError, match="incorrect geometry type"):
|
|
shapely.coverage_simplify([geometry, geometry], 0.0)
|
|
|
|
|
|
@pytest.mark.skipif(shapely.geos_version < (3, 12, 0), reason="GEOS < 3.12")
|
|
def test_coverage_simplify_multipolygon():
|
|
mp = MultiPolygon(
|
|
[
|
|
Polygon([(0, 0), (0, 1), (1, 1), (1, 0), (0, 0)]),
|
|
Polygon([(2, 2), (2, 3), (3, 3), (3, 2), (2, 2)]),
|
|
]
|
|
)
|
|
actual = shapely.coverage_simplify(mp, 1)
|
|
assert actual.equals(
|
|
shapely.from_wkt(
|
|
"MULTIPOLYGON (((0 1, 1 1, 1 0, 0 1)), ((2 3, 3 3, 3 2, 2 3)))"
|
|
)
|
|
)
|
|
|
|
|
|
@pytest.mark.skipif(shapely.geos_version < (3, 12, 0), reason="GEOS < 3.12")
|
|
def test_coverage_simplify_array():
|
|
polygons = np.array(
|
|
[
|
|
shapely.Polygon([(0, 0), (20, 0), (20, 10), (10, 5), (0, 10), (0, 0)]),
|
|
shapely.Polygon([(0, 10), (10, 5), (20, 10), (20, 20), (0, 20), (0, 10)]),
|
|
]
|
|
)
|
|
low_tolerance = shapely.coverage_simplify(polygons, 1)
|
|
mid_tolerance = shapely.coverage_simplify(polygons, 8)
|
|
high_tolerance = shapely.coverage_simplify(polygons, 10)
|
|
|
|
assert shapely.equals(low_tolerance, shapely.normalize(polygons)).all()
|
|
assert shapely.equals(
|
|
mid_tolerance,
|
|
shapely.from_wkt(
|
|
[
|
|
"POLYGON ((20 10, 0 10, 0 0, 20 0, 20 10))",
|
|
"POLYGON ((20 10, 0 10, 0 20, 20 20, 20 10))",
|
|
]
|
|
),
|
|
).all()
|
|
assert shapely.equals(
|
|
high_tolerance,
|
|
shapely.from_wkt(
|
|
[
|
|
"POLYGON ((20 10, 0 10, 20 0, 20 10))",
|
|
"POLYGON ((20 10, 0 10, 0 20, 20 10))",
|
|
]
|
|
),
|
|
).all()
|
|
|
|
no_boundary = shapely.coverage_simplify(polygons, 10, simplify_boundary=False)
|
|
assert shapely.equals(
|
|
no_boundary,
|
|
shapely.from_wkt(
|
|
[
|
|
"POLYGON ((20 10, 0 10, 0 0, 20 0, 20 10))",
|
|
"POLYGON ((20 10, 0 10, 0 20, 20 20, 20 10))",
|
|
]
|
|
),
|
|
).all()
|
|
|
|
|
|
@pytest.mark.skipif(shapely.geos_version >= (3, 12, 0), reason="requires >= 3.12")
|
|
def test_coverage_unsupported_geos():
|
|
geoms = [
|
|
Polygon([(0, 0), (1, 1), (1, 0), (0, 0)]),
|
|
Polygon([(0, 0), (1, 1), (0, 1), (0, 0)]),
|
|
]
|
|
with pytest.raises(UnsupportedGEOSVersionError):
|
|
shapely.coverage_is_valid(geoms)
|
|
|
|
with pytest.raises(UnsupportedGEOSVersionError):
|
|
shapely.coverage_invalid_edges(geoms)
|
|
|
|
with pytest.raises(UnsupportedGEOSVersionError):
|
|
shapely.coverage_simplify(geoms, 1.0)
|