R Workshop

Module 4: Data visualization with R (2)

2018-04-11
Bobae Kang
(Bobae.Kang@illinois.gov)

• Shapefile
  • a popular format for storing geospatial data
• rgdal pacakge
  • an R interface to Geospatial Data Abstraction Library (GDAL) for reading and writing geospatial data formats
• Spatial objects in R

“A shapefile is a simple, nontopological format for storing the geometric location and attribute information of geographic features. Geographic features in a shapefile can be represented by points, lines, or polygons (areas).”
- “What is a shapefile?”, Esri

“The shapefile format is a popular geospatial vector data format for geographic information system (GIS) software […] developed and regulated by Esri […]. The shapefile format can spatially describe vector features: points, lines, and polygons […]. Each item usually has attributes that describe it, such as name or temperature.” - “Shapefile”, Wikipedia

A shapefile format in fact consists of a collection of files. The following are commonly included when using shapefile data in R:

library(rgdal)
spatial_object <- readORG(dsn, layer)

# example:
# il_counties <- read(dsn = "shapefiles", layer = "il_counties")

• the readORG function imports a shapefile into R environment
  • dsn is the path to the directory with a shapefile to import
  • layer is the name of a shapefile to import
• the output is a spatial vector object

• There are multiple spatial vector object types:
  • Without attributes: Spatial* classes
    • Points, MultiPoints, Pixels, Grid, Lines, Polygons
  • With attributes: Spatial*DataFrame classes
    • The attributes data.frame table can be accessed using standard methods.
• See the “Spatial Cheatsheet” for more on spatial objects in R

class(counties)

[1] "SpatialPolygonsDataFrame"
attr(,"package")
[1] "sp"

• icjiar package provides a spatial object named counties for countes in Illinois
  • it is of the SpatialPolygonsDataFrame class

• tmap package for thematic maps
• leaftlet package for interactive maps
• And more

Source: tmap GitHub repo

“With the tmap package, thematic maps can be generated with great flexibility. The syntax for creating plots is similar to that of ggplot2. The add-on package tmaptools contains tool functions for reading and processing shape files.” - “tmap in a nutshell”

• In my experience, tmap is the most accessible R package for generating maps, making it easy to get visually appealing maps using data in the shapefile format.

qtm(shape_object, ...)

• Generates a “quick thematic map”
  • comparable to qplot() in ggplot2
• Offers the same level of flexibility as the main plotting interface
  • The main interface is stil recommended for complex plots

tm_shape(shape_object) +
  tm_*() # add tmap elements as layers

• tm_shape takes a spatial “shape object”
• Add layers using tmap elements
  • two types of “drawing” layers: base and derived
  • “attribute” layers

tm_layout(title = NA, scale = 1, title.size = 1.3, bg.color = "white", aes.color = c(fill = "grey85", borders = "grey40", symbols = "grey60", dots = "black", lines = "red", text = "black", na = "grey75"), ...)

• tm_layout is the general function to control all things about layout settings.
• tm_style_* functions which offer predefined sets of styling-related layout settings such as background colors, colors and font (similar to ggplot2 themes).
• tm_format_* functions which offer predefined sets of position-related layout settings such as margins.

tmap_mode("plot") # set to static "plot" mode
tmap_mode("view") # set to interactive "view" mode

ttmp() # toggle between modes

• “plot” mode generates a static map image
• “view” mode generates an interactive leaflet map
  • tm_view() is a function to specify options for “view” mode
  • tmap_leaflet() can directly generate an interactive leaflet map

“Leaflet is one of the most popular open-source JavaScript libraries for interactive maps. It's used by websites ranging from The New York Times and The Washington Post to GitHub and Flickr, as well as GIS specialists like OpenStreetMap, Mapbox, and CartoDB.”
-“Leaflet for R”, RStudio

• While leaflet is a powerful library for generating interactive maps, it takes much time and practice to get familiar with its API.
• Using tmap's interactive view could be an alterantive to using leaflet's API directly.

• base R plot
• sp::spplot()
• ggplot2::geom_map()
• ggmap

• Eubank, N. (2015). “Making maps in R”.
• Hijmans, R. (2016). “Spatial Data Manipulation”. R Spatial.
• leaftlet official documentation page
• Lovelace, R. et al. (2017). “Introduction to visualising spatial data in R ”.
• Pebesma, E. (n.d.). Simple Features for R.
• tmap github repository
  • Links to package vignettes and examples

