the tricky part is that rasterImage requires you to define the 4 boundaries of the image. The goal is then to be able to define the boundaries by only specifying an x, y coordinate, and have code smart enough to display the image with the appropriate dimensions
Here are the required packages
library(RCurl) #for reading file from a URL
## Loading required package: bitops
library(png) #for reading in a .png, use library(jpeg) for a .jpg
image_points = function(image, x, y, cex = 1, pos = NULL) {
if (length(x) != length(y)) {
stop("length(x)!=length(y): check your data")
}
dim.x = dim(image)[2] #image width
dim.y = dim(image)[1] #image height
if (dim.x == dim.y) {
# obtian the ratio of width to height or height to width
ratio.x = ratio.y = 1
} else if (dim.x < dim.y) {
ratio.x = dim.x/dim.y
ratio.y = 1
} else {
ratio.x = 1
ratio.y = dim.y/dim.x
}
cex = cex/10 #how large the image should be, divided by 10 so that it matches more closely to plotting points
pin = par()$pin #pin provides the width and height of the _active graphic device_
pin.ratio = pin/max(pin) #take the ratio
usr = par()$usr #usr provides the lower.x, lower.y, upper.x, upper.y values of the plotable region
# combine the active device dimensions, the image dimensions, and the
# desired output size
image.size.y = (usr[4] - usr[3]) * pin.ratio[1] * cex
image.size.x = (usr[2] - usr[1]) * pin.ratio[2] * cex
for (i in 1:length(x)) {
# plot each point pos can be NULL (default) or 1, 2, 3, or 4, corresponding
# to centered (defualt), bottom, left, top, right, respectively.
if (is.null(pos)) {
# centered at (x,y), define the bottom/top and left/right boundaries of the
# image
x.pos = c(x[i] - (image.size.x * ratio.x)/2, x[i] + (image.size.x *
ratio.x)/2)
y.pos = c(y[i] - (image.size.y * ratio.y)/2, y[i] + (image.size.y *
ratio.y)/2)
rasterImage(image, x.pos[1], y.pos[1], x.pos[2], y.pos[2])
} else if (pos == 1) {
x.pos = c(x[i] - (image.size.x * ratio.x)/2, x[i] + (image.size.x *
ratio.x)/2)
y.pos = c(y[i] - (image.size.y * ratio.y), y[i])
} else if (pos == 2) {
x.pos = c(x[i] - (image.size.x * ratio.x), x[i])
y.pos = c(y[i] - (image.size.y * ratio.y)/2, y[i] + (image.size.y *
ratio.y)/2)
} else if (pos == 3) {
x.pos = c(x[i] - (image.size.x * ratio.x)/2, x[i] + (image.size.x *
ratio.x)/2)
y.pos = c(y[i], y[i] + (image.size.y * ratio.y))
} else if (pos == 4) {
x.pos = c(x[i], x[i] + (image.size.x * ratio.x))
y.pos = c(y[i] - (image.size.y * ratio.y)/2, y[i] + (image.size.y *
ratio.y)/2)
}
rasterImage(image, x.pos[1], y.pos[1], x.pos[2], y.pos[2]) #plot image
}
}
URL = ("http://sweetclipart.com/multisite/sweetclipart/files/imagecache/middle/sports_car_2_red.png") #where the image is located
image = readPNG(getURLContent(URL)) #gets the content of the URL
Only pngs have the alpha channel, so jpegs will have 3 channels. Not all pngs have the 4th channel, if they do have the 4th channel the background won't necessarily be transparent. More on alpha values in a bit
dim(image) #width, height, alpha
## [1] 275 550 4
Using the cars dataset we can plot the distance it took to stop by speed
data(cars)
plot(cars, type = "n", axes = F, xlab = "Speed", ylab = "Distance to Stop",
main = "Cars: Distance to Stop by Speed")
axis(1)
axis(2, las = 2)
x = cars$speed
y = cars$dist
image_points(image, x, y, 2)
It turns out that the data is from the 1920s, so using this image might be more appropriate:
library(jpeg)
URL2 = "http://embed.polyvoreimg.com/cgi/img-thing/size/y/tid/4985430.jpg"
image2 = readJPEG(getURLContent(URL2))
plot(cars, type = "n", axes = F, xlab = "Speed", ylab = "Distance to Stop",
main = "Cars: Distance to Stop by Speed\n1920's car")
axis(1)
axis(2, las = 2)
image_points(image2, x, y, 2)
Here we have a jpeg file that is a width \( \times \) height matrix with values 0 to 1 representing the black/white/gray scale. We can manipulate the data using rgb() and abind() to create an array with the appropriate R, G, B, and alpha values.
First, on this color scale, values that are closer to 1 are going to be lighter gray to white, so we can assign an alpha value of 0 (transparent) to any values that are greater than 0.8.
alpha.val = matrix(1, nrow(image2), ncol(image2)) #want a matrix of 1s (not transparent) the same size as the image
alpha.val[image2 > 0.8] = 0 #for lighter gray and white values, set alpha to 0 (transparent)
library(abind)
image2.adj = array(image2, dim = c(nrow(image2), ncol(image2), 1))
image2.adj = abind(image2.adj, image2, image2, alpha.val)
plot(cars, type = "n", axes = F, xlab = "Speed", ylab = "Distance to Stop",
main = "Cars: Distance to Stop by Speed\n1920's Car w/Transparency")
axis(1)
axis(2, las = 2)
image_points(image2.adj, x, y, 2)
Notice that we have now essentially removed the border around the image, and even though the images overlap, we get a better sense of whwere the points lie.
A few final notes
- If we want the cars to be reversed, we can simply…
image2.adj.reversed = image2.adj[, ncol(image2.adj):1, ]
plot(cars, type = "n", axes = F, xlab = "Speed", ylab = "Distance to Stop",
main = "Cars: Distance to Stop by Speed\n1920's car w/Transparency, Reversed")
axis(1)
axis(2, las = 2)
image_points(image2.adj.reversed, x, y, 2)
- Using images with lower resolution will often yield better results, I don't know if there are better ways to display images at a lower resolution
- There might be better ways to do what I've figured out here - perhaps there are some more par values that would help convert the resolution and control the cex value?
