Communitygithub.com

motion-match

Analyse une animation de référence (vidéo, GIF, enregistrement d'écran) et la reproduit fidèlement dans votre outil de conception ou votre code, avec une vérification image par image.

Qu'est-ce que motion-match ?

Ce skill permet à un agent IA de transformer n'importe quelle animation de référence en spécifications mesurables et de la reconstruire dans l'outil ou le langage choisi par l'utilisateur (CSS, Web Animations API, Framer Motion, GSAP, Remotion, SwiftUI, After Effects). Il décompose automatiquement les coupures, les mouvements, les fondues, les rotations et les morphings, puis compare le rendu final image par image jusqu'à une précision de ±0,08 s. Trois modes sont disponibles : le mode standard pour une animation de référence, le mode 'Director' pour créer une animation à partir d'images fixes, et le mode 'Edit' pour découper des clips vidéo en publicités avec du motion design. Le skill s'appuie sur des scripts Python utilisant numpy, Pillow et ffmpeg, et son flux de travail est organisé en dossiers : ref/ (analyse de la référence), ours/ (analyse de notre rendu), compare-N/ (chaque round de comparaison) et spec.md (cahier des charges de l'animation).

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

Demander à votre IA préférée

Ouvre une nouvelle conversation avec cette compétence d'agent déjà préchargée.

Documentation

Motion match : mesurer n'importe quelle animation, la reconstruire, prouver qu'elle bouge de la même manière

Transforme « faites-le bouger comme ça » en chiffres : chaque coupure, et pour chaque élément en mouvement son début, sa durée, son easing, son dépassement, son déplacement, sa rotation et son changement de forme. Reconstruisez le mouvement dans l'outil que l'utilisateur utilise (CSS, l'API Web Animations, Framer Motion, GSAP, Remotion, SwiftUI, After Effects), puis comparez image par image jusqu'à ce que le timing corresponde à ±0,08 s. Pas d'animation de référence, seulement des images fixes ? Utilisez le Mode Director (ci-dessous) pour les entrées d'interface et le Mode Story pour les reels et les vidéos explicatives : Claude conçoit le mouvement, le construit, puis mesure son propre rendu avec les mêmes scripts, de sorte que le « fluide » est vérifié, pas seulement affirmé. Des clips vidéo à découper en publicité (UGC, généré par IA, filmé) ? Utilisez le Mode Edit : les mêmes mesures, règles Director et révision, appliquées à la vidéo. Méthodes adaptées de NiazMorshed2007/reanimate et rossark0/rossark-motion-skill (tous deux MIT) ; les scripts sont les nôtres.

<skill> est le dossier de ce skill. Le travail se fait dans ./motion-match/<nom>/ dans le dossier courant : ref/ (analyse de la référence), ours/ (analyse de notre rendu), compare-N/ (chaque round de comparaison), spec.md.

Configuration (première fois)

Nécessite ffmpeg/ffprobe dans le PATH et un Python 3 avec numpy et Pillow.

  • Vérifiez : python3 -c "import numpy, PIL". Si cela échoue, cherchez un Python qui les a (un venv de projet existant), sinon demandez à l'utilisateur une fois, puis : python3 -m venv ~/.motion-match/venv && ~/.motion-match/venv/bin/pip install numpy pillow et utilisez ~/.motion-match/venv/bin/python comme python ci-dessous. Exécutez chaque script avec -I.
  • Les modes Director et Story rendent également des pages sans tête : pip install playwright && python -m playwright install chromium (demandez une fois). Si cela ne peut pas être installé, enregistrez l'écran de la page à la place et dites que les timings sont moins précis.
  • Pas d'autres installations ; rien n'est téléchargé ailleurs.

0. Périmètre (écrivez-le en haut de spec.md avant de mesurer)

  • Cible : le fichier + la plage temporelle (+ le recadrage) exactement comme l'utilisateur l'a dit (« les 3 premières secondes », « seulement le bouton »).
  • Fidélité : fidèle au mouvement (par défaut) : ordre, timing (±0,08 s), famille d'easing, dépassement, déplacement relatif à la taille de l'élément, décalage. Les propres éléments graphiques, couleurs, polices et mots de l'utilisateur. Fidèle au pixel seulement si l'utilisateur le demande et seulement pour une pratique privée : le design, le logo, les personnages et la musique de quelqu'un d'autre sont les leurs ; n'aidez jamais à publier une copie de ceux-ci.
  • Destination : l'outil ou le code dans lequel le mouvement va (demandez une fois si ce n'est pas clair : cela détermine le format de sortie).
  • Obtenir la référence : un fichier donné par l'utilisateur, ou un enregistrement d'écran qu'il fait (sites web et applications : enregistrez l'interaction ; le skill fonctionne à partir des images, pas du code du site). Téléchargez depuis YouTube ou un site seulement quand l'utilisateur demande cette vidéo spécifique, dans son propre dossier ; traitez-la comme un matériel de référence privé.

1. Décomposer

python -I <skill>/scripts/ref_frames.py REF.mp4 --out motion-match/<nom>/ref [--start S --end E --crop x:y:w:h] → chaque image au fps source, sheets/timing_NN.png (chaque image : timing, easing, suivi) et sheets/poses.png (2 par seconde : ce qui se passe). Lisez chaque feuille. Les GIFs fonctionnent de la même manière.

2. Mesurer

  • Coupures et sections : python -I <skill>/scripts/motion_compare.py motion-match/<nom>/ref motion-match/<nom>/ref --out motion-match/<nom>/self --no-align liste les coupures (changements de scène) et les mouvements de la référence avec leurs temps. Les références qui ne deviennent jamais immobiles sont divisées à leurs coupures.
  • Couleurs exactes : python -I <skill>/scripts/track_motion.py <ref>/frames --sample X,Y --at T (coordonnées pixel de l'image en taille réelle, pas d'une feuille de contact).
  • Chaque élément en mouvement : track_motion.py <ref>/frames --name btn --colors HEX,HEX --tol 35 --region x,y,w,h [--save-masks] (ou --not-bg HEX pour « tout ce qui n'est pas l'arrière-plan »). Sur les références lumineuses ou chargées, donnez toujours un --region et des couleurs uniques à l'élément ; vérifiez que la plage d'images visibles imprimée a du sens. Enregistre la position (cx cy), la taille (w h), l'écrasement (aspect), les bords, les fondus/croissances (presence), la couleur et la rotation (angle) par image.
  • Chaque mouvement : python -I <skill>/scripts/fit_easing.py <ref>/track_btn.json --prop cy --from A --to B (un mouvement par fenêtre, jamais à travers une coupure) → début, fin, durée en ms et en images, famille d'easing, dépassement, temps de stabilisation et lignes prêtes à copier pour CSS, WAAPI, Framer Motion, GSAP et Remotion. Une erreur ≤ 0,03 est un ajustement serré ; « aucun easing simple ne correspond » signifie diviser la fenêtre, ou c'est une chaîne de poses (images clés).
  • Les petits mouvements (un écrasement de 2 %, un flottement de 5 px) n'apparaissent pas sur les feuilles mais apparaissent dans les chiffres de suivi : lisez-les.
  • Le texte qui apparaît en petit se situe près du bruit de la courbe d'activité : mesurez-le avec track_motion à la place.

Quels chiffres mesurent quel type de mouvement

mouvementmesuré avecremarques
déplacement, glissement, flottementcx, cyun axe par ajustement
mise à l'échelle, croissance, écrasementw, h, aspect
fondupresence (avec --colors)
rotation, vrilleangle (degrés, sens horaire +, continu au-delà de 360)à partir de la silhouette ; None pour les cercles : suivez une marque sur eux comme leur propre élément et ajustez son cx/cy. Les formes avec une symétrie d'ordre n (carré : 4) ont besoin de < 180/n degrés par image, donc les rotations rapides nécessitent une source à haute fps. D'autres formes de la même couleur dans la région la gâchent : rétrécissez --region
morphing (forme → forme)--save-masks, puis shape_compare.pyvoir ci-dessous
retournement 3D / cartew (rétrécit comme cos) + presence ; changement de couleur au point médianle dos est son propre élément
mouvement sur chemin (arc, courbe)cx et cy tous les deux, plus angle s'il tourne le long du cheminajustez chaque axe ; la forme du chemin est sur les feuilles
révélation par clip / masque, voletx1 ou y1 (le bord avant), w/h
dessin de lignepresence
scission de texte (par mot/lettre)suivez le premier et le dernier mot ; le décalage est leur écart de début ÷ (nombre − 1)
compteurs, barres de graphiquebarres : h/y0 ; nombres : les feuilles (estimé à l'œil)

Morphings. track_motion.py ... --name blob --save-masks enregistre la silhouette de chaque image (centrée, redimensionnée à une surface égale). Puis :

  • python -I <skill>/scripts/shape_compare.py <ref>/track_blob_masks.npz --from A --to B ajoute une série morph (0 = première forme, 1 = dernière) à track_blob.json. fit_easing.py ... --prop morph donne alors son début, sa fin et sa durée. Le progrès du morphing suit la surface, donc ses timings sont fiables mais son nom d'easing n'est pas une valeur à coller : prenez l'easing du cahier des charges, ou d'un paramètre que vous pouvez suivre (w, aspect, angle).
  • Notre rendu contre la référence : shape_compare.py REF_masks.npz --vs OURS_masks.npz --from A --to B [--rotate] → chemin de forme : est-ce que chaque forme intermédiaire de la référence est aussi dans la nôtre, quel que soit son temps (RÉUSSI : moyenne ≤ 10 %, pire ≤ 25 % du morphing entier). Puis fit_easing.py REF_TRACK --prop morph --vs OUR_TRACK vérifie le timing. --rotate ignore la rotation quand le morphing tourne aussi (vérifiez cela avec angle).

3. Écrire le cahier des charges du mouvement (spec.md ; chaque ligne devient une vérification)

| # | élément | propriété | de → vers | début s | durée s (images) | easing | dépassement | décalage / remarques | source |
| 1 | carte | translateY | 40 → 0 px | 0,20 | 0,60 (18) | easeOutCubic / cubic-bezier(.33,1,.68,1) | 0% | +0,08 s par carte | track + fit_easing |
| 2 | icône | rotate | 0 → 180 deg | 0,40 | 0,30 (9) | easeOutCubic | 0% | — | track angle + fit_easing |
| 3 | blob | morph | carré → cercle | 0,50 | 0,40 (12) | easeInOutCubic | — | forme chemin RÉUSSI | shape_compare |
| c | — | coupures | — | 1,77, 2,33 | — | — | — | — | motion_compare self |

Un « ? » dans une ligne signifie que les images n'ont pas encore été lues. Notez aussi ce qui ne bouge pas. Montrez le cahier des charges à l'utilisateur avant de construire quand le travail est important.

4. Construire

Dans l'outil de l'utilisateur, avec son design. Copiez les timings du cahier des charges et les easings de la sortie du script pour cet outil. Mappez les distances relatives à l'élément ou au cadre lorsque la disposition diffère. Chaînes de poses : images clés avec interpolation lisse et sans dépassement ; ressorts lorsque la référence dépasse et se stabilise.

  • Rotation : définissez transform-origin explicitement (mesurez le pivot : le point dont cx, cy reste en place).
  • Morphings : les chemins SVG ont besoin du même nombre et du même type de commandes aux deux extrémités (ou utilisez flubber / GSAP MorphSVG) ; les morphings de disposition d'interface (bouton → carte, miniature → page) utilisent FLIP ou les transitions d'élément partagé (Framer layoutId, l'API View Transitions) ; les morphings de rayon de bordure / taille sont du CSS simple.
  • 3D : perspective 800–1200 px sur le parent, backface-visibility: hidden, les deux faces en tant que couches séparées.

5. Comparer et corriger (2-5 rounds)

  1. Rendez ou enregistrez l'écran de notre rendu sur la même fenêtre au même fps (enregistrez une page web de la même manière que la référence).
  2. ref_frames.py OURS.mp4 --out motion-match/<nom>/ours --like motion-match/<nom>/ref/frames.json (même fenêtre, recadrage, fps et taille d'image).
  3. motion_compare.py motion-match/<nom>/ref motion-match/<nom>/ours --out motion-match/<nom>/compare-N → décalage, chaque coupure et mouvement avec les erreurs de début/fin/durée/pic, RÉUSSI dans ±0,08 s, activity.png (les deux courbes) et sheets/compare_NN.png (référence | notre rendu | différence). Lisez les feuilles à chaque round.
  4. Par ligne du cahier des charges : suivez notre rendu de la même manière, puis fit_easing.py REF_TRACK --prop P --from A --to B --vs OUR_TRACK → par mouvement timing RÉUSSI/ÉCHEC, correspondance du déplacement et de la famille d'easing. Lignes de morphing : shape_compare.py --vs également.
  5. Corrigez la plus petite chose que les preuves indiquent, re-rendez, répétez. Après 5 rounds, signalez tout ce qui échoue encore avec ses chiffres et la raison. Ne relâchez jamais la tolérance en silence.
SymptômeCause habituelleCorrection
tout décalé d'un décalagedélai de démarrage ou latence de déclenchementajustez le premier délai
notre rendu plus court et chargé au débuteasing trop fort (expo vs cubic)utilisez le bezier ajusté
la référence dépasse, pas la nôtrespring/back vs easing simpleback.out / un ressort réglé sur le dépassement mesuré
un mouvement dans notre rendu s'arrête tôtun mouvement secondaire manque (une dérive, un zoom avant)regardez les feuilles dans cette fenêtre
un mouvement ou une coupure supplémentaire dans notre renduquelque chose s'anime qui est immobile dans la référencesupprimez-le ou retardez-le
les numéros d'éléments sautentle suivi a attrapé un autre élémentrétrécissez --region, utilisez des couleurs qui lui sont uniques
la rotation est correcte, mais notre rendu vacille en cx/cymauvais transform-origindéplacez le pivot au point fixe mesuré
morphing timing RÉUSSI, chemin de forme ÉCHECles chemins sont interpolés différemment (ordre des points, point de départ)réordonnez les points du chemin / faites correspondre les commandes ; utilisez une bibliothèque de morphing

6. Rapport

Fidélité ; ce qui a été mis en correspondance et ce qui est propre à l'utilisateur ; le dernier tableau de comparaison (coupures et mouvements avec erreurs, RÉUSSI/ÉCHEC) ; lignes par élément ; chemins vers activity.png et les feuilles de comparaison ; chaque différence restante avec son nombre et sa raison ; et quelles vérifications ont été mesurées (un script les a produites) vs estimées à l'œil (regardées sur une feuille).

Mode Director : une image fixe en entrée, un mouvement conçu pour elle

À utiliser lorsque l'utilisateur donne une image (capture d'écran d'interface, maquette, affiche, photo de produit) sans mouvement de référence, ou demande à Claude de choisir le mouvement. Le travail se fait dans ./motion-match/<nom>/ comme d'habitude (ours/, spec.md, check-N/). Pour un morceau vidéo plutôt qu'une entrée d'interface, suivez ces étapes dans le Mode Story (ci-dessous).

  1. Lire l'image. Listez chaque élément (arrière-plan, navigation, titre, corps, image, CTA, cartes, icônes) avec sa boîte en px, son rôle et son rang : un point focal, puis support, puis chrome. Notez l'ordre de lecture, les groupes (une rangée de cartes, une liste), l'ambiance (calme/premium, neutre/produit, ludique) et tout ce qui suggère un mouvement spécial (une icône de bascule, un graphique, un logo, un chemin courbe, une carte retournable).
  2. Choisissez une personnalité selon l'ambiance à moins que l'utilisateur n'en ait nommé une. Quand ils demandent des options, construisez les trois.
personnalitéentréeduréeeasingdéplacementdécalagedépassement
calmefondu + montée400–600 mseaseOutQuart / cubic-bezier(.25,1,.5,1)8–16 px60–80 msaucun
neutrefondu + montée, ou échelle .97→1250–400 mseaseOutCubic / cubic-bezier(.33,1,.68,1)12–24 px40–60 msaucun
ludiquemontée + échelle .9→1ressortressort (raideur 300–400, amortissement 20–26)16–32 px50–70 ms3–8%
  1. Choisissez un mouvement spécial par rôle (le vocabulaire ; les valeurs sont des points de départ, mis à l'échelle par la personnalité) :
mouvementutilisez-le pourvaleurs par défaut
morphingbascules d'icônes (menu ↔ fermer, lecture ↔ pause), un bouton qui se développe en carte ou en feuille, un logo de forme300–500 ms easeInOutCubic ; morphings de disposition via FLIP/élément partagé
rotationicônes de bascule/chevron, actualisation, entrée inclinéeicône 90–180° en 200–300 ms easeOutCubic ; entrée −6…−10° → 0 avec l'easing de la personnalité ; chargeur 360° linéaire 0,8–1,2 s boucle
retournement 3D / inclinaisoncartes à deux faces, bascules de prix, profondeur au survolretournement rotateY 180° en 500–700 ms easeInOutCubic ; inclinaison au survol ≤ 8°
mouvement sur cheminquelque chose qui voyage (un avion, un point le long d'un itinéraire, un curseur)easeInOutSine, tours le long du chemin, 0,8–1,6 s
révélation par clip / masqueimages héros, grands titresclip inset ou cercle, 500–800 ms easeOutQuart
scission de texteseulement le titre principalmots 40–60 ms d'écart, lettres 15–30 ms ; ligne entière ≤ 1 s
dessin de ligneicônes, signatures, graphiques, soulignementsstroke-dashoffset, 600–1000 ms easeInOutCubic
compteurs / croissance de graphiquenombres, barres, anneauxnombres 800–1200 ms easeOutExpo ; barres à partir de la ligne de base, décalées 40–60 ms
parallaxe / profondeurhéros en couches, scènes de défilementvitesses de couche 0,2–0,6 du défilement ; timelines de défilement si supportées
  1. Chorégraphiez selon ces règles :

    • Ordre : arrière-plan/conteneur → point focal → titre → support → CTA. Chrome (navigation) en dernier, ou en premier comme un fondu rapide de 150 ms s'il encadre la page.
    • La taille définit la durée (icônes à l'extrémité basse, éléments de héros et de page entière à l'extrémité haute).
    • Les entrées jamais immobiles : un mouvement de maintien (flottement, doux rebond, impulsion) après la stabilisation.
    • Mouvement de fond : quand l'arrière-plan bouge, faites-le à 30–50 % de la vitesse de l'élément focal, en opposition.
    • Les groupes entrent par rangée ou grille : décalage calculé comme durée ÷ nombre d'éléments.
    • Même élément, même mouvement, même timing (les cartes d'une grille entrent de la même manière).
    • Évitez les conflits : un fondu + un glissement sur le même élément n'est pas un conflit ; une rotation + un morphing pourrait l'être.
  2. Construire (section 4, ci-dessus). Ensuite Mode Director Round :

    • python -I <skill>/scripts/director_preview.py motion-match/<nom>/spec.md --out motion-match/<nom>/preview (non implémenté — pour l'instant enregistrez l'écran de la page rendue comme référence, découpez-la avec ffmpeg à la même durée que l'animation, et utilisez --start 0 --end <durée en secondes> dans ref_frames.py). Le script à venir produira une vidéo de référence à partir du cahier des charges.
    • Continuez avec la comparaison et la correction (section 5, ci-dessus) avec le clip enregistré en tant que référence.
    • Rapport (section 6, ci-dessus).

Mode Story : un storyboard en entrée, une animation conçue pour lui

À utiliser lorsque l'utilisateur donne un tableau de style, une maquette Figma, une esquisse, des photos de produit ou une voix-off comme entrée unique, et veut que Claude produise un morceau animé — comme un reel, une vidéo explicative, une annonce — avec des légendes et des graphiques animés. Le travail se fait dans ./motion-match/<nom>/ (ours/, spec.md, check-N/).

  1. Décomposez l'entrée en une histoire sur une timeline. Comptez ~3–5 secondes par scène. Utilisez les règles Director pour concevoir le mouvement à l'intérieur de chaque scène, mais en suivant une narration, pas seulement une mise en page. Écrivez le scénario dans spec.md sous forme de storyboard :
| scène | temps | visuel | action | voix-off / légende | mouvement |
|---|---|---|---|---|---|
| 1 | 0–1,5 s | plan large, forme du logo | icône de logo se développe en page | titre : « Rencontrez Voxly » | morphing icône → page, logo fondu + échelle .85→1  |
| 2 | 1,5–4,0 s | liste de fonctionnalités défilant | 3 cartes glissent de la droite | légendes sous chaque carte | cartes en glissement, décalées 200 ms, easeOutCubic |
| 3 | 4,0–6,0 s | graphique en barres | barres qui poussent, compteur de nombres | « 2x plus rapide » | barres easeOutExpo, nombres décalés 50 ms |
| 4 | 6,0–8,0 s | écran partagé : avant/après | vidéo de démonstration | « Essayez-le gratuitement » | CTA fondu + montée |
  1. Construire en HTML/CSS/JS, en Remotion ou en SwiftUI selon ce que l'utilisateur a demandé. Chaque scène est un composant, lié par CSS animations ou par une bibliothèque de chronologie.
  2. Mode Edit (découpage de clips vidéo) : au lieu de construire à partir de zéro, vous travaillez avec une vidéo source. Utilisez les mesures du Mode Director pour ajouter des légendes et des graphiques animés aux moments appropriés, en calant le mouvement sur le rythme de la coupe existante.

Règles pour les légendes et la typographie

  • Police : la police de l'utilisateur, ou Inter / SF Pro / système par défaut. Poids : Bold pour les titres, Medium/Semi-Bold pour les légendes.
  • Légendes : fond sombre à 40–60 % d'opacité, remplissage de la largeur par rapport au texte, pas à l'écran. Bord arrondi 8 px.
  • Animations de texte : fondu + glissement de 12 px, 300 ms easeOutCubic ; par mot si le timing le permet.
  • Ne superposez jamais les légendes sur les visuels clés (visages, boutons, produits).
  • Les légendes ne sont pas des sous-titres codés en dur — elles sont un élément de motion design. Utilisez des légendes contextuelles qui mettent en valeur le message.

Dépannage

ProblèmeCauseSolution
ref_frames.py ne produit que des images noiresLe codec vidéo n'est pas supporté par ffmpegConvertissez la vidéo en mp4 H.264 d'abord
track_motion.py ne trouve pas l'élémentLa couleur est trop courante ou la région est trop grandeUtilisez --sample pour trouver des couleurs exactes, rétrécissez --region
Les feuilles de comparaison sont videsLes deux vidéos ont des fps ou des tailles d'image différentsUtilisez --like pour forcer la même taille d'image et le même fps
Le morphing échoue avec « shapes have different vertex counts »Les chemins ont un nombre de points différentUtilisez une bibliothèque de morphing qui gère cela (flubber) ou pré-traitez les chemins

Considérations éthiques

  • Ne jamais reproduire de designs, logos ou personnages protégés par le droit d'auteur sans autorisation explicite. Le mode pixel-faithful est destiné à la pratique privée uniquement.
  • Ne pas utiliser pour créer des deepfakes ou du contenu trompeur.
  • Les animations mesurées à partir de vidéos téléchargées doivent être traitées comme des références privées, ne pas être redistribuées.
  • Donner le crédit approprié lorsque des parties du travail sont basées sur des animations open source ou des tutoriels.

Skills associés