Package 'ggiraph'

Description

The layer is based on ggplot2::annotate(). See the documentation for that function for more details.

Usage

annotate_interactive(...)

Arguments

Details for annotate_*_interactive functions

The interactive parameters can be supplied as arguments in the relevant function and they can be scalar values or vectors depending on params on base function.

See Also

girafe(), interactive_parameters, annotation_raster_interactive()

Examples

# add interactive annotation to a ggplot -------
library(ggplot2)
library(ggiraph)
library(gdtools)

register_liberationsans()

gg <- ggplot(mtcars, aes(x = disp, y = qsec)) +
  geom_point(size = 2) +
  annotate_interactive(
    "rect",
    xmin = 100,
    xmax = 400,
    fill = "red",
    data_id = "an_id",
    tooltip = "a tooltip",
    ymin = 18,
    ymax = 20,
    alpha = .5
  ) +
  theme_minimal(base_family = "Liberation Sans", base_size = 11)

girafe(
  ggobj = gg,
  width_svg = 5,
  height_svg = 4,
  dependencies = list(
    liberationsansHtmlDependency()
  )
)

Description

The layer is based on ggplot2::annotation_raster(). See the documentation for that function for more details.

Usage

annotation_raster_interactive(...)

Arguments

Details for annotate_*_interactive functions

The interactive parameters can be supplied as arguments in the relevant function and they can be scalar values or vectors depending on params on base function.

See Also

girafe()

Examples

# add interactive raster annotation to a ggplot -------
library(ggplot2)
library(ggiraph)

# Generate data
rainbow <- matrix(hcl(seq(0, 360, length.out = 50 * 50), 80, 70), nrow = 50)
p <- ggplot(mtcars, aes(mpg, wt)) +
  geom_point() +
  annotation_raster_interactive(
    rainbow,
    15,
    20,
    3,
    4,
    tooltip = "I am an image!"
  )
x <- girafe(ggobj = p)
if (interactive()) {
  print(x)
}

# To fill up whole plot
p <- ggplot(mtcars, aes(mpg, wt)) +
  annotation_raster_interactive(
    rainbow,
    -Inf,
    Inf,
    -Inf,
    Inf,
    tooltip = "I am an image too!"
  ) +
  geom_point()
x <- girafe(ggobj = p)
if (interactive()) {
  print(x)
}

Description

This function produces SVG files (compliant to the current w3 svg XML standard) where elements can be made interactive.

In order to generate the output, used fonts must be available on the computer used to create the svg, used fonts must also be available on the computer used to render the svg.

Usage

dsvg(
  file = "Rplots.svg",
  width = 6,
  height = 6,
  bg = "white",
  pointsize = 12,
  standalone = TRUE,
  setdims = TRUE,
  canvas_id = "svg_1",
  title = NULL,
  desc = NULL,
  fonts = list()
)

Arguments

See Also

Devices

Examples

fileout <- tempfile(fileext = ".svg")
dsvg(file = fileout)
plot(rnorm(10), main="Simple Example", xlab = "", ylab = "")
dev.off()

Description

This is useful primarily for testing. Requires the htmltools package.

Usage

dsvg_view(code, ...)

Arguments

Examples

dsvg_view(plot(1:10))
dsvg_view(hist(rnorm(100)))

Description

With these functions the user can add interactivity to various ggplot2::theme() elements.

They are based on ggplot2::element_rect(), ggplot2::element_line() and ggplot2::element_text() See the documentation for those functions for more details.

Usage

element_line_interactive(...)

element_rect_interactive(...)

element_text_interactive(...)

Arguments

Details for element_*_interactive functions

The interactive parameters can be supplied as arguments in the relevant function and they should be scalar values.

For theme text elements (element_text_interactive()), the interactive parameters can also be supplied while setting a label value, via the ggplot2::labs() family of functions or when setting a scale/guide title or key label. Instead of setting a character value for the element, function label_interactive() can be used to define interactive parameters to go along with the label. When the parameters are supplied that way, they override the default values that are set at the theme via element_text_interactive() or via the guide's theme parameters.

See Also

girafe()

Examples

# add interactive theme elements -------
library(ggplot2)
library(ggiraph)
library(gdtools)

register_liberationsans()

dataset <- structure(
  list(
    qsec = c(16.46, 17.02, 18.61, 19.44, 17.02, 20.22),
    disp = c(160, 160, 108, 258, 360, 225),
    carname = c(
      "Mazda RX4",
      "Mazda RX4 Wag",
      "Datsun 710",
      "Hornet 4 Drive",
      "Hornet Sportabout",
      "Valiant"
    ),
    wt = c(2.62, 2.875, 2.32, 3.215, 3.44, 3.46)
  ),
  row.names = c(
    "Mazda RX4",
    "Mazda RX4 Wag",
    "Datsun 710",
    "Hornet 4 Drive",
    "Hornet Sportabout",
    "Valiant"
  ),
  class = "data.frame"
)

# plots
gg_point = ggplot(data = dataset) +
  geom_point_interactive(aes(
    x = wt,
    y = qsec,
    color = disp,
    tooltip = carname,
    data_id = carname
  )) +
  theme_minimal(base_family = "Liberation Sans", base_size = 11) +
  theme(
    plot.title = element_text_interactive(
      data_id = "plot.title",
      tooltip = "plot title",
      hover_css = "fill:red;stroke:none;font-size:12pt"
    ),
    plot.subtitle = element_text_interactive(
      data_id = "plot.subtitle",
      tooltip = "plot subtitle",
      hover_css = "fill:none;"
    ),
    axis.title.x = element_text_interactive(
      data_id = "axis.title.x",
      tooltip = "Description for x axis",
      hover_css = "fill:red;stroke:none;"
    ),
    axis.title.y = element_text_interactive(
      data_id = "axis.title.y",
      tooltip = "Description for y axis",
      hover_css = "fill:red;stroke:none;"
    ),
    panel.grid.major = element_line_interactive(
      data_id = "panel.grid",
      tooltip = "Major grid lines",
      hover_css = "fill:none;stroke:red;"
    )
  ) +
  labs(
    title = "Interactive points example!",
    subtitle = label_interactive(
      "by ggiraph",
      tooltip = "Click me!",
      onclick = "window.open(\"https://davidgohel.github.io/ggiraph/\")",
      hover_css = "fill:magenta;cursor:pointer;"
    )
  )

x <- girafe(
  ggobj = gg_point,
  dependencies = list(
    liberationsansHtmlDependency()
  )
)
if (interactive()) {
  print(x)
}

Description

These facets are based on ggplot2::facet_grid().

To make a facet interactive, it is mandatory to use labeller_interactive() for argument labeller.

Usage

facet_grid_interactive(..., interactive_on = "text")

Arguments

Value

An interactive facetting object.

See Also

girafe()

Description

These facets are based on ggplot2::facet_wrap().

To make a facet interactive, it is mandatory to use labeller_interactive() for argument labeller.

Usage

facet_wrap_interactive(..., interactive_on = "text")

Arguments

Value

An interactive facetting object.

See Also

girafe()

Description

These geometries are based on ggplot2::geom_abline(), ggplot2::geom_hline() and ggplot2::geom_vline().

Usage

geom_abline_interactive(...)

geom_hline_interactive(...)

geom_vline_interactive(...)

Arguments

Details for interactive geom functions

The interactive parameters can be supplied with two ways:

• As aesthetics with the mapping argument (via ggplot2::aes()). In this way they can be mapped to data columns and apply to a set of geometries.

• As plain arguments into the geom_*_interactive function. In this way they can be set to a scalar value.

See Also

girafe()

girafe()

girafe()

Examples

# add diagonal interactive reference lines to a ggplot -------
library(ggplot2)
library(ggiraph)

p <- ggplot(mtcars, aes(wt, mpg)) + geom_point()
g <- p + geom_abline_interactive(intercept = 20, tooltip = 20)
x <- girafe(ggobj = g)
if (interactive()) {
  print(x)
}

l <- coef(lm(mpg ~ wt, data = mtcars))
g <- p +
  geom_abline_interactive(
    intercept = l[[1]],
    slope = l[[2]],
    tooltip = paste("intercept:", l[[1]], "\nslope:", l[[2]]),
    data_id = "abline"
  )
x <- girafe(ggobj = g)
x <- girafe_options(
  x = x,
  opts_hover(css = "cursor:pointer;fill:orange;stroke:orange;")
)
if (interactive()) {
  print(x)
}
# add horizontal interactive reference lines to a ggplot -------
library(ggplot2)
library(ggiraph)

if (requireNamespace("dplyr", quietly = TRUE)) {
  g1 <- ggplot(economics, aes(x = date, y = unemploy)) +
    geom_point() +
    geom_line()

  gg_hline1 <- g1 +
    geom_hline_interactive(
      aes(yintercept = mean(unemploy), tooltip = round(mean(unemploy), 2)),
      linewidth = 3
    )
  x <- girafe(ggobj = gg_hline1)
  if (interactive()) print(x)
}

