CommunityImagegithub.com

Image to Fonts

Transforme une image de feuille d'échantillons de polices en un fichier OTF installable.

Qu'est-ce que Image to Fonts ?

Ce skill permet de convertir une image de spécimen de police (contenant des lettres A-Z, a-z et des chiffres 0-9) en un fichier de police OTF prêt à l'emploi. Il analyse l'image en identifiant les composants connectés, estime les lignes de base et les repères, puis vectorise les contours avec un lissage préservant les coins et une détection de fermeture de boucle. La sortie inclut le fichier .otf, un fichier project.json pour les modifications ultérieures, et un aperçu HTML. Il prend en charge le remplacement de caractères individuels via une commande patch, l'ajustement du crénage et de l'espacement, et la fusion de plusieurs feuilles de spécimens. Utilisez-le dès qu'un utilisateur demande de créer une police à partir d'une image, par exemple en disant 'crée une police à partir de cette image' ou 'transforme cet alphabet en police'. Il gère correctement les polices manuscrites, les variations de hauteur de caractères et les éléments décoratifs comme les empattements ou les fioritures.

Compatible avec✓Claude Code~Codex CLI~Cursor
npx skills add https://github.com/ssaengcho01/ssaengcho/tree/main/image-to-fonts

Installed? Explore more Image skills: steipete/songsee, affaan-m/frontend-design, mattpocock/improve-codebase-architecture · View all 6 →

Demander à votre IA préférée

Ouvre une nouvelle conversation avec cette compétence d'agent déjà préchargée.

Documentation

Image to Fonts — Spécimen d'image → Police OTF

Pipeline validé : binarisation → séparation des composants connectés (fusion des points/fragments) → estimation des lignes/repères → traçage vectoriel (marche de contour + lissage préservant les coins + RDP fermé) → arrondi des coordonnées em puis nettoyage secondaire → normalisation capitale 700 → correction optique des débordements et des espaces latéraux → packaging OTF avec opentype.js. Le débordement (ex. O légèrement sous la ligne de base) et les fioritures (ex. queue du Q) sont préservés automatiquement.

Étape 0 — Toujours demander le nom de la police en premier

Quand l'image arrive, demander le nom de la police avant de commencer le travail (ex. "Comment voulez-vous nommer la police ?"). Recommander un nom en anglais si l'image ne contient que des caractères latins — un nom en coréen peut rendre la police invisible dans Photoshop. Une fois le nom reçu, procéder. Si l'utilisateur a déjà donné un nom, l'utiliser tel quel.

À ce stade, vérifier : si le spécimen semble une police commerciale protégée par des droits d'auteur, ajouter une ligne indiquant qu'elle ne doit être utilisée qu'à des fins d'apprentissage/expérimentation personnelle. Omettre si l'utilisateur le sait déjà.

Étape 1 — Vérifier la résolution (la plus importante)

"C'est pixelisé en grand", "les lettres ont des tailles différentes" — 90% de ces retours viennent d'une résolution insuffisante, pas de l'algorithme. Mesure réelle : une feuille de lettres de hauteur 85px vs 500px, pour la même police, donne 201 points de traçage vs 575 (2.9x) — la basse résolution manque de matière pour tracer les courbes.

  • Dès réception de l'image, utiliser img2bin.py pour obtenir la taille (W, H) et estimer la hauteur en pixels par lettre avec le nombre approximatif de lignes/colonnes.
  • Si la hauteur par lettre est bien inférieure à 150px (surtout 80–100px), prévenir que le résultat pourra être rugueux en agrandissant, ou demander une nouvelle image avec une hauteur d'au moins 300px.
  • On peut recevoir plusieurs feuilles (ex. capitales + minuscules) — la procédure de fusion (ci-dessous) les combine en une seule police.
  • La limite de redimensionnement de img2bin.py est 3400px (côté le plus long). Les images plus grandes sont utilisées au maximum dans cette limite.

Étape 2 — Décomposition de l'image

