# Problem mit 3D Noise



## Fu3L (26. Mrz 2012)

Hallo^^
Nachdem ich Marcos Implementierung von Perlin Noise gesehen habe, habe ich meine etwas schäbige Variante lieber neu geschrieben. In 2D funktioniert das nun auch, aber im Dreidimensionalen konnte ich meine Platzhaltervariante noch nicht ersetzen, weil ich beim dreidimensionalen Noise einen seltsamen Fehler bekomme:
Eigentlich sollte eine Oktave des Noises nahtlos aneinanderkachelbar sein. Doch stattdessen erhalte ich sowas:







Dazu muss man sagen, dass ich dem Noise übergebe, wie viele Punkte zufällig erzeugt werden sollen und wie viel Abstand diese haben sollen. Im Bild sind das 4 Punkte a 100px Abstand. In x-Richtung scheint es erstmal gut zu funktionieren, es ist nur nicht nahtlos. In y-Richtung aber habe ich nach 100px auf mal einen ganz anderen Verlauf.
Ich hab alles oft überprüft... Getestet, obs an der Trilerp-Funktion liegt, habe in einem anderen Versuch das Array etwas größer gemacht, und in die letzten Elemente sozusagen wieder die ersten reinkopiert (was beim 2D Versuch super klappt), aber auch das half nichts.

Außerdem habe ich eingebaut, dass man per Enter-Taste die nächste scheibe des 3D Noise betrachten kann, aber auch in tieferen Schichten tritt das Problem auf 

Die Noise Klasse beginnt ab Zeile 102, die Anzahl der Punkte und die "Wavelnegth" können in Zeile 20 geändert werden.


