Worley Noise

// Steven Worley hat das 1996 beschrieben, und es ist das Gegenstück zu Perlin Noise.
// Perlin gibt weiche Hügel, Worley gibt Zellen: Punkte über das Bild streuen und an
// jedem Pixel fragen, wie weit der nächste entfernt ist. Nahe an einem Punkt ist die
// Antwort klein, dazwischen groß - und daraus werden Waben, rissiger Lehm,
// Schuppen, Stein, Lichtmuster auf Wasser.
public static class WorleyNoise
{
    // cells sagt, wie viele Punkte es je Richtung gibt. order wählt, nach welchem Punkt
    // gefragt wird: 1 ist der nächste, 2 der zweitnächste.
    // Das Ergebnis läuft von 0 bis 1 und wiederholt sich nahtlos an den Rändern.
    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;

                // Nur die neun Zellen um den Pixel herum können den nächsten Punkt enthalten.
                // Alles Weitere liegt schon von der Bauart her weiter weg.
                for (var offsetY = -1; offsetY <= 1; offsetY++)
                {
                    for (var offsetX = -1; offsetX <= 1; offsetX++)
                    {
                        // Das Modulo lässt das Bild sich wiederholen: Ein Punkt, der rechts
                        // hinausfällt, kommt links wieder herein.
                        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);

                // Geteilt durch die Größe einer Zelle, damit die Zahlen dieselben bleiben,
                // egal wie groß das Bild ist.
                noise[y * width + x] = Math.Min(distances[order - 1] / cellWidth, 1f);
            }
        }

        return noise;
    }

    // Ein Punkt je Zelle, irgendwo darin. Ohne dieses Verwackeln wäre das
    // Muster ein schlichtes Gitter.
    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;

// Der Abstand zum nächsten und zum zweitnächsten Punkt. Beide Bilder kommen
// von denselben Punkten, sie stellen nur eine andere Frage.
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++)
{
    // Wo die Differenz der beiden klein ist, liegt der Pixel genau zwischen zwei
    // Punkten - das ist die Grenze einer Zelle. Das ist der Trick, der aus
    // Blasen Risse, Adern und Waben macht.
    veins[i] = Math.Min((second[i] - nearest[i]) * 2.5f, 1f);

    // Umgedreht sieht der nächste Abstand aus wie Schuppen oder Blasen.
    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;

// Marmor sind Streifen, die verbogen wurden. Die Streifen kommen von einem
// Sinus, das Verbiegen von Perlin Noise und die Maserung des Steins von
// Worley - drei Rauschen, ein 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;

        // Sechs Streifen über das Bild, vom Rauschen seitlich verschoben.
        var stripes = MathF.Sin((x / (float)size * 5 + soft[i] * 4) * MathF.PI);

        // Genau zwischen zwei Punkten sind die beiden Abstände fast gleich. Nur dort
        // wird das hier klein, und das zeichnet die dünnen dunklen Risse.
        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}");