Communitygithub.com

Motion Match

Use quando o usuário fornecer um vídeo de referência, GIF ou gravação de tela de qualquer animação e quiser que esse movimento seja medido e recriado em seu próprio design ou verificado em relação a ele; fornecer imagens estáticas e quiser que o Claude direcione um movimento suave para ele (uma entrada de UI, um reel, um vídeo explicativo); ou fornecer clipes de vídeo (UGC, gerados por IA como o Google Flow, ou filmados) para editar em um anúncio com legendas e motion graphics. Não para vídeos de canal documental do usuário, que usam animação documental.

O que é Motion Match?

Motion Match é uma skill especializada que transforma 'faça isso se mover assim' em números. Ela permite medir cada corte de uma animação de referência e, para cada elemento em movimento, capturar seu início, duração, easing, overshoot, deslocamento, rotação e mudança de forma. A skill reconstrói o movimento na ferramenta de destino do usuário (CSS, Web Animations API, Framer Motion, GSAP, Remotion, SwiftUI, After Effects) e, em seguida, compara quadro a quadro até que a correspondência de tempo esteja dentro de ±0,08 s. A skill se destaca por sua versatilidade. Para imagens estáticas, oferece os modos Diretor (para entradas de UI) e História (para reels e peças explicativas), onde o Claude projeta, constrói e mede o movimento para garantir que seja realmente suave. Para clipes de vídeo, usa o Modo Edição, aplicando as mesmas regras de medição, direção e revisão. A skill também suporta medições avançadas de morphing, rotação, movimento 3D e animações de trajetória, usando scripts Python adaptados de projetos de código aberto. O fluxo de trabalho é estruturado e iterativo: após configurar o ambiente (ffmpeg, Python com numpy e Pillow, e Playwright para renderização headless), o usuário define o escopo, analisa a referência em quadros, mede cada elemento e movimento, escreve uma especificação detalhada (`spec.md`), constrói a animação na ferramenta de destino e, em seguida, compara e corrige em 2 a 5 rodadas. A skill também inclui modos especializados para projetar animações a partir de imagens estáticas, com personalidades de movimento predefinidas (calma, neutra, divertida) e um vocabulário de movimentos especiais (morphing, rotação, revelação com máscara, etc.).

Funciona com✓Claude Code~Codex CLI✓Cursor
npx skills add https://github.com/stazdev/motion-match/tree/HEAD/skills/motion-match

Perguntar na sua IA favorita

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

Documentação

Motion match: meça qualquer animação, recrie-a, prove que se move da mesma forma

Transforma "faça isso se mover assim" em números: cada corte e, para cada elemento em movimento, seu início, duração, easing, overshoot, deslocamento, rotação e mudança de forma. Recrie o movimento na ferramenta em que o usuário trabalha (CSS, a Web Animations API, Framer Motion, GSAP, Remotion, SwiftUI, After Effects) e, em seguida, compare quadro a quadro até que o tempo corresponda dentro de ±0,08 s. Sem movimento de referência, apenas imagens estáticas? Use o modo Diretor (abaixo) para entradas de UI e o modo História para reels e peças explicativas: o Claude projeta o movimento, o constrói e então mede sua própria renderização com os mesmos scripts, para que "suave" seja verificado, não apenas afirmado. Clipes de vídeo para editar em um anúncio (UGC, gerados por IA, filmados)? Use o modo Edição: as mesmas regras de medição, direção e revisão, aplicadas à filmagem. Métodos adaptados de NiazMorshed2007/reanimate e rossark0/rossark-motion-skill (ambos MIT); os scripts são próprios.

<skill> é a pasta desta skill. O trabalho vai em ./motion-match/<nome>/ na pasta atual: ref/ (decomposição da referência), ours/ (decomposição de nossa renderização), compare-N/ (cada rodada de comparação), spec.md.

Configuração (primeira vez)

