Aside

# Update to plot.qcc using ggplot2 and grid

Two years ago, I blogged about my experience rewriting the plot.qcc() function in the qcc package to use ggplot2 and grid. My goal was to allow manipulation of qcc’s quality control plots using grid graphics, especially to combine range charts with their associated individuals or moving range charts, as these two diagnostic tools should be used together. At the time, I posted the code on my GitHub.

I recently discovered that the update to ggplot2 v2.0 broke my code, so that attempting to generate a qcc plot would throw an obscure error from someplace deep in ggplot2. The fix turned out to be pretty easy. The original code used `aes_string()` instead of `aes()` because of a barely-documented problem of calling `aes()` inside a function. It looks like this has been quietly corrected with ggplot2 2.0, and `aes_string()` is no longer needed for this.

The updated code is up on GitHub. As before, load the qcc library, then `source()` `qcc.plot.R`. For the rest of the current session, calls to `qcc()` will automatically use the new `plot.qcc()` function.

# Explorable, multi-tabbed reports in R and Shiny

Matt Parker recently showed us how to create multi-tab reports with R and jQuery UI. His example was absurdly easy to reproduce; it was a great blog post.

I have been teaching myself Shiny in fits and starts, and I decided to attempt to reproduce Matt’s jQuery UI example in Shiny. You can play with the app on shinyapps.io, and the complete project is up on Github. The rest of this post walks through how I built the Shiny app.

### It’s a demo

The result demonstrates a few Shiny and ggplot2 techniques that will be useful in other projects, including:

• Creating tabbed reports in Shiny, with different interactive controls or widgets associated with each tab;
• Combining different ggplot2 scale changes in a single legend;
• Sorting a data frame so that categorical labels in a legend are ordered to match the position of numerical data on a plot;
• Borrowing from Matt’s work,
• Summarizing and plotting data using dplyr and ggplot2;
• Limiting display of categories in a graph legend to the top n (selectable by the user), with remaining values listed as “other;”
• Coloring only the top n categories on a graph, and making all other categories gray;
• Changing line weight for the top n categories on a graph, and making;

### Obtaining the data

As with Matt’s original report, the data can be downloaded from the CDC WONDER database by selecting “Data Request” under “current cases.”

To get the same data that I’ve used, group results by “state” and by “year,” check “incidence rate per 100,000” and, near the bottom, “export results.” Uncheck “show totals,” then submit the request. This will download a `.txt` tab-delimited data file, which in this app I read in using `read_tsv()` from the readr package.

Looking at Matt’s example, his “top 5” states look suspiciously like the most populous states. He’s used total count of cases, which will be biased toward more populous states and doesn’t tell us anything interesting. When examining occurrences—whether disease, crime or defects—we have to look at the rates rather than total counts; we can only make meaningful comparisons and make useful decisions from an examination of the rates.

### Setup

As always, we need to load our libraries into R. For this example, I use readr, dplyr, ggplot2 and RColorBrewer.

### The UI

The app generates three graphs: a national total, that calculates national rates from the state values; a combined state graph that highlights the top $n$ states, where the user chooses $n$; and a graph that displays individual state data, where the user can select the state to view. Each goes on its own tab.

`ui.R` contains the code to create a tabset panel with three tab panels.

```tabsetPanel(
tabPanel("National", fluidRow(plotOutput("nationPlot"))),
tabPanel("By State",
fluidRow(plotOutput("statePlot"),
wellPanel(
sliderInput(inputId = "nlabels",
label = "Top n States:",
min = 1,
max = 10,
value = 6,
step = 1)
)
)
),
tabPanel("State Lookup",
fluidRow(plotOutput("iStatePlot"),
wellPanel(
htmlOutput("selectState"))
)
)
)
```

Each panel contains a fluidRow element to ensure consistent alignment of graphs across tabs, and on tabs where I want both a graph and controls, `fluidRow()` is used to add the controls below the graph. The controls are placed inside a `wellPanel()` so that they are visually distinct from the graph.

