前陣子隨手修改了一下Google和Adobe分享的字型檔案，因為Max完全不懂字體相關的知識，把字型檔案解開後，打包不回去。Google查了半天，也看不懂，亂給設定值也失敗，山不轉路轉，那就用其他替代解法吧。

首先，要取得異體字的對應表，需要到別人的網站上去偷資料庫內容，偷完的結果分享如下：

查「部首」、「筆畫」、「異體字」、「同義字」和「文字組件」的字典
https://max-everyday.com/2020/04/chinese-dictionary-radical/

有了對應表後，要把字型檔裡的字都翻一遍出來檢查對應，第一個版本寫的程式跑了15分鐘，居然一個字都沒有比對完成。@_@；只好重新思考解法。

新的解法和Code Review 影片：
https://youtu.be/JX6FnCPtRyw

程式架構：

寫出來的python 副程式：

def compare_dictionary(source_ff, unicode_field, full_dict):
    target_unicode_set, target_dict = load_files_to_set_dict(source_ff, unicode_field)
    alternate_set = set()
    alternate_dict = {}
    for char_key in full_dict:
        char_dict = full_dict[char_key]
        for alternate in char_dict['alternate']:
            unicode_int = ord(alternate)
            alternate_set.add(unicode_int)
            alternate_dict[unicode_int] = ord(char_key)
    diff_set_common =  target_unicode_set & alternate_set
    copy_count = 0
    for item in diff_set_common:
        if not alternate_dict[item] in target_unicode_set:
            target_filename = "uni%s.glyph" % str(hex(alternate_dict[item]))[2:].upper()
            source_path = join(source_ff,target_dict[item])
            target_path = join(source_ff,target_filename)
            shutil.copy(source_path,target_path)
            overwrite_config_encoding(target_path, alternate_dict[item], unicode_field)
            copy_count += 1

後記：由於資料庫不是很完整，上面的方法後來沒有再使用了，改用直接修改 glyph 檔案，直接比對 unicode code 編碼，符合的話，就增加 “AltUni2: ” 欄位，使用的字典檔：
https://max-everyday.com/2020/04/chinese-dictionary-radical/

Max 要來挑戰的是判斷某一個交叉點，是二筆畫，還是同一筆畫。同一筆和不同筆，在之後文字效果的處理會不同，同一筆畫會變形，與第二筆畫的交叉不應該變形。

這次寫完的程式，過二天再回來看，就像完全沒看過的程式一樣陌生，完全不知道當初在寫什麼！數學的世界，常常讓人無法理解，太難了。Q_Q；

程式碼的Code Review 參考下面的 YouTube 影片：
https://youtu.be/TXNyNkWpde0

舉例：判斷「丸」的「十」交叉不是同一筆畫，右上角長出來的尾巴是同一筆畫。

在判斷筆畫時還是第二筆。水平線和垂直線的判斷相對容易很多，比較難的是「乂」叉叉系列的判斷，例如：「女」，的轉角是同一筆畫。

產出的副程式：

def join_line_check(self,x0,y0,x1,y1,x2,y2):
    inside_stroke_flag = False
    previous_extend_x,previous_extend_y = spline_util.two_point_extend(x0,y0,x1,y1, self.config.STROKE_WIDTH_AVERAGE)
    previous_extend_x_offset = x1-previous_extend_x
    previous_extend_y_offset = y1-previous_extend_y
    previous_left_x,previous_left_y = spline_util.two_point_extend(x0,y0,x1,y1, int(2.0 *self.config.STROKE_WIDTH_AVERAGE))
    tmp_next_extend_x,tmp_next_extend_y=spline_util.two_point_extend(x2,y2,x1,y1, self.config.STROKE_WIDTH_AVERAGE)
    next_extend_x = tmp_next_extend_x - previous_extend_x_offset
    next_extend_y = tmp_next_extend_y - previous_extend_y_offset
    next_left_x = next_extend_x - previous_extend_x_offset
    next_left_y = tmp_next_extend_y - previous_extend_y_offset -previous_extend_y_offset
    bmp_x1, bmp_y1, bmp_x2, bmp_y2, bmp_x3, bmp_y3, bmp_x4, bmp_y4 = previous_extend_x, previous_extend_y, previous_left_x, previous_left_y, next_left_x, next_left_y, next_extend_x, next_extend_y
    inside_stroke_flag = self.is_inside_stroke(bmp_x1, bmp_y1, bmp_x2, bmp_y2, bmp_x3, bmp_y3, bmp_x4, bmp_y4)
    return inside_stroke_flag

前一篇文章：
二點之間內縮後坐標
https://max-everyday.com/2020/04/two-point-extend/

上面的方法，似乎太容易誤判，改良為下面作法：

def join_line_check(self,x0,y0,x1,y1,x2,y2):
    inside_stroke_flag = False
    stroke_width = self.get_stroke_width(x0,y0,x1,y1)
    previous_extend_x,previous_extend_y = spline_util.two_point_extend(x0,y0,x1,y1, int(stroke_width * 1.2))
    next_extend_x,next_extend_y=spline_util.two_point_extend(x2,y2,x1,y1, int(stroke_width/2))
    next_extend_x_offset = x1-next_extend_x
    next_extend_y_offset = y1-next_extend_y
    test_x = previous_extend_x - next_extend_x_offset
    test_y = previous_extend_y - next_extend_y_offset
    bmp_x = self.ff_x_to_bmp_x(test_x)
    bmp_y = self.ff_y_to_bmp_y(test_y)
    data=self.bmp_image.getpixel((bmp_x, bmp_y))
    if data <=128:
        inside_stroke_flag = True
    return inside_stroke_flag