dataset <- data.frame(
  x = c(1, 2, 5, 6, 8),
  y = c(3, 6, 2, 8, 7),
  vx = c(1, 1.5, 0.8, 0.5, 1.3),
  vy = c(0.2, 1.3, 1.7, 0.8, 1.4),
  year = c(2014, 2015, 2016, 2017, 2018)
)

dataset$clickjs <- rep(paste0("alert(\"", mean(dataset$y), "\")"), 5)


g2 <- ggplot(dataset, aes(x = year, y = y)) +
  geom_point() +
  geom_line()

gg_hline2 <- g2 +
  geom_hline_interactive(
    aes(
      yintercept = mean(y),
      tooltip = round(mean(y), 2),
      data_id = y,
      onclick = clickjs
    )
  )

x <- girafe(ggobj = gg_hline2)
if (interactive()) {
  print(x)
}
# add vertical interactive reference lines to a ggplot -------
library(ggplot2)
library(ggiraph)

if (requireNamespace("dplyr", quietly = TRUE)) {
  g1 <- ggplot(diamonds, aes(carat)) +
    geom_histogram()

  gg_vline1 <- g1 +
    geom_vline_interactive(
      aes(
        xintercept = mean(carat),
        tooltip = round(mean(carat), 2),
        data_id = carat
      ),
      linewidth = 3
    )
  x <- girafe(ggobj = gg_vline1)
  if (interactive()) print(x)
}

dataset <- data.frame(x = rnorm(100))

dataset$clickjs <- rep(
  paste0("alert(\"", round(mean(dataset$x), 2), "\")"),
  100
)

g2 <- ggplot(dataset, aes(x)) +
  geom_density(fill = "#000000", alpha = 0.7)
gg_vline2 <- g2 +
  geom_vline_interactive(
    aes(
      xintercept = mean(x),
      tooltip = round(mean(x), 2),
      data_id = x,
      onclick = clickjs
    ),
    color = "white"
  )

x <- girafe(ggobj = gg_vline2)
x <- girafe_options(
  x = x,
  opts_hover(css = "cursor:pointer;fill:orange;stroke:orange;")
)
if (interactive()) {
  print(x)
}

Description

The geometries are based on ggplot2::geom_bar() and ggplot2::geom_col(). See the documentation for those functions for more details.

Usage

geom_bar_interactive(...)

geom_col_interactive(...)

Arguments

Details for interactive geom functions

The interactive parameters can be supplied with two ways:

• As aesthetics with the mapping argument (via ggplot2::aes()). In this way they can be mapped to data columns and apply to a set of geometries.

• As plain arguments into the geom_*_interactive function. In this way they can be set to a scalar value.

See Also

girafe()

Examples

# add interactive bar -------
library(ggplot2)
library(ggiraph)
library(gdtools)

register_liberationsans()

p <- ggplot(mpg, aes(x = class, tooltip = class, data_id = class)) +
  geom_bar_interactive() +
  theme_minimal(base_family = "Liberation Sans", base_size = 11)

x <- girafe(
  ggobj = p,
  dependencies = list(
    liberationsansHtmlDependency()
  )
)
if (interactive()) {
  print(x)
}

dat <- data.frame(
  name = c("David", "Constance", "Leonie"),
  gender = c("Male", "Female", "Female"),
  height = c(172, 159, 71)
)
p <- ggplot(dat, aes(x = name, y = height, tooltip = gender, data_id = name)) +
  geom_col_interactive() +
  theme_minimal(base_family = "Liberation Sans", base_size = 11)

x <- girafe(
  ggobj = p,
  dependencies = list(
    liberationsansHtmlDependency()
  )
)
if (interactive()) {
  print(x)
}

# an example with interactive guide ----
dat <- data.frame(
  name = c("Guy", "Ginette", "David", "Cedric", "Frederic"),
  gender = c("Male", "Female", "Male", "Male", "Male"),
  height = c(169, 160, 171, 172, 171)
)
p <- ggplot(dat, aes(x = name, y = height, fill = gender, data_id = name)) +
  geom_bar_interactive(stat = "identity") +
  scale_fill_manual_interactive(
    values = c(Male = "#0072B2", Female = "#009E73"),
    data_id = c(Female = "Female", Male = "Male"),
    tooltip = c(Male = "Male", Female = "Female")
  ) +
  theme_minimal(base_family = "Liberation Sans", base_size = 11)
x <- girafe(
  ggobj = p,
  dependencies = list(
    liberationsansHtmlDependency()
  )
)
if (interactive()) {
  print(x)
}

Description

The geometry is based on ggplot2::geom_bin_2d(). See the documentation for those functions for more details.

Usage

geom_bin_2d_interactive(...)

Arguments

Details for interactive geom functions

The interactive parameters can be supplied with two ways:

• As aesthetics with the mapping argument (via ggplot2::aes()). In this way they can be mapped to data columns and apply to a set of geometries.

• As plain arguments into the geom_*_interactive function. In this way they can be set to a scalar value.

See Also

girafe()

Examples

# add interactive bin2d heatmap to a ggplot -------
library(ggplot2)
library(ggiraph)

p <- ggplot(diamonds, aes(x, y, fill = cut)) +
  xlim(4, 10) +
  ylim(4, 10) +
  geom_bin2d_interactive(aes(tooltip = cut), bins = 30)

x <- girafe(ggobj = p)
if (interactive()) {
  print(x)
}

Description

The geometry is based on ggplot2::geom_boxplot(). See the documentation for that function for more details.

Usage

geom_boxplot_interactive(...)

Arguments

Details

You can supply ⁠interactive parameters⁠ for the outlier points by prefixing them with outlier. prefix. For example: aes(outlier.tooltip = 'bla', outlier.data_id = 'blabla').

IMPORTANT: when supplying outlier interactive parameters, the correct group aesthetic must be also supplied. Otherwise the default group calculation will be incorrect, which will result in an incorrect plot.

Details for interactive geom functions

The interactive parameters can be supplied with two ways:

• As aesthetics with the mapping argument (via ggplot2::aes()). In this way they can be mapped to data columns and apply to a set of geometries.

• As plain arguments into the geom_*_interactive function. In this way they can be set to a scalar value.

See Also

girafe()

Examples

# add interactive boxplot -------
library(ggplot2)
library(ggiraph)

p <- ggplot(mpg, aes(x = class, y = hwy, tooltip = class)) +
  geom_boxplot_interactive()

x <- girafe(ggobj = p)
if (interactive()) {
  print(x)
}

p <- ggplot(mpg) +
  geom_boxplot_interactive(
    aes(
      x = drv,
      y = hwy,
      fill = class,
      data_id = class,
      tooltip = after_stat({
        paste0(
          "class: ",
          .data$fill,
          "\nQ1: ",
          prettyNum(.data$lower),
          "\nQ3: ",
          prettyNum(.data$upper),
          "\nmedian: ",
          prettyNum(.data$middle)
        )
      })
    ),
    outlier.colour = "red"
  ) +
  guides(fill = "none") +
  theme_minimal()

x <- girafe(ggobj = p)
if (interactive()) {
  print(x)
}


p <- ggplot(mpg) +
  geom_boxplot_interactive(
    aes(
      x = drv,
      y = hwy,
      fill = class,
      group = paste(drv, class),
      data_id = class,
      tooltip = after_stat({
        paste0(
          "class: ",
          .data$fill,
          "\nQ1: ",
          prettyNum(.data$lower),
          "\nQ3: ",
          prettyNum(.data$upper),
          "\nmedian: ",
          prettyNum(.data$middle)
        )
      }),
      outlier.tooltip = paste(
        "I am an outlier!\nhwy:",
        hwy,
        "\ndrv:",
        drv,
        "\nclass:",
        class
      )
    ),
    outlier.colour = "red"
  ) +
  guides(fill = "none") +
  theme_minimal()

x <- girafe(ggobj = p)
if (interactive()) {
  print(x)
}

Description

These geometries are based on ggplot2::geom_contour() and ggplot2::geom_contour_filled(). See the documentation for those functions for more details.

Usage

geom_contour_interactive(...)

geom_contour_filled_interactive(...)

Arguments

Details for interactive geom functions

The interactive parameters can be supplied with two ways:

• As aesthetics with the mapping argument (via ggplot2::aes()). In this way they can be mapped to data columns and apply to a set of geometries.

• As plain arguments into the geom_*_interactive function. In this way they can be set to a scalar value.

See Also

girafe()

Examples

# add interactive contours to a ggplot -------
library(ggplot2)
library(ggiraph)

v <- ggplot(faithfuld, aes(waiting, eruptions, z = density))
p <- v +
  geom_contour_interactive(aes(
    colour = after_stat(level),
    tooltip = paste("Level:", after_stat(level))
  ))
x <- girafe(ggobj = p)
if (interactive()) {
  print(x)
}

