refactor: remove all _f32 suffixes — unified factory naming via overload

pycpp/geometry_py.h:
  - All factories now use the same name regardless of dtype:
    point(double,double) / point(float,float)       (scalar overload)
    point(array_t<double>) / point(array_t<float>)   (array overload)
    linestring(array_t<double>) / linestring(array_t<float>)
    polygon(array_t<double>) / polygon(array_t<float>)
  - Zero _f32 suffixes — dtype selected by input type in pybind11
    overload resolution (array dtype for linestring/polygon,
    scalar vs array form for point)

tests/module.cpp:
  - All factory bindings use same Python name (e.g. m.def("point", ...)
    bound 3 times with different signatures)
  - pybind11 overload resolution automatically picks the right
    C++ template instantiation based on input dtype

tests/conftest.py:
  - make fixture: f32 factories pass np.float32 arrays to cpp.point/
    cpp.linestring/cpp.polygon (same name, dtype selects overload)
  - CppFactory: same approach with numpy array dtype dispatch

Author: peng.li24

pycpp/geometry_py.h

@@ -1,11 +1,11 @@
 // Pybind11 wrappers for shapelycpp geometry types.
 //
-// Thin layer: accept Python types (py::list, scalars) → construct C++ geometry
-// types → call native methods → wrap results back to Python.
+// Thin layer: accept Python types (py::array_t<T>, scalars) → construct C++
+// geometry types → call native methods → wrap results back to Python.
 //
-// Inspired by the numpypy/pycpp pattern. Each wrapper matches a shapely Python
-// API signature.  Cross-type operations are exposed as free functions because
-// pybind11 cannot bind template member functions with mixed template args.
+// All factories are overloaded by coordinate type — no _f32 suffixes.
+// linestring/polygon/linearring use py::array_t<T> so pybind11 distinguishes
+// by array dtype.  point has both scalar (x,y) and array ([x,y]) forms.
 
 #pragma once
 
@@ -24,27 +24,12 @@
 namespace py = pybind11;
 using namespace shapely::geometry;
 
