Esempio n. 1
1
def generateFont(outputFile, listGlyphs):
    print 'glyph files: ' + str(len(listGlyphs))
    font = fontforge.font()
    font.fontname = os.path.splitext(os.path.basename(outputFile))[0]
    dict_glyphmaps = {}
    # add chars
    for fileName in listGlyphs:
        #codepoint = 
        char = font.createChar(int(fileName.split('.')[0]))
        char.importOutlines(fileName)
        # if importOutlines not changed the char, probably the char contains errors
        if not char.changed:
            print 'file with error: ' + fileName
            continue
        # align in left
        char.left_side_bearing = 0
        # set width
        x_max = char.boundingBox()[2]
        char.width = char.vwidth = x_max
        # add glyphmap
        basename = os.path.splitext(os.path.basename(fileName))[0]
        dict_glyphmaps[basename] = int(fileName.split('.')[0])
        #codePoint += 1
    font.generate(outputFile)
    print 'Generate font: ' + outputFile
    return dict_glyphmaps
Esempio n. 2
0
  def convert(self, theme):
    fontname = self.options.fontname
    if not fontname:
      fontname = theme
    file_prefix = path.join(self.options.output, theme)
    # create empty font
    self.font = font = fontforge.font()

    #file_prefix = 'icons'

    # set font names
    font.fontname = fontname
    font.familyname = self.options.familyname
    font.fullname = ' '.join([ self.options.familyname, fontname ])

    # import svgs
    files = self.collect_glyphs(theme)
    for f in files:
      self.import_glyph(f)

    #font.generate("fonts/%s.pfb" % file_prefix, flags=["tfm", "afm"]) # type1 with tfm/afm
    #font.generate("fonts/%s.otf" % file_prefix) # opentype
    font.generate("%s.ttf" % file_prefix) # truetype
    font.generate("%s.svg" % file_prefix) # svg
    font.generate("%s.woff" % file_prefix) # svg
    fontforge.printSetup('pdf-file', '%s-preview.pdf' % file_prefix)
    font.printSample('fontdisplay', 14)
Esempio n. 3
0
def create(aName):
    print("Generating %s.otf..." % aName, end="")

    # Create a new font.
    font = fontforge.font()
    font.encoding = "UnicodeFull"
    font.fontname = aName
    font.familyname = aName
    font.fullname = aName

    # License the font under OFL.
    font.copyright = "Copyright (c) 2016 Igalia S.L."
    with open('OFL.txt', 'r') as OFLFile:
        lang = "English (US)"
        font.sfnt_names = (
            (lang, 'Copyright', OFLFile.read()),
            (lang, 'License URL', 'http://scripts.sil.org/OFL'),
            (lang, 'Family', aName),
            (lang, 'SubFamily', 'Regular'),
            (lang, 'Fullname', aName),
            (lang, 'PostScriptName', aName)
        )

    # Create a space character.
    g = font.createChar(ord(" "), "space")
    g.width = em
    return font
Esempio n. 4
0
def generateTuringFont(myFont, cipher, newFontName):
	plain = "abcdefghijklmnopqrstuvwxyz"
	
	# Create a font to use as auxiliar variable
	temporal = fontforge.font()
		
	# Change the order of the letters
	plain = plain + plain.upper()
	cipher = cipher + cipher.upper()
	for i in range(len(plain)):
		myFont.selection.select( plain[i] )
		myFont.copy()                                   
		temporal.selection.select( cipher[i] )
		temporal.paste()

	# Copy back the letters in the auxiliar font to the original font.
	temporal.selection.select(("ranges",None),"a","z")
	myFont.selection.select(("ranges",None),"a","z")
	temporal.copy()
	myFont.paste()
	temporal.selection.select(("ranges",None),"A","Z")
	myFont.selection.select(("ranges",None),"A","Z")
	temporal.copy()
	myFont.paste()

	# Save new font
	myFont.fontname = newFontName
	myFont.familyname = newFontName
	myFont.fullname = newFontName
	myFont.save(newFontName + ".sfd")
	temporal.close()
def generate_font_project_file(meta, outfile):
    font = fontforge.font()
    familyname = "STDevGen_1stMix"
    font.familyname = familyname
    font.fullname = familyname + "-Normal"
    font.fontname = familyname
    for em in meta:
        codepoint = em["loose"].get("codepoint",None)
        if codepoint is None:
            # Some of the glyphs are not intended as actual characters.
            continue

        basename = em["file_basename"]
        width = em["loose"].get("width",0)
        lines = em["loose"].get("lines",[])

        glyph = font.createChar(codepoint)

        # Reportedly, importOutlines() doesn't like importing files without
        # any paths. If there are none, we can just skip it anyway.
        draw = False
        for line in lines:
            draw = bool(line.get("draw", True))
            if draw:
                break

        if draw:
            glyph.importOutlines(tight_svg_filename(basename))
        else:
            print >> sys.stderr, "Note: %s rendered as spacing-only" % codepoint

        glyph.width = width
        glyph.simplify()
    font.save(outfile)
Esempio n. 6
0
def main(filename, fontname, fullname):

    if (not filename.endswith('.svg')):
        filename = filename + '.svg'

    font = fontforge.font()

    font.fontname = fontname
    font.fullname = fullname
    font.familyname = fullname

    # Create new glyph
    glyph = font.createChar(0)

    # Get SVG
    glyph.importOutlines(filename)

    # Make the glyph rest on the baseline
    ymin = glyph.boundingBox()[1]
    glyph.transform([1, 0, 0, 1, 0, -ymin])

    # Set glyph side bearings, can be any value or even 0
    glyph.left_side_bearing = glyph.right_side_bearing = 10

    # font.generate("foobar.pfb", flags=["tfm", "afm"])  # Type1 with tfm/afm
    font.generate(split_filename(filename) + '.otf')  # OpenType
    font.generate(split_filename(filename) + '.ttf')  # TrueType
Esempio n. 7
0
def main():
    global newfont, oldfont, fontName
    newfont = fontforge.font()
#    newfont.em = 2048
    oldfont = fontforge.open("Gregoria.otf")
    fontName = "gregoria"
    newfont.encoding="ISO10646-1"
    newfont.fontname="gregoriao"
    newfont.fullname="gregoriao"
    newfont.familyname="gregoriao"
    newfont.weight=oldfont.weight
    newfont.copyright=oldfont.copyright
    first_step()
    adjustAdditionalGlyphs()
    oldfont.close()
    oldfont = fontforge.open("Gregoria-Deminutae.otf")
    fontName="gregoria-deminutae"
    first_step()
    adjustAdditionalGlyphs()
    oldfont.close()
    oldfont = fontforge.open("Gregoria-Auctae.otf")
    fontName="gregoria-auctae"
    first_step()
    adjustAdditionalGlyphs()
    oldfont.close()
    newfont.em = 2048
    newfont.generate("gregoriao.ttf")
    newfont.close()
