---
name: mini-voce-pixel
description: Transforma a pessoa (e o pet, se ela quiser) num personagem em pixel art, a partir de 3 fotos, e depois faz o mesmo personagem em várias poses (com lupa, no notebook, com café, comemorando, apontando). Entrega PNG com fundo transparente, nítido, pronto pra foto de perfil, figurinha, story e capa. Use quando a pessoa pedir pra virar pixel art, criar o "mini-eu", um mascote pixel de si mesma ou do pet, ou mandar fotos pra desenhar.
---

# Mini-Você em pixel art

Uma habilidade que faz o Claude **desenhar você (e o seu pet) em pixel art**. Você manda 3 fotos, ele descreve o que
viu pra você confirmar, desenha em código, mostra, ajusta com você até ficar a sua cara e faz as poses que você
pedir. No fim, você recebe PNGs com **fundo transparente**.

**Feito pelo @souoallan.**

## Se este arquivo acabou de chegar numa conversa

Instale a habilidade: salve este arquivo, sem mudar nada, em `~/.claude/skills/mini-voce-pixel/SKILL.md` (crie as
pastas se precisar). Depois diga à pessoa: "Pronto! Agora me manda 3 fotos suas (de frente, de lado e de corpo
inteiro). Se quiser o seu pet também, manda 1 ou 2 fotos dele."