上面共用筆寬的作做，還是踩到雷了，在下面的情況會誤判，應該不做事情，實際結果卻是加了圓角：

解法很簡單，先取得上方的筆寬（實際值是41單位），再取得左邊筆寬（實際值是74單位，跨過左邊紫色區塊後，檢查左上角有無黑線。

輪出的除錯訊息如下：

test coordinate: 731 456 - 535 456 - 535 408
stroke_width_lower: 74
stroke_width_upper: 41
test_x,y: 461 480
test_x,y: 460 480
test_x,y: 459 480
test_x,y: 458 480
test_x,y: 457 480
test_x,y: 456 480
test_x,y: 455 480
test_x,y: 454 480
test_x,y: 453 480
test_x,y: 452 480
test_x,y: 451 480
test_x,y: 450 480
test_x,y: 449 480
test_x,y: 448 480

說明：要檢查 [731,456] , [535,456] , [535,408] 這個角，是交叉線還是角落。依序取得線條寬度後，在左上角做測試。測試結果：是交叉線。

為什麼要寫下這篇文章？因為不寫下來，我隔2天就會忘了，寫過的程式碼都像全新沒看過的。

影片說明：
https://youtu.be/R0sPFHd2yis

視覺化舉例：

使用到的 Python 程式碼：

# distance between two points
from math import hypot

def two_point_extend(x1,y1,x2,y2,distance_offset):
    distance = get_distance(x1,y1,x2,y2)
    distance_percent = (distance_offset / distance)

    x_offset = int((x2-x1) * distance_percent)
    y_offset = int((y2-y1) * distance_percent)
    
    # 斜線上的「內縮」的新坐標。
    new_x=x2+x_offset
    new_y=y2+y_offset

    return new_x,new_y

有一天遇到好心人（游清松）在分享他製作的免費授權字型，真的是大好人一枚，花這麼多時間，在做照福大眾的事情，Max在用過字型後，發現還滿好看的，於是想幫他做一個網站來推廣：
https://jasonfonts.max-everyday.com/

網站隨手點一點就完成了，大約花了一個晚上的時間就完成了上列的網站，但創作字型的作者目前沒打算使用，暫時算是做白工。

在使用某些字型時發現字太細，長像太斯文，希望可以有粗一點的版本，Max示範如何幫字型加字重。參考實際操用影片：
https://youtu.be/rQ56_CHcBs0

Step 1：先取得要處理的字型

Step 2：使用FontForge 開啟並另存新檔

Step 3：執行調整字重的script

當然，也可以不要使用script（腳本）而是用滑鼠去點，用滑鼠很花時間，而且操作的步驟又很多，使用script（腳本）來操作重覆性高的事情，相對輕鬆一點。

如果是手動點，不是透過script 請先「全選」所有字型後，按右鍵選「Expand Stroke…」即可取得調整字重後的字型。

FontForge script 官方的教學網址：

• Scripting FontForge
• https://fontforge.org/docs/scripting/scripting-alpha.html

附上完整script：

!/usr/local/bin/fontforge
 Print("===================================")
 Open("JasonHandwriting2-Regular.sfdir")
 SetFontNames("JasonHandwriting2-Regular","JasonHandwriting2","JasonHandwriting2-Regular","Regular")
 Generate("JasonHandwriting2-Regular.ttf")
 Save("JasonHandwriting2-Light.sfdir")
 Save("JasonHandwriting2-SemiBold.sfdir")
 Save("JasonHandwriting2-Bold.sfdir")
 Save("JasonHandwriting2-Heavy.sfdir")
 Close()
 Print("===================================")
 Print("Open JasonHandwriting2 Light")
 Open("JasonHandwriting2-Light.sfdir")
 SetFontNames("JasonHandwriting2-Light","JasonHandwriting2","JasonHandwriting2-Light","Light")
 SelectAll()
 Print("ExpandStroke…")
 ExpandStroke(15,45,15,15,0,2)
 Save("JasonHandwriting2-Light.sfdir")
 Print("Generate ttf…")
 Generate("JasonHandwriting2-Light.ttf")
 Close()
 Print("Close JasonHandwriting2 Light")
 Print("===================================")
 Print("Open JasonHandwriting2 Medium")
 Open("JasonHandwriting2-Medium.sfdir")
 SetFontNames("JasonHandwriting2-Medium","JasonHandwriting2","JasonHandwriting2-Medium","Medium")
 SetMacStyle(-1)
 SetMacStyle(0x01)
 Print("ExpandStroke…")
 SelectAll()
 ExpandStroke(12,45,12,12,0,1)
 Save("JasonHandwriting2-Medium.sfdir")
 Print("Generate ttf…")
 Generate("JasonHandwriting2-Medium.ttf")
 Close()
 Print("Close JasonHandwriting2 Medium")
 Print("===================================")
 Print("Open JasonHandwriting2 SemiBold")
 Open("JasonHandwriting2-SemiBold.sfdir")
 SetFontNames("JasonHandwriting2-SemiBold","JasonHandwriting2","JasonHandwriting2-SemiBold","SemiBold")
 SetMacStyle(-1)
 SetMacStyle(0x01)
 Print("ExpandStroke…")
 SelectAll()
 ExpandStroke(24,45,24,24,0,1)
 Save("JasonHandwriting2-SemiBold.sfdir")
 Print("Generate ttf…")
 Generate("JasonHandwriting2-SemiBold.ttf")
 Close()
 Print("Close JasonHandwriting2 SemiBold")
 Print("===================================")
 Print("Open JasonHandwriting2 Bold")
 Open("JasonHandwriting2-Bold.sfdir")
 SetFontNames("JasonHandwriting2-Bold","JasonHandwriting2","JasonHandwriting2-Bold","Bold")
 SetMacStyle(-1)
 SetMacStyle(0x01)
 Print("ExpandStroke…")
 SelectAll()
 ExpandStroke(34,45,34,34,0,1)
 Save("JasonHandwriting2-Bold.sfdir")
 Print("Generate ttf…")
 Generate("JasonHandwriting2-Bold.ttf")
 Close()
 Print("Close JasonHandwriting2 Bold")

