4.1 Premier exemple: un diagramme de dispersion simple

La fonction principale de plotly est plot_ly. C’est la fonction à appeler pour produire la majorité des graphiques de base.

Pour créer un diagramme de dispersion, nous devons donner minimalement en argument à la fonction plot_ly les éléments suivants:

• x: Un vecteur de valeurs des points pour l’axe X.
• y: Un vecteur de valeurs des points pour l’axe Y.

Les arguments suivants sont aussi fortement conseillés pour obtenir le résultat espéré:

• type: Le type de graphique à produire (ex: scatter, box, histogram, heatmap).
• mode: Le type d’affichage à utiliser pour la série de données: markers, lines ou lines+markers.
• data: L’objet duquel extraire les données pour x et y. S’il est utilisé, il est nécessaire d’ajouter l’opérateur ~ lors de la définition des valeurs de x et y.

plot_ly(data = quakes, x = ~ long, y = ~ lat, type = 'scatter', mode = 'markers')

En absence des arguments type et mode, plotly essaie de trouver la meilleure représentation possible en fonction des données et des paramètres par défaut pour le type de graphique. Pour plus d’informations sur la fonction plot_ly, veuillez vous référer à la documentation.

4.2 Graphique plus avancé

plotly a été conçu afin de construire les figures graphiques de façon séquentielle. Pour ce faire, le résultat d’une opération est passé à la suivante. Il est possible de créer des variables temporaires et de les passer aux fonctions suivantes, mais nous recommandons l’utilisation de l’opérateur %>%.

C’est donc en passant les résultats d’une fonction à l’autre qu’il est possible de produire des graphiques plus complexes. Par exemple, il est possible de mettre plusieurs jeux de données sur le même graphique avec add_trace ou de modifier l’apparence du graphique avec layout.

La fonction add_trace s’utilise exactement de la même façon que la fonction plot_ly, mais requiert comme premier argument un objet (une liste) préalablement créé. La fonction layout sert à modifier la mise en page du graphique. Elle prend comme premier argument un objet créé par plotly sur lequel elle appliquera les modifications demandées. Dans l’exemple ci-bas, on l’utilise pour spécifier le titre du graphique et des axes.

p_scatter <- plot_ly(data = quakes[quakes$region == "Est",], x = ~ long, y = ~ lat,  
                     name = 'Est', type = 'scatter', mode = 'markers')

p_scatter <- add_trace(p_scatter, data=quakes[quakes$region == "Ouest",], x = ~ long, y= ~ lat,  
                       name = 'Ouest', type = 'scatter', mode = 'markers')

p_scatter <- layout(p_scatter,
                    title = "Longitude et latitude de séismes près de Fidji depuis 1984",
                    xaxis = list(title = "Longitude"),
                    yaxis = list(title = "Latitude", scaleanchor = "x"))

p_scatter

L’exemple précédent crée une nouvelles variable, p_scatter, et l’utilise pour garder en mémoire les données nécessaires à la production du graphique. L’exemple suivant est identique au précédent, mais ne crée pas de variable dans l’environnement de travail et utilise l’opérateur %>% afin de passer l’information d’une fonction à l’autre.

plot_ly(data = quakes[quakes$region == "Est",], x = ~ long, y = ~ lat,  
        name = 'Est', type = 'scatter', mode = 'markers') %>% 
  add_trace(data=quakes[quakes$region == "Ouest",], x = ~ long, y= ~ lat,  
            name = 'Ouest', type = 'scatter', mode = 'markers') %>%
  layout(title = "Longitude et latitude de séismes près de Fidji depuis 1984",
         xaxis = list(title = "Longitude"),
         yaxis = list(title = "Latitude", scaleanchor = "x"))

4.3 Deuxième exemple: un histogramme

Pour créer un histogramme, l’argument ‘type’ doit recevoir la valeur histogram.

plot_ly(x = quakes$mag, type = "histogram") %>% 
  layout(title = "Magnitude des séismes")

• histnorm (=probability) permet de normer l’axe des ordonnées afin de visualiser les pourcentages des données (par défaut, histnorm = count)
• y, pour un histogramme horizontal. On ne donne pas de valeurs à x dans ce cas
• barmode (= overlay ou stack) pour superposer plusieurs histogrammes
• autotick (= TRUE) pour pouvoir gérer soi-même les éléments graphiques (couleurs, épaisseurs des traits, quadrillage)

Nous allons réaliser un histogramme plus complet avec plusieurs jeux de données en superposant les jeux de données sur l’histogramme, en ajoutant une légende claire avec layout et en créant un axe des abscisses sur mesure.

axe_x <- list(
  autotick = FALSE,              # pour contrôler le pas de l'axe des abscisses
  ticks = "outside",             # ou "inside"
  dtick = 20,                    # le nombre d'intervalles
  ticklen = 10,                  # la longueur des indicateurs
  tickwidth = 2,                 # la largeur des indicateurs
  tickcolor = toRGB("blue"),     # la couleur
  zeroline = TRUE,
  showline = TRUE,
  zerolinecolor = toRGB("red"),  # pour mettre en exergue la droite 'x = 0'
  zerolinewidth = 3,
  linecolor = toRGB("black"),
  linewidth = 2
  )