if (packageVersion("grid") >= numeric_version("3.6")) {
  p <- v +
    geom_contour_filled_interactive(aes(
      colour = after_stat(level),
      fill = after_stat(level),
      tooltip = paste("Level:", after_stat(level))
    ))
  x <- girafe(ggobj = p)
  if (interactive()) print(x)
}

Description

The geometry is based on ggplot2::geom_bin2d(). See the documentation for those functions for more details.

Usage

geom_count_interactive(...)

Arguments

Details for interactive geom functions

The interactive parameters can be supplied with two ways:

• As aesthetics with the mapping argument (via ggplot2::aes()). In this way they can be mapped to data columns and apply to a set of geometries.

• As plain arguments into the geom_*_interactive function. In this way they can be set to a scalar value.

See Also

girafe()

Examples

# add interactive point counts to a ggplot -------
library(ggplot2)
library(ggiraph)

p <- ggplot(mpg, aes(cty, hwy)) +
  geom_count_interactive(aes(tooltip = after_stat(n)))
x <- girafe(ggobj = p)
if (interactive()) {
  print(x)
}

p2 <- ggplot(diamonds, aes(x = cut, y = clarity)) +
  geom_count_interactive(aes(
    size = after_stat(prop),
    tooltip = after_stat(round(prop, 3)),
    group = 1
  )) +
  scale_size_area(max_size = 10)
x <- girafe(ggobj = p2)
if (interactive()) {
  print(x)
}

Description

These geometries are based on ggplot2::geom_crossbar(), ggplot2::geom_errorbar(), ggplot2::geom_linerange() and ggplot2::geom_pointrange(). See the documentation for those functions for more details.

Usage

geom_crossbar_interactive(...)

geom_errorbar_interactive(...)

geom_linerange_interactive(...)

geom_pointrange_interactive(...)

Arguments

Details for interactive geom functions

The interactive parameters can be supplied with two ways:

• As aesthetics with the mapping argument (via ggplot2::aes()). In this way they can be mapped to data columns and apply to a set of geometries.

• As plain arguments into the geom_*_interactive function. In this way they can be set to a scalar value.

See Also

girafe()

Examples

# add interactive intervals -------
library(ggplot2)
library(ggiraph)

# Create a simple example dataset
df <- data.frame(
  trt = factor(c(1, 1, 2, 2)),
  resp = c(1, 5, 3, 4),
  group = factor(c(1, 2, 1, 2)),
  upper = c(1.1, 5.3, 3.3, 4.2),
  lower = c(0.8, 4.6, 2.4, 3.6)
)

p <- ggplot(df, aes(trt, resp, colour = group))


g <- p +
  geom_linerange_interactive(aes(ymin = lower, ymax = upper, tooltip = group))
x <- girafe(ggobj = g)
if (interactive()) {
  print(x)
}

g <- p +
  geom_pointrange_interactive(aes(ymin = lower, ymax = upper, tooltip = group))
x <- girafe(ggobj = g)
if (interactive()) {
  print(x)
}

g <- p +
  geom_crossbar_interactive(
    aes(ymin = lower, ymax = upper, tooltip = group),
    width = 0.2
  )
x <- girafe(ggobj = g)
if (interactive()) {
  print(x)
}

g <- p +
  geom_errorbar_interactive(
    aes(ymin = lower, ymax = upper, tooltip = group),
    width = 0.2
  )
x <- girafe(ggobj = g)
if (interactive()) {
  print(x)
}

Description

The geometries are based on ggplot2::geom_segment() and ggplot2::geom_curve(). See the documentation for those functions for more details.

Usage

geom_curve_interactive(...)

geom_segment_interactive(...)

Arguments

Details for interactive geom functions

The interactive parameters can be supplied with two ways:

• As aesthetics with the mapping argument (via ggplot2::aes()). In this way they can be mapped to data columns and apply to a set of geometries.

• As plain arguments into the geom_*_interactive function. In this way they can be set to a scalar value.

See Also

girafe()

Examples

# add interactive segments and curves to a ggplot -------
library(ggplot2)
library(ggiraph)

counts <- as.data.frame(table(x = rpois(100, 5)))
counts$x <- as.numeric(as.character(counts$x))
counts$xlab <- paste0("bar", as.character(counts$x))

gg_segment_1 <- ggplot(
  data = counts,
  aes(x = x, y = Freq, yend = 0, xend = x, tooltip = xlab)
) +
  geom_segment_interactive(size = I(10))
x <- girafe(ggobj = gg_segment_1)
if (interactive()) {
  print(x)
}

dataset = data.frame(
  x = c(1, 2, 5, 6, 8),
  y = c(3, 6, 2, 8, 7),
  vx = c(1, 1.5, 0.8, 0.5, 1.3),
  vy = c(0.2, 1.3, 1.7, 0.8, 1.4),
  labs = paste0("Lab", 1:5)
)
dataset$clickjs = paste0("alert(\"", dataset$labs, "\")")

gg_segment_2 = ggplot() +
  geom_segment_interactive(
    data = dataset,
    mapping = aes(
      x = x,
      y = y,
      xend = x + vx,
      yend = y + vy,
      tooltip = labs,
      onclick = clickjs
    ),
    arrow = grid::arrow(length = grid::unit(0.03, "npc")),
    size = 2,
    color = "blue"
  ) +
  geom_point(
    data = dataset,
    mapping = aes(x = x, y = y),
    size = 4,
    shape = 21,
    fill = "white"
  )

x <- girafe(ggobj = gg_segment_2)
if (interactive()) {
  print(x)
}

df <- data.frame(x1 = 2.62, x2 = 3.57, y1 = 21.0, y2 = 15.0)
p <- ggplot(df, aes(x = x1, y = y1, xend = x2, yend = y2)) +
  geom_curve_interactive(aes(colour = "curve", tooltip = I("curve"))) +
  geom_segment_interactive(aes(colour = "segment", tooltip = I("segment")))

x <- girafe(ggobj = p)
if (interactive()) {
  print(x)
}

Description

The geometries are based on ggplot2::geom_density_2d() and ggplot2::geom_density_2d_filled(). See the documentation for those functions for more details.

Usage

geom_density_2d_interactive(...)

geom_density_2d_filled_interactive(...)

Arguments

Details for interactive geom functions

The interactive parameters can be supplied with two ways:

• As aesthetics with the mapping argument (via ggplot2::aes()). In this way they can be mapped to data columns and apply to a set of geometries.

• As plain arguments into the geom_*_interactive function. In this way they can be set to a scalar value.

See Also

girafe()

Examples

# add interactive contours to a ggplot -------
library(ggplot2)
library(ggiraph)

m <- ggplot(faithful, aes(x = eruptions, y = waiting)) +
  geom_point_interactive(aes(
    tooltip = paste("Waiting:", waiting, "\neruptions:", eruptions)
  )) +
  xlim(0.5, 6) +
  ylim(40, 110)
p <- m +
  geom_density_2d_interactive(aes(tooltip = paste("Level:", after_stat(level))))
x <- girafe(ggobj = p)
x


set.seed(4393)
dsmall <- diamonds[sample(nrow(diamonds), 1000), ]
d <- ggplot(dsmall, aes(x, y))


p <- d +
  geom_density_2d_interactive(aes(colour = cut, tooltip = cut, data_id = cut))
x <- girafe(ggobj = p)
x <- girafe_options(x = x, opts_hover(css = "stroke:red;stroke-width:3px;"))
x

p <- d +
  geom_density_2d_filled_interactive(
    aes(colour = cut, tooltip = cut, data_id = cut),
    contour_var = "count"
  ) +
  facet_wrap(vars(cut))
x <- girafe(ggobj = p)
x <- girafe_options(x = x, opts_hover(css = "stroke:red;stroke-width:3px;"))
x


p <- d +
  stat_density_2d(
    aes(
      fill = after_stat(nlevel),
      tooltip = paste("nlevel:", after_stat(nlevel))
    ),
    geom = "interactive_polygon"
  ) +
  facet_grid(. ~ cut) +
  scale_fill_viridis_c_interactive(tooltip = "nlevel")
x <- girafe(ggobj = p)
x

Description

The geometry is based on ggplot2::geom_density(). See the documentation for those functions for more details.

Usage

geom_density_interactive(...)

Arguments

Details for interactive geom functions

The interactive parameters can be supplied with two ways:

• As aesthetics with the mapping argument (via ggplot2::aes()). In this way they can be mapped to data columns and apply to a set of geometries.

• As plain arguments into the geom_*_interactive function. In this way they can be set to a scalar value.

See Also

girafe()

Examples

# add interactive bar -------
library(ggplot2)
library(ggiraph)

p <- ggplot(diamonds, aes(carat)) +
  geom_density_interactive(tooltip = "density", data_id = "density")
x <- girafe(ggobj = p)
x <- girafe_options(x = x, opts_hover(css = "stroke:orange;stroke-width:3px;"))
if (interactive()) {
  print(x)
}

p <- ggplot(diamonds, aes(depth, fill = cut, colour = cut)) +
  geom_density_interactive(aes(tooltip = cut, data_id = cut), alpha = 0.1) +
  xlim(55, 70)
