openscad-cpp-evaluator 1.28.1__tar.gz → 1.28.3__tar.gz

{openscad_cpp_evaluator-1.28.1 → openscad_cpp_evaluator-1.28.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: openscad_cpp_evaluator
-Version: 1.28.1
+Version: 1.28.3
 Summary: C++ OpenSCAD evaluator with Python bindings
 Author: NeuSCAD Contributors
 License-Expression: MIT

{openscad_cpp_evaluator-1.28.1 → openscad_cpp_evaluator-1.28.3}/include/openscad_cpp_evaluator/text_metrics.hpp

@@ -2,6 +2,7 @@
 
 #include "openscad_cpp_evaluator/font_provider.hpp"
 
+#include <functional>
 #include <string>
 #include <utility>
 #include <vector>
@@ -12,7 +13,12 @@ namespace oscadeval {
 // for `size`. `glyphs` is what text() places: each shaped glyph with its
 // pen position, already scaled. An inkless glyph (a space) still advances
 // the pen and still gets a glyphs entry -- it just contributes nothing to
-// ascent/descent/inkMinX/inkMaxX.
+// the ink box or ascent/descent.
+//
+// As in OpenSCAD's ShapeResults: left/right/bottom/top is the ink box of the
+// glyphs where they are placed, while ascent/descent are the glyphs' own
+// extents above and below THEIR baseline, ignoring where they sit. The two
+// only differ for a vertical run or a glyph the shaper offsets (a mark).
 //
 // The run comes from the shaper, so kerning and ligatures are already
 // applied and `spacing` scales the shaped advances rather than raw
@@ -23,8 +29,11 @@ struct TextMeasurement {
         double x = 0, y = 0;
     };
 
-    double ascent = 0, descent = 0, inkMinX = 0, inkMaxX = 0;
+    double ascent = 0, descent = 0;
+    double left = 0, right = 0, bottom = 0, top = 0;
     double advanceX = 0, advanceY = 0;
+    bool hasInk = false;
+    bool vertical = false;  // shaped ttb/btt
     std::vector<Placed> glyphs;
 };
 
@@ -32,9 +41,14 @@ TextMeasurement measureText(FontProvider& fp, FontHandle handle, const std::stri
                             double spacing, const ShapeOptions& opts = {});
 
 // (offsetX, offsetY) translation for halign/valign, given a
-// TextMeasurement. Shared by textmetrics() (reports it) and text()
+// TextMeasurement. "default" is left/baseline for a horizontal run and
+// center/top for a vertical one, as in OpenSCAD; text with no ink is not
+// moved at all. Shared by textmetrics() (reports it) and text()
 // (applies it).
+// `warn`, when given, receives OpenSCAD's own warning for an unknown
+// halign/valign, and for valign="baseline" on a vertical run.
 std::pair<double, double> textAlignOffset(const std::string& halign, const std::string& valign,
-                                          const TextMeasurement& m);
+                                          const TextMeasurement& m,
+                                          const std::function<void(const std::string&)>& warn = {});
 
 } // namespace oscadeval

