TCAX 字幕特效制作工具官方论坛 | ASS | TCAS | Python | Aegisub | Lua

标题: 拆分字形 [附工程] [打印本页]
作者: 面麻    时间: 2015-9-10 21:48:09     标题: 拆分字形 [附工程]

本帖最后由 面麻 于 2015-9-10 22:48 编辑

当初我在一个MAD作品里看到的效果，就是拆分字形，想用ASS来实现一下。
一共2个方法，都是灾厄前辈想的，代码也是他写的。
我在其中也学到了很多，很感谢灾厄。

可能代码里面有一些东西涉及到高层次的Python语法，尽量看吧。
注释也很多，如果还有问题，直接跟帖。
完整工程在下面，可以Prase一下看看。

两种方法可能还有点小bug，各有优劣。

test_split_font_temp.zip (17.56 KB, 下载次数: 2845)

第一种方法，是拆分矢量字体的绘图代码，先通过 'm' 字符判断大致拆分开，然后再考虑内外框分别是顺时针和逆时针的情况，下面的代码是以逆时针为内框。
需要说明的是，不同字体，内外框的绕行方向是不确定的，所以如果出现大片字形不正确，可以修改函数check_clockwise()的clockwise值。
其实，这个判断是比较复杂的，尤其是凹多边形很难判断，如果出现个别字形不正确，只能手动判断和修改绘图代码。
  1. from tcaxPy import *
  2. from util.gdiFont import *

  4. import re

  6. def tcaxPy_Init():
  7.     global font   # Font和GdiFont效果差不多
  8.     global fontsize
  9.     global GdiFont
  10.     fontsize = GetVal(val_FontSize)
  11.     font = InitFont(GetVal(val_FontFileName), GetVal(val_FaceID), fontsize, GetVal(val_Spacing), GetVal(val_SpaceScale), 0xFFFFFF, 0, 0)
  12.     GdiFont = gfInitFont(GetVal(val_FontFaceName), fontsize, GetVal(val_Spacing), GetVal(val_SpaceScale), 0, False)   #GDIfont

  14. def tcaxPy_User():
  15.     pass


  18. def tcaxPy_Fin():
  19.     FinFont(font)

  21. def checkacw(str):          # 判斷內框

  23.     Ppath = ppath(str)
  24.    
  25.     if Ppath[0]==Ppath[-1]:        #字體矢量有重複最後坐標點的習慣 貌似重複的基本是外框 不過總有bug的地方 總之取首尾不同的 扔掉最後重複
  26.         Ppath.pop()
  27.     return check_clockwise(Ppath)   # 设为内框

  29. #構建一個本項和後項結合的list 比方說poly為[(1,1),(2,2),(3,3),(4,4)] 則新list為[((1,1),(2,2)),((2,2),(3,3)),((3,3),(4,4)),((4,4),(1,1))]
  30. def segments(poly):       #網上照搬
  31.     return zip(poly, poly[1:] + [poly[0]])     

  33. def check_clockwise(poly):      #判斷順時針 網上搬 算法之前判斷用的極值求叉積法 總有凹多邊形不準確 這個遍歷所有點算叉積 最後以總和的正負來判斷
  34.     clockwise = False
  35.     if (sum(x0*y1 - x1*y0 for ((x0, y0), (x1, y1)) in segments(poly))) < 0:   # 叉積为負值是逆時針
  36.         clockwise = not clockwise
  37.     return clockwise


  40. def ppath(str):   # 從str 將路徑儲存為 [(1,1),(2,2),(3,3),(4,4)] 這種格式 b 標籤捨棄中間點 做直線考慮
  41.     if str[0] != 'm':
  42.         str = 'm'+ str
  43.     sb = re.split('m|l|b ',str)     # re是一个正则表达式Module，这里的split其实就是字符串的split函数的翻版，只是可以对分隔符用正则
  44.     ppath = []
  45.     for s in sb:
  46.         b = s.split()
  47.         if len(b) > 1:
  48.             if b[-1]=='c':
  49.                 ppath.append((int(b[-3]),int(b[-2])))
  50.             else:
  51.                 ppath.append((int(b[-2]),int(b[-1])))
  52.     ppath.pop()   # 所有路徑 首尾都相同 捨棄掉最後重複
  53.     return ppath

  55. def polycmp(poly1,poly2):    #判斷多邊形是否在另一個多邊形內
  56.     result = True
  57.     if poly2[-1]==poly2[0]:
  58.         poly2.pop()
  59.     for p1 in poly1:
  60.         x1,y1= p1
  61.         if not pointinpoly(x1,y1,poly2):  #遍歷多邊形所有點是否在多邊形內
  62.             result = False
  63.     return result

  65. def pointinpoly(x,y,poly): # 判斷一個點是否在多邊形內 網上搬

  67.     n = len(poly)
  68.     inside = False

  70.     p1x,p1y = poly[0]
  71.     for i in range(n+1):
  72.         p2x,p2y = poly[i % n]
  73.         if y > min(p1y,p2y):
  74.             if y <= max(p1y,p2y):
  75.                 if x <= max(p1x,p2x):
  76.                     if p1y != p2y:
  77.                         xints = (y-p1y)*(p2x-p1x)/(p2y-p1y)+p1x
  78.                     if p1x == p2x or x <= xints:
  79.                         inside = not inside
  80.         p1x,p1y = p2x,p2y

  82.     return inside


  85. def tcaxPy_Main(_i, _j, _n, _start, _end, _elapk, _k, _x, _y, _a, _txt):

  87.     ASS_BUF  = []        # used for saving ASS FX lines

  89.     #############################
  90.     # TODO: write your codes here #

  92.     dx = _x - int(_a / 2 + 0.5)
  93.     dy = _y - int(fontsize / 2 + 0.5)

  95.     outline = gfGetOutline(GdiFont, _txt, dx,dy)

  97.     draw = outline.split('m')
  98.     num = len(draw)
  99.     tcaxLog(draw)


  102.     acdl = []   #用來儲存內框矢量
  103.     cdl = []    #儲存外框矢量
  104.     if _i>-1 :
  105.         for i in range(num):     #遍歷所有m標籤矢量 判斷內外框 并進行儲存
  106.             if draw[i] == '':
  107.                 continue

  109.             if checkacw(draw[i]):     
  110.                 acd = 'm'+draw[i]
  111.                 acdl.append(acd)
  112.             else:
  113.                 cd = 'm'+draw[i]
  114.                 cdl.append(cd)   
  115.    
  116.     cdlcopy = cdl[:]   #複製一遍list
  117.     for acd in acdl:   
  118.         index = -1
  119.         for i in range(len(cdlcopy)):
  120.             if polycmp(ppath(acd),ppath(cdlcopy[i])):     #遍歷所有內框外框 判斷內框是否在外框範圍內
  121.                 if index == -1:
  122.                     index = i
  123.                 else:                                    
  124.                     if polycmp(ppath(cdlcopy[i]),ppath(cdlcopy[index])):   #若存在多個可匹配的範圍 取最小的框 如"回"字
  125.                         index = i
  126.         if index != -1:
  127.             cdl[index] += acd    #將內框矢量 加在外框矢量之後
  128.         else:
  129.             cdl.append(acd)  #若沒找到匹配的外框 則作為外框 這個有可能是順時針逆時針的判斷問題 也有可能是字體設計的問題 總之是保險

  131.     for cd in cdl:   #繪製
  132.         posX = randint(-_a, _a) + randint(-10, 10)
  133.         posY = randint(-fontsize , fontsize ) + randint(-10, 10)
  134.         EFT = an(7) + move(posX, posY, 0, 0, 0, 500) + p(4)
  135.         ass_main(ASS_BUF, SubL(_start, _end), EFT, cd)

  137.     #############################

  139.     return (ASS_BUF, None)
