我的 Perlin Noise 函数有太多黑点和小白条答案

【问题标题】：My Perlin Noise function having too many dark spots, and little strips of white我的 Perlin Noise 函数有太多黑点和小白条
【发布时间】：2020-08-08 23:34:52
【问题描述】：

我通过松散地遵循 C# 中的 java 教程创建了一个 Perlin 噪声函数。然后我使用 Unity 对其进行可视化（我认为问题不在于统一，因为它们的内置函数可以完美运行）

问题是有太多的大黑点。 Here is a photo

This is how I would like it to look

如您所见，这些点似乎没有很好地融合。

这是我的噪音代码：

using System;
using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public class PerlinNoise
{
    public PerlinNoise()
    {
    }

    public double GetPixel(double x, double y)
    {
        int xint = (int)Math.Floor(x) & 255;
        int yint = (int)Math.Floor(y) & 255;    //gets what cube the input coords are


        int g1 = p[p[xint] + yint];
        int g2 = p[p[xint + 1] + yint];
        int g3 = p[p[xint] + yint + 1];
        int g4 = p[p[xint + 1] + yint + 1];     //gets the gradient vector's vaule on the permutation table

        double xdec = x - Math.Floor(x);
        double ydec = y - Math.Floor(y);    //gets the pixel inside the cube

        double d1 = grad(g1, xdec, ydec);
        double d2 = grad(g2, xdec - 1, ydec);
        double d3 = grad(g3, xdec, ydec - 1);
        double d4 = grad(g4, xdec - 1, ydec - 1);

        double u = fade(xdec);
        double v = fade(ydec);

        double x1Inter = lerp(u, d1, d2);
        double x2Inter = lerp(u, d3, d4);
        double yInter = lerp(v, x1Inter, x2Inter);

        return yInter;
    }

    private static double lerp(double amount, double left, double right)
    {
        return ((1 - amount) * left + amount * right);
    }

    private static double fade(double t)
    {
        return t * t * t * (t * (t * 6 - 15) + 10);
    }

    private static double grad(int hash, double x, double y)
    {
        switch (hash & 3)
        {
            case 0: return x + y;
            case 1: return -x + y;
            case 2: return x - y;
            case 3: return -x - y;
            default: return 0;
       }
   }

    private static readonly int[] p = { 151,160,137,91,90,15,
    131,13,201,95,96,53,194,233,7,225,140,36,103,30,69,142,8,99,37,240,21,10,23,    
    190, 6,148,247,120,234,75,0,26,197,62,94,252,219,203,117,35,11,32,57,177,33,
    88,237,149,56,87,174,20,125,136,171,168, 68,175,74,165,71,134,139,48,27,166,
    77,146,158,231,83,111,229,122,60,211,133,230,220,105,92,41,55,46,245,40,244,
    102,143,54, 65,25,63,161, 1,216,80,73,209,76,132,187,208, 89,18,169,200,196,
    135,130,116,188,159,86,164,100,109,198,173,186, 3,64,52,217,226,250,124,123,
    5,202,38,147,118,126,255,82,85,212,207,206,59,227,47,16,58,17,182,189,28,42,
    223,183,170,213,119,248,152, 2,44,154,163, 70,221,153,101,155,167, 43,172,9,
    129,22,39,253, 19,98,108,110,79,113,224,232,178,185, 112,104,218,246,97,228,
    251,34,242,193,238,210,144,12,191,179,162,241, 81,51,145,235,249,14,239,107,
    49,192,214, 31,181,199,106,157,184, 84,204,176,115,121,50,45,127, 4,150,254,
    138,236,205,93,222,114,67,29,24,72,243,141,128,195,78,66,215,61,156,180,151,160,137,91,90,15,
    131,13,201,95,96,53,194,233,7,225,140,36,103,30,69,142,8,99,37,240,21,10,23,
    190, 6,148,247,120,234,75,0,26,197,62,94,252,219,203,117,35,11,32,57,177,33,
    88,237,149,56,87,174,20,125,136,171,168, 68,175,74,165,71,134,139,48,27,166,
    77,146,158,231,83,111,229,122,60,211,133,230,220,105,92,41,55,46,245,40,244,
    102,143,54, 65,25,63,161, 1,216,80,73,209,76,132,187,208, 89,18,169,200,196,
    135,130,116,188,159,86,164,100,109,198,173,186, 3,64,52,217,226,250,124,123,
    5,202,38,147,118,126,255,82,85,212,207,206,59,227,47,16,58,17,182,189,28,42,
    223,183,170,213,119,248,152, 2,44,154,163, 70,221,153,101,155,167, 43,172,9,
    129,22,39,253, 19,98,108,110,79,113,224,232,178,185, 112,104,218,246,97,228,
    251,34,242,193,238,210,144,12,191,179,162,241, 81,51,145,235,249,14,239,107,
    49,192,214, 31,181,199,106,157,184, 84,204,176,115,121,50,45,127, 4,150,254,
    138,236,205,93,222,114,67,29,24,72,243,141,128,195,78,66,215,61,156,180
    };

}

这里是统一纹理代码：

using UnityEngine;
using System.Collections;
using System.Runtime.InteropServices.ComTypes;

