cairo_circles.

Author: anntzer

CHANGELOG.rst

@@ -1,7 +1,10 @@
 v0.1a2
 ======
 
-- Switched to ``dlopen``\ing Raqm.
+- Switch to ``dlopen``\ing Raqm.
+- Allow control of circle-drawing algorithm.
+- Add ``set_option``, ``get_option``.
+- Various bug, performance, and build fixes.
 
 v0.1a1
 ======

README.rst

@@ -248,8 +248,8 @@ other hand, this is currently the only way in which the webagg-based backends
 (e.g., Jupyter's inline widget) are supported.
 
 At import-time, mplcairo will attempt to load Raqm_.  The use of that library
-can be controlled and checked using the ``load_raqm``, ``unload_raqm``, and
-``has_raqm`` functions.
+can be controlled and checked using ``set_options`` and ``get_options``
+functions.
 
 The ``examples`` directory contains a few cases where the output of this
 renderer is arguably more accurate than the one of the default renderer, Agg:

lib/mplcairo/__init__.py

@@ -11,7 +11,6 @@
     except ImportError:
         pass
 
-
 if sys.platform != "win32":
     def _load_symbols():
         # dlopen() pycairo's extension module with RTLD_GLOBAL to dynamically
@@ -22,6 +21,12 @@ def _load_symbols():
 
     _load_symbols()
 
-from ._mplcairo import antialias_t, load_raqm, unload_raqm, has_raqm
+from ._mplcairo import antialias_t, get_options, set_options
+
+__all__ = ["antialias_t", "get_options", "set_options"]
 
-__all__ = ["antialias_t", "load_raqm", "unload_raqm", "has_raqm"]
+set_options(cairo_circles=True)
+try:
+    set_options(raqm=True)
+except RuntimeError:
+    pass

src/_mplcairo.cpp

@@ -1433,11 +1433,6 @@ PYBIND11_MODULE(_mplcairo, m)
 {
   m.doc() = "A cairo backend for matplotlib.";
 
-  try {
-    load_raqm();
-  } catch (std::runtime_error&) {
-  }
-
   // Setup global values.
 
 #ifndef _WIN32
@@ -1473,8 +1468,6 @@ PYBIND11_MODULE(_mplcairo, m)
 
   FT_CHECK(FT_Init_FreeType, &detail::ft_library);
 
-  detail::UNIT_CIRCLE =
-    py::module::import("matplotlib.path").attr("Path").attr("unit_circle")();
   detail::PIXEL_MARKER =
     py::module::import("matplotlib.markers").attr("MarkerStyle")(",");
   GraphicsContextRenderer::mathtext_parser_ =
@@ -1526,14 +1519,43 @@ PYBIND11_MODULE(_mplcairo, m)
 
   // Export functions.
   m.def(
-    "load_raqm", &load_raqm,
-    "Load raqm.  Raises an exception on failure.");
-  m.def(
-    "unload_raqm", &unload_raqm,
-    "Unload raqm.  Raises an exception on failure.");
+    "set_options", [](py::kwargs kwargs) -> void {
+      // FIXME[pybind11]: Redo once they pybind11 has kwonly args.
+      auto pop_option = [&](std::string key) -> std::optional<bool> {
+        return kwargs.attr("pop")(key, py::none()).cast<std::optional<bool>>();
+      };
+      if (auto cairo_circles = pop_option("cairo_circles")) {
+        detail::UNIT_CIRCLE =
+          *cairo_circles
+          ? py::module::import("matplotlib.path").attr("Path")
+            .attr("unit_circle")()
+          : py::none{};
+      }
+      if (auto raqm = pop_option("raqm")) {
+        if (*raqm) {
+          load_raqm();
+        } else {
+          unload_raqm();
+        }
+      }
+      if (py::bool_(kwargs)) {
+        throw std::runtime_error("Unknown options passed to set_options");
+      }
+    }, R"__doc__(
+Set mplcairo options.  The following options are available:
+- cairo_circles: Use cairo's circle drawing algorithm, rather than Matplotlib's
+  fixed spline approximation.
+- raqm: Use Raqm for text rendering.
+)__doc__");
   m.def(
-    "has_raqm", &has_raqm,
-    "Return whether raqm is loaded.");
+    "get_options", []() -> py::dict {
+      return py::dict(
+        "cairo_circles"_a=!detail::UNIT_CIRCLE.is(py::none{}),
+        "raqm"_a=has_raqm());
+    }, R"__doc__(
+Get current mplcairo options.  See `set_mplcairo` for a description of
+available options.
+)__doc__");
 
   // Export classes.
 

src/_util.cpp

@@ -36,7 +36,7 @@ ps_surface_set_eps_t        cairo_ps_surface_set_eps;
 ps_surface_dsc_comment_t    cairo_ps_surface_dsc_comment;
 
 cairo_user_data_key_t const REFS_KEY{}, STATE_KEY{}, FT_KEY{};