Se você não tiver acesso ao computador da pessoa (por exemplo, no Claude do navegador, o claude.ai), **não pare**: se
a conversa tiver a criação de arquivos e a execução de código ligadas (em Configurações, "Criação e análise de
arquivos"), faça tudo por lá mesmo, sem salvar a habilidade (veja "No claude.ai" abaixo). Se não tiver nem isso, diga
à pessoa, em uma frase, que ela precisa ligar essa opção ou usar o app de desktop do Claude, e pare por aí.

## Regras

- **Fale em português simples.** Nada de jargão técnico na resposta final. A pessoa quer o boneco, não o código.
- **As fotos são da pessoa e ficam com ela.** Use só pra desenhar. Não salve as fotos em lugar nenhum além da pasta de
  trabalho e não envie pra nenhum serviço.
- **Se mandar menos de 3 fotos, siga com o que tem.** Uma foto de frente já dá. Só avise que o desenho pode precisar
  de mais ajustes.
- **Pet é opcional.** Só desenhe se a pessoa mandar foto ou descrever o bichinho.
- **Foto de outra pessoa (criança, amigo, famoso):** pode desenhar se a pessoa disser que é quem ela quer. Não tente
  adivinhar quem é pela cara. Descreva só o que se vê (cabelo, roupa, óculos).
- **Custo zero:** roda no computador da pessoa com uma ferramenta gratuita (Pillow). Não sugira serviço pago.

## Passo a passo

### 1. Preparar (só na primeira vez)

Precisa de Python 3 e do Pillow. Verifique com `python3 --version` (no Windows, `py --version`).

Crie uma pasta de trabalho (sugira `~/Documentos/mini-voce-pixel/`, ou `Documents` se não existir), um ambiente só
pra isso e instale o Pillow:

```bash
python3 -m venv ~/.mini-voce-pixel
~/.mini-voce-pixel/bin/pip install -U Pillow
```

(No Windows, o caminho é `~/.mini-voce-pixel/Scripts/...` no lugar de `~/.mini-voce-pixel/bin/...`.) Abaixo, `PY` é
`~/.mini-voce-pixel/bin/python`.

Salve o código da seção "O molde" (mais abaixo) como `pixel.py` na pasta de trabalho, sem mudar nada. Ele é o molde
do desenho: a gente só troca os traços.

### Se algo der erro: corrija sozinho

Os comandos deste guia são um ponto de partida, não uma receita fechada. Sistema e versões mudam. **Se qualquer passo
falhar, não pare nem devolva o erro pra pessoa:** leia a mensagem, descubra a causa e ajuste até funcionar. Só peça
ajuda quando for algo que só ela pode fazer (digitar a senha do computador, aprovar uma instalação). Problemas já
conhecidos:

- **`pip` não existe:** use `pip3`, ou `python3 -m pip install Pillow`.
- **`python3` não existe (Windows):** use `python` ou `py`. Se não tiver Python, `winget install Python.Python.3.12`.
- **Mac sem Python:** `brew install python`. Se o Homebrew não existir, explique à pessoa como instalar (brew.sh) e
  espere ela confirmar.
- **`externally-managed-environment` (Linux e Mac novo):** não instale direto no sistema. Use o ambiente (`venv`) do
  passo 1. Se o venv falhar no Linux, `sudo apt install python3-venv` (e peça a senha à pessoa, que é a parte dela).
- **`No module named PIL`:** o Pillow não está no Python que você usou. Rode com o `PY` do ambiente, ou instale de
  novo com `PY -m pip install Pillow`.
- **Sem internet pro pip:** diga à pessoa, em uma frase, e tente de novo depois.
- **Imagem borrada ou com fundo branco:** confira que o redimensionamento usa `Image.NEAREST` e que o PNG é RGBA. O
  molde já faz isso. Se você mexeu, volte ao original.
- **Não consegue abrir o PNG pra mostrar:** mostre o caminho do arquivo e diga à pessoa onde abrir. Se der, abra pra
  ela (`open arquivo.png` no Mac, `start arquivo.png` no Windows, `xdg-open` no Linux).

### No claude.ai (sem acesso ao computador)

Se a conversa tem execução de código ligada, o Pillow já vem no ambiente: **pule o passo de instalação**. Crie o
`pixel.py` com o código do molde, rode com `python pixel.py ...`, e entregue os PNGs como arquivos da conversa pra
pessoa baixar. O resto do fluxo é igual.

### 2. Pedir as fotos

Peça, em uma mensagem curta:

1. uma foto de **frente** (rosto bem visível, de preferência sem boné e sem óculos escuros);
2. uma de **lado** (perfil);
3. uma de **corpo inteiro**;
4. se quiser, **1 ou 2 do pet** (de frente e de lado).

Diga que pode mandar tudo de uma vez.

### 3. Descrever os traços e confirmar

Olhe as fotos e diga em voz alta o que você vai desenhar, numa lista curta, pra pessoa corrigir antes de desenhar:

- **Cabelo:** cor, comprimento, se é liso, ondulado, cacheado, preso, ou se não tem (careca).
- **Barba:** não tem, rala, só cavanhaque, ou cheia. E bigode.
- **Óculos:** tem ou não, e a cor da armação.
- **Pele:** tom (claro, médio, moreno, escuro).
- **Roupa:** cor da camiseta ou blusa, manga curta ou comprida, cor da calça e do tênis.
- **Expressão:** sério ou sorrindo.
- **Pet (se tiver):** bicho, cor do pelo, cor da cara e do peito, orelha (em pé, caída), rabo (peludo, fino, curto) e
  se usa coleira ou bandana.

Pergunte: "Tá certo? Mudo alguma coisa?" Espere a resposta.

### 4. Desenhar

Traduza os traços pra dois arquivos pequenos, na pasta de trabalho.

`tracos.json` (só inclua o que for diferente do padrão; as cores são em `#RRGGBB`, escolha uma cor que combine com a
foto):

```json
{
  "pele": "#F0C4A4",
  "cabelo": "#2B1D14",
  "estilo_cabelo": "ondulado",
  "barba": "cavanhaque",
  "oculos": false,
  "camiseta": "#1E1E22",
  "manga_curta": true,
  "calca": "#343A48",
  "tenis": "#ECECEC",
  "sorriso": true
}
```

Valores aceitos: `estilo_cabelo` = `curto`, `ondulado`, `longo`, `coque`, `careca`. `barba` = `nenhuma`, `rala`,
`cavanhaque`, `cheia`.

`pet.json` (só se tiver pet):

```json
{ "corpo": "#E2AA6E", "claro": "#FAF0E1", "orelha": "pontuda", "rabo": "pompom", "acessorio": null }
```

Valores aceitos: `orelha` = `pontuda`, `caida`, `gato`. `rabo` = `pompom`, `fino`, `curto`. `acessorio` = `null` ou
uma cor (bandana ou coleira).

Rode:

```bash
PY pixel.py --tracos tracos.json --pet pet.json --poses frente --saida saida
```

(Sem pet, tire o `--pet pet.json`.) Ele cria `saida/personagem-frente.png` (e `pet.png`, `personagem-com-pet.png`).

**Se o molde não der conta de um traço** (cabelo de um jeito que nenhum estilo cobre, um acessório, uma roupa
diferente): edite o `pixel.py`. Cada traço é um retângulo de pixels (`r(x0, y0, x1, y1, cor)`) ou um pixel solto
(`p(x, y, cor)`) numa grade de 32 por 40. Mexa pouco, só o que falta, mantenha o contorno escuro e **nunca** use
suavização (anti-aliasing): pixel art precisa de pixel duro.

### 5. Mostrar e ajustar

Abra o PNG e mostre à pessoa. Pergunte: **"O que tá diferente de você?"**

Ajuste conversando ("meu cabelo é mais curto", "tô de barba maior", "troca a camiseta pra azul") mexendo no
`tracos.json` (ou no `pixel.py`, se for um detalhe novo) e gere de novo. Repita até a pessoa aprovar. Não passe pra
etapa seguinte sem o "ficou a minha cara".

### 6. Fazer as poses

Pergunte quais poses ela quer. Sugira: **com lupa** (`lupa`), **no notebook** (`notebook`), **com café** (`cafe`),
**comemorando** (`comemorando`), **apontando** (`apontando`), **de fone** (`fone`). Pose que não existe (academia,
violão, praia): crie no `pixel.py` como mais um `elif pose == '...'` com os mesmos retângulos de pixel, igual às
outras.

```bash
PY pixel.py --tracos tracos.json --pet pet.json --poses frente,lupa,notebook,cafe,comemorando,apontando --saida saida
```

### 7. Entregar

Entregue, na pasta `saida` (e diga o caminho completo à pessoa):

- um PNG por pose: `personagem-<pose>.png`;
- `folha-de-poses.png`: todas as poses numa folha só;
- `pet.png` e `personagem-com-pet.png` (se tiver pet).

Todos têm **fundo transparente** e vêm ampliados 16 vezes sem borrar. Se a pessoa quiser maior (pra imprimir), rode
com `--escala 32`. Se quiser em fundo de cor, componha o PNG sobre a cor, nunca amplie de novo com suavização.

Termine com uma frase: o que ela pode fazer com isso (foto de perfil, figurinha, story, capa de destaque) e a oferta
de mais poses.

### 8. Limpar

Não apague nada da pasta `saida`. O `pixel.py` e os `.json` ficam lá: se a pessoa voltar pedindo uma pose nova, é só
rodar de novo, sem pedir as fotos outra vez.

## O molde

Salve como `pixel.py`. Grade da pessoa: 32 por 40. Grade do pet: 22 por 20.

```python
"""Molde de pixel art: pessoa (grade 32x40) e pet (grade 22x20). So precisa do Pillow."""
import sys, json, argparse, os
from PIL import Image

W, H = 32, 40

def hexrgb(c):
    c = c.lstrip('#')
    return tuple(int(c[i:i+2], 16) for i in (0, 2, 4))

def mix(a, b, t):  # t=0 -> a, t=1 -> b
    return tuple(int(a[i] + (b[i] - a[i]) * t) for i in range(3))

def escuro(c, t=.2): return mix(c, (0, 0, 0), t)
def claro(c, t=.25): return mix(c, (255, 255, 255), t)

# ---------- TRACOS PADRAO (o Claude troca pelos da pessoa) ----------
TRACOS = dict(
    pele='#F0C4A4',          # cor da pele
    cabelo='#2B1D14',        # cor do cabelo
    estilo_cabelo='ondulado',  # curto | ondulado | longo | coque | careca
    barba='nenhuma',         # nenhuma | rala | cavanhaque | cheia
    oculos=False, cor_oculos='#232323',
    camiseta='#1E1E22',      # cor da roupa de cima
    manga_curta=True,        # False = manga comprida
    calca='#343A48',
    tenis='#ECECEC',
    sorriso=True,
)

PET_PADRAO = dict(
    corpo='#E2AA6E',         # cor principal do pelo
    claro='#FAF0E1',         # cara/peito/patas (a cor mais clara)
    orelha='pontuda',        # pontuda | caida | gato
    rabo='pompom',           # pompom | fino | curto
    acessorio=None,          # ex: '#E8758A' para uma bandana
)

def paleta(t):
    pele, cab = hexrgb(t['pele']), hexrgb(t['cabelo'])
    cam = hexrgb(t['camiseta'])
    return {
        'H': cab, 'h': claro(cab, .3), 'S': pele, 's': escuro(pele, .15),
        'B': mix(cab, pele, .5), 'b': mix(cab, pele, .3),
        'E': (35, 24, 18), 'M': mix(pele, (180, 70, 70), .5),
        'T': cam, 't': (escuro(cam, .2) if sum(cam) > 150 else claro(cam, .2)),
        'P': hexrgb(t['calca']), 'K': hexrgb(t['tenis']),
        'G': (140, 140, 150), 'W': (255, 255, 255), 'R': (150, 110, 70),
        'C': (170, 215, 240), 'F': hexrgb(t['cor_oculos']), 'A': (217, 101, 59),
        'O': (24, 18, 16),
    }

class Grade:
    def __init__(s, w, h):
        s.w, s.h, s.g = w, h, [[None] * w for _ in range(h)]
    def p(s, x, y, c):
        if 0 <= x < s.w and 0 <= y < s.h: s.g[y][x] = c
    def r(s, x0, y0, x1, y1, c):
        for y in range(y0, y1 + 1):
            for x in range(x0, x1 + 1): s.p(x, y, c)
    def contorno(s):
        out = [row[:] for row in s.g]
        for y in range(s.h):
            for x in range(s.w):
                if s.g[y][x] is None:
                    for dx, dy in ((1, 0), (-1, 0), (0, 1), (0, -1)):
                        xx, yy = x + dx, y + dy
                        if 0 <= xx < s.w and 0 <= yy < s.h and s.g[yy][xx] is not None:
                            out[y][x] = 'O'; break
        return out

def imagem(grade, pal, escala=16):
    g = grade.contorno()
    im = Image.new('RGBA', (grade.w, grade.h), (0, 0, 0, 0))
    for y in range(grade.h):
        for x in range(grade.w):
            if g[y][x]: im.putpixel((x, y), pal[g[y][x]] + (255,))
    return im.resize((grade.w * escala, grade.h * escala), Image.NEAREST)

# ---------- PESSOA ----------
def cabelo(d, estilo):
    p, r = d.p, d.r
    if estilo == 'careca':
        r(10, 5, 21, 6, 'S'); r(9, 6, 22, 7, 'S'); return
    if estilo == 'ondulado':
        r(11, 2, 20, 2, 'H'); r(9, 3, 22, 3, 'H'); r(8, 4, 23, 8, 'H'); r(8, 9, 9, 10, 'H'); r(22, 9, 23, 10, 'H')
        for x, y in [(12, 3), (13, 4), (16, 3), (17, 4), (20, 4), (10, 5), (14, 6), (19, 6), (11, 7)]: p(x, y, 'h')
        r(10, 8, 21, 8, 'H')
        for x, y in [(11, 9), (12, 9), (12, 10), (15, 9), (16, 9), (19, 9)]: p(x, y, 'H')
        return
    # base de curto / longo / coque
    r(11, 3, 20, 3, 'H'); r(9, 4, 22, 4, 'H'); r(8, 5, 23, 8, 'H'); r(8, 9, 9, 11, 'H'); r(22, 9, 23, 11, 'H')
    r(10, 8, 21, 9, 'H')
    for x in (10, 12, 15, 18, 20): p(x, 9, 'S')
    for x, y in [(12, 4), (16, 4), (19, 5), (10, 6), (14, 7)]: p(x, y, 'h')
    if estilo == 'longo':
        r(7, 9, 9, 26, 'H'); r(22, 9, 24, 26, 'H')
        for y in (13, 17, 21): p(8, y, 'h'); p(23, y, 'h')
    if estilo == 'coque':
        r(13, 0, 18, 2, 'H'); p(14, 1, 'h'); p(16, 0, 'h')

def pessoa(t=None, pose=None):
    t = {**TRACOS, **(t or {})}
    d = Grade(W, H); p, r = d.p, d.r
    # cabeca e orelhas
    r(9, 7, 22, 18, 'S')
    for x, y in [(9, 7), (22, 7), (9, 18), (22, 18)]: d.g[y][x] = None
    r(8, 11, 8, 13, 'S'); r(23, 11, 23, 13, 'S'); p(8, 12, 's'); p(23, 12, 's')
    # pescoco, tronco, bracos
    r(13, 19, 18, 20, 's')
    r(9, 21, 22, 31, 'T'); r(10, 21, 21, 31, 'T')
    r(7, 22, 8, 28, 'T'); r(23, 22, 24, 28, 'T'); r(7, 29, 8, 30, 'S'); r(23, 29, 24, 30, 'S')
    if t['manga_curta']:
        r(7, 25, 8, 28, 'S'); r(23, 25, 24, 28, 'S')
    r(9, 22, 10, 23, 't'); p(15, 22, 't'); p(15, 24, 't')
    # calca e tenis
    r(10, 32, 21, 36, 'P'); r(15, 34, 16, 36, None)
    r(9, 37, 14, 38, 'K'); r(17, 37, 22, 38, 'K')
    # cabelo (atras das feicoes)
    cabelo(d, t['estilo_cabelo'])
    # sobrancelhas, olhos, nariz, boca
    r(11, 10, 13, 10, 'b'); r(18, 10, 20, 10, 'b')
    r(12, 12, 12, 13, 'E'); r(19, 12, 19, 13, 'E')
    p(15, 14, 's'); p(16, 14, 's')
    r(14, 16, 17, 16, 'M')
    if t['sorriso']: p(13, 15, 'M'); p(18, 15, 'M')
    # barba
    b = t['barba']
    if b == 'rala':
        for x, y in [(10, 16), (11, 17), (13, 18), (15, 18), (17, 18), (20, 17), (21, 16), (12, 17), (19, 18), (14, 17), (18, 17)]: p(x, y, 'B')
        for x, y in [(15, 19), (16, 19)]: p(x, y, 'B')
    elif b == 'cavanhaque':
        r(13, 15, 18, 15, 'B'); r(14, 17, 17, 19, 'B'); p(12, 16, 'B'); p(19, 16, 'B')
        r(14, 16, 17, 16, 'M')
        for x, y in [(11, 17), (20, 17), (10, 16), (21, 16)]: p(x, y, 'B')
    elif b == 'cheia':
        r(9, 15, 22, 18, 'B'); r(10, 19, 21, 19, 'B'); r(12, 20, 19, 20, 'B'); r(13, 15, 18, 15, 'b')
        r(14, 16, 17, 16, 'M'); r(14, 17, 17, 18, 'b')
        for x, y in [(9, 15), (22, 15)]: p(x, y, 'S')
    # oculos
    if t['oculos']:
        for x0 in (10, 17):
            r(x0, 11, x0 + 4, 14, 'F'); r(x0 + 1, 12, x0 + 3, 13, 'C')
            p(x0 + 2, 12, 'E') if x0 == 10 else None
        r(15, 12, 16, 12, 'F'); r(7, 12, 9, 12, 'F'); r(22, 12, 24, 12, 'F')
        r(12, 12, 12, 13, 'E'); r(19, 12, 19, 13, 'E'); p(11, 12, 'W'); p(18, 12, 'W')
    # poses
    if pose == 'lupa':
        r(24, 19, 30, 25, 'G'); r(25, 20, 29, 24, 'C')
        for x, y in [(24, 19), (30, 19), (24, 25), (30, 25)]: d.g[y][x] = None
        p(26, 21, 'W'); p(27, 21, 'W'); p(26, 22, 'W')
        p(25, 26, 'R'); p(25, 27, 'R'); p(24, 28, 'R'); r(23, 22, 24, 26, 'T'); r(23, 27, 24, 28, 'S')
    elif pose == 'notebook':
        r(6, 26, 25, 31, 'G'); r(7, 27, 24, 30, 't'); r(5, 32, 26, 33, 'G'); p(15, 28, 'W'); p(16, 28, 'W')
    elif pose == 'cafe':
        r(25, 27, 28, 31, 'W'); r(25, 27, 28, 27, 'R'); p(29, 28, 'W'); p(29, 30, 'W'); p(30, 29, 'W')
        p(26, 25, 'G'); p(27, 24, 'G'); p(26, 23, 'G')
    elif pose == 'fone':
        r(9, 1, 22, 1, 'G'); p(8, 2, 'G'); p(23, 2, 'G'); r(7, 3, 7, 9, 'G'); r(24, 3, 24, 9, 'G')
        r(6, 10, 8, 14, 'A'); r(23, 10, 25, 14, 'A')
        for x, y in [(6, 10), (25, 10), (6, 14), (25, 14)]: d.g[y][x] = None
    elif pose == 'comemorando':
        r(7, 22, 8, 30, None); r(23, 22, 24, 30, None)
        for i in range(9):
            x = 8 - (i + 1) // 2; y = 22 - i
            r(x - 1, y, x, y, 'T'); r(31 - x, y, 32 - x, y, 'T')
        r(2, 11, 3, 13, 'S'); r(28, 11, 29, 13, 'S')
        r(14, 16, 17, 16, 'E'); p(13, 15, 'M'); p(18, 15, 'M')
    elif pose == 'apontando':
        r(23, 22, 24, 30, None); r(23, 22, 29, 23, 'T'); r(30, 22, 31, 23, 'S')
    return d, paleta(t)

# ---------- PET ----------
def pet(c=None):
    c = {**PET_PADRAO, **(c or {})}
    corpo, clr = hexrgb(c['corpo']), hexrgb(c['claro'])
    pal = {'F': corpo, 'f': escuro(corpo, .2), 'Y': clr, 'E': (30, 22, 18), 'N': (70, 50, 45),
           'W': (255, 255, 255), 'P': (235, 150, 160), 'O': (24, 18, 16),
           'X': hexrgb(c['acessorio']) if c['acessorio'] else (0, 0, 0)}
    d = Grade(22, 20); p, r = d.p, d.r
    # rabo
    if c['rabo'] == 'pompom':
        r(13, 3, 18, 7, 'Y'); r(12, 5, 19, 8, 'Y'); r(15, 2, 17, 2, 'Y'); p(19, 4, 'Y'); p(14, 6, 'F'); p(16, 7, 'F')
    elif c['rabo'] == 'fino':
        r(17, 9, 18, 16, 'F'); r(18, 5, 19, 9, 'F'); p(19, 4, 'f'); p(18, 4, 'F')
    else:
        r(17, 11, 19, 13, 'F')
    # corpo
    r(6, 9, 17, 17, 'F'); r(5, 10, 18, 16, 'F'); r(7, 8, 16, 8, 'F')
    r(7, 12, 12, 17, 'Y'); r(6, 13, 13, 16, 'Y')
    for x, y in [(16, 11), (17, 13), (15, 15), (16, 16)]: p(x, y, 'f')
    r(7, 18, 8, 18, 'Y'); r(11, 18, 12, 18, 'Y')
    # cabeca
    r(3, 4, 11, 11, 'F'); r(2, 5, 12, 10, 'F'); r(4, 7, 10, 11, 'Y'); r(3, 8, 11, 10, 'Y')
    # orelhas
    if c['orelha'] == 'caida':
        r(1, 5, 2, 10, 'f'); r(12, 5, 13, 10, 'f'); p(1, 5, None); p(13, 5, None)
    elif c['orelha'] == 'gato':
        r(3, 2, 4, 3, 'F'); p(3, 1, 'F'); r(10, 2, 11, 3, 'F'); p(11, 1, 'F'); p(4, 3, 'P'); p(10, 3, 'P')
    else:
        p(3, 3, 'F'); p(4, 2, 'F'); p(4, 3, 'f'); p(10, 3, 'F'); p(10, 2, 'F'); p(10, 3, 'f')
    # olhos, focinho
    p(5, 7, 'E'); p(9, 7, 'E'); p(5, 6, 'E'); p(9, 6, 'E'); p(6, 6, 'W')
    r(6, 9, 8, 9, 'N'); p(7, 10, 'N')
    if c['orelha'] != 'gato': p(7, 11, 'P')
    if c['acessorio']: r(4, 12, 10, 12, 'X'); r(6, 13, 8, 13, 'X'); p(7, 14, 'X')
    return d, pal

# ---------- SAIDA ----------
POSES = ['frente', 'lupa', 'notebook', 'cafe', 'comemorando', 'apontando', 'fone']

def gerar(tracos, pet_cfg, poses, pasta, escala=16):
    os.makedirs(pasta, exist_ok=True)
    imgs = {}
    for ps in poses:
        d, pal = pessoa(tracos, None if ps == 'frente' else ps)
        imgs[ps] = imagem(d, pal, escala)
        imgs[ps].save(f'{pasta}/personagem-{ps}.png')
    pet_im = None
    if pet_cfg is not None:
        d, pal = pet(pet_cfg)
        pet_im = imagem(d, pal, escala); pet_im.save(f'{pasta}/pet.png')
        base = imgs.get('frente') or next(iter(imgs.values()))
        dupla = Image.new('RGBA', (base.width + pet_im.width + 2 * escala, base.height), (0, 0, 0, 0))
        dupla.alpha_composite(base, (0, 0))
        dupla.alpha_composite(pet_im, (base.width + 2 * escala, base.height - pet_im.height - 2 * escala))
        dupla.save(f'{pasta}/personagem-com-pet.png')
    # folha com todas as poses (fundo transparente)
    cols = min(4, len(imgs)); linhas = -(-len(imgs) // cols)
    cw, ch = W * escala + escala, H * escala + escala
    folha = Image.new('RGBA', (cols * cw, linhas * ch), (0, 0, 0, 0))
    for i, im in enumerate(imgs.values()):
        folha.alpha_composite(im, ((i % cols) * cw + escala // 2, (i // cols) * ch + escala // 2))
    folha.save(f'{pasta}/folha-de-poses.png')
    return sorted(os.listdir(pasta))

if __name__ == '__main__':
    ap = argparse.ArgumentParser()
    ap.add_argument('--tracos'); ap.add_argument('--pet')
    ap.add_argument('--poses', default='frente'); ap.add_argument('--saida', default='pixel-saida')
    ap.add_argument('--escala', type=int, default=16)
    a = ap.parse_args()
    tr = json.load(open(a.tracos)) if a.tracos else {}
    pt = json.load(open(a.pet)) if a.pet else None
    print(gerar(tr, pt, a.poses.split(','), a.saida, a.escala))
```