+namespace shapely_py {
+
 // ============================================================================
 // Internal helpers
 // ============================================================================
 
-namespace shapely_py {
-
-/// Convert Python list of (x,y) tuples to a flat coordinate array.
-template <typename T>
-py::array_t<T> py_coords_to_array(const py::list& py_coords) {
-    py::ssize_t n = py::len(py_coords);
-    auto arr = py::array_t<T>({n, static_cast<py::ssize_t>(2)});
-    auto buf = arr.template request();
-    T* ptr = static_cast<T*>(buf.ptr);
-    for (py::ssize_t i = 0; i < n; ++i) {
-        auto t = py_coords[i].cast<py::tuple>();
-        ptr[i * 2] = t[0].cast<T>();
-        ptr[i * 2 + 1] = t[1].cast<T>();
-    }
-    return arr;
-}
-
 /// Copy native T* data to a Python numpy array.
 template <typename T>
 py::array_t<T> native_to_array(const T* data, size_t rows, size_t cols) {
@@ -54,86 +39,72 @@ py::array_t<T> native_to_array(const T* data, size_t rows, size_t cols) {
     return result;
 }
 
-} // namespace shapely_py
-
 // ============================================================================
-// Factory functions
+// Factory functions — all overloaded, no _f32 suffixes
 // ============================================================================
 
-namespace shapely_py {
-
+// -- Point: scalar (x,y) + array ([x,y]) forms --
 inline Point<double> point(double x, double y) { return Point<double>(x, y); }
-inline Point<float>  point_f32(float x, float y) { return Point<float>(x, y); }
+inline Point<float>  point(float x, float y)  { return Point<float>(x, y); }
 
-inline LineString<double> linestring(const py::list& coords) {
-    auto arr = py_coords_to_array<double>(coords);
+inline Point<double> point(const py::array_t<double>& arr) {
     auto buf = arr.request();
-    return LineString<double>(static_cast<const double*>(buf.ptr),
-                               buf.shape[0], buf.shape[1]);
+    const double* p = static_cast<const double*>(buf.ptr);
+    return Point<double>(buf.size > 0 ? p[0] : 0, buf.size > 1 ? p[1] : 0);
 }
-inline LineString<float> linestring_f32(const py::list& coords) {
-    auto arr = py_coords_to_array<float>(coords);
+inline Point<float> point(const py::array_t<float>& arr) {
     auto buf = arr.request();
-    return LineString<float>(static_cast<const float*>(buf.ptr),
-                              buf.shape[0], buf.shape[1]);
+    const float* p = static_cast<const float*>(buf.ptr);
+    return Point<float>(buf.size > 0 ? p[0] : 0, buf.size > 1 ? p[1] : 0);
 }
 
-inline Polygon<double> polygon(const py::list& coords) {
-    auto arr = py_coords_to_array<double>(coords);
+// -- LineString --
+inline LineString<double> linestring(const py::array_t<double>& arr) {
     auto buf = arr.request();
-    return Polygon<double>(static_cast<const double*>(buf.ptr),
-                            buf.shape[0], buf.shape[1]);
+    return LineString<double>(static_cast<const double*>(buf.ptr), buf.shape[0], buf.shape[1]);
 }
-inline Polygon<float> polygon_f32(const py::list& coords) {
-    auto arr = py_coords_to_array<float>(coords);
+inline LineString<float> linestring(const py::array_t<float>& arr) {
     auto buf = arr.request();
-    return Polygon<float>(static_cast<const float*>(buf.ptr),
-                           buf.shape[0], buf.shape[1]);
+    return LineString<float>(static_cast<const float*>(buf.ptr), buf.shape[0], buf.shape[1]);
 }
 
-inline LinearRing<double> linearring(const py::list& coords) {
-    auto arr = py_coords_to_array<double>(coords);
+// -- Polygon --
+inline Polygon<double> polygon(const py::array_t<double>& arr) {
     auto buf = arr.request();
-    return LinearRing<double>(static_cast<const double*>(buf.ptr),
-                               buf.shape[0], buf.shape[1]);
+    return Polygon<double>(static_cast<const double*>(buf.ptr), buf.shape[0], buf.shape[1]);
+}
+inline Polygon<float> polygon(const py::array_t<float>& arr) {
+    auto buf = arr.request();
+    return Polygon<float>(static_cast<const float*>(buf.ptr), buf.shape[0], buf.shape[1]);
 }
 
-} // namespace shapely_py
+// -- LinearRing (double only for now) --
+inline LinearRing<double> linearring(const py::array_t<double>& arr) {
+    auto buf = arr.request();
+    return LinearRing<double>(static_cast<const double*>(buf.ptr), buf.shape[0], buf.shape[1]);
+}
 
 // ============================================================================
-// Cross-type distance wrappers
+// Cross-type distance
 // ============================================================================
-// pybind11 cannot bind templated member functions with args of a different
-// template parameter (e.g. LineString<double>::distance(Polygon<double>)).
-// Expose these via free functions.
-
-namespace shapely_py {
 
 inline double distance_pt_ls(const Point<double>& p, const LineString<double>& l) { return p.distance(l); }
 inline double distance_pt_poly(const Point<double>& p, const Polygon<double>& poly) { return p.distance(poly); }
 inline double distance_ls_poly(const LineString<double>& l, const Polygon<double>& poly) { return l.distance(poly); }
 inline double distance_poly_ls(const Polygon<double>& poly, const LineString<double>& l) { return poly.distance(l); }
 
-} // namespace shapely_py
-
 // ============================================================================
-// Cross-type intersects wrappers
+// Cross-type intersects
 // ============================================================================
 
-namespace shapely_py {
-
 inline bool intersects_ls_poly(const LineString<double>& l, const Polygon<double>& poly) { return l.intersects(poly); }
 inline bool intersects_poly_ls(const Polygon<double>& poly, const LineString<double>& l) { return poly.intersects(l); }
 inline bool intersects_poly_poly(const Polygon<double>& p1, const Polygon<double>& p2) { return p1.intersects(p2); }
 
-} // namespace shapely_py
-
 // ============================================================================
-// Predicate wrappers  (all cross-type pairs, float64)
+// Predicates — all 9 cross-type pairs
 // ============================================================================
 
-namespace shapely_py {
-
 // -- Point ↔ Point --
 inline bool pt_contains_pt(const Point<double>& s, const Point<double>& o) { return s.contains(o); }
 inline bool pt_within_pt(const Point<double>& s, const Point<double>& o) { return s.within(o); }
@@ -269,23 +240,19 @@ inline bool poly_intersects_poly(const Polygon<double>& s, const Polygon<double>
 inline std::string poly_relate_poly(const Polygon<double>& s, const Polygon<double>& o) { return s.relate(o); }
 inline double poly_hausdorff_distance_poly(const Polygon<double>& s, const Polygon<double>& o) { return s.hausdorff_distance(o); }
 
-} // namespace shapely_py
-
 // ============================================================================
 // Centroid, project, interpolate
 // ============================================================================
 
-namespace shapely_py {
-
-inline std::tuple<double, double> centroid_point(const Point<double>& p) { auto r = p.centroid(); return {r.x, r.y}; }
-inline std::tuple<double, double> centroid_linestring(const LineString<double>& l) { auto r = l.centroid(); return {r.x, r.y}; }
-inline std::tuple<double, double> centroid_polygon(const Polygon<double>& p) { auto r = p.centroid(); return {r.x, r.y}; }
+inline std::tuple<double,double> centroid_point(const Point<double>& p) { auto r=p.centroid(); return {r.x,r.y}; }
+inline std::tuple<double,double> centroid_linestring(const LineString<double>& l) { auto r=l.centroid(); return {r.x,r.y}; }
+inline std::tuple<double,double> centroid_polygon(const Polygon<double>& p) { auto r=p.centroid(); return {r.x,r.y}; }
 
 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(const LineString<double>& l, double d) { auto r=l.interpolate(d); return {r.x,r.y}; }
 
 inline double intersection_area_poly_poly(const Polygon<double>& p1, const Polygon<double>& p2) {
-    auto inter = p1.intersection(p2); return inter.area();
+    return p1.intersection(p2).area();
 }
 
 inline py::array_t<double> polygon_exterior(const Polygon<double>& p) {
@@ -298,8 +265,6 @@ inline py::array_t<double> polygon_exterior(const Polygon<double>& p) {
 // ============================================================================
 // Pybind11 binding helper macros
 // ============================================================================
-// Use these in your PYBIND11_MODULE to consistently bind geometry classes
-// and cross-type predicates.  See tests/module.cpp for usage examples.
 
 #define BIND_PREDS(m, SRC, TGT) \
     m.def(#SRC "_contains_" #TGT, &shapely_py::SRC ## _contains_ ## TGT); \

tests/conftest.py

@@ -62,16 +62,24 @@ def dtype(request):
 
 @pytest.fixture(params=[np.float64, np.float32], ids=["float64", "float32"])
 def make(cpp, request):
-    """Parametrized fixture providing float64/float32 geometry factories and classes."""
+    """Parametrized fixture providing float64/float32 geometry factories and classes.
+
+    All factories use the SAME Python name (e.g. cpp.point) — dtype is selected
+    by passing numpy arrays with the appropriate dtype.  pybind11 overload
+    resolution picks the matching C++ template instantiation."""
     if request.param == np.float64:
         return {
-            'point': cpp.point, 'linestring': cpp.linestring, 'polygon': cpp.polygon,
+            'point': lambda x, y: cpp.point(float(x), float(y)),
+            'linestring': lambda coords: cpp.linestring(np.array(coords, dtype=np.float64)),
+            'polygon': lambda coords: cpp.polygon(np.array(coords, dtype=np.float64)),
             'Point': cpp.Point, 'LineString': cpp.LineString, 'Polygon': cpp.Polygon,
             'dtype': np.float64,
         }
     else:
         return {
-            'point': cpp.point_f32, 'linestring': cpp.linestring_f32, 'polygon': cpp.polygon_f32,
+            'point': lambda x, y: cpp.point(np.array([x, y], dtype=np.float32)),
+            'linestring': lambda coords: cpp.linestring(np.array(coords, dtype=np.float32)),
+            'polygon': lambda coords: cpp.polygon(np.array(coords, dtype=np.float32)),
             'Point': cpp.PointF32, 'LineString': cpp.LineStringF32, 'Polygon': cpp.PolygonF32,
             'dtype': np.float32,
         }
@@ -82,16 +90,19 @@ class CppFactory:
     def __init__(self, cpp_mod):
         self.m = cpp_mod
     def point(self, x, y, dtype='double'):
-        if dtype == 'float32': return self.m.point_f32(float(x), float(y))
+        if dtype == 'float32':
+            return self.m.point(np.array([float(x), float(y)], dtype=np.float32))
         return self.m.point(float(x), float(y))
     def linestring(self, coords, dtype='double'):
-        if dtype == 'float32': return self.m.linestring_f32(coords)
-        return self.m.linestring(coords)
+        if dtype == 'float32':
+            return self.m.linestring(np.array(coords, dtype=np.float32))
+        return self.m.linestring(np.array(coords, dtype=np.float64))
     def polygon(self, coords, dtype='double'):
-        if dtype == 'float32': return self.m.polygon_f32(coords)
-        return self.m.polygon(coords)
+        if dtype == 'float32':
+            return self.m.polygon(np.array(coords, dtype=np.float32))
+        return self.m.polygon(np.array(coords, dtype=np.float64))
     def linearring(self, coords):
-        return self.m.linearring(coords)
+        return self.m.linearring(np.array(coords, dtype=np.float64))
 
 @pytest.fixture(scope='session')
 def C(cpp):

tests/module.cpp

@@ -1,12 +1,8 @@
 // pybind11 test module for shapelycpp — demonstrates pycpp wrapper usage.
 //
-// Includes all shapely geometry types, cross-type predicates, distance,
-// centroid, nearest_points, serialization, etc.
-//
-// Usage (consuming project):
-//   #include "shapelycpp/pycpp/geometry_py.h"
-//   #include "shapelycpp/pycpp/ops_py.h"
-//   PYBIND11_MODULE(my_module, m) { ... bind classes + use BIND_PREDS macros ... }
+// All factories are bound under a single Python name per geometry type
+// (e.g. "point" handles float64 AND float32 via pybind11 overload resolution).
+// No _f32 suffixes anywhere — dtype is selected by the input array/numpy type.
 
 #include <pybind11/pybind11.h>
 #include <pybind11/numpy.h>
@@ -22,7 +18,7 @@ namespace py = pybind11;
 using namespace shapely::geometry;
 using namespace shapely_py;
 
-// Re-export native_to_array for module-local use (templated — supports float/double)
+// Re-export native_to_array for module-local use (templated)
 namespace {
 template <typename T>
 py::array_t<T> _native_to_array(const T* data, size_t rows, size_t cols) {
@@ -33,14 +29,18 @@ py::array_t<T> _native_to_array(const T* data, size_t rows, size_t cols) {
 PYBIND11_MODULE(shapelycpp, m) {
     m.doc() = "shapelycpp test module (powered by pycpp wrappers)";
 
-    // -- Factories (from pycpp) --
-    m.def("point",          &point,          py::arg("x"), py::arg("y"));
-    m.def("point_f32",      &point_f32,      py::arg("x"), py::arg("y"));
-    m.def("linestring",     &linestring,     py::arg("coords"));
-    m.def("linestring_f32", &linestring_f32, py::arg("coords"));
-    m.def("polygon",        &polygon,        py::arg("coords"));
-    m.def("polygon_f32",    &polygon_f32,    py::arg("coords"));
-    m.def("linearring",     &linearring,     py::arg("coords"));
+    // -- Factories — all under unified names, dtype selected via input type --
+    // point: scalar (x,y) → f64; array [x,y] with f32 dtype → f32
+    m.def("point", py::overload_cast<double, double>(&point), py::arg("x"), py::arg("y"));
+    m.def("point", py::overload_cast<const py::array_t<double>&>(&point), py::arg("coords"));
+    m.def("point", py::overload_cast<const py::array_t<float>&>(&point),  py::arg("coords"));
+
+    // linestring / polygon / linearring: array dtype selects f64 or f32
+    m.def("linestring", py::overload_cast<const py::array_t<double>&>(&linestring), py::arg("coords"));
+    m.def("linestring", py::overload_cast<const py::array_t<float>&>(&linestring),  py::arg("coords"));
+    m.def("polygon",    py::overload_cast<const py::array_t<double>&>(&polygon),    py::arg("coords"));
+    m.def("polygon",    py::overload_cast<const py::array_t<float>&>(&polygon),     py::arg("coords"));
+    m.def("linearring", py::overload_cast<const py::array_t<double>&>(&linearring), py::arg("coords"));
 
     // ======================================================================
     // Point<double> — full API