Esempio n. 8
0
    def build_font(self, dir_name, familyname, fontname, fullname):
        '''Builds the font file.'''
        self.font = font = fontforge.font()
    #    height = 32
        font.descent = 4 * SQUARE_SIZE
        font.ascent = 8 * SQUARE_SIZE
    #    font.em = 28
    #    font.design_size = 12
        font.upos = -2 * SQUARE_SIZE
        font.uwidth = SQUARE_SIZE
        font.fontname = fontname
        font.familyname = familyname
        font.fullname = fullname
        font.encoding = 'unicode'

        if 'bold' in fontname.lower():
            font.weight = 'Bold'

        if 'oblique' in fontname.lower():
            font.italicangle = -10.0

        if 'boldoblique' in fontname.lower():
            font.appendSFNTName(0x0409, 'SubFamily', 'Bold Oblique')

        font.addLookup('Anchors', 'gpos_mark2base', (), (
            ("mark", (("DFLT", ("dflt")),)),
        ))
        font.addLookupSubtable('Anchors', 'DiacriticTop')
        font.addAnchorClass('DiacriticTop', 'Top')
        font.addLookupSubtable('Anchors', 'DiacriticBottom')
        font.addAnchorClass('DiacriticBottom', 'Bottom')

        reader = Reader(
            *sorted(kitabyte.reader.get_font_def_filenames(dir_name)))

        deferred_glyph_defs = []

        for glyph_def in kitabyte.reader.read_font_def(reader):
            if isinstance(glyph_def, Glyph):
                try:
                    _logger.debug('Processing u+%x %s', glyph_def.char_code,
                        fontforge.nameFromUnicode(glyph_def.char_code))
                    self._make_glyph(glyph_def)
                except (EnvironmentError, ValueError):
                    _logger.debug('Deferring glyph u+%x %s',
                        glyph_def.char_code,
                        fontforge.nameFromUnicode(glyph_def.char_code))
                    deferred_glyph_defs.append(glyph_def)

        for glyph_def in deferred_glyph_defs:
            _logger.debug('Processing u+%x %s', glyph_def.char_code,
                    fontforge.nameFromUnicode(glyph_def.char_code))
            self._make_glyph(glyph_def)

        font.selection.all()
        font.removeOverlap()
        font.simplify()
        font.correctDirection()

        return font
Esempio n. 9
0
def generate(filepath, name, mapFile, output):
    convertedPath = filepath + "/converted"
    isExists = os.path.exists(convertedPath)
    if not isExists:
        os.makedirs(convertedPath)

    convert2pbm(filepath)
    convert2svg(filepath)
    charMap = {}
    file = open(filepath + '/' + mapFile)
    list_of_all_the_lines = file.read().splitlines()
    # 文件名到字符的映射关系
    for line in list_of_all_the_lines:
        chars = line.split(" ")
        charMap[chars[0]] = chars[1]
    #

    font = fontforge.font()
    family_name = "tesseracthand"
    style_name = name
    font.familyname = family_name
    font.fullname = family_name + "-" + style_name
    font.fontname = family_name + "-" + style_name
    for filename in os.listdir(filepath):
        if filename.endswith('.png'):
            fileRealName = filename.split('.')[0]
            char = charMap[fileRealName]
            glyph = font.createMappedChar(char)
            glyph.importOutlines("{0}/converted/{1}.svg".format(filepath, fileRealName))
    font.generate(output + '/tesseracthand.ttf')
    return True
Esempio n. 10
0
 def __init__ (self, option):
     """ The `__init__` constructor function inits the font's option. """
     if not option.input:
         self.font = fontforge.font();
     else:
         self.font = fontforge.open(option.input);
         self.font.encoding = 'UnicodeBmp';
         self.font.version = '2.000;PS 1;hotconv 1.0.49;makeotf.lib2.0.14853';
         self.font.weight = 'Book'
         self.font.fontname = option.name;
         self.font.familyname = option.name;
         self.font.fullname = option.name;
         self.font.ascent = 1000;
         self.font.descent = 200;
         self.font.em = 1000;
         self.font.addLookup('liga', 'gsub_ligature', (), (
             (
                 'liga',
                 (
                     ('latn', ('dflt')),
                 )
             ),
         ));
         self.font.addLookupSubtable('liga', 'liga');
     self.output = option.output;
     self.index = option.index;
Esempio n. 11
0
    def convert_main(self, config_file, directory, outdir, metadata):
        try:
            self.font = fontforge.font()
        except:
            import fontforge

        with open(config_file) as f:
            self.config = json.load(f)
        self.metadata = json.loads(metadata) or {}

        self.font = fontforge.font()
        self.unicode_mapping = {}
        self.set_properties()
        self.add_glyphs(directory)

        # bearing table
        self.set_bearings(self.config["typography_parameters"].get(
            "bearing_table", {}))

        # kerning table
        self.set_kerning(self.config["typography_parameters"].get(
            "kerning_table", {}))

        # Generate font and save as a .ttf file
        filename = self.metadata.get(
            "filename", None) or self.config["props"].get("filename", None)
        self.generate_font_file(str(filename), outdir, config_file)
Esempio n. 12
0
def main():
    name = "Bhaataan-Gothic"
    font = fontforge.font()
    font.encoding = "UnicodeBmp"
    font.familyname = name
    font.fontname = name
    font.fullname = name

    font.ascent = 1000
    font.descent = 0

    add_anchorclasses(font)
    add_substitution(font)

    add_punctuations(font)
    add_basic_consonants(font)
    add_vowels(font)
    add_with_o_consonants(font)

    add_kerning(font)
    add_contextual_chaining(font)

    font.em = 1024

    font.save(name)
    font.generate("%s.ttf" % name)
    font.generate("%s.woff" % name)
Esempio n. 13
0
    def __init__(self, source):
        self._new_font = fontforge.font()


        # Set up the new font shell
        self._new_font.encoding = 'UnicodeFull'
        self._new_font.fontname = source.font_name
        self._new_font.fullname = source.font_name
        self._new_font.familyname = source.font_name
        self._new_font.ascent = 850
        self._new_font.em = 1792
        self._new_font.descent = 256
        self._new_font.gasp = ((65535, (
            'gridfit',
            'antialias',
            'symmetric-smoothing',
            'gridfit+smoothing')),)
        self._new_font.gasp_version = 1
        self._new_font.hhea_descent = -34
        self._new_font.hhea_linegap = 0
        self._new_font.os2_codepages = (1, 0)
        self._new_font.os2_fstype = 4
        self._new_font.os2_panose = (0, 0, 0, 0, 0, 0, 0, 0, 0, 0)
        self._new_font.os2_strikeypos = 1075
        self._new_font.os2_strikeysize = 90
        self._new_font.os2_subyoff = 134
        self._new_font.os2_subysize = 1075
        self._new_font.os2_supyoff = 627
        self._new_font.os2_supysize = 1075
        self._new_font.os2_typolinegap = 0
        self._new_font.weight = 'Book'

        # Fire up the reference font
        self._source_font = fontforge.open(source.tff_file)
        self._source_font.encoding = 'UnicodeFull'
Esempio n. 14
0
def generate(fontname, files):
    filename = fontname + '.otb'
    newfont = fontforge.font()

    for file in files:
        if args.verbose:
            print(f'{filename}: {file}: importing bitmap strikes',
                  file=sys.stderr)

        try:
            import_bitmap(newfont, file)

        except ValueError:
            print(
                f'opentype-bitmap: warning: {file}: file must end with '
                '.pcf.gz, bdf.gz, .pcf, or .bdf',
                file=sys.stderr)

        except OSError:
            print(f'opentype-bitmap: warning: {file}: invalid bitmap font',
                  file=sys.stderr)

    if newfont.changed:
        newfont.generate(filename, 'otb')
        print(f'{filename}')
