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/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
57
58std::function<float(float)> get_erosion_profile_function(
59 const ErosionProfile &erosion_profile,
60 float delta,
61 float &profile_avg);
62
63std::vector<hmap::ErosionProfile> check_erosion_profile_function(
64 float delta = 0.01f);
65
103void coastal_erosion_diffusion(Array &z,
104 Array &water_depth,
105 float additional_depth,
106 int iterations = 10,
107 Array *p_water_mask = nullptr);
108
156void coastal_erosion_profile(Array &z,
157 Array &water_depth,
158 float shore_ground_extent, // pixels
159 float shore_water_extent,
160 float slope_shore = 0.5f,
161 float slope_shore_water = 0.5f,
162 float scarp_extent_ratio = 0.5f, // in [0, 1]
163 bool apply_post_filter = true,
164 Array *p_shore_mask = nullptr);
165
166void coastal_erosion_profile(Array &z,
167 const Array *p_mask,
168 Array &water_depth,
169 float shore_ground_extent, // pixels
170 float shore_water_extent,
171 float slope_shore = 0.5f,
172 float slope_shore_water = 0.5f,
173 float scarp_extent_ratio = 0.5f, // in [0, 1]
174 bool apply_post_filter = true,
175 Array *p_shore_mask = nullptr);
176
194void depression_filling(Array &z, int iterations = 1000, float epsilon = 1e-4f);
195
196void depression_filling_priority_flood(Array &z);
197
214void erosion_maps(Array &z_before,
215 Array &z_after,
216 Array &erosion_map,
217 Array &deposition_map,
218 float tolerance = 0.f);
219
243Array generate_bedrock(const Array &z,
244 float elevation_strength,
245 float slope_strength,
246 float slope_limit,
247 float zmin = 0.f,
248 float zmax = -1.f);
249
274void hydraulic_algebric(Array &z,
275 Array *p_mask,
276 float talus_ref,
277 int ir,
278 Array *p_bedrock = nullptr,
279 Array *p_erosion_map = nullptr,
280 Array *p_deposition_map = nullptr,
281 float c_erosion = 0.05f,
282 float c_deposition = 0.05f,
283 int iterations = 1);
284
285void hydraulic_algebric(Array &z,
286 float talus_ref,
287 int ir,
288 Array *p_bedrock = nullptr,
289 Array *p_erosion_map = nullptr,
290 Array *p_deposition_map = nullptr,
291 float c_erosion = 0.05f,
292 float c_deposition = 0.05f,
293 int iterations = 1);
294
325void hydraulic_benes(Array &z,
326 Array *p_mask,
327 int iterations = 50,
328 Array *p_bedrock = nullptr,
329 Array *p_moisture_map = nullptr,
330 Array *p_erosion_map = nullptr,
331 Array *p_deposition_map = nullptr,
332 float c_capacity = 40.f,
333 float c_erosion = 0.2f,
334 float c_deposition = 0.8f,
335 float water_level = 0.005f,
336 float evap_rate = 0.01f,
337 float rain_rate = 0.5f);
338
339void hydraulic_benes(Array &z,
340 int iterations = 50,
341 Array *p_bedrock = nullptr,
342 Array *p_moisture_map = nullptr,
343 Array *p_erosion_map = nullptr,
344 Array *p_deposition_map = nullptr,
345 float c_capacity = 40.f,
346 float c_erosion = 0.2f,
347 float c_deposition = 0.8f,
348 float water_level = 0.005f,
349 float evap_rate = 0.01f,
350 float rain_rate = 0.5f);
351
365void hydraulic_blur(Array &z,
366 float radius,
367 float vmax,
368 float k_smoothing = 0.1f);
369
387void hydraulic_diffusion(Array &z,
388 float c_diffusion,
389 float talus,
390 int iterations);
414void hydraulic_musgrave(Array &z,
415 Array &moisture_map,
416 int iterations = 100,
417 float c_capacity = 1.f,
418 float c_erosion = 0.1f,
419 float c_deposition = 0.1f,
420 float water_level = 0.01f,
421 float evap_rate = 0.01f);
422
423void hydraulic_musgrave(Array &z,
424 int iterations = 100,
425 float c_capacity = 1.f,
426 float c_erosion = 0.1f,
427 float c_deposition = 0.1f,
428 float water_level = 0.01f,
429 float evap_rate = 0.01f);
430
431void hydraulic_spl(Array &z);
432
460void hydraulic_stream(Array &z,
461 float c_erosion,
462 float talus_ref,
463 Array *p_bedrock = nullptr,
464 Array *p_moisture_map = nullptr,
465 Array *p_erosion_map = nullptr, // -> out
466 int ir = 1,
467 float clipping_ratio = 10.f);
468
469void hydraulic_stream(Array &z,
470 Array *p_mask,
471 float c_erosion,
472 float talus_ref,
473 Array *p_bedrock = nullptr,
474 Array *p_moisture_map = nullptr,
475 Array *p_erosion_map = nullptr, // -> out
476 int ir = 1,
477 float clipping_ratio = 10.f);
478
517void hydraulic_stream_log(Array &z,
518 float c_erosion,
519 float talus_ref,
520 int deposition_ir = 32,
521 float deposition_scale_ratio = 1.f,
522 float gradient_power = 0.8f,
523 float gradient_scaling_ratio = 1.f,
524 int gradient_prefilter_ir = 16,
525 float saturation_ratio = 1.f,
526 Array *p_bedrock = nullptr,
527 Array *p_moisture_map = nullptr,
528 Array *p_erosion_map = nullptr,
529 Array *p_deposition_map = nullptr,
530 Array *p_flow_map = nullptr);
531
532void hydraulic_stream_log(Array &z,
533 float c_erosion,
534 float talus_ref,
535 const Array *p_mask,
536 int deposition_ir = 32,
537 float deposition_scale_ratio = 1.f,
538 float gradient_power = 0.8f,
539 float gradient_scaling_ratio = 1.f,
540 int gradient_prefilter_ir = 16,
541 float saturation_ratio = 1.f,
542 Array *p_bedrock = nullptr,
543 Array *p_moisture_map = nullptr,
544 Array *p_erosion_map = nullptr,
545 Array *p_deposition_map = nullptr,
546 Array *p_flow_map = nullptr);
547
580void hydraulic_stream_upscale_amplification(Array &z,
581 float c_erosion,
582 float talus_ref,
583 int upscaling_levels = 1,
584 float persistence = 1.f,
585 int ir = 1,
586 float clipping_ratio = 10.f);
587
621void hydraulic_stream_upscale_amplification(
622 Array &z,
623 Array *p_mask,
624 float c_erosion,
625 float talus_ref,
626 int upscaling_levels = 1,
627 float persistence = 1.f,
628 int ir = 1,
629 float clipping_ratio = 10.f);
630
659void hydraulic_vpipes(Array &z,
660 Array *p_mask,
661 int iterations,
662 Array *p_bedrock = nullptr,
663 Array *p_moisture_map = nullptr,
664 Array *p_erosion_map = nullptr,
665 Array *p_deposition_map = nullptr,
666 float water_height = 0.1f,
667 float c_capacity = 0.1f,
668 float c_erosion = 0.05f,
669 float c_deposition = 0.05f,
670 float rain_rate = 0.f,
671 float evap_rate = 0.01f);
672
673void hydraulic_vpipes(Array &z,
674 int iterations,
675 Array *p_bedrock = nullptr,
676 Array *p_moisture_map = nullptr,
677 Array *p_erosion_map = nullptr,
678 Array *p_deposition_map = nullptr,
679 float water_height = 0.1f,
680 float c_capacity = 0.1f,
681 float c_erosion = 0.05f,
682 float c_deposition = 0.05f,
683 float rain_rate = 0.f,
684 float evap_rate = 0.01f);
685
705void stratify(Array &z,
706 Array *p_mask,
707 std::vector<float> hs,
708 std::vector<float> gamma,
709 Array *p_noise = nullptr);
710
711void stratify(Array &z,
712 std::vector<float> hs,
713 std::vector<float> gamma,
714 Array *p_noise = nullptr);
715
716void stratify(Array &z,
717 std::vector<float> hs,
718 float gamma = 0.5f,
719 Array *p_noise = nullptr);
720
721void stratify(Array &z,
722 Array &partition,
723 int nstrata,
724 float strata_noise,
725 float gamma,
726 float gamma_noise,
727 int npartitions,
728 uint seed,
729 float mixing_gain_factor = 1.f,
730 Array *p_noise = nullptr,
731 float vmin = 1.f,
732 float vmax = 0.f);
733
757void stratify_multiscale(Array &z,
758 float zmin,
759 float zmax,
760 std::vector<int> n_strata,
761 std::vector<float> strata_noise,
762 std::vector<float> gamma_list,
763 std::vector<float> gamma_noise,
764 uint seed,
765 Array *p_mask = nullptr,
766 Array *p_noise = nullptr);
767
788void stratify_oblique(Array &z,
789 Array *p_mask,
790 std::vector<float> hs,
791 std::vector<float> gamma,
792 float talus,
793 float angle,
794 Array *p_noise = nullptr);
795
796void stratify_oblique(Array &z,
797 std::vector<float> hs,
798 std::vector<float> gamma,
799 float talus,
800 float angle,
801 Array *p_noise = nullptr);
802
822void thermal(Array &z,
823 Array *p_mask,
824 const Array &talus,
825 int iterations = 10,
826 Array *p_bedrock = nullptr,
827 Array *p_deposition_map = nullptr);
828
829void thermal(Array &z,
830 const Array &talus,
831 int iterations = 10,
832 Array *p_bedrock = nullptr,
833 Array *p_deposition_map = nullptr);
834
835void thermal(Array &z,
836 float talus,
837 int iterations = 10,
838 Array *p_bedrock = nullptr,
839 Array *p_deposition_map = nullptr);
840
862void thermal_auto_bedrock(Array &z,
863 const Array &talus,
864 int iterations = 10,
865 Array *p_deposition_map = nullptr);
866
867void thermal_auto_bedrock(Array &z,
868 float talus,
869 int iterations = 10,
870 Array *p_deposition_map = nullptr);
871
872void thermal_auto_bedrock(Array &z,
873 Array *p_mask,
874 float talus,
875 int iterations = 10,
876 Array *p_deposition_map = nullptr);
877
895void thermal_flatten(Array &z,
896 const Array &talus,
897 const Array &bedrock,
898 int iterations = 10,
899 int post_filter_ir = 1);
900
901void thermal_flatten(Array &z,
902 float talus,
903 int iterations = 10,
904 int post_filter_ir = 1);
905
925void thermal_olsen(Array &z,
926 const Array &talus,
927 int iterations = 10,
928 Array *p_bedrock = nullptr,
929 Array *p_deposition_map = nullptr);
930
943void thermal_rib(Array &z, int iterations, Array *p_bedrock = nullptr);
944
968void thermal_schott(Array &z,
969 const Array &talus,
970 int iterations = 10,
971 float intensity = 0.001f);
972
973void thermal_schott(Array &z,
974 const Array &talus,
975 Array *p_mask,
976 int iterations = 10,
977 float intensity = 0.001f);
978
1000void thermal_schott(Array &z,
1001 const float talus,
1002 int iterations = 10,
1003 float intensity = 0.001f);
1004
1005void thermal_schott(Array &z,
1006 const float talus,
1007 Array *p_mask,
1008 int iterations = 10,
1009 float intensity = 0.001f);
1010
1011} // namespace hmap
1012
1013namespace hmap::gpu
1014{
1015
1048void hydraulic_particle(Array &z,
1049 int nparticles,
1050 uint seed,
1051 const Array *p_bedrock = nullptr,
1052 const Array *p_moisture_map = nullptr,
1053 const Array *p_elevation_shift = nullptr,
1054 Array *p_erosion_map = nullptr,
1055 Array *p_deposition_map = nullptr,
1056 float c_capacity = 10.f,
1057 float c_erosion = 0.05f,
1058 float c_deposition = 0.05f,
1059 float c_inertia = 0.1f,
1060 float c_gravity = 1.f,
1061 float drag_rate = 0.001f,
1062 float evap_rate = 0.001f,
1063 bool enable_directional_bias = false,
1064 float angle_bias = 30.f);
1065
1067void hydraulic_particle(Array &z,
1068 const Array *p_mask,
1069 int nparticles,
1070 uint seed,
1071 const Array *p_bedrock = nullptr,
1072 const Array *p_moisture_map = nullptr,
1073 const Array *p_elevation_shift = nullptr,
1074 Array *p_erosion_map = nullptr,
1075 Array *p_deposition_map = nullptr,
1076 float c_capacity = 10.f,
1077 float c_erosion = 0.05f,
1078 float c_deposition = 0.05f,
1079 float c_inertia = 0.1f,
1080 float c_gravity = 1.f,
1081 float drag_rate = 0.001f,
1082 float evap_rate = 0.001f,
1083 bool enable_directional_bias = false,
1084 float angle_bias = 30.f);
1085
1134void hydraulic_procedural(
1135 Array &z,
1136 float kp_global,
1137 float c_erosion,
1138 uint seed,
1139 ErosionProfile erosion_profile = ErosionProfile::EP_TRIANGLE_GRENIER,
1140 float erosion_profile_parameter = 0.01f,
1141 float angle_shift = 0.f, // degs
1142 float phase_smoothing = 0.1f,
1143 float talus_ref = 0.001f,
1144 float gradient_scaling_ratio = 1.f,
1145 float gradient_power = 0.8f,
1146 bool exclude_ridges = true,
1147 bool apply_deposition = false,
1148 float deposition_strength = 1.f,
1149 bool enable_default_noise = true,
1150 float noise_amp = 0.01f,
1151 const Array *p_kp_multiplier = nullptr,
1152 const Array *p_angle_shift = nullptr,
1153 const Array *p_noise_x = nullptr,
1154 const Array *p_noise_y = nullptr,
1155 Array *p_ridge_mask = nullptr, // ouptput
1156 glm::vec4 bbox = {0.f, 1.f, 0.f, 1.f});
1157
1196void hydraulic_procedural_fbm(
1197 Array &z,
1198 float kp_global,
1199 float c_erosion,
1200 uint seed,
1201 ErosionProfile erosion_profile = ErosionProfile::EP_TRIANGLE_GRENIER,
1202 int octaves = 3,
1203 float persistence = 0.5f,
1204 float lacunarity = 2.f,
1205 float erosion_profile_parameter = 0.01f,
1206 float angle_shift = 0.f, // degs
1207 float phase_smoothing = 0.1f,
1208 float talus_ref = 0.001f,
1209 float gradient_scaling_ratio = 1.f,
1210 float gradient_power = 0.8f,
1211 bool exclude_ridges = true,
1212 bool apply_deposition = false,
1213 float deposition_strength = 1.f,
1214 bool enable_default_noise = true,
1215 float noise_amp = 0.01f,
1216 const Array *p_kp_multiplier = nullptr,
1217 const Array *p_angle_shift = nullptr,
1218 const Array *p_noise_x = nullptr,
1219 const Array *p_noise_y = nullptr,
1220 Array *p_ridge_mask = nullptr, // ouptput
1221 glm::vec4 bbox = {0.f, 1.f, 0.f, 1.f});
1222
1223void hydraulic_procedural_fbm(
1224 Array &z,
1225 float kp_global,
1226 float c_erosion,
1227 uint seed,
1228 const Array *p_mask,
1229 ErosionProfile erosion_profile = ErosionProfile::EP_TRIANGLE_GRENIER,
1230 int octaves = 3,
1231 float persistence = 0.5f,
1232 float lacunarity = 2.f,
1233 float erosion_profile_parameter = 0.01f,
1234 float angle_shift = 0.f, // degs
1235 float phase_smoothing = 0.1f,
1236 float talus_ref = 0.001f,
1237 float gradient_scaling_ratio = 1.f,
1238 float gradient_power = 0.8f,
1239 bool exclude_ridges = true,
1240 bool apply_deposition = false,
1241 float deposition_strength = 1.f,
1242 bool enable_default_noise = true,
1243 float noise_amp = 0.01f,
1244 const Array *p_kp_multiplier = nullptr,
1245 const Array *p_angle_shift = nullptr,
1246 const Array *p_noise_x = nullptr,
1247 const Array *p_noise_y = nullptr,
1248 Array *p_ridge_mask = nullptr, // ouptput
1249 glm::vec4 bbox = {0.f, 1.f, 0.f, 1.f});
1250
1298void hydraulic_schott(Array &z,
1299 int iterations,
1300 const Array &talus,
1301 float c_erosion = 1.f,
1302 float c_thermal = 0.1f,
1303 float c_deposition = 0.2f,
1304 float flow_acc_exponent = 0.8f,
1305 float flow_acc_exponent_depo = 0.8f,
1306 float flow_routing_exponent = 1.3f,
1307 float thermal_weight = 1.5f,
1308 float deposition_weight = 2.5f,
1309 Array *p_flow = nullptr);
1310
1311void hydraulic_schott(Array &z,
1312 int iterations,
1313 const Array &talus,
1314 Array *p_mask,
1315 float c_erosion = 1.f,
1316 float c_thermal = 0.1f,
1317 float c_deposition = 0.2f,
1318 float flow_acc_exponent = 0.8f,
1319 float flow_acc_exponent_depo = 0.8f,
1320 float flow_routing_exponent = 1.3f,
1321 float thermal_weight = 1.5f,
1322 float deposition_weight = 2.5f,
1323 Array *p_flow = nullptr);
1324
1326void hydraulic_schott_erosion(Array &z,
1327 int iterations,
1328 float c_erosion = 1.f,
1329 float flow_acc_exponent = 0.8f,
1330 float flow_routing_exponent = 1.3f,
1331 const Array *p_moisture_map = nullptr,
1332 Array *p_flow = nullptr);
1333
1335void hydraulic_stream_log(Array &z,
1336 float c_erosion,
1337 float talus_ref,
1338 int deposition_ir = 32,
1339 float deposition_scale_ratio = 1.f,
1340 float gradient_power = 0.8f,
1341 float gradient_scaling_ratio = 1.f,
1342 int gradient_prefilter_ir = 16,
1343 float saturation_ratio = 1.f,
1344 Array *p_bedrock = nullptr,
1345 Array *p_moisture_map = nullptr,
1346 Array *p_erosion_map = nullptr,
1347 Array *p_deposition_map = nullptr,
1348 Array *p_flow_map = nullptr);
1349
1350void hydraulic_stream_log(Array &z,
1351 float c_erosion,
1352 float talus_ref,
1353 const Array *p_mask,
1354 int deposition_ir = 32,
1355 float deposition_scale_ratio = 1.f,
1356 float gradient_power = 0.8f,
1357 float gradient_scaling_ratio = 1.f,
1358 int gradient_prefilter_ir = 16,
1359 float saturation_ratio = 1.f,
1360 Array *p_bedrock = nullptr,
1361 Array *p_moisture_map = nullptr,
1362 Array *p_erosion_map = nullptr,
1363 Array *p_deposition_map = nullptr,
1364 Array *p_flow_map = nullptr);
1365
1367void hydraulic_vpipes(Array &z,
1368 float water_height = 1e-2f,
1369 bool maintain_water_volume = true,
1370 float evap_rate = 0.1f,
1371 int iterations = 50,
1372 float dt = 0.5f,
1373 float k_capacity = 0.5f,
1374 float k_erode = 0.001f,
1375 float k_depose = 0.01f,
1376 float k_discharge_exp = 1.f,
1377 float downcutting_max_depth_ratio = 10.f,
1378 bool flux_diffusion = true,
1379 float flux_diffusion_strength = 0.01f,
1380 Array *p_rain_map = nullptr,
1381 Array *p_water_depth = nullptr,
1382 Array *p_sediment = nullptr,
1383 Array *p_vel_u = nullptr,
1384 Array *p_vel_v = nullptr);
1385
1414void mudslide(Array &z,
1415 const Array &landslide_mask,
1416 float depth,
1417 int iterations,
1418 float depth_map_exponent = 0.5f,
1419 float viscosity_law_power = 1.5f,
1420 Array *p_depth_end = nullptr,
1421 Array *p_depth_init = nullptr);
1422
1424void mudslide(Array &z,
1425 float talus_limit,
1426 float depth,
1427 int iterations,
1428 float depth_map_exponent = 0.5f,
1429 float viscosity_law_power = 1.5f,
1430 Array *p_depth_end = nullptr,
1431 Array *p_depth_init = nullptr);
1432
1484void rifts(Array &z,
1485 const glm::vec2 &kw, // = {4.f, 1.2f},
1486 float angle, // degs
1487 float amplitude,
1488 uint seed,
1489 float elevation_noise_shift = 0.f,
1490 float k_smooth_bottom = 0.05f,
1491 float k_smooth_top = 0.05f,
1492 float radial_spread_amp = 0.2f,
1493 float elevation_noise_amp = 0.1f,
1494 float clamp_vmin = 0.f,
1495 float remap_vmin = 0.f,
1496 bool apply_mask = true,
1497 bool reverse_mask = false,
1498 float mask_gamma = 1.f,
1499 const Array *p_noise_x = nullptr,
1500 const Array *p_noise_y = nullptr,
1501 const Array *p_mask = nullptr,
1502 const glm::vec2 &center = {0.5f, 0.5f},
1503 const glm::vec4 &bbox = {0.f, 1.f, 0.f, 1.f});
1504
1527void sediment_deposition(Array &z,
1528 Array *p_mask,
1529 const Array &talus,
1530 Array *p_deposition_map = nullptr,
1531 float max_deposition = 0.01,
1532 int iterations = 5,
1533 int thermal_subiterations = 10);
1534
1535void sediment_deposition(Array &z,
1536 const Array &talus,
1537 Array *p_deposition_map = nullptr,
1538 float max_deposition = 0.01,
1539 int iterations = 5,
1540 int thermal_subiterations = 10);
1541
1563void sediment_layer(Array &z,
1564 const Array &talus_layer,
1565 const Array &talus_upper_limit,
1566 int iterations,
1567 bool apply_post_filter = true,
1568 Array *p_deposition_map = nullptr);
1569
1627void strata(Array &z,
1628 float angle,
1629 float slope,
1630 float gamma, // e.g 0.5f or 1.5f
1631 uint seed,
1632 bool linear_gamma = true,
1633 float kz = 1.f,
1634 int octaves = 4,
1635 float lacunarity = 2.f,
1636 float gamma_noise_ratio = 0.5f,
1637 float noise_amp = 0.4f,
1638 const glm::vec2 &noise_kw = {4.f, 4.f},
1639 bool enable_ridge_noise = true,
1640 const glm::vec2 &ridge_noise_kw = {4.f, 1.2f},
1641 float ridge_angle_shift = 45.f,
1642 float ridge_noise_amp = 0.5f,
1643 float ridge_clamp_vmin = 0.f,
1644 float ridge_remap_vmin = 0.f,
1645 bool apply_elevation_mask = true,
1646 bool apply_ridge_mask = true,
1647 float mask_gamma = 0.4f,
1648 const Array *p_mask = nullptr,
1649 const glm::vec4 &bbox = {0.f, 1.f, 0.f, 1.f});
1650
1677void strata_cells(Array &z,
1678 glm::vec2 kw,
1679 float amp,
1680 uint seed,
1681 float gamma = 0.5f,
1682 float gamma_lateral = 0.4f,
1683 float angle = 0.f,
1684 float noise_amp = 0.5f,
1685 bool absolute_displacement = true,
1686 float occurence_probability = 0.5f,
1687 const Array *p_noise_x = nullptr,
1688 const Array *p_noise_y = nullptr,
1689 glm::vec4 bbox = {0.f, 1.f, 0.f, 1.f});
1690
1718void strata_cells(Array &z,
1719 glm::vec2 kw,
1720 float amp,
1721 uint seed,
1722 const Array *p_mask,
1723 float gamma = 0.5f,
1724 float gamma_lateral = 0.4f,
1725 float angle = 0.f,
1726 float noise_amp = 0.5f,
1727 bool absolute_displacement = true,
1728 float occurence_probability = 0.5f,
1729 const Array *p_noise_x = nullptr,
1730 const Array *p_noise_y = nullptr,
1731 glm::vec4 bbox = {0.f, 1.f, 0.f, 1.f});
1732
1763void strata_cells_fbm(Array &z,
1764 glm::vec2 kw,
1765 float amp,
1766 uint seed,
1767 float gamma = 0.5f,
1768 float gamma_lateral = 0.4f,
1769 float angle = 0.f,
1770 bool enable_default_noise = true,
1771 float default_noise_amp = 0.05f,
1772 bool absolute_displacement = true,
1773 float occurence_probability = 0.5f,
1774 int octaves = 8,
1775 float persistence = 0.4f,
1776 float lacunarity = 2.2f,
1777 const Array *p_noise_x = nullptr,
1778 const Array *p_noise_y = nullptr,
1779 glm::vec4 bbox = {0.f, 1.f, 0.f, 1.f});
1780
1812void strata_cells_fbm(Array &z,
1813 glm::vec2 kw,
1814 float amp,
1815 uint seed,
1816 const Array *p_mask,
1817 float gamma = 0.5f,
1818 float gamma_lateral = 0.4f,
1819 float angle = 0.f,
1820 bool enable_default_noise = true,
1821 float default_noise_amp = 0.05f,
1822 bool absolute_displacement = true,
1823 float occurence_probability = 0.5f,
1824 int octaves = 8,
1825 float persistence = 0.4f,
1826 float lacunarity = 2.2f,
1827 const Array *p_noise_x = nullptr,
1828 const Array *p_noise_y = nullptr,
1829 glm::vec4 bbox = {0.f, 1.f, 0.f, 1.f});
1830
1852void strata_terrace(Array &z,
1853 float gamma, // e.g 0.5f or 1.5f
1854 uint seed,
1855 float kz = 4.f, // 4-layers
1856 bool linear_gamma = true,
1857 float gamma_noise_ratio = 0.5f,
1858 const Array *p_noise = nullptr);
1859
1881void strata_terrace(Array &z,
1882 float gamma, // e.g 0.5f or 1.5f
1883 uint seed,
1884 const Array *p_mask,
1885 float kz = 4.f, // 4-layers
1886 bool linear_gamma = true,
1887 float gamma_noise_ratio = 0.5f,
1888 const Array *p_noise = nullptr);
1889
1891void thermal(Array &z,
1892 const Array &talus,
1893 int iterations = 10,
1894 Array *p_bedrock = nullptr,
1895 Array *p_deposition_map = nullptr);
1896
1898void thermal(Array &z,
1899 Array *p_mask,
1900 const Array &talus,
1901 int iterations = 10,
1902 Array *p_bedrock = nullptr,
1903 Array *p_deposition_map = nullptr);
1904
1906void thermal(Array &z,
1907 float talus,
1908 int iterations = 10,
1909 Array *p_bedrock = nullptr,
1910 Array *p_deposition_map = nullptr);
1911
1913void thermal_auto_bedrock(Array &z,
1914 const Array &talus,
1915 int iterations = 10,
1916 Array *p_deposition_map = nullptr);
1917
1919void thermal_auto_bedrock(Array &z,
1920 Array *p_mask,
1921 const Array &talus,
1922 int iterations = 10,
1923 Array *p_deposition_map = nullptr);
1924
1926void thermal_auto_bedrock(Array &z,
1927 float,
1928 int iterations = 10,
1929 Array *p_deposition_map = nullptr);
1930
1932void thermal_olsen(Array &z, const Array &talus, int iterations);
1933void thermal_olsen(Array &z, Array *p_mask, const Array &talus, int iterations);
1934
1952void thermal_inflate(Array &z, const Array &talus, int iterations = 10);
1953
1954void thermal_inflate(Array &z,
1955 const Array *p_mask,
1956 const Array &talus,
1957 int iterations = 10);
1958
1960void thermal_rib(Array &z, int iterations, Array *p_bedrock = nullptr);
1961
1981void thermal_ridge(Array &z,
1982 const Array &talus,
1983 int iterations = 10,
1984 Array *p_deposition_map = nullptr);
1985
1986void thermal_ridge(Array &z,
1987 const Array *p_mask,
1988 const Array &talus,
1989 int iterations = 10,
1990 Array *p_deposition_map = nullptr);
1991
2011void thermal_scree(Array &z,
2012 const Array &talus,
2013 const Array &zmax,
2014 int iterations = 10,
2015 Array *p_deposition_map = nullptr);
2016
2017void thermal_scree(Array &z,
2018 const Array *p_mask,
2019 const Array &talus,
2020 const Array &zmax,
2021 int iterations = 10,
2022 Array *p_deposition_map = nullptr);
2023
2044void valley_fill(Array &z,
2045 const Array &talus,
2046 int iterations = 100,
2047 float gamma = 2.f,
2048 float ratio = 0.8f,
2049 float zmin = 0.f,
2050 float zmax = 0.f,
2051 float elevation_max_ratio = 1.f,
2052 bool preserve_elevation_range = true,
2053 const Array *p_noise = nullptr,
2054 Array *p_deposition_map = nullptr);
2055
2056void valley_fill(Array &z,
2057 const Array *p_mask,
2058 const Array &talus,
2059 int iterations = 100,
2060 float gamma = 2.f,
2061 float ratio = 0.8f,
2062 float zmin = 0.f,
2063 float zmax = 0.f,
2064 float elevation_max_ratio = 1.f,
2065 bool preserve_elevation_range = true,
2066 const Array *p_noise = nullptr,
2067 Array *p_deposition_map = nullptr);
2068
2090Array watershed_ridge(
2091 const Array &z,
2092 float amplitude = 0.2f,
2093 float width = 32.f, // pixels
2094 float edt_exponent = 0.5f,
2095 int prefilter_ir = 0,
2096 FlowDirectionMethod fd_method = FlowDirectionMethod::FDM_D8,
2097 const Array *p_noise_x = nullptr,
2098 const Array *p_noise_y = nullptr,
2099 const Array *p_scaling = nullptr);
2100
2101Array watershed_ridge(
2102 const Array &z,
2103 const Array *p_mask,
2104 float amplitude = 0.2f,
2105 float width = 32.f,
2106 float edt_exponent = 0.5f,
2107 int prefilter_ir = 0,
2108 FlowDirectionMethod fd_method = FlowDirectionMethod::FDM_D8,
2109 const Array *p_noise_x = nullptr,
2110 const Array *p_noise_y = nullptr,
2111 const Array *p_scaling = nullptr);
2112
2113} // 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::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::strata_cells_fbm
void strata_cells_fbm(Array &z, glm::vec2 kw, float amp, uint seed, float gamma=0.5f, float gamma_lateral=0.4f, float angle=0.f, bool enable_default_noise=true, float default_noise_amp=0.05f, bool absolute_displacement=true, float occurence_probability=0.5f, int octaves=8, float persistence=0.4f, float lacunarity=2.2f, const Array *p_noise_x=nullptr, const Array *p_noise_y=nullptr, glm::vec4 bbox={0.f, 1.f, 0.f, 1.f})
Applies multi-octave (fBm) stratified cell displacement.
Definition strata_gpu.cpp:173
hmap::gpu::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::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::mudslide
void mudslide(Array &z, const Array &landslide_mask, float depth, int iterations, float depth_map_exponent=0.5f, float viscosity_law_power=1.5f, Array *p_depth_end=nullptr, Array *p_depth_init=nullptr)
Simulate a mudslide (landslide-driven material redistribution) on a height field.
Definition mudslide.cpp:15
hmap::gpu::watershed_ridge
Array watershed_ridge(const Array &z, float amplitude=0.2f, float width=32.f, float edt_exponent=0.5f, int prefilter_ir=0, FlowDirectionMethod fd_method=FlowDirectionMethod::FDM_D8, const Array *p_noise_x=nullptr, const Array *p_noise_y=nullptr, const Array *p_scaling=nullptr)
Carves watershed ridges using basin-wise distance transforms.
Definition watershed_ridge.cpp:19
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, float downcutting_max_depth_ratio=10.f, bool flux_diffusion=true, float flux_diffusion_strength=0.01f, 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::hydraulic_procedural_fbm
void hydraulic_procedural_fbm(Array &z, float kp_global, float c_erosion, uint seed, ErosionProfile erosion_profile=ErosionProfile::EP_TRIANGLE_GRENIER, int octaves=3, float persistence=0.5f, float lacunarity=2.f, float erosion_profile_parameter=0.01f, float angle_shift=0.f, float phase_smoothing=0.1f, float talus_ref=0.001f, float gradient_scaling_ratio=1.f, float gradient_power=0.8f, bool exclude_ridges=true, bool apply_deposition=false, float deposition_strength=1.f, bool enable_default_noise=true, float noise_amp=0.01f, const Array *p_kp_multiplier=nullptr, const Array *p_angle_shift=nullptr, const Array *p_noise_x=nullptr, const Array *p_noise_y=nullptr, Array *p_ridge_mask=nullptr, glm::vec4 bbox={0.f, 1.f, 0.f, 1.f})
Multi-octave (fBm) variant of hydraulic_procedural().
Definition hydraulic_procedural.cpp:196
hmap::gpu::strata_cells
void strata_cells(Array &z, glm::vec2 kw, float amp, uint seed, float gamma=0.5f, float gamma_lateral=0.4f, float angle=0.f, float noise_amp=0.5f, bool absolute_displacement=true, float occurence_probability=0.5f, const Array *p_noise_x=nullptr, const Array *p_noise_y=nullptr, glm::vec4 bbox={0.f, 1.f, 0.f, 1.f})
Applies procedural stratified cell displacement to a heightmap.
Definition strata_gpu.cpp:74
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::strata_terrace
void strata_terrace(Array &z, float gamma, uint seed, float kz=4.f, bool linear_gamma=true, float gamma_noise_ratio=0.5f, const Array *p_noise=nullptr)
Applies a terrace (stratification) filter to a heightmap.
Definition strata_gpu.cpp:321
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, const Array *p_moisture_map=nullptr, Array *p_flow=nullptr)
See hmap::hydraulic_schott.
Definition hydraulic_schott_gpu.cpp:125
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::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}, bool enable_ridge_noise=true, 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:14
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::hydraulic_particle
void hydraulic_particle(Array &z, int nparticles, uint seed, const Array *p_bedrock=nullptr, const Array *p_moisture_map=nullptr, const Array *p_elevation_shift=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.1f, float c_gravity=1.f, float drag_rate=0.001f, float evap_rate=0.001f, bool enable_directional_bias=false, float angle_bias=30.f)
Simulates hydraulic erosion on a heightmap using particle-based flow.
Definition erosion_gpu.cpp:13
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::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)
Applies a talus-based sediment deposition layer.
Definition deposition.cpp:75
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::hydraulic_procedural
void hydraulic_procedural(Array &z, float kp_global, float c_erosion, uint seed, ErosionProfile erosion_profile=ErosionProfile::EP_TRIANGLE_GRENIER, float erosion_profile_parameter=0.01f, float angle_shift=0.f, float phase_smoothing=0.1f, float talus_ref=0.001f, float gradient_scaling_ratio=1.f, float gradient_power=0.8f, bool exclude_ridges=true, bool apply_deposition=false, float deposition_strength=1.f, bool enable_default_noise=true, float noise_amp=0.01f, const Array *p_kp_multiplier=nullptr, const Array *p_angle_shift=nullptr, const Array *p_noise_x=nullptr, const Array *p_noise_y=nullptr, Array *p_ridge_mask=nullptr, glm::vec4 bbox={0.f, 1.f, 0.f, 1.f})
Apply phase-guided hydraulic procedural erosion to a heightmap.
Definition hydraulic_procedural.cpp:24
hmap
Definition algebra.hpp:23
hmap::get_erosion_profile_function
std::function< float(float)> get_erosion_profile_function(const ErosionProfile &erosion_profile, float delta, float &profile_avg)
Definition get_erosion_profile_function.cpp:84
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::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::EP_COSINE
@ EP_COSINE
Definition erosion.hpp:45
hmap::EP_PARABOL
@ EP_PARABOL
Definition erosion.hpp:48
hmap::EP_TRIANGLE_SMOOTH
@ EP_TRIANGLE_SMOOTH
Definition erosion.hpp:55
hmap::EP_TRIANGLE_GRENIER
@ EP_TRIANGLE_GRENIER
Definition erosion.hpp:53
hmap::EP_COSINE_BULK
@ EP_COSINE_BULK
Definition erosion.hpp:46
hmap::EP_SHARP_VALLEYS
@ EP_SHARP_VALLEYS
Definition erosion.hpp:51
hmap::EP_SAW_SMOOTH
@ EP_SAW_SMOOTH
Definition erosion.hpp:50
hmap::EP_SAW_SHARP
@ EP_SAW_SHARP
Definition erosion.hpp:49
hmap::EP_COSINE_PEAK
@ EP_COSINE_PEAK
Definition erosion.hpp:47
hmap::EP_TRIANGLE_SHARP
@ EP_TRIANGLE_SHARP
Definition erosion.hpp:54
hmap::EP_SQRT
@ EP_SQRT
Definition erosion.hpp:52
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::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::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::check_erosion_profile_function
std::vector< hmap::ErosionProfile > check_erosion_profile_function(float delta=0.01f)
Definition get_erosion_profile_function.cpp:17
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::generate_bedrock
Array generate_bedrock(const Array &z, float elevation_strength, float slope_strength, float slope_limit, float zmin=0.f, float zmax=-1.f)
Generates a modified bedrock heightmap from an input elevation array.
Definition generate_bedrock.cpp:10
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