प्रक्रियात्मक जल विज्ञान: नदियों और झीलों का गतिशील अनुकरण

नोट: परियोजना का पूर्ण स्रोत कोड Github [ यहाँ ] पर पोस्ट किया गया है । रिपॉजिटरी में कोड को पढ़ने और उसका उपयोग करने के बारे में विस्तृत जानकारी भी है।

स्पष्टीकरण: मैं एक भूविज्ञानी नहीं हूं, इसलिए मैंने अपने ज्ञान के आधार पर प्रणाली बनाई।

जल विज्ञान अवधारणा

• नदी और धारा का पलायन
• प्राकृतिक झरने
• घाटी का गठन
• मिट्टी और बाढ़ की सूजन

• राहत पानी की आवाजाही को प्रभावित करती है
• कटाव और अवसादन इलाके को प्रभावित करते हैं

• एक चलती हुई धारा में, पानी अलग तरह से व्यवहार करता है।
• एक खड़े पूल में, पानी अलग तरह से व्यवहार करता है

सरलीकृत हाइड्रोलॉजिकल मॉडल

नोट: यह मत भूलो कि वे 2D सिस्टम के रूप में मॉडलिंग करते हैं।

स्ट्रीम और पूल मैप्स

नोट: स्ट्रीम और पूल मैप्स ऊंचाई के नक्शे के समान आकार के एरेज़ हैं।

एक कण के रूप में पानी

हाइड्रोलॉजिकल चक्र और मानचित्र इंटरैक्शन

• इलाके पर एक कण बनाना
• (.. ).
• , .
• , .
• , ( ) .
• .

कार्यान्वयन

कण वर्ग

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);
};

वंश एल्गोरिथ्म

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]);
//...

नोट: मुझे पता चला है कि इस तरह के एक पैरामीटर परिवर्तन अच्छी तरह से काम करता है।

//... 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;

//...

ध्यान दें: अतिप्रवाह की स्थिति भी मात्रा को रीसेट करती है ताकि कण बाढ़ एल्गोरिथ्म पर न जाएं।

बाढ़ एल्गोरिथ्म

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);

    //...

नोट: सादगी के लिए, एक आठ- मार्ग भरण एल्गोरिथ्म का उपयोग यहां किया जाता है । भविष्य में, इसे और अधिक प्रभावी ढंग से लागू करना संभव होगा।

    //...

    //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;
    }

    //...

नोट: जब रिसाव के कारण जल स्तर घटता है, तो मुझे पता चला कि यह कम रिसाव दर के साथ सबसे अच्छा काम करता है। इसके अलावा, तलछटी चट्टानों के हिस्से को खत्म करने से कार्यान्वयन में मदद मिलती है।

    //...

    //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

कटाव लपेट

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};

};

नोट: ऊंचाई का नक्शा पेर्लिन शोर का उपयोग करके आरंभ किया गया है।

//...

//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--;
}

//...

नोट: कण शायद ही कभी पूल में प्रवेश करते हैं और वंश चरणों के दौरान पूरी तरह से वाष्पित होने से पहले उन्हें एक या दो बार से अधिक छोड़ देते हैं, लेकिन मैंने इसे सिर्फ मामले में जोड़ा है।

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);

}

पेड़

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

नोट: ट्री मॉडल "वनस्पति" h में पाया जा सकता है और फ़ंक्शन "वर्ल्ड :: ग्रो ()" में।

अन्य जानकारी

परिणाम

संकीर्ण प्रवाह के प्रभावों की तुलना

• कण-आधारित क्षरण (बुनियादी क्षरण) जो प्रवाह और पूल मानचित्र प्राप्त करता है। ताल अब भी पीढ़ी को प्रभावित करते हैं
• हाइड्रोलॉजिकल नक्शों द्वारा बदले गए मापदंडों के साथ बुनियादी क्षरण (कटाव के साथ संयोजन में)
• हाइड्रोलॉजिकल नक्शों और पेड़ों द्वारा कटाव को प्रभावित करने वाले मापदंडों के साथ संयुक्त कटाव

पूल प्रभाव

नोट: मुझे कई बीज मिले, जिसमें तीन झीलें एक-दूसरे में क्रमिक रूप से प्रवाहित हुईं, लेकिन मैं इस लेख के लिए सही खोजने में बहुत समय नहीं लगाना चाहता था। मैंने पहले ही बहुत सारी तस्वीरें और वीडियो तैयार किए हैं।

सिमुलेशन गति

नोट: इस लेख के प्रकाशन के तुरंत बाद, मैंने सतह के मानदंडों की गणना करने की विधि में एक छोटा सा बदलाव किया, जिससे सिमुलेशन गति में वृद्धि हुई। सिमुलेशन के दौरान इस का प्रभाव बहुत ध्यान देने योग्य है, लेकिन लॉन्च और बाढ़ के समय में बड़ी विविधता के कारण इसे बेंचमार्क करना मुश्किल है। मेरे अनुमान के अनुसार, सिमुलेशन गति दोगुनी हो गई है।

अधिक सुंदर वीडियो

निष्कर्ष और भविष्य के लिए काम करते हैं