feat: ST_IsClosed

refactor: update ST_IsClosed implementation and add tests

refactor: update ST_IsClosed tests with comprehensive cases

chore: fixed format on is_closed.rs

feat: add ST_IsClosed to Python bindings and update tests

chore: fix formatting

refactor: move ST_IsClosed to validation module

refactor: move IsClosed from measurement to validation

refactor: update error with IsClosed UDF

refactor: add pytest validation test for ST_IsClosed UDF

Author: oglego

README.md

@@ -58,7 +58,7 @@ Functions are explicitly modeled after the [PostGIS API](https://postgis.net/doc
 | ST_GeometryN        |             | Return an element of a geometry collection.                                                             |
 | ST_GeometryType     | ✅          | Returns the SQL-MM type of a geometry as text.                                                          |
 | ST_InteriorRingN    |             | Returns the Nth interior ring (hole) of a Polygon.                                                      |
-| ST_IsClosed         |             | Tests if a LineStrings's start and end points are coincident.                                           |
+| ST_IsClosed         | ✅          | Tests if a LineStrings's start and end points are coincident.                                           |
 | ST_IsCollection     |             | Tests if a geometry is a geometry collection type.                                                      |
 | ST_IsEmpty          |             | Tests if a geometry is empty.                                                                           |
 | ST_IsPolygonCCW     |             | Tests if Polygons have exterior rings oriented counter-clockwise and interior rings oriented clockwise. |

python/python/geodatafusion/__init__.py

@@ -43,6 +43,7 @@ def register_all_geo(ctx: SessionContext):
     ctx.register_udf(udf(geo.Within()))
 
     # validation
+    ctx.register_udf(udf(geo.IsClosed()))
     ctx.register_udf(udf(geo.IsValid()))
     ctx.register_udf(udf(geo.IsValidReason()))
 

python/python/geodatafusion/geo/_validation.pyi

@@ -1,3 +1,7 @@
+class IsClosed:
+    def __init__(self) -> None: ...
+    def __datafusion_scalar_udf__(self) -> object: ...
+
 class IsValid:
     def __init__(self) -> None: ...
     def __datafusion_scalar_udf__(self) -> object: ...

python/src/udf/geo/mod.rs

@@ -34,6 +34,7 @@ pub(crate) fn geo(m: &Bound<PyModule>) -> PyResult<()> {
     m.add_class::<relationships::PyWithin>()?;
 
     // validation
+    m.add_class::<validation::PyIsClosed>()?;
     m.add_class::<validation::PyIsValid>()?;
     m.add_class::<validation::PyIsValidReason>()?;
 

python/src/udf/geo/validation.rs

@@ -1,6 +1,7 @@
-use geodatafusion::udf::geo::validation::{IsValid, IsValidReason};
+use geodatafusion::udf::geo::validation::{IsClosed, IsValid, IsValidReason};
 
 use crate::impl_udf;
 
+impl_udf!(IsClosed, PyIsClosed, "IsClosed");
 impl_udf!(IsValid, PyIsValid, "IsValid");
 impl_udf!(IsValidReason, PyIsValidReason, "IsValidReason");

python/tests/udf/geo/__init__.py

@@ -0,0 +1,15 @@
+from __future__ import annotations
+
+from arro3.core import Table
+from datafusion import SessionContext
+import geodatafusion
+from geodatafusion import register_all
+
+
+def test_st_is_closed_geoarrow():
+    ctx = SessionContext()
+    register_all(ctx)
+    sql = "SELECT ST_IsClosed(ST_GeomFromText('POLYGON((0 0, 0 1, 1 1, 1 0, 0 0))')) as geom"
+    df = ctx.sql(sql)
+    table = df.to_arrow_table()
+    assert table.column("geom")[0].as_py() is True

python/tests/udf/geo/test_validation.py

@@ -0,0 +1,185 @@
+use std::any::Any;
+use std::sync::{Arc, OnceLock};
+
+use arrow_array::BooleanArray;
+use arrow_array::builder::BooleanBuilder;
+use arrow_schema::DataType;
+use datafusion::error::Result;
+use datafusion::logical_expr::scalar_doc_sections::DOC_SECTION_OTHER;
+use datafusion::logical_expr::{
+    ColumnarValue, Documentation, ScalarFunctionArgs, ScalarUDFImpl, Signature,
+};
+use geo_traits::{CoordTrait, GeometryTrait, LineStringTrait, MultiLineStringTrait};
+use geoarrow_array::{GeoArrowArrayAccessor, WrapArray, downcast_geoarrow_array};
+use geoarrow_schema::GeoArrowType;
+
+use crate::data_types::any_single_geometry_type_input;
+use crate::error::GeoDataFusionResult;
+
+#[derive(Debug, Eq, PartialEq, Hash)]
+pub struct IsClosed;
+
+impl IsClosed {
+    pub fn new() -> Self {
+        Self {}
+    }
+}
+
+impl Default for IsClosed {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+static DOCUMENTATION: OnceLock<Documentation> = OnceLock::new();
+
+impl ScalarUDFImpl for IsClosed {
+    fn as_any(&self) -> &dyn Any {
+        self
+    }
+
+    fn name(&self) -> &str {
+        "st_isclosed"
+    }
+
+    fn signature(&self) -> &Signature {
+        any_single_geometry_type_input()
+    }
+
+    fn return_type(&self, _arg_types: &[DataType]) -> Result<DataType> {
+        Ok(DataType::Boolean)
+    }
+
+    fn invoke_with_args(&self, args: ScalarFunctionArgs) -> Result<ColumnarValue> {
+        Ok(is_closed_impl(args)?)
+    }
+
+    fn documentation(&self) -> Option<&Documentation> {
+        Some(DOCUMENTATION.get_or_init(|| {
+            Documentation::builder(
+                DOC_SECTION_OTHER,
+                "Tests if a LineStrings's start and end points are coincident.",
+                "ST_IsClosed(geom)",
+            )
+            .with_argument("geom", "geometry")
+            .build()
+        }))
+    }
+}
+
+fn is_closed_impl(args: ScalarFunctionArgs) -> GeoDataFusionResult<ColumnarValue> {
+    let array = ColumnarValue::values_to_arrays(&args.args)?
+        .into_iter()
+        .next()
+        .unwrap();
+    let geo_type = GeoArrowType::from_arrow_field(&args.arg_fields[0])?;
+    let geo_array = geo_type.wrap_array(&array)?;
+    let geo_array_ref = geo_array.as_ref();
+
+    let result = downcast_geoarrow_array!(geo_array_ref, impl_is_closed)?;
+
+    Ok(ColumnarValue::Array(Arc::new(result)))
+}
+
+fn impl_is_closed<'a>(
+    array: &'a impl GeoArrowArrayAccessor<'a>,
+) -> GeoDataFusionResult<BooleanArray> {
+    let mut builder = BooleanBuilder::with_capacity(array.len());
+
+    for item in array.iter() {
+        match item {
+            Some(geom) => {
+                let geom = geom?;
+                let is_closed = match geom.as_type() {
+                    geo_traits::GeometryType::LineString(ls) => check_ls_closed(ls),
+                    geo_traits::GeometryType::MultiLineString(mls) => {
+                        mls.num_line_strings() > 0
+                            && mls.line_strings().all(|ls| check_ls_closed(&ls))
+                    }
+                    geo_traits::GeometryType::Point(_)
+                    | geo_traits::GeometryType::MultiPoint(_)
+                    | geo_traits::GeometryType::Polygon(_)
+                    | geo_traits::GeometryType::MultiPolygon(_) => true,
+                    _ => false,
+                };
+                builder.append_value(is_closed);
+            }
+            None => {
+                builder.append_null();
+            }
+        }
+    }
+
+    Ok(builder.finish())
+}
+
+fn check_ls_closed(ls: &impl LineStringTrait<T = f64>) -> bool {
+    let n = ls.num_coords();
+    if n < 2 {
+        return false;
+    }
+    if let (Some(first), Some(last)) = (ls.coord(0), ls.coord(n - 1)) {
+        first.x() == last.x() && first.y() == last.y()
+    } else {
+        false
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use arrow_array::cast::AsArray;
+    use datafusion::prelude::SessionContext;
+
+    use super::*;
+    use crate::udf::native::io::GeomFromText;
+
+    #[tokio::test]
+    async fn test_st_isclosed() {
+        let ctx = SessionContext::new();
+        ctx.register_udf(IsClosed::new().into());
+        ctx.register_udf(GeomFromText::new(Default::default()).into());
+
+        let cases = vec![
+            ("LINESTRING(0 0, 1 1, 0 1, 0 0)", true, "closed linestring"),
+            ("LINESTRING(0 0, 1 1, 1 0)", false, "open linestring"),
+            ("LINESTRING(0 0, 0 0)", true, "single segment closed"),
+            ("LINESTRING EMPTY", false, "empty linestring is not closed"),
+            (
+                "MULTILINESTRING((0 0, 1 1, 0 0), (2 2, 3 3, 2 2))",
+                true,
+                "all closed",
+            ),
+            (
+                "MULTILINESTRING((0 0, 1 1, 0 0), (2 2, 3 3, 2 3))",
+                false,
+                "one open",
+            ),
+            (
+                "MULTILINESTRING EMPTY",
+                false,
+                "empty multilinestring is not closed",
+            ),
+            ("POINT(0 0)", true, "point is closed"),
+            ("MULTIPOINT(0 0, 1 1)", true, "multipoint is closed"),
+            ("POLYGON((0 0, 1 0, 1 1, 0 0))", true, "polygon is closed"),
+            (
+                "MULTIPOLYGON(((0 0, 1 0, 1 1, 0 0)))",
+                true,
+                "multipolygon is closed",
+            ),
+        ];
+
+        for (wkt, expected, description) in cases {
+            let sql = format!("SELECT ST_IsClosed(ST_GeomFromText('{}'))", wkt);
+            let df = ctx
+                .sql(&sql)
+                .await
+                .unwrap_or_else(|_| panic!("Failed to execute SQL for {}", description));
+
+            let batch = df.collect().await.unwrap().into_iter().next().unwrap();
+            let col = batch.column(0).as_boolean();
+
+            assert_eq!(col.value(0), expected, "Failed on {}: {}", description, wkt);
+        }
+    }
+}

rust/geodatafusion/src/udf/geo/validation/is_closed.rs

@@ -1,10 +1,13 @@
+mod is_closed;
 mod is_valid;
 mod is_valid_reason;
 
+pub use is_closed::IsClosed;
 pub use is_valid::IsValid;
 pub use is_valid_reason::IsValidReason;
 
 pub fn register(session_context: &datafusion::prelude::SessionContext) {
+    session_context.register_udf(IsClosed.into());
     session_context.register_udf(IsValid.into());
     session_context.register_udf(IsValidReason.into());
 }