Blog on ArData

Les nouveautés de flextable 0.9.11

info@ardata.fr (ArData) — Tue, 17 Feb 2026 00:00:00 +0000

La version 0.9.11 de flextable est arrivée récemment sur le CRAN. Elle contient deux fonctionnalités que nous sommes ravis de vous présenter :

l’intégration avec patchwork : aligner un tableau et un graphique était jusqu’ici un exercice laborieux. C’est désormais aussi simple que d’écrire wrap_flextable(ft) + mon_graphique.
le support natif de Quarto avec as_qmd() : il est désormais possible d’utiliser les références croisées, les captions et le markdown directement dans les cellules.

Intégration avec patchwork

Combiner et aligner un tableau et un graphique est devenu possible grâce à ‘patchwork’ qui offre un système sur lequel s’appuyer. C’est bien sûr ce dernier que s’appuie la nouvelle fonction wrap_flextable() qui va permettre que les objets flextable s’intègrent dans les compositions patchwork via les opérateurs +, | et /.

Les options sont détaillées dans la section Plotting flextable du “flextable-book”.

Pour illustrer, nous construisons un graphique “dumbbell” des statistiques de la Bundesliga accompagné d’un flextable (adapté de R Graph Gallery).

dataset <- data.frame(
  team = c(
    "FC Bayern Munchen", "SV Werder Bremen", "Borussia Dortmund",
    "VfB Stuttgart", "Borussia M'gladbach", "Hamburger SV",
    "Eintracht Frankfurt", "FC Schalke 04", "1. FC Koln",
    "Bayer 04 Leverkusen"
  ),
  matches = c(2000, 1992, 1924, 1924, 1898, 1866, 1856, 1832, 1754, 1524),
  won     = c(1206,  818,  881,  782,  763,  746,  683,  700,  674,  669),
  lost    = c( 363,  676,  563,  673,  636,  625,  693,  669,  628,  447)
)
dataset$win_pct  <- dataset$won  / dataset$matches * 100
dataset$loss_pct <- dataset$lost / dataset$matches * 100
dataset$team <- factor(dataset$team, levels = rev(dataset$team))

Le graphique “dumbbell” :

pal <- c(lost = "#EFAC00", won = "#28A87D")
df_long <- reshape(dataset, direction = "long",
  varying = list(c("loss_pct", "win_pct")),
  v.names = "pct", timevar = "type",
  times = c("lost", "won"), idvar = "team"
)

p <- ggplot(df_long, aes(x = pct / 100, y = team)) +
  stat_summary(
    geom = "linerange", fun.min = "min", fun.max = "max",
    linewidth = .7, color = "grey60"
  ) +
  geom_point(aes(fill = type), size = 4, shape = 21,
    stroke = .8, color = "white"
  ) +
  scale_x_continuous(
    labels = scales::percent,
    expand = expansion(add = c(.02, .02))
  ) +
  scale_y_discrete(name = NULL, guide = "none") +
  scale_fill_manual(
    values = pal,
    guide = FALSE
  ) +
  labs(x = NULL, fill = NULL) +
  theme(
    legend.position = "top",
    legend.justification = "left",
    panel.grid.minor = element_blank(),
    panel.grid.major.y = element_blank()
  )
p

Et le flextable correspondant :

ft_dat <- dataset[, c("matches", "loss_pct", "win_pct", "team")]
ft_dat$team <- as.character(ft_dat$team)

ft <- flextable(ft_dat) |>
  border_remove() |>
  bold(part = "header") |> 
  colformat_double(j = c("win_pct", "loss_pct"), digits = 1, suffix = "%") |>
  set_header_labels(team = "Equipe", matches = "MJ", win_pct = "Gagnés", loss_pct = "Perdus") |>
  color(color = c("#28A87D", "#EFAC00"), j = c("win_pct", "loss_pct")) |>
  italic(j = "team", italic = TRUE, part = "all") |>
  align(align = "right", part = "all") |>
  autofit()

ft

MJ	Perdus	Gagnés	Equipe
2,000	18.1%	60.3%	FC Bayern Munchen
1,992	33.9%	41.1%	SV Werder Bremen
1,924	29.3%	45.8%	Borussia Dortmund
1,924	35.0%	40.6%	VfB Stuttgart
1,898	33.5%	40.2%	Borussia M'gladbach
1,866	33.5%	40.0%	Hamburger SV
1,856	37.3%	36.8%	Eintracht Frankfurt
1,832	36.5%	38.2%	FC Schalke 04
1,754	35.8%	38.4%	1. FC Koln
1,524	29.3%	43.9%	Bayer 04 Leverkusen

Aligner les lignes avec `flex_body`

Quand flex_body = TRUE, les lignes du corps du tableau s’étirent pour correspondre à la hauteur du panneau du graphique adjacent. Chaque ligne du tableau s’aligne avec la catégorie correspondante sur l’axe y. L’en-tête et le pied de page conservent leur taille fixe.

wrap_flextable(ft, flex_body = TRUE, just = "right") +
  p +
  plot_layout(widths = c(1.3, 2))

Les lignes du tableau sont parfaitement alignées avec les catégories du graphique, tableau et graphique ne font plus qu’un et le monde paraît magique.

Aligner les colonnes avec `flex_cols`

Quand flex_cols = TRUE, les colonnes de données s’étirent pour remplir la largeur du panneau déterminée par le graphique adjacent. Chaque colonne s’aligne avec la catégorie correspondante sur l’axe x.

cyl_mpg <- mtcars |> 
  mutate(
    cyl = factor(cyl, levels = c(4, 6, 8), labels = c("4-cyl", "6-cyl", "8-cyl"))
  ) |> 
  summarise(
    `mpg mean` = mean(mpg, na.rm = TRUE),
    `mpg sd` = sd(mpg, na.rm = TRUE),
    n = n(),
    .by = c(cyl)
  )

gg_bar <- ggplot(cyl_mpg, aes(cyl, `mpg mean`)) +
  geom_col(fill = "#28A87D", width = 0.7) +
  labs(x = "Cylindres", y = "MPG moyen") +
  theme(axis.text.x = element_blank())
  

cyl_pivoted <- cyl_mpg |> 
  pivot_longer(
    cols = where(is.numeric)
  ) |> 
  pivot_wider(
    id_cols = name,
    names_from = cyl, values_from = value,
    names_sort = TRUE
  )
cyl_pivoted

#> # A tibble: 3 × 4
#>   name     `4-cyl` `6-cyl` `8-cyl`
#>   <chr>      <dbl>   <dbl>   <dbl>
#> 1 mpg mean   26.7    19.7    15.1 
#> 2 mpg sd      4.51    1.45    2.56
#> 3 n          11       7      14

set_flextable_defaults(border.color = "#28A87D")
ft_cyl <- flextable(cyl_pivoted) |>
  set_header_labels(name = "") |> 
  align(align = "center", part = "all") |>
  align(align = "right", j = 1, part = "all") |>
  colformat_double(i = 1:2, digits = 2) |> 
  colformat_double(i = 3, digits = 0) |> 
  autofit()
ft_cyl

	4-cyl	6-cyl	8-cyl
mpg mean	26.66	19.74	15.10
mpg sd	4.51	1.45	2.56
n	11	7	14

wrap_flextable(ft_cyl, n_row_headers = 1, flex_cols = TRUE) /
  gg_bar +
  plot_layout(heights = c(1, 4))

Ici, chaque colonne du tableau correspond exactement à une barre du graphique, l’ensemble se lit comme une seule visualisation.

Quarto markdown dans les cellules

‘flextable’ ne permettait pas jusqu’alors l’utilisation du markdown dans les cellules, avec comme conséquences que les cross-références, formules mathématiques, liens n’étaient pas supportés au sein d’un document quarto. La nouvelle fonction as_qmd() comble ce manque.

as_qmd() fonctionne avec les sorties HTML, PDF et Word.

Pour l’utiliser dans un projet Quarto, il faut d’abord installer le filtre Lua compagnon avec use_flextable_qmd(), puis déclarer le filtre dans le YAML du document :

filters:
  - flextable-qmd
  - at: post-render
    path: _extensions/flextable-qmd/unwrap-float.lua

Voici un exemple de document Quarto qui utilise as_qmd() pour des cross-références et du formatage markdown dans les cellules :

---
title: "Exemple flextable-qmd"
format: docx
filters:
  - flextable-qmd
  - at: post-render
    path: _extensions/flextable-qmd/unwrap-float.lua
---

Voir le @tbl-example pour un apercu.

```{r}
#| label: tbl-example
#| tbl-cap: Tableau avec du markdown Quarto dans les cellules
library(flextable)

dat <- data.frame(
  Fonctionnalite = c("Cross-ref", "Gras", "Maths", "Lien"),
  Demo = c(
    "Voir @tbl-example",
    "**texte important**",
    "$E = mc^2$",
    "[ardata.fr](https://www.ardata.fr)"
  ),
  stringsAsFactors = FALSE
)

flextable(dat) |>
  mk_par(j = "Demo",
    value = as_paragraph(as_qmd(Demo))) |>
  autofit() |>
  theme_vanilla()
```

Le résultat dans un document Word :

Le fichier produit est téléchargeable ici : quarto-as-qmd-fr.docx

N’hésitez pas à essayer ces nouvelles fonctionnalités.

Pour la liste complète des changements, consultez le changelog.

flextable et tabular

info@ardata.fr (ArData) — Fri, 07 Apr 2023 00:00:00 +0000

Le package ‘flextable’ (Gohel and Skintzos 2023) fourni une fonction as_flextable() qui permet de transformer les tableaux créés avec le package ‘tables’ (Murdoch 2023) en flextable.

La fonction tables::tabular() est un outil puissant qui permet aux utilisateurs de créer facilement des tableaux croisés simples et complexes. La fonction as_flextable() est simple à utiliser, elle transforme les objets ‘tables’ en objets ‘flextable’ et vous permet d’enrichir le tableau avec des informations et/ou du formatage.

Le package ‘tables’ est décrit par son auteur comme suivant :

The tables package provides a formula-driven interface for computing the contents of tables and formatting them. It was inspired by SAS PROC TABULATE, but is not compatible with it.

The user computes a table object by specifying a formula, with the left-hand side giving the rows, and the right-hand side giving the columns; the formula describes the summary functions to apply and how to organize them. […]

La combinaison de ces deux packages offre la possibilité de créer très facilement des tableaux croisés, de les empiler ou de les filtrer, puis de les formater avec “flextable” et de bénéficier de toute une série de fonctionnalités de formatage ainsi que de la possibilité de les exporter dans les formats de sortie pris en charge par “flextable”.

Exemple avec tabular

Créons un tableau croisée d’agrégations basée sur le jeu de données penguins fourni par le package ‘palmerpenguins’ (Horst, Hill, and Gorman 2022) :

library(tables)
library(palmerpenguins)

Mean <- function(x) mean(x, na.rm = TRUE)

Sd <- function(x) sd(x, na.rm = TRUE)

tab <- tabular(
  table = (species + 1) * island ~ 
    (n = 1) + Format(digits = 2) * 
      (bill_depth_mm + body_mass_g) * (Mean + Sd), 
  data = penguins)
print(tab)

#>                                                                   
#>                          bill_depth_mm         body_mass_g        
#>  species   island    n   Mean          Sd      Mean        Sd     
#>  Adelie    Biscoe     44   18.37          1.19 3709.66      487.73
#>            Dream      56   18.25          1.13 3688.39      455.15
#>            Torgersen  52   18.43          1.34 3706.37      445.11
#>  Chinstrap Biscoe      0     NaN            NA     NaN          NA
#>            Dream      68   18.42          1.14 3733.09      384.34
#>            Torgersen   0     NaN            NA     NaN          NA
#>  Gentoo    Biscoe    124   14.98          0.98 5076.02      504.12
#>            Dream       0     NaN            NA     NaN          NA
#>            Torgersen   0     NaN            NA     NaN          NA
#>  All       Biscoe    168   15.87          1.82 4716.02      782.86
#>            Dream     124   18.34          1.13 3712.90      416.64
#>            Torgersen  52   18.43          1.34 3706.37      445.11

Transformation en flextable

Un appel simple à as_flextable() produit un flextable assez similaire aux sorties de la fonction tabular() :

as_flextable(tab)

species	island		bill_depth_mm	body_mass_g
n	Mean	Sd	Mean	Sd
Adelie	Biscoe	44	18.37	1.19	3709.66	487.73
Dream	56	18.25	1.13	3688.39	455.15
Torgersen	52	18.43	1.34	3706.37	445.11
Chinstrap	Biscoe	0	NaN	NA	NaN	NA
Dream	68	18.42	1.14	3733.09	384.34
Torgersen	0	NaN	NA	NaN	NA
Gentoo	Biscoe	124	14.98	0.98	5076.02	504.12
Dream	0	NaN	NA	NaN	NA
Torgersen	0	NaN	NA	NaN	NA
All	Biscoe	168	15.87	1.82	4716.02	782.86
Dream	124	18.34	1.13	3712.90	416.64
Torgersen	52	18.43	1.34	3706.37	445.11

Il utilise les paramètres par défaut de flextable dans la mesure du possible, il est recommandé de les définir une fois par session.

set_flextable_defaults(
    font.family = "Open Sans", 
    font.color = "#333333",
    digits = 2,
    big.mark = "'", 
    na_str = "", nan_str = "",
    theme_fun = theme_booktabs)

‘tables’ propose de nombreuses options permettant de formater les tableaux. La transformation flextable préserve les types de colonnes, il est plus facile de post formater le tableau avec la syntaxe de flextable si c’est nécessaire :

as_flextable(tab) |> 
  colformat_double() |>
  theme_vanilla()

species	island		bill_depth_mm	body_mass_g
n	Mean	Sd	Mean	Sd
Adelie	Biscoe	44	18.37	1.19	3'709.66	487.73
Dream	56	18.25	1.13	3'688.39	455.15
Torgersen	52	18.43	1.34	3'706.37	445.11
Chinstrap	Biscoe	0
Dream	68	18.42	1.14	3'733.09	384.34
Torgersen	0
Gentoo	Biscoe	124	14.98	0.98	5'076.02	504.12
Dream	0
Torgersen	0
All	Biscoe	168	15.87	1.82	4'716.02	782.86
Dream	124	18.34	1.13	3'712.90	416.64
Torgersen	52	18.43	1.34	3'706.37	445.11

Le séparateur de lignes

Les séparateurs de groupes peuvent être définis comme des lignes au lieu d’une première colonne afin de réduire la largeur du tableau :

as_flextable(tab, spread_first_col = TRUE) |> 
  colformat_double()

island		bill_depth_mm	body_mass_g
n	Mean	Sd	Mean	Sd
Adelie
Biscoe	44	18.37	1.19	3'709.66	487.73
Dream	56	18.25	1.13	3'688.39	455.15
Torgersen	52	18.43	1.34	3'706.37	445.11
Chinstrap
Biscoe	0
Dream	68	18.42	1.14	3'733.09	384.34
Torgersen	0
Gentoo
Biscoe	124	14.98	0.98	5'076.02	504.12
Dream	0
Torgersen	0
All
Biscoe	168	15.87	1.82	4'716.02	782.86
Dream	124	18.34	1.13	3'712.90	416.64
Torgersen	52	18.43	1.34	3'706.37	445.11

Améliorer avec flextable

Ajoutons maintenant d’autres personnalisations pour illustrer quelques fonctionnalités de flextable qui s’utilisent facilement à tabular() :

formatage du titre de la ligne avec as_paragraph(),
tabulation du contenu avec prepend_chunks(as_chunk("\t")),
remplacement des labels avec labelizor().

ft <- as_flextable(tab, spread_first_col = TRUE,
    row_title = as_paragraph(
      colorize("species: ", color = "#8f2218"),
      colorize(as_b(.row_title), color = "#8f2218")
    )) |> 
  colformat_double() |>
  align(j = 1, align = "left") |>
  prepend_chunks(i = ~ .is_row_title %in% FALSE, j = 1, as_chunk("\t")) |>
  labelizor(part = "header", labels = c(bill_depth_mm = "bill length\n(millimeters)", 
    body_mass_g = "body mass\n(grams)", island = "Island\nin Palmer\nArchipelago",
    n = "Number\nof\npenguins")) |>
  labelizor(part = "body", labels = stringr::str_to_title) |>
  autofit()
ft

Island in Palmer Archipelago		bill length (millimeters)	body mass (grams)
Number of penguins	Mean	Sd	Mean	Sd
Species: Adelie
Biscoe	44	18.37	1.19	3'709.66	487.73
Dream	56	18.25	1.13	3'688.39	455.15
Torgersen	52	18.43	1.34	3'706.37	445.11
Species: Chinstrap
Biscoe	0
Dream	68	18.42	1.14	3'733.09	384.34
Torgersen	0
Species: Gentoo
Biscoe	124	14.98	0.98	5'076.02	504.12
Dream	0
Torgersen	0
Species: All
Biscoe	168	15.87	1.82	4'716.02	782.86
Dream	124	18.34	1.13	3'712.90	416.64
Torgersen	52	18.43	1.34	3'706.37	445.11