Requer ffmpeg/ffprobe no PATH e um Python 3 com numpy e Pillow.

  • Verifique: python3 -c "import numpy, PIL". Se falhar, procure um Python que os tenha (um venv de projeto existente), senão pergunte ao usuário uma vez, então: python3 -m venv ~/.motion-match/venv && ~/.motion-match/venv/bin/pip install numpy pillow e use ~/.motion-match/venv/bin/python como python abaixo. Execute cada script com -I.
  • Os modos Diretor e História também renderizam páginas sem cabeça: pip install playwright && python -m playwright install chromium (pergunte uma vez). Se não for possível instalar, grave a tela da página e informe que os tempos são menos precisos.
  • Nenhuma outra instalação; nada é enviado para lugar nenhum.

0. Escopo (escreva no topo do spec.md antes de medir)

  • Alvo: o arquivo + intervalo de tempo (+ corte) exatamente como o usuário disse ("os primeiros 3 s", "apenas o botão").
  • Fidelidade: fiel ao movimento (padrão): ordem, tempo (±0,08 s), família de easing, overshoot, deslocamento relativo ao tamanho do elemento, stagger. A própria arte, cores, fontes e palavras do usuário. Fiel ao pixel apenas quando o usuário pedir e apenas para prática privada: o design, logotipo, personagens e música de outra pessoa são deles; nunca ajude a publicar uma cópia deles.
  • Destino: a ferramenta ou código para onde o movimento vai (pergunte uma vez se não estiver claro: isso decide o formato de saída).
  • Obtendo a referência: um arquivo que o usuário fornece ou uma gravação de tela que ele faz (sites e aplicativos: grave a interação; a skill funciona a partir de quadros, não do código de um site). Baixe do YouTube ou de um site apenas quando o usuário pedir aquele vídeo específico, em sua própria pasta; trate-o como material de referência privado.

1. Decomponha

python -I <skill>/scripts/ref_frames.py REF.mp4 --out motion-match/<nome>/ref [--start S --end E --crop x:y:w:h] → cada quadro na fps de origem, sheets/timing_NN.png (cada quadro: tempo, easing, follow-through) e sheets/poses.png (2 por segundo: o que acontece). Leia cada folha. GIFs funcionam da mesma forma.

2. Meça

  • Cortes e seções: python -I <skill>/scripts/motion_compare.py motion-match/<nome>/ref motion-match/<nome>/ref --out motion-match/<nome>/self --no-align lista os cortes da referência (mudanças de cena) e movimentos com seus tempos. Referências que nunca ficam paradas são divididas em seus cortes.
  • Cores exatas: python -I <skill>/scripts/track_motion.py <ref>/frames --sample X,Y --at T (coordenadas de pixel do quadro em tamanho real, não de uma folha de contato).
  • Cada elemento em movimento: track_motion.py <ref>/frames --name btn --colors HEX,HEX --tol 35 --region x,y,w,h [--save-masks] (ou --not-bg HEX para "tudo que não é o fundo"). Em referências brilhantes ou ocupadas, sempre forneça um --region e cores únicas para o elemento; verifique se o intervalo de quadros visíveis impresso faz sentido. Registra posição (cx cy), tamanho (w h), squash (aspect), bordas, desaparecimentos/crescimento (presence), cor e rotação (angle) por quadro.
  • Cada movimento: python -I <skill>/scripts/fit_easing.py <ref>/track_btn.json --prop cy --from A --to B (um movimento por janela, nunca através de um corte) → início, fim, duração em ms e quadros, família de easing, overshoot, tempo de estabilização e linhas prontas para copiar e colar para CSS, WAAPI, Framer Motion, GSAP e Remotion. Erro ≤ 0,03 é um ajuste próximo; "no single ease fits" significa dividir a janela, ou é uma cadeia de poses (keyframes).
  • Movimento pequeno (um squash de 2%, uma flutuação de 5 px) não aparece nas folhas, mas aparece nos números do rastreamento: leia-os.
  • Texto que desaparece pequeno fica próximo ao ruído da curva de atividade: meça-o com track_motion.

Quais números medem qual tipo de movimento

