fixes + add more needed functionality

Author: SimonDanisch

src/layout.jl

@@ -5,10 +5,15 @@ 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
+    return Rect2D(mini, Vec2f0(extent.pixel_size)), extent
+end
+
+function glyph_ink_size(char::Char, font::FTFont, pixel_size)
+    bb, extent = metrics_bb(char, font, pixel_size)
+    return widths(bb)
 end
 
 """
@@ -41,7 +46,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 +57,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,6 +1,5 @@
 
-function renderface(face::FTFont, c::Char,
-                    pixelsize::Integer=get_pixelsize(face))
+function renderface(face::FTFont, c::Char, pixelsize::Integer)
     set_pixelsize(face, pixelsize)
     loadchar(face, c)
     glyph = face.glyph

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
 
@@ -182,13 +186,13 @@ function kerning(c1::Char, c2::Char, face::FTFont)
 end
 
 function loadchar(face::FTFont, c::Char)
-    err = FT_Load_Char(face, c, FT_LOAD_RENDER)
+    err = FT_Load_Char(face, c, FT_LOAD_RENDER | FT_LOAD_NO_HINTING)
     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 +201,11 @@ 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)
+    err = FT_Load_Char(face, char, FT_LOAD_NO_SCALE)
     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))
+    # This gives us the font metrics in normalized units (-1, 1)
+    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

@@ -5,6 +5,37 @@ using FreeType
 
 face = FreeTypeAbstraction.findfont("hack"; additional_fonts=@__DIR__)
 
+FreeTypeAbstraction.get_pixelsize(face)
+FreeTypeAbstraction.set_pixelsize(face, 122)
+FreeTypeAbstraction.set_pixelsize(face, 64)
+err = FT_Load_Char(face, 'm', FT_LOAD_DEFAULT)
+metrics = face.glyph.metrics
+# 64 since metrics are in 1/64 units (units to 26.6 fractional pixels)
+FontExtent(metrics, 64.0)
+
+
+
+
+
+
+
+
+err = FT_Load_Char(face, 'm', FT_LOAD_NO_AUTOHINT)
+metrics = face.glyph.metrics
+# 64 since metrics are in 1/64 units (units to 26.6 fractional pixels)
+FontExtent(metrics, 1.0)
+
+
+
+
+
+
+
+
+
+
+
+
 bb = boundingbox("asdasd", face, 1.0)
 @test bb == Rect(4.0, -1.0, 224.0, 50.0)