- 1 Introduction
- 2 Goals
- 3 Pedagogical Note
- 3.1 Set Up
- 4 A Teaser from John Snow
- 5 Review of Tidy Data
- 5.1 Kinds of Variables
- 6 Interrogations and Graphs
- 7 Components of the layered grammar of graphics
- 7.1 Data
- 7.2 Mapping
- 7.3 Geometric objects
- 7.4 Position adjustment
- 7.5 Statistical transformation
- 7.6 Scale
- 7.7 Coordinate system
- 7.8 Faceting
- 7.9 Defaults
The Grammar of Graphics
Arvind Venkatadri
06/July/2021
Abstract
Part of theR for Artists and Designers at the School of
Foundation Studies, Srishti Manipal Institute of Art, Design, and
Technology, Bangalore.
1 Introduction
This RMarkdown document is part of the Generic Skills Component (GSK) of the Course of the Foundation Studies Programme at Srishti Manipal Institute of Art, Design, and Technology, Bangalore India. The material is based on A Layered Grammar of Graphics by Hadley Wickham. The course is meant for First Year students pursuing a Degree in Art and Design.
The intent of this GSK part is to build Skill in coding in R, and also appreciate R as a way to metaphorically visualize information of various kinds, using predominantly geometric figures and structures.
All RMarkdown files combine code, text, web-images, and figures developed using code. Everything is text; code chunks are enclosed in fences (```)
2 Goals
At the end of this Lab session, we should: - know the types and
structures of tidy data and be able to work with them - be able to
create data visualizations using ggplot - Understand
aesthetics and scales in `ggplot
3 Pedagogical Note
The method followed will be based on PRIMM:
- PREDICT Inspect the code and guess at what the code might do, write predictions
- RUN the code provided and check what happens
- INFER what the
parametersof the code do and write comments to explain. What bells and whistles can you see? - MODIFY the
parameterscode provided to understand theoptionsavailable. Write comments to show what you have aimed for and achieved. - MAKE : take an idea/concept of your own, and graph it.
3.1 Set Up
The setup code chunk below brings into
our coding session R packages that provide specific
computational abilities and also datasets which we can
use.
To reiterate: Packages and datasets are not the same thing !! Packages are (small) collections of programs. Datasets are just….information.
5 Review of Tidy Data
“Tidy Data” is an important way of thinking about what data typically
look like in R. Let’s fetch a figure from the web to show the
(preferred) structure of data in R. (The syntax to bring in a web-figure
is )
The three features described in the figure above
define the nature of tidy data:
- Variables in Columns
- Observations in Rows and
- Measurements in Cells.
Data are imagined to be resulting from an experiment. Each variable represents a parameter/aspect in the experiment. Each row represents an additional datum of measurement. A cell is a single measurement on a single parameter(column) in a single observation(row).
5.1 Kinds of Variables
Kinds of Variable are defined by the kind of questions they answer to:
- What/Who/Where? -> Some kind of Name. Categorical variable
- What Kind? How? -> Some kind of “Type”. Factor variable
- How Many? How large? -> Some kind of Quantity. Numerical variable. Most Figures in R are computed with variables, and therefore, with columns.
6 Interrogations and Graphs
Creating graphs from data is an act of asking questions and viewing answers in a geometric way. Let us write some simple English descriptions of measures and visuals and see what commands they use in R.
7 Components of the layered grammar of graphics
Layers are used to create the objects on a plot. They are defined by five basic parts:
- Data (What dataset/spreadsheet am I using?)
- Mapping (What does each column do in my graph?)
- Statistical transformation (stat) (Do I have count something first?)
- Geometric object (geom) (What shape, colour, size…do I want?)
- Position adjustment (position) (Where do I want it on the graph?)
7.1 Data
We will use “real world” data. Let’s use the penguins
dataset in the palmerpenguins package. Run
?penguins in the console to get more information about this
dataset.
head(penguins)## # A tibble: 6 × 8
## species island bill_length_mm bill_depth_mm flipper_length_mm body_mass_g sex year
## <fct> <fct> <dbl> <dbl> <int> <int> <fct> <int>
## 1 Adelie Torgersen 39.1 18.7 181 3750 male 2007
## 2 Adelie Torgersen 39.5 17.4 186 3800 female 2007
## 3 Adelie Torgersen 40.3 18 195 3250 female 2007
## 4 Adelie Torgersen NA NA NA NA <NA> 2007
## 5 Adelie Torgersen 36.7 19.3 193 3450 female 2007
## 6 Adelie Torgersen 39.3 20.6 190 3650 male 2007tail(penguins)## # A tibble: 6 × 8
## species island bill_length_mm bill_depth_mm flipper_length_mm body_mass_g sex year
## <fct> <fct> <dbl> <dbl> <int> <int> <fct> <int>
## 1 Chinstrap Dream 45.7 17 195 3650 female 2009
## 2 Chinstrap Dream 55.8 19.8 207 4000 male 2009
## 3 Chinstrap Dream 43.5 18.1 202 3400 female 2009
## 4 Chinstrap Dream 49.6 18.2 193 3775 male 2009
## 5 Chinstrap Dream 50.8 19 210 4100 male 2009
## 6 Chinstrap Dream 50.2 18.7 198 3775 female 2009dim(penguins)## [1] 344 8So we know what our data looks like. We pass this data to
ggplot use to plot as follows: in R this creates an empty
graph sheet!! Because we have not (yet) declared the geometric shapes we
want to use to plot our information.
ggplot(data = penguins) # Creates an empty graphsheet, ready for plotting!!
7.2 Mapping
Now that we have told R what data to use, we need to state what variables to plot and how.
Aesthetic Mapping defines how the variables are applied to the plot, i.e. we take a variable from the data and “metaphorize” it into a geometric feature. We can map variables metaphorically to a variety of geometric things: coordinate, length, height, size, shape, colour, alpha(how dark?)….
The syntax uses:
aes(some_geometric_thing = some_variable)
Remember variable = column.
So if we were graphing information from penguins, we
might map a penguin’s flipper_length_mm
column to the x
position, and the body_mass_g column to
the y position.
7.2.1 Mapping Example-1
We can try another example of aesthetic mapping with the same dataset:
ggplot(data = penguins)
ggplot(penguins) +
# Plot geom = histogram. So we need a quantity on the x
geom_histogram(
aes(x = body_mass_g))
## `stat_bin()` using `bins = 30`. Pick better value with `binwidth`.
## Warning: Removed 2 rows containing non-finite values (stat_bin).
ggplot(penguins) +
# Plot geom = histogram. So we need a quantity on the x
geom_histogram(
aes(x = body_mass_g,
fill = island) # color aesthetic = another variable
)
## `stat_bin()` using `bins = 30`. Pick better value with `binwidth`.
## Warning: Removed 2 rows containing non-finite values (stat_bin).
7.2.2 Mapping Example-2
We can try another example of aesthetic mapping with the same dataset:
ggplot(data = penguins)
ggplot(penguins) +
# Plot geom = histogram. So we need a quantity on the x
geom_histogram(
aes(x = body_mass_g))
## `stat_bin()` using `bins = 30`. Pick better value with `binwidth`.
## Warning: Removed 2 rows containing non-finite values (stat_bin).
ggplot(penguins) +
# Plot geom = histogram. So we need a quantity on the x
geom_histogram(
aes(x = body_mass_g,
fill = island) # color aesthetic = another variable
)
## `stat_bin()` using `bins = 30`. Pick better value with `binwidth`.
## Warning: Removed 2 rows containing non-finite values (stat_bin).
7.2.3 Mapping Example-3
We can try another example of aesthetic mapping with the same dataset:
ggplot(data = penguins)
ggplot(penguins) +
# Plot geom = histogram. So we need a quantity on the x
geom_histogram(
aes(x = body_mass_g))
## `stat_bin()` using `bins = 30`. Pick better value with `binwidth`.
## Warning: Removed 2 rows containing non-finite values (stat_bin).
ggplot(penguins) +
# Plot geom = histogram. So we need a quantity on the x
geom_histogram(
aes(x = body_mass_g,
fill = island) # color aesthetic = another variable
)
## `stat_bin()` using `bins = 30`. Pick better value with `binwidth`.
## Warning: Removed 2 rows containing non-finite values (stat_bin).
7.2.4 Mapping Example-4
We can try another example of aesthetic mapping with the same dataset:
ggplot(data = penguins)
ggplot(penguins) +
# Plot geom = histogram. So we need a quantity on the x
geom_histogram(
aes(x = body_mass_g))
## `stat_bin()` using `bins = 30`. Pick better value with `binwidth`.
## Warning: Removed 2 rows containing non-finite values (stat_bin).
ggplot(penguins) +
# Plot geom = histogram. So we need a quantity on the x
geom_histogram(
aes(x = body_mass_g,
fill = island) # color aesthetic = another variable
)
## `stat_bin()` using `bins = 30`. Pick better value with `binwidth`.
## Warning: Removed 2 rows containing non-finite values (stat_bin).
7.3 Geometric objects
Geometric objects (geoms) control the type of plot you create. Geoms are classified by their dimensionality:
- 0 dimensions - point, text
- 1 dimension - path, line
- 2 dimensions - polygon, interval
Each geom can only display certain aesthetics or visual attributes of the geom. For example, a point geom has position, color, shape, and size aesthetics.
We can also stack up geoms on top of one another to add layers to the graph.
ggplot(penguins, aes(x = flipper_length_mm, y = body_mass_g)) +
geom_line()## Warning: Removed 2 row(s) containing missing values (geom_path).
ggplot(data = penguins) +
geom_line(aes(x = bill_length_mm,
y = body_mass_g))## Warning: Removed 2 row(s) containing missing values (geom_path).
ggplot(data = penguins) +
geom_point(aes(x = bill_length_mm,
y = body_mass_g,
color = island,
shape = species)) +
ggtitle("A point geom with position and color and shape aesthetics")## Warning: Removed 2 rows containing missing values (geom_point).
ggplot(data = penguins,
aes(x = species)) + # x position => ?
# No need to type "mapping"...
geom_bar() + # Where does the height come from?
ggtitle("A bar geom with position and height aesthetics")
ggplot(data = penguins, aes(x = species)) +
geom_bar() +
ggtitle("A bar geom with position and height aesthetics")
- Position determines the starting location (origin) of each bar
- Height determines how tall to draw the bar. Here the height is based on the number of observations in the dataset for each possible number of cylinders.
7.4 Position adjustment
Sometimes with dense data we need to adjust the position of elements on the plot, otherwise data points might obscure one another. Bar plots frequently stack or dodge the bars to avoid overlap:
count(x = penguins, species, island) %>%
ggplot(mapping = aes(x = species, y = n, fill = island)) +
geom_bar(stat = "identity") +
ggtitle(label = "A stacked bar chart")
count(x = penguins, species, island) %>%
ggplot(mapping = aes(x = species, y = n, fill = island)) +
geom_bar(stat = "identity", position = "dodge") +
ggtitle(label = "A dodged bar chart")
penguins %>%
ggplot(mapping = aes(x = species, fill = island)) +
geom_bar() +
ggtitle(label = "A stacked bar chart")
penguins %>%
ggplot(mapping = aes(x = species, fill = island)) +
geom_bar(position = "dodge") +
ggtitle(label = "A dodged bar chart")
Sometimes scatterplots with few unique x and y values are jittered (random noise is added) to reduce overplotting.
ggplot(data = penguins,
mapping = aes(x = species,
y = body_mass_g)) +
geom_point() +
ggtitle("A point geom with obscured data points")## Warning: Removed 2 rows containing missing values (geom_point).
ggplot(data = penguins,
mapping = aes(x = species,
y = body_mass_g)) +
geom_jitter() +
ggtitle("A point geom with jittered data points")## Warning: Removed 2 rows containing missing values (geom_point).
7.5 Statistical transformation
A statistical transformation (stat)
pre-transforms the data, before plotting. For instance, in a bar graph
you might summarize the data by counting the total number
of observations within a set of categories, and then plotting the
count.
count(x = penguins, island)## # A tibble: 3 × 2
## island n
## <fct> <int>
## 1 Biscoe 168
## 2 Dream 124
## 3 Torgersen 52mydat <- count(penguins,island)
ggplot(data = mydat) +
geom_col(aes(x = island, y = n))
penguins %>% # This IS a pipe Operator!!
count(., island) %>% # "." represents what is passed from the preceding command
ggplot(.) +
geom_col(aes(x = island, y = n))
penguins %>% # Our pipe Operator
ggplot(.) + # "." becomes the penguins dataset
geom_bar(aes(x = island)) # Note: y = count, and is computed internally!!
Sometimes you don’t need to make a statistical transformation. For example, in a scatterplot you use the raw values for the x and y variables to map onto the graph. In these situations, the statistical transformation is an identity transformation - the stat simply passes in the original dataset and exports the exact same dataset.
7.6 Scale
A scale controls how data is mapped to aesthetic attributes, so we need one scale for every aesthetic property employed in a layer. For example, this graph defines a scale for color:
ggplot(data = penguins,
mapping = aes(x = bill_depth_mm,
y = bill_length_mm,
color = species)) +
geom_point() ## Warning: Removed 2 rows containing missing values (geom_point).
The scale can be changed to use a different color palette:
ggplot(data = penguins,
mapping = aes(x = bill_length_mm,
y = body_mass_g,
color = species)) +
geom_point() +
scale_color_brewer(palette = "Dark2",direction = -1)## Warning: Removed 2 rows containing missing values (geom_point).
Now we are using a different palette, but the scale is still consistent: all Adelie penguins utilize the same color, whereas Chinstrap use a new color but each Adelie still uses the same, consistent color.
7.7 Coordinate system
A coordinate system (coord) maps the position of objects onto the plane of the plot, and controls how the axes and grid lines are drawn. Plots typically use two coordinates (x,y), but could use any number of coordinates. Most plots are drawn using the Cartesian coordinate system:
x1 <- c(1, 10)
y1 <- c(1, 5)
p <- qplot(x = x1, y = y1, geom = "point", xlab = NULL, ylab = NULL) +
theme_bw()
p +
ggtitle(label = "Cartesian coordinate system")
ggplot(penguins, aes(flipper_length_mm, body_mass_g)) +
geom_point() +
coord_polar()## Warning: Removed 2 rows containing missing values (geom_point).
This system requires a fixed and equal spacing between values on the axes. That is, the graph draws the same distance between 1 and 2 as it does between 5 and 6. The graph could be drawn using a semi-log coordinate system which logarithmically compresses the distance on an axis:
p +
coord_trans(y = "log10") +
ggtitle(label = "Semi-log coordinate system")
Or could even be drawn using polar coordinates:
p +
coord_polar() +
ggtitle(label = "Polar coordinate system")
7.8 Faceting
Faceting can be used to split the data up into subsets of the entire dataset. This is a powerful tool when investigating whether patterns are the same or different across conditions, and allows the subsets to be visualized on the same plot (known as conditioned or trellis plots). The faceting specification describes which variables should be used to split up the data, and how they should be arranged.
ggplot(data = penguins,
mapping = aes(x = bill_length_mm,
y = body_mass_g)) +
geom_point() +
facet_wrap(~ island)## Warning: Removed 2 rows containing missing values (geom_point).
ggplot(data = penguins, mapping = aes(x = bill_length_mm, y = body_mass_g, color = sex)) +
geom_point() +
facet_grid(species ~ island, scales = "free_y")## Warning: Removed 2 rows containing missing values (geom_point).
# Ria's explanation: This code did not work becasue....7.9 Defaults
Rather than explicitly declaring each component of a layered graphic (which will use more code and introduces opportunities for errors), we can establish intelligent defaults for specific geoms and scales. For instance, whenever we want to use a bar geom, we can default to using a stat that counts the number of observations in each group of our variable in the x position.
Consider the following scenario: you wish to generate a scatterplot visualizing the relationship between penguins’ bill_length and their body_mass. With no defaults, the code to generate this graph is:
ggplot() +
layer(
data = penguins,
mapping = aes(x = bill_length_mm,
y = body_mass_g),
geom = "point",
stat = "identity",
position = "identity"
) +
scale_x_continuous() +
scale_y_continuous() +
coord_cartesian()## Warning: Removed 2 rows containing missing values (geom_point).
The above code:
Creates a new plot object (
ggplot)Adds a layer (
layer)- Specifies the data (
penguins) - Maps engine bill length to the x position and body mass to the y position (
mapping) - Uses the point geometric transformation
(
geom = "point") - Implements an identity transformation and position
(
stat = "identity"andposition = "identity")
- Specifies the data (
Establishes two continuous position scales (
scale_x_continuousandscale_y_continuous)Declares a cartesian coordinate system (
coord_cartesian)
How can we simplify this using intelligent defaults?
We only need to specify one geom and stat, since each geom has a default stat.
Cartesian coordinate systems are most commonly used, so it should be the default.
Default scales can be added based on the aesthetic and type of variables.
- Continuous values are transformed with a linear scaling.
- Discrete values are mapped to integers.
- Scales for aesthetics such as color, fill, and size can also be intelligently defaulted.
Using these defaults, we can rewrite the above code as:
ggplot() +
geom_point(data = penguins,
mapping = aes(x = bill_length_mm,
y = body_mass_g))## Warning: Removed 2 rows containing missing values (geom_point).
This generates the exact same plot, but uses fewer lines of code.
Because multiple layers can use the same components (data, mapping,
etc.), we can also specify that information in the ggplot()
function rather than in the layer() function:
ggplot(data = penguins,
mapping = aes(x = bill_length_mm,
y = body_mass_g)) +
geom_point()## Warning: Removed 2 rows containing missing values (geom_point).
And as we will learn, function arguments in R use specific ordering,
so we can omit the explicit call to data and
mapping:
ggplot(penguins, aes(bill_length_mm, body_mass_g)) +
geom_point()## Warning: Removed 2 rows containing missing values (geom_point).
---
title: "The Grammar of Graphics"
author: "Arvind Venkatadri"
date: 06/July/2021
output:
  html_document:
    theme: flatly
    toc: TRUE
    toc_float: TRUE
    toc_depth: 2
    number_sections: TRUE
    code_folding: hide
    code_download: TRUE
abstract: Part of the `R for Artists and Designers` at the School of Foundation Studies, Srishti Manipal Institute of Art, Design, and Technology, Bangalore.
---

# Introduction

This RMarkdown document is part of the Generic Skills Component  (GSK) of the Course of the  Foundation Studies Programme at Srishti Manipal Institute of Art, Design, and Technology, Bangalore India. The material is based on *A Layered Grammar of Graphics* by Hadley Wickham. The course is meant for First Year students pursuing a Degree in Art and Design. 

The intent of this GSK part is to build Skill in coding in R, and also appreciate R as a way to metaphorically visualize information of various kinds, using predominantly geometric figures and structures.

All RMarkdown files combine code, text, web-images, and figures developed using code. Everything is text; code chunks are enclosed in **fences** (```)


# Goals

At the end of this Lab session, we should:
- know the types and structures of tidy data and be able to work with them
- be able to create data visualizations using `ggplot`
- Understand *aesthetics* and *scales* in `ggplot


# Pedagogical Note

The method followed will be based on
[PRIMM](https://blogs.kcl.ac.uk/cser/2017/09/01/primm-a-structured-approach-to-teaching-programming/):

-   **PREDICT** Inspect the code and guess at what the code might do,
    **write predictions**
-   **RUN** the code provided and check what happens
-   **INFER** what the `parameters` of the code do and **write comments to explain**. What bells and whistles can you see?
-   **MODIFY** the `parameters` code provided to understand the
    `options` available. **Write comments** to show what you have aimed for and achieved.
-   **MAKE** : take an idea/concept of your own, and graph it.


## Set Up

The `setup` code **chunk** below brings into our coding session **R packages** that provide specific computational abilities and also **datasets** which we can use. 

To reiterate: Packages and datasets are **not** the same thing !! Packages are (small) collections of programs. Datasets are just....information.


```{r setup, include = FALSE}

knitr::opts_chunk$set(cache = TRUE)
options(digits = 3)

# Here we will include **packages** that allow us to code in specific way. 
# Using the library() command.
# Some packages also contain datasets that we can use


# Programs to mess with data, and to plot it.
# Also has some demo datasets
library(tidyverse) 

# Data from Ecology
# Becoming the `lorem ipsum` dataset in R!!
library(palmerpenguins)

# A collection of historical datasets
library(HistData)

# For pedagogical reasons
library(flair)

```



# A Teaser from John Snow

```{r teaser,echo=FALSE}

# SnowMap(polygons = TRUE)
# Write some comments on this code and what it seems to be creating
# Are there "layers" in this visualization?
library(sf)
library(sfheaders)
library(ggformula)

data(Snow.deaths)
data(Snow.pumps)
data(Snow.streets)
data(Snow.polygons)
data(Snow.dates)

## Convert to spatial format using sfheaders
snow_streets_sf <- Snow.streets %>% 
  sfheaders::sf_linestring(., linestring_id = "street",x = "x", y = "y")

#####
snow_polygons_sf <- Snow.polygons %>% 
  map_df(.f = ~ sfheaders::sf_linestring(.x), c(x = .x$"x", y = .x$"y", keep = TRUE))

#####
snow_pumps_sf <- Snow.pumps %>% sfheaders::sf_point(x = "x", y = "y", keep = TRUE)

####
snow_deaths_sf <- Snow.deaths2 %>% sfheaders::sf_point(x = "x", y = "y", keep = TRUE)

### Now to plot it

ggplot() + 
  
    
  geom_density_2d_filled(data = Snow.deaths2, aes(x = x, y = y), 
                         colour = "black", show.legend = FALSE, bins = 9, alpha = 0.5) + 
  
  geom_sf(data = snow_polygons_sf, color = "brown",fill = "white",
          linewidth = 1) +
  
  geom_sf(data = snow_streets_sf, color = "grey") +
  
  geom_sf(data = snow_pumps_sf, fill = "blue", color = "blue",
          shape = 17, size = 6) +
  
  geom_sf(data = snow_deaths_sf, shape = 22, fill = "red", 
            colour = "red", size = 1) + 
  
  geom_sf_text(data = snow_pumps_sf,aes(label = label),
               nudge_x = 0.5, nudge_y = -0.75) + 
  

  
  # stat_density_2d_filled(data = Snow.deaths2, aes(x = x, y = y), bins = 8, contour_var = "ndensity") +
  
  scale_fill_brewer(palette = "Greens", direction = 1,type = "qual") + 
  theme_void()


```


# Review of Tidy Data

"Tidy Data" is an important way of thinking about what data typically look like in R. Let's fetch a figure from the web to show the (preferred) structure of data in R. (The syntax to bring in a web-figure is `![caption](url)`)

![Tidy Data](https://raw.githubusercontent.com/allisonhorst/stats-illustrations/master/rstats-artwork/tidydata_1.jpg)
The three features described in the figure above define the nature of tidy data:

- *Variables in Columns*  
- *Observations in Rows* and   
- *Measurements in Cells*.

Data are imagined to be resulting from an **experiment**. Each *variable* represents a parameter/aspect in the experiment. Each *row* represents an additional datum of measurement. A *cell* is a single measurement on a single parameter(column) in a single observation(row).


## Kinds of Variables

**Kinds of Variable** are defined by the kind of *questions* they answer to:

1.  What/Who/Where? -> Some kind of Name. **Categorical** variable
2.  What Kind? How? -> Some kind of "Type".  **Factor** variable
3.  How Many? How large? -> Some kind of Quantity. **Numerical** variable. 
Most Figures in R are computed with variables, and therefore, with **columns**.

# Interrogations and Graphs

Creating graphs from data is an act of asking questions and viewing answers in a geometric way. 
Let us write some simple English descriptions of measures and visuals and see what commands they use in R.

# Components of the layered grammar of graphics

**Layers** are used to create the objects on a plot. They are defined by five basic parts:

1.  Data (What dataset/spreadsheet am I using?)
2.  Mapping (What does each column do in my graph?)
3.  Statistical transformation (stat) (Do I have count something first?)
4.  Geometric object (geom) (What shape, colour, size...do I want?)
5.  Position adjustment (position) (Where do I want it on the graph?)


## Data{.tabset .tabset-pills}

We will use "real world" data. Let's use the `penguins` dataset in the `palmerpenguins` package. Run `?penguins` in the console to get more information about this dataset.

### Head
```{r penguins-1}
head(penguins)
```

### Tail
```{r penguins-2}
tail(penguins)
```

### Dim
```{r penguins-3}
dim(penguins)
```


So we know what our data looks like. We pass this data to `ggplot` use to plot as follows: in R this creates an empty graph sheet!! Because we have not (yet) declared the geometric shapes we want to use to plot our information. 


```{r data-1}
ggplot(data = penguins) # Creates an empty graphsheet, ready for plotting!!

```




## Mapping

Now that we have told R what data to use, we need to state what variables to plot and how. 

**Aesthetic Mapping** defines how the variables are applied to the plot, i.e. we take a variable from the data and "metaphorize" it into a geometric feature. We can map variables metaphorically to a variety of geometric things: coordinate, length, height, size, shape, colour, alpha(how dark?)....

The syntax uses: `aes(some_geometric_thing = some_variable)`

Remember **variable** = **column**. 

So if we were graphing information from `penguins`, we might map a penguin's `flipper_length_mm` **column** to the $x$ position, and the `body_mass_g` **column** to the $y$ position.

### Mapping Example-1 {.tabset .tabset-pills}

We can try another example of aesthetic mapping with the same dataset:

#### Plot-1a

```{r mapping-1a}
ggplot(data = penguins)
```



#### Plot-1b

```{r mapping-1b,include=FALSE}
ggplot(penguins) + 

# Plot geom = histogram. So we need a quantity on the x
  geom_histogram(
    aes(x = body_mass_g))
```


```{r, echo=FALSE}

decorate("mapping-1b") %>% 
  flair_lines(4:5) %>% 
  knit_print.with_flair()
```


#### Plot-1c
```{r mapping-1c,include = FALSE}
ggplot(penguins) +

# Plot geom = histogram. So we need a quantity on the x
  geom_histogram(
    aes(x = body_mass_g,
        fill = island)    # color aesthetic = another variable
    )

```


```{r, echo=FALSE}
decorate("mapping-1c") %>% 
  flair_lines(5:6) %>% 
  knit_print.with_flair()

```

### Mapping Example-2 {.tabset .tabset-pills}

We can try another example of aesthetic mapping with the same dataset:

#### Plot-2a

```{r mapping-2a}
ggplot(data = penguins)
```



#### Plot-2b

```{r mapping-2b,include=FALSE}
ggplot(penguins) + 

# Plot geom = histogram. So we need a quantity on the x
  geom_histogram(
    aes(x = body_mass_g))
```


```{r, echo=FALSE}

decorate("mapping-2b") %>% 
  flair_lines(4:5) %>% 
  knit_print.with_flair()
```


#### Plot-2c
```{r mapping-2c,include = FALSE}
ggplot(penguins) +

# Plot geom = histogram. So we need a quantity on the x
  geom_histogram(
    aes(x = body_mass_g,
        fill = island)    # color aesthetic = another variable
    )

```


```{r, echo=FALSE}
decorate("mapping-2c") %>% 
  flair_lines(5:6) %>% 
  knit_print.with_flair()

```

### Mapping Example-3 {.tabset .tabset-pills}

We can try another example of aesthetic mapping with the same dataset:

#### Plot-3a

```{r mapping-3a}
ggplot(data = penguins)
```



#### Plot-3b

```{r mapping-3b,include=FALSE}
ggplot(penguins) + 

# Plot geom = histogram. So we need a quantity on the x
  geom_histogram(
    aes(x = body_mass_g))
```


```{r, echo=FALSE}

decorate("mapping-3b") %>% 
  flair_lines(4:5) %>% 
  knit_print.with_flair()
```


#### Plot-3c
```{r mapping-3c,include = FALSE}
ggplot(penguins) +

# Plot geom = histogram. So we need a quantity on the x
  geom_histogram(
    aes(x = body_mass_g,
        fill = island)    # color aesthetic = another variable
    )

```


```{r, echo=FALSE}
decorate("mapping-3c") %>% 
  flair_lines(5:6) %>% 
  knit_print.with_flair()

```



### Mapping Example-4 {.tabset .tabset-pills}

We can try another example of aesthetic mapping with the same dataset:

#### Plot-4a

```{r mapping-4a}
ggplot(data = penguins)
```



#### Plot-4b

```{r mapping-4b,include=FALSE}
ggplot(penguins) + 

# Plot geom = histogram. So we need a quantity on the x
  geom_histogram(
    aes(x = body_mass_g))
```


```{r, echo=FALSE}

decorate("mapping-4b") %>% 
  flair_lines(4:5) %>% 
  knit_print.with_flair()
```


#### Plot-4c
```{r mapping-4c,include = FALSE}
ggplot(penguins) +

# Plot geom = histogram. So we need a quantity on the x
  geom_histogram(
    aes(x = body_mass_g,
        fill = island)    # color aesthetic = another variable
    )

```


```{r, echo=FALSE}
decorate("mapping-4c") %>% 
  flair_lines(5:6) %>% 
  knit_print.with_flair()

```


## Geometric objects {.tabset .tabset-pills}

**Geometric objects** (*geoms*) control the type of plot you create. Geoms are classified by their dimensionality:

-   0 dimensions - point, text
-   1 dimension - path, line
-   2 dimensions - polygon, interval

Each geom can only display certain **aesthetics** or visual attributes of the geom. For example, a point geom has position, color, shape, and size aesthetics.

We can also stack up geoms on top of one another to add layers to the graph.

### Plot1
```{r other_geoms-1}
ggplot(penguins, aes(x = flipper_length_mm, y = body_mass_g)) +
  geom_line()
```

### Plot2
```{r other-geoms-2}
ggplot(data = penguins) + 
  geom_line(aes(x = bill_length_mm, 
                     y = body_mass_g))
```

### Plot3
```{r other-geoms-3}
ggplot(data = penguins) + 
  geom_point(aes(x = bill_length_mm, 
                     y = body_mass_g,
                 color = island, 
                 shape = species)) + 
  
  ggtitle("A point geom with position and color and shape aesthetics")
```


```{r geom_bar-1}
ggplot(data = penguins, 
       aes(x = species)) + # x position => ?
  # No need to type "mapping"...
  geom_bar() + # Where does the height come from?
  ggtitle("A bar geom with position and height aesthetics")
```

```{r geom_bar-2}
ggplot(data = penguins, aes(x = species)) +
  geom_bar() +
  ggtitle("A bar geom with position and height aesthetics")
```

-   Position determines the starting location (origin) of each bar
-   Height determines how tall to draw the bar. Here the height is based on the number of observations in the dataset for each possible number of cylinders.

## Position adjustment {.tabset .tabset-pills}

Sometimes with dense data we need to adjust the position of elements on the plot, otherwise data points might obscure one another. Bar plots frequently **stack** or **dodge** the bars to avoid overlap:

```{r geom_bar_position_stack_and_dodge}
count(x = penguins, species, island) %>%
  ggplot(mapping = aes(x = species, y = n, fill = island)) +
  geom_bar(stat = "identity") +
  ggtitle(label = "A stacked bar chart")

count(x = penguins, species, island) %>%
  ggplot(mapping = aes(x = species, y = n, fill = island)) +
  geom_bar(stat = "identity", position = "dodge") +
  ggtitle(label = "A dodged bar chart")
```

```{r}
penguins %>%
  ggplot(mapping = aes(x = species, fill = island)) +
  geom_bar() +
  ggtitle(label = "A stacked bar chart")

penguins %>%
  ggplot(mapping = aes(x = species, fill = island)) +
  geom_bar(position = "dodge") +
  ggtitle(label = "A dodged bar chart")
```

Sometimes scatterplots with few unique $x$ and $y$ values are **jittered** (random noise is added) to reduce overplotting.

```{r position}
ggplot(data = penguins, 
       mapping = aes(x = species, 
                     y = body_mass_g)) +
  geom_point() +
  ggtitle("A point geom with obscured data points")

ggplot(data = penguins, 
       mapping = aes(x = species, 
                     y = body_mass_g)) +
  geom_jitter() +
  ggtitle("A point geom with jittered data points")
```

## Statistical transformation {.tabset .tabset-pills}

A **statistical transformation** (*stat*) pre-transforms the data, before plotting. For instance, in a bar graph you might summarize the data by `count`ing the total number of observations within a set of categories, and then plotting the count.

### Count
```{r stat-transform-1}
count(x = penguins, island)
```
### Count and Bar Graph

```{r stat-transform-2}
mydat <- count(penguins,island)

ggplot(data = mydat) +
    geom_col(aes(x = island, y = n))
```

### Tidy Count and Bar Graph
```{r stat-transform-3,echo=FALSE}
penguins %>%           # This IS a pipe Operator!!
  
  count(., island) %>% # "." represents what is passed from the preceding command
  
  ggplot(.) +    
  
  geom_col(aes(x = island, y = n))

```

```{r, echo = FALSE}
decorate("stat-transform-3") %>% 
  flair("%>%") %>% 
  flair(".") %>% 
  knit_print.with_flair()
  
```



### Count inside the Plot
```{r stat-transform-4}
penguins %>%           # Our pipe Operator
  
  ggplot(.) +          # "." becomes the penguins dataset
  
  geom_bar(aes(x = island)) # Note: y = count, and is computed internally!!

```

Sometimes you don't need to make a statistical transformation. For example, in a scatterplot you use the raw values for the $x$ and $y$ variables to map onto the graph. In these situations, the statistical transformation is an *identity* transformation - the stat simply passes in the original dataset and exports the exact same dataset.

## Scale {.tabset .tabset-pills}

A **scale** controls how data is mapped to aesthetic attributes, so we need one scale for every aesthetic property employed in a layer. For example, this graph defines a scale for color:

```{r scale-color}
ggplot(data = penguins, 
       mapping = aes(x = bill_depth_mm, 
                     y = bill_length_mm, 
                     color = species)) +
  geom_point() 

```
 The scale can be changed to use a different color palette:

```{r scale-color-palette}
ggplot(data = penguins, 
       mapping = aes(x = bill_length_mm, 
                     y = body_mass_g, 
                     color = species)) +
  geom_point() +
  scale_color_brewer(palette = "Dark2",direction = -1)
```

Now we are using a different palette, but the scale is still consistent: all Adelie penguins utilize the same color, whereas Chinstrap use a new color **but each Adelie still uses the same, consistent color**.

## Coordinate system {.tabset .tabset-pills}

A **coordinate system** (*coord*) maps the position of objects onto the plane of the plot, and controls how the axes and grid lines are drawn. Plots typically use two coordinates ($x, y$), but could use any number of coordinates. Most plots are drawn using the [**Cartesian coordinate system**](https://en.wikipedia.org/wiki/Cartesian_coordinate_system):

```{r coord-cart}
x1 <- c(1, 10)
y1 <- c(1, 5)
p <- qplot(x = x1, y = y1, geom = "point", xlab = NULL, ylab = NULL) +
  theme_bw()
p +
  ggtitle(label = "Cartesian coordinate system")


ggplot(penguins, aes(flipper_length_mm, body_mass_g)) +
  geom_point() + 
  coord_polar()
```

This system requires a fixed and equal spacing between values on the axes. 
That is, the graph draws the same distance between 1 and 2 as it does between 5 and 6. The graph could be drawn using a [**semi-log coordinate system**](https://en.wikipedia.org/wiki/Semi-log_plot) which logarithmically compresses the distance on an axis:

```{r coord_semi_log}
p +
  coord_trans(y = "log10") +
  ggtitle(label = "Semi-log coordinate system")
```



Or could even be drawn using [**polar coordinates**](https://en.wikipedia.org/wiki/Polar_coordinate_system):

```{r coord_polar}
p +
  coord_polar() +
  ggtitle(label = "Polar coordinate system")
```

## Faceting {.tabset .tabset-pills}


**Faceting** can be used to split the data up into subsets of the entire dataset. This is a powerful tool when investigating whether patterns are the same or different across conditions, and allows the subsets to be visualized on the same plot (known as **conditioned** or **trellis** plots). The faceting specification describes which variables should be used to split up the data, and how they should be arranged.

```{r facet-1}
ggplot(data = penguins, 
       mapping = aes(x = bill_length_mm, 
                     y = body_mass_g)) +
  geom_point() +
  facet_wrap(~ island)
```


```{r facet-2}
ggplot(data = penguins, mapping = aes(x = bill_length_mm, y = body_mass_g, color = sex)) +
  geom_point() +
  facet_grid(species ~ island, scales = "free_y")

# Ria's explanation: This code did not work becasue....
```


## Defaults

Rather than explicitly declaring each component of a layered graphic (which will use more code and introduces opportunities for errors), we can establish intelligent defaults for specific geoms and scales. For instance, whenever we want to use a bar geom, we can default to using a stat that counts the number of observations in each group of our variable in the $x$ position.

Consider the following scenario: you wish to generate a scatterplot visualizing the relationship between penguins' bill_length and their body_mass. With no defaults, the code to generate this graph is:

```{r default}
ggplot() +
  layer(
    data = penguins, 
    mapping = aes(x = bill_length_mm, 
                  y = body_mass_g),
    geom = "point", 
    stat = "identity", 
    position = "identity"
  ) +
  scale_x_continuous() +
  scale_y_continuous() +
  coord_cartesian()
```

The above code:

-   Creates a new plot object (`ggplot`)

-   Adds a layer (`layer`)

    -   Specifies the data (`penguins`)
    -   Maps engine bill length to the $x$ position and body mass to the $y$ position (`mapping`)
    -   Uses the point geometric transformation (`geom = "point"`)
    -   Implements an identity transformation and position (`stat = "identity"` and `position = "identity"`)

-   Establishes two continuous position scales (`scale_x_continuous` and `scale_y_continuous`)

-   Declares a cartesian coordinate system (`coord_cartesian`)

How can we simplify this using intelligent defaults?

1.  We only need to specify one geom and stat, since each geom has a default stat.

2.  Cartesian coordinate systems are most commonly used, so it should be the default.

3.  Default scales can be added based on the aesthetic and type of variables.

    -   Continuous values are transformed with a linear scaling.
    -   Discrete values are mapped to integers.
    -   Scales for aesthetics such as color, fill, and size can also be intelligently defaulted.

Using these defaults, we can rewrite the above code as:

```{r default2}
ggplot() +
  geom_point(data = penguins, 
             mapping = aes(x = bill_length_mm, 
                           y = body_mass_g))
```

This generates the exact same plot, but uses fewer lines of code. Because multiple layers can use the same components (data, mapping, etc.), we can also specify that information in the `ggplot()` function rather than in the `layer()` function:

```{r default3}
ggplot(data = penguins, 
       mapping = aes(x = bill_length_mm, 
                     y = body_mass_g)) +
  geom_point()
```

And as we will learn, function arguments in R use specific ordering, so we can omit the explicit call to `data` and `mapping`:

```{r default4}
ggplot(penguins, aes(bill_length_mm, body_mass_g)) +
  geom_point()
```


```{r echo=FALSE}
knitr::include_graphics("https://isabella-b.com/blog/ggplot2-theme-elements-reference/ggplot2-theme-elements-reference-v2_hu8994090e1960a0a71878a3756da20076_580819_2000x2000_fit_lanczos_2.png")

```

