hydrology.hpp

Go to the documentation of this file.

/* Copyright (c) 2023 Otto Link. Distributed under the terms of the GNU General
   Public License. The full license is in the file LICENSE, distributed with
   this software. */
 
#pragma once
#include <limits>
 
#include "highmap/array.hpp"
#include "highmap/geometry/path.hpp"
 
namespace hmap
{
 
Array d8_compute_ndip(const Array &d8);
 
void find_flow_sinks(const Array      &z,
                     std::vector<int> &is,
                     std::vector<int> &js);
 
Array flooding_uniform_level(const Array &z, float zref);
 
Array flooding_from_boundaries(const Array &z,
                               float        zref,
                               bool         from_east = true,
                               bool         from_west = true,
                               bool         from_north = true,
                               bool         from_south = true);
 
Array flooding_from_point(const Array &z,
                          int          i,
                          int          j,
                          float depth_min = std::numeric_limits<float>::max());
 
Array flooding_from_point(const Array            &z,
                          const std::vector<int> &i,
                          const std::vector<int> &j,
                          float depth_min = std::numeric_limits<float>::max());
 
Array flooding_lake_system(const Array &z,
                           int          iterations = 500,
                           float        epsilon = 1e-3f,
                           float        surface_threshold = 0);
 
Array flow_accumulation_d8(const Array &z);
 
Array flow_accumulation_dinf(const Array &z, float talus_ref);
 
Array flow_direction_d8(const Array &z);
 
std::vector<Array> flow_direction_dinf(const Array &z, float talus_ref);
 
Array flow_direction_dinf_angle(const Array &z, float talus_ref);
 
Path flow_stream(const Array    &z,
                 const Vec2<int> ij_start,
                 const float     elevation_ratio = 0.5f,
                 const float     distance_exponent = 2.f,
                 const float     upward_penalization = 100.f);
 
Array generate_riverbed(const Path &path,
                        Vec2<int>   shape,
                        Vec4<float> bbox = {0.f, 1.f, 0.f, 1.f},
                        bool        bezier_smoothing = false,
                        float       depth_start = 0.01f,
                        float       depth_end = 1.f,
                        float       slope_start = 64.f,
                        float       slope_end = 32.f,
                        float       shape_exponent_start = 1.f,
                        float       shape_exponent_end = 10.f,
                        float       k_smoothing = 0.5f,
                        int         post_filter_ir = 0,
                        Array      *p_noise_x = nullptr,
                        Array      *p_noise_y = nullptr,
                        Array      *p_noise_r = nullptr);
 
Array merge_water_depths(const Array &depth1,
                         const Array &depth2,
                         float        k_smooth = 0.f);
 
Array water_depth_from_mask(const Array &z,
                            const Array &mask,
                            float        mask_threshold = 0.f,
                            int          iterations_max = 10000,
                            float        tolerance = 1e-2f,
                            float        omega = 1.8f);
 
void water_depth_dry_out(Array       &water_depth,
                         float        dry_out_ratio = 0.5f,
                         const Array *p_mask = nullptr,
                         float depth_max = std::numeric_limits<float>::max());
 
Array water_depth_increase(const Array &water_depth,
                           const Array &z,
                           float        additional_depth);
 
Array water_mask(const Array &water_depth);
 
Array water_mask(const Array &water_depth,
                 const Array &z,
                 float        additional_depth);
 
} // namespace hmap
 
namespace hmap::gpu
{
 
Array flow_direction_d8(const Array &z);
 
Array generate_riverbed(const Path &path,
                        Vec2<int>   shape,
                        Vec4<float> bbox = {0.f, 1.f, 0.f, 1.f},
                        bool        bezier_smoothing = false,
                        float       depth_start = 0.01f,
                        float       depth_end = 1.f,
                        float       slope_start = 64.f,
                        float       slope_end = 32.f,
                        float       shape_exponent_start = 1.f,
                        float       shape_exponent_end = 10.f,
                        float       k_smoothing = 0.5f,
                        int         post_filter_ir = 0,
                        Array      *p_noise_x = nullptr,
                        Array      *p_noise_y = nullptr,
                        Array      *p_noise_r = nullptr);
 
} // namespace hmap::gpu