Esempio n. 15
0
def main():
    font = fontforge.font()
    font.descent = 1 * SQUARE_SIZE
    font.ascent = 8 * SQUARE_SIZE
    font.upos = -1 * SQUARE_SIZE
    font.uwidth = SQUARE_SIZE
    font.fontname = 'pkmn_gb_en_tppocr-regular'
    font.familyname = 'pkmn_gb_en_tppocr'
    font.fullname = 'PkMn GB English TPPOCR Regular'
    font.encoding = 'unicode'

    char_pixel_data = get_pixel_data()
    red_char_pixel_data = get_pixel_data('red_font.png', rows=7)

    def draw_glyph(char, char_pixel_data):
        glyph = font.createChar(ord(char))
        glyph.clear()
        pixel_data = char_pixel_data[char_row][char_col]
        pen = glyph.glyphPen()

        for tile_y, tile_x in itertools.product(range(8), range(8)):
            if pixel_data[tile_y * 8 + tile_x] != 0:
                continue

            x = tile_x * SQUARE_SIZE
            y = 7 * SQUARE_SIZE - tile_y * SQUARE_SIZE

            # Add +/-1 to slightly increase the block size so each block
            # will slightly overlap and ensure no points overlap.
            pen.moveTo((x - 1, y - 1))
            pen.lineTo((x + SQUARE_SIZE + 1, y - 1))
            pen.lineTo((x + SQUARE_SIZE + 1, y + SQUARE_SIZE + 1))
            pen.lineTo((x - 1, y + SQUARE_SIZE + 1))
            pen.closePath()

        glyph.width = SQUARE_SIZE * 8

    for char_row, row in enumerate(CHARS):
        for char_col, char in enumerate(row):
            if char == ' ':
                continue

            draw_glyph(char, char_pixel_data)

            if char == 'c':
                draw_glyph(u'ċ', red_char_pixel_data)

    glyph = font.createChar(ord(' '))
    glyph.width = SQUARE_SIZE * 8

    font.selection.all()
    font.removeOverlap()
    font.simplify()
    font.correctDirection()

    font.version = VERSION
    font.copyright = COPYRIGHT

    font.generate(font.fontname + '.ttf', flags=('no-hints',))
Esempio n. 16
0
def create_font():
    """create a minimal FontForge font"""
    font = fontforge.font()
    # font.addLookup("belowbaseline","gpos_mark2base",0,
    #                [["blwm",[["deva",["dflt"]]]]])
    # font.addLookupSubtable("belowbaseline", "belowbasesub")
    # font.addAnchorClass("belowbasesub", "sub")
    return font
Esempio n. 17
0
    def __init__(self, kerning=15):
        #initialize the font
        self.font = fontforge.font()
        # starts  in the character code for !
        self.font_character_index = 33

        #other fontforge options:
        self.kerning = kerning
Esempio n. 18
0
def create_font():
    """create a minimal FontForge font"""
    font = fontforge.font()
    #font.addLookup("belowbaseline","gpos_mark2base",0,
    #                [["blwm",[["deva",["dflt"]]]]])
    #font.addLookupSubtable("belowbaseline", "belowbasesub")
    #font.addAnchorClass("belowbasesub", "sub")
    return font
Esempio n. 19
0
 def __init__(self, kerning=15):
     #initialize the font
     self.font = fontforge.font()
     # starts  in the character code for !
     self.font_character_index = 33
     
     #other fontforge options:
     self.kerning = kerning
Esempio n. 20
0
 def generateFont(fontName: str,
                  text: str,
                  saveType: int = WOFF_TYPE,
                  flags: int = 0) -> str:
     try:
         fontLocation = getFontLocation(fontName)
         if fontLocation is None:
             return None
         if saveType <= 0:
             return None
         if flags & ASCII_SUPPORT:
             charList = [chr(i) for i in range(32, 127)]
         else:
             charList = []
         for i in text:
             if i not in charList:
                 charList.append(i)
         fn = f"fonts/{md5(fontName)}_{sha256(''.join(charList))}"
         cont = False
         if saveType & TTF_TYPE and not exists(f"{fn}.ttf"):
             cont = True
         if saveType & WOFF_TYPE and not exists(f"{fn}.woff"):
             cont = True
         if saveType & WOFF2_TYPE and not exists(f"{fn}.woff2"):
             cont = True
         if saveType & EOT_TYPE and not exists(f"{fn}.eot"):
             cont = True
         if not cont:
             return fn
         print(fontLocation)
         ft: font = openfont(fontLocation)
         print(ft.encoding)
         nf = font()
         nf.encoding = 'UnicodeBMP'
         for char in charList:
             char = ord(char)
             ft.selection.select(("more", None), char)
             nf.selection.select(("more", None), char)
         ft.copy()
         nf.paste()
         if not exists('fonts/'):
             mkdir('fonts/')
         if saveType & TTF_TYPE:
             nf.generate(f"{fn}.ttf", flags="opentype")
         if saveType & WOFF_TYPE:
             nf.generate(f"{fn}.woff")
         if saveType & WOFF2_TYPE:
             nf.generate(f"{fn}.woff2")
         if saveType & EOT_TYPE:
             nf.generate(f"{fn}.eot")
         nf.close()
         return fn
     except Exception as e:
         s = settings()
         s.ReadSettings()
         if s.debug:
             raise e
         return None
def main(config_file):
    config = loadConfig(config_file)
    os.chdir(os.path.dirname(config_file) or '.')
    font = fontforge.font()
    setProperties(font, config)
    addGlyphs(font, config)
    for outfile in config['output']:
        sys.stderr.write('Generating %s...\n' % outfile)
        font.generate(outfile)
Esempio n. 22
0
    def __init__(self, code_base=1):
        f = fontforge.font()
        f.encoding = 'UnicodeFull'
        f.design_size = 16
        f.em = 512
        f.ascent = 448
        #  f.design_sizescent = 64

        self.f = f
        self.char_code = code_base
def createFont():
  font = fontforge.font()
  font.fontname = fontname
  font.fullname = fullname
  font.ascent = ascent
  font.descent = descent
  font.em = em
  font.encoding = encoding
  font.save(buildPath+fontname+".sfd")
  return font
Esempio n. 24
0
def make_font(options: argparse.Namespace) -> None:
    font = fontforge.font()
    font.familyname = 'Duployan'
    font.fontname = font.familyname
    font.fullname = font.familyname
    font.encoding = 'UnicodeFull'
    builder = duployan.Builder(font, options.bold, options.noto)
    builder.augment()
    build_font(options, builder.font)
    patch_fonttools()
    tweak_font(options, builder)
def configFont(config_file, user):
    config = loadConfig(config_file)
    os.chdir(os.path.dirname(config_file) or '.')
    font = fontforge.font()
    setProperties(font, config)
    addGlyphs(font, config)
    i = 0
    while os.path.exists('my_fonts/hand-spoken-' + user + '-' + str(i) +
                         '.ttf'):
        i += 1
    font.generate('my_fonts/hand-spoken-' + user + '-' + str(i) + '.ttf')
def main():
    try:
        opts, args = getopt.getopt(sys.argv[1:], '', ['font='])
    except getopt.GetoptError as err:
        print >> sys.stderr, str(err)
        sys.exit(1)
    
    font_file = None
    
    for o, a in opts:
        if o == '--font':
            font_file = a
    
    if font_file == None:
        print >> sys.stderr, "no font file"
        sys.exit(1)
    
    chars = set([])
    
    for fi in args:
        f = codecs.open(fi, encoding='utf-8')
        for line in f:
            for c in line:
                chars.add(c)
        f.close()
    
    font = fontforge.open(font_file)
    
    ft_out = fontforge.font()
    ft_out.fontname = font.fontname
    ft_out.familyname = font.familyname
    ft_out.fullname = font.fullname
    ft_out.encoding = font.encoding
    
    for c in chars:
        try:
            uc = font[ord(c)]
            print ord(c),
            font.selection.select(uc)
            font.copy()
            ft_out.selection.select(uc)
            ft_out.paste()
        except TypeError:
            print "not found",
            pass
        print
    
    ft_out.generate("partial.ttf")
    print ft_out.fontname
    print ft_out.familyname
    print ft_out.fullname
    
    font.close()
    ft_out.close()
Esempio n. 27
0
def init(options = {}, extensions = {}, **args):
    if 'svg' not in extensions:
        print 'font extension requires svg extension'
        exit(1)
    options['_font'] = font = fontforge.font()
    font.copyright = options['font-copyright']
    font.familyname = options['font-family']
    font.fondname = options['font-family']
    font.fontname = options['font-family']
    font.fullname = options['font-family']
    font.weight = str(options['font-weight'])
    font.em = 1000
