matplotlib/src/ft2font_wrapper.cpp at main · matplotlib/matplotlib

1946 lines (1687 loc) · 69 KB
#define NPY_NO_DEPRECATED_API NPY_1_7_API_VERSION
#include <pybind11/pybind11.h>
#include <pybind11/numpy.h>
#include <pybind11/stl.h>
#include "ft2font.h"
#include "_enums.h"
#include <set>
#include <sstream>
#include <unordered_map>
namespace py = pybind11;
using namespace pybind11::literals;
template <typename T>
using double_or_ = std::variant<T, double>;
template <typename T>
_double_to_(const char *name, double_or_<T> &var)
    if (auto value = std::get_if<double>(&var)) {
        auto api = py::module_::import("matplotlib._api");
        auto warn = api.attr("warn_deprecated");
        warn("since"_a="3.10", "name"_a=name, "obj_type"_a="parameter as float",
             "alternative"_a="int({})"_s.format(name));
        return static_cast<T>(*value);
    } else if (auto value = std::get_if<T>(&var)) {
        return *value;
    } else {
        // pybind11 will have only allowed types that match the variant, so this `else`
        // can't happen. We only have this case because older macOS doesn't support
        // `std::get` and using the conditional `std::get_if` means an `else` to silence
        // compiler warnings about "unhandled" cases.
        throw std::runtime_error("Should not happen");
/**********************************************************************
 * Enumerations
const char *Kerning__doc__ = R"""(
    Kerning modes for `.FT2Font.get_kerning`.
    For more information, see `the FreeType documentation
    <https://freetype.org/freetype2/docs/reference/ft2-glyph_retrieval.html#ft_kerning_mode>`_.
    .. versionadded:: 3.10
P11X_DECLARE_ENUM(
    "Kerning", "Enum",
    {"DEFAULT", FT_KERNING_DEFAULT},
    {"UNFITTED", FT_KERNING_UNFITTED},
    {"UNSCALED", FT_KERNING_UNSCALED},
const char *FaceFlags__doc__ = R"""(
    Flags returned by `FT2Font.face_flags`.
    For more information, see `the FreeType documentation
    <https://freetype.org/freetype2/docs/reference/ft2-face_creation.html#ft_face_flag_xxx>`_.
    .. versionadded:: 3.10
#ifndef FT_FACE_FLAG_VARIATION  // backcompat: ft 2.9.0.
#define FT_FACE_FLAG_VARIATION (1L << 15)
#ifndef FT_FACE_FLAG_SVG  // backcompat: ft 2.12.0.
#define FT_FACE_FLAG_SVG (1L << 16)
#ifndef FT_FACE_FLAG_SBIX  // backcompat: ft 2.12.0.
#define FT_FACE_FLAG_SBIX (1L << 17)
#ifndef FT_FACE_FLAG_SBIX_OVERLAY  // backcompat: ft 2.12.0.
#define FT_FACE_FLAG_SBIX_OVERLAY (1L << 18)
enum class FaceFlags : FT_Long {
#define DECLARE_FLAG(name) name = FT_FACE_FLAG_##name
    DECLARE_FLAG(SCALABLE),
    DECLARE_FLAG(FIXED_SIZES),
    DECLARE_FLAG(FIXED_WIDTH),
    DECLARE_FLAG(SFNT),
    DECLARE_FLAG(HORIZONTAL),
    DECLARE_FLAG(VERTICAL),
    DECLARE_FLAG(KERNING),
    DECLARE_FLAG(FAST_GLYPHS),
    DECLARE_FLAG(MULTIPLE_MASTERS),
    DECLARE_FLAG(GLYPH_NAMES),
    DECLARE_FLAG(EXTERNAL_STREAM),
    DECLARE_FLAG(HINTER),
    DECLARE_FLAG(CID_KEYED),
    DECLARE_FLAG(TRICKY),
    DECLARE_FLAG(COLOR),
    DECLARE_FLAG(VARIATION),
    DECLARE_FLAG(SVG),
    DECLARE_FLAG(SBIX),
    DECLARE_FLAG(SBIX_OVERLAY),
#undef DECLARE_FLAG
P11X_DECLARE_ENUM(
    "FaceFlags", "Flag",
    {"SCALABLE", FaceFlags::SCALABLE},
    {"FIXED_SIZES", FaceFlags::FIXED_SIZES},
    {"FIXED_WIDTH", FaceFlags::FIXED_WIDTH},
    {"SFNT", FaceFlags::SFNT},
    {"HORIZONTAL", FaceFlags::HORIZONTAL},
    {"VERTICAL", FaceFlags::VERTICAL},
    {"KERNING", FaceFlags::KERNING},
    {"FAST_GLYPHS", FaceFlags::FAST_GLYPHS},
    {"MULTIPLE_MASTERS", FaceFlags::MULTIPLE_MASTERS},
    {"GLYPH_NAMES", FaceFlags::GLYPH_NAMES},
    {"EXTERNAL_STREAM", FaceFlags::EXTERNAL_STREAM},
    {"HINTER", FaceFlags::HINTER},
    {"CID_KEYED", FaceFlags::CID_KEYED},
    {"TRICKY", FaceFlags::TRICKY},
    {"COLOR", FaceFlags::COLOR},
    {"VARIATION", FaceFlags::VARIATION},
    {"SVG", FaceFlags::SVG},
    {"SBIX", FaceFlags::SBIX},
    {"SBIX_OVERLAY", FaceFlags::SBIX_OVERLAY},
const char *LoadFlags__doc__ = R"""(
    Flags for `FT2Font.load_char`, `FT2Font.load_glyph`, and `FT2Font.set_text`.
    For more information, see `the FreeType documentation
    <https://freetype.org/freetype2/docs/reference/ft2-glyph_retrieval.html#ft_load_xxx>`_.
    .. versionadded:: 3.10
#ifndef FT_LOAD_COMPUTE_METRICS  // backcompat: ft 2.6.1.
#define FT_LOAD_COMPUTE_METRICS (1L << 21)
#ifndef FT_LOAD_BITMAP_METRICS_ONLY  // backcompat: ft 2.7.1.
#define FT_LOAD_BITMAP_METRICS_ONLY (1L << 22)
#ifndef FT_LOAD_NO_SVG  // backcompat: ft 2.13.1.
#define FT_LOAD_NO_SVG (1L << 24)
enum class LoadFlags : FT_Int32 {
#define DECLARE_FLAG(name) name = FT_LOAD_##name
    DECLARE_FLAG(DEFAULT),
    DECLARE_FLAG(NO_SCALE),
    DECLARE_FLAG(NO_HINTING),
    DECLARE_FLAG(RENDER),
    DECLARE_FLAG(NO_BITMAP),
    DECLARE_FLAG(VERTICAL_LAYOUT),
    DECLARE_FLAG(FORCE_AUTOHINT),
    DECLARE_FLAG(CROP_BITMAP),
    DECLARE_FLAG(PEDANTIC),
    DECLARE_FLAG(IGNORE_GLOBAL_ADVANCE_WIDTH),
    DECLARE_FLAG(NO_RECURSE),
    DECLARE_FLAG(IGNORE_TRANSFORM),
    DECLARE_FLAG(MONOCHROME),
    DECLARE_FLAG(LINEAR_DESIGN),
    DECLARE_FLAG(NO_AUTOHINT),
    DECLARE_FLAG(COLOR),
    DECLARE_FLAG(COMPUTE_METRICS),
    DECLARE_FLAG(BITMAP_METRICS_ONLY),
    DECLARE_FLAG(NO_SVG),
    DECLARE_FLAG(TARGET_NORMAL),
    DECLARE_FLAG(TARGET_LIGHT),
    DECLARE_FLAG(TARGET_MONO),
    DECLARE_FLAG(TARGET_LCD),
    DECLARE_FLAG(TARGET_LCD_V),
#undef DECLARE_FLAG
P11X_DECLARE_ENUM(
    "LoadFlags", "Flag",
    {"DEFAULT", LoadFlags::DEFAULT},
    {"NO_SCALE", LoadFlags::NO_SCALE},
    {"NO_HINTING", LoadFlags::NO_HINTING},
    {"RENDER", LoadFlags::RENDER},
    {"NO_BITMAP", LoadFlags::NO_BITMAP},
    {"VERTICAL_LAYOUT", LoadFlags::VERTICAL_LAYOUT},
    {"FORCE_AUTOHINT", LoadFlags::FORCE_AUTOHINT},
    {"CROP_BITMAP", LoadFlags::CROP_BITMAP},
    {"PEDANTIC", LoadFlags::PEDANTIC},
    {"IGNORE_GLOBAL_ADVANCE_WIDTH", LoadFlags::IGNORE_GLOBAL_ADVANCE_WIDTH},
    {"NO_RECURSE", LoadFlags::NO_RECURSE},
    {"IGNORE_TRANSFORM", LoadFlags::IGNORE_TRANSFORM},
    {"MONOCHROME", LoadFlags::MONOCHROME},
    {"LINEAR_DESIGN", LoadFlags::LINEAR_DESIGN},
    {"NO_AUTOHINT", LoadFlags::NO_AUTOHINT},
    {"COLOR", LoadFlags::COLOR},
    {"COMPUTE_METRICS", LoadFlags::COMPUTE_METRICS},
    {"BITMAP_METRICS_ONLY", LoadFlags::BITMAP_METRICS_ONLY},
    {"NO_SVG", LoadFlags::NO_SVG},
    // These must be unique, but the others can be OR'd together; I don't know if
    // there's any way to really enforce that.
    {"TARGET_NORMAL", LoadFlags::TARGET_NORMAL},
    {"TARGET_LIGHT", LoadFlags::TARGET_LIGHT},
    {"TARGET_MONO", LoadFlags::TARGET_MONO},
    {"TARGET_LCD", LoadFlags::TARGET_LCD},
    {"TARGET_LCD_V", LoadFlags::TARGET_LCD_V},
const char *RenderMode__doc__ = R"""(
    Render modes.
    For more information, see `the FreeType documentation
    <https://freetype.org/freetype2/docs/reference/ft2-glyph_retrieval.html#ft_render_mode>`_.
    .. versionadded:: 3.10
P11X_DECLARE_ENUM(
    "RenderMode", "Enum",
    {"NORMAL", FT_RENDER_MODE_NORMAL},
    {"LIGHT", FT_RENDER_MODE_LIGHT},
    {"MONO", FT_RENDER_MODE_MONO},
    {"LCD", FT_RENDER_MODE_LCD},
    {"LCD_V", FT_RENDER_MODE_LCD_V},
    {"SDF", FT_RENDER_MODE_SDF},
const char *StyleFlags__doc__ = R"""(
    Flags returned by `FT2Font.style_flags`.
    For more information, see `the FreeType documentation
    <https://freetype.org/freetype2/docs/reference/ft2-face_creation.html#ft_style_flag_xxx>`_.
    .. versionadded:: 3.10
enum class StyleFlags : FT_Long {
#define DECLARE_FLAG(name) name = FT_STYLE_FLAG_##name
    NORMAL = 0,
    DECLARE_FLAG(ITALIC),
    DECLARE_FLAG(BOLD),
#undef DECLARE_FLAG
P11X_DECLARE_ENUM(
    "StyleFlags", "Flag",
    {"NORMAL", StyleFlags::NORMAL},
    {"ITALIC", StyleFlags::ITALIC},
    {"BOLD", StyleFlags::BOLD},
/**********************************************************************
 * FT2Image
const char *PyFT2Image__doc__ = R"""(
    An image buffer for drawing glyphs.
const char *PyFT2Image_init__doc__ = R"""(
    Parameters
    ----------
    width, height : int
        The dimensions of the image buffer.
const char *PyFT2Image_draw_rect_filled__doc__ = R"""(
    Draw a filled rectangle to the image.
    Parameters
    ----------
    x0, y0, x1, y1 : float
        The bounds of the rectangle from (x0, y0) to (x1, y1).
static void
PyFT2Image_draw_rect_filled(FT2Image *self,
                            double_or_<long> vx0, double_or_<long> vy0,
                            double_or_<long> vx1, double_or_<long> vy1)
    auto x0 = _double_to_<long>("x0", vx0);
    auto y0 = _double_to_<long>("y0", vy0);
    auto x1 = _double_to_<long>("x1", vx1);
    auto y1 = _double_to_<long>("y1", vy1);
    self->draw_rect_filled(x0, y0, x1, y1);
/**********************************************************************
 * Positioned Bitmap; owns the FT_Bitmap!
struct PyPositionedBitmap {
    FT_Int left, top;
    bool owning;
    FT_Bitmap bitmap;
    PyPositionedBitmap(FT_GlyphSlot slot) :
        left{slot->bitmap_left}, top{slot->bitmap_top}, owning{true}
        FT_Bitmap_Init(&bitmap);
        FT_CHECK(FT_Bitmap_Convert, _ft2Library, &slot->bitmap, &bitmap, 1);
    PyPositionedBitmap(FT_BitmapGlyph bg) :
        left{bg->left}, top{bg->top}, owning{true}
        FT_Bitmap_Init(&bitmap);
        FT_CHECK(FT_Bitmap_Convert, _ft2Library, &bg->bitmap, &bitmap, 1);
    PyPositionedBitmap(PyPositionedBitmap& other) = delete;  // Non-copyable.
    PyPositionedBitmap(PyPositionedBitmap&& other) :
        left{other.left}, top{other.top}, owning{true}, bitmap{other.bitmap}
        other.owning = false;  // Prevent double deletion.
    ~PyPositionedBitmap()
        if (owning) {
            FT_Bitmap_Done(_ft2Library, &bitmap);
/**********************************************************************
typedef struct
    size_t glyphInd;
    long width;
    long height;
    long horiBearingX;
    long horiBearingY;
    long horiAdvance;
    long linearHoriAdvance;
    long vertBearingX;
    long vertBearingY;
    long vertAdvance;
    FT_BBox bbox;
const char *PyGlyph__doc__ = R"""(
    Information about a single glyph.
    You cannot create instances of this object yourself, but must use
    `.FT2Font.load_char` or `.FT2Font.load_glyph` to generate one. This object may be
    used in a call to `.FT2Font.draw_glyph_to_bitmap`.
    For more information on the various metrics, see `the FreeType documentation
    <https://freetype.org/freetype2/docs/glyphs/glyphs-3.html>`_.
static PyGlyph *
PyGlyph_from_FT2Font(const FT2Font *font)
    const FT_Face &face = font->get_face();
    const FT_Glyph &glyph = font->get_last_glyph();
    PyGlyph *self = new PyGlyph();
    self->glyphInd = font->get_last_glyph_index();
    FT_Glyph_Get_CBox(glyph, ft_glyph_bbox_subpixels, &self->bbox);
    self->width = face->glyph->metrics.width;
    self->height = face->glyph->metrics.height;
    self->horiBearingX = face->glyph->metrics.horiBearingX;
    self->horiBearingY = face->glyph->metrics.horiBearingY;
    self->horiAdvance = face->glyph->metrics.horiAdvance;
    self->linearHoriAdvance = face->glyph->linearHoriAdvance;
    self->vertBearingX = face->glyph->metrics.vertBearingX;
    self->vertBearingY = face->glyph->metrics.vertBearingY;
    self->vertAdvance = face->glyph->metrics.vertAdvance;
    return self;
static py::tuple
PyGlyph_get_bbox(PyGlyph *self)
    return py::make_tuple(self->bbox.xMin, self->bbox.yMin,
                          self->bbox.xMax, self->bbox.yMax);
/**********************************************************************
class PyFT2Font final : public FT2Font
    using FT2Font::FT2Font;
    py::object py_file;
    FT_StreamRec stream;
    py::list fallbacks;
    ~PyFT2Font()
        // Because destructors are called from subclass up to base class, we need to
        // explicitly close the font here. Otherwise, the instance attributes here will
        // be destroyed before the font itself, but those are used in the close callback.
        close();
    void ft_glyph_warn(FT_ULong charcode, std::set<FT_String*> family_names)
        std::set<FT_String*>::iterator it = family_names.begin();
        std::stringstream ss;
        ss<< (*it ? *it : "unknown family name");
        while(++it != family_names.end()){
            ss<<", "<< (*it ? *it : "unknown family name");
        auto text_helpers = py::module_::import("matplotlib._text_helpers");
        auto warn_on_missing_glyph = text_helpers.attr("warn_on_missing_glyph");
        warn_on_missing_glyph(charcode, ss.str());
const char *PyFT2Font__doc__ = R"""(
    An object representing a single font face.
    Outside of the font itself and querying its properties, this object provides methods
    for processing text strings into glyph shapes.
    Commonly, one will use `FT2Font.set_text` to load some glyph metrics and outlines.
    Then `FT2Font.draw_glyphs_to_bitmap` and `FT2Font.get_image` may be used to get a
    rendered form of the loaded string.
    For single characters, `FT2Font.load_char` or `FT2Font.load_glyph` may be used,
    either directly for their return values, or to use `FT2Font.draw_glyph_to_bitmap` or
    `FT2Font.get_path`.
    Useful metrics may be examined via the `Glyph` return values or
    `FT2Font.get_kerning`. Most dimensions are given in 26.6 or 16.6 fixed-point
    integers representing subpixels. Divide these values by 64 to produce floating-point
    pixels.
static unsigned long
read_from_file_callback(FT_Stream stream, unsigned long offset, unsigned char *buffer,
                        unsigned long count)
    PyFT2Font *self = (PyFT2Font *)stream->descriptor.pointer;
    Py_ssize_t n_read = 0;
        char *tmpbuf;
        auto seek_result = self->py_file.attr("seek")(offset);
        auto read_result = self->py_file.attr("read")(count);
        if (PyBytes_AsStringAndSize(read_result.ptr(), &tmpbuf, &n_read) == -1) {
            throw py::error_already_set();
        memcpy(buffer, tmpbuf, n_read);
    } catch (py::error_already_set &eas) {
        eas.discard_as_unraisable(__func__);
        if (!count) {
            return 1;  // Non-zero signals error, when count == 0.
    return (unsigned long)n_read;
static void
close_file_callback(FT_Stream stream)
    PyObject *type, *value, *traceback;
    PyErr_Fetch(&type, &value, &traceback);
    PyFT2Font *self = (PyFT2Font *)stream->descriptor.pointer;
        self->py_file.attr("close")();
    } catch (py::error_already_set &eas) {
        eas.discard_as_unraisable(__func__);
    self->py_file = py::object();
    PyErr_Restore(type, value, traceback);
const char *PyFT2Font_init__doc__ = R"""(
    Parameters
    ----------
    filename : str, bytes, os.PathLike, or io.BinaryIO
        The source of the font data in a format (ttf or ttc) that FreeType can read.
    face_index : int, optional
        The index of the face in the font file to load.
    _fallback_list : list of FT2Font, optional
        A list of FT2Font objects used to find missing glyphs.
        .. warning::
            This API is both private and provisional: do not use it directly.
    _warn_if_used : bool, optional
        Used to trigger missing glyph warnings.
        .. warning::
            This API is private: do not use it directly.
static PyFT2Font *
PyFT2Font_init(py::object filename, std::optional<long> hinting_factor = std::nullopt,
               FT_Long face_index = 0,
               std::optional<std::vector<PyFT2Font *>> fallback_list = std::nullopt,
               std::optional<int> kerning_factor = std::nullopt,
               bool warn_if_used = false)
    if (hinting_factor) {
        auto api = py::module_::import("matplotlib._api");
        auto warn = api.attr("warn_deprecated");
        warn("since"_a="3.11", "name"_a="hinting_factor", "obj_type"_a="parameter");
    if (kerning_factor) {
        auto api = py::module_::import("matplotlib._api");
        auto warn = api.attr("warn_deprecated");
        warn("since"_a="3.11", "name"_a="_kerning_factor", "obj_type"_a="parameter");
    } else {
        kerning_factor = 0;
    if (face_index < 0 || face_index > 0xffff) {
        throw std::range_error("face_index must be between 0 and 65535, inclusive");
    std::vector<FT2Font *> fallback_fonts;
    if (fallback_list) {
Provide feedback

Saved searches

Use saved searches to filter your results more quickly

Uh oh!

Uh oh!

FilesExpand file tree

ft2font_wrapper.cpp

Latest commit

History

ft2font_wrapper.cpp

File metadata and controls
