Outils du site


wiki:latex:modules:animate

Introduction

Le package animate, conçu par Alexander Grahn, va vous permettre de créer des animations mathématiques sur des document pdf. Des animations comme celle-ci par exemple (cliquez sur la figure ou sur le bouton de lecture pour lancer l'animation). Attention, ces animations ne sont lisibles qu'avec les lecteurs de pdf Adobe Reader version 6 ou plus.

Quelques informations avant de commencer

But de ce wiki

Les objectifs sont :

  • De vous apprendre à utiliser le package animate en essayant de vous guider pas à pas à l'aide d'exemples complets. Beaucoup de choses sont abordées dans ce wiki mais il n'est pas exhaustif au point de se substituer à la documentation officielle sur le CTAN (pour lire la documentation, cliquez sur “download” situé sur la même ligne que “animate.pdf”). Le but est vraiment de vous initier en supposant que vous ne connaissez rien au départ sur ce package. En revanche, il vous est malgré tout nécessaire de posséder quelques bases en LaTeX, même si j'ai essayé de rendre ce wiki le plus accessible possible. Si vous vous donnez la peine de lire ce wiki jusqu'au bout, vous aurez une très bonne connaissance des principales fonctionnalités de ce package et serez en mesure de faire vos propres animations. Vous pourrez également consulter la documentation officielle sereinement pour obtenir plus d'informations (à condition d'avoir quelques notions d'anglais bien sûr).
  • De vous proposer une liste d'exemples complets (liste qui peut être agrandie par vos propres exemples si vous vous en sentez l'envie ;-)). Cette liste se trouve au dernier chapitre du wiki. N'hésitez surtout pas à rajouter vos propres exemples en éditant ce paragraphe si vous en avez les droits. Sinon, vous pouvez toujours poster vos exemples sur ce fil du forum MathemaTeX consacré au package animate. Je suis sûr qu'une âme charitable se fera un plaisir de les mettre sur ce wiki.

Où se trouve ce package ?

Voici un lien donnant accès au contenu du package sur le CTAN. Celui-ci est en fait constitué de deux fichiers (si l'on ne compte pas la documentation et un fichier README) nommés animate.sty et animfp.sty. La documentation, en anglais, est vraiment très bien faite.

Attention, petite restriction sur le lecteur de pdf

Pour lire les animations, il faut utiliser les lecteur de pdf Adobe Reader version 6 ou plus. La version 8 a longtemps posé des problèmes mais il semble que cela ne soit plus le cas désormais. De l'avis d'Alexander Grahn, Adobe Reader version 7 reste néanmoins la version la plus sûr pour lire les animations. Rappelons que tous ces lecteurs de pdf sont téléchargeables gratuitement sur le site d'Adobe.

Si vous voulez éventuellement tester un autre lecteur de pdf pour savoir s'il peut lire les animations du package animate, vous n'avez qu'à directement ouvrir sa documentation ici. Elle contient de belles animations (vers la fin). Vous verrez si vous pouvez les lire. D'ailleurs, si c'est le cas (avec donc un autre lecteur de pdf qu'Adobe Reader version 6 ou plus), merci de le signaler sur ce wiki (en éditant ce paragraphe) ou sur ce fil.

L’installation du package