复制代码
第二种方法，是用粒子，这里面用到了判断连通性的Labeling算法，网络上搜索 'Labeling' 就可以找到相关资料，比如：http://blog.csdn.net/icvpr/article/details/10259577
具体的算法不做解释，但还是需要自己查看一下才能看懂下面的代码。
  1. from tcaxPy import *

  3. def tcaxPy_Init():
  4.     global font
  5.     global fontsize

  7.     fontsize = GetVal(val_FontSize)
  8.     font = InitFont(GetVal(val_FontFileName), GetVal(val_FaceID), fontsize, GetVal(val_Spacing), GetVal(val_SpaceScale), 0xFFFFFF, 0, 0)


  11. def tcaxPy_User():
  12.     pass


  15. def tcaxPy_Fin():
  16.     FinFont(font)

  18. def GetPixelPointFromPix(PIX, InitPosX, InitPosY):      # 将方形PIX[1][0]xPIX[1][1]范围的pixel扫描成一个list，保存位置、RGBA、label信息
  19.     pixel = []
  20.     label = 0
  21.     for h in range(PIX[1][1]):
  22.         posY = InitPosY + h
  23.         for w in range(PIX[1][0]):
  24.             posX = InitPosX + w
  25.             idx = 4 * (h * PIX[1][0] + w)
  26.             pixR = PIX[2][idx + 0]
  27.             pixG = PIX[2][idx + 1]
  28.             pixB = PIX[2][idx + 2]
  29.             pixA = PIX[2][idx + 3]
  30.             pixel.append([(posX, posY), (pixR, pixG, pixB, pixA), label])
  31.    
  32.     return pixel

  34. def DeleteRepeat(labelset):     # 删除list中的重复元素

  36.     labelset2 = []

  38.     [labelset2.append(label) for label in labelset if not label in labelset2]

  40.     return labelset2      


  43. def UnionTwoLists(list1, list2):     # 合并2个list，默认它们含有相同元素
  44.     for elem in list1:
  45.         if elem in list2:
  46.             continue
  47.         else:
  48.             list2.append(elem)

  50.     return list2


  53. def UnionLabelSet(labelset):        # 整理labelset，合并
  54.     labelset = sorted(labelset, key=lambda k: k[0]) # 排序
  55.     labelset = DeleteRepeat(labelset) # 刪除重複

  57.     labelset2 = []


  60.     for label in labelset:
  61.         if labelset2 == []:               #第一個 label 直接添加
  62.             labelset2.append(label)

  64.         else:
  65.             flag = 0
  66.             for i in range(len(labelset2)):   #遍歷之前的label找交集 若存在交集 向對應位置 添加未存在的元素
  67.                 #tcaxLog(label2)
  68.                 if (label[0] not in labelset2[i]) and (label[1] in labelset2[i]):
  69.                     flag = 1
  70.                     labelset2[i].append(label[0])
  71.                 elif (label[0] in labelset2[i]) and (label[1] not in labelset2[i]):
  72.                     flag = 1
  73.                     labelset2[i].append(label[1])
  74.                 elif (label[0] in labelset2[i]) and (label[1] in labelset2[i]):
  75.                     flag = 1
  76.             if flag == 0:   # 若不存在交集 則另存
  77.                 labelset2.append(label)

  79.     #tcaxLog(labelset2)           
  80.     return labelset2
  81.    

  83. def tcaxPy_Main(_i, _j, _n, _start, _end, _elapk, _k, _x, _y, _a, _txt):

  85.     ASS_BUF  = []        # used for saving ASS FX lines

  87.     #############################
  88.     # TODO: write your codes here #

  90.     PIX = TextPix(font, _txt)

  92.     InitPosX = _x - int(_a / 2 + 0.5) + PIX[0][0]
  93.     InitPosY = _y - int(fontsize / 2 + 0.5) + PIX[0][1]

  95.     pixel = GetPixelPointFromPix(PIX, InitPosX, InitPosY)

  97.     num = len(pixel)
  98.     label = 0
  99.     labelset = []

  101.     # 1-pass
  102.     for i in range(num):
  103.         if pixel[i][1][3] != 0:     # 如果是有效像素
  104.             if i == 0:              # 如果是第1个像素，没有左面和上面的相邻像素，需要单独考虑
  105.                 label += 1
  106.                 pixel[i][2] = label
  107.             elif i % PIX[1][0] == 0:                # 如果是第1列像素，没有左面的相邻像素，需要单独考虑
  108.                 uppixelindex = i - PIX[1][0]        # 取上面的相邻像素index
  109.                 if pixel[uppixelindex][2] != 0:      
  110.                     pixel[i][2] = pixel[uppixelindex][2]    # 如果上面的相邻像素是有效像素，就把上面像素的label赋给当前像素
  111.                 else:                                       # 如果上面的相邻像素不是有效像素，就把label加1，然后赋给当前像素
  112.                     label += 1
  113.                     pixel[i][2] = label
  114.             elif i <= PIX[1][0] - 1:        # 如果是第1行像素，没有上面的相邻像素，需要单独考虑
  115.                 leftpixelindex = i - 1
  116.                 if pixel[leftpixelindex][2] != 0:
  117.                     pixel[i][2] = pixel[leftpixelindex][2]
  118.                 else:
  119.                     label += 1
  120.                     pixel[i][2] = label
  121.             else:                           # 同时考虑上面和左面的相邻像素是否是有效像素
  122.                 uppixelindex = i - PIX[1][0]
  123.                 leftpixelindex = i - 1
  124.                 if pixel[leftpixelindex][2] != 0 and pixel[uppixelindex][2] != 0:                   # 如果上面和左面的相邻像素都是有效像素，
  125.                     pixel[i][2] = min(pixel[leftpixelindex][2], pixel[uppixelindex][2])             # 就把它们的label的最小值赋给当前像素
  126.                     if pixel[leftpixelindex][2] != pixel[uppixelindex][2]:                          # 如果它们的label不相等，
  127.                         labelset.append(sorted([pixel[leftpixelindex][2], pixel[uppixelindex][2]])) # 就把它们的label组成一个list加入labelset
  128.                 elif pixel[leftpixelindex][2] != 0 and pixel[uppixelindex][2] == 0:                 # 如果上面的相邻像素不是有效像素，
  129.                     pixel[i][2] = pixel[leftpixelindex][2]                                          # 就把左面像素的label赋给相邻像素
  130.                 elif pixel[leftpixelindex][2] == 0 and pixel[uppixelindex][2] != 0:                 # 如果左面的相邻像素不是有效像素，
  131.                     pixel[i][2] = pixel[uppixelindex][2]                                            # 就把上面像素的label赋给相邻像素
  132.                 else:                                                                               # 如果如果上面和左面的相邻像素都不是有效像素，
  133.                     label += 1                                                                      # 把label加1，赋给当前像素
  134.                     pixel[i][2] = label
  135.     #tcaxLog(pixel)                                       
  136.     labelset = UnionLabelSet(labelset)       

  138.     #print(labelset)                       
  139.       
  140.     # 2-pass    #這個地方寫法冗長 比較亂 沒仔細想

  142.     for i in range(len(pixel)):   #按labelset 修改相同 label
  143.         if pixel[i][2] != 0:
  144.             for j in range(len(labelset)):
  145.                 if pixel[i][2] in labelset[j]:                                            
  146.                     pixel[i][2] = min(labelset[j])
  147.                  
  148.     #tcaxLog(min(labelset[j]))
  149.     rndx = []
  150.     rndy = []
  151.     cor = []
  152.     labelbuf = []

  154.     for i in range(len(pixel)):   # 將不連續的label修改成最小連續數列

  156.         label = pixel[i][2]
  157.         if label != 0:
  158.             if label not in labelbuf:
  159.                 labelbuf.append(label)
  160.             pixel[i][2] = labelbuf.index(label) +1


  163.     for i in range(len(labelbuf)):  # 按照label個數生成隨機位置和顏色list
  164.         rndx.append(randint(-50, 50))
  165.         rndy.append(randint(-100, 100))
  166.         cor.append(RandRGB())

  168.     #tcaxLog(sorted(labelbuf))

  170.     #if _i == 0 and _j == 2:
  171.     #    tcaxLog(pixel)
  172.   
  173.     for i in range(len(pixel)):   #繪製  
  174.         label = pixel[i][2]

  176.         if label != 0:

  178.             EFT = move(pixel[i][0][0] + rndx[label-1], pixel[i][0][1] + rndy[label-1], pixel[i][0][0], pixel[i][0][1], 0, 500) + alpha(255 - pixel[i][1][3]) + color1(cor[label-1])
  179.             ass_main(ASS_BUF, SubL(_start, _end, 0, Pix_Style), EFT, DrawPoint())


  182.     #############################

  184.     return (ASS_BUF, None)
