Move Python code from ft2font to its wrapper

QuLogic · QuLogic · commit 5f2a89ab3a85 · 2024-08-22T21:49:42.000-04:00
This improves the encapsulation and separation of concerns between the
files.
diff --git a/src/ft2font.cpp b/src/ft2font.cpp
@@ -1,18 +1,16 @@
 /* -*- mode: c++; c-basic-offset: 4 -*- */
 
-#define NO_IMPORT_ARRAY
-
 #include <algorithm>
+#include <charconv>
 #include <iterator>
 #include <set>
 #include <sstream>
 #include <stdexcept>
 #include <string>
+#include <vector>
 
 #include "ft2font.h"
 #include "mplutils.h"
-#include "numpy_cpp.h"
-#include "py_exceptions.h"
 
 #ifndef M_PI
 #define M_PI 3.14159265358979323846264338328
@@ -185,30 +183,6 @@ FT2Image::draw_rect_filled(unsigned long x0, unsigned long y0, unsigned long x1,
     m_dirty = true;
 }
 
-static void ft_glyph_warn(FT_ULong charcode, std::set<FT_String*> family_names)
-{
-    PyObject *text_helpers = NULL, *tmp = NULL;
-    std::set<FT_String*>::iterator it = family_names.begin();
-    std::stringstream ss;
-    ss<<*it;
-    while(++it != family_names.end()){
-        ss<<", "<<*it;
-    }
-
-    if (!(text_helpers = PyImport_ImportModule("matplotlib._text_helpers")) ||
-        !(tmp = PyObject_CallMethod(text_helpers,
-                "warn_on_missing_glyph", "(k, s)",
-                charcode, ss.str().c_str()))) {
-        goto exit;
-    }
-exit:
-    Py_XDECREF(text_helpers);
-    Py_XDECREF(tmp);
-    if (PyErr_Occurred()) {
-        throw mpl::exception();
-    }
-}
-
 // ft_outline_decomposer should be passed to FT_Outline_Decompose.  On the
 // first pass, vertices and codes are set to NULL, and index is simply
 // incremented for each vertex that should be inserted, so that it is set, at
@@ -296,52 +270,41 @@ static FT_Outline_Funcs ft_outline_funcs = {
     ft_outline_conic_to,
     ft_outline_cubic_to};
 