Esempio n. 28
0
    def __init__(self, paramsFile, svgdir, outname) :
        self.params = ConfigParser.SafeConfigParser()
        parameters = codecs.open(paramsFile, "r", "UTF-8")
        self.params.readfp(parameters)
        self.svgDir = svgdir
        self.font = fontforge.font()
        self.font.encoding = 'UnicodeBmp' # 1 USC-2 Unicode BMP
        self.font.fontname = self.params.get("Font", "enFamilyName")
        self.font.fullname = self.params.get("Font", "enFullName")
        self.font.familyname = self.params.get("Font", "enFamilyName")
        sfntNameList = list(self.font.sfnt_names[:])
        subFamily = self.params.get("Font", "enSubFamily")
        self.font.sfnt_names = (('English (US)', 'Copyright', self.params.get("Font", 'copyright')), \
            ('English (US)', 'Family', self.font.familyname), ('English (US)', 'SubFamily', subFamily), \
            ('English (US)', 'UniqueID', u'FontForge 2.0 : ' + self.font.fullname + ": " + datetime.datetime.now().isoformat()),\
            ('English (US)', 'Fullname', self.font.fullname),\
            ('English (US)', 'Version', 'Version {0:09.3f}'.format(float(self.params.get("Font", 'version')))),\
#            ('English (US)', 'PostScriptName', self.font.fontname),\
            ('English (US)', 'License', "Open Font License"), ('English (US)', 'License URL', 'http://scripts.sil.org/OFL'))
        langCode = int(self.params.get("Font", "localizedLang"))   
        self.font.appendSFNTName(langCode, 1, self.params.get("Font", "localizedFamilyName").encode('UTF-8'))
        self.font.appendSFNTName(langCode, 2, self.params.get("Font", "localizedSubFamily").encode('UTF-8'))
        self.font.appendSFNTName(langCode, 4, self.params.get("Font", "localizedFullName").encode('UTF-8'))
        self.font.appendSFNTName(0x409, 8, self.params.get("Font", "vendor"))
        self.font.appendSFNTName(0x409, 9, self.params.get("Font", "designer"))
        self.font.appendSFNTName(0x409, 11, self.params.get("Font", "vendorUrl"))

        print(self.font.sfnt_names)
        self.font.ascent = self.params.getint("Font", "fontAscent")
        self.font.descent = self.params.getint("Font", "fontDescent")
        self.font.os2_weight = self.params.getint("Font", "fontWeight")
        self.font.os2_winascent = self.params.getint("Font", "ascent") - self.font.ascent
        self.font.os2_windescent = self.params.getint("Font", "descent") - self.font.descent
        self.font.os2_family_class = self.params.getint("Font", "familyClass")
        self.fixedWidth = int(self.params.get("Font", "fixedWidth"))
        self.font.os2_panose = (2, 0, 6, 3, 0, 0, 0, 0, 0, 0)
        if self.fixedWidth > 0: self.font.os2_panose = (2, 0, 6, 9, 0, 0, 0, 0, 0, 0)

        self.font.em = int(self.params.get("Font", "emWidth"))
        logFile =  codecs.open(outname +".log", "w", "UTF-8")
        logging.basicConfig(filemode="r", level=logging.DEBUG, stream=logFile)
        self.log = logging.getLogger(outname)
        # self.log =
        self.outName = outname
        self.sfdFile = outname + ".sfd"
        self.ttfFile = outname + ".ttf"
        self.glyphCount = 0
        self.alternateTables = dict()
        # dict of tables, where each table is a list of tuples in the form
        # (precontext, orig_glyphs, postcontext, replace_glyphs)
        self.substitutions = []
        self.subDict = dict()
        self.classes = dict()
Esempio n. 29
0
def initialize_font(weight):
    """Create a new font, with constans initialized.
    """
    font = fontforge.font()
    font.fontname = FONT_FAMILY_NAME + "-" + weight
    font.fullname = FONT_FAMILY_FULL_NAME + " " + weight
    font.familyname = FONT_FAMILY_FULL_NAME
    font.weight = weight
    font.encoding = "UnicodeFull"
    font.copyright = ""
    font.version = ""
    font.comment = None
    return font
Esempio n. 30
0
def main():
    font = fontforge.font()

    name = "liparxe-round"
    font.encoding = "UnicodeBmp"
    font.familyname = name
    font.fullname = name
    font.fontname = name

    create(font)

    font.save("%s.sfd" % name)
    font.generate("%s.ttf" % name)
Esempio n. 31
0
    def process(process_id, line_num_p_process):
        for i in range(process_id * line_num_p_process,
                       (process_id + 1) * line_num_p_process):
            if i >= lines_num:
                break
            font_line = valid_fonts[i]
            font_id = font_line.strip().split(', ')[0]
            split = font_line.strip().split(', ')[1]
            font_name = font_line.strip().split(', ')[-1]

            font_file_path = os.path.join(fonts_file_path, split, font_name)
            try:
                cur_font = fontforge.open(font_file_path)
            except Exception as e:
                print('Cannot open', font_name)
                print(e)
                continue

            target_dir = os.path.join(sfd_path, split, "{}".format(font_id))
            if not os.path.exists(target_dir):
                os.makedirs(target_dir)

            for char_id, char in enumerate(alphabet_chars):
                char_description = open(
                    os.path.join(target_dir,
                                 '{}_{:02d}.txt'.format(font_id, char_id)),
                    'w')

                cur_font.selection.select(char)
                cur_font.copy()

                new_font_for_char = fontforge.font()
                new_font_for_char.selection.select(char)
                new_font_for_char.paste()
                new_font_for_char.fontname = "{}_".format(font_id) + font_name

                new_font_for_char.save(
                    os.path.join(target_dir,
                                 '{}_{:02d}.sfd'.format(font_id, char_id)))

                char_description.write(str(ord(char)) + '\n')
                char_description.write(
                    str(new_font_for_char[char].width) + '\n')
                char_description.write(
                    str(new_font_for_char[char].vwidth) + '\n')
                char_description.write('{:02d}'.format(char_id) + '\n')
                char_description.write('{}'.format(font_id))

                char_description.close()

            cur_font.close()
Esempio n. 32
0
 def post(self, request, *args, **kwargs):
   try: pk_list = json.loads(request.body)
   except: pk_list = []
   if len(pk_list)<=0: return redirect("/")
   pk = [int(x) for x in pk_list]
   att = []
   f = fontforge.font()
   gs = Glyph.objects.all()
   gs = Glyph.objects.filter(pk__in=pk_list)
   svgs = glob.glob("/Users/kirby/htdocs/testcol/font/don/svgs/*")
   count = 1
   for g in gs:
     if g.license.attribution: att += [g]
     fn = os.path.join(settings.MEDIA_ROOT, str(g.svg))
     if not os.path.exists(fn): continue
     c = f.createChar(0xf000 + count)
     c.importOutlines(fn)
     c.left_side_bearing = KERNING
     c.right_side_bearing = KERNING
     c.simplify()
     c.round()
     count += 1
   random_name = ""
   while True:
     random_name = hex(int(1000000000000*random.random()))
     dir = os.path.join(tmp_root, random_name)
     if not os.path.exists(dir): break
   os.makedirs(dir)
   ttf_fn = os.path.join(dir, "font.ttf")
   eof_fn = os.path.join(dir, "font.eof")
   woff_fn = os.path.join(dir, "font.woff")
   license_fn = os.path.join(dir, "attribution.txt")
   f.generate(ttf_fn)
   f.generate(eof_fn)
   f.generate(woff_fn)
   f = open(license_fn, "w")
   for g in att:
     f.writelines("the icon '%s' is contributed by %s %s\n"%(g.name, g.author, "("+g.author_url+")" if g.author_url else ""))
   f.close()
   files = glob.glob(os.path.join(dir, "*"))
   #buf = StringIO.StringIO()
   zip_fn = os.path.join(tmp_root, random_name+".zip")
   z = zipfile.ZipFile(zip_fn, "w")
   #z = zipfile.ZipFile(buf, "w")
   for f in files:
     b = os.path.basename(f)
     print(b)
     z.write(f, b)
   z.close()
   return HttpResponse(json.dumps({"name": random_name}))