{openscad_cpp_evaluator-1.28.1 → openscad_cpp_evaluator-1.28.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "scikit_build_core.build"
 
 [project]
 name = "openscad_cpp_evaluator"
-version = "1.28.1"
+version = "1.28.3"
 description = "C++ OpenSCAD evaluator with Python bindings"
 readme = "README.md"
 requires-python = ">=3.12"

{openscad_cpp_evaluator-1.28.1 → openscad_cpp_evaluator-1.28.3}/src/builtins/function_builtins.cpp

@@ -782,7 +782,7 @@ Value objectOf(std::vector<std::pair<std::string, Value>> items) {
 // descent/offset/advance in real OpenSCAD's key order. Going through the
 // same measureText() the geometry goes through is the point: the numbers
 // a script positions against cannot disagree with what it draws.
-Value builtinTextmetrics(Evaluator& ev, const CallArgs& args) {
+Value builtinTextmetrics(Evaluator& ev, const CallArgs& args, const oscad::Position* pos) {
     const std::string text = asStringOr(getArg(args, 0, "text", Value{std::string("")}), "");
     const double size = toDoubleLenient(getArg(args, 1, "size", Value{10.0}));
     // Positional indices, all of them: OpenSCAD's own signature is
@@ -792,8 +792,8 @@ Value builtinTextmetrics(Evaluator& ev, const CallArgs& args) {
     // `font` being name-only here is what made
     // `textmetrics("Hi", 10, "Liberation Sans:style=Bold")` silently
     // measure the default face (BelfrySCAD #381).
-    const std::string halign = asStringOr(getArg(args, 6, "halign", Value{std::string("left")}), "left");
-    const std::string valign = asStringOr(getArg(args, 7, "valign", Value{std::string("baseline")}), "baseline");
+    const std::string halign = asStringOr(getArg(args, 6, "halign", Value{std::string("default")}), "default");
+    const std::string valign = asStringOr(getArg(args, 7, "valign", Value{std::string("default")}), "default");
     const double spacing = toDoubleLenient(getArg(args, 8, "spacing", Value{1.0}));
     const std::string fontSpec = asStringOr(getArg(args, 2, "font", Value{std::string("")}), "");
     ShapeOptions shape;
@@ -804,11 +804,12 @@ Value builtinTextmetrics(Evaluator& ev, const CallArgs& args) {
     FontProvider& fp = ev.fontProvider();
     const FontHandle handle = fp.resolveFont(fontSpec);
     const TextMeasurement m = measureText(fp, handle, text, size, spacing, shape);
-    const auto [offsetX, offsetY] = textAlignOffset(halign, valign, m);
+    const auto [offsetX, offsetY] = textAlignOffset(
+        halign, valign, m, [&](const std::string& w) { ev.warn(w, pos); });
 
     return objectOf({
-        {"position", numList({offsetX + m.inkMinX, offsetY + m.descent})},
-        {"size", numList({m.inkMaxX - m.inkMinX, m.ascent - m.descent})},
+        {"position", numList({offsetX + m.left, offsetY + m.bottom})},
+        {"size", numList({m.right - m.left, m.top - m.bottom})},
         {"ascent", Value{m.ascent}},
         {"descent", Value{m.descent}},
         {"offset", numList({offsetX, offsetY})},
@@ -1251,7 +1252,7 @@ Value evalBuiltinFunctionResolved(Evaluator& ev, BuiltinFnId id, const std::vect
 
     switch (id) {
         case BuiltinFnId::None: return Value{}; // unreachable: handled above
-        case BuiltinFnId::TextMetrics: return builtinTextmetrics(ev, args);
+        case BuiltinFnId::TextMetrics: return builtinTextmetrics(ev, args, &node.position());
         case BuiltinFnId::FontMetrics: return builtinFontmetrics(ev, args);
         case BuiltinFnId::Abs: return Value{std::fabs(toDoubleLenient(getArg(args, 0, "x", Value{})))};
         case BuiltinFnId::Sign: {

{openscad_cpp_evaluator-1.28.1 → openscad_cpp_evaluator-1.28.3}/src/builtins/text.cpp

@@ -7,7 +7,7 @@
 
 #include <algorithm>
 
-// text(text=, size=10, font=, halign="left", valign="baseline", spacing=1,
+// text(text=, size=10, font=, halign="default", valign="default", spacing=1,
 // direction=, language=, script=) -- renders `text` as 2D glyph outlines
 // through the FontProvider (Evaluator::fontProvider(), lazily the built-in
 // FreetypeFontProvider if none was injected).
@@ -46,8 +46,8 @@ CSGParams resolveText(Evaluator& ev, const oscad::ModularCall& node, EvalContext
     // genuinely differ here -- textmetrics takes all nine positionally --
     // so neither can be assumed from the other.
     const std::string fontSpec = asStringOr(getArg(args, 2, "font", Value{std::string("")}), "");
-    const std::string halign = asStringOr(getArg(args, std::nullopt, "halign", Value{std::string("left")}), "left");
-    const std::string valign = asStringOr(getArg(args, std::nullopt, "valign", Value{std::string("baseline")}), "baseline");
+    const std::string halign = asStringOr(getArg(args, std::nullopt, "halign", Value{std::string("default")}), "default");
+    const std::string valign = asStringOr(getArg(args, std::nullopt, "valign", Value{std::string("default")}), "default");
     const double spacing = toDoubleLenient(getArg(args, std::nullopt, "spacing", Value{1.0}));
     ShapeOptions shape;
     shape.direction = asStringOr(getArg(args, std::nullopt, "direction", Value{std::string("")}), "");
@@ -60,7 +60,8 @@ CSGParams resolveText(Evaluator& ev, const oscad::ModularCall& node, EvalContext
     const double scale = size * (100.0 / 72.0) / fm.unitsPerEm;
     const int segs = std::max(2, fnSegmentsFromCtx(effCtx) / 2);
     const TextMeasurement m = measureText(fp, handle, text, size, spacing, shape);
-    const auto [offsetX, offsetY] = textAlignOffset(halign, valign, m);
+    const auto [offsetX, offsetY] = textAlignOffset(
+        halign, valign, m, [&](const std::string& w) { ev.warn(w, &node.position()); });
 
     std::vector<Value> glyphs;
     glyphs.reserve(m.glyphs.size());

{openscad_cpp_evaluator-1.28.1 → openscad_cpp_evaluator-1.28.3}/src/text/freetype_font_provider.cpp

@@ -31,6 +31,45 @@ void scaleHbFontToEm(hb_font_t* font, unsigned int unitsPerEm) {
     hb_font_set_scale(font, static_cast<int>(unitsPerEm), static_cast<int>(unitsPerEm));
 }
 
+// Vertical metrics come from FreeType, as they do in OpenSCAD (which shapes
+// through hb-ft). For a font with no vmtx -- nearly every Latin font,
+// Liberation Sans included -- the two disagree: hb-ot falls back to hhea
+// ascender-descender, FreeType to OS/2 typo ascender-descender, so a ttb
+// run of "abc" was 46.5 tall here and 39.1 there. Mirrors hb-ft's own
+// callbacks; font units in and out, since the hb font is scaled to the em.
+hb_position_t ftVAdvance(hb_font_t*, void* data, hb_codepoint_t glyph, void*) {
+    FT_Face ft = static_cast<FT_Face>(data);
+    if (FT_Load_Glyph(ft, glyph, FT_LOAD_NO_SCALE | FT_LOAD_NO_HINTING | FT_LOAD_VERTICAL_LAYOUT) != 0) return 0;
+    return static_cast<hb_position_t>(-ft->glyph->metrics.vertAdvance);  // FreeType's vertical grows downward
+}
+
+hb_bool_t ftVOrigin(hb_font_t*, void* data, hb_codepoint_t glyph, hb_position_t* x, hb_position_t* y, void*) {
+    FT_Face ft = static_cast<FT_Face>(data);
+    if (FT_Load_Glyph(ft, glyph, FT_LOAD_NO_SCALE | FT_LOAD_NO_HINTING | FT_LOAD_VERTICAL_LAYOUT) != 0) return false;
+    const FT_Glyph_Metrics& m = ft->glyph->metrics;
+    *x = static_cast<hb_position_t>(m.horiBearingX - m.vertBearingX);
+    *y = static_cast<hb_position_t>(m.horiBearingY + m.vertBearingY);
+    return true;
+}
+
+// hb-ot for everything, with the vertical metrics overridden by FreeType.
+hb_font_t* makeHbFont(hb_face_t* face, FT_Face ft, unsigned int unitsPerEm) {
+    static hb_font_funcs_t* vfuncs = [] {
+        hb_font_funcs_t* f = hb_font_funcs_create();
+        hb_font_funcs_set_glyph_v_advance_func(f, ftVAdvance, nullptr, nullptr);
+        hb_font_funcs_set_glyph_v_origin_func(f, ftVOrigin, nullptr, nullptr);
+        hb_font_funcs_make_immutable(f);
+        return f;
+    }();
+    hb_font_t* parent = hb_font_create(face);
+    hb_ot_font_set_funcs(parent);
+    scaleHbFontToEm(parent, unitsPerEm);
+    hb_font_t* font = hb_font_create_sub_font(parent);  // everything unset delegates to parent
+    hb_font_destroy(parent);
+    hb_font_set_funcs(font, vfuncs, ft, nullptr);
+    return font;
+}
+
 struct OutlineSink {
     GlyphContours contours;
     std::vector<std::array<double, 2>> current;
@@ -159,10 +198,8 @@ struct FreetypeFontProvider::Impl {
             return std::nullopt;
         }
         f.hbFace = hb_face_create(f.blob, static_cast<unsigned>(index));
-        f.hbFont = hb_font_create(f.hbFace);
-        hb_ot_font_set_funcs(f.hbFont);
         f.metrics = readMetrics(f.ft);
-        scaleHbFontToEm(f.hbFont, static_cast<unsigned>(f.metrics.unitsPerEm));
+        f.hbFont = makeHbFont(f.hbFace, f.ft, static_cast<unsigned>(f.metrics.unitsPerEm));
         faces.push_back(f);
         return faces.size() - 1;
     }
@@ -185,10 +222,8 @@ struct FreetypeFontProvider::Impl {
             f.blob = hb_blob_create(reinterpret_cast<const char*>(src.data),
                                     static_cast<unsigned>(src.size), HB_MEMORY_MODE_READONLY, nullptr, nullptr);
             f.hbFace = hb_face_create(f.blob, 0);
-            f.hbFont = hb_font_create(f.hbFace);
-            hb_ot_font_set_funcs(f.hbFont);
             f.metrics = readMetrics(f.ft);
-            scaleHbFontToEm(f.hbFont, static_cast<unsigned>(f.metrics.unitsPerEm));
+            f.hbFont = makeHbFont(f.hbFace, f.ft, static_cast<unsigned>(f.metrics.unitsPerEm));
             faces.push_back(f);
         }
     }

openscad_cpp_evaluator-1.28.3/src/text/text_metrics.cpp

@@ -0,0 +1,95 @@
+#include "openscad_cpp_evaluator/text_metrics.hpp"
+
+#include <algorithm>
+#include <cctype>
+
+namespace oscadeval {
+
+TextMeasurement measureText(FontProvider& fp, FontHandle handle, const std::string& text, double size,
+                            double spacing, const ShapeOptions& opts) {
+    const FontMetrics fm = fp.metrics(handle);
+    // The 100/72 factor is real OpenSCAD's long-standing text() size bug
+    // (its issue #4304: FT_Set_Char_Size is given 100 dpi where 72 is
+    // correct, making glyphs ~1.39x the nominal size). It is reproduced
+    // deliberately -- a decade of models are drawn to it, and OpenSCAD
+    // itself chose to keep the bug and add an `em=` parameter rather than
+    // fix it.
+    const double scale = size * (100.0 / 72.0) / fm.unitsPerEm;
+
+    TextMeasurement m;
+    // hb_direction_from_string reads only the first letter, so this is
+    // exactly the set of strings the shaper takes as vertical.
+    const char d = opts.direction.empty() ? 'l' : static_cast<char>(std::tolower(opts.direction[0]));
+    m.vertical = d == 't' || d == 'b';
+    double penX = 0.0, penY = 0.0;
+
+    for (const ShapedGlyph& g : fp.shapeText(handle, text, opts)) {
+        const double x = (penX + g.xOffset) * scale;
+        const double y = (penY + g.yOffset) * scale;
+
+        if (const std::optional<std::array<double, 4>> b = fp.glyphInkBounds(handle, g.glyph)) {
+            const double gl = x + (*b)[0] * scale, gr = x + (*b)[2] * scale;
+            const double gb = y + (*b)[1] * scale, gt = y + (*b)[3] * scale;
+            const double asc = (*b)[3] * scale, desc = (*b)[1] * scale;
+            if (!m.hasInk) {
+                m.left = gl, m.right = gr, m.bottom = gb, m.top = gt;
+                m.ascent = asc, m.descent = desc;
+                m.hasInk = true;
+            } else {
+                m.left = std::min(m.left, gl);
+                m.right = std::max(m.right, gr);
+                m.bottom = std::min(m.bottom, gb);
+                m.top = std::max(m.top, gt);
+                m.ascent = std::max(m.ascent, asc);
+                m.descent = std::min(m.descent, desc);
+            }
+        }
+
+        m.glyphs.push_back(TextMeasurement::Placed{g.glyph, x, y});
+        penX += g.xAdvance * spacing;
+        penY += g.yAdvance * spacing;
+    }
+
+    m.advanceX = penX * scale;
+    m.advanceY = penY * scale;
+    return m;
+}
+
+// OpenSCAD's ShapeResults::calc_offsets_horiz/_vert, warnings included. An
+// unknown value, or valign="baseline" on a vertical run, leaves that axis
+// where it is. Text with no ink never gets this far there, so it never
+// warns either.
+std::pair<double, double> textAlignOffset(const std::string& halign, const std::string& valign,
+                                          const TextMeasurement& m,
+                                          const std::function<void(const std::string&)>& warn) {
+    if (!m.hasInk) return {0.0, 0.0};
+    auto unknown = [&](const char* param, const char* choices, const std::string& value) {
+        if (warn) {
+            warn(std::string("Unknown value for the ") + param + " parameter (use " + choices + "): '" + value + "'");
+        }
+    };
+    const char* hChoices = "\"left\", \"right\" or \"center\"";
+    const char* vChoices = "\"baseline\", \"bottom\", \"top\" or \"center\"";
+    double offsetX = 0.0, offsetY = 0.0;
+    if (m.vertical) {
+        if (halign == "right") offsetX = -m.right;
+        else if (halign == "left") offsetX = -m.left;
+        else if (halign != "center" && halign != "default") unknown("halign", hChoices, halign);
+        if (valign == "center") offsetY = -m.advanceY / 2;
+        else if (valign == "bottom") offsetY = -m.advanceY;
+        else if (valign == "baseline") {
+            if (warn) warn("Don't use valign=\"baseline\" with vertical layouts");
+        } else if (valign != "top" && valign != "default") unknown("valign", vChoices, valign);
+    } else {
+        if (halign == "center") offsetX = -0.5 * m.advanceX;
+        else if (halign == "right") offsetX = -m.advanceX;
+        else if (halign != "left" && halign != "default") unknown("halign", hChoices, halign);
+        if (valign == "top") offsetY = -m.ascent;
+        else if (valign == "center") offsetY = -(m.ascent + m.descent) / 2;
+        else if (valign == "bottom") offsetY = -m.descent;
+        else if (valign != "baseline" && valign != "default") unknown("valign", vChoices, valign);
+    }
+    return {offsetX, offsetY};
+}
+
+} // namespace oscadeval

{openscad_cpp_evaluator-1.28.1 → openscad_cpp_evaluator-1.28.3}/tests/test_text.cpp

@@ -97,6 +97,69 @@ TEST(Textmetrics, AdvanceXIsPositiveForNonEmptyText) {
     EXPECT_DOUBLE_EQ(asNum(items[1]), 0.0);
 }
 
+// Vertical runs, against OpenSCAD 2026.02.01 (it hints, so ~0.01 apart).
+// Its vertical metrics are FreeType's -- OS/2 typo ascender-descender for a
+// font without vmtx -- not hb-ot's hhea fallback, which gave 46.5 here.
+namespace {
+double vec(const Value& obj, const std::string& key, int i) {
+    return asNum(std::get<ListPtr>(objGet(obj, key))->items[i]);
+}
+} // namespace
+
+TEST(Textmetrics, VerticalRunMatchesOpenscad) {
+    Evaluator ev;
+    Value v = asExpr("textmetrics(\"abc\", size=10, direction=\"ttb\")", ev);
+    EXPECT_NEAR(vec(v, "advance", 1), -39.1032, 1e-3);
+    EXPECT_NEAR(vec(v, "position", 0), -3.2733, 0.01);
+    EXPECT_NEAR(vec(v, "position", 1), -36.3957, 0.01);
+    EXPECT_NEAR(vec(v, "size", 1), 33.6848, 0.01);
+    EXPECT_NEAR(asNum(objGet(v, "ascent")), 10.0672, 0.01);  // the glyphs' own, not their placement
+}
+
+TEST(Textmetrics, VerticalRunAlignsByItsOwnRules) {
+    Evaluator ev;
+    Value lc = asExpr("textmetrics(\"abc\", size=10, direction=\"ttb\", halign=\"left\", valign=\"center\")", ev);
+    EXPECT_NEAR(vec(lc, "offset", 0), 3.2733, 0.01);
+    EXPECT_NEAR(vec(lc, "offset", 1), 19.5516, 1e-3);
+    Value rb = asExpr("textmetrics(\"abc\", size=10, direction=\"ttb\", halign=\"right\", valign=\"bottom\")", ev);
+    EXPECT_NEAR(vec(rb, "offset", 0), -3.8627, 0.01);
+    EXPECT_NEAR(vec(rb, "offset", 1), 39.1032, 1e-3);
+}
+
+// OpenSCAD 2026.02.01's warnings, verbatim. Inkless text never reaches
+// its alignment code there, so it does not warn.
+TEST(Text, UnknownAlignmentWarnsAsOpenscadDoes) {
+    const std::pair<const char*, std::vector<std::string>> cases[] = {
+        {"m = textmetrics(\"ab\", halign=\"middle\");",
+         {"Unknown value for the halign parameter (use \"left\", \"right\" or \"center\"): 'middle'"}},
+        {"m = textmetrics(\"ab\", valign=\"mid\");",
+         {"Unknown value for the valign parameter (use \"baseline\", \"bottom\", \"top\" or \"center\"): 'mid'"}},
+        {"m = textmetrics(\"ab\", direction=\"ttb\", valign=\"baseline\");",
+         {"Don't use valign=\"baseline\" with vertical layouts"}},
+        {"text(\"ab\", direction=\"ttb\", halign=\"x\", valign=\"y\");",
+         {"Unknown value for the halign parameter (use \"left\", \"right\" or \"center\"): 'x'",
+          "Unknown value for the valign parameter (use \"baseline\", \"bottom\", \"top\" or \"center\"): 'y'"}},
+        {"m = textmetrics(\"  \", halign=\"bogus\");", {}},
+        {"m = textmetrics(\"ab\", halign=\"default\", valign=\"default\");", {}},
+        {"m = textmetrics(\"ab\", direction=\"ttb\", valign=\"top\");", {}},
+    };
+    for (const auto& [src, want] : cases) {
+        std::vector<std::string> log;
+        evalSrc(src, [&](const std::string& m) { log.push_back(m); });
+        ASSERT_EQ(log.size(), want.size()) << src;
+        for (size_t i = 0; i < want.size(); ++i) {
+            EXPECT_EQ(log[i], "WARNING: " + want[i] + " in file <string>, line 1") << src;
+        }
+    }
+}
+
+TEST(Textmetrics, InklessTextIsNotAligned) {
+    Evaluator ev;
+    Value v = asExpr("textmetrics(\"  \", size=10, halign=\"right\")", ev);
+    EXPECT_EQ(vec(v, "offset", 0), 0.0);
+    EXPECT_GT(vec(v, "advance", 0), 7.0);
+}
+
 TEST(Textmetrics, AscentIsPositiveDescentIsNonPositive) {
     Evaluator ev;
     Value v = asExpr("textmetrics(text=\"Hi\", size=10)", ev);

{openscad_cpp_evaluator-1.28.1 → openscad_cpp_evaluator-1.28.3}/uv.lock

@@ -55,7 +55,7 @@ wheels = [
 
 [[package]]
 name = "openscad-cpp-evaluator"
-version = "1.28.1"
+version = "1.28.3"
 source = { editable = "." }
 dependencies = [
     { name = "numpy" },

openscad_cpp_evaluator-1.28.1/src/text/text_metrics.cpp

@@ -1,70 +0,0 @@
-#include "openscad_cpp_evaluator/text_metrics.hpp"
-
-#include <algorithm>
-
-namespace oscadeval {
-
-TextMeasurement measureText(FontProvider& fp, FontHandle handle, const std::string& text, double size,
-                            double spacing, const ShapeOptions& opts) {
-    const FontMetrics fm = fp.metrics(handle);
-    // The 100/72 factor is real OpenSCAD's long-standing text() size bug
-    // (its issue #4304: FT_Set_Char_Size is given 100 dpi where 72 is
-    // correct, making glyphs ~1.39x the nominal size). It is reproduced
-    // deliberately -- a decade of models are drawn to it, and OpenSCAD
-    // itself chose to keep the bug and add an `em=` parameter rather than
-    // fix it.
-    const double scale = size * (100.0 / 72.0) / fm.unitsPerEm;
-
-    TextMeasurement m;
-    double penX = 0.0, penY = 0.0;
-    bool hasInk = false;
-
-    for (const ShapedGlyph& g : fp.shapeText(handle, text, opts)) {
-        const double x = (penX + g.xOffset) * scale;
-        const double y = (penY + g.yOffset) * scale;
-
-        if (const std::optional<std::array<double, 4>> b = fp.glyphInkBounds(handle, g.glyph)) {
-            const double left = x + (*b)[0] * scale;
-            const double right = x + (*b)[2] * scale;
-            const double bottom = y + (*b)[1] * scale;
-            const double top = y + (*b)[3] * scale;
-            if (!hasInk) {
-                m.inkMinX = left;
-                m.inkMaxX = right;
-                m.ascent = top;
-                m.descent = bottom;
-                hasInk = true;
-            } else {
-                m.inkMinX = std::min(m.inkMinX, left);
-                m.inkMaxX = std::max(m.inkMaxX, right);
-                m.ascent = std::max(m.ascent, top);
-                m.descent = std::min(m.descent, bottom);
-            }
-        }
-
-        m.glyphs.push_back(TextMeasurement::Placed{g.glyph, x, y});
-        penX += g.xAdvance * spacing;
-        penY += g.yAdvance * spacing;
-    }
-
-    m.advanceX = penX * scale;
-    m.advanceY = penY * scale;
-    return m;
-}
-
-std::pair<double, double> textAlignOffset(const std::string& halign, const std::string& valign,
-                                          const TextMeasurement& m) {
-    double offsetX = 0.0;
-    if (halign == "center") offsetX = -0.5 * m.advanceX;
-    else if (halign == "right") offsetX = -1.0 * m.advanceX;
-
-    double offsetY = 0.0;
-    if (valign == "top") offsetY = -m.ascent;
-    else if (valign == "center") offsetY = -(m.ascent + m.descent) / 2;
-    else if (valign == "bottom") offsetY = -m.descent;
-    // "baseline" (or anything else) -> 0
-
-    return {offsetX, offsetY};
-}
-
-} // namespace oscadeval