C++ 柏林噪声，块状，c++；

好的，首先，我正在尝试实现柏林噪声算法，我成功地实现了一些奇怪的东西，但我找不到解决方案。我正在使用matlab可视化我已经检查过的结果，这个问题：

我在这个网站上做这件事：

另一个网站，我现在找不到，但我会尽快更新

下面是一些关于这个问题的图片：

如果增加缩放，这就是问题所在

以下是.cpp-s：

//perlin.cpp
     #include "Perlin_H.h"
    #include <stdlib.h>
    #include <math.h>
    #include <iostream>
    #include <random>
    using namespace std;

double Perlin::interp1(double a, double b, double x) {

    double ft = x * 3.1415927;
    double f = (1.0-cos(ft)) * 0.5;
    //return (b-x > b-1/2) ? b-x : a+x;
    return a * (1.0-f) + b * f;
}

double Perlin::smoothNoise(double x,double y) {
    double corners =  ( rand2(x-1, y-1)+rand2(x+1, y-1)+rand2(x-1, y+1)+rand2(x+1, y+1) ) / 16;
    double sides = ( rand2(x-1, y)  +rand2(x+1, y)  +rand2(x, y-1)  +rand2(x, y+1) ) /  8;
    double center = rand2(x,y)/4;

    return corners + sides +center;
}



double Perlin::lininterp1(double a,double b, double x) {
    return a*(1-x) + b * x;
}
double Perlin::rand2(double x, double y) {

    int n = (int)x + (int)y*57;
    //n=pow((n<<13),n);
    n=(n<<13)^n;
    return ( 1.0 - ( (n * (n * n * 15731 + 789221) + 1376312589) & 0x7fffffff) / 1073741824.0);

}

double Perlin::noise(double x, double y) {
    double floorX = (double)floor(x);
    double floorY = (double)floor(y);

    double s,t,u,v;

    s = smoothNoise(floorX,floorY);
    t = smoothNoise(floorX+1,floorY);
    u = smoothNoise(floorY,floorY+1);
    v = smoothNoise(floorX+1,floorY+1);

    double int1 = interp1(s,t,x-floorX);
    double int2 = interp1(u,v,x-floorX);

    return interp1(int1,int2,y-floorY);
}

//perlin.cpp
#包括“Perlin_H.H”
#包括
#包括
#包括
#包括
使用名称空间std；
双柏林：：interp1（双a、双b、双x）{
双英尺=x*3.1415927；
双f=（1.0-cos（ft））*0.5；
//返回（b-x>b-1/2）？b-x:a+x；
返回a*（1.0-f）+b*f；
}
双柏林：：平滑噪波（双x，双y）{
双角=（rand2（x-1，y-1）+rand2（x+1，y-1）+rand2（x-1，y+1）+rand2（x+1，y+1））/16；
双面=（rand2（x-1，y）+rand2（x+1，y）+rand2（x，y-1）+rand2（x，y+1））/8；
双中心=rand2（x，y）/4；
返回角+边+中心；
}
双层柏林：内衬层P1（双层a、双层b、双层x）{
返回a*（1-x）+b*x；
}
双柏林：rand2（双x，双y）{
int n=（int）x+（int）y*57；
//n=pow（（n发现您的实现中没有数学错误，我怀疑这是一个数字格式问题

当从不同侧面获取的网格点值实际上不相同时，即
rand2（楼层（n）+1，y）！=rand2（楼层（n+1），y）

若要修复它，请将floorX声明为
int
或
long
，并将其传递给smoothNoise（）和rand2（）

这可能是由于整数值
floorX
，
floorX+1
的表示中存在浮点错误造成的。ulp或更小量级的ε可以有符号。加法的结果[floor（n）+1]和floor直接[floor（n+1）]由不同的代码绑定，因此无需共享选择哪一侧出错的模式。当结果在不同的一侧出错时，int类型强制转换将0.999999999和0.0000000001等分，将数学上等价的数字视为不同的。
这是一个打字错误

尝试：
u=平滑噪声（地板，地板+1）

这解释了为什么对角线没有块状外观（其中x=y），以及为什么许多常见的特征形状以镜像和倾斜的方式微妙地偏离。
由于rand2（楼层（y），楼层（y）+1）！=rand2（楼层（x），楼层（y+1））通常是显而易见的，因此将导致单元不连续性。
只是一个建议，但查看Simplex Noise以获得柏林噪音的改进版本。不幸的是，它似乎不起作用，或者可能我又做错了什么。我更改了
double floorX=（double）地板（x）；
改为
int floorX=floor（x）；
没有变化，然后我也把这个改为
floorY
，仍然没有结果，然后我把
s=smoothNoise（floorX+1，floorY）；等等。
改为
s=smoothNoise（floor（x+1），floorY）
以及以上两者的组合都不起作用。也许随机生成器也有问题。
双柏林：：rand2（int x，int y）
实现了伪随机散列函数的角色。它可能是其他的。噢，非常感谢！这是不使用ctrl+c ctrl+v:D的完美示例
#include "Perlin_H.h"
#include <stdlib.h>
#include <math.h>
#include <iostream>
#include <fstream>;
using namespace std;
int main() {
    const int h=64,w=64,octaves=2;
    double p=1/1;
    double zoom = 30;
    Perlin perlin;

    double map[h][w];
    ofstream output;
    output.open("map.txt");
    for(int i = 0; i < h ; i++) {   
        for(int j = 0; j < w ; j++) {
            map[i][j] = 0;
        }
    }
    double freq = 2;




    for(int i = 0; i < h ; i++) {


        for(int j = 0; j < w ; j++) {

            double getnoise = 0;
            for(int a=0; a < octaves; a++) {


                double freq = pow(2,a);

                double amp = pow(p,a);
                getnoise = perlin.noise((((double)i)*freq)/zoom-(a*10),
                    ((((double)j))*freq)/zoom+(a*10))*amp;
                int color = (int)((getnoise * 128.0) + 128.0);
                if(color > 255) color = 255;
                if(color < 0) color = 0;

                map[i][j] = color;


            }
        output  << map[i][j] << "\t";
        }
        output << "\n";

    }


    output.close();



    system("PAUSE");
    return 0;
}

s = smoothNoise(floorX,floorY);
t = smoothNoise(floorX+1,floorY);
u = smoothNoise(floorY,floorY+1);
v = smoothNoise(floorX+1,floorY+1);