Because I wanted to populate a selection menu (`selectInput()`) from the data frame, I created the selection menu in `server.R` and then displayed it in the third tab panel set using the `htmlOutput()` function.

### The graphs

The first two graphs are very similar to Matt’s example. For the national rates, the only change is the use of rates rather than counts.

```df_tb <- read_tsv("../data/OTIS 2013 TB Data.txt", n_max = 1069, col_types = "-ciiii?di")

df_tb %>%
group_by(Year) %>%
summarise(n_cases = sum(Count), pop = sum(Population), us_rate = (n_cases / pop * 100000)) %>%
ggplot(aes(x = Year, y = us_rate)) +
geom_line() +
labs(x = "Year Reported",
y = "TB Cases per 100,000 residents",
title = "Reported Active Tuberculosis Cases in the U.S.") +
theme_minimal()
```

The main trick, here, is the use of `dplyr` to summarize the data across states. Since we can’t just sum or average rates to get the combined rate, we have to sum all of the state counts and populations for each year, and add another column for the calculated national rate.

To create a graph that highlights the top $n$ states, we generate a data frame with one variable, State, that contains the top $n$ states. This is, again, almost a direct copy of Matt’s code with changes to make the graph interactive within Shiny. This code goes inside of the `shinyServer()` block so that it will update when the user selects a different value for $n$. Instead of hard-coding $n$, there’s a Shiny input slider named `nlabels`. With a list of the top $n$ states ordered by rate of TB cases, `df_tb` is updated with a new field containing the top $n$ state names and “Other” for all other states.

```top_states <- df_tb %>%
filter(Year == 2013) %>%
arrange(desc(Rate)) %>%
slice(1:input\$nlabels) %>%
select(State)

df_tb\$top_state <- factor(df_tb\$State, levels = c(top_states\$State, "Other"))
df_tb\$top_state[is.na(df_tb\$top_state)] <- "Other"
```

The plot is generated from the newly-organized data frame. Where Matt’s example has separate legends for line weight (size) and color, I’ve had ggplot2 combine these into a single legend by passing the same value to the “`guide =`” argument in the `scale_XXX_manual()` calls. The colors and line sizes also have to be updated dynamically for the selected $n$.

```    df_tb %>%
ggplot() +
labs(x = "Year reported",
y = "TB Cases per 100,000 residents",
title = "Reported Active Tuberculosis Cases in the U.S.") +
theme_minimal() +
geom_line(aes(x = Year, y = Rate, group = State, colour = top_state, size = top_state)) +
scale_colour_manual(values = c(brewer.pal(n = input\$nlabels, "Paired"), "grey"), guide = guide_legend(title = "State")) +
scale_size_manual(values = c(rep(1,input\$nlabels), 0.5), guide = guide_legend(title = "State"))
})

})
```

The last graph is nearly a copy of the national totals graph, except that it is filtered for the state selected in the drop-down menu control. The menu is as `selectInput()` control.

```renderUI({
selectInput(inputId = "state", label = "Which state?", choices = unique(df_tb\$State), selected = "Alabama", multiple = FALSE)
})
```

With a state selected, the data is filtered by the selected state and TB rates are plotted.

```df_tb %>%
filter(State == input\$state) %>%
ggplot() +
labs(x = "Year reported",
y = "TB Cases per 100,000 residents",
title = "Reported Active Tuberculosis Cases in the U.S.") +
theme_minimal() +
geom_line(aes(x = Year, y = Rate))
```

### Wrap up

I want to thank Matt Parker for his original example. It was well-written, clear and easy to reproduce.

# A Simple Introduction to the Graphing Philosophy of ggplot2

“The emphasis in ggplot2 is reducing the amount of thinking time by making it easier to go from the plot in your brain to the plot on the page.” (Wickham, 2012)

