Beispiel #1
0
def testOuroborosKerning(rootPath, cleanUp=True):
    # that works, let's do it via MutatorMath
    path1, path2, path3 = makeTestFonts(rootPath)
    documentPath = os.path.join(rootPath, "kerningTest.designspace")

    doc = DesignSpaceDocumentWriter(documentPath, verbose=True)
    doc.addSource(
        path1, name="master_1", location=dict(width=0), copyLib=True, copyGroups=True, copyInfo=True, copyFeatures=True
    )
    doc.addSource(
        path2,
        name="master_2",
        location=dict(width=1000),
        copyLib=False,
        copyGroups=False,
        copyInfo=False,
        copyFeatures=False,
    )
    doc.startInstance(fileName=path3, familyName="TestInstance", styleName="Regular", location=dict(width=100))
    doc.writeKerning(location=dict(width=500))
    doc.endInstance()
    doc.save()

    # execute the designspace. Kerning errors should be tripped by the
    doc = DesignSpaceDocumentReader(documentPath, 2, roundGeometry=True, verbose=True, progressFunc=testingProgressFunc)
    doc.process(makeGlyphs=True, makeKerning=True, makeInfo=True)

    if cleanUp:
        # remove the mess
        shutil.rmtree(path1)
        shutil.rmtree(path2)
        shutil.rmtree(path3)

    return True
Beispiel #2
0
def testOuroborosKerning(rootPath, cleanUp=True):
    # that works, let's do it via MutatorMath
    path1, path2, path3 = makeTestFonts(rootPath)
    documentPath = os.path.join(rootPath, 'kerningTest.designspace')
    logPath = os.path.join(rootPath,"kerningTest.log")
    try:
        testLogFile = open(logPath, 'w')
        testLogFile.close()
    except:
        print "Can't make a logfile."

    doc = DesignSpaceDocumentWriter(documentPath, verbose=True)
    doc.addSource(
            path1,
            name="master_1", 
            location=dict(width=0), 
            copyLib=True,
            copyGroups=True,
            copyInfo=True, 
            copyFeatures=True,
            )
    doc.addSource(
            path2,
            name="master_2", 
            location=dict(width=1000), 
            copyLib=False,
            copyGroups=False,
            copyInfo=False, 
            copyFeatures=False,
            )
    doc.startInstance(fileName=path3,
            familyName="TestInstance",
            styleName="Regular",
            location=dict(width=100)
            )
    doc.writeKerning(location=dict(width=500))
    doc.endInstance()
    doc.save()

    # execute the designspace. Kerning errors should be tripped by the 
    doc = DesignSpaceDocumentReader(documentPath, 2, roundGeometry=True, verbose=True, logPath=logPath, progressFunc=testingProgressFunc)
    doc.process(makeGlyphs=True, makeKerning=True, makeInfo=True)

    # did we log the error?
    report = u"""invalidInstance.ufo:\nThese kerning pairs failed validation and have been removed:\nglyphOne, public.kern2.@MMK_R_two (-400) conflicts with public.kern1.@MMK_L_one, glyphThree (-250)\npublic.kern1.@MMK_L_one, glyphThree (-250) conflicts with glyphOne, public.kern2.@MMK_R_two (-400)"""
    log = open(logPath, 'r')
    logText = log.read()
    log.close()
    #print logText
    #assert report in logText

    if cleanUp:
        # remove the mess
        shutil.rmtree(path1)
        shutil.rmtree(path2)
        shutil.rmtree(path3)

    return True
