2.1 quakes

Le jeu de données quakes du package datasets du R de base contient les données de 1000 séismes de magnitude 4.0 et plus s’étant produits près des îles Fidji depuis 1964. Chaque observation inclut la latitude (lat), la longitude (long), la profondeur (depth), la magnitude (mag) et le nombre de stations à proximité (stations) ayant rapporté une activité sismique.

Ajoutons à ce jeu de données une variable factorielle prénommée region. Ce facteur déterminera si chaque observation a été observée à l’ouest ou à l’est de la longitude 175°. Créons également un facteur nommé mag_catego. Ce dernier servira à créer des classes de magnitude du séisme arrondie à l’entier inférieur (4, 5 ou 6).

quakes$region <- factor(quakes$long >= 175, labels = c("Ouest", "Est"))
quakes$mag_catego <- factor(floor(quakes$mag))
str(quakes)

'data.frame':   1000 obs. of  7 variables:
 $ lat       : num  -20.4 -20.6 -26 -18 -20.4 ...
 $ long      : num  182 181 184 182 182 ...
 $ depth     : int  562 650 42 626 649 195 82 194 211 622 ...
 $ mag       : num  4.8 4.2 5.4 4.1 4 4 4.8 4.4 4.7 4.3 ...
 $ stations  : int  41 15 43 19 11 12 43 15 35 19 ...
 $ region    : Factor w/ 2 levels "Ouest","Est": 2 2 2 2 2 2 1 2 2 2 ...
 $ mag_catego: Factor w/ 3 levels "4","5","6": 1 1 2 1 1 1 1 1 1 1 ...

2.2 WorldPhones

Le jeu de données WorldPhones du package datasets du R de base contient les données du nombre de lignes téléphoniques enregistrées entre 1951 et 1961 sur chaque continent sous forme de matrice. Dans cette matrice, le nom des colonnes indique le nom du continent où les données ont été enregistrées alors que le nom des rangées représente l’année à laquelle le nombre de lignes téléphoniques a été calculé.

Transformons d’abord cette matrice en dataframe avec le nom des rangées, donc l’année, inclus dans une colonne à part (Year).

WorldPhones <- data.frame(WorldPhones)
WorldPhones$Year <- as.numeric(rownames(WorldPhones))
head(WorldPhones, n = 3)

     N.Amer Europe Asia S.Amer Oceania Africa Mid.Amer Year
1951  45939  21574 2876   1815    1646     89      555 1951
1956  60423  29990 4708   2568    2366   1411      733 1956
1957  64721  32510 5230   2695    2526   1546      773 1957

Nous pouvons constater que le dataframe WorldPhones a une mise en forme large. Afin de pouvoir utiliser ce dataframe pour produire un graphique animé plus tard, transférons-le dans une mise en forme longue. Pour ce faire, nous utiliserons la fonction pivot_longer du package tidyr.

library(tidyr)
WorldPhones_long <- pivot_longer(
  data = WorldPhones, 
  cols = c(N.Amer, Europe, Asia, S.Amer, Oceania, Africa, Mid.Amer), 
  names_to = "Region", 
  values_to = "Nbr.Phones")

head(WorldPhones_long, n = 5)

# A tibble: 5 x 3
   Year Region  Nbr.Phones
  <dbl> <chr>        <dbl>
1  1951 N.Amer       45939
2  1951 Europe       21574
3  1951 Asia          2876
4  1951 S.Amer        1815
5  1951 Oceania       1646

3.1 Installation de gganimate

Une fois le package installé dans notre librairie à l’aide de la fonction install.packages, chargeons-le dans notre espace de travail. À noter que gganimate charge automatiquement le package ggplot2 à notre session.

library(gganimate)

Loading required package: ggplot2

NOTE: L’installation du package gifski avec la fonction install.packages peut être nécessaire pour le bon fonctionnement des animations. Le package gifski permet d’assembler les différents tableaux produits en un GIF. Par la suite, même si l’installation en soi est requise, vous n’aurez pas besoin de le charger dans votre espace de travail.

3.2 Fonctions de base

NOTE: L’ajout de la fonction view_* ou transition_* à une série de commandes suivant la syntaxe de ggplot2 permet d’animer n’importe quel graphique.

NOTE 2: La description exhaustive de chaque fonction du package gganimate est disponible sur le site web de gganimate.

3.3 Premier exemple avec quakes

Explorons maintenant le package gganimate. Nous débuterons en créant un graphique statique avec ggplot2 à partir du jeu de données quakes. Nous voulons mettre sous forme d’un nuage de points la latitude et la longitude où un séisme a été enregistré. Ces points seront colorés selon un gradient de la profondeur du séisme.

