rCharts¶

Credits¶

Most of the implementation in rCharts is inspired by rHighcharts and rVega. I have reused some code from these packages verbatim, and would like to acknowledge the efforts of its author Thomas Reinholdsson, who has since merged his rHighcharts package into rCharts. I would also like to thank @timelyportfolio for adding Dimple JS to rCharts, as well as for his contagious enthusiasm, which has egged me on constantly.

License¶

rCharts is licensed under the MIT License. However, the JavaScript charting libraries that are included with this package are licensed under their own terms. All of them are free for non-commercial and commercial use, with the exception of Polychart and Highcharts, both of which require paid licenses for commercial use. For more details on the licensing terms, you can consult the License.md file in each of the charting libraries.

See Also¶

There has been a lot of interest recently in creating packages that allow R users to make use of Javascript charting libraries.

• ggvis by RStudio
• clickme by Nacho Caballero

Standalone

NVD3¶

hair_eye = as.data.frame(HairEyeColor)
p2 <- nPlot(Freq ~ Hair, group = 'Eye',
  data = subset(hair_eye, Sex == "Female"),
  type = 'multiBarChart'
)
p2$chart(color = c('brown', 'blue', '#594c26', 'green'))
p2

Standalone

View Interactive

Morris¶

data(economics, package = "ggplot2")
econ <- transform(economics, date = as.character(date))
m1 <- mPlot(x = "date", y = c("psavert", "uempmed"), type = "Line", data = econ)
m1$set(pointSize = 0, lineWidth = 1)
m1

Standalone

Highcharts¶

h1 <- hPlot(x = "Wr.Hnd", y = "NW.Hnd",
  data = MASS::survey,
  type = c("line", "bubble", "scatter"),
  group = "Clap",
  size = "Age"
)
h1

Standalone

Rickshaw¶

usp = reshape2::melt(USPersonalExpenditure)
usp$Var2 <- as.numeric(as.POSIXct(paste0(usp$Var2, "-01-01")))
p4 <- Rickshaw$new()
p4$layer(value ~ Var2, group = "Var1", data = usp, type = "area")
p4$set(slider = TRUE)
p4

Standalone

xCharts¶

require(reshape2)
uspexp <- melt(USPersonalExpenditure)
names(uspexp)[1:2] = c('category', 'year')
x1 <- xPlot(value ~ year, group = 'category', data = uspexp,
  type = 'line-dotted')
x1

Standalone

Save¶

You can save your chart using the save method. The additional parameters passed to the save method determine how the js/css assets of the javascript visualization library are served. You can now email your visualization or embed it in a blog post as an iframe.

# link js/css assets from an online cdn
r1$save('mychart1.html', cdn = TRUE)
# create standalone chart with all assets included directly in the html file
r1$save('mychart2.html', standalone = TRUE)

Publish¶

Sometimes, you may want to directly publish the visualization you created, without having to bother with the steps of saving it and then uploading it. rChart has you covered here, and provides a publish method that combines these two steps. It currently supports publishing to RPubs and Gist and I expect to add more providers over time.

# the host defaults to 'gist'
r1$publish("My Chart")
r1$publish("My Chart", host = 'rpubs')

Publishing a chart saves the html in a temporary file, uploads it to the specified host, and returns a link to where the chart can be viewed. There are many gist viewers out there, and rCharts uses a custom viewer http://rcharts.io/viewer, designed specifically for rCharts, and is a modified version of another excellent gist viewer http://www.pagist.info/. Another popular gist viewer is http://blocks.org, built by Mike Bostock, the creator of d3.js.

If you wish to simply update a visualization you have already created and shared, you can pass the gist/rpubs id to the publish method, and it will update instead of uploading it as a brand new chart.

r1$publish("My Chart", id = 9253202)

While using a provider like Gist that allows multiple files to be uploaded, you can use the extras argument to add additional files that you want to upload. This is especially useful, if you want to provide a README.md or upload external assets like js/css/json files that are required for your chart to render.

r1$publish("My Chart", id = 9253202, extras = "README.md")

Embed¶

```{r results = "asis", comment = NA}
r1$show('iframe', cdn = TRUE)
```

```{r setup, cache = F}
options(rcharts.mode = 'iframe', rcharts.cdn = TRUE)
knitr::opts_chunk$set(results = "asis", comment = NA)
```

```{r}
r1
```

```{r results = "asis", comment = NA}
r1$show('iframesrc', cdn  = TRUE)
```

