Accessibility Tools

Web Accessibility plugin by DJ-Extensions.com

- Le blog participatif de bioinformatique francophone depuis 2012 -

Rendre ses projets R plus accessibles grâce à Shiny

-

par

Thomas Denecker
dans ,

Vous avez un script que vous sou­hai­tez par­ta­ger avec une équipe expé­ri­men­tale ? Vous ne vou­lez pas que les uti­li­sa­teurs modi­fient le code pour para­mé­trer votre pro­gramme ? Vous codez avec R ? Alors cet article est fait pour vous ! Nous allons voir com­ment créer une appli­ca­tion web avec R et per­mettre à votre uti­li­sa­teur d’exécuter votre code sans le voir.

Shiny

Le package que nous uti­li­se­rons est shi­ny. Il est pro­po­sé par Rstu­dio (https://​shi​ny​.rstu​dio​.com/) et dis­po­nible sur le CRAN. Ce package per­met de construire des appli­ca­tions web très sim­ple­ment sans connais­sances par­ti­cu­lières en HTML et CSS. Les fonc­tions que nous appel­le­rons dans R vont être tra­duites en HTML. Par exemple,

1
h1(‘Un titre’)

sera trans­for­mé en

1
&lt ;h1&gt ;Un titre&lt ;/​h1&gt ;

. Il n’est donc pas indis­pen­sable de savoir coder en HTML, mais des connais­sances dans les lan­gages web pour­ront vous être utiles dans des cas par­ti­cu­liers, puisqu'il est pos­sible d’intégrer dans l’application shi­ny du code HTML brut. 

Une appli­ca­tion shi­ny se divise en 2 par­ties :

  • l’UI : Il s’agit de l’interface uti­li­sa­teur visible dans une page web. Nous pour­rons y retrou­ver des graphes, des tableaux, du texte, etc. L’utilisateur pour­ra inter­agir avec cette inter­face par le biais de bou­tons, de sli­ders, de cases, etc.
  • le ser­veur : Il s’agit de la « zone de tra­vail ». Tous les cal­culs, pré­pa­ra­tions de don­nées ou ana­lyses que R réa­li­se­ra seront faits côté ser­veur.

Nous allons voir dans cet article toutes les étapes pour créer une appli­ca­tion com­plète. Elle sera capable de lire un fichier en fonc­tion de para­mètres enre­gis­trés par l’utilisateur puis d'afficher :

  • Un tableau avec de la colo­ra­tion condi­tion­nelle
  • 4 gra­phiques obte­nus par des approches dif­fé­rentes
    • Un clas­sique réa­li­sé avec R. Ce gra­phique sera para­mé­trable par l’utilisateur (cou­leur ou titre par exemple).
    • Un réa­li­sé avec la librai­rie ggplot2
    • Un dyna­mique réa­li­sé avec plot­ly
    • Un dyna­mique réa­li­sé avec Google

L’ensemble du code per­met­tant de réa­li­ser l’application est dis­po­nible sur github : https://​github​.com/​b​i​o​i​n​f​o​-​f​r​/​b​i​o​i​n​f​o​-​f​r​_​S​h​iny

Pré-requis

Toutes les étapes pour créer une appli­ca­tion Shi­ny seront détaillées dans ce post. Connaître la syn­taxe de R sim­pli­fie­ra gran­de­ment la lec­ture de l'article mais n’est pas indis­pen­sable.

Pour réa­li­ser cette appli­ca­tion, il vous fau­dra une ver­sion à jour de RStu­dio (plus simple que la console R). Pour l’installer, sui­vez les étapes sui­vantes (l’ordre est impor­tant) :

  1. ins­tal­ler R : https://cran.r‑project.org/
  2. Ins­tal­ler RStu­dio : https://​www​.rstu​dio​.com/​p​r​o​d​u​c​t​s​/​r​s​t​u​d​i​o​/​d​o​w​n​l​o​ad/

Note : pour les uti­li­sa­teurs de R les plus avan­cés, l’application peut être déve­lop­pée dans un envi­ron­ne­ment vir­tuel comme docker (sujet de mon pro­chain post).

Les données

Les don­nées uti­li­sées pour cette appli­ca­tion pro­viennent du tableau IRIS regrou­pant des mesures sur des fleurs (dis­po­nible dans Rda­ta­set et décrit ici https://​archive​.ics​.uci​.edu/​m​l​/​d​a​t​a​s​e​t​s​/​i​ris ). Ce jeu de don­nées est très uti­li­sé pour illus­trer les fonc­tions dans R et pour le machine lear­ning. Le tableau est com­po­sé de 5 colonnes :

  • la lon­gueur des sépales ;
  • la lar­geur des sépales ;
  • la lon­gueur des pétales ;
  • la lar­geur des pétales ;
  • l’espèce de fleurs.

Un fichier au for­mat txt est dis­po­nible ici :
https://​github​.com/​b​i​o​i​n​f​o​-​f​r​/​b​i​o​i​n​f​o​-​f​r​_​S​h​i​n​y​/​b​l​o​b​/​m​a​s​t​e​r​/​d​a​t​a​s​e​t​I​r​i​s​.​txt .

Les packages R

Les packages uti­li­sés pour réa­li­ser l’application sont dis­po­nibles sur le CRAN. Ils s’installent avec la com­mande :

1
ins­tall.packages()

. Les packages que nous uti­li­se­rons sont :

  • shi­ny [1] : Il per­met­tra de construire l’application web
  • shi­ny­da­sh­board [2]: Il per­met­tra de créer une archi­tec­ture dyna­mique à la page web avec une zone de titre, une menu rabat­table et une zone prin­ci­pale
  • shi­ny­Wid­gets [3] : Il per­met­tra de mettre un mes­sage d’alerte pour confir­mer la lec­ture cor­recte du tableau
  • DT [4] : Il per­met­tra de créer un tableau dyna­mique avec de la colo­ra­tion condi­tion­nelle
  • plot­ly [5] , ggplot2 [6] et goo­gle­Vis [7] : Ils nous per­met­tront de réa­li­ser des gra­phiques
  • colour­pi­cker [8] : Il per­met­tra à l’utilisateur de sélec­tion­ner une cou­leur.

Nous uti­li­se­rons pour les ins­tal­ler et les char­ger un autre package : any­lib [9]. Ce package est très pra­tique car il per­met d'installer (si besoin) et de char­ger une liste de package. En plus, il a été créé par un des auteurs de Bioin­fo-fr : Aure­lien Cha­tei­gner. Que deman­der de plus !

1
2
[crayon-673f876039488453919405  ]ins­tall.packages("any­Lib")
any­Lib::any­Lib(c("shi­ny", "shi­ny­da­sh­board", "shi­ny­Wid­gets", "DT", "plot­ly", "ggplot2", "goo­gle­Vis", "colour­pi­cker"))
[/​crayon]

Création de l’architecture

Mise en place d’un dashboard

Pour mettre en forme notre appli­ca­tion web (la par­tie UI visible par l’utilisateur), nous allons uti­li­ser le package shi­ny­da­sh­board. La docu­men­ta­tion est pré­sente ici : https://​rstu​dio​.github​.io/​s​h​i​n​y​d​a​s​h​b​o​a​r​d​/​i​n​d​e​x​.​h​tml .

L'architecture mini­male avec shi­ny­das­bord est zone de titre (bleue), une barre laté­rale (noir) et une zone prin­ci­pale (grise).

1
2
3
4
5
6
7
8
9
10
11
12
[crayon-673f876039491271791802  ]libra­ry(shi­ny)
libra­ry(shi­ny­da­sh­board)
 
ui <- dash­board­Page(
  dash­board­Hea­der(),
  dash­board­Si­de­bar(),
  dash­board­Bo­dy()
)
 
ser­ver <- func­tion(input, out­put) { }
 
shi­nyApp(ui, ser­ver)
[/​crayon]
Visua­li­sa­tion de l’application

Test de l’application

Pour tes­ter l’application, il faut sau­ve­gar­der le code puis appuyer sur le bou­ton

1
Run App

au des­sus à droite de l’éditeur de texte de Rstu­dio. Un point impor­tant, Rstu­dio recon­naît par défaut les appli­ca­tions qui se nomme app.R. Je vous conseille vive­ment de nom­mer votre fichier app.R.

Si vous tra­vaillez avec la console R, vous pou­vez lan­cer la com­mande sui­vante :

1
[crayon-673f87603949b498777206  ]runApp()
[/​crayon]

Ajouter un titre

Dans la fonc­tion dash­board­Hea­der, nous ajou­tons un titre à l’application (ici bioin­fo-fr). Ce titre sera affi­ché en haut à gauche.

1
2
3
4
5
[crayon-673f8760394a2986258803  ]ui <- dash­board­Page(
  dash­board­Hea­der(title = "bioin­fo-fr"),
  dash­board­Si­de­bar( ),
  dash­board­Bo­dy( )
)
[/​crayon]
Visua­li­sa­tion de l’application

Ajouter des pages

La pre­mière étape est d’ajouter des élé­ments (item) dans la barre de menu laté­rale (par­tie noire). Nous uti­li­sons pour cela la fonc­tion

1
dash­board­Si­de­bar

. Nous y ajou­tons la fonc­tion

1
side­bar­Me­nu

qui contient les items du menu.

Ensuite, il faut indi­quer que la par­tie body aura plu­sieurs pages (des

1
tabI­tems

). Chaque

1
tabI­tem

cor­res­pond à une page acces­sible par le menu. Le

1
menuI­tem

doit avoir le même nom que l’argument

1
tab­Name

de la fonc­tion

1
tabI­tem

pour y accé­der (exemple : read­Da­ta). Dans chaque page, nous ajou­tons un titre de niveau 1 (h1). Vous pou­vez remar­quer l'utilisation de la fonc­tion

1
icon

(

1
icon = icon(...)

). L'argument de la fonc­tion est un nom d'icône que nous pou­vons trou­ver sur ces deux sites :
https://​fon​ta​we​some​.com/ et
https://​get​boots​trap​.com/​d​o​c​s​/​4​.​3​/​c​o​m​p​o​n​e​n​t​s​/​a​l​e​r​ts/ . En uti­li­sant cette fonc­tion, vous aurez une petite image (icônes) à gauche du nom de l'élément (par exemple un livre pour la lec­ture des don­nées). Il est aus­si pos­sible de l'utiliser pour des bou­tons .

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
[crayon-673f8760394c6645175952  ]ui <- dash­board­Page(
  dash­board­Hea­der(title = "bioin­fo-fr"),
  dash­board­Si­de­bar(
    side­bar­Me­nu(
      menuI­tem("Lec­ture des don­nées", tab­Name = "read­Da­ta", icon = icon("readme")),
      menuI­tem("Visua­li­sa­tion des don­nées", tab­Name = "visua­li­za­tion", icon = icon("poll"))
    )
  ),
  dash­board­Bo­dy(
    tabI­tems(
      # Read data
      tabI­tem(tab­Name = "read­Da­ta",
              h1("Lec­ture des don­nées")
      ),
      
      # visua­li­za­tion
      tabI­tem(tab­Name = "visua­li­za­tion",
              h1("Visua­li­sa­tion des don­nées")
      )
    )
  )
)
[/​crayon]
Visua­li­sa­tion de l'application

Création d’un lecteur de fichier

L’objectif est de pro­po­ser une inter­face simple pour lire un fichier dans l’application et qui per­mette à l’utilisateur de para­mé­trer la lec­ture et d’avoir une pré­vi­sua­li­sa­tion du fichier lu.

Importer un fichier

Pour impor­ter un fichier, shi­ny pro­pose la fonc­tion

1
fileIn­put

. Il est pos­sible de faire du “drag and drop” dans la zone de l’import ou de sélec­tion­ner un fichier dans l’explorateur de fichiers. Le type de fichier visible est para­mé­trable dans les argu­ments. Ici, nous uti­li­se­rons le para­mé­trage par défaut.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
[crayon-673f8760394d0117622612  ]ui <- dash­board­Page(
  dash­board­Hea­der(title = "bioin­fo-fr"),
  dash­board­Si­de­bar(
    side­bar­Me­nu(
      menuI­tem("Lec­ture des don­nées", tab­Name = "read­Da­ta", icon = icon("readme")),
      menuI­tem("Visua­li­sa­tion des don­nées", tab­Name = "visua­li­za­tion", icon = icon("poll"))
    )
  ),
  dash­board­Bo­dy(
    tabI­tems(
      # Read data
      tabI­tem(tab­Name = "read­Da­ta",
              h1("Lec­ture des don­nées"),
              fileIn­put("data­File",label = NULL,
                        but­ton­La­bel = "Browse…",
                        pla­ce­hol­der = "No file selec­ted")
      ),
      
      # visua­li­za­tion
      tabI­tem(tab­Name = "visua­li­za­tion",
              h1("Visua­li­sa­tion des don­nées")
      )
    )
  )
)
[/​crayon]
Visua­li­sa­tion de l’application

Zone de paramétrage

Nous sou­hai­tons main­te­nant para­mé­trer 3 points lors de la lec­ture du fichier : type de sépa­ra­teur (vir­gule, tabu­la­tion, espace), type de quote (simple, double, aucune) et la présence/​absence des noms de colonnes (hea­der). Nous uti­li­sons pour cela des radio bou­tons. La fonc­tion uti­li­sée est

1
radio­But­tons

. 5 argu­ments sont uti­li­sés :

  • id : iden­ti­fiant du groupe de radio bou­tons (ici nous avons 3 groupes de radio bou­tons pour nos 3 para­mètres),
  • label : le titre pré­sent au des­sus du groupe de radio bou­tons,
  • choices : les choix pos­sibles dans le groupe de radio bou­tons. A noter, la zone située à gauche du "=" contient les infor­ma­tions qui seront affi­chées dans l'application alors que la par­tie droite indique ce que com­prend R côté ser­veur. Pour le hea­der par exemple, il sera affi­ché “Yes” côté UI et nous récu­pé­re­rons côté ser­veur
    1
    TRUE
    (“Yes” = TRUE) lorsque que nous récu­pé­re­rons la valeur du radio bou­ton côté ser­veur.
  • Selec­ted : Nom du radio bou­ton sélec­tion­né au lan­ce­ment de l’application
  • inline = T : pour avoir les radio bou­tons ali­gnés
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
[crayon-673f8760394dd203567210  ][…]
tabI­tem(tab­Name = "read­Da­ta",
              h1("Lec­ture des don­nées"),
              fileIn­put("data­File",label = NULL,
                        but­ton­La­bel = "Browse…",
                        pla­ce­hol­der = "No file selec­ted"),
              
              h3("Para­me­ters"),
              
              # Input : Check­box if file has hea­der
              radio­But­tons(id = "hea­der",
                           label = "Hea­der",
                           choices = c("Yes" = TRUE,
                                       "No" = FALSE),
                           selec­ted = TRUE, inline=T),
              
              # Input : Select sepa­ra­tor —-
              radio­But­tons(id = "sep",
                           label = "Sepa­ra­tor",
                           choices = c(Com­ma = ",",
                                       Semi­co­lon = ";",
                                       Tab = "\t"),
                           selec­ted = "\t", inline=T),
              
              # Input : Select quotes —-
              radio­But­tons(id = "quote",
                           label= "Quote",
                           choices = c(None = "",
                                       "Double Quote" = '"',
                                       "Single Quote" = "'"),
                           selec­ted = "", inline=T)
              
      ),
 
[…]
[/​crayon]
Visua­li­sa­tion de l'application

Zone de prévisualisation

Dans cette zone, nous allons visua­li­ser les pre­mières lignes du fichier que nous sou­hai­tons lire. Il faut donc :

  • Créer une zone d’affichage dans l’UI
  • Lire les don­nées côté ser­veur et envoyer les don­nées dans la zone d’affichage

Côté UI

Pour affi­cher le tableau, nous uti­li­sons la fonc­tion

1
data­Ta­bleOut­put

. Une zone va être créée pour affi­cher un tableau. Nous don­nons à cette zone un iden­ti­fiant en uti­li­sant l’argument

1
out­pu­tId

. Cet iden­ti­fiant est indis­pen­sable pour retrou­ver la zone côté ser­veur.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
[crayon-673f8760394eb897509431  ] tabI­tems(
      # Read data
      tabI­tem(tab­Name = "read­Da­ta",
              h1("Lec­ture des don­nées"),
              fileIn­put("data­File",label = NULL,
                        but­ton­La­bel = "Browse…",
                        pla­ce­hol­der = "No file selec­ted"),
              
              h3("Para­me­ters"),
              
              # Input : Check­box if file has hea­der
              radio­But­tons(inpu­tId = "hea­der",
                           label = "Hea­der",
                           choices = c("Yes" = TRUE,
                                       "No" = FALSE),
                           selec­ted = TRUE, inline=T),
              
              # Input : Select sepa­ra­tor —-
              radio­But­tons(inpu­tId = "sep",
                           label = "Sepa­ra­tor",
                           choices = c(Com­ma = ",",
                                       Semi­co­lon = ";",
                                       Tab = "t"),
                           selec­ted = "t", inline=T),
              
              # Input : Select quotes —-
              radio­But­tons(inpu­tId = "quote",
                           label= "Quote",
                           choices = c(None = "",
                                       "Double Quote" = '"',
                                       "Single Quote" = "'"),
                           selec­ted = "", inline=T),
              h3("File pre­view"),
              data­Ta­bleOut­put(out­pu­tId = "pre­view")
              
      ),
[/​crayon]

Côté Ser­ver

Nous sou­hai­tons à pré­sent affi­cher de l’information. Du côté ser­veur, pour envoyer de l’information, la syn­taxe com­mence qua­si­ment tou­jours par

1
out­put$

puis l’ID de la zone de sor­tie (ici notre tableau de pré­vi­sua­li­sa­tion avec l’id "pre­view"). Ce que nous sou­hai­tons lui envoyer est un tableau. Nous uti­li­sons donc la fonc­tion

1
&lt ;- ren­der­Da­ta­Table({ })

. Dans cette der­nière fonc­tion, nous allons lire le tableau qui va être ren­voyé. Pour récu­pé­rer de l’information du côté UI, il faut uti­li­ser la syn­taxe sui­vante :

1
input$ID

. Par exemple, nous sou­hai­tons récu­pé­rer le choix de l'utilisateur concer­nant le hea­der :

1
input$hea­der

.

1
2
3
4
5
6
7
8
9
10
11
[crayon-673f8760394ff421147867  ]out­put$pre­view <-  ren­der­Da­ta­Table({
    
    req(input$data­File)
    
    df <- read.csv(input$data­File$data­path,
                   hea­der = as.logi­cal(input$hea­der),
                   sep = input$sep,
                   quote = input$quote,
                   nrows=10
    )
  },  options = list(scrollX = TRUE , dom = 't'))
[/​crayon]

Si nous détaillons le code :

  • req(input$dataFile) : bloque la suite du code si la zone d’import de fichier est vide
  • df <- read.csv() : on stocke dans df la lec­ture du fichier
  • input$dataFile$datapath : che­min d’accès au fichier impor­té
  • hea­der = as.logical(input$header) : récu­pé­ra­tion de la réponse de l’utilisateur pour savoir si pré­sence ou absence d’un hea­der. Le as.logical per­met de conver­tir un TRUE ou FALSE en boo­léen.
  • sep = input$sep, quote = input$quote : récu­pé­ra­tion du para­mé­trage de l’utilisateur pour le sépa­ra­teur et les quotes. Ces infor­ma­tions sont don­nées aux argu­ments de la fonc­tion read.csv()
  • nrows=10 : Nous ne sou­hai­tons pas lire tout le fichier. Seules les pre­mières lignes sont néces­saires pour savoir si le tableau est lu cor­rec­te­ment ou non. Nous lisons donc les 10 pre­mières lignes.
  • options = list(scrollX = TRUE , dom = 't') : Si le tableau a de nom­breuses colonnes, cette option per­met d’avoir un scroll hori­zon­tal

Vous pou­vez main­te­nant tes­ter sur un fichier texte conte­nant un tableau. Le chan­ge­ment de para­mé­trage a un effet direct sur la visua­li­sa­tion.

Visua­li­sa­tion de l'application

Organisation des éléments

Pour les connais­seurs de boots­trap, Shi­ny intègre son code. Pour les autres, il est pos­sible d’organiser le conte­nu d’une page à l’aide d’une grille. La grille est com­po­sée de lignes (

1
flui­dRow()

) elles-mêmes com­po­sées de 12 blocs. Nous allons pla­cer les para­mètres et la pré­vi­sua­li­sa­tion sur une même ligne. Nous sou­hai­tons sto­cker les para­mètres dans  3 blocs (

1
column(3,...)

: la colonne aura une taille de 3 blocs) et 9 blocs pour la pré­vi­sua­li­sa­tion (

1
column(9,...)

).

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
[crayon-673f876039511813084007  ]tabI­tem(tab­Name = "read­Da­ta",
              h1("Lec­ture des don­nées"),
              fileIn­put("data­File",label = NULL,
                        but­ton­La­bel = "Browse…",
                        pla­ce­hol­der = "No file selec­ted"),
              
              flui­dRow(
                column(3,
                       h3("Para­me­ters"),
                      
                       # Input : Check­box if file has hea­der
                       radio­But­tons(inpu­tId = "hea­der",
                                    label = "Hea­der",
                                    choices = c("Yes" = TRUE,
                                                "No" = FALSE),
                                    selec­ted = TRUE, inline=T),
                      
                       # Input : Select sepa­ra­tor —-
                       radio­But­tons(inpu­tId = "sep",
                                    label = "Sepa­ra­tor",
                                    choices = c(Com­ma = ",",
                                                Semi­co­lon = ";",
                                                Tab = "t"),
                                    selec­ted = "t", inline=T),
                      
                       # Input : Select quotes —-
                       radio­But­tons(inpu­tId = "quote",
                                    label= "Quote",
                                    choices = c(None = "",
                                                "Double Quote" = '"',
                                                "Single Quote" = "'"),
                                    selec­ted = "", inline=T)
                ),
                column(9,
                       h3("File pre­view"),
                       data­Ta­bleOut­put(out­pu­tId = "pre­view")
                )
              )
[/​crayon]
Visua­li­sa­tion de l'application

Bouton de lecture

Pour finir avec cette page, nous allons créer un bou­ton pour vali­der le para­mé­trage de la lec­ture du tableau. En cli­quant sur ce bou­ton, l’ensemble du fichier sera lu. Nous ne réa­li­sons pas une lec­ture dyna­mique comme pré­cé­dem­ment. En effet,  à chaque chan­ge­ment de para­mètre, l’ensemble du fichier est relu. Si le fichier est gros, le temps de lec­ture sera long.

Côté UI

Nous ajou­tons un

1
action­But­ton

. L’identifiant de notre bou­ton est "actBtn­Vi­sua­li­sa­tion".

1
2
3
[crayon-673f87603951b900802934  ][...]
action­But­ton(inpu­tId = "actBtn­Vi­sua­li­sa­tion", label = "Visua­li­sa­tion",icon = icon("play") )
[...]
[/​crayon]

Pour une ques­tion esthé­tique, nous ajou­tons un saut de ligne avant le bou­ton et nous met­tons le bou­ton dans une divi­sion pour pou­voir le cen­trer :

1
2
3
4
[crayon-673f876039522158861536  ][...]
tags$br(),
div(action­But­ton(inpu­tId = "actBtn­Vi­sua­li­sa­tion", label = "Visua­li­sa­tion",icon = icon("play") ), ali­gn = "cen­ter")
[...]
[/​crayon]

Côté ser­veur

Lorsque que le bou­ton est cli­qué, nous sou­hai­tons à pré­sent que le conte­nu du fichier soit sto­cké dans une variable. Il s’agit d’une variable par­ti­cu­lière. Elle doit être visible par toutes les fonc­tions côté ser­veur et relan­cer toutes les fonc­tions qui l’utilisent si elle change. Il s’agit d’une variable réac­tive (

1
reac­ti­ve­Va­lues

). Si nous détaillons le code :

  • Nous décla­rons une reac­ti­ve­Va­lue avec comme nom
    1
    data
    .
  • Nous allons uti­li­ser une fonc­tion qui per­met d’attendre une action par­ti­cu­lière. Ici nous atten­dons que l’utilisateur clique sur le bou­ton. Une fois que le bou­ton a été cli­qué, le code entre les { } sera exé­cu­té. Ici, l’objectif sera de sto­cker le conte­nu du fichier impor­té dans la reac­ti­ve­Va­lue sous le nom
    1
    table
    (data$table)
1
2
3
4
5
6
7
8
9
[crayon-673f876039533173493249  ]data = reac­ti­ve­Va­lues()
 
  obser­veEvent(input$actBtn­Vi­sua­li­sa­tion, {
    data$table = read.csv(input$data­File$data­path,
                          hea­der = as.logi­cal(input$hea­der),
                          sep = input$sep,
                          quote = input$quote,
                          nrows=10)
  })
[/​crayon]

Ain­si, à chaque clic du bou­ton,

1
data$table

sera mis à jour ain­si que toutes les fonc­tions qui l’utilise (ex : des gra­phiques).
Nous pou­vons aus­si ajou­ter un mes­sage pour confir­mer la lec­ture du fichier. Nous uti­li­se­rons

1
send­Swee­tA­lert

pro­po­sé dans le package shi­ny­Wid­gets. La docu­men­ta­tion est dis­po­nible ici : https://​github​.com/​d​r​e​a​m​R​s​/​s​h​i​n​y​W​i​d​g​ets .

1
2
3
4
5
6
7
8
9
10
11
12
13
[crayon-673f876039540901853465  ]obser­veEvent(input$actBtn­Vi­sua­li­sa­tion, {
    data$table = read.csv(input$data­File$data­path,
                          hea­der = as.logi­cal(input$hea­der),
                          sep = input$sep,
                          quote = input$quote,
                          nrows=10)
    send­Swee­tA­lert(
      ses­sion = ses­sion,
      title = "Done !",
      text = "Le fichier a bien été lu !",
      type = "suc­cess"
    )  
  })
[/​crayon]
Visua­li­sa­tion du mes­sage

Chan­ge­ment de page

Enfin, notre appli­ca­tion étant com­po­sée de 2 pages, nous sou­hai­tons chan­ger de page une fois que le fichier est lu pour arri­ver sur la page de visua­li­sa­tion.

1
[crayon-673f87603954b519520394  ]upda­te­Ta­bI­tems(ses­sion, "tabs", selec­ted = "visua­li­za­tion")
[/​crayon]

Pour rap­pel, “tabs” est l’identifiant de notre side­bar­Me­nu. Nous allons avec cette com­mande cher­cher dans la side­bar­Me­nu la page qui a comme iden­ti­fiant “visua­li­za­tion” et chan­ger de page.

Visualisation

Exploration du tableau

Nous allons à pré­sent affi­cher le tableau com­plet. Nous uti­li­sons pour cela le package DT (https://​rstu​dio​.github​.io/​DT/ ). Il per­met de recher­cher, sélec­tion­ner ou trier les infor­ma­tions d'un tableau de don­nées. Il faut pour cela créer une zone où sera affi­ché le tableau dans l’UI.

Côté UI

1
2
3
4
5
[crayon-673f876039552135581906  ]tabI­tem(tab­Name = "visua­li­za­tion",
              h1("Visua­li­sa­tion des don­nées"),
              h2("Explo­ra­tion du tableau"),
              data­Ta­bleOut­put('data­Table')
      )
[/​crayon]

Puis du côté ser­veur, il ne reste plus qu’à envoyer le conte­nu de notre fichier dans ce tableau par le biais de la

1
reac­ti­ve­Va­lue

. Ain­si, le tableau sera auto­ma­ti­que­ment mis à jour si un nou­veau fichier est lu.

1
[crayon-673f87603955c678082937  ]out­put$data­Table = DT::ren­der­Da­ta­Table(data$table)
[/​crayon]
Visua­li­sa­tion de l'application

Il est pos­sible de faire de la mise en forme condi­tion­nelle comme dans excel. Le code pro­po­sé par la suite est dépen­dant du tableau uti­li­sé. En effet, nous allons cibler les colonnes d’intérêt par leur nom pour une ques­tion de lisi­bi­li­té.

Voi­ci une pro­po­si­tion de mise en forme condi­tion­nelle de notre tableau (ins­pi­ré de l’exemple pro­po­sé dans la docu­men­ta­tion du package DT).

  • His­to­gramme des valeurs pour les colonnes Sepal.length et Petal.length
  • Colo­ra­tion par seuils mul­tiples pour les colonnes Sepal.width et Petal.width (fond blanc écri­ture noire, fond rouge écri­ture blanche et fond rouge fon­cé écri­ture blanche)
  • Colo­ra­tion du fond en fonc­tion de l’espèce pour la colonne espèce.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
[crayon-673f876039563743757926  ]
out­put$data­Table = DT::ren­der­Da­ta­Table({
    data­table(data$table, fil­ter = 'top') %>%
      for­mat­Style('Sepal.Length',
                  back­ground = sty­le­Co­lor­Bar(data$table$Sepal.Length, 'light­co­ral'),
                  back­ground­Size = '100% 90%',
                  back­groun­dRe­peat = 'no-repeat',
                  back­ground­Po­si­tion = 'cen­ter'
      ) %>%
      for­mat­Style(
        'Sepal.Width',
        back­ground­Co­lor = sty­leIn­ter­val(c(3,4), c('white', 'red', "fire­brick")),
        color = sty­leIn­ter­val(c(3,4), c('black', 'white', "white"))
      ) %>%
      for­mat­Style(
        'Petal.Length',
        back­ground = sty­le­Co­lor­Bar(data$table$Petal.Length, 'light­co­ral'),
        back­ground­Size = '100% 90%',
        back­groun­dRe­peat = 'no-repeat',
        back­ground­Po­si­tion = 'cen­ter'
      ) %>%
      for­mat­Style(
        'Petal.Width',
        back­ground­Co­lor = sty­leIn­ter­val(c(1,2), c('white', 'red', "fire­brick")),
        color = sty­leIn­ter­val(c(1,2), c('black', 'white', "white"))
      ) %>%
      for­mat­Style(
        'Spe­cies',
        back­ground­Co­lor = sty­leE­qual(
          unique(data$table$Spe­cies), c('light­blue', 'light­green', 'laven­der')
        )
      )
  })
[/​crayon]
Visua­li­sa­tion de l'application

Enfin, pour amé­lio­rer l’exploration, il est pos­sible d’ajouter des filtres par colonnes. Pour les valeurs numé­riques, les don­nées sont fil­trées par un sli­der. Pour les colonnes conte­nant du texte, il y a deux pos­si­bi­li­tés :

  • Peu de varia­bi­li­té entre les élé­ments. Par exemple, la colonne Spe­cies ne contient que 3 élé­ments dif­fé­rents : seto­sa, ver­si­co­lor et vir­gi­ni­ca. Dans ce cas, le filtre sera com­po­sé des élé­ments uniques de cette colonne qui seront cli­quables. En les cli­quant, toutes les lignes avec cet élé­ment seront sélec­tion­nées.  
  • Grande varia­bi­li­té entre les élé­ments. Dans ce cas, une zone pour entrer du texte sera pro­po­sée. Le texte sai­si sera recher­ché dans la colonne.
1
2
3
[crayon-673f87603956a024498534  ]out­put$data­Table = DT::ren­der­Da­ta­Table({
    data­table(data$table, fil­ter = 'top') %>%
     [...]
[/​crayon]
Visua­li­sa­tion de l'application

Visualisation graphique

Nous allons créer de 4 façons dif­fé­rentes des gra­phiques et les affi­cher dans l’application shi­ny :

  • des gra­phiques sta­tiques
    • un plot de base avec R
    • un gra­phique avec ggplot2
  • des gra­phiques dyna­miques
    • Avec plot­ly
    • Avec google

Les gra­phiques seront repré­sen­tés sur la même ligne avec une flui­dRow et 4 colonnes (comme nous avons fait pré­cé­dem­ment).

Graphique R

R pro­pose une grande palette de gra­phiques de base. Cepen­dant, il s'agit uni­que­ment de gra­phiques sta­tiques.

Côté UI

Il faut comme pré­cé­dem­ment créer une zone pour indi­quer où va être affi­ché le gra­phique. La fonc­tion uti­li­sée est plo­tOut­put.

1
2
3
4
5
6
7
8
9
[crayon-673f876039571520694025  ]tabI­tem(tab­Name = "visua­li­za­tion",
              h1("Visua­li­sa­tion des don­nées"),
              h2("Explo­ra­tion du tableau"),
              data­Ta­bleOut­put('data­Table'),
              h2("Gra­phiques"),
             flui­dRow(
                column(3,plo­tOut­put("plo­tA­ve­cR") )
              )
      )
[/​crayon]

Côté ser­veur

Nous allons pour ce gra­phique com­pa­rer la cor­ré­la­tion entre la taille des sépales et des pétales. Comme pour le tableau, la syn­taxe est la sui­vante pour envoyer de l’information du côté UI :

1
out­put$ID_​de_​la_​zone

. Pour envoyer un plot, nous uti­li­sons la fonc­tion ren­der­Plot. Dans cette fonc­tion, vous pou­vez mettre n’importe quel gra­phique de R. Afin de mettre à jour auto­ma­ti­que­ment les gra­phiques, nous uti­li­sons notre reac­ti­ve­Va­lue :

1
data

. Chaque fois que

1
data

chan­ge­ra, le plot sera géné­ré de nou­veau. Pour accé­der au conte­nu du fichier lu qui est sto­cké dans la reac­ti­ve­Va­lue

1
data

sous le nom de

1
table

, nous uti­li­sons de nou­veau la syn­taxe sui­vante :

1
data$table

. Il s’agit d’un data­frame (la lec­ture par read.csv2 ren­voie un data­frame). Les colonnes sont donc acces­sibles par un $ puis le nom. Au final, pour obte­nir le vec­teur conte­nant les valeurs de lon­gueur des pétales, nous uti­li­se­rons la syn­taxe sui­vante :

1
data$table$Petal.Length

.

1
2
3
4
5
6
[crayon-673f876039591016832898  ]out­put$plo­tA­ve­cR <- ren­der­Plot({
    plot(data$table$Petal.Length,data$table$Sepal.Length,
         main = "Sepal length vs Petal length (R)",
         ylab = "Sepal length",
         xlab = "Petal length")
  })
[/​crayon]

Le para­mé­trage du plot est libre et n’est pas contraint par shi­ny.

Visua­li­sa­tion de l'application

Graphique par ggplot2

Ggplot2 est une librai­rie gra­phique de plus en plus uti­li­sée. Elle pro­pose des gra­phiques plus évo­lués que ceux de base dans R. Vous trou­ve­rez une docu­men­ta­tion très bien faite ici : https://​ggplot2​.tidy​verse​.org/. Nous allons com­pa­rer les lar­geurs et les lon­gueurs des sépales. Une colo­ra­tion en fonc­tion de l’espèce est pro­po­sée.

Côté UI

Comme tou­jours, nous allons créer une zone où sera affi­ché le gra­phique. La fonc­tion uti­li­sée est encore

1
plo­tOut­put

.

1
2
3
4
[crayon-673f87603959b884178752  ]flui­dRow(
                column(3,plo­tOut­put("plo­tA­ve­cR")),
                column(3, plo­tOut­put("plotAvecGgplot2"))
              )
[/​crayon]

Côté ser­veur

Nous allons pro­cé­der de la même façon que pré­cé­dem­ment. La dif­fé­rence est liée au conte­nu de la fonc­tion

1
ren­der­Plot

. Nous allons cette fois-ci uti­li­ser les fonc­tions de ggplot2.

1
2
3
4
5
6
[crayon-673f8760395a5322246706  ]out­put$plotAvecGgplot2 <- ren­der­Plot({
    ggplot(data=data$table, aes(x = Sepal.Length, y = Sepal.Width)) +
      geom_​point(aes(color=Spe­cies, shape=Spe­cies)) +
      xlab("Sepal Length") +  ylab("Sepal Width") +
      ggtitle("Sepal Length-Width (ggplot2")
  })
[/​crayon]
Visua­li­sa­tion de l'application

Graphique Plotly

Plot­ly est un package de j’affectionne par­ti­cu­liè­re­ment. Il pro­pose énor­mé­ment d’outils pré­pro­gram­més (enre­gis­tre­ment de l’image, zoom, infor­ma­tions sup­plé­men­taires). De plus, il n’est pas exclu­si­ve­ment réser­vé à R. Il est pos­sible de l’utiliser aus­si dans des pro­jets en JS et en python (aus­si simple d’utilisation).

Côté UI

De nou­veau, nous allons créer une zone pour affi­cher le gra­phique. Atten­tion, nous chan­geons de fonc­tion. Nous uti­li­se­rons cette fois plot­lyOut­put.

1
2
3
4
5
[crayon-673f8760395c5482593604  ]flui­dRow(
                column(3, plo­tOut­put("plo­tA­ve­cR")),
                column(3, plo­tOut­put("plotAvecGgplot2")),
                column(3, plot­lyOut­put("plo­tA­vec­Plot­ly"))
              )
[/​crayon]

Côté ser­veur

Je n’expliquerai pas ici la syn­taxe pour réa­li­ser un gra­phique avec Plot­ly. La docu­men­ta­tion sur le site est extrê­me­ment bien faite avec de très nom­breux exemples (https://​plot​.ly/r/). Vous pou­vez mettre n’importe quel gra­phique plot­ly dans la fonc­tion. Ici, nous com­pa­rons la lar­geur et la lon­gueur des pétales.

1
2
3
4
[crayon-673f8760395ce143415682  ]plot_​ly(data = data$table, x = ~ Petal.Length, y = ~ Petal.Width, color = ~ Spe­cies) %>%
        layout(title = 'Petal Length-Width (plot­ly)',
               yaxis = list(title = "Petal width"),
               xaxis = list(title = "Petal length"))
[/​crayon]

Je vous invite lorsque vous lan­ce­rez l’application à sur­vo­ler ce gra­phique. Il y a énor­mé­ment d’informations dis­po­nibles et d’outils d’exploration.

Graphique Google

Pour finir, les gra­phiques de Google sont de plus en plus popu­laires et offrent un plus large choix de repré­sen­ta­tions que Plot­ly (calen­drier, etc.). Ici, nous allons réa­li­ser un his­to­gramme de la lar­geur des pétales.

Côté UI

Nous créons de nou­veau une zone pour affi­cher le gra­phique. La fonc­tion uti­li­sée est htm­lOut­put. Cette fonc­tion est capable d’interpréter du code HTML venant du ser­veur. Si vous sou­hai­tez écrire du HTML direc­te­ment dans la par­tie UI, il vous suf­fit d’utiliser la fonc­tion HTML (ex : HTML(“<h1>Titre 1</h1>”) ) .

1
2
3
4
5
6
[crayon-673f8760395d4645934507  ]flui­dRow(
                column(3, plo­tOut­put("plo­tA­ve­cR")),
                column(3, plo­tOut­put("plotAvecGgplot2")),
                column(3, plot­lyOut­put("plo­tA­vec­Plot­ly")),
                column(3, htm­lOut­put("plo­tA­vec­Google"))
              )
[/​crayon]

Côté ser­veur

Pour les gra­phiques Google, nous uti­li­sons les fonc­tions gra­phiques com­men­çant par gvis et le ren­du est fait avec la fonc­tion

1
ren­derG­vis

. Elles sont détaillées à la page sui­vante https://cran.r‑project.org/web/packages/googleVis/vignettes/googleVis_examples.html .

1
2
3
4
5
6
[crayon-673f8760395e1383762011  ]out­put$plo­tA­vec­Google <- ren­derG­vis({
      gvi­sHis­to­gram(as.data.frame(data$table$Petal.Width),
                    options=list(title ="Petal width (Google)",
                                 height=400)
      )
  })
[/​crayon]

Visua­li­sa­tion de l’application

Visua­li­sa­tion du l'application

Gérer le tableau vide

En lan­çant l’application, si vous vous ren­dez sur la par­tie visua­li­sa­tion, vous trou­ve­rez plein d’erreurs. Ces erreurs sont la cause de l’utilisation d’une

1
reac­ti­ve­Va­lue

. En effet, lorsque rien n’a encore été lu,

1
data$table

est NULL (vide). Or toutes les fonc­tions que nous uti­li­sons ne gèrent pas les NULL. Nous ajou­te­rons pour le tableau et les gra­phiques un peu de code pour lui dire de ren­voyer NULL si le tableau est vide.

1
2
3
4
5
[crayon-673f8760395ee966480424  ]if (!is.null(data$table)) {
    [représen­ta­tion gra­phique ou le tableau]
} else {
    NULL
}
[/​crayon]

Interagir avec les graphique

Nous allons voir deux types d'interactions avec les gra­phiques pour illus­trer la sim­pli­ci­té pour l’utilisateur d'interagir avec les don­nées et les repré­sen­ta­tions :

  • Sélec­tion­ner les don­nées à affi­cher à l’aide du tableau
  • Chan­ger des para­mètres gra­phiques sur le plot de base pro­po­sé par R (le pre­mier gra­phique). Tous ces chan­ge­ments peuvent bien sûr être appli­qués sur tous les gra­phiques.

Sélectionner les données à afficher à l’aide du tableau

Grâce à Shi­ny, il est pos­sible de faire com­mu­ni­quer le tableau avec les gra­phiques. Nous pro­fi­tons pour cela de la puis­sance du package DT qui génère le tableau. Les modi­fi­ca­tions que nous allons réa­li­ser seront uni­que­ment côté ser­veur. L'objectif est de récu­pé­rer les lignes qui sont affi­chées dans le tableau et de n'utiliser que ces lignes dans les gra­phiques. Comme pré­cé­dem­ment, pour récu­pé­rer de l’information dans l’UI, il faut uti­li­ser

1
input$ID_​ZONE

. Nous sou­hai­tons récu­pé­rer de l'information de notre tableau qui a comme iden­ti­fiant

1
data­Table

. Ensuite, nous ajou­tons

1
_​rows_​all

à la fin de l’ID pour obte­nir les lignes. Ain­si, avec

1
input$dataTable_​rows_​all

, nous avons les lignes affi­chées dans le tableau. Il ne reste plus qu’à les sélec­tion­ner dans le vec­teur de don­nées.  Le gra­phique est à pré­sent dyna­mique.

1
2
3
4
5
6
7
8
9
10
11
[crayon-673f876039605456509425  ]out­put$plo­tA­ve­cR <- ren­der­Plot({
    if (!is.null(data$table)) {
      plot(data$table$Petal.Length[input$dataTable_​rows_​all],
           data$table$Sepal.Length[input$dataTable_​rows_​all],
           main = "Sepal length vs Petal length (R)",
           ylab = "Sepal length",
           xlab = "Petal length")
    } else {
      NULL
    }
  })
[/​crayon]

La même démarche est ensuite appli­quée aux autres gra­phiques. Grâce aux filtres du tableau, nous avons ain­si la pos­si­bi­li­té de sélec­tion­ner par les don­nées numé­riques (lon­gueur et lar­geur) et par l’espèce.

Changement de couleur pour le graphique de base R

L’objectif est de vous mon­trer une autre façon d'interagir avec les gra­phiques. En effet, il se peut que vous n’utilisiez pas de tableau dans votre appli­ca­tion. De très nom­breux exemples sont dis­po­nibles en ligne (ici par exemple : https://​shi​ny​.rstu​dio​.com/​g​a​l​l​e​ry/). Nous allons implé­men­ter 4 chan­ge­ments sur ce gra­phique pour vous don­ner des exemples d’utilisation d’inputs :

  • Chan­ge­ment de la cou­leur des points (avec l’utilisation d’un colour picker capable de gérer la trans­pa­rence)
  • Chan­ge­ment du type de point
  • Chan­ge­ment de la taille des points
  • Chan­ge­ment du titre

Côté UI

Pour plus de lisi­bi­li­té lors de l’utilisation, nous avons chan­gé la dis­po­si­tion des gra­phiques pour avoir sur une ligne le gra­phique R avec ses para­mètres et sur une seconde les trois autres gra­phiques. Vous pou­vez ain­si voir la sim­pli­ci­té de la réor­ga­ni­sa­tion d’une page à l’aide du sys­tème de Grid.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
[crayon-673f87603960d595676580  ]tabI­tem(tab­Name = "visua­li­za­tion",
              h1("Visua­li­sa­tion des don­nées"),
              h2("Explo­ra­tion du tableau"),
              data­Ta­bleOut­put('data­Table'),
              h2("Gra­phiques"),
              flui­dRow(
                column(4, plo­tOut­put("plo­tA­ve­cR")),
                column(4, colour­pi­cker::colou­rIn­put("colR", "Cou­leur gra­phique R", "black",allow­Trans­pa­rent = T),
                       sli­de­rIn­put("cex", "Taille",
                                   min = 0.5, max = 3,
                                   value = 1,step = 0.2
                                  )),
                column(4, selec­tIn­put(inpu­tId = "pch", choices = 1 :20, label = "Type de points",selec­ted = 1),
                       tex­tIn­put("title", "Titre", "Sepal length vs Petal length (R)") )
              ),
              tags$br(),
              flui­dRow(
                column(4, plo­tOut­put("plotAvecGgplot2")),
                column(4, plot­lyOut­put("plo­tA­vec­Plot­ly")),
                column(4, htm­lOut­put("plo­tA­vec­Google"))
              )
      )
[/​crayon]

Pour faire entrer de l’information, nous avons besoin de 4 fonc­tions

1
input

:

1
colou­rIn­put

pour la cou­leur (du package colourp­ci­cker),

1
sli­de­rIn­put

pour la taille des points,

1
selec­tIn­put

pour le type de points et

1
tex­tIn­put

pour le titre du gra­phique.

Côté ser­veur

Nous allons récu­pé­rer les entrées et les inté­grer dans notre plot.

1
2
3
4
5
6
7
8
[crayon-673f876039627719855217  ]      plot(data$table$Petal.Length[input$dataTable_​rows_​all],
           data$table$Sepal.Length[input$dataTable_​rows_​all],
           main = input$title,
           ylab = "Sepal length",
           xlab = "Petal length",
           pch = as.nume­ric(input$pch),
           col = input$colR,
           cex = input$cex)
[/​crayon]

Visua­li­sa­tion dans l’application

Visua­li­sa­tion de l'application

Conclusion

Et voi­là ! Vous avez réa­li­sé une appli­ca­tion com­plète capable de lire un fichier en fonc­tion de para­mètres et d'explorer ses don­nées. Vous trou­ve­rez l’ensemble du code sur github ici :
https://​github​.com/​b​i​o​i​n​f​o​-​f​r​/​b​i​o​i​n​f​o​-​f​r​_​S​h​iny . A tra­vers ce post, nous avons vu com­ment rendre inter­ac­tive l’exploration d’un tableau de don­nées à l’aide de Shi­ny. Vos uti­li­sa­teurs n’auront plus à voir votre code. Ils auront sim­ple­ment à appuyer sur Run App. Il existe de nom­breuses solu­tions de par­tage (https://​shi​ny​.rstu​dio​.com/​t​u​t​o​r​i​a​l​/​w​r​i​t​t​e​n​-​t​u​t​o​r​i​a​l​/​l​e​s​s​o​n7/).  De nom­breuses autres pos­si­bi­li­tés sont dis­po­nibles et pour­ront être détaillées dans d’autres articles (conca­té­mé­ri­sa­tion et inté­gra­tion conti­nue d’une appli­ca­tion Shi­ny, par exemple).

Mer­ci à mes relec­teurs Auré­lien C. et Ismaël P. pour leur aide !

Versions des outils utilisés

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
[crayon-673f87603962e155570881  ]
R ver­sion 3.5.1 (2018-07-02)
Plat­form : x86_​64-pc-linux-gnu (64-bit)
Run­ning under : Debian GNU/​Linux 9 (stretch)
 
Matrix pro­ducts : default
BLAS : /​usr/​lib/​open­blas-base/​lib­blas.so.3
LAPACK : /​usr/​lib/​libo­pen­blasp-r0.2.19.so
 
locale :
[1] LC_​CTYPE=en_​US.UTF-8       LC_​NUMERIC=C               LC_​TIME=en_​US.UTF-8        LC_​COLLATE=en_​US.UTF-8     LC_​MONETARY=en_​US.UTF-8    LC_​MESSAGES=C            
[7] LC_​PAPER=en_​US.UTF-8       LC_​NAME=C                  LC_​ADDRESS=C               LC_​TELEPHONE=C             LC_​MEASUREMENT=en_​US.UTF-8 LC_​IDENTIFICATION=C      
 
atta­ched base packages :
[1] paral­lel  stats4    stats     gra­phics  grDe­vices utils     data­sets  methods   base    
 
other atta­ched packages :
[1] bindrcpp_​0.2.2              shinycssloaders_​0.2.0       shinyjs_​1.0                 colourpicker_​1.0            shinyWidgets_​0.4.4          reshape2_​1.4.3            
[7] plotly_​4.8.0                ggplot2_​3.1.0               FactoMineR_​1.41             DT_​0.5                      DESeq2_​1.22.2               SummarizedExperiment_​1.12.0
[13] DelayedArray_​0.8.0          BiocParallel_​1.16.5         matrixStats_​0.54.0          Biobase_​2.42.0              GenomicRanges_​1.34.0        GenomeInfoDb_​1.18.1        
[19] IRanges_​2.16.0              S4Vectors_​0.20.1            BiocGenerics_​0.28.0         shinydashboard_​0.7.1        shiny_​1.2.0                
 
loa­ded via a names­pace (and not atta­ched):
[1] bitops_​1.0-6           bit64_​0.9-7            RColorBrewer_​1.1-2     httr_​1.4.0             tools_​3.5.1            backports_​1.1.3        R6_​2.3.0              
[8] rpart_​4.1-13           Hmisc_​4.1-1            DBI_​1.0.0              lazyeval_​0.2.1         colorspace_​1.3-2       nnet_​7.3-12            withr_​2.1.2          
[15] tidyselect_​0.2.5       gridExtra_​2.3          bit_​1.1-14             compiler_​3.5.1         htmlTable_​1.13.1       flashClust_​1.01-2      scales_​1.0.0          
[22] checkmate_​1.9.0        genefilter_​1.64.0      stringr_​1.3.1          digest_​0.6.18          foreign_​0.8-70         XVector_​0.22.0         base64enc_​0.1-3      
[29] pkgconfig_​2.0.2        htmltools_​0.3.6        htmlwidgets_​1.3        rlang_​0.3.0.1          rstudioapi_​0.8         RSQLite_​2.1.1          bindr_​0.1.1          
[36] jsonlite_​1.6           acepack_​1.4.1          dplyr_​0.7.8            RCurl_​1.95-4.11        magrittr_​1.5           GenomeInfoDbData_​1.2.0 Formula_​1.2-3        
[43] leaps_​3.0              Matrix_​1.2-14          Rcpp_​1.0.0             munsell_​0.5.0          yaml_​2.2.0             scatterplot3d_​0.3-41   stringi_​1.2.4        
[50] MASS_​7.3-50            zlibbioc_​1.28.0        plyr_​1.8.4             grid_​3.5.1             blob_​1.1.1             promises_​1.0.1         crayon_​1.3.4          
[57] miniUI_​0.1.1.1         lattice_​0.20-35        splines_​3.5.1          annotate_​1.60.0        locfit_​1.5-9.1         knitr_​1.21             pillar_​1.3.1          
[64] geneplotter_​1.60.0     XML_​3.98-1.16          glue_​1.3.0             latticeExtra_​0.6-28    data.table_​1.11.8      httpuv_​1.4.5           gtable_​0.2.0          
[71] purrr_​0.2.5            tidyr_​0.8.2            assertthat_​0.2.0       xfun_​0.4               mime_​0.6               xtable_​1.8-3           later_​0.7.5          
[78] viridisLite_​0.3.0      survival_​2.42-3        tibble_​1.4.2           AnnotationDbi_​1.44.0   memoise_​1.1.0          cluster_​2.0.7-1
[/​crayon]

Bibliographie

[1]Wins­ton Chang, Joe Cheng, JJ Allaire, Yihui Xie and Jona­than McPher­son (2018). shi­ny : Web Appli­ca­tion Fra­me­work for R. R package ver­sion 1.2.0.https://CRAN.R‑project.org/package=shiny
[2]Wins­ton Chang and Bar­ba­ra Borges Ribei­ro (2018). shi­ny­da­sh­board : Create Dash­boards with 'Shi­ny'. R package ver­sion 0.7.1. https://CRAN.R‑project.org/package=shinydashboard
[3]Vic­tor Per­rier, Fan­ny Meyer and David Gran­jon (2018). shi­ny­Wid­gets : Cus­tom Inputs Wid­gets for Shi­ny. R package ver­sion 0.4.4. https://CRAN.R‑project.org/package=shinyWidgets
[4]Yihui Xie, Joe Cheng and Xia­nying Tan (2018). DT : A Wrap­per of the JavaS­cript Libra­ry 'Data­Tables'. R package ver­sion 0.5. https://CRAN.R‑project.org/package=DT
[5]Car­son Sie­vert (2018) plot­ly for R. https://​plot​ly​-book​.cpsie​vert​.me
[6]H. Wick­ham. ggplot2 : Ele­gant Gra­phics for Data Ana­ly­sis. Sprin­ger-Ver­lag New York, 2016.
[7]Mar­kus Ges­mann and Die­go de Cas­tillo. Using the Google Visua­li­sa­tion API with R. The R Jour­nal, 3(2):40–44, Decem­ber 2011.
[8]Dean Atta­li (2017). colour­pi­cker : A Colour Picker Tool for Shi­ny and for Selec­ting Colours in Plots. R package ver­sion 1.0. https://CRAN.R‑project.org/package=colourpicker
[9]Aure­lien Cha­tei­gner (2018). any­Lib : Ins­tall and Load Any Package from CRAN, Bio­con­duc­tor or Github. R package ver­sion 1.0.5.
https://CRAN.R‑project.org/package=anyLib

Vous avez aimé ? Dites-le nous !

Moyenne : 5 /​ 5. Nb de votes : 1

Pas encore de vote pour cet article.

Partagez cet article

Thomas Denecker

Thomas Denecker

Pour continuer la lecture :

Commentaires

5 réponses à “Rendre ses projets R plus accessibles grâce à Shiny”

  1. Avatar de Magali Michaut (@michautbioinfo)
    Magali Michaut (@michautbioinfo)

    Super article ! Mer­ci Tho­mas.

    Répondre
  2. Avatar de Malo Bonfils
    Malo Bonfils

    Bon­jour,
    je me sers de votre code pour me for­mer sur Rshi­ny, il est très com­plet. Petit pro­blème, quand je rentre mon fichier en lec­ture et que je sou­haite le vali­der pour l'afficher sur la page sui­vante, le bou­ton visua­li­sa­tion ne me per­met pas de le faire, et R stu­dio ne me met aucune erreur spé­ci­fique par rap­port à cela. Je me demande si vous avez déja ren­con­tré ça ?

    Répondre
    1. Avatar de Thomas Denecker
      Thomas Denecker

      Bon­jour,
      Je vous remer­cie pour votre retour et je vous prie de m'excuser pour le délai de réponse lié aux fêtes de fin d'année.

      Concer­nant votre pro­blème, serait-il pos­sible d'avoir plus de détails ?
      Il peut y avoir plu­sieurs expli­ca­tions pos­sibles :
      — La taille du fichier. Shi­ny a un para­mé­trage par défaut pour ne pas lire des fichiers trop gros. Il est pos­sible d'ajouter cette com­mande au début du code

      options(shiny.maxRequestSize = 1000*1024^2)

      . Elle per­met de pas­ser la taille des fichiers acceptés/​importés à 1Go.
      — Le temps. Shi­ny ne tra­vaille pas plus vite de R /​ Rstu­dio. Si la lec­ture du fichier est longue sans shi­ny, elle le sera avec shi­ny.
      — Un pro­blème de lec­ture du fichier. Il fau­drait tes­ter de voir si la lec­ture est cor­rec­te­ment para­mé­trée.

      Un bon moyen de savoir s'il y a un bug dans une appli­ca­tion shi­ny est le pas­sage de la fenêtre en gris et l'apparition d'un ban­deau pro­po­sant de rechar­ger le ser­veur. Si c'est le cas, il faut explo­rer la console Rstu­dio si l'application a été lan­cé avec Rstu­dio ou les fichiers log.

      Répondre
  3. Avatar de MAEL
    MAEL

    Bon­jour Tho­mas,
    Mer­ci de votre tuto­riel.
    Hyper com­plet, pas-à-pas et très didac­tique.
    Thumb up 🙂
    Encore mer­ci.

    Répondre
  4. Avatar de Marc Scho
    Marc Scho

    Bon­jour,

    Je ne par­viens pas à affi­cher la seconde page , j'ai une erreur dans send­Swee­tA­lert, "object 'ses­sion' not found.

    Répondre

Laisser un commentaire

Pour insérer du code dans vos commentaires, utilisez les balises <code> et <\code>.