Hidrologi prosedural: simulasi dinamis sungai dan danau

Catatan: kode sumber lengkap proyek ini diposting di Github [di sini ]. Repositori juga berisi informasi terperinci tentang cara membaca dan menggunakan kode.

Penjelasan: Saya bukan ahli geologi, jadi saya menciptakan sistem berdasarkan pengetahuan saya.

Konsep hidrologi

• Migrasi sungai dan aliran
• Air terjun alami
• Formasi Ngarai
• Pembengkakan tanah dan dataran banjir

• Relief mempengaruhi pergerakan air
• Erosi dan sedimentasi mempengaruhi medan

• Dalam aliran yang bergerak , air berperilaku berbeda.
• Di kolam berdiri , air berperilaku berbeda

Model hidrologi yang disederhanakan

Catatan: jangan lupa bahwa mereka dimodelkan sebagai sistem 2D.

Stream dan Pool Map

Catatan: peta aliran dan kumpulan adalah array dengan ukuran yang sama dengan peta ketinggian.

Air sebagai partikel

Siklus hidrologi dan interaksi peta

• Membuat partikel di medan
• (.. ).
• , .
• , .
• , ( ) .
• .

Penerapan

Kelas partikel

struct Drop{
  
  //... constructors

  int index;                         //Flat Array Index
  glm::vec2 pos;                     //2D Position
  glm::vec2 speed = glm::vec2(0.0);
  double volume = 1.0;
  double sediment = 0.0;

  //... parameters
  const double volumeFactor = 100.0; //"Water Deposition Rate"

  //Hydrological Cycle Functions
  void descend(double* h, double* stream, double* pool, bool* track, glm::ivec2 dim, double scale);
  void flood(double* h, double* pool, glm::ivec2 dim);
};

Algoritma keturunan

void Drop::descend(double* h, double* stream, double* pool, bool* track, glm::ivec2 dim, double scale){

  glm::ivec2 ipos; 

  while(volume > minVol){

    ipos = pos; //Initial Position
    int ind = ipos.x*dim.y+ipos.y; //Flat Array Index

    //Register Position
    track[ind] = true;

    //...
  }
};

//...
  //Effective Parameter Set
  double effD = depositionRate;
  double effF = friction*(1.0-0.5*stream[ind]);
  double effR = evapRate*(1.0-0.2*stream[ind]);
//...

Catatan: Saya menemukan bahwa perubahan parameter seperti itu berfungsi dengan baik.

//... nind is the next position after moving the particle
  
  //Out-Of-Bounds
  if(!glm::all(glm::greaterThanEqual(pos, glm::vec2(0))) ||
     !glm::all(glm::lessThan((glm::ivec2)pos, dim))){
       volume = 0.0;
       break;
  }

  //Slow-Down
  if(stream[nind] > 0.5 && length(acc) < 0.01)
    break;

  //Enter Pool
  if(pool[nind] > 0.0)
    break;

//...

Catatan: kondisi overflow juga mengatur ulang volume sehingga partikel tidak mengarah ke algoritma flooding.

Algoritma banjir

