Image to Fonts — Imagen de hoja de muestra → Fuente OTF
Pipeline validado: binarización → separación de componentes conectados (fusión de puntos/fragmentos) → estimación de filas/líneas base → trazado de vectores (recorrido de contornos + suavizado con preservación de esquinas + RDP cerrado) → redondeo de coordenadas em + limpieza secundaria → normalización de mayúsculas a 700 → corrección de overshoot óptico/sidebearings → empaquetado OTF con opentype.js. El overshoot (la O sobresale ligeramente por debajo de la línea base) y los florituras (cola de la Q, etc.) se dibujan tal cual, preservándose automáticamente.
Paso 0 — Preguntar primero el nombre de la fuente
Cuando llegue una imagen, pregunta primero el nombre de la fuente antes de empezar (p. ej., "¿Cómo quieres que se llame la fuente?"). Si es solo para inglés, recomienda un nombre en inglés: con nombres en coreano, a veces Photoshop muestra la fuente de forma transparente (el nombre no se ve) en la lista de fuentes. Después de recibir el nombre, continúa. Si el usuario ya ha dicho el nombre, úsalo tal cual.
Al mismo tiempo, verifica: si es una muestra de una fuente comercial con derechos de autor, indica que solo se use para aprendizaje/experimentación personal (si el usuario ya lo sabe, omítelo).
Paso 1 — Verificar la resolución (críticamente importante)
El 90% de los comentarios como "se ve pixelado al ampliar" o "los caracteres tienen diferentes tamaños" se deben a la baja resolución de la imagen original, no al algoritmo. Medición real: comparando una hoja con altura de letra de 85 px y otra de 500 px con la misma letra, el número de puntos de datos de trazado original antes del suavizado fue de 201 frente a 575 (2.9 veces de diferencia); la baja resolución simplemente carece de material para dibujar curvas.
- Al recibir la imagen, primero ejecuta
img2bin.pypara obtener el tamaño convertido (W, H) y estima la altura en píxeles por letra a partir del número aproximado de filas/columnas de la cuadrícula. - Si la altura de las letras está muy por debajo de 150 px (especialmente en el rango de 80-100 px), continúa con el trabajo pero advierte de antemano que "podría verse algo rugoso al ampliar", o mejor, pide primero "exporta la imagen con una altura de letra de al menos 300 px y vuelve a subirla".
- Se pueden recibir varias hojas (p. ej., hoja de mayúsculas + hoja de minúsculas); se fusionan en una sola fuente siguiendo el procedimiento "Fusión de varias hojas" más abajo.
- El límite de redimensionamiento de
img2bin.pyes 3400 px (en el lado más grande, ancho o alto). Si se recibe una imagen original más grande, se aprovechará al máximo dentro de este límite.
Paso 2 — Descomposición de la imagen
cd <carpeta de scripts de esta habilidad>
python3 img2bin.py <imagen_subida> /tmp/ff/sheet.bin # Salida: W H
node pipeline.js segment /tmp/ff/sheet.bin <W> <H> /tmp/ff/work
Revisa count y standard en el JSON de salida de segment:
standard: true(26/52/62 elementos) → Se considera una hoja en orden alfabético. Genera etiquetas automáticamente en el orden de lectura:- 26 =
A~Z, 52 =A~Z a~z, 62 =A~Z a~z 0~9 - Escribe labels.json:
{"0":"A","1":"B",...}(el orden i de comps.json = orden de lectura)
- 26 =
standard: false→ La hoja contiene títulos, adornos, frases de muestra o muestras de palabras. No fuerces las etiquetas en orden (un solo desplazamiento arruinaría toda la fuente). En su lugar:
→ Observa directamente contact.png con la herramienta view e identifica visualmente la letra de cada casilla numerada para escribir labels.json. Las decoraciones o ilegibles se marcan comopython3 contact_sheet.py /tmp/ff/work /tmp/ff/contact.png"skip". Si la misma letra aparece varias veces, usa solo la más limpia; el resto,"skip". (No uses"?"para fragmentos desechados, ya que representaría el signo de interrogación real).- Aprovecha la estructura de filas si es visible: si es una hoja alfabética con filas de encabezado/muestra antes/después, busca filas de 13 elementos (= A-M / N-Z / a-m / n-z) y etiqueta solo esas; todas las demás filas se marcan como
"skip". - Si es una muestra de palabras (p. ej., "MODERN SERIF"), informa al usuario de antemano que solo las letras presentes se incluirán en la fuente.
- Aprovecha la estructura de filas si es visible: si es una hoja alfabética con filas de encabezado/muestra antes/después, busca filas de 13 elementos (= A-M / N-Z / a-m / n-z) y etiqueta solo esas; todas las demás filas se marcan como
Fusión de varias hojas (p. ej., mayusculas.png + minusculas.png)
python3 img2bin.py mayusculas.png /tmp/ff/upper.bin # Salida: W H
python3 img2bin.py minusculas.png /tmp/ff/lower.bin # Salida: 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
Fusiona los dos archivos comps.json resultantes (renumerando los índices de recorte para que no se superpongan y copiando también los archivos crops). Escribe el labels.json fusionado (índices de mayúsculas → A-Z, índices de minúsculas → a-z) y luego ejecuta build solo una vez. De esta manera, la escala basada en mayúsculas (capMed) se aplica de manera consistente a ambos conjuntos. (Consulta el historial de la sesión anterior para ver un script de ejemplo de fusión: simplemente concatena los dos arrays comps.json con Python y copia los archivos de la carpeta crops/).
Hoja de números y símbolos
Las etiquetas no solo pueden ser letras y números, sino también símbolos de un solo carácter tal cual ("!", "@", "?", "’", etc.). Los nombres de glifo se convierten automáticamente a nombres estándar como exclam, at, question, y el kerning solo se aplica a pares de letras y números.
- Las hojas de símbolos (
!·?·;·%·=, etc.) tienen muchos caracteres compuestos por varios fragmentos y puntos/comillas pequeños, por lo que la fusión automática y el filtrado de filas de segment suelen fallar (fusionando símbolos vecinos en un solo bloque o descartando filas pequeñas por completo). Si el recuento no coincide con lo esperado, verifica con la hoja de contactos; si está incorrecta, extrae los componentes conectados directamente, mira la imagen numerada y agrupa los fragmentos por carácter para crearcomps.json/crops/manualmente (con el mismo formato que la salida de segment: i, row, x0..y1, baseline, cropW, cropH, offX, offY). Si los números son más pequeños que las mayúsculas en la hoja, escala la imagen primero para igualar los tamaños. - Los símbolos que no están en la hoja se pueden combinar a partir de fragmentos existentes:
"= dos comillas,:= dos puntos,.= punto,,= coma. - La disposición en la hoja difiere de la posición tipográfica. Después de construir, corrige las posiciones en el project.json y vuelve a ejecutar
node pipeline.js rebuild <project.json> <out.otf>para regenerar (con cap 700 como referencia):- + = ~ < > *centrados verticalmente ≈340, comillas con extremo superior ≈705,_con extremo superior ≈-60,[ ]ajustados a la altura de( ). Muchas hojas tienen la última fila de letras dibujadas inusualmente pequeñas (XYZ, etc.), así que verifica la altura también; después de la corrección, informa al usuario. - Si solo hay una hoja de mayúsculas, copia los glifos de mayúsculas en a–z para que las minúsculas también sean visibles (informa al usuario). El kerning también se duplica para pares de minúsculas y pares mixtos mayúscula-minúscula mediante
apply_kerning.py.
Paso 3 — Construcción de la fuente + control de calidad
Cierre de contornos — El error "pico saliente en el punto de inicio" está corregido en pipeline.js
El error que producía picos en lugares que deberían ser redondeados (como la parte superior de la S) se ha corregido haciendo que loopsToPath pase todas las coordenadas como enteros (consulta la nota de ingeniería a continuación). Aun así, después de cada compilación, verifica con la siguiente prueba.
Prueba de cierre (siempre incluida en el QA posterior a la compilación; el resultado debe ser 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('Glifos con cierre de contorno desalineado:', len(bad), bad[:10])
EOF
node pipeline.js build /tmp/ff/work /tmp/ff/labels.json "<nombre_fuente>" /tmp/ff/font.otf /tmp/ff/project.json
Después de la compilación, realiza obligatoriamente la limpieza de compatibilidad Mac/Windows y la validación:
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" "<nombre_fuente>" /tmp/ff/font_final.otf
fontbakery check-opentype /tmp/ff/font_final.otf --loglevel FAIL 2>&1 | grep -c "Result: FAIL" # Debe ser 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 "<nombre_fuente>"
Revisa qc.png directamente con view. Sin embargo, en este entorno, a veces no es posible ver realmente la imagen renderizada con view según la sesión. En ese caso, realiza la máxima verificación posible con el diagnóstico estructural (ver sección "QA estructural" más abajo). Si aún así no se detectan defectos, admite honestamente que "no puedo verlo" y pide al usuario una captura de pantalla ampliada que muestre la parte problemática: no finjas haber visto algo que no ves ni hagas correcciones basadas en conjeturas.
Paso 4 — Entrega de resultados
- Copia a
/mnt/user-data/outputs/:<nombre_fuente>.otf+<nombre_fuente>_project.json(el project.json es necesario para futuros reemplazos y ajustes, así que entrégale ambos e indícale que los guarde). Empaqueta ambos archivos en un zip y entrégalo también (por si el entorno bloquea la descarga directa del .otf). - Artefacto de vista previa HTML (usando
make_preview.py): un solo archivo con el .otf incrustado en base64.- Se genera a partir de
preview_template.html(carpeta assets). Composición:- Título superior "Image to Font Skill"
- Nombre de la fuente renderizado en grande con esa fuente + tabla completa de caracteres (incluye mayúsculas, minúsculas, números y símbolos presentes en la fuente real, con su cantidad)
- Una línea de texto de muestra definida por el usuario
- Probador de escritura (Type Tester) — campo de entrada + controles deslizantes de tamaño (16–160 px) y espaciado entre letras. Debajo de la tarjeta de muestra, encima de la tarjeta de descarga.
- Botón [Descargar archivo de fuente (.otf)] — si el HTML se abre localmente, guarda el .otf directamente; en el visor de artefactos de Claude, usa la función
downloadspara guardar<nombre>.zip(con el .otf dentro) (el visor bloquea las descargas directas de páginas y no permite la extensión .otf). Al publicar como artefacto, debes declarar la función{downloads: true}para que el botón funcione; de lo contrario, al hacer clic no ocurrirá nada. - Tarjeta informativa "¿Hay alguna letra que quieras cambiar?" — no es una función para adjuntar/modificar dentro de este HTML, sino un aviso estático que dice "vuelve a esta ventana de chat y adjunta una imagen de la letra" (sin botones ni JS, solo texto estático). El reemplazo de letras se maneja únicamente a través del chat — nunca incluyas funciones de adjuntar archivos, arrastrar y soltar, o descarga de zip dentro del HTML (antes se incluyeron, pero solo añadían complejidad y nunca se usaron realmente).
- Pie de página con derechos de autor
© @handle_usuario+ texto "Se solicita atribución al compartir/usar".
- La vista previa, además de publicarse como artefacto, siempre se entrega también como archivo HTML (junto con el .otf, el project.json y el zip). Si el entorno no permite declarar la función de descarga, indica al usuario que reciba la fuente a través de la tarjeta de archivo del chat.
- Se genera a partir de
- Entrega los archivos (.otf, project.json, zip, preview.html) + un resumen de cuántos caracteres se reconocieron, cuáles faltan y las instrucciones de instalación (doble clic en .otf).
- Al final del mensaje de entrega, pregunta siempre (puedes preguntar ambas cosas a la vez):
- "Si alguna letra se ve extraña o quieres cambiarla, adjunta una imagen ampliada de esa letra en esta conversación (se recomienda una altura de letra de al menos 150 px)."
- "¿Hay algo más que quieras ajustar, como el espaciado entre letras o la forma de alguna letra?"
Si el usuario adjunta una imagen, sigue el procedimiento de "Reemplazo de letras (patch)" a continuación; si da comentarios sobre el espaciado, vuelve a compilar ajustando solo las constantes en
/tmp/ff/worken caché (no es necesario volver a subir la imagen).
Reemplazo de letras (patch) — Retrabajar letras específicas con imágenes de alta resolución
Si al usuario no le gusta una letra específica y sube una imagen grande de esa letra:
python3 img2bin.py <imagen_ampliada> /tmp/ff/patch.bin # Salida: W H
node pipeline.js patch <ruta_project.json> /tmp/ff/patch.bin <W> <H> <letra> /tmp/ff/font.otf /tmp/ff/project.json
- El project.json puede haber sido adjuntado por el usuario (de una sesión anterior) o estar en /tmp de la misma sesión. Si no está, pídelo.
- patch trata "la tinta de toda la imagen = una sola letra" (no selecciona solo el fragmento más grande basado en componentes conectados). Esto asegura que detalles separados del trazo, como un remolino decorativo dentro de la O, se conserven por completo; antes, solo se elegía el fragmento más grande, lo que hacía que esos detalles desaparecieran por completo.
- Si una imagen contiene varias letras juntas (p. ej., "Z" y "H" una al lado de la otra), encuentra automáticamente el punto donde la densidad de tinta en dirección de columna es casi cero para separarlas y aplicar patch a cada una.
- Se alinea automáticamente con la altura y el punto más bajo (incluyendo overshoot/descendente) de la letra existente, sin preocuparse por el tamaño. Después del reemplazo, recompila → QA (fontbakery/OTS) → actualiza la vista previa → vuelve a entregar.
- Agregar nuevas letras minúsculas como g/j/p/q/y mediante patch no es posible porque no se puede estimar su línea base; indica que se cree una hoja completa.
Ajuste fino del espaciado y la forma de las letras (sin necesidad de volver a subir)
Si los segmentos originales están en caché en /tmp/ff/work (o en work_merged fusionado), puedes ajustar solo las constantes en pipeline.js y volver a ejecutar node pipeline.js build .... Puntos ajustables (todos dentro del comando build):
- Espaciado base (sidebearings): factor de la fórmula de
LSB(actualmente 0.66) — reducir lo hace más estrecho en general - Ancho del espacio entre palabras: factor de la fórmula de
spaceAdv(actualmente LSB×5.4) - Intensidad del kerning: umbral de activación (actualmente -3) y ancho máximo de ajuste (actualmente -190) — suavizar el umbral (p. ej., a -1) atrae más pares
- Sidebearings ópticos (independientes izquierda/derecha): solo se reduce el lado (leftStd/rightStd medido por
edgeCurviness) que supere el umbral (cropW×0.02) al 72% actual. Debe calcularse de forma independiente para izquierda y derecha — usar el mismo valor para ambos lados en letras con un solo lado curvo (como el bucle izquierdo de la j, con la columna derecha recta) provocaba que el lado recto se estrechara injustamente (se descubrió con el comentario "la j parece pegada a la letra siguiente"). - Overshoot óptico por letra: la "proporción de planitud" en los extremos superior e inferior (ancho de una banda delgada en el extremo ÷ ancho de una banda un poco más adentro, midiendo desde el punto donde termina el bracket del serif, actualmente en puntos ´H0.03
/H0.15con umbral 0.62) determina automáticamente topFlat/botFlat. Las letras completamente planas (puramente flat) usan factor 1.0; si solo un lado es plano, 1+OVERSHOOT_HALF; si ninguno, 1+OVERSHOOT_ROUND, multiplicado por lascaleoriginal (actualmente 0.7%/1.2% respectivamente). Se puede verificar topFlat/botFlat/nativeH por letra conDEBUG_SHAPE=1 node pipeline.js build ...` en stderr. - Agrupación natural de la altura x (x-height): independientemente de la presencia de ascendentes/descendentes (no filtres candidatos por descendente:
nativeHmide la distancia desde la línea base hasta la parte superior, sin relación con los descendentes), ordena elnativeHde todas las minúsculas, encuentra el espacio más grande (gap) y selecciona solo el grupo inferior (solo si representa ≥35% del total) para alinearlo con precisión a una altura de referencia común. Se usa para alinear letras de altura x pura (v, w, x, y, z) que pueden tener pequeñas variaciones en la altura superior.
Lo que nunca debes hacer — error grave que ocurrió realmente: Nunca uses el método de "reajustar forzosamente todas las minúsculas a una altura objetivo basada en la altura x" porque aplastaría también los ascendentes (b, d, f, h, i, j, k, l, etc.) hasta la altura x, haciendo la fuente mucho más pequeña que la original (recibiendo inmediatamente una solicitud de reversión con un comentario como "¿es broma?"). El método correcto: nunca modifiques la scale global de la imagen original; solo multiplica la escala de cada letra individual por un factor muy pequeño (p. ej., 1.007~1.012) para agrandarla ligeramente. El agrupamiento de la altura x también está diseñado para no incluir nunca letras fuera del grupo (ascendentes, etc.).
Las diferencias reales de tamaño en la imagen original (p. ej., si una letra específica se dibujó realmente más grande en la hoja) no son algo que el algoritmo deba corregir; pregunta al usuario si ese era el diseño previsto.
Solicitudes de derivar una letra específica de otra letra de la fuente (p. ej., "haz la minúscula s como una versión reducida de la S mayúscula") no deben incluirse como funcionalidad estándar de esta habilidad — se ha recibido la instrucción explícita de "aplícalo solo esta vez, no lo integres en la lógica de la habilidad". Si es necesario, manéjalo con un script de posprocesamiento único que manipule directamente el project.json (copia los bucles del glifo de destino, los escala a la altura deseada y recoloca las coordenadas), sin modificar la lógica build de pipeline.js.
QA estructural (cuando no se puede ver directamente con view)
En sesiones donde no se pueda ver la imagen renderizada, puedes inspeccionar directamente los datos de glifos en el project.json para verificar lo siguiente:
- Dirección de enrollado del contorno: verifica que el área con signo (fórmula del cordón de zapato) de los bucles del contorno exterior y del contorno interior (counter) tengan signos opuestos; si son iguales, el interior podría no perforarse al renderizar.
- Autointersecciones: verifica si segmentos no adyacentes dentro de un bucle se cruzan (prueba O(n²)).
- Segmentos anómalos: segmentos con una longitud 4 veces mayor que la media o menor de 0.5 (aunque las columnas rectas pueden ser largas de forma normal; úsalo como referencia).
- Medición de altura/espaciado: con
BoundsPeny la tablahmtxde fontTools, extrae el top/bottom/advance/RSB de letras específicas y compáralos con los valores objetivo. También se puede medir el ancho de shape real (incluyendo kerning) conuharfbuzz.
Si incluso con estos diagnósticos no se detecta un problema (p. ej., "parte de la letra parece desgarrada"), admite honestamente que "no se detectan defectos estructurales, pero no puedo ver el renderizado en este entorno" y pide una captura de pantalla ampliada.
Nota de ingeniería
- Métricas: unitsPerEm 1000, ascender 760, descender -240 (la suma debe ser exactamente 1000; si no, todas las letras se desplazan verticalmente)
- Mediana de la altura de mayúsculas y números → normalización a 700. Línea base de la fila = mediana de las y del fondo de esa fila (el overshoot y los descendentes se conservan naturalmente como valores negativos)
- Regla de fusión: solo los fragmentos pequeños (área <30%) se absorben en fragmentos grandes — para el punto de la i/j y líneas finas rotas. Nunca fusiones letras entre sí (para evitar que un descendente con floritura se trague la letra de la fila inferior)
- Filtro de filas: elimina filas fuera del rango de 0.5~1.28 veces la altura mediana (bigH) de los fragmentos con mayor área (filas de encabezado/descripción/muestras muy grandes). Este filtro tampoco es perfecto; si el recuento no es estándar, revisa la hoja de contactos visualmente
- Las etiquetas duplicadas solo usan la primera
- Efecto de escalera por redondeo de coordenadas em (corregido): al convertir coordenadas de píxeles a unidades em finales (normalmente 5-6 veces de ampliación), redondear cada punto de forma independiente podía hacer que secciones perfectamente rectilíneas en el original se desalinearan ligeramente, pareciendo escalones.
glyphFromCroprealiza una simplificación adicional con una tolerancia muy pequeña (2.2 unidades) inmediatamente después del redondeo para eliminar este zigzag residual. Este problema no desaparece automáticamente al aumentar la resolución (de hecho, se hace más evidente cuanto mayor es el factor de ampliación). - Suavizado de contornos:
traceBinaryelimina primero el ruido escalonado producido al caminar por los bordes de los píxeles mediantesmoothPolyline(con preservación de esquinas, solo suaviza los puntos con ángulo de curvatura menor de 71 grados promediándolos con sus vecinos) antes de la simplificaciónrdpClosed. El umbral de detección de esquinas también se ha suavizado a 71 grados para mantener solo las esquinas realmente angulosas (como los brackets de los serifs) y tratar el resto como curvas. - Pico saliente en el punto de inicio del contorno (corregido, 2026-11): El antiguo error que producía picos en lugares redondeados (como la parte superior de la S). La causa no era el refinamiento de bordes ni la resolución, sino la etapa de escritura del archivo — cuando
loopsToPathpasaba puntos medios y puntos de control bezier como decimales, opentype.js los redondeaba individualmente al escribir las coordenadas relativas en CFF, acumulando errores durante un bucle completo hasta que el punto final se desviaba 5-15 unidades del punto inicial, y closePath unía ese espacio con una línea recta, creando un pico (existía en casi todas las letras, pero era más visible en la S, que tiene muchos puntos). Ahora todas las coordenadas se redondean a enteros antes de pasarlas. Como esto no se ve en absoluto en el project.json, si se sospecha, verifica directamente los comandos de dibujo del .otf final como en la "Prueba de cierre". - El formato de salida es .otf (la instalación y el uso son idénticos a .ttf). Si el usuario realmente quiere TTF, indica que lo abra en FontForge y seleccione Generate.