Esempio n. 33
0
def generateTTF(filename):
    emsize = 1024
    width = emsize
    height = emsize

    from xie.graphics.canvas import TrueTypeGlyphCanvasController
    canvas = TrueTypeGlyphCanvasController(width, height)

    from xie.graphics.drawing import DrawingSystem
    drawSystem = DrawingSystem(canvas)

    import fontforge
    f = fontforge.font()
    f.is_quadratic = True
    #	f.strokedfont=True
    #	f.strokewidth=50
    f.em = emsize

    characters = sorted(rm.getCharacters())
    print("總共有 %s 個字符" % len(characters))
    for index, ch in enumerate(characters):
        if index % 100 == 0:
            print("正在描繪 %s 到 %s 個字符" % (index * 1, index + 100))

        o = ord(ch)
        g = f.createChar(o)
        g.left_side_bearing = 100
        g.right_side_bearing = 100
        canvas.changeGlyph(g)

        character = rm.getCharacter(ch)

        from xie.graphics.shape import Boundary
        descriptionBoundary = Boundary(0, 0, 256, 256)

        drawSystem.save()
        drawSystem.setSourceBoundary(descriptionBoundary)
        drawSystem.draw(character)
        drawSystem.restore()

        # stroke(penType, strokeWidth, lineCap, lineJoin)
        # stroke(circular|calligraphic|polygon, strokeWidth, square|round|butt, miter|round|bevel)
        g.stroke("circular", 30, "round", "miter")
        g.correctDirection()
        g.removeOverlap()
        g.correctDirection()

    makeSureDirCreated(filename)
    f.generate(filename)
    print('結束')
Esempio n. 34
0
    def __init__(self, basename, isBold=False, isItalic=False):
        if isBold:
            self.weight = 'bold'
        else:
            self.weight = 'normal'

        if isItalic:
            self.style = 'italic'
            self.bitmaps = italicBitmaps
        else:
            self.style = 'normal'
            self.bitmaps = romanBitmaps

        self.glyphs = glyphs # That is, glyphs.glyphs

        s = [basename]

        if self.weight == 'bold':
            s.append(self.weight)

        if self.style == 'italic':
            s.append('italic')

        s = [cap(x) for x in s]

        self.human_name = ' '.join(s)
        self.fontname = ''.join(self.human_name.split())
        self.familyname = ''.join(basename.split())
        print("basename: {0}".format(basename))
        print("fontname: {0}".format(self.fontname))
        print("familyname: {0}".format(self.familyname))
        print("human name: {0}".format(self.human_name))
        print("")
        self.sfd_name = '{0}.sfd'.format(self.fontname)
        self.otf_name = '{0}.otf'.format(self.fontname)
        self.ttf_name = '{0}.ttf'.format(self.fontname)

        self.font = fontforge.font()
        self.font.ascent = ASCENT
        self.font.descent = DESCENT
        self.font.fontname = self.fontname
        self.font.familyname = self.familyname
        self.font.fullname = self.human_name
        if self.weight == 'bold':
            self.font.weight = cap(self.weight)
#        if self.style == 'italic':
#            self.font.isItalic = True
        g = self.font.createChar(0x0020, 'space')
        g.width = CHAR_WIDTH
Esempio n. 35
0
  def run(self):
    self.name = self.options.name
    self.path = self.options.path

    self.font = font = fontforge.font()

    font.fontname = self.name
    font.fullname = self.name
    font.familyname = self.name

    glyphs = self.options.glyphs.split(',,')
    for g in glyphs:
      self.grab(g)

    font.generate(self.path)
Esempio n. 36
0
def createFont(strFontName):
	logFile= open(options.logfile,"w")
	if options.font_in:
		tt=fontforge.open(options.font_in)
	else:
		tt=fontforge.font(options.font_out)
	print "Adding Glyphs"
	AddGlyphs(tt, logFile)
	print "Setting font em size from", tt.em, "to", options.emsize
	tt.em = options.emsize
	logFile.write("Font em size set to {0}\n".format(tt.em))
	print "Generating font"
	tt.generate(strFontName)
	print "Done"
	logFile.close()
Esempio n. 37
0
def main(model_fd):
    data = json.load(model_fd)
    if not data:
        return

    validateModel(data)

    font = fontforge.font()
    font.familyname = data["font_name"]
    font.fontname = data["font_name"]
    font.design_size = 1024.0

    font.hasvmetrics = True

    font.upos = 0
    font.ascent = 1024
    font.descent = 0

    font.hhea_ascent = 1024
    font.hhea_ascent_add = False
    font.hhea_descent = 0
    font.hhea_descent_add = False
    font.hhea_linegap = 0

    font.os2_use_typo_metrics = True
    font.os2_typoascent = 1024
    font.os2_typoascent_add = False
    font.os2_typodescent = 0
    font.os2_typodescent_add = False
    font.os2_typolinegap = 0

    font.os2_winascent = 1024
    font.os2_winascent_add = False
    font.os2_windescent = 0
    font.os2_windescent_add = False

    for i, glyph in enumerate(data["glyphs"]):
        charcode = UTF8_AREA + i
        c = font.createChar(charcode)
        glyph["charcode"] = "\\u{:x}".format(charcode)
        c.importOutlines(glyph["path"])
        #scale glyph to fit between 200 (base line) and 800 (x 0.6)
        #c.transform((0.6, 0.0, 0.0, 0.6, 200, 200.))
        c.vwidth = 1024
        c.width = 1024

    font.generate(data["font_file"])
    genQml(data)
Esempio n. 38
0
    def __init__(self, existing_font=None, preset=None):
        self._ff_messages = []

        if existing_font:
            with self._captures_messages():
                self._ff = fontforge.open(existing_font)
        else:
            self._ff = fontforge.font()

            self.name = DEFAULT_FONT_NAME
            self.family = DEFAULT_FAMILY_NAME
            self.postscript_name = DEFAULT_POSTSCRIPT_NAME

            self.apply_preset(preset or DefaultPreset)

        self.closed = False
Esempio n. 39
0
def main():
    font = fontforge.font();
    name = "BhataanTransliteration"

    font.fullname = name;
    font.fontname = name;
    font.familyname = name;

    font.encoding = "UnicodeBmp";

    create_characters(font);
    create(font);
    
    font.save("%s.sfd" % name);
    font.generate("%s.ttf" % name);
    font.generate("%s.woff" % name);
Esempio n. 40
0
def initialize_font(glyph_database, font_type):
    font_name = FONT_NAME_PATTERN % font_type

    font = fontforge.font()
    font.familyname = font_name
    font.fullname = font_name

    for glyph_id, glyph_info in glyph_database['info'].iteritems():
        print("Importing glyph [%s]: %s" % (font_type, glyph_id))
        unicode_id = glyph_info['unicode_id']
        unicode_name = 'uni' + hex(unicode_id).upper()[2:]
        char = font.createChar(unicode_id, unicode_name)
        char.importOutlines(GLYPH_PATH_PATTERN %
                            (FONT_TYPES[font_type], glyph_id))
        char.width = 1000

    return font, font_name.replace(' ', '-')
