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"
@@ -40,17 +41,11 @@ PyBufferRegion_get_extents(BufferRegion *self)
 
 static void
 PyRendererAgg_draw_path(RendererAgg *self,
-                        pybind11::object gc_obj,
+                        GCAgg &gc,
                         mpl::PathIterator path,
                         agg::trans_affine trans,
                         agg::rgba face)
 {
-    GCAgg gc;
-
-    if (!convert_gcagg(gc_obj.ptr(), &gc)) {
-        throw pybind11::error_already_set();
-    }
-
     self->draw_path(gc, path, trans, face);
 }
 
@@ -60,52 +55,38 @@ PyRendererAgg_draw_text_image(RendererAgg *self,
                               double x,
                               double y,
                               double angle,
-                              pybind11::object gc_obj)
+                              GCAgg &gc)
 {
     numpy::array_view<agg::int8u, 2> image;
-    GCAgg gc;
 
     if (!image.converter_contiguous(image_obj.ptr(), &image)) {
         throw pybind11::error_already_set();
     }
-    if (!convert_gcagg(gc_obj.ptr(), &gc)) {
-        throw pybind11::error_already_set();
-    }
 
     self->draw_text_image(gc, image, x, y, angle);
 }
 
 static void
 PyRendererAgg_draw_markers(RendererAgg *self,
-                           pybind11::object gc_obj,
+                           GCAgg &gc,
                            mpl::PathIterator marker_path,
                            agg::trans_affine marker_path_trans,
                            mpl::PathIterator path,
                            agg::trans_affine trans,
                            agg::rgba face)
 {
-    GCAgg gc;
-
-    if (!convert_gcagg(gc_obj.ptr(), &gc)) {
-        throw pybind11::error_already_set();
-    }
-
     self->draw_markers(gc, marker_path, marker_path_trans, path, trans, face);
 }
 
 static void
 PyRendererAgg_draw_image(RendererAgg *self,
-                         pybind11::object gc_obj,
+                         GCAgg &gc,
                          double x,
                          double y,
                          pybind11::array_t<agg::int8u, pybind11::array::c_style> image_obj)
 {
-    GCAgg gc;
     numpy::array_view<agg::int8u, 3> image;
 
-    if (!convert_gcagg(gc_obj.ptr(), &gc)) {
-        throw pybind11::error_already_set();
-    }
     if (!image.set(image_obj.ptr())) {
         throw pybind11::error_already_set();
     }
@@ -119,7 +100,7 @@ PyRendererAgg_draw_image(RendererAgg *self,
 
 static void
 PyRendererAgg_draw_path_collection(RendererAgg *self,
-                                   pybind11::object gc_obj,
+                                   GCAgg &gc,
                                    agg::trans_affine master_transform,
                                    pybind11::object paths_obj,
                                    pybind11::object transforms_obj,
@@ -128,25 +109,20 @@ PyRendererAgg_draw_path_collection(RendererAgg *self,
                                    pybind11::object facecolors_obj,
                                    pybind11::object edgecolors_obj,
                                    pybind11::object linewidths_obj,
-                                   pybind11::object dashes_obj,
+                                   DashesVector dashes,
                                    pybind11::object antialiaseds_obj,
                                    pybind11::object Py_UNUSED(ignored_obj),
                                    // offset position is no longer used
                                    pybind11::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 pybind11::error_already_set();
-    }
     if (!convert_pathgen(paths_obj.ptr(), &paths)) {
         throw pybind11::error_already_set();
     }
@@ -165,9 +141,6 @@ PyRendererAgg_draw_path_collection(RendererAgg *self,
     if (!linewidths.converter(linewidths_obj.ptr(), &linewidths)) {
         throw pybind11::error_already_set();
     }
-    if (!convert_dashes_vector(dashes_obj.ptr(), &dashes)) {
-        throw pybind11::error_already_set();
-    }
     if (!antialiaseds.converter(antialiaseds_obj.ptr(), &antialiaseds)) {
         throw pybind11::error_already_set();
     }
@@ -187,7 +160,7 @@ PyRendererAgg_draw_path_collection(RendererAgg *self,
 
 static void
 PyRendererAgg_draw_quad_mesh(RendererAgg *self,
-                             pybind11::object gc_obj,
+                             GCAgg &gc,
                              agg::trans_affine master_transform,
                              unsigned int mesh_width,
                              unsigned int mesh_height,
@@ -198,15 +171,11 @@ PyRendererAgg_draw_quad_mesh(RendererAgg *self,
                              bool antialiased,
                              pybind11::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 pybind11::error_already_set();
-    }
     if (!coordinates.converter(coordinates_obj.ptr(), &coordinates)) {
         throw pybind11::error_already_set();
     }
@@ -234,18 +203,14 @@ PyRendererAgg_draw_quad_mesh(RendererAgg *self,
 
 static void
 PyRendererAgg_draw_gouraud_triangles(RendererAgg *self,
-                                     pybind11::object gc_obj,
+                                     GCAgg &gc,
                                      pybind11::object points_obj,
                                      pybind11::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 pybind11::error_already_set();
-    }
     if (!points.converter(points_obj.ptr(), &points)) {
         throw pybind11::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 <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::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::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"));
@@ -161,6 +194,59 @@ 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
+    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<std::tuple<pybind11::object, agg::trans_affine>>();
+
+            if (!convert_path(std::get<0>(clippath_tuple).ptr(), &value.path)) {
+                throw pybind11::error_already_set();
+            }
+            value.trans = std::get<1>(clippath_tuple);
+
+            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<std::tuple<double, pybind11::object>>();
+            auto dash_offset = std::get<0>(dash_tuple);
+            auto dashes_seq_or_none = std::get<1>(dash_tuple);
+
+            if (dashes_seq_or_none.is_none()) {
+                return true;
+            }
+
+            auto dashes_seq = dashes_seq_or_none.cast<pybind11::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 (pybind11::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"));
@@ -177,6 +263,31 @@ 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>();
+            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