feat: update geometry_py.h, linestring.h, module.cpp, and tests

Author: peng.li24

pycpp/geometry_py.h

@@ -444,6 +444,10 @@ inline std::tuple<double,double> centroid_polygon(const Polygon<double>& p) { au
 
 inline double project_ls_pt(const LineString<double>& l, const Point<double>& p) { return l.project(p); }
 inline std::tuple<double,double> interpolate_ls(const LineString<double>& l, double d) { auto r=l.interpolate(d); return {r.x,r.y}; }
+inline std::tuple<double,double> interpolate_ls_normalized(const LineString<double>& l, double t) {
+    auto r = l.interpolate(t, true);
+    return {r.x, r.y};
+}
 
 inline double intersection_area_poly_poly(const Polygon<double>& p1, const Polygon<double>& p2) {
     return p1.intersection(p2).area();

shapely/geometry/linestring.h

@@ -121,7 +121,7 @@ class LineString {
 
     // -- Topology --
     template <typename U> double project(const Point<U>& other) const;
-    Point<double> interpolate(double distance) const;
+    Point<double> interpolate(double distance, bool normalized = false) const;
     Point<double> centroid() const;
     Polygon<double> buffer(double distance) const;
 
@@ -344,9 +344,17 @@ double LineString<T>::project(const Point<U>& o) const {
 
 // Python: base.py::interpolate:L915
 template <typename T>
-Point<double> LineString<T>::interpolate(double distance) const {
+Point<double> LineString<T>::interpolate(double distance, bool normalized) const {
+    double abs_dist;
+    if (normalized) {
+        if (distance < 0.0) distance = 0.0;
+        if (distance > 1.0) distance = 1.0;
+        abs_dist = distance * this->length();
+    } else {
+        abs_dist = distance;
+    }
     geos::linearref::LengthIndexedLine lil(geos_linestring_.get());
-    auto c = lil.extractPoint(distance);
+    auto c = lil.extractPoint(abs_dist);
     return Point<double>(c.x, c.y);
 }
 

tests/module.cpp

@@ -387,8 +387,9 @@ PYBIND11_MODULE(shapelycpp, m) {
     // ======================================================================
     // Project / interpolate (from pycpp)
     // ======================================================================
-    m.def("project_linestring_point", &project_ls_pt);
-    m.def("interpolate_linestring",   &interpolate_ls);
+    m.def("project_linestring_point",   &project_ls_pt);
+    m.def("interpolate_linestring",    &interpolate_ls);
+    m.def("interpolate_linestring_normalized", &interpolate_ls_normalized);
 
     // ======================================================================
     // Intersection area (from pycpp)

tests/report.csv

@@ -230,6 +230,11 @@ ops,interpolate_linestring,unknown,f64,v_mid,PASS,0
 ops,interpolate_linestring,unknown,f64,h_start,PASS,0
 ops,interpolate_linestring,unknown,f64,h_end,PASS,0
 ops,interpolate_linestring,unknown,f64,v3pt,PASS,0
+ops,interpolate_linestring_normalized,unknown,f64,h_mid,PASS,0
+ops,interpolate_linestring_normalized,unknown,f64,h_start,PASS,0
+ops,interpolate_linestring_normalized,unknown,f64,h_end,PASS,0
+ops,interpolate_linestring_normalized,unknown,f64,v_mid,PASS,0
+ops,interpolate_linestring_normalized,unknown,f64,v3pt_end,PASS,0
 ops,centroid_point,unknown,f64,3-4,PASS,0
 ops,centroid_point,unknown,f64,neg,PASS,0
 ops,centroid_linestring,unknown,f64,d,PASS,0

tests/test_all.py

@@ -147,6 +147,7 @@ def _compare_bit_exact(cpp_result, py_result, label=""):
 _OPS_NAMES = {
     "centroid_point", "centroid_linestring", "centroid_polygon",
     "project_linestring_point", "interpolate_linestring",
+    "interpolate_linestring_normalized",
     "intersection_area_polygon_polygon",
     "polygon_exterior",
     "nearest_points", "nearest_points_ls_pt",
@@ -356,6 +357,14 @@ def _call_ops(api_name, cpp, *args, **kwargs):
         py_pt = py_ls.interpolate(dist)
         return np.array(c_result), np.array((py_pt.x, py_pt.y))
 
+    if api_name == "interpolate_linestring_normalized":
+        c_ls = _build_cpp_geom(cpp, *geoms[0])
+        py_ls = _build_py_geom(*geoms[0])
+        t = float(extras[0]) if extras else 0.5
+        c_result = cpp.interpolate_linestring_normalized(c_ls, t)
+        py_pt = py_ls.interpolate(t, normalized=True)
+        return np.array(c_result), np.array((py_pt.x, py_pt.y))
+
     if api_name == "intersection_area_polygon_polygon":
         c_a = _build_cpp_geom(cpp, *geoms[0])
         c_b = _build_cpp_geom(cpp, *geoms[1])
@@ -879,6 +888,17 @@ def _catalog_ops():
         yield _TestCase("interpolate_linestring", (ls, dist), {}, "f64", tag,
                        "bit_exact", True, None, "ops")
 
+    # -- interpolate_linestring_normalized --
+    for ls, t, py_t_expected_tag, tag in [
+        (("ls", _L_H), 0.5, "h_mid", "h_mid"),       # t=0.5 → midpoint of 10-length horizontal
+        (("ls", _L_H), 0.0, "h_start", "h_start"),   # t=0.0 → start
+        (("ls", _L_H), 1.0, "h_end", "h_end"),        # t=1.0 → end
+        (("ls", _L_V), 0.5, "v_mid", "v_mid"),        # vertical 10-length, t=0.5
+        (("ls", _L_3), 1.0, "v3pt", "v3pt_end"),      # 3-point L, t=1.0
+    ]:
+        yield _TestCase("interpolate_linestring_normalized", (ls, t), {},
+                       "f64", tag, "bit_exact", True, None, "ops")
+
     # -- Centroid --
     for name, geom, tag in [
         ("centroid_point", ("pt", (3, 4)), "3-4"),