// Create a texture and fill it with Perlin noise.
// Try varying the xOrg, yOrg and scale values in the inspector
// while in Play mode to see the effect they have on the noise.

public class TextureApply : MonoBehaviour
{
    // Width and height of the texture in pixels.
    public int pixWidth;
    public int pixHeight;

    // The origin of the sampled area in the plane.
    public float xOrg;
    public float yOrg;

    // The number of cycles of the basic noise pattern that are repeated
    // over the width and height of the texture.
    public float scale = 1.0F;

    private Texture2D noiseTex;
    private Color[] pix;
    private Renderer rend;

    void Start()
    {
        rend = GetComponent<Renderer>();

        // Set up the texture and a Color array to hold pixels during processing.
        noiseTex = new Texture2D(pixWidth, pixHeight);
        pix = new Color[noiseTex.width * noiseTex.height];
        rend.material.mainTexture = noiseTex;

        CalcNoise();
    }

    void CalcNoise()
    {
        // For each pixel in the texture...
        float y = 0.0F;

         while (y < noiseTex.height)
        {
            float x = 0.0F;
            while (x < noiseTex.width)
             {
                double xCoord = xOrg + x / noiseTex.width * scale;
                double yCoord = yOrg + y / noiseTex.height * scale;

                PerlinNoise perlin = new PerlinNoise();
                double sample = perlin.GetPixel(xCoord, yCoord);
            
                pix[(int)y * noiseTex.width + (int)x] = new Color((float)sample, (float)sample, (float)sample);
                x++;
            }
            y++;
        }

        // Copy the pixel data to the texture and load it into the GPU.
        noiseTex.SetPixels(pix);
        noiseTex.Apply();
    }

    void OnValidate()
    {
        CalcNoise();
    }
}

以上只是来自docs.unity3d.com的修改代码

我认为问题可能出在置换表上，我没有采取一些复杂的方法将值的数量加倍，而是复制并粘贴了它。

编辑： [这是我将其更改为 Simplex Noise 时得到的图片][1] [1]：https://i.stack.imgur.com/jfxNr.png

【问题讨论】：

标签： c# unity3d perlin-noise

【解决方案1】：

这是正在使用的渐变集。方向 (1, 1) 直接指向对角线邻居。如果这些对角线邻居有 (-1, -1)，那么它们会建设性地干扰。其他角对也是如此，以及当它们彼此指向负而不是正时。编辑：您可以尝试 +x + ROOT2*y, +ROOT2*x + y 及其所有符号排列，以产生 8 个渐变。

此外，即使您改进了梯度，您也可能听说 Perlin 是一种较旧的噪声方法，它会产生大量 45 度和 90 度偏差。我推荐它的情况并不多。如果您想将噪声作为编程练习来实现，那就太好了。但是，如果您想在项目中使用噪声，我会编写代码或导入一个好的 2D 单纯形实现。

编辑：见 cmets。我看错了图片。您需要的解决方案是仅sample = sample * 0.5 + 0.5 重新调整输出，以便图像中的负值不会全部被截断。

此外，如果您想将噪声转换为基本单纯形，您可以这样做：

定义常量double F2 = 0.366025403784439 和double G2 = -0.211324865405187。这些将在下面用于三角网格。
在GetPixel(double x, double y)的开头加上double s = (x + y) * F2;x += s; y += s;。这会将在方形网格上产生整数的坐标转换为在表示等边三角形的对角压缩方形网格上产生整数的坐标。
在定义xdec 和ydec 后，添加double t = (xdec + ydec) * G2; xdec += t; ydec += t;。这将使这些坐标相对于压缩正方形的底部不倾斜，以便它们现在可以再次用于距离和渐变。
定义双精度 xdec2 = xdec - 1 - G2; ydec2 = ydec - G2;。定义xdec3 = xdec - G2;ydec3 = ydec - 1 - G2;。定义xdec4 = xdec - 1 - 2*G2;ydec4 = ydec - 1 - 2*G2;。你需要这个，因为简单地减去 1 不再适用于获得其他四个角的相对坐标，因为这些角不再与正方形对齐。现在，每当您从 either 坐标中减去 1 时，您还需要从 both 中减去 G2。因此，对于 #2 和 #3，您从每个中减去 G2，对于 #4，您将其减去两次 (2*G2)。在计算定义 double t 的上一步之前，您可以通过查看如果您已经从一个或两个坐标中减去 1 会发生什么来重新推导这一点。
更改 d2、d3、d4 以改用这些值，例如 d2 = grad(g2, xdec2, ydec2);
删除以double u 开头并以return yInter; 结尾的所有内容。添加double value = 0;。您将向此值添加内容。
为 a3 和 a4 定义 double a1 = 0.5 - xdec*xdec - ydec*ydec; double a2 = 0.5 - xdec2*xdec2 - ydec2*ydec2; 和相同的模式。这些函数表示围绕每个三角形顶点的圆圈，这些圆圈在三角形边缘处停止。
添加if (a1 > 0) value += (a1 * a1) * (a1 * a1) * d1;，同样为a2、a3、a4。这些根据梯度和距离为每个圆圈内的噪声添加一个值。
如果您使用我为 Perlin 建议的改进渐变，请添加 return value * 38.283687591552734375;。如果您使用原始值，我认为乘以的正确值是75.3929901123046875，但我不确定。不过，这将是接近的东西。确实，您可能想要更多的单纯形渐变，但至少 8 应该使它看起来比 Perlin 更好。

