Both of them use the background image to configure the graphical window defining functions (automap and ggmap, respectively) to display the images with ggplot2. Additional information can be layered upon this background image with ggplot2 functions. In my opinion, this approach is somewhat strange. I feel more comfortable with the approach implemented in the spplot function of the sp package, which relies on the main data to be displayed to configure the graphical window instead of using an auxiliary image as the starting point.

Although none of these two packages include functions to work with spplot, it is not difficult to build a mixed solution. The key point is that the result of their queries is mainly a raster image which can be easily displayed with the grid.raster function after some corrections.

The next code displays the location of the photovoltaic systems installed in California grouped by nominal power using data available from the OpenPV project. The procedure is:

• Download the data and define the coordinates and projection.
• Download an image from the Stamen Maps service according to the spatial extent of the data (this example uses ggmap but a similar approach can be followed with the OpenStreetMap package).
• Use grid.raster to display the image using the coordinates of its corners to define the width, height and center location.
• Display the variable with circles of different sizes and colours over the background image.

The second part is more sophisticated. It uses the movie dataset to show how to carry out 2D binning.

Some key points I have learned about data.table:

• := to add, remove or modify by reference (avoids memory overhead since it does not make additional copies)
• .N and .SD symbols for grouping

Still learning!

proj <- CRS('+proj=longlat +datum=WGS84')
df <- expand.grid(x=seq(-2, 2, .01), y=seq(-2, 2, .01))

df$z <- with(df, (3*x^2 + y)*exp(-x^2-y^2))
r <- rasterFromXYZ(df, crs=proj)

streamplot(r)

streamplot accepts two arguments (droplets and streamlets) to control the number of droplets, the length of the streamlets and the streamlet calculation step. The streamlet colour palette and the panel background color are defined with an specific theme for streamplot, streamTheme. The default options can be changed easily:

df$z <- with(df, sqrt(x^2 + y^2))
df$phi <- with(df, atan2(-y, x))
r2 <- rasterFromXYZ(df, crs=proj)

streamplot(r2, isField=TRUE, streamlet=list(L=30), droplet=list(pc=.3),
           par.settings=streamTheme(symbol=brewer.pal(n=5, name='Reds')))

The first step is to produce the graphic. We will use a custom panel function which assigns unique identifiers to each element.

panel.circles <- function(x, y, identifier,...){
    for (i in seq_along(x)){
    grid.circle(x[i], y[i], r=unit(5, 'mm'),
                default.units='native',
                ## Add the identifier
                name = paste('myPoint', identifier[i], sep='.'), 
                gp=gpar(fill='gray',...))
    }}

library(gridSVG)
library(lattice)

x <- rnorm(10)
y <- rnorm(10)
id <- seq_along(x)
df <- data.frame(x, y, id)

xyplot(y ~ x, data=df,
       panel=panel.circles,
       ## Identifier of each circle
       identifier=df$id)

The tooltipster plugin will use the content of the title attribute of each element to show the tooltip. Therefore we visit each circle to add content to the title attribute with grid.garnish.

for (i in 1:nrow(df)){
  idPoint <- df[i, "id"]
  ## Each circle is identified with myPoint.1, myPoint.2,etc.
  namePoint <- paste('myPoint', idPoint, sep='.')
  point <- signif(df[i, ], 2)
  ## Text to be included in the 'title' attribute
  info <- paste('x = ', point$x, 
                   '<br />y = ', point$y, 
                   '<br />ID = ', idPoint, sep='')
  imageURL <- 'http://developer.r-project.org/Logo/Rlogo-5.png'
  imageInfo <- paste("<img src=", imageURL, " width='50' />", sep='')
  tooltip <- paste(imageInfo, info, sep='<br />')
  grid.garnish(namePoint, title=tooltip)
}

Next step is to add JavaScript code to the graphic with the grid.script function. The jQuery library can be loaded with being downloaded. However, you need a local copy of the tooltipster plugin. Next code assumes that this local copy is located in a folder named js.

## jQuery
grid.script(file='http://ajax.googleapis.com/ajax/libs/jquery/1.8.0/jquery.min.js')
## tooltipster (downloaded from http://calebjacob.com/tooltipster/)
grid.script(file='js/jquery.tooltipster.min.js')

An additional small JavaScript code is needed to join them all. It is a simple jQuery filter that triggers a tooltip when an object whose id begins with myPoint is hovered over. For details about fixedWidth, arrow and followMouse you should visit the tooltipster webpage.

$(document).ready(function() {
    $('[id^="myPoint"]').tooltipster({
        fixedWidth: 120,
        arrow: false,
        followMouse: true
    });
});

Save this code in a file named myTooltipLattice.js (for example) under the js/ folder. Then you can add it to the graphic with grid.script.

grid.script(file='js/myTooltipLattice.js')

Last step is to produce the SVG file and include it in a basic HTML page. If you wish you can change the title of this page and modify the tooltip CSS configuration using the tooltipster.css file (included in the tooltipster plugin).

gridToSVG('tooltipLattice.svg')

htmlBegin <- '<!DOCTYPE html>
  <html>
  <head>
  <title>Tooltips with jQuery and gridSVG</title>
  <link rel="stylesheet" type="text/css" href="css/tooltipster.css" />
  </head>
  <body>'

htmlEnd <- '</body>
  </html>'

svgText <- paste(readLines('tooltipLattice.svg'), collapse='\n')

writeLines(paste(htmlBegin, svgText, htmlEnd, sep='\n'),
             'tooltipLattice.html')

The result is available here.

In this chapter I have included a collection of different techniques. For example, you will find a proportional symbol map with tooltips (click on this image to open the map with tooltips)