x <- girafe(ggobj = p)
x <- girafe_options(
  x = x,
  opts_hover(css = "stroke:yellow;stroke-width:3px;fill-opacity:0.8;")
)
if (interactive()) {
  print(x)
}


p <- ggplot(diamonds, aes(carat, fill = cut)) +
  geom_density_interactive(
    aes(tooltip = cut, data_id = cut),
    position = "stack"
  )
x <- girafe(ggobj = p)
if (interactive()) {
  print(x)
}

p <- ggplot(diamonds, aes(carat, after_stat(count), fill = cut)) +
  geom_density_interactive(aes(tooltip = cut, data_id = cut), position = "fill")
x <- girafe(ggobj = p)
if (interactive()) {
  print(x)
}

Description

This geometry is based on ggplot2::geom_dotplot(). See the documentation for those functions for more details.

Usage

geom_dotplot_interactive(...)

Arguments

Details for interactive geom functions

The interactive parameters can be supplied with two ways:

• As aesthetics with the mapping argument (via ggplot2::aes()). In this way they can be mapped to data columns and apply to a set of geometries.

• As plain arguments into the geom_*_interactive function. In this way they can be set to a scalar value.

See Also

girafe()

Examples

# add interactive dot plots to a ggplot -------
library(ggplot2)
library(ggiraph)

p <- ggplot(mtcars, aes(x = mpg, fill = factor(cyl))) +
  geom_dotplot_interactive(
    aes(tooltip = row.names(mtcars)),
    stackgroups = TRUE,
    binwidth = 1,
    method = "histodot"
  )

x <- girafe(ggobj = p)
if (interactive()) {
  print(x)
}

gg_point = ggplot(
  data = mtcars,
  mapping = aes(
    x = factor(vs),
    fill = factor(cyl),
    y = mpg,
    tooltip = row.names(mtcars)
  )
) +
  geom_dotplot_interactive(
    binaxis = "y",
    stackdir = "center",
    position = "dodge"
  )

x <- girafe(ggobj = gg_point)
if (interactive()) {
  print(x)
}

Description

This geometry is based on ggplot2::geom_errorbarh(). See the documentation for those functions for more details.

Usage

geom_errorbarh_interactive(...)

Arguments

Details for interactive geom functions

The interactive parameters can be supplied with two ways:

• As aesthetics with the mapping argument (via ggplot2::aes()). In this way they can be mapped to data columns and apply to a set of geometries.

• As plain arguments into the geom_*_interactive function. In this way they can be set to a scalar value.

See Also

girafe()

Examples

# add horizontal error bars -------
library(ggplot2)
library(ggiraph)

df <- data.frame(
  trt = factor(c(1, 1, 2, 2)),
  resp = c(1, 5, 3, 4),
  group = factor(c(1, 2, 1, 2)),
  se = c(0.1, 0.3, 0.3, 0.2)
)

# Define the top and bottom of the errorbars

p <- ggplot(df, aes(resp, trt, colour = group))
g <- p +
  geom_point() +
  geom_errorbarh_interactive(aes(
    xmax = resp + se,
    xmin = resp - se,
    tooltip = group
  ))
x <- girafe(ggobj = g)
if (interactive()) {
  print(x)
}

Description

The geometries are based on ggplot2::geom_histogram() and ggplot2::geom_freqpoly(). See the documentation for those functions for more details.

This interactive version is only providing a single tooltip per group of data (same for data_id). It means it is only possible to associate a single tooltip to a set of bins.

Usage

geom_freqpoly_interactive(...)

geom_histogram_interactive(...)

Arguments

Details for interactive geom functions

The interactive parameters can be supplied with two ways:

• As aesthetics with the mapping argument (via ggplot2::aes()). In this way they can be mapped to data columns and apply to a set of geometries.

• As plain arguments into the geom_*_interactive function. In this way they can be set to a scalar value.

See Also

girafe()

Examples

# add interactive histogram -------
library(ggplot2)
library(ggiraph)

p <- ggplot(diamonds, aes(carat)) +
  geom_histogram_interactive(
    bins = 30,
    aes(tooltip = after_stat(count), group = 1L)
  )
x <- girafe(ggobj = p)
if (interactive()) {
  print(x)
}

p <- ggplot(diamonds, aes(price, colour = cut, tooltip = cut, data_id = cut)) +
  geom_freqpoly_interactive(binwidth = 500)
x <- girafe(ggobj = p)
x <- girafe_options(x = x, opts_hover(css = "stroke-width:3px;"))
if (interactive()) {
  print(x)
}

Description

The geometry is based on ggplot2::geom_hex(). See the documentation for those functions for more details.

Usage

geom_hex_interactive(...)

Arguments

Details for interactive geom functions

The interactive parameters can be supplied with two ways:

• As aesthetics with the mapping argument (via ggplot2::aes()). In this way they can be mapped to data columns and apply to a set of geometries.

• As plain arguments into the geom_*_interactive function. In this way they can be set to a scalar value.

See Also

girafe()

Examples

# add interactive hexagonal heatmaps to a ggplot -------
library(ggplot2)
library(ggiraph)

p <- ggplot(diamonds, aes(carat, price)) +
  geom_hex_interactive(aes(tooltip = after_stat(count)), bins = 10)
x <- girafe(ggobj = p)
if (interactive()) {
  print(x)
}

Description

The geometry is based on ggplot2::geom_jitter(). See the documentation for those functions for more details.

Usage

geom_jitter_interactive(...)

Arguments

Details for interactive geom functions

The interactive parameters can be supplied with two ways:

• As aesthetics with the mapping argument (via ggplot2::aes()). In this way they can be mapped to data columns and apply to a set of geometries.

• As plain arguments into the geom_*_interactive function. In this way they can be set to a scalar value.

See Also

girafe()

Examples

# add interactive paths to a ggplot -------
library(ggplot2)
library(ggiraph)

gg_jitter <- ggplot(
  mpg,
  aes(cyl, hwy, tooltip = paste(manufacturer, model, year, trans, sep = "\n"))
) +
  geom_jitter_interactive()

x <- girafe(ggobj = gg_jitter)
if (interactive()) {
  print(x)
}

Description

The geometries are based on ggplot2::geom_text() and ggplot2::geom_label(). See the documentation for those functions for more details.

Usage

geom_label_interactive(...)

geom_text_interactive(...)

Arguments

Details for interactive geom functions

The interactive parameters can be supplied with two ways:

• As aesthetics with the mapping argument (via ggplot2::aes()). In this way they can be mapped to data columns and apply to a set of geometries.

• As plain arguments into the geom_*_interactive function. In this way they can be set to a scalar value.

See Also

girafe()

Examples

# add interactive labels to a ggplot -------
library(ggplot2)
library(ggiraph)
library(gdtools)

register_liberationsans()

p <- ggplot(mtcars, aes(wt, mpg, label = rownames(mtcars))) +
  geom_label_interactive(
    aes(
      tooltip = paste(rownames(mtcars), mpg, sep = "\n")
    ),
    family = "Liberation Sans"
  ) +
  theme_minimal(base_family = "Liberation Sans", base_size = 11)
x <- girafe(
  ggobj = p,
  dependencies = list(
    liberationsansHtmlDependency()
  )
)
if (interactive()) {
  print(x)
}


p <- ggplot(mtcars, aes(wt, mpg, label = rownames(mtcars))) +
  geom_label_interactive(
    aes(fill = factor(cyl), tooltip = paste(rownames(mtcars), mpg, sep = "\n")),
    colour = "white",
    fontface = "bold",
    family = "Liberation Sans"
  ) +
  theme_minimal(base_family = "Liberation Sans", base_size = 11)
x <- girafe(
  ggobj = p,
  dependencies = list(
    liberationsansHtmlDependency()
  )
)
if (interactive()) {
  print(x)
}
# add interactive texts to a ggplot -------
library(ggplot2)
library(ggiraph)
library(gdtools)

register_liberationsans()

## the data
dataset = mtcars
dataset$label = row.names(mtcars)

dataset$tooltip = paste0(
  "cyl: ",
  dataset$cyl,
  "<br/>",
  "gear: ",
  dataset$gear,
  "<br/>",
  "carb: ",
  dataset$carb
)

## the plot
gg_text = ggplot(
  dataset,
  aes(
    x = mpg,
    y = wt,
    label = label,
    color = qsec,
    tooltip = tooltip,
    data_id = label
  )
) +
  geom_text_interactive(check_overlap = TRUE, family = "Liberation Sans") +
  coord_cartesian(xlim = c(0, 50)) +
  theme_minimal(base_family = "Liberation Sans", base_size = 11)

## display the plot
x <- girafe(
  ggobj = gg_text,
  dependencies = list(
    liberationsansHtmlDependency()
  )
)
x <- girafe_options(x = x, opts_hover(css = "fill:#FF4C3B;font-style:italic;"))
if (interactive()) {
  print(x)
}

Description

The geometry is based on ggplot2::geom_map(). See the documentation for those functions for more details.

