Comment faire pour convertir une police bitmap (.FON) dans une police truetype (.TTF)?

je sais que cette question Est ancienne, mais pour ce qu'elle vaut j'ai pu facilement convertir une ancienne .fon .ttf à l'aide de PixFont . Je l'ai lancé en tant qu'administrateur (pas d'installation - un ancien exécutable en place) et il a généré un bon TTF même si l'original .fon manquait des bons glyphes.

et, bien qu'il ne soit pas gratuit, à 29 $Il est presque, surtout par rapport aux produits commerciaux très coûteux là-bas.

pour ceux qui ne veulent pas compiler fontforge (pour windows) : http://www.mpetroff.net/software/fontforge-windows /

qui utilise potrace au lieu d'autotrace. Les meilleurs paramètres que j'ai eu pour la police que j'étais en train de convertir (vgasys.fon) étaient:

--turdsize 0 --opttolerance 0 --unit 1 --longcurve --gamma 0 --blacklevel 0 --cleartext

il restait des heures de travail manuel pour obtenir une bonne apparence de la police (en ajoutant et en supprimant des points).

en utilisant FontForge j'ai pu générer une police truetype correspondante, qui donne exactement les mêmes caractères que la police originale lorsqu'elle est utilisée à la bonne taille. Peut-être que j'ai encore besoin de modifier certaines options, parce que j'ai utilisé ma police originale à la taille=11. La nouvelle police ne fonctionne bien qu'à la taille=10.5, ce qui est impossible à utiliser dans delphi. La police est vraiment horrible à toutes les autres tailles.

1. Charger le .FON police dans FontForge
2. Choisir Fichier - > Générer Des Polices
3. Select "(faux) MS bitmap seulement sfnt (ttf)" comme type, entre un nom de fichier et cliquez sur "enregistrer".

apparemment, il utilise une possibilité de stocker des polices bitmap dans une police truetype. La police résultante n'a pas les problèmes que j'avais avec les polices bitmap, mais elle est complètement vide sur l'imprimante afin qu'elle ne résolve pas mon problème.

