Java Perlin Noise class.

PerlinNoise.java

import java.util.Random;

public class PerlinNoise {

    final static int TABLE_SIZE = 64;

	private final static double WEIGHT(double T) {
		return ((2.0 * Math.abs(T) - 3.0) * (T) * (T) + 1.0);
	}

	private final int CLAMP(int val, int min, int max) {
		return ((val < min ? min : val) > max ? max : val);
	}

	private final double CLAMP(double val, double min, double max) {
		return ((val < min ? min : val) > max ? max : val);
	}

	final int SCALE_WIDTH = 128;
	final double MIN_SIZE = 0.1;
	final double MAX_SIZE = 16.0;

	private boolean tilable = false;
	private boolean turbulent = false;
	private long seed = 0;
	private int detail = 1;
	private double size = 8.0;

	private static int clip;
	private static double offset, factor;
	static int[] perm_tab = new int[TABLE_SIZE];
	static Vector2d[] grad_tab = new Vector2d[TABLE_SIZE];

	public PerlinNoise(long seed) {
		this.seed = seed;
		init();
	}

	public double noise2(double x, double y) {
		x /= 100;
		y /= 100;
		return noise(x, y);
	}

	void init() {
		int i, j, k, t;
		double m;
		Random r;

		r = new Random(seed);

		/* Force sane parameters */
		detail = CLAMP(detail, 0, 15);
		size = CLAMP(size, MIN_SIZE, MAX_SIZE);

		/* Set scaling factors */
		if (tilable) {
			this.size = Math.ceil(size);
			clip = (int) size;
		}

		/* Set totally empiric normalization values */
		if (turbulent) {
			offset = 0.0;
			factor = 1.0;
		} else {
			offset = 0.94;
			factor = 0.526;
		}

		/* Initialize the permutation table */
		for (i = 0; i < TABLE_SIZE; i++)
			perm_tab[i] = i;

		for (i = 0; i < (TABLE_SIZE >> 1); i++) {
			j = r.nextInt(TABLE_SIZE);
			k = r.nextInt(TABLE_SIZE);
			t = perm_tab[j];
			perm_tab[j] = perm_tab[k];
			perm_tab[k] = t;
		}

		/* Initialize the gradient table */
		for (i = 0; i < TABLE_SIZE; i++) {
			grad_tab[i] = new Vector2d();
			do {
				grad_tab[i].setX((r.nextDouble() * 2) - 1);
				grad_tab[i].setY((r.nextDouble() * 2) - 1);
				m = grad_tab[i].getX() * grad_tab[i].getX() + grad_tab[i].getY() * grad_tab[i].getY();
			} while (m == 0.0 || m > 1.0);

			m = 1.0 / Math.sqrt(m);
			grad_tab[i].setX(grad_tab[i].getX() * m);
			grad_tab[i].setY(grad_tab[i].getY() * m);
		}

		r = null;
	}

	double plain_noise(double x, double y, int s) {
		Vector2d v = new Vector2d();
		int a, b, i, j, n;
		double sum;

		sum = 0.0;
		x *= s;
		y *= s;
		a = (int) Math.floor(x);
		b = (int) Math.floor(y);

		for (i = 0; i < 2; i++)
			for (j = 0; j < 2; j++) {
				if (tilable)
					n = perm_tab[betterMod((betterMod((a + i), (clip * s)) + perm_tab[betterMod(betterMod((b + j), (clip * s)), TABLE_SIZE)]), TABLE_SIZE)];
				else
					n = perm_tab[betterMod(a + i + perm_tab[betterMod(b + j, TABLE_SIZE)], TABLE_SIZE)];
				v.setX(x - a - i);
				v.setY(y - b - j);
				sum += WEIGHT(v.getX()) * WEIGHT(v.getY()) * (grad_tab[n].getX() * v.getX() + grad_tab[n].getY() * v.getY());
			}

		return sum / s;
	}
        
        /** Modified modulus, so that negative numbers wrap correctly! */
	private int betterMod(int val, int range) {
		return (val % range + range) % range;
	}

	double noise(double x, double y) {
		int i;
		int s;
		double sum;

		s = 1;
		sum = 0.0;
		x *= size;
		y *= size;

		for (i = 0; i <= detail; i++) {
			if (turbulent)
				sum += Math.abs(plain_noise(x, y, s));
			else
				sum += plain_noise(x, y, s);
			s <<= 1;
		}

		return (sum + offset) * factor;
	}
}