plotly v4.7.0

0

Monthly downloads

0th

Percentile

by Carson Sievert

Create Interactive Web Graphics via 'plotly.js'

Easily translate 'ggplot2' graphs to an interactive web-based version and/or create custom web-based visualizations directly from R. Once uploaded to a 'plotly' account, 'plotly' graphs (and the data behind them) can be viewed and modified in a web browser.

Readme

Build Status

plotly

An R package for creating interactive web graphics via the open source JavaScript graphing library plotly.js.

Installation

Install from CRAN:

install.packages("plotly")

Or install the latest development version (on GitHub) via devtools:

devtools::install_github("ropensci/plotly")

NOTE: The CRAN version of plotly is designed to work with the CRAN version of ggplot2, but at least for the time being, we recommend using the development versions of both plotly and ggplot2 (devtools::install_github("hadley/ggplot2")).

Getting started

Web-based ggplot2 graphics

If you use ggplot2, ggplotly() converts your static plots to an interactive web-based version!

library(plotly)
g <- ggplot(faithful, aes(x = eruptions, y = waiting)) +
  stat_density_2d(aes(fill = ..level..), geom = "polygon") + 
  xlim(1, 6) + ylim(40, 100)
ggplotly(g)

http://i.imgur.com/G1rSArP.gifv

By default, ggplotly() tries to replicate the static ggplot2 version exactly (before any interaction occurs), but sometimes you need greater control over the interactive behavior. The ggplotly() function itself has some convenient "high-level" arguments, such as dynamicTicks, which tells plotly.js to dynamically recompute axes, when appropriate. The style() function also comes in handy for modifying the underlying traces attributes used to generate the plot:

gg <- ggplotly(g, dynamicTicks = "y")
style(gg, hoveron = "points", hoverinfo = "x+y+text", hoverlabel = list(bgcolor = "white"))

http://i.imgur.com/qRvLgea.gifv

Moreover, since ggplotly() returns a plotly object, you can apply essentially any function from the R package on that object. Some useful ones include layout() (for customizing the layout), add_traces() (and its higher-level add_*() siblings, for example add_polygons(), for adding new traces/data), subplot() (for combining multiple plotly objects), and plotly_json() (for inspecting the underlying JSON sent to plotly.js).

The ggplotly() function will also respect some "unofficial" ggplot2 aesthetics, namely text (for customizing the tooltip) and frame (for creating animations).

Using plotly without ggplot2

The plot_ly() function provides a more direct interface to plotly.js so you can leverage more specialized chart types (e.g., parallel coordinates or maps) or even some visualization that the ggplot2 API won't ever support (e.g., surface, mesh, trisurf, or sankey diagrams). The cheatsheet is a nice quick reference for this interface, but the plotly cookbook has more complete overview of the philosophy behind this "non-ggplot2" approach.

plot_ly(z = ~volcano, type = "surface")

https://plot.ly/~brnvg/1134

Crosstalk support

The R package has special support for linking/highlighting/filtering views that is not (yet) available outside of the R package. This functionality is built upon the crosstalk package, which distinguishes between two event classes: select and filter. The plotly package interprets these classes in the following way:

  1. Select: add new "selection" trace(s) (i.e., graphical marks) and dim the other traces. Some people refer to this as "brushing" or "highlighting".
  2. Filter: retain "selection" trace(s), but remove other traces, and update the layout accordingly. Some people refer to this as "crossfilter" or "drill-down".

The following gif helps to demonstrate the difference -- see here for the code used to generate it.

http://rpubs.com/cpsievert/275511

Like other crosstalk enabled widgets, plotly responds to filter events, but you can't (yet) emit a filter event via direct manipulation of a plotly graph. Unlike (some) other crosstalk enabled widgets, plotly has advanced support for select (a much more broad class than filter) events, like persistent/dynamic brushing, brushing via indirect manipulation, and even ways to completely control the appearance new selection traces. In other words, these "special" brushing features work when linking multiple plotly graphs, but may not when linking to other crosstalk enabled widgets.