Esempio n. 41
0
 def __init__(self, filename=None):
     self.filename = filename
     if filename != None and os.path.isfile(filename):
         self.sfdfile = fontforge.open(filename)
     else:
         self.sfdfile = fontforge.font()
         # set default
         self.setName('unnamed')
         self.sfdfile.weight = 'Medium'
         self.sfdfile.copyright =  \
                'Created with python-fontforge, edit with FontForge'
         self.sfdfile.comment = 'Created %s' % time.ctime()
         self.sfdfile.ascent = 1000
         self.sfdfile.descent = 0
         self.sfdfile.upos = 0
         self.sfdfile.encoding = 'UnicodeFull'
     self.glyphs = {}
Esempio n. 42
0
def createFont(name):
    font = fontforge.font()
    font.familyname = fontName
    font.fontname = fontName
    font.fondname = fontName
    font.fullname = fontName
    font.copyright = ' '
    font.comment = ' '
    font.woffMetadata = ' '
    font.version = '1.0.1'
    font.encoding = "utf-8"
    font.uwidth = 0
    font.upos = 0
    font.ascent = 960
    font.descent = 64
    font.em = 1024
    return font
Esempio n. 43
0
def icon(filepath):
    """Try to convert the contents of svg file to json representation of icon.

    :filepath: path to file
    :returns: dict

    """
    iconfile = open(filepath)
    origincontents = iconfile.read()
    tempfont = fontforge.font()
    tempfont.ascent = BASE_ASCENT
    tempfont.descent = BASE_DESCENT
    tempfont.em = BASE_ASCENT + BASE_DESCENT
    glyph = tempfont.createChar(0xf000)
    try:
        tempiconfile = tempfile.NamedTemporaryFile(suffix='.svg')
        tempiconfile.write(origincontents)
        tempiconfile.flush()
        glyph.importOutlines(tempiconfile.name)
        bbox = glyph.boundingBox()
        if abs(bbox[2] - bbox[0]) < 1.0 or abs(bbox[3] - bbox[1]) < 1.0:
            return None
        glyph.transform((1, 0, 0, 1, -bbox[0], -bbox[1]))
        glyph.round()
        bbox = map(int, glyph.boundingBox())
        tempiconfile.close()
    except:
        return None

    tmpf = tempfile.NamedTemporaryFile(suffix='.svg')
    tempfont.generate(tmpf.name)
    tempfont.close()

    output = tmpf.read()
    tmpf.close()
    output = re.sub(r'xmlns\s*=\s*["\'][^"\']+["\']', '', output)
    fontquery = pq(output)
    glyph = fontquery('glyph').eq(0)
    d = glyph.attr('d')

    return {
        'viewBox': (0, 0, BASE_ASCENT, BASE_ASCENT),
        'boundingBox': bbox,
        'svg_d': d
    }
Esempio n. 44
0
def icon(filepath):
    """Try to convert the contents of svg file to json representation of icon.

    :filepath: path to file
    :returns: dict

    """
    iconfile = open(filepath)
    origincontents = iconfile.read()
    tempfont = fontforge.font()
    tempfont.ascent = BASE_ASCENT
    tempfont.descent = BASE_DESCENT
    tempfont.em = BASE_ASCENT + BASE_DESCENT
    glyph = tempfont.createChar(0xf000)
    try:
        tempiconfile = tempfile.NamedTemporaryFile(suffix='.svg')
        tempiconfile.write(origincontents)
        tempiconfile.flush()
        glyph.importOutlines(tempiconfile.name)
        bbox = glyph.boundingBox()
        if abs(bbox[2] - bbox[0]) < 1.0 or abs(bbox[3] - bbox[1]) < 1.0:
            return None
        glyph.transform((1, 0, 0, 1, -bbox[0], -bbox[1]))
        glyph.round()
        bbox = map(int, glyph.boundingBox())
        tempiconfile.close()
    except:
        return None
    
    tmpf = tempfile.NamedTemporaryFile(suffix='.svg')
    tempfont.generate(tmpf.name)
    tempfont.close()

    output = tmpf.read()
    tmpf.close()
    output = re.sub(r'xmlns\s*=\s*["\'][^"\']+["\']', '', output)
    fontquery = pq(output)
    glyph = fontquery('glyph').eq(0)
    d = glyph.attr('d')

    return {
        'viewBox': (0, 0,BASE_ASCENT, BASE_ASCENT),
        'boundingBox': bbox,
        'svg_d': d
        }
Esempio n. 45
0
def create_font(conf):
    """
    Create font with some default options
    """

    font = fontforge.font()

    font.encoding = 'UnicodeFull'

    font.em = FONT_EM

    # TODO: Make ligatures optional
    # Forcing strings to stop TypeError: Bad type for argument due to
    # unicode_literals
    liga = str('liga')
    latn = str('latn')
    dflt = str('dflt')
    feature_script_lang = ((liga, ((latn, (dflt)),)),)
    # Set up ligatures
    font.addLookup('liga', 'gsub_ligature', (), feature_script_lang)
    font.addLookupSubtable('liga', 'liga')

    # Add all recommended font characters
    # Reference: https://www.microsoft.com/typography/otspec/recom.htm
    glyph = font.createChar(-1, '.notdef')
    glyph.width = 0
    # TODO: Needs a default notdef glyph
    glyph = font.createChar(0x0, '.null')
    glyph.width = DEFAULT_GLYPH_WIDTH
    glyph = font.createChar(0xD, 'CR')
    glyph.width = DEFAULT_GLYPH_WIDTH
    glyph = font.createChar(0x20, 'space')
    try:
        glyph.width = conf['width_space']
    except KeyError:
        glyph.width = DEFAULT_GLYPH_WIDTH
    logger.debug("Space character width: %d", glyph.width)
    glyph = font.createChar(ZWJ_INT)
    glyph.width = 0
    glyph = font.createChar(VS16_INT)
    glyph.width = 0

    return font
Esempio n. 46
0
def makeFont():

	boardWidth = (PARAMS['keyWidth']+PARAMS['horizontalSpacing'])*10
	boardHeight = PARAMS['tallHeight']*1.8

	font = fontforge.font()
	font.fontname = FONTNAME
	font.fullname = FONTNAME
	font.familyname = FONTNAME
	font.ascent = boardHeight
	font.descent = 0

	def storeGlyph(char, svgFilename, width=0):
		glyph = font.createChar(ord(char))
		glyph.width = width
		glyph.importOutlines(svgFilename)

	storeGlyph('/', 'board.svg', boardWidth)

	for key in KEYS.keys():

		svgFilename = key+'.svg'

		if key=='star':
			storeGlyph('*', svgFilename)
		elif '2' in key:
			# this is a key that exists on the left
			# and the right, and this one is on the right.
			# So we store it as a lowercase letter
			storeGlyph(key[0].lower(), svgFilename)
		elif (key+'2') in KEYS:
			# this is a key that exists on the left
			# and the right, and this one is on the left
			# So we store it as an uppercase letter
			storeGlyph(key.upper(), svgFilename)
		else:
			# it appears on one side only;
			# be convenient and store it as both cases
			storeGlyph(key.upper(), svgFilename)
			storeGlyph(key.lower(), svgFilename)

	font.save('stenoboard.sfd')
	font.generate('stenoboard.ttf')