p <- ggplot(data = quakes) +
  geom_point(mapping = aes(x = long, 
                           y = lat,
                           colour = depth,
                           group = region)) +
  ggtitle("1000 séismes près de Fidji") +
  xlab("longitude") + 
  ylab("latitude") +
  labs(colour = "profondeur") +
  scale_color_gradient(low = "paleturquoise", 
                       high = "#008080") +
  theme_classic() +
  coord_quickmap()

p

Nous allons maintenant ajouter un peu de mouvement. Pour faciliter la visualisation du gradient de couleur, nous voulons que chaque point apparaisse graduellement en fonction de la profondeur à laquelle les séismes ont été enregistrés. Nous nous attarderons au rôle de chacune des fonctions plus bas.

panim <- p + 
  transition_time(depth) +
  shadow_mark(past = TRUE, 
              future = FALSE) + 
  enter_fade() +
  exit_fade()
 
animate(panim, nframes = 100, end_pause = 15, rewind = TRUE) 

Nous constatons que la syntaxe s’intègre très bien à celle de ggplot2. Explorons chacune des fonctions ci-haut, en les appliquant une à une au graphique p.

panim1 <- p + 
  transition_time(depth)

panim1

transion_time permet que chaque état soit défini comme une période de temps et chaque transition se fasse selon la durée entre les différents états. Bien que la profondeur (depth) ne soit pas une mesure de temps, nous voulions ici que chaque point apparaisse graduellement dans le temps selon la profondeur. Avec cette seule fonction, le graphique est un peu chaotique: les points disparaissent les uns après les autres. Nous aurons donc besoin d’une fonction de type shadow_* pour la suite.

panim2 <- p + 
  transition_time(depth) +
  shadow_mark(past = TRUE, 
              future = FALSE)
 
panim2

shadow_mark permet d’afficher les données des animations passées et futures à l’aide de ses arguments logiques past et future. En donnant la valeur TRUE à past et la valeur FALSE à future (qui sont d’ailleurs les valeurs par défaut), les données des animations passées restent visibles jusqu’à la fin de l’animation, tandis que les données des animations futures ne sont pas affichées. Toutefois, la transition entre les points est un peu abrupte. Tentons d’intégrer une fonction de type enter/exit_*.

panim3 <- p + 
  transition_time(depth) +
  shadow_mark(past = TRUE, 
              future = FALSE) + 
  enter_fade() +
  exit_fade()

enter_fade et exit_fade nous permettent de faire apparaître et disparaître les points de façon graduelle. Cependant, l’animation se réinitialise lorsque l’intégralité des données ont apparu. Il nous faudra donc contrôler l’enchaînement des tableaux avec animate.

panim <- p + 
  transition_time(depth) +
  shadow_mark(past = TRUE, 
              future = FALSE) + 
  enter_fade() +
  exit_fade()
 
animate(panim, nframes = 100, end_pause = 15, rewind = TRUE) 

animate nous permet de contrôler la visualisation des tableaux (frames) de l’animation et leur nombre (argument nframes). L’argument rewind permet de “rembobiner” notre animation panim en faisant rejouer les différents tableaux dans l’ordre inverse. De plus, nous avons pu ajouter une pause à la fin de l’animation (argument end_pause) d’une durée de 15 tableaux afin d’augmenter la période de temps où on peut voir tous les points de l’animation.

p2 <- p + 
  transition_states(region, 
                    wrap = FALSE, 
                    transition_length = 3, 
                    state_length = 0.5) +
  shadow_mark(past = FALSE, 
              future = FALSE) + 
  enter_fade() +
  exit_fade()
 
animate(p2, nframes = 100, rewind = TRUE) 

bp <- ggplot(data = quakes, 
             mapping = aes(x = mag_catego, y = stations)) +
  geom_boxplot() +
  geom_jitter(mapping = aes(colour = region),
              alpha = 0.4) +
  ggtitle("Nombre de stations ayant rapporté des séismes\nd'une certaine classe de magnitudes") +
  theme(plot.title = element_text(hjust = 0.5)) +
  xlab("Classe de magnitude") +
  ylab("Nombre de stations") +
  labs(colour = "Région")+
  theme_classic()+
  scale_color_manual(values = c("darkcyan", "#FF69B4"))
  

bpanim <- bp + 
  transition_layers(layer_length = 0.5, 
                    transition_length = 1) +
  enter_grow() + 
  enter_fade()

