HighMap library (C++)
Loading...
Searching...
No Matches
erosion.hpp
Go to the documentation of this file.
1/* Copyright (c) 2023 Otto Link. Distributed under the terms of the GNU General
2 Public License. The full license is in the file LICENSE, distributed with
3 this software. */
4
16#pragma once
17#include <cmath>
18
19#include "highmap/array.hpp"
20#include "highmap/hydrology.hpp"
21
22// neighbor pattern search based on Moore pattern and define diagonal
23// weight coefficients ('c' corresponds to a weight coefficient
24// applied to take into account the longer distance for diagonal
25// comparison between cells)
26
27// clang-format off
28// 6 2 8
29// 1 . 4
30// 5 3 7
31#define HMAP_DI {-1, 0, 0, 1, -1, -1, 1, 1}
32#define HMAP_DJ {0, 1, -1, 0, -1, 1, -1, 1}
33#define HMAP_CD {1.f, 1.f, 1.f, 1.f, M_SQRT2, M_SQRT2, M_SQRT2, M_SQRT2}
34#define HMAP_CD_INV {1.f, 1.f, 1.f, 1.f, M_SQRT2, M_SQRT2, M_SQRT2, M_SQRT2}
35// clang-format on
36
37namespace hmap
38{
39
54
55std::function<float(float)> get_erosion_profile_function(
56 const ErosionProfile &erosion_profile,
57 float delta,
58 float &profile_avg);
59
97void coastal_erosion_diffusion(Array &z,
98 Array &water_depth,
99 float additional_depth,
100 int iterations = 10,
101 Array *p_water_mask = nullptr);
102
150void coastal_erosion_profile(Array &z,
151 Array &water_depth,
152 float shore_ground_extent, // pixels
153 float shore_water_extent,
154 float slope_shore = 0.5f,
155 float slope_shore_water = 0.5f,
156 float scarp_extent_ratio = 0.5f, // in [0, 1]
157 bool apply_post_filter = true,
158 Array *p_shore_mask = nullptr);
159
160void coastal_erosion_profile(Array &z,
161 const Array *p_mask,
162 Array &water_depth,
163 float shore_ground_extent, // pixels
164 float shore_water_extent,
165 float slope_shore = 0.5f,
166 float slope_shore_water = 0.5f,
167 float scarp_extent_ratio = 0.5f, // in [0, 1]
168 bool apply_post_filter = true,
169 Array *p_shore_mask = nullptr);
170
188void depression_filling(Array &z, int iterations = 1000, float epsilon = 1e-4f);
189
190void depression_filling_priority_flood(Array &z);
191
208void erosion_maps(Array &z_before,
209 Array &z_after,
210 Array &erosion_map,
211 Array &deposition_map,
212 float tolerance = 0.f);
213
238void hydraulic_algebric(Array &z,
239 Array *p_mask,
240 float talus_ref,
241 int ir,
242 Array *p_bedrock = nullptr,
243 Array *p_erosion_map = nullptr,
244 Array *p_deposition_map = nullptr,
245 float c_erosion = 0.05f,
246 float c_deposition = 0.05f,
247 int iterations = 1);
248
249void hydraulic_algebric(Array &z,
250 float talus_ref,
251 int ir,
252 Array *p_bedrock = nullptr,
253 Array *p_erosion_map = nullptr,
254 Array *p_deposition_map = nullptr,
255 float c_erosion = 0.05f,
256 float c_deposition = 0.05f,
257 int iterations = 1);
258
289void hydraulic_benes(Array &z,
290 Array *p_mask,
291 int iterations = 50,
292 Array *p_bedrock = nullptr,
293 Array *p_moisture_map = nullptr,
294 Array *p_erosion_map = nullptr,
295 Array *p_deposition_map = nullptr,
296 float c_capacity = 40.f,
297 float c_erosion = 0.2f,
298 float c_deposition = 0.8f,
299 float water_level = 0.005f,
300 float evap_rate = 0.01f,
301 float rain_rate = 0.5f);
302
303void hydraulic_benes(Array &z,
304 int iterations = 50,
305 Array *p_bedrock = nullptr,
306 Array *p_moisture_map = nullptr,
307 Array *p_erosion_map = nullptr,
308 Array *p_deposition_map = nullptr,
309 float c_capacity = 40.f,
310 float c_erosion = 0.2f,
311 float c_deposition = 0.8f,
312 float water_level = 0.005f,
313 float evap_rate = 0.01f,
314 float rain_rate = 0.5f);
315
329void hydraulic_blur(Array &z,
330 float radius,
331 float vmax,
332 float k_smoothing = 0.1f);
333
351void hydraulic_diffusion(Array &z,
352 float c_diffusion,
353 float talus,
354 int iterations);
378void hydraulic_musgrave(Array &z,
379 Array &moisture_map,
380 int iterations = 100,
381 float c_capacity = 1.f,
382 float c_erosion = 0.1f,
383 float c_deposition = 0.1f,
384 float water_level = 0.01f,
385 float evap_rate = 0.01f);
386
387void hydraulic_musgrave(Array &z,
388 int iterations = 100,
389 float c_capacity = 1.f,
390 float c_erosion = 0.1f,
391 float c_deposition = 0.1f,
392 float water_level = 0.01f,
393 float evap_rate = 0.01f);
394
425void hydraulic_particle(Array &z,
426 Array *p_mask,
427 int nparticles,
428 int seed,
429 Array *p_bedrock = nullptr,
430 Array *p_moisture_map = nullptr,
431 Array *p_erosion_map = nullptr, // -> out
432 Array *p_deposition_map = nullptr, // -> out
433 float c_capacity = 10.f,
434 float c_erosion = 0.05f,
435 float c_deposition = 0.05f,
436 float c_inertia = 0.3f,
437 float drag_rate = 0.001f,
438 float evap_rate = 0.001f,
439 bool post_filtering = false);
440
441void hydraulic_particle(Array &z,
442 int nparticles,
443 int seed,
444 Array *p_bedrock = nullptr,
445 Array *p_moisture_map = nullptr,
446 Array *p_erosion_map = nullptr, // -> out
447 Array *p_deposition_map = nullptr, // -> out
448 float c_capacity = 10.f,
449 float c_erosion = 0.05f,
450 float c_deposition = 0.05f,
451 float c_inertia = 0.3f,
452 float drag_rate = 0.001f,
453 float evap_rate = 0.001f,
454 bool post_filtering = false);
455
489void hydraulic_particle_multiscale(Array &z,
490 float particle_density,
491 int seed,
492 Array *p_bedrock = nullptr,
493 Array *p_moisture_map = nullptr,
494 Array *p_erosion_map = nullptr, // -> out
495 Array *p_deposition_map = nullptr, // -> out
496 float c_capacity = 10.f,
497 float c_erosion = 0.05f,
498 float c_deposition = 0.01f,
499 float c_inertia = 0.3f,
500 float drag_rate = 0.01f,
501 float evap_rate = 0.001f,
502 int pyramid_finest_level = 0);
503
552void hydraulic_procedural(
553 Array &z,
554 uint seed,
555 float ridge_wavelength,
556 float ridge_scaling = 0.1f,
557 ErosionProfile erosion_profile = ErosionProfile::TRIANGLE_SMOOTH,
558 float delta = 0.02f,
559 float noise_ratio = 0.2f,
560 int prefilter_ir = -1,
561 float density_factor = 1.f,
562 float kernel_width_ratio = 2.f,
563 float phase_smoothing = 2.f,
564 float phase_noise_amp = M_PI,
565 bool reverse_phase = false,
566 bool rotate90 = false,
567 bool use_default_mask = true,
568 float talus_mask = 0.f,
569 Array *p_mask = nullptr,
570 Array *p_ridge_mask = nullptr,
571 float vmin = 0.f,
572 float vmax = -1.f);
573
574void hydraulic_spl(Array &z);
575
603void hydraulic_stream(Array &z,
604 float c_erosion,
605 float talus_ref,
606 Array *p_bedrock = nullptr,
607 Array *p_moisture_map = nullptr,
608 Array *p_erosion_map = nullptr, // -> out
609 int ir = 1,
610 float clipping_ratio = 10.f);
611
612void hydraulic_stream(Array &z,
613 Array *p_mask,
614 float c_erosion,
615 float talus_ref,
616 Array *p_bedrock = nullptr,
617 Array *p_moisture_map = nullptr,
618 Array *p_erosion_map = nullptr, // -> out
619 int ir = 1,
620 float clipping_ratio = 10.f);
621
660void hydraulic_stream_log(Array &z,
661 float c_erosion,
662 float talus_ref,
663 int deposition_ir = 32,
664 float deposition_scale_ratio = 1.f,
665 float gradient_power = 0.8f,
666 float gradient_scaling_ratio = 1.f,
667 int gradient_prefilter_ir = 16,
668 float saturation_ratio = 1.f,
669 Array *p_bedrock = nullptr,
670 Array *p_moisture_map = nullptr,
671 Array *p_erosion_map = nullptr,
672 Array *p_deposition_map = nullptr,
673 Array *p_flow_map = nullptr);
674
675void hydraulic_stream_log(Array &z,
676 float c_erosion,
677 float talus_ref,
678 Array *p_mask,
679 int deposition_ir = 32,
680 float deposition_scale_ratio = 1.f,
681 float gradient_power = 0.8f,
682 float gradient_scaling_ratio = 1.f,
683 int gradient_prefilter_ir = 16,
684 float saturation_ratio = 1.f,
685 Array *p_bedrock = nullptr,
686 Array *p_moisture_map = nullptr,
687 Array *p_erosion_map = nullptr,
688 Array *p_deposition_map = nullptr,
689 Array *p_flow_map = nullptr);
690
723void hydraulic_stream_upscale_amplification(Array &z,
724 float c_erosion,
725 float talus_ref,
726 int upscaling_levels = 1,
727 float persistence = 1.f,
728 int ir = 1,
729 float clipping_ratio = 10.f);
730
764void hydraulic_stream_upscale_amplification(
765 Array &z,
766 Array *p_mask,
767 float c_erosion,
768 float talus_ref,
769 int upscaling_levels = 1,
770 float persistence = 1.f,
771 int ir = 1,
772 float clipping_ratio = 10.f);
773
802void hydraulic_vpipes(Array &z,
803 Array *p_mask,
804 int iterations,
805 Array *p_bedrock = nullptr,
806 Array *p_moisture_map = nullptr,
807 Array *p_erosion_map = nullptr,
808 Array *p_deposition_map = nullptr,
809 float water_height = 0.1f,
810 float c_capacity = 0.1f,
811 float c_erosion = 0.05f,
812 float c_deposition = 0.05f,
813 float rain_rate = 0.f,
814 float evap_rate = 0.01f);
815
816void hydraulic_vpipes(Array &z,
817 int iterations,
818 Array *p_bedrock = nullptr,
819 Array *p_moisture_map = nullptr,
820 Array *p_erosion_map = nullptr,
821 Array *p_deposition_map = nullptr,
822 float water_height = 0.1f,
823 float c_capacity = 0.1f,
824 float c_erosion = 0.05f,
825 float c_deposition = 0.05f,
826 float rain_rate = 0.f,
827 float evap_rate = 0.01f);
828
851void sediment_deposition(Array &z,
852 Array *p_mask,
853 const Array &talus,
854 Array *p_deposition_map = nullptr,
855 float max_deposition = 0.01,
856 int iterations = 5,
857 int thermal_subiterations = 10);
858
859void sediment_deposition(Array &z,
860 const Array &talus,
861 Array *p_deposition_map = nullptr,
862 float max_deposition = 0.01,
863 int iterations = 5,
864 int thermal_subiterations = 10);
865
889void sediment_deposition_particle(Array &z,
890 Array *p_mask,
891 int nparticles,
892 int ir,
893 int seed = 1,
894 Array *p_spawning_map = nullptr,
895 Array *p_deposition_map = nullptr,
896 float particle_initial_sediment = 0.1f,
897 float deposition_velocity_limit = 0.01f,
898 float drag_rate = 0.001f);
899
900void sediment_deposition_particle(Array &z,
901 int nparticles,
902 int ir,
903 int seed = 1,
904 Array *p_spawning_map = nullptr,
905 Array *p_deposition_map = nullptr,
906 float particle_initial_sediment = 0.1f,
907 float deposition_velocity_limit = 0.01f,
908 float drag_rate = 0.001f);
909
910void sediment_layer(Array &z,
911 const Array &talus_layer,
912 const Array &talus_upper_limit,
913 int iterations,
914 bool apply_post_filter = true,
915 Array *p_deposition_map = nullptr);
916
936void stratify(Array &z,
937 Array *p_mask,
938 std::vector<float> hs,
939 std::vector<float> gamma,
940 Array *p_noise = nullptr);
941
942void stratify(Array &z,
943 std::vector<float> hs,
944 std::vector<float> gamma,
945 Array *p_noise = nullptr);
946
947void stratify(Array &z,
948 std::vector<float> hs,
949 float gamma = 0.5f,
950 Array *p_noise = nullptr);
951
952void stratify(Array &z,
953 Array &partition,
954 int nstrata,
955 float strata_noise,
956 float gamma,
957 float gamma_noise,
958 int npartitions,
959 uint seed,
960 float mixing_gain_factor = 1.f,
961 Array *p_noise = nullptr,
962 float vmin = 1.f,
963 float vmax = 0.f);
964
988void stratify_multiscale(Array &z,
989 float zmin,
990 float zmax,
991 std::vector<int> n_strata,
992 std::vector<float> strata_noise,
993 std::vector<float> gamma_list,
994 std::vector<float> gamma_noise,
995 uint seed,
996 Array *p_mask = nullptr,
997 Array *p_noise = nullptr);
998
1019void stratify_oblique(Array &z,
1020 Array *p_mask,
1021 std::vector<float> hs,
1022 std::vector<float> gamma,
1023 float talus,
1024 float angle,
1025 Array *p_noise = nullptr);
1026
1027void stratify_oblique(Array &z,
1028 std::vector<float> hs,
1029 std::vector<float> gamma,
1030 float talus,
1031 float angle,
1032 Array *p_noise = nullptr);
1033
1053void thermal(Array &z,
1054 Array *p_mask,
1055 const Array &talus,
1056 int iterations = 10,
1057 Array *p_bedrock = nullptr,
1058 Array *p_deposition_map = nullptr);
1059
1060void thermal(Array &z,
1061 const Array &talus,
1062 int iterations = 10,
1063 Array *p_bedrock = nullptr,
1064 Array *p_deposition_map = nullptr);
1065
1066void thermal(Array &z,
1067 float talus,
1068 int iterations = 10,
1069 Array *p_bedrock = nullptr,
1070 Array *p_deposition_map = nullptr);
1071
1093void thermal_auto_bedrock(Array &z,
1094 const Array &talus,
1095 int iterations = 10,
1096 Array *p_deposition_map = nullptr);
1097
1098void thermal_auto_bedrock(Array &z,
1099 float talus,
1100 int iterations = 10,
1101 Array *p_deposition_map = nullptr);
1102
1103void thermal_auto_bedrock(Array &z,
1104 Array *p_mask,
1105 float talus,
1106 int iterations = 10,
1107 Array *p_deposition_map = nullptr);
1108
1126void thermal_flatten(Array &z,
1127 const Array &talus,
1128 const Array &bedrock,
1129 int iterations = 10,
1130 int post_filter_ir = 1);
1131
1132void thermal_flatten(Array &z,
1133 float talus,
1134 int iterations = 10,
1135 int post_filter_ir = 1);
1136
1156void thermal_olsen(Array &z,
1157 const Array &talus,
1158 int iterations = 10,
1159 Array *p_bedrock = nullptr,
1160 Array *p_deposition_map = nullptr);
1161
1174void thermal_rib(Array &z, int iterations, Array *p_bedrock = nullptr);
1175
1199void thermal_schott(Array &z,
1200 const Array &talus,
1201 int iterations = 10,
1202 float intensity = 0.001f);
1203
1204void thermal_schott(Array &z,
1205 const Array &talus,
1206 Array *p_mask,
1207 int iterations = 10,
1208 float intensity = 0.001f);
1209
1231void thermal_schott(Array &z,
1232 const float talus,
1233 int iterations = 10,
1234 float intensity = 0.001f);
1235
1236void thermal_schott(Array &z,
1237 const float talus,
1238 Array *p_mask,
1239 int iterations = 10,
1240 float intensity = 0.001f);
1241
1263Array watershed_ridge(
1264 const Array &z,
1265 float amplitude = 0.5f,
1266 int ir = 1,
1267 float edt_exponent = 0.5f,
1268 FlowDirectionMethod fd_method = FlowDirectionMethod::FDM_D8);
1269
1270Array watershed_ridge(
1271 const Array &z,
1272 Array *p_mask,
1273 float amplitude = 0.5f,
1274 int ir = 1,
1275 float edt_exponent = 0.5f,
1276 FlowDirectionMethod fd_method = FlowDirectionMethod::FDM_D8);
1277
1278} // namespace hmap
1279
1280namespace hmap::gpu
1281{
1282
1284void hydraulic_particle(Array &z,
1285 int nparticles,
1286 int seed,
1287 Array *p_bedrock = nullptr,
1288 Array *p_moisture_map = nullptr,
1289 Array *p_erosion_map = nullptr,
1290 Array *p_deposition_map = nullptr,
1291 float c_capacity = 10.f,
1292 float c_erosion = 0.05f,
1293 float c_deposition = 0.05f,
1294 float c_inertia = 0.3f,
1295 float c_gravity = 1.f,
1296 int radius = 2,
1297 float drag_rate = 0.001f,
1298 float evap_rate = 0.001f,
1299 bool post_filtering = false);
1300
1302void hydraulic_particle(Array &z,
1303 Array *p_mask,
1304 int nparticles,
1305 int seed,
1306 Array *p_bedrock = nullptr,
1307 Array *p_moisture_map = nullptr,
1308 Array *p_erosion_map = nullptr,
1309 Array *p_deposition_map = nullptr,
1310 float c_capacity = 10.f,
1311 float c_erosion = 0.05f,
1312 float c_deposition = 0.05f,
1313 float c_inertia = 0.3f,
1314 float c_gravity = 1.f,
1315 int radius = 2,
1316 float drag_rate = 0.001f,
1317 float evap_rate = 0.001f,
1318 bool post_filtering = false);
1319
1366void hydraulic_schott(Array &z,
1367 int iterations,
1368 const Array &talus,
1369 float c_erosion = 1.f,
1370 float c_thermal = 0.1f,
1371 float c_deposition = 0.2f,
1372 float flow_acc_exponent = 0.8f,
1373 float flow_acc_exponent_depo = 0.8f,
1374 float flow_routing_exponent = 1.3f,
1375 float thermal_weight = 1.5f,
1376 float deposition_weight = 2.5f,
1377 Array *p_flow = nullptr);
1378
1379void hydraulic_schott(Array &z,
1380 int iterations,
1381 const Array &talus,
1382 Array *p_mask,
1383 float c_erosion = 1.f,
1384 float c_thermal = 0.1f,
1385 float c_deposition = 0.2f,
1386 float flow_acc_exponent = 0.8f,
1387 float flow_acc_exponent_depo = 0.8f,
1388 float flow_routing_exponent = 1.3f,
1389 float thermal_weight = 1.5f,
1390 float deposition_weight = 2.5f,
1391 Array *p_flow = nullptr);
1392
1394void hydraulic_schott_erosion(Array &z,
1395 int iterations,
1396 float c_erosion = 1.f,
1397 float flow_acc_exponent = 0.8f,
1398 float flow_routing_exponent = 1.3f,
1399 Array *p_flow = nullptr);
1400
1402void hydraulic_stream_log(Array &z,
1403 float c_erosion,
1404 float talus_ref,
1405 int deposition_ir = 32,
1406 float deposition_scale_ratio = 1.f,
1407 float gradient_power = 0.8f,
1408 float gradient_scaling_ratio = 1.f,
1409 int gradient_prefilter_ir = 16,
1410 float saturation_ratio = 1.f,
1411 Array *p_bedrock = nullptr,
1412 Array *p_moisture_map = nullptr,
1413 Array *p_erosion_map = nullptr,
1414 Array *p_deposition_map = nullptr,
1415 Array *p_flow_map = nullptr);
1416
1417void hydraulic_stream_log(Array &z,
1418 float c_erosion,
1419 float talus_ref,
1420 Array *p_mask,
1421 int deposition_ir = 32,
1422 float deposition_scale_ratio = 1.f,
1423 float gradient_power = 0.8f,
1424 float gradient_scaling_ratio = 1.f,
1425 int gradient_prefilter_ir = 16,
1426 float saturation_ratio = 1.f,
1427 Array *p_bedrock = nullptr,
1428 Array *p_moisture_map = nullptr,
1429 Array *p_erosion_map = nullptr,
1430 Array *p_deposition_map = nullptr,
1431 Array *p_flow_map = nullptr);
1432
1434void hydraulic_vpipes(Array &z,
1435 float water_height = 1e-2f,
1436 bool maintain_water_volume = true,
1437 float evap_rate = 0.1f,
1438 int iterations = 50,
1439 float dt = 0.5f,
1440 float k_capacity = 0.5f,
1441 float k_erode = 0.001f,
1442 float k_depose = 0.01f,
1443 float k_discharge_exp = 1.f,
1444 bool flux_diffusion = true,
1445 float flux_diffusion_strength = 0.001f,
1446 Array *p_rain_map = nullptr,
1447 Array *p_water_depth = nullptr,
1448 Array *p_sediment = nullptr,
1449 Array *p_vel_u = nullptr,
1450 Array *p_vel_v = nullptr);
1451
1503void rifts(Array &z,
1504 const glm::vec2 &kw, // = {4.f, 1.2f},
1505 float angle, // degs
1506 float amplitude,
1507 uint seed,
1508 float elevation_noise_shift = 0.f,
1509 float k_smooth_bottom = 0.05f,
1510 float k_smooth_top = 0.05f,
1511 float radial_spread_amp = 0.2f,
1512 float elevation_noise_amp = 0.1f,
1513 float clamp_vmin = 0.f,
1514 float remap_vmin = 0.f,
1515 bool apply_mask = true,
1516 bool reverse_mask = false,
1517 float mask_gamma = 1.f,
1518 const Array *p_noise_x = nullptr,
1519 const Array *p_noise_y = nullptr,
1520 const Array *p_mask = nullptr,
1521 const glm::vec2 &center = {0.5f, 0.5f},
1522 const glm::vec4 &bbox = {0.f, 1.f, 0.f, 1.f});
1523
1581void strata(Array &z,
1582 float angle,
1583 float slope,
1584 float gamma, // e.g 0.5f or 1.5f
1585 uint seed,
1586 bool linear_gamma = true,
1587 float kz = 1.f,
1588 int octaves = 4,
1589 float lacunarity = 2.f,
1590 float gamma_noise_ratio = 0.5f,
1591 float noise_amp = 0.4f,
1592 const glm::vec2 &noise_kw = {4.f, 4.f},
1593 const glm::vec2 &ridge_noise_kw = {4.f, 1.2f},
1594 float ridge_angle_shift = 45.f,
1595 float ridge_noise_amp = 0.5f,
1596 float ridge_clamp_vmin = 0.f,
1597 float ridge_remap_vmin = 0.f,
1598 bool apply_elevation_mask = true,
1599 bool apply_ridge_mask = true,
1600 float mask_gamma = 0.4f,
1601 const Array *p_mask = nullptr,
1602 const glm::vec4 &bbox = {0.f, 1.f, 0.f, 1.f});
1603
1605void thermal(Array &z,
1606 const Array &talus,
1607 int iterations = 10,
1608 Array *p_bedrock = nullptr,
1609 Array *p_deposition_map = nullptr);
1610
1612void thermal(Array &z,
1613 Array *p_mask,
1614 const Array &talus,
1615 int iterations = 10,
1616 Array *p_bedrock = nullptr,
1617 Array *p_deposition_map = nullptr);
1618
1620void thermal(Array &z,
1621 float talus,
1622 int iterations = 10,
1623 Array *p_bedrock = nullptr,
1624 Array *p_deposition_map = nullptr);
1625
1627void thermal_auto_bedrock(Array &z,
1628 const Array &talus,
1629 int iterations = 10,
1630 Array *p_deposition_map = nullptr);
1631
1633void thermal_auto_bedrock(Array &z,
1634 Array *p_mask,
1635 const Array &talus,
1636 int iterations = 10,
1637 Array *p_deposition_map = nullptr);
1638
1640void thermal_auto_bedrock(Array &z,
1641 float,
1642 int iterations = 10,
1643 Array *p_deposition_map = nullptr);
1644
1646void thermal_olsen(Array &z, const Array &talus, int iterations);
1647void thermal_olsen(Array &z, Array *p_mask, const Array &talus, int iterations);
1648
1666void thermal_inflate(Array &z, const Array &talus, int iterations = 10);
1667
1668void thermal_inflate(Array &z,
1669 const Array *p_mask,
1670 const Array &talus,
1671 int iterations = 10);
1672
1674void thermal_rib(Array &z, int iterations, Array *p_bedrock = nullptr);
1675
1695void thermal_ridge(Array &z,
1696 const Array &talus,
1697 int iterations = 10,
1698 Array *p_deposition_map = nullptr);
1699
1700void thermal_ridge(Array &z,
1701 const Array *p_mask,
1702 const Array &talus,
1703 int iterations = 10,
1704 Array *p_deposition_map = nullptr);
1705
1725void thermal_scree(Array &z,
1726 const Array &talus,
1727 const Array &zmax,
1728 int iterations = 10,
1729 Array *p_deposition_map = nullptr);
1730
1731void thermal_scree(Array &z,
1732 const Array *p_mask,
1733 const Array &talus,
1734 const Array &zmax,
1735 int iterations = 10,
1736 Array *p_deposition_map = nullptr);
1737
1758void valley_fill(Array &z,
1759 const Array &talus,
1760 int iterations = 100,
1761 float gamma = 2.f,
1762 float ratio = 0.8f,
1763 float zmin = 0.f,
1764 float zmax = 0.f,
1765 float elevation_max_ratio = 1.f,
1766 bool preserve_elevation_range = true,
1767 const Array *p_noise = nullptr,
1768 Array *p_deposition_map = nullptr);
1769
1770void valley_fill(Array &z,
1771 const Array *p_mask,
1772 const Array &talus,
1773 int iterations = 100,
1774 float gamma = 2.f,
1775 float ratio = 0.8f,
1776 float zmin = 0.f,
1777 float zmax = 0.f,
1778 float elevation_max_ratio = 1.f,
1779 bool preserve_elevation_range = true,
1780 const Array *p_noise = nullptr,
1781 Array *p_deposition_map = nullptr);
1782
1784Array watershed_ridge(
1785 const Array &z,
1786 float amplitude = 0.5f,
1787 int ir = 1,
1788 float edt_exponent = 0.5f,
1789 FlowDirectionMethod fd_method = FlowDirectionMethod::FDM_D8,
1790 const Array *p_noise_x = nullptr,
1791 const Array *p_noise_y = nullptr);
1792
1794Array watershed_ridge(
1795 const Array &z,
1796 Array *p_mask,
1797 float amplitude = 0.5f,
1798 int ir = 1,
1799 float edt_exponent = 0.5f,
1800 FlowDirectionMethod fd_method = FlowDirectionMethod::FDM_D8,
1801 const Array *p_noise_x = nullptr,
1802 const Array *p_noise_y = nullptr);
1803
1804} // namespace hmap::gpu
array.hpp
Declaration of the Array class for 2D floating-point arrays with various mathematical operations and ...
uint
unsigned int uint
Definition array.hpp:14
hydrology.hpp
Header file for hydrological modeling functions and utilities.
hmap::gpu
Definition blending.hpp:186
hmap::gpu::thermal_olsen
void thermal_olsen(Array &z, const Array &talus, int iterations)
See hmap::thermal_olsen.
Definition thermal_gpu.cpp:190
hmap::gpu::hydraulic_vpipes
void hydraulic_vpipes(Array &z, float water_height=1e-2f, bool maintain_water_volume=true, float evap_rate=0.1f, int iterations=50, float dt=0.5f, float k_capacity=0.5f, float k_erode=0.001f, float k_depose=0.01f, float k_discharge_exp=1.f, bool flux_diffusion=true, float flux_diffusion_strength=0.001f, Array *p_rain_map=nullptr, Array *p_water_depth=nullptr, Array *p_sediment=nullptr, Array *p_vel_u=nullptr, Array *p_vel_v=nullptr)
See hmap::hydraulic_vpipes.
Definition hydraulic_vpipes_gpu.cpp:17
hmap::gpu::thermal_ridge
void thermal_ridge(Array &z, const Array &talus, int iterations=10, Array *p_deposition_map=nullptr)
Apply thermal weathering erosion to give a ridge like effect.
Definition thermal_gpu.cpp:241
hmap::gpu::hydraulic_particle
void hydraulic_particle(Array &z, int nparticles, int seed, Array *p_bedrock=nullptr, Array *p_moisture_map=nullptr, Array *p_erosion_map=nullptr, Array *p_deposition_map=nullptr, float c_capacity=10.f, float c_erosion=0.05f, float c_deposition=0.05f, float c_inertia=0.3f, float c_gravity=1.f, int radius=2, float drag_rate=0.001f, float evap_rate=0.001f, bool post_filtering=false)
See hmap::hydraulic_particle.
Definition erosion_gpu.cpp:13
hmap::gpu::watershed_ridge
Array watershed_ridge(const Array &z, float amplitude=0.5f, int ir=1, float edt_exponent=0.5f, FlowDirectionMethod fd_method=FlowDirectionMethod::FDM_D8, const Array *p_noise_x=nullptr, const Array *p_noise_y=nullptr)
See hmap::watershed_ridge.
Definition watershed_ridge.cpp:87
hmap::gpu::thermal
void thermal(Array &z, const Array &talus, int iterations=10, Array *p_bedrock=nullptr, Array *p_deposition_map=nullptr)
See hmap::thermal.
Definition thermal_gpu.cpp:14
hmap::gpu::thermal_auto_bedrock
void thermal_auto_bedrock(Array &z, const Array &talus, int iterations=10, Array *p_deposition_map=nullptr)
See hmap::thermal_auto_bedrock.
Definition thermal_gpu.cpp:98
hmap::gpu::hydraulic_schott_erosion
void hydraulic_schott_erosion(Array &z, int iterations, float c_erosion=1.f, float flow_acc_exponent=0.8f, float flow_routing_exponent=1.3f, Array *p_flow=nullptr)
See hmap::hydraulic_schott.
Definition hydraulic_schott_gpu.cpp:125
hmap::gpu::hydraulic_stream_log
void hydraulic_stream_log(Array &z, float c_erosion, float talus_ref, int deposition_ir=32, float deposition_scale_ratio=1.f, float gradient_power=0.8f, float gradient_scaling_ratio=1.f, int gradient_prefilter_ir=16, float saturation_ratio=1.f, Array *p_bedrock=nullptr, Array *p_moisture_map=nullptr, Array *p_erosion_map=nullptr, Array *p_deposition_map=nullptr, Array *p_flow_map=nullptr)
See hmap::hydraulic_stream_log.
Definition hydraulic_stream_gpu.cpp:17
hmap::gpu::hydraulic_schott
void hydraulic_schott(Array &z, int iterations, const Array &talus, float c_erosion=1.f, float c_thermal=0.1f, float c_deposition=0.2f, float flow_acc_exponent=0.8f, float flow_acc_exponent_depo=0.8f, float flow_routing_exponent=1.3f, float thermal_weight=1.5f, float deposition_weight=2.5f, Array *p_flow=nullptr)
Simulates hydraulic erosion and deposition on a heightmap using the Schott method.
Definition hydraulic_schott_gpu.cpp:10
hmap::gpu::thermal_scree
void thermal_scree(Array &z, const Array &talus, const Array &zmax, int iterations=10, Array *p_deposition_map=nullptr)
Performs thermal scree erosion on a heightmap.
Definition thermal_gpu.cpp:283
hmap::gpu::rifts
void rifts(Array &z, const glm::vec2 &kw, float angle, float amplitude, uint seed, float elevation_noise_shift=0.f, float k_smooth_bottom=0.05f, float k_smooth_top=0.05f, float radial_spread_amp=0.2f, float elevation_noise_amp=0.1f, float clamp_vmin=0.f, float remap_vmin=0.f, bool apply_mask=true, bool reverse_mask=false, float mask_gamma=1.f, const Array *p_noise_x=nullptr, const Array *p_noise_y=nullptr, const Array *p_mask=nullptr, const glm::vec2 &center={0.5f, 0.5f}, const glm::vec4 &bbox={0.f, 1.f, 0.f, 1.f})
Applies a "rift" deformation effect to a heightmap array.
Definition rifts_gpu.cpp:12
hmap::gpu::thermal_inflate
void thermal_inflate(Array &z, const Array &talus, int iterations=10)
Apply thermal weathering erosion to give a scree like effect.
Definition thermal_gpu.cpp:157
hmap::gpu::valley_fill
void valley_fill(Array &z, const Array &talus, int iterations=100, float gamma=2.f, float ratio=0.8f, float zmin=0.f, float zmax=0.f, float elevation_max_ratio=1.f, bool preserve_elevation_range=true, const Array *p_noise=nullptr, Array *p_deposition_map=nullptr)
Fill valleys using thermal scree deposition and height-based blending.
Definition valley_fill.cpp:12
hmap::gpu::thermal_rib
void thermal_rib(Array &z, int iterations, Array *p_bedrock=nullptr)
See hmap::thermal_rib.
Definition thermal_gpu.cpp:222
hmap::gpu::strata
void strata(Array &z, float angle, float slope, float gamma, uint seed, bool linear_gamma=true, float kz=1.f, int octaves=4, float lacunarity=2.f, float gamma_noise_ratio=0.5f, float noise_amp=0.4f, const glm::vec2 &noise_kw={4.f, 4.f}, const glm::vec2 &ridge_noise_kw={4.f, 1.2f}, float ridge_angle_shift=45.f, float ridge_noise_amp=0.5f, float ridge_clamp_vmin=0.f, float ridge_remap_vmin=0.f, bool apply_elevation_mask=true, bool apply_ridge_mask=true, float mask_gamma=0.4f, const Array *p_mask=nullptr, const glm::vec4 &bbox={0.f, 1.f, 0.f, 1.f})
Applies stratification to a heightfield using directional noise and multiscale gamma transformations.
Definition strata_gpu.cpp:12
hmap
Definition algebra.hpp:22
hmap::get_erosion_profile_function
std::function< float(float)> get_erosion_profile_function(const ErosionProfile &erosion_profile, float delta, float &profile_avg)
Definition hydraulic_procedural.cpp:20
hmap::stratify_oblique
void stratify_oblique(Array &z, Array *p_mask, std::vector< float > hs, std::vector< float > gamma, float talus, float angle, Array *p_noise=nullptr)
Stratify the heightmap by creating a series of oblique layers with elevations corrected by a gamma fa...
Definition stratify.cpp:241
hmap::FlowDirectionMethod
FlowDirectionMethod
Definition hydrology.hpp:34
hmap::FDM_D8
@ FDM_D8
Definition hydrology.hpp:35
hmap::thermal_olsen
void thermal_olsen(Array &z, const Array &talus, int iterations=10, Array *p_bedrock=nullptr, Array *p_deposition_map=nullptr)
Apply thermal weathering erosion.
Definition thermal_olsen.cpp:23
hmap::hydraulic_blur
void hydraulic_blur(Array &z, float radius, float vmax, float k_smoothing=0.1f)
Apply cell-based hydraulic erosion using a nonlinear diffusion model.
Definition hydraulic_blur.cpp:13
hmap::ErosionProfile
ErosionProfile
Procedural erosion angular profile type.
Definition erosion.hpp:44
hmap::SAW_SMOOTH
@ SAW_SMOOTH
Definition erosion.hpp:47
hmap::TRIANGLE_GRENIER
@ TRIANGLE_GRENIER
Definition erosion.hpp:50
hmap::SQUARE_SMOOTH
@ SQUARE_SMOOTH
Definition erosion.hpp:49
hmap::SAW_SHARP
@ SAW_SHARP
Definition erosion.hpp:46
hmap::TRIANGLE_SHARP
@ TRIANGLE_SHARP
Definition erosion.hpp:51
hmap::SHARP_VALLEYS
@ SHARP_VALLEYS
Definition erosion.hpp:48
hmap::TRIANGLE_SMOOTH
@ TRIANGLE_SMOOTH
Definition erosion.hpp:52
hmap::COSINE
@ COSINE
Definition erosion.hpp:45
hmap::sediment_deposition
void sediment_deposition(Array &z, Array *p_mask, const Array &talus, Array *p_deposition_map=nullptr, float max_deposition=0.01, int iterations=5, int thermal_subiterations=10)
Perform sediment deposition combined with thermal erosion.
Definition deposition.cpp:47
hmap::coastal_erosion_profile
void coastal_erosion_profile(Array &z, Array &water_depth, float shore_ground_extent, float shore_water_extent, float slope_shore=0.5f, float slope_shore_water=0.5f, float scarp_extent_ratio=0.5f, bool apply_post_filter=true, Array *p_shore_mask=nullptr)
Applies a coastal erosion profile to a terrain elevation field.
Definition coastal_erosion.cpp:43
hmap::hydraulic_stream_log
void hydraulic_stream_log(Array &z, float c_erosion, float talus_ref, int deposition_ir=32, float deposition_scale_ratio=1.f, float gradient_power=0.8f, float gradient_scaling_ratio=1.f, int gradient_prefilter_ir=16, float saturation_ratio=1.f, Array *p_bedrock=nullptr, Array *p_moisture_map=nullptr, Array *p_erosion_map=nullptr, Array *p_deposition_map=nullptr, Array *p_flow_map=nullptr)
Apply hydraulic erosion based on a flow accumulation map, alternative formulation.
Definition hydraulic_stream.cpp:100
hmap::thermal_rib
void thermal_rib(Array &z, int iterations, Array *p_bedrock=nullptr)
Apply thermal erosion using a 'rib' algorithm (taken from Geomorph).
Definition thermal_rib.cpp:17
hmap::coastal_erosion_diffusion
void coastal_erosion_diffusion(Array &z, Array &water_depth, float additional_depth, int iterations=10, Array *p_water_mask=nullptr)
Simulates terrain diffusion due to coastal erosion.
Definition coastal_erosion.cpp:13
hmap::hydraulic_musgrave
void hydraulic_musgrave(Array &z, Array &moisture_map, int iterations=100, float c_capacity=1.f, float c_erosion=0.1f, float c_deposition=0.1f, float water_level=0.01f, float evap_rate=0.01f)
Apply cell-based hydraulic erosion/deposition of Musgrave et al. (1989).
Definition hydraulic_musgrave.cpp:22
hmap::thermal_flatten
void thermal_flatten(Array &z, const Array &talus, const Array &bedrock, int iterations=10, int post_filter_ir=1)
Apply modified thermal weathering of Olsen.
Definition thermal_flatten.cpp:22
hmap::hydraulic_stream_upscale_amplification
void hydraulic_stream_upscale_amplification(Array &z, float c_erosion, float talus_ref, int upscaling_levels=1, float persistence=1.f, int ir=1, float clipping_ratio=10.f)
Applies hydraulic erosion with upscaling amplification.
Definition hydraulic_stream_upscale_amplification.cpp:17
hmap::slope
Array slope(glm::ivec2 shape, float angle, float slope, const Array *p_ctrl_param=nullptr, const Array *p_noise_x=nullptr, const Array *p_noise_y=nullptr, const Array *p_stretching=nullptr, glm::vec2 center={0.5f, 0.5f}, glm::vec4 bbox={0.f, 1.f, 0.f, 1.f})
Return an array corresponding to a slope with a given overall.
Definition primitives.cpp:279
hmap::hydraulic_diffusion
void hydraulic_diffusion(Array &z, float c_diffusion, float talus, int iterations)
Apply cell-based hydraulic erosion using a nonlinear diffusion model.
Definition hydraulic_diffusion.cpp:17
hmap::stratify_multiscale
void stratify_multiscale(Array &z, float zmin, float zmax, std::vector< int > n_strata, std::vector< float > strata_noise, std::vector< float > gamma_list, std::vector< float > gamma_noise, uint seed, Array *p_mask=nullptr, Array *p_noise=nullptr)
Stratify the heightmap by creating a multiscale series of layers with elevations corrected by a gamma...
Definition stratify.cpp:62
hmap::hydraulic_particle
void hydraulic_particle(Array &z, Array *p_mask, int nparticles, int seed, Array *p_bedrock=nullptr, Array *p_moisture_map=nullptr, Array *p_erosion_map=nullptr, Array *p_deposition_map=nullptr, float c_capacity=10.f, float c_erosion=0.05f, float c_deposition=0.05f, float c_inertia=0.3f, float drag_rate=0.001f, float evap_rate=0.001f, bool post_filtering=false)
Apply hydraulic erosion using a particle based procedure.
Definition hydraulic_particle.cpp:184
hmap::watershed_ridge
Array watershed_ridge(const Array &z, float amplitude=0.5f, int ir=1, float edt_exponent=0.5f, FlowDirectionMethod fd_method=FlowDirectionMethod::FDM_D8)
Carves watershed ridges using basin-wise distance transforms.
Definition watershed_ridge.cpp:21
hmap::sediment_layer
void sediment_layer(Array &z, const Array &talus_layer, const Array &talus_upper_limit, int iterations, bool apply_post_filter=true, Array *p_deposition_map=nullptr)
Definition deposition.cpp:209
hmap::depression_filling
void depression_filling(Array &z, int iterations=1000, float epsilon=1e-4f)
Fill the depressions of the heightmap using the Planchon-Darboux algorithm.
Definition depression_filling.cpp:14
hmap::hydraulic_vpipes
void hydraulic_vpipes(Array &z, Array *p_mask, int iterations, Array *p_bedrock=nullptr, Array *p_moisture_map=nullptr, Array *p_erosion_map=nullptr, Array *p_deposition_map=nullptr, float water_height=0.1f, float c_capacity=0.1f, float c_erosion=0.05f, float c_deposition=0.05f, float rain_rate=0.f, float evap_rate=0.01f)
Apply hydraulic erosion using the 'virtual pipes' algorithm.
Definition hydraulic_vpipes.cpp:288
hmap::angle
float angle(const Point &p1, const Point &p2)
Computes the angle between two points relative to the x-axis.
Definition points.cpp:42
hmap::hydraulic_particle_multiscale
void hydraulic_particle_multiscale(Array &z, float particle_density, int seed, Array *p_bedrock=nullptr, Array *p_moisture_map=nullptr, Array *p_erosion_map=nullptr, Array *p_deposition_map=nullptr, float c_capacity=10.f, float c_erosion=0.05f, float c_deposition=0.01f, float c_inertia=0.3f, float drag_rate=0.01f, float evap_rate=0.001f, int pyramid_finest_level=0)
Apply hydraulic erosion using a particle based procedure, using a pyramid decomposition to allow a mu...
Definition hydraulic_particle_multiscale.cpp:17
hmap::thermal_schott
void thermal_schott(Array &z, const Array &talus, int iterations=10, float intensity=0.001f)
Applies the thermal erosion process to an array of elevation values.
Definition thermal_schott.cpp:24
hmap::thermal
void thermal(Array &z, Array *p_mask, const Array &talus, int iterations=10, Array *p_bedrock=nullptr, Array *p_deposition_map=nullptr)
Apply thermal weathering erosion.
Definition thermal.cpp:174
hmap::stratify
void stratify(Array &z, Array *p_mask, std::vector< float > hs, std::vector< float > gamma, Array *p_noise=nullptr)
Stratify the heightmap by creating a series of layers with elevations corrected by a gamma factor.
Definition stratify.cpp:46
hmap::hydraulic_algebric
void hydraulic_algebric(Array &z, Array *p_mask, float talus_ref, int ir, Array *p_bedrock=nullptr, Array *p_erosion_map=nullptr, Array *p_deposition_map=nullptr, float c_erosion=0.05f, float c_deposition=0.05f, int iterations=1)
Apply an algerbic formula based on the local gradient to perform erosion/deposition.
Definition hydraulic_algebric.cpp:73
hmap::hydraulic_spl
void hydraulic_spl(Array &z)
Definition hydraulic_spl.cpp:15
hmap::thermal_auto_bedrock
void thermal_auto_bedrock(Array &z, const Array &talus, int iterations=10, Array *p_deposition_map=nullptr)
Apply thermal weathering erosion with automatic determination of the bedrock.
Definition thermal.cpp:206
hmap::hydraulic_stream
void hydraulic_stream(Array &z, float c_erosion, float talus_ref, Array *p_bedrock=nullptr, Array *p_moisture_map=nullptr, Array *p_erosion_map=nullptr, int ir=1, float clipping_ratio=10.f)
Apply hydraulic erosion based on a flow accumulation map.
Definition hydraulic_stream.cpp:20
hmap::depression_filling_priority_flood
void depression_filling_priority_flood(Array &z)
Definition depression_filling_priority_flood.cpp:14
hmap::hydraulic_benes
void hydraulic_benes(Array &z, Array *p_mask, int iterations=50, Array *p_bedrock=nullptr, Array *p_moisture_map=nullptr, Array *p_erosion_map=nullptr, Array *p_deposition_map=nullptr, float c_capacity=40.f, float c_erosion=0.2f, float c_deposition=0.8f, float water_level=0.005f, float evap_rate=0.01f, float rain_rate=0.5f)
Apply cell-based hydraulic erosion/deposition based on Benes et al. procedure.
Definition hydraulic_benes.cpp:207
hmap::sediment_deposition_particle
void sediment_deposition_particle(Array &z, Array *p_mask, int nparticles, int ir, int seed=1, Array *p_spawning_map=nullptr, Array *p_deposition_map=nullptr, float particle_initial_sediment=0.1f, float deposition_velocity_limit=0.01f, float drag_rate=0.001f)
Definition deposition.cpp:172
hmap::hydraulic_procedural
void hydraulic_procedural(Array &z, uint seed, float ridge_wavelength, float ridge_scaling=0.1f, ErosionProfile erosion_profile=ErosionProfile::TRIANGLE_SMOOTH, float delta=0.02f, float noise_ratio=0.2f, int prefilter_ir=-1, float density_factor=1.f, float kernel_width_ratio=2.f, float phase_smoothing=2.f, float phase_noise_amp=M_PI, bool reverse_phase=false, bool rotate90=false, bool use_default_mask=true, float talus_mask=0.f, Array *p_mask=nullptr, Array *p_ridge_mask=nullptr, float vmin=0.f, float vmax=-1.f)
Generates a procedurally eroded terrain using hydraulic erosion and ridge generation techniques.
Definition hydraulic_procedural.cpp:144
hmap::erosion_maps
void erosion_maps(Array &z_before, Array &z_after, Array &erosion_map, Array &deposition_map, float tolerance=0.f)
Definition erosion_maps.cpp:16