如果没有改进的渐变，噪点看起来不会很好。你仍然会看到很多 45 度偏差。如果你想真正改善噪音，这是我的建议，有 24 个渐变。你可以找到这些渐变here。使用99.83685446303647 作为最后乘以的值。

    private static double grad(int hash, double x, double y)
    {
        switch (hash % 24)
        {
            case 0:  return 0.130526192220052 * x +   0.99144486137381 * y;
            case 1:  return 0.38268343236509 * x +    0.923879532511287 * y;
            case 2:  return 0.608761429008721 * x +   0.793353340291235 * y;
            case 3:  return 0.793353340291235 * x +   0.608761429008721 * y;
            case 4:  return 0.923879532511287 * x +   0.38268343236509 * y;
            case 5:  return 0.99144486137381 * x +    0.130526192220051 * y;
            case 6:  return 0.99144486137381 * x +   -0.130526192220051 * y;
            case 7:  return 0.923879532511287 * x +  -0.38268343236509 * y;
            case 8:  return 0.793353340291235 * x +  -0.60876142900872 * y;
            case 9:  return 0.608761429008721 * x +  -0.793353340291235 * y;
            case 10: return 0.38268343236509 * x +   -0.923879532511287 * y;
            case 11: return 0.130526192220052 * x +  -0.99144486137381 * y;
            case 12: return -0.130526192220052 * x + -0.99144486137381 * y;
            case 13: return -0.38268343236509 * x +  -0.923879532511287 * y;
            case 14: return -0.608761429008721 * x + -0.793353340291235 * y;
            case 15: return -0.793353340291235 * x + -0.608761429008721 * y;
            case 16: return -0.923879532511287 * x + -0.38268343236509 * y;
            case 17: return -0.99144486137381 * x +  -0.130526192220052 * y;
            case 18: return -0.99144486137381 * x +   0.130526192220051 * y;
            case 19: return -0.923879532511287 * x +  0.38268343236509 * y;
            case 20: return -0.793353340291235 * x +  0.608761429008721 * y;
            case 21: return -0.608761429008721 * x +  0.793353340291235 * y;
            case 22: return -0.38268343236509 * x +   0.923879532511287 * y;
            case 23: return -0.130526192220052 * x +  0.99144486137381 * y;
            default: return 0;
       }
   }

可选优化：一次只需要 a2/g2/xdec2/ydec2、a3/g3/xdec3/ydec3 之一。如果 ydec > xdec 则可以执行 a3/g3/xdec3/ydec3，否则执行 a2/g2/xdec2/ydec2。几乎每个教程和实现都会有这个，但你不需要它来制造噪音。

可选优化 #2：在第 8 步中，您可以拉入 d1 的定义，并在其中拉入 g1 的定义。这样，只有在条件内需要定义时才会计算定义（如果编译器还没有捕捉到它）。 if (a1 > 0) value += (a1 * a1) * (a1 * a1) * grad(p[p[xint] + yint], xdec, ydec); 然后您可以将它们从最初计算的位置删除。

注意：一些教程或实现将使用正 G2，并翻转它的加法/减法。我发现将其保持为负值最有意义，因为这样 unskew 变换的工作原理与 skew 变换完全相同。但值得牢记。

【讨论】：

你能告诉我我需要在哪里进行更改吗，我刚刚开始学习这些东西。还要感谢您让我了解单纯形噪声（这将很有用，因为它是一个学校项目并且有更多选择是好的），但现在我只是在尝试。
IMO 如果一所学校教授 Perlin 噪音，至少在没有强调更好的替代方案的情况下，这是有问题的。尽管如此，在你的 grad 语句中，将 hash & 3 更改为 hash & 7 因为你现在有 8 个梯度。 case 0: return + x + ROOT2*y;case 1: return + ROOT2 * x + y; 并为其余的符号排列 +-、-+ 和 -- 定义案例 2-7 然后定义一个常量浮点 ROOT2=1.4142135623730951f；这是2的平方根。这些梯度方向形成一个完美的八边形，需要2的平方根。
另外，如果您愿意，您可以将输出乘以 0.579106986522674560546875f。不久前我写了一个程序来找到这个。它将使输出范围正好 -1 到 1。
另外我刚刚重新阅读了您的帖子。我把想要的照片和你得到的照片混淆了。我的错。您唯一的问题是输出范围是负数和正数（以零为中心），而您渲染它的方式只能处理正数。解决您的问题的方法是使用 sample = sample * 0.5 + 0.5; 将 -1 到 1 的范围重新调整为 0 到 1 的范围。我发送的关于渐变的内容只是进一步改进。
如果您不需要自己对噪声进行编码，您可以导入Unity.Mathematics 并将Unity.Mathematics.noise.snoise(float2) 用于2D 单纯形。