# axe_y <- list()   # On pourrait faire de même avec l'axe des ordonnées
plot_ly(alpha = 0.8, histnorm = "probability", xlim = c()) %>% 
  add_histogram(x = quakes$long, name = "Longitudes") %>% 
  add_histogram(x = quakes$stations, name = "Nombre de stations") %>%
  add_histogram(x = quakes$lat, name = "Latitudes") %>%
  layout(title = "Distribution empirique de trois variables décrivant les séismes", 
         barmode = "overlay", xaxis = axe_x)

4.4 Modification des propriétés graphiques avec la fonction layout

layout, qui signifie mise en page en français, permet de manipuler la mise en page d’un graphique en modifiant certaines caractéristiques comme la police et la couleur du titre, les axes, la légende, les marges, etc.

Nous allons apprendre comment ajouter des éléments à un graphique, sur l’exemple du boxplot ci-dessous réalisé à l’aide de plot_ly.

plot_ly(y = ~ depth, data = quakes, type = "box", name = "Profondeur en mètres") %>%
  layout(
    title = "Statistiques des profondeurs de séismes\nprès de Fidji depuis 1984",  # ajoute un titre
    yaxis = list(title = ""),  # précise les noms de l'axe des ordonnées
    titlefont = list(
      family = "sans serif",   # plusieurs polices de caractère en Word sont acceptées par family
      size = 14,               # comme "Courier New", "Arial", "Comic sans MS", "monospace", etc.
      color = '#ad42f4'),      # modifie la police
    paper_bgcolor = "white",   # modifie la couleur de fond 
    plot_bgcolor = "white",    # modifie la couleur en arrière du graphique
    showlegend = FALSE,        # affiche ou non la légende
    dragmode = "pan",          # choix du curseur d'interaction (pan, lasso, select, zoom (défaut))
    hovermode = "closest"      # affiche les labels (x, y, closest ou FALSE)
)

## Warning: The titlefont attribute is deprecated. Use title = list(font = ...)
## instead.

Les arguments à la fonction layout sont nombreux. Parmi les plus courants, on peut citer : direction, orientation, width, height, margin, legend, autosize. Pour la liste complète des arguments et leur utilisation, veuillez vous référer à la page web suivante : https://plot.ly/r/reference/#layout.

7.1 Graphiques 3D

Tel que mentionné précédemment, plotly permet de produire des graphiques en trois dimensions. La syntaxe est identique à celle utilisée pour produire un graphique à deux dimensions dans le cas d’un graphique de dispersion, mais on doit lui ajouter un argument z contenant les valeurs de la troisième dimension.

Voici un exemple de graphique de dispersion tridimensionnel:

plot_ly(quakes, x = ~ long, y = ~ lat, z = ~ depth, color = ~ region, 
        type = "scatter3d", mode = "markers", marker = list(size = 3)) %>%
  layout(title="Longitude, latitude et profondeur des tremblements de terre")

Ici, nous avons utilisé l’attribut region afin de colorier les points sans produire deux séries de données différentes. De plus, l’argument type serait optionnel, car plotly produirait par défaut un graphique de dispersion lorsque x, y et zsont des vecteurs de valeurs.

Pour d’autres exemples de graphiques 3D, il y a quelques exemples sur la page officielle.

7.2 Cartes géographiques

Avec un peu de motivation et quelques recherches, il est possible de produire des cartes géographiques directement avec plotly. Afin d’en montrer un exemple, nous avons positionné les tremblements de terre de quakes sur une carte et avons colorié les points en fonction de la profondeur.

On peut remarquer que la création d’une carte utilise la fonction plot_geo qui possède sa propre série d’arguments (long et lat) et un type scattergeo. De plus, la fonction layout prend dans ce cas, un argument spécial: geo. Ce dernier est une liste de paramètres à considérer lors du rendu de la carte.

params <- list(
  scope = 'world',
  projection = list(type = 'equirectangular', 
                    rotation = list(lon = 160)),  # Rotation de la carte pour voir 
  showland = TRUE,                                # une section au milieu
  showocean = TRUE,
  oceancolor = "#a5c7ff",
  landcolor = "#d6d6d6",
  lonaxis = list(range = c(120, 200)),  # Étendu sur la longitude
  lataxis = list(range = c(-80, 10))    # Étendu sur la latitude
)

plot_geo(data = quakes, lat = ~ lat, lon = ~ long, 
         type = "scattergeo", mode = "markers", color = ~ depth, marker = list(size = 3)) %>%
  layout(title = 'Position et profondeur des tremblements de terre', geo = params)

Les pages suivantes contiennent plus d’information et d’exemples quant à la production de cartes géographiques:

• https://plot.ly/r/maps/
• https://moderndata.plot.ly/county-level-choropleth-in-plotly-and-r/
  
• https://plotly-book.cpsievert.me/maps.html

7.3 WebGL

Pour améliorer la fluidité d’un graphique contenant beaucoup de valeurs à afficher, plotly permet l’utilisation de la technologie WebGL. WebGL est une librairie JavaScript qui utilise la puissance des processeurs graphiques (GPU) afin d’accélérer le traitement des images et graphiques d’une page web ³. Dans plotly, WebGL sert notamment à produire des graphiques de dispersion contenant des milliers, voire des millions, de points tout en gardant les interactions fluides. Pour utiliser la technologie WebGL, on doit simplement spécifier type="scattergl" en argument à la fonction plot_ly.

Un exemple montrant l’incroyable gain de performance obtenu grâce à l’utilisation de scattergl est disponible ici.