movimentomedir comnotas
mover, deslizar, flutuarcx, cyum eixo por ajuste
escalar, crescer, squashw, h, aspect
desaparecerpresence (com --colors)
rotação, giroangle (graus, sentido horário +, contínuo acima de 360)a partir da silhueta; None para círculos: rastreie uma marca neles como seu próprio elemento e ajuste seu cx/cy. Formas com simetria de n dobras (quadrado: 4) precisam de < 180/n graus por quadro, então giros rápidos precisam de uma fonte de alta fps. Outras formas da mesma cor na região estragam: estreite --region
morph (forma → forma)--save-masks, então shape_compare.pyveja abaixo
giro 3D / virada de cartaw (encolhe como cos) + presence; mudança de cor no ponto médioo verso é seu próprio elemento
movimento de trajetória (arco, curva)cx e cy ambos, mais angle se girar ao longo do caminhoajuste cada eixo; a forma do caminho está nas folhas
revelação de clipe / máscara, wipex1 ou y1 (a borda principal), w/h
desenho de linhapresence
divisão de texto (por palavra/letra)rastreie a primeira e a última palavra; o stagger é a diferença de início ÷ (contagem − 1)
contadores, barras de gráficobarras: h/y0; números: as folhas (estimado visualmente)

Morphs. track_motion.py ... --name blob --save-masks salva a silhueta de cada quadro (centralizada, redimensionada para área igual). Então:

  • python -I <skill>/scripts/shape_compare.py <ref>/track_blob_masks.npz --from A --to B adiciona uma série morph (0 = primeira forma, 1 = última) para track_blob.json. fit_easing.py ... --prop morph então fornece seu início, fim e duração. O progresso do morph segue a área, então seus tempos são confiáveis, mas seu nome de easing não é um valor para colar: pegue o easing da especificação, ou de um parâmetro que você possa rastrear (w, aspect, angle).
  • Nosso vs a referência: shape_compare.py REF_masks.npz --vs OURS_masks.npz --from A --to B [--rotate] → caminho da forma: cada forma intermediária da referência também está na nossa, independentemente do seu tempo (PASS: média ≤ 10%, pior ≤ 25% de todo o morph). Então fit_easing.py REF_TRACK --prop morph --vs OUR_TRACK verifica o tempo. --rotate ignora a rotação quando o morph também gira (verifique isso com angle).

3. Escreva a especificação do movimento (spec.md; cada linha se torna uma verificação)

| # | elemento | propriedade | de → para | início s | dur s (quadros) | easing | overshoot | stagger / notas | fonte |
| 1 | card | translateY | 40 → 0 px | 0.20 | 0.60 (18) | easeOutCubic / cubic-bezier(.33,1,.68,1) | 0% | +0.08 s por card | track + fit_easing |
| 2 | ícone | rotate | 0 → 180 deg | 0.40 | 0.30 (9) | easeOutCubic | 0% | — | track angle + fit_easing |
| 3 | blob | morph | quadrado → círculo | 0.50 | 0.40 (12) | easeInOutCubic | — | shape path PASS | shape_compare |
| c | — | cortes | — | 1.77, 2.33 | — | — | — | — | motion_compare self |

Um "?" em uma linha significa que os quadros ainda não foram lidos. Anote também o que não se move. Mostre a especificação ao usuário antes de construir quando o trabalho for grande.

4. Construa

Na ferramenta do usuário, com seu design. Copie os tempos da especificação e os easings da saída do ajustador para aquela ferramenta. Mapeie distâncias relativas ao elemento ou ao quadro quando o layout diferir. Cadeias de poses: keyframes com interpolação suave e sem overshooting; molas onde a referência overshoot e estabiliza.

  • Rotação: defina transform-origin explicitamente (meça o pivô: o ponto cujo cx, cy permanece fixo).
  • Morphs: caminhos SVG precisam do mesmo número e tipo de comandos em ambas as extremidades (ou use flubber / GSAP MorphSVG); morphs de layout de UI (botão → card, miniatura → página) usam FLIP ou transições de elemento compartilhado (Framer layoutId, a View Transitions API); morphs de raio de borda / tamanho são CSS simples.
  • 3D: perspective 800–1200 px no pai, backface-visibility: hidden, ambas as faces como camadas separadas.