```
import java.awt.Color;
import java.awt.Dimension;
import java.awt.Graphics;
import java.awt.event.KeyEvent;
import java.awt.event.KeyListener;
import java.awt.image.BufferedImage;
import java.util.Random;

import javax.swing.JFrame;
import javax.swing.JPanel;

public class TutNicht extends JPanel implements KeyListener {

	BufferedImage img;
	Color c1 = Color.BLUE;
	Color c2 = Color.GREEN;
	Color c3 = Color.RED;
	int WIDTH = 500;
	int HEIGHT = 500;
	Noise3D n = new Single3D2(new Random().nextInt(), 4, 100);
	int z = 0;

	public TutNicht() {
		this.setPreferredSize(new Dimension(WIDTH, HEIGHT));
		this.addKeyListener(this);
		this.setFocusable(true);
		updateImg();
	}

	public void updateImg() {
		img = new BufferedImage(WIDTH, HEIGHT, BufferedImage.TYPE_INT_ARGB);
		for(int x = 0; x < img.getWidth(); x++) {
			for(int y = 0; y < img.getHeight(); y++) {
				int c = lerpColor(n.get(x, y, z));
				img.setRGB(x, y, c);
			}
		}
		//Per Enter kann man hineinzoomen.
		z++;
		repaint();
		System.out.println("success");
	}

	private int lerpColor(double d) {
		Color x = null;
		Color y = null;
		if(d <= 0.5) {
			d = d / 0.5;
			x = c1;
			y = c2;
			d = d < 0.15 ? 0 : d - 0.15;
		} else {
			d = (d - 0.5) / 0.5;
			x = c2;
			y = c3;
			d = d > 0.85 ? 1 : d + 0.15;
		}
		double e = 1 - d;
		int r = (int) (x.getRed() * e + y.getRed() * d);
		int g = (int) (x.getGreen() * e + y.getGreen() * d);
		int b = (int) (x.getBlue() * e + y.getBlue() * d);
		return 255 << 24 | r << 16 | g << 8 | b;
	}

	public static void main(String[] args) {
		JFrame f = new JFrame();
		f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		f.setResizable(false);
		f.add(new TutNicht());
		f.pack();
		f.setLocationRelativeTo(null);
		f.setVisible(true);
	}

	@Override
	public void paintComponent(Graphics g) {
		super.paintComponent(g);
		g.drawImage(img, 0, 0, null);
	}

	@Override
	public void keyPressed(KeyEvent e) {
	}

	@Override
	public void keyReleased(KeyEvent e) {
		if(e.getKeyCode() == KeyEvent.VK_ENTER) {
			updateImg();
		}
	}

	@Override
	public void keyTyped(KeyEvent e) {
	}

	interface Noise3D {

		public double get(double x, double y, double z);

	}

	class Single3D2 implements Noise3D {

		private double[][][] values;
		private Random random;
		private int wavelength;

		private int width;
		private int height;
		private int depth;

		public Single3D2(int seed, int numPoints, int wavelength) {
			this.width = numPoints;
			this.height = width;
			this.depth = width;
			this.values = new double[width][height][depth];
			this.random = new Random(seed);
			this.wavelength = wavelength;
			this.fillArray();
		}

		private void fillArray() {
			for(int x = 0; x < width; x++) {
				for(int y = 0; y < height; y++) {
					for(int z = 0; z < depth; z++) {
						values[x][y][z] = random.nextDouble();
					}
				}
			}
		}

		@Override
		public double get(double globalX, double globalY, double globalZ) {
			//Wird als globaler x-ert zB 500 übergeben, aber das Noise deckt nur Werte bis 400 ab, soll x = 100 sein.
			int x = (int) globalX % (width * wavelength);
			int y = (int) globalY % (height * wavelength);
			int z = (int) globalZ % (depth * wavelength);
//Welcher Punkt des Arrays gewählt werden soll:
			int xOffset = x / wavelength;
			int yOffset = y / wavelength;
			int zOffset = z / wavelength;
//Welcher Punkt ist eine wavelength weiter?
			int xOffset2 = xOffset + 1;
			int yOffset2 = yOffset + 1;
			int zOffset2 = zOffset + 1;
//Sollte die Grenze des Arrays überschritten werden, fange vorne wieder an:
			if(xOffset2 >= width) {
				xOffset2 = 0;
			}
			if(yOffset2 >= height) {
				yOffset2 = 0;
			}
			if(zOffset2 >= depth) {
				zOffset2 = 0;
			}
			return trilerp(x, y, z, xOffset * wavelength, xOffset2 * wavelength, yOffset * wavelength, yOffset2 * wavelength,
					zOffset * wavelength, zOffset2 * wavelength,
					values[xOffset][yOffset][zOffset], values[xOffset][yOffset][zOffset2],
					values[xOffset][yOffset2][zOffset], values[xOffset][yOffset2][zOffset2],
					values[xOffset2][yOffset][zOffset], values[xOffset2][yOffset][zOffset2],
					values[xOffset2][yOffset2][zOffset], values[xOffset2][yOffset2][zOffset2]);
		}
	}

	/**
	 * Trilinear Interpolation as a combination of many Lerps
	 * 
	 * @param x The point to lerp's x coord
	 * @param y The point to lerp's y coord
	 * @param z The point to lerp's z coord
	 * @param x1 x-value of the first cube-face
	 * @param x2 x-value of the second cube face
	 * @param y1 y-value of the first cube-face
	 * @param y2 y-value of the second cube face
	 * @param z1 z-value of the first cube-face
	 * @param z2 z-value of the second cube face
	 * @param v000 Value for point 0 0 0 x y z
	 * @param v001 Value for point 0 0 1 x y z
	 * @param v010 Value for point 0 1 0 x y z
	 * @param v011 Value for point 0 1 1 x y z
	 * @param v100 Value for point 1 0 0 x y z
	 * @param v101 Value for point 1 0 1 x y z
	 * @param v110 Value for point 1 1 0 x y z
	 * @param v111 Value for point 1 1 1 x y z
	 * @return The lerped value
	 */
	public static double trilerp(double x, double y, double z, double x1, double x2, double y1, double y2, double z1, double z2, double v000, double v001, double v010, double v011, double v100, double v101, double v110, double v111) {
		double lerped1 = lerp(x, x1, x2, v000, v100);
		double lerped2 = lerp(x, x1, x2, v010, v110);
		double lerped3 = lerp(x, x1, x2, v001, v101);
		double lerped4 = lerp(x, x1, x2, v011, v111);
		double bilerped1 = lerp(y, y1, y2, lerped1, lerped3);
		double bilerped2 = lerp(y, y1, y2, lerped2, lerped4);
		return lerp(z, z1, z2, bilerped1, bilerped2);
	}

	/**
	 * Linear Interpolation
	 * 
	 * @param x The point to lerp
	 * @param a The first source point
	 * @param b The second source point
	 * @param v1 The first point's value
	 * @param v2 The second point's value
	 * @return The interpolated value for point x.
	 */
	private static double lerp(double x, double a, double b, double v1, double v2) {
		return v1 + (x - a) * ((v2 - v1) / (b - a));
	}

	/**
	 * Bilinear Interpolation as a combination of 2 Lerps
	 * 
	 * @param x The point to lerp's x coord
	 * @param y The point to lerp's y coord
	 * @param x1 x-value of the first cube-face
	 * @param x2 x-value of the second cube-face
	 * @param y1 y-value of the first cube-face
	 * @param y2 y-value of the second cube face
	 * @param v00 Value for point 0 0 x y
	 * @param v01 Value for point 0 1 x y
	 * @param v10 Value for point 1 0 x y
	 * @param v11 Value for point 1 1 x y
	 * @return the bilerped value
	 */
	public static double bilerp(double x, double y, double x1, double x2, double y1, double y2, double v00, double v01, double v10, double v11) {
		double lerped1 = lerp(x, x1, x2, v00, v10);
		double lerped2 = lerp(x, x1, x2, v01, v11);
		return lerp(y, y1, y2, lerped1, lerped2);
	}

}
```