Source: Wikipedia Commons

• ggiraph: an htmlwidget package for interactive ggplot2 graphics
• plotly: R API for the plotly.js library
• highcharter: R API for the highchart.js library
• And more

“ggiraph is an htmlwidget and a ggplot2 extension. It allows ggplot graphics to be animated.”
- Gohel, D. (package author/creator)

ggiraph offers interactive “geoms” to be used for a ggplot2 plot and renders the plot with interactive “geoms” as an interactive visualization.

p <- plot + geom_*_interactive(...)
ggiraph(code = print(p), ...)

• plot is a ggplot object
• ggiraph() takes a ggplot2::ggplot object with an interactive “geom” to generate an interactive plot
• 12 interactive “geom” layers that can be integrated into a ggplot object:
  • bar, boxplot, histogram, line, map, path, point, polygon, rect, segment, text, tile

aes(tooltip, onclick, data_id)

• Each interactive “geom” has mapping for the following interactive elements:
  • tooltip is a column containing information to be displayed as tooltip
  • onclick is a column containing JavaScript instructions to run for a “click” event
  • data_id is a column containing id to be associated with elements.
    • Must be specified to use a customized “hover” effect

“Plotly's R graphing library makes interactive, publication-quality graphs online. Examples of how to make line plots, scatter plots, area charts, bar charts, error bars, box plots, histograms, heatmaps, subplots, multiple-axes, and 3D (WebGL based) charts.”
- “Plotly R Library”, plotly

ggplotly(p = ggplot2::last_plot(), ...)

• ggplotly() provides a quick and easy way to convert a ggplot object into an interactive plotly object
• p is a ggplot2::ggplot object to be made interactive
  • The default value for p is the most recently created ggplot object if there is any

plot_ly(data, x, y, color, alpha, symbol, size, ...)

 # equivalent to add_type()
add_trace(p, ..., type = "type", inheret = TRUE)

• plot_ly takes a data frame and defines the aesthetic mappings
• “trace” is the “geom” equivalent in plot_ly interface, which adds a layer to the plot output
  • While plot_ly can define traces, using add_trace() and its variants make it possible to use a dplyr-style workflow with pipe operators
  • By default, each trace inherits the mappings from p

“Highcharter is a R wrapper for Highcharts javascript libray and its modules. Highcharts is very mature and flexible javascript charting library and it has a great and powerful API.”
-Kunst, J. (package author)

• We have already seen Highcharts plots in ICJIA R&A Unit's online articles (e.g. Figure 1 and Figure 2 in this article).

hchart(data, type, hcaes(x, y, ...))

• Quickly generates a hichchart plot
  • Comparable to qplot() in ggplot2
• type specifies the type of plot (e.g. “scattor” for scattorplot)
• hcaes() works like aes() in ggplot2

highchart() %>%
  hc_add_series(...) %>% # add a "series"
  hc_xAxis(...) %>% # define x-axis
  hc_yAxis(...) %>% # define y-axis
  hc_title(...) %>% # add the main title
  hc_chart(...) %>% # modify general plot options
  hc_color(...) %>% # control colors
  hc_*(...) # and more...

• Closely follows the original Javascript API

• ggiraph official documentation page
• highcharter official documentation page
• plotly official documentation page
• Sievert, C. (n.d.) plotly for R.

• rAmCharts is an R interface to the amCharts JavaScript library that offers interactive options for many common plot types and more.
• chartjs is an R interface to the Chart.js JavaScript library and offers six chart types (bar, line, pie, doughnut, radar, and polar area) for interactive plots.
• googleVis offers an R API to Google Charts, which offers rich set of interactive charts and data tools.
• dygraphs is an R interface to the dygraphs JavaScript library for interactive time-series plots.

• visNetwork (wrapper for vis.js) and networkD3 are two popular packages for interactive visualization of network/graph data in R. Start with igraph or tidygraph package to learn how to work with network objects in R
• wordcloud2 (wrapper for worldcloud2.js) is a package for creating word clouds, a popular way to visualize text data.
• data.tree is an R package for managing as well as visualizing hierarchical data and tree structures.

Source: Gifimage.net