5. Compare e corrija (2-5 rodadas)

  1. Renderize ou grave a tela do nosso sobre a mesma janela na mesma fps (grave uma página web da mesma forma que a referência).
  2. ref_frames.py OURS.mp4 --out motion-match/<nome>/ours --like motion-match/<nome>/ref/frames.json (mesma janela, corte, fps e tamanho de quadro).
  3. motion_compare.py motion-match/<nome>/ref motion-match/<nome>/ours --out motion-match/<nome>/compare-N → deslocamento, cada corte e movimento com erros de início/fim/duração/pico, PASS dentro de ±0,08 s, activity.png (ambas as curvas) e sheets/compare_NN.png (referência | nossa | diferença). Leia as folhas a cada rodada.
  4. Por linha de especificação: rastreie o nosso da mesma forma, então fit_easing.py REF_TRACK --prop P --from A --to B --vs OUR_TRACK → PASS/FAIL de tempo por movimento, correspondência de deslocamento e família de easing. Linhas de morph: shape_compare.py --vs também.
  5. Corrija a menor coisa que a evidência apontar, re-renderize, repita. Após 5 rodadas, relate qualquer coisa que ainda falhe com seus números e o motivo. Nunca afrouxe a tolerância silenciosamente.
SintomaCausa usualCorreção
tudo deslocado por um offsetatraso inicial ou latência de disparoajuste o primeiro atraso
o nosso é mais curto e carregado na frenteeasing muito forte (expo vs cubic)use o bezier ajustado
referência overshoot, o nosso nãospring/back vs ease simplesback.out / uma mola ajustada ao overshoot medido
um movimento no nosso para cedoum movimento secundário está faltando (um desvio, um push-in)olhe as folhas naquela janela
um movimento ou corte extra no nossoalgo anima que está parado na referênciaremova ou atrase
números de elemento saltamo rastreamento capturou outro elementoestreite --region, use cores únicas para ele
deslocamento de rotação certo, mas o nosso oscila em cx/cytransform-origin erradomova o pivô para o ponto de parada medido
tempo de morph PASS, shape path FAILcaminhos interpolam de forma diferente (ordem de pontos, ponto inicial)re-ordene os pontos do caminho / combine comandos; use uma biblioteca de morph

6. Relatório

Fidelidade; o que foi correspondido e o que é do próprio usuário; a última tabela de comparação (cortes e movimentos com erros, PASS/FAIL); linhas por elemento; caminhos para activity.png e as folhas de comparação; cada diferença restante com seu número e motivo; e quais verificações foram medidas (um script as produziu) vs estimadas visualmente (olhou para uma folha).

Modo Diretor: uma imagem estática entra, movimento projetado para ela

Use quando o usuário fornecer uma imagem (captura de tela de UI, mockup, pôster, foto de produto) sem movimento de referência, ou pedir ao Claude para escolher o movimento. O trabalho vai em ./motion-match/<nome>/ como de costume (ours/, spec.md, check-N/). Para uma peça de vídeo em vez de uma entrada de UI, siga estas etapas dentro do modo História (abaixo).

  1. Leia a imagem. Liste cada elemento (fundo, nav, título, corpo, imagem, CTA, cards, ícones) com sua caixa em px, sua função e sua classificação: um ponto focal, depois suporte, depois cromo. Anote a ordem de leitura, os grupos (uma linha de cards, uma lista), o clima (calmo/premium, neutro/produto, divertido) e qualquer coisa que sugira um movimento especial (um ícone de alternância, um gráfico, uma marca de logotipo, um caminho curvo, um card giratório).
  2. Escolha uma personalidade do clima, a menos que o usuário nomeie uma. Quando eles pedirem opções, construa todas as três.
personalidadeentradaduraçãoeasingdeslocamentostaggerovershoot
calmofade + subida400–600 mseaseOutQuart / cubic-bezier(.25,1,.5,1)8–16 px60–80 msnenhum
neutrofade + subida, ou escala .97→1250–400 mseaseOutCubic / cubic-bezier(.33,1,.68,1)12–24 px40–60 msnenhum
divertidosubida + escala .9→1molamola (rigidez 300–400, amortecimento 20–26)16–32 px50–70 ms3–8%
  1. Escolha movimento especial por função (o vocabulário; valores são pontos de partida, escalados pela personalidade):