Ajout dans un document

Il existe des méthodes simples permettant d’exporter un document flextable dans un document :

save_as_docx(ft, path = "flextable-tabular.docx")
save_as_rtf(ft, path = "flextable-tabular.rtf")
save_as_html(ft, path = "flextable-tabular.html")
save_as_image(ft, path = "flextable-tabular.png")
save_as_pptx(ft, path = "flextable-tabular.pptx")

Les fichiers peuvent être téléchargés à partir des liens suivants :

Gohel, David, and Panagiotis Skintzos. 2023. Flextable: Functions for Tabular Reporting. https://CRAN.R-project.org/package=flextable.

Horst, Allison, Alison Hill, and Kristen Gorman. 2022. Palmerpenguins: Palmer Archipelago (Antarctica) Penguin Data. https://CRAN.R-project.org/package=palmerpenguins.

Murdoch, Duncan. 2023. Tables: Formula-Driven Table Generation. https://dmurdoch.github.io/tables/.

flextable supporte le format RTF

info@ardata.fr (ArData) — Wed, 05 Apr 2023 00:00:00 +0000

La version 0.9 du package ‘flextable’ amène la possibilité de produire les tableaux dans des documents RTF.

L’intérêt de supporter ce format est de pouvoir satisfaire les communautés qui sont contraintes d’utiliser ce format, c’est à dire essentiellement dans le milieu pharmaceutique à notre connaissance.

utilisations

Deux méthodes peuvent être utilisées pour embarquer les flextable dans un fichier RTF.

On peut utiliser la fonction save_as_rtf() qui produit un fichier RTF à partir d’un ou plusieurs flextable. La fonction save_as_rtf() est une fonction utilitaire du package ‘flextable’. La documentation de la fonction peut être consultée à cette adresse : https://davidgohel.github.io/flextable/reference/save_as_rtf.html.

Si la sortie n’est pas adaptée à vos besoins, vous pouvez utiliser les fonctions du package ‘officer’ dédiées à la production de fichiers RTF, c’est à dire officer::rtf_doc() et officer::rtf_add(). La documentation de rtf_add() peut être consultée à cette adresse : https://davidgohel.github.io/officer/reference/rtf_add.html.

Nous allons montrer dans la suite l’utilisation de save_as_rtf() et le résultat produit.

Le tableau pour l’illustration

L’actualité française a mis en évidence quelques jeux de données publics sur les premiers ministres de la cinquième république et les utilisations de l’article 49-3. Nous avons joué avec des données pour en produire un tableau simple avec flextable.

Les données sont disponible directement au format rds et le script permettant d’obtenir ces données est disponible dans le fichier src-history-49-3.R.

x <- readRDS("history-49-3.RDS")
head(x)

#>   couleur              name n_nominations      debut        fin duration
#> 1    CENT   Élisabeth Borne             1 2022-05-16 2023-03-25      313
#> 2    CENT       Jean Castex             1 2020-07-03 2022-05-16      682
#> 3    CENT  Édouard Philippe             2 2017-05-15 2020-07-03     1145
#> 4     GAU Bernard Cazeneuve             1 2016-12-06 2017-05-10      155
#> 5     GAU      Manuel Valls             2 2014-03-31 2016-12-06      981
#> 6     GAU Jean-Marc Ayrault             2 2012-05-15 2014-03-31      685
#>   n_eng_resp n_text n_censor_motion
#> 1         11      3              14
#> 2         NA     NA              NA
#> 3          1      1               2
#> 4         NA     NA              NA
#> 5          6      2               3
#> 6         NA     NA              NA

Préparations

On déclare d’abord quelques paramétrages généraux pour flextable.

set_flextable_defaults(
    font.family = "Open Sans", font.color = "#333333",
    big.mark = "", fmt_date = "%Y", na_str = "",
    theme_fun = theme_vanilla)

Le bord politique du ministre est indiqué avec un cercle dont la couleur est la couleur utilisée en général dans les médias. On doit d’abord préparer ces formes, on utilise le package ‘grid’ pour cela.

library(grid)
library(dplyr)
x$couleur <- mapply(function(z) {
  col <- case_when(
    z %in% "GAU" ~ "#FF8080",
    z %in% "DTE" ~ "#143c77",
    z %in% "CENT" ~ "#ff9900",
    TRUE ~ "transparent"
  )
  circleGrob(gp = gpar(fill = col, col = "transparent"))
}, z = x$couleur, SIMPLIFY = FALSE, USE.NAMES = FALSE)

Le flextable

On peut maintenant définir le tableau avec les fonctions de flextable.

z <- flextable(
  data = x, 
  col_keys = c("name", "couleur", "exercice", "n_eng_resp", "n_text", "n_censor_motion")) |> 
  mk_par(j = "exercice", 
         value = as_paragraph(
           as_i(debut), as_i("-"), as_i(fin),
           as_i(as_bracket(duration, p = " (", s = " jours)")))) |> 
  mk_par(j = "couleur", value = as_paragraph(grid_chunk(couleur, width = .15, height = .15))) |> 
  align(j = "name", align = "right", part = "all") |>
  align(j = c("n_eng_resp", "n_text", "n_censor_motion"), align = "center", part = "all") |>
  set_header_labels(name = "Premier ministre",
                    period = "Période",
                    couleur = "",
                    n_eng_resp = "Recours\nau 49-3",
                    n_text = "Textes\nconcernés",
                    n_censor_motion = "Motions\nde censure",
                    longeur = "Nombre de jours\nen fonction") |> 
  autofit() |> 
  width(j = "couleur", width = .3)
z

Premier ministre		Recours au 49-3	Textes concernés	Motions de censure
Élisabeth Borne	2022-2023 (313 jours)	11	3	14
Jean Castex	2020-2022 (682 jours)
Édouard Philippe	2017-2020 (1145 jours)	1	1	2
Bernard Cazeneuve	2016-2017 (155 jours)
Manuel Valls	2014-2016 (981 jours)	6	2	3
Jean-Marc Ayrault	2012-2014 (685 jours)
François Fillon	2007-2012 (1820 jours)
Dominique de Villepin	2005-2007 (712 jours)	1	1	0
Jean-Pierre Raffarin	2002-2005 (1121 jours)	2	2	2
Lionel Jospin	1997-2002 (1799 jours)
Alain Juppé	1995-1997 (747 jours)	2	2	2
Édouard Balladur	1993-1995 (773 jours)	1	1	1
Pierre Bérégovoy	1992-1993 (361 jours)	3	3	1
Edith Cresson	1991-1992 (323 jours)	8	4	2
Michel Rocard	1988-1991 (1100 jours)	28	13	5
Jacques Chirac	1986-1988 (782 jours)	8	7	7
Laurent Fabius	1984-1986 (611 jours)	4	2	1
Pierre Mauroy	1981-1984 (1153 jours)	7	5	6
Raymond Barre	1976-1981 (1722 jours)	8	5	13
Jacques Chirac	1974-1976 (821 jours)
Pierre Messmer	1972-1974 (691 jours)
Jacques Chaban-Delmas	1969-1972 (1111 jours)
Maurice Couve de Murville	1968-1969 (345 jours)
Georges Pompidou	1962-1968 (2279 jours)	6	2	4
Michel Debré	1959-1962 (1192 jours)	4	2	4

Les annotations

Il reste à ajouter quelques annotations et le tableau pourra être envoyé dans un document RTF.

z <- add_header_lines(z, 
  values = as_paragraph(
    as_chunk("Historique des recours au 49-3 pendant la V république",
      prop = fp_text_default(font.size = 13, bold = TRUE)
    ))
  ) |> 
  footnote(i = 1, j = 1, ref_symbols = "(1)",
           part = "header",
           value = as_paragraph(
             as_chunk(" source : "),
             as_i("https://www.assemblee-nationale.fr")
             )
           ) |> 
  footnote(i = 1, j = 1, ref_symbols = "(2)",
           part = "header",
           value = as_paragraph(
             as_chunk(" source : "),
             as_i("https://www.politiquemania.com/longevite-premier-ministre.html")
           )) |> 
  footnote(i = 2, j = c(4, 6), ref_symbols = "(3)",
           part = "header",
           value = as_paragraph(
             as_chunk("Fréquence ")
           )) |> 
  footnote(i = 2, j = 5, ref_symbols = "(4)", inline = TRUE,
           part = "header",
           value = as_paragraph(
             as_chunk("Nombre de cas")
           )) |> 
  hline(i = 1, part = "header", border = fp_border_default(width = 0))

Production du RTF

Parce que le tableau est assez large, nous utilisons une orientation ‘paysage’ ; l’entête et le pied de page sont aussi enrichis de quelques informations dont une numérotation automatique des pages. Ces paramétrages sont réalisés grâce à la fonction officer::prop_section().

library(officer)

sect_properties <- prop_section(
  page_size = page_size(
    width = 8.3, height = 11.7, orient = "landscape"
  ),
  header_default = block_list(fpar("flextable and RTF")),
  footer_default = block_list(fpar("page ", run_word_field(field = "PAGE  \\* MERGEFORMAT"))),
  page_margins = page_mar(bottom = .6, top = .6, right = .5, left = .5)
)

L’appel à la fonction save_as_rtf() permet de finalement produire le fichier RTF.

save_as_rtf(
  "Recours au 49-3" = z, 
  pr_section = sect_properties,
  path = "49-3.rtf")

aperçu de 49-3.rtf

flextable et les 'grid graphics'

info@ardata.fr (ArData) — Mon, 03 Apr 2023 00:00:00 +0000

Une des fonctionnalités récentes du package flextable est la capacité à travailler avec un format ‘grid graphics’. La fonction gen_grob() génére un ‘grob’ (Graphical Object) à partir d’un flextable, ce dernier peut ensuite être ajouté à un graphique ggplot grace au package ‘patchwork’ ou avec le package ‘grid’.

Ces fonctionnalités nécessitent l’utilisation d’une sortie graphique utilisant ‘systemfonts’ : svglite::svglite(), ragg::agg_png() ou ggiraph::dsvg(). Ces packages doivent être utilisés pour garantir que toutes les polices que vous utilisez seront reconnues par le moteur graphique R.

Le graphique ci-dessus est produit par la fonction gen_grob().
Le code associé est disponible dans l’article Utiliser les masques de grid et flextable de la ‘galerie flextable’.

Exporter un flextable en png

Les versions antérieures de “flextable” utilisaient les paquets “webshot” ou “webshot2” pour obtenir une image à partir du résultat HTML. Ce mécanisme a été remplacé par l’utilisation de la sortie ‘Grid graphics’ et du paquet ‘ragg’. Cela permet d’avoir un processus d’écriture plus rapide et facilite la maintenance.

Dans un premier temps, on définit quelques paramètres généraux.

library(flextable)
library(gdtools)
set_flextable_defaults(
  font.family = "Open Sans", font.color = "#333333",
  theme_fun = theme_vanilla,
  digits = 2, big.mark = "", na_str = "")
register_gfont("Open Sans") # register Open Sans

Pour enregistrer un tableau au format png, il faut appeler la fonction save_as_image(). Illustrons notre propos avec un tableau fabriqué à partir du jeu de données ‘palmerpenguins::penguins’.

library(palmerpenguins)
filename <- "head-penguins.png"
ft <- as_flextable(palmerpenguins::penguins) |> bg(bg = "#EFEFEF", part = "all")
save_as_image(ft, path = filename)

La fonction gen_grob

Illustrons notre propos avec notre ‘flextable’ fabriqué à partir du jeu de données ‘penguins’ et un graphique ‘ggplot’.

library(tidyverse)
g1 <- ggplot(penguins, aes(x = bill_length_mm, y = bill_depth_mm, color = species)) +
  geom_point() +
  scale_color_viridis_d() +
  theme_minimal() +
  theme(plot.margin = unit(c(0, 0, 30, 0), "pt"))

Utilisation simple

La fonction gen_grob() va offrir par défaut un comportement d’adaptation à l’espace disponible pour le tableau.

library(patchwork)
g1 / gen_grob(ft, just = "bottom")

Cela fonctionne avec toutes les fonctions qui supportent les ‘grid Graphics’ :

g1 + 
  inset_element(gen_grob(ft |> bg(bg = "#EFEFEFAA", part = "all"), just = "bottom"), 0.1, 0.25, .9, .75) + 
  theme(
    plot.background = element_rect(fill = "transparent"),
    panel.background = element_rect(fill = "transparent")
  )

Les options de redimensionnements

Il est bien sûr possible de reprendre le contrôle sur ce redimensionnement automatique.

Nous allons utiliser pour cela un petit tableau qui aidera à présenter les options.

set_flextable_defaults(font.family = "Fira Sans Condensed")
register_gfont("Fira Sans Condensed")

dummy_ft <- data.frame(zzzz = ";)") |>
  flextable() |>
  color(color = "white", part = "all") |>
  mk_par(
    value = as_paragraph(
      as_chunk("made", props = fp_text_default(font.size = 30, color = "#f2af00")),
      as_chunk(" with\n", props = fp_text_default(color = "gray", font.size = 15)),
      as_chunk("flextable", props = fp_text_default(color = "#c32900", font.size = 45))
    ),
    part = "header") |>
  autofit() |>
  align(align = "center", part = "all") |>
  border_outer(border = fp_border_default(width = 0))

Le tableau dans sa version HTML est le suivant :

dummy_ft

made with flextable
;)

Le graphique ci dessous présente quelques options de redimensionnements possibles :

Le premier tableau sera dimensionné pour s’adapter à la largeur disponible (fit = "width") et les polices seront redimensionnées au maximum possible (scaling = "full").
Le deuxième tableau est affiché sans aucun redimensionnement (fit = "fixed").
Le dernier tableau est affiché en utilisant la taille maximum possible (fit = "auto").

design <- "AAA
           BBC"
wrap_plots(
  dummy_ft |> 
    bg(bg = "#ff006e", part = "all") |> 
    gen_grob(fit = "width", scaling = "full", just = "bottom"),
  dummy_ft |> 
    bg(bg = "#3a86ff", part = "all") |> 
    gen_grob(fit = "fixed"),
  dummy_ft |> bg(bg = "#ffbe0b", part = "all") |> gen_grob(),
  design = design
)

Déroulement du contenu dans les cellules

Un algorithme est utilisé pour permettre au contenu d’être déroulé dans l’espace disponible de la cellule. Il est activé par défaut.

library(safetyData)

adsl <- adam_adsl[, c("AGE", "SEX", "ARM")]

dat <- summarizor(adsl, by = "ARM")
ft <- as_flextable(dat, spread_first_col = TRUE)
ft |> bg(bg = "#EFEFEF", part = "all") |> 
  plot(fit = "width", wrapping = TRUE, scaling = FALSE)

On peut désactiver ce comportement avec l’argument wrapping = FALSE.

ft |> bg(bg = "#EFEFEF", part = "all") |> 
  plot(fit = "width", wrapping = FALSE, scaling = FALSE)

Mettre à jour les champs et Word documents update from R with doconv

info@ardata.fr (ArData) — Thu, 25 Aug 2022 00:00:00 +0000

Si vous êtes un utilisateur de Word, il est maintenant possible de mettre à jour automatiquement les champs et les tables des matières et non plus devoir le faire manuellement depuis Word, à condition d’avoir Word disponible sur le PC hébergeant votre R.

Suite à une issue sur github (lien) et à d’autres demandes d’utilisateurs sur le sujet, le package “doconv” à évoluer afin de répondre à cette demande.

Prenons l’exemple d’un fichier ‘.docx’ généré depuis un document ‘R Markdown’ et le package ‘officedown’:

 title: "Exemple with references"
 output: 
     officedown::rdocx_document:
       toc: true
 ---
 
 ```{r setup, include=FALSE}
 knitr::opts_chunk$set(echo = FALSE, message = FALSE, warning = FALSE)
 library(officer)
 library(officedown)
 library(ggplot2)
 library(flextable)
 ```
 
 This is `r run_word_field("DOCPROPERTY \"custom_field_value\" \\* MERGEFORMAT")`.
 
 ## Figure 
 
 ```{r}
 ggplot(iris, mapping = aes(x = Sepal.Length, y = Petal.Length)) +
   geom_point()
 ```
 
 ## Table
 
 ```{r}
 flextable(head(iris)) |> autofit()
 ```

Le document exemple.docx contiendra une table des matières et un champ nommé custom_field_value ; pour l’instant sans valeur.

Ce document est généré par pandoc et les tables des matières, les références et en général tous les champs calculés par Word ne sont pas mis à jour à moins d’une intervention manuelle par l’utilisateur. Il doit ouvrir Word et rafraichir lui même ces champs pour par exemple obtenir une table des matières avec les bonnes valeurs de titres et de numéros de pages correspondants.