void Drop::flood(double* height, double* pool, glm::ivec2 dim){

  index = (int)pos.x*dim.y + (int)pos.y;
  double plane = height[index] + pool[index];  //Testing Plane
  double initialplane = plane;                 //Water Level

  //Flood Set
  std::vector<int> set;
  int fail = 10; //Just in case...

  //Iterate while particle still has volume
  while(volume > minVol && fail){

    set.clear();
    bool tried[dim.x*dim.y] = {false};

    //Lowest Drain
    int drain;
    bool drainfound = false;

    //Recursive Flood-Fill Function
    std::function<void(int)> fill = [&](int i){

      //Out of Bounds
      if(i/dim.y >= dim.x || i/dim.y < 0) return;
      if(i%dim.y >= dim.y || i%dim.y < 0) return;

      //Position has been tried
      if(tried[i]) return;
      tried[i] = true;

      //Wall / Boundary of the Pool
      if(plane < height[i] + pool[i]) return;

      //Drainage Point
      if(initialplane > height[i] + pool[i]){

        //No Drain yet
        if(!drainfound)
          drain = i;

        //Lower Drain
        else if( pool[drain] + height[drain] < pool[i] + height[i] )
          drain = i;

        drainfound = true;
        return; //No need to flood from here
      }

      //Part of the Pool
      set.push_back(i);
      fill(i+dim.y);    //Fill Neighbors
      fill(i-dim.y);
      fill(i+1);
      fill(i-1);
      fill(i+dim.y+1);  //Diagonals (Improves Drainage)
      fill(i-dim.y-1);
      fill(i+dim.y-1);
      fill(i-dim.y+1);
    };

    //Perform Flood
    fill(index);

    //...

Catatan: untuk kesederhanaan, algoritma pengisian delapan arah digunakan di sini . Di masa depan, dimungkinkan untuk mengimplementasikannya dengan lebih efisien.

    //...

    //Drainage Point
    if(drainfound){

      //Set the Particle Position
      pos = glm::vec2(drain/dim.y, drain%dim.y);

      //Set the New Waterlevel (Slowly)
      double drainage = 0.001;
      plane = (1.0-drainage)*initialplane + drainage*(height[drain] + pool[drain]);

      //Compute the New Height
      for(auto& s: set) //Iterate over Set
        pool[s] = (plane > height[s])?(plane-height[s]):0.0;

      //Remove some sediment
      sediment *= 0.1;
      break;
    }

    //...

Catatan: ketika ketinggian air berkurang karena kebocoran, saya menemukan bahwa ini bekerja paling baik dengan tingkat kebocoran yang rendah. Selain itu, menghilangkan bagian dari batuan sedimen membantu implementasi.

    //...

    //Get Volume under Plane
    double tVol = 0.0;
    for(auto& s: set)
      tVol += volumeFactor*(plane - (height[s]+pool[s]));

    //We can partially fill this volume
    if(tVol <= volume && initialplane < plane){

      //Raise water level to plane height
      for(auto& s: set)
        pool[s] = plane - height[s];

      //Adjust Drop Volume
      volume -= tVol;
      tVol = 0.0;
    }

    //Plane was too high and we couldn't fill it
    else fail--;

    //Adjust Planes
    float approach = 0.5;
    initialplane = (plane > initialplane)?plane:initialplane;
    plane += approach*(volume-tVol)/(double)set.size()/volumeFactor;
  }

  //Couldn't place the volume (for some reason)- so ignore this drop.
  if(fail == 0)
    volume = 0.0;

} //End of Flood Algorithm

Bungkus erosi

class World {

public:
  void generate();            //Initialize
  void erode(int cycles);     //Erode with N Particles

  //...

  double heightmap[256*256] = {0.0};
  double waterstream[256*256] = {0.0};
  double waterpool[256*256] = {0.0};

};

Catatan: Peta ketinggian diinisialisasi menggunakan noise Perlin.

//...

//Spawn Particle
glm::vec2 newpos = glm::vec2(rand()%(int)dim.x, rand()%(int)dim.y);
Drop drop(newpos);

int spill = 5;
while(drop.volume > drop.minVol && spill != 0){

  drop.descend(heightmap, waterstream, waterpool, track, dim, scale);

  if(drop.volume > drop.minVol)
    drop.flood(heightmap, waterpool, dim);

  spill--;
}

//...

Catatan: partikel jarang memasuki kolam dan meninggalkannya lebih dari satu atau dua kali sebelum benar-benar menguap selama tahap penurunan, tetapi saya menambahkan ini untuk berjaga-jaga.

void World::erode(int N){

  //Track the Movement of all Particles
  bool track[dim.x*dim.y] = {false};

  //Simulate N Particles
  for(int i = 0; i < N; i++){
   
    //... simulate individual particle

  }

  //Update Path
  double lrate = 0.01;  //Adaptation Rate
  for(int i = 0; i < dim.x*dim.y; i++)
    waterstream[i] = (1.0-lrate)*waterstream[i] + lrate*((track[i])?1.0:0.0);

}

Pohon

//... descend function
double effD = depositionRate*max(0.0, 1.0-treedensity[ind]);
//...

Catatan: model pohon dapat ditemukan di file "vegetation.h" dan dalam fungsi "World :: grow ()".

Detail lainnya

hasil

Perbandingan efek dari penyempitan aliran

• Erosi berbasis partikel (erosi dasar) yang menerima peta aliran dan genangan. Kolam masih mempengaruhi generasi
• Erosi dasar dengan parameter diubah oleh peta hidrologi (dalam kombinasi dengan erosi)
• Erosi gabungan dengan parameter diubah oleh peta hidrologi dan memengaruhi erosi oleh pohon

Dampak Kolam

Catatan: Saya mendapatkan beberapa biji, di mana tiga danau mengalir satu sama lain secara berurutan, tetapi saya tidak ingin menghabiskan banyak waktu mencari yang tepat untuk artikel ini. Saya sudah menghasilkan terlalu banyak gambar dan video.

Kecepatan simulasi

Catatan: tak lama setelah publikasi artikel ini, saya membuat sedikit perubahan dalam metode menghitung permukaan normal, yang meningkatkan kecepatan simulasi. Efek dari ini sangat nyata selama simulasi, tetapi sulit untuk membandingkannya karena variasi besar dalam waktu yang dibutuhkan untuk memulai dan membanjiri. Menurut perkiraan saya, kecepatan simulasi telah dua kali lipat.

Video yang lebih indah

Kesimpulan dan kerja untuk masa depan