“Base graphics are good for drawing pictures; ggplot2 graphics are good for understanding the data.” (Wickham, 2012)

I’m not ggplot2’s creator, Hadley Wickham, but I do find myself in discussions trying to explain how to build graphs in ggplot2. It’s a very elegant system, but also very different from other graphing systems. Once you understand the organizing philosophy, ggplot2 becomes very easy to work with.

### The grammar of ggplot2 graphics

There is a basic grammar to all graphics production. In R‘s base graphics or in Excel, you feed ranges of data to a plot as x and y elements, then manipulate colors, scale dimensions and other parts of the graph as graphical elements or options.

ggplot2’s grammar makes a clear distinction between your data and what gets displayed on the screen or page. You feed ggplot2 your data, then apply a series of mappings and transformations to create a visual representation of that data. Even with base graphics or Excel we never really plot the data itself, we only create a representation; ggplot2 makes this distinction explicit. In addition, ggplot2’s structure makes it very easy to tweak a graph to look the way you want by adding mappings.

A ggplot2 graph is built up from a few basic elements:

 1 Data The raw data that you want to plot 2 Geometries `geom_` The geometric shapes that will represent the data. 3 Aethetics `aes()` Aesthetics of the geometric and statistical objects, such as color, size, shape and position. 4 Scales `scale_` Maps between the data and the aesthetic dimensions, such as data range to plot width or factor values to colors

Putting it together, the code to build a ggplot2 graph looks something like:

```data
+ geometry to represent the data,
+ aesthetic mappings of data to plot coordinates like position, color and size
+ scaling of ranges of the data to ranges of the aesthetics
```

A real example shows off how this all fits together.

```library(ggplot2)
# Create some data for our example
some.data <- data.frame(timer = 1:12,
countdown = 12:1,
category = factor(letters[1:3]))
# Generate the plot
some.plot <- ggplot(data = some.data, aes(x = timer, y = countdown)) +
geom_point(aes(colour = category)) +
scale_x_continuous(limits = c(0, 15)) +
scale_colour_brewer(palette = "Dark2") +
coord_fixed(ratio=1)
# Display the plot
some.plot
```

Demonstration of the key concepts in the grammar of graphics: data, geometries, aesthetic mappings and scale mappings.

Here you can see that the data is passed to ggplot(), aesthetic mappings between the data and the plot coordinates, a geometry to represent the data and a couple of scales to map between the data range and the plot ranges.

### More advanced parts of the ggplot2 grammar

The above will get you a basic graph, but ggplot2 includes a few more parts of the grammar that you’ll want to be aware of as you try to visualize more complex data:

 5 Statistical transformations `stat_` Statistical summaries of the data that can be plotted, such as quantiles, fitted curves (loess, linear models, etc.), sums and so o. 6 Coordinate systems `coord_` The transformation used for mapping data coordinates into the plane of the data rectangle. 7 Facets `facet_` The arrangement of the data into a grid of plots (also known as latticing, trellising or creating small multiples). 8 Visual Themes `theme` The overall visual defaults of a plot: background, grids, axe, default typeface, sizes, colors, etc.

Hadley Wickham describes various pieces of this grammar in recorded presentations on Vimeo and YouTube and the online documentation to ggplot2. The most complete explanation is in his book ggplot2: Elegant Graphics for Data Analysis (Use R!) (Wickham, 2009).

### References

Wickham, Hadley. ggplot2: Elegant Graphics for Data Analysis. Dordrecht, Heibelberg, London, New York: Springer, 2009. Print.
Wickham, Hadley. A Backstage Tour of ggplot2 with Hadley Wickham. 2012. Video. YouTube. Web. 21 Mar 2014. . Contributed by REvolutionAnalytics.

# Rewriting plot.qcc using ggplot2 and grid