FontForge 的說明：

ExpandStroke(width)
ExpandStroke(width,line cap, line join)
ExpandStroke(width,line cap, line join,0,removeinternal /external flag)
ExpandStroke(width,calligraphic-angle,height-numerator,height-denom)
ExpandStroke(width,calligraphic-angle,height-numerator,height-denom, 0, remove internal/external flag)

In the first format a line cap of “butt” and line join of “round” are implied.
A value of 1 for remove internal/external will remove the internal contour, a value of 2 will remove the external contour.
The first three calls simulate the PostScript “stroke” command, the two final simulate a caligraphic pen.

• Width
  In the PostScript “stroke” command the width is the distance between the two generated curves. To be more precise, at ever point on the original curve, a point will be added to each of the new curves at width/2 units as measured on a vector normal to the direction of the original curve at that point.
  In a caligraphic pen, the width is the width of the pen used to draw the curve.
• Line-cap
  Can have one of three values:
  0=> butt,
  1=>round,
  2=>square
• Line-join
  Can have one of three values:
  0=>miter,
  1=>round,
  2=>bevel
• caligraphic-angle
  the (fixed) angle at which the pen is held.
• height-numerator/denominator
  These two values specify a ratio between the height and the width
  height = numerator * width / denominator
  (the scripting language only deals in integers, so when fractions are needed this kludge is used)
• remove internal/external contour flags
  1 => remove internal contour
  2=> remove external contour
  (you may not remove both contours)
  4 => run remove overlap on result (buggy)

實際測試，使用參數愈少的，問題愈多！建議使用最後一組，參數很多的，我幫大家把參數加粗。

使用最後一組的缺點是，Line Join 會使用 Bevel 很醜！不能接受 Bevel 請改用
ExpandStroke(width,line cap, line join,0,removeinternal /external flag)

範例：

ExpandStroke(15,1,0,0,1)

大多的情況都是很難二全其美，在使用 line join=0 可以讓文字在變細時，比較銳利，問題是也可能變成這樣子，「微」字就開叉了：

折衷的方案是使用 join join=1 ，讓筆畫間有渲染的感覺，會略醜，但問題較少 T_T。

最佳解法是使用 Join Limit as Legnth

更多的 stroke() 範例：
https://github.com/fontforge/fontforge/blob/1cd85a0e621352f81aca07bf9eb42467ee078f38/tests/test1003.py

附註：上面的範例，要使用新的版本才能使用。Max 用的 stroke 是：

glyph.stroke("circular",54,cap="round",join="miter",angle=math.radians(45),removeexternal=True,simplify=True,joinlimit=6)

針對使用上面會掛掉的字，改用下面這組就 OK 了：

glyph.stroke("circular",54,cap="round",join="miter",removeexternal=True,simplify=True)

主要差在，angle=math.radians(45)，有些字可以使用，有些字不行。

完整的程式碼，放在這一個網頁裡：
FontForge script debug
http://stackoverflow.max-everyday.com/2020/03/fontforge-script-debug/

建議使用「較新」版本的FontForge 執行檔來處理，可能錯誤會較少。如果是使用macOS 可以試看看在 .pe 檔案裡，最上面使用這一行：

#!/Applications/FontForge.app/Contents/Resources/opt/local/bin/fontforge

開發者的版本(Development builds)：
http://dl.bintray.com/fontforge/fontforge/

開發者的版本，不是萬能的，雖然解決掉一些字在 expand stroke 時會亂掉的問題，但相對不太隱定，有較高的機率程式會卡住，卡住有可能是(1)程式完全沒回應，也可能是(2)顯示有錯就關閉掉程式（閃退）。

「Correct Direction」 有可能會造成字型檔被改壞掉，使用「全選」來做這一個功能，可能會有不具名的字會改壞掉。

但是！有些字型裡，還沒有去使用「Correct Direction」功能，產生出來的方向就已經出問題了，又不可能一個一個字去檢查，到底修改字重後，會放大還是縮小。結論：用與不用，都很難選。

最後Max還是決定都使用，因為這樣比較方便用來做其他字體樣式的處理，透過使用Correct Direction，大多的「點」會被重新排序，方便做處理。

如果遇到在 Expand stroke 時，方向錯誤的區塊，就是預期應該變細，但是卻變粗了的情況，請使用一下 Correct Direction，如果還是無法解決，最佳解法是使用匯出(export)功能匯出該字為 svg 格式，再把 fontforge 裡的線條都清空，透過匯入(import)功能匯入該字的 svg 檔案，通常就不會有問題。

為什麼會講到開發者版本，參考看看：

莫大毛筆字體的調整 ver 1.30
https://max-everyday.com/2020/03/bakudaifont-ver-1-30/

除了透過 FontForge script 來改字重，也可以透過 python script , 可以操控的變數更多，功能也更多。
https://fontforge.org/docs/scripting/python/fontforge.html#module-functions