Résultat sans intervention manuelle

doconv::docx_update() va permettre d’automatiser ce processus manuel et va mettre à jour le document Word.

library(officer)
library(doconv)
x <- read_docx("example.docx")
x <- set_doc_properties(
  x,
  custom_field_value = "trop cool"
)
print(x,target = "updated-example.docx")
docx_update(input = "updated-example.docx")

Le code précédent va faire correspondre une valeur au champ custom_field_value avec la fonction set_doc_properties(), il prendra la valeur “trop cool”. Ensuite, on appelle la fonction docx_update() pour mettre à jour les valeurs calculées par Word.

Le résultat updated-example.docx a ce rendu :

Result doconv-update

La version 0.7.2 de flextable est sortie

info@ardata.fr (ArData) — Thu, 23 Jun 2022 00:00:00 +0000

La dernière version de ‘flextable’ est sur CRAN depuis quelques jours.

Cette version apporte quelques améliorations majeures :

Les retours chariot \n sont maintenant supportés avec autofit(),
le rendu HTML du texte orienté verticalement est désormais correct et cohérent avec les alignements horizontaux,
les tabulations \t et les retours chariot \n sont désormais correctement gérés dans PowerPoint,
il est désormais possible de placer plusieurs fois une même référence dans une note de bas de page.
le rendu PDF permet trois options de placement, fixe, flottant et enveloppant.

Il contient également quelques nouvelles fonctionnalités que nous sommes heureux de vous présenter dans ce post.

tabulator

Cette nouvelle fonction prépare des agrégations dans une structure qui peut ensuite être transformée en flextable. L’objectif est de fournir un outil permettant la création de tableaux de reporting où les dimensions sont disposées en lignes et en colonnes et où une ou plusieurs statistiques sont affichées dans le contenu des cellules. La grammaire ‘flextable’ peut être utilisée pour personnaliser le tableau généré avec comamnd flextable::as_flextable().

La fonction va créer un tableau à partir d’agrégations déjà calculées.

Table 1: Prices of over 50 000 round cut diamonds
Subset of original dataset
Good n = 2634	D		3.5 (± 2.2)		3.0 (± 2.8)		3.6 (± 3.4)
E		4.4 (± 2.5)		3.2 (± 3.1)		3.8 (± 3.3)
F		2.6 (± 1.9)		3.3 (± 3.0)		3.8 (± 3.2)
G		3.2 (± 2.0)		4.1 (± 3.9)		4.1 (± 3.3)
H		3.8 (± 2.2)		4.2 (± 3.8)		4.4 (± 4.2)
I		4.2 (± 2.9)		4.7 (± 4.5)		6.0 (± 5.1)
J		3.8 (± 2.1)		4.6 (± 3.9)		4.8 (± 3.6)
Very Good n = 5915	D		2.6 (± 0.8)		3.2 (± 2.9)		3.1 (± 3.3)
E		3.4 (± 2.2)		3.2 (± 3.1)		3.3 (± 3.5)
F		4.3 (± 2.6)		3.6 (± 3.2)		4.0 (± 3.8)
G		3.2 (± 2.1)		3.5 (± 3.6)		4.4 (± 4.0)
H		5.3 (± 2.5)		4.9 (± 4.4)		4.6 (± 4.0)
I		6.0 (± 4.9)		5.2 (± 4.5)		5.8 (± 5.1)
J		4.5 (± 2.7)		5.0 (± 4.1)		5.3 (± 4.5)

Dans un document Word, le résultat serait le suivant. Notez que le numéro de page est indiqué dans la ligne supérieure du tableau. Le code de cet exemple est disponible dans la galerie flextable ici.

tabulator() bénéficie de tous les avantages de la grammaire flextable et peut construire des tableaux complexes composés de graphiques et de texte :

Summarizor pour les résumés de tableaux

La fonction summarizor() est une fonction utilitaire qui prépare un résumé numérique pour chaque variable d’un ensemble de données, éventuellement par groupes. Elle est censée être utilisée pour produire l’argument de tabulator().

Le code de cet exemple est disponible dans la galerie flextable ici.

Impression automatique des flextable

flextable fournit deux nouvelles fonctions dédiées au ‘R Markdown’ qui transforment automatiquement les data.frame et les modèles en flextable.

Les data.frames en flextables

Nous avons ajouté un code que nous utilisions pour nos formations et qui permet d’afficher des data.frame comme des flextables dans des documents ‘R Markdown’. Nous avons essayé d’imiter la sortie de ‘data.table’ et de ‘tibble’ en affichant seulement les premières lignes et le type des colonnes. Pour tirer parti de cette fonctionnalité, nous devons appeler la fonction use_df_printer() et voilà !

use_df_printer()
airquality

Ozone	Solar.R	Wind	Temp	Month	Day
41	190	7.4	67	5	1
36	118	8.0	72	5	2
12	149	12.6	74	5	3
18	313	11.5	62	5	4
		14.3	56	5	5
28		14.9	66	5	6
23	299	8.6	65	5	7
19	99	13.8	59	5	8
8	19	20.1	61	5	9
	194	8.6	69	5	10
n: 153

Les modèles en flextables

Nous avons implémenté la déclaration des modèles dans flextable, la fonction as_flextable() fait la transformation. Pour le moment, les modèles suivants sont supportés : gam, lm, glm, glmmTMB, glmmadmb, htest, kmeans, pam, lme, gls, merMod, nlme et brmsfit.

Voici un exemple réalisé à partir d’un modèle lme :

library(nlme)
m1 <- lme(distance ~ age, data = Orthodont)
ft <- as_flextable(m1)
ft

group		Estimate	Standard Error	df	statistic	p-value
Fixed effects
	(Intercept)	16.761	0.775	80	21.620	0.0000	***
	age	0.660	0.071	80	9.265	0.0000	***
Random effects
Subject	sd_(Intercept)	2.327
Subject	cor_age.(Intercept)	-0.609
Subject	sd_age	0.226
Residual	sd_Observation	1.310
Signif. codes: 0 <= '*' < 0.001 < '' < 0.01 < '*' < 0.05

square root of the estimated residual variance: 1.3
data's log-likelihood under the model: -221.3
Akaike Information Criterion: 454.6
Bayesian Information Criterion: 470.6

Dans un document ‘R Markdown’, il est possible d’automatiser l’impression des modèles en flextable en utilisant la fonction use_model_printer(). Voici un exemple réalisé avec un clustering kmean :

use_model_printer()
kmeans(scale(mtcars[1:7]), 5)

variable	1	2	3	4	5
withinss	14.5	12.8	0.6	1.5	23.9
size	10	7	2	2	11
mpg*	-0.7949	-0.0577	-1.0437	-0.7783	1.0906
cyl*	1.0149	-0.1050	1.0149	1.0149	-1.2249
disp*	1.0281	-0.3825	1.0027	0.7688	-1.0133
hp*	0.5442	-0.3559	1.4339	2.2288	-0.9342
drat*	-1.0204	-0.0203	-0.2367	0.5301	0.8872
wt*	0.9879	-0.1023	0.4985	0.1561	-0.9520
qsec*	-0.2254	0.0719	-1.2444	-1.8460	0.7211
(*) Centers
Total sum of squares: 217.0
Total within-cluster sum of squares: 53.3
Total between-cluster sum of squares: 163.7
BSS/TSS ratio: 75.4%
Number of iterations: 2

Separation des entêtes

Vous pouvez maintenant séparer les noms de colonnes en plusieurs lignes avec la fonction separate_header(). Cela facilite la création de rapports sur les agrégations calculées avec ‘dplyr’ ou ‘data.table’.

Dans l’exemple suivant, nous agrégeons la célèbre table ‘penguins’.

species	island	bill_length_avg	bill_length_sd	bill_depth_avg	bill_depth_sd	flipper_length_avg	flipper_length_sd
Adelie	Biscoe	39.0	2.5	18.4	1.2	188.8	6.7
Adelie	Dream	38.5	2.5	18.3	1.1	189.7	6.6
Adelie	Torgersen	39.0	3.0	18.4	1.3	191.2	6.2
Chinstrap	Dream	48.8	3.3	18.4	1.1	195.8	7.1
Gentoo	Biscoe	47.5	3.1	15.0	1.0	217.2	6.5

Sans aucune manipulation intermédiaire, nous créons le “flextable” et restructurons les étiquettes d’en-tête avec la fonction separate_header().

ft <- dat |> 
  flextable() |> 
  separate_header() |> 
  autofit()
ft

species	island	bill	flipper
Adelie	Biscoe	38.97500	2.480916	18.37045	1.1888199	188.7955	6.729247
Adelie	Dream	38.50179	2.465359	18.25179	1.1336171	189.7321	6.585083
Adelie	Torgersen	38.95098	3.025318	18.42941	1.3394468	191.1961	6.232238
Chinstrap	Dream	48.83382	3.339256	18.42059	1.1353951	195.8235	7.131894
Gentoo	Biscoe	47.50488	3.081857	14.98211	0.9812198	217.1870	6.484976

Il est ensuite assez facile de le personnaliser et de produire un tableau comme ci-dessous :

species	island	bill	flipper
Adelie	Biscoe	38.98	2.48	18.37	1.19	188.80	6.73
Dream	38.50	2.47	18.25	1.13	189.73	6.59
Torgersen	38.95	3.03	18.43	1.34	191.20	6.23
Chinstrap	Dream	48.83	3.34	18.42	1.14	195.82	7.13
Gentoo	Biscoe	47.50	3.08	14.98	0.98	217.19	6.48
1Arithmetic Mean
2Standard Deviation

Le code de cet exemple est disponible dans la galerie flextable ici.

GitHub Discussions

Faites-nous part de vos problèmes, de vos questions et de vos commentaires dans les “Discussions GitHub”, désormais disponibles sur la page Github de flextable’ : https://github.com/davidgohel/flextable/discussions.

R VS SAS

info@ardata.fr (ArData) — Wed, 08 Jan 2020 00:00:00 +0000

Il n’est pas évident de passer d’un langage de programmation à un autre. Les deux langages de programmation SAS et R disposent de certaines différences. Une des différences principales est que SAS fonctionne avec une logique en ligne des tables alors que R fonctionne avec une logique en colonne.

Cependant il y a des outils qui peuvent permettre de s’adapter plus facilement au langage R, tels que le package dplyr développé par RStudio, qui permet d’effectuer les opérations de manipulation de tables de manière très lisible. Nous pouvons donc l’utiliser pour faire nos premiers pas dans l’écosystème R.

Nous espérons que cet article vous permettra de trouver des outils pour débuter sur R sans être perdu, vous trouverez ci-dessous quelques exemples de traductions de programmes SAS en R. Dans un premier temps, les codes seront des exemples de manipulation basique de table à l’aide du package dplyr puis nous verrons des exemples pour trouver des alternatives à des PROC souvent utilisées en SAS.

Les illustrations vont s’appuyer sur la table suivante:

dat <- structure(list(type = c(
  "chat", "chat", "chien", "perroquet",
  "chien", "chat", "chat", "perroquet", "canari", "chien", "perroquet",
  "canari", "chien"
), age = c(
  1, 4, 4, 5, 3, 2, 5, 6, 7, 2, 6,
  7, 8
), couleur = c(
  "blanc", "bleu", "chocolat", "rouge", "bleu",
  "gris", "roux", "multi", "jaune", "jaune", "mutli", "vert", "orange"
), taille = c(20, 17, 35, 10, 40, 19, 18, 9, 4, 43, 13, 6, 15), poids = c(
  4, 3.7, 7, 3.1, 10, 2.5, 2.4, 1.2, 0.6, 11, 1, 0.5,
  6
)), row.names = c(NA, -13L), class = c("tbl_df", "tbl", "data.frame"))

dat

type	age	couleur	taille	poids
character	numeric	character	numeric	numeric
chat	1	blanc	20	4.0
chat	4	bleu	17	3.7
chien	4	chocolat	35	7.0
perroquet	5	rouge	10	3.1
chien	3	bleu	40	10.0
chat	2	gris	19	2.5
chat	5	roux	18	2.4
perroquet	6	multi	9	1.2
canari	7	jaune	4	0.6
chien	2	jaune	43	11.0
n: 13

Nous allons également utiliser les packages suivants:

library(dplyr)
library(tidyr)
library(readxl)

Sélection de colonnes

La table est composée de 5 variables (colonnes), type, age, couleur, taille et poids. Une étape DATA de SAS avec l’instruction de table keep permettra de sélectionner les colonnes à garder, dans l’exemple ci-dessous : type, age et couleur.

Le package dplyr pourra réaliser la même opération grâce à la fonction select().

Programme SAS

data dat_select;
  set dat (keep = type age couleur);
run;

Programme R

dat_select <- select(dat, type, age, couleur)

type	age	couleur
character	numeric	character
chat	1	blanc
chat	4	bleu
chien	4	chocolat
perroquet	5	rouge
chien	3	bleu
chat	2	gris
chat	5	roux
perroquet	6	multi
canari	7	jaune
chien	2	jaune
n: 13

Sélection de lignes

La table est composée de 13 observations. Une étape DATA de SAS avec l’instruction if ou where permettra d’indiquer la condition à respecter pour les observations. Ici, la sélection se porte sur les animaux dont l’age est strictement inférieur à 4.

Dans R, l’utilisation de la fonction filter() est possible pour reproduire le même résultat.

Programme SAS

data dat_filter;
  set dat;
  if age < 4;
run;

Programme R

dat_filter <- filter(dat, age < 4)

type	age	couleur	taille	poids
character	numeric	character	numeric	numeric
chat	1	blanc	20	4.0
chien	3	bleu	40	10.0
chat	2	gris	19	2.5
chien	2	jaune	43	11.0
n: 4

Tri d’une table

Pour trier une table, nous utiliserons une PROC SORT dans SAS, avec R, nous pourrons utiliser la fonction arrange().

Programme SAS

proc sort data = dat out = dat_arrange;
  by type;
run;

Programme R

dat_arrange <- arrange(dat, type)

type	age	couleur	taille	poids
character	numeric	character	numeric	numeric
canari	7	jaune	4	0.6
canari	7	vert	6	0.5
chat	1	blanc	20	4.0
chat	4	bleu	17	3.7
chat	2	gris	19	2.5
chat	5	roux	18	2.4
chien	4	chocolat	35	7.0
chien	3	bleu	40	10.0
chien	2	jaune	43	11.0
chien	8	orange	15	6.0
n: 13

Renommage d’une variable

L’instruction rename de SAS va nous permettre de renommer une variable. L’équivalent en R sera la fonction rename(). Dans notre exemple, nous renommons la variable couleur en color.

Programme SAS

data dat_rename;
   set dat;
   rename couleur = color;
run;

Programme R

dat_rename <- rename(dat, color = couleur)

type	age	color	taille	poids
character	numeric	character	numeric	numeric
chat	1	blanc	20	4.0
chat	4	bleu	17	3.7
chien	4	chocolat	35	7.0
perroquet	5	rouge	10	3.1
chien	3	bleu	40	10.0
chat	2	gris	19	2.5
chat	5	roux	18	2.4
perroquet	6	multi	9	1.2
canari	7	jaune	4	0.6
chien	2	jaune	43	11.0
n: 13

Création d’une nouvelle variable

L’exemple suivant est plus complet et permet de créer une nouvelle variable: sum_poids qui correspond à la somme des poids par type d’animal.

En SAS, nous utiliserons la table déjà triée précedemment par type. L’instruction by indiquera que le calcul de cette nouvelle variable se fait par groupe d’animal. En R, ce sera la fonction group_by() qui nous permettra de faire la même chose. Avec le programme SAS, la fonction first est aussi utilisée pour indiquer que lorsque c’est la première fois qu’il voit une modalité différente pour la variable type, il réinitialise la varibale sum_poids avec le poids de l’observation et sinon il ajoutera à sum_poids la valeur du poids des observations suivantes.

En R, nous utiliserons la fonction mutate() pour la création d’une variable, pour calculer la somme cumulée, ce sera la fonction cumsum qui sera utilisée.

A la différence de SAS où nous sommes obligé d’ajouter l’instruction retain pour que SAS se souvienne de la modalité de la ligne précédente, R n’impose aucune contrainte.

Note: il n’est pas obligatoire dans R de trier par la variable qui sera utilisée comme variable de groupement.

Programme SAS

data dat_group;
  set dat_arrange;
  retain sum_poids;
  by type;
  if first.type then sum_poids = poids;
  else sum_poids = sum_poids + poids;
run;

Programme R

dat_group <- dat %>%
  arrange(type) %>%
  group_by(type) %>%
  mutate(sum_poids = cumsum(poids))