or a reference map combining data from OpenStreetMap and hill shading.

Afortunadamente, los datos publicados por AEMET hasta el 28 de Octubre de este año han sido recopilados en la página web tiempodiario.com. Con mis limitados conocimientos de HTML y la inestimable ayuda del paquete XML, he aprendido a acceder a la información de radiación solar de manera automática con R. Expongo a continuación lo que he conseguido. Debo avisar de que no siempre funciona bien el acceso a las páginas, y es posible que se produzca un error en el bucle. Una posible solución es reiniciar el bucle a partir del enlace problemático, o añadir controles de error con try:

library(XML)
library(zoo)

mainURL <- 'http://www.tiempodiario.com'
radURL <- 'http://www.tiempodiario.com/radiacion/'

## Días disponibles en tiempodiario.com
days <- seq(as.POSIXct('2010-12-05'), as.POSIXct('2012-10-28'), by='day')


for (i in seq_along(days)){
  day <- days[i]
  dayURL <- paste(radURL, format(day, '%Y/%m/%d'), '/', sep='')

  ## Obtengo el contenido HTML de la página del día en cuestión
  content <- htmlParse(dayURL, encoding='utf8')
  ## y extraigo los enlaces a cada estación para ese día
  links <- xpathSApply(content, "//a/@href")
  linksData <- links[grep('radiacion-estacion', links)]
  ## Los nombres de las estaciones están escritos en los encabezados H2
  h2 <- xpathSApply(content, "//h2")
  namesStations <- sapply(h2[-1], function(s){
    val <- xmlValue(s)
    substr(val, 10, nchar(val))
  })
  ## pero sus códigos de identificación están en los enlaces correspondientes
  idStation <- strsplit(linksData, '/')
  idStations <- sapply(idStation, function(x)x[4])

  dayStationURL <- paste(mainURL, linksData, sep='')

  ## Accedo a la página de cada estación para ese día
  zList <- lapply(dayStationURL, function(ds){
    print(ds)
    ## Obtengo el contenido HTML de la página
    content <- htmlParse(ds, encoding='utf8')
    ## y extraigo las tablas
    tabs <- readHTMLTable(content, header=TRUE)
    ## Cada tabla codifica el índice temporal en la primera
    ## columna. A pesar de usar header=TRUE, la primera fila
    ## contiene el nombre las columnas. De ahí que tenga que usar
    ## -1 en el indexado.
    time <- tabs[[1]][-1,1]
    dayTime <- format(as.POSIXct(paste(day, time)), '%Y-%m-%d %H:%M')
    ## El nombre de la variable de cada tabla está codificado en
    ## los encabezados H2
    h2 <- getNodeSet(content, '//h2')
    tabLabels <- sapply(h2, xmlValue)
    ## Sólo me quedaré con las radiación difusa, directa y global
    radVars <- c('Radiación Difusa (DF)',
                 'Radiación Directa (DT)',
                 'Radiación Global (GL)')
    whichTabs <- which(tabLabels %in% radVars)
    ## Extraigo la información de las tablas seleccionadas. Dado
    ## que la primera fila contiene los nombres de las columnas,
    ## todo el contenido es leído como un "factor". De ahí que
    ## tenga que usar la conversión as.character y después
    ## as.numeric.
    dat <- sapply(tabs[whichTabs],
                  function(tab)as.numeric(as.character(tab[-1, 2])))
    ## Finalmente, si todo ha ido bien, construyo un objeto zoo
    ## para almacenar la serie temporal de esta estación para este
    ## día. Si algo no ha funcionado obtendré NULL.
    if (length(dat) > 0 & !is.list(dat)) {
      z <- zoo(dat, as.POSIXct(dayTime))
      names(z) <- tabLabels[whichTabs]
      } else {
        z <- NULL
        }
    z
  })
  ## El resultado de lapply será una lista de objetos zoo, uno
  ## para cada estación. Pongo los nombres de las estaciones a
  ## cada componente de esta lista y grabo el resultado como un
  ## fichero RData.
  names(zList) <- make.names(namesStations)
  save(zList, file=paste(day, 'RData', sep='.'))
  ## Este código se repetirá para cada día, de forma que obtendré
  ## un conjunto de ficheros RData, uno por día. Cada uno de ellos
  ## contiene una lista de zoo's, correspondiendo cada componente
  ## de la lista a una estación de medida.
}

Una vez ejecutado el código anterior obtendremos una colección de ficheros diarios. Si nos interesa tener el registro completo de una estación determinada, es posible obtenerlo recorriendo todos los ficheros:

## Ficheros que he obtenido del bucle anterior.
files <- dir(pattern='RData')

## Por ejemplo, para obtener el registro de la estación de
## Valladolid, recorro todos los ficheros con lapply, y extraigo
## de cada uno el componente que me interesa.
valladolid <- lapply(files, FUN=function(f){
                     load(f)
                     dat <- zList$Valladolid
                     })
## El resultado de lapply será una lista de objetos zoo, que puedo
## transformar en un único objeto zoo con do.call
valladolid <- do.call(rbind, valladolid)

Con otro bucle adicional se puede automatizar el paso anterior y obtener toda la colección de estaciones:

stations <- names(zList)

lapply(stations, FUN=function(name){
  datStation <- lapply(files, FUN=function(f){
    load(f)
    dat <- zList[[name]]
  })
  datStation <- do.call(rbind, datStation)
  write.zoo(datStation, sep=';', file=paste(name, '.txt', sep=''))
})

Quiero destacar que la editorial ha publicado el libro bajo una licencia Creative Commons.