Merge pull request TheAlgorithms#265 from Kromzem/master

Perlin-Noise-Algorithm added

Author: Christian Bender

Others/PerlinNoise.java

@@ -0,0 +1,164 @@
+import java.util.Random;
+import java.util.Scanner;
+
+/**
+ * For detailed info and implementation see: <a href="http://devmag.org.za/2009/04/25/perlin-noise/">Perlin-Noise</a>
+ */
+public class PerlinNoise {
+    /**
+     * @param width width of noise array
+     * @param height height of noise array
+     * @param octaveCount numbers of layers used for blending noise
+     * @param persistence value of impact each layer get while blending
+     * @param seed used for randomizer
+     * @return float array containing calculated "Perlin-Noise" values
+     */
+    static float[][] generatePerlinNoise(int width, int height, int octaveCount, float persistence, long seed) {
+        final float[][] base = new float[width][height];
+        final float[][] perlinNoise = new float[width][height];
+        final float[][][] noiseLayers = new float[octaveCount][][];
+
+        Random random = new Random(seed);
+        //fill base array with random values as base for noise
+        for(int x = 0; x < width; x++) {
+            for(int y = 0; y < height; y++) {
+                base[x][y] = random.nextFloat();
+            }
+        }
+
+        //calculate octaves with different roughness
+        for(int octave = 0; octave < octaveCount; octave++) {
+            noiseLayers[octave] = generatePerlinNoiseLayer(base, width, height, octave);
+        }
+
+        float amplitude = 1f;
+        float totalAmplitude = 0f;
+
+        //calculate perlin noise by blending each layer together with specific persistence
+        for(int octave = octaveCount - 1; octave >= 0; octave--) {
+            amplitude *= persistence;
+            totalAmplitude += amplitude;
+
+            for(int x = 0; x < width; x++) {
+                for(int y = 0; y < height; y++) {
+                    //adding each value of the noise layer to the noise
+                    //by increasing amplitude the rougher noises will have more impact
+                    perlinNoise[x][y] += noiseLayers[octave][x][y] * amplitude;
+                }
+            }
+        }
+
+        //normalize values so that they stay between 0..1
+        for(int x = 0; x < width; x++) {
+            for (int y = 0; y < height; y++) {
+                perlinNoise[x][y] /= totalAmplitude;
+            }
+        }
+
+        return perlinNoise;
+    }
+
+    /**
+     * @param base base random float array
+     * @param width width of noise array
+     * @param height height of noise array
+     * @param octave current layer
+     * @return float array containing calculated "Perlin-Noise-Layer" values
+     */
+    static float[][] generatePerlinNoiseLayer(float[][] base, int width, int height, int octave) {
+        float[][] perlinNoiseLayer = new float[width][height];
+
+        //calculate period (wavelength) for different shapes
+        int period = 1 << octave; //2^k
+        float frequency = 1f / period; // 1/2^k
+
+        for(int x = 0; x < width; x++) {
+            //calculates the horizontal sampling indices
+            int x0 = (x / period) * period;
+            int x1 = (x0 + period) % width;
+            float horizintalBlend = (x - x0) * frequency;
+
+            for(int y = 0; y < height; y++) {
+                //calculates the vertical sampling indices
+                int y0 = (y / period) * period;
+                int y1 = (y0 + period) % height;
+                float verticalBlend = (y - y0) * frequency;
+
+                //blend top corners
+                float top = interpolate(base[x0][y0], base[x1][y0], horizintalBlend);
+
+                //blend bottom corners
+                float bottom = interpolate(base[x0][y1], base[x1][y1], horizintalBlend);
+
+                //blend top and bottom interpolation to get the final blend value for this cell
+                perlinNoiseLayer[x][y] = interpolate(top, bottom, verticalBlend);
+            }
+        }
+
+        return perlinNoiseLayer;
+    }
+
+    /**
+     * @param a value of point a
+     * @param b value of point b
+     * @param alpha determine which value has more impact (closer to 0 -> a, closer to 1 -> b)
+     * @return interpolated value
+     */
+    static float interpolate(float a, float b, float alpha) {
+        return a * (1 - alpha) + alpha * b;
+    }
+
+    public static void main(String[] args) {
+        Scanner in = new Scanner(System.in);
+
+        final int width;
+        final int height;
+        final int octaveCount;
+        final float persistence;
+        final long seed;
+        final String charset;
+        final float[][] perlinNoise;
+
+        System.out.println("Width (int): ");
+        width = in.nextInt();
+
+        System.out.println("Height (int): ");
+        height = in.nextInt();
+
+        System.out.println("Octave count (int): ");
+        octaveCount = in.nextInt();
+
+        System.out.println("Persistence (float): ");
+        persistence = in.nextFloat();
+
+        System.out.println("Seed (long): ");
+        seed = in.nextLong();
+
+        System.out.println("Charset (String): ");
+        charset = in.next();
+
+
+        perlinNoise = generatePerlinNoise(width, height, octaveCount, persistence, seed);
+        final char[] chars = charset.toCharArray();
+        final int length = chars.length;
+        final float step = 1f / length;
+        //output based on charset
+        for(int x = 0; x < width; x++) {
+            for(int y = 0; y < height; y++) {
+                float value = step;
+                float noiseValue = perlinNoise[x][y];
+
+                for (char c : chars) {
+                    if (noiseValue <= value) {
+                        System.out.print(c);
+                        break;
+                    }
+
+                    value += step;
+                }
+            }
+
+            System.out.println();
+        }
+    }
+}