type	age	couleur	taille	poids	sum_poids
character	numeric	character	numeric	numeric	numeric
canari	7	jaune	4	0.6	0.6
canari	7	vert	6	0.5	1.1
chat	1	blanc	20	4.0	4.0
chat	4	bleu	17	3.7	7.7
chat	2	gris	19	2.5	10.2
chat	5	roux	18	2.4	12.6
chien	4	chocolat	35	7.0	7.0
chien	3	bleu	40	10.0	17.0
chien	2	jaune	43	11.0	28.0
chien	8	orange	15	6.0	34.0
n: 13

Pour les deux prochains exemples, nous verrons des fusions de tables horizontales et verticales. Nous aurons ainsi besoin de deux autres tables dat_merge et dat_plus que vous trouverez ci-dessous.

dat_merge <- structure(list(type = c("chat", "chien", "canari", "perroquet"), espece = c("mammifère", "mammifère", "oiseau", "oiseau")), row.names = c(
  NA,
  -4L
), class = c("tbl_df", "tbl", "data.frame"))
dat_merge

type	espece
character	character
chat	mammifère
chien	mammifère
canari	oiseau
perroquet	oiseau
n: 4

dat_plus <- structure(list(type = c(
  "chien", "perroquet", "chien", "chat",
  "chat"
), age = c(6, 7, 2, 6, 7), couleur = c(
  "bleu", "mutli",
  "jaune", "roux", "vert"
), taille = c(15, 13, 43, 6, 15), poids = c(
  5,
  1, 11, 0.5, 6
)), row.names = c(NA, -5L), class = c(
  "tbl_df",
  "tbl", "data.frame"
))
dat_plus

type	age	couleur	taille	poids
character	numeric	character	numeric	numeric
chien	6	bleu	15	5.0
perroquet	7	mutli	13	1.0
chien	2	jaune	43	11.0
chat	6	roux	6	0.5
chat	7	vert	15	6.0
n: 5

Combinaison verticale de tables

Pour combiner deux tables verticalement, une étape DATA avec l’instruction set sera utilisée. En R, c’est la fonction bind_rows qui sera utilisée.

Programme SAS

data dat_set ;
   set dat dat_plus;
run;

Programme R

dat_set <- dat %>%
  bind_rows(dat_plus)

type	age	couleur	taille	poids
character	numeric	character	numeric	numeric
chat	1	blanc	20	4.0
chat	4	bleu	17	3.7
chien	4	chocolat	35	7.0
perroquet	5	rouge	10	3.1
chien	3	bleu	40	10.0
chat	2	gris	19	2.5
chat	5	roux	18	2.4
perroquet	6	multi	9	1.2
canari	7	jaune	4	0.6
chien	2	jaune	43	11.0
n: 18

Combinaison horizontale de tables

Pour combiner deux tables horizontalement en fonction d’une clé de jointure, une étape DATA avec l’instruction merge sera utilisée et l’instruction by pour indiquer la variable qui servira de clé de jointure. En R, c’est la fonction full_join qui sera utilisée avec comme paramètre by qui permettra d’indiquer la variable qui sera la clé de jointure.

Note: avec une étape DATA pour fusionner deux tables, elles devront être triées par la variable utilisée comme clé de jointure, ce qui n’est pas nécessaire avec les fonctions de jointures disponibles dans le package dplyr.

Programme SAS

proc sort data = dat out = dat_sort; by type; run;
proc sort data = dat_merge out = dat_merge_sort; by type; run;

data dat_merge_res;
  merge dat_sort(in = a) dat_merge_sort(in = b) ;
  if a;
  by type;
run;

Programme R

dat_merge_res <- dat %>%
  left_join(dat_merge, by = "type")

type	age	couleur	taille	poids	espece
character	numeric	character	numeric	numeric	character
chat	1	blanc	20	4.0	mammifère
chat	4	bleu	17	3.7	mammifère
chien	4	chocolat	35	7.0	mammifère
perroquet	5	rouge	10	3.1	oiseau
chien	3	bleu	40	10.0	mammifère
chat	2	gris	19	2.5	mammifère
chat	5	roux	18	2.4	mammifère
perroquet	6	multi	9	1.2	oiseau
canari	7	jaune	4	0.6	oiseau
chien	2	jaune	43	11.0	mammifère
n: 13

Quelques fonctions équivalentes à certaines PROC

PROC IMPORT

La PROC IMPORT de SAS va permettre d’importer des fichiers excel .xlsx, l’équivalent en R proviendra du package readxl avec la fonction read_excel().

Programme SAS

proc import datafile="pres_drees.xlsx" out = dat dbms = xlsx;
getname=yes;
run;

Programme R

library(readxl)

dat <- read_excel("pres_drees.xlsx", sheet = "Feuil1")

type	age	couleur	taille	poids
character	numeric	character	numeric	numeric
chat	1	blanc	20	4.0
chat	4	bleu	17	3.7
chien	4	chocolat	35	7.0
perroquet	5	rouge	10	3.1
chien	3	bleu	40	10.0
chat	2	gris	19	2.5
chat	5	roux	18	2.4
perroquet	6	multi	9	1.2
canari	7	jaune	4	0.6
chien	2	jaune	43	11.0
n: 13

PROC MEANS

La PROC MEANS de SAS va permettre de faire un résumé (moyenne, min, max …) sur les variables quantitatives qui se trouvent dans la table. Un équivalent en R serait la fonction summary() qui fera un résumé également sur les variables qualitatives présentes dans la table.

Programme SAS

proc means data = dat;
run;

Programme R

summary_dat <- summary(dat)

##      type                age          couleur              taille     
##  Length:13          Min.   :1.000   Length:13          Min.   : 4.00  
##  Class :character   1st Qu.:3.000   Class :character   1st Qu.:10.00  
##  Mode  :character   Median :5.000   Mode  :character   Median :17.00  
##                     Mean   :4.615                      Mean   :19.15  
##                     3rd Qu.:6.000                      3rd Qu.:20.00  
##                     Max.   :8.000                      Max.   :43.00  
##      poids       
##  Min.   : 0.500  
##  1st Qu.: 1.200  
##  Median : 3.100  
##  Mean   : 4.077  
##  3rd Qu.: 6.000  
##  Max.   :11.000

PROC TRANSPOSE

La PROC TRANSPOSE va permettre de pivoter une table. En R, pour avoir l’équivalent du résultat SAS, il faut une pré-modification de la table pour ensuite pouvoir utiliser la fonction pivot_wider() du package tidyr.

Programme SAS

proc sort data = dat; by type; run;

proc transpose data = dt out = dat_transpose;
   var age;
   by type;
run;

Programme R

dat_t <- dat %>%
  select(type, age) %>%
  group_by(type) %>%
  mutate(col = seq_len(n()))

dat_transpose <- pivot_wider(
  data = dat_t,
  names_from = col, values_from = age,
  names_prefix = "col"
)

type	col1	col2	col3	col4
character	numeric	numeric	numeric	numeric
chat	1	4	2	5
chien	4	3	2	8
perroquet	5	6	6
canari	7	7
n: 4

PROC FREQ

La PROC FREQ de SAS va permettre de créer un tableau de fréquence. Dans l’exemple suivant, ce sont les variable age et type qui sont utilisées. En R, un équivalent peut être la fonction table().

Programme SAS

proc freq data = dat;
   tables age * type;
run;

Programme R

table_dat <- table(dat$age, dat$type)

Var1		Var2
canari	chat	chien	perroquet	Total
1	Count	0 (0.0%)	1 (7.7%)	0 (0.0%)	0 (0.0%)	1 (7.7%)
Mar. pct (1)	0.0% ; 0.0%	25.0% ; 100.0%	0.0% ; 0.0%	0.0% ; 0.0%
2	Count	0 (0.0%)	1 (7.7%)	1 (7.7%)	0 (0.0%)	2 (15.4%)
Mar. pct	0.0% ; 0.0%	25.0% ; 50.0%	25.0% ; 50.0%	0.0% ; 0.0%
3	Count	0 (0.0%)	0 (0.0%)	1 (7.7%)	0 (0.0%)	1 (7.7%)
Mar. pct	0.0% ; 0.0%	0.0% ; 0.0%	25.0% ; 100.0%	0.0% ; 0.0%
4	Count	0 (0.0%)	1 (7.7%)	1 (7.7%)	0 (0.0%)	2 (15.4%)
Mar. pct	0.0% ; 0.0%	25.0% ; 50.0%	25.0% ; 50.0%	0.0% ; 0.0%
5	Count	0 (0.0%)	1 (7.7%)	0 (0.0%)	1 (7.7%)	2 (15.4%)
Mar. pct	0.0% ; 0.0%	25.0% ; 50.0%	0.0% ; 0.0%	33.3% ; 50.0%
6	Count	0 (0.0%)	0 (0.0%)	0 (0.0%)	2 (15.4%)	2 (15.4%)
Mar. pct	0.0% ; 0.0%	0.0% ; 0.0%	0.0% ; 0.0%	66.7% ; 100.0%
7	Count	2 (15.4%)	0 (0.0%)	0 (0.0%)	0 (0.0%)	2 (15.4%)
Mar. pct	100.0% ; 100.0%	0.0% ; 0.0%	0.0% ; 0.0%	0.0% ; 0.0%
8	Count	0 (0.0%)	0 (0.0%)	1 (7.7%)	0 (0.0%)	1 (7.7%)
Mar. pct	0.0% ; 0.0%	0.0% ; 0.0%	25.0% ; 100.0%	0.0% ; 0.0%
Total	Count	2 (15.4%)	4 (30.8%)	4 (30.8%)	3 (23.1%)	13 (100.0%)
(1) Columns and rows percentages

Il est aussi possible d’avoir un rendu plus proche de celui de la PROC FREQ de SAS en utilisant la fonction proc_freq du package flextable.

library(flextable)

proc_freq(dat, "age", "type")

age		type
canari	chat	chien	perroquet	Total
1	Count		1 (7.7%)			1 (7.7%)
Mar. pct (1)		25.0% ; 100.0%
2	Count		1 (7.7%)	1 (7.7%)		2 (15.4%)
Mar. pct		25.0% ; 50.0%	25.0% ; 50.0%
3	Count			1 (7.7%)		1 (7.7%)
Mar. pct			25.0% ; 100.0%
4	Count		1 (7.7%)	1 (7.7%)		2 (15.4%)
Mar. pct		25.0% ; 50.0%	25.0% ; 50.0%
5	Count		1 (7.7%)		1 (7.7%)	2 (15.4%)
Mar. pct		25.0% ; 50.0%		33.3% ; 50.0%
6	Count				2 (15.4%)	2 (15.4%)
Mar. pct				66.7% ; 100.0%
7	Count	2 (15.4%)				2 (15.4%)
Mar. pct	100.0% ; 100.0%
8	Count			1 (7.7%)		1 (7.7%)
Mar. pct			25.0% ; 100.0%
Total	Count	2 (15.4%)	4 (30.8%)	4 (30.8%)	3 (23.1%)	13 (100.0%)
(1) Columns and rows percentages

PROC CORR

La PROC CORR de SAS permet de calculer les corrélations entre les variables précisées dans l’instruction var. Le type de corrélation effectué est choisi avec l’indication pearson dans notre cas. En R, ce sera la fonction cor() qui sera utilisée en précisant pour argument de method : "pearson".

Programme SAS

proc corr data = dat pearson;
   var age poids taille;
run;

Programme R

cor_dat <- cor(dat[, c("age", "poids", "taille")],
  method = "pearson"
)

##               age      poids     taille
## age     1.0000000 -0.4894355 -0.6526009
## poids  -0.4894355  1.0000000  0.9280667
## taille -0.6526009  0.9280667  1.0000000

PROC REG

Pour effectuer une régression linéaire, la PROC REG sera utilisée, en R ce sera la fonction lm(). Pour obtenir les résultats de cette regression, nous utiliserons la fonction summary().

Programme SAS

proc reg data = dat ;
   model poids = age;
run;

Programme R

model <- lm(poids ~ age, dat)

summary(model)

## 
## Call:
## lm(formula = poids ~ age, data = dat)
## 
## Residuals:
##    Min     1Q Median     3Q    Max 
## -3.612 -1.800 -1.378  2.444  4.888 
## 
## Coefficients:
##             Estimate Std. Error t value Pr(>|t|)   
## (Intercept)   7.6685     2.1189   3.619  0.00403 **
## age          -0.7782     0.4180  -1.861  0.08959 . 
## ---
## Signif. codes:  0 '***' 0.001 '**' 0.01 '*' 0.05 '.' 0.1 ' ' 1
## 
## Residual standard error: 3.158 on 11 degrees of freedom
## Multiple R-squared:  0.2395,	Adjusted R-squared:  0.1704 
## F-statistic: 3.465 on 1 and 11 DF,  p-value: 0.08959

Cet article visait uniquement à vous donner un aperçu des rapprochements possibles entre R et SAS sur des opérations basiques, lorsque l’on connait SAS et que l’on souhaite passer sous R. En espérant que cet article vous a aidé. :)

Modules Shiny (partie 3) : Appel dynamique de modules

info@ardata.fr (ArData) — Mon, 01 Jul 2019 00:00:00 +0000

Dans l’article précédent nous avons vu les mécanismes de transfert de données entre l’application Shiny et ses modules.

Maintenant que les modules n’ont (presque plus) de secrets pour vous ; peut-être êtes-vous intéressé pour utiliser un même module plusieurs fois sans pour autant coder chaque appel ?

Dans cet article, nous verrons comment appeler dynamiquement un module et gérer ses outputs server et/ou UI avec 2 exemples :

Récupérer l’UI d’un module apellé dynamiquement.
Récupérer l’UI & server d’un module appelé dynamiquement.

Si vous souhaitez jouer les exemples en local

Tous les codes utilisés ici sont disponibles sur Github ardata-fr/Shiny-Modules-Tutorials. Ce dépôt est un package R dont les modules sont les fonctions exportées. Les applications Shiny sont dans le dossier inst.

Installer le package et lancer localement les applications :

# install.packages("remotes")
remotes::install_github("ardata-fr/Shiny-Modules-Tutorials")

library(shinyModulesTuto)
# Lister les applications disponibles
listEx()
# Lancer la 1ere application
runEx(listEx()[1])

Exemple 1 : Récupérer seulement l’output `UI`

Comme vous le savez, un module est composé de 2 fonctions. L’interface UI & la logique server.

Dans cet exemple, la logique server ne retourne rien. Nous avons simplement à gérer les sorties UI.

https://ardata.shinyapps.io/dynamic-call/ ou bien lancer la commande :

# Lancer localement l'application exemple
runEx("dynamic-call")

NB : Dans cet exemple, chaque sortie UI est shinyWidgets::panel.

Application demo

Initialiser `rv$all_ui`

La reactive rv est initialisée comme ci-dessous :

rv <- reactiveValues(all_ui = list())

Appel dynamique au travers d’un `observeEvent`

A chaque chargement d’un dataset (cf : incrémentation de data_mod1$trigger), l’observeEvent :

Exécute la partie server logique du module

callModule(
    module = data_info,
    id = data_mod1$trigger,
    data = data_mod1$data,
    data_name = data_mod1$data_name
)

Récupére la sortie UI dans la reactive rv$all_ui

rv$all_ui[[data_mod1$trigger]] <- data_infoUI(id = data_mod1$trigger)

Agencement des éléments `UI`

Dans cet exemple, chaque sortie UI est un shinyWidgets::panel, ainsi on peut les utiliser dans un tagList :

output$all_results <- renderUI({
    tagList(rv$all_ui)
})

Exemple 2 : Récupérer les sorties `UI` & `server`

Est-ce que vous vous souvenez de l’application whole-app dans l’article précédent ?

Elle est encore disponible en ligne ou vous pouvez la lancer localement :

# Lancer localement l'application exemple
runEx("whole-app")

Pour cet exemple, j’ai créé le module merge_modules qui contient les modules utilisés dans whole-app sauf load_data. L’objectif est de faire une application contenant le module load_data pour envoyer les données vers le “super-module” merge_modules.

Ce “super-module” merge_modules retourne les parties UI de tous les modules sous-jacents. Sa partie server renvoie une reactiveValues contenant le nom ainsi que le nombre de fonctions appliquées sur chaque jeu de données chargé.

L’application est disponible en ligne https://ardata.shinyapps.io/dynamic-call-whole-app/ ou bien vous pouvez la lancer localement :

# Lancer localement l'application exemple
runEx("dynamic-call-whole-app")

NB : L’application est organisée avec un tabsetPanel, chaque sortie de merge_modules est ajoutée au travers d’un nouveau tabPanel. De plus, chaque tabPanel contient un bouton de fermeture.

Application demo

Initialisation des variables

trick     <- reactiveVal(0)
res       <- list()
obs_close <- list()

