Merge pull request #71 from t-bltg/trunc

Various fixes

Author: SimonDanisch

src/findfonts.jl

@@ -1,6 +1,6 @@
 if Sys.isapple()
     function _font_paths()
-        [
+        return [
             "/Library/Fonts", # Additional fonts that can be used by all users. This is generally where fonts go if they are to be used by other applications.
             joinpath(homedir(), "Library/Fonts"), # Fonts specific to each user.
             "/Network/Library/Fonts", # Fonts shared for users on a network
@@ -9,10 +9,12 @@ if Sys.isapple()
         ]
     end
 elseif Sys.iswindows()
-    _font_paths() = [
-        joinpath(get(ENV, "SYSTEMROOT", "C:\\Windows"), "Fonts"),
-        joinpath(homedir(), "AppData", "Local", "Microsoft", "Windows", "Fonts"),
-    ]
+    function _font_paths()
+        return [
+            joinpath(get(ENV, "SYSTEMROOT", "C:\\Windows"), "Fonts"),
+            joinpath(homedir(), "AppData", "Local", "Microsoft", "Windows", "Fonts"),
+        ]
+    end
 else
     function add_recursive(result, path)
         for p in readdir(path)
@@ -25,27 +27,26 @@ else
     end
     function _font_paths()
         result = String[]
-	for p in ("/usr/share/fonts", joinpath(homedir(), ".fonts"), joinpath(homedir(), ".local/share/fonts"), "/usr/local/share/fonts",)
+        for p in (
+            "/usr/share/fonts",
+            joinpath(homedir(), ".fonts"),
+            joinpath(homedir(), ".local/share/fonts"),
+            "/usr/local/share/fonts"
+        )
             if isdir(p)
                 push!(result, p)
                 add_recursive(result, p)
             end
         end
-        result
+        return result
     end
 end
 
-function family_name(x::FTFont)
-    lowercase(x.family_name)
-end
-
-function style_name(x::FTFont)
-    lowercase(x.style_name)
-end
+family_name(x::FTFont) = lowercase(x.family_name)
+style_name(x::FTFont) = lowercase(x.style_name)
 
 const REGULAR_STYLES = ("regular", "normal", "medium", "standard", "roman", "book")
 
-
 """
 Match a font using the user-specified search string. Each part of the search string
 is searched in the family name first which has to match once to include the font
@@ -79,7 +80,6 @@ Then this is how this function would match different search strings:
 - "arial"               => no match
 """
 function match_font(face::FTFont, searchparts)::Tuple{Int, Int, Bool, Int}
-
     fname = family_name(face)
     sname = style_name(face)
     is_regular_style = any(occursin(s, sname) for s in REGULAR_STYLES)
@@ -108,7 +108,7 @@ function match_font(face::FTFont, searchparts)::Tuple{Int, Int, Bool, Int}
 
     style_score = sum(length(part) for part in remaining_parts if occursin(part, sname))
 
-    (family_score, style_score, is_regular_style, fontlength_penalty)
+    return (family_score, style_score, is_regular_style, fontlength_penalty)
 end
 
 function try_load(fpath)
@@ -121,7 +121,6 @@ end
 
 fontname(ft::FTFont) = "$(family_name(ft)) $(style_name(ft))"
 
-
 function findfont(
         searchstring::String;
         italic::Bool=false, # this is unused in the new implementation
@@ -170,5 +169,5 @@ function findfont(
         end
     end
 
-    best_font
+    return best_font
 end

src/layout.jl

@@ -7,8 +7,7 @@ iter_or_array(x::StaticArray) = repeated(x)
 
 function metrics_bb(char::Char, font::FTFont, pixel_size)
     extent = get_extent(font, char) .* Vec2f(pixel_size)
-    mini = bearing(extent)
-    return Rect2(mini, Vec2f(extent.scale)), extent
+    return boundingbox(extent), extent
 end
 
 function boundingbox(char::Char, font::FTFont, pixel_size)

src/rendering.jl

@@ -4,14 +4,23 @@ function loadchar(face::FTFont, c::Char)
     check_error(err, "Could not load char to render.")
 end
 
-function renderface(face::FTFont, c::Char, pixelsize::Integer)
+function loadglyph(face::FTFont, c::Char, pixelsize::Integer)
     set_pixelsize(face, pixelsize)
     loadchar(face, c)
     glyph = unsafe_load(face.glyph)
     @assert glyph.format == FreeType.FT_GLYPH_FORMAT_BITMAP
+    return glyph
+end
+
+function renderface(face::FTFont, c::Char, pixelsize::Integer)
+    glyph = loadglyph(face, c, pixelsize)
     return glyphbitmap(glyph.bitmap), FontExtent(glyph.metrics)
 end
 
+function extents(face::FTFont, c::Char, pixelsize::Integer)
+    return FontExtent(loadglyph(face, c, pixelsize).metrics)
+end
+
 function glyphbitmap(bitmap::FreeType.FT_Bitmap)
     @assert bitmap.pixel_mode == FreeType.FT_PIXEL_MODE_GRAY
     bmp = Matrix{UInt8}(undef, bitmap.width, bitmap.rows)
@@ -27,114 +36,172 @@ function glyphbitmap(bitmap::FreeType.FT_Bitmap)
     return bmp
 end
 
-one_or_typemax(::Type{T}) where {T<:Union{Real,Colorant}} = T<:Integer ? typemax(T) : oneunit(T)
+function one_or_typemax(::Type{T}) where {T<:Union{Real,Colorant}}
+    return T<:Integer ? typemax(T) : oneunit(T)
+end
 
 """
     renderstring!(img::AbstractMatrix, str::String, face, pixelsize, y0, x0;
     fcolor=one_or_typemax(T), bcolor=zero(T), halign=:hleft, valign=:vbaseline) -> Matrix
 
 Render `str` into `img` using the font `face` of size `pixelsize` at coordinates `y0,x0`.
+Uses the conventions of freetype.org/freetype2/docs/glyphs/glyphs-3.html
 
 # Arguments
 * `y0,x0`: origin is in upper left with positive `y` going down
 * `fcolor`: foreground color; AbstractVector{T}, typemax(T) for T<:Integer, otherwise one(T)
 * `gcolor`: background color; AbstractVector{T}, typemax(T) for T<:Integer, otherwise one(T)
 * `bcolor`: canvas background color; set to `nothing` for transparent
 * `halign`: :hleft, :hcenter, or :hright
-* `valign`: :vtop, :vcenter, :vbaseline, or :vbottom
+* `valign`: :vtop, :vcenter, :vbaseline, or :vbttom
+* `bbox_glyph`: glyph bounding box color (debugging)
+* `bbox`: bounding box color (debugging)
+* `gstr`: background string or array of chars (for background sizing)
+* `incx`: extra x spacing
 """
 function renderstring!(
-        img::AbstractMatrix{T}, str::Union{AbstractVector{Char},String}, face::FTFont, pixelsize::Union{Int, Tuple{Int, Int}}, y0, x0;
+        img::AbstractMatrix{T}, fstr::Union{AbstractVector{Char},String},
+        face::FTFont, pixelsize::Union{Int, Tuple{Int, Int}}, y0, x0;
         fcolor::Union{AbstractVector{T},T} = one_or_typemax(T),
         gcolor::Union{AbstractVector{T},T,Nothing} = nothing,
         bcolor::Union{T,Nothing} = zero(T),
-        halign::Symbol = :hleft, valign::Symbol = :vbaseline
+        halign::Symbol = :hleft,
+        valign::Symbol = :vbaseline,
+        bbox_glyph::Union{T,Nothing} = nothing,
+        bbox::Union{T,Nothing} = nothing,
+        gstr::Union{AbstractVector{Char},String,Nothing} = nothing,
+        off_bg::Int = 0,
+        incx::Int = 0,
     ) where T<:Union{Real,Colorant}
 
     if pixelsize isa Tuple
         @warn "using tuple for pixelsize is deprecated, please use one integer"
         pixelsize = pixelsize[1]
     end
-
-    str = str isa AbstractVector ? String(str) : str
-
     set_pixelsize(face, pixelsize)
 
-    bitmaps = Vector{Matrix{UInt8}}(undef, lastindex(str))
-    metrics = Vector{FontExtent{Int}}(undef, lastindex(str))
-    # ymin and ymax w.r.t the baseline
-    ymin = ymax = sumadvancex = 0
+    fstr = fstr isa AbstractVector ? fstr : collect(fstr)
+    if gstr !== nothing
+        gstr = gstr isa AbstractVector ? gstr : collect(gstr)
+    end
 
-    for (istr, char) = enumerate(str)
-        bitmap, metric_float = renderface(face, char, pixelsize)
-        metric = round.(Int, metric_float)
-        bitmaps[istr] = bitmap
-        metrics[istr] = metric
+    len = length(fstr)
+    bitmaps = Vector{Matrix{UInt8}}(undef, len)
+    metrics = Vector{FontExtent{Int}}(undef, len)
 
-        # scale of glyph (size of bitmap)
-        w, h = metric.scale
-        # offset between glyph origin and bitmap top left corner
-        bx, by = metric.horizontal_bearing
-        ymin = min(ymin, by - h)
-        ymax = max(ymax, by)
-        sumadvancex += metric.advance[1]
+    y_min = y_max = sum_advance_x = 0  # y_min and y_max are w.r.t the baseline
+    for (i, char) in enumerate(fstr)
+        bitmap, metricf = renderface(face, char, pixelsize)
+        metric = round.(Int, metricf)
+        bitmaps[i] = bitmap
+        metrics[i] = metric
+
+        y_min = min(y_min, bottominkbound(metric))
+        y_max = max(y_max, topinkbound(metric))
+        sum_advance_x += hadvance(metric)
     end
 
-    px = x0 - (halign == :hright ? sumadvancex : halign == :hcenter ? sumadvancex >> 1 : 0)
+    bitmap_max = bitmaps |> first |> eltype |> typemax
+    imgh, imgw = size(img)
+
+    # initial pen position
+    px = x0 - (halign == :hright ? sum_advance_x : halign == :hcenter ? sum_advance_x >> 1 : 0)
     py = y0 + (
-        valign == :vtop ? ymax : valign == :vbottom ? ymin :
-        valign == :vcenter ? (ymax - ymin) >> 1 + ymin : 0
+        valign == :vtop ? y_max : valign == :vbottom ? y_min :
+        valign == :vcenter ? (y_max - y_min) >> 1 + y_min : 0
     )
 
-    bitmapmax = typemax(eltype(bitmaps[1]))
-
-    imgh, imgw = size(img)
     if bcolor !== nothing
         img[
-            clamp(py-ymax+1, 1, imgh) : clamp(py-ymin-1, 1, imgh),
-            clamp(px-1, 1, imgw) : clamp(px+sumadvancex-1, 1, imgw)
+            clamp(py - y_max, 1, imgh) : clamp(py - y_min, 1, imgh),
+            clamp(px, 1, imgw) : clamp(px + sum_advance_x, 1, imgw)
         ] .= bcolor
     end
 
     local prev_char::Char
-    for (istr, char) = enumerate(str)
-        w, h = metrics[istr].scale
-        bx, by = metrics[istr].horizontal_bearing
+    for (i, char) in enumerate(fstr)
+        bitmap = bitmaps[i]
+        metric = metrics[i]
+        bx, by = metric.horizontal_bearing
+        ax, ay = metric.advance
+        sx, sy = metric.scale
 
-        if istr == 1
+        if i == 1
             prev_char = char
         else
-            kx, ky = map(x-> round(Int, x), kerning(prev_char, char, face))
+            kx, _ = map(x-> round(Int, x), kerning(prev_char, char, face))
             px += kx
         end
 
-        fcol = fcolor isa AbstractVector ? fcolor[istr] : fcolor
-        gcol = gcolor isa AbstractVector ? gcolor[istr] : gcolor
+        # glyph origin
+        oy = py - by
+        ox = px + bx
+
+        fcol = fcolor isa AbstractVector ? fcolor[i] : fcolor
+        gcol = gcolor isa AbstractVector ? gcolor[i] : gcolor
 
         # trim parts of glyph images that are outside the destination
-        cliprowlo, cliprowhi = max(0, -(py-by)), max(0, py - by + h - imgh)
-        clipcollo, clipcolhi = max(0, -bx-px),   max(0, px + bx + w - imgw)
+        row_lo, row_hi = 1 + max(0, -oy), sy - max(0, oy + sy - imgh)
+        col_lo, col_hi = 1 + max(0, -ox), sx - max(0, ox + sx - imgw)
 
         if gcol === nothing
-            for row = 1+cliprowlo : h-cliprowhi, col = 1+clipcollo : w-clipcolhi
-                bitmaps[istr][col,row] == 0 && continue
-                c1 = bitmaps[istr][col,row] / bitmapmax * fcol
-                img[row+py-by, col+px+bx] = T <: Integer ? round(T, c1) : T(c1)
+            for r in row_lo:row_hi, c in col_lo:col_hi
+                (bm = bitmap[c, r]) == 0 && continue
+                color = bm / bitmap_max * fcol
+                img[oy + r, ox + c] = T <: Integer ? round(T, color) : T(color)
             end
         else
-            img[
-                clamp(py-ymax+1, 1, imgh) : clamp(py-ymin-1, 1, imgh),
-                clamp(px-1, 1, imgw) : clamp(px+sumadvancex-1, 1, imgw)
-            ] .= gcol
-            for row = 1+cliprowlo : h-cliprowhi, col = 1+clipcollo : w-clipcolhi
-                bitmaps[istr][col, row] == 0 && continue
-                w1 = bitmaps[istr][col, row] / bitmapmax
-                c1 = w1 * fcol
-                c0 = (1.0 - w1) * gcol
-                img[row + py - by, col + px + bx] = T <: Integer ? round(T, c1 + c0) : T(c1 + c0)
+            if gstr !== nothing
+                gmetric = round.(Int, extents(face, gstr[i], pixelsize))
+                y_min = bottominkbound(gmetric)
+                y_max = topinkbound(gmetric)
+            end
+
+            # fill background
+            by1, by2 = py - y_max, py - y_min
+            bx1, bx2 = px, px + ax
+            r1, r2 = clamp(by1, 1, imgh), clamp(by2, 1, imgh)
+            c1, c2 = clamp(bx1, 1, imgw), clamp(bx2, 1, imgw)
+            for r in r1 + off_bg:r2 - off_bg, c in c1 + off_bg:c2 - off_bg
+                img[r, c] = gcol
+            end
+
+            # render character by drawing the corresponding glyph
+            for r in row_lo:row_hi, c in col_lo:col_hi
+                (bm = bitmap[c, r]) == 0 && continue
+                w1 = bm / bitmap_max
+                color0 = w1 * fcol
+                color1 = (1.0 - w1) * gcol
+                img[oy + r, ox + c] = T <: Integer ? round(T, color0 + color1) : T(color0 + color1)
+            end
+
+            # draw background bounding box
+            if bbox !== nothing && r2 > r1 && c2 > c1
+                img[r1, c1:c2] .= bbox
+                img[r2, c1:c2] .= bbox
+                img[r1:r2, c1] .= bbox
+                img[r1:r2, c2] .= bbox
             end
         end
-        px += metrics[istr].advance[1]
+
+        # draw glyph bounding box
+        if bbox_glyph !== nothing
+            # rect = boundingbox(metric)
+            # (mc, mr), (Mc, Mr) = extrema(rect)
+            # r1, r2 = clamp(py + mr, 1, imgh), clamp(py + Mr, 1, imgh)
+            # c1, c2 = clamp(px + mc, 1, imgw), clamp(px + Mc, 1, imgw)
+            # ^^^ should be equivalent to vvv: see JuliaGraphics/FreeTypeAbstraction.jl/pull/71
+            r1, r2 = clamp(oy + row_lo, 1, imgh), clamp(oy + row_hi, 1, imgh)
+            c1, c2 = clamp(ox + col_lo, 1, imgw), clamp(ox + col_hi, 1, imgw)
+            if r2 > r1 && c2 > c1
+                img[r1, c1:c2] .= bbox_glyph
+                img[r2, c1:c2] .= bbox_glyph
+                img[r1:r2, c1] .= bbox_glyph
+                img[r1:r2, c2] .= bbox_glyph
+            end
+        end
+
+        px += ax + incx
     end
     return img
 end