Beispiel #3
0
def testOuroborosKerning(rootPath, cleanUp=True):
    # that works, let's do it via MutatorMath
    path1, path2, path3 = makeTestFonts(rootPath)
    documentPath = os.path.join(rootPath, 'kerningTest.designspace')
    logPath = os.path.join(rootPath,"kerningTest.log")
    try:
        testLogFile = open(logPath, 'w')
        testLogFile.close()
    except:
        print("Can't make a logfile.")

    doc = DesignSpaceDocumentWriter(documentPath, verbose=True)
    doc.addSource(
            path1,
            name="master_1", 
            location=dict(width=0), 
            copyLib=True,
            copyGroups=True,
            copyInfo=True, 
            copyFeatures=True,
            )
    doc.addSource(
            path2,
            name="master_2", 
            location=dict(width=1000), 
            copyLib=False,
            copyGroups=False,
            copyInfo=False, 
            copyFeatures=False,
            )
    doc.startInstance(fileName=path3,
            familyName="TestInstance",
            styleName="Regular",
            location=dict(width=100)
            )
    doc.writeKerning(location=dict(width=500))
    doc.endInstance()
    doc.save()

    # execute the designspace. Kerning errors should be tripped by the 
    doc = DesignSpaceDocumentReader(documentPath, 2, roundGeometry=True, verbose=True, logPath=logPath, progressFunc=testingProgressFunc)
    doc.process(makeGlyphs=True, makeKerning=True, makeInfo=True)

    # did we log the error?
    report = u"""invalidInstance.ufo:\nThese kerning pairs failed validation and have been removed:\nglyphOne, public.kern2.@MMK_R_two (-400) conflicts with public.kern1.@MMK_L_one, glyphThree (-250)\npublic.kern1.@MMK_L_one, glyphThree (-250) conflicts with glyphOne, public.kern2.@MMK_R_two (-400)"""
    log = open(logPath, 'r')
    logText = log.read()
    log.close()
    #print logText
    #assert report in logText

    if cleanUp:
        # remove the mess
        shutil.rmtree(path1)
        shutil.rmtree(path2)
        shutil.rmtree(path3)

    return True
Beispiel #4
0
def testGeometry(rootPath, cleanUp=True):
    # that works, let's do it via MutatorMath
    path1, path2, path3, path4, path5 = makeTestFonts(rootPath)
    documentPath = os.path.join(rootPath, "geometryTest.designspace")
    logPath = os.path.join(rootPath, "geometryTest.log")
    try:
        testLogFile = open(logPath, "w")
        testLogFile.close()
    except:
        print "Can't make a logfile."

    doc = DesignSpaceDocumentWriter(documentPath, verbose=True)
    doc.addSource(
        path1, name="master_1", location=dict(width=0), copyLib=True, copyGroups=True, copyInfo=True, copyFeatures=True
    )
    doc.addSource(
        path2,
        name="master_2",
        location=dict(width=1000),
        copyLib=False,
        copyGroups=False,
        copyInfo=False,
        copyFeatures=False,
    )
    doc.startInstance(fileName=path3, familyName="TestInstance", styleName="Regular", location=dict(width=500))
    doc.endInstance()
    doc.startInstance(
        fileName=path4, familyName="TestInstance", styleName="Anisotropic1", location=dict(width=(0, 1000))
    )
    doc.endInstance()
    doc.startInstance(
        fileName=path5, familyName="TestInstance", styleName="Anisotropic2", location=dict(width=(1000, 0))
    )
    doc.endInstance()
    doc.save()

    # execute the designspace.
    doc = DesignSpaceDocumentReader(
        documentPath, 2, roundGeometry=True, verbose=True, logPath=logPath, progressFunc=testingProgressFunc
    )
    doc.process(makeGlyphs=True, makeKerning=False, makeInfo=True)

    r1 = Font(path3)
    assert r1["glyphOne"].bounds == (0, 0, 300, 300)

    r2 = Font(path4)
    assert r2["glyphOne"].bounds == (0, 0, 100, 500)

    r3 = Font(path5)
    assert r3["glyphOne"].bounds == (0, 0, 500, 100)

    if cleanUp:
        # remove the mess
        shutil.rmtree(path1)
        shutil.rmtree(path2)
        shutil.rmtree(path3)

    return True
