Esempio n. 1
0
 public bool IsEqualTo(NoiseParams ns)
 {
     return(Seed == ns.Seed &&
            Octaves == ns.Octaves &&
            Lacunarity == ns.Lacunarity &&
            Persistence == ns.Persistence &&
            InitialAmplitude == ns.InitialAmplitude &&
            InitialFrequency == ns.InitialFrequency &&
            NoiseSize == ns.NoiseSize &&
            Offset == ns.Offset &&
            UseKernel == ns.UseKernel);
 }
Esempio n. 2
0
 public void Set(NoiseParams ns)
 {
     Seed             = ns.Seed;
     Octaves          = ns.Octaves;
     Lacunarity       = ns.Lacunarity;
     Persistence      = ns.Persistence;
     InitialAmplitude = ns.InitialAmplitude;
     InitialFrequency = ns.InitialFrequency;
     NoiseSize        = ns.NoiseSize;
     Offset           = ns.Offset;
     UseKernel        = ns.UseKernel;
 }
Esempio n. 3
0
        private static float[,] CreateNoise2D(NoiseParams noiseSettings)
        {
            var noise = new OpenSimplexNoise(noiseSettings.Seed);
            var data  = new float[noiseSettings.NoiseSize, noiseSettings.NoiseSize];

            for (var y = 0; y < data.GetLength(1); y++)
            {
                for (var x = 0; x < data.GetLength(0); x++)
                {
                    var amplitude      = noiseSettings.InitialAmplitude;
                    var frequency      = noiseSettings.InitialFrequency;
                    var totalAmplitude = 0f;
                    var total          = 0f;
                    var xEval          = x + noiseSettings.Offset.X;
                    var yEval          = y + noiseSettings.Offset.Y;

                    for (var o = 1; o < noiseSettings.Octaves + 1; o++)
                    {
                        var noisev = (float)noise.Evaluate(xEval * frequency, yEval * frequency);

                        // [[-1, 1] -> [0, 1]
                        noisev  = (noisev + 1) / 2;
                        noisev *= amplitude;
                        total  += noisev;

                        totalAmplitude += amplitude;
                        amplitude      *= noiseSettings.Persistence;
                        frequency      *= noiseSettings.Lacunarity;
                    }

                    // normalise
                    total /= totalAmplitude;

                    data[x, y] = total;
                }
            }

            var dd = NormaliseNoise2D(data);

            if (noiseSettings.UseKernel)
            {
                var identityKernel = new float[, ] {
                    { 1f }
                };
                var smoothingKernel = new float[, ]
                {
                    { 1f, 1f, 1f },
                    { 1f, 1f, 1f },
                    { 1f, 1f, 1f },
                };

                var sharpenKernel = new float[, ]
                {
                    { 0f, -1f, 0f },
                    { -1f, 5f, -1f },
                    { 0f, -1f, 0f },
                };

                var outlineKernel = new float[, ]
                {
                    { -1f, -1f, -1f },
                    { -1f, 8f, -1f },
                    { -1f, -1f, -1f },
                };

                var topSobel = new float[, ]
                {
                    { 1f, 2f, 1f },
                    { 0f, 0f, 0f },
                    { -1f, -2f, -1f },
                };
                dd = ApplyKernel(dd, topSobel);
            }


            var erosion = new Erosion();
            var dmap    = To1D(dd);

            //erosion.Erode(dmap, 256, 10, false);
            dd = To2D(dmap);

            var res = AddBorder(dd);

            return(res);
        }