Merge pull request #45 from JuliaGraphics/sd/em_units

fixes + add more needed functionality

Author: SimonDanisch

src/layout.jl

@@ -5,12 +5,22 @@ iter_or_array(x::AbstractArray) = x
 iter_or_array(x::StaticArray) = repeated(x)
 
 
-function metrics_bb(char::Char, font::FTFont, scale)
-    extent = get_extent(font, char) .* Vec2f0(scale)
+function metrics_bb(char::Char, font::FTFont, pixel_size)
+    extent = get_extent(font, char) .* Vec2f0(pixel_size)
     mini = bearing(extent)
     return Rect2D(mini, Vec2f0(extent.scale)), extent
 end
 
+function boundingbox(char::Char, font::FTFont, pixel_size)
+    bb, extent = metrics_bb(char, font, pixel_size)
+    return bb
+end
+
+function glyph_ink_size(char::Char, font::FTFont, pixel_size)
+    bb, extent = metrics_bb(char, font, pixel_size)
+    return widths(bb)
+end
+
 """
     iterate_extents(f, line::AbstractString, fonts, scales)
 Iterates over the extends of the characters (glyphs) in line!
@@ -41,7 +51,6 @@ function iterate_extents(f, line::AbstractString, fonts, scales)
     end
 end
 
-
 function glyph_rects(line::AbstractString, fonts, scales)
     rects = Rect2D[]
     iterate_extents(line, fonts, scales) do char, box, advance
@@ -53,3 +62,19 @@ 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)
+    b = bottominkbound(ext)
+    t = topinkbound(ext)
+    return FRect2D((l, b), (r - l, t - b))
+end
+
+function height_insensitive_boundingbox(ext::FontExtent, font::FTFont)
+    l = leftinkbound(ext)
+    r = rightinkbound(ext)
+    b = descender(font)
+    t = ascender(font)
+    return FRect2D((l, b), (r - l, t - b))
+end

src/rendering.jl

@@ -1,11 +1,15 @@
 
-function renderface(face::FTFont, c::Char,
-                    pixelsize::Integer=get_pixelsize(face))
+function loadchar(face::FTFont, c::Char)
+    err = FT_Load_Char(face, c, FT_LOAD_RENDER)
+    check_error(err, "Could not load char to render.")
+end
+
+function renderface(face::FTFont, c::Char, pixelsize::Integer)
     set_pixelsize(face, pixelsize)
     loadchar(face, c)
     glyph = face.glyph
     @assert glyph.format == FreeType.FT_GLYPH_FORMAT_BITMAP
-    return glyphbitmap(glyph.bitmap), get_extent(face, c)
+    return glyphbitmap(glyph.bitmap), FontExtent(glyph.metrics)
 end
 
 function glyphbitmap(bitmap::FreeType.FT_Bitmap)
@@ -46,17 +50,17 @@ function renderstring!(
 
     if pixelsize isa Tuple
         @warn "using tuple for pixelsize is deprecated, please use one integer"
-        set_pixelsize(face, pixelsize[1])
-    else
-        set_pixelsize(face, pixelsize)
+        pixelsize = pixelsize[1]
     end
 
+    set_pixelsize(face, pixelsize)
+
     bitmaps = Vector{Matrix{UInt8}}(undef, lastindex(str))
     metrics = Vector{FontExtent{Int}}(undef, lastindex(str))
     ymin = ymax = sumadvancex = 0
 
     for (istr, char) = enumerate(str)
-        bitmap, metric_float = renderface(face, char)
+        bitmap, metric_float = renderface(face, char, pixelsize)
         metric = round.(Int, metric_float)
         bitmaps[istr] = bitmap
         metrics[istr] = metric

src/types.jl

@@ -35,6 +35,16 @@ struct FontExtent{T}
     scale::Vec{2, T}
 end
 
+hadvance(ext::FontExtent) = ext.advance[1]
+inkwidth(ext::FontExtent) = ext.scale[1]
+inkheight(ext::FontExtent) = ext.scale[2]
+hbearing_ori_to_left(ext::FontExtent) = ext.horizontal_bearing[1]
+hbearing_ori_to_top(ext::FontExtent) = ext.horizontal_bearing[2]
+leftinkbound(ext::FontExtent) = hbearing_ori_to_left(ext)
+rightinkbound(ext::FontExtent) = leftinkbound(ext) + inkwidth(ext)
+bottominkbound(ext::FontExtent) = hbearing_ori_to_top(ext) - inkheight(ext)
+topinkbound(ext::FontExtent) = hbearing_ori_to_top(ext)
+
 BroadcastStyle(::Type{<: FontExtent}) = Style{FontExtent}()
 BroadcastStyle(::Style{FontExtent}, x) = Style{FontExtent}()
 BroadcastStyle(x, ::Style{FontExtent}) = Style{FontExtent}()
@@ -110,20 +120,18 @@ end
 
 mutable struct FTFont
     ft_ptr::FreeType.FT_Face
-    current_pixelsize::Base.RefValue{Int}
     use_cache::Bool
-    cache::Dict{Tuple{Int, Char}, FontExtent{Float32}}
-    function FTFont(ft_ptr::FreeType.FT_Face, pixel_size::Int=64, use_cache::Bool=true)
-        cache = Dict{Tuple{Int, Char}, FontExtent{Float32}}()
-        face = new(ft_ptr, Ref(pixel_size), use_cache, cache)
+    extent_cache::Dict{Char, FontExtent{Float32}}
+    function FTFont(ft_ptr::FreeType.FT_Face, use_cache::Bool=true)
+        extent_cache = Dict{Tuple{Int, Char}, FontExtent{Float32}}()
+        face = new(ft_ptr, use_cache, extent_cache)
         finalizer(safe_free, face)
-        FT_Set_Pixel_Sizes(face, pixel_size, 0);
         return face
     end
 end
 
 use_cache(face::FTFont) = getfield(face, :use_cache)
-get_cache(face::FTFont) = getfield(face, :cache)
+get_cache(face::FTFont) = getfield(face, :extent_cache)
 
 function FTFont(path::String)
     return FTFont(newface(path))
@@ -159,13 +167,9 @@ end
 # Allow broadcasting over fonts
 Base.Broadcast.broadcastable(ft::FTFont) = Ref(ft)
 
-get_pixelsize(face::FTFont) = getfield(face, :current_pixelsize)[]
-
 function set_pixelsize(face::FTFont, size::Integer)
-    get_pixelsize(face) == size && return size
     err = FT_Set_Pixel_Sizes(face, size, size)
     check_error(err, "Couldn't set pixelsize")
-    getfield(face, :current_pixelsize)[] = size
     return size
 end
 
@@ -181,14 +185,9 @@ function kerning(c1::Char, c2::Char, face::FTFont)
     return Vec2f0(kerning2d[].x / divisor, kerning2d[].y / divisor)
 end
 
-function loadchar(face::FTFont, c::Char)
-    err = FT_Load_Char(face, c, FT_LOAD_RENDER)
-    check_error(err, "Could not load char to render.")
-end
-
 function get_extent(face::FTFont, char::Char)
     if use_cache(face)
-        get!(get_cache(face), (get_pixelsize(face), char)) do
+        get!(get_cache(face), char) do
             return internal_get_extent(face, char)
         end
     else
@@ -197,9 +196,20 @@ function get_extent(face::FTFont, char::Char)
 end
 
 function internal_get_extent(face::FTFont, char::Char)
-    err = FT_Load_Char(face, char, FT_LOAD_DEFAULT)
-    check_error(err, "Could not load char to get extend.")
-    metrics = face.glyph.metrics
-    # 64 since metrics are in 1/64 units (units to 26.6 fractional pixels)
-    return FontExtent(metrics, Float32(64))
-end
+    #=
+    Load chars without scaling. This leaves all glyph metrics that can be
+    retrieved in font units, which can be normalized by dividing with the
+    font's units_per_EM. This is more robust than relying on extents
+    that are only valid with a specific pixelsize, because a font's
+    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.")
+    # This gives us the font metrics in normalized units (0, 1), with negative
+    # numbers interpreted as an offset
+    return FontExtent(face.glyph.metrics, Float32(face.units_per_EM))
+end
+
+descender(font) = font.descender / font.units_per_EM
+ascender(font) = font.ascender / font.units_per_EM

test/runtests.jl

@@ -1,22 +1,20 @@
 using FreeTypeAbstraction, Colors, ColorVectorSpace, GeometryBasics
 using Test
-using FreeTypeAbstraction: boundingbox, Vec, glyph_rects, get_extent, FTFont, kerning
+using FreeTypeAbstraction: boundingbox, Vec, glyph_rects, get_extent, FTFont, kerning, glyph_ink_size
 using FreeType
 
 face = FreeTypeAbstraction.findfont("hack"; additional_fonts=@__DIR__)
 
-bb = boundingbox("asdasd", face, 1.0)
-@test bb == Rect(4.0, -1.0, 224.0, 50.0)
+bb = boundingbox("asdasd", face, 64)
+@test round.(Int, minimum(bb)) == Vec(4, -1)
+@test round.(Int, widths(bb)) == Vec2(221, 50)
 
 FA = FreeTypeAbstraction
 
 FA.set_pixelsize(face, 64) # should be the default
-img, extent = renderface(face, 'C')
+img, extent = renderface(face, 'C', 64)
 @test size(img) == (30, 49)
 @test typeof(img) == Array{UInt8,2}
-@test extent == FontExtent{Float32}(Float32[-15.0, 6.0], Float32[4.0, 48.0], Float32[39.0, 62.0], Float32[30.0, 49.0])
-img, extent = renderface(face, 'C', 200)
-@test round.(Int, widths(FA.boundingbox(extent))) == Vec(size(img))
 
 a = renderstring!(zeros(UInt8, 20, 100), "helgo", face, 10, 10, 10)