Usage

geom_map_interactive(...)

Arguments

Details for interactive geom functions

The interactive parameters can be supplied with two ways:

• As aesthetics with the mapping argument (via ggplot2::aes()). In this way they can be mapped to data columns and apply to a set of geometries.

• As plain arguments into the geom_*_interactive function. In this way they can be set to a scalar value.

See Also

girafe()

Examples

# add interactive maps to a ggplot -------
library(ggplot2)
library(ggiraph)

crimes <- data.frame(state = tolower(rownames(USArrests)), USArrests)

# create tooltips and onclick events
states_ <- sprintf("<p>%s</p>", as.character(crimes$state))
table_ <- paste0(
  "<table><tr><td>UrbanPop</td>",
  sprintf("<td>%.0f</td>", crimes$UrbanPop),
  "</tr><tr>",
  "<td>Assault</td>",
  sprintf("<td>%.0f</td>", crimes$Assault),
  "</tr></table>"
)

onclick <- sprintf(
  "window.open(\"%s%s\")",
  "http://en.wikipedia.org/wiki/",
  as.character(crimes$state)
)


crimes$labs <- paste0(states_, table_)
crimes$onclick = onclick

if (require("maps")) {
  states_map <- map_data("state")
  gg_map <- ggplot(crimes, aes(map_id = state))
  gg_map <- gg_map +
    geom_map_interactive(
      aes(
        fill = Murder,
        tooltip = labs,
        data_id = state,
        onclick = onclick
      ),
      map = states_map
    ) +
    expand_limits(x = states_map$long, y = states_map$lat)
  x <- girafe(ggobj = gg_map)
  if (interactive()) print(x)
}

Description

These geometries are based on ggplot2::geom_path(), ggplot2::geom_line() and ggplot2::geom_step(). See the documentation for those functions for more details.

Usage

geom_path_interactive(...)

geom_line_interactive(...)

geom_step_interactive(...)

Arguments

Details for interactive geom functions

The interactive parameters can be supplied with two ways:

• As aesthetics with the mapping argument (via ggplot2::aes()). In this way they can be mapped to data columns and apply to a set of geometries.

• As plain arguments into the geom_*_interactive function. In this way they can be set to a scalar value.

See Also

girafe()

Examples

# add interactive paths to a ggplot -------
library(ggplot2)
library(ggiraph)

# geom_line_interactive example -----
if (requireNamespace("dplyr", quietly = TRUE)) {
  gg <- ggplot(
    economics_long,
    aes(
      date,
      value01,
      colour = variable,
      tooltip = variable,
      data_id = variable,
      hover_css = "fill:none;"
    )
  ) +
    geom_line_interactive(size = .75)
  x <- girafe(ggobj = gg)
  x <- girafe_options(x = x, opts_hover(css = "stroke:red;fill:orange"))
  if (interactive()) print(x)
}

# geom_step_interactive example -----
if (requireNamespace("dplyr", quietly = TRUE)) {
  recent <- economics[economics$date > as.Date("2013-01-01"), ]
  gg = ggplot(recent, aes(date, unemploy)) +
    geom_step_interactive(aes(
      tooltip = "Unemployement stairstep line",
      data_id = 1
    ))
  x <- girafe(ggobj = gg)
  x <- girafe_options(x = x, opts_hover(css = "stroke:red;"))
  if (interactive()) print(x)
}

# create datasets -----
id = paste0("id", 1:10)
data = expand.grid(list(
  variable = c("2000", "2005", "2010", "2015"),
  id = id
))
groups = sample(LETTERS[1:3], size = length(id), replace = TRUE)
data$group = groups[match(data$id, id)]
data$value = runif(n = nrow(data))
data$tooltip = paste0('line ', data$id)
data$onclick = paste0("alert(\"", data$id, "\")")

cols = c("orange", "orange1", "orange2", "navajowhite4", "navy")
dataset2 <- data.frame(
  x = rep(1:20, 5),
  y = rnorm(100, 5, .2) + rep(1:5, each = 20),
  z = rep(1:20, 5),
  grp = factor(rep(1:5, each = 20)),
  color = factor(rep(1:5, each = 20)),
  label = rep(paste0("id ", 1:5), each = 20),
  onclick = paste0(
    "alert(\"",
    sample(letters, 100, replace = TRUE),
    "\")"
  )
)


# plots ---
gg_path_1 = ggplot(
  data,
  aes(
    variable,
    value,
    group = id,
    colour = group,
    tooltip = tooltip,
    onclick = onclick,
    data_id = id
  )
) +
  geom_path_interactive(alpha = 0.5)

gg_path_2 = ggplot(
  data,
  aes(variable, value, group = id, data_id = id, tooltip = tooltip)
) +
  geom_path_interactive(alpha = 0.5) +
  facet_wrap(~group)

gg_path_3 = ggplot(dataset2) +
  geom_path_interactive(
    aes(
      x,
      y,
      group = grp,
      data_id = label,
      color = color,
      tooltip = label,
      onclick = onclick
    ),
    size = 1
  )

# ggiraph widgets ---
x <- girafe(ggobj = gg_path_1)
x <- girafe_options(x = x, opts_hover(css = "stroke-width:3px;"))
if (interactive()) {
  print(x)
}

x <- girafe(ggobj = gg_path_2)
x <- girafe_options(x = x, opts_hover(css = "stroke:orange;stroke-width:3px;"))
if (interactive()) {
  print(x)
}

x <- girafe(ggobj = gg_path_3)
x <- girafe_options(x = x, opts_hover(css = "stroke-width:10px;"))
if (interactive()) {
  print(x)
}

m <- ggplot(economics, aes(unemploy / pop, psavert))
p <- m + geom_path_interactive(aes(colour = as.numeric(date), tooltip = date))
x <- girafe(ggobj = p)
if (interactive()) {
  print(x)
}

Description

The geometry is based on ggplot2::geom_point(). See the documentation for those functions for more details.

Usage

geom_point_interactive(...)

Arguments

Details for interactive geom functions

The interactive parameters can be supplied with two ways:

• As aesthetics with the mapping argument (via ggplot2::aes()). In this way they can be mapped to data columns and apply to a set of geometries.

• As plain arguments into the geom_*_interactive function. In this way they can be set to a scalar value.

Note

The following shapes id 3, 4 and 7 to 14 are composite symbols and should not be used.

See Also

girafe()

Examples

# add interactive points to a ggplot -------
library(ggplot2)
library(ggiraph)
library(gdtools)

register_liberationsans()

dataset <- structure(
  list(
    qsec = c(16.46, 17.02, 18.61, 19.44, 17.02, 20.22),
    disp = c(160, 160, 108, 258, 360, 225),
    carname = c(
      "Mazda RX4",
      "Mazda RX4 Wag",
      "Datsun 710",
      "Hornet 4 Drive",
      "Hornet Sportabout",
      "Valiant"
    ),
    wt = c(2.62, 2.875, 2.32, 3.215, 3.44, 3.46)
  ),
  row.names = c(
    "Mazda RX4",
    "Mazda RX4 Wag",
    "Datsun 710",
    "Hornet 4 Drive",
    "Hornet Sportabout",
    "Valiant"
  ),
  class = "data.frame"
)
dataset

# plots
gg_point = ggplot(data = dataset) +
  geom_point_interactive(aes(
    x = wt,
    y = qsec,
    color = disp,
    tooltip = carname,
    data_id = carname
  )) +
  theme_minimal(base_family = "Liberation Sans", base_size = 11)

x <- girafe(
  ggobj = gg_point,
  dependencies = list(
    liberationsansHtmlDependency()
  )
)
if (interactive()) {
  print(x)
}

Description

The geometry is based on ggplot2::geom_polygon(). See the documentation for those functions for more details.

Usage

geom_polygon_interactive(...)

Arguments

Details for interactive geom functions

The interactive parameters can be supplied with two ways:

• As aesthetics with the mapping argument (via ggplot2::aes()). In this way they can be mapped to data columns and apply to a set of geometries.

• As plain arguments into the geom_*_interactive function. In this way they can be set to a scalar value.

See Also

girafe()

Examples

# add interactive polygons to a ggplot -------
library(ggplot2)
library(ggiraph)

# create data
ids <- factor(c("1.1", "2.1", "1.2", "2.2", "1.3", "2.3"))

values <- data.frame(
  id = ids,
  value = c(3, 3.1, 3.1, 3.2, 3.15, 3.5)
)
positions <- data.frame(
  id = rep(ids, each = 4),
  x = c(
    2,
    1,
    1.1,
    2.2,
    1,
    0,
    0.3,
    1.1,
    2.2,
    1.1,
    1.2,
    2.5,
    1.1,
    0.3,
    0.5,
    1.2,
    2.5,
    1.2,
    1.3,
    2.7,
    1.2,
    0.5,
    0.6,
    1.3
  ),
  y = c(
    -0.5,
    0,
    1,
    0.5,
    0,
    0.5,
    1.5,
    1,
    0.5,
    1,
    2.1,
    1.7,
    1,
    1.5,
    2.2,
    2.1,
    1.7,
    2.1,
    3.2,
    2.8,
    2.1,
    2.2,
    3.3,
    3.2
  )
)

