Annexe V · SVG

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.

Objectif de ce chapitreWhat you’ll learn
Wat je leert
  • 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
⏱ ~45 min
PrérequisPrerequisites
Vereisten

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 :

\[ s_x = \frac{W}{w}, \qquad s_y = \frac{H}{h}, \qquad \texttt{meet} : s = \min(s_x, s_y), \qquad \texttt{slice} : s = \max(s_x, s_y) \]

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 :

\[ t_x = \alpha_x\,(W - s\,w) - s\,x_{min}, \qquad \alpha_x \in \{0,\ \tfrac12,\ 1\} \ \text{pour Min, Mid, Max} \]
\[ \begin{pmatrix} X \\ Y \\ 1 \end{pmatrix} = \begin{pmatrix} s & 0 & t_x \\ 0 & s & t_y \\ 0 & 0 & 1 \end{pmatrix} \begin{pmatrix} x \\ y \\ 1 \end{pmatrix} \]

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.

Piège

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é :

Le d, jeton par jeton

#jetonΔpoint absolu

Les sommes ne sont pas nulles avant le z :

\[ \sum \Delta x = 2 + 5 - 5 - 2 - 2 - 5 + 5 = -2, \qquad \sum \Delta y = 5 + 2 + 2 + 5 - 5 - 2 - 2 = 5 \]

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 :

\[ P_k = C + \rho_k \begin{pmatrix} \cos\theta_k \\ \sin\theta_k \end{pmatrix}, \qquad \theta_k = -\frac{\pi}{2} + \frac{k\pi}{n}, \qquad \rho_k = \begin{cases} R & k \text{ pair} \\ r & k \text{ impair} \end{cases} \]

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 à

\[ Q\!\left(\tfrac12\right) = \frac{P_0 + 2P_1 + P_2}{4} \]

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 :

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) :

\[ x_1' = \cos\varphi\,\frac{x_1 - x_2}{2} + \sin\varphi\,\frac{y_1 - y_2}{2}, \qquad y_1' = -\sin\varphi\,\frac{x_1 - x_2}{2} + \cos\varphi\,\frac{y_1 - y_2}{2} \]
\[ \Lambda = \frac{ {x_1'}^2 }{r_x^2} + \frac{ {y_1'}^2 }{r_y^2}, \qquad \Lambda > 1 \;\Rightarrow\; (r_x, r_y) \leftarrow \sqrt{\Lambda}\,(r_x, r_y) \]

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, Δygauchehautdroite = x + wbas = y + hbande visible
(0, 0)==−3−3droite + bas
(3, 0)+3==−3gauche + 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.

#xyw = hx+wy+hbande

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.

Les rayons ne sont pas concentriques

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 ».

Deux détails du fichier
  • class="clean" sur un rect : seul fill: white s'applique. font et text-anchor n'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 porte clip-path="url(#carre)". Ses rx="28" ne correspondent d'ailleurs pas aux rx="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)
Piège : le tiret dans un id

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 :

\[ P = 2(w + h) - (8 - 2\pi)\,r_x \qquad \Rightarrow \qquad P_{75 \times 75,\ r_x = 22} = 300 - 37{,}77 = 262{,}23 \]

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)

w = 60 → rx max 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 :

\[ R(\theta;\ c) = T(c)\; R(\theta)\; T(-c) \]

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

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

Bugs
  • logo.click ne se déclenche jamais. Aucun élément n'a id="logo". SMIL ignore en silence un begin qui 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=1 sont 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 le set to="1" de click+.6s regagne, 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.
À vérifier (peut-être voulu)
  • y devient 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) et fill noir. 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, .texte s'appliquent à toute la page HTML, comme une feuille CSS ordinaire. Même chose pour les id : #carre entre 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

\[ B(t) = (1-t)^3P_0 + 3(1-t)^2t\,P_1 + 3(1-t)t^2\,P_2 + t^3P_3 \]

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.

getBBox ment (un peu)

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).

Récap
  • 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-box sinon tout tourne autour de (0, 0).
  • JS : createElementNS, getScreenCTM().inverse(), getPointAtLength.
  • Les <style> et les id d'un SVG inline sont globaux à la page.