Si vous souhaitez dans un premier temps faire des essais immédiatement sans vous lancer dans une installation (qui n'est cependant pas difficile du tout comme on va le voir ci-dessous), il vous suffit simplement de mettre les deux fichiers animate.sty et animfp.sty dans le répertoire courant du fichier source .tex que vous voulez compiler. En effet, lorsqu'un package est appelé dans un source (par la commande \usepackage), LaTeX va toujours le chercher, suivant un ordre bien précis, dans une liste prédéfinie de répertoires : d'abord dans le répertoire numéro 1, puis dans le répertoire numéro 2 si le package n'est pas dans le répertoire numéro 1 etc. Or, le répertoire numéro 1 est toujours par défaut le répertoire courant du source qui est compilé, quelle que soit votre distribution LaTeX.

Une vraie installation est cependant préférable car il est pénible de devoir systématiquement copier les deux fichiers animate.sty et animfp.sty dans le répertoire courant du fichier source à compiler. Voyons maintenant comment on installe le package.

Si vous possédez la distribution MikTeX, il vous suffit d'utiliser le programme MikTeX Package Manager qui vous permet d'installer automatiquement le package. Si vous possédez une autre distribution LaTeX, il faut suivre les étapes suivantes :

  1. Téléchargez le fichier animate.tds.zip que vous trouverez ici.
  2. Passez ensuite à l'extraction de l'archive animate.tds.zip directement dans le répertoire racine de l'arborescence TeX de votre distribution. Ce répertoire porte en principe le nom texmf. Pour obtenir l'adresse exacte de ce répertoire, vous pouvez taper en ligne de commande l'instruction suivante :
    kpsewhich -var-value TEXMFLOCAL

    Après extraction, il faut que vous ayez (je ne donne que des adresses relatives par rapport au répertoire racine de l'arborescence TeX - à savoir le répertoire texmf) :

    • un répertoire texmf/tex/latex/animate/ contenant les deux fichiers animate.sty et animfp.sty
    • et un répertoire texmf/doc/latex/animate/ contenant la documentation du package.
  3. Enfin, une fois que vous avez bien les deux répertoires précédents avec leur contenu, mettez à jour la base de données des packages installés en tapant en ligne de commande l'instruction suivante :
    texhash

Le type de compilation

Le type de compilation ne dépend absolument pas du package animate. En effet, le package animate, comme on le verra plus loin, utilise des images dont il forme un enchaînement qui donnera une animation. Par conséquent, le type de compilation est uniquement déterminé :

  • soit par le type d'images que vous incluez dans votre animation, dans le cas où vous construisez l'animation par inclusion d'images ;
  • soit par le type de code que vous utilisez pour faire vos images, dans le cas où vous fabriquez vous-même vos images directement dans le source.

Par exemple si vous créez votre animation en incluant des images au format pdf, il vous faudra compiler le source via pdflatex avec une commande du genre

latex.exe MonFichier.tex

tapée en ligne de commande au niveau du répertoire courant (pensez à enlever le ”.exe” si vous êtes sous Linux).

En revanche, si vous créez votre animation en codant les images directement dans le source avec du code PSTricks, alors il vous faudra compiler le source en passant par du PostScript avec des commandes du genre

latex.exe MonFichier.tex
dvips.exe MonFichier.dvi
ps2pdf14.exe MonFichier.ps

tapée en ligne de commande au niveau du répertoire courant (sans les ”.exe” si vous êtes sous Linux). Méfiez vous si vous utilisez un éditeur pour compiler vos sources en appuyant sur des boutons. Souvent, on ne connaît pas les commandes exactes qui se cachent derrière ces boutons. Par exemple, pour des compilations passant par du PostScript, les éditeurs ont tendance à ajouter l'option ”-P pdf” à la commande dvips. Cette option pose problème avec le package animate. Le cas échéant, il faudra alors paramétrer votre éditeur favori afin de supprimer cette option. Sachez également que, lorsque la compilation passe par du PostScript, il est parfois nécessaire de charger le package graphicx dans le source (via la commande \usepackage{graphicx}). Si c'est le cas et que vous oubliez de charger ce package, n'ayez crainte : vous aurez de toute façon un message d'erreur très explicite vous demandant de le faire.

Dernier exemple : si vous créez votre animation en codant les images directement dans le source avec du code PGF/TikZ, alors vous pourrez choisir n'importe quel type de compilation.

Avertissement sur les sources .tex proposés en exemples

Pour faire des animations, il va falloir, soit fabriquer des images nous-mêmes, soit inclure des images déjà existantes. Comme je souhaitais vous proposer des exemples complets, vous serez amenés dans ce wiki à faire vos propres images avec LaTeX. Les exemples complets utiliseront du code PSTricks pour fabriquer ces images. Ce n'est pas le seul type de code existant pour faire des dessins avec LaTeX. Il existe notamment le code PGF/TikZ apprécié par de nombreux utilisateurs. Je suis désolé pour les fervents défenseurs de PGF/TikZ d'avoir choisi PSTricks, mais la raison de ce choix est simple : je ne connais quasiment pas PGF/TikZ (et je le regrette). Si vous ne connaissez pas du tout PSTricks, sachez que cela n'entravera en rien votre compréhension sur le fonctionnement du package animate. Le but de ce wiki n'est pas d'apprendre à faire du code PSTricks mais bien à utiliser le package animate qui, dans le fond, n'est rien d'autre qu'une simple machine à fabriquer des enchaînements d'images, peu importe la manière dont on les a fabriquées. Les explications de ce wiki sont donc totalement indépendantes du code utilisé pour fabriquer les images.

Sachez également que, mis à part les exemples complets donnés en toute fin de wiki, tous les exemples sont surtout des exemples à but pédagogique, donc assez basiques. Ce qui veux dire que même si vous ne connaissez rien à PSTricks, avec les commentaires mis dans les sources et éventuellement avec une visualisation du document pdf, vous pourrez toujours comprendre la totalité des commandes PSTricks utilisées. Je le répète, les exemples donnés seront vraiment très basiques : on trace un cercle, une petite courbe et c'est à peu près tout.

Les sources fonctionnent avec les versions du package animate datant du 15/07/08 ou au delà. Vérifiez bien que la version que vous avez installée est postérieure à cette date, sans quoi la compilation de certains exemples risque de donner des erreurs. Vous pourrez par exemple ouvrir le fichier animate.sty qui doit être installé quelque part sur votre ordinateur. Dans les premières lignes de ce fichier vous pourrez voir la date (au format Année/Mois/Jour) correspondant à votre version.

Initiation sur quelques exemples basiques

Introduction

Le package animate permet de faire des petites animations (de dessins mathématiques essentiellement) lisibles directement dans un document pdf, document qui peut également contenir du texte, comme d'habitude. Ce package permet donc de faire un document pdf classique, sauf que les dessins peuvent être animés (on les actionne par un simple clic dessus). Il est clair que faire une figure animée dans un document qui finira de toute façon à la photocopieuse papier n’est pas très utile. Ce package sera donc surtout utile pour faire une présentation rétroprojetée. Présentation que l'on peut faire avec LaTeX en utilisant par exemple la classe beamer.

Pour faire des dessins animés, l'idée générale est assez simple. Des images étant créées d'une manière ou d'une autre, le package animate va fabriquer lors de la compilation du source MonAnimation.tex un enchaînement de ces images (enchaînement qui pourra être paramétré), ce qui formera une animation dans le document MonAnimation.pdf.

On pourra fabriquer les animations de deux manières différentes :

  • Soit l'animation est fabriquée en incluant des fichiers-images déjà existants. Ce sont par exemples des fichiers-images au format pdf (bien d'autres formats sont acceptés) se trouvant dans le même répertoire que le source (ou dans un sous répertoire). Peu importe comment ces images ont été fabriquées, que ce soit par un logiciel externe, par LaTeX lui-même etc. Dans ce cas, on utilisera la commande \animategraphics, qui n'est pas sans rappeler la commande \includegraphics du package graphicx. L'idée est vraiment la même, on inclue des images pour former l'animation.
  • Soit l'animation et les images sont conçues en même temps dans le source lui-même, grâce par exemple à du code PSTricks ou bien à du code PGF/TikZ (peu importe du point de vue du package animate, il faudra seulement choisir la compilation adéquate). Dans ce cas, on utilisera l'environnement animateinline qui contiendra le code (PSTricks ou PGF/TikZ) produisant les images qui formeront l'animation.

Exemple avec la commande \animategraphics

Si on utilise la commande \animategraphics, c'est que l'on souhaite former une animation avec des images déjà créées. Ce cas là est vraiment le plus simple car, d'une certaine manière, on a fait le plus dur : on a déjà créé les images de notre future animation. Nous allons donc supposer que l'on dispose de 74 images au format pdf nommées ainsi : image_01.pdf, image_02.pdf, …, image_74.pdf. J'ai choisis le format pdf à titre d'exemple, mais sachez que de très nombreux formats sont acceptés : citons entre autres mps, png, jpg, jpeg, eps, ps (voir la documentation du package pour avoir la liste complète des formats acceptés). Afin de tester vous-même l'exemple qui va suivre, téléchargez donc cette archive puis désarchivez là. Vous obtiendrez un répertoire nommé images contenant les 74 images pdf. Plus loin, nous verrons la procédure (plus simple qu'il n'y paraît) permettant de créer ces images. Dans un même répertoire, copiez le répertoire images et éditez le source .tex suivant :

\documentclass[12pt]{article}
\usepackage[latin1]{inputenc}
\usepackage[T1]{fontenc}
\usepackage{lmodern}
\usepackage[a4paper]{geometry}
\usepackage{animate} 
\usepackage[frenchb]{babel}


\begin{document}

Animation 1 :

\begin{center}
\animategraphics{5}{images/image_}{01}{74}
\end{center}

Animation 2 :

\begin{center}
\animategraphics[controls]{10}{images/image_}{01}{74}
\end{center}

Animation 3 :

\begin{center}
\animategraphics[loop]{15}{images/image_}{01}{74}
\end{center}

\end{document}

Je vais vous donner les explications de ce source bien sûr mais avant passons à l'action. Je vous rappelle que, dans un même répertoire, doivent se trouver le source et le répertoire images (avec son contenu) que vous venez de télécharger. Ensuite, vous pouvez compiler le source via pdflatex (car nous incluons des images au format pdf) et visualiser le document pdf résultant. Vous pouvez activer les animations en cliquant dessus. Ces trois animations consistent simplement en l'enchaînement des images image_01.pdf, image_02.pdf, …, image_74.pdf dans cette ordre là.

La syntaxe de la commande \animategraphics est très simple. Là voici :

\animategraphics[<options>]{<images par seconde>}{<nom de base>}{<num1>}{<num2>}
  • <options> (facultatif) est une suite d'options séparées par des virgules. Avec le source précédent, vous venez d'en découvrir deux : controls et loop. L'option controls est une option booléenne, c'est-à-dire que vous auriez très bien pu mettre controls=true au lieu de controls tout seul. Cette option crée toute une série de boutons (lecture, pause, lecture arrière etc.) permettant de contrôler agréablement l’animation. L'option loop permet de faire répéter l'animation indéfiniment. Ces options peuvent être passées en options globales dans le préambule en tapant par exemple :
    \usepackage[controls]{animate}

    Dans ce cas, toutes les animations auront automatiquement par défaut des boutons de contrôles même si l'option controls n'est pas spécifiée en local, c'est-à-dire au moment de la commande \animategraphics. Sachez que si une option est spécifiée en global et en local, c'est toujours le local qui l'emporte. Par exemple si vous avez

    \usepackage[controls]{animate}

    dans votre préambule alors que vous avez

    \animategraphics[controls=false]{15}{images/image_}{01}{74}

    dans le corps de texte, alors l'animation en question n'aura pas de boutons de contrôle. Cette caractéristique nous sera utile pour l'option draft que l'on verra plus loin. Nous découvrirons d'autres options au fur et à mesure de ce wiki.

  • <images par seconde> est un nombre entier qui indique le nombre d'images par seconde dans l'animation.
  • <nom de base> est le nom relatif (par rapport au source) commun à nos fichiers-images. Dans notre exemple, les noms relatifs des fichiers-images sont images/image_01.pdf, images/image_02.pdf, …, images/image_74.pdf. Donc le nom relatif commun est image/image_. Au passage, il n'est pas obligatoire que la numérotation possède des chiffres zéros à gauche. Une numérotation du type 1, 2, 3, …, 74 est autorisée. Par contre, si la numérotation possède des chiffres zéros à gauche, tous les numéros doivent avoir le même nombre de chiffres. Autrement dit, la numérotation 01, 02, 03 est correcte mais 01, 02, 003 ne l'est pas et 01, 02, 03, …, 135, 136 non plus. Enfin, signalons qu'il n'est pas obligatoire de commencer la numérotation par le numéro un, n'importe quel entier positif ou nul convient.
  • <num1> et <num2> représente respectivement le plus petit et le plus grand numéro des images qui seront incluses dans l'animation. Dans notre exemple, <num1>=01 et <num2>=74 ce qui signifie que l'animation sera constituée de toutes les images allant du numéro un jusqu'au numéro soixante-quatorze. Les numéros <num1> et <num2> doivent correspondre exactement à des numéros des fichiers-images ; si l'on avait posé <num1>=1 au lieu de <num1>=01 dans notre exemple, la compilation aurait donné une erreur. Par défaut, l'animation enchaîne les images dans le même ordre que la numérotation. On verra plus loin, avec l'option timeline, qu'il est possible non seulement de modifier cet ordre mais aussi de superposer les images comme des transparents.

Autre exemple avec \animategraphics, le fichier-image est un seul pdf de plusieurs pages

Vous vous demandez peut-être dans quelles situations peut-on se retrouver avec une série de fichiers-images numérotés comme dans l'exemple précédent. Sachez que cela peut surtout se produire quand on utilise un logiciel externe de dessin capable d'exporter des images. Si vous utilisez LaTeX pour faire vos images, vous avez sans doute rarement l'occasion d'obtenir une longue série de fichiers-images numérotés. En revanche, il est assez simple d'avoir un seul fichier-image du type document pdf de plusieurs pages où une page du document pdf représente une image de l'animation (on verra comment obtenir un tel fichier-image dans le paragraphe suivant). La bonne nouvelle, c'est que le package animate permet de prendre en charge ce type de fichier-image, toujours avec la commande \animategraphics. Supposons que vous ayez, dans un même répertoire, un source .tex et un document pdf nommé toutes_les_images.pdf constitué de plusieurs pages. Alors, la ligne

\animategraphics{15}{toutes_les_images}{}{}

dans votre source produira une animation qui sera l'enchaînement des images formées par les pages du document toutes_les_images.pdf. Remarquez que l'on utilise bien la même commande \animategraphics mais avec une syntaxe légèrement différente de précédemment : les deux derniers arguments de la macro \animategraphics doivent être vides. Remarquez également qu'il ne faut pas mettre l'extension pdf dans le nom du fichier-image.

Voyons un exemple. Téléchargez ce fichier toutes_les_images.pdf qui n'est autre que la concaténation en unique document pdf des fichiers-images de l'exemple précédent. Dans un même répertoire, placer le fichier toutes_les_images.pdf et le source suivant :

\documentclass[12pt]{article}
\usepackage[latin1]{inputenc}
\usepackage[T1]{fontenc}
\usepackage{lmodern}
\usepackage[a4paper]{geometry}
\usepackage{animate} 
\usepackage[frenchb]{babel}


\begin{document}

Du texte...

\begin{center}
\animategraphics[palindrome]{15}{toutes_les_images}{}{}
\end{center}

\end{document}

À nouveau, vous compilez le source via pdflatex. Au passage, vous pouvez voir l'effet de l'option palindrome qui répète l'animation en boucle dans le sens «avant» puis dans le sens «arrière» et ainsi de suite…

Comment fabriquer les fichiers-images des deux exemples précédents ?

J'ai utilisé LaTeX pour créer ces fichiers-images. Comme je vous l'ai déjà dit, quand on fabrique ses propres images avec LaTeX, il est assez facile de fabriquer ses propres fichiers-images sous la forme d'un seul fichier-image du type document pdf où «une page = une image de l'animation». Avec LaTeX, j'ai donc créé d'abord le document toutes_les_images.pdf. La façon de faire ce genre de pdf n'est pas sans intérêt pour faire des animations avec le package animate puisque a) c'est assez facile à faire avec LaTeX b) le package animate est capable de prendre en charge ce type de fichier-image tel quel. Le source toutes_les_images.tex fait appel à du code PSTricks, il faut donc le compiler en passant par du PostScript via latex⇒dvips⇒ps2pdf14. Le voici, abondamment commenté pour que vous puissiez le comprendre aisément même sans rien y connaître à PSTricks :

\documentclass{article}
\usepackage[latin1]{inputenc}
\usepackage[T1]{fontenc}
\usepackage{lmodern}
\usepackage{pstricks-add}
\usepackage[frenchb]{babel}

% Pour avoir des en-têtes et pieds de page vides.
\pagestyle{empty} 

% Pour avoir une largeur de page de 4cm, comme le dessin (voir ci-dessous).
\usepackage[paperwidth=4cm,margin=0cm,dvips]{geometry}

% Pour avoir une hauteur de page adaptée au dessin
% À chaque environnement pspicture, une nouvelle page
% est créée dont la hauteur coïncidera avec celle du dessin.
\usepackage[active,tightpage]{preview}
\PreviewEnvironment{pspicture}

\begin{document}


% Avec l'environnement pspicture, on crée un rectangle de dessin
% dont le coin inférieur gauche a pour coordonnées (0,0) et le coin
% supérieur droit a pour coordonnées (4,4)
\begin{pspicture}(0,0)(4,4)
% On crée un cadre noir pour matérialiser le rectangle de dessin avec \psframe
% sans quoi le rectangle de dessin existera bel et bien, mais sera invisible.
\psframe(0,0)(4,4)
% Aucun dessin dans le premier rectangle. C'est un rectangle blanc.
\end{pspicture}


% On répète les mêmes dessins avec, en plus, un arc de cercle qui grossit.
\multido{\i=5+5}{73}% \i prendra les valeur 5, 10, 15, ..., 365
{%
  \begin{pspicture}(0,0)(4,4)
  \psframe(0,0)(4,4)
  % On crée un arc de cercle de centre (2,2) de rayon 1.5 allant de 0 à \i degrés
  \psarc{->}(2,2){1.5}{0}{\i}
  \end{pspicture}%
}


\end{document}

Répétons le une dernière fois, le code pour faire le dessin importe peu ; c'est du code PSTricks ici, mais ça pourrait très bien être du code PGF/TikZ. L'intérêt de cet exemple et des exemples suivants est d'apprendre à utiliser le package animate, et dans ce cas particulier de montrer comment on peut faire avec LaTeX un document pdf du type «une page = une image».

Une fois le fichier-image toutes_les_images.pdf créé, j'ai utilisé un petit logiciel libre appelé pdftk pour avoir les fichiers image_01.pdf, image_02.pdf, image_03.pdf, …, image_74.pdf. Sous Linux, voici la ligne de commande à taper lorsqu'on est dans le même répertoire que le fichier toutes_les_images.pdf :

pdftk toutes_les_images.pdf burst output image_%02d.pdf 

