Java 柏林噪声不会随着八度音阶的增加而增加深度

我是柏林噪音的新手，遇到了障碍。我从C++翻译的PrLin噪声函数似乎对一个八度音阶正确地工作，但是我发现低音阶的噪声不会增加到原始的柏林噪声。这是我的密码：

public class Perlin {
    float[][] generateWhiteNoise(int width, int height) {
        Random random = new Random(0);
        float[][] noise = new float[width][height];

        for (int i = 0; i < noise.length; i++) {
            for (int j = 0; j < noise[i].length; j++){
                noise[i][j] = (float)random.nextDouble();
            }
        }

        return noise;
    }

    float[][] generateSmoothNoise(float[][] baseNoise, int octave){
        int width = baseNoise.length;
        int height = baseNoise[0].length;

        float[][] smoothNoise = baseNoise;

        int samplePeriod = (int) Math.pow(2,octave); // calculates 2 ^ k
        float sampleFrequency = 1.0f / samplePeriod;

        for (int i = 0; i < width; i++) {
          //calculate the horizontal sampling indices
          int sample_i0 = (i / samplePeriod) * samplePeriod;
          int sample_i1 = (sample_i0 + samplePeriod) % width; //wrap around
          float horizontal_blend = (i - sample_i0) * sampleFrequency;
          for (int j = 0; j < height; j++){
             //calculate the vertical sampling indices
             int sample_j0 = (j / samplePeriod) * samplePeriod;
             int sample_j1 = (sample_j0 + samplePeriod) % height; //wrap around
             float vertical_blend = (j - sample_j0) * sampleFrequency;
             //blend the top two corners
             float top = interpolate(baseNoise[sample_i0][sample_j0],
                baseNoise[sample_i1][sample_j0], horizontal_blend);

             //blend the bottom two corners
             float bottom = interpolate(baseNoise[sample_i0][sample_j1],
                baseNoise[sample_i1][sample_j1], horizontal_blend);

             //final blend
             smoothNoise[i][j] = interpolate(top, bottom, vertical_blend);
          }
       }

       return smoothNoise;
    }

    float interpolate(float x0, float x1, float alpha){
        return (float) ((float)(x0) * (float)(1 - alpha) + (float)(alpha * x1));
    }

    float[][] generatePerlinNoise(float[][] baseNoise, int octaveCount) {
       int width = baseNoise.length;
       int height = baseNoise[0].length;

       float[][][] smoothNoise = new float[octaveCount][][]; //an array of 2D arrays containing

       float persistance = .5f;

       //generate smooth noise
       for (int i = 0; i<octaveCount; i++) {
           System.out.println("Generating Smooth Noise: " + i);
           smoothNoise[i] = generateSmoothNoise(baseNoise, i);
       }

        float[][] perlinNoise = new float[width][height];
        float amplitude = 1.0f;
        float totalAmplitude = 0.0f;

        //blend noise together
        for (int octave = octaveCount - 1; octave >= 0; octave--) {
           amplitude *= persistance;
           totalAmplitude += amplitude;
           System.out.println("Adding smooth noise for octave: " + octave + " at amplitude: " + amplitude);
           for (int i = 0; i < width; i++) {
              for (int j = 0; j < height; j++) {
                 perlinNoise[i][j] += smoothNoise[octave][i][j] * amplitude;
              }
           }
        }

       //normalization
       for (int i = 0; i < width; i++) {
          for (int j = 0; j < height; j++) {
             perlinNoise[i][j] /= totalAmplitude;
          }
       }
       return perlinNoise;
    }

    public float[][] printVals(float[][] baseNoise){
        baseNoise = generatePerlinNoise(generateWhiteNoise(800,800),6);
        for(int i = 0; i<baseNoise.length; i++){
            String row = "";
            for(int j = 0; j<baseNoise[i].length;j++){
                row+= (int)(baseNoise[i][j]*255) + " ";
            }
            System.out.println(row);
        }
        return baseNoise;
    }
}

以下是倍频程1、2、3和4的输出

任何帮助都将不胜感激

编辑：

---

通过反复试验，我发现最有可能出现问题的地方是

generatePerInnoise（）

函数。如果我改变八度音阶，我会得到想要的噪声级，这就是我想要的。这也意味着

generateWhiteNoise（）

和

generateSmoothNoise（）

可以工作。因此，在

generatePerInnoise（）

混合中的某个地方存在一个问题，但它似乎应该可以工作。

我找到了一个答案。我原以为

generateSmoothNoise（）

命令会给我多倍频程柏林噪声。然而，我意识到我需要构建另一个类似于平滑噪声混合的命令来混合柏林噪声的不同八度

public float[][] generateMultiOctavePerlinNoise(int octaves, double persistence, double dropoff, int width, int height){
        float[][][]noise = new float[octaves][width][height];
        for(int i = octaves - 1; i > 0;i--){
            noise[i] = generatePerlinNoise(generateWhiteNoise(width,height),octaves - i);
        }

        float[][] multiOctave = new float[width][height];

        for(int a= 0; a<noise.length; a++){
            persistence*= dropoff;
            for(int i = 0; i<multiOctave.length; i++){
                for(int j = 0; j<multiOctave[i].length; j++){
                    multiOctave[i][j] += noise[a][i][j]*persistence;
                }
            }
        }
        return multiOctave;

    }

public float[]generateMultiOctavePerlinNoise（整数倍频程、双持续、双衰减、整数宽度、整数高度）{
浮点[][]噪声=新浮点[倍频程][宽度][高度]；
对于（int i=八度音阶-1；i>0；i--）{
噪声[i]=发电机的白噪声（宽度、高度），倍频程-i）；
}
浮动[]多倍频程=新浮动[宽度][高度]；
对于（int a=0；a
public float[][] generateMultiOctavePerlinNoise(int octaves, double persistence, double dropoff, int width, int height){
        float[][][]noise = new float[octaves][width][height];
        for(int i = octaves - 1; i > 0;i--){
            noise[i] = generatePerlinNoise(generateWhiteNoise(width,height),octaves - i);
        }

        float[][] multiOctave = new float[width][height];

        for(int a= 0; a<noise.length; a++){
            persistence*= dropoff;
            for(int i = 0; i<multiOctave.length; i++){
                for(int j = 0; j<multiOctave[i].length; j++){
                    multiOctave[i][j] += noise[a][i][j]*persistence;
                }
            }
        }
        return multiOctave;

    }