Python 3.x 柏林噪声理解

我找到了两个教程来解释柏林噪声是如何工作的，但在第一个教程中，我发现了不可理解的梯度之谜，在第二个教程中，我发现了冲浪之谜

第一例

第一个教程位于此处。首先，autor解释了值噪波，这是完全可以理解的，因为我们需要做的只是绘制一个随机颜色的网格，然后在颜色之间进行插值

但是说到柏林噪声，我们必须处理渐变，而不是单色。首先我认为梯度是颜色，所以如果我们有两个梯度，我们想在它们之间进行插值，我们必须取第一个梯度的一个点，然后用第二个梯度的相应点进行插值。但是如果梯度是相同的，我们会得到与梯度相同的结果

在本教程中，作者以另一种方式进行了说明。如果我们有一个由相同渐变填充的列组成的一维网格，每个渐变可以表示为从0到1的过渡（这里0是黑色，1是白色）。然后作者说

现在每个条纹都有相同的渐变，只是它们是偏移的 从一个到另一个。所以对于每一个t0，它右边的梯度是 t1=t0-1。让我们平滑地插值它们

这意味着我们必须在梯度和梯度之间插值，梯度表示为从0到1的过渡，梯度表示为从-1到0的过渡

这意味着每个渐变不会从值为0的位置开始，也不会在值为1的位置停止。它从-1开始，在2结束，或者它没有起点和终点。我们只能看到0到1的范围，我不明白为什么会这样。我们从哪里得到了连续梯度的概念？我以为每个条带只有从0到1的梯度，就这些，不是吗

当我问作者这一切时，他回答说这是显而易见的

右边的渐变是一个视觉参照。这是一个梯度 下一个更高的整数。你是对的，它会变成负数 左边他们都有

t0是在左边晶格点处为零的梯度 两个整数之间区域的边。t1是梯度 在同一区域右侧的晶格点处为零。 梯度噪声是通过在这两者之间插值得到的 晶格点之间的渐变。是的，这可以产生 负面结果，结果为黑色。这就是为什么下一步是 缩放并偏移结果

现在我觉得这对我来说是不可能理解的，所以我必须相信，然后跟着更聪明的人重复。但希望终将消逝，所以我请求你以某种方式向我解释它

第二种情况

第二个教程就在这里，它远没有前一个复杂。 我遇到的唯一问题是，我无法理解下一段以及接下来的内容

因此，我们可以只关注G的方向，并始终使用 单位长度向量。如果我们钳制衰减内核的乘积 在2×2平方之外的所有点上，梯度为0，这给了我们 在那句晦涩的句子中提到的冲浪板

我不确定问题是否出在我糟糕的数学或英语知识上，所以我请你用简单的话解释一下这到底意味着什么

这是我到目前为止写的一些代码，它与第二个案例有关

import sys
import random
import math
from PyQt4.QtGui import *
from PyQt4.QtCore import pyqtSlot

class Example(QWidget):

    def __init__(self):
        super(Example, self).__init__()
        self.gx=1
        self.gy=0
        self.lbl=QLabel()
        self.tlb = None
        self.image = QImage(512, 512, QImage.Format_RGB32)
        self.hbox = QHBoxLayout()
        self.pixmap = QPixmap()
        self.length = 1
        self.initUI()

    def mousePressEvent(self, QMouseEvent):
        px = QMouseEvent.pos().x()
        py = QMouseEvent.pos().y()

        size = self.frameSize()

        self.gx = px-size.width()/2
        self.gy = py-size.height()/2

        h = (self.gx**2+self.gy**2)**0.5

        self.gx/=h
        self.gy/=h

        self.fillImage()

    def wheelEvent(self,event):
        self.length+=(event.delta()*0.001)
        print(self.length)


    def initUI(self):    
        self.hbox = QHBoxLayout(self)
        self.pixmap = QPixmap()
        self.move(300, 200)
        self.setWindowTitle('Red Rock')

        self.addedWidget = None

        self.fillImage()

        self.setLayout(self.hbox)

        self.show()  

    def fillImage(self):

        step = 128
        for x in range(0, 512, step):
            for y in range(0, 512, step):

                rn = random.randrange(0, 360)
                self.gx = math.cos(math.radians(rn))
                self.gy = math.sin(math.radians(rn))

                for x1 in range(0, step):

                    t = -1+(x1/step)*2
                    color =  (1 - (3 - 2*abs(t))*t**2) 

                    for y1 in range(0, step):

                        t1 = -1+(y1/step)*2
                        color1 = (1 - (3 - 2*abs(t1))*t1**2)
                        result = (255/2)+(color * color1 * (t*self.gx+t1*self.gy) )*(255/2)
                        self.image.setPixel(x+x1, y+y1, qRgb(result, result, result))


        self.pixmap = self.pixmap.fromImage(self.image)

        if self.lbl == None:
            self.lbl = QLabel(self)
        else:
            self.lbl.setPixmap(self.pixmap)

        if self.addedWidget == None:
            self.hbox.addWidget(self.lbl)
            self.addedWidget = True

        self.repaint()
        self.update()


