Adding upstream version 1.6.0.upstream/1.6.0upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 327 insertions, 0 deletions

diff --git a/examples/psftoneletters.py b/examples/psftoneletters.py
new file mode 100644
index 0000000..5fd871f
--- /dev/null
+++ b/examples/psftoneletters.py
@@ -0,0 +1,327 @@
+#!/usr/bin/env python
+from __future__ import unicode_literals
+'''Creates Latin script tone letters (pitch contours)'''
+__url__ = 'http://github.com/silnrsi/pysilfont'
+__copyright__ = 'Copyright (c) 2017 SIL International (http://www.sil.org)'
+__license__ = 'Released under the MIT License (http://opensource.org/licenses/MIT)'
+__author__ = 'Victor Gaultney'
+
+# Usage: psftoneletters ifont ofont
+# Assumption is that the named tone letters already exist in the font,
+# so this script is only to update (rebuild) them. New tone letter spaces
+# in the font can be created with psfbuildcomp.py
+
+# To Do
+# Get parameters from lib.plist org.sil.lcg.toneLetters
+
+# main input, output, and execution handled by pysilfont framework
+from silfont.core import execute
+import silfont.ufo as UFO
+
+from robofab.world import OpenFont
+
+from math import tan, radians, sqrt
+
+suffix = '_toneletters'
+argspec = [
+   ('ifont',{'help': 'Input font file'}, {'type': 'filename'}),
+   ('ofont',{'help': 'Output font file','nargs': '?' }, {'type': 'filename', 'def': "_"+suffix}),
+   ('-l','--log',{'help': 'Log file'}, {'type': 'outfile', 'def': suffix+'log'})]
+
+
+def getParameters(font):
+    global glyphHeight, marginFlatLeft, marginPointLeft, marginFlatRight, marginPointRight, contourWidth, marginDotLeft, marginDotRight, dotSpacing, italicAngle, radius, strokeHeight, strokeDepth, contourGap, fakeBottom, dotRadius, dotBCP, contourGapDot, fakeBottomDot, anchorHeight, anchorOffset
+
+    source = font.lib.getval("org.sil.lcg.toneLetters")
+
+    strokeThickness = int(source["strokeThickness"]) # total width of stroke (ideally an even number)
+    glyphHeight = int(source["glyphHeight"]) # height, including overshoot
+    glyphDepth = int(source["glyphDepth"]) # depth - essentially overshoot (typically negative)
+    marginFlatLeft = int(source["marginFlatLeft"]) # left sidebearing for straight bar
+    marginPointLeft = int(source["marginPointLeft"]) # left sidebearing for endpoints
+    marginFlatRight = int(source["marginFlatRight"]) # left sidebearing for straight bar
+    marginPointRight = int(source["marginPointRight"]) # left sidebearing for endpoints
+    contourWidth = int(source["contourWidth"]) # this is how wide the contour portions are, from the middle
+                            # of one end to the other, in the horizontal axis. The actual
+                            # bounding box of the contours would then be this plus the
+                            # strokeThickness.
+    marginDotLeft = int(source["marginDotLeft"]) # left sidebearing for dots
+    marginDotRight = int(source["marginDotRight"]) # right sidebearing for dots
+    dotSize = int(source["dotSize"]) # the diameter of the dot, normally 150% of the stroke weight
+                            #  (ideally an even number)
+    dotSpacing = int(source["dotSpacing"]) # the space between the edge of the dot and the
+                            # edge of the expanded stroke
+    italicAngle = float(source["italicAngle"]) # angle of italic slant, 0 for upright
+
+    radius = round(strokeThickness / 2)
+    strokeHeight = glyphHeight - radius                # for the unexpanded stroke
+    strokeDepth = glyphDepth + radius
+    strokeLength = strokeHeight - strokeDepth
+    contourGap = round(strokeLength / 4)            # gap between contour levels
+    fakeBottom = strokeDepth - contourGap            # a false 'bottom' for building contours
+
+    dotRadius = round(dotSize / 2)                    # this gets redefined during nine tone process
+    dotBCP = round((dotSize / 2) * .55)                # this gets redefined during nine tone process
+    contourGapDot = round(( (glyphHeight - dotRadius) - (glyphDepth + dotRadius) ) / 4)
+    fakeBottomDot = (glyphDepth + dotRadius) - contourGapDot
+
+    anchorHeight = [ 0 , strokeDepth , (strokeDepth + contourGap) , (strokeDepth + contourGap * 2) , (strokeHeight - contourGap) , strokeHeight ]
+    anchorOffset = 20   # hardcoded for now
+
+# drawing functions
+
+def drawLine(glyph,startX,startY,endX,endY):
+
+    dx = (endX - startX)                        # dx of original stroke
+    dy = (endY - startY)                        # dy of original stroke
+    len = sqrt( dx * dx + dy * dy )                # length of original stroke
+    opp = round(dy * (radius / len))                    # offsets for on-curve points
+    adj = round(dx * (radius / len))
+    oppOff = round(opp * .55)                             # offsets for off-curve from on-curve
+    adjOff = round(adj * .55)
+
+    glyph.clearContours()
+
+    pen = glyph.getPen()
+
+    # print startX + opp, startY - adj
+
+    pen.moveTo((startX + opp, startY - adj))
+    pen.lineTo((endX + opp, endY - adj))        # first straight line
+
+    bcp1x = endX + opp + adjOff
+    bcp1y = endY - adj + oppOff
+    bcp2x = endX + adj + oppOff
+    bcp2y = endY + opp - adjOff
+    pen.curveTo((bcp1x, bcp1y), (bcp2x, bcp2y), (endX + adj, endY + opp))
+
+    bcp1x = endX + adj - oppOff
+    bcp1y = endY + opp + adjOff
+    bcp2x = endX - opp + adjOff
+    bcp2y = endY + adj + oppOff
+    pen.curveTo((bcp1x, bcp1y), (bcp2x, bcp2y), (endX - opp, endY + adj))
+
+    pen.lineTo((startX - opp, startY + adj))    # second straight line
+
+    bcp1x = startX - opp - adjOff
+    bcp1y = startY + adj - oppOff
+    bcp2x = startX - adj - oppOff
+    bcp2y = startY - opp + adjOff
+    pen.curveTo((bcp1x, bcp1y), (bcp2x, bcp2y), (startX - adj, startY - opp))
+
+    bcp1x = startX - adj + oppOff
+    bcp1y = startY - opp - adjOff
+    bcp2x = startX + opp - adjOff
+    bcp2y = startY - adj - oppOff
+    pen.curveTo((bcp1x, bcp1y), (bcp2x, bcp2y), (startX + opp, startY - adj))
+    # print startX + opp, startY - adj
+
+    pen.closePath()
+
+
+def drawDot(glyph,dotX,dotY):
+
+    glyph.clearContours()
+
+    pen = glyph.getPen()
+
+    pen.moveTo((dotX, dotY - dotRadius))
+    pen.curveTo((dotX + dotBCP, dotY - dotRadius), (dotX + dotRadius, dotY - dotBCP), (dotX + dotRadius, dotY))
+    pen.curveTo((dotX + dotRadius, dotY + dotBCP), (dotX + dotBCP, dotY + dotRadius), (dotX, dotY + dotRadius))
+    pen.curveTo((dotX - dotBCP, dotY + dotRadius), (dotX - dotRadius, dotY + dotBCP), (dotX - dotRadius, dotY))
+    pen.curveTo((dotX - dotRadius, dotY - dotBCP), (dotX - dotBCP, dotY - dotRadius), (dotX, dotY - dotRadius))
+    pen.closePath()
+
+
+def adjItalX(aiX,aiY):
+    newX = aiX + round(tan(radians(italicAngle)) * aiY)
+    return newX
+
+
+def buildComp(f,g,pieces,ancLevelLeft,ancLevelMidLeft,ancLevelMidRight,ancLevelRight):
+
+    g.clear()
+    g.width = 0
+
+    for p in pieces:
+        g.appendComponent(p, (g.width, 0))
+        g.width += f[p].width
+
+    if ancLevelLeft > 0:
+        anc_nm = "_TL"
+        anc_x = adjItalX(0,anchorHeight[ancLevelLeft])
+        if g.name[0:7] == 'TnStaff':
+        	anc_x = anc_x - anchorOffset
+        anc_y = anchorHeight[ancLevelLeft]
+        g.appendAnchor(anc_nm, (anc_x, anc_y))
+
+    if ancLevelMidLeft > 0:
+        anc_nm = "_TL"
+        anc_x = adjItalX(marginPointLeft + radius,anchorHeight[ancLevelMidLeft])
+        anc_y = anchorHeight[ancLevelMidLeft]
+        g.appendAnchor(anc_nm, (anc_x, anc_y))
+
+    if ancLevelMidRight > 0:
+        anc_nm = "TL"
+        anc_x = adjItalX(g.width - marginPointRight - radius,anchorHeight[ancLevelMidRight])
+        anc_y = anchorHeight[ancLevelMidRight]
+        g.appendAnchor(anc_nm, (anc_x, anc_y))
+
+    if ancLevelRight > 0:
+        anc_nm = "TL"
+        anc_x = adjItalX(g.width,anchorHeight[ancLevelRight])
+        if g.name[0:7] == 'TnStaff':
+        	anc_x = anc_x + anchorOffset
+        anc_y = anchorHeight[ancLevelRight]
+        g.appendAnchor(anc_nm, (anc_x, anc_y))
+
+
+# updating functions
+
+def updateTLPieces(targetfont):
+
+    f = targetfont
+
+    # set spacer widths
+    f["TnLtrSpcFlatLeft"].width = marginFlatLeft + radius
+    f["TnLtrSpcPointLeft"].width = marginPointLeft + radius - 1    # -1 corrects final sidebearing
+    f["TnLtrSpcFlatRight"].width = marginFlatRight + radius
+    f["TnLtrSpcPointRight"].width = marginPointRight + radius - 1    # -1 corrects final sidebearing
+    f["TnLtrSpcDotLeft"].width = marginDotLeft + dotRadius
+    f["TnLtrSpcDotMiddle"].width = dotRadius + dotSpacing + radius
+    f["TnLtrSpcDotRight"].width = dotRadius + marginDotRight
+
+    # redraw bar
+    g = f["TnLtrBar"]
+    drawLine(g,adjItalX(0,strokeDepth),strokeDepth,adjItalX(0,strokeHeight),strokeHeight)
+    g.width = 0
+
+    # redraw contours
+    namePre = 'TnLtrSeg'
+    for i in range(1,6):
+        for j in range(1,6):
+
+            nameFull = namePre + str(i) + str(j)
+
+            if i == 5:                            # this deals with round off errors
+                startLevel = strokeHeight
+            else:
+                startLevel = fakeBottom + i * contourGap
+            if j == 5:
+                endLevel = strokeHeight
+            else:
+                endLevel = fakeBottom + j * contourGap
+
+            g = f[nameFull]
+            g.width = contourWidth
+            drawLine(g,adjItalX(1,startLevel),startLevel,adjItalX(contourWidth-1,endLevel),endLevel)
+
+
+    # redraw dots
+    namePre = 'TnLtrDot'
+    for i in range(1,6):
+
+        nameFull = namePre + str(i)
+
+        if i == 5:                            # this deals with round off errors
+            dotLevel = glyphHeight - dotRadius
+        else:
+            dotLevel = fakeBottomDot + i * contourGapDot
+
+        g = f[nameFull]
+        drawDot(g,adjItalX(0,dotLevel),dotLevel)
+
+
+def rebuildTLComps(targetfont):
+
+    f = targetfont
+
+    # staff right
+    for i in range(1,6):
+        nameFull = 'TnStaffRt' + str(i)
+        buildComp(f,f[nameFull],['TnLtrBar','TnLtrSpcFlatRight'],i,0,0,0)
+
+    # staff right no outline
+    for i in range(1,6):
+        nameFull = 'TnStaffRt' + str(i) + 'no'
+        buildComp(f,f[nameFull],['TnLtrSpcFlatRight'],i,0,0,0)
+
+    # staff left
+    for i in range(1,6):
+        nameFull = 'TnStaffLft' + str(i)
+        buildComp(f,f[nameFull],['TnLtrSpcFlatLeft','TnLtrBar'],0,0,0,i)
+
+    # staff left no outline
+    for i in range(1,6):
+        nameFull = 'TnStaffLft' + str(i) + 'no'
+        buildComp(f,f[nameFull],['TnLtrSpcFlatLeft'],0,0,0,i)
+
+    # contours right
+    for i in range(1,6):
+        for j in range(1,6):
+            nameFull = 'TnContRt' + str(i) + str(j)
+            segment = 'TnLtrSeg' + str(i) + str(j)
+            buildComp(f,f[nameFull],['TnLtrSpcPointLeft',segment],0,i,0,j)
+
+    # contours left
+    for i in range(1,6):
+        for j in range(1,6):
+            nameFull = 'TnContLft' + str(i) + str(j)
+            segment = 'TnLtrSeg' + str(i) + str(j)
+            buildComp(f,f[nameFull],[segment,'TnLtrSpcPointRight'],i,0,j,0)
+
+    # basic tone letters
+    for i in range(1,6):
+        nameFull = 'TnLtr' + str(i)
+        segment = 'TnLtrSeg' + str(i) + str(i)
+        buildComp(f,f[nameFull],['TnLtrSpcPointLeft',segment,'TnLtrBar','TnLtrSpcFlatRight'],0,0,0,0)
+
+    # basic tone letters no outline
+    for i in range(1,6):
+        nameFull = 'TnLtr' + str(i) + 'no'
+        segment = 'TnLtrSeg' + str(i) + str(i)
+        buildComp(f,f[nameFull],['TnLtrSpcPointLeft',segment,'TnLtrSpcFlatRight'],0,i,0,0)
+
+    # left stem tone letters
+    for i in range(1,6):
+        nameFull = 'LftStemTnLtr' + str(i)
+        segment = 'TnLtrSeg' + str(i) + str(i)
+        buildComp(f,f[nameFull],['TnLtrSpcFlatLeft','TnLtrBar',segment,'TnLtrSpcPointRight'],0,0,0,0)
+
+    # left stem tone letters no outline
+    for i in range(1,6):
+        nameFull = 'LftStemTnLtr' + str(i) + 'no'
+        segment = 'TnLtrSeg' + str(i) + str(i)
+        buildComp(f,f[nameFull],['TnLtrSpcFlatLeft',segment,'TnLtrSpcPointRight'],0,0,i,0)
+
+    # dotted tone letters
+    for i in range(1,6):
+        nameFull = 'DotTnLtr' + str(i)
+        dot = 'TnLtrDot' + str(i)
+        buildComp(f,f[nameFull],['TnLtrSpcDotLeft',dot,'TnLtrSpcDotMiddle','TnLtrBar','TnLtrSpcFlatRight'],0,0,0,0)
+
+    # dotted left stem tone letters
+    for i in range(1,6):
+        nameFull = 'DotLftStemTnLtr' + str(i)
+        dot = 'TnLtrDot' + str(i)
+        buildComp(f,f[nameFull],['TnLtrSpcFlatLeft','TnLtrBar','TnLtrSpcDotMiddle',dot,'TnLtrSpcDotRight'],0,0,0,0)
+
+
+def doit(args):
+
+    psffont = UFO.Ufont(args.ifont, params = args.paramsobj)
+    rffont = OpenFont(args.ifont)
+    outfont = args.ofont
+
+    getParameters(psffont)
+
+    updateTLPieces(rffont)
+    rebuildTLComps(rffont)
+
+
+    rffont.save(outfont)
+
+    return
+
+def cmd() : execute(None,doit,argspec)
+if __name__ == "__main__": cmd()