La reactiveVal trick est un entier qui s’incrémente à chaque appel du module merge_modules. Elle est ensuite utilisée comme id pour tabPanel et pour les noms d’éléments de la liste res.
La liste res contient les sorties server de chaque appel au module merge_modules.
La liste obs_close contient les observers qui se déclenchent pour la fermeture des tabPanel.

Appel dynamique au travers d’un `observeEvent`

A chaque chargement de dataset (cf : incrémentation de data_mod1$trigger), l’observeEvent :

Exécute la partie server logique du module et stocke le résultat dans la liste res.

res[[paste(id)]] <<- callModule(
    module = merge_modules,
    id = id,
    data = data,
    name = name
)

Récupère la sortie UI et crée directement un tabPanel (via la fonction appendTab) :

appendTab(
    inputId = "all_tabs",
    tabPanel(
        title = tabTitle(name, id),
        value = id,
        tags$br(),
        merge_modulesUI(id = id)
    ),
    select = TRUE
)

Ajoute un observer dans la liste obs_close pour déclencher la fermeture du tabPanel :

obs_close[[paste(id)]] <<- observe({
    shinyjs::onclick(id = paste0("close", id), closeTab(id = id))
})

Incrémente la reactiveValue trick

trick(trick() + 1)

NB : L’incrémentation de trick délenche la mise à jour du renderUI ui_summary.

La reactiveVal trick est indispensable pour mettre à jour ui_summarycar la liste res n’est pas reactive.

Utiliser les sorties `server` dans l’application

La liste res peut être utilisée n’importe où dans l’application. Cependant, il faut penser à référencer la reactiveVal trick afin que le contexte reactif se mette à jour lorsque res est modifié.

# Summary of all opened tabs
output$ui_summary <- renderUI({
    # Reference trick to update reactive context
    fool <- trick()
    
    zz <- lapply(res, reactiveValuesToList)

    if (length(zz) == 0) {
        content <- div(class = "warn ", "No variable loaded")
    } else {
        # Use output of module merge_modules :
        #  - name
        #  - nb_funs
        content <- tags$ul(
          lapply(zz, function(x) {
            tags$li(paste(x$name, ":", x$nb_funs))
          })
        )
    }

    tagList(content)
})

Bonus : Fermer un `tabPanel`

Dans cet exemple, on peut “supprimer” l’appel à un module. Nous devons défaire les étapes réalisées au chapitre précédent :

Supprimer le tabPanel correspondant (UI part).
Supprimer l’élément correspondant dans la liste res (Server part).

Ces 2 étapes sont réalisées dans la fonction closeTab décrite ci-dessous. Cette fonction est lancée dans l’observer créé dynamiquement et situé dans obs_close :

closeTab <- function(id) {
    # Remove tab from UI
    removeTab(inputId = "all_tabs", target = paste(id))
    
    # Remove related element from list
    res[[paste(id)]] <<- NULL
    
    # Increase trick to refresh output$ui_summary
    trick(trick() + 1)
}

Le bouton de fermeture du tabPanel est créé avec la fonction ci-dessous :

# Function to add a cross after tabPanel title
tabTitle <- function(name, id) {
    tags$span(
        name, HTML("&nbsp;"),
        tags$span(
            id = paste0("close", id),
            class = "close",
            HTML("&times;")
        )
    )
}

Conclusion

L’appel dynamique à un module est très pratique lorsque celui-ci :

Peut être exécuté un nombre de fois indéfini.
Executé à partir d’une action utilisateur.

L’appel se fait ensuite dans un observeEvent ou bien un observe puis :

Si on a besoin de la sortie server alors la stocker comme nouvel élément d’une liste.
Pour la sortie UI deux solutions :
- Stocker la sortie UI dans une reactiveValues (cf exemple 1).
- Utiliser directement la sortie UI dans l’observer (cf exemple 2).

Etre le maître des modules Shiny

Au travers de ces 3 articles, nous avons vu :

Pourquoi utiliser les modules Shiny ? : Voici quelques cas où ils vous apporteront une précieuse aide.
Transfert de reactive : Description des mécanismes de transfert de données entre l’application Shiny et ses modules.
Appel dynamique de modules : Gérer l’appel dynamique aux modules.

J’espère que ces articles vous seront d’une grande aide pour que vous puissiez prendre un max de plaisir à développer vos applications Shiny !

Quoi de neuf avec ggiraph

info@ardata.fr (ArData) — Fri, 24 May 2019 00:00:00 +0000

ggiraph 0.6.1 a évolué et il convient de faire une annonce rapide pour présenter les quelques travaux qui ont été réalisés ces derniers temps.

ggiraph, qu’est ce que c’est?

Le package ggiraph permet de travailler avec ggplot et de produire des graphiques interactifs. Le nombre de fonctionnalités est restreint et l’utilisation simple. Les trois fonctionnalités à retenir sont

la capacité à animer les points, polygones et lignes,
l’affichage de tooltip quand la souris passe sur ces éléments
la capacité de sélectionner ces éléments quand le graphique est affiché dans une application shiny.

Un exemple avec des chats qui miaulent

Une illustration s’impose… On va représenter les répartitions des chats et chiens parmi les animaux de compagnie aux Etats Unis. On va afficher un tooltip, animer les barres et le click déclenchera la lecture d’un son de chien ou de chat.

Tout d’abord, je défini quelques objets JavaScript. Ces objets sont des objets media qui nous permettront de jouer un son quand on cliquera sur une barre interactive.

var ouahouah = new Audio("/media/uhauha.ogg" ) ;
var meow = new Audio("/media/Meow.ogg" ) ;

Maintenant, il faut préparer les données. Le code suivant permet l’importation des données et la création d’un tableau de répartition par état.

library(ggiraph)
library(tidyverse)

# curl download file from github ----
xlfile <- tempfile()
curl::curl_download(
  url = paste0(
    "https://github.com/davidgohel/budapestbi2017/",
    "blob/master/docs/ggiraph/data/",
    "cats-vs-dogs.xlsx?raw=true"
  ), destfile = xlfile
)

# aggregate and prepare data for ggplot/ggiraph ----
data <- readxl::read_excel(xlfile) %>%
  select(Location, `Percentage of Dog Owners`, `Percentage of Cat Owners`) %>%
  set_names(c("location", "dog", "cat")) %>%
  gather(animal, percentage, -location) %>%
  mutate(clickjs = case_when(
    animal %in% "dog" ~ "ouahouah.play();",
    animal %in% "cat" ~ "meow.play();",
    TRUE ~ "coincoin.play();"
  ), data_id = paste0(location, animal))

head(data)

location	animal	percentage	clickjs	data_id
character	character	numeric	character	character
District of Columbia	dog	13.1	ouahouah.play();	District of Columbiadog
Iowa	dog	33.4	ouahouah.play();	Iowadog
Missouri	dog	45.9	ouahouah.play();	Missouridog
Montana	dog	41.2	ouahouah.play();	Montanadog
New Jersey	dog	32.4	ouahouah.play();	New Jerseydog
Minnesota	dog	31.9	ouahouah.play();	Minnesotadog

On peut maintenant créer notre graphique ggplot, on utilise seulement geom_bar_interactive à la place de geom_bar.

gg <- ggplot(data = data, aes(
  x = location, y = percentage, fill = animal,
  onclick = clickjs, data_id = data_id, tooltip = percentage
)) +
  geom_bar_interactive(stat = "identity") +
  theme_minimal() +
  scale_fill_manual(values = c("#FF4136", "#FFDC00")) +
  labs(title = "click on bars to play cat or dog sound!") +
  theme(axis.text.x = element_text(angle = 45, hjust = 1))

girafe(ggobj = gg, width_svg = 10, height_svg = 4) %>%
  girafe_options(ggiraph::opts_hover(css = "fill:#22222288;cursor:pointer;"))

Les nouveautés

Une nouvelle syntaxe

La fonction principale ggiraph devenait un peu lourde, le nombre d’arguments avait trop augmenté au fur et à mesure des évolutions. Les nouveaux utilisateurs ne comprenaient pas toujours quels arguments se rapportaient à quelles fonctionnalités.

Plutôt que casser l’existant, nous avons préféré implémenter de nouvelles fonctions : girafe pour transformer le ggplot en widget interactif et girafe_options pour personnaliser les effets et options de la visualisation.

girafe_options prend comme argument des appels à opts_tooltip, opts_hover, opts_zoom, opts_selection et opts_toolbar. Ces fonctions facilitent la compréhension des options offertes en les segmentant clairement. Ainsi, tout ce qui concerne le zoom peut être précisé en utilisant opts_zoom, tout ce qui est relatif aux tooltip peut être précisé avec opts_tooltip.

Illustrons cette syntaxe avec un exemple simple. Nous allons :

spécifier l’opacité de la couleur de fond du tooltip à 70% (opts_tooltip(opacity = .7)),
spécifier les niveaux de zoom autorisés, de 50% à 400% (opts_zoom(min = .5, max = 4)),
définir le style des points identifiables avec la couleur rouge pour le fond et grise pour le contour (opts_hover(css = "fill:red;stroke:gray;")).

library(tibble)
library(ggiraph)
library(magrittr)

gg_point <- ggplot(
  data = mtcars,
  mapping = aes(x = wt, y = mpg, size = disp, color = as.factor(carb))
) +
  geom_point_interactive(aes(tooltip = row.names(mtcars), data_id = row.names(mtcars))) +
  scale_color_brewer(palette = "Set1", name = "carb") +
  scale_size(range = c(1, 15), name = "disp") +
  scale_x_continuous(limits = c(1, 6)) +
  scale_y_continuous(limits = c(7, 36)) +
  theme_minimal() +
  theme(legend.position = "bottom")

girafe_obj <- girafe(ggobj = gg_point) %>%
  girafe_options(
    opts_tooltip(opacity = .7),
    opts_zoom(min = .5, max = 4),
    opts_hover(css = "fill:red;stroke:white;stroke-width:2px;")
  )

Download as a png

Une nouvelle fonctionnalité de la visualisation est aussi apparue, c’est la capacité à télécharger la visualisation sous forme de png. Dans le graphique, il suffit de cliquer sur l’icone et l’image est téléchargée sur votre machine.

Cette option ne marche pas sur les anciens navigateurs. Elle peut être désactivée avec l’option opts_toolbar(saveaspng = TRUE).

Utilisation de webpack et d’ES6

Grâce à Babel et Webpack, nous avons pu réécrire complètement le code JavaScript sous forme d’un module ES6. Modulariser l’application a été l’opportunité de nettoyer et consolider le code mais aussi de mieux supporter les anciens navigateurs.

Cela a semble t-il facilité également la collaboration. Nous avons reçu l’aide de Panagiotis Skintzos qui a réalisé un super travail de revue et d’amélioration du rendu (si vous voyez un graphique ggiraph dans une application shiny depuis votre mobile, c’est grâce à lui par exemple).

visual studio code

Les évolutions à venir

Le projet est maintenant assez stable. Dans les prochaines itérations, les efforts porteront majoritairement sur la partie interactive. Le travail qui nous semble le plus motivant est la possibilité d’avoir une animation sur le point le plus proche du curseur et pas seulement sur le point sous le curseur.

Créer une image à partir d'un flextable

info@ardata.fr (ArData) — Thu, 23 May 2019 00:00:00 +0000

flextable 0.5.4 est maintenant sur le CRAN. Cette version contient une nouvelle option de sortie qui répond à la demande de quelques utilisateurs : la capacité à sauver les flextables en tant qu’images grâce à la fonction save_as_image.

La solution existait déjà mais elle était un peu perdue dans une question de stackoverflow au lieu d’être implémentée proprement dans flextable.

Cette fonctionnalité a ouvert d’autres possibilités ; vous pouvez maintenant utiliser la méthode plot, ainsi que as_raster, et faire du raster ce que vous voulez (par exemple le combiner avec un objet ggplot).

Demo

D’abord, on créer un flextable simple.

library(flextable)
ft <- flextable( head( mtcars ) )
ft <- autofit(ft)
ft

mpg	cyl	disp	hp	drat	wt	qsec	vs	am	gear	carb
21.0	6	160	110	3.90	2.620	16.46	0	1	4	4
21.0	6	160	110	3.90	2.875	17.02	0	1	4	4
22.8	4	108	93	3.85	2.320	18.61	1	1	4	1
21.4	6	258	110	3.08	3.215	19.44	1	0	3	1
18.7	8	360	175	3.15	3.440	17.02	0	0	3	2
18.1	6	225	105	2.76	3.460	20.22	1	0	3	1

Si on souhaite le sauver en png, on peut utiliser le code suivant :

save_as_image(ft, path = "name.png")

On peut aussi utiliser la fonction plot :

plot(ft)

Ou encore le combiner avec un graphique ggplot :

library(ggplot2)
library(grid)
library(cowplot)

anyplot <- qplot(speed, dist, data = cars, geom = "point")

ft_raster <- as_raster(ft)

gflextable <- ggplot() +
  theme_void() +
  annotation_custom(rasterGrob(ft_raster),
    xmin = -Inf, xmax = Inf, ymin = -Inf, ymax = Inf)

plot_grid(anyplot, gflextable, nrow = 2, ncol = 1, rel_heights = c(4, 1))

Note à propos de la largeur et hauteur

Il peut être intéressant de connaître les dimensions exactes d’un flextable. Pour cela, on utilise la fonction flextable_dim() qui va renvoyer les dimensions et le ratio d’aspect.

dims <- flextable_dim(ft)
dims

#> $widths
#> [1] 6.186252
#> 
#> $heights
#> [1] 2.800021
#> 
#> $aspect_ratio
#> [1] 0.4526199

Il faudra par exemple utiliser ces informations pour renseigner les options knitr du chunk qui produit le graphique avec plot : fig.asp, fig.width et fig.height.

Modules Shiny (partie 2) : Transfert de reactive entre l'application et ses modules

info@ardata.fr (ArData) — Fri, 26 Apr 2019 00:00:00 +0000

Dans l’article précédent nous avons vu pourquoi les modules sont d’une grande aide dans la création d’applications Shiny. Nous avons également vu un exemple minimal “Hello-World”.

Cela peut parfois être difficile de partager des reactives entre l’application Shiny elle-même et ses modules. Dans cet article nous décrirons les trois cas les plus communs d’échange de données :

Module → Application
Application → Module
Application ↔︎ Module

Si vous souhaitez jouer les exemples en local

Installer le package et lancer localement les applications :

# install.packages("remotes")
remotes::install_github("ardata-fr/Shiny-Modules-Tutorials")

library(shinyModulesTuto)
# Lister les applications disponibles
listEx()
# Lancer la 1ere application
runEx(listEx()[1])

La donnée du module vers l’application

Voir l’application exemple en ligne ou bien lancer la commande :

# Lancer localement l'application exemple
runEx("module-vs-app")

Dans le module

On initialise la reactiveValues que l’on va retourner :

toReturn <- reactiveValues(
                variables = NULL,
                variable_name = NULL,
                trigger = 0
            )

Puis on la met à jour reactiveValues :

observeEvent(input$AB_load, {
    toReturn$variable       <- get(input$SI_dataset)[,input$SI_var]
    toReturn$variable_name  <- input$SI_var
    toReturn$trigger        <- toReturn$trigger + 1
})

Pour finir elle est retournée à l’application :

return(toReturn)

Dans l’application

On récupère les résultats du module :

# results est une reactiveValues avec 3 slots (defini dans le module)
results <- callModule(module = load_data, id = "id1")

On peut ensuite l’utiliser comme une reactiveValues classique :

output$PR_results_print <- renderPrint({
    print(results$variable_name)
    print(results$variable)
})

La donnée de l’application vers le module

Voir l’application exemple en ligne ou bien lancer la commande :

# Lancer localement l'application exemple
runEx("app-vs-module")

Dans l’application

Solution 1 : Utiliser une reactive

On crée la reactive que l’on donnera ensuite au module :

variable <- reactive({
    iris[, input$SI_colname]
})

On passe la reactive comme un paramètre du module :

callModule(module = show_data, id = "id1",
    variable = variable,
    variable_name = reactive(input$SI_colname))

NB : variable étant une reactive, pas besoin de l’encapsuler dans la fonction reactive().

Solution 2 : Utiliser une reactiveValues

On crée la reactiveValues que l’on donnera ensuite au module :

rv <- reactiveValues(variable = NULL)

observe({
    rv$variable <- iris[, input$SI_colname]
})

On passe la reactiveValues comme un paramètre du module :

callModule(module = show_data, id = "id2",
    variable = reactive(rv$variable),
    variable_name = reactive(input$SI_colname))

NB : Comme rv$variable est une reactiveValues, on l’encapsule dans la fonction reactive().

Dans le module

Solutions 1 & 2

Pour les deux solutions (avec une reactive ou une reactiveValues dans l’application), on récupère les paramètres depuis le module avec :

output$PL_histogram_var <- renderPlot({
    hist(variable(), main = variable_name(), xlab = NULL)
})

