PerlinNoise.java

packagecom.thealgorithms.others;

importjava.util.Random;
importjava.util.Scanner;

/**
 * For detailed info and implementation see: <a
 * href="http://devmag.org.za/2009/04/25/perlin-noise/">Perlin-Noise</a>
 */
publicfinalclassPerlinNoise {
privatePerlinNoise() {
 }

/**
 * @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
 */
staticfloat[][] generatePerlinNoise(intwidth, intheight, intoctaveCount, floatpersistence, longseed) {
finalfloat[][] base = newfloat[width][height];
finalfloat[][] perlinNoise = newfloat[width][height];
finalfloat[][][] noiseLayers = newfloat[octaveCount][][];

Randomrandom = newRandom(seed);
// fill base array with random values as base for noise
for (intx = 0; x < width; x++) {
for (inty = 0; y < height; y++) {
base[x][y] = random.nextFloat();
 }
 }

// calculate octaves with different roughness
for (intoctave = 0; octave < octaveCount; octave++) {
noiseLayers[octave] = generatePerlinNoiseLayer(base, width, height, octave);
 }

floatamplitude = 1f;
floattotalAmplitude = 0f;

// calculate perlin noise by blending each layer together with specific persistence
for (intoctave = octaveCount - 1; octave >= 0; octave--) {
amplitude *= persistence;
totalAmplitude += amplitude;

for (intx = 0; x < width; x++) {
for (inty = 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 (intx = 0; x < width; x++) {
for (inty = 0; y < height; y++) {
perlinNoise[x][y] /= totalAmplitude;
 }
 }

returnperlinNoise;
 }

/**
 * @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
 */
staticfloat[][] generatePerlinNoiseLayer(float[][] base, intwidth, intheight, intoctave) {
float[][] perlinNoiseLayer = newfloat[width][height];

// calculate period (wavelength) for different shapes
intperiod = 1 << octave; // 2^k
floatfrequency = 1f / period; // 1/2^k

for (intx = 0; x < width; x++) {
// calculates the horizontal sampling indices
intx0 = (x / period) * period;
intx1 = (x0 + period) % width;
floathorizintalBlend = (x - x0) * frequency;

for (inty = 0; y < height; y++) {
// calculates the vertical sampling indices
inty0 = (y / period) * period;
inty1 = (y0 + period) % height;
floatverticalBlend = (y - y0) * frequency;

// blend top corners
floattop = interpolate(base[x0][y0], base[x1][y0], horizintalBlend);

// blend bottom corners
floatbottom = 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);
 }
 }

returnperlinNoiseLayer;
 }

/**
 * @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
 */
staticfloatinterpolate(floata, floatb, floatalpha) {
returna * (1 - alpha) + alpha * b;
 }

publicstaticvoidmain(String[] args) {
Scannerin = newScanner(System.in);

finalintwidth;
finalintheight;
finalintoctaveCount;
finalfloatpersistence;
finallongseed;
finalStringcharset;
finalfloat[][] 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);
finalchar[] chars = charset.toCharArray();
finalintlength = chars.length;
finalfloatstep = 1f / length;
// output based on charset
for (intx = 0; x < width; x++) {
for (inty = 0; y < height; y++) {
floatvalue = step;
floatnoiseValue = perlinNoise[x][y];

for (charc : chars) {
if (noiseValue <= value) {
System.out.print(c);
break;
 }

value += step;
 }
 }

System.out.println();
 }
in.close();
 }
}