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
21// neighbor pattern search based on Moore pattern and define diagonal
22// weight coefficients ('c' corresponds to a weight coefficient
23// applied to take into account the longer distance for diagonal
24// comparison between cells)
25
26// 6 2 8
27// 1 . 4
28// 5 3 7
29// clang-format off
30#define DI {-1, 0, 0, 1, -1, -1, 1, 1}
31#define DJ {0, 1, -1, 0, -1, 1, -1, 1}
32#define CD {1.f, 1.f, 1.f, 1.f, M_SQRT2, M_SQRT2, M_SQRT2, M_SQRT2}
33// clang-format on
34
35namespace hmap
36{
37
52
53std::function<float(float)> get_erosion_profile_function(
54 const ErosionProfile &erosion_profile,
55 float delta,
56 float &profile_avg);
57
95void coastal_erosion_diffusion(Array &z,
96 Array &water_depth,
97 float additional_depth,
98 int iterations = 10,
99 Array *p_water_mask = nullptr);
100
148void coastal_erosion_profile(Array &z,
149 Array &water_depth,
150 float shore_ground_extent, // pixels
151 float shore_water_extent,
152 float slope_shore = 0.5f,
153 float slope_shore_water = 0.5f,
154 float scarp_extent_ratio = 0.5f, // in [0, 1]
155 bool apply_post_filter = true,
156 Array *p_shore_mask = nullptr);
157
158void coastal_erosion_profile(Array &z,
159 const Array *p_mask,
160 Array &water_depth,
161 float shore_ground_extent, // pixels
162 float shore_water_extent,
163 float slope_shore = 0.5f,
164 float slope_shore_water = 0.5f,
165 float scarp_extent_ratio = 0.5f, // in [0, 1]
166 bool apply_post_filter = true,
167 Array *p_shore_mask = nullptr);
168
186void depression_filling(Array &z, int iterations = 1000, float epsilon = 1e-4f);
187
204void erosion_maps(Array &z_before,
205 Array &z_after,
206 Array &erosion_map,
207 Array &deposition_map,
208 float tolerance = 0.f);
209
234void hydraulic_algebric(Array &z,
235 Array *p_mask,
236 float talus_ref,
237 int ir,
238 Array *p_bedrock = nullptr,
239 Array *p_erosion_map = nullptr,
240 Array *p_deposition_map = nullptr,
241 float c_erosion = 0.05f,
242 float c_deposition = 0.05f,
243 int iterations = 1);
244
245void hydraulic_algebric(Array &z,
246 float talus_ref,
247 int ir,
248 Array *p_bedrock = nullptr,
249 Array *p_erosion_map = nullptr,
250 Array *p_deposition_map = nullptr,
251 float c_erosion = 0.05f,
252 float c_deposition = 0.05f,
253 int iterations = 1);
254
285void hydraulic_benes(Array &z,
286 Array *p_mask,
287 int iterations = 50,
288 Array *p_bedrock = nullptr,
289 Array *p_moisture_map = nullptr,
290 Array *p_erosion_map = nullptr,
291 Array *p_deposition_map = nullptr,
292 float c_capacity = 40.f,
293 float c_erosion = 0.2f,
294 float c_deposition = 0.8f,
295 float water_level = 0.005f,
296 float evap_rate = 0.01f,
297 float rain_rate = 0.5f);
298
299void hydraulic_benes(Array &z,
300 int iterations = 50,
301 Array *p_bedrock = nullptr,
302 Array *p_moisture_map = nullptr,
303 Array *p_erosion_map = nullptr,
304 Array *p_deposition_map = nullptr,
305 float c_capacity = 40.f,
306 float c_erosion = 0.2f,
307 float c_deposition = 0.8f,
308 float water_level = 0.005f,
309 float evap_rate = 0.01f,
310 float rain_rate = 0.5f);
311
325void hydraulic_blur(Array &z,
326 float radius,
327 float vmax,
328 float k_smoothing = 0.1f);
329
347void hydraulic_diffusion(Array &z,
348 float c_diffusion,
349 float talus,
350 int iterations);
374void hydraulic_musgrave(Array &z,
375 Array &moisture_map,
376 int iterations = 100,
377 float c_capacity = 1.f,
378 float c_erosion = 0.1f,
379 float c_deposition = 0.1f,
380 float water_level = 0.01f,
381 float evap_rate = 0.01f);
382
383void hydraulic_musgrave(Array &z,
384 int iterations = 100,
385 float c_capacity = 1.f,
386 float c_erosion = 0.1f,
387 float c_deposition = 0.1f,
388 float water_level = 0.01f,
389 float evap_rate = 0.01f);
390
421void hydraulic_particle(Array &z,
422 Array *p_mask,
423 int nparticles,
424 int seed,
425 Array *p_bedrock = nullptr,
426 Array *p_moisture_map = nullptr,
427 Array *p_erosion_map = nullptr, // -> out
428 Array *p_deposition_map = nullptr, // -> out
429 float c_capacity = 10.f,
430 float c_erosion = 0.05f,
431 float c_deposition = 0.05f,
432 float c_inertia = 0.3f,
433 float drag_rate = 0.001f,
434 float evap_rate = 0.001f,
435 bool post_filtering = false);
436
437void hydraulic_particle(Array &z,
438 int nparticles,
439 int seed,
440 Array *p_bedrock = nullptr,
441 Array *p_moisture_map = nullptr,
442 Array *p_erosion_map = nullptr, // -> out
443 Array *p_deposition_map = nullptr, // -> out
444 float c_capacity = 10.f,
445 float c_erosion = 0.05f,
446 float c_deposition = 0.05f,
447 float c_inertia = 0.3f,
448 float drag_rate = 0.001f,
449 float evap_rate = 0.001f,
450 bool post_filtering = false);
451
485void hydraulic_particle_multiscale(Array &z,
486 float particle_density,
487 int seed,
488 Array *p_bedrock = nullptr,
489 Array *p_moisture_map = nullptr,
490 Array *p_erosion_map = nullptr, // -> out
491 Array *p_deposition_map = nullptr, // -> out
492 float c_capacity = 10.f,
493 float c_erosion = 0.05f,
494 float c_deposition = 0.01f,
495 float c_inertia = 0.3f,
496 float drag_rate = 0.01f,
497 float evap_rate = 0.001f,
498 int pyramid_finest_level = 0);
499
548void hydraulic_procedural(
549 Array &z,
550 uint seed,
551 float ridge_wavelength,
552 float ridge_scaling = 0.1f,
553 ErosionProfile erosion_profile = ErosionProfile::TRIANGLE_SMOOTH,
554 float delta = 0.02f,
555 float noise_ratio = 0.2f,
556 int prefilter_ir = -1,
557 float density_factor = 1.f,
558 float kernel_width_ratio = 2.f,
559 float phase_smoothing = 2.f,
560 float phase_noise_amp = M_PI,
561 bool reverse_phase = false,
562 bool rotate90 = false,
563 bool use_default_mask = true,
564 float talus_mask = 0.f,
565 Array *p_mask = nullptr,
566 Array *p_ridge_mask = nullptr,
567 float vmin = 0.f,
568 float vmax = -1.f);
569
597void hydraulic_stream(Array &z,
598 float c_erosion,
599 float talus_ref,
600 Array *p_bedrock = nullptr,
601 Array *p_moisture_map = nullptr,
602 Array *p_erosion_map = nullptr, // -> out
603 int ir = 1,
604 float clipping_ratio = 10.f);
605
606void hydraulic_stream(Array &z,
607 Array *p_mask,
608 float c_erosion,
609 float talus_ref,
610 Array *p_bedrock = nullptr,
611 Array *p_moisture_map = nullptr,
612 Array *p_erosion_map = nullptr, // -> out
613 int ir = 1,
614 float clipping_ratio = 10.f);
615
648void hydraulic_stream_upscale_amplification(Array &z,
649 float c_erosion,
650 float talus_ref,
651 int upscaling_levels = 1,
652 float persistence = 1.f,
653 int ir = 1,
654 float clipping_ratio = 10.f);
655
689void hydraulic_stream_upscale_amplification(
690 Array &z,
691 Array *p_mask,
692 float c_erosion,
693 float talus_ref,
694 int upscaling_levels = 1,
695 float persistence = 1.f,
696 int ir = 1,
697 float clipping_ratio = 10.f);
698
737void hydraulic_stream_log(Array &z,
738 float c_erosion,
739 float talus_ref,
740 int deposition_ir = 32,
741 float deposition_scale_ratio = 1.f,
742 float gradient_power = 0.8f,
743 float gradient_scaling_ratio = 1.f,
744 int gradient_prefilter_ir = 16,
745 float saturation_ratio = 1.f,
746 Array *p_bedrock = nullptr,
747 Array *p_moisture_map = nullptr,
748 Array *p_erosion_map = nullptr,
749 Array *p_deposition_map = nullptr,
750 Array *p_flow_map = nullptr);
751
752void hydraulic_stream_log(Array &z,
753 float c_erosion,
754 float talus_ref,
755 Array *p_mask,
756 int deposition_ir = 32,
757 float deposition_scale_ratio = 1.f,
758 float gradient_power = 0.8f,
759 float gradient_scaling_ratio = 1.f,
760 int gradient_prefilter_ir = 16,
761 float saturation_ratio = 1.f,
762 Array *p_bedrock = nullptr,
763 Array *p_moisture_map = nullptr,
764 Array *p_erosion_map = nullptr,
765 Array *p_deposition_map = nullptr,
766 Array *p_flow_map = nullptr);
767
796void hydraulic_vpipes(Array &z,
797 Array *p_mask,
798 int iterations,
799 Array *p_bedrock = nullptr,
800 Array *p_moisture_map = nullptr,
801 Array *p_erosion_map = nullptr,
802 Array *p_deposition_map = nullptr,
803 float water_height = 0.1f,
804 float c_capacity = 0.1f,
805 float c_erosion = 0.05f,
806 float c_deposition = 0.05f,
807 float rain_rate = 0.f,
808 float evap_rate = 0.01f);
809
810void hydraulic_vpipes(Array &z,
811 int iterations,
812 Array *p_bedrock = nullptr,
813 Array *p_moisture_map = nullptr,
814 Array *p_erosion_map = nullptr,
815 Array *p_deposition_map = nullptr,
816 float water_height = 0.1f,
817 float c_capacity = 0.1f,
818 float c_erosion = 0.05f,
819 float c_deposition = 0.05f,
820 float rain_rate = 0.f,
821 float evap_rate = 0.01f);
822
845void sediment_deposition(Array &z,
846 Array *p_mask,
847 const Array &talus,
848 Array *p_deposition_map = nullptr,
849 float max_deposition = 0.01,
850 int iterations = 5,
851 int thermal_subiterations = 10);
852
853void sediment_deposition(Array &z,
854 const Array &talus,
855 Array *p_deposition_map = nullptr,
856 float max_deposition = 0.01,
857 int iterations = 5,
858 int thermal_subiterations = 10);
859
883void sediment_deposition_particle(Array &z,
884 Array *p_mask,
885 int nparticles,
886 int ir,
887 int seed = 1,
888 Array *p_spawning_map = nullptr,
889 Array *p_deposition_map = nullptr,
890 float particle_initial_sediment = 0.1f,
891 float deposition_velocity_limit = 0.01f,
892 float drag_rate = 0.001f);
893
894void sediment_deposition_particle(Array &z,
895 int nparticles,
896 int ir,
897 int seed = 1,
898 Array *p_spawning_map = nullptr,
899 Array *p_deposition_map = nullptr,
900 float particle_initial_sediment = 0.1f,
901 float deposition_velocity_limit = 0.01f,
902 float drag_rate = 0.001f);
903
904void sediment_layer(Array &z,
905 const Array &talus_layer,
906 const Array &talus_upper_limit,
907 int iterations,
908 bool apply_post_filter = true,
909 Array *p_deposition_map = nullptr);
910
930void stratify(Array &z,
931 Array *p_mask,
932 std::vector<float> hs,
933 std::vector<float> gamma,
934 Array *p_noise = nullptr);
935
936void stratify(Array &z,
937 std::vector<float> hs,
938 std::vector<float> gamma,
939 Array *p_noise = nullptr);
940
941void stratify(Array &z,
942 std::vector<float> hs,
943 float gamma = 0.5f,
944 Array *p_noise = nullptr);
945
946void stratify(Array &z,
947 Array &partition,
948 int nstrata,
949 float strata_noise,
950 float gamma,
951 float gamma_noise,
952 int npartitions,
953 uint seed,
954 float mixing_gain_factor = 1.f,
955 Array *p_noise = nullptr,
956 float vmin = 1.f,
957 float vmax = 0.f);
958
982void stratify_multiscale(Array &z,
983 float zmin,
984 float zmax,
985 std::vector<int> n_strata,
986 std::vector<float> strata_noise,
987 std::vector<float> gamma_list,
988 std::vector<float> gamma_noise,
989 uint seed,
990 Array *p_mask = nullptr,
991 Array *p_noise = nullptr);
992
1013void stratify_oblique(Array &z,
1014 Array *p_mask,
1015 std::vector<float> hs,
1016 std::vector<float> gamma,
1017 float talus,
1018 float angle,
1019 Array *p_noise = nullptr);
1020
1021void stratify_oblique(Array &z,
1022 std::vector<float> hs,
1023 std::vector<float> gamma,
1024 float talus,
1025 float angle,
1026 Array *p_noise = nullptr);
1027
1047void thermal(Array &z,
1048 Array *p_mask,
1049 const Array &talus,
1050 int iterations = 10,
1051 Array *p_bedrock = nullptr,
1052 Array *p_deposition_map = nullptr);
1053
1054void thermal(Array &z,
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 float talus,
1062 int iterations = 10,
1063 Array *p_bedrock = nullptr,
1064 Array *p_deposition_map = nullptr);
1065
1087void thermal_auto_bedrock(Array &z,
1088 const Array &talus,
1089 int iterations = 10,
1090 Array *p_deposition_map = nullptr);
1091
1092void thermal_auto_bedrock(Array &z,
1093 float talus,
1094 int iterations = 10,
1095 Array *p_deposition_map = nullptr);
1096
1097void thermal_auto_bedrock(Array &z,
1098 Array *p_mask,
1099 float talus,
1100 int iterations = 10,
1101 Array *p_deposition_map = nullptr);
1102
1120void thermal_flatten(Array &z,
1121 const Array &talus,
1122 const Array &bedrock,
1123 int iterations = 10,
1124 int post_filter_ir = 1);
1125
1126void thermal_flatten(Array &z,
1127 float talus,
1128 int iterations = 10,
1129 int post_filter_ir = 1);
1130
1150void thermal_olsen(Array &z,
1151 const Array &talus,
1152 int iterations = 10,
1153 Array *p_bedrock = nullptr,
1154 Array *p_deposition_map = nullptr);
1155
1168void thermal_rib(Array &z, int iterations, Array *p_bedrock = nullptr);
1169
1193void thermal_schott(Array &z,
1194 const Array &talus,
1195 int iterations = 10,
1196 float intensity = 0.001f);
1197
1198void thermal_schott(Array &z,
1199 const Array &talus,
1200 Array *p_mask,
1201 int iterations = 10,
1202 float intensity = 0.001f);
1203
1225void thermal_schott(Array &z,
1226 const float talus,
1227 int iterations = 10,
1228 float intensity = 0.001f);
1229
1230void thermal_schott(Array &z,
1231 const float talus,
1232 Array *p_mask,
1233 int iterations = 10,
1234 float intensity = 0.001f);
1235
1236} // namespace hmap
1237
1238namespace hmap::gpu
1239{
1240
1242void hydraulic_particle(Array &z,
1243 int nparticles,
1244 int seed,
1245 Array *p_bedrock = nullptr,
1246 Array *p_moisture_map = nullptr,
1247 Array *p_erosion_map = nullptr,
1248 Array *p_deposition_map = nullptr,
1249 float c_capacity = 10.f,
1250 float c_erosion = 0.05f,
1251 float c_deposition = 0.05f,
1252 float c_inertia = 0.3f,
1253 float drag_rate = 0.001f,
1254 float evap_rate = 0.001f,
1255 bool post_filtering = false);
1256
1258void hydraulic_particle(Array &z,
1259 Array *p_mask,
1260 int nparticles,
1261 int seed,
1262 Array *p_bedrock = nullptr,
1263 Array *p_moisture_map = nullptr,
1264 Array *p_erosion_map = nullptr,
1265 Array *p_deposition_map = nullptr,
1266 float c_capacity = 10.f,
1267 float c_erosion = 0.05f,
1268 float c_deposition = 0.05f,
1269 float c_inertia = 0.3f,
1270 float drag_rate = 0.001f,
1271 float evap_rate = 0.001f,
1272 bool post_filtering = false);
1273
1320void hydraulic_schott(Array &z,
1321 int iterations,
1322 const Array &talus,
1323 float c_erosion = 1.f,
1324 float c_thermal = 0.1f,
1325 float c_deposition = 0.2f,
1326 float flow_acc_exponent = 0.8f,
1327 float flow_acc_exponent_depo = 0.8f,
1328 float flow_routing_exponent = 1.3f,
1329 float thermal_weight = 1.5f,
1330 float deposition_weight = 2.5f,
1331 Array *p_flow = nullptr);
1332
1333void hydraulic_schott(Array &z,
1334 int iterations,
1335 const Array &talus,
1336 Array *p_mask,
1337 float c_erosion = 1.f,
1338 float c_thermal = 0.1f,
1339 float c_deposition = 0.2f,
1340 float flow_acc_exponent = 0.8f,
1341 float flow_acc_exponent_depo = 0.8f,
1342 float flow_routing_exponent = 1.3f,
1343 float thermal_weight = 1.5f,
1344 float deposition_weight = 2.5f,
1345 Array *p_flow = nullptr);
1346
1348void hydraulic_stream_log(Array &z,
1349 float c_erosion,
1350 float talus_ref,
1351 int deposition_ir = 32,
1352 float deposition_scale_ratio = 1.f,
1353 float gradient_power = 0.8f,
1354 float gradient_scaling_ratio = 1.f,
1355 int gradient_prefilter_ir = 16,
1356 float saturation_ratio = 1.f,
1357 Array *p_bedrock = nullptr,
1358 Array *p_moisture_map = nullptr,
1359 Array *p_erosion_map = nullptr,
1360 Array *p_deposition_map = nullptr,
1361 Array *p_flow_map = nullptr);
1362
1363void hydraulic_stream_log(Array &z,
1364 float c_erosion,
1365 float talus_ref,
1366 Array *p_mask,
1367 int deposition_ir = 32,
1368 float deposition_scale_ratio = 1.f,
1369 float gradient_power = 0.8f,
1370 float gradient_scaling_ratio = 1.f,
1371 int gradient_prefilter_ir = 16,
1372 float saturation_ratio = 1.f,
1373 Array *p_bedrock = nullptr,
1374 Array *p_moisture_map = nullptr,
1375 Array *p_erosion_map = nullptr,
1376 Array *p_deposition_map = nullptr,
1377 Array *p_flow_map = nullptr);
1378
1430void rifts(Array &z,
1431 const Vec2<float> &kw, // = {4.f, 1.2f},
1432 float angle, // degs
1433 float amplitude,
1434 uint seed,
1435 float elevation_noise_shift = 0.f,
1436 float k_smooth_bottom = 0.05f,
1437 float k_smooth_top = 0.05f,
1438 float radial_spread_amp = 0.2f,
1439 float elevation_noise_amp = 0.1f,
1440 float clamp_vmin = 0.f,
1441 float remap_vmin = 0.f,
1442 bool apply_mask = true,
1443 bool reverse_mask = false,
1444 float mask_gamma = 1.f,
1445 const Array *p_noise_x = nullptr,
1446 const Array *p_noise_y = nullptr,
1447 const Array *p_mask = nullptr,
1448 const Vec2<float> &center = {0.5f, 0.5f},
1449 const Vec4<float> &bbox = {0.f, 1.f, 0.f, 1.f});
1450
1508void strata(Array &z,
1509 float angle,
1510 float slope,
1511 float gamma, // e.g 0.5f or 1.5f
1512 uint seed,
1513 bool linear_gamma = true,
1514 float kz = 1.f,
1515 int octaves = 4,
1516 float lacunarity = 2.f,
1517 float gamma_noise_ratio = 0.5f,
1518 float noise_amp = 0.4f,
1519 const Vec2<float> &noise_kw = {4.f, 4.f},
1520 const Vec2<float> &ridge_noise_kw = {4.f, 1.2f},
1521 float ridge_angle_shift = 45.f,
1522 float ridge_noise_amp = 0.5f,
1523 float ridge_clamp_vmin = 0.f,
1524 float ridge_remap_vmin = 0.f,
1525 bool apply_elevation_mask = true,
1526 bool apply_ridge_mask = true,
1527 float mask_gamma = 0.4f,
1528 const Array *p_mask = nullptr,
1529 const Vec4<float> &bbox = {0.f, 1.f, 0.f, 1.f});
1530
1532void thermal(Array &z,
1533 const Array &talus,
1534 int iterations = 10,
1535 Array *p_bedrock = nullptr,
1536 Array *p_deposition_map = nullptr);
1537
1539void thermal(Array &z,
1540 Array *p_mask,
1541 const Array &talus,
1542 int iterations = 10,
1543 Array *p_bedrock = nullptr,
1544 Array *p_deposition_map = nullptr);
1545
1547void thermal(Array &z,
1548 float talus,
1549 int iterations = 10,
1550 Array *p_bedrock = nullptr,
1551 Array *p_deposition_map = nullptr);
1552
1554void thermal_auto_bedrock(Array &z,
1555 const Array &talus,
1556 int iterations = 10,
1557 Array *p_deposition_map = nullptr);
1558
1560void thermal_auto_bedrock(Array &z,
1561 Array *p_mask,
1562 const Array &talus,
1563 int iterations = 10,
1564 Array *p_deposition_map = nullptr);
1565
1567void thermal_auto_bedrock(Array &z,
1568 float,
1569 int iterations = 10,
1570 Array *p_deposition_map = nullptr);
1571
1589void thermal_inflate(Array &z, const Array &talus, int iterations = 10);
1590
1591void thermal_inflate(Array &z,
1592 const Array *p_mask,
1593 const Array &talus,
1594 int iterations = 10);
1595
1597void thermal_rib(Array &z, int iterations, Array *p_bedrock = nullptr);
1598
1618void thermal_ridge(Array &z,
1619 const Array &talus,
1620 int iterations = 10,
1621 Array *p_deposition_map = nullptr);
1622
1623void thermal_ridge(Array &z,
1624 const Array *p_mask,
1625 const Array &talus,
1626 int iterations = 10,
1627 Array *p_deposition_map = nullptr);
1628
1650void thermal_scree(Array &z,
1651 const Array &talus,
1652 const Array &zmax,
1653 int iterations = 10,
1654 bool talus_constraint = true,
1655 Array *p_deposition_map = nullptr);
1656
1657void thermal_scree(Array &z,
1658 const Array *p_mask,
1659 const Array &talus,
1660 const Array &zmax,
1661 int iterations = 10,
1662 bool talus_constraint = true,
1663 Array *p_deposition_map = nullptr);
1664
1665} // 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
hmap::gpu
Definition blending.hpp:186
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:207
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 Vec2< float > &noise_kw={4.f, 4.f}, const Vec2< float > &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 Vec4< float > &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::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:13
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:97
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_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 drag_rate=0.001f, float evap_rate=0.001f, bool post_filtering=false)
See hmap::hydraulic_particle.
Definition erosion_gpu.cpp:12
hmap::gpu::thermal_scree
void thermal_scree(Array &z, const Array &talus, const Array &zmax, int iterations=10, bool talus_constraint=true, Array *p_deposition_map=nullptr)
Performs thermal scree erosion on a heightmap.
Definition thermal_gpu.cpp:249
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::rifts
void rifts(Array &z, const Vec2< float > &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 Vec2< float > &center={0.5f, 0.5f}, const Vec4< float > &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:156
hmap::gpu::thermal_rib
void thermal_rib(Array &z, int iterations, Array *p_bedrock=nullptr)
See hmap::thermal_rib.
Definition thermal_gpu.cpp:189
hmap
Definition algebra.hpp:28
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::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:42
hmap::SAW_SMOOTH
@ SAW_SMOOTH
Definition erosion.hpp:45
hmap::TRIANGLE_GRENIER
@ TRIANGLE_GRENIER
Definition erosion.hpp:48
hmap::SQUARE_SMOOTH
@ SQUARE_SMOOTH
Definition erosion.hpp:47
hmap::SAW_SHARP
@ SAW_SHARP
Definition erosion.hpp:44
hmap::TRIANGLE_SHARP
@ TRIANGLE_SHARP
Definition erosion.hpp:49
hmap::SHARP_VALLEYS
@ SHARP_VALLEYS
Definition erosion.hpp:46
hmap::TRIANGLE_SMOOTH
@ TRIANGLE_SMOOTH
Definition erosion.hpp:50
hmap::COSINE
@ COSINE
Definition erosion.hpp:43
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:31
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::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::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:23
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:289
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::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::slope
Array slope(Vec2< int > 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, Vec2< float > center={0.5f, 0.5f}, Vec4< float > 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_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