NB : On utilise ici les paramètres du module variable et variable_name comme des reactives classiques (cf variable() & variable_name()).

Donnée de l’application modifiée dans un module

Voir l’application exemple en ligne ou bien lancer la commande :

# Lancer localement l'application exemple
runEx("app-pong-module")

L’objectif est d’utiliser un module pour modifier une donnée présente dans l’application. L’astuce ici est d’utiliser une deuxième reactiveValues.

Comme nous avons décrit dans le chapitre précédent comment utiliser les paramètres dans un module, dans cette partie on se concentre uniquement sur l’application.
Considérons le module apply_function qui prend en paramètre un vecteur numérique sur lequel l’utilisateur peut appliquer une fonction (ex : log(x)). Ensuite, le module retourne une reactiveValues contenant plusieurs slots : le vecteur numérique résultant de cette fonction, le nom de la fonction appliquée et un “trigger” qui s’incrémente dès lors qu’une nouvelle fonction est appliquée.

Dans l’application, on initialise la reactiveValues comme d’habitude :

rv <- reactiveValues(variable = NULL, fun_historic = NULL)

observe({
    rv$variable     <- iris[, input$SI_colname]
    rv$fun_historic <- NULL
})

Que l’on passe ensuite au module apply_function :

modified_data <- callModule(module = apply_function, id = "id1",
                     variable = reactive(rv$variable))

La sortie du module est une reactiveValues avec les 3 slots suivants :

result (le vecteur numérique résultant de la fonction)
fun (nom de la fonction appliquée)
trigger (integer qui s’incrémente dès qu’une nouvelle fonction est appliquée)

Dans l’application, pour mettre à jour la reactiveValues rv$variable en fonction du résultat obtenu (modified_data$result), on utilise un observeEvent basé sur modified_data$trigger.

observeEvent(modified_data$trigger, {
    rv$variable     <- modified_data$result
    rv$fun_historic <- c(rv$fun_historic, modified_data$transformation)
})

L’astuce ici consistait à utiliser une reactiveValues “tampon”. Le vrai schéma devrait donc être :

Application avec l’ensemble des exemples précédents

Voir l’application exemple en ligne ou bien lancer la commande :

# Lancer localement l'application exemple
runEx("whole-app")

Cette application utilise l’ensemble des modules des exemples précédents. De plus, le module apply_scale ajoute une deuxième façon de modifier la reactiveValues “principale” rv (applique la fonction scale(x)).
Le schéma ci-dessous montre que la reactiveValues rv est le coeur de l’application. Elle contient deux slots, variable qui est le vecteur numérique ainsi que fun_history qui est l’ensemble des fonctions qui ont été appliquées.

La reactiveValues rv est initialisée dans l’application comme ci-dessous :

rv <- reactiveValues(variable = NULL, fun_history = NULL)

Puis elle est mise à jour par trois modules différents :

Par le module load_data en utilisant la reactiveValues tampon data_mod1.
Par le module apply_function en utilisant la reactiveValues tampon data_mod2.
Par le module apply_scale en utilisant la reactiveValues tampon data_mod3.

Pour faciliter le processus de mise à jour de la reactiveValues rv, on place des observeEvent sur les slots trigger retournés pour les modules. Ainsi on s’assure que la dernière action de l’utilisateur est bien prise en compte.

Déclenchement de la mise à jour à partir des résultats du module load_data :

# Appel du module load_data
data_mod1 <- callModule(module = load_data, id = "mod1")

# Lorsque data_mod1$trigger change, mise à jour de rv$variable & rv$fun_history
observeEvent(data_mod1$trigger, {
    req(data_mod1$trigger>0)
    rv$variable    <- data_mod1$variable
    rv$fun_history <- c()
})

Déclenchement de la mise à jour à partir des résultats du module apply_function :

# Appel du module apply_function avec le parametre rv$variable
data_mod2 <- callModule(module = apply_function, id = "mod2",
                 variable = reactive(rv$variable))

# Lorsque data_mod2$trigger change, mise à jour de rv$variable & rv$fun_history
observeEvent(data_mod2$trigger, {
    req(data_mod2$trigger>0)
    rv$variable    <- data_mod2$result
    rv$fun_history <- c(rv$fun_history, data_mod2$fun)
})

Déclenchement de la mise à jour à partir des résultats du module apply_scale :

# Appel du module apply_scale avec le parametre rv$variable
data_mod3 <- callModule(module = apply_scale, id = "mod3",
                 variable = reactive(rv$variable))

# Lorsque data_mod3$trigger change, mise à jour de rv$variable & rv$fun_history
observeEvent(data_mod3$trigger, {
    req(data_mod3$trigger>0)
    rv$variable    <- data_mod3$result
    rv$fun_history <- c(rv$fun_history, "scale")
})

Conclusion

Nous avons décrit les cas ci-dessous (lien vers les applications) :

Nous vous recommandons vivement d’utiliser les modules lors du développement d’applications Shiny conséquentes. Vous pouvez aller encore plus loin avec :

Les modules imbriqués (très simple en réalité)
L’appel dynamique de modules

Avant de voir ces concepts (il me reste une partie 3 à écrire), j’espère que vous allez vous amuser à créer vos applications Shiny !

Envoyer des emails contenant des flextable depuis R

info@ardata.fr (ArData) — Mon, 04 Mar 2019 00:00:00 +0000

Une question sur stackoverflow a motivé ce billet : https://stackoverflow.com/q/54845375/3315962. Répondre à la question m’a permis plusieurs choses : confirmer qu’il est possible d’envoyer par email des tableaux HTML réalisés avec flextable et réviser mes connaissances du package sendmailR.

L’objet du post est de montrer comment envoyer des emails contenant des tableaux de reporting depuis R.

On utilise ici deux packages R:

sendmailR, qui va nous permettre d’envoyer des emails depuis R. Le package est stable (sa dernière mise à jour date de 2014!), il presente un nombre limité de fonctionnalités et est très simple à utiliser.
flextable, la référence en terme de reporting tabulaire avec R :). Le package permet la production de tableaux simples et de tableaux complexes, l’utilisateur peut récupérer la sortie au format HTML mais aussi au format Word, PowerPoint et PDF. On va utiliser un exemple basique afin de ne pas complexifier les illustrations. Le code ci-dessous créé le tableau qu’on va envoyer :

library(flextable)
myft <- flextable(head(iris, n = 10))
myft <- autofit(myft)
myft

Sepal.Length	Sepal.Width	Petal.Length	Petal.Width	Species
5.1	3.5	1.4	0.2	setosa
4.9	3.0	1.4	0.2	setosa
4.7	3.2	1.3	0.2	setosa
4.6	3.1	1.5	0.2	setosa
5.0	3.6	1.4	0.2	setosa
5.4	3.9	1.7	0.4	setosa
4.6	3.4	1.4	0.3	setosa
5.0	3.4	1.5	0.2	setosa
4.4	2.9	1.4	0.2	setosa
4.9	3.1	1.5	0.1	setosa

Solution 1 : Composer le HTML

On peut créer un contenu HTML assez simplement à condition de connaître les bases du HTML…

On va composer le contenu HTML et y insérer le résultat de la fonction flextable::format(myft, type = "html") qui retourne le code HTML d’un flextable sous forme d’une chaîne de caractères.

raw_html <- paste(
  "<!DOCTYPE html>",
  "<html>",
  "<head>",
  "<meta http-equiv='Content-Type' content='text/html; charset=utf-8' />",
  "<meta name='viewport' content='width=device-width, initial-scale=1.0'/>",
  "<title>your report title</title>",
  "</head>",
  "<body>",
  format(myft, type = "html"),
  "</body>",
  "</html>"
)

Le contenu à afficher étant défini, il faut maintenant l’intégrer dans un email et l’envoyer avec la fonction sendmailR::sendmail.

Attention, il faut bien sûr aussi connaître les paramètres de serveur de mail que vous devez utiliser, pour l’illustration, j’utilise le service de google.

Si vous êtes dans une entreprise et que vous n’avez aucune idée de quoi je parle (serveur SMTP, quel port utiliser, existe t-il un compte pour l’envoi d’email automatique?), je vous invite à prendre un café avec quelqu’un de votre service informatique et de lui demander de vous expliquer ce qu’est un serveur SMTP.

Dans un premier temps, on définit notre contenu HTML comme tel en précisant un Content-Type à la valeur "text/html". Ce contenu doit être dans une liste (mail_message dans notre exemple) comme indiqué dans la documentation de sendmail.

library(sendmailR)

# un contenu mime
body_message <- mime_part(raw_html)
body_message$headers$`Content-Type` <- "text/html"

# le message sera composé d'un seul contenu : body_message
mail_message <- list(body_message)

Il reste à appeler la fonction principale pour envoyer l’email :

sendmail(
  from = "<arthur.dent@gmail.com>",
  to = "<ford.prefect@gmail.com>",
  subject = "this is not a towel",
  msg = mail_message,
  control = list(smtpServer = "ASPMX.L.GOOGLE.COM")
)

Voici ce que peut lire Ford Prefect :

Solution 2 : Utiliser R Markdown

La technique est à peu près la même - en revanche, on ne créé pas le HTML directement, on utilise un document R Markdown. Cela offre de nombreux avantages mais ce n’est pas l’objet du billet - le sujet est trop vaste… Retenons ici que je n’ai plus à comprendre le HTML en travaillant avec R Markdown et que je peux facilement créer des contenus plus riches.

Pour l’illustration, on va utiliser un fichier R Markdown existant dans le package flextable.

an_rmd_example <- system.file(package = "flextable", "examples/rmd/demo.Rmd")

Le contenu du fichier est le suivant:

fpeek::peek_head(an_rmd_example, n = 100)

## ---
## title: "flextable example"
## ---
## 
## ```{r setup, include=FALSE}
## library(knitr)
## library(flextable)
## library(officer)
## library(magrittr)
## library(data.table)
## opts_chunk$set(echo = FALSE, message = FALSE)
## ```
## 
## ```{r}
## col_palette <- c("#D73027", "#F46D43", "#FDAE61", "#FEE08B", 
##   "#D9EF8B", "#A6D96A", "#66BD63", "#1A9850")
## cor_matrix <- cor(mtcars)
## mycut <- cut( cor_matrix, 
##   breaks = c(-1, -0.75, -0.5, -0.25, 0, 0.25, 0.5, 0.75, 1), 
##   include.lowest = TRUE, label = FALSE)
## mycolors <- col_palette[mycut]
## data <- data.frame(rowname = row.names(cor_matrix), stringsAsFactors = FALSE) %>%
##   cbind(cor_matrix)
## ```
## 
## ## An example 
## 
## ```{r}
## flextable(data) %>%
##   bg(j = colnames(cor_matrix), bg = mycolors) %>%
##   align(align = "center", part = "all") %>%
##   compose(i = 1, j = 1, value = as_paragraph(""), part = "header") %>% 
##   colformat_num(j = colnames(cor_matrix), digits = 2) %>% 
##   autofit()
## ```
## 
## ## Another example 
## 
## ```{r}
## ft <- flextable(head(iris))
## 
## # measure column widths but only for the body part
## w_body <- dim_pretty(ft, part = "body")$widths
## # measure column widths only for the header part and get the max
## # as height value for rotated text
## h_header <- max( dim_pretty(ft, part = "header")$widths )
## 
## ft <- rotate(ft, j = 1:4, rotation="btlr",part="header")
## ft <- rotate(ft, j = 5, rotation="tbrl",part="header")
## 
## ft <- valign(ft, valign = "center", part = "header")
## ft <- align(ft, align = "center", part = "all")
## 
## # Manage header height
## ft <- height(ft, height = h_header * 1.1, part = "header")
## # ... mainly because Word don't handle auto height with rotated headers
## ft <- hrule(ft, i = 1, rule = "exact", part = "header")
## 
## ft <- set_caption(ft, caption = "iris dataset", autonum = run_autonum(bkm = "iris"))
## ft
## ```
## 
## 
## ## flextable - demo as_grouped_data
## 
## ```{r tab.cap='mean of carbon dioxide uptake in grass plants', tab.id='CO2-id', label='CO2-label'}
## data_CO2 <- dcast(as.data.table(CO2), 
##   Treatment + conc ~ Type, value.var = "uptake", fun.aggregate = mean)
## data_CO2 <- as_grouped_data(x = data_CO2, groups = c("Treatment"))
## 
## as_flextable( data_CO2 ) %>% 
##   bold(j = 1, i = ~ !is.na(Treatment), bold = TRUE, part = "body" ) %>% 
##   bold(part = "header", bold = TRUE ) %>% 
##   width(width = 1.5) %>% 
##   compose(i = ~ !is.na(conc), j = "conc", 
##           value = as_paragraph(
##             as_chunk(conc, formatter = function(x) sprintf("%.0f", x))
##           )
##   ) %>% add_footer_lines("dataset CO2 has been used for this flextable") %>% 
##   bg(bg = "#FFFFFF", part = "footer") %>% 
##   set_header_labels(conc = "Concentration") %>% 
##   width(width = c(1.5, 1, 1)) 
## ```

On génère le fichier HTML avec la fonction rmarkdown::render puis le contenu de ce fichier est stocké dans une chaîne de caractère :

out <- tempfile(fileext = ".html")
rmarkdown::render(an_rmd_example, output_file = out)
raw_html <- paste(readLines(out), collapse = "")

On peut désormais reprendre les mêmes opérations que précédemment :

body_message <- mime_part(raw_html)
body_message$headers$`Content-Type` <- "text/html"

mail_message <- list(body_message)

sendmail(
  from = "<arthur.dent@gmail.com>",
  to = "<ford.prefect@gmail.com>",
  subject = "this is not a towel",
  msg = mail_message,
  control = list(smtpServer = "ASPMX.L.GOOGLE.COM")
)

Complément : ajouter une pièce jointe

Pour l’illustration, on va envoyer aussi le fichier R Markdown comme pièce attachée. Dans la pratique, on a le plus souvent envie de joindre un fichier de données, la démarche est la même.

Il faut définir une nouvelle partie MIME et l’ajouter dans la liste mail_message :

rmd_attachment <- mime_part(x = an_rmd_example, name = "demo_html.Rmd")

mail_message <- list(body_message, rmd_attachment)

sendmail(
  from = "<arthur.dent@gmail.com>",
  to = "<ford.prefect@gmail.com>",
  subject = "this is not a towel",
  msg = mail_message,
  control = list(smtpServer = "ASPMX.L.GOOGLE.COM")
)

Commentaires

Attention à ne pas abuser de l’outil sendmailR - nous recevons déjà tous beaucoup TROP de mails - n’hésitez pas à regarder aussi du côté de slackr écrit par Bob Rudis et beaucoup d’autres. Egalement, faites attention à la taille du message que vous souhaitez envoyer (par exemple, n’envoyez pas des emails de 10 Mo).

Utilisez R Markdown pour aider à la composition de vos contenus depuis R. Si vous avez peu de contenu à envoyer, ce n’est pas vraiment critique ; mais si vous devez envoyer des tableaux, du texte, tout en prenant en compte des paramètres - R Markdown sera votre ami.

Ce post ne couvre qu’une petite partie d’un vaste sujet. Il faudrait idéalement couvrir aussi les problèmes engendrés par l’insertion de javascript, parler des pixels qui permettent de savoir si votre email est consulté, expliquer comment insérer des images… Peut-être une autre fois :)

Aller plus loin

Vous souhaitez aller plus loin dans la dissémination de vos reporting ; contactez nous et nous échangerons sur vos besoins.

Modules Shiny (partie 1) : Pourquoi les utiliser ?

info@ardata.fr (ArData) — Mon, 11 Feb 2019 00:00:00 +0000

Brève introduction aux modules Shiny

La construction d’application(s) Shiny complexes peut mener à dupliquer du code.
Les modules Shiny sont initialement la réponse à cette duplication.

Un module Shiny est un composant réutilisable au sein d’application(s) plus complexes.

On peut ainsi voir un module comme une fonction que l’on pourrait appeler n fois plutôt que de dupliquer du code.

Une application Shiny est composée :

D’un fichier ui.R pour l’interface.
D’un fichier server.R pour la logique serveur.
OU bien d’un seul fichier app.R qui défini l’interface et la logique serveur.

Tout comme l’application, le module est défini par 2 fonctions :

Une pour l’interface (suffixé par ‘_UI’ ou ‘UI’, ex = monModule_UI).
Une pour la logique serveur (ex = monModule).

Nous verrons ici les autres aspects positifs des modules, les situations favorables à leurs utilisations ainsi qu’une brève introduction à leur fonctionnement au travers d’un exemple hello-world.

NB : Cet article de Joe Cheng est une bonne introduction à la modularisation Shiny.

Répétition d’un module au sein d’une application

Dès lors que l’on a besoin de dupliquer un bloc de code UI et/ou des fonctions serveur on peut définir un module et l’utiliser autant de fois que nécessaire.

