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.pypour 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.pyest 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'ordreidecomps.json= ordre de lecture)
- 26 =
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 :
→ Regarder contact.png avec l'outil view et identifier visuellement chaque caractère. Écrirepython3 contact_sheet.py /tmp/ff/work /tmp/ff/contact.pnglabels.jsonavec 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.
- 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
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 desegment. 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 construirecomps.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.jsonpuis reconstruire avecnode 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
- 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é). - 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
downloadspour 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_utilisateuravec 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.
- Basé sur
- 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).
- À 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 avecnode 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.
patchtraite "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"),
patchtrouve 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
patchn'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) :
edgeCurvinessmesure 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 lescaleoriginal (actuellement 0.7%/1.2%). UtiliserDEBUG_SHAPE=1 node pipeline.js build ...pour voir topFlat/botFlat/nativeH sur stderr. - Clustering naturel du x-height : trier les
nativeHde 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
BoundsPenet la tablehmtxde fontTools pour extraire top/bottom/advance/RSB de lettres spécifiques et les comparer aux valeurs cibles.uharfbuzzpermet 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.
glyphFromCropapplique 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 quesmoothPolyline(conservation des coins, angles <71° lissés par moyenne avec les voisins) supprime avant la simplificationrdpClosed. 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 —
loopsToPathpassait 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.