cd <dossier des scripts>
python3 img2bin.py <image> /tmp/ff/sheet.bin   # sortie : W H
node pipeline.js segment /tmp/ff/sheet.bin <W> <H> /tmp/ff/work

Vérifier count et standard dans le JSON de sortie :

  • standard: true (26/52/62 éléments) → feuille alphabétique. Générer les étiquettes automatiquement dans l'ordre de lecture :
    • 26 = A~Z, 52 = A~Z a~z, 62 = A~Z a~z 0~9
    • Écrire labels.json : {"0":"A","1":"B",...} (l'ordre i de comps.json = ordre de lecture)
  • standard: false → la feuille contient des titres, décorations ou échantillons de mots. Ne jamais forcer l'ordre d'étiquetage (un seul décalage casse toute la police). À la place :
    python3 contact_sheet.py /tmp/ff/work /tmp/ff/contact.png
    
    → Regarder contact.png avec l'outil view et identifier visuellement chaque caractère. Écrire labels.json avec les lettres identifiées. Marquer "skip" pour les éléments illisibles ou décoratifs. Si la même lettre apparaît plusieurs fois, ne garder que la plus nette comme lettre, mettre "skip" pour les autres. (Ne pas utiliser "?" comme marqueur de saut car c'est un véritable point d'interrogation.)
    • Profiter de la structure en lignes : si une feuille alphabétique a des lignes d'en-tête/échantillon mélangées, repérer les lignes de 13 éléments (= A-M / N-Z / a-m / n-z) et les étiqueter dans l'ordre, marquer toutes les autres lignes "skip".
    • Si c'est un échantillon de mots (ex. "MODERN SERIF"), prévenir l'utilisateur que seules les lettres présentes seront dans la police.

Fusion de plusieurs feuilles (ex. capitales.png + minuscules.png)

python3 img2bin.py capitales.png /tmp/ff/upper.bin   # sortie : W H
python3 img2bin.py minuscules.png /tmp/ff/lower.bin   # sortie : W H
node pipeline.js segment /tmp/ff/upper.bin <W1> <H1> /tmp/ff/work_upper
node pipeline.js segment /tmp/ff/lower.bin <W2> <H2> /tmp/ff/work_lower

Fusionner les deux comps.json (renuméroter les index de rognage pour éviter les conflits, copier les fichiers crops), créer un labels.json fusionné (index capitales → A-Z, index minuscules → a-z) puis exécuter build une seule fois. Ainsi l'échelle capitale (capMed) sera cohérente entre les deux ensembles. (Script de fusion d'exemple dans l'historique de la session précédente — concaténer les deux tableaux comps.json en Python et copier les fichiers crops/.)

Feuilles de chiffres et symboles

Les étiquettes peuvent inclure des symboles d'un seul caractère ("!", "@", "?", "’", etc.). Leurs noms de glyphe sont automatiquement convertis en noms standards (exclam, at, question), et le crénage ne s'applique qu'aux paires lettre-chiffre.

  • Les feuilles de symboles contiennent beaucoup de fragments (comme !·?·;·%·=) et de petits points/guillemets, ce qui perturbe souvent la fusion automatique et le filtrage des lignes de segment. Si le compte ne correspond pas, vérifier avec la contact sheet. Si c'est faux, extraire les composants connectés manuellement, créer une image numérotée, puis assembler les fragments par lettre et construire comps.json/crops/ manuellement (même format que le segment : i, row, x0..y1, baseline, cropW, cropH, offX, offY). Redimensionner d'abord l'image si nécessaire pour harmoniser les tailles (ex. chiffres plus petits que les capitales).
  • Les symboles manquants sur la feuille peuvent être combinés à partir de fragments existants : " = deux guillemets, : = deux points, . = point, , = virgule.
  • La disposition sur la feuille ne correspond pas à la position typographique. Après le build, corriger les positions dans project.json puis reconstruire avec node pipeline.js rebuild <project.json> <out.otf> (référence cap 700) : - + = ~ < > * centré ≈340 verticalement, guillemets haut ≈705, _ bas ≈-60, [ ] alignés sur la hauteur de ( ). Beaucoup de feuilles ont la dernière ligne de lettres anormalement petite (XYZ etc.), vérifier aussi la hauteur. Informer l'utilisateur des corrections effectuées.
  • Si la feuille ne contient que des capitales, copier les glyphes de A-Z dans a-z pour qu'ils s'affichent également en minuscules (en informant l'utilisateur). Dupliquer également le crénage pour les paires minuscules et mixtes avec apply_kerning.py.

Étape 3 — Construction de la police + vérification qualité

Fermeture des contours — le bug "point de départ pointu" est corrigé dans pipeline.js

Le bug qui créait des pointes aux endroits arrondis (comme le sommet du S) a été corrigé en passant toutes les coordonnées comme entiers dans loopsToPath (voir note technique ci-dessous). Néanmoins, à chaque build, vérifier avec le test suivant.

Test de fermeture (toujours inclus dans la QA après le build, doit donner 0) :

python3 - /tmp/ff/font_final.otf <<'EOF'
import sys
from fontTools.ttLib import TTFont
from fontTools.pens.recordingPen import RecordingPen
gs=TTFont(sys.argv[1]).getGlyphSet(); bad=[]
for n in gs.keys():
    p=RecordingPen(); gs[n].draw(p); st=la=None
    for op,a in p.value:
        if op=='moveTo': st=a[0]
        elif op in('curveTo','lineTo','qCurveTo'): la=a[-1]
        elif op=='closePath' and st and la and max(abs(st[0]-la[0]),abs(st[1]-la[1]))>2: bad.append(n)
print('Glyphes avec contour mal fermé :', len(bad), bad[:10])
EOF
node pipeline.js build /tmp/ff/work /tmp/ff/labels.json "<NomPolice>" /tmp/ff/font.otf /tmp/ff/project.json

Après le build, procéder au nettoyage/validation de compatibilité Mac/Windows :

PSNAME=$(node -e "
const opentype=require('./opentype.min.js');
const b=require('fs').readFileSync('/tmp/ff/font.otf');
const f=opentype.parse(b.buffer.slice(b.byteOffset,b.byteOffset+b.length));
console.log(f.names.postScriptName.en);
")
python3 fix_mac_names.py /tmp/ff/font.otf "$PSNAME" "<NomPolice>" /tmp/ff/font_final.otf
fontbakery check-opentype /tmp/ff/font_final.otf --loglevel FAIL 2>&1 | grep -c "Result: FAIL"   # doit être 0
python3 -c "from ots import sanitize; print('OTS:', 'PASS' if sanitize('/tmp/ff/font_final.otf', check=False, capture_output=True).returncode==0 else 'FAIL')"
python3 render_preview.py /tmp/ff/font_final.otf /tmp/ff/qc.png "<NomPolice>"

Vérifier qc.png avec l'outil view. Cependant, dans cet environnement, selon la session, il peut être impossible de visualiser l'image rendue. Dans ce cas, procéder à un diagnostic structurel (section "QA structurelle" ci-dessous). Si même cela ne révèle aucun défaut, admettre honnêtement "je ne vois pas” en demandant une capture d'écran agrandie des parties problématiques — ne pas prétendre voir ni multiplier les corrections au hasard.

Étape 4 — Remise des résultats

  1. Copier dans /mnt/user-data/outputs/ : <NomPolice>.otf + <NomPolice>_project.json (le project.json est nécessaire pour les remplacements de caractères ultérieurs, donc le fournir impérativement et conseiller de le conserver). Zipper les deux fichiers pour un téléchargement alternatif (au cas où le téléchargement direct de l'otf soit bloqué).
  2. Aperçu HTML sous forme d'artefact (utiliser make_preview.py) : un fichier unique avec l'otf encodé en base64 intégré.
    • Basé sur preview_template.html (dossier assets). Composition :
      • Titre "Image to Font Skill" en haut
      • Nom de la police rendu dans cette police en grand + table de caractères complète (capitales, minuscules, chiffres, symboles, avec compteur)
      • Une ligne de texte d'exemple choisi par l'utilisateur
      • Zone de test (Type Tester) — champ de saisie + curseurs de taille (16–160px) et d'espacement. Sous la carte d'échantillon, au-dessus de la carte de téléchargement.
      • Bouton [Télécharger le fichier de police (.otf)] — si l'HTML est ouvert localement, enregistre directement l'otf ; dans le visualiseur d'artefact Claude, utilise la fonction downloads pour enregistrer <Nom>.zip (contenant l'otf). Déclarer {downloads: true} dans l'artefact pour que le bouton fonctionne — sans quoi il reste inactif.
      • Carte d'information "Une lettre à modifier ?" — texte statique uniquement (pas de boutons/JS) indiquant de revenir dans le chat pour joindre une image de la lettre à modifier. Les modifications de lettres se font uniquement par chat — ne jamais ajouter d'attachement de fichier/drag-and-drop/téléchargement zip dans l'HTML (ça a déjà été tenté, ça n'a fait qu'ajouter de la complexité sans être utilisé).
      • Bas : © @pseudo_utilisateur avec un message "veuillez mentionner la source si vous utilisez/partagez".
    • Toujours fournir le fichier HTML en plus de le publier en artefact (avec l'otf, project.json et le zip). Si l'environnement ne supporte pas la déclaration de téléchargement, indiquer que la police sera reçue via la carte de chat.
  3. Fournir les fichiers (.otf, project.json, zip, preview.html) + résumer combien de caractères ont été reconnus, ceux manquants, et instructions d'installation (double-clic sur .otf).
  4. À la fin du message, poser obligatoirement les deux questions (peuvent être posées ensemble) :
    • "Si une lettre a un aspect étrange ou doit être changée, veuillez joindre une image agrandie de cette lettre dans ce chat (hauteur minimale 150px recommandée)."
    • "Souhaitez-vous d'autres ajustements, comme l'espacement ou la forme des lettres ?" Si l'utilisateur joint une image, suivre la procédure "remplacement de caractère (patch)" ci-dessous. S'il donne un retour sur l'espacement, ajuster les constantes dans /tmp/ff/work (mis en cache) et re-construire avec node pipeline.js build ... (pas besoin de re-télécharger l'image).

Remplacement de caractère (patch) — retravailler une lettre avec une image haute résolution

Si l'utilisateur n'aime pas une lettre et fournit une grande image de celle-ci :

python3 img2bin.py <image_agrandie> /tmp/ff/patch.bin    # sortie : W H
node pipeline.js patch <chemin project.json> /tmp/ff/patch.bin <W> <H> <lettre> /tmp/ff/font.otf /tmp/ff/project.json
  • Le project.json doit avoir été fourni par l'utilisateur (session précédente) ou se trouver dans /tmp de la session courante. Sinon, le demander.
  • patch traite "l'encre totale de l'image = une seule lettre" (ne sélectionne pas le plus grand fragment seulement). Ainsi, les détails décoratifs séparés du trait (comme un tourbillon à l'intérieur du O) sont préservés — un ancien bug ne gardait que le plus grand fragment et supprimait ces détails.
  • Si l'image contient plusieurs lettres côte à côte (ex. "Z" et "H"), patch trouve automatiquement les points où la densité d'encre verticale est quasi nulle, les sépare, et patch chaque lettre individuellement.
  • La hauteur et la ligne de base (incluant le débordement/descendant) sont automatiquement alignées sur la lettre existante — pas besoin de s'inquiéter de la taille. Après patch, reconstruction → QA (fontbakery/OTS) → mise à jour de l'aperçu → re-remise.
  • Ajouter une nouvelle lettre minuscule (g/j/p/q/y, etc.) manquante via patch n'est pas possible car l'estimation de ligne de base échoue ; demander à l'utilisateur de fournir une feuille complète.

Réglage fin de l'espacement et des formes (sans re-téléchargement)

Si la segmentation originale est encore en cache dans /tmp/ff/work (ou work_merged pour les feuilles fusionnées), on peut ajuster les constantes dans pipeline.js et relancer node pipeline.js build .... Points ajustables (tous dans la commande build) :

  • Espacement par défaut (sidebearings) : facteur de la formule de LSB (actuellement 0.66) — le réduire resserre globalement
  • Largeur de l'espace (space width) : facteur de la formule de spaceAdv (actuellement LSB×5.4)
  • Force du crénage : seuil de déclenchement (actuellement -3) et valeur de resserrement maximum (actuellement -190) — un seuil plus large (ex. -1) engage plus de paires
  • Optical sidebearings (gauche/droite indépendants) : edgeCurviness mesure leftStd/rightStd ; ne réduire que le côté dépassant le seuil (cropW×0.02) par un facteur (actuellement 72%). Impérativement calculer indépendamment gauche et droite — un bug historique (feedback "le j semble collé au caractère suivant") venait du fait qu'un côté courbe (anneau gauche du j) et l'autre côté droit (tige droite) étaient traités avec le même facteur, ce qui rétrécissait injustement le côté droit.
  • Débordement optique par caractère : le "taux d'aplatissement" en haut/bas (largeur d'une bande fine au bout ÷ largeur d'une bande légèrement à l'intérieur, mesuré au-delà du bracket de l'empattement, actuellement aux points H*0.03/H*0.15, seuil 0.62) détermine topFlat/botFlat automatiquement. Les lettres plates (flat pur) reçoivent un facteur 1.0, celles plates d'un seul côté 1+OVERSHOOT_HALF, les autres 1+OVERSHOOT_ROUND multiplié sur le scale original (actuellement 0.7%/1.2%). Utiliser DEBUG_SHAPE=1 node pipeline.js build ... pour voir topFlat/botFlat/nativeH sur stderr.
  • Clustering naturel du x-height : trier les nativeH de toutes les minuscules, trouver le plus grand écart, ne prendre que le cluster en dessous (uniquement s'il représente ≥35% du total) et aligner finement ces lettres sur une hauteur commune. Cela sert pour les lettres purement x-height comme v,w,x,y,z qui peuvent avoir de légères variations en hauteur haute.

Ne surtout pas faire (bug grave historique) : Ne jamais forcer le réajustement de toutes les minuscules sur la hauteur cible du x-height. Sinon, les ascendantes (b,d,f,h,i,j,k,l, etc.) sont écrasées à la hauteur du x-height, rendant la police beaucoup plus petite que l'original (retour utilisateur : "c'est une blague ?"). La bonne méthode : ne jamais toucher au scale global de l'image originale ; pour une lettre individuelle, ne multiplier que son propre scale par un facteur très faible (1.007–1.012) pour la grandir légèrement. Le clustering du x-height est conçu pour exclure les lettres en dehors du cluster (ascendantes, etc.).

Les différences de taille réelle dans l'image originale (ex. une lettre effectivement plus grande sur la feuille) ne sont pas du domaine de l'algorithme — demander à l'utilisateur si c'est intentionnel.

Demande de dériver une lettre d'une autre (ex. "transforme la minuscule s en version réduite du S majuscule") — ne pas intégrer cette demande comme fonctionnalité standard ; il a été expressément demandé de ne pas le faire. Si nécessaire, traiter avec un script de post-traitement ponctuel en manipulant directement project.json (copier les boucles du glyphe cible, les redimensionner, repositionner les coordonnées), sans toucher à la logique build de pipeline.js.

QA structurelle (quand l'aperçu visuel est impossible)

Si on ne peut pas voir l'image rendue, ouvrir les données des glyphes dans project.json et vérifier :

  • Sens d'enroulement des contours : l'aire signée (formule du lacet) du contour extérieur doit être de signe opposé à celle des contre-formes (intérieur) — sinon ces dernières risquent de ne pas être perforées à l'affichage.
  • Auto-intersection : vérifier O(n²) si des segments non adjacents d'une même boucle se croisent.
  • Segments anormaux : repérer les segments dont la longueur est >4× la moyenne ou <0.5 (à titre indicatif, car de longs segments droits comme les jambages sont normaux).
  • Mesure de hauteur/espacement : utiliser BoundsPen et la table hmtx de fontTools pour extraire top/bottom/advance/RSB de lettres spécifiques et les comparer aux valeurs cibles. uharfbuzz permet aussi de mesurer la largeur de mise en forme réelle (crénage inclus).

Si même ce diagnostic ne révèle aucun défaut (ex. "une partie de la lettre semble arrachée"), admettre honnêtement "structurellement aucun défaut, mais je ne peux pas voir le rendu dans cet environnement" et demander une capture d'écran agrandie.

Note technique

  • Métriques : unitsPerEm 1000, ascender 760, descender -240 (la somme doit faire 1000 — sinon tout le texte est décalé verticalement)
  • Hauteur médiane capitales+chiffres → normalisation à 700. Ligne de base de la rangée = médiane des y du bas de la rangée (le débordement/descendant sont naturellement négatifs, donc préservés)
  • Règle de fusion : seuls les petits fragments (surface <30%) sont absorbés par un fragment plus grand — pour les points du i/j, les cheveux cassés. Interdiction de fusionner des fragments appartenant à des lettres différentes ! (empêche que le descendant d'une fioriture ne mange la lettre de la ligne du dessous)
  • Filtre de rangées : supprimer les rangées dont la hauteur médiane (bigH) est en dehors d'un facteur 0.5–1.28 par rapport à la hauteur médiane des plus grands fragments (supprime les rangées d'en-tête/légende/échantillon géant). Ce filtre n'est pas parfait ; si le compte n'est pas standard, regarder absolument la contact sheet.
  • Les étiquettes en double sont ignorées (seule la première compte).
  • Phénomène d'escalier d'arrondi des coordonnées em (corrigé) : lors de la conversion des coordonnées pixel en unités em (5–6× de grossissement), arrondir chaque point indépendamment provoquait un décalage imperceptible mais visible sur les lignes droites, créant un effet d'escalier. glyphFromCrop applique une simplification supplémentaire avec une tolérance très faible (2.2 unités) juste après l'arrondi pour éliminer ce zigzag résiduel. Ce problème ne disparaît pas en augmentant la résolution (au contraire, il devient plus visible).
  • Lissage des contours : traceBinary, en suivant les pixels, génère un bruit en escalier que smoothPolyline (conservation des coins, angles <71° lissés par moyenne avec les voisins) supprime avant la simplification rdpClosed. Le seuil d'angle de 71° préserve les vraies cassures (comme les embruns d'empattement) et traite le reste en courbes.
  • Bug du point de départ des contours (corrigé, 2026-11) : les pointes aux endroits arrondis (comme le sommet du S). La cause n'était pas le lissage des bords ou la résolution mais l'étape d'enregistrement sur fichier — loopsToPath passait les points médians et les points de contrôle de Bézier en virgule flottante, et opentype.js, dans le CFF, arrondissait les coordonnées relatives point par point. L'erreur s'accumulait sur une boucle, décalant le point de fermeture de 5–15 unités, et closePath reliait cet écart par une ligne droite, créant une épine (présente dans presque tous les symboles, plus visible dans le S). Maintenant, toutes les coordonnées sont transmises sous forme d'entiers arrondis. Cela n'est pas visible dans project.json ; si soupçon, vérifier directement les commandes de dessin dans le .otf final, comme dans le "test de fermeture".
  • Format de sortie : .otf (installation et utilisation identiques à .ttf). Si l'utilisateur veut absolument du .ttf, lui conseiller d'ouvrir avec FontForge et d'exporter.

Individual skills in this repo

This repo contains 1 individual skill — each has its own dedicated page.

Skills associés