---
title: Graphics and Data Visualization in R
author: "First/last name (first.last@ucr.edu)"
date: "Last update: `r format(Sys.time(), '%d %B, %Y')`" 
output:
  html_document:
    toc: true
    toc_float:
        collapsed: true
        smooth_scroll: true
    toc_depth: 3
    fig_caption: yes
    code_folding: show
    number_sections: true

fontsize: 14pt
bibliography: bibtex.bib
weight: 15
type: docs
---

<!--
- Compile from command-line
Rscript -e "rmarkdown::render('rgraphics.Rmd', c('html_document'), clean=F); knitr::knit('rgraphics.Rmd', tangle=TRUE)"
-->


```{r style, echo = FALSE, results = 'asis'}
BiocStyle::markdown()
options(width=100, max.print=1000)
knitr::opts_chunk$set(
    message=FALSE,
    eval=as.logical(Sys.getenv("KNITR_EVAL", "TRUE")),
    cache=as.logical(Sys.getenv("KNITR_CACHE", "TRUE")))
```

<div style="text-align: right"> 
Source code downloads: &nbsp; &nbsp;
[ [.Rmd](https://raw.githubusercontent.com/tgirke/GEN242//main/content/en/tutorials/rgraphics/rgraphics.Rmd) ] &nbsp; &nbsp; 
[ [.R](https://raw.githubusercontent.com/tgirke/GEN242//main/content/en/tutorials/rgraphics/rgraphics.R) ]
</div>


## Overview

### Graphics in R

-   Powerful environment for visualizing scientific data
-   Integrated graphics and statistics infrastructure
-   Publication quality graphics
-   Fully programmable
-   Highly reproducible
-   Full [LaTeX](http://www.latex-project.org/), [Sweave](http://www.stat.auckland.ac.nz/~dscott/782/Sweave-manual-20060104.pdf), [knitr](http://yihui.name/knitr/) and [R Markdown](http://rmarkdown.rstudio.com/) support.
-   Vast number of R packages with graphics utilities


### Documentation on Graphics in R

- General 
    - [Graphics Task Page](https://cran.r-project.org/web/views/)
    - [R Graph Gallery](http://www.r-graph-gallery.com/)
    - [R Graphical Manual](https://www.imsbio.co.jp/RGM/R_image_list?page=575&init=true)
    - [Paul Murrell’s book R (Grid) Graphics](http://www.stat.auckland.ac.nz/~paul/RGraphics/rgraphics.html)
    - ggplot2: [Book](https://ggplot2-book.org/), [R for Data Science](https://r4ds.had.co.nz/data-visualisation.html) and [ggplot2 reference](https://ggplot2.tidyverse.org/reference/)

- Interactive graphics
    - [rggobi (GGobi)](http://www.ggobi.org/)
    - [iplots](http://www.iplots.org/)
    - [Open GL (`rgl`)](http://rgl.neoscientists.org/gallery.shtml)
    - [plotly](https://plotly.com/r/)


### Graphics Environments

- Viewing and savings graphics in R
    - On-screen graphics
    - postscript, pdf, svg
    - jpeg/png/wmf/tiff/...

- Four major graphics environments
    - Low-level infrastructure
        - R Base Graphics (low- and high-level)
        - `grid`: [Manual](http://www.stat.auckland.ac.nz/~paul/grid/grid.html), [Book](http://www.stat.auckland.ac.nz/~paul/RGraphics/rgraphics.html)
    - High-level infrastructure
        - `lattice`: [Manual](http://lmdvr.r-forge.r-project.org), [Intro](https://lattice.r-forge.r-project.org/Vignettes/src/lattice-intro/lattice-intro.pdf), [Book](http://www.amazon.com/Lattice-Multivariate-Data-Visualization-Use/dp/0387759689)
        - `ggplot2`: [Manual](https://r4ds.hadley.nz/data-visualize.html), [Intro](http://www.ling.upenn.edu/~joseff/rstudy/summer2010_ggplot2_intro.html), [Book](https://ggplot2-book.org/)


## Base Graphics

### Overview

- Important high-level plotting functions
    - `plot`: generic x-y plotting
    - `barplot`: bar plots
    - `boxplot`: box-and-whisker plot
    - `hist`: histograms
    - `pie`: pie charts
    - `dotchart`: cleveland dot plots
    - `image, heatmap, contour, persp`: functions to generate image-like plots
    - `qqnorm, qqline, qqplot`: distribution comparison plots
    - `pairs, coplot`: display of multivariant data

- Help on these functions
    - `?myfct`
    - `?plot`
    - `?par`

### Preferred Input Data Objects

- Matrices and data frames
- Vectors
- Named vectors

### Scatter Plots

#### Basic scatter plots

Sample data set for subsequent plots
```{r scatter_plot_basic, eval=TRUE}
set.seed(1410)
y <- matrix(runif(30), ncol=3, dimnames=list(letters[1:10], LETTERS[1:3]))
y
plot(y[,1], y[,2]) 
```

#### All pairs

```{r scatter_plot_allpairs, eval=TRUE}
pairs(y) 
```

#### Plot labels

```{r scatter_plot_labels, eval=TRUE}
plot(y[,1], y[,2], pch=20, col="red", main="Symbols and Labels")
text(y[,1]+0.03, y[,2], rownames(y))
```

#### More examples

Print instead of symbols the row names

```{r scatter_plot_row_names, eval=FALSE}
plot(y[,1], y[,2], type="n", main="Plot of Labels")
text(y[,1], y[,2], rownames(y)) 
```

Usage of important plotting parameters

```{r plot_parameters, eval=FALSE}
grid(5, 5, lwd = 2) 
op <- par(mar=c(8,8,8,8), bg="lightblue")
plot(y[,1], y[,2], type="p", col="red", cex.lab=1.2, cex.axis=1.2, 
     cex.main=1.2, cex.sub=1, lwd=4, pch=20, xlab="x label", 
     ylab="y label", main="My Main", sub="My Sub")
par(op)
```

Important arguments}
    - `mar`: specifies the margin sizes around the plotting area in order: `c(bottom, left, top, right)` 
    - `col`: color of symbols
    - `pch`: type of symbols, samples: `example(points)`
    - `lwd`: size of symbols
    - `cex.*`: control font sizes
    - For details see `?par`


Add a regression line to a plot

```{r scatter_plot_regress, eval=TRUE}
plot(y[,1], y[,2])
myline <- lm(y[,2]~y[,1]); abline(myline, lwd=2) 
summary(myline) 
```

Same plot as above, but on log scale

```{r scatter_plot_log_scale, eval=TRUE}
plot(y[,1], y[,2], log="xy") 
```

Add a mathematical expression to a plot

```{r scatter_plot_math, eval=TRUE}
plot(y[,1], y[,2]); text(y[1,1], y[1,2], 
     expression(sum(frac(1,sqrt(x^2*pi)))), cex=1.3) 
```

#### Exercise 1

- __Task 1__: Generate scatter plot for first two columns in `iris` data frame and color dots by its `Species` column.
- __Task 2__: Use the `xlim/ylim` arguments to set limits on the x- and y-axes so that all data points are restricted to the left bottom quadrant of the plot. 

Structure of iris data set:
```{r iris_structure, eval=TRUE}
class(iris)
iris[1:4,]
table(iris$Species)
```

```{r exercise1_solution, eval=FALSE, echo=FALSE}
plot(iris[,1], iris[,2], col=iris$Species, lwd=2, pch=19)
plot(iris[,1], iris[,2], col=iris$Species, lwd=2, pch=19, xlim=c(4,16), ylim=c(2,8))
```

### Line Plots

#### Single Data Set

```{r line_plot_single, eval=TRUE}
plot(y[,1], type="l", lwd=2, col="blue") 
```

Additional lines can be added to an existing plot with the `lines()` function.

```{r line_plot_multiple, eval=TRUE}
plot(y[,1], type="l", lwd=2, col="blue")
lines(y[,2], lwd=2, lty=1,  col="red")
legend(8.3, 0.95, legend=c("Line 1", "Line 2"), col=c("blue", "red"), lty=1)
```

#### Many Data Sets 

Alterntively, one can plot a line graph for all columns in data frame `y` with the following approach. The `split.screen` 
function is used in this example in a `for` loop to overlay several line graphs in the same plot. 

```{r line_plot_many, eval=TRUE}
split.screen(c(1,1)) 
plot(y[,1], ylim=c(0,1), xlab="Measurement", ylab="Intensity", type="l", lwd=2, col=1)
for(i in 2:length(y[1,])) { 
	screen(1, new=FALSE)
	plot(y[,i], ylim=c(0,1), type="l", lwd=2, col=i, xaxt="n", yaxt="n", ylab="", 
             xlab="", main="", bty="n") 
}
close.screen(all=TRUE) 
```

### Bar Plots

#### Basics

```{r bar_plot_basic, eval=TRUE}
barplot(y[1:4,], ylim=c(0, max(y[1:4,])+0.3), beside=TRUE, 
        legend=letters[1:4]) 
text(labels=round(as.vector(as.matrix(y[1:4,])),2), x=seq(1.5, 13, by=1)
     +sort(rep(c(0,1,2), 4)), y=as.vector(as.matrix(y[1:4,]))+0.04) 
```
	
#### Error bars

```{r bar_plot_error_bar, eval=TRUE}
bar <- barplot(m <- rowMeans(y) * 10, ylim=c(0, 10))
stdev <- sd(t(y))
arrows(bar, m, bar, m + stdev, length=0.15, angle = 90)
```

#### Mirrored bar plot

```{r bar_plot_mirrored, eval=TRUE}
df <- data.frame(group = rep(c("Above", "Below"), each=10), x = rep(1:10, 2), y = c(runif(10, 0, 1), runif(10, -1, 0)))
plot(c(0,12), range(df$y), type = "n")
barplot(height = df$y[df$group == "Above"], add = TRUE, axes = FALSE)
barplot(height = df$y[df$group == "Below"], add = TRUE, axes = FALSE)
```

#### Bar plot of loan payments and amortization tables

The following imports a `mortgage` payment function (from [here](https://raw.githubusercontent.com/tgirke/GEN242/main/content/en/tutorials/rgraphics/scripts/mortgage.R)) that calculates
monthly and annual mortgage/loan payments, generates amortization tables and
plots the results in form of a bar plot. A Shiny App using this function has been created
by Antoine Soetewey [here](https://antoinesoetewey.shinyapps.io/mortgage-calculator/). 

```{r bar_plot_mortgage, eval=TRUE}
source("https://raw.githubusercontent.com/tgirke/GEN242/main/content/en/tutorials/rgraphics/scripts/mortgage.R")
m <- mortgage(P=250000, I=6, L=15, plotData=TRUE)
```

### Histograms

```{r hist_plot, eval=TRUE}
hist(y, freq=TRUE, breaks=10)
```

### Density Plots}

```{r density_plot, eval=TRUE}
plot(density(y), col="red")
```

### Pie Charts

```{r pie_chart, eval=TRUE}
pie(y[,1], col=rainbow(length(y[,1]), start=0.1, end=0.8), clockwise=TRUE)
legend("topright", legend=row.names(y), cex=1.3, bty="n", pch=15, pt.cex=1.8, 
col=rainbow(length(y[,1]), start=0.1, end=0.8), ncol=1) 
```

### Color Selection Utilities

Default color palette and how to change it

```{r color_palette, eval=TRUE}
palette()
palette(rainbow(5, start=0.1, end=0.2))
palette()
palette("default")
```

The `gray` function allows to select any type of gray shades by providing values from 0 to 1

```{r gray_palette, eval=TRUE}
gray(seq(0.1, 1, by= 0.2))
```

Color gradients with `colorpanel` function from `gplots` library

```{r color_panel, eval=FALSE}
library(gplots)
colorpanel(5, "darkblue", "yellow", "white")
```

Much more on colors in R see Earl Glynn's [color chart](http://earlglynn.github.io/color/ColorInR)


### Arranging Several Plots on Single Page

With `par(mfrow=c(nrow, ncol))` one can define how several plots are arranged next to each other.

```{r par_mfrow, eval=TRUE}
par(mfrow=c(2,3)) 
for(i in 1:6) plot(1:10) 
```

#### Arranging Plots with Variable Width

The `layout` function allows to divide the plotting device into variable numbers of rows and columns with the column-widths and the row-heights specified in the respective arguments.

```{r layout_plot, eval=TRUE}
nf <- layout(matrix(c(1,2,3,3), 2, 2, byrow=TRUE), c(3,7), c(5,5), 
             respect=TRUE)
# layout.show(nf)
for(i in 1:3) barplot(1:10) 
```

### Saving Graphics to Files

After the `pdf()` command all graphs are redirected to file `test.pdf`. Works for all common formats similarly: jpeg, png, ps, tiff, ...

```{r save_pdf, eval=FALSE}
pdf("test.pdf"); plot(1:10, 1:10); dev.off() 
```

Generates Scalable Vector Graphics (SVG) files that can be edited in vector graphics programs, such as InkScape.

```{r save_svg, eval=FALSE}
svg("test.svg"); plot(1:10, 1:10); dev.off() 
```

#### Exercise 2

Bar plots
        
- __Task 1__: Calculate the mean values for the `Species` components of the first four columns in the `iris` data set. Organize the results in a matrix where the row names are the unique values from the `iris Species` column and the column names are the same as in the first four `iris` columns. 
- __Task 2__: Generate two bar plots: one with stacked bars and one with horizontally arranged bars. 

Structure of iris data set:

```{r structure_iris2, eval=TRUE}
class(iris)
iris[1:4,]
table(iris$Species)
```

```{r exercise2_solution, eval=FALSE, echo=FALSE}
mMA <- sapply(colnames(iris[,1:4]), function(x) tapply(iris[,x], iris[,5], mean))
barplot(mMA, beside=T, legend=rownames(mMA))
```

## Grid Graphics

- What is `grid`?
    - Low-level graphics system 
    - Highly flexible and controllable system
    - Does not provide high-level functions 
    - Intended as development environment for custom plotting functions 
    - Pre-installed on new R distributions

- Documentation and Help
    - [Manual](http://www.stat.auckland.ac.nz/~paul/grid/grid.html)
    - [Book](http://www.stat.auckland.ac.nz/~paul/RGraphics/rgraphics.html)

## lattice Graphics

- What is `lattice`?
    - High-level graphics system 
    - Developed by Deepayan Sarkar 
    - Implements Trellis graphics system from S-Plus
    - Simplifies high-level plotting tasks: arranging complex graphical features 
    - Syntax similar to R's base graphics

- Documentation and Help
    - [Manual](http://lmdvr.r-forge.r-project.org)
    - [Intro](https://www.statmethods.net/advgraphs/trellis.html)
    - [Book](http://www.amazon.com/Lattice-Multivariate-Data-Visualization-Use/dp/0387759689)
		
Open a list of all functions available in the lattice package

```{r help_lattice, eval=FALSE}
library(lattice) 
library(help=lattice) 
```

Accessing and changing global parameters:

```{r param_lattice, eval=FALSE}
?lattice.options
?trellis.device
```

### Scatter Plot Sample

```{r scatter_plot_lattice, eval=TRUE}
library(lattice)
p1 <- xyplot(1:8 ~ 1:8 | rep(LETTERS[1:4], each=2), as.table=TRUE) 
plot(p1)
```

### Line Plot Sample

```{r line_plot_lattice, eval=TRUE}
library(lattice)
p2 <- parallelplot(~iris[1:4] | Species, iris, horizontal.axis = FALSE, 
              layout = c(1, 3, 1))  
plot(p2)
```

## ggplot2 Graphics

- What is `ggplot2`?
    - High-level graphics system developed by Hadley Wickham
    - Implements grammar of graphics from [Leland Wilkinson](http://www.amazon.com/Grammar-Graphics-Leland-Wilkinson/dp/0387987746) 
    - Streamlines many graphics workflows for complex plots
    - Syntax centered around main `ggplot` function 
    - Simpler `qplot` function provides many shortcuts
        
- Documentation and Help
    - [Book](https://ggplot2-book.org/)
    - [R for Data Science](https://r4ds.had.co.nz/data-visualisation.html) 
    - [ggplot2 reference](https://ggplot2.tidyverse.org/reference/)
    - [Cookbook for R](http://www.cookbook-r.com/Graphs/)

### Design Concept of `ggplot2`

Plotting formalized and implemented by the grammar of graphics by Leland Wilkinson and Hadley Wickham [@Wickham2010-nu; @Wilkinson2012-wv; @Wickham2009-aq]. The plotting process
in `ggplot2` is devided into layers including:

1. Data: the actual data to be plotted
2. Aesthetics: visual property of the objects in a plot (_e.g._ size, shape or color )
3. Geometries: shapes used to represent data (_e.g._ bar or scatter plot)
4. Facets: row and column layout of sub-plots
5. Statistics: data models and summaries
6. Coordinates: the plotting space
7. Theme: styles to be used, such as fonts, backgrounds, etc.

<center><img title="sphm" src="../images/grammar_ggplot2.png" width="500" /></center>


### `ggplot2` Usage
	
- `ggplot` function accepts two main arguments
    - Data set to be plotted 
	- Aesthetic mappings provided by `aes` function
- Additional parameters such as geometric objects (_e.g._ points, lines, bars) are passed on by appending them with `+` as separator. 
- List of available `geom_*` functions see [here](https://ggplot2.tidyverse.org/reference/) 
- Settings of plotting theme can be accessed with the command `theme_get()` and its settings can be changed with `theme()`. 
- Preferred input data object 
    - `qplot`: `data.frame` or `tibble` (support for `vector`, `matrix`, `...`)
    - `ggplot`: `data.frame` or `tibble`
- Packages with convenience utilities to create expected inputs
    - `dplyr` (`plyr`)
    - `tidyr` and `reshape2`

### `qplot` Function

The syntax of `qplot` is similar as R's basic `plot` function

- Arguments
    - `x`: x-coordinates (_e.g._ `col1`)
    - `y`: y-coordinates (_e.g._ `col2`)
	- `data`: `data.frame` or `tibble` with corresponding column names
	- `xlim, ylim`: _e.g._ `xlim=c(0,10)` 
    - `log`: _e.g._ `log="x"` or `log="xy"`
	- `main`: main title; see `?plotmath` for mathematical formula
	- `xlab, ylab`: labels for the x- and y-axes
	- `color`, `shape`, `size`
	- `...`: many arguments accepted by `plot` function

### `qplot`: scatter plot basics

Create sample data, here 3 vectors: `x`, `y` and `cat`
```{r qplot_scatter_plot_sample, eval=TRUE}
library(ggplot2)
x <- sample(1:10, 10); y <- sample(1:10, 10); cat <- rep(c("A", "B"), 5)
```

Simple scatter plot

```{r qplot_scatter_plot, eval=TRUE}
qplot(x, y, geom="point")
```

Prints dots with different sizes and colors

```{r qplot_scatter_plot_dot_param, eval=TRUE}
qplot(x, y, geom="point", size=x, color=cat, 
      main="Dot Size and Color Relative to Some Values")
```

Drops legend

```{r qplot_scatter_plot_no_legend, eval=TRUE}
qplot(x, y, geom="point", size=x, color=cat) + 
      theme(legend.position = "none")
```

Plot different shapes

```{r qplot_scatter_plot_shapes, eval=TRUE}
qplot(x, y, geom="point", size=5, shape=cat)
```

#### Colored groups

```{r qplot_scatter_plot_colored_groups, eval=TRUE}
p <- qplot(x, y, geom="point", size=x, color=cat, 
            main="Dot Size and Color Relative to Some Values") + 
     theme(legend.position = "none")
print(p)
``` 

#### Regression line

```{r qplot_scatter_regression_line, eval=TRUE}
set.seed(1410)
dsmall <- diamonds[sample(nrow(diamonds), 1000), ]
p <- qplot(carat, price, data = dsmall) +
           geom_smooth(method="lm")
print(p)
```

#### Local regression curve (loess)

```{r qplot_scatter_regression_loess, eval=TRUE}
p <- qplot(carat, price, data=dsmall, geom=c("point", "smooth")) 
print(p) # Setting se=FALSE removes error shade
```

### `ggplot` Function

- More important than `qplot` to access full functionality of `ggplot2`
- Main arguments
    - data set, usually a `data.frame` or `tibble`
	- aesthetic mappings provided by `aes` function
- General `ggplot` syntax
    - __`ggplot(data, aes(...)) + geom() + ... + stat() + ...`__
- Layer specifications
    - `geom(mapping, data, ..., geom, position)`
    - `stat(mapping, data, ..., stat, position)`
- Additional components
    - `scales`
	- `coordinates`
	- `facet`
- `aes()` mappings can be passed on to all components (`ggplot, geom`, etc.). Effects are global when passed on to `ggplot()` and local for other components.
    - `x, y`
	- `color`: grouping vector (factor) 
	- `group`: grouping vector (factor)

#### Changing Plotting Themes in `ggplot`

- Theme settings can be accessed with `theme_get()`
- Their settings can be changed with `theme()`

Example how to change background color to white
		
```{r ggplot_background_color, eval=FALSE}
... + theme(panel.background=element_rect(fill = "white", colour = "black")) 
```

#### Storing `ggplot` Specifications

Plots and layers can be stored in variables

```{r ggplot_store_plot, eval=FALSE}
p <- ggplot(dsmall, aes(carat, price)) + geom_point() 
p # or print(p)
```

Returns information about data and aesthetic mappings followed by each layer

```{r ggplot_summary, eval=FALSE}
summary(p) 
```

Print dots with different sizes and colors

```{r ggplot_dot_sizes, eval=FALSE}
bestfit <- geom_smooth(method = "lm", se = F, color = alpha("steelblue", 0.5), size = 2)
p + bestfit # Plot with custom regression line
```

Syntax to pass on other data sets

```{r ggplot_pass_data, eval=FALSE}
p %+% diamonds[sample(nrow(diamonds), 100),] 
```

Saves plot stored in variable `p` to file

```{r ggplot_save_plot, eval=FALSE}
ggsave(p, file="myplot.pdf") 
```

Standard R export functons for graphics work as well (see [here](https://girke.bioinformatics.ucr.edu/GEN242/tutorials/rgraphics/rgraphics/#saving-graphics-to-files)). 

### `ggplot`: scatter plots

#### Basic example

```{r ggplot_scatter_plot1, eval=TRUE}
set.seed(1410)  
dsmall <- as.data.frame(diamonds[sample(nrow(diamonds), 1000), ])
p <- ggplot(dsmall, aes(carat, price, color=color)) + 
            geom_point(size=4)
print(p) 
```

Interactive version of above plot can be generated with the `ggplotly` function from 
the `plotly` package.

```{r ggplot_scatter_plot_interactive1, eval=TRUE}
library(plotly)
ggplotly(p)
```

#### Regression line

```{r ggplot_regression_line, eval=TRUE}
p <- ggplot(dsmall, aes(carat, price)) + geom_point() + 
            geom_smooth(method="lm", se=FALSE) +
    	    theme(panel.background=element_rect(fill = "white", colour = "black"))
print(p) 
```

#### Several regression lines

```{r ggplot_many_regression_lines, eval=TRUE}
p <- ggplot(dsmall, aes(carat, price, group=color)) + 
            geom_point(aes(color=color), size=2) + 
            geom_smooth(aes(color=color), method = "lm", se=FALSE) 
print(p) 
```

#### Local regression curve (loess)

```{r ggplot_loess_regression, eval=TRUE}
p <- ggplot(dsmall, aes(carat, price)) + geom_point() + geom_smooth() 
print(p) # Setting se=FALSE removes error shade
```

### `ggplot`: line plot

```{r ggplot_line_plot, eval=TRUE}
p <- ggplot(iris, aes(Petal.Length, Petal.Width, group=Species, 
            color=Species)) + geom_line() 
print(p) 
```

### Faceting

```{r ggplot_line_plot_faceting, eval=TRUE}
p <- ggplot(iris, aes(Sepal.Length, Sepal.Width)) + 
    	    geom_line(aes(color=Species), size=1) + 
            facet_wrap(~Species, ncol=1)
print(p) 
```

#### Exercise 3

Scatter plots with `ggplot2`

- __Task 1__: Generate scatter plot for first two columns in `iris` data frame and color dots by its `Species` column.
- __Task 2__: Use the `xlim` and `ylim` arguments to set limits on the x- and y-axes so that all data points are restricted to the left bottom quadrant of the plot. 
- __Task 3__: Generate corresponding line plot with faceting presenting the individual data sets in saparate plots. 

Structure of `iris` data set

```{r structure_iris_data3, eval=TRUE}
class(iris)
iris[1:4,]
table(iris$Species)
```

```{r exercise3_solution, eval=FALSE, echo=FALSE}
ggplot(iris, aes(Sepal.Length, Sepal.Width)) + geom_point(aes(color=Species), size=3) + xlim(4,15) + ylim(2,12)
ggplot(iris, aes(Sepal.Length, Sepal.Width)) + geom_line(aes(color=Species), size=3) + ggtitle("Line Plot") + facet_wrap(~Species, ncol=1)
```

### Bar Plots

Sample Set: the following transforms the `iris` data set into a ggplot2-friendly format.

Calculate mean values for aggregates given by `Species` column in `iris` data set

```{r iris_mean, eval=TRUE}
iris_mean <- aggregate(iris[,1:4], by=list(Species=iris$Species), FUN=mean) 
```

Calculate standard deviations for aggregates given by `Species` column in `iris` data set

```{r iris_sd, eval=TRUE}
iris_sd <- aggregate(iris[,1:4], by=list(Species=iris$Species), FUN=sd) 
```

Reformat `iris_mean` with `melt` from wide to long form as expected by `ggplot2`. Newer 
alternatives for restructuring `data.frames` and `tibbles` from wide into long form use the 
`gather` and  `pivot_longer` functions defined by the `tidyr` package. Their usage is shown 
below as well. The functions `pivot_longer` and `pivot_wider` are expected to provide the most
flexible long-term solution, but may not work in older R versions.

```{r iris_mean_melt, eval=TRUE}
library(reshape2) # Defines melt function
df_mean <- melt(iris_mean, id.vars=c("Species"), variable.name = "Samples", value.name="Values")
df_mean2 <- tidyr::gather(iris_mean, !Species, key = "Samples", value = "Values")
df_mean3 <- tidyr::pivot_longer(iris_mean, !Species, names_to="Samples", values_to="Values") 
```

Reformat `iris_sd` with `melt`

```{r iris_sd_melt, eval=TRUE}
df_sd <- melt(iris_sd, id.vars=c("Species"), variable.name = "Samples", value.name="Values")
```

Define standard deviation limits

```{r iris_limits, eval=TRUE}
limits <- aes(ymax = df_mean[,"Values"] + df_sd[,"Values"], ymin=df_mean[,"Values"] - df_sd[,"Values"])
```

#### Verical orientation

```{r iris_mean_bar_plot, eval=TRUE}
p <- ggplot(df_mean, aes(Samples, Values, fill = Species)) + 
            geom_bar(position="dodge", stat="identity")
print(p) 
```

To enforce that the bars are plotted in the order specified in the input data, one can instruct `ggplot` 
to do so by turning the corresponding column (here `Species`) into an ordered factor as follows. 


```{r iris_factor_order, eval=FALSE}
df_mean$Species <- factor(df_mean$Species, levels=unique(df_mean$Species), ordered=TRUE)
```

In the above example this is not necessary since `ggplot` uses this order already. 

#### Horizontal orientation

```{r iris_mean_bar_plot_sideways, eval=TRUE}
p <- ggplot(df_mean, aes(Samples, Values, fill = Species)) + 
            geom_bar(position="dodge", stat="identity") + coord_flip() + 
            theme(axis.text.y=element_text(angle=0, hjust=1))
print(p) 
```

#### Faceting

```{r iris_mean_bar_plot_facetting, eval=FALSE}
p <- ggplot(df_mean, aes(Samples, Values)) + geom_bar(aes(fill = Species), stat="identity") +
            facet_wrap(~Species, ncol=1)
print(p) 
```

#### Error bars

```{r iris_mean_bar_plot_error, eval=TRUE}
p <- ggplot(df_mean, aes(Samples, Values, fill = Species)) + 
            geom_bar(position="dodge", stat="identity") + 
            geom_errorbar(limits, position="dodge") 
print(p) 
```

#### Mirrored 

```{r ggplot2_mirrored_barplot, eval=TRUE}
df <- data.frame(group = rep(c("Above", "Below"), each=10), x = rep(1:10, 2), y = c(runif(10, 0, 1), runif(10, -1, 0)))
p <- ggplot(df, aes(x=x, y=y, fill=group)) + 
	        geom_col()
print(p) 
```

### Changing Color Settings

```{r ggplot2_color1, eval=TRUE}
library(RColorBrewer)
# display.brewer.all() 
p <- ggplot(df_mean, aes(Samples, Values, fill=Species, color=Species)) +
            geom_bar(position="dodge", stat="identity") + geom_errorbar(limits, position="dodge") + 
            scale_fill_brewer(palette="Blues") + scale_color_brewer(palette = "Greys") 
print(p) 
```

#### Using standard R color theme

```{r ggplot2_color2, eval=TRUE}
p <- ggplot(df_mean, aes(Samples, Values, fill=Species, color=Species)) + 
            geom_bar(position="dodge", stat="identity") + geom_errorbar(limits, position="dodge") + 
            scale_fill_manual(values=c("red", "green3", "blue")) + 
            scale_color_manual(values=c("red", "green3", "blue")) 
print(p) 
```

#### Exercise 4

Bar plots

- __Task 1__: Calculate the mean values for the `Species` components of the first four columns in the `iris` data set. Use the `melt` function from the `reshape2` package to bring the data into the expected format for `ggplot`.
- __Task 2__: Generate two bar plots: one with stacked bars and one with horizontally arranged bars. 

Structure of iris data set

```{r iris_structure4, eval=TRUE}
class(iris)
iris[1:4,]
table(iris$Species)
```

```{r exercise4_solution, eval=FALSE, echo=FALSE}
iris_mean <- aggregate(iris[,1:4], by=list(Species=iris$Species), FUN=mean)
library(reshape2)
df_mean <- melt(iris_mean, id.vars=c("Species"), variable.name = "Samples", value.name="Values")
ggplot(df_mean, aes(Samples, Values, fill=Species)) + geom_bar(position="stack", stat="identity")
ggplot(df_mean, aes(Samples, Values, fill=Species)) + geom_bar(position="dodge", stat="identity")
```

### Data reformatting example 

Here for line plot

```{r ggplot_melt_data, eval=TRUE}
y <- matrix(rnorm(500), 100, 5, dimnames=list(paste("g", 1:100, sep=""), paste("Sample", 1:5, sep="")))
y <- data.frame(Position=1:length(y[,1]), y)
y[1:4, ] # First rows of input format expected by melt()
df <- melt(y, id.vars=c("Position"), variable.name = "Samples", value.name="Values")
p <- ggplot(df, aes(Position, Values)) + geom_line(aes(color=Samples)) + facet_wrap(~Samples, ncol=1)
print(p)
```

Same data can be represented in box plot as follows

```{r ggplot_melt_box_plot, eval=FALSE}
ggplot(df, aes(Samples, Values, fill=Samples)) + geom_boxplot() + geom_jitter(color="darkgrey")
```

### Jitter Plots

```{r ggplot_jitter_plot, eval=TRUE}
p <- ggplot(dsmall, aes(color, price/carat)) + 
            geom_jitter(alpha = I(1 / 2), aes(color=color))
print(p) 
```

### Box plots

```{r ggplot_box_plot2, eval=TRUE}
p <- ggplot(dsmall, aes(color, price/carat, fill=color)) + geom_boxplot()
print(p) 
```

### Violin plots

```{r ggplot_box_violin, eval=TRUE}
p <- ggplot(dsmall, aes(color, price/carat, fill=color)) + geom_violin()
print(p)
```

Same violin plot as interactive plot generated with `ggplotly`, where the actual data points 
are shown as well by including `geom_jitter()`. 

```{r ggplot_box_plot2_jitter, eval=TRUE}
p <- ggplot(dsmall, aes(color, price/carat, fill=color)) + geom_violin() + geom_jitter(aes(color=color))
ggplotly(p) 
```

### Density plots 

#### Line coloring

```{r ggplot_density_plot_linecol, eval=TRUE}
p <- ggplot(dsmall, aes(carat)) + geom_density(aes(color = color))
print(p) 
```

#### Area coloring

```{r ggplot_density_plot_areacol, eval=TRUE}
p <- ggplot(dsmall, aes(carat)) + geom_density(aes(fill = color))
print(p) 
```

### Histograms

```{r ggplot_histogram, eval=TRUE}
p <- ggplot(iris, aes(x=Sepal.Width)) + 
            geom_histogram(aes(y = ..density.., fill = ..count..), binwidth=0.2) + 
            geom_density()  
print(p) 
```

### Pie Chart

```{r ggplot_pie_chart, eval=TRUE}
df <- data.frame(variable=rep(c("cat", "mouse", "dog", "bird", "fly")), 
                 value=c(1,3,3,4,2)) 
p <- ggplot(df, aes(x = "", y = value, fill = variable)) + 
            geom_bar(width = 1, stat="identity") + 
            coord_polar("y", start=pi / 3) + ggtitle("Pie Chart") 
print(p) 
```

### Wind Rose Pie Chart

```{r ggplot_windrose_pie_chart, eval=TRUE}
p <- ggplot(df, aes(x = variable, y = value, fill = variable)) + 
            geom_bar(width = 1, stat="identity") + 
            coord_polar("y", start=pi / 3) + 
            ggtitle("Pie Chart") 
print(p) 
```

### Arranging Graphics on Page 

Using `grid` package

```{r ggplot_arrange_graphics, eval=TRUE}
library(grid)
a <- ggplot(dsmall, aes(color, price/carat)) + geom_jitter(size=4, alpha = I(1 / 1.5), aes(color=color))
b <- ggplot(dsmall, aes(color, price/carat, color=color)) + geom_boxplot()
c <- ggplot(dsmall, aes(color, price/carat, fill=color)) + geom_boxplot() + theme(legend.position = "none")
grid.newpage() # Open a new page on grid device
pushViewport(viewport(layout = grid.layout(2, 2))) # Assign to device viewport with 2 by 2 grid layout 
print(a, vp = viewport(layout.pos.row = 1, layout.pos.col = 1:2))
print(b, vp = viewport(layout.pos.row = 2, layout.pos.col = 1))
print(c, vp = viewport(layout.pos.row = 2, layout.pos.col = 2, width=0.3, height=0.3, x=0.8, y=0.8))
```

Using `gridExtra` package                                                                                                                                                     
                                                                                                                                                                              
```{r ggplot_arrange_graphics2, eval=TRUE, warning=FALSE, message=FALSE}
library(gridExtra)                                                                                                                                                            
grid.arrange(a, b, c, nrow = 2, ncol=2)                                                                                                                                       
```    

Also see `patchwork` in ggplot2 book [here](https://ggplot2-book.org/arranging-plots.html).

### Inserting Graphics into Plots

```{r ggplot_insert_graphics, eval=TRUE}
library(grid)
print(a)
print(b, vp=viewport(width=0.3, height=0.3, x=0.8, y=0.8))
```

## Specialty Graphics

### Spatial Heatmap Diagrams 

Spatial expression data can be visualized with the [`spatialHeatmap`](https://bioconductor.org/packages/release/bioc/vignettes/spatialHeatmap/inst/doc/spatialHeatmap.html) package.

<center><img title="sphm" src="../images/spatial_heatmap.jpeg" width="500" /></center>


### Venn Diagrams 

```{r specgraph_venn, eval=TRUE, message=FALSE, fig.dim=c(5,5), fig.align="center"}
library(systemPipeR)
setlist5 <- list(A=sample(letters, 18), B=sample(letters, 16), C=sample(letters, 20), D=sample(letters, 22), E=sample(letters, 18))
OLlist5 <- overLapper(setlist=setlist5, sep="_", type="vennsets")
vennPlot(OLlist5, mymain="", mysub="default", colmode=2, ccol=c("blue", "red"))
```

### UpSet Plots

```{r specgraph_upset, eval=TRUE, message=FALSE, fig.dim=c(5,5), fig.align="center"}
library(ComplexHeatmap)
setlist <- list(A=sample(letters, 18), B=sample(letters, 16), C=sample(letters, 20))
setma <- make_comb_mat(setlist)
UpSet(setma)
```

### Compound Structures 

Plots depictions of small molecules with `ChemmineR` package

```{r specgraph_structure, eval=TRUE}
library(ChemmineR)
data(sdfsample)
plot(sdfsample[1], print=FALSE)
```

### Heatmaps

There are many packages for plotting heatmaps in R. The following uses `pheatmap`.

```{r pheatmap, eval=TRUE, warning=FALSE, message=FALSE, fig.dim=c(6,6), fig.align="center"}
library(pheatmap); library("RColorBrewer")
y <- matrix(rnorm(50), 10, 5, dimnames=list(paste("g", 1:10, sep=""), paste("t", 1:5, sep="")))
pheatmap(y, color=brewer.pal(9,"Blues"))
```

### ROC Plots

A variety of libraries are available for plotting receiver operating characteristic (ROC) curves in R:

+ [ROCR](http://rocr.bioinf.mpi-sb.mpg.de/)
+ [ROC](http://bioconductor.org/packages/release/bioc/html/ROC.html)
+ [pROC](http://web.expasy.org/pROC/) (includes ggplot2)
+ [plotROC](https://cran.r-project.org/web/packages/plotROC/) (uses ggplot2)
+ [ggplot2](http://largedata.blogspot.com/2011/07/plotting-roc-curves-in-ggplot2.html) (custom code example)

#### Example with ROCR

Most commonly, in an ROC we plot the true positive rate (y-axis) against the false positive rate (x-axis) at decreasing thresholds. 
An illustrative example is provided in the `ROCR` package where one wants to inspect the content of the `ROCR.simple` object
defining the structure of the input data in two vectors.


```{r ROCR_example, eval=TRUE, warning=FALSE, message=FALSE}
# install.packages("ROCR") # Install if necessary
library(ROCR)
data(ROCR.simple)
ROCR.simple
pred <- prediction(ROCR.simple$predictions, ROCR.simple$labels)
perf <- performance( pred, "tpr", "fpr" )
plot(perf)
```

Obtain area under the curve (AUC)

```{r ROCR_example2, eval=TRUE, warning=FALSE, message=FALSE}
auc <- performance( pred, "tpr", "fpr", measure = "auc")
auc@y.values[[1]]
```

#### Example with plotROC

The [`plotROC`](https://cran.r-project.org/web/packages/plotROC/) package plots ROCs with `ggplot2`. The following generates a sample data set for several performance
results, here three. For convenience the data are first arranged in a `data.frame` in wide format. Next, the `melt_roc` 
is used to convert the `data.frame` into the long format as required by `ggplot`.

```{r plotROC_example, eval=TRUE, warning=FALSE, message=FALSE}
library(plotROC)
set.seed(2529)
D.ex <- rbinom(200, size = 1, prob = .5); M1 <- rnorm(200, mean = D.ex, sd = .65); M2 <- rnorm(200, mean = D.ex, sd = 1.1); M3 <- rnorm(200, mean = D.ex, sd = 1.5)
perfDF <- data.frame(D = D.ex, D.str = c("TRUE", "Ill")[D.ex + 1], M1 = M1, M2 = M2, M3=M3, stringsAsFactors = FALSE)
perfDF[1:4,] # wide format
long_perfDF <- melt_roc(perfDF, "D", c("M1", "M2", "M3")) # transformed into long format for ggplot
long_perfDF[1:4,] # long format
```

After converting the sample data into the long format the results can be plotted with `geom_roc`, where several 
ROCs are combined in a single plot and the corresponding AUC values are shown in the legend. 

```{r plotROC_example2, eval=TRUE, warning=FALSE, message=FALSE}
multi_roc <- ggplot(long_perfDF, aes(d = D, m = M, color = name)) + geom_roc(n.cuts=0) 
auc_df <- calc_auc(multi_roc) # calculate AUC values
auc_str <- paste0(auc_df$name, ": ", round(auc_df$AUC, 2))
multi_roc + scale_color_manual(name="AUC:", labels=auc_str, values=seq_along(auc_str))
```

### Trees 

The [`ape`](http://ape-package.ird.fr/ape_screenshots.html) package provides many useful utilities for phylogenetic analysis and tree plotting. Another useful package for 
plotting trees is [`ggtree`](http://bioconductor.org/packages/release/bioc/html/ggtree.html). The following example plots two trees face to face with links to identical
leaf labels.

```{r trees_ape1, eval=TRUE}
library(ape)
tree1 <- rtree(40)
tree2 <- rtree(20)
association <- cbind(tree2$tip.label, tree2$tip.label)
cophyloplot(tree1, tree2, assoc = association,
            length.line = 4, space = 28, gap = 3)
```



## Genome Graphics

### `ggbio`

- What is `ggbio`?
    - A programmable genome browser environment

- Genome broswer concepts 
    - A genome browser is a visulalization tool for plotting different types of genomic data in separate tracks along chromosomes. 
	- The `ggbio` package [@Yin2012-jj] facilitates plotting of complex genome data objects, such as read alignments (SAM/BAM), genomic context/annotation information (gff/txdb), variant calls (VCF/BCF), and more. To easily compare these data sets, it extends the faceting facility of `ggplot2` to genome browser-like tracks.
	- Most of the core object types for handling genomic data with R/Bioconductor are supported: `GRanges`, `GAlignments`, `VCF`, etc. For more details, see Table 1.1 of the `ggbio` vignette [here](http://www.bioconductor.org/packages/release/bioc/vignettes/ggbio/inst/doc/ggbio.pdf).
    - `ggbio`'s convenience plotting function is `autoplot`. For more customizable plots, one can use the generic `ggplot` function.
	- Apart from the standard `ggplot2` plotting components, `ggbio` defines serval new components useful for genomic data visualization. A detailed list is given in Table 1.2 of the vignette [here](http://www.bioconductor.org/packages/release/bioc/vignettes/ggbio/inst/doc/ggbio.pdf). 
	- Useful web sites:
		- [ggbio Bioc vignette](http://bioconductor.org/packages/release/bioc/html/ggbio.html)
        - [ggbio online manual](https://lawremi.github.io/ggbio/)
		- [autoplot demo](https://lawremi.github.io/ggbio/docs/man/autoplot-method.html)

#### Tracks: aligning plots along chromosomes

```{r ggbio_align, eval=TRUE, warning=FALSE, message=FALSE}
library(ggbio)
df1 <- data.frame(time = 1:100, score = sin((1:100)/20)*10)
p1 <- qplot(data = df1, x = time, y = score, geom = "line")
df2 <- data.frame(time = 30:120, score = sin((30:120)/20)*10, value = rnorm(120-30 +1))
p2 <- ggplot(data = df2, aes(x = time, y = score)) + geom_line() + geom_point(size = 2, aes(color = value))
tracks(time1 = p1, time2 = p2) + xlim(1, 40) + theme_tracks_sunset()
```

#### Plotting genomic ranges

`GRanges` objects are essential for storing alignment or annotation ranges in R/Bioconductor. The following creates a sample `GRanges` object and plots its content.

```{r ggbio_granges, eval=TRUE}
library(GenomicRanges)
set.seed(1); N <- 100; gr <- GRanges(seqnames = sample(c("chr1", "chr2", "chr3"), size = N, replace = TRUE), IRanges(start = sample(1:300, size = N, replace = TRUE), width = sample(70:75, size = N,replace = TRUE)), strand = sample(c("+", "-"), size = N, replace = TRUE), value = rnorm(N, 10, 3), score = rnorm(N, 100, 30), sample = sample(c("Normal", "Tumor"), size = N, replace = TRUE), pair = sample(letters, size = N, replace = TRUE))
autoplot(gr, aes(color = strand, fill = strand), facets = strand ~ seqnames)
```

#### Plotting coverage 

```{r ggbio_coverage, eval=TRUE}
autoplot(gr, aes(color = strand, fill = strand), facets = strand ~ seqnames, stat = "coverage")
```

#### Mirrored coverage 

```{r ggbio_mirrored_coverage, eval=TRUE}
pos <- sapply(coverage(gr[strand(gr)=="+"]), as.numeric)
pos <- data.frame(Chr=rep(names(pos), sapply(pos, length)), Strand=rep("+", length(unlist(pos))), Position=unlist(sapply(pos, function(x) 1:length(x))), Coverage=as.numeric(unlist(pos)))
neg <- sapply(coverage(gr[strand(gr)=="-"]), as.numeric)
neg <- data.frame(Chr=rep(names(neg), sapply(neg, length)), Strand=rep("-", length(unlist(neg))), Position=unlist(sapply(neg, function(x) 1:length(x))), Coverage=-as.numeric(unlist(neg)))
covdf <- rbind(pos, neg)
p <- ggplot(covdf, aes(Position, Coverage, fill=Strand)) + 
            geom_col() + 
            facet_wrap(~Chr)
p
```

### Circular genome plots

```{r ggbio_circular1, eval=TRUE}
ggplot(gr) + 
    layout_circle(aes(fill = seqnames), geom = "rect")
```

More complex circular example

```{r ggbio_circular2, eval=FALSE}
seqlengths(gr) <- c(400, 500, 700)
values(gr)$to.gr <- gr[sample(1:length(gr), size = length(gr))]
idx <- sample(1:length(gr), size = 50)
gr <- gr[idx]
ggplot() + 
    layout_circle(gr, geom = "ideo", fill = "gray70", radius = 7, trackWidth = 3) +
    layout_circle(gr, geom = "bar", radius = 10, trackWidth = 4, aes(fill = score, y = score)) +
    layout_circle(gr, geom = "point", color = "red", radius = 14, trackWidth = 3, grid = TRUE, aes(y = score)) +
    layout_circle(gr, geom = "link", linked.to = "to.gr", radius = 6, trackWidth = 1)
```

<center><img title="vim-r" src="../images/circularplot.png"/></center>

#### Alignments and variants

To make the following example work, please download and unpack this [data archive](https://cluster.hpcc.ucr.edu/~tgirke/HTML_Presentations/Manuals/Workshop_Dec_12_16_2013/Rgraphics/data.zip) containing GFF, BAM and VCF sample files.

```{r ggbio_align_variants, eval=TRUE, warning=FALSE, message=FALSE}
library(rtracklayer); library(GenomicFeatures); library(Rsamtools); library(GenomicAlignments); library(VariantAnnotation)
ga <- readGAlignments("./data/SRR064167.fastq.bam", use.names=TRUE, param=ScanBamParam(which=GRanges("Chr5", IRanges(4000, 8000))))
p1 <- autoplot(ga, geom = "rect")
p2 <- autoplot(ga, geom = "line", stat = "coverage")
vcf <- readVcf(file="data/varianttools_gnsap.vcf", genome="ATH1")
p3 <- autoplot(vcf[seqnames(vcf)=="Chr5"], type = "fixed") + xlim(4000, 8000) + theme(legend.position = "none", axis.text.y = element_blank(), axis.ticks.y=element_blank())
txdb <- makeTxDbFromGFF(file="./data/TAIR10_GFF3_trunc.gff", format="gff3")
p4 <- autoplot(txdb, which=GRanges("Chr5", IRanges(4000, 8000)), names.expr = "gene_id")
tracks(Reads=p1, Coverage=p2, Variant=p3, Transcripts=p4, heights = c(0.3, 0.2, 0.1, 0.35)) + ylab("")
```

### Additional examples

See `autoplot` demo [here](https://lawremi.github.io/ggbio/docs/man/autoplot-method.html)

### Additional genome graphics
	
- [`Gviz`](http://www.bioconductor.org/packages/devel/bioc/html/Gviz.html)
- [`RCircos`](http://cran.us.r-project.org/web/packages/RCircos/index.html) [@Zhang2013-zn]
- [`genoPlotR`](http://genoplotr.r-forge.r-project.org/)

### Genome Browser: IGV

View genome data in IGV

- Download and open [IGV](http://software.broadinstitute.org/software/igv/download)
- Select in menu in top left corner _A. thaliana_ (TAIR10)
- Upload the following indexed/sorted Bam files with `File -> Load from URL...`

```
https://cluster.hpcc.ucr.edu/~tgirke/Teaching/GEN242/bam_samples/SRR064154.fastq.bam
https://cluster.hpcc.ucr.edu/~tgirke/Teaching/GEN242/bam_samples/SRR064155.fastq.bam
https://cluster.hpcc.ucr.edu/~tgirke/Teaching/GEN242/bam_samples/SRR064166.fastq.bam
https://cluster.hpcc.ucr.edu/~tgirke/Teaching/GEN242/bam_samples/SRR064167.fastq.bam
```

- To view area of interest, enter its coordinates `Chr1:49,457-51,457` in position menu on top.

<center><img title="vim-r" src="../images/igv_peak_3.png"/></center>


#### Create symbolic links 

For viewing BAM files in IGV as part of `systemPipeR` workflows.

- `systemPipeR`: utilities for building NGS analysis pipelines.
	

```{r systempiper_symbolic_links, eval=FALSE, message=FALSE}
library("systemPipeR")
symLink2bam(sysargs=args, htmldir=c("~/.html/", "somedir/"), 
            urlbase="http://myserver.edu/~username/",
            urlfile="IGVurl.txt")
```

#### Controlling IGV from R

Open IGV before running the following routine. Alternatively, open IGV from within R with `startIGV("lm")`.
Note, the latter may not work on all systems. 

```{r control_igv, eval=FALSE, warning=FALSE, message=FALSE}
library(SRAdb)
myurls <- readLines("http://cluster.hpcc.ucr.edu/~tgirke/Documents/R_BioCond/Samples/bam_urls.txt")
# startIGV("lm") # opens IGV
sock <- IGVsocket()
IGVload(sock, myurls)
IGVgoto(sock, 'Chr1:45296-47019')
```

## Session Info

```{r sessionInfo}
sessionInfo()
```

## References