Beispiel #5
0
def testOuroborosKerning(rootPath, cleanUp=True):
    # that works, let's do it via MutatorMath
    path1, path2, path3 = makeTestFonts(rootPath)
    documentPath = os.path.join(rootPath, 'kerningTest.designspace')

    doc = DesignSpaceDocumentWriter(documentPath, verbose=True)
    doc.addSource(
        path1,
        name="master_1",
        location=dict(width=0),
        copyLib=True,
        copyGroups=True,
        copyInfo=True,
        copyFeatures=True,
    )
    doc.addSource(
        path2,
        name="master_2",
        location=dict(width=1000),
        copyLib=False,
        copyGroups=False,
        copyInfo=False,
        copyFeatures=False,
    )
    doc.startInstance(fileName=path3,
                      familyName="TestInstance",
                      styleName="Regular",
                      location=dict(width=100))
    doc.writeKerning(location=dict(width=500))
    doc.endInstance()
    doc.save()

    # execute the designspace. Kerning errors should be tripped by the
    doc = DesignSpaceDocumentReader(documentPath,
                                    2,
                                    roundGeometry=True,
                                    verbose=True,
                                    progressFunc=testingProgressFunc)
    doc.process(makeGlyphs=True, makeKerning=True, makeInfo=True)

    if cleanUp:
        # remove the mess
        shutil.rmtree(path1)
        shutil.rmtree(path2)
        shutil.rmtree(path3)

    return True

    def test1():
        """
def makeInstances(stepsWeight, stepsWidth):
    doc = DesignSpaceDocumentWriter(designSpacePath, verbose=True)

    doc.addSource(os.path.join(mutatorSansFolder,
                               "MutatorSansLightCondensed.ufo"),
                  name="LightCondensed",
                  location=dict(weight=0, width=0),
                  copyInfo=True,
                  familyName="MutatorSans",
                  styleName="LightCondensed")

    doc.addSource(os.path.join(mutatorSansFolder, "MutatorSansLightWide.ufo"),
                  name="LightWide",
                  location=dict(weight=0, width=1))

    doc.addSource(os.path.join(mutatorSansFolder,
                               "MutatorSansBoldCondensed.ufo"),
                  name="BoldCondensed",
                  location=dict(weight=1, width=0))

    doc.addSource(os.path.join(mutatorSansFolder, "MutatorSansBoldWide.ufo"),
                  name="BoldWide",
                  location=dict(weight=1, width=1))

    for i in range(stepsWeight):
        wt = i * 1.0 / (stepsWeight - 1)
        for j in range(stepsWidth):
            wd = j * 1.0 / (stepsWidth - 1)
            doc.startInstance(fileName=os.path.join(
                ufosFolder, "MutatorSansInstance_%s-%s.ufo" %
                (int(wt * 1000), int(wd * 1000))),
                              familyName="MutatorSansExample",
                              styleName="%s-%s" %
                              (int(wt * 1000), int(wd * 1000)),
                              location=dict(weight=wt, width=wd))
            doc.endInstance()

    doc.save()

    doc = DesignSpaceDocumentReader(designSpacePath,
                                    3,
                                    roundGeometry=True,
                                    verbose=False)
    doc.process(makeGlyphs=True, makeKerning=False, makeInfo=False)
Beispiel #7
0
def testMutingOptions(rootPath, cleanUp=True):
    # that works, let's do it via MutatorMath
    # path1 and path2 are masters. path3 is the instance
    path1, path2, path3 = makeTestFonts(rootPath)
    documentPath = os.path.join(rootPath, 'mutingTest.designspace')
    logPath = os.path.join(rootPath,"mutingTest.log")

    try:
        testLogFile = open(logPath, 'w')
        testLogFile.close()
    except:
        print "Can't make a logfile."

    doc = DesignSpaceDocumentWriter(documentPath, verbose=True)
    doc.addSource(
            path1,
            name="master_1", 
            location=dict(width=0), 
            copyLib=True,
            copyGroups=True,
            copyInfo=True, 
            copyFeatures=True,
            muteKerning=True
            )
    doc.addSource(
            path2,
            name="master_2", 
            location=dict(width=1000), 
            copyLib=False,
            copyGroups=False,
            copyInfo=False, 
            copyFeatures=False,
            muteInfo=True,
            mutedGlyphNames=['glyphThree']  # mute glyphThree in master 1
            )
    doc.startInstance(fileName=path3,
            familyName="TestInstance",
            styleName="Regular",
            location=dict(width=500)
            )
    doc.writeGlyph('glyphFour', mute=True)  # mute glyphFour in the instance
    doc.writeKerning()
    doc.writeInfo()
    doc.endInstance()
    doc.save()

    # execute the designspace. 
    doc = DesignSpaceDocumentReader(documentPath, 2, roundGeometry=True, verbose=True, logPath=logPath, progressFunc=testingProgressFunc)
    doc.process(makeGlyphs=True, makeKerning=True, makeInfo=True)

    # look at the results
    m1 = Font(path1)
    m2 = Font(path2)
    r = Font(path3)
    # 
    # the glyphThree master was muted in the second master
    # so the instance glyphThree should be the same as the first master:
    assert r['glyphThree'].bounds == m1['glyphThree'].bounds
    # we muted glyphFour in the instance.
    # so it should not be part of the instance UFO:
    assert "glyphFour" not in r
    # font.info is muted for master2, so the instance has to have the values from master 1
    assert r.info.unitsPerEm == m1.info.unitsPerEm
    # kerning is muted for master1, so the instance has to have the kerning from master 2
    assert r.kerning[('glyphOne', 'glyphOne')] == m2.kerning[('glyphOne', 'glyphOne')]

    if cleanUp:
        # remove the mess
        try:
            shutil.rmtree(path1)
            shutil.rmtree(path2)
            shutil.rmtree(path3)
        except:
            pass

    return True
Beispiel #8
0
def testMutingOptions(rootPath, cleanUp=True):
    # that works, let's do it via MutatorMath
    # path1 and path2 are masters. path3 is the instance
    path1, path2, path3 = makeTestFonts(rootPath)
    documentPath = os.path.join(rootPath, 'mutingTest.designspace')

    doc = DesignSpaceDocumentWriter(documentPath, verbose=True)
    doc.addSource(path1,
                  name="master_1",
                  location=dict(width=0),
                  copyLib=True,
                  copyGroups=True,
                  copyInfo=True,
                  copyFeatures=True,
                  muteKerning=True)
    doc.addSource(
        path2,
        name="master_2",
        location=dict(width=1000),
        copyLib=False,
        copyGroups=False,
        copyInfo=False,
        copyFeatures=False,
        muteInfo=True,
        mutedGlyphNames=['glyphThree']  # mute glyphThree in master 1
    )
    doc.startInstance(fileName=path3,
                      familyName="TestInstance",
                      styleName="Regular",
                      location=dict(width=500))
    doc.writeGlyph('glyphFour', mute=True)  # mute glyphFour in the instance
    doc.writeKerning()
    doc.writeInfo()
    doc.endInstance()
    doc.save()

    # execute the designspace.
    doc = DesignSpaceDocumentReader(documentPath,
                                    2,
                                    roundGeometry=True,
                                    verbose=True,
                                    progressFunc=testingProgressFunc)
    doc.process(makeGlyphs=True, makeKerning=True, makeInfo=True)

    # look at the results
    m1 = Font(path1)
    m2 = Font(path2)
    r = Font(path3)
    #
    # the glyphThree master was muted in the second master
    # so the instance glyphThree should be the same as the first master:
    assert r['glyphThree'].bounds == m1['glyphThree'].bounds
    # we muted glyphFour in the instance.
    # so it should not be part of the instance UFO:
    assert "glyphFour" not in r
    # font.info is muted for master2, so the instance has to have the values from master 1
    assert r.info.unitsPerEm == m1.info.unitsPerEm
    # kerning is muted for master1, so the instance has to have the kerning from master 2
    assert r.kerning[('glyphOne', 'glyphOne')] == m2.kerning[('glyphOne',
                                                              'glyphOne')]

    if cleanUp:
        # remove the mess
        try:
            shutil.rmtree(path1)
            shutil.rmtree(path2)
            shutil.rmtree(path3)
        except:
            pass

    return True
Beispiel #9
0
def testGeometry(rootPath, cleanUp=True):
    # that works, let's do it via MutatorMath
    path1, path2, path3, path4, path5 = makeTestFonts(rootPath)
    documentPath = os.path.join(rootPath, 'geometryTest.designspace')

    doc = DesignSpaceDocumentWriter(documentPath, verbose=True)
    doc.addSource(
            path1,
            name="master_1", 
            location=dict(width=0), 
            copyLib=True,
            copyGroups=True,
            copyInfo=True, 
            copyFeatures=True,
            )
    doc.addSource(
            path2,
            name="master_2", 
            location=dict(width=1000), 
            copyLib=False,
            copyGroups=False,
            copyInfo=False, 
            copyFeatures=False,
            )
    doc.startInstance(fileName=path3,
            familyName="TestInstance",
            styleName="Regular",
            location=dict(width=500)
            )
    doc.endInstance()
    doc.startInstance(fileName=path4,
            familyName="TestInstance",
            styleName="Anisotropic1",
            location=dict(width=(0, 1000))
            )
    doc.endInstance()
    doc.startInstance(fileName=path5,
            familyName="TestInstance",
            styleName="Anisotropic2",
            location=dict(width=(1000, 0))
            )
    doc.endInstance()
    doc.save()

    # execute the designspace.
    doc = DesignSpaceDocumentReader(documentPath, 2, roundGeometry=True, verbose=True, progressFunc=testingProgressFunc)
    doc.process(makeGlyphs=True, makeKerning=False, makeInfo=True)

    r1 = Font(path3)
    assert r1['glyphOne'].bounds == (0, 0, 300, 300)

    r2 = Font(path4)
    assert r2['glyphOne'].bounds == (0, 0, 100, 500)

    r3 = Font(path5)
    assert r3['glyphOne'].bounds == (0, 0, 500, 100)

    if cleanUp:
        # remove the mess
        shutil.rmtree(path1)
        shutil.rmtree(path2)
        shutil.rmtree(path3)

    return True
    #	dict(fileName="instances/Amstelvar-Italic-opsz144-wdth50.ufo", location=dict(wght=400, wdth=75, opsz=144), styleName="opsz144-wdth50", familyName=familyName, postScriptFontName=None, styleMapFamilyName=None, styleMapStyleName=None),
]
for instance in instances:
    doc.startInstance(**instance)
    doc.writeInfo()
    doc.writeKerning()
    doc.endInstance()

doc.save()
# read and process the designspace
doc = DesignSpaceDocumentReader(tmpDesignSpace,
                                ufoVersion=2,
                                roundGeometry=False,
                                verbose=False)
print("Reading DesignSpace...")
doc.process(makeGlyphs=True, makeKerning=True, makeInfo=True)
os.remove(tmpDesignSpace)  # clean up

# update the instances with the source fonts
# print str(instances) + ' instances! '
for instance in instances:
    fileName = os.path.basename(instance["fileName"])
    source_path = os.path.join(src_dir, fileName)
    instance_path = os.path.join(instance_dir, fileName)
    source_font = Font(source_path)
    instance_font = Font(instance_path)
    # insert the source glyphs in the instance font
    for glyph in source_font:
        instance_font.insertGlyph(glyph)
    master_path = os.path.join(master_dir, fileName)
    instance_font.save(master_path)