This is an automated email from the ASF dual-hosted git repository.
jiayu pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/sedona.git
The following commit(s) were added to refs/heads/master by this push:
new 433891285e [GH-2110] Geopandas.GeoSeries: Implement simplify and snap
(#2111)
433891285e is described below
commit 433891285efe5f2dfbf319ffc73e67f50fe4c8f9
Author: Peter Nguyen <[email protected]>
AuthorDate: Wed Jul 23 16:43:03 2025 -0700
[GH-2110] Geopandas.GeoSeries: Implement simplify and snap (#2111)
* Implement simplify and snap
* Skip test_snap for versions < 1.0.0
* Set fail-fast to false temporarily for debugging version issues
* Modify test to avoid invalid_geometry
* Add is_valid check in assert_geometry_almost_equal
* Fix after merging in dataframe api code
* empty commit to retrigger ci
* Clean up and simplify match series tests and add LinearRing tests
* Apply suggestions from code review
Co-authored-by: Copilot <[email protected]>
* Use minimum pass rate instead of num_passed in test_snap
Co-authored-by: Copilot <[email protected]>
* Fix check_sgpd_equals_gpd after copilot change
* Fix after the merge
* Skip linearring test in test_simplify
* empty commit
---------
Co-authored-by: Copilot <[email protected]>
---
python/sedona/geopandas/geoseries.py | 183 +++++++++++++++++++++
python/sedona/spark/sql/st_functions.py | 4 +-
python/tests/geopandas/test_geopandas_base.py | 10 +-
python/tests/geopandas/test_geoseries.py | 78 +++++++++
.../tests/geopandas/test_match_geopandas_series.py | 34 ++++
python/tests/test_base.py | 9 +-
6 files changed, 311 insertions(+), 7 deletions(-)
diff --git a/python/sedona/geopandas/geoseries.py
b/python/sedona/geopandas/geoseries.py
index c4bbd8e51e..f1cb7a0592 100644
--- a/python/sedona/geopandas/geoseries.py
+++ b/python/sedona/geopandas/geoseries.py
@@ -2933,6 +2933,122 @@ class GeoSeries(GeoFrame, pspd.Series):
)
return result
+ def snap(self, other, tolerance, align=None) -> "GeoSeries":
+ """Snap the vertices and segments of the geometry to vertices of the
reference.
+
+ Vertices and segments of the input geometry are snapped to vertices of
the
+ reference geometry, returning a new geometry; the input geometries are
not
+ modified. The result geometry is the input geometry with the vertices
and
+ segments snapped. If no snapping occurs then the input geometry is
returned
+ unchanged. The tolerance is used to control where snapping is
performed.
+
+ Where possible, this operation tries to avoid creating invalid
geometries;
+ however, it does not guarantee that output geometries will be valid.
It is
+ the responsibility of the caller to check for and handle invalid
geometries.
+
+ Because too much snapping can result in invalid geometries being
created,
+ heuristics are used to determine the number and location of snapped
+ vertices that are likely safe to snap. These heuristics may omit
+ some potential snaps that are otherwise within the tolerance.
+
+ Note: Sedona's result may differ slightly from geopandas's snap()
result
+ because of small differences between the underlying engines being used.
+
+ The operation works in a 1-to-1 row-wise manner:
+
+ Parameters
+ ----------
+ other : GeoSeries or geometric object
+ The Geoseries (elementwise) or geometric object to snap to.
+ tolerance : float or array like
+ Maximum distance between vertices that shall be snapped
+ align : bool | None (default None)
+ If True, automatically aligns GeoSeries based on their indices.
None defaults to True.
+ If False, the order of elements is preserved.
+
+ Returns
+ -------
+ GeoSeries
+
+ Examples
+ --------
+ >>> from sedona.geopandas import GeoSeries
+ >>> from shapely import Polygon, LineString, Point
+ >>> s = GeoSeries(
+ ... [
+ ... Point(0.5, 2.5),
+ ... LineString([(0.1, 0.1), (0.49, 0.51), (1.01, 0.89)]),
+ ... Polygon([(0, 0), (0, 10), (10, 10), (10, 0), (0, 0)]),
+ ... ],
+ ... )
+ >>> s
+ 0 POINT (0.5 2.5)
+ 1 LINESTRING (0.1 0.1, 0.49 0.51, 1.01 0.89)
+ 2 POLYGON ((0 0, 0 10, 10 10, 10 0, 0 0))
+ dtype: geometry
+
+ >>> s2 = GeoSeries(
+ ... [
+ ... Point(0, 2),
+ ... LineString([(0, 0), (0.5, 0.5), (1.0, 1.0)]),
+ ... Point(8, 10),
+ ... ],
+ ... index=range(1, 4),
+ ... )
+ >>> s2
+ 1 POINT (0 2)
+ 2 LINESTRING (0 0, 0.5 0.5, 1 1)
+ 3 POINT (8 10)
+ dtype: geometry
+
+ We can snap each geometry to a single shapely geometry:
+
+ >>> s.snap(Point(0, 2), tolerance=1)
+ 0 POINT (0 2)
+ 1 LINESTRING (0.1 0.1, 0.49 0.51, 1.01 0.89)
+ 2 POLYGON ((0 0, 0 2, 0 10, 10 10, 10 0, 0 0))
+ dtype: geometry
+
+ We can also snap two GeoSeries to each other, row by row.
+ The GeoSeries above have different indices. We can either align both
GeoSeries
+ based on index values and snap elements with the same index using
+ ``align=True`` or ignore index and snap elements based on their
matching
+ order using ``align=False``:
+
+ >>> s.snap(s2, tolerance=1, align=True)
+ 0 None
+ 1 LINESTRING (0.1 0.1, 0.49 0.51, 1.01 0.89)
+ 2 POLYGON ((0.5 0.5, 1 1, 0 10, 10 10, 10 0, 0.5...
+ 3 None
+ dtype: geometry
+
+ >>> s.snap(s2, tolerance=1, align=False)
+ 0 POINT (0 2)
+ 1 LINESTRING (0 0, 0.5 0.5, 1 1)
+ 2 POLYGON ((0 0, 0 10, 8 10, 10 10, 10 0, 0 0))
+ dtype: geometry
+ """
+ if not isinstance(tolerance, (float, int)):
+ raise NotImplementedError(
+ "Array-like values for tolerance are not supported yet."
+ )
+
+ # Both sgpd and gpd implementations simply call the snap functions
+ # in JTS and GEOs, respectively. The results often differ slightly,
but these
+ # must be differences inside of the engines themselves.
+
+ other_series, extended = self._make_series_of_val(other)
+ align = False if extended else align
+
+ spark_expr = stf.ST_Snap(F.col("L"), F.col("R"), tolerance)
+ result = self._row_wise_operation(
+ spark_expr,
+ other_series,
+ align,
+ returns_geom=True,
+ )
+ return result
+
def _row_wise_operation(
self,
spark_col: PySparkColumn,
@@ -3184,6 +3300,73 @@ class GeoSeries(GeoFrame, pspd.Series):
returns_geom=True,
)
+ def simplify(self, tolerance=None, preserve_topology=True) -> "GeoSeries":
+ """Returns a ``GeoSeries`` containing a simplified representation of
+ each geometry.
+
+ The algorithm (Douglas-Peucker) recursively splits the original line
+ into smaller parts and connects these parts' endpoints
+ by a straight line. Then, it removes all points whose distance
+ to the straight line is smaller than `tolerance`. It does not
+ move any points and it always preserves endpoints of
+ the original line or polygon.
+ See
https://shapely.readthedocs.io/en/latest/manual.html#object.simplify
+ for details
+
+ Simplifies individual geometries independently, without considering
+ the topology of a potential polygonal coverage. If you would like to
treat
+ the ``GeoSeries`` as a coverage and simplify its edges, while
preserving the
+ coverage topology, see :meth:`simplify_coverage`.
+
+ Parameters
+ ----------
+ tolerance : float
+ All parts of a simplified geometry will be no more than
+ `tolerance` distance from the original. It has the same units
+ as the coordinate reference system of the GeoSeries.
+ For example, using `tolerance=100` in a projected CRS with meters
+ as units means a distance of 100 meters in reality.
+ preserve_topology: bool (default True)
+ False uses a quicker algorithm, but may produce self-intersecting
+ or otherwise invalid geometries.
+
+ Notes
+ -----
+ Invalid geometric objects may result from simplification that does not
+ preserve topology and simplification may be sensitive to the order of
+ coordinates: two geometries differing only in order of coordinates may
be
+ simplified differently.
+
+ See also
+ --------
+ simplify_coverage : simplify geometries using coverage simplification
+
+ Examples
+ --------
+ >>> from sedona.geopandas import GeoSeries
+ >>> from shapely.geometry import Point, LineString
+ >>> s = GeoSeries(
+ ... [Point(0, 0).buffer(1), LineString([(0, 0), (1, 10), (0, 20)])]
+ ... )
+ >>> s
+ 0 POLYGON ((1 0, 0.99518 -0.09802, 0.98079 -0.19...
+ 1 LINESTRING (0 0, 1 10, 0 20)
+ dtype: geometry
+
+ >>> s.simplify(1)
+ 0 POLYGON ((0 1, 0 -1, -1 0, 0 1))
+ 1 LINESTRING (0 0, 0 20)
+ dtype: geometry
+ """
+
+ spark_expr = (
+ stf.ST_SimplifyPreserveTopology(self.spark.column, tolerance)
+ if preserve_topology
+ else stf.ST_Simplify(self.spark.column, tolerance)
+ )
+
+ return self._query_geometry_column(spark_expr)
+
def to_parquet(self, path, **kwargs):
"""
Write the GeoSeries to a GeoParquet file.
diff --git a/python/sedona/spark/sql/st_functions.py
b/python/sedona/spark/sql/st_functions.py
index 83a16811a3..db07e2be3b 100644
--- a/python/sedona/spark/sql/st_functions.py
+++ b/python/sedona/spark/sql/st_functions.py
@@ -1703,7 +1703,9 @@ def ST_SetSRID(geometry: ColumnOrName, srid:
Union[ColumnOrName, int]) -> Column
@validate_argument_types
def ST_Snap(
- input: ColumnOrName, reference: ColumnOrName, tolerance:
Union[ColumnOrName, float]
+ input: ColumnOrName,
+ reference: ColumnOrName,
+ tolerance: Union[ColumnOrName, float, int],
) -> Column:
"""Snaps input Geometry to reference Geometry controlled by distance
tolerance.
diff --git a/python/tests/geopandas/test_geopandas_base.py
b/python/tests/geopandas/test_geopandas_base.py
index d30c3dbb5f..2d2fe22c50 100644
--- a/python/tests/geopandas/test_geopandas_base.py
+++ b/python/tests/geopandas/test_geopandas_base.py
@@ -46,9 +46,13 @@ class TestGeopandasBase(TestBase):
# TODO chore: rename to check_sgpd_series_equals_gpd_series and change the
names in the geoseries tests
@classmethod
- def check_sgpd_equals_gpd(cls, actual: GeoSeries, expected: gpd.GeoSeries):
- assert isinstance(actual, GeoSeries), "result is not a sgpd.GeoSeries"
- assert isinstance(expected, gpd.GeoSeries), "expected is not a
gpd.GeoSeries"
+ def check_sgpd_equals_gpd(
+ cls,
+ actual: GeoSeries,
+ expected: gpd.GeoSeries,
+ ):
+ assert isinstance(actual, GeoSeries)
+ assert isinstance(expected, gpd.GeoSeries)
sgpd_result = actual.to_geopandas()
assert len(sgpd_result) == len(expected), "results are of different
lengths"
for a, e in zip(sgpd_result, expected):
diff --git a/python/tests/geopandas/test_geoseries.py
b/python/tests/geopandas/test_geoseries.py
index 99b0fb3039..7c663e5585 100644
--- a/python/tests/geopandas/test_geoseries.py
+++ b/python/tests/geopandas/test_geoseries.py
@@ -96,6 +96,33 @@ class TestGeoSeries(TestGeopandasBase):
assert result.count() > 0
self.check_sgpd_equals_gpd(result, expected)
+ def test_simplify(self):
+ s = GeoSeries([Point(0, 0).buffer(1), LineString([(0, 0), (1, 10), (0,
20)])])
+
+ result = s.simplify(1)
+ expected = gpd.GeoSeries(
+ [Polygon([(0, 1), (0, -1), (-1, 0), (0, 1)]), LineString([(0, 0),
(0, 20)])]
+ )
+
+ self.check_sgpd_equals_gpd(result, expected)
+
+ result = s.simplify(1.2, preserve_topology=False)
+ expected = gpd.GeoSeries([Polygon(), LineString([(0, 0), (0, 20)])])
+ self.check_sgpd_equals_gpd(result, expected)
+
+ s = GeoSeries([LineString([(0, 0), (1, 0.1), (2, 0)])])
+ result = s.simplify(0.2)
+ expected = gpd.GeoSeries([LineString([(0, 0), (2, 0)])])
+ self.check_sgpd_equals_gpd(result, expected)
+
+ result = s.simplify(0.2, preserve_topology=False)
+ expected = gpd.GeoSeries(
+ [
+ LineString([(0, 0), (2, 0)]),
+ ]
+ )
+ self.check_sgpd_equals_gpd(result, expected)
+
def test_geometry(self):
sgpd_geoseries = sgpd.GeoSeries([Point(0, 0), Point(1, 1)])
assert isinstance(sgpd_geoseries.geometry, sgpd.GeoSeries)
@@ -1353,6 +1380,57 @@ e": "Feature", "properties": {}, "geometry": {"type":
"Point", "coordinates": [3
# Ensure result of align=False retains the left's index
assert result.index.to_pandas().equals(expected.index)
+ def test_snap(self):
+ s = GeoSeries(
+ [
+ Point(0.5, 2.5),
+ LineString([(0.1, 0.1), (0.49, 0.51), (1.01, 0.89)]),
+ Polygon([(0, 0), (0, 10), (10, 10), (10, 0), (0, 0)]),
+ ],
+ )
+ s2 = GeoSeries(
+ [
+ Point(0, 2),
+ LineString([(0, 0), (0.5, 0.5), (1.0, 1.0)]),
+ Point(8, 10),
+ ],
+ index=range(1, 4),
+ )
+ result = s.snap(Point(0, 2), tolerance=1)
+ expected = gpd.GeoSeries(
+ [
+ Point(0, 2),
+ LineString([(0.1, 0.1), (0.49, 0.51), (1.01, 0.89)]),
+ Polygon([(0, 0), (0, 2), (0, 10), (10, 10), (10, 0), (0, 0)]),
+ ]
+ )
+ self.check_sgpd_equals_gpd(result, expected)
+
+ # Note: This test result slightly differs from the original
geopandas's result,
+ # which doesn't include the Point(0, 0) in the Polygon below.
+ result = s.snap(s2, tolerance=1, align=True)
+ expected = gpd.GeoSeries(
+ [
+ None,
+ LineString([(0.1, 0.1), (0.49, 0.51), (1.01, 0.89)]),
+ Polygon(
+ [(0, 0), (0.5, 0.5), (1, 1), (0, 10), (10, 10), (10, 0),
(0, 0)]
+ ),
+ None,
+ ]
+ )
+ self.check_sgpd_equals_gpd(result, expected)
+
+ result = s.snap(s2, tolerance=1, align=False)
+ expected = gpd.GeoSeries(
+ [
+ Point(0, 2),
+ LineString([(0, 0), (0.5, 0.5), (1, 1)]),
+ Polygon([(0, 0), (0, 10), (8, 10), (10, 10), (10, 0), (0, 0)]),
+ ]
+ )
+ self.check_sgpd_equals_gpd(result, expected)
+
def test_intersection_all(self):
pass
diff --git a/python/tests/geopandas/test_match_geopandas_series.py
b/python/tests/geopandas/test_match_geopandas_series.py
index 543ab729eb..85e38a9468 100644
--- a/python/tests/geopandas/test_match_geopandas_series.py
+++ b/python/tests/geopandas/test_match_geopandas_series.py
@@ -214,6 +214,18 @@ class TestMatchGeopandasSeries(TestGeopandasBase):
self.g1.buffer(0.2).to_parquet(temp_file_path)
assert os.path.exists(temp_file_path)
+ def test_simplify(self):
+ for geom in self.geoms:
+ if isinstance(geom[0], LinearRing):
+ continue
+ sgpd_result = GeoSeries(geom).simplify(100.1)
+ gpd_result = gpd.GeoSeries(geom).simplify(100.1)
+ self.check_sgpd_equals_gpd(sgpd_result, gpd_result)
+
+ sgpd_result = GeoSeries(geom).simplify(0.05,
preserve_topology=False)
+ gpd_result = gpd.GeoSeries(geom).simplify(0.05,
preserve_topology=False)
+ self.check_sgpd_equals_gpd(sgpd_result, gpd_result)
+
def test_geometry(self):
for geom in self.geoms:
gpd_result = gpd.GeoSeries(geom).geometry
@@ -794,6 +806,28 @@ class TestMatchGeopandasSeries(TestGeopandasBase):
gpd_result = gpd_series1.intersection(gpd_series2, align=False)
self.check_sgpd_equals_gpd(sgpd_result, gpd_result)
+ def test_snap(self):
+ if parse_version(gpd.__version__) < parse_version("1.0.0"):
+ return
+
+ # Sedona's snap result fails fairly often, even though the results are
fairly close.
+ # (though in a way where increasing the buffer tolerance wouldn't help
with)
+ # Instead of testing all self.pairs, we test a few specific cases that
are known to succeed
+ # currently, just so we can catch regressions
+
+ tests = [
+ (self.linestrings, self.multipoints, 1.1, True),
+ (self.linestrings, self.multipoints, 1, False),
+ (self.linearrings, self.multilinestrings, 1, False),
+ ]
+
+ for geom, geom2, tol, align in tests:
+ sgpd_result = GeoSeries(geom).snap(GeoSeries(geom2), tol,
align=align)
+ gpd_result = gpd.GeoSeries(geom).snap(
+ gpd.GeoSeries(geom2), tol, align=align
+ )
+ self.check_sgpd_equals_gpd(sgpd_result, gpd_result)
+
def test_intersection_all(self):
pass
diff --git a/python/tests/test_base.py b/python/tests/test_base.py
index 6e820ade01..f9978ca4a8 100644
--- a/python/tests/test_base.py
+++ b/python/tests/test_base.py
@@ -131,9 +131,12 @@ class TestBase:
if not actual_geom.equals_exact(expected_geom, tolerance=tolerance):
# If the exact equals check fails, perform a buffer check with
tolerance
- if actual_geom.buffer(tolerance).contains(
- expected_geom
- ) and expected_geom.buffer(tolerance).contains(actual_geom):
+ if (
+ actual_geom.is_valid
+ and actual_geom.buffer(tolerance).contains(expected_geom)
+ and expected_geom.is_valid
+ and expected_geom.buffer(tolerance).contains(actual_geom)
+ ):
return
else:
# fail the test with error message
