Title: “Introducing ggbrick: A New Way to Visualize Data on CRAN”

If you’re looking for something a little different, ggbrick creates a ‘waffle’ style chart with the aesthetic of a brick wall. The usage is similar to geom_col where you supply counts as the height of the bar and a fill for a stacked bar. Each whole brick represents 1 unit. Two half bricks equal one whole brick.

It has been available on Git for a while, but recently I’ve made some changes and it now has CRAN’s tick of approval.

Installation

install.packages("ggbrick")

Geoms

There are two main geoms included:

1. geom_brick(): To make the brick wall-style waffle chart.
2. geom_waffle(): To make a regular-style waffle chart.

geom_brick()

Use geom_brick() the same way you would use geom_col().

library(dplyr)
library(ggplot2)
library(ggbrick)

# basic usage
mpg |>
  count(class, drv) |>
  ggplot() +
  geom_brick(aes(class, n, fill = drv)) +
  coord_brick()

coord_brick() is included to maintain the aspect ratio of the bricks. It is similar to coord_fixed(), in fact, it is just a wrapper for coord_fixed() with a parameterised aspect ratio based on the number of bricks. The default number of bricks is 4. To change the width of the line outlining the brick use the linewidth parameter as normal.

To change specify the bricks_per_layer parameter in the geom and coord functions.

mpg |>
  count(class, drv) |>
  ggplot() +
  geom_brick(aes(class, n, fill = drv), bricks_per_layer = 6) +
  coord_brick(6)

You can change the width of the columns similar to geom_col() to add more space between the bars. To maintain the aspect ratio you also need to set the width in coord_brick().

mpg |>
  count(class, drv) |>
  ggplot() +
  geom_brick(aes(class, n, fill = drv), width = 0.5) +
  coord_brick(width = 0.5)

To get more space between each brick use the gap parameter.

mpg |>
  count(class, drv) |>
  ggplot() +
  geom_brick(aes(class, n, fill = drv), gap = 0.04) +
  coord_brick()

For no gap set gap = 0 or use the shorthand geom_brick0().

mpg |>
  count(class, drv) |>
  ggplot() +
  geom_brick0(aes(class, n, fill = drv)) +
  coord_brick()

For fun, I’ve included a parameter to randomise the fill of the bricks or add a small amount of variation at the join between two groups. The proportions are maintained and designed to just give a different visual.

mpg |>
  count(class, drv) |>
  ggplot() +
  geom_brick(aes(class, n, fill = drv), type = "soft_random") +
  coord_brick()

mpg |>
  count(class, drv) |>
  ggplot() +
  geom_brick(aes(class, n, fill = drv), type = "random") +
  coord_brick()

geom_waffle()

geom_waffle() has the same functionality as geom_brick() but the bricks are square giving a standard waffle chart. I added this so you can make a normal waffle chart in the same way you would use geom_col(). It requires coord_waffle(). To maintain the aspect ratio.

mpg |>
  count(class, drv) |>
  ggplot() +
  geom_waffle(aes(class, n, fill = drv)) +
  coord_waffle()

mpg |>
  count(class, drv) |>
  ggplot() +
  geom_waffle0(aes(class, n, fill = drv), bricks_per_layer = 6) +
  coord_waffle(6)

You may want to flip the coords when using geom_waffle(). To do so you’ll need to use coord_flip() and theme(aspect.ratio = <number>). I haven’t made a coord_waffle_flip(), yet!

mpg |>
  count(class, drv) |>
  ggplot() +
  geom_waffle0(aes(class, n, fill = drv)) +
  coord_flip() +
  theme(aspect.ratio = 1.8)

Use {ggfx}

I think geom_brick() pairs with with_shadow() and with_inner_blur() pretty well!

library(ggbrick)
library(ggfx)

font_add_google("Karla", "karla")
showtext_auto()
ft <- "karla"
txt <- "grey10"
bg <- "white"

survivoR::challenge_results |>
  filter(
    version == "US",
    outcome_type == "Individual",
    result == "Won"
    ) |>
   left_join(
      survivoR::castaway_details |>
        select(castaway_id, gender, bipoc),
      by = "castaway_id"
   ) |>
  left_join(
    survivoR::challenge_description |>
      mutate(type = ifelse(race, "Race", "Endurance")) |>
      select(version_season, challenge_id, type),
    by = c("version_season", "challenge_id")
  ) |>
  count(type, gender) |>
  drop_na() |>
  ggplot() +
  with_shadow(
    with_inner_glow(
      geom_brick(aes(type, n, fill = gender), linewidth = 0.1, bricks_per_layer = 6)
    ),
    x_offset = 4,
    y_offset = 4
  ) +
  coord_brick(6) +
  scale_fill_manual(values = blue_pink[c(5, 1, 4)]) +
  labs(
    title = toupper("Survivor Challenges"),
    subtitle = "Approximately a third of races and half of endurance challengesnare won by women.",
    fill = "Gender",
    caption = "Individual challenges only. The different proportions of men and women at merge hasn't been taken into consideration."
  ) +
  theme_void() +
  theme(
    text = element_text(family = ft, colour = txt, lineheight = 0.3, size = 32),
    plot.background = element_rect(fill = bg, colour = bg),
    plot.title = element_markdown(size = 128, colour = txt, hjust = 0.5, margin = margin(b = 10)),
    plot.subtitle = element_text(hjust = 0.5, size = 48, margin = margin(b = 30)),
    plot.caption = element_text(size = 24, hjust = 0, margin = margin(t = 20)),
    axis.text = element_text(vjust = 0),
    axis.title.y = element_blank(),
    plot.margin = margin(t = 30, b = 10, l = 30, r = 30),
    legend.position = "top"
  )

The post ggbrick is now on CRAN appeared first on Dan Oehm | Gradient Descending.

Continue reading: ggbrick is now on CRAN

Overview

The recently introduced ‘ggbrick’ package in R has acquired CRAN’s tick of approval. ‘ggbrick’ extends visualization capabilities in R by creating new chart types known as geom_brick() and geom_waffle() that functions like a ‘geom_col’.

Long-Term Implications

The ‘ggbrick’ package amplifies R’s data visualization capabilities — an essential aspect of data analysis. It introduces a new way of representing data using a ‘waffle’ style chart that offers a different aesthetic and comparative perspective to routine bar charts. This shift can enhance data interpretation processes across various fields, allowing more extensive and more comprehensive analysis. The adoption of these new chart types may potentially lead to new patterns and trends being discovered.

Possible Future Developments

The ‘ggbrick’ package is a relatively recent addition and developers are improving it. Currently, it offers two main geoms: geom_brick() and geom_waffle(). Future developments may see the addition of more geoms and alterations to existing ones, to offer a wider range of aesthetic options and functionalities based on user feedback and needs. The package may consider adding flexibility in terms of shapes, designs and representations.

Actionable Advice

R users and data analysts are recommended to familiarise themselves with the ‘ggbrick’ package and its functionality. To begin with, the ‘ggbrick’ package can be installed with the command: install.packages(“ggbrick”). Further, it might be beneficial to explore different scenarios and compare the visual output from ‘ggbrick’ with traditional visualization packages in R. This exercise would help users leverage the package effectively in relevant contexts. Continued monitoring of package updates and effective usage can help in staying ahead of data visualization trends in the world of data analytics.

Read the original article