Pekka Väänänen

@pekkavaa.bsky.social

1230 Followers 397 Following

Avid reader, computer graphics fan and atmospheric jungle beats enjoyer. Demoscene: cce/Peisik. Blog at https://30fps.net/

Warning: Don't Abuse Lab Space Lab color space is designed for low spatial frequencies. - It is very good for measuring color differences in objects. - It is the standard for measuring paint color. - It is good for measuring color accuracy of printers and displays. Direct application to images works poorly. - Lab does not account for high spatial frequency content of images. - Lab formulation ignores different form of CSF for luminance and chrominance spaces. - Image coding in Lab space will produce poor results. C. A. Bouman: Digital Image Processing - January 11, 2026
A graphic showing a side-by-side comparison of three versions of the same image, each processed with a different dithering algorithm. The image consists of three vertical panels arranged horizontally, with a text summary located at the bottom. Each panel features a stylized bird from the Big Buck Bunny animated short. A yellow beak and large eyes, sitting on a branch. A blue-to-pink gradient sky and green leaves in the background. The three panels: Yliluoma's 2nd dithering algorithm: Dithered result with the most noise. EMA-Constant: Significantly smoother result. Knoll (10% strength): Smooth result similar to EMA-Constant. Text at the bottom: Summary: This article discusses Yliiluoma's 2011 ordered dither algorithm (left), explains its internals in greater detail than other treatments, presents new simplified variants (middle), and compares the results to a state-of-the-art algorithm (right). Source code is included at the end.
A six-pane comparison of a Chrono Cross screenshot reduced to a 16-color fixed palette. Each pane shows a different result and they all are somewhat noisy. The panes are labeled EMA-Sweep, EMA-Exact, EMA-Constant, Yliluoma-2, Yliluoma-2 (no luma weighting), Knoll (30% strength).
A PowerPoint slide titled "Cathedral Church of Saint Vitus". There is a three-pane comparison images labeled "Direct and emissive", "Indirect diffuse (baked)" and "Final render (Xbox One)". The background color is black and at the bottom there's a grey text "Rendering Secrets of 'Pekka's Two Nights in Prague'"
A number line where 3-bit integers in the range [0..7] being mapped to real numbers with two approaches: the standard (top) and alternative (bottom). On the X-axis we’ve got a number line and the locations of brown circles on it represent the decoded floating-point values. The numbers inside are the integer inputs. Each integer has arrows pointing to it; these show a range of floating-point values that round to it. I’ll call these ranges “bins” in the rest of this article.
Abstract—Quantization is the process of replacing analog samples with approximate values taken from a finite set of allowed values. The approximate values corresponding to a sequence of analog samples can then be specified by a digital signal for transmission, storage, or other digital processing. In this expository paper, the basic ideas of uniform quantization, companding, robustness to input power level, and optimal quantization are reviewed and explained. The performance of various schemes is compared using the ratio of signal power to QUANTIZATION mean-square quantizing noise as a criterion. Entropy coding and the ultimate theoretical bound on block quantizer performance are also compared with the simpler zero-memory quantizer. ALLEN GERSHO, MEMBER, IEEE
A comparison table with two rows and two columns. The top row header is "Order" and "Intermediate OKM result (32 colors)". The first row contains "Bayer 2x2 (unshuffled)" on the left and a pixelated image of two macaws on a branch on the right, with a 2x2 Bayer dithering effect. The second row contains "Bayer 4x4 (unshuffled)" on the left and another version of the same macaws on the right, with a finer 4x4 Bayer dithering effect.
Table of contents Contents and chapter order are still subject to change. Part 1: Setting the Standard Popularity and bit cutting The trivial median cut Palette refinement with K-means Cutting by variance Error diffusion dithering Part 2: Practical Improvements Structure-preserving dithering Ordered dithering Image preprocessing Perceptual color spaces Alpha difference formula Part 3: Flights of Fancy k-means as a color quantizer Top-down clustering via 2-means Wu’s Famous 1991 Technique The axis of greatest variation Combined reduction and dithering Epilogue and Appendices Epilogue: The historical Octree Image processing in Python Alpha difference formula derivation Proof of Celebi’s update formulas
Two images of Swedish red houses with transparent sky shown as a grey checkerboard pattern. The top one is the original, below it is the color reduced version that looks almost identical. Here the 4-bit quantized 256-color result does look decent. The only visible issues are the white fringes on the treeline on the left half of the image, and small overall color distortion caused by the 4-bit colors. For example the red paint of the facades is reproduced with a subtle greyish noise not present in the original.
"Our experience of ICM on such scenes is limited to a couple of artificial examples and several lung and liver scans produced by a gamma camera, with Poisson distributed records. The processing was carried out on the BBC Model B, with 8 or 16 levels and second-order neighbourhood. Although the results were satisfactory, it would be desirable generally to adopt a larger neighbourhood to allow for curvature effects, through coefficients which depend"
A screenshot of code that says: /** * The ZX has one bit per pixel, but can assign two colours to an 8x8 block. The * two colours must both be 'regular' or 'bright'. Black exists as both regular * and bright. */ val zx_quantize(std::string rawimage, int image_width, int image_height, float dithering) { auto image_buffer = (const liq_color*)rawimage.c_str(); int size = image_width * image_height; liq_color block[8 * 8]; uint8_t image8bit[8 * 8]; std::vector<liq_color> result(size); // For each 8x8 grid for (int block_start_y = 0; block_start_y < image_height; block_start_y += 8) { for (int block_start_x = 0; block_start_x < image_width; block_start_x += 8) { int color_popularity[15] = {0};
Left: Without error dampening. Right: with 0.8 error dampening when accumulated per-pixel error (squared magnitude) is greater than 0.02
Left: Original Floyd-Steinberg dithering. Sky gradients are reproduced with very distracting pixel patterns. Right: With large error dampening added, only moderate noise appears.
Gimp's normal Floyd-Steinberg (left) and the same with reduced color bleeding turned on (right).
Left: Floyd-Steinberg dithering. Right: Floyd-Steinberg with reduced color bleeding aka clamped error offset.
Gamma bird
The diagram shows a matrix X with labeled points (1–6) representing an original image, and a matrix Y with corresponding labeled points with the name c (sub index 1–2) showing a reconstruction. Below each matrix is a point diagram: the left one for the original image with scattered colored dots divided in two classes, and the right one for the reconstruction with connected dots showing how the two clusters are represented by their mean positions. The formula between them indicates a difference squared, representing reconstruction error.
Four images of a red building scene, each resulting from different combinations of k-means refinement and dithering settings: top row (k-means, dithering), second row (k-means, dithering), third row (k-means, dithering), bottom row (k-means, dithering). Figure caption: Results of Pillow’s MAXCOVERAGE color quantizer (aka the maximin k-means initializer) with varying k-means refinement and dithering settings. The bottom “☒ k-means, ☒ dithering” result may appear the best at first glance but the “☐ k-means, ☒ dithering” (second from the top) image has more vibrant colors when viewed from afar.
The book cover for Palette Programming: A Modern Guide to Color Quantization by Pekka R. H. Väänänen. The book title and author name are written in black monospace font on a white background at the top part of the cover. The rest of the cover shows a 4x6 grid of images. The images show a photo of a red house getting progressively more colors. Cover design by https://www.instagram.com/porcelain_hive/
Python code that says: # Set the number of local seeding trials if none is given if n_local_trials is None: # This is what Arthur/Vassilvitskii tried, but did not report # specific results for other than mentioning in the conclusion # that it helped. n_local_trials = 2 + int(np.log(n_clusters))
A rotated and alpha blended sprite with a black fringe.
I've found a big danger with rm in bash is that bash usually doesn't stop for errors. That means that: cd $SOMEPATH rm -rf * Is a very dangerous combination if the change directory fails. A safer way would be: cd $SOMEPATH && rm -rf * Which will ensure the rf won't run unless you are really in $SOMEPATH. This doesn't protect you from a bad $SOMEPATH but it can be combined with the advice given by others to help make your script safer.
A blue-to-white gradient in the sRGB, CIELAB, CAM16-UCS, Oklab, IPT, and Optimized IPT color spaces. The CIELAB and CAM16-UCS results are clearly off. The gamma-space sRGB interpolation is also slightly too purple.
"The last control that was offered through the user interface was the ability to apply linear regression to either the pretransform matrix, or the posttransform matrix. The data used was the Ebner and Fairchild data set (306 points of constant hue on 15 different hue surfaces)."
"3.1.3.6 Observers 30 observers, 18 males and 12 females, between the ages of 27 and 59 participated in the experiment. The author was pleasantly surpnsed to learn that the lure of a free lunch would entice so many willing and qualified observers."
"The experiment was performed on a Sun Sparc Ultra 1 with a 20" Sony GDM-20E20 monitor. The resolution was 1152x900 with a refresh rate of 76 Hz and a 0.31mm-phosphor trio pitch. The CRT display was kept on during the extent of the experiment (which ran from May through July, 1997) to minimize drift from power cycling. The layout of the interface is shown in figure 31. The stimulus squares for both test and reference subtended an angle of 4.2 degrees."
A snippet of my book manuscript that shows paragraphs of text around code snippet.s The line numbers of the code snippets are shifted left over the margin.
A Doom screenshot using a slightly more accurate colormap for lighting. Of course differences to the original become apparent only in a side-by-side comparison.
Carmack's typo was a minor bug in dcolors.c, a program written by John Carmack in 1992 during early development of Doom. To generate the invulnerability colormap, Carmack converted each color in the palette to a gray scale value using a standard formula, where the gray scale value equals red*0.299 + green*0.587 + blue*0.114. In the utility, Carmack accidentally wrote 0.144 instead of 0.114, meaning that the invulnerability colormap converts all blues to be slightly too dark.[1] Since the invulnerability colormap inverts the gray scale palette, this means the gray scale colors converted from blue are calculated as brighter than they should be, and so become darker than they should be when the palette is inverted.
This graph shows how eager each color space is to minimize lightness error. The X-axis represents median cut’s splits as it works its way through clusters until all palette colors have been found. The Y-axis shows the sum of squared lightness errors of the whole image, measured as CIELAB’s L∗. I believe the low lightness weight is the main reason why median cut doesn’t work better in unscaled CIELAB than in sRGB.
A four-pane comparison of different formulas for greyscale conversion. Top row: Linear sRGB (the correct way to do it), Gamma sRGB (the somewhat wrong "luma" formula). Bottom row: CIELAB L* (a high quality option), and the new alternative gamma-space version. Careful inspection shows the "Gamma sRGB" case is slightly dimmer at points than the others.
A top-down hierarchical color quantization routine shown as a binary tree. The algorithm starts from the top box 1 that contains all image colors and continues splitting the box with the greatest error (in this case just max volume) into color subsets. Each box is split at the median, shown in red. Splitting stops when the requested number of colors has been reached. The mean colors of the leaf nodes at the bottom define the final 12-color palette.
Figure 1: The Grace Cathedral light probe subdivided into 64 regions of equal light energy using the median cut algorithm. The small circles are the 64 light sources chosen as the energy centroids of each region; the lights are all approximately equal in energy. From Paul Debevec, "A Median Cut Algorithm for Light Probe Sampling"
A diagram showing three images: the Source, a crop from Big Buck Bunny; the target image, the PICO-8 palette; and the result image. The result image's color distribution has been moved to match the target. Paper reference: "Color Transfer Between Images" Reinhard et al. 2001.
A four-pane comparison of pixel mapping results in CAM16-UCS, Oklab, and the CIELAB colorspace (HyAB distance function). Top right is the input image.
# First deduplicate the colors unique_colors, counts = deduplicate_colors(img.reshape(-1, 4)) # Create a structured array so that we can have float RGBA colors, per color weight and # the original RGBA8 color accessible and sortable with a single index. ColorRGBA = np.dtype([ ('r', 'f4'), ('g', 'f4'), ('b', 'f4'), ('a', 'f4'), ('weight', 'f4'), ('original', 'u4'), ]) colors = np.rec.array(np.zeros(unique_colors.shape[0], dtype=ColorRGBA)) colors.r = unique_colors[:, 0] / 255.0 colors.g = unique_colors[:, 1] / 255.0 colors.b = unique_colors[:, 2] / 255.0 colors.a = unique_colors[:, 3] / 255.0 colors.weight = counts / num_total colors.original = unique_colors.view(np.uint32).reshape(-1) # Scale the channels to weight luminance more when picking a split-plane axis. # This is why its convenient to store the original RGBA8 color: the final step # that averages colors for the palette doesn't need to know about this transform. colors.r *= 0.30 colors.g *= 0.59 colors.b *= 0.11 colors.a *= 0.50
The screenshot shows the "VariQuant" tool interface with a preview panel displaying an image named "boom.png" The interface includes settings for the number of colors, cut order, split plane, split position ("Mean" is chosen), color space for palette design and pixel mapping, averaging, luminance-scale, and K-means iterations. File operation buttons for opening, exporting, canceling, and generating palettes are also visible.
A screenshot of a chapter in the linked article with the following text: "Does NTSC use a gamma of 2.2? Television is usually viewed in a dim environment. If an images's correct physical luminance is reproduced in a dim surround, a subjective effect called simultaneous contrast causes the reproduced image to appear lacking in contrast, as demonstrated above. The effect can be overcome by applying an end-to-end power function whose exponent is about 1.1 or 1.2. Rather than having each receiver provide this correction, the assumed 2.5-power at the CRT is under-corrected at the camera by using an exponent of about 1/2.2 instead of 1/2.5. The assumption of a dim viewing environment is built into video coding. " There's also and a visual test diagram with two columns. The left column has three squares in a vertical arrangement, each with varying shades of gray, transitioning from light to dark. The right column also has three squares in a vertical arrangement, each with the same shades of gray as the left column, but with a black background behind them. It looks like the one on the right with a black background has less contrast.
Screenshot of VariQuant with a still from the movie 2001: Space Odyssey.
A screenshot of "VariQuant", my color quantization (palette creation) tool. From left to right: the quantized result, a palette visualization sorted by hue on the vertical axis, and finally the quantization parameters that can be adjusted live.
A counter example where the PCA approximation fails. The cross shape consists of 200 points with 100 uniformly distributed both on the X and Y axes. However, the points on the X axis have twice the range, hence more variation. PCA (red) interpretes the situation correctly but the approximation (orange) fails.
from dataclasses import dataclass @dataclass class Data: value: int other = 1 # conceptually not part of a dataclass a = Data(0) b = Data(0) assert a == b, "values are equal" b.other = 100 assert a == b, "values are still equal!" print("a:", a) print("b:", a) # even in printouts "other" is ignored print("a == b:", a == b)
A diagram from "The Irradiance Volume" by Gene Greger, Peter Shirley, Philip M. Hubbard, and Donald P. Greenberg. 1998.
A plot comparing the original PCA and a simpler approximation. Accurate (red) and approximate (orange) first principal components are shown. The approximation seems close to the original based on this experiment. The shown directions are aggregated over five random trials.
A screenshot of an image editing tool with three horizontal panels. The first two show versions of the same image, with the one on the right slightly degraded. The third column includes a single horizontal slider labelled "Colors", set to 16, and a "Generate palette" button. Looks like a professional UNIX tool!
A four-pane comparison of the same image with different color palettes. From left to right, top to bottom: The original 128x128 image (has some saturation added), the baseline result in CAM16-UCS, the Oklab result, and the HyAB result. CAM16-UCS and Oklab use an Euclidean distance, HyAB a mixed absolute + Euclidean distance.
Initialization and k-means refined results of palettes produced by two different color quantization methods (Wu91, VC) on two images (skybox, caps). The blue channel in the images was zeroed out. Colored points are image pixel colors and the X and V signs are Wu91 and VC methods' respective cluster centers. We can see that in the beginning the centers are spread out but after k-means they roughly line up. There are still many differences and the Wu91 seems to achieve lower sum of squared error ("inertia") in the end. The difference is less than 1% though.