Esempio n. 47
0
def create_font(conf):
    """
    Create font with some default options
    """

    font = fontforge.font()

    font.encoding = 'UnicodeFull'

    font.em = FONT_EM

    # TODO: Make ligatures optional
    # Forcing strings to stop TypeError: Bad type for argument due to
    # unicode_literals
    liga = str('liga')
    latn = str('latn')
    dflt = str('dflt')
    feature_script_lang = ((liga, ((latn, (dflt)),)),)
    # Set up ligatures
    font.addLookup('liga', 'gsub_ligature', (), feature_script_lang)
    font.addLookupSubtable('liga', 'liga')

    # Add all recommended font characters
    # Reference: https://www.microsoft.com/typography/otspec/recom.htm
    glyph = font.createChar(-1, '.notdef')
    glyph.width = 0
    # TODO: Needs a default notdef glyph
    glyph = font.createChar(0x0, '.null')
    glyph.width = DEFAULT_GLYPH_WIDTH
    glyph = font.createChar(0xD, 'CR')
    glyph.width = DEFAULT_GLYPH_WIDTH
    glyph = font.createChar(0x20, 'space')
    try:
        glyph.width = conf['width_space']
    except KeyError:
        glyph.width = DEFAULT_GLYPH_WIDTH
    logger.debug("Space character width: %d", glyph.width)
    glyph = font.createChar(ZWJ_INT)
    glyph.width = 0
    glyph = font.createChar(VS16_INT)
    glyph.width = 0

    return font
Esempio n. 48
0
def font_generate(filename, dirpath):
    font = ff.font()
    font.fontname = "User"
    font.familyname = "UserFont1"

    for i in xrange(96):
        image_name = str(i + 32) + '.png'

        image_path = os.path.join(dirpath, image_name)

        glyph = font.createMappedChar(chr(i + 32))
        glyph.importOutlines(image_path)
        font.selection.select(chr(i + 32))
        font.autoTrace()
        if i != 0:
            font.autoWidth(10)
        # font.autoKern()

    filepath = os.path.join(dirpath, filename)
    font.generate(filepath)
Esempio n. 49
0
def build_font(_f):

    modify_and_save_latin(_f, EN_TEMP)
    modify_and_save_jp(_f, JP_TEMP)

    deco_print('merge modified {} and modified {}'.format(
        _f.get('latin'), _f.get('japanese')))

    target_font = fontforge.font()
    target_font = set_height(target_font)

    target_font.upos = 45
    target_font.fontname = _f.get('family')
    target_font.familyname = _f.get('family')
    target_font.fullname = _f.get('name')
    target_font.weight = _f.get('weight_name')

    target_font = set_os2_values(target_font, _f)
    target_font = set_sfnt_names(target_font, _f)
    target_font = set_gasp_table(target_font)

    target_font.mergeFonts(EN_TEMP)
    if not DEBUG: os.remove(EN_TEMP)
    target_font.mergeFonts(JP_TEMP)
    if not DEBUG: os.remove(JP_TEMP)

    target_font = vertical_line_to_broken_bar(target_font)
    # target_font = emdash_to_broken_dash(target_font) # あまり必要性を感じないので削除
    # 全角をいじるのはマージ前に行う

    target_font = post_process(target_font)

    fontpath = DIST + '/{}'.format(_f.get('filename'))
    if DEBUG: print_pdf(target_font, fontpath + '.pdf')

    target_font.generate(fontpath)
    target_font.close()

    fix_xAvgCharWidth(SOURCE + '/{}'.format(_f.get('japanese')), fontpath)

    deco_print('Generate {} completed.'.format(_f.get('name')))
Esempio n. 50
0
def build_svg_only():
    build = fontforge.font()
    build.encoding = "UnicodeBMP"
    build.ascent = ASCENT
    build.descent = DESCENT

    add_own_symbols(build)

    licf = open("src/COPYING")
    lic = licf.read()
    licf.close()

    build.appendSFNTName(0x409, 0, "No Copyright")
    build.appendSFNTName(0x409, 1, "Ocami PD")
    build.appendSFNTName(0x409, 2, "Regular")
    build.appendSFNTName(0x409, 4, "Ocami PD Regular")
    build.appendSFNTName(0x409, 6, "Ocami PD Regular")
    build.appendSFNTName(0x409, 13, lic)

    build.save("dist/ocami-symbols.sfd")
    build.close()
Esempio n. 51
0
def newMathFont(aName):
    print("Generating %s.otf..." % aName, end="")
    mathFont = fontforge.font()
    mathFont.fontname = aName
    mathFont.familyname = aName
    mathFont.fullname = aName
    mathFont.copyright = "Copyright (c) 2014 Mozilla Corporation"
    mathFont.encoding = "UnicodeFull"

    # Create a space character. Also force the creation of some MATH subtables
    # so that OTS will not reject the MATH table.
    g = mathFont.createChar(ord(" "), "space")
    g.width = em
    g.italicCorrection = 0
    g.topaccent = 0
    g.mathKern.bottomLeft = tuple([(0, 0)])
    g.mathKern.bottomRight = tuple([(0, 0)])
    g.mathKern.topLeft = tuple([(0, 0)])
    g.mathKern.topRight = tuple([(0, 0)])
    mathFont[ord(" ")].horizontalVariants = "space"
    mathFont[ord(" ")].verticalVariants = "space"
    return mathFont
Esempio n. 52
0
    def __init__(self, em_size, basename):
        self.EM_SIZE = em_size
        SCALE_FACTOR = self.EM_SIZE/2048.0

        if em_size == EM_SIZE_OTF:
            self.format = 'otf'
        elif em_size == EM_SIZE_TTF:
            self.format = 'ttf'

        self.human_name = basename
        self.fontname = ''.join(self.human_name.split())
        self.familyname = ''.join(basename.split())
        
        self.ASCENT = SCALE_FACTOR * 1700.0
        self.DESCENT = SCALE_FACTOR * 324.0
        self.CAP_HEIGHT = SCALE_FACTOR * 1790.0
        self.CHAR_WIDTH = (self.EM_SIZE / ASPECT_RATIO) * 0.9
        self.ROW_SIZE = self.EM_SIZE / DOT_ROWS
        self.COL_SIZE = self.CHAR_WIDTH / (DOT_COLUMNS - 1)
        self.DOT_SIZE = max(self.ROW_SIZE, self.COL_SIZE) / 2.0
        self.DOT_H = self.DOT_SIZE * 2.1
        self.DOT_V = self.DOT_SIZE * 2.1
        
        self.font = fontforge.font()
        
        self.font.ascent = self.ASCENT
        self.font.descent = self.DESCENT
        self.font.fontname = self.fontname
        self.font.familyname = self.familyname
        self.font.fullname = self.human_name
        self.font.fontlog = open(FONTLOG_FILENAME, 'r').read()
        self.font.copyright = open(COPYRIGHT_FILENAME, 'r').read()
        
        g = self.font.createChar(0x0020, 'space')
        g.width = self.COL_SIZE * DOT_COLUMNS
        
        self.binary_filename = '{0}.{1}'.format(self.fontname, self.format)
        self.archive_filename = '{0}-{1}.sfd'.format(self.fontname, self.format)
Esempio n. 53
0
def generate( font_path, texts, output ):
    font = fontforge.open(font_path)
    new_font = fontforge.font()
    new_font.encoding = 'UnicodeFull'

    texts = get_text_str(texts)
    
    for text in texts:
        hex_text = hex(ord(text))
        val = hex_text.replace("0x","").upper()
        if len(val) < 4:
            for i in range(0, 4 - len(val)):
                val = "0" + val
        val = "uni" + val
        #print(text, val, texts, re.search("0x", hex_text), hex_text)
        try:
            font.selection.select(("ranges",None), val, val)
            font.copy()
            new_font.selection.select(("ranges",None), val, val)
            new_font.paste()
        except Exception as e:
            print(val, e)

    new_font.generate(output)