datapoly <- merge(values, positions, by = c("id"))

datapoly$oc = "alert(this.getAttribute(\"data-id\"))"

# create a ggplot -----
gg_poly_1 <- ggplot(datapoly, aes(x = x, y = y)) +
  geom_polygon_interactive(aes(
    fill = value,
    group = id,
    tooltip = value,
    data_id = value,
    onclick = oc
  ))

# display ------
x <- girafe(ggobj = gg_poly_1)
if (interactive()) {
  print(x)
}

if (packageVersion("grid") >= "3.6") {
  # As of R version 3.6 geom_polygon() supports polygons with holes
  # Use the subgroup aesthetic to differentiate holes from the main polygon

  holes <- do.call(
    rbind,
    lapply(split(datapoly, datapoly$id), function(df) {
      df$x <- df$x + 0.5 * (mean(df$x) - df$x)
      df$y <- df$y + 0.5 * (mean(df$y) - df$y)
      df
    })
  )
  datapoly$subid <- 1L
  holes$subid <- 2L
  datapoly <- rbind(datapoly, holes)
  p <- ggplot(datapoly, aes(x = x, y = y)) +
    geom_polygon_interactive(aes(
      fill = value,
      group = id,
      subgroup = subid,
      tooltip = value,
      data_id = value,
      onclick = oc
    ))
  x <- girafe(ggobj = p)
  if (interactive()) print(x)
}

Description

The geometry is based on ggplot2::geom_quantile(). See the documentation for those functions for more details.

Usage

geom_quantile_interactive(...)

Arguments

Details for interactive geom functions

The interactive parameters can be supplied with two ways:

• As aesthetics with the mapping argument (via ggplot2::aes()). In this way they can be mapped to data columns and apply to a set of geometries.

• As plain arguments into the geom_*_interactive function. In this way they can be set to a scalar value.

See Also

girafe()

Examples

# add interactive quantiles to a ggplot -------
library(ggplot2)
library(ggiraph)

if (requireNamespace("quantreg", quietly = TRUE)) {
  m <- ggplot(mpg, aes(displ, 1 / hwy)) + geom_point()
  p <- m +
    geom_quantile_interactive(
      aes(
        tooltip = after_stat(quantile),
        data_id = after_stat(quantile),
        colour = after_stat(quantile)
      ),
      formula = y ~ x,
      size = 2,
      alpha = 0.5
    )
  x <- girafe(ggobj = p)
  x <- girafe_options(x = x, opts_hover(css = "stroke:red;stroke-width:10px;"))
  if (interactive()) print(x)
}

Description

The geometry is based on ggbeeswarm::geom_quasirandom().

Usage

geom_quasirandom_interactive(...)

Arguments

Details for interactive geom functions

The interactive parameters can be supplied with two ways:

• As aesthetics with the mapping argument (via ggplot2::aes()). In this way they can be mapped to data columns and apply to a set of geometries.

• As plain arguments into the geom_*_interactive function. In this way they can be set to a scalar value.

See Also

girafe()

Examples

# add interactive repulsive texts to a ggplot -------
library(ggplot2)
library(ggiraph)

# geom_text_repel_interactive
if (
  requireNamespace("ggbeeswarm", quietly = TRUE) &&
    requireNamespace("dplyr", quietly = TRUE)
) {
  set.seed(2)

  dat <- dplyr::filter(
    .data = diamonds,
    cut %in% c("Fair", "Good"),
    color %in% c("D", "E", "H")
  )
  dat <- dplyr::sample_n(tbl = dat, 150)

  dodge_width <- .8
  position <- position_dodge(width = dodge_width)

  gg_qr <- ggplot(dat, aes(x = cut, y = y, fill = color)) +
    geom_violin(
      alpha = .5,
      width = dodge_width
    ) +
    geom_boxplot(position = position, alpha = .5, outliers = FALSE) +
    geom_quasirandom_interactive(
      aes(tooltip = y, data_id = color),
      shape = 21,
      size = 2,
      dodge.width = dodge_width,
      color = "black",
      alpha = .5
    ) +
    theme_minimal()

  x <- girafe(ggobj = gg_qr)
  x <- girafe_options(x = x, opts_hover(css = "fill:#FF4C3B;"))
  if (interactive()) {
    print(x)
  }

  dat <- mtcars
  dat$name <- row.names(mtcars)
  dat$am <- factor(dat$am)
  dat$gear <- factor(dat$gear)

  dodge_width <- .8
  position <- position_dodge(width = dodge_width)

  gg_qr <- ggplot(
    dat,
    aes(x = am, y = disp, fill = gear, group = interaction(am, gear))
  ) +
    geom_quasirandom_interactive(
      aes(tooltip = disp, data_id = name),
      shape = 21,
      size = 2,
      dodge.width = dodge_width,
      color = "black"
    ) +
    scale_fill_manual_interactive(
      name = label_interactive(
        "Gearrrrrr",
        tooltip = "Gearrrrrr",
        data_id = "gear"
      ),
      values = c("3" = "#0072B2", "4" = "#009E73", "5" = "red"),
      data_id = c("3" = "tree", "4" = "tree", "5" = "four"),
      tooltip = c("3" = "tree", "4" = "tree", "5" = "four")
    ) +
    theme_minimal()

  x <- girafe(ggobj = gg_qr)
  if (interactive()) print(x)
}

Description

The geometry is based on ggplot2::geom_raster(). See the documentation for those functions for more details.

Usage

geom_raster_interactive(...)

Arguments

Details for interactive geom functions

The interactive parameters can be supplied with two ways:

• As aesthetics with the mapping argument (via ggplot2::aes()). In this way they can be mapped to data columns and apply to a set of geometries.

• As plain arguments into the geom_*_interactive function. In this way they can be set to a scalar value.

See Also

girafe()

girafe()

Examples

# add interactive raster to a ggplot -------
library(ggplot2)
library(ggiraph)

df <- expand.grid(x = 0:5, y = 0:5)
df$z <- runif(nrow(df))

gg <- ggplot(df, aes(x, y, fill = z, tooltip = "tooltip")) +
  geom_raster_interactive() +
  scale_fill_gradient_interactive(
    data_id = "coco",
    onclick = "cici",
    tooltip = "cucu"
  )

x <- girafe(ggobj = gg)
if (interactive()) {
  print(x)
}

Description

These geometries are based on ggplot2::geom_rect() and ggplot2::geom_tile(). See the documentation for those functions for more details.

Usage

geom_rect_interactive(...)

geom_tile_interactive(...)

Arguments

Details for interactive geom functions

The interactive parameters can be supplied with two ways:

• As aesthetics with the mapping argument (via ggplot2::aes()). In this way they can be mapped to data columns and apply to a set of geometries.

• As plain arguments into the geom_*_interactive function. In this way they can be set to a scalar value.

Note

Converting a raster to svg elements could inflate dramatically the size of the svg and make it unreadable in a browser. Function geom_tile_interactive should be used with caution, total number of rectangles should be small.

See Also

girafe()

Examples

# add interactive polygons to a ggplot -------
library(ggplot2)
library(ggiraph)

dataset = data.frame(
  x1 = c(1, 3, 1, 5, 4),
  x2 = c(2, 4, 3, 6, 6),
  y1 = c(1, 1, 4, 1, 3),
  y2 = c(2, 2, 5, 3, 5),
  t = c('a', 'a', 'a', 'b', 'b'),
  r = c(1, 2, 3, 4, 5),
  tooltip = c("ID 1", "ID 2", "ID 3", "ID 4", "ID 5"),
  uid = c("ID 1", "ID 2", "ID 3", "ID 4", "ID 5"),
  oc = rep("alert(this.getAttribute(\"data-id\"))", 5)
)

gg_rect = ggplot() +
  scale_x_continuous(name = "x") +
  scale_y_continuous(name = "y") +
  geom_rect_interactive(
    data = dataset,
    mapping = aes(
      xmin = x1,
      xmax = x2,
      ymin = y1,
      ymax = y2,
      fill = t,
      tooltip = tooltip,
      onclick = oc,
      data_id = uid
    ),
    color = "black",
    alpha = 0.5,
    linejoin = "bevel",
    lineend = "round"
  ) +
  geom_text(
    data = dataset,
    aes(x = x1 + (x2 - x1) / 2, y = y1 + (y2 - y1) / 2, label = r),
    size = 4
  )

x <- girafe(ggobj = gg_rect)
if (interactive()) {
  print(x)
}
# add interactive tiles to a ggplot -------
library(ggplot2)
library(ggiraph)

df <- data.frame(
  id = rep(c("a", "b", "c", "d", "e"), 2),
  x = rep(c(2, 5, 7, 9, 12), 2),
  y = rep(c(1, 2), each = 5),
  z = factor(rep(1:5, each = 2)),
  w = rep(diff(c(0, 4, 6, 8, 10, 14)), 2)
)