-PyObject*
-FT2Font::get_path()
+void
+FT2Font::get_path(std::vector<double> &vertices, std::vector<unsigned char> &codes)
 {
     if (!face->glyph) {
-        PyErr_SetString(PyExc_RuntimeError, "No glyph loaded");
-        return NULL;
+        throw std::runtime_error("No glyph loaded");
     }
     ft_outline_decomposer decomposer = {};
-    if (FT_Error error =
-        FT_Outline_Decompose(
-          &face->glyph->outline, &ft_outline_funcs, &decomposer)) {
-        PyErr_Format(PyExc_RuntimeError,
-                     "FT_Outline_Decompose failed with error 0x%x", error);
-        return NULL;
+    if (FT_Error error = FT_Outline_Decompose(
+            &face->glyph->outline, &ft_outline_funcs, &decomposer)) {
+        throw std::runtime_error("FT_Outline_Decompose failed with error " +
+                                 std::to_string(error));
     }
     if (!decomposer.index) {  // Don't append CLOSEPOLY to null glyphs.
-      npy_intp vertices_dims[2] = { 0, 2 };
-      numpy::array_view<double, 2> vertices(vertices_dims);
-      npy_intp codes_dims[1] = { 0 };
-      numpy::array_view<unsigned char, 1> codes(codes_dims);
-      return Py_BuildValue("NN", vertices.pyobj(), codes.pyobj());
-    }
-    npy_intp vertices_dims[2] = { decomposer.index + 1, 2 };
-    numpy::array_view<double, 2> vertices(vertices_dims);
-    npy_intp codes_dims[1] = { decomposer.index + 1 };
-    numpy::array_view<unsigned char, 1> codes(codes_dims);
+        return;
+    }
+    vertices.resize((decomposer.index + 1) * 2);
+    codes.resize(decomposer.index + 1);
     decomposer.index = 0;
     decomposer.vertices = vertices.data();
     decomposer.codes = codes.data();
-    if (FT_Error error =
-        FT_Outline_Decompose(
-          &face->glyph->outline, &ft_outline_funcs, &decomposer)) {
-        PyErr_Format(PyExc_RuntimeError,
-                     "FT_Outline_Decompose failed with error 0x%x", error);
-        return NULL;
+    if (FT_Error error = FT_Outline_Decompose(
+            &face->glyph->outline, &ft_outline_funcs, &decomposer)) {
+        throw std::runtime_error("FT_Outline_Decompose failed with error " +
+                                 std::to_string(error));
     }
     *(decomposer.vertices++) = 0;
     *(decomposer.vertices++) = 0;
     *(decomposer.codes++) = CLOSEPOLY;
-    return Py_BuildValue("NN", vertices.pyobj(), codes.pyobj());
 }
 
 FT2Font::FT2Font(FT_Open_Args &open_args,
                  long hinting_factor_,
-                 std::vector<FT2Font *> &fallback_list)
-    : image(), face(NULL)
+                 std::vector<FT2Font *> &fallback_list,
+                 FT2Font::WarnFunc warn)
+    : ft_glyph_warn(warn), image(), face(NULL)
 {
     clear();
 
@@ -819,7 +782,8 @@ void FT2Font::draw_glyph_to_bitmap(FT2Image &im, int x, int y, size_t glyphInd,
     im.draw_bitmap(&bitmap->bitmap, x + bitmap->left, y);
 }
 
-void FT2Font::get_glyph_name(unsigned int glyph_number, char *buffer, bool fallback = false)
+void FT2Font::get_glyph_name(unsigned int glyph_number, std::string &buffer,
+                             bool fallback = false)
 {
     if (fallback && glyph_to_font.find(glyph_number) != glyph_to_font.end()) {
         // cache is only for parent FT2Font
@@ -830,9 +794,11 @@ void FT2Font::get_glyph_name(unsigned int glyph_number, char *buffer, bool fallb
     if (!FT_HAS_GLYPH_NAMES(face)) {
         /* Note that this generated name must match the name that
            is generated by ttconv in ttfont_CharStrings_getname. */
-        PyOS_snprintf(buffer, 128, "uni%08x", glyph_number);
+        buffer.replace(0, 3, "uni");
+        std::to_chars(buffer.data() + 3, buffer.data() + buffer.size(),
+                      glyph_number, 16);
     } else {
-        if (FT_Error error = FT_Get_Glyph_Name(face, glyph_number, buffer, 128)) {
+        if (FT_Error error = FT_Get_Glyph_Name(face, glyph_number, buffer.data(), buffer.size())) {
             throw_ft_error("Could not get glyph names", error);
         }
     }
diff --git a/src/ft2font.h b/src/ft2font.h
@@ -11,6 +11,7 @@
 
 #include <cstdint>
 #include <set>
+#include <string>
 #include <unordered_map>
 #include <vector>
 
@@ -71,9 +72,11 @@ extern FT_Library _ft2Library;
 
 class FT2Font
 {
+    typedef void (*WarnFunc)(FT_ULong charcode, std::set<FT_String*> family_names);
 
   public:
-    FT2Font(FT_Open_Args &open_args, long hinting_factor, std::vector<FT2Font *> &fallback_list);
+    FT2Font(FT_Open_Args &open_args, long hinting_factor,
+            std::vector<FT2Font *> &fallback_list, WarnFunc warn);
     virtual ~FT2Font();
     void clear();
     void set_size(double ptsize, double dpi);
@@ -106,10 +109,10 @@ class FT2Font
     void get_xys(bool antialiased, std::vector<double> &xys);
     void draw_glyphs_to_bitmap(bool antialiased);
     void draw_glyph_to_bitmap(FT2Image &im, int x, int y, size_t glyphInd, bool antialiased);
-    void get_glyph_name(unsigned int glyph_number, char *buffer, bool fallback);
+    void get_glyph_name(unsigned int glyph_number, std::string &buffer, bool fallback);
     long get_name_index(char *name);
     FT_UInt get_char_index(FT_ULong charcode, bool fallback);
-    PyObject* get_path();
+    void get_path(std::vector<double> &vertices, std::vector<unsigned char> &codes);
     bool get_char_fallback_index(FT_ULong charcode, int& index) const;
 
     FT_Face const &get_face() const
@@ -143,6 +146,7 @@ class FT2Font
     }
 
   private:
+    WarnFunc ft_glyph_warn;
     FT2Image image;
     FT_Face face;
     FT_Vector pen;    /* untransformed origin  */
diff --git a/src/ft2font_wrapper.cpp b/src/ft2font_wrapper.cpp
@@ -1,11 +1,13 @@
 #include "mplutils.h"
 #include "ft2font.h"
+#include "numpy_cpp.h"
 #include "py_converters.h"
 #include "py_exceptions.h"
 
 // From Python
 #include <structmember.h>
 
+#include <sstream>
 #include <set>
 
 static PyObject *convert_xys_to_array(std::vector<double> &xys)
@@ -308,6 +310,31 @@ static void close_file_callback(FT_Stream stream)
     PyErr_Restore(type, value, traceback);
 }
 
+static void
+ft_glyph_warn(FT_ULong charcode, std::set<FT_String*> family_names)
+{
+    PyObject *text_helpers = NULL, *tmp = NULL;
+    std::set<FT_String*>::iterator it = family_names.begin();
+    std::stringstream ss;
+    ss<<*it;
+    while(++it != family_names.end()){
+        ss<<", "<<*it;
+    }
+
+    if (!(text_helpers = PyImport_ImportModule("matplotlib._text_helpers")) ||
+        !(tmp = PyObject_CallMethod(text_helpers,
+                "warn_on_missing_glyph", "(k, s)",
+                charcode, ss.str().c_str()))) {
+        goto exit;
+    }
+exit:
+    Py_XDECREF(text_helpers);
+    Py_XDECREF(tmp);
+    if (PyErr_Occurred()) {
+        throw mpl::exception();
+    }
+}
+
 static PyObject *PyFT2Font_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
 {
     PyFT2Font *self;
@@ -455,7 +482,8 @@ static int PyFT2Font_init(PyFT2Font *self, PyObject *args, PyObject *kwds)
     Py_CLEAR(data);
 
     CALL_CPP_FULL(
-        "FT2Font", (self->x = new FT2Font(open_args, hinting_factor, fallback_fonts)),
+        "FT2Font",
+        (self->x = new FT2Font(open_args, hinting_factor, fallback_fonts, ft_glyph_warn)),
         Py_CLEAR(self->py_file), -1);
 
     CALL_CPP_INIT("FT2Font->set_kerning_factor", (self->x->set_kerning_factor(kerning_factor)));
@@ -555,13 +583,13 @@ static PyObject *PyFT2Font_get_kerning(PyFT2Font *self, PyObject *args)
 {
     FT_UInt left, right, mode;
     int result;
-    int fallback = 1;
+    bool fallback = true;
 
     if (!PyArg_ParseTuple(args, "III:get_kerning", &left, &right, &mode)) {
         return NULL;
     }
 
-    CALL_CPP("get_kerning", (result = self->x->get_kerning(left, right, mode, (bool)fallback)));
+    CALL_CPP("get_kerning", (result = self->x->get_kerning(left, right, mode, fallback)));
 
     return PyLong_FromLong(result);
 }
@@ -704,7 +732,7 @@ const char *PyFT2Font_load_char__doc__ =
 static PyObject *PyFT2Font_load_char(PyFT2Font *self, PyObject *args, PyObject *kwds)
 {
     long charcode;
-    int fallback = 1;
+    bool fallback = true;
     FT_Int32 flags = FT_LOAD_FORCE_AUTOHINT;
     const char *names[] = { "charcode", "flags", NULL };
 
@@ -717,7 +745,7 @@ static PyObject *PyFT2Font_load_char(PyFT2Font *self, PyObject *args, PyObject *
     }
 
     FT2Font *ft_object = NULL;
-    CALL_CPP("load_char", (self->x->load_char(charcode, flags, ft_object, (bool)fallback)));
+    CALL_CPP("load_char", (self->x->load_char(charcode, flags, ft_object, fallback)));
 
     return PyGlyph_from_FT2Font(ft_object);
 }
@@ -743,7 +771,7 @@ static PyObject *PyFT2Font_load_glyph(PyFT2Font *self, PyObject *args, PyObject
 {
     FT_UInt glyph_index;
     FT_Int32 flags = FT_LOAD_FORCE_AUTOHINT;
-    int fallback = 1;
+    bool fallback = true;
     const char *names[] = { "glyph_index", "flags", NULL };
 
     /* This makes a technically incorrect assumption that FT_Int32 is
@@ -755,7 +783,7 @@ static PyObject *PyFT2Font_load_glyph(PyFT2Font *self, PyObject *args, PyObject
     }
 
     FT2Font *ft_object = NULL;
-    CALL_CPP("load_glyph", (self->x->load_glyph(glyph_index, flags, ft_object, (bool)fallback)));
+    CALL_CPP("load_glyph", (self->x->load_glyph(glyph_index, flags, ft_object, fallback)));
 
     return PyGlyph_from_FT2Font(ft_object);
 }
@@ -912,14 +940,16 @@ const char *PyFT2Font_get_glyph_name__doc__ =
 static PyObject *PyFT2Font_get_glyph_name(PyFT2Font *self, PyObject *args)
 {
     unsigned int glyph_number;
-    char buffer[128];
-    int fallback = 1;
+    std::string buffer;
+    bool fallback = true;
 
     if (!PyArg_ParseTuple(args, "I:get_glyph_name", &glyph_number)) {
         return NULL;
     }
-    CALL_CPP("get_glyph_name", (self->x->get_glyph_name(glyph_number, buffer, (bool)fallback)));
-    return PyUnicode_FromString(buffer);
+    buffer.resize(128);
+    CALL_CPP("get_glyph_name",
+             (self->x->get_glyph_name(glyph_number, buffer, fallback)));
+    return PyUnicode_FromString(buffer.c_str());
 }
 
 const char *PyFT2Font_get_charmap__doc__ =
@@ -962,13 +992,13 @@ static PyObject *PyFT2Font_get_char_index(PyFT2Font *self, PyObject *args)
 {
     FT_UInt index;
     FT_ULong ccode;
-    int fallback = 1;
+    bool fallback = true;
 
     if (!PyArg_ParseTuple(args, "k:get_char_index", &ccode)) {
         return NULL;
     }
 
-    CALL_CPP("get_char_index", index = self->x->get_char_index(ccode, (bool)fallback));
+    CALL_CPP("get_char_index", index = self->x->get_char_index(ccode, fallback));
 
     return PyLong_FromLong(index);
 }
@@ -1270,7 +1300,20 @@ const char *PyFT2Font_get_path__doc__ =
 
 static PyObject *PyFT2Font_get_path(PyFT2Font *self, PyObject *args)
 {
-    CALL_CPP("get_path", return self->x->get_path());
+    std::vector<double> vertices;
+    std::vector<unsigned char> codes;
+
+    CALL_CPP("get_path", self->x->get_path(vertices, codes));
+
+    npy_intp length = codes.size();
+    npy_intp vertices_dims[2] = { length, 2 };
+    numpy::array_view<double, 2> vertices_arr(vertices_dims);
+    memcpy(vertices_arr.data(), vertices.data(), sizeof(double) * vertices.size());
+    npy_intp codes_dims[1] = { length };
+    numpy::array_view<unsigned char, 1> codes_arr(codes_dims);
+    memcpy(codes_arr.data(), codes.data(), codes.size());
+
+    return Py_BuildValue("NN", vertices_arr.pyobj(), codes_arr.pyobj());
 }
 
 const char *PyFT2Font_get_image__doc__ =