glyph.stroke(“circular”, width[, CAP, JOIN, FLAGS])glyph.stroke(“elliptical”, width, minor_width, ANGLE[, CAP, JOIN, FLAGS])glyph.stroke(“calligraphic”, width, height, angle[, FLAGS])glyph.stroke(“polygon”, contour[, FLAGS])(Legacy interface)glyph.stroke(“circular”, width[, CAP, JOIN, ANGLE, KEYWORD])glyph.stroke(“elliptical”, width, minor_width[, ANGLE, CAP, JOIN, KEYWORD])glyph.stroke(“calligraphic”, width, height[, ANGLE, CAP, JOIN, KEYWORD])glyph.stroke(“convex”, contour[, ANGLE, CAP, JOIN, KEYWORD])(Current interface)

Strokes the contours of the glyph according to the supplied parameters. See the stroke documentation for a more complete description of the facility and its parameters.

A "circular" nib just has a width (the diameter), while an "elliptical" nib has a width (major axis) and a minor_width (minor axis). A "calligraphic" or "rectangular" nib is similar in that it has a width and a height. Finally a "convex" nib is one supplied by the user as a fontforge.contour or fontforge.layer. It must be convex as defined in the main stroke facility documentation.

ANGLE is optional. It can be specified either positionally or with angle=float. It must be a floating point number in units of radians and defaults to zero. The nib is rotated by this angle before stroking the path.

CAP is optional. It can be specified either positionally or with cap=string. It must be one of the strings “nib” (the default), “butt”, “round”, and “bevel”.

JOIN is optional. It can be specified either positionally or with join=string. It must be one of the strings “nib” (the default), “bevel”, “miter”, and “miterclip”, “round”, and “arcs”.

KEYWORD Parameters:removeinternal (boolean, default=False)

When a contour is closed and clockwise, only the smaller “inside” contour is retained. When a contour is closed and counter-clockwise only the larger “outside” contour is retained.removeexternal (boolean, default=False)

When a contour is closed and clockwise, only the larger “outside” contour is retained. When a contour is closed and counter-clockwise only the smaller “inside” contour is retained.extrema (boolean, default=True)

When true, any missing extrema on the stroked paths are added.simplify (boolean, default=True)

When true, simplify is called on the path before it is returned. The error-bound is set to the accuracy value.removeoverlap (string, default="layer")

Specifies whether, and on what basis, remove-overlap should be run. “layer” corresponds to running remove-overlap on the layer as a whole. “contour” corresponds to running remove-overlap on individual contours. “none” corresponds to not running remove-overlap. Note that because the stroke facility relies on remove-overlap to eliminate cusps and other artifacts, “none” is an unusual choice and available primarily for debugging purposes.accuracy (float, default=0.25)

This is a target (but not a guarantee) for the allowed error, in em-units, of the output relative to the input path and nib geometries. Higher values allow more error will typically yield contours with fewer points.jlrelative (boolean, default=True)

See below.joinlimit (float, default=20)

Specifies the maximum length of a “miter”, “miterclip”, or “arcs” join. For “miter” joins that would be longer will fall back to “bevel”. With “miterclip” and “arcs” a longer join will be trimmed to the specified length. Note, however, that no join is trimmed past the “bevel line” and therefore lower values do not guarantee a given length.

When jlrelative is false the value is interpreted as a length in em-units. Otherwise the value is interpreted as a multiple of “stroke-widths”: the average of the spans of the nib at the incoming and outgoing join angles.ecrelative (boolean, default=True)

See below.extendcap (float, default=0)

When the contour being stroked is open and the cap style is “butt” or “round”, this parameter adds area between the end of that contour and the cap. The length of that area will never be less than the specified value but may be more, depending on the geometry of the nib and the join. (However, it will always be exact for circular nibs.)

When ecrelative is false the value is interpreted as a length in em-units. Otherwise the value is interpreted as a multiple of “stroke-widths”: the span of the stroked path at the angle at the cap.arcsclip (string, default="auto")

When using the “arcs” join style this parameter influences the algorithm used to clip joins that exceed the joinlimit. The value “svg2” specifies the standard SVG algorithm while the value “ratio” specifies an alternative algorithm that works better for longer and thinner nibs at shorter limits. The default value “auto” chooses the “ratio” algorithm for oblong elliptical and calligraphic nibs and jlrelative joinlimit < 4 and the “svg2” algorithm otherwise.

In the legacy interface, FLAGS is an optional tuple containing zero or more of the strings “removeinternal”, “removeexternal”, and “cleanup”. The last is interpreted as simplify=True, with a default of False when a FLAGS tuple is present.

補充說明：

• 上面的例子，可以在Windows/macOS/Linux平台上使用。
• 非開源的字型檔，自行編修沒有辦法被得知，但公開發佈也許會有法律上的問題。
• 不是所有的字型都可以使用。
• 透過程式調整筆劃可能會失敗，字可能會被改壞掉。
• 有些字型需要先使用Select All，再用 Correct Direction 調整方向，才不會造成調整的結論是：有些字變粗，有些字變細。
• 透過程式調整筆劃，只能調整粗細無法調整間距，所以有些字會因為調粗而變的太擠，或跟下一個字會相連在一起。
• 沒有任何一個字型編輯軟體能確保重新儲存的字型檔跟原始檔一模一樣。編修後的字型檔，很有可能會有kerning數值跑掉、直排字符異常或各種問題。
• 有空多看些英文的網站也滿好的，練習一下英文。

相關文章：

幫字型檔補缺字
https://max-everyday.com/2020/02/how-to-add-new-glyph-to-font/

免費商用字體整理
https://max-everyday.com/2020/02/free-commercial-fonts/

