CommunityImagemgithub.com

image-to-fonts

Converte imagens de amostras de fontes em arquivos OTF instaláveis. Use esta skill quando o usuário solicitar a criação de uma fonte a partir de uma imagem de glifos.

O que é image-to-fonts?

Esta skill pega uma imagem contendo uma amostra de fonte (como uma folha de caracteres A-Z, a-z, 0-9) e a transforma em um arquivo de fonte OTF pronto para instalação. O pipeline inclui binarização, separação de componentes conectados, estimativa de linha e linha de base, rastreamento vetorial com suavização preservando cantos, normalização de altura para 700 unidades por em, correção óptica de overshoot e sidebearings, e empacotamento usando opentype.js. A skill suporta correção de caracteres individuais via um comando `patch`, mesclagem de várias folhas (maiúsculas + minúsculas) e ajustes finos de kerning e espaçamento. O resultado final é um arquivo .otf, um arquivo project.json para edição futura e um HTML de pré-visualização inline. Ela é projetada para lidar com imagens de baixa resolução, emitindo avisos quando a altura dos caracteres for inferior a 150px, e oferece um processo de QA estrutural para verificar fechamento de contornos, direção dos loops e auto-interseções.

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

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

Perguntar na sua IA favorita

Abre um novo chat com esta habilidade de agente já pré-carregada.

Documentação

Image to Fonts — Amostra de Folha → Fonte OTF

Pipeline validado: binarização → separação de componentes conectados (mesclagem de pontos/fragmentos) → estimativa de linha/linha de base → rastreamento vetorial (caminhada de contorno + suavização com preservação de cantos + RDP fechado) → arredondamento de coordenadas em unidades em seguido de simplificação → normalização de maiúsculas para 700 → correção óptica de overshoot/sidebearings → empacotamento OTF via opentype.js. Overshoot (por exemplo, O ligeiramente abaixo da linha de base) e floreios (como cauda do Q) são traçados fielmente e preservados automaticamente.

Etapa 0 — Pergunte o nome da fonte primeiro

Quando a imagem chegar, pergunte o nome da fonte antes de começar (por exemplo, "Qual vai ser o nome da fonte?"). Se for apenas caracteres latinos, recomende um nome em inglês — nomes em coreano podem aparecer invisíveis (transparentes) na lista de fontes do Photoshop, etc. Após receber o nome, prossiga. Se o usuário já disse o nome, use-o.

Ao mesmo tempo, verifique: se for uma amostra de fonte comercial com direitos autorais, avise que é apenas para uso pessoal/experimental (pule se o usuário já souber).

Etapa 1 — Verifique a resolução (fundamentalmente a mais importante)

"Parece pixelado quando ampliado", "Os caracteres têm tamanhos diferentes" — 90% desses feedbacks não são do algoritmo, mas da baixa resolução da imagem original. Medição real: folha com altura de 85px vs 500px para o mesmo caractere resultou em 201 pontos vs 575 pontos (2,9x de diferença) nos dados de rastreamento antes da suavização — baixa resolução simplesmente não tem material suficiente para curvas.

  • Ao receber a imagem, primeiro use img2bin.py para obter o tamanho (W, H) e estime a altura em pixels por caractere com base em quantas linhas/colunas.
  • Se a altura do caractere for muito inferior a 150px (especialmente 80–100px), prossiga com o trabalho, mas avise que "pode ficar um pouco áspero quando ampliado" ou, melhor, peça para o usuário recapturar/exportar a imagem com altura de caractere de 300px ou mais.
  • É aceitável receber várias folhas separadas (como folha de maiúsculas + minúsculas) — siga o procedimento de mesclagem abaixo para combinar em uma única fonte.
  • O limite de redimensionamento do img2bin.py é 3400px (no lado maior). Imagens maiores que isso serão usadas dentro desse limite.

Etapa 2 — Decomposição da imagem

cd <pasta de scripts desta skill>
python3 img2bin.py <imagem_upload> /tmp/ff/sheet.bin   # saída: W H
node pipeline.js segment /tmp/ff/sheet.bin <W> <H> /tmp/ff/work

