# Realismo

> Tira o aspecto de plástico de imagens e vídeos gerados por IA. Aplica contraste local, microtextura de pele, dessaturação leve, grão de filme e vinheta via ffmpeg, em arquivo solto ou pasta inteira, e gera o comparativo antes/depois com zoom no rosto para aprovação. Use quando o usuário pedir para deixar um vídeo ou imagem de IA mais real, menos plástico, com pele/textura melhor, ou ao finalizar peças de UGC e anúncios gerados por IA.

- Skill: `marcosluz/realismo` (Agent Skill, multi-file: 2 files)
- Install (CLI): `npx skillmds@latest add marcosluz/realismo`
- Raw SKILL.md: https://api.skillmd.com/api/skills/marcosluz/realismo/raw
- Safety review: pending (external: skill-scanner PASS, skillspector PASS)
- Works with: Claude Code, Claude.ai, OpenAI Codex
- Category: Coding & Dev Tools
- Author: MarcosLuz (https://skillmd.com/u/marcosluz)
- Updated: 2026-09-22
- Page: https://skillmd.com/skills/marcosluz/realismo

---


# /realismo

Imagem e vídeo de IA têm sempre o mesmo defeito: pele chapada, sem poro, cor
saturada demais e ausência total de grão. O olho humano lê isso como falso antes
mesmo de identificar o motivo. Esta skill devolve as três coisas que faltam,
usando só ffmpeg, sem modelo de IA e sem enviar nada para fora da máquina.

## Passo 1: localizar o script

O script fica em `scripts/realismo.py`, sempre irmão deste SKILL.md. Use o
caminho absoluto do diretório onde você leu este arquivo. Instalado pelo plugin,
esse diretório é `${CLAUDE_PLUGIN_ROOT}/skills/realismo`.

No Windows use `python`, não `python3` (o `python3` é o stub da Microsoft Store).

```bash
python "${SKILL_DIR}/scripts/realismo.py" --help
```

Dependência única: ffmpeg no PATH. Se faltar, o script avisa e a instalação é
`winget install Gyan.FFmpeg`.

## Passo 2: gerar o comparativo e pedir aprovação

**Nunca rode o lote inteiro sem mostrar o antes e depois primeiro.** O ponto
certo do filtro depende do material, e refazer um lote grande é caro em tempo.

```bash
python "${SKILL_DIR}/scripts/realismo.py" "<pasta>" --so-comparar
```

Isso escreve `realista/_comparativo_<nome>.jpg` (ou `.mp4`) com quatro painéis
lado a lado: **ANTES | DEPOIS | ANTES rosto | DEPOIS rosto**. Os dois painéis de
rosto são o recorte em 100%, que é onde a diferença realmente aparece. No vídeo
o comparativo usa um trecho de 6s tirado de um terço da duração.

Leia o comparativo com a ferramenta Read e mostre ao usuário antes de processar
o resto. Se o enquadramento do zoom pegar o lugar errado, ajuste com
`--rosto x,y,w,h` em fração do quadro (padrão `0.25,0.08,0.50,0.35`, calibrado
para UGC vertical com rosto no alto e ao centro).

## Passo 3: processar

```bash
python "${SKILL_DIR}/scripts/realismo.py" "<arquivo-ou-pasta>"
```

Aceita arquivo solto ou pasta com imagem e vídeo misturados. A saída vai para a
subpasta `realista`, os originais nunca são tocados. Flags úteis:

| Flag | Efeito |
|---|---|
| `--nivel suave\|medio\|forte` | intensidade. Padrão `medio` |
| `--comparar` | processa **e** gera o comparativo |
| `--so-comparar` | só o comparativo, não processa o lote |
| `--saida DIR` | outra pasta de destino |
| `--rosto x,y,w,h` | recorte do zoom no comparativo |
| `--segundos N` / `--inicio N` | trecho do vídeo usado no comparativo |

Cada rodada grava `realista/_realismo.log` com o nível e a cadeia de filtros
exata usada, e os vídeos saem com `comment=realismo=<nivel>` nos metadados. Dá
para reproduzir ou auditar o tratamento depois.

## Escolher o nível

O padrão é **`medio`**, definido em 19/09/2026 comparando antes e depois em
material real: um retrato gerado por IA e um vídeo de cabeça falante.

- **`suave`**: foto de produto, qualquer peça que vá receber texto por cima, e
  imagem que já saiu de um upscaler. O grão come a legibilidade de texto.
- **`medio`**: rosto, cabeça falante, UGC. É o padrão.
- **`forte`**: só material muito chapado. Passa fácil do ponto: vigie nariz,
  bigode e sobrancelha, que endurecem primeiro e ganham cara de HDR.

A vinheta está ligada em todos os níveis. Se precisar tirar, remova
`vignette=...` das cadeias em `scripts/realismo.py`.

## O que cada etapa faz

| Filtro | Papel | Por que a IA precisa |
|---|---|---|
| `unsharp` raio 11 | contraste local | a imagem sai chapada, sem volume |
| `cas` | microtextura | devolve poro, fio de cabelo, barba por fazer |
| `eq` saturação < 1 | correção de cor | IA satura demais pele e céu |
| `smartblur` só no chroma | cor mais mole que luz | é assim que sensor real se comporta |
| `noise` | grão de filme | **o item que mais engana o olho** |
| `vignette` | queda de luz nas bordas | toda lente real faz isso |

O `smartblur` de chroma só entra na cadeia de imagem. Em vídeo ele custa caro e
o ganho não aparece em 720p.

## Onde entra no fluxo

É o **último passo de imagem e vídeo, antes de queimar legenda**. Aplicar o
filtro depois da legenda coloca grão em cima do texto e fica feio.

Num fluxo típico de vídeo com IA: gerar a imagem → gerar o clipe → gerar a voz →
lipsync → **realismo** → legenda.

Detalhe que vale dizer ao usuário: o ganho cresce com a resolução da fonte. Em
720x1280 o rosto ocupa pouca área e o filtro tem pouca informação para realçar.
Se a peça for importante, vale gerar em 1080p na origem.

Para imagem existe um passo opcional que vale mais que o filtro: passar antes
por um upscaler que regenera textura. A ordem é upscale e **depois** o filtro,
nunca o contrário: o upscaler reconstrói detalhe que não existe, o filtro só realça o que
já está lá.

## Formatos

Entrada: `.jpg .jpeg .png .webp` e `.mp4 .mov .mkv .webm .m4v`.
Saída: imagem mantém a extensão (webp vira o mesmo nome com o filtro aplicado),
vídeo sai em H.264 CRF 17 com o áudio copiado sem recompressão. Se o codec de
áudio não couber em MP4, o script reencoda em AAC 192k automaticamente.

## Segurança

Roda tudo local. Não sobe arquivo para lugar nenhum, não usa API, não altera os
originais. A única escrita fora da pasta de saída é o log dentro dela.