p <- ggplot(df, aes(x, y, tooltip = id)) + geom_tile_interactive(aes(fill = z))
x <- girafe(ggobj = p)
if (interactive()) {
  print(x)
}


# correlation dataset ----
cor_mat <- cor(mtcars)
diag(cor_mat) <- NA
var1 <- rep(row.names(cor_mat), ncol(cor_mat))
var2 <- rep(colnames(cor_mat), each = nrow(cor_mat))
cor <- as.numeric(cor_mat)
cor_mat <- data.frame(
  var1 = var1,
  var2 = var2,
  cor = cor,
  stringsAsFactors = FALSE
)
cor_mat[["tooltip"]] <-
  sprintf("<i>`%s`</i> vs <i>`%s`</i>:</br><code>%.03f</code>", var1, var2, cor)

p <- ggplot(data = cor_mat, aes(x = var1, y = var2)) +
  geom_tile_interactive(aes(fill = cor, tooltip = tooltip), colour = "white") +
  scale_fill_gradient2_interactive(
    low = "#BC120A",
    mid = "white",
    high = "#BC120A",
    limits = c(-1, 1),
    data_id = "cormat",
    tooltip = "cormat"
  ) +
  coord_equal()
x <- girafe(ggobj = p)
if (interactive()) {
  print(x)
}

Description

The geometries are based on ggplot2::geom_ribbon() and ggplot2::geom_area(). See the documentation for those functions for more details.

Usage

geom_ribbon_interactive(...)

geom_area_interactive(...)

Arguments

Details for interactive geom functions

The interactive parameters can be supplied with two ways:

• As aesthetics with the mapping argument (via ggplot2::aes()). In this way they can be mapped to data columns and apply to a set of geometries.

• As plain arguments into the geom_*_interactive function. In this way they can be set to a scalar value.

See Also

girafe()

Examples

# add interactive bar -------
library(ggplot2)
library(ggiraph)

# Generate data
huron <- data.frame(year = 1875:1972, level = as.vector(LakeHuron))
h <- ggplot(huron, aes(year))

g <- h +
  geom_ribbon_interactive(
    aes(ymin = level - 1, ymax = level + 1),
    fill = "grey70",
    tooltip = "ribbon1",
    data_id = "ribbon1",
    outline.type = "both",
    hover_css = "stroke:red;stroke-width:inherit;"
  ) +
  geom_line_interactive(
    aes(y = level),
    tooltip = "level",
    data_id = "line1",
    hover_css = "stroke:orange;fill:none;"
  )
x <- girafe(ggobj = g)
x <- girafe_options(
  x = x,
  opts_hover(
    css = girafe_css(
      css = "stroke:orange;stroke-width:3px;",
      area = "fill:blue;"
    )
  )
)
if (interactive()) {
  print(x)
}


g <- h + geom_area_interactive(aes(y = level), tooltip = "area1")
x <- girafe(ggobj = g)
if (interactive()) {
  print(x)
}

Description

These geometries are based on ggplot2::geom_sf(), ggplot2::geom_sf_label() and ggplot2::geom_sf_text(). See the documentation for those functions for more details.

Usage

geom_sf_interactive(...)

geom_sf_label_interactive(...)

geom_sf_text_interactive(...)

Arguments

Details for interactive geom functions

The interactive parameters can be supplied with two ways:

• As aesthetics with the mapping argument (via ggplot2::aes()). In this way they can be mapped to data columns and apply to a set of geometries.

• As plain arguments into the geom_*_interactive function. In this way they can be set to a scalar value.

See Also

girafe()

Examples

# add interactive sf objects to a ggplot -------
library(ggplot2)
library(ggiraph)

## original code: see section examples of ggplot2::geom_sf help file
if (
  requireNamespace(
    "sf",
    quietly = TRUE,
    versionCheck = list(op = ">=", version = "0.7-3")
  )
) {
  nc <- sf::st_read(system.file("shape/nc.shp", package = "sf"), quiet = TRUE)
  gg <- ggplot(nc) +
    geom_sf_interactive(aes(fill = AREA, tooltip = NAME, data_id = NAME))
  x <- girafe(ggobj = gg)
  if (interactive()) {
    print(x)
  }

  nc_3857 <- sf::st_transform(nc, 3857)

  # Unfortunately if you plot other types of feature you'll need to use
  # show.legend to tell ggplot2 what type of legend to use
  nc_3857$mid <- sf::st_centroid(nc_3857$geometry)
  gg <- ggplot(nc_3857) +
    geom_sf(colour = "white") +
    geom_sf_interactive(
      aes(geometry = mid, size = AREA, tooltip = NAME, data_id = NAME),
      show.legend = "point"
    )
  x <- girafe(ggobj = gg)
  if (interactive()) {
    print(x)
  }

  # Example with texts.
  gg <- ggplot(nc_3857[1:3, ]) +
    geom_sf(aes(fill = AREA)) +
    geom_sf_text_interactive(aes(label = NAME, tooltip = NAME), color = "white")
  x <- girafe(ggobj = gg)
  if (interactive()) {
    print(x)
  }

  # Example with labels.
  gg <- ggplot(nc_3857[1:3, ]) +
    geom_sf(aes(fill = AREA)) +
    geom_sf_label_interactive(aes(label = NAME, tooltip = NAME))
  x <- girafe(ggobj = gg)
  if (interactive()) print(x)
}

Description

The geometry is based on ggplot2::geom_smooth(). See the documentation for those functions for more details.

Usage

geom_smooth_interactive(...)

Arguments

Details for interactive geom functions

The interactive parameters can be supplied with two ways:

• As aesthetics with the mapping argument (via ggplot2::aes()). In this way they can be mapped to data columns and apply to a set of geometries.

• As plain arguments into the geom_*_interactive function. In this way they can be set to a scalar value.

See Also

girafe()

Examples

# add interactive bar -------
library(ggplot2)
library(ggiraph)

p <- ggplot(mpg, aes(displ, hwy)) +
  geom_point() +
  geom_smooth_interactive(aes(tooltip = "smoothed line", data_id = "smooth"))
x <- girafe(ggobj = p)
x <- girafe_options(x = x, opts_hover(css = "stroke:orange;stroke-width:3px;"))
if (interactive()) {
  print(x)
}

p <- ggplot(mpg, aes(displ, hwy)) +
  geom_point() +
  geom_smooth_interactive(
    method = lm,
    se = FALSE,
    tooltip = "smooth",
    data_id = "smooth"
  )
x <- girafe(ggobj = p)
if (interactive()) {
  print(x)
}

p <- ggplot(
  mpg,
  aes(displ, hwy, colour = class, tooltip = class, data_id = class)
) +
  geom_point_interactive() +
  geom_smooth_interactive(se = FALSE, method = lm)
x <- girafe(ggobj = p)
x <- girafe_options(x = x, opts_hover(css = "stroke:red;stroke-width:3px;"))
if (interactive()) {
  print(x)
}

Description

The geometry is based on ggplot2::geom_spoke(). See the documentation for those functions for more details.

Usage

geom_spoke_interactive(...)

Arguments

Details for interactive geom functions

The interactive parameters can be supplied with two ways:

• As aesthetics with the mapping argument (via ggplot2::aes()). In this way they can be mapped to data columns and apply to a set of geometries.

• As plain arguments into the geom_*_interactive function. In this way they can be set to a scalar value.

See Also

girafe()

Examples

# add interactive line segments parameterised by location,
# direction and distance to a ggplot -------
library(ggplot2)
library(ggiraph)

df <- expand.grid(x = 1:10, y = 1:10)
df$angle <- runif(100, 0, 2 * pi)
df$speed <- runif(100, 0, sqrt(0.1 * df$x))

p <- ggplot(df, aes(x, y)) +
  geom_point() +
  geom_spoke_interactive(
    aes(angle = angle, tooltip = round(angle, 2)),
    radius = 0.5
  )
x <- girafe(ggobj = p)
if (interactive()) {
  print(x)
}

p2 <- ggplot(df, aes(x, y)) +
  geom_point() +
  geom_spoke_interactive(aes(
    angle = angle,
    radius = speed,
    tooltip = paste(round(angle, 2), round(speed, 2), sep = "\n")
  ))
x2 <- girafe(ggobj = p2)
if (interactive()) {
  print(x2)
}

Description

The geometries are based on ggrepel::geom_text_repel() and ggrepel::geom_label_repel(). See the documentation for those functions for more details.

Usage

geom_text_repel_interactive(...)

geom_label_repel_interactive(...)

Arguments

Details for interactive geom functions

The interactive parameters can be supplied with two ways:

• As aesthetics with the mapping argument (via ggplot2::aes()). In this way they can be mapped to data columns and apply to a set of geometries.

• As plain arguments into the geom_*_interactive function. In this way they can be set to a scalar value.

Note

The ggrepel package is required for these geometries

See Also

girafe()