Une note sur la FontForge : Je n'ai pas réussi à installer la Version Windows de FontForge (basée sur cygwin). Au lieu de cela , j'ai installé portable Ubuntu Tres , qui est une version linux qui fonctionne sur Windows. Il est facile à installer: décompressez le fichier et lancer l'exe. Ensuite, choisissez System - > Administration - > Ajouter / Supprimer des Applications et rechercher FontForge et l'installer (le mot de passe de l'administrateur est 123456). J'ai fait installer la version 20090622 de FontForge.

une possibilité pourrait être d'utiliser l'outil en ligne de commande SBIT32 fom Microsoft . Il est facile de convertir le .Fon file en a.Fichier BDF utilisant FontForge . Mais ensuite, vous devez écrire un fichier metrics (.RENCONTRER.) Je ne l'ai pas essayé, car je suppose que j'obtiendrais une police truetype avec une police bitmaps intégrée, et il est possible de générer de telles polices directement avec FontForge (type "(faked) MS bitmap only sfnt (ttf) " sous Fichier->Création De Polices De Caractères).

j'ai trouvé que la route la plus facile pour obtenir une bonne version TTF d'un FON est d'utiliser l'un des éditeurs de police bitmap en ligne gratuit. Vous devez entrer manuellement chaque glyphe, mais le processus est beaucoup plus simple que de venir à bout de FontForge. Il y a deux éditeurs que je connais, et ils produisent tous les deux des TTFs qui fonctionnent bien sur Windows et Linux.

BitFontMaker est le plus simple des deux. J'aime son interface propre, mais j'ai fini par ne pas l'utiliser parce que les polices monosplaced ne peuvent avoir que des largeurs de cellules de 10 à 14 pixels.

FontStruct nécessite un enregistrement et utilise une interface Flash. J'ai été capable de faire de nouvelles polices assez rapidement une fois que je me suis habitué à l'interface. (C'est peut-être une coïncidence, mais j'ai remarqué une augmentation dans le spam sur le compte email que j'ai utilisé pour enregistrer.)

les deux éditeurs établissent l'espacement des lignes automatiquement. Une astuce pour obtenir l'espacement que vous voulez est d'ajouter un pixel sur un caractère, puis utilisez un éditeur de police vectoriel pour le supprimer du TTF. ( Type light fonctionne bien et est beaucoup plus facile à utiliser que FontForge.)

il est peu probable que vous puissiez l'accomplir avec un simple outil gratuit. http://www.fontlab.com ont des outils pour le faire, mais ils sont très coûteux.

selon la description du produit BitFonter 3.0 semble pouvoir le faire:

conversion puissante des polices bitmaps et bitmap à partir et vers le Type 1, les polices TrueType et OpenType par intégration avec FontLab Studio et TypeTool. "

mais US$999 est un peu cher pour convertir une seule police.

j'ai cherché ces polices pour les utiliser avec un projet sur lequel je travaille. Terrés à l'idée de modifier manuellement tous les glyphes comme mentionné dans les autres réponses, j'ai continué à rechercher. Finalement, je suis tombé sur un site qui a la police originale ainsi que quelques nouvelles .ttf variantes. Si vous ne vous souciez pas que certains des glyphes ont été remappés (ils sont tous encore présents) c'est une bonne alternative: Oldschool PC Fonts . Comme un ajouté un bonus pour moi ces soutien étendu latin, grec, cyrillique et Hébreu scripts plus un tas de glyphes supplémentaires et des symboles Unicode.

Je ne pouvais pas faire fonctionner autotrace, donc j'ai écrit un script python pour tracer les images en noir et blanc dans des polygones vectoriels, un pour chaque pixel.

ainsi avec un dossier d'images glyphe, vous pouvez le convertir dans un dossier de fichiers svg .

puis dans Inkscape union + simplifier le chemin pour nettoyer chaque glyphe. ( peut-être faisable sur la ligne de commande avec Inkscape)

enfin importer le svg correspondant dans FontForge pour chaque glyphe.

- > script hébergé à gist.gisthub.com

from PIL import Image
import svgwrite
import os
import argparse


def bmp_to_svg(filename, multiply =1):

    img = Image.open(filename)
    w, h = img.size
    pixel_acc = img.load()

    generated_paths = paths_gen(pixel_acc, w,h, multiply=multiply)

    dwg = svgwrite.Drawing(profile='tiny')
    for path in generated_paths:
        options = path
        kwoptions = {} #{"fill":"black"}
        dwg.add(dwg.polygon(options, **kwoptions))

    #clip_path = dwg.defs.add(dwg.clipPath())
    #clip_path.add(dwg.Rect(insert=(0,0), size=((w*multiply)+1, (h*multiply)+1)))
    return dwg

def paths_gen(pixel_acc, w, h, multiply = 1):
    m = multiply
    paths = []
    for y in range(0,h):
        for x in range(0,w):
            pix = pixel_acc[x,y]
            brightval = sum(pix) /3
            if brightval < 128:
                paths.append([
                        ##top left
                        (x * m, y * m),
                        ##top right
                        ((x+1) * m, y * m),
                        ##bottom right
                        ((x+1) * m, (y+1) * m),
                        ##bottom list
                        ((x) * m, (y+1) * m),
                        ##close back to top left
                        #(x, y), 
                    ])
    return paths


def main():
    parser = argparse.ArgumentParser(
        description='Script to convert black and white images into vector art')
    parser.add_argument("input_dir")
    parser.add_argument("ouput_dir")
    parser.add_argument("in_ext", default="bmp", help="file extension of images in input folder")
    parser.add_argument("-m", "--multiply", default=1, type=int)
    ## TODO
    #parser.add_argument("-u", "--union", store=True, help="unifies adjecent polgons")
    #parser.add_argument("-s", "--simplify", store=True, help="removes points that are part of a straight line")
    #parser.add_argument("-c", "--compress", store=True, help="same as '--union --simplify'")

    args = parser.parse_args()


    cdir = os.path.abspath(args.input_dir)

    fn_gen = ( x for x in os.listdir(cdir)
                 if x.endswith('.'+args.in_ext)
             )

    for count, filename in enumerate(fn_gen):

        full_filename =  os.path.join(cdir, filename)

        new_fn = "{}_.svg".format(filename)
        new_fullfn =  os.path.join(args.ouput_dir, new_fn)


        svg = bmp_to_svg(full_filename, multiply=args.multiply)
        print "Converted file: '{}'".format(full_filename)
        svg.filename = new_fullfn
        svg.save()

if __name__ == '__main__':
    main()