复制代码


附件: test_split_font_temp.zip (2015-9-10 21:46:04, 17.56 KB) / 下载次数 2845
http://tcax.org/forum.php?mod=attachment&aid=MTkxNHw0N2JmNjE3OXwxNzMyMjcyOTg3fDB8MA%3D%3D
作者: 100alife    时间: 2015-9-11 08:29:32

好东西 新人回覆
作者: milkyjing    时间: 2015-9-12 22:55:57

给你32个赞.
作者: qwe7989199    时间: 2015-10-6 12:54:08

赞一个！
作者: 哔哩哔哩    时间: 2016-5-1 20:23:58

话说，怎么使用这些代码？
作者: CMD    时间: 2018-2-11 21:53:42

谢谢楼主分享
作者: Seekladoom    时间: 2020-7-31 12:04:06

github上的NyuFX源码也有拆分字形的lua脚本，也是根据楼主所说的第1种方法来的：
https://github.com/Youka/NyuFX/b ... ons/shape.split.lua
作者: saiyaku    时间: 2020-7-31 20:18:54

Seekladoom 发表于 2020-7-31 12:04
github上的NyuFX源码也有拆分字形的lua脚本，也是根据楼主所说的第1种方法来的：
https://github.com/Youka ...

嗯 不太一样 国外不太讨论这种问题 没汉字
其实主要是一个拆分笔画的问题
但笔画的话 不太好实现
于是想 把连通的部分 拆出来
两种方法吧
一种通过字体读到的矢量情报来拆 代码没什么印象了
字体矢量连通图像 是这么一个顺序 外圈轮廓画完
逆时针再画一圈 在ass图形上 就镂空了
问题是整体代码 不是画完外圈紧接着画内圈
还有像“日”这样的字 一个外圈 接很多个内圈
所以这个代码就是怎么找 正确的外圈和内圈的归类

