Hacker News Reader

Comment by Syzygies | Hacker News Reader

My father Bryce Bayer studied this question fifty years ago at Eastman Kodak; his approach is known as ordered dithering:

https://en.wikipedia.org/wiki/Ordered_dithering

One is effectively posterizing a grayscale image, and his primary goal was to reduce artifacts drawing unwanted attention to the borders between poster levels.

With improvements in hardware other approaches to dithering took over. The last time I saw my father's pattern was on a DEC box logo. He moved to the color group at Kodak, and designed the "Bayer filter" used in digital cameras.

View on HN

I think this is one of the better, well my dad can beat up your dad type of stories. I know you absolutely didn't mean it that way, but there's a part of me that read it that on the second reading of it.

Oh yeah, well my dad...! kind of thing =)

My grandad maintained that he has sorted out some issue with the soon to be rover V8 when it was bought from GM.

My dad manufactured some nozzles to make bonio biscuits. That's not quite as impressive though... Unless you have a dog.

Your father invented the Bayer filter. HN never ceases to amaze me :)

If you think that’s good, also check out further down in this thread. Gotta love HN for finding people that wrote old libraries. In the below case, it’s a library for using grayscale on a TI83.

https://news.ycombinator.com/item?id=34356244

Kudos to your dad! Every time I explain how a digital camera works to people, invariably it's the concept and application of the Bayer filter that causes their jaw to drop.

Most people think 50 megapixels = 50 red, 50 blue, and 50 green megapixels, so it's quite eye-opening. That our eyes work similarly with cones tuned to specific frequencies is just icing on the cake after that.

For a Foveon, the way you first think it works is the way it works :).

https://en.wikipedia.org/wiki/Foveon_X3_sensor

Yeah, realizing the actual image is only about 1/4 of the resolution of the sensor is something not everyone grasps. Marketing of course doesn't try to explain it either. I tend to take it too far by then explaining the benefits of using 3-chip monocolor sensors (or if not real-time, a single sensor triple flashed) to get the full resolution for each color channel. These are usually CCDs instead of CMOS, but the theory is the same. This is how most astronomy things work, like the Hubble, but instead of RGB, they use other filters that get "colorized" into RGB-ish.

It's really not 1/4 of the resolution. That's the beauty of the demosaicing process.

sure, and i knew the pedantics would beat me up over it (maybe rightly so, but i tried to use a number hyperbolically to make it obvious). however, it's not the full resolution of the chip. hence the use of monochrome chips for "full" resolution.

Luma is at full resolution, chroma is "upscaled", but we're less sensitive to color than to light so it's almost as good.

Most JPEG uses subsampling on chroma channels anyway.

Pedants, actually. :)

I couldn't help myself not to point out that the people being pedantic are pedants.

Thanks for the example though, as it was a simple way of mostly expressing a complicated concept.

i'm going to go with autotypo. yeah, that's it.

It's not about being pedantic, but that's literally the whole point of the Bayer process (which is what was being discussed).

If we were fine with getting 1/4 resolution output we'd just put one color filter for each sensor pixel and don't Bayer demosaic anything and call it a day.

> Marketing of course doesn't try to explain it either.

I remember early CCD digital camera brochures stating "actual resolution", and "enhanced resolution" (or something similar), where the latter is ~3x the former number. I wonder if this was referring to the demosaicing procedure.

Nope, since the early sensors were very low resolution, many cameras included interpolation engines inside, and some of them were pretty good at what they did.

They used blurry language to thinly veil the fact that the 1024x768 image you got indeed started its life as 640x480 one out of the sensor.

To add to the above, an alternative dithering approach is error diffusion, e.g.:

https://en.wikipedia.org/wiki/Floyd–Steinberg_dithering

The article mentions also doing this in the temporal domain.

And for 1-bit, Atkinson dithering can produce good effect. Floyd-Steinberg and Atkinson are the only two I'd usually consider for 1-bit dithering, with a preference for Atkinson for most images.

Ordered dithering, even at 8-bit, is…not my cup of tea.

For static images, yes. For animation, not so much as a pixel moving can have huge implications on other sides of the image due to error diffusion.

I find this to be the most elegant way to handle dithering. Been working with this on a side project.

I've been looking to build an engine/game that approximates this art style: https://obradinn.com

> I find this to be the most elegant way to handle dithering