-py::object UNIT_CIRCLE{}, PIXEL_MARKER{};
+py::object UNIT_CIRCLE{py::none{}}, PIXEL_MARKER{py::none{}};
 }
 
 rgba_t AdditionalState::get_hatch_color() {

tests/test_speed.py

@@ -6,6 +6,7 @@
 import numpy as np
 
 from matplotlib.backends.backend_agg import FigureCanvasAgg
+import mplcairo
 from mplcairo import antialias_t
 from mplcairo.base import FigureCanvasCairo
 
@@ -17,6 +18,7 @@
 @pytest.fixture
 def axes():
     mpl.rcdefaults()
+    mplcairo.set_options(cairo_circles=True, raqm=False)
     return Figure().subplots()
 
 
@@ -37,7 +39,7 @@ def sample_image():
 
 
 @pytest.mark.parametrize("canvas_cls", _canvas_classes)
-def test_axes(benchmark, canvas_cls, axes):
+def test_axes(benchmark, axes, canvas_cls):
     axes.figure.canvas = canvas_cls(axes.figure)
     benchmark(axes.figure.canvas.draw)
 
@@ -54,7 +56,7 @@ def test_axes(benchmark, canvas_cls, axes):
      (FigureCanvasCairo, antialias_t.BEST)])
 @pytest.mark.parametrize("joinstyle", ["miter", "round", "bevel"])
 def test_line(
-        benchmark, canvas_cls, antialiased, joinstyle, axes, sample_vectors):
+        benchmark, axes, sample_vectors, canvas_cls, antialiased, joinstyle):
     with mpl.rc_context({"agg.path.chunksize": 0}):
         axes.plot(*sample_vectors,
                   antialiased=antialiased, solid_joinstyle=joinstyle)
@@ -67,23 +69,34 @@ def test_line(
 # code path for circles which may not be representative of general performance.
 
 
-@pytest.mark.parametrize("canvas_cls", _canvas_classes)
-@pytest.mark.parametrize("threshold", [1 / 8, 0])
-@pytest.mark.parametrize("marker", ["o", "s"])
-def test_markers(
-        benchmark, canvas_cls, threshold, marker, axes, sample_vectors):
+_marker_test_parametrization = pytest.mark.parametrize(
+    "canvas_cls, threshold, marker, cairo_circles", [
+        (FigureCanvasAgg, 0, "o", False),
+        (FigureCanvasAgg, 0, "s", False),
+        (FigureCanvasCairo, 0, "o", False),
+        (FigureCanvasCairo, 0, "o", True),
+        (FigureCanvasCairo, 0, "s", False),
+        (FigureCanvasCairo, 1 / 8, "o", False),
+        (FigureCanvasCairo, 1 / 8, "o", True),
+        (FigureCanvasCairo, 1 / 8, "s", False),
+    ]
+)
+
+
+@_marker_test_parametrization
+def test_markers(benchmark, axes, sample_vectors,
+                 canvas_cls, threshold, marker, cairo_circles):
+    mplcairo.set_options(cairo_circles=cairo_circles)
     with mpl.rc_context({"path.simplify_threshold": threshold}):
         axes.plot(*sample_vectors, marker=marker)
         despine(axes)
         axes.figure.canvas = canvas_cls(axes.figure)
         benchmark(axes.figure.canvas.draw)
 
 
-@pytest.mark.parametrize("canvas_cls", _canvas_classes)
-@pytest.mark.parametrize("threshold", [1 / 8, 0])
-@pytest.mark.parametrize("marker", ["o", "s"])
-def test_scatter_multicolor(
-        benchmark, canvas_cls, threshold, marker, axes, sample_vectors):
+@_marker_test_parametrization
+def test_scatter_multicolor(benchmark, axes, sample_vectors,
+                            canvas_cls, threshold, marker, cairo_circles):
     with mpl.rc_context({"path.simplify_threshold": threshold}):
         a, b = sample_vectors
         axes.scatter(a, a, c=b, marker=marker)
@@ -92,11 +105,9 @@ def test_scatter_multicolor(
         benchmark(axes.figure.canvas.draw)
 
 
-@pytest.mark.parametrize("canvas_cls", _canvas_classes)
-@pytest.mark.parametrize("threshold", [1 / 8, 0])
-@pytest.mark.parametrize("marker", ["o", "s"])
-def test_scatter_multisize(
-        benchmark, canvas_cls, threshold, marker, axes, sample_vectors):
+@_marker_test_parametrization
+def test_scatter_multisize(benchmark, axes, sample_vectors,
+                           canvas_cls, threshold, marker, cairo_circles):
     with mpl.rc_context({"path.simplify_threshold": threshold}):
         a, b = sample_vectors
         axes.scatter(a, a, s=100 * b ** 2, marker=marker)