mplcairo 0.1

Unix

The following additional dependencies are required:

• a C++ compiler with C++17 support, e.g. GCC≥7.2 or Clang≥5.0.

• cairo and FreeType headers, and pkg-config information to locate them.

  If using conda, they can be installed using

  conda install -y -c conda-forge pycairo pkg-config

  as pycairo (also a dependency) depends on cairo, which depends on freetype. Note that cairo and pkg-config from the anaconda channel will not work.

  On Linux, they can also be installed with your distribution’s package manager (Debian/Ubuntu: libcairo2-dev, Fedora: cairo-devel).

Raqm (≥0.2) headers are also needed, but will be automatically downloaded if not found.

Windows

The following additional dependencies are required:

• a “recent enough” version of MSVC (19.13.26128 is sufficient). (This is the reason for restricting support to Python 3.6 on Windows: distutils is able to use MSVC 2017 only since Python 3.6.4.)

• FreeType headers, which can e.g. be installed using conda

  conda install -y freetype

• a cairo build (the headers, cairo.lib, and cairo.dll) with FreeType support. As noted above, this excludes, in particular, the Anaconda, conda-forge, or Gohlke builds. One place from where such a build is available is https://github.com/preshing/cairo-windows/releases: download the zip file and unpack it.

  Because you will always need to provide cairo yourself, we did not implement any special way to configure the location where it will be found. Instead, you must set the (standard) CL and LINK environment variables (which always get prepended respectively to the invocations of the compiler and the linker) as follows:

  set CL=/IC:\path\to\directory\containing\cairo.h
  set LINK=/LIBPATH:C\path\to\directory\containing\cairo.lib

  Moreover, we also need to find cairo.dll and copy it next to mplcairo’s extension module. As cairo.dll is typically found next to cairo.lib, we explicitly require the LINK environment variable to use the above format and start with /LIBPATH: (case-insensitive); we always copy cairo.dll from that directory.

Antialiasing

The artist antialiasing property can be set to any of the cairo_antialias_t enum values, or True (the default) or False (which is synonym to NONE).

Setting antialiasing to True uses FAST antialiasing for lines thicker than 1/3px and BEST for lines thinner than that: for lines thinner than 1/3px, the former leads to artefacts such as lines disappearing in certain sections (see e.g. test_cycles.test_property_collision_plot after forcing the antialiasing to FAST). The threshold of 1/3px was determined empirically, see examples/thin_line_antialiasing.py.

Note that in order to set the lines.antialiased or patch.antialiased rcparams to a cairo_antialias_t enum value, it is necessary to bypass rcparam validation, using, e.g.

dict.__setitem__(plt.rcParams, "lines.antialiased", antialias_t.FAST)

The text.antialiased rcparam can likewise be set to any cairo_antialias_t enum value, or True (the default, which maps to SUBPIXEL – GRAY is not sufficient to benefit from Raqm’s subpixel positioning; see also cairo bug #99021) or False (which maps to NONE).

Fast drawing

For fast drawing of path with many segments, the agg.path.chunksize rcparam should be set to 1000 (see examples/time_drawing_per_element.py for the determination of this value); this causes longer paths to be split into individually rendered sections of 1000 segments each (directly rendering longer paths appears to have slightly superlinear complexity).

Simplification threshold

The path.simplify_threshold rcparam is used to control the accuracy of marker stamping, down to an arbitrarily chosen threshold of 1/16px. Values lower than that will use the exact (slower) marker drawing path. Marker stamping is also implemented for scatter plots (which can have multiple colors). Likewise, markers of different sizes get mapped into markers of discretized sizes, with an error bounded by the threshold.

NOTE: “Pixel” markers (",") must be drawn snapped. This is currently not implemented.

NOTE: pcolor and mplot3d’s plot_surface display some artifacts where the facets join each other. This is because these functions internally use a PathCollection, thus triggering the approximate stamping. pcolor should be deprecated in favor of pcolormesh (internally using a QuadMesh), and plot_surface should likewise instead represent the surface using QuadMesh, which is drawn without such artefacts.

Font formats

In order to use a specific font that Matplotlib may be unable to use, pass a filename directly:

from matplotlib.font_manager import FontProperties
ax.text(.5, .5, "hello, world", fontproperties=FontProperties(fname="..."))

mplcairo still relies on Matplotlib’s font cache, so fonts unsupported by Matplotlib remain unavailable by other means. Matplotlib’s current FreeType wrapper also limits the use of ttc collections to the first font in the collection.

Note that Matplotlib’s (default) Agg backend will handle such fonts equally well (ultimately, both backends relies on FreeType for rasterization). It is Matplotlib’s vector backends (PS, PDF, and, for pfb fonts, SVG) that do not support these fonts, whereas mplcairo support these fonts in all output formats.

Multi-page output

Matplotlib’s PdfPages class is deeply tied with the builtin backend_pdf (in fact, it cannot even be used with Matplotlib’s own cairo backend). Instead, use mplcairo.multipage.MultiPage for multi-page PDF and PS output. The API is similar:

from mplcairo.multipage import MultiPage

fig1 = ...
fig2 = ...
with MultiPage(path_or_stream) as mp:
    mp.savefig(fig1)
    mp.savefig(fig2)

cairo-script output

Setting the MPLCAIRO_SCRIPT_SURFACE environment variable to vector or raster allows one to save figures (with savefig) in the .cairoscript format, which is a “native script that matches the cairo drawing model”. The value of the variable determines the rendering path used (e.g., whether marker stamping is used at all). This may be helpful for troubleshooting purposes.

Note that this may crash the process after the file is written, due to cairo bug #104410.

Markers at Bézier control points

draw_markers draws a marker at each control point of the given path, which is the documented behavior, even though all builtin renderers only draw markers at straight or Bézier segment ends.

Missing implementation

Support for the following features is missing:

• the svg.image_inline rcparam.

Missing support from cairo

• SVG output does not set URLs on any element, as cairo provides no support for doing so.

• PS output does not respect SOURCE_DATE_EPOCH.

• The following rcparams have no effect: pdf.fonttype, pdf.use14corefonts, ps.fonttype, ps.useafm, svg.fonttype, svg.hashsalt.