Examples

# add interactive repulsive texts to a ggplot -------
library(ggplot2)
library(ggiraph)

# geom_text_repel_interactive
if (requireNamespace("ggrepel", quietly = TRUE)) {
  dataset = mtcars
  dataset$label = row.names(mtcars)
  dataset$tooltip = paste0(
    dataset$label,
    "<br/>",
    "cyl: ",
    dataset$cyl,
    "<br/>",
    "gear: ",
    dataset$gear,
    "<br/>",
    "carb: ",
    dataset$carb
  )
  p <- ggplot(dataset, aes(wt, mpg, color = qsec)) +
    geom_point_interactive(aes(tooltip = tooltip, data_id = label))

  gg_text = p +
    geom_text_repel_interactive(
      aes(label = label, tooltip = tooltip, data_id = label),
      size = 3
    )

  x <- girafe(ggobj = gg_text)
  x <- girafe_options(x = x, opts_hover(css = "fill:#FF4C3B;"))
  if (interactive()) print(x)
}

# geom_label_repel_interactive
if (requireNamespace("ggrepel", quietly = TRUE)) {
  gg_label = p +
    geom_label_repel_interactive(
      aes(label = label, tooltip = tooltip, data_id = label),
      size = 3,
      max.overlaps = 12
    )

  x2 <- girafe(ggobj = gg_label)
  x2 <- girafe_options(
    x = x2,
    opts_hover(
      css = ggiraph::girafe_css(
        css = ";",
        area = "fill:#FF4C3B;"
      )
    )
  )
  if (interactive()) print(x2)
}

Description

The geometry is based on ggplot2::geom_violin(). See the documentation for those functions for more details.

Usage

geom_violin_interactive(...)

Arguments

Details for interactive geom functions

The interactive parameters can be supplied with two ways:

• As aesthetics with the mapping argument (via ggplot2::aes()). In this way they can be mapped to data columns and apply to a set of geometries.

• As plain arguments into the geom_*_interactive function. In this way they can be set to a scalar value.

See Also

girafe()

Examples

# add interactive violin plot -------
library(ggplot2)
library(ggiraph)

p <- ggplot(mtcars, aes(factor(cyl), mpg)) +
  geom_violin_interactive(aes(fill = cyl, tooltip = cyl))
x <- girafe(ggobj = p)
if (interactive()) {
  print(x)
}

# Show quartiles
p2 <- ggplot(mtcars, aes(factor(cyl), mpg)) +
  geom_violin_interactive(
    aes(tooltip = after_stat(density)),
    draw_quantiles = c(0.25, 0.5, 0.75)
  )
x2 <- girafe(ggobj = p2)
if (interactive()) {
  print(x2)
}

Description

Create an interactive graphic with a ggplot object to be used in a web browser.

Usage

girafe(
  ggobj = NULL,
  code,
  pointsize = 12,
  width_svg = NULL,
  height_svg = NULL,
  options = list(),
  font_set = NULL,
  dependencies = NULL,
  check_fonts_registered = FALSE,
  check_fonts_dependencies = FALSE,
  ...
)

Arguments

Details

Use geom_zzz_interactive to create interactive graphical elements.

Tooltips can be displayed when mouse is over graphical elements.

If id are associated with points, they get animated when mouse is over and can be selected when used in shiny apps.

On click actions can be set with javascript instructions. This option should not be used simultaneously with selections in Shiny applications as both features are "on click" features.

When a zoom effect is set, "zoom activate", "zoom desactivate" and "zoom init" buttons are available in a toolbar.

When selection type is set to 'multiple' (in Shiny applications), lasso selection and lasso anti-selections buttons are available in a toolbar.

Managing Grouping with Interactive Aesthetics

Adding an interactive aesthetic like tooltip can sometimes alter the implicit grouping that ggplot2 performs automatically.

In these cases, you must explicitly specify the group aesthetic to ensure correct graph rendering by clearly defining the variables that determine the grouping.

mapping = ggplot2::aes(tooltip = .data_tooltip, group = interaction(factor1, factor2, ...))

This precaution is necessary:

• ggplot2 automatically determines grouping based on the provided aesthetics

• Interactive aesthetics added by ggiraph can interfere with this logic

• Explicit group specification prevents unexpected behavior and ensures predictable results

Widget options

girafe animations can be customized with function girafe_options(). Options are available to customize tooltips, hover effects, zoom effects selection effects and toolbar.

Options passed to girafe() are merged with defaults set via set_girafe_defaults(). This means you can define global styles once and override only specific parameters per plot. For example, if you set a custom tooltip CSS globally, you can still adjust offx and offy in a specific girafe() call without losing your CSS styling.

Widget sizing

girafe graphics are responsive, which mean, they will be resized according to their container. There are two responsive behavior implementations:

• one for Shiny applications and flexdashboard documents,

• and another one for other documents (i.e. R markdown and saveWidget).

Graphics are created by an R graphic device (i.e pdf, png, svg here) and need arguments width and height to define a graphic region. Arguments width_svg and height_svg are used as corresponding values. They are defining the aspect ratio of the graphic. This proportion is always respected when the graph is displayed.

When a girafe graphic is in a Shiny application, graphic will be resized according to the arguments width and height of the function girafeOutput. Default values are '100\ outer bounding box of the graphic (the HTML element that will contain the graphic with an aspect ratio).

When a girafe graphic is in an R markdown document (producing an HTML document), the graphic will be resized according to the argument width of the function girafe. Its value is beeing used to define a relative width of the graphic within its HTML container. Its height is automatically adjusted regarding to the argument width and the aspect ratio.

See Also

girafe_options(), dsvg(), gdtools::font_set()

Examples

library(ggplot2)
library(ggiraph)
library(gdtools)

fonts <- font_set(sans = font_liberation("sans"))

dataset <- mtcars
dataset$carname <- row.names(mtcars)

gg_point <- ggplot(
  data = dataset,
  mapping = aes(
    x = wt,
    y = qsec,
    color = disp,
    tooltip = carname,
    data_id = carname
  )
) +
  geom_point_interactive(hover_nearest = TRUE, size = 11 / .pt) +
  theme_minimal(base_family = fonts$sans, base_size = 11)

x <- girafe(
  ggobj = gg_point,
  font_set = fonts
)

x

Description

These functions allow programmatic manipulation of CSS classes on SVG elements within a girafe output in Shiny applications. Elements are targeted by their data-id, key-id, or theme-id attributes.

Usage

girafe_class_add(
  session,
  id,
  class,
  data_id = NULL,
  key_id = NULL,
  theme_id = NULL
)

girafe_class_remove(
  session,
  id,
  class,
  data_id = NULL,
  key_id = NULL,
  theme_id = NULL
)

girafe_class_toggle(
  session,
  id,
  class,
  data_id = NULL,
  key_id = NULL,
  theme_id = NULL
)

Arguments

Details

At least one of data_id, key_id, or theme_id must be provided.

These functions send a custom message to the JavaScript side, which applies the CSS class operation to all matching SVG elements within the girafe root node.

Examples

## Not run: 
# In a Shiny server function:
girafe_class_add(session, "plot", "highlighted", data_id = "some_id")
girafe_class_remove(session, "plot", "highlighted", data_id = "some_id")
girafe_class_toggle(session, "plot", "highlighted", data_id = "some_id")

## End(Not run)

Description

It allows specifying individual styles for various SVG elements.

Usage

girafe_css(
  css,
  text = NULL,
  point = NULL,
  line = NULL,
  area = NULL,
  image = NULL
)

Arguments

Value

css as scalar character

See Also

girafe_css_bicolor(), girafe()

Examples

library(ggiraph)

girafe_css(
  css = "fill:orange;stroke:gray;",
  text = "stroke:none; font-size: larger",
  line = "fill:none",
  area = "stroke-width:3px",
  point = "stroke-width:3px",
  image = "outline:2px red"
)

Description

It allows the creation of a css set of individual styles for animation of 'girafe' elements. The used model is based on a simple pattern that works most of the time for girafe hover effects and selection effects.

It sets properties based on a primary and a secondary color.

Usage

girafe_css_bicolor(primary = "orange", secondary = "gray")

Arguments

See Also

girafe_css(), girafe()

Examples

library(ggplot2)
library(ggiraph)

dat <- mtcars
dat$id <- "id"
dat$label <- "a line"
dat <- dat[order(dat$wt), ]

p <- ggplot(
  data = dat,
  mapping = aes(
    x = wt, y = mpg, data_id = id, tooltip = label)) +
  geom_line_interactive(color = "white", size  = .75,
                        hover_nearest = TRUE) +
  theme_dark() +
  theme(plot.background = element_rect(fill="black"),
        panel.background = element_rect(fill="black"),
        text = element_text(colour = "white"),
        axis.text = element_text(colour = "white")
        )

x <- girafe(
  ggobj = p,
  options = list(
    opts_hover(
      css = girafe_css_bicolor(
        primary = "yellow", secondary = "black"))
))
if (interactive()) print(x)