Merge pull request #92 from dummy-index/feature/adaptive_bearing

add adaptive side-bearing calculation

Author: pelson

xkcd-script/font/xkcd-script.otf

@@ -235,10 +235,67 @@ def pad_glyph(c):
     # Put horizontal padding around the glyph. I choose a number here that looks reasonable,
     # there are far more sophisticated means of doing this (like looking at the original image,
     # and calculating how much space there should be).
-    space = 20
-    scaled_width = c.boundingBox()[2]
-    c.width = int(round(scaled_width + 2 * space))
-    t = psMat.translate(space, 0)
+    space = 0
+    rspace = 20
+    c.font['_pad_space'].width = space + rspace
+    bbox = c.boundingBox()
+    if c.glyphname in list('gjpqy'):
+        # Recalculate the bounding box by excluding the tail of the glyph
+        # Do not remove the glyph's tail if it is too close to the baseline
+        capxrange = c.foreground.xBoundsAtY(-40, 600)
+        if c.glyphname == 'j':
+            bbox = tuple([(capxrange[0] + bbox[0])/2, bbox[1], capxrange[1], bbox[3]])
+        else:
+            bbox = tuple([capxrange[0], bbox[1], capxrange[1], bbox[3]])
+    if c.glyphname == 'f':
+        # Recalculate the bounding box by excluding the arm of the glyph
+        # Restrict the arm so that it does not pierce through the stem of the next glyph
+        xxrange = c.foreground.xBoundsAtY(0, 420)
+        bbox = tuple([xxrange[0], bbox[1], max(xxrange[1], bbox[2] - (rspace + space + 0.12 * 600)), bbox[3]])
+    lflatness = c.foreground.yBoundsAtX(bbox[0] - 1, bbox[0] + 20)
+    rflatness = c.foreground.yBoundsAtX(bbox[2] - 20, bbox[2] + 1)
+    roughness = []
+    for i in range(4):
+        roughness.append(c.foreground.xBoundsAtY(100 + 100 * i, 150 + 100 * i) or tuple([bbox[2], bbox[0]]))
+    lroughness = np.sqrt(np.median([(roughness[i][0] - bbox[0])**2 for i in range(4)]))
+    rroughness = np.sqrt(np.median([(bbox[2] - roughness[i][1])**2 for i in range(4)]))
+    add_left = 0
+    if lflatness[1] - lflatness[0] < 0.25 * 600:
+        add_left = 0
+    elif lroughness >= 35:
+        add_left = 0
+    elif lroughness >= 20:
+        add_left = 5
+    elif lroughness >= 10:
+        add_left = 10
+    elif lroughness >= 5:
+        add_left = 15
+    else:
+        add_left = 20
+    add_right = 0
+    if rflatness[1] - rflatness[0] < 0.25 * 600:
+        add_right = 0
+    elif rroughness >= 35:
+        add_right = 0
+    elif rroughness >= 20:
+        add_right = 5
+    elif rroughness >= 10:
+        add_right = 10
+    elif rroughness >= 5:
+        add_right = 15
+    else:
+        add_right = 20
+    if c.glyphname == 'i':
+        add_left += 10
+        add_right += 10
+    may_too_wide1 = list('aebdpr')
+    if c.glyphname in may_too_wide1:
+        if bbox[2] - bbox[0] > 370:
+            add_left -= 5
+            add_right -= 10
+    scaled_width = bbox[2]
+    c.width = round(scaled_width + rspace + space / 2 + add_right)
+    t = psMat.translate(round((-bbox[0]) + space / 2 + add_left), 0)
     c.transform(t)
 
 
@@ -264,6 +321,10 @@ def charname(char):
 font.hhea_descent = -270; font.hhea_descent_add = False
 font.hhea_linegap = 77
 
+# Information to be conveyed to the next stage.
+# I wanted to use font.persistent, but it causes an error. Instead, I use a dummy glyph.
+font.createChar(-1, '_pad_space')
+
 # Per-character size scaling applied after changeWeight, to fine-tune individual glyphs
 # that end up slightly too large despite correct stroke weight.
 _per_char_operation = {

xkcd-script/font/xkcd-script.sfd

@@ -6,7 +6,6 @@
 applies properties, saves.
 """
 import fontforge
-import psMat
 import unicodedata
 
 font_fname = '../generated/xkcd-script-pt7.sfd'
@@ -60,40 +59,6 @@ def _expand_with_variants(font, chars):
     return result
 
 
-# ---------------------------------------------------------------------------
-# Advance-width overrides
-# ---------------------------------------------------------------------------
-
-# f's lsb (17) leaves too much space before the stem; shift left 12 units.
-# Width is reduced by 110 total to bring natural spacing after the crossbar
-# into line (~90 units for fo), leaving arm clearance handled by kern rules.
-_f = font['f']
-_f.transform(psMat.translate(-12, 0))
-_f.width -= 110
-font['r'].transform(psMat.translate(10, 0))
-
-
-# g's bowl (above baseline) starts ~19 units further right than other rounded
-# letters.  Shift the whole glyph left by 90 to bring bowl_lsb to ~20, matching
-# e/n/o.  Width is reduced by 30 to leave a moderate right sidebearing (~25).
-_g = font['g']
-_g.transform(psMat.translate(-145, 0))
-_g.width -= 30
-
-
-# j
-_j = font['j']
-_j.transform(psMat.translate(-115, 0))
-_j.width -= 25
-
-
-# r's arm extends to ~x=402 but the default advance (440) leaves too much
-# whitespace; reduce to give a slight negative right sidebearing.
-_r = font['r']
-_r.transform(psMat.translate(-30, 0))
-_r.width = 385
-
-
 # ---------------------------------------------------------------------------
 # Kerning
 # ---------------------------------------------------------------------------
@@ -133,10 +98,15 @@ def expand(chars, left_side):
             return expanded
         font.autoKern('kern', sep, expand(left, left_side=True), expand(right, left_side=False), **kwargs)
 
+    a = font['_pad_space'].width
+    a = max(a - 20, 0)
+
+    # autoKern looks at the outline, so even if you change the padding, it absorbs all of it.
+    # Use `+a` when you want to link the spacing after kerning to the padding.
     kern(150, ['/', '\\'], ['/', '\\'])
-    kern(60, ['s'], set(lower) - {'j', 'f'}, minKern=50)
+    kern(60+a, ['s'], set(lower) - {'j', 'f'}, minKern=50)
     # x has diagonal strokes that leave visual space on its left side.
-    kern(90, set(lower) - {'f'}, ['x'], minKern=40)
+    kern(90+a, set(lower) - {'f'}, ['x'], minKern=40)
     # F/E are separated from T/J so they can use a tighter target gap.
     kern(130, ['F'], set(all_chars) - {'f', 'j'})
     kern(140, ['E'], ['V', 'W', 'Y'])
@@ -149,6 +119,7 @@ def expand(chars, left_side):
 
 
 autokern(font)
+font.removeGlyph(font['_pad_space'])
 
 
 # ---------------------------------------------------------------------------