I think they're showing it in the two videos on the page, though it's a bit subtle.
From what I understand, they were struggling to have good color resolution (distinguishable colors) at lower brightnesses. The first video demonstrates that well, especially if you look at red, which seems to be almost the same pale red color throughout the 10 or so LEDs that color occupies.
The second video, I assume, is after the temporal dithering is applied. If you focus on red again, you can see a much more smooth transition from red, to magenta, to blue.
The fun part here is that this is basically "doing modern GPU tricks with 8-bit-era constraints".
You're running into the same problems display vendors and graphics people hit, just with way harsher limits: no FPU, tiny RAM, tight timing, but the same human visual system on the other end. Temporal dithering, fixed point instead of floats, packing multiple error terms into a single byte, abusing wraparound as modulo arithmetic - it's all what you'd do on purpose if you were designing a minimal, deterministic rendering pipeline.
Also interesting that NeoPixels kind of force you into thinking in terms of a streaming architecture. You don't really have a framebuffer, you have a scanout with strict timing, so error diffusion "forward in time" instead of "across space" becomes the natural thing. It's like taking all the old image processing literature and rotating it 90 degrees so space becomes time and seeing what still works.
Projects like this are a good reminder that most "needs a faster chip" problems are actually "needs a different representation" problems.
It would be interesting to show the effect of the feature in a video. I can appreciate the theory, but a video would sell it better.
I think they're showing it in the two videos on the page, though it's a bit subtle.
From what I understand, they were struggling to have good color resolution (distinguishable colors) at lower brightnesses. The first video demonstrates that well, especially if you look at red, which seems to be almost the same pale red color throughout the 10 or so LEDs that color occupies.
The second video, I assume, is after the temporal dithering is applied. If you focus on red again, you can see a much more smooth transition from red, to magenta, to blue.
The fun part here is that this is basically "doing modern GPU tricks with 8-bit-era constraints".
You're running into the same problems display vendors and graphics people hit, just with way harsher limits: no FPU, tiny RAM, tight timing, but the same human visual system on the other end. Temporal dithering, fixed point instead of floats, packing multiple error terms into a single byte, abusing wraparound as modulo arithmetic - it's all what you'd do on purpose if you were designing a minimal, deterministic rendering pipeline.
Also interesting that NeoPixels kind of force you into thinking in terms of a streaming architecture. You don't really have a framebuffer, you have a scanout with strict timing, so error diffusion "forward in time" instead of "across space" becomes the natural thing. It's like taking all the old image processing literature and rotating it 90 degrees so space becomes time and seeing what still works.
Projects like this are a good reminder that most "needs a faster chip" problems are actually "needs a different representation" problems.
Odd that in both of these, it appears that blue is leading the way.
[dead]