More tests, more bindings, some fixes (#11)

* more bindings

* more

* not ready

* to value

* update

* ready

* test more geometry collection

* test more

* more tests

* resize

* more tests

* more tests

* more tests

* more tests

* fix a bug in as_numpy

* init from json

* handle feature id

* buggy

* fix

* to rapidjson

* update version

* update release note

* some fixes

* there is still a bug in encoder/decoder

Author: district10

docs/about/release-notes.md

@@ -10,6 +10,11 @@ To upgrade `pybind11-geobuf` to the latest version, use pip:
 pip install -U pybind11-geobuf
 ```
 
+## Version 0.0.6 (2023-03-25)
+
+*   More bindings, more tests
+*   Some fixes
+
 ## Version 0.0.5 (2023-03-08)
 
 *   Add windows version

setup.py

@@ -127,7 +127,7 @@ def build_extension(self, ext):
 # logic and declaration, and simpler if you include description/version in a file.
 setup(
     name="pybind11_geobuf",
-    version="0.0.5",
+    version="0.0.6",
     author="tzx",
     author_email="dvorak4tzx@gmail.com",
     url="https://geobuf-cpp.readthedocs.io",

src/geobuf/geobuf.cpp

@@ -251,7 +251,6 @@ std::string Encoder::encode(const mapbox::geojson::geojson &geojson)
             protozero::pbf_writer pbf_g{pbf, 6};
             writeGeometry(geometry, pbf_g);
         });
-    keys.clear();
     return data;
 }
 
@@ -361,7 +360,7 @@ void Encoder::saveKey(const std::string &key)
     if (keys.find(key) != keys.end()) {
         return;
     }
-    keys.emplace(key, keys.size());
+    keys[key] = keys.size();
 }
 
 void Encoder::saveKey(const mapbox::feature::property_map &props)
@@ -606,7 +605,7 @@ void unpack_properties(mapbox::geojson::prop_map &properties,
     for (auto it = indexes.begin(); it != indexes.end();) {
         auto &key = keys[*it++];
         auto &value = values[*it++];
-        properties.emplace(key, value);
+        properties[key] = value;
     }
 }
 

src/geobuf/geobuf.hpp

@@ -6,6 +6,9 @@
 #include <protozero/pbf_builder.hpp>
 #include <protozero/pbf_reader.hpp>
 
+#include <map>
+#include <unordered_map>
+
 #define MAPBOX_GEOBUF_DEFAULT_PRECISION 6
 #define MAPBOX_GEOBUF_DEFAULT_DIM 2
 
@@ -99,6 +102,11 @@ struct Encoder
     std::string encode(const RapidjsonValue &json);
     bool encode(const std::string &input_path, const std::string &output_path);
 
+    std::map<std::string, std::uint32_t> __keys() const
+    {
+        return std::map<std::string, std::uint32_t>(keys.begin(), keys.end());
+    }
+
   private:
     void analyze(const mapbox::geojson::geojson &geojson);
     void analyzeGeometry(const mapbox::geojson::geometry &geometry);

src/geobuf/geojson_helpers.hpp

@@ -52,15 +52,24 @@ inline Eigen::Map<RowVectors> as_row_vectors(mapbox::geojson::linear_ring &geom)
 inline Eigen::Map<RowVectors>
 as_row_vectors(mapbox::geojson::multi_line_string &geom)
 {
+    if (geom.empty()) {
+        return Eigen::Map<RowVectors>((double *)0, 0, 3);
+    }
     return as_row_vectors(geom[0]);
 }
 inline Eigen::Map<RowVectors> as_row_vectors(mapbox::geojson::polygon &geom)
 {
+    if (geom.empty() || geom.front().empty()) {
+        return Eigen::Map<RowVectors>((double *)0, 0, 3);
+    }
     return as_row_vectors(&geom[0][0].x, geom[0].size());
 }
 inline Eigen::Map<RowVectors>
 as_row_vectors(mapbox::geojson::multi_polygon &geom)
 {
+    if (geom.empty()) {
+        return Eigen::Map<RowVectors>((double *)0, 0, 3);
+    }
     auto &shell = geom[0];
     return as_row_vectors(shell);
 }
@@ -117,18 +126,27 @@ as_row_vectors(const mapbox::geojson::linear_ring &geom)
 inline Eigen::Map<const RowVectors>
 as_row_vectors(const mapbox::geojson::multi_line_string &geom)
 {
+    if (geom.empty()) {
+        return Eigen::Map<const RowVectors>((const double *)0, 0, 3);
+    }
     auto &ls = geom[0];
     return Eigen::Map<const RowVectors>(&ls[0].x, ls.size(), 3);
 }
 inline Eigen::Map<const RowVectors>
 as_row_vectors(const mapbox::geojson::polygon &geom)
 {
+    if (geom.empty() || geom.front().empty()) {
+        return Eigen::Map<const RowVectors>((const double *)0, 0, 3);
+    }
     auto &shell = geom[0];
     return Eigen::Map<const RowVectors>(&shell[0].x, shell.size(), 3);
 }
 inline Eigen::Map<const RowVectors>
 as_row_vectors(const mapbox::geojson::multi_polygon &geom)
 {
+    if (geom.empty()) {
+        return Eigen::Map<const RowVectors>((const double *)0, 0, 3);
+    }
     auto &poly = geom[0];
     return as_row_vectors(poly);
 }
@@ -293,6 +311,24 @@ inline void geometry_push_back(mapbox::geojson::geometry &self,
     geometry_push_back(self, eigen2geom(point));
 }
 
+inline void geometry_push_back(mapbox::geojson::geometry &self,
+                               const Eigen::Ref<const MatrixXdRowMajor> &points)
+{
+    self.match(
+        [&](mapbox::geojson::multi_line_string &g) {
+            g.push_back({});
+            eigen2geom(points, g.back());
+        },
+        [&](mapbox::geojson::polygon &g) {
+            g.push_back({});
+            eigen2geom(points, g.back());
+        },
+        [&](auto &g) {
+            std::cerr << "geometry_push_back not handled for this type: "
+                      << geometry_type(g) << std::endl;
+        });
+}
+
 inline void geometry_push_back(mapbox::geojson::geometry &self,
                                const mapbox::geojson::geometry &geom)
 {

src/geobuf/pybind11_helpers.hpp

@@ -29,7 +29,7 @@ using RapidjsonAllocator = mapbox::geojson::rapidjson_allocator;
 using RapidjsonDocument = mapbox::geojson::rapidjson_document;
 using geojson_value = mapbox::geojson::value;
 
-inline RapidjsonValue py_int_to_rapidjson(const py::handle &obj)
+inline RapidjsonValue __py_int_to_rapidjson(const py::handle &obj)
 {
     try {
         auto num = obj.cast<int64_t>();
@@ -60,7 +60,7 @@ inline RapidjsonValue to_rapidjson(const py::handle &obj,
         return RapidjsonValue(obj.cast<bool>());
     }
     if (py::isinstance<py::int_>(obj)) {
-        return py_int_to_rapidjson(obj);
+        return __py_int_to_rapidjson(obj);
     }
     if (py::isinstance<py::float_>(obj)) {
         return RapidjsonValue(obj.cast<double>());
@@ -276,7 +276,7 @@ inline py::object to_python(const mapbox::geojson::geometry &obj)
         [&](const mapbox::geojson::geometry_collection &g) {
             py::list geometries;
             for (auto &gg : g) {
-                geometries.append(to_python(mapbox::geojson::geometry(gg)));
+                geometries.append(to_python(gg));
             }
             ret["geometries"] = geometries;
         },
@@ -295,6 +295,44 @@ inline py::object to_python(const mapbox::geojson::geometry &obj)
     return ret;
 }
 
+inline py::object to_python(const mapbox::geojson::geometry_collection &obj)
+{
+    return to_python(mapbox::geojson::geometry{obj});
+}
+
+inline py::object to_python(const mapbox::geojson::identifier &id)
+{
+    py::object ret = py::none();
+    // null_value_t, uint64_t, int64_t, double, std::string
+    id.match([&](mapbox::feature::null_value_t v) {},
+             [&](uint64_t v) { ret = py::int_(v); },
+             [&](int64_t v) { ret = py::int_(v); },
+             [&](double v) { ret = py::float_(v); },
+             [&](const std::string &v) { ret = py::str(v); },
+             [&](const auto &) -> void {});
+    return ret;
+}
+
+inline mapbox::geojson::identifier to_feature_id(const py::object &obj)
+{
+    if (obj.ptr() == nullptr || obj.is_none()) {
+        return {};
+    }
+    if (py::isinstance<py::int_>(obj)) {
+        auto val = obj.cast<long long>();
+        if (val < 0) {
+            return int64_t(val);
+        } else {
+            return uint64_t(val);
+        }
+    } else if (py::isinstance<py::float_>(obj)) {
+        return obj.cast<double>();
+    } else if (py::isinstance<py::str>(obj)) {
+        return obj.cast<std::string>();
+    }
+    return {};
+}
+
 inline py::object to_python(const mapbox::geojson::feature &f)
 {
     py::dict ret;

src/geobuf/rapidjson_helpers.hpp

@@ -1,7 +1,9 @@
 #ifndef CUBAO_RAPIDJSON_HELPERS_HPP
 #define CUBAO_RAPIDJSON_HELPERS_HPP
 
+#include <mapbox/geojson.hpp>
 #include <mapbox/geojson/rapidjson.hpp>
+#include <mapbox/geojson/value.hpp>
 
 #include "rapidjson/error/en.h"
 #include "rapidjson/filereadstream.h"
@@ -178,6 +180,98 @@ inline int __len__(const RapidjsonValue &self)
     }
     return 0;
 }
+
+struct to_value
+{
+    RapidjsonAllocator &allocator;
+
+    RapidjsonValue operator()(mapbox::geojson::null_value_t)
+    {
+        RapidjsonValue result;
+        result.SetNull();
+        return result;
+    }
+
+    RapidjsonValue operator()(bool t)
+    {
+        RapidjsonValue result;
+        result.SetBool(t);
+        return result;
+    }
+
+    RapidjsonValue operator()(int64_t t)
+    {
+        RapidjsonValue result;
+        result.SetInt64(t);
+        return result;
+    }
+
+    RapidjsonValue operator()(uint64_t t)
+    {
+        RapidjsonValue result;
+        result.SetUint64(t);
+        return result;
+    }
+
+    RapidjsonValue operator()(double t)
+    {
+        RapidjsonValue result;
+        result.SetDouble(t);
+        return result;
+    }
+
+    RapidjsonValue operator()(const std::string &t)
+    {
+        RapidjsonValue result;
+        result.SetString(t.data(), rapidjson::SizeType(t.size()), allocator);
+        return result;
+    }
+
+    RapidjsonValue operator()(const std::vector<mapbox::geojson::value> &array)
+    {
+        RapidjsonValue result;
+        result.SetArray();
+        for (const auto &item : array) {
+            result.PushBack(mapbox::geojson::value::visit(item, *this),
+                            allocator);
+        }
+        return result;
+    }
+
+    RapidjsonValue operator()(
+        const std::unordered_map<std::string, mapbox::geojson::value> &map)
+    {
+        RapidjsonValue result;
+        result.SetObject();
+        for (const auto &property : map) {
+            result.AddMember(
+                RapidjsonValue(property.first.data(),
+                               rapidjson::SizeType(property.first.size()),
+                               allocator),
+                mapbox::geojson::value::visit(property.second, *this),
+                allocator);
+        }
+        return result;
+    }
+};
+
+inline RapidjsonValue to_rapidjson(const mapbox::geojson::value &json,
+                                   RapidjsonAllocator &allocator)
+{
+    return mapbox::geojson::value::visit(json, cubao::to_value{allocator});
+}
+
+inline RapidjsonValue to_rapidjson(const mapbox::geojson::value &json)
+{
+    RapidjsonAllocator allocator;
+    return to_rapidjson(json, allocator);
+}
+
+// inline mapbox::geojson::value to_geojson_value(const RapidjsonValue &json)
+// {
+//     return mapbox::geojson::convert<mapbox::geojson::value>(json);
+// }
+
 } // namespace cubao
 
 #endif

src/main.cpp

@@ -141,6 +141,7 @@ PYBIND11_MODULE(_pybind11_geobuf, m)
              py::overload_cast<const std::string &, const std::string &>(
                  &Encoder::encode),
              py::kw_only(), "geojson"_a, "geobuf"_a)
+        .def("keys", &Encoder::__keys)
         //
         ;