Worley Noise

// Steven Worley wrote this down in 1996, and it is the counterpart to Perlin noise.
// Perlin gives soft hills, Worley gives cells: scatter points across the picture and
// ask at every pixel how far away the nearest of them is. Near a point the answer is
// small, in between it is large - and out of that come honeycombs, cracked mud,
// scales, stone, water caustics.
public static class WorleyNoise
{
    // cells says how many points there are in each direction. order picks which
    // point is asked for: 1 is the nearest, 2 the second nearest.
    // The result runs from 0 to 1 and repeats seamlessly at the edges.
    public static float[] Generate(int width, int height, int cells, ulong seed, int order = 1)
    {
        ArgumentOutOfRangeException.ThrowIfLessThan(order, 1);

        var points = Scatter(cells, seed);
        var cellWidth = (float)width / cells;
        var cellHeight = (float)height / cells;
        var noise = new float[width * height];
        var distances = new float[9];

        for (var y = 0; y < height; y++)
        {
            for (var x = 0; x < width; x++)
            {
                var cellX = (int)(x / cellWidth);
                var cellY = (int)(y / cellHeight);
                var found = 0;

                // Only the nine cells around the pixel can hold the nearest point.
                // Everything further away is further away by construction.
                for (var offsetY = -1; offsetY <= 1; offsetY++)
                {
                    for (var offsetX = -1; offsetX <= 1; offsetX++)
                    {
                        // The modulo makes the picture repeat: a point falling off
                        // the right edge comes back in on the left.
                        var neighbourX = (cellX + offsetX + cells) % cells;
                        var neighbourY = (cellY + offsetY + cells) % cells;
                        var point = (neighbourY * cells + neighbourX) * 2;

                        var pointX = (cellX + offsetX + points[point]) * cellWidth;
                        var pointY = (cellY + offsetY + points[point + 1]) * cellHeight;

                        var dx = x - pointX;
                        var dy = y - pointY;

                        distances[found++] = MathF.Sqrt(dx * dx + dy * dy);
                    }
                }

                Array.Sort(distances, 0, found);

                // Divided by the size of a cell, so that the numbers stay the same
                // no matter how large the picture is.
                noise[y * width + x] = Math.Min(distances[order - 1] / cellWidth, 1f);
            }
        }

        return noise;
    }

    // One point per cell, placed somewhere inside it. Without that jitter the
    // pattern would be a plain grid.
    private static float[] Scatter(int cells, ulong seed)
    {
        var random = new Pcg(seed);
        var points = new float[cells * cells * 2];

        for (var i = 0; i < points.Length; i++)
            points[i] = (float)random.NextDouble();

        return points;
    }
}

const int size = 240;
const int cells = 8;
const ulong seed = 20240921;

// The distance to the nearest point and to the second nearest one. Both
// pictures come from the same points, they only ask a different question.
var nearest = WorleyNoise.Generate(size, size, cells, seed);
var second = WorleyNoise.Generate(size, size, cells, seed, order: 2);

var veins = new float[nearest.Length];
var scales = new float[nearest.Length];

for (var i = 0; i < nearest.Length; i++)
{
    // Where the difference between the two is small, the pixel lies exactly
    // between two points - that is the border of a cell. This is the trick
    // that makes cracks, veins and honeycombs out of blobs.
    veins[i] = Math.Min((second[i] - nearest[i]) * 2.5f, 1f);

    // Inverted, the nearest distance looks like scales or bubbles.
    scales[i] = 1 - nearest[i];
}

Channels.ToImage(nearest, size, size).Save(Path.Combine(folder, "worley-cells.png"));
Channels.ToImage(veins, size, size).Save(Path.Combine(folder, "worley-veins.png"));
Channels.ToImage(scales, size, size).Save(Path.Combine(folder, "worley-scales.png"));

Console.WriteLine($"{cells * cells} points on {size} x {size} pixels");
Console.WriteLine($"nearest point:  {nearest.Min():0.00} to {nearest.Max():0.00}, average {nearest.Average():0.00}");
Console.WriteLine($"second nearest: {second.Min():0.00} to {second.Max():0.00}, average {second.Average():0.00}");

const int size = 240;

// Marble is stripes that have been pushed out of shape. The stripes come
// from a sine, the pushing from Perlin noise, and the grain of the stone
// from Worley - three lines of noise, one material.
var random = new Pcg(4711);
var seeds = new float[size * size];

for (var i = 0; i < seeds.Length; i++)
    seeds[i] = (float)random.NextDouble();

var soft = PerlinNoise.Generate(seeds, size, size, octaves: 5, persistence: 0.55f);
var nearest = WorleyNoise.Generate(size, size, cells: 5, seed: 4711);
var second = WorleyNoise.Generate(size, size, cells: 5, seed: 4711, order: 2);
var marble = new float[seeds.Length];

for (var y = 0; y < size; y++)
{
    for (var x = 0; x < size; x++)
    {
        var i = y * size + x;

        // Six stripes across the picture, pushed sideways by the noise.
        var stripes = MathF.Sin((x / (float)size * 5 + soft[i] * 4) * MathF.PI);

        // Right between two points the two distances are almost equal. Only
        // there does this get small, and that draws the thin dark cracks.
        var crack = Math.Min((second[i] - nearest[i]) * 14f, 1f);

        marble[i] = Math.Clamp((0.66f + stripes * 0.26f) * (0.45f + crack * 0.55f), 0f, 1f);
    }
}

Channels.ToImage(marble, size, size).Save(Path.Combine(folder, "worley-marble.png"));

Console.WriteLine($"marble: {marble.Min():0.00} to {marble.Max():0.00}, average {marble.Average():0.00}");