Convert remaining array_view to pybind11 array_t

Author: QuLogic

src/_backend_agg_wrapper.cpp

@@ -112,43 +112,24 @@ PyRendererAgg_draw_path_collection(RendererAgg *self,
                                    GCAgg &gc,
                                    agg::trans_affine master_transform,
                                    mpl::PathGenerator paths,
-                                   py::object transforms_obj,
-                                   py::object offsets_obj,
+                                   py::array_t<double> transforms_obj,
+                                   py::array_t<double> offsets_obj,
                                    agg::trans_affine offset_trans,
-                                   py::object facecolors_obj,
-                                   py::object edgecolors_obj,
-                                   py::object linewidths_obj,
+                                   py::array_t<double> facecolors_obj,
+                                   py::array_t<double> edgecolors_obj,
+                                   py::array_t<double> linewidths_obj,
                                    DashesVector dashes,
-                                   py::object antialiaseds_obj,
+                                   py::array_t<uint8_t> antialiaseds_obj,
                                    py::object Py_UNUSED(ignored_obj),
                                    // offset position is no longer used
                                    py::object Py_UNUSED(offset_position_obj))
 {
-    numpy::array_view<const double, 3> transforms;
-    numpy::array_view<const double, 2> offsets;
-    numpy::array_view<const double, 2> facecolors;
-    numpy::array_view<const double, 2> edgecolors;
-    numpy::array_view<const double, 1> linewidths;
-    numpy::array_view<const uint8_t, 1> antialiaseds;
-
-    if (!convert_transforms(transforms_obj.ptr(), &transforms)) {
-        throw py::error_already_set();
-    }
-    if (!convert_points(offsets_obj.ptr(), &offsets)) {
-        throw py::error_already_set();
-    }
-    if (!convert_colors(facecolors_obj.ptr(), &facecolors)) {
-        throw py::error_already_set();
-    }
-    if (!convert_colors(edgecolors_obj.ptr(), &edgecolors)) {
-        throw py::error_already_set();
-    }
-    if (!linewidths.converter(linewidths_obj.ptr(), &linewidths)) {
-        throw py::error_already_set();
-    }
-    if (!antialiaseds.converter(antialiaseds_obj.ptr(), &antialiaseds)) {
-        throw py::error_already_set();
-    }
+    auto transforms = convert_transforms(transforms_obj);
+    auto offsets = convert_points(offsets_obj);
+    auto facecolors = convert_colors(facecolors_obj);
+    auto edgecolors = convert_colors(edgecolors_obj);
+    auto linewidths = linewidths_obj.unchecked<1>();
+    auto antialiaseds = antialiaseds_obj.unchecked<1>();
 
     self->draw_path_collection(gc,
             master_transform,
@@ -170,26 +151,16 @@ PyRendererAgg_draw_quad_mesh(RendererAgg *self,
                              unsigned int mesh_width,
                              unsigned int mesh_height,
                              py::array_t<double, py::array::c_style | py::array::forcecast> coordinates_obj,
-                             py::object offsets_obj,
+                             py::array_t<double> offsets_obj,
                              agg::trans_affine offset_trans,
-                             py::object facecolors_obj,
+                             py::array_t<double> facecolors_obj,
                              bool antialiased,
-                             py::object edgecolors_obj)
+                             py::array_t<double> edgecolors_obj)
 {
-    numpy::array_view<const double, 2> offsets;
-    numpy::array_view<const double, 2> facecolors;
-    numpy::array_view<const double, 2> edgecolors;
-
     auto coordinates = coordinates_obj.mutable_unchecked<3>();
-    if (!convert_points(offsets_obj.ptr(), &offsets)) {
-        throw py::error_already_set();
-    }
-    if (!convert_colors(facecolors_obj.ptr(), &facecolors)) {
-        throw py::error_already_set();
-    }
-    if (!convert_colors(edgecolors_obj.ptr(), &edgecolors)) {
-        throw py::error_already_set();
-    }
+    auto offsets = convert_points(offsets_obj);
+    auto facecolors = convert_colors(facecolors_obj);
+    auto edgecolors = convert_colors(edgecolors_obj);
 
     self->draw_quad_mesh(gc,
             master_transform,

src/_path.h

@@ -245,8 +245,7 @@ inline void points_in_path(PointArray &points,
     typedef agg::conv_curve<no_nans_t> curve_t;
     typedef agg::conv_contour<curve_t> contour_t;
 
-    size_t i;
-    for (i = 0; i < safe_first_shape(points); ++i) {
+    for (auto i = 0; i < safe_first_shape(points); ++i) {
         result[i] = false;
     }
 
@@ -270,10 +269,11 @@ template <class PathIterator>
 inline bool point_in_path(
     double x, double y, const double r, PathIterator &path, agg::trans_affine &trans)
 {
-    npy_intp shape[] = {1, 2};
-    numpy::array_view<double, 2> points(shape);
-    points(0, 0) = x;
-    points(0, 1) = y;
+    py::ssize_t shape[] = {1, 2};
+    py::array_t<double> points_arr(shape);
+    *points_arr.mutable_data(0, 0) = x;
+    *points_arr.mutable_data(0, 1) = y;
+    auto points = points_arr.mutable_unchecked<2>();
 
     int result[1];
     result[0] = 0;
@@ -292,10 +292,11 @@ inline bool point_on_path(
     typedef agg::conv_curve<no_nans_t> curve_t;
     typedef agg::conv_stroke<curve_t> stroke_t;
 
-    npy_intp shape[] = {1, 2};
-    numpy::array_view<double, 2> points(shape);
-    points(0, 0) = x;
-    points(0, 1) = y;
+    py::ssize_t shape[] = {1, 2};
+    py::array_t<double> points_arr(shape);
+    *points_arr.mutable_data(0, 0) = x;
+    *points_arr.mutable_data(0, 1) = y;
+    auto points = points_arr.mutable_unchecked<2>();
 
     int result[1];
     result[0] = 0;
@@ -382,20 +383,19 @@ void get_path_collection_extents(agg::trans_affine &master_transform,
         throw std::runtime_error("Offsets array must have shape (N, 2)");
     }
 
-    size_t Npaths = paths.size();
-    size_t Noffsets = safe_first_shape(offsets);
-    size_t N = std::max(Npaths, Noffsets);
-    size_t Ntransforms = std::min(safe_first_shape(transforms), N);
-    size_t i;
+    auto Npaths = paths.size();
+    auto Noffsets = safe_first_shape(offsets);
+    auto N = std::max(Npaths, Noffsets);
+    auto Ntransforms = std::min(safe_first_shape(transforms), N);
 
     agg::trans_affine trans;
 
     reset_limits(extent);
 
-    for (i = 0; i < N; ++i) {
+    for (auto i = 0; i < N; ++i) {
         typename PathGenerator::path_iterator path(paths(i % Npaths));
         if (Ntransforms) {
-            size_t ti = i % Ntransforms;
+            py::ssize_t ti = i % Ntransforms;
             trans = agg::trans_affine(transforms(ti, 0, 0),
                                       transforms(ti, 1, 0),
                                       transforms(ti, 0, 1),
@@ -429,24 +429,23 @@ void point_in_path_collection(double x,
                               bool filled,
                               std::vector<int> &result)
 {
-    size_t Npaths = paths.size();
+    auto Npaths = paths.size();
 
     if (Npaths == 0) {
         return;
     }
 
-    size_t Noffsets = safe_first_shape(offsets);
-    size_t N = std::max(Npaths, Noffsets);
-    size_t Ntransforms = std::min(safe_first_shape(transforms), N);
-    size_t i;
+    auto Noffsets = safe_first_shape(offsets);
+    auto N = std::max(Npaths, Noffsets);
+    auto Ntransforms = std::min(safe_first_shape(transforms), N);
 
     agg::trans_affine trans;
 
-    for (i = 0; i < N; ++i) {
+    for (auto i = 0; i < N; ++i) {
         typename PathGenerator::path_iterator path = paths(i % Npaths);
 
         if (Ntransforms) {
-            size_t ti = i % Ntransforms;
+            auto ti = i % Ntransforms;
             trans = agg::trans_affine(transforms(ti, 0, 0),
                                       transforms(ti, 1, 0),
                                       transforms(ti, 0, 1),

src/_path_wrapper.cpp

@@ -44,17 +44,9 @@ static py::array_t<double>
 Py_points_in_path(py::array_t<double> points_obj, double r, mpl::PathIterator path,
                   agg::trans_affine trans)
 {
-    numpy::array_view<double, 2> points;
+    auto points = convert_points(points_obj);
 
-    if (!convert_points(points_obj.ptr(), &points)) {
-        throw py::error_already_set();
-    }
-
-    if (!check_trailing_shape(points, "points", 2)) {
-        throw py::error_already_set();
-    }
-
-    py::ssize_t dims[] = { static_cast<py::ssize_t>(points.size()) };
+    py::ssize_t dims[] = { points.shape(0) };
     py::array_t<uint8_t> results(dims);
     auto results_mutable = results.mutable_unchecked<1>();
 
@@ -123,20 +115,15 @@ Py_update_path_extents(mpl::PathIterator path, agg::trans_affine trans,
 
 static py::tuple
 Py_get_path_collection_extents(agg::trans_affine master_transform,
-                               mpl::PathGenerator paths, py::object transforms_obj,
-                               py::object offsets_obj, agg::trans_affine offset_trans)
+                               mpl::PathGenerator paths,
+                               py::array_t<double> transforms_obj,
+                               py::array_t<double> offsets_obj,
+                               agg::trans_affine offset_trans)
 {
-    numpy::array_view<const double, 3> transforms;
-    numpy::array_view<const double, 2> offsets;
+    auto transforms = convert_transforms(transforms_obj);
+    auto offsets = convert_points(offsets_obj);
     extent_limits e;
 
-    if (!convert_transforms(transforms_obj.ptr(), &transforms)) {
-        throw py::error_already_set();
-    }
-    if (!convert_points(offsets_obj.ptr(), &offsets)) {
-        throw py::error_already_set();
-    }
-
     get_path_collection_extents(
         master_transform, paths, transforms, offsets, offset_trans, e);
 
@@ -158,20 +145,14 @@ Py_get_path_collection_extents(agg::trans_affine master_transform,
 static py::object
 Py_point_in_path_collection(double x, double y, double radius,
                             agg::trans_affine master_transform, mpl::PathGenerator paths,
-                            py::object transforms_obj, py::object offsets_obj,
+                            py::array_t<double> transforms_obj,
+                            py::array_t<double> offsets_obj,
                             agg::trans_affine offset_trans, bool filled)
 {
-    numpy::array_view<const double, 3> transforms;
-    numpy::array_view<const double, 2> offsets;
+    auto transforms = convert_transforms(transforms_obj);
+    auto offsets = convert_points(offsets_obj);
     std::vector<int> result;
 
-    if (!convert_transforms(transforms_obj.ptr(), &transforms)) {
-        throw py::error_already_set();
-    }
-    if (!convert_points(offsets_obj.ptr(), &offsets)) {
-        throw py::error_already_set();
-    }
-
     point_in_path_collection(x, y, radius, master_transform, paths, transforms, offsets,
                              offset_trans, filled, result);
 
@@ -229,13 +210,9 @@ Py_affine_transform(py::array_t<double, py::array::c_style | py::array::forcecas
 }
 
 static int
-Py_count_bboxes_overlapping_bbox(agg::rect_d bbox, py::object bboxes_obj)
+Py_count_bboxes_overlapping_bbox(agg::rect_d bbox, py::array_t<double> bboxes_obj)
 {
-    numpy::array_view<const double, 3> bboxes;
-
-    if (!convert_bboxes(bboxes_obj.ptr(), &bboxes)) {
-        throw py::error_already_set();
-    }
+    auto bboxes = convert_bboxes(bboxes_obj);
 
     return count_bboxes_overlapping_bbox(bbox, bboxes);
 }

src/mplutils.h

@@ -67,6 +67,10 @@ inline int prepare_and_add_type(PyTypeObject *type, PyObject *module)
 #ifdef __cplusplus  // not for macosx.m
 // Check that array has shape (N, d1) or (N, d1, d2).  We cast d1, d2 to longs
 // so that we don't need to access the NPY_INTP_FMT macro here.
+#include <pybind11/pybind11.h>
+#include <pybind11/numpy.h>
+
+namespace py = pybind11;
 
 template<typename T>
 inline bool check_trailing_shape(T array, char const* name, long d1)
@@ -113,6 +117,25 @@ inline bool check_trailing_shape(T array, char const* name, long d1, long d2)
     }
     return true;
 }
+
+/* In most cases, code should use safe_first_shape(obj) instead of obj.shape(0), since
+   safe_first_shape(obj) == 0 when any dimension is 0. */
+template <typename T, py::ssize_t ND>
+py::ssize_t
+safe_first_shape(const py::detail::unchecked_reference<T, ND> &a)
+{
+    bool empty = (ND == 0);
+    for (py::ssize_t i = 0; i < ND; i++) {
+        if (a.shape(i) == 0) {
+            empty = true;
+        }
+    }
+    if (empty) {
+        return 0;
+    } else {
+        return a.shape(0);
+    }
+}
 #endif
 
 #endif

src/py_converters_11.h

@@ -17,6 +17,38 @@ namespace py = pybind11;
 
 void convert_trans_affine(const py::object& transform, agg::trans_affine& affine);
 
+inline auto convert_points(py::array_t<double> obj)
+{
+    if (!check_trailing_shape(obj, "points", 2)) {
+        throw py::error_already_set();
+    }
+    return obj.unchecked<2>();
+}
+
+inline auto convert_transforms(py::array_t<double> obj)
+{
+    if (!check_trailing_shape(obj, "transforms", 3, 3)) {
+        throw py::error_already_set();
+    }
+    return obj.unchecked<3>();
+}
+
+inline auto convert_bboxes(py::array_t<double> obj)
+{
+    if (!check_trailing_shape(obj, "bbox array", 2, 2)) {
+        throw py::error_already_set();
+    }
+    return obj.unchecked<3>();
+}
+
+inline auto convert_colors(py::array_t<double> obj)
+{
+    if (!check_trailing_shape(obj, "colors", 4)) {
+        throw py::error_already_set();
+    }
+    return obj.unchecked<2>();
+}
+
 namespace PYBIND11_NAMESPACE { namespace detail {
     template <> struct type_caster<agg::rect_d> {
     public: