def test_buildCoverage(self):
     cov = builder.buildCoverage({"two", "four"}, {"two": 2, "four": 4})
     self.assertEqual(getXML(cov.toXML),
                      '<Coverage>'
                      '  <Glyph value="two"/>'
                      '  <Glyph value="four"/>'
                      '</Coverage>')
Пример #2
0
 def test_buildCoverage(self):
     cov = builder.buildCoverage({"two", "four"}, {"two": 2, "four": 4})
     self.assertEqual(getXML(cov.toXML),
                      '<Coverage>'
                      '  <Glyph value="two"/>'
                      '  <Glyph value="four"/>'
                      '</Coverage>')
Пример #3
0
 def test_buildCoverage(self):
     cov = builder.buildCoverage({"two", "four"}, {"two": 2, "four": 4})
     assert getXML(cov.toXML) == [
         "<Coverage>",
         '  <Glyph value="two"/>',
         '  <Glyph value="four"/>',
         "</Coverage>",
     ]
Пример #4
0
    def build(self):
        markClasses = self.buildMarkClasses_(self.marks)
        markClassList = sorted(markClasses.keys(), key=markClasses.get)
        marks = {mark: (markClasses[mc], anchor) for mark, (mc, anchor) in self.marks.items()}

        st = otTables.MarkMarkPos()
        st.Format = 1
        st.ClassCount = len(markClasses)
        st.Mark1Coverage = otl.buildCoverage(marks, self.glyphMap)
        st.Mark2Coverage = otl.buildCoverage(self.baseMarks, self.glyphMap)
        st.Mark1Array = otl.buildMarkArray(marks, self.glyphMap)
        st.Mark2Array = otTables.Mark2Array()
        st.Mark2Array.Mark2Count = len(st.Mark2Coverage.glyphs)
        st.Mark2Array.Mark2Record = []
        for base in st.Mark2Coverage.glyphs:
            anchors = [self.baseMarks[base].get(mc) for mc in markClassList]
            st.Mark2Array.Mark2Record.append(otl.buildMark2Record(anchors))
        return self.buildLookup_([st])
Пример #5
0
    def build(self):
        markClasses = self.buildMarkClasses_(self.marks)
        markClassList = sorted(markClasses.keys(), key=markClasses.get)
        marks = {mark: (markClasses[mc], anchor)
                 for mark, (mc, anchor) in self.marks.items()}

        st = otTables.MarkMarkPos()
        st.Format = 1
        st.ClassCount = len(markClasses)
        st.Mark1Coverage = otl.buildCoverage(marks, self.glyphMap)
        st.Mark2Coverage = otl.buildCoverage(self.baseMarks, self.glyphMap)
        st.Mark1Array = otl.buildMarkArray(marks, self.glyphMap)
        st.Mark2Array = otTables.Mark2Array()
        st.Mark2Array.Mark2Count = len(st.Mark2Coverage.glyphs)
        st.Mark2Array.Mark2Record = []
        for base in st.Mark2Coverage.glyphs:
            anchors = [self.baseMarks[base].get(mc) for mc in markClassList]
            st.Mark2Array.Mark2Record.append(otl.buildMark2Record(anchors))
        return self.buildLookup_([st])
Пример #6
0
 def build(self):
     subtables = []
     for prefix, suffix, mapping in self.substitutions:
         st = otTables.ReverseChainSingleSubst()
         st.Format = 1
         self.setBacktrackCoverage_(prefix, st)
         self.setLookAheadCoverage_(suffix, st)
         st.Coverage = otl.buildCoverage(mapping.keys(), self.glyphMap)
         st.GlyphCount = len(mapping)
         st.Substitute = [mapping[g] for g in st.Coverage.glyphs]
         subtables.append(st)
     return self.buildLookup_(subtables)
Пример #7
0
 def build(self):
     subtables = []
     for prefix, suffix, mapping in self.substitutions:
         st = otTables.ReverseChainSingleSubst()
         st.Format = 1
         self.setBacktrackCoverage_(prefix, st)
         self.setLookAheadCoverage_(suffix, st)
         st.Coverage = otl.buildCoverage(mapping.keys(), self.glyphMap)
         st.GlyphCount = len(mapping)
         st.Substitute = [mapping[g] for g in st.Coverage.glyphs]
         subtables.append(st)
     return self.buildLookup_(subtables)