Verifique count e standard no JSON de saída do segment:

  • standard: true (26/52/62) → considerada uma folha em ordem alfabética. Gere rótulos automaticamente na ordem de leitura:
    • 26 = A~Z, 52 = A~Z a~z, 62 = A~Z a~z 0~9
    • Crie labels.json: {"0":"A","1":"B",...} (a ordem i no comps.json = ordem de leitura)
  • standard: false → a folha contém títulos, decorações, amostras de texto ou palavras. NÃO force rótulos em ordem (um único deslocamento arruína a fonte inteira). Em vez disso:
    python3 contact_sheet.py /tmp/ff/work /tmp/ff/contact.png
    
    → Veja o contact.png diretamente com a ferramenta view e identifique visualmente o caractere em cada célula numerada para escrever o labels.json. Para decorações/ilegíveis, use "skip". Se o mesmo caractere aparecer várias vezes, mantenha o mais limpo como caractere e marque os outros como "skip". (Não use "?" para fragmentos descartados, pois ele se tornaria um ponto de interrogação real.)
    • Use a estrutura de linhas se visível: se for uma folha alfabética com linhas de cabeçalho/amostra intercaladas, encontre 4 linhas de 13 caracteres (A-M / N-Z / a-m / n-z) e rotule apenas essas linhas em ordem, marcando o resto como "skip".
    • Se for uma amostra de palavra (ex: "MODERN SERIF"), avise ao usuário que apenas as letras presentes entrarão na fonte.

Mesclagem de várias folhas (ex: maiúsculas.png + minúsculas.png)

python3 img2bin.py maiusculas.png /tmp/ff/upper.bin   # saída: W H
python3 img2bin.py minusculas.png /tmp/ff/lower.bin   # saída: 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

Mescle os dois comps.json (renumere os índices de crop para não sobrepor e copie os arquivos crops também), crie um labels.json mesclado (índices de maiúsculas → A-Z, minúsculas → a-z) e execute o build apenas uma vez. Isso garante que a escala de maiúsculas (capMed) seja aplicada consistentemente aos dois conjuntos. (Um script de exemplo para mesclagem está em registros de sessão anteriores — use Python para concatenar os dois arrays comps.json e copiar os arquivos crops/.)

Folha de números/símbolos

Além de letras e números, os rótulos podem incluir símbolos de um caractere diretamente ("!", "@", "?", "’", etc.). Os nomes dos glifos são convertidos automaticamente para nomes padrão (exclam, at, question, etc.), e o kerning é aplicado apenas a pares de letras/números.

  • Folhas de símbolos (!, ?, ;, %, =, etc.) têm muitos fragmentos (pontos pequenos, aspas) e a mesclagem/filtro de linhas do segment frequentemente erra (mescla símbolos vizinhos ou descarta linhas pequenas). Se a contagem for diferente do esperado, verifique com a contact sheet e, se estiver errada, extraia os componentes conectados manualmente, veja a imagem numerada, agrupe fragmentos por caractere e crie comps.json/crops/ diretamente (formato igual ao resultado do segment: i, row, x0..y1, baseline, cropW, cropH, offX, offY). Se a folha tiver números desenhados menores que as maiúsculas, redimensione a imagem primeiro para equalizar os tamanhos.
  • Símbolos ausentes na folha podem ser compostos a partir de fragmentos existentes: " = duas aspas, : = dois pontos, . = ponto, , = vírgula.
  • O layout na folha é diferente da posição tipográfica. Após o build, corrija as posições no project.json e execute node pipeline.js rebuild <project.json> <out.otf> (base cap 700): - + = ~ < > * com centro vertical ≈340, aspas com topo ≈705, _ com topo ≈-60, [ ] na altura de ( ). Muitas folhas têm a última linha desenhada excepcionalmente pequena (XYZ, etc.) — verifique a altura também. Informe o usuário sobre as correções.
  • Se for uma folha apenas com maiúsculas, copie os glifos maiúsculos para a–z para que apareçam como minúsculas (avise o usuário). O kerning também deve ser duplicado para pares de minúsculas e mistos, usando apply_kerning.py.

Etapa 3 — Build da fonte + QA de qualidade

Fechamento de contorno — o bug de "ponta pontiaguda no início" foi corrigido no pipeline.js

O bug que criava um espinho em lugares arredondados (como o topo do S) foi corrigido fazendo o loopsToPath passar todas as coordenadas como inteiros (veja nota de engenharia abaixo). Mesmo assim, a cada build, verifique com o teste abaixo.

