Hello, spectral.js

Pseudo-blue noise shader

How fast does walk-on-spheres converge?

KDE estimation

Spherical Perlin Noise

Hull padding

Dithered heatmap

Mean value coordinates

Heatmap

Poisson potential

K-means binning

Image FFT

Transport to a map

Squircle interpolator

Disc Transport

An approximate formula for the chord area inverse problem

Walk on Spheres

noFrame contours

Hue blur

Moving average blur

Fitting a sigmoid

Gaussian Smoothing

Plateau detection

Hello, LOESS

Linde–Buzo–Gray stippling

interpolateBalanced?

Hello, delatin

Hillshading & supersampling

Blurry contours

Spherical contours iterator

Spherical contours as a gradient

Geo Voronoi interpolation

Modified Shepard’s method II (with geoContour)

Mapfill

Spherical contours

Modified Shepard’s method

Shepard’s method

Spherical kernel interpolation with nearest neighbors

Spherical Heatmap

Kriging

Spherical KDE Interpolation

Interpolation

Algorithms

I've said elsewhere that my pbn algorithm is really a merge sort in reverse, with random swaps. So that might be one direction to explore.

Another option is to see if we can improve on NuSan's shader they came up with after reading my notebook:

https://twitter.com/NuSan_fx/status/1464273180059750401

https://www.shadertoy.com/view/7lV3Ry

Job van der Zwan

*he (hadn't checked the twitter bio for pronouns so defaulted to "they")

Also, this is way above my math level but might be relevant: http://abdallagafar.com/publications/dyadic-nets/

(I've promoted http://abdallagafar.com/ before right? His work is so good)

The ACM link has an 18min video: https://dl.acm.org/doi/abs/10.1145/3450626.3459880

Oh, they actually wrote a follow-up with actual blue noise! https://dl.acm.org/doi/abs/10.1145/3550454.3555519

I had missed all this activity! Amazing :)

I have now reduced NuSan’s shader to a few lines of code.

Sorry, was just figuring out what the `b = y` was for. Mind if I try if Interleaved Gradient Noise works as a mix function?

try all you want! (use the tinker mode if you don't want to fork or to add to history.)
I've tried several things that are much faster but less nicely distributed (e.g. sqrt instead of sin). There's potential to be at least 5x faster.

I suspect that if we manage to avoid the casting between floating point and integers (for bitmasking) and inline that we'd get close to the speed of unmodified bayer

When I profile it's the 16 calls to Math.sin that take about 90% of the CPU time.

Why do I suddenly hear a carillon playing? https://www.youtube.com/watch?v=8qvdAWLcPyU