Add a pybind11 type caster for GCAgg and its requirements

Author: QuLogic

src/_backend_agg_wrapper.cpp

@@ -1,5 +1,6 @@
 #include <pybind11/pybind11.h>
 #include <pybind11/numpy.h>
+#include <pybind11/stl.h>
 #include "mplutils.h"
 #include "numpy_cpp.h"
 #include "py_converters.h"
@@ -41,18 +42,13 @@ PyBufferRegion_get_extents(BufferRegion *self)
 
 static void
 PyRendererAgg_draw_path(RendererAgg *self,
-                        py::object gc_obj,
+                        GCAgg &gc,
                         mpl::PathIterator path,
                         agg::trans_affine trans,
                         py::object face_obj)
 {
-    GCAgg gc;
     agg::rgba face;
 
-    if (!convert_gcagg(gc_obj.ptr(), &gc)) {
-        throw py::error_already_set();
-    }
-
     if (!convert_face(face_obj.ptr(), gc, &face)) {
         throw py::error_already_set();
     }
@@ -66,37 +62,28 @@ PyRendererAgg_draw_text_image(RendererAgg *self,
                               double x,
                               double y,
                               double angle,
-                              py::object gc_obj)
+                              GCAgg &gc)
 {
     numpy::array_view<agg::int8u, 2> image;
-    GCAgg gc;
 
     if (!image.converter_contiguous(image_obj.ptr(), &image)) {
         throw py::error_already_set();
     }
-    if (!convert_gcagg(gc_obj.ptr(), &gc)) {
-        throw py::error_already_set();
-    }
 
     self->draw_text_image(gc, image, x, y, angle);
 }
 
 static void
 PyRendererAgg_draw_markers(RendererAgg *self,
-                           py::object gc_obj,
+                           GCAgg &gc,
                            mpl::PathIterator marker_path,
                            agg::trans_affine marker_path_trans,
                            mpl::PathIterator path,
                            agg::trans_affine trans,
                            py::object face_obj)
 {
-    GCAgg gc;
     agg::rgba face;
 
-    if (!convert_gcagg(gc_obj.ptr(), &gc)) {
-        throw py::error_already_set();
-    }
-
     if (!convert_face(face_obj.ptr(), gc, &face)) {
         throw py::error_already_set();
     }
@@ -106,17 +93,13 @@ PyRendererAgg_draw_markers(RendererAgg *self,
 
 static void
 PyRendererAgg_draw_image(RendererAgg *self,
-                         py::object gc_obj,
+                         GCAgg &gc,
                          double x,
                          double y,
                          py::array_t<agg::int8u, py::array::c_style> image_obj)
 {
-    GCAgg gc;
     numpy::array_view<agg::int8u, 3> image;
 
-    if (!convert_gcagg(gc_obj.ptr(), &gc)) {
-        throw py::error_already_set();
-    }
     if (!image.set(image_obj.ptr())) {
         throw py::error_already_set();
     }
@@ -130,7 +113,7 @@ PyRendererAgg_draw_image(RendererAgg *self,
 
 static void
 PyRendererAgg_draw_path_collection(RendererAgg *self,
-                                   py::object gc_obj,
+                                   GCAgg &gc,
                                    agg::trans_affine master_transform,
                                    py::object paths_obj,
                                    py::object transforms_obj,
@@ -139,25 +122,20 @@ PyRendererAgg_draw_path_collection(RendererAgg *self,
                                    py::object facecolors_obj,
                                    py::object edgecolors_obj,
                                    py::object linewidths_obj,
-                                   py::object dashes_obj,
+                                   DashesVector dashes,
                                    py::object antialiaseds_obj,
                                    py::object Py_UNUSED(ignored_obj),
                                    // offset position is no longer used
                                    py::object Py_UNUSED(offset_position_obj))
 {
-    GCAgg gc;
     mpl::PathGenerator paths;
     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;
-    DashesVector dashes;
     numpy::array_view<const uint8_t, 1> antialiaseds;
 
-    if (!convert_gcagg(gc_obj.ptr(), &gc)) {
-        throw py::error_already_set();
-    }
     if (!convert_pathgen(paths_obj.ptr(), &paths)) {
         throw py::error_already_set();
     }
@@ -176,9 +154,6 @@ PyRendererAgg_draw_path_collection(RendererAgg *self,
     if (!linewidths.converter(linewidths_obj.ptr(), &linewidths)) {
         throw py::error_already_set();
     }
-    if (!convert_dashes_vector(dashes_obj.ptr(), &dashes)) {
-        throw py::error_already_set();
-    }
     if (!antialiaseds.converter(antialiaseds_obj.ptr(), &antialiaseds)) {
         throw py::error_already_set();
     }
@@ -198,7 +173,7 @@ PyRendererAgg_draw_path_collection(RendererAgg *self,
 
 static void
 PyRendererAgg_draw_quad_mesh(RendererAgg *self,
-                             py::object gc_obj,
+                             GCAgg &gc,
                              agg::trans_affine master_transform,
                              unsigned int mesh_width,
                              unsigned int mesh_height,
@@ -209,15 +184,11 @@ PyRendererAgg_draw_quad_mesh(RendererAgg *self,
                              bool antialiased,
                              py::object edgecolors_obj)
 {
-    GCAgg gc;
     numpy::array_view<const double, 3> coordinates;
     numpy::array_view<const double, 2> offsets;
     numpy::array_view<const double, 2> facecolors;
     numpy::array_view<const double, 2> edgecolors;
 
-    if (!convert_gcagg(gc_obj.ptr(), &gc)) {
-        throw py::error_already_set();
-    }
     if (!coordinates.converter(coordinates_obj.ptr(), &coordinates)) {
         throw py::error_already_set();
     }
@@ -245,18 +216,14 @@ PyRendererAgg_draw_quad_mesh(RendererAgg *self,
 
 static void
 PyRendererAgg_draw_gouraud_triangles(RendererAgg *self,
-                                     py::object gc_obj,
+                                     GCAgg &gc,
                                      py::object points_obj,
                                      py::object colors_obj,
                                      agg::trans_affine trans)
 {
-    GCAgg gc;
     numpy::array_view<const double, 3> points;
     numpy::array_view<const double, 3> colors;
 
-    if (!convert_gcagg(gc_obj.ptr(), &gc)) {
-        throw py::error_already_set();
-    }
     if (!points.converter(points_obj.ptr(), &points)) {
         throw py::error_already_set();
     }

src/py_converters.cpp

@@ -415,8 +415,6 @@ int convert_pathgen(PyObject *obj, void *pathgenp)
 int convert_clippath(PyObject *clippath_tuple, void *clippathp)
 {
     ClipPath *clippath = (ClipPath *)clippathp;
-    mpl::PathIterator path;
-    agg::trans_affine trans;
 
     if (clippath_tuple != NULL && clippath_tuple != Py_None) {
         if (!PyArg_ParseTuple(clippath_tuple,

src/py_converters_11.h

@@ -8,6 +8,8 @@
 
 namespace py = pybind11;
 
+#include <unordered_map>
+
 #include "agg_basics.h"
 #include "agg_color_rgba.h"
 #include "agg_trans_affine.h"
@@ -135,6 +137,37 @@ namespace PYBIND11_NAMESPACE { namespace detail {
 
 /* Remove all this macro magic after dropping NumPy usage and just include `py_adaptors.h`. */
 #ifdef MPL_PY_ADAPTORS_H
+    template <> struct type_caster<agg::line_cap_e> {
+    public:
+        PYBIND11_TYPE_CASTER(agg::line_cap_e, const_name("line_cap_e"));
+
+        bool load(handle src, bool) {
+            const std::unordered_map<std::string, agg::line_cap_e> enum_values = {
+                {"butt", agg::butt_cap},
+                {"round", agg::round_cap},
+                {"projecting", agg::square_cap},
+            };
+            value = enum_values.at(src.cast<std::string>());
+            return true;
+        }
+    };
+
+    template <> struct type_caster<agg::line_join_e> {
+    public:
+        PYBIND11_TYPE_CASTER(agg::line_join_e, const_name("line_join_e"));
+
+        bool load(handle src, bool) {
+            const std::unordered_map<std::string, agg::line_join_e> enum_values = {
+                {"miter", agg::miter_join_revert},
+                {"round", agg::round_join},
+                {"bevel", agg::bevel_join},
+            };
+            value = agg::miter_join_revert;
+            value = enum_values.at(src.cast<std::string>());
+            return true;
+        }
+    };
+
     template <> struct type_caster<mpl::PathIterator> {
     public:
         PYBIND11_TYPE_CASTER(mpl::PathIterator, const_name("PathIterator"));
@@ -144,14 +177,14 @@ namespace PYBIND11_NAMESPACE { namespace detail {
                 return true;
             }
 
-            auto vertices = src.attr("vertices");
-            auto codes = src.attr("codes");
+            py::object vertices = src.attr("vertices");
+            py::object codes = src.attr("codes");
             auto should_simplify = src.attr("should_simplify").cast<bool>();
             auto simplify_threshold = src.attr("simplify_threshold").cast<double>();
 
-            if (!value.set(vertices.ptr(), codes.ptr(),
+            if (!value.set(vertices.inc_ref().ptr(), codes.inc_ref().ptr(),
                            should_simplify, simplify_threshold)) {
-                return false;
+                throw py::error_already_set();
             }
 
             return true;
@@ -161,6 +194,64 @@ namespace PYBIND11_NAMESPACE { namespace detail {
 
 /* Remove all this macro magic after dropping NumPy usage and just include `_backend_agg_basic_types.h`. */
 #ifdef MPL_BACKEND_AGG_BASIC_TYPES_H
+#  ifndef MPL_PY_ADAPTORS_H
+#    error "py_adaptors.h must be included to get Agg type casters"
+#  endif
+
+    template <> struct type_caster<ClipPath> {
+    public:
+        PYBIND11_TYPE_CASTER(ClipPath, const_name("ClipPath"));
+
+        bool load(handle src, bool) {
+            if (src.is_none()) {
+                return true;
+            }
+
+            auto clippath_tuple = src.cast<py::tuple>();
+
+            auto path = clippath_tuple[0];
+            if (!path.is_none()) {
+                value.path = path.cast<mpl::PathIterator>();
+            }
+            value.trans = clippath_tuple[1].cast<agg::trans_affine>();
+
+            return true;
+        }
+    };
+
+    template <> struct type_caster<Dashes> {
+    public:
+        PYBIND11_TYPE_CASTER(Dashes, const_name("Dashes"));
+
+        bool load(handle src, bool) {
+            auto dash_tuple = src.cast<py::tuple>();
+            auto dash_offset = dash_tuple[0].cast<double>();
+            auto dashes_seq_or_none = dash_tuple[1];
+
+            if (dashes_seq_or_none.is_none()) {
+                return true;
+            }
+
+            auto dashes_seq = dashes_seq_or_none.cast<py::sequence>();
+
+            auto nentries = dashes_seq.size();
+            // If the dashpattern has odd length, iterate through it twice (in
+            // accordance with the pdf/ps/svg specs).
+            auto dash_pattern_length = (nentries % 2) ? 2 * nentries : nentries;
+
+            for (py::size_t i = 0; i < dash_pattern_length; i += 2) {
+                auto length = dashes_seq[i % nentries].cast<double>();
+                auto skip = dashes_seq[(i + 1) % nentries].cast<double>();
+
+                value.add_dash_pair(length, skip);
+            }
+
+            value.set_dash_offset(dash_offset);
+
+            return true;
+        }
+    };
+
     template <> struct type_caster<SketchParams> {
     public:
         PYBIND11_TYPE_CASTER(SketchParams, const_name("SketchParams"));
@@ -179,6 +270,32 @@ namespace PYBIND11_NAMESPACE { namespace detail {
             return true;
         }
     };
+
+    template <> struct type_caster<GCAgg> {
+    public:
+        PYBIND11_TYPE_CASTER(GCAgg, const_name("GCAgg"));
+
+        bool load(handle src, bool) {
+            value.linewidth = src.attr("_linewidth").cast<double>();
+            value.alpha = src.attr("_alpha").cast<double>();
+            value.forced_alpha = src.attr("_forced_alpha").cast<bool>();
+            value.color = src.attr("_rgb").cast<agg::rgba>();
+            value.isaa = src.attr("_antialiased").cast<bool>();
+            value.cap = src.attr("_capstyle").cast<agg::line_cap_e>();
+            value.join = src.attr("_joinstyle").cast<agg::line_join_e>();
+            value.dashes = src.attr("get_dashes")().cast<Dashes>();
+            value.cliprect = src.attr("_cliprect").cast<agg::rect_d>();
+            /* value.clippath = src.attr("get_clip_path")().cast<ClipPath>(); */
+            convert_clippath(src.attr("get_clip_path")().ptr(), &value.clippath);
+            value.snap_mode = src.attr("get_snap")().cast<e_snap_mode>();
+            value.hatchpath = src.attr("get_hatch_path")().cast<mpl::PathIterator>();
+            value.hatch_color = src.attr("get_hatch_color")().cast<agg::rgba>();
+            value.hatch_linewidth = src.attr("get_hatch_linewidth")().cast<double>();
+            value.sketch = src.attr("get_sketch_params")().cast<SketchParams>();
+
+            return true;
+        }
+    };
 #endif
 }} // namespace PYBIND11_NAMESPACE::detail