Atkinson Dithering (2021)

To avoid changing the overall brightness like in the examples it is important to work on linearized values or to adjust the running error accordingly. It's not correct to work on the encoded sRGB values of the image directly. This is a very common mistake in blog articles about diy image filtering.

I fell in love with the original Macintosh display. It was so crisp, the black and white pixels so beautiful (especially if you had come off the typical computer hooked up to a TV). Combine that with the beautiful dithering and I almost shunned color when it came along.

(I believe I've read that Atkinson's dithering didn't come about until scanner software was needed for the Macintosh and so he wrote his own dithering code.)

This was the article that inspired me to study the MacPaint format. I ended up writing first a Python program that can do Atkinson dithering of a modern image and then save it as a MacPaint file for display on a retro Mac. That code is a chapter in my upcoming book. I then added 9 more 1-bit dithering algorithms and turned it into a Swift/AppKit app so it's easy to use if you want to Atkinson dither your own images and transfer them over to your retro Macs:

https://apps.apple.com/us/app/retro-dither-b-w-is-beautiful/...

More on dithering: https://surma.dev/things/ditherpunk/

These days dithering is a lost technique other than as an arty effect. It's a shame, digital video playback would really benefit from it as a way to eliminate posterization.

Thanks for sharing this.

I once used Floyd-Steinberg dithering to make 3D voxel prints from brain MRI scans [0]. You just convert the scan to full white and black values to represent different inks, and it means you don't have to do any segmentation and can represent fine structures much more accurately.

May be interesting to try with Atkinson dithering too, although the loss of detail may be an issue.

[0] https://www.lukehale.com/voxelprinting/

Error diffusions are hard to be parallelized. They're also not stable, meaning moving pixel may look different in different frame. But they usually give best result for static images.

I would like to see the ideas of dithering applied to voting systems.

Ie. Imagine a country with hundreds of elected officials, each of which represents a town or city. Each official is part of a party.

A dithering-like system could be used during the vote so that the country as a whole is fairly represented, and most towns also are represented by who the majority of their population wants.

It would work by, during an election, whenever a candidate is chosen for a location, any votes for other parties get transferred to neighbouring towns and cities. That is done repeatedly until every towns seat is filled, and nearly every voters vote has an impact (if not in their local town, then it gets to help a candidate of the same party nearbyish)

Am I the only person who thinks the Floyd-Steinberg dithering is superior is clarity and detail?

The Atkinson dithering makes the image appear overexposed/blown-out (not true to the original image).

This PHD thesis is the best technical coverage of dither science that I've seen:

https://uwspace.uwaterloo.ca/bitstream/handle/10012/3867/the...

Among the things it covers is the design of a noise shaping filter with a more symmetrical response than the Floyd-Steinberg one.

One really nice use case for dithering that I've found is for building graphics for 8-bit (Pico-8 and Picotron) games and toys.

I made a ruby script that can take a graphic and scale it to whatever size, then it uses a closest color match to substitute colors for the _very_ limited Pico* palette and applies dithering to make it look attractive. I like Stenberg the most, but have played with Atkinson and am still feeling around a bit.

I never really paid attention to the grid-like artifacts[0] that FSD and some other dithering algorithms cause when a dithered image is scaled way down (as is the case of the thumbnails in this article).

[0] https://en.m.wikipedia.org/wiki/Moir%C3%A9_pattern

This just reminded me of the “secret” bitmap of the dev team hidden in the OS.

I recall using Macsbug to show it.

I remember creating an X-Face[0] using Atkinson Dithering for my SeaMonkey add-on MessageFaces[1]!

You can create one online here[2], but it doesn't seem to support Atkinson for whatever reason.

[0]: https://en.wikipedia.org/wiki/X-Face

[1]: https://github.com/JohnDDuncanIII/messagefaces

[2]: https://www.dairiki.org/xface/

Why is the Floyd-Steinberg error diffusion kernel so uneven? What's the output like if the error is distributed equally among the bottom-right pixels?

And this is a naive question, but could one construct a kernel that diffuses the error across all surrounding pixels, not just the bottom+right? I get that this will cause recursion difficulties as error bounces back-and-forth between neighboring pixels, but is that resolvable?

More example (and algorithms) can be found here:

https://brucebcampbell.wordpress.com/wp-content/uploads/2013...

There is implementation variance on whether you apply the dithering consistently left to right on each row or you alternate. Floyd-Steinberg definitely benefits from the latter approach.

Also whether you apply the dithering in a linear colorspace.

Just curious, does the website name "Beyond Loom" has anything to do with the video game "Loom" (1990)?

Floyd-Steinberg looks a lot better IMHO.

Dithering can still be a striking aesthetic choice. Low Tech Magazine is my go-to example: https://solar.lowtechmagazine.com/

From their About page:

"Thus, instead of using full-colour high-resolution images, we chose to convert all images to black and white, with four levels of grey in-between. These black-and-white images are then coloured according to the pertaining content category via the browser’s native image manipulation capacities. Compressed through this dithering plugin, images featured in the articles add much less load to the content: compared to the old website, the images are roughly ten times less resource-intensive."