SVG — que des cas compliqués
Pas de « voici un cercle ». On part d'un vrai fichier, le logo animé de la page ↘ Introduction : neuf rect empilés, des lettres qui tombent, un é qui tourne, et une étoile tenue en quinze nombres. On le démonte pièce par pièce : le repère, le path, l'arc, la pile de rectangles, la timeline SMIL, et les bugs qu'on y trouve. Chaque démo est vivante : modifie, casse, regarde.
- Calculer à la main ce que font viewBox et preserveAspectRatio
- Lire un path relatif avec répétition implicite, commande par commande
- Choisir parmi les 4 arcs possibles d'une commande A
- Comprendre la pile de rect du logo et l'animer en cascade (syncbase)
- Maîtriser la timeline SMIL : begin multiples, fill, additive, keySplines
- Piloter le SVG en JavaScript : getScreenCTM, getPointAtLength, createElementNS
- Générer le même SVG en Python
Le fichier de départ
Voici le logo tel quel, sans une virgule de changée. Il est rendu juste en dessous à partir du même texte : ce que tu lis est exactement ce qui tourne.
Rendu (original)
Étoile seule : <path d="M80 70 l2 5 5 2 -5 2 -2 5 -2 -5 -5 -2 5 -2z"/>
En bas à droite, en noir : l'étoile à sa vraie place (aucun fill = noir par défaut). Au centre, en orange : la même, agrandie par une chaîne de transform — on y revient plus bas.
Code source complet
1. Le repère : viewBox et preserveAspectRatio
viewBox="0 0 100 100" ne dit pas « 100 pixels ». Il dit : « le dessin vit dans un carré de 100 unités, débrouille-toi pour le faire tenir dans la boîte que la page me donne ». La boîte (le viewport) mesure \( W \times H \) pixels CSS, la viewBox \( w \times h \) unités à partir de \( (x_{min}, y_{min}) \). Le navigateur calcule une échelle par axe :
Avec meet (le défaut), tout le dessin est visible et il reste des bandes vides ; avec slice, la boîte est entièrement couverte et le dessin déborde, donc il est rogné. Puis l'alignement (xMin, xMid, xMax, idem en y) décide où va le surplus :
C'est la même matrice qu'une projection orthographique 2D : \( (x, y) \) en unités utilisateur devient \( (X, Y) \) en pixels. Avec none, il n'y a plus un seul \( s \) mais \( s_x \neq s_y \) : le carré devient rectangle, et meet/slice sont ignorés.
Le fond gris foncé est le viewport. Le cadre pointillé orange est la viewBox, dessinée dans le repère du SVG : avec slice, il sort du viewport.
Sans viewBox ni taille, un <svg> inline fait 300 × 150 px, la taille par défaut d'un élément remplacé (comme <canvas>). Avec une viewBox mais sans largeur, il prend toute la largeur disponible et la hauteur suit le ratio. Dans un conteneur flex ou inline-block, cette largeur « disponible » peut tomber à 0 et le logo disparaît. Donne toujours une largeur explicite à un SVG inline.
2. Une étoile en quinze nombres
Trois règles du mini-langage de d font toute la difficulté :
- Majuscule = absolu, minuscule = relatif.
M80 70pose le stylo en (80, 70).l2 5veut dire « 2 à droite, 5 vers le bas depuis où tu es » : en SVG, y grandit vers le bas. - Répétition implicite. Après
l2 5, les paires suivantes n'ont pas de lettre : elles réutilisentl. Le piège : après unM, les paires suivantes deviennent desL(et après unm, desl), pas d'autresM. zn'est pas un « dernier segment » comme un autre. Il trace le segment de retour et soude la fin au début avec une jointure (stroke-linejoin). Revenir à la main au point de départ laisse deux bouts de trait non soudés.
Le d, jeton par jeton
| # | jeton | Δ | point absolu |
|---|
Les sommes ne sont pas nulles avant le z :
On finit en (78, 75), et c'est le z qui ajoute le dernier segment (+2, −5). Le dessin est symétrique autour du centre \( C = (80, 77) \) : quatre pointes à 7 unités, quatre creux en \( C + (\pm 2, \pm 2) \), donc à \( 2\sqrt2 \approx 2{,}83 \). Chaque segment mesure \( \sqrt{2^2 + 5^2} = \sqrt{29} \), le périmètre vaut \( 8\sqrt{29} \approx 43{,}08 \) — un nombre qu'on retrouvera avec getTotalLength().
z contre retour manuel
Même étoile, trait épais (stroke-width="2", stroke-linejoin="miter"). À gauche …5 -2z, à droite …5 -2 2 -5 : on revient au même point, mais sans soudure. Regarde la pointe du haut.
…5 -2z
…5 -2 2 -5 (pas de z)
À droite, la pointe du haut est coupée à plat : ce sont deux extrémités de trait (stroke-linecap="butt") qui se chevauchent, pas une jointure. Le fill, lui, est identique : le remplissage ferme toujours le chemin tout seul.
3. Générer l'étoile : \( n \) branches, lignes ou courbes
L'étoile du logo est un cas particulier d'une formule. On alterne \( 2n \) points, une pointe à la distance \( R \), un creux à la distance \( r \), en tournant d'un demi-secteur à chaque fois, à partir du haut :
Avec \( n = 4,\ R = 7,\ r = 2\sqrt2 \), le premier creux est à \( \theta_1 = -45° \), soit \( C + (2, -2) = (82, 75) \). Le générateur ci-dessous ressort exactement le d du logo en version relative.
En mode courbe, chaque pointe rejoint la suivante par une Bézier quadratique Q dont le point de contrôle est le creux. La courbe ne passe pas par son point de contrôle : son milieu est à
donc plus près du centre que la ligne droite. Avec \( r = 0 \), le contrôle est au centre : c'est l'étincelle ✦ concave classique.
d généré
4. L'arc A : 7 paramètres, 4 solutions
A rx ry φ large sweep x y est la commande la plus traître du SVG. On ne donne pas un centre et deux angles, on donne deux extrémités et une ellipse. Or par deux points passent en général deux ellipses de rayons \( (r_x, r_y) \) tournées de \( \varphi \), et sur chacune on peut faire le petit ou le grand tour : 4 arcs. Les deux drapeaux choisissent lequel :
large-arc-flag: 1 = l'arc de plus de 180°, 0 = celui de moins de 180°.sweep-flag: 1 = sens des angles croissants, c'est-à-dire horaire à l'écran puisque y descend ; 0 = antihoraire.
Deuxième piège : si les rayons sont trop petits pour relier les deux points, le navigateur ne lève pas d'erreur, il les agrandit en silence (spec SVG, annexe B.2.5) :
Quand \( \Lambda \ge 1 \), les deux ellipses n'en font plus qu'une, et les 4 arcs se réduisent à 2 demi-ellipses : large-arc-flag ne change plus rien. Descends \( r_x \) pour le voir.
Lecture
En gris : les 4 arcs possibles. En orange : celui que tes drapeaux sélectionnent. Le point bleu est le départ (30, 62), le point blanc l'arrivée (70, 38).
5. La pile de rect du logo
Neuf rectangles arrondis, alternativement vert (.fond) et blanc (.clean), chacun 3 unités plus petit que le précédent. Dans quel ordre ? Le SVG n'a pas de z-index : l'ordre du document est l'ordre de peinture, chaque élément recouvre ceux d'avant. Ce qu'on voit n'est donc jamais un rectangle entier, mais la bande que le suivant ne recouvre pas.
La clé est dans le décalage entre deux rect successifs. Comme la taille baisse toujours de 3, le côté qui « perd » ses 3 unités dépend de (Δx, Δy) :
| Δx, Δy | gauche | haut | droite = x + w | bas = y + h | bande visible |
|---|---|---|---|---|---|
| (0, 0) | = | = | −3 | −3 | droite + bas |
| (3, 0) | +3 | = | = | −3 | gauche + bas |
| (3, 3) | +3 | +3 | = | = | gauche + haut |
| (0, 3) | = | +3 | −3 | = | haut + droite |
Le logo enchaîne exactement ce cycle, deux fois : (0,0) (3,0) (3,3) (0,3) (0,0) (3,0) (3,3) (0,3). La bande en L tourne d'un quart de tour à chaque rect, dans le sens horaire : bas-droite, bas-gauche, haut-gauche, haut-droite. C'est ça qui donne l'effet de spirale, sans un seul path.
| # | x | y | w = h | x+w | y+h | bande |
|---|
Le dernier rect est cerné en pointillé orange. Monte rx au-delà de la moitié de la taille : le navigateur le plafonne à \( w/2 \), et les petits rect deviennent des cercles.
Tous les rect gardent rx="22" alors qu'ils rétrécissent. Deux arcs de même rayon dont les centres sont décalés ne sont pas parallèles. Dans un coin où les deux côtés reculent de 3, les centres sont décalés de (3, 3) : sur la diagonale, la bande mesure \( 3\sqrt2 \approx 4{,}24 \) au lieu de 3, elle s'épaissit. Dans un coin où un seul côté recule, elle passe à \( 3/\sqrt2 \approx 2{,}12 \) sur la diagonale et s'effile vers le côté qui ne bouge pas. Pour une bande d'épaisseur constante, il faudrait \( r_{int} = r_{ext} - e \) avec le même retrait \( e \) des deux côtés, ce qui n'est pas le cas ici. Que ce soit voulu ou non, c'est ce qui donne au logo son côté « dessiné à la main ».
class="clean"sur unrect: seulfill: whites'applique.fontettext-anchorn'ont aucun sens pour un rect et sont ignorés sans erreur.- Le
<clipPath id="carre">est déclaré mais jamais utilisé : aucun élément ne porteclip-path="url(#carre)". Sesrx="28"ne correspondent d'ailleurs pas auxrx="22"des rect. La version corrigée plus bas l'utilise pour rogner « À RISQUE ».
6. Animer les rect
6.1 Cascade : chaque rect naît du précédent
Idée : chaque rect démarre avec la géométrie du précédent (donc invisible, puisque pile dessus), puis rétrécit vers la sienne. La bande apparaît en glissant. Pour enchaîner sans calculer de temps à la main, on utilise un syncbase : begin="ca3.end" veut dire « commence quand l'animation ca3 finit ». Change une durée, toute la chaîne suit.
Les autres attributs du même rect se calent sur begin="ca4.begin". Un <set attributeName="visibility"> le rend visible au même instant. Pour finir, les deux cadres pointillés et l'étoile se dessinent quand le dernier rect a fini.
SVG généré (c'est du SMIL pur, aucun JS pendant l'animation)
Dans begin, - sert aussi à écrire un décalage négatif : begin="a.end-0.2s". Un id comme ca-3 rend begin="ca-3.end" ambigu, et SMIL impose alors d'échapper le tiret (ca\-3.end). Les navigateurs ne sont pas tous d'accord entre eux : le plus sûr est de ne pas mettre de tiret dans les id que tu références. Ici : ca3, et logofix plus bas.
6.2 Les fourmis : stroke-dashoffset et le raccord
Les deux cadres pointillés du logo ont stroke-dasharray="3 2" : un motif de période \( 3 + 2 = 5 \). Animer stroke-dashoffset de 0 à −5 en boucle fait défiler les tirets sans saut, puisque décaler d'une période redonne la même image.
Sans saut… sauf à un endroit. Le motif part du début du contour (pour un rect arrondi : juste après le coin haut-gauche, en \( (x + r_x, y) \)) et s'arrête quand le périmètre est épuisé. Si le périmètre n'est pas un multiple de 5, le dernier tiret est tronqué et se colle au premier. Pour un rect à coins circulaires :
262,23 n'est pas un multiple de 5 : il reste 2,23 unités, soit un tiret de 2,23 au lieu de 3 au point de départ. La parade : pathLength="260". Le navigateur fait alors comme si le contour mesurait 260 et étire tout le motif (tirets et offset) d'un facteur 262,23 / 260. 260 = 52 périodes pile.
sans pathLength
pathLength="260"
Regarde dans le cercle orange : à gauche, un tiret court qui « bégaie » ; à droite, le défilement est continu.
6.3 Trois effets en un attribut chacun
tracé : pathLength="1"
Avec pathLength="1", stroke-dasharray: 1 = un tiret aussi long que tout le chemin. On fait glisser stroke-dashoffset de 1 à 0 : le trait se dessine, quelle que soit la vraie longueur.
rx : 0 → 45 (plafonné à 30)
De rx = 30 à 45, il ne se passe plus rien : le rect reste un cercle. Le « plateau » au milieu de l'animation est le clamp \( r_x \le w/2 \).
CSS rotate
7. CSS sur du SVG : le piège du transform-origin
Dans la démo de droite, sans la case cochée, l'étoile ne tourne pas sur elle-même : elle fait le tour du point bleu en (0, 0). En HTML, transform-origin vaut 50% 50% de la boîte de l'élément. En SVG, il vaut 0 0 et la boîte de référence est la viewBox entière (transform-box: view-box). Résultat : toute rotation CSS tourne autour du coin haut-gauche du dessin.
SMIL n'a pas ce problème parce qu'on lui donne le centre explicitement : type="rotate" from="0 64 30". Et rotate(θ, cx, cy) n'est qu'un raccourci :
On ramène le centre à l'origine, on tourne, on renvoie. Les matrices se lisent de droite à gauche, comme dans le chapitre ↘ Matrices. C'est aussi ce que fait l'étoile orange agrandie du tout début : translate(-30 -27) scale(1.6) translate(-30 -27) est un \( T\,S\,T \) qui agrandit autour d'un point. Le point fixe \( p \) vérifie \( 1{,}6\,(p - 30) - 30 = p \), soit \( p_x = 130 \). Il ne s'agit donc pas d'un zoom autour de l'étoile : la composition déplace aussi l'étoile vers le centre du carré.
8. La timeline du logo, seconde par seconde
Le logo ne contient pas une ligne de JS : tout est du SMIL, l'animation déclarative intégrée au SVG. Ce diagramme est construit en lisant le DOM du logo original rendu plus haut, et la barre verticale suit son horloge réelle (svg.getCurrentTime()). Clique « Rejouer » en haut de page pour la voir repartir.
Les briques
begin=".6s;logo.click+.6s": une liste d'instants. 0,6 s après le chargement, et 0,6 s après chaque clic sur l'élément d'idlogo. Chaque nouvel instant redémarre l'animation (restart="always"par défaut).<set>: saute à une valeur, sans interpolation. Sansdur, sa durée est indéfinie : il reste actif pour toujours, doncfill="remove"ne sert à rien sur cesset.fill="freeze"garde la dernière valeur à la fin ;fill="remove"(défaut) revient à la valeur de base. « À RISQUE » finit entranslate(0 0)puis leremoveenlève le transform : même image, aucun saut visible. Avec untodifférent de 0, la lettre sauterait.values="0 -20;0 3;0 0" keyTimes="0;.7;1": trois étapes. La lettre tombe de 20 unités en 70 % du temps, dépasse de 3 (le rebond), revient en 30 %.additive="sum"sur la rotation dué: sans lui, lerotateremplacerait letranslate. Avec, les deux se composent : \( M = T(t)\, R(\theta;\ 64, 30) \). La rotation est appliquée dans le repère déjà translaté : le centre (64, 30) voyage avec la lettre. 450° = un tour complet + 90° : leéfinit couché.calcMode="spline" keySplines="0 0 .2 1": chaque intervalle est réglé par une Bézier cubique de \( (0,0) \) à \( (1,1) \), commecubic-bezier()en CSS :\[ B(u) = 3(1-u)^2u\,P_1 + 3(1-u)u^2\,P_2 + u^3, \qquad P_1 = (0, 0),\ P_2 = (0{,}2,\ 1) \]On résout \( B_x(u) = t \) (le temps), puis on lit \( B_y(u) \) (la progression). Ici, un ease-out très fort : près de 70 % du trajet est fait dans le premier tiers du temps.
Deux animations sur le même attribut : le « sandwich »
R et é ont deux animateTransform translate non additifs. SMIL les empile par priorité : celle qui a commencé le plus tard gagne. De 0,6 s à 1,6 s, seule la chute est active. À 1,6 s, le glissement vers la gauche commence, devient prioritaire et remplace la chute (figée à 0 0). Ça marche parce que la chute s'arrête exactement en 0 0 et que le glissement repart de 0 0. Change l'un des deux, et la lettre sautera. Pour composer vraiment les deux, il faut additive="sum" sur le second, avec values="0 0;0 0;-23 0" devenu un delta.
9. Ce qui cloche dans le logo, et la version corrigée
logo.clickne se déclenche jamais. Aucun élément n'aid="logo". SMIL ignore en silence unbeginqui vise un id inexistant : seul le temps de chargement compte, et le logo n'est pas cliquable.- Même avec l'id, cliquer ne rejoue rien de visible. Les
set opacity=1sont indéfinis : les lettres restent affichées pendant que leurs chutes redémarrent. Il faut un<set to="0" begin="logo.click"/>pour les cacher d'abord. Il gagne, car commencé plus tard ; puis leset to="1"declick+.6sregagne, pour la même raison. - « Clean » rebondit dans le vide. Sa chute part à 1,6 s, mais il ne devient visible qu'à 8,6 s, quand tout est fini depuis longtemps. Au clic, en revanche, les deux sont à +1,6 s. La timeline le montre : barre à gauche, point tout à droite. C'est très probablement une faute de frappe pour 1,6 s.
ydevient visible à 2,9 s alors que sa chute part à 2,6 s : il apparaît aux trois quarts de sa course, donc presque sans rebond.- « À RISQUE » est ancré à droite en
x="116"(text-anchor="end"), hors de la viewBox (0 → 100). Le bout du texte est rogné par le débordement du SVG. - « À RISQUE » et « NETTOYAGE » sont en
#1f6f5c, la couleur du fond : on ne les lit qu'à travers les bandes blanches de la pile. Si c'est voulu, c'est un masque gratuit. - Le
équi tourne n'a pas de classe : police par défaut (serif, 16 px) etfillnoir. La classe.lettres(orange, 600) est déclarée mais jamais utilisée, peut-être lui était-elle destinée. - Le
<style>d'un SVG inline n'est pas privé..fond,.clean,.textes'appliquent à toute la page HTML, comme une feuille CSS ordinaire. Même chose pour les id :#carreentre en collision dès que le logo est inclus deux fois. La version corrigée préfixe tout par#logofix.
Corrigé — clique dessus
Ce qui change
id="logofix"sur le<svg>,begin="…;logofix.click+…"partout- un
<set opacity=0 begin="logofix.click"/>par élément animé - « Clean » visible à 1,6 s
- styles et id préfixés :
#logofix .fond,#logofix-carre - la pile est rognée par le
clipPath(qui sert enfin)
Code source corrigé
10. JavaScript ↔ SVG
10.1 Créer un élément : le namespace
10.2 Souris → coordonnées SVG : getScreenCTM()
Le SVG est affiché à 100 % de la largeur de la colonne : un pixel écran ne vaut pas une unité. getScreenCTM() renvoie la matrice complète « unités utilisateur → pixels écran » (viewBox, preserveAspectRatio, transforms, scroll). Son inverse fait le trajet retour. Attrape les poignées :
Lecture
La courbe ne touche que \( P_0 \) et \( P_3 \). Elle part tangente à \( P_0P_1 \) et arrive tangente à \( P_2P_3 \). Le point blanc est \( B(\tfrac12) = \tfrac18(P_0 + 3P_1 + 3P_2 + P_3) \).
10.3 Suivre un chemin : getTotalLength / getPointAtLength
Lecture
On retrouve \( 8\sqrt{29} \approx 43{,}08 \). L'orientation vient de deux points proches : \( \theta = \operatorname{atan2}(\Delta y, \Delta x) \). Aux pointes, la tangente tourne brutalement : la flèche pivote d'un coup.
el.getBBox() renvoie la boîte de la géométrie, dans le repère local de l'élément : sans l'épaisseur du trait, sans son propre transform, sans les filtres. Pour la boîte réellement peinte à l'écran, c'est getBoundingClientRect(), en pixels CSS. Pour un <text>, la bbox dépend de la police réellement chargée : mesure après document.fonts.ready.
11. Python : régénérer le logo
Les deux algorithmes de la page (pile et étoile) en vingt lignes. python3 pile.py écrit pile.svg et affiche M80 70 l2 5 5 2 -5 2 -2 5 -2 -5 -5 -2 5 -2z, caractère pour caractère celui du logo.
Le piège de fmt : \( 80 + 7\cos(-\pi/2) \) ne vaut pas 80 mais \( 80 + 4{,}3\cdot10^{-16} \), et une différence peut sortir en -4.44e-16, notation que le parseur de d accepte mais qui pollue le fichier. On arrondit, puis + 0.0 transforme le -0.0 en 0.0. Le JS de cette page fait la même chose avec Object.is(x, -0).
- viewBox → une matrice \( s, t_x, t_y \) ;
meet= min,slice= max,none= deux échelles. - Dans
d: minuscule = relatif, paires sans lettre = commande répétée,z= segment + soudure. - Arc : deux drapeaux pour 4 solutions ; rayons trop petits agrandis par \( \sqrt\Lambda \).
- Pas de z-index : l'ordre du document peint. La pile du logo est un cycle de 4 décalages.
- SMIL : syncbase
id.end, pas de tiret dans les id référencés, sandwich de priorités,additive="sum"pour composer. - CSS :
transform-box: fill-boxsinon tout tourne autour de (0, 0). - JS :
createElementNS,getScreenCTM().inverse(),getPointAtLength. - Les
<style>et les id d'un SVG inline sont globaux à la page.