Investigating the relationship between two variables may be much easier than investigating it for several variables simultaneously. There is one good reason for that: we can visualize bivariate relationships way better. Problems with numerous amount of variables are often split into several problems with only two variables.

There are several visualizations that supports the two variables context. The most popular of them may be the scatterplots. People are familiar with them, on the other hand there is a problem that haunts many scatterplots: over-plottingting. This chapter begins with recipes to draw very simple scatterplots, going all the way to explore solutions available when it comes to deal with over-plottingting, and demonstrate how enhance scattersplots by setting up marginal graphics.

Scatterplots play a major role in the representation of two continuous variables. Making simple scatterplots is a very easy task to handle using ggplot2, ggvis, or plotly. This recipe uses a data frame called iris to draw plots, it comes with base R (datasets package).

From the various features presented by this data set, this recipe uses Petal.Width and Petal.Length. They respectively account for iris' petal widths and lengths measured in centimeters. Besides drawing the plots, this recipe also teaches how to add a title to them. So, move on to the coding!

> library(ggplot2)
> sca1 ...

Version 0.4.3 of ggvisdoes not have a function to add titles to plots, but still there is a known way to hack the add_axis() function to work as a title function. If a user expects to explore this device many times, it's advised to wrap it into a function. Besides making the code more readable, it's a quicker way to address the problem.

> library(ggvis)
> ggvis_title <- function(vis, plot_title, title_size = 18, shift = 0, ...){ 
    add_axis(vis, 'x', ticks = 0, orient = 'top', 
             properties = axis_props( axis = list(strokeWidth = 0),
       ...

There are several aesthetics coming out from geom_points() that can be changed. Typing ?geom_point into the R console will take you to the function documentation, which comes with a complete list of aesthetics understood by the function. The mandatory ones come in bold.

Names given are nothing but self-explanatory. Besides the mandatory x and y values, optional values range from alpha to stroke. For this particular recipe, we're settling for changes in the shape and colours arguments. Recipe  also aims for similar results using both ggvis and plotly. 

How to do it...

1. Change the shape and colour arguments to get a better result:

> library(ggplot2)
> sca1 <- ggplot(data = iris, aes(x = Petal.Length, y = Petal.Width))
> sca1 + geom_point(aes(shape = Species, colour = Species))

Now each iris species is designated by a unique combination of shapes and colors:

Figure 2.3 - Adding shapes and colors to a scatter plot.

2. plotly can also handle such...

Shapes are picked following a default scale when you input a variable to work as shape using ggplot2. You can always choose to tweak this scale to one of your preference. To do so you need to know which shapes are available and how you can call for them. This recipe simply draws the following shape palette:

Figure 2.4 - ggplot2 shape palette.

It shows available points, plus the number used to call for them. Now let's explore the code that built it.

> palette <- data.frame(x = rep(seq(1,5,1),5))
> palette$y <- c(rep(5,5),rep(4,5),rep(3,5),rep(2,5),rep(1,5))
> library(ggplot2)
> ggplot(data = palette,aes(x,y)) +
    geom_point(shape = seq(1,25,1), size = 10, fill ='white') +
    scale_size(range = c(2, 10)) +
    geom_text(nudge_y = .3, label = seq(1,25,1))

There are mainly three techniques used to deal with over-plot. They are: (i) adopting smaller points,(ii) jittering data, and (iii) alpha blending. These are useful tools, not only to deal with over-plot but also to check if there is over-plotting.

However, these are not the only options; for example, alternative geometries can also be implemented. No matter how troublesome over-plotting may be there are good solutions available.There is not a single solution that is better for all the situations, so you must know a bunch of them. 

This recipe advises how to apply a technique based on point size reduction using ggplot2, ggvis and plotly. In order to do so, we are trusting the ggplot2::diamonds data frame. Keep in mind that reducing points works better for cases where points are very close to each other but do not actually occupy the same coordinates.

> library(ggplot2)
&gt...

Size reduction is never an option when there are too many points sharing the exact same coordinates; it simply is not the right tool for the job. A clear option therefore is to jitter the data, that is, add a little noise to the data so that the points move around a little bit and the over-plotting kind of wears off.

Two points must be highlighted here. Jittering may be a good way to adjust the plot but not to adjust the data, so do not use jittered data for modeling and always be honest when transformations of that nature take place. Second point is that as long it may work pretty well when many points share coordinates. Although, if too many points are only close enough but do no share same coordinates there is a chance that jittering will work very badly.

Now let's go back to the iris data set and demonstrate how this technique can be applied using ggplot2, ggvis and plotly.

Another popular technique is known as alpha blending. It consists on making points translucent, this way the audience gets to know if points are stacked or not.  Between all the techniques demonstrated so far, alpha blending must be the most popular one. This recipe teaches how to apply alpha blending using ggplot2, plotly, and ggvis.

How to do it...

1. Set the alpha parameter to apply alpha blending to ggplot:

> library(ggplot2)
> sca1 <- ggplot( iris, aes( x = Petal.Length, y = Petal.Width))
> sca1 + geom_point( alpha = .5 , 
                     aes(shape = Species, colour = Species))

The following figure 2.7 shows alpha blending working:

Figure 2.7 - alpha blending with ggplot2.

2. Setting alpha parameter with plotly will also apply alpha blending:

> library(plotly)
> sca9 <- plot_ly( iris, x = ~Petal.Length, y = ~Petal.Width, 
>                  type = 'scatter', mode = 'markers', alpha = .5, symbol = ~Species)
> sca9

3. ggvis applies...

Up till now, the chapter has focused on how to draw scatterplots and solutions related to over-plotting. Upcoming recipes, including this one, shall focus on enhancing scatterplots. If there is a bivariate relation to be displayed there is also two univariate distributions to show. How can they be used to improve the plots? 

Answer lies in filling the margins with supplemental plots carrying representations of underlying univariate distributions. Still relying on the iris data set framework, this recipe introduces a simple solution, almost restricted to ggplot2. Let's rug plots in the margins with geom_rug().

> set.seed(50) ; library(ggplot2)
> rug <- ggplot(iris,
                aes(x = Petal.Length, 
                    y = Petal.Width, 
                    colour = Species))
> rug <- rug +
    geom_jitter(aes( shape = Species), alpha = .4) +
    geom_rug(position...

Another way to go is to draw histograms or even density distributions in the margins. Drawing tailor made plots in the margins would require more code. On the other hand, if there is no need for greater customization ggExtra package can be used to spare many code lines. This recipe is demonstrating how to use ggExtra to easily draw histograms in the margins of a scatterplot. 

> if( !require(ggExtra)){ install.packages('ggExtra')}

library(ggplot2)
base_p <- ggplot(iris, aes(x = Petal.Length, y = Petal.Width, colour = Species))
scatter <- base_p + geom_point( alpha = .5, aes(shape = Species)) + 
  geom_rug(alpha = .5, sides = 'tr', show.legend = F) +
  theme(legend.position = 'bottom')