Dans l’exemple ci-dessous, le module createPlot est utilisé avec les jeux de données :

dataset_1
dataset_2
dataset_3

NB : Le module createPlot est défini par les fonctions :

createPlot pour la logique serveur.
createPlotUI pour l’interface.

Module within Shiny application

Répétition d’un module entre différentes applications

En cours de développement d’une application, il peut arriver que l’on ait besoin d’une “partie d’application” déjà créée ailleurs. Voici les étapes à suivre dans ce cas :

Convertir ces “parties d’application” en modules (cf 2 fonctions : interface & logique serveur).
Rassembler ces fonctions dans un package R.
Utiliser les modules à partir du package créé.

Rassembler les modules nous offre les avantages du packaging comme :

La seule mise à jour du package suffit à maintenir l’ensemble des applications Shiny.
On peut ajouter des tests au package avec testthat.
Ajout simplifié de la documentation.
etc…

NB : Pour toutes ces raisons, cette solution peut également être appropriée même dans le cas où les modules ne sont utilisés que dans une seule application.

Module across Shiny application

Pour une meilleure organisation des fichiers Shiny

L’ensemble des codes liés à une application Shiny peut être stocké dans les fichiers ui.R & server.R ou dans le seul fichier app.R.
Les modules permettent de séparer le code en plusieurs fichiers, ce qui facilite :

La compréhension de l’architecture.
La collaboration entre différents développeurs.

Cas 1 : réutilisation dans une seule application

Exemple d’application non modularisée :

application1
|___ server.R (1000 lines)
|___ ui.R     (500 lines)

Création de 2 modules (module_1 & module_2), réutilisés chacun n fois dans l’application1 :

application1
|___ server.R (300 lines)
|___ ui.R (200 lines)
|
|___ modules
    |___ module_1.R (200 lines)
    |___ module_2.R (200 lines)

On observe dans ce cas, une meilleure organisation des fichiers ainsi qu’un gain de lignes de codes (si les modules sont réutilisés au moins 2 fois).

Cas 2 : Mise à disposition d’un module au travers d’un package

Exemple d’applications non modularisées :

application1                    application2                    application3
|___ server.R (400 lines)       |___ server.R (400 lines)       |___ server.R (400 lines)
|___ ui.R     (250 lines)       |___ ui.R     (250 lines)       |___ ui.R     (250 lines)

Création d’un package qui contient le module_1 réutilisé dans les 3 applications :

packageModules
|___ module_1.R (350 lines)

application1                    application2                    application3
|___ server.R (200 lines)       |___ server.R (200 lines)       |___ server.R (200 lines)
|___ ui.R     (150 lines)       |___ ui.R     (150 lines)       |___ ui.R     (150 lines)

On observe un gain du nombre de lignes de code. On bénéficie également dans ce cas des avantages du packaging exprimés au chapitre précédent.

Résumé

Les bonnes raisons d’utiliser les modules Shiny :

Répliquer facilement une “petite application” au sein d’une application Shiny elle-même.
Eviter la réplication de code entre différentes applications Shiny.
Réorganiser les fichiers de code et gagner en lisibilité.
Rassembler ses modules afin de bénéficier des avantages du packaging R.

Hello Shiny module world

L’application ci-dessous décrit un exemple minimaliste Hello World. Son code est disponible dans ce répertoire GitHub. L’application est accessible en ligne.

Vous pouvez lancer l’application localement avec le code ci-dessous :

shiny::runGitHub(repo = "ardata-fr/shinyapps", subdir = "modules-hello-world")

app.R

Notez ici l’appel aux fonctions du module hello-world :

hello_worldUI dans la partie ui.
hello_world dans la partie server au travers de la fonction callModule.

library(shiny)

# load module functions
source("hello_world.R")

ui <- fluidPage(
    
    titlePanel("Using of Shiny modules"),
    
    fluidRow(
        # Call interface function of module "hello_world"
        hello_worldUI(id = "id_1")
    )
    
)

server <- function(input, output, session) {
    
    # Call logic server function of module "hello_world"
    callModule(module = hello_world, id = "id_1")
    
}

shinyApp(ui = ui, server = server)

hello_world.R

Notez ici la définition des 2 fonctions :

hello_worldUI qui définit l’interface
hello_world qui définit la logique serveur

# Function for module UI
hello_worldUI <- function(id) {
    ns <- NS(id)
    
    fluidPage(
        fluidRow(
            column(2, textInput(ns("TI_username"), label = NULL, placeholder = "your name")),
            column(2, actionButton(ns("AB_hello"), label = "Hello !"))
        ),
        hr(),
        fluidRow(
            column(12, textOutput(ns("TO_Hello_user")))
        )
    )
    
}

# Function for module server logic
hello_world <- function(input, output, session) {
    
    # When user clicks on "Hello" button : Update reactive variable "name"
    name <- eventReactive(input$AB_hello, {
        return(input$TI_username)
    })
    
    # Show greetings
    output$TO_Hello_user <- renderText({
        if (name() %in% "") {
            return("Hello world !")
        } else {
            return(paste("Hello", name(), "!"))
        }
    })
    
}

A suivre

Nous avons vu l’importance des modules Shiny et décrit un premier exemple simple.
Le mécanisme du transfert de données entre l’application Shiny et ses modules fera l’objet d’un prochain article.

Les nouveautés du package flextable 0.4.6

info@ardata.fr (ArData) — Wed, 05 Dec 2018 00:00:00 +0000

De nouvelles fonctions pour le package flextable sont disponibles depuis sa mise à jour le 31/09/2018. Ce post illustre deux nouvelles fonctionnalités :

des fonctions pour faciliter la gestion des bordures
des fonctions pour faciliter le formatage des contenus affichés des colonnes.

Pour l’illustration, on va utiliser des données provenant d’Eurostat.

Nous allons avoir besoin de charger quelques packages :

library(eurostat)
library(tidyr)
library(dplyr)
library(flextable)
library(officer)
library(magrittr)

Importons d’abord un jeu de données en utilisant le package eurostat.

raw_data <- get_eurostat(
  id = "hlth_hlye", time_format = "num", 
  filters = list(time = 2016),
  stringsAsFactors = FALSE)

eu_countries_ <- bind_rows(
    eu_countries, ea_countries, 
    efta_countries, eu_candidate_countries) %>% 
  distinct()

Voici à quoi ressemblent les données importées :

head(raw_data) %>% flextable()

unit	sex	indic_he	geo	time	values
PC	F	HLY_PC_0	AT	2,016	67.9
PC	F	HLY_PC_0	BE	2,016	75.8
PC	F	HLY_PC_0	BG	2,016	86.0
PC	F	HLY_PC_0	CH	2,016	67.4
PC	F	HLY_PC_0	CY	2,016	81.1
PC	F	HLY_PC_0	CZ	2,016	78.0

head(eu_countries_) %>% flextable()

code	name	label
BE	Belgium	Belgium
BG	Bulgaria	Bulgaria
CZ	Czechia	Czechia
DK	Denmark	Denmark
DE	Germany	Germany (until 1990 former territory of the FRG)
EE	Estonia	Estonia

Utilisons la fonction spread pour transformer les données en non tidy et faciliter l’affichage.

dat <- raw_data %>% 
  filter(indic_he %in% "HLY_PC_0", unit %in% "PC", sex %in% c("F", "M")) %>% 
  inner_join(eu_countries_, by = c("geo" = "code")) %>% 
  mutate(sex = paste0(sex, "_0_DFLE")) %>% 
  pivot_wider(id_cols = c(geo, name), names_from = sex, values_from = values)

head(dat) %>% flextable()

geo	name	F_0_DFLE	M_0_DFLE
AT	Austria	67.9	71.9
BE	Belgium	75.8	80.6
BG	Bulgaria	86.0	89.8
CH	Switzerland	67.4	74.7
CY	Cyprus	81.1	83.9
CZ	Czechia	78.0	82.4

Et maintenant on va créer un flextable :

flex_data <- head(dat, n=8) %>% 
  flextable(col_keys = c("geo", "name", "F_0_DFLE", "M_0_DFLE"))

flex_data <- set_header_labels(
  flex_data, geo = "Code pays", name = "Pays",
  F_0_DFLE = "\U2640", M_0_DFLE = "\U2642" )

flex_data <- add_header(flex_data, geo = "Code pays", name = "Pays", 
    F_0_DFLE = "Nombre d'années de vie en bonne santé à la naissance", 
    M_0_DFLE = "Nombre d'années de vie en bonne santé à la naissance" ,
    top = TRUE) 

flex_data <- merge_h(flex_data, part = "header")
flex_data <- merge_v(flex_data, part = "header")


flex_data <- align(flex_data, j = c("geo", "name"), align = 'center', part = "all")
flex_data <- align(flex_data, j = c("F_0_DFLE",  "M_0_DFLE"), 
                   align = 'right', part = "all")
flex_data <- padding(flex_data, padding.left = 5, padding.right = 5)

flex_data

Code pays	Pays	Nombre d'années de vie en bonne santé à la naissance
AT	Austria	67.9	71.9
BE	Belgium	75.8	80.6
BG	Bulgaria	86.0	89.8
CH	Switzerland	67.4	74.7
CY	Cyprus	81.1	83.9
CZ	Czechia	78.0	82.4
DE	Germany	80.7	83.1
DK	Denmark	72.8	76.3

Les nouvelles fonctions intégrées au package colformat_*, vline, hline ont été créées dans le but de faciliter la mise en forme des flextables.

`hline` et `vline`

Commençons par modifier les bordures à l’aide des fonctions hline et vline. Ces fonctions vont permettre de mettre en forme les interlignes horizontales et verticales du tableau. Il est possible de choisir la partie du tableau concernée par les modifications grâce au paramètre part =, soit “all”, “body”, “header” ou “footer”.

dash_border <- fp_border(color = "gray", style = "dashed")
big_border <- fp_border(color = "black", width = 2)

flex_data <- vline(x = flex_data, j = 1:4, border = dash_border ,part = "all")
flex_data <- hline(x = flex_data, border = dash_border, part = "body")
flex_data <- hline_bottom(x = flex_data, border = big_border, part = "all")

flex_data

Code pays	Pays	Nombre d'années de vie en bonne santé à la naissance
AT	Austria	67.9	71.9
BE	Belgium	75.8	80.6
BG	Bulgaria	86.0	89.8
CH	Switzerland	67.4	74.7
CY	Cyprus	81.1	83.9
CZ	Czechia	78.0	82.4
DE	Germany	80.7	83.1
DK	Denmark	72.8	76.3

`colformat_*`

Avant la dernière mise à jour, pour modifier l’affichage des données (quelle que soit la ligne ou la colonne) d’un flextable, comme supprimer les décimales pour la colonne années, ajouter une image, etc., nous pouvions utiliser la fonction display. Pour l’affichage des données d’un flextable (uniquement par colonnes), nous pouvions utiliser la fonction set_formatter.

flex_data <- display( 
  flex_data, 
  col_key = "time",
  pattern = "{{value}}",
  formatters = list(
    value ~ sprintf("%.0f", time)
    )
  )
flex_data

Apparement, utiliser display ou set_formatter c’est complexe. Plusieurs questions ont été posées sur stackoverflow-flextable et nous avons vu apparaître le besoin d’une fonction plus simple d’utilisation.

Ces fonctions sont très puissantes mais la majorité des besoins utilisateurs sont simples et devraient être possible avec peu de code. L’exemple ci-dessus le met plutôt bien en évidence, il y a beaucoup de code à taper alors que l’ordre à donner est simple: La colonne time doit être formatée avec l’appel sprintf("%.0f", time).

Afin d’offrir une fonction de formatage plus simple à utiliser, les fonctions colformat_* ont été créées.

Les fonctions colformat_* permettent de mettre facilement en forme le contenu des colonnes. Si plusieurs colonnes vont être modifiés de la même manière, il est possible de le faire dans la même instruction colformat_*.

L’option suffix = nous permet d’ajouter une valeur supplementaire à toutes les modalités d’une colonne, ici, nous ajoutons le suffixe years aux variables numeriques F_0_DFLE et M_0_DFLE.

Les options big.mark = et digits = modifient l’apparence des modalités numériques, big.mark = indiquera le séparateur des milliers et digits = permettra de choisir le nombre de chiffres après la virgule qui sera affiché.

flex_data <- colformat_num(x = flex_data, 
  j = c("F_0_DFLE",  "M_0_DFLE"),  
  suffix = " years", na_str = "-", digits = 1)

flex_data <- autofit(flex_data)
flex_data <- width(flex_data, j = 3:4, width = 1)
flex_data <- hline_top(flex_data, part = "all", border = big_border )

flex_data

Code pays	Pays	Nombre d'années de vie en bonne santé à la naissance
AT	Austria	67.9 years	71.9 years
BE	Belgium	75.8 years	80.6 years
BG	Bulgaria	86.0 years	89.8 years
CH	Switzerland	67.4 years	74.7 years
CY	Cyprus	81.1 years	83.9 years
CZ	Czechia	78.0 years	82.4 years
DE	Germany	80.7 years	83.1 years
DK	Denmark	72.8 years	76.3 years

Merci aux utilisateurs pour leur feedback, à plus tard pour d’autres news.

flextable 0.4.0 is out

info@ardata.fr (ArData) — Thu, 11 Jan 2018 00:00:00 +0000

The package flextable is existing since mid 2016 and I did not made any communication about it; obviously if I wrote it, I’d like it to be used by R users! That post is an attempt to fix that.

The flextable package makes it simpler to create tables for reporting purposes. The goal of the package is to provide a set of functions that can be used to design and format tabular reporting.

It’s been originally written in order to provide an alternative to ReporteRs::FlexTable objects that are not supported by package officer.

What the `flextable` package does

It lets customize tables, their formats and their contents. Formatting can be done on cells, paragraphs and text. It also lets you to insert headers and footer rows with eventually merged cells.

Common operations can be made with simple functions, i.e. use bold() to make a table selection bold, use align() to set alignment, merge_at() to merge contiguous cells, etc. Conditional formatting is possible with each of these functions.

Supported outputs

These objects can be rendered with R markdown documents. There is a knitr::knit_print method for HTML output and for Word output (thanks to Maxim Nazarov). Note that you will need pandoc >= 2.0.0 if you want to use Word output.

These objects can also be used with package officer and can be rendered into Word and PowerPoint documents (and Excel when I will find time and motivation for it).

xtable

A work started to support outputs from package xtable. It make statistical reporting easier for those used to work with xtable.

For now, only xtable objects are supported but xtableList will also be supported later.

library(xtable)
library(flextable)
temp.ts <- ts(cumsum(1 + round(rnorm(100), 0)),
  start = c(1954, 7), frequency = 12)
ft <- xtable_to_flextable(x = xtable(temp.ts, digits = 0),
  NA.string = "-")
ft

	Jan	Feb	Mar	Apr	May	Jun	Jul	Aug	Sep	Oct	Nov	Dec
1954							0.0	1.0	1.0	2.0	4.0	5.0
1955	5.0	7.0	5.0	7.0	7.0	8.0	9.0	10.0	11.0	11.0	12.0	13.0
1956	14.0	16.0	17.0	18.0	19.0	20.0	20.0	21.0	22.0	23.0	24.0	27.0
1957	27.0	29.0	31.0	33.0	35.0	36.0	38.0	41.0	41.0	42.0	45.0	45.0
1958	47.0	49.0	50.0	50.0	49.0	49.0	50.0	50.0	51.0	54.0	56.0	56.0
1959	57.0	59.0	59.0	59.0	60.0	61.0	61.0	63.0	65.0	64.0	65.0	66.0
1960	66.0	67.0	68.0	69.0	70.0	73.0	75.0	75.0	77.0	80.0	79.0	80.0
1961	80.0	80.0	81.0	82.0	83.0	84.0	86.0	85.0	85.0	86.0	90.0	94.0
1962	94.0	95.0	94.0	95.0	96.0	96.0	95.0	96.0	98.0	99.0

Preview

the function print() makes it easier to view the flextable inside all supported format.

By default, the print method display the flextable in an HTML page, if you are running R with RStudio, the flextable is displayed in the Viewer as an HTML table.

This can be change with argument preview. The document will be opened with the application associated to the file extension (Word or PowerPoint). This will not work on a Web server, i.e. RStudio Server.

library(flextable)

ft <- regulartable(head(iris))
ft <- theme_vanilla(ft)
ft <- width(ft, width = 1)
ft

Sepal.Length	Sepal.Width	Petal.Length	Petal.Width	Species
5.1	3.5	1.4	0.2	setosa
4.9	3.0	1.4	0.2	setosa
4.7	3.2	1.3	0.2	setosa
4.6	3.1	1.5	0.2	setosa
5.0	3.6	1.4	0.2	setosa
5.4	3.9	1.7	0.4	setosa