Quel intérêt pour moi de «découper» le document toutes_les_images.pdf en plusieurs ? Aucun : si on m'avait demandé de faire l'animation vue en exemple, je me serais contenté du fichier-image toutes_les_images.pdf et c'est tout. Le but était simplement de vous fournir un exemple avec une série de fichiers-images numérotés. Tout le monde n'utilise pas forcément LaTeX pour faire ses images. Beaucoup utilise un logiciel externe et dans ce cas il est fréquent de se retrouver avec une série de fichiers-images numérotés.

En revanche, si jamais vous vous retrouvez avec la série de fichiers-images numérotés image_01.pdf, image_02.pdf, image_03.pdf, …, image_74.pdf, il n'est pas sans intérêt de savoir concaténer ces documents en un seul document (on peut imaginer par exemple que vous ne voulez pas encombrer vos répertoires avec des nombreux fichiers). Là encore, le programme pdftk permet la concaténation très simplement. Sous Linux, voici la ligne de commande à taper lorsqu'on est dans le même répertoire que la série des fichiers-images :

pdftk image_*.pdf cat output toutes_les_images.pdf

Vous vous retrouverez alors avec le document toutes_les_images.pdf de 74 pages regroupant à lui seul tous les fichiers image_01.pdf, image_02.pdf, image_03.pdf, …, image_74.pdf.

Exemple avec l'environnement animateinline

Mais si l'on fabrique ses images avec LaTeX, pourquoi ne pas réunir le code donnant les images et le code donnant l'animation dans un seul source ? C'est exactement ce que permet l'environnement animateinline du package animate. Comme on l'a déjà dit, avec cet environnement l'animation et les images sont conçues en même temps, dans un même et unique source. La syntaxe de cet environnement est la suivante :

\begin{animateinline}[<options>]{<images par seconde>}
   frame0 % image 0 de l'animation
\newframe
   frame1 % image 1 de l'animation
\newframe
   frame2 % image 2 de l'animation
etc ...
\end{animateinline}

où frame0, frame1, frame2, etc. représente du code (par exemples PGF/TikZ ou PSTricks) faisant chacun un dessin complet. L'animation sera alors un enchaînement des images fabriquées par les codes frame0, frame1, frame2… Par défaut, l'enchaînement des images se fera exactement dans l'ordre frame0, frame1, frame2… Comme déjà signalé, on verra plus loin avec l'option timeline qu'on pourra modifier cet ordre et même superposer les images comme des transparents. Dans toute la suite, ce que l'on appelle frame est simplement le code qu'il y a entre les séquences \newframe, c'est-à-dire le code frame0, le code frame1, le code frame2… Toutes les frames sont donc systématiquement séparées par la commande \newframe.

Pour être complet sur la syntaxe, signalons que la commande \newframe, dont la raison d'être est avant tout de délimiter le code produisant les images (les frames), admet une version étoilée ainsi qu'un paramètre optionnel. Donnons des exemples en guise d'explication :

...
   frame14
\newframe*
   frame15
...

entraînera une pause automatique de l'animation au niveau de la frame15. L'animation pourra reprendre si l'on clique dessus ou si l'on clique sur le bouton lecture (si toutefois les boutons de contrôles existent).

...
   frame14
\newframe[20]
   frame15
...

entraînera un changement de rythme qui passera à partir de la frame15 à 20 images par seconde, quelle que soit la vitesse précisée au niveau de l'environnement animateinline. Je vous laisse deviner ce que pourrait faire la commande \newframe*[20]…

Il est clair que pour avoir une animation fluide, il faudra une vitesse de défilement des images assez élevée, mais il faudra aussi un grand nombre d'images générées (parfois plus d'une centaine). Rassurez vous, on ne fera pas les images une par une. On va utiliser la commande \multiframe (voir plus loin) pour générer les frames à l'aide d'une boucle.

Pour l'instant, voici notre premier exemple élémentaire avec l'environnement animateinline. Compilez donc ce source (encore une fois abondamment commenté) en passant par du PostScript via latex⇒dvips⇒ps2pdf14, puis ouvrez le document pdf :

\documentclass{article}
\usepackage[latin1]{inputenc}
\usepackage[T1]{fontenc}
\usepackage{lmodern}
\usepackage[dvips,a4paper]{geometry}
\usepackage{pstricks-add}
\usepackage{animate}
\usepackage[frenchb]{babel}


% L'option algebraic permet d'indiquer l'expression d'une
% fonction à tracer avec \psplot sous la forme algébrique
% classique (x^2 pour la fonction carré).
% On règle 2cm pour l'unité graphique.
\psset{algebraic,unit=2cm}