Teste de fechamento (sempre incluso no QA pós-build; resultado deve 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 com fechamento incorreto:', len(bad), bad[:10])
EOF
node pipeline.js build /tmp/ff/work /tmp/ff/labels.json "<NomeFonte>" /tmp/ff/font.otf /tmp/ff/project.json

Após o build, faça a limpeza e validação de compatibilidade 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" "<NomeFonte>" /tmp/ff/font_final.otf
fontbakery check-opentype /tmp/ff/font_final.otf --loglevel FAIL 2>&1 | grep -c "Result: FAIL"   # Deve 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 "<NomeFonte>"

Verifique o qc.png diretamente com view. No entanto, neste ambiente, dependendo da sessão, pode não ser possível ver a imagem renderizada pelo view. Nesse caso, use o diagnóstico estrutural (seção "QA Estrutural" abaixo) ao máximo e, se mesmo assim não detectar defeitos, admita honestamente que "não estou vendo" e peça ao usuário uma captura de tela ampliada da parte problemática — não finja que viu algo ou faça correções especulativas.

Etapa 4 — Entrega dos resultados

  1. Copie para /mnt/user-data/outputs/: <NomeFonte>.otf + <NomeFonte>_project.json (o project.json é necessário para troca de caracteres e reajustes futuros, então entregue junto e peça para guardar). Empacote os dois também em um zip para entrega (caso o download direto de .otf seja bloqueado).
  2. Artefato de pré-visualização HTML (usando make_preview.py): um único arquivo com o otf embutido em base64.
    • Baseado em preview_template.html (pasta assets). Composição:
      • Título no topo "Image to Font Skill"
      • Nome da fonte renderizado grande com a fonte + tabela de caracteres (mostrando maiúsculas, minúsculas, números, símbolos presentes, com contagem)
      • Uma linha com a frase de amostra escolhida pelo usuário
      • Teste de digitação (Type Tester) — campo de entrada + controles deslizantes de tamanho (16–160px) e espaçamento. Abaixo do cartão de amostra, acima do cartão de download.
      • Botão [Baixar arquivo de fonte (.otf)] — se aberto localmente, salva o .otf; no visualizador de artefatos Claude, usa a funcionalidade downloads para salvar <Nome>.zip (contendo .otf). Para o botão funcionar, ao publicar como artefato, declare {downloads: true} — sem isso, o botão não responde.
      • Cartão informativo "Tem algum caractere que deseja substituir?" — é um aviso estático (sem botão ou JS) dizendo para o usuário voltar ao chat e anexar a imagem do caractere. A substituição é tratada apenas pelo chat — não coloque anexo de arquivo, drag-and-drop ou download zip dentro do HTML (já foi tentado antes e só adicionou complexidade sem uso real).
      • Rodapé com © @handle_do_usuario + texto "Solicita-se atribuição ao compartilhar/usar".
    • A pré-visualização deve ser entregue como arquivo HTML separado, junto com o otf, project.json e zip. Se o ambiente não suportar a declaração de download, avise que a fonte será recebida pelo cartão de arquivo no chat.
  3. Entregue os arquivos (.otf, project.json, zip, preview.html) + resumo de quantos caracteres foram reconhecidos, os que faltam e instruções de instalação (clique duplo no .otf).
  4. No final da mensagem de entrega, pergunte obrigatoriamente (pode perguntar ambos de uma vez):
    • "Se houver caracteres com formato estranho ou que você queira trocar, anexe uma imagem ampliada desse caractere a esta conversa (altura recomendada de 150px ou mais)."
    • "Há mais algum ajuste que você gostaria de fazer, como espaçamento ou formato das letras?" Se o usuário anexar uma imagem, siga o procedimento de "substituição de caractere (patch)" abaixo; se der feedback de espaçamento, recompile com constantes ajustadas a partir do cache em /tmp/ff/work (sem necessidade de reupload).

Substituição de caractere (patch) — Retrabalho de um caractere específico com imagem de alta resolução

Se o usuário não gostar de um caractere específico e enviar uma imagem ampliada dele:

python3 img2bin.py <imagem_ampliada> /tmp/ff/patch.bin    # saída: W H
node pipeline.js patch <caminho_project.json> /tmp/ff/patch.bin <W> <H> <caractere> /tmp/ff/font.otf /tmp/ff/project.json
  • O project.json pode ter sido enviado pelo usuário (sessão anterior) ou estar em /tmp da sessão atual. Se não existir, peça.
  • O patch trata toda a tinta da imagem como um único caractere (não seleciona apenas o maior fragmento de componente conectado). Isso garante que detalhes como ornamentos dentro do O (ex: redemoinhos) sejam preservados — antes, selecionar apenas o maior fragmento fazia esses detalhes desaparecerem completamente.
  • Se a imagem contiver vários caracteres lado a lado (ex: "Z" e "H"), o patch encontra automaticamente pontos onde a densidade de tinta na direção da coluna é próxima de zero, separa e aplica patch em cada um.
  • A altura e o ponto mais baixo (incluindo overshoot/descendente) do caractere existente são automaticamente alinhados, sem preocupação com tamanho. Após a substituição, recompile → QA (fontbakery/OTS) → atualize a pré-visualização → re-entrega.
  • Adicionar novos caracteres minúsculos como g/j/p/q/y via patch não é suportado (impossível estimar a linha de base) — peça para criar uma folha completa.

Ajuste fino de espaçamento e formato (sem reupload)

Se os segmentos originais estiverem em cache em /tmp/ff/work (ou work_merged para mesclagens), basta ajustar constantes no pipeline.js e executar node pipeline.js build ... novamente. Pontos ajustáveis (todos dentro do comando build):

  • Espaçamento padrão (sidebearings): fator multiplicador do cálculo de LSB (atualmente 0,66) — reduzir para estreitar globalmente.
  • Largura do espaço (space): fator do cálculo de spaceAdv (atualmente LSB×5,4).
  • Intensidade do kerning: limiar de disparo (atualmente -3) e largura máxima de puxada (atualmente -190) — suavizar o limiar (ex: -1) puxa mais pares.
  • Sidebearings ópticos (independentes por lado): edgeCurviness mede leftStd/rightStd e reduz apenas o lado que ultrapassa um limiar (cropW×0,02) em 72%. Deve ser calculado independentemente para cada lado — usar o mesmo valor para ambos os lados em caracteres com um lado curvo e outro reto (ex: j, com anel curvo à esquerda e haste reta à direita) já causou problemas reais (feedback de "j parece grudado no caractere seguinte").
  • Overshoot óptico por caractere: calcula topFlat/botFlat com base na "proporção de achatamento" no topo/base (largura de uma faixa fina no extremo ÷ largura de uma faixa um pouco mais para dentro, medida após o bracket da serifa, atualmente pontos H*0.03/H*0.15, limiar 0,62). Caracteres puramente retos (flat) usam fator 1,0; um lado achatado usa 1+OVERSHOOT_HALF; nenhum lado achatado usa 1+OVERSHOOT_ROUND, multiplicado pela scale original (atualmente 0,7%/1,2%). Use DEBUG_SHAPE=1 node pipeline.js build ... para ver topFlat/botFlat/nativeH no stderr.
  • Agrupamento natural de x-height: ordena o nativeH de todas as minúsculas (independentemente de ascendentes/descendentes — nativeH é distância da baseline ao topo, sem relação com descendentes). Encontra o maior gap e, se o cluster inferior tiver 35% ou mais do total, alinha apenas esse cluster a uma altura comum. Útil para alinhar minúsculas puras (v,w,x,y,z) que têm pequenas variações de altura no topo.

O que NUNCA fazer — bug grave real: NUNCA force o reajuste de todas as minúsculas para a altura alvo da x-height. Isso já achatou ascendentes (b,d,f,h,i,j,k,l, etc.) para a altura da x-height, tornando-os muito menores que o original (recebeu feedback de "é brincadeira?" e foi revertido imediatamente). A abordagem correta: nunca mexa na scale global da imagem original; apenas multiplique a escala de caracteres individuais por fatores muito pequenos (1,007–1,012) para aumentar ligeiramente. O agrupamento de x-height também é projetado para nunca incluir caracteres fora do cluster (ascendentes) no alinhamento.

Diferenças reais de tamanho na imagem original (ex: um caractere foi desenhado maior na folha) não são corrigíveis por algoritmo — pergunte ao usuário se o design original era intencional.

Pedidos para derivar um caractere de outro dentro da fonte (ex: "faça o s minúsculo a partir do S maiúsculo reduzido") não devem ser incorporados como funcionalidade padrão da skill — já foi instruído explicitamente: "aplicar apenas desta vez, não incluir na lógica da skill". Se necessário, crie um script de pós-processamento avulso que manipule o project.json diretamente (copie loops do glifo alvo, escale para a altura desejada e reposicione coordenadas), sem alterar a lógica do build no pipeline.js.

QA Estrutural (quando a visualização direta não for possível)

Em sessões onde a imagem renderizada não pode ser vista, inspecione os dados dos glifos no project.json:

  • Direção dos contornos: verifique se a área com sinal (shoelace formula) dos loops externo e interno (contra-forma) têm sinais opostos — se forem iguais, a contra-forma pode não aparecer na renderização.
  • Auto-interseção: teste O(n²) para interseções entre segmentos não adjacentes dentro de um loop.
  • Segmentos anômalos: segmentos com comprimento 4x maior que a média ou menor que 0,5 (embora hastes retas longas sejam normais).
  • Medição de altura/espaçamento: use BoundsPen e tabela hmtx do fontTools para extrair top/bottom/advance/RSB de caracteres específicos e comparar com alvos. Use uharfbuzz para medir larguras reais de shaping (com kerning).

Se esses diagnósticos não detectarem o problema (ex: "parte do caractere parece arrancada"), admita honestamente: "Estruturalmente não há defeito, mas não consigo ver a renderização neste ambiente" e peça uma captura de tela ampliada.

Notas de engenharia

  • Métricas: unitsPerEm 1000, ascender 760, descender -240 (a soma deve ser exatamente 1000 — caso contrário, todos os caracteres serão deslocados verticalmente).
  • Altura mediana de maiúsculas/números → normalizada para 700. Linha de base de cada linha = mediana do y do fundo daquela linha (overshoot e descendentes são preservados como valores negativos).
  • Regra de mesclagem: apenas fragmentos pequenos (área < 30%) são absorvidos por fragmentos maiores — para pontos de i/j e hairline quebrados. Nunca mescle caracteres entre si (evita que descendentes com floreios engulam caracteres da linha de baixo).
  • Filtro de linhas: remove linhas cuja altura mediana dos maiores fragmentos (bigH) esteja fora do intervalo 0,5–1,28× da mediana geral (remove cabeçalhos, descrições, linhas de amostra muito grandes). Este filtro não é perfeito — se a contagem não for padrão, veja a contact sheet com os olhos.
  • Rótulos duplicados: apenas o primeiro é usado.
  • Degrau de arredondamento em coordenadas em (corrigido): ao converter coordenadas de pixel para em (normalmente 5–6x de ampliação), arredondar cada ponto independentemente pode criar pequenos desalinhamentos em segmentos perfeitamente retos, parecendo degraus. O glyphFromCrop simplifica novamente com uma tolerância muito pequena (2,2 unidades) após o arredondamento para remover esse zigzag residual. Este problema não desaparece com o aumento da resolução (na verdade, fica mais evidente com ampliações maiores).
  • Suavização de contorno: o traceBinary produz ruído de escada ao percorrer bordas de pixels; o smoothPolyline (preservando cantos com ângulo < 71°) suaviza com média de vizinhos antes da simplificação rdpClosed. O limiar de canto foi suavizado para 71° para manter apenas dobras verdadeiras (como brackets de serifa) angulares e tratar o resto como curvas.
  • Ponta pontiaguda no início do contorno (corrigido, 2026-11): o bug antigo que criava espinhos em lugares arredondados (como topo do S) não era devido ao contorno ou resolução, mas à etapa de salvamento em arquivo — o loopsToPath passava pontos médios e pontos de controle Bezier com casas decimais, e o opentype.js, ao escrever CFF, arredondava cada coordenada relativa, acumulando erro ao longo de um loop e fazendo o ponto final divergir 5–15 unidades do inicial, que o closePath conectava com uma linha reta, criando o espinho (presente em quase todos os caracteres, mas mais perceptível no S, que tem muitos pontos). Agora todas as coordenadas são passadas como inteiros. Esse bug nunca era visível apenas no project.json; se suspeitar, verifique os comandos de desenho no .otf final diretamente, como no teste de fechamento.
  • O formato de saída é .otf (instalação/uso idêntico ao .ttf). Se o usuário quiser TTF, peça para abrir no FontForge e gerar como TTF.

Individual skills in this repo

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

Habilidades Relacionadas