print(ft, preview = "log")

#> a flextable object.
#> col_keys: `Sepal.Length`, `Sepal.Width`, `Petal.Length`, `Petal.Width`, `Species` 
#> header has 1 row(s) 
#> body has 6 row(s) 
#> original dataset sample: 
#>   Sepal.Length Sepal.Width Petal.Length Petal.Width Species
#> 1          5.1         3.5          1.4         0.2  setosa
#> 2          4.9         3.0          1.4         0.2  setosa
#> 3          4.7         3.2          1.3         0.2  setosa
#> 4          4.6         3.1          1.5         0.2  setosa
#> 5          5.0         3.6          1.4         0.2  setosa

print(ft, preview = "docx")
print(ft, preview = "pptx")

Detailed example

Let’s first create a data.frame example from a sample of mtcars. We will use it as data source for our reporting table.

library(tibble)
library(magrittr)

dataset <- mtcars %>% 
  rownames_to_column(var = "car_name") %>% 
  head() %T>%
  print()

#>            car_name  mpg cyl disp  hp drat    wt  qsec vs am gear carb
#> 1         Mazda RX4 21.0   6  160 110 3.90 2.620 16.46  0  1    4    4
#> 2     Mazda RX4 Wag 21.0   6  160 110 3.90 2.875 17.02  0  1    4    4
#> 3        Datsun 710 22.8   4  108  93 3.85 2.320 18.61  1  1    4    1
#> 4    Hornet 4 Drive 21.4   6  258 110 3.08 3.215 19.44  1  0    3    1
#> 5 Hornet Sportabout 18.7   8  360 175 3.15 3.440 17.02  0  0    3    2
#> 6           Valiant 18.1   6  225 105 2.76 3.460 20.22  1  0    3    1

Now let’s use flextable API:

myft <- regulartable( dataset, 
  col_keys = c("car_name", "am", "carb", "gear", "blank", "mpg", "drat" )) %>% 
  theme_vanilla() %>% 
  width(j = c("am", "carb", "gear", "mpg", "drat" ), width = 1) %>% 
  width(j = 1, width = 2)
myft

car_name	am	carb	gear	mpg	drat
Mazda RX4	1	4	4	21.0	3.90
Mazda RX4 Wag	1	4	4	21.0	3.90
Datsun 710	1	1	4	22.8	3.85
Hornet 4 Drive	0	1	3	21.4	3.08
Hornet Sportabout	0	2	3	18.7	3.15
Valiant	0	1	3	18.1	2.76

We’ve just created a simple table. Let’s customize printed values.

# Change labels
myft <- myft %>% 
  set_header_labels(
    car_name = "Car name", am = "Transmission", carb = "# carburetors", 
    gear = "# forward gears", mpg = "Miles/(US) gallon", drat = "Rear axle ratio") 
myft <- myft %>% 
  add_header(mpg = "Some measures") %>% 
  merge_at(i = 1, j = c("mpg", "drat"), part = "header") %>% 
  set_formatter( 
    am = function(x) ifelse( x < 1, "automatic", "manual"),
    carb = function(x) sprintf("%.0f", x),
    gear = function(x) sprintf("%.0f", x)
    ) 
myft

				Some measures
Mazda RX4	manual	4	4	21.0	3.90
Mazda RX4 Wag	manual	4	4	21.0	3.90
Datsun 710	manual	1	4	22.8	3.85
Hornet 4 Drive	automatic	1	3	21.4	3.08
Hornet Sportabout	automatic	2	3	18.7	3.15
Valiant	automatic	1	3	18.1	2.76

And now let’s add some formattings.

myft <- myft %>% 
  bold(i = 3, bold = TRUE) %>% bold(j = 3, bold = TRUE) %>% 
  color(j = 3, color = "#4790b5") %>% color(i = 3, color = "#d24625") %>% 
  align(j = 3:6, align = "center", part = "all") %>% 
  empty_blanks()
myft

				Some measures
Mazda RX4	manual	4	4	21.0	3.90
Mazda RX4 Wag	manual	4	4	21.0	3.90
Datsun 710	manual	1	4	22.8	3.85
Hornet 4 Drive	automatic	1	3	21.4	3.08
Hornet Sportabout	automatic	2	3	18.7	3.15
Valiant	automatic	1	3	18.1	2.76

Finally, adjust widths and heights:

myft <- autofit(myft)
myft

				Some measures
Mazda RX4	manual	4	4	21.0	3.90
Mazda RX4 Wag	manual	4	4	21.0	3.90
Datsun 710	manual	1	4	22.8	3.85
Hornet 4 Drive	automatic	1	3	21.4	3.08
Hornet Sportabout	automatic	2	3	18.7	3.15
Valiant	automatic	1	3	18.1	2.76

With package officer

The following code is producing a PowerPoint document containing the flextable.

library(officer)
read_pptx() %>% 
  add_slide(layout = "Title and Content", master = "Office Theme") %>% 
  ph_with(myft, ph_location_type(type="body")) %>% 
  print(target = "../../static/files/flextable_example_01.pptx")

Download file flextable_example_01.pptx - view with office web viewer

The following code is producing a Word document containing the flextable.

library(officer)
read_docx() %>% 
  body_add_flextable(value = myft) %>% 
  print(target = "../../static/files/flextable_example_01.docx")

Download file flextable_example_01.docx - view with office web viewer

officer version 0.1.6

info@ardata.fr (ArData) — Wed, 13 Sep 2017 00:00:00 +0000

It’s time to announce the release of officer version 0.1.6. It allows to generate Microsoft documents from R; supported formats are Word and PowerPoint. It does come with other new packages¹:

flextable: produces sophisticated tables.
rvg: produces vector graphics for PowerPoints
mschart: produces native Microsoft charts

Package officer is the reboot of ReporteRs. It’s better, faster and does only rely on R.²

Example

Let’s have a demo. I have made a video for impatients:

First load packages:

library(officer)
library(flextable)
library(rvg)
library(mschart)
library(magrittr)
library(ggplot2)

We will use the following dataset:

Download file data.RDS

data <- readRDS(here("static/files/melanoma.RDS"))
flextable(data) %>% theme_vanilla() %>% autofit()

Status	Gender	Ulceration	n	Mean	SD
Alive	Female	Absent	68	1.693	2.004
Alive	Female	Present	23	2.972	2.593
Alive	Male	Absent	24	1.468	1.719
Alive	Male	Present	19	4.319	2.423
Melanoma	Female	Absent	8	2.139	1.184
Melanoma	Female	Present	20	4.724	4.128
Melanoma	Male	Absent	8	3.266	4.681
Melanoma	Male	Present	21	5.143	2.862
Non-melanoma	Female	Absent	3	1.667	1.141
Non-melanoma	Female	Present	4	3.302	3.713
Non-melanoma	Male	Absent	4	2.420	2.499
Non-melanoma	Male	Present	3	8.053	4.019

First let’s create a ggplot object:

gg <- ggplot(data, aes(x = Ulceration , y = Mean, colour = Gender, size = n)) + 
  geom_point() + 
  facet_wrap(~Status ) + 
  theme_minimal()
gg

Then a summary table:

ft <- flextable(data = head(data)) %>% 
  theme_booktabs() %>% 
  set_header_labels( n = "#", Mean = "\u03D1", SD = "\u03C3") %>% 
  color(i = ~ n < 4, color = "wheat") %>% 
  autofit() 
ft

Status	Gender	Ulceration	#	ϑ	σ
Alive	Female	Absent	68	1.693	2.004
Alive	Female	Present	23	2.972	2.593
Alive	Male	Absent	24	1.468	1.719
Alive	Male	Present	19	4.319	2.423
Melanoma	Female	Absent	8	2.139	1.184
Melanoma	Female	Present	20	4.724	4.128

A Microsoft chart:

scatter_ms <- ms_scatterchart(data = data, x = "Mean", y = "n", group = "Status")

And gather them in a new PowerPoint document:

read_pptx() %>% 
  # add a slide then the flextable
  add_slide(layout = "Title and Content", master = "Office Theme") %>% 
  ph_with(ft, location = ph_location_type(type="body") ) %>% 
  # add a slide then the ggplot
  add_slide(layout = "Title and Content", master = "Office Theme") %>% 
  ph_with(dml(code = print(gg)), location = ph_location_type(type="body")) %>% 
  # add a slide then the microsoft chart
  add_slide(layout = "Title and Content", master = "Office Theme") %>% 
  ph_with(scatter_ms, location = ph_location_type(type="body")) %>% 
  # generate pptx
  print(target = here("static/files/melanoma.pptx")) %>% 
  invisible()

Download file melanoma.pptx - view with office web viewer

Documentation

The documentation of the packages can be found here:

officer: https://davidgohel.github.io/officer
flextable: https://davidgohel.github.io/flextable
mschart: https://ardata-fr.github.io/mschart

What’s next

I will work later on:

Fix issues if any.
Add a minimal support for Excel files with flextables, vector graphics.
Add pages headers and footers support for Word files.

I will write more about these in future posts.↩︎
ReporteRs exists since beginning of 2014. In the beginning, everything was under control, I was able to help or debug when necessary. But then the package became more popular and support started to be painful; because of rJava dependency and other reasons. The best solution was to rewrite the package so that I could do something better without breaking existing codes of users that choosed ReporteRs…↩︎

ggiraph 0.3.3 est sur le CRAN

info@ardata.fr (ArData) — Wed, 29 Mar 2017 00:00:00 +0000

Je suis content d’annoncer la sortie de la version 0.3.3 de ggiraph.

Etant assez pris, je n’avait pas fait évolué le package depuis quelques mois. J’ai finalement trouvé le temps de travailler dessus.

Le pan est maintenant ajusté au niveau du zoom.
ggiraph() a un nouvel argument ggobj pour éviter d’avoir à utiliser la fonction print dans l’argument code.
La gestion de la taille des graphiques (des htmlwidgets en fait) est grandement améliorée.

Allez, une petite illustration :

On créé d’abord un objet ggplot mais on utilise un geom spécifique geom_point_interactive.

library(ggplot2)
library(ggiraph)

gg1 <- ggplot(data = mtcars, 
  mapping = aes(x = wt, y = mpg, size = disp, color = as.factor(carb) ) ) +
  geom_point_interactive(aes(tooltip = row.names(mtcars), data_id = row.names(mtcars))) +
  scale_color_brewer(palette = "Set1", name = "carb") +
  scale_size(range = c(1, 15), name = "disp") +
  scale_x_continuous(limits = c(1, 6)) +
  scale_y_continuous(limits = c(7, 36)) +
  theme_minimal() +
  theme(legend.position = "bottom")

Maintenant, l’appel ggiraph :

ggiraph(ggobj = gg1 )

Règlons le zoom et fixons la taille (un pourcentage de la largeur de l’espace pour le graphique) :

x <- girafe(ggobj = gg1 )
girafe_options(x = x, opts_sizing(width = .5), opts_zoom(max = 4), 
  opts_hover(css = "fill:wheat;stroke:black;stroke-width:2px;") )

Bientôt, une version avec la sélection lasso dans Shiny. Cela permet de sélectionner/désélectionner beaucoup d’éléments en créant un lasso avec la souris.

Premier post

info@ardata.fr (ArData) — Tue, 28 Mar 2017 00:00:00 +0000

C’est le premier message du blog.

Jusqu’à présent, je n’avais pas le bon outil pour écrire un blog. Grâce au package blogdown de Yihui Xie, je n’ai plus d’excuse…

variable	stat		nonchilled		chilled		Overall
	Est.	N		Est.	N		Est.	N
Type	Quebec			21 (50.0 %)			21 (50.0 %)			42 (50.0 %)
Mississippi			21 (50.0 %)			21 (50.0 %)			42 (50.0 %)
Missing			0 (0.0 %)			0 (0.0 %)			0 (0.0 %)
conc	Min.		95.0			95.0			95.0
1st Qu.		175.0			175.0			175.0
Mean		435.0			435.0			435.0
Median		350.0			350.0			350.0
3rd Qu.		675.0			675.0			675.0
Max.		1 000.0			1 000.0			1 000.0
Missing			0 (0.0 %)			0 (0.0 %)			0 (0.0 %)
uptake	Min.		10.6			7.7			7.7
1st Qu.		26.5			14.5			17.9
Mean		30.6			23.8			27.2
Median		31.3			19.7			28.3
3rd Qu.		38.7			34.9			37.1
Max.		45.5			42.4			45.5
Missing			0 (0.0 %)			0 (0.0 %)			0 (0.0 %)

Subset of original dataset
cut	color		I1 (n = 180)		SI1 (n = 4800)		VS2 (n = 3569)
Good n = 2634	D		3.5 (± 2.2)		3.0 (± 2.8)		3.6 (± 3.4)
E		4.4 (± 2.5)		3.2 (± 3.1)		3.8 (± 3.3)
F		2.6 (± 1.9)		3.3 (± 3.0)		3.8 (± 3.2)
G		3.2 (± 2.0)		4.1 (± 3.9)		4.1 (± 3.3)
H		3.8 (± 2.2)		4.2 (± 3.8)		4.4 (± 4.2)
I		4.2 (± 2.9)		4.7 (± 4.5)		6.0 (± 5.1)
J		3.8 (± 2.1)		4.6 (± 3.9)		4.8 (± 3.6)
Very Good n = 5915	D		2.6 (± 0.8)		3.2 (± 2.9)		3.1 (± 3.3)
E		3.4 (± 2.2)		3.2 (± 3.1)		3.3 (± 3.5)
F		4.3 (± 2.6)		3.6 (± 3.2)		4.0 (± 3.8)
G		3.2 (± 2.1)		3.5 (± 3.6)		4.4 (± 4.0)
H		5.3 (± 2.5)		4.9 (± 4.4)		4.6 (± 4.0)
I		6.0 (± 4.9)		5.2 (± 4.5)		5.8 (± 5.1)
J		4.5 (± 2.7)		5.0 (± 4.1)		5.3 (± 4.5)

				Some measures
Car name	Transmission	# carburetors	# forward gears	Miles/(US) gallon	Rear axle ratio
Mazda RX4	manual	4	4	21.0	3.90
Mazda RX4 Wag	manual	4	4	21.0	3.90
Datsun 710	manual	1	4	22.8	3.85
Hornet 4 Drive	automatic	1	3	21.4	3.08
Hornet Sportabout	automatic	2	3	18.7	3.15
Valiant	automatic	1	3	18.1	2.76

Blog on ArData

Les nouveautés de flextable 0.9.11

Intégration avec patchwork

Aligner les lignes avec flex_body

Aligner les colonnes avec flex_cols

Quarto markdown dans les cellules

flextable et tabular

Exemple avec tabular

Transformation en flextable

Le séparateur de lignes

Améliorer avec flextable

Ajout dans un document

flextable supporte le format RTF

utilisations

Le tableau pour l’illustration

Préparations

Le flextable

Les annotations

Production du RTF

flextable et les 'grid graphics'

Exporter un flextable en png

La fonction gen_grob

Utilisation simple

Les options de redimensionnements

Déroulement du contenu dans les cellules

Mettre à jour les champs et Word documents update from R with doconv

La version 0.7.2 de flextable est sortie

tabulator

Summarizor pour les résumés de tableaux

Impression automatique des flextable

Les data.frames en flextables

Les modèles en flextables

Separation des entêtes

GitHub Discussions

R VS SAS

Sélection de colonnes

Programme SAS

Programme R

Sélection de lignes

Programme SAS

Programme R

Tri d’une table

Programme SAS

Programme R

Renommage d’une variable

Programme SAS

Programme R

Création d’une nouvelle variable

Programme SAS

Programme R

Combinaison verticale de tables

Programme SAS

Programme R

Combinaison horizontale de tables

Programme SAS

Programme R

Quelques fonctions équivalentes à certaines PROC

PROC IMPORT

Programme SAS

Programme R

PROC MEANS

Programme SAS

Programme R

PROC TRANSPOSE

Programme SAS

Programme R

PROC FREQ

Programme SAS

Programme R

PROC CORR

Programme SAS

Programme R

PROC REG

Programme SAS

Programme R

Modules Shiny (partie 3) : Appel dynamique de modules

Si vous souhaitez jouer les exemples en local

Exemple 1 : Récupérer seulement l’output UI

Initialiser rv$all_ui

Appel dynamique au travers d’un observeEvent

Aligner les lignes avec `flex_body`

Aligner les colonnes avec `flex_cols`

Exemple 1 : Récupérer seulement l’output `UI`

Initialiser `rv$all_ui`

Appel dynamique au travers d’un `observeEvent`

Agencement des éléments `UI`

Exemple 2 : Récupérer les sorties `UI` & `server`

Appel dynamique au travers d’un `observeEvent`

Utiliser les sorties `server` dans l’application

Bonus : Fermer un `tabPanel`

`hline` et `vline`

`colformat_*`

What the `flextable` package does