Java柏林噪声实现问题

嘿，社区！在过去的两周里，我一直在阅读有关柏林噪声的文章，并尝试以最基本的方式自己实现它。即便如此，我的程序还是不起作用。它始终输出相似的结果，持久性似乎没有改变任何东西。这是我的密码：

import java.awt.Color;
import java.awt.Graphics;
import java.util.Random;
import javax.swing.JFrame;
import javax.swing.JPanel;

@SuppressWarnings("serial")
public class Noise extends JPanel{

public static int octaves = 4;
public static int size =  128;
public static float[][][] noise = new float[size][size][octaves];
public static float[][] perlinnoise = new float[size][size];

public static float p = (float) 1/4;

public static Random gen = new Random();

public static float GenerateNoise() {
    return gen.nextFloat();
}

public static float SmoothNoise(int x, int y, int z) {
    try{
        float corners = (noise[x - 1][y - 1][z] + noise[x + 1][y - 1][z] + noise[x - 1][y + 1][z] + noise[x + 1][y + 1][z]) / 16;
        float sides = (noise[x - 1][y][z] + noise[x + 1][y][z] + noise[x][y - 1][z] + noise[x][y + 1][z]) / 8;
        float center = noise[x][y][z] / 4;
        return corners + sides + center;
    }catch(Exception e) {
        return 0;
    }
}

public static float InterpolatedNoise(float x, float y, int pX, int pY, int pZ) {
    int intX = (int) x;
    int intY = (int) y;
    float fracX = x - intX;
    float fracY = y - intY;
    float v1 = SmoothNoise(pX, pY, pZ);
    float v2 = SmoothNoise(pX + 1, pY, pZ);
    float v3 = SmoothNoise(pX, pY + 1, pZ);
    float v4 = SmoothNoise(pX + 1, pY + 1, pZ);
    float i1 = Interpolate(v1, v2, fracX);
    float i2 = Interpolate(v3, v4, fracX);
    return Interpolate(i1, i2, fracY);
}

public static float Interpolate(float a, float b, float x) {
    float ft = (float) (x * 3.1415927);
    float f = (float) ((1 - Math.cos(ft)) * 0.5);
    return (float) (a * (1 - f) + b * f);
}

public static float Perlin2D(float x, float y, int posX, int posY, int posZ) {
    float total = 0;
    for(int i = 0; i < octaves; i++) {
        double f = Math.pow(2, i);
        double a = Math.pow(p, i);
        total = (float) (total + InterpolatedNoise((float)(x * f), (float)(y * f), posX, posY, posZ) * a);
    }
    return total;
}

public static void main(String [] args) {
    for(int z = 0; z < octaves; z++) {
        for(int y = 0; y < size; y++) {
            for(int x = 0; x < size; x++) {
                noise[x][y][z] = GenerateNoise();
            }
        }
    }
    
    for(int z = 0; z < octaves; z++) {
        for(int y = 0; y < size; y++) {
            for(int x = 0; x < size; x++) {
                perlinnoise[x][y] = Perlin2D(x / (size - 1), y / (size - 1), x, y, z) / octaves;
            }
        }
    }
    
    JFrame f = new JFrame("Perlin Noise");
    f.setSize(400, 400);
    f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    f.add(new Noise());
    f.setVisible(true);
}

public void paintComponent(Graphics g) {
    super.paintComponent(g);
    for(int y = 0; y < size; y++) {
        for(int x = 0; x < size; x++) {
            g.setColor(new Color(perlinnoise[x][y], perlinnoise[x][y], perlinnoise[x][y]));
            g.fillRect(x * 2, y * 2, 2, 2);
        }
    }
    repaint();
}
}

导入java.awt.Color；
导入java.awt.Graphics；
导入java.util.Random；
导入javax.swing.JFrame；
导入javax.swing.JPanel；
@抑制警告（“串行”）
公共级噪声扩展JPanel{
公共静态整数倍频程=4；
公共静态int size=128；
公共静态浮点[][]噪声=新浮点[大小][大小][倍频程]；
公共静态浮点数[][]perlinnoise=新浮点数[大小][大小]；
公共静态浮动p=（浮动）1/4；
public static Random gen=new Random（）；
公共静态浮点数生成器（可选）{
返回gen.nextFloat（）；
}
公共静态浮点平滑噪声（整数x、整数y、整数z）{
试一试{
浮动角=（噪声[x-1][y-1][z]+噪声[x+1][y-1][z]+噪声[x-1][y+1][z]+噪声[x+1][y+1][z]）/16；
浮动边=（噪声[x-1][y][z]+噪声[x+1][y][z]+噪声[x][y-1][z]+噪声[x][y+1][z]）/8；
浮动中心=噪声[x][y][z]/4；
返回角+边+中心；
}捕获（例外e）{
返回0；
}
}
公共静态浮点插值噪声（浮点x、浮点y、整数pX、整数pY、整数pZ）{
intX=（int）x；
int intY=（int）y；
浮动分形x=x-intX；
浮动分形=y-intY；
浮点v1=平滑噪声（pX，pY，pZ）；
浮点v2=平滑噪声（pX+1，pY，pZ）；
浮点v3=平滑噪声（pX，pY+1，pZ）；
浮点v4=平滑噪声（pX+1，pY+1，pZ）；
浮点i1=插值（v1，v2，分形）；
浮点i2=插值（v3，v4，fracX）；
返回插值（i1，i2，分形）；
}
公共静态浮点插值（浮点a、浮点b、浮点x）{
浮动英尺=（浮动）（x*3.1415927）；
浮点数f=（浮点数）（（1-数学cos（ft））*0.5）；
回报（浮动）（a*（1-f）+b*f）；
}
公共静态浮点Perlin2D（浮点x，浮点y，整数posX，整数posY，整数posZ）{
浮动总数=0；
对于（int i=0；i<八度；i++）{
双f=数学功率（2，i）；
双a=数学功率（p，i）；
总计=（浮点）（总计+插值噪声（（浮点）（x*f），（浮点）（y*f），posX，posY，posZ）*a）；
}
返回总数；
}
公共静态void main（字符串[]args）{
对于（int z=0；z<八度；z++）{
对于（int y=0；y

我不明白为什么它不起作用，因为它和文章中的伪代码完全一样。有人能帮我弄清楚这件事吗？谢谢

---

编辑：好的，请有人解释一下做这件事所需的过程，好吗？我想弄清楚这件事，快发疯了。在过去的两周里，我一直在努力解决这个问题，但没有人给我任何帮助。如果你知道怎么做，请给我解释一下，我会非常感激的。谢谢。

上有一个Java实现，您不需要自己实现。我想自己实现：）您应该在调试器中逐步完成您的实现和参考实现，为了发现行为发散的地方。好吧，我试过了，但我的问题包括插值和平滑的地方，但我不知道如何正确进行，因为我不理解这一部分的过程，并且多次询问。我注意到Ken的代码有3d噪音。如果你想要一些2d噪音呢？他是否为不太复杂的2d噪波提供（某处）代码，而不是使用相同的z值调用3d噪波？