Yes, it's so simple, it can be applied in a single pass on a single pixel buffer. Because in convolution kernel terms - it's only sampling from half of a moor neighbourhood, and that half can be from pixels not yet processed in the same buffer when moving through them in order.

It's so simple it fits in a dweet ;P

https://www.dwitter.net/d/24142

> I've been looking to build an engine/game that approximates this art style: https://obradinn.com

Killedbyapixel took the above dweet for inspiration in the style of some of his proc gen art, although I haven't dug into the how yet. I suppose deeper game/object awareness integration could produce better results than merely piping the output of the renderer into the dither algorithm, perhaps even the rendering could be optimized by targetting dithering specifically.

https://www.fxhash.xyz/generative/4686

> perhaps even the rendering could be optimized by targetting dithering specifically.

I was wondering about this possibility as well. I'm already up to my elbows in hand-rolled software rasterizer - which is already constrained to only using a luminance channel (8-bits).

I suppose I could still accumulate dither error and do a one-pass, 1-bit raster by combining the world-space 256-level luminance information with whatever error information is in the accumulator.

> I suppose I could still accumulate dither error and do a one-pass, 1-bit raster by combining the world-space 256-level luminance information with whatever error information is in the accumulator.

That would be interesting to see. I like the idea of renderers that give up things e.g resolution in exchange for something else. Pixel depth is just another. Would be interesting what gains in other areas might be possible if the rasterisation stage turns into 1-bit. Then again the cost of actually operating on single bit stored values might out weight any gains... unless this is done in hardware.

Think about it like this... In 1-bit dithered scheme, 1 machine word represents 64 entire pixels worth of values. You can access 64 pixels at a time and use bit-wise operations to manipulate the individual values.

Compare to a typical 24-bit RGB array, you just reduced your full-scan array access requirements from 3 per pixel to 1/64 per pixel.

For 720p (1280x720), you'd only be talking about 14,400 loop iterations to walk the entire frame buffer.

You could almost get away without even compressing the frames in some applications. At 30fps, totally uncompressed, 720p 1-bit dither would come in right at 30 mbps.

Surely you intended a Moore neighborhood and not moor? No relation.

yes

One more relevant use case: I've found Floyd-Steinberg dithering to be somewhat useful in compressing scanned JPEG paper notes at 600dpi (~1.5-2.5MB per page) to 1-bit PNG (100-300KB).

At full scale, there is no loss in readability and in fact I think I prefer the aesthetic quality of the 1-bit PNG. However, at <50% zoom, the dithered version was way less readable than a 2-bit PNG of slightly higher file size, so I ended up not compressing to 1-bit.

Edit: I was wrong, my (ex-) image viewer was at fault at 50% zoom. Viewing in other apps, the dithered version is visually no different from the 2-bit version. I bet the difference is even less with a HiDPI screen.

This sounds really interesting. Can you share some screenshots for us to see?

Wow! I worked on digital camera chips and had coworkers writing demosaic algorithms. We wouldn't have even had those jobs if it wasn't for your father.

Must be such a good feeling to have this legacy. Your father did great!

This reminds of this great article about creating a modern ordered dithering algorithm, and its effect on animations: https://bisqwit.iki.fi/story/howto/dither/jy/

I really hope your childhood home had a stained glass window with a Bayer pattern!

now that is something that could be interesting. maybe change from squares to diamonds for effect, but i like the suggestion! a stained Bayer glass window makes it sound like it should be found in medieval cathedrals

Wow, I deeply remember seeing these patterns in my relatively early computing days. I think it primarily was in Windows 3.x, back when graphics modes with 16 colors were still normal.

It definitely was not Floyd-Steinberg or anything else using error diffusion (which however I also remember seeing in those days, from some Windows applications' splash dialog for example), because there were these very characteristic stable patterns.

During countless hours staring at the dithered blue gradient of InstallShield, for example.

I recall graphics programming books in the mid/late 90's about dithering techniques.

There's also some fun related work on ASCII art rendering.

This sort of thing is/will still be useful for low-cost displays. I'm sure we'll have Wifi-enabled e-ink displays on cereal boxes soon.

Seeing that brings back a lot of nostalgia for the old PC Paintbrush that was once ubiquitous on DOS machines. The images it turned out were really great for the time, and I sometimes miss the aesthetic of those dithering patterns.

Ordered dithering is great. I use it in my video player, it looks good and is a fast alternative to error diffusion which requires more hardware resources.

Reply on news.ycombinator.com