Quality Dithering

This program includes several dithering algorithms, including some original ones. This suite is focused on accurate dithering over speed and as such its output is higher quality than most (if not all) other dithering apps.

The scoring metric is the most unique thing here. It uses a perception kernel to approximate psychovisual perception. All the algorithms on this page except Burkes and Pattern-Dithering use this metric to direct the dithering process.

Energy Dithering is a technique that uses a simulated annealing process to attempt to find a high-quality local minimal to the scoring function. It's fairly slow, but the default values are tuned to work fairly well. You can adjust the settings in the Advanced Version.

Least Error First starts out assuming the image is as given and iteratively changes pixels to palette colors that would add the least amount of error among all possible pixels and palette colors. It is very slow, but works very well.

Least Error Scan is a modification of Least Error First that goes in scan-line order. It does several passes iteratively improving the image until it gets stuck at a local minima. That restriction makes it slightly worse, but significantly faster than Least Error First. The change is enough to make it tend to out-pace Energy Dithering until it gets stuck in a local minimal at which point Energy Dithering is able to overtake it.

Pattern Dithering and Burkes (Error Diffusion) are both existing algorithms, however I'm using the HCT colorspace here so you'll likely get better results from this program than from those that don't use HCT. I'm also down-scaling images using a high-quality downscaling algorithm with all color-blending math done in Linear RGB.

Pattern Dithering requires a pattern and there are many pattern generating algorithms. Pattern Dithering isn't as good as algorithms that can diffuse error dynamically but they have a place and Joel Yliluoma has a great article on the topic: Joel Yliluoma's arbitrary-palette positional dithering algorithm. The main algorithms mentioned in that article are available here as patterns under Preprocessing as well as a few others. In particular, Saffron Smooth is an algorithm I made that often gives very good results. It starts by assuming the entire pattern is the closest paletteColor and iteratively checks if replacing the first n (from n to 1) pattern entries with a different color improves the pattern's overall accuracy. Because it starts be demanding that as many entries as possible are replaced, it inherently disincentivizes colors that are starkly different from entering the pattern unless necessary. Adobe's Pattern Dithering is also very good.