Was ist Perlin-Noise für eine Funktion?

Irgendwann ist man beim Programmieren konfrontiert mit dem Begriff Perlin oder Noise oder Perlin-Noise und fragt sich was für eine Funktion ist das und wofür ist sie gut!

1.) ... Beispiel eine schlichte Perlin-Noise als einfache Wolke!
2.) ... Wofür soll ich das Wissen, muss ich Perlin-Noise verstehen!
3.) ... Schlichter Perlin-Noise Beispiel Kode in CPP

1.) Beispiel eine schlichte Perlin-Noise als einfache Wolke!

(Bild-3) Perlin-Noise Holz!

(Bild-4) Wolken mit Perlin-Noise als Funktion!

2.) Wofür soll ich das Wissen, muss ich Perlin-Noise verstehen!

(Bild-1) Ken Perlin und weitere Funktionen!

(Bild-2) Perlin-Noise und Stadt mit, bzw. aus Zufallszahlen!

3.) Schlichter Perlin-Noise Beispiel Kode in CPP

 
#include <iostream>
#include <cmath>
#include <vector>
#include <conio.h>  // Für _getch, um auf eine Tastatureingabe zu warten
 
std::vector<int> permutation = std::vector<int>(512);
 
class PerlinNoise {
public:
 PerlinNoise() {
  int i = 0;
  // Initialisiere den Permutationsvektor
    // mit zufälligen Werten zwischen 0 und 255
  for (i = 0; i < 256; ++i) {
   permutation[i] = i;
  }
 
  // Mische den Permutationsvektor
    // mit einem benutzerdefinierten Zufallszahlengenerator
  int seed = 42;
    // Du kannst den Seed
    // für verschiedene Muster ändern
  shufflePermutation(seed);
 
  // Dupliziere den Permutationsvektor,
    // um das Wickeln zu erleichtern
 
  for (i = 0; i < 256; ++i) {
   permutation[256 + i] = permutation[i];
  }
 }
 
 double noise(double x, double y, double z) const {
  int X = static_cast<int>(floor(x)) & 255;
  int Y = static_cast<int>(floor(y)) & 255;
  int Z = static_cast<int>(floor(z)) & 255;
 
  x -= floor(x);
  y -= floor(y);
  z -= floor(z);
 
  double u = fade(x);
  double v = fade(y);
  double w = fade(z);
 
  int A = permutation[X] + Y;
  int AA = permutation[A] + Z;
  int AB = permutation[A + 1] + Z;
  int B = permutation[X + 1] + Y;
  int BA = permutation[B] + Z;
  int BB = permutation[B + 1] + Z;
 
  double p1 = grad(permutation[AA], x, y, z);
  double p2 = grad(permutation[BA], x - 1, y, z);
  double p3 = grad(permutation[AB], x, y - 1, z);
  double p4 = grad(permutation[BB], x - 1, y - 1, z);
  double p5 = grad(permutation[AA + 1], x, y, z - 1);
  double p6 = grad(permutation[BA + 1], x - 1, y, z - 1);
  double p7 = grad(permutation[AB + 1], x, y - 1, z - 1);
  double p8 = grad(permutation[BB + 1], x - 1, y - 1, z - 1);
 
  double x1 = lerp(u, p1, p2);
  double x2 = lerp(u, p3, p4);
  double x3 = lerp(u, p5, p6);
  double x4 = lerp(u, p7, p8);
 
  double y1 = lerp(v, x1, x2);
  double y2 = lerp(v, x3, x4);
 
  return lerp(w, y1, y2);
 }
 
private:
 double fade(double t) const {
  return t * t * t * (t * (t * 6 - 15) + 10);
 }
 
 double lerp(double t, double a, double b) const {
  return a + t * (b - a);
 }
 
 double grad(int hash, double x, double y, double z) const {
  int h = hash & 15;
  double u = h < 8 ? x : y;
  double v = h < 4 ? y : h == 12 || h == 14 ? x : z;
  return ((h & 1) == 0 ? u : -u) + ((h & 2) == 0 ? v : -v);
 }
 
 void shufflePermutation(int seed) {
  int size = permutation.size();
  for (int i = size - 1; i > 0; --i) {
   int j = seed % (i + 1);
   std::swap(permutation[i], permutation[j]);
  }
 }
 
};
 
int main() {
 PerlinNoise perlin;
 double x = 5.0, y = 10.0, z = 15.0;
 double noiseValue = perlin.noise(x, y, z);
 std::cout << "Perlin-Rauschen bei (" << x << ", " << y << ", " << z << ") = " << noiseValue << std::endl;
 
 printf("Warte auf eine Tastatureingabe.\n");
 
 // Warten auf Tastendruck
      _getch();
 
 return 0;
}