一种读字体像素情报进行归类
labeling 这是很经典的一个算法 学一点图像处理的话 应该都会教
https://zh.wikipedia.org/wiki/%E ... F%E6%A0%87%E8%AE%B0

嘛 这么多年过去了 现在想想 可能找个笔画的数据库 读一读 有笔顺再识别可能好一点
作者: Seekladoom    时间: 2020-7-31 21:54:07

本帖最后由 Seekladoom 于 2020-7-31 22:22 编辑
saiyaku 发表于 2020-7-31 20:18
嗯 不太一样 国外不太讨论这种问题 没汉字
其实主要是一个拆分笔画的问题
但笔画的话 不太好实现

关于笔画的数据库，我自己知道的方法有两种：

方法1：商业字体厂商（比如方正字库和汉仪字库）有那种专门的字体骨架，但是那种东西是商业机密，就算拿到了也只能自己玩玩，不能对外公开。

方法2：自己去给字体画字体骨架，临时做OPED的话一般也就是几十百八来个字，偶尔做做还行，但长期搞就顶不住。

但如果有人有毅力把大厂的字体，比如Adobe的思源黑体和思源宋体的骨架（Adobe的字体骨架自行仿制画出来不用担心会有侵权问题，毕竟思源字体的开源协议是OFL协议，基本上允许你随便用。国内厂商这块就捏得比较死，要当心侵权问题。）全给画一遍，然后再公开出来，那就方便了，至少凑合做特效用用应该还是可以的。稍微降下档次的话，先把GB2312-80的简体字体的6763外加常用字扩充的101个字做出来，也就是6864字，这个工作量就小一点，就看有没有人有毅力做并且肯公开了。BIG5的话，繁体的汉字数是13000左右，工作量将近是简体的2倍，要画的时间就稍微长一点。

当然也不是真的做不到，可以试着去学习字体骨架和笔画拼接技术这块的相关知识，把工作量分段来完成，现在知乎和中印社区也有不少关于字体这块的各种技术经验分享了，可以去这里多搜搜看。特别是知乎，这上面能提高人的工作效率的各种手段非常多，可以极大降低字幕制作者的工作压力。
作者: Seekladoom    时间: 2022-5-13 14:43:50

本帖最后由 Seekladoom 于 2022-5-13 14:44 编辑

【Aegisub】极度高效的拆字算法、连通域提取



欢迎光临 TCAX 字幕特效制作工具官方论坛 | ASS | TCAS | Python | Aegisub | Lua (http://tcax.org/) Powered by Discuz! X2