Glyph indices (#72)

* use glyph indices instead of Chars in a bunch of places

* make more Char code glyph generic

* throw more descriptive loading errors

* remove old string boundingbox code

* remove old layout-related tests

* remove iter_or_array and add (broken) tests

* add more tests

* add more tests

* bump minor version

Project.toml

@@ -1,6 +1,6 @@
 name = "FreeTypeAbstraction"
 uuid = "663a7486-cb36-511b-a19d-713bb74d65c9"
-version = "0.9.9"
+version = "0.10.0"
 
 [deps]
 ColorVectorSpace = "c3611d14-8923-5661-9e6a-0046d554d3a4"

src/layout.jl

@@ -1,67 +1,18 @@
-iter_or_array(x) = repeated(x)
-iter_or_array(x::Repeated) = x
-iter_or_array(x::AbstractArray) = x
-# We treat staticarrays as scalar
-iter_or_array(x::Union{Mat, StaticVector}) = repeated(x)
-
-
-function metrics_bb(char::Char, font::FTFont, pixel_size)
-    extent = get_extent(font, char) .* Vec2f(pixel_size)
+function metrics_bb(glyph, font::FTFont, pixel_size)
+    extent = get_extent(font, glyph) .* Vec2f(pixel_size)
     return boundingbox(extent), extent
 end
 
-function boundingbox(char::Char, font::FTFont, pixel_size)
-    bb, extent = metrics_bb(char, font, pixel_size)
+function boundingbox(glyph, font::FTFont, pixel_size)
+    bb, extent = metrics_bb(glyph, font, pixel_size)
     return bb
 end
 
-function glyph_ink_size(char::Char, font::FTFont, pixel_size)
-    bb, extent = metrics_bb(char, font, pixel_size)
+function glyph_ink_size(glyph, font::FTFont, pixel_size)
+    bb, extent = metrics_bb(glyph, font, pixel_size)
     return widths(bb)
 end
 
-"""
-    iterate_extents(f, line::AbstractString, fonts, scales)
-Iterates over the extends of the characters (glyphs) in line!
-Newlines will be drawn like any other character.
-`fonts` can be a vector of fonts, or a single font.
-`scales` can be a single float or a Vec2, or a vector of any of those.
-
-`f` will get called with `(char::Char, glyph_box::Rec2D, glyph_advance::Point2f)`.
-
-`char` is the currently iterated char.
-
-`glyph_box` is the boundingbox of the glyph.
-widths(box) will be the size of the bitmap, while minimum(box) is where one starts drawing the glyph.
-For the minimum at y position, 0 is the where e.g. `m` starts, so `g` will start in the negative, while `^` will start positive.
-
-`glyph_advance` The amount one advances after glyph, before drawing next glyph.
-"""
-function iterate_extents(f, line::AbstractString, fonts, scales)
-    iterator = zip(line, iter_or_array(scales), iter_or_array(fonts))
-    lastpos = 0.0
-    for (char, scale, font) in iterator
-        glyph_box, extent = metrics_bb(char, font, scale)
-        mini = minimum(glyph_box) .+ Vec2f(lastpos, 0.0)
-        glyph_box = Rect2(mini, widths(glyph_box))
-        glyph_advance = Point2f(extent.advance)
-        lastpos += glyph_advance[1]
-        f(char, glyph_box, glyph_advance)
-    end
-end
-
-function glyph_rects(line::AbstractString, fonts, scales)
-    rects = Rect2[]
-    iterate_extents(line, fonts, scales) do char, box, advance
-        push!(rects, box)
-    end
-    return rects
-end
-
-function boundingbox(line::AbstractString, fonts, scales)
-    return reduce(union, glyph_rects(line, fonts, scales))
-end
-
 function inkboundingbox(ext::FontExtent)
     l = leftinkbound(ext)
     r = rightinkbound(ext)
@@ -73,6 +24,7 @@ end
 function height_insensitive_boundingbox(ext::FontExtent, font::FTFont)
     l = leftinkbound(ext)
     r = rightinkbound(ext)
+    # this is wrong because of pixel size
     b = descender(font)
     t = ascender(font)
     return Rect2f((l, b), (r - l, t - b))

src/rendering.jl

@@ -1,24 +1,25 @@
 
-function loadchar(face::FTFont, c::Char)
-    err = FT_Load_Char(face, c, FT_LOAD_RENDER)
-    check_error(err, "Could not load char to render.")
+function load_glyph(face::FTFont, glyph)
+    gi = glyph_index(face, glyph)
+    err = FT_Load_Glyph(face, gi, FT_LOAD_RENDER)
+    check_error(err, "Could not load glyph $(repr(glyph)) from $(face) to render.")
 end
 
-function loadglyph(face::FTFont, c::Char, pixelsize::Integer)
+function loadglyph(face::FTFont, glyph, pixelsize::Integer)
     set_pixelsize(face, pixelsize)
-    loadchar(face, c)
-    glyph = unsafe_load(face.glyph)
-    @assert glyph.format == FreeType.FT_GLYPH_FORMAT_BITMAP
-    return glyph
+    load_glyph(face, glyph)
+    gl = unsafe_load(face.glyph)
+    @assert gl.format == FreeType.FT_GLYPH_FORMAT_BITMAP
+    return gl
 end
 
-function renderface(face::FTFont, c::Char, pixelsize::Integer)
-    glyph = loadglyph(face, c, pixelsize)
-    return glyphbitmap(glyph.bitmap), FontExtent(glyph.metrics)
+function renderface(face::FTFont, glyph, pixelsize::Integer)
+    gl = loadglyph(face, glyph, pixelsize)
+    return glyphbitmap(gl.bitmap), FontExtent(gl.metrics)
 end
 
-function extents(face::FTFont, c::Char, pixelsize::Integer)
-    return FontExtent(loadglyph(face, c, pixelsize).metrics)
+function extents(face::FTFont, glyph, pixelsize::Integer)
+    return FontExtent(loadglyph(face, glyph, pixelsize).metrics)
 end
 
 function glyphbitmap(bitmap::FreeType.FT_Bitmap)

src/types.jl

@@ -126,9 +126,9 @@ end
 mutable struct FTFont
     ft_ptr::FreeType.FT_Face
     use_cache::Bool
-    extent_cache::Dict{Char, FontExtent{Float32}}
+    extent_cache::Dict{UInt64, FontExtent{Float32}}
     function FTFont(ft_ptr::FreeType.FT_Face, use_cache::Bool=true)
-        extent_cache = Dict{Tuple{Int, Char}, FontExtent{Float32}}()
+        extent_cache = Dict{UInt64, FontExtent{Float32}}()
         face = new(ft_ptr, use_cache, extent_cache)
         finalizer(safe_free, face)
         return face
@@ -173,9 +173,9 @@ function set_pixelsize(face::FTFont, size::Integer)
     return size
 end
 
-function kerning(c1::Char, c2::Char, face::FTFont)
-    i1 = FT_Get_Char_Index(face, c1)
-    i2 = FT_Get_Char_Index(face, c2)
+function kerning(glyphspec1, glyphspec2, face::FTFont)
+    i1 = glyph_index(face, glyphspec1)
+    i2 = glyph_index(face, glyphspec2)
     kerning2d = Ref{FreeType.FT_Vector}()
     err = FT_Get_Kerning(face, i1, i2, FreeType.FT_KERNING_DEFAULT, kerning2d)
     # Can error if font has no kerning! Since that's somewhat expected, we just return 0
@@ -185,17 +185,23 @@ function kerning(c1::Char, c2::Char, face::FTFont)
     return Vec2f(kerning2d[].x / divisor, kerning2d[].y / divisor)
 end
 
-function get_extent(face::FTFont, char::Char)
+function get_extent(face::FTFont, glyphspec)
+    gi = glyph_index(face, glyphspec)
     if use_cache(face)
-        get!(get_cache(face), char) do
-            return internal_get_extent(face, char)
+        get!(get_cache(face), gi) do
+            return internal_get_extent(face, gi)
         end
     else
-        return internal_get_extent(face, char)
+        return internal_get_extent(face, gi)
     end
 end
 
-function internal_get_extent(face::FTFont, char::Char)
+glyph_index(face::FTFont, glyphname::String)::UInt64 = FT_Get_Name_Index(face, glyphname)
+glyph_index(face::FTFont, char::Char)::UInt64 = FT_Get_Char_Index(face, char)
+glyph_index(face::FTFont, int::Integer) = UInt64(int)
+
+function internal_get_extent(face::FTFont, glyphspec)
+    gi = glyph_index(face, glyphspec)
     #=
     Load chars without scaling. This leaves all glyph metrics that can be
     retrieved in font units, which can be normalized by dividing with the
@@ -204,8 +210,8 @@ function internal_get_extent(face::FTFont, char::Char)
     pixelsize can be silently changed by third parties, such as Cairo.
     If that happens, all glyph metrics are incorrect. We avoid this by using the normalized space.
     =#
-    err = FT_Load_Char(face, char, FT_LOAD_NO_SCALE)
-    check_error(err, "Could not load char to get extent.")
+    err = FT_Load_Glyph(face, gi, FT_LOAD_NO_SCALE)
+    check_error(err, "Could not load glyph $(repr(glyphspec)) from $(face) to get extent.")
     # This gives us the font metrics in normalized units (0, 1), with negative
     # numbers interpreted as an offset
     return FontExtent(unsafe_load(face.glyph).metrics, Float32(face.units_per_EM))

test/runtests.jl

@@ -1,10 +1,18 @@
 ENV["FREETYPE_ABSTRACTION_FONT_PATH"] = @__DIR__  # coverage
 
 using FreeTypeAbstraction, Colors, ColorVectorSpace, GeometryBasics
+using GeometryBasics: Vec2f
 import FreeTypeAbstraction as FA
 using FreeType
 using Test
 
+@testset "init and done" begin
+    @test_throws ErrorException FA.ft_init()
+    @test FA.ft_done()
+    @test_throws ErrorException FA.ft_done()
+    @test FA.ft_init()
+end
+
 face = FA.findfont("hack")
 
 @testset "basics" begin
@@ -15,10 +23,6 @@ face = FA.findfont("hack")
     @test FA.ascender(face) isa Real
     @test FA.descender(face) isa Real
 
-    bb = FA.boundingbox("asdasd", face, 64)
-    @test round.(Int, minimum(bb)) == Vec(4, -1)
-    @test round.(Int, widths(bb)) == Vec2(221, 50)
-
     FA.set_pixelsize(face, 64) # should be the default
     img, extent = FA.renderface(face, 'C', 64)
     @test size(img) == (30, 49)
@@ -33,6 +37,8 @@ face = FA.findfont("hack")
     @test FA.rightinkbound(extent) == 34
     @test FA.bottominkbound(extent) == -1
     @test FA.topinkbound(extent) == 48
+    @test FA.inkboundingbox(extent) == HyperRectangle{2, Float32}(Float32[4.0, -1.0], Float32[30.0, 49.0])
+    @test_broken FA.height_insensitive_boundingbox(extent, face) == HyperRectangle{2, Float32}(Float32[4.0, 64 * -0.23583984], Float32[30.0, 64 * 1.2006836])
 
     a = renderstring!(zeros(UInt8, 20, 100), "helgo", face, 10, 10, 10)
 
@@ -55,6 +61,12 @@ face = FA.findfont("hack")
     @test_logs (:warn, "using tuple for pixelsize is deprecated, please use one integer") renderstring!(zeros(UInt8, 20, 100), "helgo", face, (10, 10), 1, 1)
 end
 
+@testset "ways to access glyphs" begin
+    i = FA.glyph_index(face, 'A')
+    @test FA.glyph_index(face, i) == i
+    @test FA.glyph_index(face, "A") == i
+end
+
 @testset "alignements" begin
     a = renderstring!(
         zeros(UInt8, 20, 100),
@@ -217,25 +229,6 @@ end
     @test true
 end
 
-@testset "layout" begin
-    extent = FA.extents(face, '█', 10)
-    @test extent == FA.extents(face, '█', 10)
-    FA.inkboundingbox(extent)
-    FA.height_insensitive_boundingbox(extent, face)
-
-    FA.boundingbox('a', face, .5)
-    FA.glyph_ink_size('a', face, .5)
-    FA.metrics_bb('a', face, .5)
-
-    for (ft, sc) in (
-        (face, .5),
-        ([face, face], [.5, .5]),
-        (Iterators.repeated(face), Iterators.repeated(.5))
-    )
-        FA.boundingbox("ab", ft, sc)
-    end
-end
-
 # Find fonts
 # these fonts should be available on all platforms:
 
@@ -283,3 +276,21 @@ end
     end
     @test true
 end
+
+@testset "Font extent" begin
+    f1 = FontExtent(Vec2f(1, 2), Vec2f(3, 4), Vec2f(5, 6), Vec2f(7, 8))
+    f2 = FA.broadcasted(x -> 2 * x, f1)
+    @test f2 == FontExtent(Vec2f(2, 4), Vec2f(6, 8), Vec2f(10, 12), Vec2f(14, 16))
+    f3 = FA.broadcasted(*, f1, Vec2f(2, 3))
+    @test f3 == FontExtent(Vec2f(2, 4), Vec2f(9, 12), Vec2f(10, 18), Vec2f(14, 24))
+end
+
+@testset "Boundingbox" begin
+    for glyph in ('a', FA.glyph_index(face, 'a'), "a")
+        bb, extent = FA.metrics_bb(glyph, face, 64)
+        bb2 = FA.boundingbox(glyph, face, 64)
+        @test bb == bb2
+        w = GeometryBasics.widths(bb2)
+        @test w == FA.glyph_ink_size(glyph, face, 64)
+    end
+end