def main():

    app = QApplication(sys.argv)
    ex = Example()
    sys.exit(app.exec_())


if __name__ == '__main__':
    main()    

float Noise:：perlin1D（glm:：vec3点，浮点频率）
{
//将点映射到频率空间
点*=频率；
//获取点所在的基整数
int i0=静态施法（地板（点x））；
//从左整数到点的距离
浮点数t0=点x-静态_铸造（i0）；
//从右整数到点的距离
浮点数t1=t0-1.f；
//确保基整数在哈希函数的范围内
i0&=hashMask；
//获取正确的整数（已在哈希函数的范围内）
int i1=i0+1；
//为左整数和右整数选择伪随机渐变
float g0=gradients1D[hash[i0]&gradientsMask1D]；
float g1=gradients1D[hash[i1]&gradientsMask1D]；
//取梯度和距离之间的点积
//获取影响值。（渐变越靠近点影响越大）
浮子v0=g0*t0；
浮点数v1=g1*t1；
//将该点映射到具有0的一阶导数和二阶导数的平滑曲线
浮动t=平滑（t0）；
//沿平滑曲线插值我们的影响值
返回glm：：混合物（v0，v1，t）*2.f；
}

下面是有问题的代码的注释版本。但改写C++。很明显，所有的功劳都归他所有

我们给了函数一个点p。假设点p是分数的，例如，如果p是.25，那么p左边的整数是0，p右边的整数是1。让我们分别称这些整数为l和r

t0是从l到p的距离，t1是从r到p的距离。t1的距离为负，因为从r到p必须朝负方向移动

如果我们继续讨论perlin噪声部分，那么g0和g1是一维的伪随机梯度。再一次，梯度在这里可能会混淆，因为g0和g1是浮点数，但梯度只是一个方向，在一维中只能为正或负，所以这些梯度是+1和-1。我们取梯度和距离之间的点积，但在一维中这只是乘法。点积的结果是两个浮点数v0和v1。这些是柏林噪声实施的影响值。最后，我们平滑地在

float Noise::perlin1D(glm::vec3 point, float frequency)
{
    // map the point to the frequency space
    point *= frequency;

    // get the base integer the point exists on
    int i0 = static_cast<int>(floorf(point.x));

    // distance from the left integer to the point
    float t0 = point.x - static_cast<float>(i0);

    // distance from the right integer to the point
    float t1 = t0 - 1.f;

    // make sure the base integer is in the range of the hash function
    i0 &= hashMask;

    // get the right integer (already in range of the hash function)
    int i1 = i0 + 1;

    // choose a pseudorandom gradient for the left and the right integers
    float g0 = gradients1D[hash[i0] & gradientsMask1D];
    float g1 = gradients1D[hash[i1] & gradientsMask1D];

    // take the dot product between our gradients and our distances to
    // get the influence values. (gradients are more influential the closer they are to the point)
    float v0 = g0 * t0;
    float v1 = g1 * t1;

    // map the point to a smooth curve with first and second derivatives of 0
    float t = smooth(t0);

    // interpolate our influence values along the smooth curve 
    return glm::mix(v0, v1, t) * 2.f;
}