feat: add auto-double py::array overloads — accept any numpy dtype, always produce Geometry<double>

Author: peng.li24

pycpp/geometry_py.h

@@ -43,6 +43,25 @@ py::array_t<T> native_to_array(const T* data, size_t rows, size_t cols) {
     return result;
 }
 
+/// Convert any py::array coordinate buffer to std::vector<double>.
+/// dtype double → direct copy; float32/other → cast & widen to double.
+inline std::vector<double> array_to_double_vec(const py::array& arr) {
+    auto buf = arr.request();
+    size_t sz = static_cast<size_t>(buf.shape[0]) * 2;
+    std::vector<double> tmp(sz);
+    if (arr.dtype().is(py::dtype::of<double>())) {
+        const double* src = static_cast<const double*>(buf.ptr);
+        std::copy(src, src + sz, tmp.begin());
+    } else {
+        // float32 or other → cast through pybind11 to float32, then widen
+        auto f32 = py::cast<py::array_t<float>>(arr);
+        auto fbuf = f32.request();
+        const float* src = static_cast<const float*>(fbuf.ptr);
+        for (size_t i = 0; i < sz; ++i) tmp[i] = static_cast<double>(src[i]);
+    }
+    return tmp;
+}
+
 // ============================================================================
 // Factory functions — all overloaded, no _f32 suffixes
 // ============================================================================
@@ -61,6 +80,11 @@ inline Point<float> point(const py::array_t<float>& arr) {
     const float* p = static_cast<const float*>(buf.ptr);
     return Point<float>(buf.size > 0 ? p[0] : 0, buf.size > 1 ? p[1] : 0);
 }
+// auto-double: accept any dtype (int, unknown), always produce Point<double>
+inline Point<double> point(const py::array& arr) {
+    auto tmp = array_to_double_vec(arr);
+    return Point<double>(tmp[0], tmp[1]);
+}
 
 // -- LineString --
 inline LineString<double> linestring(const py::array_t<double>& arr) {
@@ -71,6 +95,11 @@ inline LineString<float> linestring(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]);
 }
+inline LineString<double> linestring(const py::array& arr) {
+    py::ssize_t n = arr.request().shape[0];
+    auto tmp = array_to_double_vec(arr);
+    return LineString<double>(tmp.data(), static_cast<size_t>(n), 2);
+}
 
 // -- Polygon --
 inline Polygon<double> polygon(const py::array_t<double>& arr) {
@@ -81,12 +110,22 @@ 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]);
 }
+inline Polygon<double> polygon(const py::array& arr) {
+    py::ssize_t n = arr.request().shape[0];
+    auto tmp = array_to_double_vec(arr);
+    return Polygon<double>(tmp.data(), static_cast<size_t>(n), 2);
+}
 
 // -- 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]);
 }
+inline LinearRing<double> linearring(const py::array& arr) {
+    py::ssize_t n = arr.request().shape[0];
+    auto tmp = array_to_double_vec(arr);
+    return LinearRing<double>(tmp.data(), static_cast<size_t>(n), 2);
+}
 
 // -- MultiPoint: single array of shape (n_pts, 2) --
 inline MultiPoint<double> multipoint(const py::array_t<double>& arr) {
@@ -97,6 +136,11 @@ inline MultiPoint<float> multipoint(const py::array_t<float>& arr) {
     auto buf = arr.request();
     return MultiPoint<float>(static_cast<const float*>(buf.ptr), buf.shape[0], buf.shape[1]);
 }
+inline MultiPoint<double> multipoint(const py::array& arr) {
+    py::ssize_t n = arr.request().shape[0];
+    auto tmp = array_to_double_vec(arr);
+    return MultiPoint<double>(tmp.data(), static_cast<size_t>(n), 2);
+}
 
 // -- MultiLineString: vector of arrays, each (n_rows, 2); dtype distinguishes overload --
 inline MultiLineString<double> multilinestring(const std::vector<py::array_t<double>>& arrays) {
@@ -115,6 +159,15 @@ inline MultiLineString<float> multilinestring(const std::vector<py::array_t<floa
     }
     return mls;
 }
+inline MultiLineString<double> multilinestring(const std::vector<py::array>& arrays) {
+    MultiLineString<double> mls;
+    for (auto& arr : arrays) {
+        py::ssize_t n = arr.request().shape[0];
+        auto tmp = array_to_double_vec(arr);
+        mls.add_line(tmp.data(), static_cast<size_t>(n), 2);
+    }
+    return mls;
+}
 
 // -- MultiPolygon: vector of arrays, each (n_rows, 2); dtype distinguishes overload --
 inline MultiPolygon<double> multipolygon(const std::vector<py::array_t<double>>& arrays) {
@@ -133,6 +186,15 @@ inline MultiPolygon<float> multipolygon(const std::vector<py::array_t<float>>& a
     }
     return mp;
 }
+inline MultiPolygon<double> multipolygon(const std::vector<py::array>& arrays) {
+    MultiPolygon<double> mp;
+    for (auto& arr : arrays) {
+        py::ssize_t n = arr.request().shape[0];
+        auto tmp = array_to_double_vec(arr);
+        mp.add_polygon(tmp.data(), static_cast<size_t>(n), 2);
+    }
+    return mp;
+}
 
 // ============================================================================
 // Cross-type distance

tests/module.cpp

@@ -34,13 +34,17 @@ PYBIND11_MODULE(shapelycpp, m) {
     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"));
+    m.def("point", py::overload_cast<const py::array&>(&point), py::arg("coords"));       // auto-double
 
     // 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("linestring", py::overload_cast<const py::array&>(&linestring),  py::arg("coords"));    // auto-double
     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("polygon",    py::overload_cast<const py::array&>(&polygon),     py::arg("coords"));    // auto-double
     m.def("linearring", py::overload_cast<const py::array_t<double>&>(&linearring), py::arg("coords"));
+    m.def("linearring", py::overload_cast<const py::array&>(&linearring), py::arg("coords"));     // auto-double
 
     // ======================================================================
     // Point<double> — full API
@@ -177,10 +181,13 @@ PYBIND11_MODULE(shapelycpp, m) {
     // -- Multi* factories (multipoint overloads by array dtype; multilinestring/multipolygon by vector<array_t<T>>) --
     m.def("multipoint", py::overload_cast<const py::array_t<double>&>(&multipoint), py::arg("coords"));
     m.def("multipoint", py::overload_cast<const py::array_t<float>&>(&multipoint),  py::arg("coords"));
+    m.def("multipoint", py::overload_cast<const py::array&>(&multipoint),  py::arg("coords"));   // auto-double
     m.def("multilinestring", py::overload_cast<const std::vector<py::array_t<double>>&>(&multilinestring), py::arg("lines"));
     m.def("multilinestring", py::overload_cast<const std::vector<py::array_t<float>>&>(&multilinestring),  py::arg("lines"));
+    m.def("multilinestring", py::overload_cast<const std::vector<py::array>&>(&multilinestring),  py::arg("lines")); // auto-double
     m.def("multipolygon", py::overload_cast<const std::vector<py::array_t<double>>&>(&multipolygon), py::arg("polygons"));
     m.def("multipolygon", py::overload_cast<const std::vector<py::array_t<float>>&>(&multipolygon),  py::arg("polygons"));
+    m.def("multipolygon", py::overload_cast<const std::vector<py::array>&>(&multipolygon),  py::arg("polygons")); // auto-double
 
     // ======================================================================
     // MultiPoint<double> — full API