movimentouse parapadrões
morphalternâncias de ícone (menu ↔ fechar, play ↔ pausa), um botão expandindo para um card ou folha, um logotipo de forma300–500 ms easeInOutCubic; morphs de layout via FLIP/elemento compartilhado
rotaçãoícones de alternância/chevron, atualizar, uma entrada inclinadaícone 90–180° em 200–300 ms easeOutCubic; entrada −6…−10° → 0 com o easing da personalidade; loader 360° linear 0.8–1.2 s loop
giro 3D / inclinaçãocards com duas faces, alternâncias de preço, profundidade de hovergirar rotateY 180° em 500–700 ms easeInOutCubic; hover inclinação ≤ 8°
movimento de trajetóriaalgo viajando (um avião, um ponto ao longo de uma rota, um cursor)easeInOutSine, gira ao longo do caminho, 0.8–1.6 s
revelação de clipe / máscaraimagens de herói, grandes títulosclipe inset ou círculo, 500–800 ms easeOutQuart
divisão de textoapenas o título principalpalavras com 40–60 ms de intervalo, letras 15–30 ms; linha inteira ≤ 1 s
desenho de linhaícones, assinaturas, gráficos, sublinhadosstroke-dashoffset, 600–1000 ms easeInOutCubic
contadores / crescimento de gráficonúmeros, barras, anéisnúmeros 800–1200 ms easeOutExpo; barras a partir da linha de base, stagger 40–60 ms
paralaxe / profundidadeheróis em camadas, cenas de rolagemvelocidades de camada 0.2–0.6 da rolagem; linhas do tempo de rolagem onde suportado
  1. Coreografe por estas regras:

    • Ordem: fundo/contêiner → ponto focal → título → suporte → CTA. Cromo (nav) por último, ou primeiro como um fade rápido de 150 ms se emoldurar a página.
    • O tamanho define a duração (ícones no limite inferior, hero images/cards no limite superior da faixa).
    • Uma única alternância (alternar item aberto/fechado, alternar preço) é um morph ou rotação em 250 ms sem stagger e com bounce/fade de 80 ms nos outros elementos.
    • Múltiplas alternâncias usam stagger como listas.
    • Texto corrido em vez de título tratado: fade + subida com o texto inteiro como um bloco.
    • Um gráfico (um número, uma barra, um termômetro) é o ponto focal; os valores anteriores e o rótulo entram como suporte, mas com parada imediata no layout (sem stagger antes do gráfico).
    • Rolagem: as animações de entrada acionam no first-view (interseção inicial com a viewport) a menos que o usuário peça scroll-triggered. Parallax é uma adição separada.
    • Durações da página: a primeira peça e a última peça são mais lentas (o topo define o tom, o CTA convida à ação).
  2. Construa na ferramenta de destino (pergunte uma vez, a menos que o usuário tenha especificado). Copie os easings e os tempos da personalidade; mapeie o deslocamento em px da imagem para o destino. Use os scripts de rastreamento da Etapa 2 se você não tiver certeza da distância (medir é sempre mais rápido do que adivinhar).

  3. Verifique (rodada 1): ref_frames.py da renderização (ou gravação), motion_compare.py referência vs nossa — mas aqui a "referência" é a imagem estática. motion_compare não tem nada para comparar, então pule para activity.png: o movimento projetado está suave (curva de velocidade contínua sem picos) e visível (curva de atividade está acima do ruído)? Em seguida, uma inspeção visual das folhas: a animação de entrada corresponde ao que o modo Diretor projetou na especificação? Quando a especificação for pequena (3-5 elementos), leia as folhas; quando for grande, exiba o spec.md e pergunte ao usuário: "O movimento parece certo?" Após o OK, pule para a Etapa 5 acima (compare e corrija).

Modo História: uma cena de vídeo em vez de uma entrada de UI, projetada a partir de imagens estáticas

(Veja o resumo original para detalhes; o fluxo é semelhante ao modo Diretor, mas aplicado a uma peça de vídeo de 15-60 segundos com transições e narrativa.)

Habilidades Relacionadas