The free and open-source R statistics package is a great tool for data analysis. The free add-on package qcc provides a wide array of statistical process control charts and other quality tools, which can be used for monitoring and controlling industrial processes, business processes or data collection processes. It’s a great package and highly customizable, but the one feature I wanted was the ability to manipulate the control charts within the grid graphics system, and that turned out to be not so easy.

I went all-in and completely rewrote qcc’s `plot.qcc()` function to use Hadley Wickham’s ggplot2 package, which itself is built on top of grid graphics. I have tested the new code against all the examples provided on the qcc help page, and the new ggplot2 version works for all the plots, including X-bar and R, p- and u- and c-charts.

In qcc, an individuals and moving range (XmR or ImR) chart can be created simply:

```library(qcc)
my.xmr.raw <- c(5045,4350,4350,3975,4290,4430,4485,4285,3980,3925,3645,3760,3300,3685,3463,5200)
x <- qcc(my.xmr.raw, type = "xbar.one", title = "Individuals Chart\nfor Wheeler sample data")
x <- qcc(matrix(cbind(my.xmr.raw[1:length(my.xmr.raw)-1], my.xmr.raw[2:length(my.xmr.raw)]), ncol = 2), type = "R", title = "Moving Range Chart\nfor Wheeler sample data")
```

This both generates the plot and creates a qcc object, assigning it to the variable `x`. You can generate another copy of the plot with `plot(x)`.

To use my new plot function, you will need to have the packages ggplot2, gtable, qcc and grid installed. Download my code from the qcc_ggplot project on Github, load qcc in R and then run `source("qcc.plot.R")`. The ggplot2-based version of the plotting function will be used whenever a qcc object is plotted.

```library(qcc)
source("qcc.plot.R")
my.xmr.raw <- c(5045,4350,4350,3975,4290,4430,4485,4285,3980,3925,3645,3760,3300,3685,3463,5200)
x <- qcc(my.xmr.raw, type = "xbar.one", title = "Individuals Chart\nfor Wheeler sample data")
x <- qcc(matrix(cbind(my.xmr.raw[1:length(my.xmr.raw)-1], my.xmr.raw[2:length(my.xmr.raw)]), ncol = 2), type = "R", title = "Moving Range Chart\nfor Wheeler sample data")
```

Below, you can compare the individuals and moving range charts generated by qcc and by my new implementation of `plot.qcc()`:

The qcc individuals chart as implemented in the qcc package.

The qcc individuals chart as implemented using ggplot2 and grid graphics.

The qcc moving range chart as implemented in the qcc package.

The qcc moving range chart as implemented using ggplot2 and grid graphics.

### New features

In addition to the standard features in qcc plots, I’ve added a few new options.

`size` or `cex`
Set the size of the points used in the plot. This is passed directly to `geom_point()`.
`font.size`
Sets the size of text elements. Passed directly to `ggplot()` and grid’s `viewport()`.
`title = element_blank()`
Eliminate the main graph title completely, and expand the data region to fill the empty space. As with qcc, with the default `title = NULL` a title will be created, or a user-defined text string may be passed to `title`.
new.plot
If `TRUE`, creates a new graph (`grid.newpage()`). Otherwise, will write into the existing device and viewport. Intended to simplify the creation of multi-panel or composite charts.
digits
The argument `digits` is provided by the qcc package to control the number of digits printed on the graph, where it either uses the default option set for R or a user-supplied value. I have tried to add some intelligence to calculating a default value under the assumption that we can tell something about the measurement from the data supplied. You can see the results in the sample graphs above.

### Lessons Learned

This little project turned out to be somewhat more difficult than I had envisioned, and there are several lessons-learned, particularly in the use of ggplot2.

First, ggplot2 really needs data frames when plotting. Passing discrete values or variables not connected to a data frame will often result in errors or just incorrect results. This is different than either base graphics or grid graphics, and while Hadley Wickham has mentioned this before, I hadn’t fully appreciated it. For instance, this doesn’t work very well:

```my.test.data <- data.frame(x = seq(1:10), y = round(runif(10, 100, 300)))
my.test.gplot <- ggplot(my.test.data, aes(x = x, y = y)) +
geom_point(shape = 20)
index.1 <- c(5, 6, 7)
my.test.gplot <- my.test.gplot +
geom_point(aes(x = x[index.1], y = y[index.1]), col = "red")
my.test.gplot
```

Different variations of this sometimes worked, or sometimes only plotted some of the points that are supposed to be colored red.

However, if I wrap that index.1 into a data frame, it works perfectly:

```my.test.data <- data.frame(x = seq(1:10), y = round(runif(10, 100, 300)))
my.test.gplot <- ggplot(my.test.data, aes(x = x, y = y)) +
geom_point(shape = 20)
index.1 <- c(5, 6, 7)
my.test.subdata <- my.test.data[index.1,]
my.test.gplot <- my.test.gplot +
geom_point(data = my.test.subdata, aes(x = x, y = y), col = "red")
my.test.gplot
```

Another nice lesson was that `aes()` doesn’t always work properly when ggplot2 is called from within a function. In this case, `aes_string()` usually works. There’s less documentation than I would like on this, but you can search the ggplot2 Google Group or Stack Overflow for more information.

One of the bigger surprises was discovering that `aes()` searches for data frames in the global environment. When `ggplot()` is used from within a function, though, any variables created within that function are not accessible in the global environment. The work-around is to tell ggplot which environment to search in, and a simple addition of `environment = environment()` within the `ggplot()` call seems to do the trick. This is captured in a stack overflow post and the ggplot2 issue log.

```my.test.data <- data.frame(x = seq(1:10), y = round(runif(10, 100, 300)))
my.test.gplot <- ggplot(my.test.data, environment = environment(), aes(x = x, y = y)) +
geom_point(shape = 20)
index.1 <- c(5, 6, 7)
my.test.subdata <- my.test.data[index.1,]
my.test.gplot <- my.test.gplot +
geom_point(data = my.test.subdata, aes(x = x, y = y), col = "blue")
my.test.gplot
```

Finally, it is possible to completely and seamlessly replace a function created in a package and loaded in that package’s namespace. When I set out, I wanted to end up with a complete replacement for qcc’s internal `plot.qcc()` function, but wasn’t quite sure this would be possible. Luckily, the below code, called after the function declaration, worked. One thing I found was that I needed to name my function the same as the one in the qcc package in order for the replacement to work in all cases. If I used a different name for my function, it would work when I called `plot()` with a qcc object, but qcc’s base graphics version would be used when calling `qcc()` with the parameter `plot = TRUE`.

```unlockBinding(sym="plot.qcc", env=getNamespace("qcc"));
assignInNamespace(x="plot.qcc", value=plot.qcc, ns=asNamespace("qcc"), envir=getNamespace("qcc"));
assign("plot.qcc", plot.qcc, envir=getNamespace("qcc"));
lockBinding(sym="plot.qcc", env=getNamespace("qcc"));
```

### Outlook

For now, the code suits my immediate needs, and I hope that you will find it useful. I have some ideas for additional features that I may implement in the future. There are some parts of the code that can and should be further cleaned up, and I’ll tweak the code as needed. I am certainly interested in any bug reports and in seeing any forks; good ideas are always welcome.

### References

• R Core Team (2013). R: A language and environment for statistical computing. R Foundation for Statistical Computing, Vienna, Austria. URL http://www.R-project.org/.
• Scrucca, L. (2004). qcc: an R package for quality control charting and statistical process control. R News 4/1, 11-17.
• H. Wickham. ggplot2: elegant graphics for data analysis. Springer New York, 2009.
• Wheeler, Donald. “Individual Charts Done Right and Wrong.” Quality Digest. 2 Feb 20102 Feb 2010. Print. <http://www.spcpress.com/pdf/DJW206.pdf>.