This January I played the most intriguing computer game I’ve played in ages: The Return of the Obra Dinn. Except for being a masterpiece of murder-mystery storytelling it also has the most unique art-style as it only uses black and white pixels. To pull this off Obra Dinn makes use of image dithering: the arrangement of pixels of low color resolution to emulate the color shades in between. Since the game was over all too quickly I thought I instead would explore how basic image dithering can be implemented in R. If old school graphics piques your interest, read on! There will be some grainy looking ggplot charts at the end.
(The image above is copyright Lucas Pope and is the title screen of The Return of the Obra Dinn)
Horatio Nelson in black and white
Image dithering tries to solve the problem that you want to show an image with many shades of color, but your device can only display a much smaller number of colors. This might sound like a silly problem now, but was a very real problem in the early days of computers. For example, the original Mac could only display black and white pixels, not even any shades of grey!
So let’s do some image dithering in R! The Return of Obra Dinn takes place on an early 19th century East Indiaman ship, so let’s use something related as an example image. Why not use a low-resolution painting of Vice Admiral Horatio Nelson (1758 - 1805) the British officer who defeated the French and Spanish navies during the battle of Trafalgar. To read in the image I will use the
1 2 3
imager package is a really useful package when you want to manipulate (and mess with) images directly in R. The
nelson object is now a
cimg object, which is basically an
array with dimensions Width, Height, Depth (a time dimension, if you have a series of images), and Color channels. More importantly,
cimg objects can be
As an example, I’m going to do black-and-white dithering so let’s remove the color and any transparency (called “alpha” here) from the image.
Now let’s imagine that we would want to display this image using only black and white pixels. Before getting to the dithering, what would the simplest method be to achieve this? Well, we could just threshold the image. A pixel with value
0.0 (fully black) to
0.5 are made black, and pixels with values above
0.5 are set to white (
1.0). This is easy to do as
nelson_gray can be treated as a matrix:
So, while the image looks kind of cool, it has lost a lot of nuance as large parts of it are now completely black. So how to fake shades of gray using only black and white pixels? Well, you can dither the image, that is, add some noise to the image as you reduce the number of colors. Let’s start by trying out the most basic kind of noise: White noise, here created using the
1 2 3 4 5
Each pixel in
rand_cimg is a value from
1.0 and we can now use
rand_cimg when thresholding instead of the static
0.5. If you try out many different noise images then every black and white pixel will on average have the same value as the original grayscale pixel. This sounds like a good property, but let’s see how it looks with the current
To be correct on average doesn’t help much, in practice, we get a very noisy Nelson. But if you squint you can now see shades of gray in the picture, at least. Random noise is just too random, but maybe we can get better dithering by adding less random noise. What about a checker pattern?
1 2 3
The pattern above uses cutoffs of 1/3 and 2/3, so Nelson-pixels that gets compared to a darker 1/3-pixel will be more likely to go white and Nelson-pixels that are compared to a lighter 2/3-pixel will tend to go black. Let’s scale this patter to Nelson-size.
1 2 3 4 5 6 7 8 9 10
And let’s do the thresholding with this new checker pattern:
Well, it’s not good, but it kind of looks like we got at least one shade of gray now compared to using the static
0.5. Actually, that’s exactly what we got! We can see that by taking a smooth gradient…
… and thresholding with the checker pattern:
1 2 3 4
This gives us three columns: black, “checker-gray”, and white. So, using the checker pattern we can achieve some more nuance than with simple thresholding. Is there perhaps an even better pattern that allows for even more nuance?
Better patterns, Bayer patterns
Yes, there is! The classical pattern used in many image dithering implementations is the Bayer pattern (or Bayer matrix) named after it’s inventor Bryce Bayer. It’s an evolution of the checker pattern defined for matrices of size 2×2, 4×4, 8×8, etc. The exact construction and properties of the Bayer matrix are well described in the Wikipedia article but here is how to create it in R and how it looks:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22
Basically, a Bayer matrix contains as many shades of gray it’s possible to fit in there, and the shades are as spread out as possible. Let’s see how a 4x4 Bayer matrix transforms the smooth gradient:
1 2 3 4
Pretty smooth! We get the classical “crosshatch” patterns reminiscent of last-century computer graphics. Let’s give Admiral Nelson the same treatment:
1 2 3 4 5
Now he looks doubly old-school. So far I’ve only worked with grayscale images and black-and-white dithering, but we can quickly hack together some color dithering by just performing the dither thresholding on one color channel at a time.
1 2 3 4 5 6
This method does not generalize to arbitrary color scales, but I still think it looks pretty cool!
Image dithering ggplots in R
Finally, I’ll show you how to dither some ggplots. Below is most of the code above wrapped up into functions:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51
Let’s then create the ggplot we will transform.
1 2 3 4 5
Then we’ll turn it into a low res
1 2 3 4 5 6 7 8 9 10
Finally, we can turn it into a retro-dithered black and white plot…
…or a dithered eight-color plot.
Something for your next retro inspired presentation, maybe? If you want to have full control over your image dithering it would probably be more convenient to post-process your plots using an image editor, such as the free and open source GIMP rather than to do it directly in R.
This post has covered basic image dithering in R and, to be more specific, it has covered ordered dithering. There is also error-diffusion dithering which works in a rather different way. But that’s for another time. Now I’m going to go back to mourning that I’ve already finished The Return of the Obra Dinn.