To date, this slide deck is the most comprehensive, yet somewhat thorough, walk-through of this framework, but the linking views without shiny chapter of the plotly book provides even more background. There are also numerous demos shipped with the package which provide nice examples (list all the demos via demo(package = "plotly")).

plotly's crosstalk functionality aims to provide tools for interactively exploring subsets of your data with a fixed definition from data to plot. If you need more flexibility, you can always embed crosstalk plots within a larger shiny app, or even access and respond to any plotly event within shiny, but adding shiny into the equation comes with a cost -- the result is no longer standalone HTML (harder to share/host) and linking views requires fairly sophicated knowledge/use of shiny's reactive programming framework.

Learn more

We have lots of examples on https://plot.ly/r/ and https://plot.ly/ggplot2/, but a more comprehensive review is also available at https://cpsievert.github.io/plotly_book/. I also have a number of slide decks that also have useful demos.

Contributing

Please read through our contributing guidelines. Included are directions for opening issues, asking questions, contributing changes to plotly, and our code of conduct.


http://ropensci.org

Functions in plotly

Name Description
attrs_selected Specify attributes of selection traces
bbox Estimate bounding box of a rotated string
as.widget Convert a plotly object to an htmlwidget object
as_widget Convert a list to a plotly htmlwidget object
animation_opts Animation configuration options
api_create Tools for working with plotly's REST API (v2)
add_annotations Add an annotation(s) to a plot
add_data Add data to a plotly visualization
add_fun Apply function to plot, without modifying data
add_trace Add trace(s) to a plotly visualization
embed_notebook Embed a plot as an iframe into a Jupyter Notebook
event_data Access plotly user input event data in shiny
plot_geo Initiate a plotly-geo object
export Export a plotly graph to a static file
geom2trace Convert a "basic" geoms to a plotly.js trace.
group2NA Separate groups with missing values
hide_colorbar Hide color bar(s)
layout Modify the layout of a plotly visualization
mic Mic data
get_figure Request a figure object
get_l Obtain number of points comprising a geometry
highlight Query graphical elements in multiple linked views
hide_guides Hide guides (legends and colorbars)
hide_legend Hide legend
plot_mapbox Initiate a plotly-mapbox object
plotly-shiny Shiny bindings for plotly
plotly_json Inspect JSON sent to plotly.js
print.api Print method for a 'generic' API response
raster2uri Convert a raster object to a data URI
mutate Objects exported from other packages
toRGB Convert R colours to RGBA hexadecimal colour values
toWebGL Convert trace types to WebGL
plotly Main interface to plotly
plotly_IMAGE Create a static image
style Modify trace(s)
subplot View multiple plots in a single view
to_basic Convert a geom to a "basic" geom.
get_x Obtain x coordinates of sf geometry/geometries
get_y Obtain y coordinates of sf geometry/geometries
knit_print.api_grid Embed a plotly grid as an iframe in a knitr doc
knit_print.api_grid_local Embed a plotly grid as an iframe in a knitr doc
wind Wind data
hobbs Hobbs data
print.api_grid Print a plotly grid object
print.api_grid_local Print a plotly grid object
showRGB View colors already formatted by toRGB()
signup Create a new plotly account.
offline Plotly Offline
plot_dendro Plot an interactive dendrogram
print.api_plot Print a plot on plotly's platform
plot_ly Initiate a plotly visualization
plotly_POST Create/Modify plotly graphs
plotly_build 'Build' (i.e., evaluate) a plotly object
remove_typedarray_polyfill Remove TypedArray polyfill
colorbar Modify the colorbar
config Set the default configuration for plotly
gg2list Convert a ggplot to a list.
ggplotly Convert ggplot2 to plotly
knit_print.api_plot Embed a plotly figure as an iframe in a knitr doc
last_plot Retrieve the last plot to be modified or created.
plotly_data Obtain data associated with a plotly graph
plotly_empty Create a complete empty plotly graph.
schema Display plotly's plot schema
rangeslider Add a range slider to the x-axis
No Results!

Last month downloads

Details

Include our badge in your README

[![Rdoc](http://www.rdocumentation.org/badges/version/plotly)](http://www.rdocumentation.org/packages/plotly)