比較不同字形檔之間的缺字差異：
https://max-everyday.com/2020/02/font-glyph-set-compare/

FontForge 調整字型在 Windows 的安裝顯示名稱
https://stackoverflow.max-everyday.com/2020/02/fontforge-chinese/

Max影片教學：
https://youtu.be/LPAshVmfF6s

[MaxCodeReview] FontForge 補缺字：㧳
https://youtu.be/ugrR1Oh0LSw

[MaxCodeReview] FontForge 補缺字：霉
https://youtu.be/QjZNT8uBwMg

[MaxCodeReview] FontForge 補缺字：齜
https://youtu.be/X4X-m-vthw8

[MaxCodeReview] FontForge 補缺字：鼴
https://youtu.be/N4hCLq-Db9A

前置準備，下載和安裝：

• FontForge
  https://github.com/fontforge/fontforge/releases
• (選用，非必要) ImageMagick
  https://imagemagick.org/script/download.php
• (選用，非必要) potrace
  http://potrace.sourceforge.net/#downloading

FontForge 的執行在 Windows 和 Linux 因為檔案的安全性設計，執行上比較沒問題，在 macOS 雖然在「安全性」裡設定了「Full Disk Access」但還是會出現「Unauthorized Operation not permitted」的Error。

解法很簡單，在App 按右鍵選「Show Package Contents」，再進去 Contents/MacOS 目錄下點2下 FontForge 執行檔。

或是透過 Terminal 執行：

/Applications/FontForge.app/Contents/MacOS/FontForge

在 macOS 裡要安裝 imageMagicK 可以執行：

brew install imagemagick

在 macOS 裡要安裝 potrace ，把檔案解壓縮後，把將：

• potrace
• potrace.1
• mkbitmap
• mkbitmap.1

這4個檔案複製到目錄 /usr/local/bin 即可。

執行 FontForge 後 “File” – “Open” 開啟我們有缺字的字型檔。

使用熱鍵 Command + Shift + > 這3個鍵，出發到編輯畫面，也可以點選單 “View” – “Goto”

因為在FontForge 裡無法使用輸入法，所以請在其他文字編輯器裡copy 缺字，到 FontForge 裡 paste 貼上：

透過繪圖軟體製作我們的字型圖片，大小設定 1024 x 1024 px：

把畫好的影像檔，透過 magick 指令轉成 svg 格式：

magick image.png image.svg

附說：除了potrace 可以轉換為 svg 格式之外，還有很多程式也支援，但對曲線的判斷，potrace 效果好一點點。但 potrace 1.8 版會在直線中間多插入一個多的點，覺得占空間。

• 說明1：除了在 krita 裡匯出 png 格式，也可以使用 bmp 格式，最後都可以使用 magick 指令轉換成 SVG 格式。如果是匯出成 bmp 就不需要安裝 imagemagicK，只需要 potrace，執行範例：

potrace -s inputfile.bmp

上面的指令會把bmp 檔轉成 svg 檔案。

• 說明2：請連白色的背景一起放進匯出的PNG或BMP格式檔案裡，不然magick 匯出會失敗。

在 FontForge 裡 import svg ：

除了在繪圖軟體裡畫字，也可以透過 FontForge 的編輯界面來設計字型，但相對對畫筆的筆觸的控制就沒有那麼方便。

在 FontForget 裡編輯的好處是，有些新字路徑可以從其他已建立的字裡只複製部份，併裝組合成新字。

最後在 “File” – “Generate Fonts”，就可以取得修改後的字型：

如何在FontForge 裡組合出需要的缺字：

如果我們要組合出「洩 」(6D29)。

Step 1：
先分別使用Pointer(箭頭)的選取工具，選取出需要組合的字，例如：曳

Step 2：
找到組合字的另一邊，例如：「洪」的三點水，選取好後複制到其他缺字的格子裡，暫時借放，之後記得按Clear 把做一半的字清掉。

Step 3：
透過Transform (Command + \ ) 工具，可以進行X,Y軸的移動（Move）或縮放（Scale）。
（其他的做法是：使用其他的圖片編輯軟體來編修改，再存成SVG格式，最後在FontForge裡匯入）

Step 4：
把要被組合的字，複製並貼回我們的目的地，我們的字就完成了。

自己組合的字，有點不協調感，但總比缺字好看多了。要讓字的協調感較佳，可以試看看下面這篇文章的作法：

AI造字經驗分享
https://max-everyday.com/2021/07/zi2zi-ai-font/

也可以把組合好的字的ttf 檔，再分享回來給原作者，如果原作者有空也許會調整一下，再發佈到新的版本裡。

要匯出某一個字，可以先進入編輯該字，再點「Export」，匯出的格式，建議使用 ttf 或 otf格式會比較少問題。

透過繪圖軟體 Krtia 補缺字

以補 setofont （瀨戶字體）的缺字「鄉」(9109)為例：

Step 1：
在FontForge 先把缺字需要的原料匯出。

例如：匯出相似的2個字unicode 9115 和 unicode 90F7 ，匯出為SVG , bmp 或 png 格式可以。

Step 2：
在Krtia 分別開啟匯出的SVG檔，並把 9115 上方的點，複製起來，到90F7 貼上，並移動到想要的位置。

Step 3：
影像處理完成後，匯出為bmp格式。

附註：背景白色，請一起匯出。

Step 4：
在指令模式裡，轉換BMP格式為SVG格式：

使用 potrace 指令：

potrace -b svg -u 50 90F7.bmp -o 9109.svg

附註：如果你的繪圖工具高級一點，也許可以直接匯出為 SVG 格式，如果不想安裝 potrace 也可以使用很多免費的網上網站，有提線上轉檔的服務。