% Dessin récurrent dans l'animation
% Cette commande trace la courbe de la fonction carré
% sur l'intervalle [-2 ; #1] avec #1 qui augmentera
% au fur et à mesure de l'animation.
\newcommand{\dessin}[1]%
{%
  % Avec l'environnement pspicture, on crée un rectangle de dessin
  % dont le coin inférieur gauche a pour coordonnées (-2,-1) et le coin
  % supérieur droit a pour coordonnées (2,4)
  \begin{pspicture}(-2,-1)(2,4)
  % On crée un cadre noir pour matérialiser le rectangle de dessin avec \psframe
  % sans quoi le rectangle de dessin existera bel et bien, mais sera invisible.
  \psframe[linewidth=3pt](-2,-1)(2,4) % l'épaisseur du trait est de 3pt
  % On crée les deux axes du repère avec \psline
  \psline[arrowscale=2]{->}(-2,0)(2,0)
  \psline[arrowscale=2]{->}(0,-1)(0,4)
  % \psplot trace la fonction carré sur l'intervalle [-2;#1]
  \psplot{-2}{#1}{x^2}
  \end{pspicture}% fin de l'environnement pspicture
}

\begin{document}

Oh ... La jolie animation !

\begin{center}
% L'option buttonsize permet de régler la taille des boutons de contrôle.
\begin{animateinline}[controls,buttonsize=1cm]{2}
  \dessin{-2}
\newframe
  \dessin{-1.5}
\newframe
  \dessin{-1}
\newframe
  \dessin{-0.5}
\newframe[10] % Changement de vitesse de défilement des images
  \dessin{0}
\newframe
  \dessin{0.5}
\newframe
  \dessin{1}
\newframe
  \dessin{1.5}
\newframe
  \dessin{2}
\newframe* % \newframe* entraîne une pause automatique
  %
  % La dernière frame est équivalente à \dessin{2}, sauf qu'on rajoute
  % une petite légende.
  \begin{pspicture}(-2,-1)(2,4)
  \psframe[linewidth=3pt](-2,-1)(2,4)
  \psline[arrowscale=2]{->}(-2,0)(2,0)
  \psline[arrowscale=2]{->}(0,-1)(0,4)
  \psplot{-2}{2}{x^2}
  % On pose la légende $f(x)=x^2$ au niveau des coordonnées (1,2)
  \uput[l](1,2){$f(x)=x^2$}
  \end{pspicture}
  %
\end{animateinline}
\end{center}

\end{document}

Dans le document pdf créé par la compilation, cliquez alors sur lecture. Vous voyez la courbe de la fonction carré se dessiner lentement au début : on a 2 images par seconde. Puis l'animation s'accélère grâce à la commande \newframe[10] qui impose alors un nouveau rythme de 10 images par seconde. Puis, il y a une pause automatique grâce à la commande \newframe*. Si l’on reclique sur lecture, l'animation reprend pour faire seulement apparaître une dernière image (celle formée par la dernière frame du source) qui n'est autre que la courbe de fonction carré avec une petite légende en plus. Comme vous pouvez le constater, cette animation n'est franchement pas très fluide. Mais nous résoudrons ce problème un peu plus loin.

Alléger le code avec l'environnement animateinline

Les options begin et end pour alléger le code source

Dans l'exemple du paragraphe précédent, les frames commencent toujours par le même code et finissent toujours par le même code. En effet, toutes les frames sont de la forme :

\begin{pspicture}(-2,-1)(2,4)
\psframe[linewidth=3pt](-2,-1)(2,4)
\psline[arrowscale=2]{->}(-2,0)(2,0)
\psline[arrowscale=2]{->}(0,-1)(0,4)
[...]
\end{pspicture}

C'est assez fréquent avec une animation créée avec l'environnement animateinline. En effet, il faut bien ouvrir et fermer à chaque frame notre environnement de dessin (environnement pspicture ici). De plus, il est assez fréquent que dans une animation il y ait des éléments graphiques qui soient immobiles d'un bout à l'autre (comme un repère par exemple). C’est pourquoi l’environnement animateinline possède deux options begin et end qui permettent de stocker une bonne fois pour toute le début du code de nos frames et la fin du code de nos frames. Si l’on reprend l’exemple précédent en utilisant ces options cela donne ceci :

\documentclass{article}
\usepackage[latin1]{inputenc}
\usepackage[T1]{fontenc}
\usepackage{lmodern}
\usepackage[dvips,a4paper]{geometry}
\usepackage{pstricks-add}
\usepackage{animate}
\usepackage[frenchb]{babel}

% L'option algebraic permet d'indiquer l'expression d'une
% fonction à tracer avec \psplot sous la forme algébrique
% classique (x^2 pour la fonction carré).
% On règle 2cm pour l'unité graphique.
\psset{algebraic,unit=2cm}

% Dessin récurrent dans l'animation
% Cette commande trace la courbe de la fonction carré
% sur l'intervalle [-2 ; #1] avec #1 qui augmentera
% au fur et à mesure de l'animation.
\newcommand*{\dessin}[1]%
{%
  % \psplot trace la fonction carré sur l'intervalle [-2;#1]
  \psplot{-2}{#1}{x^2}%
}

\newcommand{\Debut}% Début systématique du dessin
{% 
  % Avec l'environnement pspicture, on crée un rectangle de dessin
  % dont le coin inférieur gauche a pour coordonnées (-2,-1) et le coin
  % supérieur droit a pour coordonnées (2,4)
  \begin{pspicture}(-2,-1)(2,4)
  % On crée un cadre noir pour matérialiser le rectangle de dessin avec \psframe
  % sans quoi le rectangle de dessin existera bel et bien, mais sera invisible.
  \psframe[linewidth=3pt](-2,-1)(2,4) % l'épaisseur du trait est de 3pt
  % On crée les deux axes du repère avec \psline
  \psline[arrowscale=2]{->}(-2,0)(2,0)
  \psline[arrowscale=2]{->}(0,-1)(0,4)%
}
   
\newcommand{\Fin}% Fin systématique du dessin
{%
  \end{pspicture}% fin de l'environnement pspicture
}

\begin{document}

Oh ... La jolie animation !

\begin{center}
\begin{animateinline}[controls,buttonsize=1cm,begin={\Debut},end={\Fin}]{2}
  \dessin{-2}
\newframe
  \dessin{-1.5}
\newframe
  \dessin{-1}
\newframe
  \dessin{-0.5}
\newframe[10] % Changement de vitesse de défilement des images
  \dessin{0}
\newframe
  \dessin{0.5}
\newframe
  \dessin{1}
\newframe
  \dessin{1.5}
\newframe
  \dessin{2}
\newframe* % \newframe* entraîne une pause automatique
  %
  % La dernière frame est équivalente à \dessin{2}, sauf qu'on rajoute
  % une petite légende.
  \dessin{2}
  % On pose la légende $f(x)=x^2$ au niveau des coordonnées (1,2)
  \uput[l](1,2){$f(x)=x^2$}
  %
\end{animateinline}
\end{center}

\end{document}

L'allègement du code n'est pas exceptionnel, mais le gain est tout de même assez visible dans la dernière frame de l'animation (faites la comparaison avec l'exemple précédent où il n'y avait pas les options begin et end). De plus, dans cet exemple, les parcelles de codes systématiques ne sont pas énormes, mais on peut imaginer une animation où ces parcelles sont bien plus importantes ; imaginez une animation où dans chaque frame on ait toujours le même repère, avec un même quadrillage, un même cercle toujours présents et immobiles tout au long de l'animation etc. Tout le code nécessaire pour tracer ces éléments trouverait naturellement sa place dans les options begin et end. Du moins pour l'instant…

En effet, à ce stade du wiki, il est tout à fait logique de procéder de la sorte. Cependant, quand nous verrons plus loin l'option timeline, nous verrons qu'il n'est en fait pas très pertinent de répéter du code dans plusieurs frames, ce que font ni plus ni moins les options begin et end (mais de manière cachée et commode). En fait, dans les options begin et end, sachez d'emblée qu'il faudra se contenter d'y mettre respectivement le code ouvrant l'environnement graphique et le code fermant l'environnement graphique et c'est tout ! Ces parcelles de codes sont absolument incontournables dans chaque frame, c'est une évidence. En revanche, il faudra autant que possible (ce n'est pas non plus une obligation) éviter de répéter du code identique (le code donnant un repère par exemple) dans toutes les frames de l'animation. Mais alors, vous pouvez légitimement vous poser la question suivante : «Éviter de répéter dans chaque frame le code donnant mon repère ? Mais comment est-ce possible si mon repère apparaît d'un bout à l'autre de mon animation de manière immobile sans discontinuer ? Je suis bien obligé de mettre le code de mon repère dans toutes les frames ?». Patience… Vous aurez la réponse quand on abordera l'option timeline. Nous verrons cela en temps utiles.

L'avantage des options begin et end réside donc surtout (et uniquement) dans le fait que l'environnement de dessin (l'environnement pspicture ici) n'est pas fermé entre les commandes \newframe. En effet, dans l’exemple ci-dessus, la commande \dessin{2} ne ferme pas l’environnement pspicture contrairement à précédemment (sans les options begin et end). Donc dans la dernière frame, on a pu rajouter une ou plusieurs lignes de code (PSTricks), chose qui était impossible dans le premier exemple car l'environnement pspicture était fermé par la commande \dessin{2}.

Donc, non seulement ces options permettent d'alléger un peu le code (bon d'accord, c'est pas exceptionnel mais je pense que je vais grandement me rattraper avec la suite sur ce point là), mais en plus et surtout elles rendent beaucoup plus simple l'ajout de code supplémentaire à l'intérieur des frames (pour ajouter par exemple des légendes).

Générer un grand nombre de frames avec la commande \multiframe

Évidemment, on ne va pas s’amuser à taper les frames une à une comme on l'a fait jusqu'à présent ; surtout que pour avoir une animation fluide, il faut quand même fabriquer un certain nombre de frames (plus d'une cinquantaine par exemple). Il nous faudrait donc une commande permettant générer un grand nombre de frames à la suite, frames dépendant de paramètres incrémentés au fur et à mesure. C'est exactement ce que fait la commande \multiframe fournie par le package animate.

Avant de donner précisément la syntaxe de cette commande qui est d'ailleurs assez naturelle, donnons d'emblée un exemple imaginaire. Supposons que la macro \dessin admette deux arguments, un nombre réel pour le premier argument et une dimension pour le deuxième argument, et supposons que cette macro donne après développement du code produisant une image. Alors les deux codes suivant sont totalement équivalents :

\begin{animateinline}{10}
  % Ci-dessous, 5 c'est le nombre de frames générées
  \multiframe{5}{reel=2+-0.5,dim=0pt+0.1pt}
  {%
    \dessin{\reel}{\dim}%
  }
\end{animateinline}
\begin{animateinline}{10}
  \dessin{2}{0pt}
\newframe
  \dessin{1.5}{0.1pt}
\newframe
  \dessin{1}{0.2pt}
\newframe
  \dessin{0.5}{0.3pt}
\newframe
  \dessin{0}{0.4pt}
\end{animateinline}

Le gain de productivité ne saute pas aux yeux avec cet exemple de 5 frames, mais imaginez qu'il faille générer 100 frames au lieu de 5 !

Regardons précisément la syntaxe de la commande \multiframe. Elle doit toujours s'insérer dans l'environnement animateinline sous la forme suivante :

\multiframe{<nombre de frames>}{<variables>}{<DESSIN>}

avec :

  1. <nombre de frames> ::= un entier strictement positif qui représente le nombre de frames générées.
  2. <variables> ::= une liste de <variable> séparés par des virgules. <variables> peut aussi être vide. Dans ce cas, il n'y a pas de variables incrémentées du tout, il y aura juste une répétition du même code <DESSIN> dans toutes les frames générées.
    • <variable> ::= <nom de variable>=<valeur initiale>+<incrément>
    • <nom de variable> ::= une chaîne constituée des caractères a, …, z et A, …, Z uniquement (donc pas de caractère backslash “\” au début). Le premier caractère doit être : a) i ou I si la variable est un entier relatif b) n, N, r ou R si la variable est un nombre réel (enfin un nombre décimal plus exactement) c) d ou D si la variable est une dimension.
    • <valeur initiale> ::= un nombre ou une dimension suivant la nature de la variable, éventuellement négatif (-2.24 ou -3pt etc).
    • <incrément> ::= un nombre ou une dimension suivant la nature de la variable, éventuellement négatif (-2.24 ou -3pt etc).
  3. <DESSIN> ::= n'importe quel code formant une image et qui peut contenir les macros de la forme \<nom de variable> (avec le caractère backslash “\” cette fois) qui auront été spécifiées dans l'argument précédent de la commande \multiframe. Dans l'exemple imaginaire juste au dessus, les <nom de variable> reel et dim ont été spécifiées dans le deuxième argument, donc le troisième argument peut contenir les macros \reel et \dim.

Les nombres sont calculés avec une précision de 18 chiffres après la virgule. Les nombres à plus de 18 chiffres après la virgule seront implicitement tronqués à 18 chiffres après la virgule par la commande \multiframe.

Afin de bien fixer les idées, voici deux exemples de syntaxes valides utilisant \multiframe :

\multiframe{100}{Inum=-1+-2}%
{
  \dessin{\Inum}
  % où \dessin est une macro à un seul argument qui est un entier relatif
}

\multiframe{100}{Dim=10tp+-0.1pt,rx=2.4+0.025}%
{
  \dessin{\Dim}{\rx}
  % où \dessin est une macro à deux arguments (une dimension et un nombre décimal)
}

Maintenant reprenons notre exemple de la courbe de la fonction carré qui se dessine au fur et à mesure. Notre animation n'était pas très fluide ! Voici donc l'équivalent, en plus fluide, avec la commande \multiframe. Toujours à compiler en passant par du PostScript via latex⇒dvips⇒ps2pdf14 :

\documentclass{article}
\usepackage[latin1]{inputenc}
\usepackage[T1]{fontenc}
\usepackage{lmodern}
\usepackage[dvips,a4paper]{geometry}
\usepackage{pstricks-add}
\usepackage{animate}
\usepackage[frenchb]{babel}


% L'option algebraic permet d'indiquer l'expression d'une
% fonction à tracer avec \psplot sous la forme algébrique
% classique (x^2 pour la fonction carré).
% On règle 2cm pour l'unité graphique.
\psset{algebraic,unit=2cm}

% Dessin récurrent dans l'animation
% Cette commande trace la courbe de la fonction carré
% sur l'intervalle [-2 ; #1] avec #1 qui augmentera
% au fur et à mesure de l'animation.
\newcommand*{\dessin}[1]%
{%
  % \psplot trace la fonction carré sur l'intervalle [-2;#1]
  \psplot{-2}{#1}{x^2}%
}

\newcommand{\Debut}% Début systématique du dessin
{% 
  % Avec l'environnement pspicture, on crée un rectangle de dessin
  % dont le coin inférieur gauche a pour coordonnées (-2,-1) et le coin
  % supérieur droit a pour coordonnées (2,4)
  \begin{pspicture}(-2,-1)(2,4)
  % On crée un cadre noir pour matérialiser le rectangle de dessin avec \psframe
  % sans quoi le rectangle de dessin existera bel et bien, mais sera invisible.
  \psframe[linewidth=3pt](-2,-1)(2,4) % l'épaisseur du trait est de 3pt
  % On crée les deux axes du repère avec \psline
  \psline[arrowscale=2]{->}(-2,0)(2,0)
  \psline[arrowscale=2]{->}(0,-1)(0,4)%
}
   
\newcommand{\Fin}% Fin systématique du dessin
{%
  \end{pspicture}% fin de l'environnement pspicture
}


\begin{document}


\begin{center}
\begin{animateinline}[controls,begin={\Debut},end={\Fin}]{10}
  % \param = -2, -1.9, ..., 1.9, 2, ce qui fera bien 41 valeurs
  \multiframe{41}{rparam=-2+0.1}
  {%
    \dessin{\rparam}%
  }% fin de \multiframe
\newframe* %%% Pause Automatique
  \dessin{2}
  \uput[l](1,2){$f(x)=x^2$}
\end{animateinline}
\end{center}


\end{document}

Non seulement le code est plus court, mais en plus l'animation est quand même plus fluide. Forcément, on a mis plus de frames et le rythme est de 10 images par seconde. De plus, désormais, on peut parfaitement augmenter le nombre de frames pour avoir une animation encore plus fluide sans trop se fatiguer. Il suffit de prendre un incrément plus petit, 0.05 par exemple. Dans ce cas, il faudra bien sûr augmenter le nombre de frames puisqu'il faut toujours que notre variable aille de -2 à +2 mais en faisant des sauts plus petits. En allant de -2 à +2 avec un incrément de 0.05, notre variable va «découper» l'intervalle [-2 ; +2] de longueur 4 en 4/0.05=80 petits intervalles de longueurs 0.05 (l'intervalle [-2 ; -1.95], puis l'intervalle [-1.95 ; -1.9] etc). Ceci nous donne 81 valeurs (et oui 80 petits intervalles donnent 81 valeurs, c'est la fameuse histoire des poteaux et des intervalles) et donc 81 frames à générer (car à une frame correspond une valeur de la variable bien sûr). Tout cette petite cuisine pour dire qu'il vous sera peut-être utile de retenir ceci : si une variable doit aller de la valeur initiale Vi à la valeur finale Vf avec un incrément inc, alors le nombre N de valeurs prises par cette variable (c'est-à-dire le nombre de frames pour nos animations) est donné par la formule N = | (Vf - Vi) / inc | + 1.

Vous pouvez donc remplacer la ligne

% \param = -2, -1.9, ..., 1.9, 2, ce qui fera bien 41 valeurs
\multiframe{41}{rparam=-2+0.1}

de l'exemple précédent par

% \param = -2, -1.95, ..., 1.95, 2, ce qui fera bien 81 valeurs
\multiframe{81}{rparam=-2+0.05}

et recompiler le source (via latex⇒dvips⇒ps2pdf14). Vous verrez que l'animation sera plus fluide. Par contre l'animation sera plus longue puisqu'on a gardé 10 images par seconde : la vitesse de défilement est la même, mais il y a plus d'images à faire défiler, environ deux fois plus. Donc si l'on veut sensiblement une même durée globale pour l'animation, il faudra aussi changer le nombre d'images par seconde et mettre 20 au lieu de 10. Faites le, vous verrez que votre animation paraîtra encore plus fluide.

Bref, on peut jouer avec le nombre total de frames, l'incrément et le rythme d'images par seconde pour avoir une animation plus ou moins fluide. Mais évidemment, il n'y a pas de miracle : plus vous voudrez avoir une animation fluide, plus vous devrez générer un grand nombre de frames dans le source, et plus la compilation sera longue et nécessitera des ressources mémoire à LaTeX. D'où le paragraphe suivant.

Mémoire et compilations

Attention au problème de mémoire

Avec l'utilisation du package animate, non seulement vous pourrez avoir des compilations assez longues, mais en plus vous pourrez parfois rencontrer le message d'erreur

TeX capacity exceeded

alors que votre code est parfaitement valide. On a tendance à dire lorsqu’on a ce message d'erreur que c'est forcément une véritable erreur dans le code (une accolade qui n'est pas fermée etc). C'est très souvent vrai, voire même tout le temps sauf avec le package animate où on peut parfaitement avoir ce message d'erreur avec un code pourtant parfaitement correct. En effet, avec ce package, on peut être amené à faire compiler beaucoup d’informations à LaTeX et parfois plus d'informations qu'il ne peut gérer par défaut. Vous pouvez vous amuser à reprendre l'exemple précédent, en augmentant la fluidité de l'animation. Vous augmentez le nombre de frames et vous diminuez en conséquence la valeur de l'incrément. Avec environ 500 frames par exemple, il est très probable que obteniez le message d'erreur ci-dessus, autrement dit que vous dépassiez les capacités mémoire de LaTeX. Et pourtant le code est juste ! Si cela vous arrive dans une situation normale (où vous ne cherchez pas délibérément et sournoisement à faire craquer LaTeX), sachez qu'il y a une solution. Déjà, il faudra vous poser des questions sur votre code afin de voir s'il n'y a pas moyen de le rendre moins gourmand en mémoire (c'est souvent possible). Sinon, il faut alors allouer plus de mémoire à LaTeX qu'il n'en a par défaut. Comment faire ? Cela dépend de votre distribution LaTeX.

Avant d'expliquer les démarches à suivre pour allouer plus de mémoire à LaTeX, voici deux remarques :

  • Évitez de mettre plusieurs (grosses) animations sur une même page car vous augmenterez le risque d'avoir un problème de mémoire. En effet, la mémoire dont dispose LaTeX est limitée, ce qui est normal, mais surtout cette limite est une limite par page et non une limite pour l'ensemble du document (LaTeX travaille réellement page après page). Il se peut parfaitement qu'en mettant deux (grosses) animations sur une même page vous ayez un problème de mémoire et que vous n'en ayez aucun en répartissant ces deux mêmes animations sur deux pages différentes.
  • Plus loin dans ce wiki, on verra que l'option timeline est également un très bon moyen pour rendre la compilation moins coûteuse en mémoire (même si ce n'est pas l'objectif initial de cette option).

En fonction de votre distribution, vous pourrez donc appliquer une des procédures ci-dessous. Évidemment, le nombre 10000000, qui représente dans ce qui suit la quantité de mémoire allouée à LaTeX, pourra être remplacé par un nombre encore plus grand si cela ne suffit pas. En principe, tous les exemples proposés sur ce wiki marchent parfaitement sans allouer plus de mémoire à LaTeX. Mais on ne sait jamais …

Procédure avec MikTeX version < 2.7

Il suffit donc de remplacer dans votre compilation la commande :

latex.exe MonFichier.tex

par celle-ci :

latex.exe -mem-max=10000000 MonFichier.tex

Vous remplacez latex.exe par pdflatex.exe si c'est lui que vous utilisez pour la compilation bien sûr.

Procédure avec MikTeX version 2.7

Vous ouvrez un terminal de ligne de commande DOS et vous lancez l'instruction suivante :

initexmf --edit-config-file=latex

Un éditeur de texte ouvre un fichier de configuration latex dans lequel vous tapez la ligne suivante :

main_memory=10000000

Vous enregistrez puis vous fermez l'éditeur. Ensuite, vous lancez l'instruction

initexmf --dump=latex

qui va compiler le format LaTeX. Vous répétez les mêmes instructions en remplaçant latex par pdflatex et aussi par xelatex.

Procédure avec TeXLive

Déterminez l'adresse du fichier de configuration texmf.cnf avec la commande

kpsewhich texmf.cnf

tapée dans un terminal. Une fois que vous avez donc localisé ce fichier, ouvrez le sous root avec n'importe quel éditeur de texte. Cherchez dans ce fichier la chaîne de caractères “main_memory =” Remplacez le nombre juste après cette chaîne de caractères par un nombre plus grand, 10000000 par exemple.

Puis enfin recompilez les formats avec les instructions suivantes (exécutées sous root) :

fmtutil-sys --byfmt latex
fmtutil-sys --byfmt pdflatex
fmtutil-sys --byfmt xelatex

Mettre de côté une (des) animation(s) avec les options draft et final

Lorsqu'on crée un document pdf avec LaTeX, il faut compiler souvent afin de surveiller le rendu du document. Or, les compilations peuvent prendre du temps quand il y a une ou plusieurs animations. Temps qui peut s'avérer totalement inutile si ce que vous voulez vérifier ne concerne absolument pas la ou les animations. Pour résoudre ce problème, il y a les options draft et final qui peuvent être activées, soit globalement lors du chargement du package animate via :

\usepackage[draft]{animate}

soit localement via :

\begin{animateinline}[final]{25}
[...]
\end{animateinline}

% Ou bien

\animategraphics[draft]{15}{images/image_}{01}{74}

L'option draft permet de mettre simplement un cadre vide à la place exacte d'une animation (avec bien sûr les mêmes dimensions pour ne pas bouleverser la mise en page). Dans ce cas, la compilation est bien sûr rapide car LaTeX ne fabrique pas l'animation : il ignore le code de l'animation et met un cadre vide à la place. En revanche, l'option final force LaTeX à créer l'animation. C'est l'option par défaut bien sûr. Les options draft et final sont donc antagonistes, mais on peut en tirer profit si on se rappelle qu'en terme d'option une activation locale l'emporte toujours sur une activation globale. Si vous ne voyez pas le rapport, voici maintenant l'explication détaillée.

En effet, quand vous composez un document pdf avec des animations, l'idée est de procéder de la manière suivante. Vous chargez le package animate avec l'option draft de manière globale (via \usepackage[draft]{animate}). Puis vous commencez à composer votre document. Lorsque vous faites une animation (avec la commande \animategraphics ou avec l'environnement animateinline), vous mettez en local l'option final, qui va donc l'emporter sur l'option globale draft, si bien que lors de vos compilations l'animation sera effectivement fabriquée. Tant mieux, il faut bien que vous puissiez vérifier si l'animation fonctionne correctement. Une fois que vous avez terminé votre animation et que vous êtes satisfait du résultat, vous enlevez l'option locale final de la susdite animation. L'option globale draft reprend alors le dessus et l'animation sera «oubliée» par LaTeX lors des prochaines compilations (on aura juste un cadre vide à la place). Tant mieux, vous savez que l'animation fonctionne, vous pouvez donc poursuivre la composition de votre document avec des compilations relativement rapides : votre animation fraîchement terminée n'est pas prise en compte, elle est provisoirement laissée de côté. Pourquoi diable faire travailler LaTeX sur cette animation ? Elle est selon vous achevée et ce n'est plus votre problème. À ce moment là, vous êtes passé à la suite du document. Lorsque vous allez faire de nouvelles animations dans votre document pdf, vous procéderez de même et ainsi de suite… Puis, enfin, votre document est définitivement achevé. Vient alors l'ultime compilation : celle qui doit vous donner le document pdf final avec toutes ses animations. Juste avant cette dernière compilation, il vous suffit d'enlever l'option globale draft que vous aviez mise au départ dans le préambule. Et c'est parti pour l'ultime compilation, qui, elle, sera relativement longue car elle fabriquera toutes vos animations, mais elle sera en principe la dernière compilation.

Que choisir entre \animategraphics et l'environnement animateinline ?

C'est évidemment en fonction de votre goût et en réalité il n'y a pas de réponse à cette question. Je vais me contenter de pointer les avantages et inconvénients des deux méthodes.

  • Avec l'environnement animateinline, ce qui est très agréable (je trouve), c'est que tout est réuni dans un seul et unique source : les images et l'animation formée par ces images. Pour toute modification, il n'y a qu'un fichier à aller voir : le source. En revanche, cette méthode est plus gourmande en ressource mémoire que la méthode \animategraphics puisqu'il faut faire les images et l'animation en même temps lors d'une seule compilation. Par conséquent la compilation peut être assez longue voire trop longue.
  • Avec la commande \animategraphics, les fichiers-images et le source donnant l'animation sont séparés. Cela peut rendre les modifications moins pratiques. En revanche, la compilation du source est en général plus rapide qu'avec l'environnement animateinline puisque les images existent déjà : LaTeX n'a pas à les produire, cela a déjà été fait auparavant.

L'option timeline et les images deviennent des transparents

Introduction

Nous allons nous intéresser maintenant à l'option timeline. Cette option rend (je trouve) le package animate particulièrement attractif car elle lui rajoute une dimension supplémentaire. Pour faire vite, on peut dire qu'avec cette option les images ne sont plus seulement de simples images, mais de véritables transparents que l'on va pouvoir superposer comme on veut. Sachez que cette option est valable aussi bien avec la commande \animategraphics qu'avec l'environnement animateinline.

Pour donner des explications claires, il va falloir s'entendre sur un point de vocabulaire. Nous allons définir le mot «transparents» au sens du package animate. Quand vous créez une animation, que ce soit avec la commande \animategraphics ou avec l'environnement animateinline, le package animate dispose d'images qu'il numérote toujours en partant de zéro. Ces images, nous les appellerons des transparents. Par exemple, supposons que nous disposons de fichiers-images image_1.pdf, image_2.pdf, image_3.pdf,… , image_100.pdf. Supposons que nous les utilisons pour former une animation via la commande :

\animategraphics{20}{image_}{1}{100}

Alors :

  • le transparent 0 sera l'image image_1.pdf
  • le transparent 1 sera l'image image_2.pdf
  • le transparent 2 sera l'image image_3.pdf etc…

Remarquez que, bien que le premier fichier-image porte le numéro 1 (image_1.pdf), le package animate le reconnaîtra en tant que transparent numéro 0. Quoi qu'il arrive, le package animate numérote toujours ses transparents en partant de zéro. De même, si vous créez une animation via le code suivant :

\begin{animateinline}{25}
  frame0	
\newframe
  frame1
\newframe
  frame2
etc...
\end{animateinline}

Alors :

  • le transparent 0 sera l'image formée par le code frame0
  • le transparent 1 sera l'image formée par le code frame1
  • le transparent 2 sera l'image formée par le code frame2 etc…

Mais pourquoi ce nouveau vocabulaire ? Tout simplement parce que désormais avec l'option timeline une image de notre animation ne coïncidera pas forcément avec un transparent (au sens défini précédemment) de l'animation. Je vais être plus clair et plus précis. Jusqu'à présent, c'est-à-dire sans l'option timeline, nos animations étaient l'enchaînement dans cet ordre des images suivantes :

  • Première image de l'animation constituée du transparent 0
  • Deuxième image de l'animation constituée du transparent 1
  • Troisième image de l'animation constituée du transparent 2
  • et ainsi de suite …

Donc, jusqu'à présent, on pouvait dire en gros qu'une image de notre animation était ni plus ni moins un transparent (les deux notions étaient confondues). De plus, l'ordre des images et des transparents coïncidait. Et bien avec l'option timeline, on pourra constituer chaque image de notre animation avec n'importe quelles superpositions des transparents dont dispose le package animate. Par exemple, on pourra créer l'animation suivante :

  • Première image constituée de la superposition de transparent 0, transparent 10, transparent 2
  • Deuxième image constituée de la superposition de transparent 0, transparent 11, transparent 25
  • Troisième image constituée de la superposition de de transparent 0, transparent 1
  • et ainsi de suite …

Nous pourrons former chaque image de notre animation par une superposition absolument quelconque des transparents. Désormais, il faudra donc bien faire la distinction entre :

  • d'un côté les transparents, qui sont le «matériel» dont dispose le package animate pour construire l'animation.
  • de l'autre les images de l'animation, celles que nous voyons avec nos propres yeux ;

Regardez par exemple cette animation qui vous montre successivement une série de transparents apparaissant dans l'ordre habituel (sans l'option timeline donc), c'est-à-dire dans l'ordre transparent 0, puis transparent 1, puis transparent 2 etc. Cette animation ne ressemble à rien sous cette forme. Mais maintenant regardez la même animation, utilisant les mêmes transparents que la première, mais avec l'option timeline qui nous a permis de superposer (d'agencer) les transparents de manière «intelligente» pour donner à l'animation tout son sens.

Mais comment allons nous spécifier au package animate la façon dont nous voulons agencer nos transparents ? Tout simplement à l'aide d'un petit fichier de texte externe qui suivra une syntaxe très simple mais très précise. Concrètement, nous allons utiliser l'option timeline de la manière suivante :

\animategraphics[timeline=agencement.txt]{20}{image_}{1}{100}

ou bien (si l'on utilise l'environnement animateinline) :

\begin{animateinline}[timeline=agencement.txt]{25}
  frame0	
\newframe
  frame1
\newframe
  frame2
etc...
\end{animateinline}

Dans les deux cas, on créera un fichier de texte agencement.txt qui contiendra les informations sur la façon dont nous voulons agencer nos transparents. Ce fichier est toujours un simple fichier de texte, mais il n'est pas obligatoire de lui donner l'extension .txt, on peut même ne lui donner aucune extension. En revanche, utilisez uniquement des caractères «gentils» pour nommer ce fichier : éviter les accents, les espaces…

En fait, ce n'est pas le nom du fichier agencement.txt que l'on précise dans l'option timeline, mais l'adresse relative du fichier par rapport au source à compiler. Si le fichier agencement.txt est à la racine du répertoire courant du source, alors il faut spécifier l'option comme ci-dessus. En revanche, si le fichier agencement.txt est dans le répertoire rep qui se trouve lui-même à la racine du répertoire courant du source, alors il faut spécifier l'option ainsi :

\animategraphics[timeline=rep/agencement.txt]{20}{image_}{1}{100}

% ou bien

\begin{animateinline}[timeline=rep/agencement.txt]{25}
  frame0	
\newframe
  frame1
\newframe
  frame2
etc...
\end{animateinline}

Syntaxe du fichier agencement.txt

Nous allons prendre un exemple de source qui construira l'animation à partir de sept transparents (transparent 0, transparent 1, transparent 2, … et transparent 6). Ces transparents se contenteront simplement d'afficher la légende “Transparent <numéro du transparent>” dans le cadre de dessin. On aura donc :

  • le transparent 0 qui affichera la légende “Transparent 0”
  • le transparent 1 qui affichera la légende “Transparent 1”
  • et ainsi de suite…

Ces transparents ne présentent pas beaucoup d'intérêt sur le plan esthétique bien sûr, c'est un exemple purement pédagogique. Chaque image de l'animation indiquera d'elle-même les transparents qui auront été utilisés pour la former. Par exemple, si vous avez sous vos yeux une image qui affiche les légendes “Transparent 3” et “Transparent 6”, c'est que cette image aura été formée par la superposition des transparents 3 et 6.

Dans un répertoire, copiez le source suivant :

\documentclass{article}
\usepackage[latin1]{inputenc}
\usepackage[T1]{fontenc}
\usepackage{lmodern}
\usepackage[dvips,a4paper]{geometry}
\usepackage{pstricks-add}
\usepackage{animate}
\usepackage[frenchb]{babel}

% On règle 2cm pour l'unité graphique.
\psset{unit=2cm}

\newcommand{\Debut}% Début systématique du dessin
{% 
  % Avec l'environnement pspicture, on crée un rectangle de dessin
  % dont le coin inférieur gauche a pour coordonnées (0,0) et le coin
  % supérieur droit a pour coordonnées (4,4)
  \begin{pspicture}(0,0)(4,4)
  % On crée un cadre noir pour matérialiser le rectangle de dessin avec \psframe
  % sans quoi le rectangle de dessin existera bel et bien, mais sera invisible.
  \psframe[linewidth=3pt](0,0)(4,4)% l'épaisseur du trait est de 3pt
}


\newcommand{\Fin}% Fin systématique du dessin
{%
  \end{pspicture}% fin de l'environnement pspicture
}

\begin{document}


\begin{center}
\begin{animateinline}[controls,begin={\Debut},end={\Fin},timeline=agencement.txt]{4}
  \rput[l](1,0.5){\LARGE Transparent 0}
   % pose l'étiquette «Transparent 0» au point (1,0.5)
\newframe
  \rput[l](1,1){\LARGE Transparent 1}
  % pose l'étiquette «Transparent 1» au point (1,1)
\newframe
  \rput[l](1,1.5){\LARGE Transparent 2}
  % pose l'étiquette «Transparent 2» au point (1,1.5)
\newframe
  \rput[l](1,2){\LARGE Transparent 3}
  % pose l'étiquette «Transparent 3» au point (1,2)
\newframe
  \rput[l](1,2.5){\LARGE Transparent 4}
  % pose l'étiquette «Transparent 4» au point (1,2.5)
\newframe
  \rput[l](1,3){\LARGE Transparent 5}
  % pose l'étiquette «Transparent 5» au point (1,3)
\newframe
  \rput[l](1,3.5){\LARGE Transparent 6}
  % pose l'étiquette «Transparent 6» au point (1,3.5)
\end{animateinline}
\end{center}

\end{document}

Comme vous pouvez le voir dans le source, un certain fichier nommé agencement.txt va contenir les instructions de superpositions des transparents et permettre de former l'animation. Ce fichier dont nous allons étudier la syntaxe le voici. Copiez le dans le même répertoire que le source :

::6
::1,5
::3x2
::1,0,5x2,4x10
::2x0
::5
::6
::5
::6
::5
::6
::5
::6
::5
::6
::5
::6
::5
::6
::5
::6
::5
::6
::5
::6
::5
::6
::5
::6
::5
::6
::5
::6
::5
::6

Vous devez vous demander ce que peut signifier cette infâme bouillie. Vous allez voir que c'est très simple. Pour l'instant, regardez donc l'animation produite par ce source grâce à une compilation via latex⇒dvips⇒ps2pdf14. Sans l'option timeline, vous auriez obtenu une animation qui affiche successivement le transparent 0, puis de le transparent 1, …, puis le transparent 6. Vous pouvez en faire vous-même l'expérience en enlevant l'option timeline du source puis en le recompilant. Grâce à l'option timeline et au fichier agencement.txt, nous ne sommes plus forcément condamnés à cet ordre apparition des transparents ; ordre systématiquement en vigueur par défaut (si on ne fait pas appel à l'option timeline). Nous allons pouvoir bouleverser cet ordre et même superposer les transparents à volonté.

Étudions la syntaxe du fichier agencement.txt. Il y a déjà une chose très simple que vous devez avoir en tête : une image de notre animation pdf correspond à une ligne du fichier agencement.txt. Plus exactement, la première ligne du fichier agencement.txt correspond à la première image de l'animation, la deuxième ligne du fichier agencement.txt correspond à la deuxième image de l'animation etc. Autrement dit, on a ceci :

::6               % cette ligne forme la première image de l'animation
::1,5             % cette ligne forme la deuxième image de l'animation
::3x2             % cette ligne forme la troisième image de l'animation
::1,0,5x2,4x10    % cette ligne forme la quatrième image de l'animation
::2x0             % cette ligne forme la cinquième image de l'animation

etc...

Au passage, vous avez parfaitement le droit de mettre des commentaires (avec le caractère %) dans le fichier agencement.txt comme ci-dessus. Conséquence de cette première caractéristique : l'animation possédera autant d'images qu'il y a de lignes dans le fichier agencement.txt. Donc une animation de 500 images nécessitera un fichier agencement.txt de 500 lignes. Ça peut être long à taper, n'est-ce pas ? Pas de problème, nous avons un outil qui nous permettra de le taper sans se fatiguer : encore et toujours notre bon vieux LaTeX bien sûr ! Et oui, vous verrez que LaTeX permet d'écrire dans des fichiers externes très simplement, et avec la commande \multido, nous pourrons écrire beaucoup de lignes dans le fichier agencement.txt avec peu de code dans le source. Nous verrons cela plus loin dans le wiki.

Une ligne du fichier agencement.txt est égale à une image de l'animation. Donc, il ne reste plus qu'à comprendre la syntaxe d'une seule ligne. La syntaxe d'une ligne est de la forme suivante :

<élément 1> : <élément 2> : <élément 3>

où les deux-points ”:” sont simplement des délimiteurs (ils délimitent les trois éléments). Dans notre fichier agencement.txt, il s'avère qu'à chaque fois <élément 1> et <élément 2> étaient vides. La syntaxe de ces deux premiers éléments est vraiment très simple, nous les décrirons en dernier. Pour l'instant, découvrons la syntaxe de <élément 3> à travers les lignes de notre fichier agencement.txt.

Ligne 1

La première ligne ”::6” signifie que la première image de l'animation sera formée du transparent 6 et c'est tout.

Ligne 2

La deuxième ligne ”::1,5” signifie que la deuxième image de notre animation sera formée de la superposition du transparent 1 et du transparent 5. Le mot transparent n'est pas anodin. Il faut réellement imaginer des transparents de la «vraie vie» que l'on pose les uns au dessus des autres. Ici, retenez que c'est d'abord le transparent 1 qui est posé, puis ensuite le transparent 5 est posé par dessus le 1 avec une petite conséquence assez naturelle : le transparent 5 peut recouvrir éventuellement des éléments graphiques du transparent 1. La ligne ”::1,5” n'est donc pas exactement équivalente à la ligne ”::5,1” car l'ordre de superposition n'est pas le même et les recouvrements éventuels ne se feront pas dans le même sens. Dans notre exemple, il s'avère que ça ne change rien car les éléments des transparents sont tous deux à deux disjoints. Mais c'est un cas particulier qui ne se produit pas toujours, voire rarement. Donc rappelez vous que l'ordre de superposition des transparents compte par rapport à des problèmes éventuels de recouvrements et se fait de la gauche vers la droite.

Ligne 3

La troisième ligne ”::3×2” signifie que la troisième image de notre animation sera formée uniquement du transparent 3. Mais juste après “3”, il y a “x2” qui donne la «durée de vie» du transparent. Donc, pour être exact, la ligne ”::3×2” signifie que la troisième image de notre animation sera formée uniquement du transparent 3, mais que ce transparent aura une durée de vie de 2 images. Cela veut dire que le transparent 3 sera présent dans la troisième image de l'animation et aussi dans la quatrième. En revanche, il ne sera plus présent dans la cinquième image. D'une certaine manière, on peut dire que le transparent 3 laissera une trace persistante pendant une durée de deux images. Cette notion de trace est particulièrement pratique. Si vous avez bien compris la notion de «durée de vie» de transparent, alors vous ne devriez pas être choqué si je vous dis que ”::3×1” est complètement équivalent à ”::3”.

Ligne 4

Normalement la quatrième ligne devrait être une formalité pour vous. La quatrième ligne ”::1,0,5×2,4×10” signifie que la quatrième image de l'animation sera la superposition, dans cet ordre, des transparents suivants :

  1. du transparent 3 à cause de la ligne ”::3×2” précédente qui a laissé une trace
  2. du transparent 1 (posé par dessus pour une durée de vie de 1 image (celle que nous décrivons en ce moment)
  3. du transparent 0 pour une durée de vie de 1 image (celle que nous décrivons en ce moment)
  4. du transparent 5 pour une durée de vie de 2 images (celle que nous décrivons en ce moment et la suivante)
  5. du transparent 4 pour une durée de vie de 10 images (celles que nous décrivons en ce moment et les 9 suivantes)

Il faut bien comprendre que c'est le transparent 3 qui est posé en premier (donc il est en dessous de tous les autres et peut subir éventuellement des recouvrements partiels ou non par les transparents suivants) et que c'est le transparent 4 qui est posé en dernier (il est donc au dessus de tous les autres et peut éventuellement recouvrir partiellement ou non les transparents précédents)

Ligne 5

Enfin, la cinquième ligne ”::2×0” signifie que dans la cinquième image de l'animation, en plus des transparents ayant laissé des traces à cause des lignes précédentes, on superposera le transparent 2 avec une durée de vie infinie. Et oui, le “x0” ne veut pas dire «durée de vie de 0 images» (ça n'aurait pas grand intérêt), mais veut dire «durée de vie infinie». Le transparent 2 sera donc présent jusqu'à la fin de l'animation, même s'il pourra être éventuellement recouvert par d'autres transparents dans la suite de l'animation. Cette notion de trace perpétuelle est très pratique, notamment lorsque vous avez des éléments immobiles d'un bout à l'autre de l'animation, comme un repère par exemple. Vous placez le code du repère dans le transparent 0 par exemple (et uniquement dans celui-ci), puis dans votre fichier agencement.txt vous mettez en début de première ligne ”::0x0” et c'est fini : vous aurez votre repère présent d'un bout à l'autre de l'animation. Pour vérifier que tout est bien compris, nous allons récapituler ce que nous devrions obtenir dans la cinquième image de l'animation. Elle sera la superposition, dans cet ordre, des transparents suivants :

  1. du transparent 5 à cause de la ligne ”::1,0,5×2,4×10” précédente
  2. du transparent 4 à cause de la ligne ”::1,0,5×2,4×10” précédente
  3. du transparent 2 pour une durée de vie infinie (le transparent 2 sera donc présent jusqu'à la fin de l'animation, même s'il pourra être éventuellement recouvert par d'autres transparents par la suite)

Vous pouvez voir à nouveau l'animation, vous verrez que ces prédictions coïncident bien avec le résultat observé. Malheureusement, notre exemple ne rend pas compte du fait que les transparents peuvent se recouvrir mutuellement et que par conséquence l'ordre de superposition des transparents peut influencer le résultat final. Retenez que l'ordre de superposition se fait d'abord de haut en bas (un transparent appelé à la ligne n du fichier agencement.txt et laissant une trace sera toujours en dessous des transparents appelés dans les lignes suivantes) puis de gauche à droite (par exemple avec la ligne ”::5,2” le transparent 5 sera en dessous du transparent 2 ou le transparent 2 recouvrira le transparent 5 si vous préférez). Nous reviendrons plus loin sur cette histoire d'ordre de recouvrement.

Maintenant, dans une ligne du fichier agencement.txt, toujours de la forme

<élément 1> : <élément 2> : <élément 3>

la syntaxe de <élément 3> n'a presque plus de secret pour vous. Regardons la syntaxe de <élément 1> et de <élément 2>.

Concernant <élément 1>, il peut être, soit vide (comme à chaque ligne dans notre exemple), soit constitué de l'unique caractère * (par exemple dans une ligne du type “*::1,3×0”). La présence du caractère * sur une ligne du fichier agencement.txt signifie qu'il y aura une pause automatique au niveau de l'image concernée par cette ligne. Faites le test avec notre exemple en rajoutant le caractère * quelque part dans agencement.txt puis en recompilant le source bien sûr. Vous constaterez une pause automatique dans votre animation. C'est l'équivalent de la commande \newframe* de l'environnement animateinline.

Enfin, <élément 2> peut être, soit vide (comme à chaque ligne dans notre exemple), soit constitué d'un entier strictement positif qui représentera la nouvelle vitesse de défilement (en images par seconde) de l'animation. Par exemple, si dans la n-ième ligne du fichier agencement.txt on a ”:20:1,3×0”, alors l'animation passera à 20 images par secondes à partir de la n-ième image, quelle que soit la valeur qui avait été précisée dans la commande \animategraphics ou dans l'environnement animateinline. C'est l'équivalent de la commande \newframe[20] de l'environnement animateinline. Là aussi, je vous laisse le soin de faire des tests avec notre exemple en modifiant le fichier agencement.txt puis en recompilant le source.

On peut donc dans le fichier agencement.tex gérer non seulement les superpositions des transparents pour chaque image, mais aussi la vitesse de défilement des images et les pauses éventuelles. Bref, on peut tout faire !

Au final, le fichier agencement.txt suit la syntaxe suivante :

  • une ligne ::= <élément 1> : <élément 2> : <élément 3> (correspond à une image de l'animation)
  • <élément 1> ::= * ou rien du tout suivant qu'on souhaite une pause automatique ou non
  • <élément 2> ::= un entier strictement positif ou rien du tout pour changer ou non le nombre d'images par seconde
  • <élément 3> ::= une suite de <transparent> séparés par des virgules
  • <transparent> ::= ou bien <num> ou bien <num>x<durée> sachant que <num> équivaut à <num>x1
  • <num> ::= un entier donnant le numéro du transparent appelé
  • <durée> ::= un entier donnant la durée de vie du transparent. Si d=0 alors la durée de vie du transparent est infinie.

En fait, je n'ai pas encore tout dit sur la syntaxe du fichier agencement.txt. Pour être totalement complet, <élément 3> est une suite de <transparent> séparés par des virgules ou des points-virgules. Nous allons voir la signification des points-virgules ci-dessous.

Grouper les transparents par couche

Nous avons vu que l'ordre de superposition des transparents dans le fichier agencement.txt se fait de haut en bas et de gauche à droite. Le recouvrement des transparents se fait donc dans cet ordre là, qui n'est autre que l'ordre de lecture du fichier agencement.txt. Cela peut entraîner des réécritures (= recouvrements) d'éléments graphiques qui peuvent être gênantes parfois (parfois mais pas toujours, dès fois c'est un effet au contraire souhaitable). Prenons un exemple imaginaire. Regardez bien ce fichier agencement.txt :

::0x49  ,   1x0   % Nous avons le transparent 0 qui servira «d'image de
::          2x0   % fond» pendant 49 images.
::          3x0
   etc...
::          49x0
::50x0  ,   51x0  % Puis nous changeons «d'image de fond» en cours de
::          52x0  % route. Désormais «l'image de fond» transparent 0 a
::          53x0  % disparu et est remplacée par le transparent 50.
::          54x0
   etc...

L'idée de ce fichier est la suivante :

  • l'animation se déroule pendant les 49 premières images avec le transparent 0 comme «image de fond».
  • puis, à partir de la cinquantième image, «l'image de fond» de l'animation change pour être remplacée par le transparent 50.

Une chose parfois gênante peut se produire avec ce fichier agencement.txt : le transparent 50 (la «nouvelle image de fond» de l'animation) va recouvrir tous les transparents 1, 2, 3, …, 49. En effet, le transparent 50 est posé au dessus des transparents 1, 2, 3, …, 49 vu qu'il intervient après dans l'ordre de lecture du fichier agencement.txt. Ce recouvrement pourra faire éventuellement disparaître des éléments graphiques formés par les transparents 1, 2, …, 49, alors peut-être voudrait-on les conserver.

Pour éviter cet effet (si on souhaite l'éviter), nous allons introduire des «couches» avec le caractère ”;”. Regardez donc la nouvelle version du fichier agencement.txt :

% <---couche 1---> <---couche 2--->
%
::      0x49      ;     1x0         % Nous avons le transparent 0 qui servira
::                ;     2x0         % «d'image de fond» pendant 49 images.
::                ;     3x0
   etc...
::                ;     49x0
::      50x0      ;     51x0        % Puis nous changeons «d'image de fond» en
::                ;     52x0        % cours de route. Désormais «l'image de fond»
::                ;     53x0        % transparent 0 a disparu et est remplacée
::                ;     54x0        % par le transparent 50.
   etc...

L'idée est la suivante. Avec les points-virgules, on a créé deux couches de transparents : la couche 1 et la couche 2. L'élément clé à comprendre, c'est qu'un transparent de la couche 1 sera toujours posé en dessous des transparents de la couche 2, quel que soit leur ordre d'apparition dans le fichier agencement.txt. Donc la nouvelle «image de fond» formée par le transparent 50 ne va pas recouvrir les transparents 1, 2, …, 49 puisqu'ils sont dans la couche 2. Dans cet exemple, deux couches ont été créées. Mais on peut en créer autant que l'on souhaite. Donc, au final, non seulement vous pouvez superposer les transparents à volonté mais en plus vous pouvez les regrouper par couches afin de mieux contrôler les problèmes de recouvrements.

Récapitulons de manière définitive l'ordre de superposition des transparents dans le fichier agencement.txt :

  • L'ordre dans lequel on pose les transparents compte, comme avec des transparents de la «vraie vie». Si on a posé un transparent B au dessus du transparent A, il pourra éventuellement recouvrir des éléments graphiques du transparent A. En fait, il y aura recouvrement au niveau de l'intersection entre les éléments graphiques de A et les éléments graphiques de B, et bien sûr sur cette intersection les éléments graphiques de B recouvriront ceux de A.
  • Dans le fichier agencement.txt, un transparent B est posé au dessus du transparent A si et seulement si :
    1. ou bien les transparents A et B sont dans des couches distinctes et dans ce cas le transparent B appartient à une couche supérieure à la couche du transparent A.
    2. ou bien les transparents A et B sont dans une même couche et dans ce cas le transparent B est posé après le transparent A. C'est-à-dire :
      1. soit le transparent B intervient dans le fichier agencement.txt dans une ligne en dessous de la ligne où intervient le transparent A.
      2. soit les transparents A et B sont sur la même ligne et le transparent B intervient plus à droite que le transparent A.

Écriture du fichier agencement.txt avec LaTeX

Pour l'instant, on peut faire un petit reproche à l'option timeline : il faut taper un fichier externe au code source, à savoir le fichier agencement.tex, qui peut être long à taper s'il contient 200 lignes par exemple (soit 200 images pour l'animation). Sachez que cela peut se résoudre très simplement car on peut demander à LaTeX d'écrire dans un fichier externe directement depuis un source grâce (entre autres) à la commande \write. Pour ceux qui ne connaissent pas trop cette commande, vous pouvez regarder l'exemple suivant que vous comprendrez parfaitement à l'aide des commentaires et de quelques compilations. Vous pourrez voir que lors de la compilation (via pdflatex par exemple) un fichier toto.txt est créé dans le même répertoire que le source et de nombreuses lignes sont écrites dedans :

\documentclass{article}
\usepackage[latin1]{inputenc}
\usepackage[T1]{fontenc}
\usepackage{lmodern}
\usepackage{geometry}
\usepackage{multido}
\usepackage[frenchb]{babel}

% On crée le fichier toto.txt ouvert en écriture
\newwrite\Fichier 
\immediate\openout\Fichier=toto.txt

% Puis, on peut ensuite écrire dessus ainsi
\immediate\write\Fichier{1 On saute une ligne à chaque commande}
\immediate\write\Fichier{2 On saute une ligne à chaque commande}
\immediate\write\Fichier{3 On saute une ligne à chaque commande}
\immediate\write\Fichier{} % provoque un saut de ligne
\immediate\write\Fichier{} % provoque un saut de ligne
\immediate\write\Fichier{} % provoque un saut de ligne

% Attention, contrairement à \multiframe, dans la déclaration
% des variables avec \multido il faut mettre le caractère backslash "\".
\multido{\ix=0+1,\iy=0+3,\nz=2.000+0.005}{100}%
{%
  \immediate\write\Fichier{(x;y;z) = (\ix;\iy;\nz)}%
}

% Toujours penser à fermer le fichier une fois les écritures terminées
\immediate\closeout\Fichier


\begin{document}

Un texte ...

\end{document}

Remarquez qu'à chaque appel de la commande \immediate\write\Fichier{…}, une ligne est sautée dans le fichier toto.txt. Remarquez également que la commande \multido marche parfaitement pour écrire de nombreuses lignes dépendantes de paramètres à incrémenter, ce qui peut être utile pour créer un fichier agencement.txt. Bien que cela ne soit pas d'un intérêt extraordinaire, je vous donne le source donnant l'animation de l'exemple vu précédemment, où cette fois-ci le fichier agencement.txt est écrit dans le source lui-même, par LaTeX.

\documentclass{article}
\usepackage[latin1]{inputenc}
\usepackage[T1]{fontenc}
\usepackage{lmodern}
\usepackage[dvips]{geometry}
\usepackage{pstricks-add}
\usepackage{animate}
\usepackage[frenchb]{babel}

% On règle 2cm pour l'unité graphique.
\psset{unit=2cm}

\newcommand{\Debut}% Début systématique du dessin
{% 
  % Avec l'environnement pspicture, on crée un rectangle de dessin
  % dont le coin inférieur gauche a pour coordonnées (0,0) et le coin
  % supérieur droit a pour coordonnées (4,4)
  \begin{pspicture}(0,0)(4,4)
  % On crée un cadre noir pour matérialiser le rectangle de dessin avec \psframe
  % sans quoi le rectangle de dessin existera bel et bien, mais sera invisible.
  \psframe[linewidth=3pt](0,0)(4,4)% l'épaisseur du trait est de 3pt
}

\newcommand{\Fin}% Fin systématique du dessin
{%
  \end{pspicture}% fin de l'environnement pspicture
}

% On crée le fichier agencement.txt ouvert en écriture
\newwrite\agencement
\immediate\openout\agencement=agencement.txt

% On peut ensuite écrire dessus
\immediate\write\agencement{::6}
\immediate\write\agencement{::1,5}
\immediate\write\agencement{::3x2}
\immediate\write\agencement{::1,0,5x2,4x10}
\immediate\write\agencement{::2x0}

\multido{}{15}% pas besoin de variable à incrémenter ici
{%
  \immediate\write\agencement{::5}
  \immediate\write\agencement{::6}
}%

% Toujours penser à fermer le fichier une fois les écritures terminées
\immediate\closeout\agencement

\begin{document}

\begin{center}
\begin{animateinline}[controls,begin={\Debut},end={\Fin},timeline=agencement.txt]{4}
  \rput[l](1,0.5){\LARGE Transparent 0}
  % pose l'étiquette «Transparent 0» au point (1,0.5)
\newframe
  \rput[l](1,1){\LARGE Transparent 1}
  % pose l'étiquette «Transparent 1» au point (1,1)
\newframe
  \rput[l](1,1.5){\LARGE Transparent 2}
  % pose l'étiquette «Transparent 2» au point (1,1.5)
\newframe
  \rput[l](1,2){\LARGE Transparent 3}
  % pose l'étiquette «Transparent 3» au point (1,2)
\newframe
  \rput[l](1,2.5){\LARGE Transparent 4}
  % pose l'étiquette «Transparent 4» au point (1,2.5)
\newframe
  \rput[l](1,3){\LARGE Transparent 5}
  % pose l'étiquette «Transparent 5» au point (1,3)
\newframe
  \rput[l](1,3.5){\LARGE Transparent 6}
  % pose l'étiquette «Transparent 6» au point (1,3.5)
\end{animateinline}
\end{center}

\end{document}

Le source doit être compilé via latex⇒dvips⇒ps2pdf14 bien sûr. Lors de la compilation, le fichier agencement.txt sera créé et utilisé pour l'animation engendrée par l'environnement animateinline. Évidemment, l'écriture du fichier agencement.txt doit précéder dans le source la création de l'animation. Il faut d'abord créer le fichier agencement.txt avant l'animation puisque l'animation a besoin de ce fichier pour fonctionner.

Comme cela a déjà été signalé, même si l'option timeline a été testée ici avec l'environnement animateinline, elle est parfaitement valable pour des animations créées par la commande \animategraphics. Le principe est bien sûr exactement le même : agencer les transparents à sa guise.

Pour une utilisation plus intéressante de l'option timeline que celle faite dans l'exemple précédent (exemple purement didactique), vous pourrez consulter le source de l'animation euler.pdf qui figure dans la liste des exemples complets.

L'option timeline permet d'alléger la compilation

Avec l'option timeline et sa possibilité de garder une trace des transparents, vous pourrez faire en sorte de ne jamais avoir un même élément graphique (cercle, droite, courbe etc.) dans deux transparents différents. En effet, pourquoi diable infliger à LaTeX la fabrication d'éléments graphiques identiques à deux reprises (ou plus) dans des transparents différents ? Avec l'option timeline, non seulement cela devient inutile, mais en plus cela rendra la compilation plus longue. Prenons un exemple. Imaginons qu'une animation contienne des éléments graphiques immobiles du début à la fin, comme un repère et une courbe par exemples. Vous placez le code de ces éléments dans le transparent 0 par exemple et dans le fichier agencement.txt vous mettez en première ligne ceci :

:: 0x0 % et éventuellement d'autres transparents

Vous aurez alors votre repère et votre courbe en «image de fond» tout au long de l'animation. À partir de là, dans tous les autres transparents autre que le numéro 0, hors de question de coder à nouveau le repère et la courbe ! Cela demanderait à LaTeX du travail supplémentaire totalement inutile. Le repère et la courbe existent déjà dans un transparent que l'on pourra faire apparaître absolument quand on veut avec le fichier agencement.txt. La philosophie peut donc se résumer en une phrase : pas d'éléments graphiques en double dans les transparents ! Ça n'a l'air de rien, mais en suivant ce principe, on peut vraiment rendre la compilation beaucoup plus rapide, voire résoudre des problèmes de mémoire, et obtenir un document pdf beaucoup plus léger.

Conclusion

Si vous avez lu ce wiki jusqu'au bout, vous disposez maintenant d'une très bonne base concernant le package animate. Félicitations ! :-D

N'hésitez pas à consulter sa documentation sur le CTAN afin de connaître par exemple quelques options supplémentaires qui n'ont pas été évoquées ici (il y en a). Mais je vous rassure, nous avons largement abordé l'essentiel.

Désormais, vous êtes parfaitement en mesure de faire toutes sortes d'animations que vous pourrez placer dans des documents pdf. Sous LaTeX, avec la classe beamer destinée à faire des présentations à la PowerPoint (mais en mieux), vous pourrez faire par exemple des cours rétroprojetés et illustrer des passages à l'aide de petites animations. Sans aucun doute, ce package peut être d'une grande utilité pour un professeur de mathématiques (ou d'une autre matière scientifique).

Allez, au travail maintenant… ;-)

Quelques exemples complets

Un exemple complet comportera :

  1. un lien vers une archive .zip qui, une fois désarchivée, doit donner un répertoire contenant tous les sources nécessaires.
  2. Les sources devront être compilables tels quels, le plus lisibles possible et le plus commentés possible (les commentaires, c'est inestimable pour celui qui découvre le source).
  3. le type de compilation requise.
  4. un lien vers le document pdf contenant l'animation.
  5. une description rapide.

N'hésitez surtout pas à rajouter vos propres exemples !

  • soit en éditant ce paragraphe du wiki si vous en avez les droits.
  • soit en postant vos exemples sur ce fil du forum MathemaTeX consacré au package animate. Votre exemple sera certainement ensuite rajouté sur ce wiki.

Pour l'instant, la liste ci-dessous ne contient que des dessins faits avec du code PSTricks. Les animations utilisant du code PGF/TikZ seraient particulièrement les bienvenues. Même des exemples simples ont leur place ici. Tout est bon à prendre, n'hésitez pas…

tangente.tex

Lien vers l'archive contenant tous les sources. À compiler via latex ⇒ dvips ⇒ ps2pdf14.

Lien vers le document pdf contenant l'animation.

Cette animation est un zoom sur le point de contact entre une courbe et sa tangente en un point.

euler.tex

Lien vers l'archive contenant tous les sources. À compiler via latex ⇒ dvips ⇒ ps2pdf14.

Lien vers le document pdf contenant l'animation.

Cette animation représente la construction d'Euler permettant d'approcher la courbe de la fonction exponentielle par des lignes brisées. Cet exemple est dû à Alexander Grahn. Dans le code, on utilise grandement l'option timeline sans laquelle la réalisation de cet exemple serait très lourde.

bille.tex

Lien vers l'archive contenant tous les sources. À compiler via latex ⇒ dvips ⇒ ps2pdf14.

Lien vers le document pdf contenant l'animation.

Cette animation représente une bille roulant sur un plan incliné. Le résultat est très beau mais le code est assez compliqué. On peut en revanche modifier très facilement l'angle d'inclinaison du plan. Cet exemple est de Jean-Côme Charpentier, Herbert Voss, Manuel Luque, et Alexander Grahn.

elevateur.tex

Lien vers l'archive contenant tous les sources. À compiler via latex ⇒ dvips ⇒ ps2pdf14.

Lien vers le document pdf contenant l'animation.

C'est pour la beauté du sport. Là aussi, le code est assez compliqué. Cet exemple est amusant mais la compilation est assez lourde. Il est également dû à Alexander Grahn.

wiki/latex/modules/animate.txt · Dernière modification: 2010/08/29 00:48 (modification externe)