Esempio n. 54
0
    def generate(self):
        """Goes through all the registered glyphs inside the font and
        generates each one."""

        # Create a new font.
        self.font = fontforge.font()

        # Go through the glyphs and generate each one. We display the
        # current status of the generation to the screen so we can see
        # something happening.
        total = len(self.glyphs)
        processed = 0

        for gid, glyph in self.glyphs.iteritems():
            processed += 1
            self.log.debug("  [{0:4}/{1:4}] Unicode {3:04x}: {2}".format(
                processed,
                total,
                glyph.label,
                glyph.gid))
            glyph.generate(self.font)

        # Finalize the font.
        self.font.fontname = self.name
Esempio n. 55
0
def generate():
    font = fontforge.font()
    # Some basic metadata.
    font.copyright   = ('Copyright (c) 2014 Ryan Dorsey\n'
                        'Licensed under SIL Open Font License v1.1 '
                        '(http://scripts.sil.org/OFL)\n'
                        'Created with FontForge 2.0 (http://fontforge.sf.net)')
    font.encoding    = config['specs']['encoding']
    font.em          = config['specs']['fontforge em']
    font.descent     = config['specs']['descent']
    font.ascent      = config['specs']['ascent']
    font.familyname  = config['specs']['family name']
    font.fontname    = config['specs']['font name']
    font.fullname    = config['specs']['full name']
    font.version     = config['specs']['version']
    font.weight      = config['specs']['weight']

    make_basic_glyphs(font)
    make_private_use_glyphs(font)
    make_space_glyphs(font)

    font.mergeFeature('MazonHebrew-Regular.fea')
    font.save('MazonHebrew-Regular.gen.sfd')
    font.generate('MazonHebrew-Regular.gen.otf')
Esempio n. 56
0
	parser.add_argument('--debug', '-d', action='store_true', help='display debug messages')
	args = parser.parse_args()
	indir = args.dir[0]
	outdir = args.dir[1]
except ImportError:
	# Older Pythons don't have argparse, so we use optparse instead
	import optparse
	parser = optparse.OptionParser(description='Convert a directory of svg and eps files into a unified font file.')
	parser.add_option('--name', metavar='fontname', type='string', nargs='?', default='fontrobot', help='reference name of the font (no spaces)')
	parser.add_option('--nohash', '-n', action='store_true', help='disable hash fingerprinting of font files')
	parser.add_argument('--debug', '-d', action='store_true', help='display debug messages')
	(args, posargs) = parser.parse_args()
	indir = posargs[0]
	outdir = posargs[1]

f = fontforge.font()
f.encoding = 'UnicodeFull'

m = md5.new()
cp = 0xf100
files = []

KERNING = 15

for dirname, dirnames, filenames in os.walk(indir):
	for filename in filenames:
		name, ext = os.path.splitext(filename)
		filePath = os.path.join(dirname, filename)
		size = os.path.getsize(filePath)

		if ext in ['.svg', '.eps']:
Esempio n. 57
0
if len(src_codes) != len(set(src_codes)):
    stderr.write("Error in file %s: glyph codes aren't unique:\n" % args.config)
    for code in set(src_codes):
        if src_codes.count(code) > 1:
            stderr.write("Duplicate 'from:' 0x%04x\n" % code)
    sys.exit(1)

try:
    font = fontforge.open(args.src_font)
    # set font encoding so we can select any unicode code point
    font.encoding = 'UnicodeFull'
except:
    stderr.write("Error: Fontforge can't open source %s" % args.src_font)
    sys.exit(1)

new_font = fontforge.font()
new_font.encoding = 'UnicodeFull'

# load font properties from config
for key, value in config.get('font', {}).items():
    setattr(new_font, key, value)


for from_code, to_code in remap_config:
    try:
        font[from_code]
    except TypeError:
        stderr.write("Warning: no such glyph in the source font (code=0x%04x)\n" %
            from_code)
        continue
Esempio n. 58
0
#!/usr/local/bin/fontforge
#Needs: fonts/ayn+meem.init.svg

# At one point splinestroke failed if the first spline on a contour had a length of 0

import fontforge;

font=fontforge.font();
a = font.createChar(65);
a.importOutlines("fonts/ayn+meem.init.svg");
Esempio n. 59
0
def subset_font_raw(font_in, font_out, unicodes, opts):
    if '--namelist' in opts:
        # 2010-12-06 DC To allow setting namelist filenames, 
        # change getopt.gnu_getopt from namelist to namelist= 
        # and invert comments on following 2 lines
        # nam_fn = opts['--namelist']
        nam_fn = font_out + '.nam'
        nam = file(nam_fn, 'w')
    else:
        nam = None
    if '--script' in opts:
        pe_fn = "/tmp/script.pe"
        pe = file(pe_fn, 'w')
    else:
        pe = None
    font = fontforge.open(font_in)
    if pe:
      print >> pe, 'Open("' + font_in + '")'
      extract_vert_to_script(font_in, pe)
    for i in unicodes:
        select_with_refs(font, i, font, pe, nam)

    addl_glyphs = []
    if '--nmr' in opts: addl_glyphs.append('nonmarkingreturn')
    if '--null' in opts: addl_glyphs.append('.null')
    for glyph in addl_glyphs:
        font.selection.select(('more',), glyph)
        if nam:
            print >> nam, "0x%0.4X" % fontforge.unicodeFromName(glyph), glyph
        if pe:
            print >> pe, 'SelectMore("%s")' % glyph

    flags = ()

    if '--simplify' in opts:
        font.simplify()
        font.round()
        flags = ('omit-instructions',)

    if '--strip_names' in opts:
        font.sfnt_names = ()

    if '--new' in opts:
        font.copy()
        new = fontforge.font()
        new.encoding = font.encoding
        new.em = font.em
        new.layers['Fore'].is_quadratic = font.layers['Fore'].is_quadratic
        for i in unicodes:
            select_with_refs(font, i, new, pe, nam)
        new.paste()
        # This is a hack - it should have been taken care of above.
        font.selection.select('space')
        font.copy()
        new.selection.select('space')
        new.paste()
        new.sfnt_names = font.sfnt_names
        font = new
    else:
        font.selection.invert()
        print >> pe, "SelectInvert()"
        font.cut()
        print >> pe, "Clear()"

    if nam: 
        print "Writing NameList", 
        nam.close()

    if pe:
        print >> pe, 'Generate("' + font_out + '")'
        pe.close()
        os.system("fontforge -script " + pe_fn)
    else:
        font.generate(font_out, flags = flags)
    font.close()

    if '--roundtrip' in opts:
        # FontForge apparently contains a bug where it incorrectly calculates
        # the advanceWidthMax in the hhea table, and a workaround is to open
        # and re-generate
        font2 = fontforge.open(font_out)
        font2.generate(font_out, flags = flags)
Esempio n. 60
0
    fontforge.logWarning("      code point:" + str(f.CollabLastChangedCodePoint()))
    f.generate(fontFileOnDisk)
    js = json.dumps({
            "seq": str(f.CollabLastSeq()), 
            "glyph": str(f.CollabLastChangedName()), 
            "codepoint": str(f.CollabLastChangedCodePoint()),
            "earl": str(fontFileURL),
            "end": "null" # this is simply so we dont have to manage keeping the last item with no terminating ,
            }, 
            sort_keys=True, indent=4, separators=(',', ': '))
    print js
    fi = open(fontJsonOnDisk, 'w')
    fi.write(js)

    
newfont=fontforge.font()       
f = newfont.CollabSessionJoin()
fontforge.logWarning( "Joined session, font name: " + f.fullname )

openURLInBrowser( "http://localhost:8000" )

fontforge.logWarning("web-test-collab: starting up...");
f.CollabSessionSetUpdatedCallback( OnCollabUpdate )
while True:
    f.CollabSessionRunMainLoop()
    # if keyPressed(): 
    #     break;

finalOutput = "/tmp/out-final.ttf"
f.generate(finalOutput)
fontforge.logWarning( "Left collab session, final file is at " + finalOutput )