Step 5：
在FontForge裡匯入完成的 SVG：

如果沒有要調整字重，補缺字到這裡就可以結束了。如果希望生出來的新字，可以有其他的字重，需要再有一些微調。

FontForge 匯出的SVG 只有 1.3KB，但potrace 轉檔出來的預設是 3.9KB，長大了 3倍，potrace 預設 -u 是 10px ，在使用FontForge 的 Expand Stroke… 時，會造成像腫瘤般的奇怪小圈圈，如圖所示：

解法：是 potrace 指令，設定 quantize（量化）參數 -u 為 50px，這時候匯出的檔案會再略大一點，長大到 4.5KB，即可是解決在FontForge 裡 Expand Stroke 造成的筆畫的誤判。上面的範例已修改為 -u 50.

做到這裡，其實就沒有問題了，只是字型檔比較胖一點，如果你想讓新長出來的字型檔更完美一點，就看接下來優化的部份。

附註：如果你也是使用 potrace 1.8 版，上面的 -u 50 參數應該是不用加了，因為效果差不多。

匯入的SVG檔裡有很多的「點」，是因為點陣圖（BMP）轉換到到向量圖（SVG）時多出來的，請在 FontForge 裡使用左上角第一個選取工具（Pointer，熱鍵V）去點擊多餘的點，使用Merge(Command + M）進行點的合併。

有時候合併的結果會讓直線變成曲線，這時候請先使用還原（Command＋Z）功能，再使用 Merge to Line （Command + Shift + M）讓消失的點，變成一直線，或是放棄合併這一個點。

有時候會需要拉進（Zoom in）請使用熱鍵 Z ；拉遠（Zoom out）熱鍵 X 來調整。

重要：由於是囫圇吞棗，在完全不懂的情況下亂改字型檔，所以最後存檔（Save）前，請執行一次選單裡 Element 裡的 Correct Direction（Command + Shift + D）來修正方向錯誤。

為確定Expand Stroke 不會出錯，請用熱鍵 Command＋Shift＋E 先試看看無誤。

良裡有二個口，上面的口有經過 merge 功能來消除多餘的點，下面的口還未經處理，Merge 過簡化的字型，在檔案大小會略小一點，在Expand Stroke 時，可能比較不會誤判。

• 結論1：字體的開發，是非常的花時間！
• 結論2：幫字型檔補上差強人意的缺字還滿簡單的。
• 結論3：FontForge用一陣子後，發現還滿簡單的，補字不需要使到其他的影像編輯軟體。大多數的情況下，使用預設的選取工具（Pointer），就可以完成編輯和移動，如果情況需要縮放的話，使用 Transform(Command+\) 。

附註：

• 上面的例子，可以在Windows/macOS/Linux平台上使用。
• 非開源的字型檔，自行編修沒有辦法被得知，但公開發佈也許會有法律上的問題。
• 沒有任何一個字型編輯軟體能確保重新儲存的字型檔跟原始檔一模一樣。編修後的字型檔，很有可能會有kerning數值跑掉、直排字符異常或各種問題。

針對 Warning 的處理：

建議開啟ttf檔案後，請存成資料夾格式的FontForge’s SFD 格式，每個字都會變成獨立的檔案，可以透過其他文字編輯器去調整或置換掉glyph檔案。

最後，強力推薦一個網站，對於補字的工作很有幫助：

中國哲學書電子化計劃 – 字典
https://ctext.org/dictionary.pl?if=gb

這個網站很神奇，比如我想補「唬」，想知道字的組成元件有「虎」的字有那些，可以在這個網站看到有「虓」，有些字型還真的有這一個字可以拿來組合。

也可以使用「漢文博士」
https://www.cnblogs.com/hanbox/

査詢漢字的構字資料，快速尋找有沒有可以借用的字元。

相關文章：

Python 字型相關工具
https://stackoverflow.max-everyday.com/2020/02/python-font/

Font­Tools 安裝與使用簡明指南
https://stackoverflow.max-everyday.com/2020/02/fonttools/

幫字型加字重
https://max-everyday.com/2020/02/change-weight-for-font/

比較不同字形檔之間的缺字差異：
https://max-everyday.com/2020/02/font-glyph-set-compare/

FontForge 調整字型在 Windows 的安裝顯示名稱
https://stackoverflow.max-everyday.com/2020/02/fontforge-chinese/

免費中文字體 NotoSans 思源黑體
https://max-everyday.com/2018/03/noto-font/

免費商用字體整理
https://max-everyday.com/2020/02/free-commercial-fonts/

「粉圓字型 」
https://blog.justfont.com/2020/02/huninn-preview/

真的是很漂亮的圓體，也有被「找腳」的是這一個圓體：「源泉圓體」：
https://github.com/ButTaiwan/gensen-font
把印刷字的怪角給拔掉，好神奇，但也聽到很多「災情」，像是「關」這個字的中間下面的腳被誤判為多出來的角而被拔掉，也不是所有字重都有問題，反而是較重的字才有被拔的情況。

相關影片：

【央視走基層】中華美學無所不在 街訪國人同胞對「美」的忍受度｜眼球中央電視台
https://www.youtube.com/watch?v=1jQnbXKF_jY

可以看到 justfont 公司裡面的情況，及字型設計師如何去設計字型。

• 增加電腦字形一點點知識
• 如何轉換ttf 為 ufo / ufo 轉為 ttf
• 如何比對2個字型檔的缺字情況
• 顯示文字對應到的unicode字碼

MaxCodeReview：
https://youtu.be/HSxRJ7_MyJQ

Max發現有一個好心人（游清松），花了很多時間去寫手寫字，並把字變成字型檔開放免費下載，我在過年期間隨手幫他弄了一個網頁：
https://jasonfonts.max-everyday.com/

原作者說，暫時他還沒有打算架網頁，如果未來有需要再找來請教我。

我發現有人在社團裡提出增字的要求：

Max 使用的Python程式碼轉換 ttf 為 ufo：

 import extractor
 import defcon
 ufo = defcon.Font()
 extractor.extractUFO("JasonFonts1.ttf", ufo)
 ufo.save("JasonFonts1.ufo", removeUnreferencedImages=True)
 ufo = defcon.Font()
 extractor.extractUFO("JasonFonts2.ttf", ufo)
 ufo.save("JasonFonts2.ufo", removeUnreferencedImages=True)
 ufo = defcon.Font()

Max 使用的Python程式碼比對缺字，並輸出比較結果到文字檔：

 def output_to_file(myfile, myfont_set):
     for item in myfont_set:
         output_string = "%s(%s)" % (chr(item),str(hex(item))[2:])
         myfile.write(output_string)
 import defcon
 ufo_font1 = defcon.Font(path="JasonFonts1.ufo")
 set_font1 = set()
 for glyph in ufo_font1:
     set_font1.add(glyph.unicode)
 ufo_font2 = defcon.Font(path="JasonFonts2.ufo")
 set_font2 = set()
 for glyph in ufo_font2:
     set_font2.add(glyph.unicode)
 print("start to compare…")
 print("1 have 2 without")
 filename_output = "diff_1_sub_2.txt"
 outfile = open(filename_output, 'w')
 diff_1_sub_2 = set_font1 - set_font2
 sorted_set=sorted(diff_1_sub_2)
 output_to_file(outfile,sorted_set)
 outfile.close()

最後貼上比較的結果：

轉成 ufo 格式有點麻煩，Max 後來是直接使用 FontForge 的資料夾格式去進行缺字的比對，使用的程式碼如下：

from os import listdir, remove
from os.path import join, exists

import shutil

def output_to_file(myfile, myfont_set):
    for item in myfont_set:
        try:
            output_string = "%s(%s)" % (chr(item),str(hex(item))[2:])
        except Exception as exc:
            print("error item:%d" %(item))
            print("error item(hex):%s" %(str(hex(item))))
            raise
        myfile.write(output_string)

def load_unicode_from_file(filename_input):
    mycode = 0
    myfile = open(filename_input, 'r')
    left_part = 'Encoding: '
    left_part_length = len(left_part)
    for x_line in myfile:
        #print(x_line)
        if left_part == x_line[:left_part_length]:
            right_part = x_line[left_part_length:]
            if ' ' in right_part:
                mychar_array = right_part.split(' ')
                if len(mychar_array) > 0:
                    mycode = int(mychar_array[0])
                    #print("bingo")
                    break
        
    myfile.close()
    return mycode

def load_files_to_set_dict(ff_folder):
    my_set = set()
    my_dict = {}

    files = listdir(ff_folder)

    for f in files:
        if '.glyph' in f:
            unicode_info = load_unicode_from_file(join(ff_folder,f))
            if unicode_info > 0 and unicode_info < 0x110000:
                #print('code:', unicode_info)
                my_set.add(unicode_info)
                my_dict[unicode_info] = f
                #break
    return my_set, my_dict

source_ff = 'JasonHandwriting1-Regular.sfdir'
target_ff = 'JasonHandwriting2-Regular.sfdir'

source_unicode_set, source_dict = load_files_to_set_dict(source_ff)
target_unicode_set, target_dict = load_files_to_set_dict(target_ff)

print("length source:", len(source_unicode_set))
print("length target:", len(target_unicode_set))
diff_set_more =  target_unicode_set - source_unicode_set
diff_set_lost =  source_unicode_set - target_unicode_set
diff_set_common =  source_unicode_set & target_unicode_set
print("length more:", len(diff_set_more))
print("length lost:", len(diff_set_lost))
print("length common:", len(diff_set_common))

print("output compare result to file...")

filename_output = "diff_base_sub_%s.txt" % (target_ff)
outfile = open(filename_output, 'w')
sorted_set=sorted(diff_set_more)
output_to_file(outfile,sorted_set)
outfile.close()

如果是想合併 2個字型檔，也可以服用下面的 code:

 conflic_count = 0
 copy_count = 0
 for item in diff_set_more:
     target_path = join(target_ff,target_dict[item])
     source_path = join(source_ff,target_dict[item])
     if exists(source_path):
         print("conflic:", source_path)
         conflic_count += 1
     else:
         shutil.copy(target_path, source_path)
         copy_count += 1

如果是想刪除2個字型檔裡，共用的部分，只留下差異的文字，請服用下面的code：

 remove_count = 0
 for item in diff_set_common:
     target_path = join(target_ff,target_dict[item])
     remove(target_path)
     remove_count += 1

與其使用 ufo 格式，不用直接使用 FontForge 的檔案，方便很多，也更容易產生成新的字型檔案，在編輯字型上也很方便。

要刪字或增字，只要直接去存取FontForge資料夾下的 .glyph 的檔案就完成了。

上面的Python程式碼，可以在Windows/macOS/Linux平台上使用。

如果是想比對特定文章裡的字串，在字型檔裡有沒有缺字，可以使用下面文章裡的程式：

常見的「台灣方言字」整理
https://max-everyday.com/2020/03/taiwanese-common-word-700/

附註（非商用）：

• 「教育部 4808 個常用字」係指民國 71 年 9 月 1 日教育部公告的「常用國字標準字體表」所收錄之常用字。
• 教育部標準楷書字形檔(Version 4.00)，目前收錄國字數為 13,076 字。
  https://language.moe.gov.tw/001/Upload/Files/site_content/M0001/edukai-4.0.zip
• 教育部隸書字形檔(Version 3.00)，目前收錄國字數為4,808字。
  https://language.moe.gov.tw/001/Upload/Files/site_content/M0001/MoeLI-3.0.zip
• 教育部標準宋體字形檔 ：
  https://language.moe.gov.tw/001/Upload/Files/site_content/M0001/eduSong_Unicode.zip

附註（可商用）：

• マメロン Regular
  https://moji-waku.com/mamelon/
• 花園明朝：
  http://osdn.jp/projects/hanazono-font/releases/
  日本花園明朝體(HanaMin)是一款非常漂亮的藝術字體，包含近十萬字，所以不必擔心缺字，有分割成HanaMinA、HanaMinB兩個字體檔，安裝A就好了，在macOS 裡 HanaMinB 會有問題，會跳回去PingFang 並變粗體字。
• 王漢宗自由字型：(193MB)
  https://drive.google.com/file/d/1eM7bpKCdcZc1i7QGIhXiUquS2TFCbXUf/view
• M+ FONTS PROJECT
  http://mplus-fonts.osdn.jp/about.html
• Fandol字体（4款）仿宋 黑体 楷体 宋体
  https://ctan.org/pkg/fandol
  Fandol系列字体来自一家已经破产的字体公司，现在已经开源了。
• 瀨戶字體
  https://zh-tw.osdn.net/projects/setofont/
  瀨戶字體是一個由日本人開發的線上免費字體，支援繁體中文、簡體中文、日文、英文和其他特殊符號，總共支援3萬多個漢字。
• 楊任東竹石體
  http://www.fonts.net.cn/author-6289251609-1.html
  上面的這個版本，字型檔案好像有點問題，有些字會出錯。改下載這個版本即可解決：
  https://m.fontke.com/font/28225026/
  出錯的原因是在版本號，第一個連結是 1.2 版，後面的是 1.5版，1.5版才有支援繁體字，可是 1.5 版的字重被調重了，相當於1.2版的 Medium。
  
  “杨任东字体”微信公众号
  https://www.weibo.com/p/1005053026020863/info?mod=pedit_more
  好年輕的人哦，生日：1993年12月30日。
• TanukiMagic 麥克筆手繪 POP 日文字型：
  http://tanukifont.com/tanuki-permanent-marker/
• 日系851原子筆手寫風格字型，可商用免費下載
  https://pm85122.onamae.jp/851fontpage.html

相關文章：

Python 字型相關工具
https://stackoverflow.max-everyday.com/2020/02/python-font/

Font­Tools 安裝與使用簡明指南
https://stackoverflow.max-everyday.com/2020/02/fonttools/

FontForge
https://github.com/fontforge/fontforge/releases

Awesome Typography
https://github.com/Jolg42/awesome-typography

免費中文字體 NotoSans 思源黑體
https://max-everyday.com/2018/03/noto-font/

free and carefree: 可以免費商用的中文或漢字字型
https://tips.justfont.com/post/113397509827/freeandcarefreefonts

免費商用字體整理
https://max-everyday.com/2020/02/free-commercial-fonts/

FontForge 調整字型在 Windows 的安裝顯示名稱
https://stackoverflow.max-everyday.com/2020/02/fontforge-chinese/

內海字體 (NaikaiFont)
https://max-everyday.com/2020/03/naikaifont/

幫字型檔補缺字
https://max-everyday.com/2020/02/how-to-add-new-glyph-to-font/

發生的原因：css 裡 em 和 px 的轉換不一致所造成，Google一下 em 轉 px 應該是 1em=16px，但實際測試在 macOS 裡的 chrome 居然是 1em=20px。

影片說明：
https://youtu.be/CJ_YEo3Uv3g

瀏覽器的實測結果：

解法：把 64em 改用 1024px 。

會去用em 應該是有原因的，但目前不同瀏覽器對em的定義似乎不太一致，所以做出來的網頁在不同瀏覽器的效果會有所差別。

沒想到會來研究css，多學一點也滿好的，可以自己幫自己解決問題。

附上測試用的網頁：

<html>
 <body>
 <div style="box-sizing: border-box;
     width: 64em;    background: #fff3d4;
     border-color: #f6b73c;">hello 64em</div>
 <hr/>
 <div style="box-sizing: border-box;
     width: 1024px;    background: #fff3d4;
     border-color: #f6b73c;">hello 1024px</div>
 <hr/>
 <div style="box-sizing: border-box;
     width: 51.2em;    background: #fff3d4;
     border-color: #f6b73c;">hello 51.2em</div>
 </body>
 </html>

css如何實作網頁右上角選單效果：

@media print, screen and (min-width: 1024px) {
   .hide-for-large {
     display: none !important; } }

程式碼說明：

當符合最小寬度1024px（等於：螢幕寬度為 1024px 以上）執行括號內的設定值。

倒過來的範例：

@media screen and (max-width: 1024px) {
   .show-for-large {
     display: none !important; } }

程式碼說明：

當符合最大寬度1024px（等於：螢幕寬度為 1024px 以下）執行括號內的設定值。

相關文章：

Day22：小事之 Media Query
https://ithelp.ithome.com.tw/articles/10196578

CSS Media Queries 詳細介紹
https://www.oxxostudio.tw/articles/201810/css-media-queries.html