----------



## Marco13 (26. Mrz 2012)

Auf die schnelle wird es schwer, da DEN Fehler zu finden. Beim Überfliegen hätte ich statt
        double bilerped1 = lerp(y, y1, y2, lerped1, lerped3);
vermutet, dass dort "bilerp" aufgerufen werden sollte, aber hab's nicht nachvollzogen.

Ich bastle gerade an einem animierten Noise auf der GPU. Vielleicht sollte ich das nicht erwähnen, weil sonst Fancy in 10 Minuten sowas postet, aber das Risiko gehe ich jetzt mal ein


----------



## Fu3L (26. Mrz 2012)

Hab mir trilerp nochmal angeguckt und rumprobiert. Es war nicht ganz, was du sagtest, aber ein Fehler lag auf jeden Fall dort: Die Reihenfolge stimmte nicht. (Zu deiner Vermutung: Die 6 lerps sind im Prinzip 2 bilerps. Weiß auch nicht, warum ich nicht einfach bilerp aufrief, als ich die Methode geschrieben habe)


```
public static double trilerp(double x, double y, double z, double x1, double x2, double y1, double y2, double z1, double z2, double v000, double v001, double v010, double v011, double v100, double v101, double v110, double v111) {
		double lerped1 = lerp(x, x1, x2, v000, v100);
		double lerped3 = lerp(x, x1, x2, v010, v110);
		double lerped2 = lerp(x, x1, x2, v001, v101);
		double lerped4 = lerp(x, x1, x2, v011, v111);
		double bilerped1 = lerp(y, y1, y2, lerped1, lerped3);
		double bilerped2 = lerp(y, y1, y2, lerped2, lerped4);
		return lerp(z, z1, z2, bilerped1, bilerped2);
	}
```

Es ist allerdings noch immer nicht nahtlos. Vielleicht habe ich beim Rumprobieren vorher etwas kaputtgemacht. Gucke ich heute Abend noch einmal genauer an.


----------



## Guest2 (26. Mrz 2012)

Moin,



Marco13 hat gesagt.:


> Ich bastle gerade an einem animierten Noise auf der GPU. Vielleicht sollte ich das nicht erwähnen, weil sonst Fancy in 10 Minuten sowas postet, aber das Risiko gehe ich jetzt mal ein



durch die Zeit zurückrenn und Blub. 

Aber wie schon im anderen Thread erwähnt, Perlin Noise auf der GPU ist nicht trivial (zumindest wenn man eine schnelle Lösung möchte) und leider auch nichts was ich selber in 10 Minuten aus dem Hut zaubern könne. 


Viele Grüße,
Fancy


----------



## Fu3L (28. Mrz 2012)

So, möchte noch mitteilen, dass ich das Problem nun komplett gelöst habe. Den Array Index auf 0 zu setzen hat - seltsamerweise - nicht funktioniert, aber wenn ich das Array in jede Dimension um 1 vergrößere und dann die "erste" Seite von jeder Dimension in die letzte kopiere, gehts.

Nach der Klausur Donnerstag wird Terrain generiert


----------