Пример #8
0
 def setInputCoverage_(self, glyphs, subtable):
     subtable.InputGlyphCount = len(glyphs)
     subtable.InputCoverage = []
     for g in glyphs:
         coverage = otl.buildCoverage(g, self.glyphMap)
         subtable.InputCoverage.append(coverage)
Пример #9
0
 def setLookAheadCoverage_(self, suffix, subtable):
     subtable.LookAheadGlyphCount = len(suffix)
     subtable.LookAheadCoverage = []
     for s in suffix:
         coverage = otl.buildCoverage(s, self.glyphMap)
         subtable.LookAheadCoverage.append(coverage)
Пример #10
0
 def setBacktrackCoverage_(self, prefix, subtable):
     subtable.BacktrackGlyphCount = len(prefix)
     subtable.BacktrackCoverage = []
     for p in reversed(prefix):
         coverage = otl.buildCoverage(p, self.glyphMap)
         subtable.BacktrackCoverage.append(coverage)
Пример #11
0
    def _post_process(self, otf):
        font = self._font
        gdef = otf["GDEF"].table
        classdef = gdef.GlyphClassDef.classDefs
        for glyph in font:
            if glyph.lib.get(GLYPHCLASS_KEY) == "mark":
                classdef[glyph.name] = 3

        constants = font.lib.get(MATH_KEY)
        if constants:
            from fontTools.ttLib import newTable
            from fontTools.ttLib.tables import otTables
            from fontTools.otlLib import builder as otl

            glyphMap = {n: i for i, n in enumerate(font.glyphOrder)}
            table = otTables.MATH()
            table.Version = 0x00010000
            table.MathConstants = otTables.MathConstants()
            for c in constants:
                if c == "MinConnectorOverlap":
                    continue
                v = constants[c]
                if c not in ("ScriptPercentScaleDown",
                        "ScriptScriptPercentScaleDown",
                        "DelimitedSubFormulaMinHeight",
                        "DisplayOperatorMinHeight",
                        "RadicalDegreeBottomRaisePercent"):
                    vr = otTables.MathValueRecord()
                    vr.Value = v
                    v = vr
                setattr(table.MathConstants, c, v)
            extended = set()
            italic = {}
            accent = {}
            vvars = {}
            hvars = {}
            vcomp = {}
            hcomp = {}
            for glyph in font:
                math = glyph.lib.get(MATH_KEY)
                if math:
                    if "IsExtendedShape" in math:
                        extended.add(glyph.name)
                    if "ItalicCorrection" in math:
                        italic[glyph.name] = otTables.MathValueRecord()
                        italic[glyph.name].Value = math["ItalicCorrection"]
                    if "TopAccentHorizontal" in math:
                        accent[glyph.name] = otTables.MathValueRecord()
                        accent[glyph.name].Value = math["TopAccentHorizontal"]
                    if "GlyphVariantsVertical" in math:
                        vvars[glyph.name] = math["GlyphVariantsVertical"]
                        if "GlyphCompositionVertical" in math:
                            vcomp[glyph.name] = math["GlyphCompositionVertical"]
                    if "GlyphVariantsHorizontal" in math:
                        hvars[glyph.name] = math["GlyphVariantsHorizontal"]
                        if "GlyphCompositionHorizontal" in math:
                            hcomp[glyph.name] = math["GlyphCompositionHorizontal"]

            table.MathGlyphInfo = otTables.MathGlyphInfo()
            table.MathGlyphInfo.populateDefaults()

            coverage = otl.buildCoverage(italic.keys(), glyphMap)
            table.MathGlyphInfo.MathItalicsCorrectionInfo = otTables.MathItalicsCorrectionInfo()
            table.MathGlyphInfo.MathItalicsCorrectionInfo.Coverage = coverage
            table.MathGlyphInfo.MathItalicsCorrectionInfo.ItalicsCorrection = [italic[n] for n in coverage.glyphs]

            coverage = otl.buildCoverage(accent.keys(), glyphMap)
            table.MathGlyphInfo.MathTopAccentAttachment = otTables.MathTopAccentAttachment()
            table.MathGlyphInfo.MathTopAccentAttachment.TopAccentCoverage = coverage
            table.MathGlyphInfo.MathTopAccentAttachment.TopAccentAttachment = [accent[n] for n in coverage.glyphs]

            table.MathGlyphInfo.ExtendedShapeCoverage = otl.buildCoverage(extended, glyphMap)

            table.MathVariants = otTables.MathVariants()
            table.MathVariants.MinConnectorOverlap = constants["MinConnectorOverlap"]

            coverage = otl.buildCoverage(vvars.keys(), glyphMap)
            table.MathVariants.VertGlyphCoverage = coverage
            table.MathVariants.VertGlyphConstruction = []
            for name in coverage.glyphs:
                variants = vvars[name]
                construction = otTables.MathGlyphConstruction()
                construction.populateDefaults()
                construction.VariantCount = len(variants)
                construction.MathGlyphVariantRecord = []
                for variant in variants:
                    bbox = font[variant].getBounds(font)
                    record = otTables.MathGlyphVariantRecord()
                    record.VariantGlyph = variant
                    record.AdvanceMeasurement = int(bbox[-1] - bbox[1] + 1)
                    construction.MathGlyphVariantRecord.append(record)
                if name in vcomp:
                    construction.GlyphAssembly = otTables.GlyphAssembly()
                    construction.GlyphAssembly.ItalicsCorrection = otTables.MathValueRecord()
                    construction.GlyphAssembly.ItalicsCorrection.Value = 0
                    construction.GlyphAssembly.PartRecords = []
                    for comp in vcomp[name]:
                        record = otTables.GlyphPartRecord()
                        record.glyph = comp[0]
                        f, s, e, a = [int(v) for v in comp[1].split(",")]
                        record.StartConnectorLength = s
                        record.EndConnectorLength = e
                        record.FullAdvance = a
                        record.PartFlags = f
                        construction.GlyphAssembly.PartRecords.append(record)
                table.MathVariants.VertGlyphConstruction.append(construction)

            coverage = otl.buildCoverage(hvars.keys(), glyphMap)
            table.MathVariants.HorizGlyphCoverage = coverage
            table.MathVariants.HorizGlyphConstruction = []
            for name in coverage.glyphs:
                variants = hvars[name]
                construction = otTables.MathGlyphConstruction()
                construction.populateDefaults()
                construction.VariantCount = len(variants)
                construction.MathGlyphVariantRecord = []
                for variant in variants:
                    bbox = font[variant].getBounds(font)
                    record = otTables.MathGlyphVariantRecord()
                    record.VariantGlyph = variant
                    record.AdvanceMeasurement = int(bbox[-2] - bbox[0] + 1)
                    construction.MathGlyphVariantRecord.append(record)
                if name in hcomp:
                    construction.GlyphAssembly = otTables.GlyphAssembly()
                    construction.GlyphAssembly.ItalicsCorrection = otTables.MathValueRecord()
                    construction.GlyphAssembly.ItalicsCorrection.Value = 0
                    construction.GlyphAssembly.PartRecords = []
                    for comp in hcomp[name]:
                        record = otTables.GlyphPartRecord()
                        record.glyph = comp[0]
                        f, s, e, a = [int(v) for v in comp[1].split(",")]
                        record.StartConnectorLength = s
                        record.EndConnectorLength = e
                        record.FullAdvance = a
                        record.PartFlags = f
                        construction.GlyphAssembly.PartRecords.append(record)
                table.MathVariants.HorizGlyphConstruction.append(construction)


            otf["MATH"] = newTable("MATH")
            otf["MATH"].table = table
Пример #12
0
 def setInputCoverage_(self, glyphs, subtable):
     subtable.InputGlyphCount = len(glyphs)
     subtable.InputCoverage = []
     for g in glyphs:
         coverage = otl.buildCoverage(g, self.glyphMap)
         subtable.InputCoverage.append(coverage)
Пример #13
0
 def setLookAheadCoverage_(self, suffix, subtable):
     subtable.LookAheadGlyphCount = len(suffix)
     subtable.LookAheadCoverage = []
     for s in suffix:
         coverage = otl.buildCoverage(s, self.glyphMap)
         subtable.LookAheadCoverage.append(coverage)
Пример #14
0
 def setBacktrackCoverage_(self, prefix, subtable):
     subtable.BacktrackGlyphCount = len(prefix)
     subtable.BacktrackCoverage = []
     for p in reversed(prefix):
         coverage = otl.buildCoverage(p, self.glyphMap)
         subtable.BacktrackCoverage.append(coverage)