animate(bpanim, rewind = TRUE)

3.4 Deuxième exemple avec WorldPhones

Nous voulons ici que le nombre de lignes téléphoniques change en fonction des années et des régions. Nous utiliserons alors un diagramme à barres.

WP <- ggplot(data = WorldPhones_long) +
  geom_col(mapping = aes(x = Region, y = Nbr.Phones), 
           fill = "darkcyan") +
  theme_classic() +
  xlab("Région") +
  ylab("Nombre de téléphones (en milliers)") +
  transition_states(Year,
                    transition_length = 2,
                    state_length = 1, 
                    wrap = TRUE) +
  ggtitle("Année : {closest_state}")

WP

• Cet exemple fait appel à la fonction transition_states pour animer le graphique. Chaque état représente une année différente. Encore une fois, nous avons pu définir le temps entre les transitions, donc la vitesse à laquelle on change d’année avec l’argument transition_length. Aussi, nous avons laissé la valeur par défaut pour l’argument state_length, qui permet de contrôler le temps que les données de chaque année restent visibles. En donnant la valeur TRUE à l’argument logique wrap, on ajoute une transition entre le dernier état et le premier état, ce qui permet d’avoir une animation plus fluide lorsqu’elle se termine.

• Il est possible d’afficher de façon interactive l’année représentée à chaque état de l’animation grâce à la variable closest_state. Cette variable permet de définir le nom de l’état le plus près du tableau représenté (frame).

WP2 <- ggplot(data = WorldPhones_long) +
  geom_col(mapping = aes(x = Region, y = Nbr.Phones), 
           fill = "cyan3") +
  geom_col(data = WorldPhones_long[WorldPhones_long$Year == 1951,], 
           mapping = aes(x = Region, y = Nbr.Phones), 
           fill = "darkcyan", 
           show.legend = TRUE) +
  theme_classic() +
  xlab("Région") +
  ylab("Nombre de téléphones (en milliers)") +
  transition_states(Year,
                    transition_length = 2,
                    state_length = 1, 
                    wrap = TRUE) +
  ggtitle("Année : {closest_state}") +
  shadow_mark()

WP2

WP3 <- ggplot(data = WorldPhones_long, aes(x = Year, y = Nbr.Phones, group=Region, color=Region)) +
    geom_line() +
    geom_point() +
    ggtitle("Nombre de téléphones (en milliers) entre 1951 et 1961") +
    ylab("Nombre de téléphones") +
    xlab("Année")+
    theme_classic()+
    view_follow(fixed_x = TRUE, 
                fixed_y = FALSE) +
    transition_reveal(Year)
    

WP3 <- animate(WP3, end_pause = 15)

WP3

3.5 Sauvegarder une animation (anim_save)

Les animations produites par gganimate peuvent soit être visualisées en RStudio (fenêtre Viewer), intégrées directement dans des documents HTML avec la syntaxe R Markdown ou sauvegardées à l’aide de la fonction anim_save en fournissant une chaîne de caractères pour le nom de fichier (argument filename) et en désignation quelle animation enregistrer (argument animation). Sauvegardées ainsi, ces animations peuvent ensuite être implémentées dans d’autres documents.

anim_save(filename = "WP3.gif", animation = WP3)

4.1 Points forts

• La syntaxe est compatible avec ggplot2, donc facile à intégrer rapidement dans une série de commandes.
• Animer un graphique ggplot2 est très simple, et nécessite dans bien des cas seulement l’ajout d’une fonction ou deux.
• Un nombre limité de fonctions permet d’arriver à une panoplie de résultats.
• Qui n’aime pas les animations, sincèrement?

4.2 Limitations

• On ne peut pas superposer deux types de transition, ce qui peut limiter les possibilités de création ou demander de passer par des chemins plus complexes pour arriver à un résultat donné.
• Les graphiques sont lents à produire selon la puissance de l’ordinateur. Cela rend l’exploration du package plus difficile.
• La combinaison de certaines fonctions peut produire des résultats inattendus. Animer un graphique exactement comme on l’imagine peut alors devenir complexe.
• Les tailles des graphiques sont difficiles à contrôler, surtout lorsqu’on les intègre à des documents en utilisant R Markdown.
• La documentation R des différentes fonctions manque de clarté, car elle ne donne pas d’exemples visuels de ses commandes. Il faut souvent faire rouler le code qui est fourni, et celui-ci ne fonctionne pas toujours. Il faut alors avoir recours à des forums ou à des pages webs afin de mieux comprendre l’intégration des différentes fonctions.