```{r chart3}
r1$show('inline', include_assets = TRUE, cdn = TRUE)
```

 ## server.r
 require(rCharts)
 shinyServer(function(input, output) {
   output$myChart <- renderChart({
     names(iris) = gsub("\\.", "", names(iris))
     p1 <- rPlot(input$x, input$y, data = iris, color = "Species",
       facet = "Species", type = 'point')
     p1$addParams(dom = 'myChart')
     return(p1)
   })
 })

 ## ui.R
 require(rCharts)
 shinyUI(pageWithSidebar(
   headerPanel("rCharts: Interactive Charts from R using polychart.js"),

   sidebarPanel(
     selectInput(inputId = "x",
      label = "Choose X",
      choices = c('SepalLength', 'SepalWidth', 'PetalLength', 'PetalWidth'),
      selected = "SepalLength"),
     selectInput(inputId = "y",
       label = "Choose Y",
       choices = c('SepalLength', 'SepalWidth', 'PetalLength', 'PetalWidth'),
       selected = "SepalWidth")
   ),
   mainPanel(
     showOutput("myChart", "polycharts")
   )
 ))

Data¶

The first step is to get data on strikeouts by team across years. The NY Times graphic uses data scraped from baseball-reference, using the XML package in R. However, I will be using data from the R package Lahman, which provides tables from Sean Lahman’s Baseball Database as a set of data frames.

The data processing step involves using the plyr package to create two data frames:

1. team_data containing SOG (strikeouts per game) by yearID and team name
2. league_data containing SOG by yearID averaged across the league.

require(Lahman) ; require(plyr); library(ascii)
dat = Teams[,c('yearID', 'name', 'G', 'SO')]
team_data = na.omit(transform(dat, SOG = round(SO/G, 2)))
league_data = ddply(team_data, .(yearID), summarize, SOG = mean(SOG))
ascii(head(team_data), type = 'rst')

Charts¶

We will start by first creating a scatterplot of SOG by yearID across all teams. We use the rPlot function which uses the PolyChartsJS library to create interactive visualizations. The formula interface specifies the x and y variables, the data to use and the type of plot. We also specify a size and color argument to style the points. Finally, we pass a tooltip argument, which is a javascript function that overrides the default tooltip to display the information we require. You will see below the R code and the resulting chart.

require(rCharts)
p1 <- rPlot(SOG ~ yearID, data = team_data,
  type = "point",
  size = list(const = 2),
  color = list(const = "#888"),
  tooltip = "#! function(item){
    return item.SOG + ' ' + item.name + ' ' + item.yearID
   } !#"
)
p1

Standalone

Now, we need to add a line plot of the average SOG for the league by yearID. We do this by adding a second layer to the chart, which copies the elements of the previous layer and overrides the data, type, color and tooltip arguments. The R code is shown below and you will note that the resulting chart now shows a blue line chart corresponding to the league average SOG.

p1$layer(data = league_data, type = 'line',
  color = list(const = 'blue'), copy_layer = T, tooltip = NULL)
p1

Standalone

Finally, we will overlay a line plot of SOG by yearID for a specific team name. Later, while building the shiny app, we will turn this into an input variable that a user can choose from a dropdown menu. We use the layer approach used earlier and this time override the data and color arguments so that the line plot for the team stands out from the league average.

myteam = "Boston Red Sox"
p1$layer(data = team_data[team_data$name == myteam,],
  color = list(const = 'red'),
  copy_layer = T)
p1$set(dom = 'chart3')
p1

Standalone

Let us add a little more interactivity to the chart. To keep it simple, we will use handlers in PolychartJS to initiate an action when a user clicks on a point. The current handler is a simple one, which just displays the name of the team clicked on. If you are familiar with Javascript event handlers, the code should be self explanatory.

p2 <- p1$copy()
p2$setTemplate(afterScript = '
  <script>
    graph_chart3.addHandler(function(type, e) {
      var data;
      data = e.evtData;
      if (type === "click") {
        return alert("You clicked on the team: " + data.name["in"][0]);
      }
    });
  </script>
')
p2

Standalone

Application¶

Now it is time to convert this into a Shiny App. We will throw the data processing code into global.R so that it can be accessed both by ui.R and server.R. For the dropdown menu allowing users to choose a specific team, we will restrict the choices to only those which have data for more than 30 years. Accordingly, we have the following global.R.

## global.R
require(Lahman); require(plyr)
dat = Teams[,c('yearID', 'name', 'G', 'SO')]
team_data = na.omit(transform(dat, SOG = round(SO/G, 2)))
league_data = ddply(team_data, .(yearID), summarize, SOG = mean(SOG))
THRESHOLD = 30
team_appearances = count(team_data, .(name))
teams_in_menu = subset(team_appearances, freq > THRESHOLD)$name

For the UI, we will use a bootstrap page with controls being displayed in the sidebar. Shiny makes it really easy to create a page like this. See the annotated graphic below and the ui.R code that accompanies it to understand how the different pieces fit together.

We now need to write the server part of the shiny app. Thankfully, this is the easiest part, since it just involves wrapping the charting code inside renderChart and replacing user inputs to enable reactivity. We add a few more lines of code to set the height and title and remove the axis titles, since they are self explanatory.