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#pragma once
5#include <cmath>
6
7#include "highmap/array.hpp"
8#include "highmap/hydrology/hydrology.hpp"
9#include "highmap/interpolate2d.hpp"
10#include "highmap/terrain_tri_mesh.hpp"
11
12// neighbor pattern search based on Moore pattern and define diagonal
13// weight coefficients ('c' corresponds to a weight coefficient
14// applied to take into account the longer distance for diagonal
15// comparison between cells)
16
17// clang-format off
18// 6 2 8
19// 1 . 4
20// 5 3 7
21#define HMAP_DI {-1, 0, 0, 1, -1, -1, 1, 1}
22#define HMAP_DJ {0, 1, -1, 0, -1, 1, -1, 1}
23#define HMAP_CD {1.f, 1.f, 1.f, 1.f, M_SQRT2, M_SQRT2, M_SQRT2, M_SQRT2}
24#define HMAP_CD_INV {1.f, 1.f, 1.f, 1.f, M_SQRT2, M_SQRT2, M_SQRT2, M_SQRT2}
25// clang-format on
26
27namespace hmap
28{
29
47
48std::function<float(float)> get_erosion_profile_function(
49 const ErosionProfile &erosion_profile,
50 float delta,
51 float &profile_avg);
52
53std::vector<hmap::ErosionProfile> check_erosion_profile_function(
54 float delta = 0.01f);
55
93void coastal_erosion_diffusion(Array &z,
94 Array &water_depth,
95 float additional_depth,
96 int iterations = 10,
97 Array *p_water_mask = nullptr);
98
146void coastal_erosion_profile(Array &z,
147 Array &water_depth,
148 float shore_ground_extent, // pixels
149 float shore_water_extent,
150 float slope_shore = 0.5f,
151 float slope_shore_water = 0.5f,
152 float scarp_extent_ratio = 0.5f, // in [0, 1]
153 bool apply_post_filter = true,
154 int post_filter_iterations = 3,
155 const Array *p_noise = nullptr,
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 int post_filter_iterations = 3,
168 const Array *p_noise = nullptr,
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
237Array generate_bedrock(const Array &z,
238 float elevation_strength,
239 float slope_strength,
240 float slope_limit,
241 float zmin = 0.f,
242 float zmax = -1.f);
243
268void hydraulic_algebric(Array &z,
269 Array *p_mask,
270 float talus_ref,
271 int ir,
272 Array *p_bedrock = nullptr,
273 Array *p_erosion_map = nullptr,
274 Array *p_deposition_map = nullptr,
275 float c_erosion = 0.05f,
276 float c_deposition = 0.05f,
277 int iterations = 1);
278
279void hydraulic_algebric(Array &z,
280 float talus_ref,
281 int ir,
282 Array *p_bedrock = nullptr,
283 Array *p_erosion_map = nullptr,
284 Array *p_deposition_map = nullptr,
285 float c_erosion = 0.05f,
286 float c_deposition = 0.05f,
287 int iterations = 1);
288
319void hydraulic_benes(Array &z,
320 Array *p_mask,
321 int iterations = 50,
322 Array *p_bedrock = nullptr,
323 Array *p_moisture_map = nullptr,
324 Array *p_erosion_map = nullptr,
325 Array *p_deposition_map = nullptr,
326 float c_capacity = 40.f,
327 float c_erosion = 0.2f,
328 float c_deposition = 0.8f,
329 float water_level = 0.005f,
330 float evap_rate = 0.01f,
331 float rain_rate = 0.5f);
332
333void hydraulic_benes(Array &z,
334 int iterations = 50,
335 Array *p_bedrock = nullptr,
336 Array *p_moisture_map = nullptr,
337 Array *p_erosion_map = nullptr,
338 Array *p_deposition_map = nullptr,
339 float c_capacity = 40.f,
340 float c_erosion = 0.2f,
341 float c_deposition = 0.8f,
342 float water_level = 0.005f,
343 float evap_rate = 0.01f,
344 float rain_rate = 0.5f);
345
359void hydraulic_blur(Array &z,
360 float radius,
361 float vmax,
362 float k_smoothing = 0.1f);
363
381void hydraulic_diffusion(Array &z,
382 float c_diffusion,
383 float talus,
384 int iterations);
408void hydraulic_musgrave(Array &z,
409 Array &moisture_map,
410 int iterations = 100,
411 float c_capacity = 1.f,
412 float c_erosion = 0.1f,
413 float c_deposition = 0.1f,
414 float water_level = 0.01f,
415 float evap_rate = 0.01f);
416
417void hydraulic_musgrave(Array &z,
418 int iterations = 100,
419 float c_capacity = 1.f,
420 float c_erosion = 0.1f,
421 float c_deposition = 0.1f,
422 float water_level = 0.01f,
423 float evap_rate = 0.01f);
424
445void hydraulic_saleve(TerrainTriMesh &mesh,
446 const std::vector<float> &erodibility,
447 const std::vector<float> &max_slope,
448 float m_exp = 0.8f,
449 float uplift_rate = 1.f,
450 float tolerance = 1e-3f,
451 int max_iterations = 200,
452 float noise_strength = 0.f,
453 uint seed = 0,
454 bool enable_post_slope_limiter = false,
455 float post_slope_limit = 0.f,
456 bool enable_post_smoothing = false);
457
488Array hydraulic_saleve(const Array &z,
489 uint seed,
490 size_t control_points_count = 10000,
491 float m_exp = 0.8f,
492 float uplift_rate = 1.f,
493 float tolerance = 1e-3f,
494 int max_iterations = 200,
495 float smin = 0.f,
496 float smax = 6.f,
497 float strength = 0.5f,
498 bool scale_erodibility_with_z = true,
499 float erodibility_distrib_exp = 1.f,
500 float noise_strength = 0.f,
501 bool enable_post_slope_limiter = false,
502 float post_slope_limit = 0.f,
503 bool enable_post_smoothing = false,
504 InterpolationMethod2D interpolation_method =
505 InterpolationMethod2D::ITP2D_DELAUNAY_GRADIENT,
506 const Array *p_noise_x = nullptr,
507 const Array *p_noise_y = nullptr);
508
509Array hydraulic_saleve(const Array &z,
510 const Array *p_mask,
511 uint seed,
512 size_t control_points_count = 10000,
513 float m_exp = 0.8f,
514 float uplift_rate = 1.f,
515 float tolerance = 1e-3f,
516 int max_iterations = 200,
517 float smin = 0.f,
518 float smax = 6.f,
519 float strength = 0.5f,
520 bool scale_erodibility_with_z = true,
521 float erodibility_distrib_exp = 1.f,
522 float noise_strength = 0.f,
523 bool enable_post_slope_limiter = false,
524 float post_slope_limit = 0.f,
525 bool enable_post_smoothing = false,
526 InterpolationMethod2D interpolation_method =
527 InterpolationMethod2D::ITP2D_DELAUNAY_GRADIENT,
528 const Array *p_noise_x = nullptr,
529 const Array *p_noise_y = nullptr);
530
558void hydraulic_stream(Array &z,
559 float c_erosion,
560 float talus_ref,
561 Array *p_bedrock = nullptr,
562 Array *p_moisture_map = nullptr,
563 Array *p_erosion_map = nullptr, // -> out
564 int ir = 1,
565 float clipping_ratio = 10.f);
566
567void hydraulic_stream(Array &z,
568 Array *p_mask,
569 float c_erosion,
570 float talus_ref,
571 Array *p_bedrock = nullptr,
572 Array *p_moisture_map = nullptr,
573 Array *p_erosion_map = nullptr, // -> out
574 int ir = 1,
575 float clipping_ratio = 10.f);
576
615void hydraulic_stream_log(Array &z,
616 float c_erosion,
617 float talus_ref,
618 int deposition_ir = 32,
619 float deposition_scale_ratio = 1.f,
620 float gradient_power = 0.8f,
621 float gradient_scaling_ratio = 1.f,
622 int gradient_prefilter_ir = 16,
623 float saturation_ratio = 1.f,
624 Array *p_bedrock = nullptr,
625 Array *p_moisture_map = nullptr,
626 Array *p_erosion_map = nullptr,
627 Array *p_deposition_map = nullptr,
628 Array *p_flow_map = nullptr);
629
630void hydraulic_stream_log(Array &z,
631 float c_erosion,
632 float talus_ref,
633 const Array *p_mask,
634 int deposition_ir = 32,
635 float deposition_scale_ratio = 1.f,
636 float gradient_power = 0.8f,
637 float gradient_scaling_ratio = 1.f,
638 int gradient_prefilter_ir = 16,
639 float saturation_ratio = 1.f,
640 Array *p_bedrock = nullptr,
641 Array *p_moisture_map = nullptr,
642 Array *p_erosion_map = nullptr,
643 Array *p_deposition_map = nullptr,
644 Array *p_flow_map = nullptr);
645
678void hydraulic_stream_upscale_amplification(Array &z,
679 float c_erosion,
680 float talus_ref,
681 int upscaling_levels = 1,
682 float persistence = 1.f,
683 int ir = 1,
684 float clipping_ratio = 10.f);
685
719void hydraulic_stream_upscale_amplification(
720 Array &z,
721 Array *p_mask,
722 float c_erosion,
723 float talus_ref,
724 int upscaling_levels = 1,
725 float persistence = 1.f,
726 int ir = 1,
727 float clipping_ratio = 10.f);
728
757void hydraulic_vpipes(Array &z,
758 Array *p_mask,
759 int iterations,
760 Array *p_bedrock = nullptr,
761 Array *p_moisture_map = nullptr,
762 Array *p_erosion_map = nullptr,
763 Array *p_deposition_map = nullptr,
764 float water_height = 0.1f,
765 float c_capacity = 0.1f,
766 float c_erosion = 0.05f,
767 float c_deposition = 0.05f,
768 float rain_rate = 0.f,
769 float evap_rate = 0.01f);
770
771void hydraulic_vpipes(Array &z,
772 int iterations,
773 Array *p_bedrock = nullptr,
774 Array *p_moisture_map = nullptr,
775 Array *p_erosion_map = nullptr,
776 Array *p_deposition_map = nullptr,
777 float water_height = 0.1f,
778 float c_capacity = 0.1f,
779 float c_erosion = 0.05f,
780 float c_deposition = 0.05f,
781 float rain_rate = 0.f,
782 float evap_rate = 0.01f);
783
803void stratify(Array &z,
804 Array *p_mask,
805 std::vector<float> hs,
806 std::vector<float> gamma,
807 Array *p_noise = nullptr);
808
809void stratify(Array &z,
810 std::vector<float> hs,
811 std::vector<float> gamma,
812 Array *p_noise = nullptr);
813
814void stratify(Array &z,
815 std::vector<float> hs,
816 float gamma = 0.5f,
817 Array *p_noise = nullptr);
818
819void stratify(Array &z,
820 Array &partition,
821 int nstrata,
822 float strata_noise,
823 float gamma,
824 float gamma_noise,
825 int npartitions,
826 uint seed,
827 float mixing_gain_factor = 1.f,
828 Array *p_noise = nullptr,
829 float vmin = 1.f,
830 float vmax = 0.f);
831
855void stratify_multiscale(Array &z,
856 float zmin,
857 float zmax,
858 std::vector<int> n_strata,
859 std::vector<float> strata_noise,
860 std::vector<float> gamma_list,
861 std::vector<float> gamma_noise,
862 uint seed,
863 Array *p_mask = nullptr,
864 Array *p_noise = nullptr);
865
886void stratify_oblique(Array &z,
887 Array *p_mask,
888 std::vector<float> hs,
889 std::vector<float> gamma,
890 float talus,
891 float angle,
892 Array *p_noise = nullptr);
893
894void stratify_oblique(Array &z,
895 std::vector<float> hs,
896 std::vector<float> gamma,
897 float talus,
898 float angle,
899 Array *p_noise = nullptr);
900
920void thermal(Array &z,
921 Array *p_mask,
922 const Array &talus,
923 int iterations = 10,
924 Array *p_bedrock = nullptr,
925 Array *p_deposition_map = nullptr);
926
927void thermal(Array &z,
928 const Array &talus,
929 int iterations = 10,
930 Array *p_bedrock = nullptr,
931 Array *p_deposition_map = nullptr);
932
933void thermal(Array &z,
934 float talus,
935 int iterations = 10,
936 Array *p_bedrock = nullptr,
937 Array *p_deposition_map = nullptr);
938
960void thermal_auto_bedrock(Array &z,
961 const Array &talus,
962 int iterations = 10,
963 Array *p_deposition_map = nullptr);
964
965void thermal_auto_bedrock(Array &z,
966 float talus,
967 int iterations = 10,
968 Array *p_deposition_map = nullptr);
969
970void thermal_auto_bedrock(Array &z,
971 Array *p_mask,
972 float talus,
973 int iterations = 10,
974 Array *p_deposition_map = nullptr);
975
993void thermal_flatten(Array &z,
994 const Array &talus,
995 const Array &bedrock,
996 int iterations = 10,
997 int post_filter_ir = 1);
998
999void thermal_flatten(Array &z,
1000 float talus,
1001 int iterations = 10,
1002 int post_filter_ir = 1);
1003
1023void thermal_olsen(Array &z,
1024 const Array &talus,
1025 int iterations = 10,
1026 Array *p_bedrock = nullptr,
1027 Array *p_deposition_map = nullptr);
1028
1041void thermal_rib(Array &z, int iterations, Array *p_bedrock = nullptr);
1042
1066void thermal_schott(Array &z,
1067 const Array &talus,
1068 int iterations = 10,
1069 float intensity = 0.001f);
1070
1071void thermal_schott(Array &z,
1072 const Array &talus,
1073 Array *p_mask,
1074 int iterations = 10,
1075 float intensity = 0.001f);
1076
1098void thermal_schott(Array &z,
1099 const float talus,
1100 int iterations = 10,
1101 float intensity = 0.001f);
1102
1103void thermal_schott(Array &z,
1104 const float talus,
1105 Array *p_mask,
1106 int iterations = 10,
1107 float intensity = 0.001f);
1108
1109} // namespace hmap
1110
1111namespace hmap::gpu
1112{
1113
1125void deposition_fill_holes(Array &z,
1126 int deposition_ir,
1127 float deposition_strength,
1128 int iterations = 1);
1129
1162void hydraulic_particle(Array &z,
1163 int nparticles,
1164 uint seed,
1165 const Array *p_bedrock = nullptr,
1166 const Array *p_moisture_map = nullptr,
1167 const Array *p_elevation_shift = nullptr,
1168 Array *p_erosion_map = nullptr,
1169 Array *p_deposition_map = nullptr,
1170 float c_capacity = 10.f,
1171 float c_erosion = 0.05f,
1172 float c_deposition = 0.05f,
1173 float c_inertia = 0.1f,
1174 float c_gravity = 1.f,
1175 float drag_rate = 0.001f,
1176 float evap_rate = 0.001f,
1177 bool enable_directional_bias = false,
1178 float angle_bias = 30.f);
1179
1181void hydraulic_particle(Array &z,
1182 const Array *p_mask,
1183 int nparticles,
1184 uint seed,
1185 const Array *p_bedrock = nullptr,
1186 const Array *p_moisture_map = nullptr,
1187 const Array *p_elevation_shift = nullptr,
1188 Array *p_erosion_map = nullptr,
1189 Array *p_deposition_map = nullptr,
1190 float c_capacity = 10.f,
1191 float c_erosion = 0.05f,
1192 float c_deposition = 0.05f,
1193 float c_inertia = 0.1f,
1194 float c_gravity = 1.f,
1195 float drag_rate = 0.001f,
1196 float evap_rate = 0.001f,
1197 bool enable_directional_bias = false,
1198 float angle_bias = 30.f);
1199
1248void hydraulic_procedural(
1249 Array &z,
1250 float kp_global,
1251 float c_erosion,
1252 uint seed,
1253 ErosionProfile erosion_profile = ErosionProfile::EP_TRIANGLE_GRENIER,
1254 float erosion_profile_parameter = 0.01f,
1255 float angle_shift = 0.f, // degs
1256 float phase_smoothing = 0.1f,
1257 float talus_ref = 0.001f,
1258 float gradient_scaling_ratio = 1.f,
1259 float gradient_power = 0.8f,
1260 bool exclude_ridges = true,
1261 bool apply_deposition = false,
1262 float deposition_strength = 1.f,
1263 bool enable_default_noise = true,
1264 float noise_amp = 0.01f,
1265 const Array *p_kp_multiplier = nullptr,
1266 const Array *p_angle_shift = nullptr,
1267 const Array *p_noise_x = nullptr,
1268 const Array *p_noise_y = nullptr,
1269 Array *p_ridge_mask = nullptr, // ouptput
1270 glm::vec4 bbox = {0.f, 1.f, 0.f, 1.f});
1271
1310void hydraulic_procedural_fbm(
1311 Array &z,
1312 float kp_global,
1313 float c_erosion,
1314 uint seed,
1315 ErosionProfile erosion_profile = ErosionProfile::EP_TRIANGLE_GRENIER,
1316 int octaves = 3,
1317 float persistence = 0.5f,
1318 float lacunarity = 2.f,
1319 float erosion_profile_parameter = 0.01f,
1320 float angle_shift = 0.f, // degs
1321 float phase_smoothing = 0.1f,
1322 float talus_ref = 0.001f,
1323 float gradient_scaling_ratio = 1.f,
1324 float gradient_power = 0.8f,
1325 bool exclude_ridges = true,
1326 bool apply_deposition = false,
1327 float deposition_strength = 1.f,
1328 bool enable_default_noise = true,
1329 float noise_amp = 0.01f,
1330 const Array *p_kp_multiplier = nullptr,
1331 const Array *p_angle_shift = nullptr,
1332 const Array *p_noise_x = nullptr,
1333 const Array *p_noise_y = nullptr,
1334 Array *p_ridge_mask = nullptr, // ouptput
1335 glm::vec4 bbox = {0.f, 1.f, 0.f, 1.f});
1336
1337void hydraulic_procedural_fbm(
1338 Array &z,
1339 float kp_global,
1340 float c_erosion,
1341 uint seed,
1342 const Array *p_mask,
1343 ErosionProfile erosion_profile = ErosionProfile::EP_TRIANGLE_GRENIER,
1344 int octaves = 3,
1345 float persistence = 0.5f,
1346 float lacunarity = 2.f,
1347 float erosion_profile_parameter = 0.01f,
1348 float angle_shift = 0.f, // degs
1349 float phase_smoothing = 0.1f,
1350 float talus_ref = 0.001f,
1351 float gradient_scaling_ratio = 1.f,
1352 float gradient_power = 0.8f,
1353 bool exclude_ridges = true,
1354 bool apply_deposition = false,
1355 float deposition_strength = 1.f,
1356 bool enable_default_noise = true,
1357 float noise_amp = 0.01f,
1358 const Array *p_kp_multiplier = nullptr,
1359 const Array *p_angle_shift = nullptr,
1360 const Array *p_noise_x = nullptr,
1361 const Array *p_noise_y = nullptr,
1362 Array *p_ridge_mask = nullptr, // ouptput
1363 glm::vec4 bbox = {0.f, 1.f, 0.f, 1.f});
1364
1412void hydraulic_schott(Array &z,
1413 int iterations,
1414 const Array &talus,
1415 float c_erosion = 1.f,
1416 float c_thermal = 0.1f,
1417 float c_deposition = 0.2f,
1418 float flow_acc_exponent = 0.8f,
1419 float flow_acc_exponent_depo = 0.8f,
1420 float flow_routing_exponent = 1.3f,
1421 float thermal_weight = 1.5f,
1422 float deposition_weight = 2.5f,
1423 Array *p_flow = nullptr);
1424
1425void hydraulic_schott(Array &z,
1426 int iterations,
1427 const Array &talus,
1428 Array *p_mask,
1429 float c_erosion = 1.f,
1430 float c_thermal = 0.1f,
1431 float c_deposition = 0.2f,
1432 float flow_acc_exponent = 0.8f,
1433 float flow_acc_exponent_depo = 0.8f,
1434 float flow_routing_exponent = 1.3f,
1435 float thermal_weight = 1.5f,
1436 float deposition_weight = 2.5f,
1437 Array *p_flow = nullptr);
1438
1440void hydraulic_schott_erosion(Array &z,
1441 int iterations,
1442 float c_erosion = 1.f,
1443 float flow_acc_exponent = 0.8f,
1444 float flow_routing_exponent = 1.3f,
1445 const Array *p_moisture_map = nullptr,
1446 Array *p_flow = nullptr);
1447
1449void hydraulic_stream_log(Array &z,
1450 float c_erosion,
1451 float talus_ref,
1452 int deposition_ir = 32,
1453 float deposition_scale_ratio = 1.f,
1454 float gradient_power = 0.8f,
1455 float gradient_scaling_ratio = 1.f,
1456 int gradient_prefilter_ir = 16,
1457 float saturation_ratio = 1.f,
1458 Array *p_bedrock = nullptr,
1459 Array *p_moisture_map = nullptr,
1460 Array *p_erosion_map = nullptr,
1461 Array *p_deposition_map = nullptr,
1462 Array *p_flow_map = nullptr);
1463
1464void hydraulic_stream_log(Array &z,
1465 float c_erosion,
1466 float talus_ref,
1467 const Array *p_mask,
1468 int deposition_ir = 32,
1469 float deposition_scale_ratio = 1.f,
1470 float gradient_power = 0.8f,
1471 float gradient_scaling_ratio = 1.f,
1472 int gradient_prefilter_ir = 16,
1473 float saturation_ratio = 1.f,
1474 Array *p_bedrock = nullptr,
1475 Array *p_moisture_map = nullptr,
1476 Array *p_erosion_map = nullptr,
1477 Array *p_deposition_map = nullptr,
1478 Array *p_flow_map = nullptr);
1479
1481void hydraulic_vpipes(Array &z,
1482 float water_height = 1e-2f,
1483 bool maintain_water_volume = true,
1484 float evap_rate = 0.1f,
1485 int iterations = 50,
1486 float dt = 0.5f,
1487 float k_capacity = 0.5f,
1488 float k_erode = 0.001f,
1489 float k_depose = 0.01f,
1490 float k_discharge_exp = 1.f,
1491 float downcutting_max_depth_ratio = 10.f,
1492 bool flux_diffusion = true,
1493 float flux_diffusion_strength = 0.01f,
1494 Array *p_rain_map = nullptr,
1495 Array *p_water_depth = nullptr,
1496 Array *p_sediment = nullptr,
1497 Array *p_vel_u = nullptr,
1498 Array *p_vel_v = nullptr);
1499
1528void mudslide(Array &z,
1529 const Array &landslide_mask,
1530 float depth,
1531 int iterations,
1532 float depth_map_exponent = 0.5f,
1533 float viscosity_law_power = 1.5f,
1534 Array *p_depth_end = nullptr,
1535 Array *p_depth_init = nullptr);
1536
1538void mudslide(Array &z,
1539 float talus_limit,
1540 float depth,
1541 int iterations,
1542 float depth_map_exponent = 0.5f,
1543 float viscosity_law_power = 1.5f,
1544 Array *p_depth_end = nullptr,
1545 Array *p_depth_init = nullptr);
1546
1598void rifts(Array &z,
1599 const glm::vec2 &kw, // = {4.f, 1.2f},
1600 float angle, // degs
1601 float amplitude,
1602 uint seed,
1603 float elevation_noise_shift = 0.f,
1604 float k_smooth_bottom = 0.05f,
1605 float k_smooth_top = 0.05f,
1606 float radial_spread_amp = 0.2f,
1607 float elevation_noise_amp = 0.1f,
1608 float clamp_vmin = 0.f,
1609 float remap_vmin = 0.f,
1610 bool apply_mask = true,
1611 bool reverse_mask = false,
1612 float mask_gamma = 1.f,
1613 const Array *p_noise_x = nullptr,
1614 const Array *p_noise_y = nullptr,
1615 const Array *p_mask = nullptr,
1616 const glm::vec2 &center = {0.5f, 0.5f},
1617 const glm::vec4 &bbox = {0.f, 1.f, 0.f, 1.f});
1618
1641void sediment_deposition(Array &z,
1642 Array *p_mask,
1643 const Array &talus,
1644 Array *p_deposition_map = nullptr,
1645 float max_deposition = 0.01,
1646 int iterations = 5,
1647 int thermal_subiterations = 10);
1648
1649void sediment_deposition(Array &z,
1650 const Array &talus,
1651 Array *p_deposition_map = nullptr,
1652 float max_deposition = 0.01,
1653 int iterations = 5,
1654 int thermal_subiterations = 10);
1655
1677void sediment_layer(Array &z,
1678 const Array &talus_layer,
1679 const Array &talus_upper_limit,
1680 int iterations,
1681 bool apply_post_filter = true,
1682 Array *p_deposition_map = nullptr);
1683
1741void strata(Array &z,
1742 float angle,
1743 float slope,
1744 float gamma, // e.g 0.5f or 1.5f
1745 uint seed,
1746 bool linear_gamma = true,
1747 float kz = 1.f,
1748 int octaves = 4,
1749 float lacunarity = 2.f,
1750 float gamma_noise_ratio = 0.5f,
1751 float noise_amp = 0.4f,
1752 const glm::vec2 &noise_kw = {4.f, 4.f},
1753 bool enable_ridge_noise = true,
1754 const glm::vec2 &ridge_noise_kw = {4.f, 1.2f},
1755 float ridge_angle_shift = 45.f,
1756 float ridge_noise_amp = 0.5f,
1757 float ridge_clamp_vmin = 0.f,
1758 float ridge_remap_vmin = 0.f,
1759 bool apply_elevation_mask = true,
1760 bool apply_ridge_mask = true,
1761 float mask_gamma = 0.4f,
1762 const Array *p_mask = nullptr,
1763 const glm::vec4 &bbox = {0.f, 1.f, 0.f, 1.f});
1764
1791void strata_cells(Array &z,
1792 glm::vec2 kw,
1793 float amp,
1794 uint seed,
1795 float gamma = 0.5f,
1796 float gamma_lateral = 0.4f,
1797 float angle = 0.f,
1798 float noise_amp = 0.5f,
1799 bool absolute_displacement = true,
1800 float occurence_probability = 0.5f,
1801 const Array *p_noise_x = nullptr,
1802 const Array *p_noise_y = nullptr,
1803 glm::vec4 bbox = {0.f, 1.f, 0.f, 1.f});
1804
1832void strata_cells(Array &z,
1833 glm::vec2 kw,
1834 float amp,
1835 uint seed,
1836 const Array *p_mask,
1837 float gamma = 0.5f,
1838 float gamma_lateral = 0.4f,
1839 float angle = 0.f,
1840 float noise_amp = 0.5f,
1841 bool absolute_displacement = true,
1842 float occurence_probability = 0.5f,
1843 const Array *p_noise_x = nullptr,
1844 const Array *p_noise_y = nullptr,
1845 glm::vec4 bbox = {0.f, 1.f, 0.f, 1.f});
1846
1877void strata_cells_fbm(Array &z,
1878 glm::vec2 kw,
1879 float amp,
1880 uint seed,
1881 float gamma = 0.5f,
1882 float gamma_lateral = 0.4f,
1883 float angle = 0.f,
1884 bool enable_default_noise = true,
1885 float default_noise_amp = 0.05f,
1886 bool absolute_displacement = true,
1887 float occurence_probability = 0.5f,
1888 int octaves = 8,
1889 float persistence = 0.4f,
1890 float lacunarity = 2.2f,
1891 const Array *p_noise_x = nullptr,
1892 const Array *p_noise_y = nullptr,
1893 glm::vec4 bbox = {0.f, 1.f, 0.f, 1.f});
1894
1926void strata_cells_fbm(Array &z,
1927 glm::vec2 kw,
1928 float amp,
1929 uint seed,
1930 const Array *p_mask,
1931 float gamma = 0.5f,
1932 float gamma_lateral = 0.4f,
1933 float angle = 0.f,
1934 bool enable_default_noise = true,
1935 float default_noise_amp = 0.05f,
1936 bool absolute_displacement = true,
1937 float occurence_probability = 0.5f,
1938 int octaves = 8,
1939 float persistence = 0.4f,
1940 float lacunarity = 2.2f,
1941 const Array *p_noise_x = nullptr,
1942 const Array *p_noise_y = nullptr,
1943 glm::vec4 bbox = {0.f, 1.f, 0.f, 1.f});
1944
1966void strata_terrace(Array &z,
1967 float gamma, // e.g 0.5f or 1.5f
1968 uint seed,
1969 float kz = 4.f, // 4-layers
1970 bool linear_gamma = true,
1971 float gamma_noise_ratio = 0.5f,
1972 const Array *p_noise = nullptr);
1973
1995void strata_terrace(Array &z,
1996 float gamma, // e.g 0.5f or 1.5f
1997 uint seed,
1998 const Array *p_mask,
1999 float kz = 4.f, // 4-layers
2000 bool linear_gamma = true,
2001 float gamma_noise_ratio = 0.5f,
2002 const Array *p_noise = nullptr);
2003
2005void thermal(Array &z,
2006 const Array &talus,
2007 int iterations = 10,
2008 Array *p_bedrock = nullptr,
2009 Array *p_deposition_map = nullptr);
2010
2012void thermal(Array &z,
2013 Array *p_mask,
2014 const Array &talus,
2015 int iterations = 10,
2016 Array *p_bedrock = nullptr,
2017 Array *p_deposition_map = nullptr);
2018
2020void thermal(Array &z,
2021 float talus,
2022 int iterations = 10,
2023 Array *p_bedrock = nullptr,
2024 Array *p_deposition_map = nullptr);
2025
2027void thermal_auto_bedrock(Array &z,
2028 const Array &talus,
2029 int iterations = 10,
2030 Array *p_deposition_map = nullptr);
2031
2033void thermal_auto_bedrock(Array &z,
2034 Array *p_mask,
2035 const Array &talus,
2036 int iterations = 10,
2037 Array *p_deposition_map = nullptr);
2038
2040void thermal_auto_bedrock(Array &z,
2041 float,
2042 int iterations = 10,
2043 Array *p_deposition_map = nullptr);
2044
2046void thermal_olsen(Array &z, const Array &talus, int iterations);
2047void thermal_olsen(Array &z, Array *p_mask, const Array &talus, int iterations);
2048
2066void thermal_inflate(Array &z, const Array &talus, int iterations = 10);
2067
2068void thermal_inflate(Array &z,
2069 const Array *p_mask,
2070 const Array &talus,
2071 int iterations = 10);
2072
2074void thermal_rib(Array &z, int iterations, Array *p_bedrock = nullptr);
2075
2095void thermal_ridge(Array &z,
2096 const Array &talus,
2097 int iterations = 10,
2098 Array *p_deposition_map = nullptr);
2099
2100void thermal_ridge(Array &z,
2101 const Array *p_mask,
2102 const Array &talus,
2103 int iterations = 10,
2104 Array *p_deposition_map = nullptr);
2105
2125void thermal_scree(Array &z,
2126 const Array &talus,
2127 const Array &zmax,
2128 int iterations = 10,
2129 Array *p_deposition_map = nullptr);
2130
2131void thermal_scree(Array &z,
2132 const Array *p_mask,
2133 const Array &talus,
2134 const Array &zmax,
2135 int iterations = 10,
2136 Array *p_deposition_map = nullptr);
2137
2158void valley_fill(Array &z,
2159 const Array &talus,
2160 int iterations = 100,
2161 float gamma = 2.f,
2162 float ratio = 0.8f,
2163 float zmin = 0.f,
2164 float zmax = 0.f,
2165 float elevation_max_ratio = 1.f,
2166 bool preserve_elevation_range = true,
2167 const Array *p_noise = nullptr,
2168 Array *p_deposition_map = nullptr);
2169
2170void valley_fill(Array &z,
2171 const Array *p_mask,
2172 const Array &talus,
2173 int iterations = 100,
2174 float gamma = 2.f,
2175 float ratio = 0.8f,
2176 float zmin = 0.f,
2177 float zmax = 0.f,
2178 float elevation_max_ratio = 1.f,
2179 bool preserve_elevation_range = true,
2180 const Array *p_noise = nullptr,
2181 Array *p_deposition_map = nullptr);
2182
2204Array watershed_ridge(
2205 const Array &z,
2206 float amplitude = 0.2f,
2207 float width = 32.f, // pixels
2208 float edt_exponent = 0.5f,
2209 int prefilter_ir = 0,
2210 FlowDirectionMethod fd_method = FlowDirectionMethod::FDM_D8,
2211 const Array *p_noise_x = nullptr,
2212 const Array *p_noise_y = nullptr,
2213 const Array *p_scaling = nullptr);
2214
2215Array watershed_ridge(
2216 const Array &z,
2217 const Array *p_mask,
2218 float amplitude = 0.2f,
2219 float width = 32.f,
2220 float edt_exponent = 0.5f,
2221 int prefilter_ir = 0,
2222 FlowDirectionMethod fd_method = FlowDirectionMethod::FDM_D8,
2223 const Array *p_noise_x = nullptr,
2224 const Array *p_noise_y = nullptr,
2225 const Array *p_scaling = nullptr);
2226
2227} // 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.
interpolate2d.hpp
Header file for 2D interpolation methods.
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:18
hmap::gpu::deposition_fill_holes
void deposition_fill_holes(Array &z, int deposition_ir, float deposition_strength, int iterations=1)
Fill holes using Gaussian-based deposition.
Definition deposition_fill_holes.cpp:12
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 drainage_basin_cell_based.hpp:14
hmap::FDM_D8
@ FDM_D8
Definition drainage_basin_cell_based.hpp:15
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:34
hmap::EP_COSINE
@ EP_COSINE
Definition erosion.hpp:35
hmap::EP_PARABOL
@ EP_PARABOL
Definition erosion.hpp:38
hmap::EP_TRIANGLE_SMOOTH
@ EP_TRIANGLE_SMOOTH
Definition erosion.hpp:45
hmap::EP_TRIANGLE_GRENIER
@ EP_TRIANGLE_GRENIER
Definition erosion.hpp:43
hmap::EP_COSINE_BULK
@ EP_COSINE_BULK
Definition erosion.hpp:36
hmap::EP_SHARP_VALLEYS
@ EP_SHARP_VALLEYS
Definition erosion.hpp:41
hmap::EP_SAW_SMOOTH
@ EP_SAW_SMOOTH
Definition erosion.hpp:40
hmap::EP_SAW_SHARP
@ EP_SAW_SHARP
Definition erosion.hpp:39
hmap::EP_COSINE_PEAK
@ EP_COSINE_PEAK
Definition erosion.hpp:37
hmap::EP_TRIANGLE_SHARP
@ EP_TRIANGLE_SHARP
Definition erosion.hpp:44
hmap::EP_SQRT
@ EP_SQRT
Definition erosion.hpp:42
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:101
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::InterpolationMethod2D
InterpolationMethod2D
Enumeration of 2D interpolation methods.
Definition interpolate2d.hpp:45
hmap::ITP2D_DELAUNAY_GRADIENT
@ ITP2D_DELAUNAY_GRADIENT
Delaunay triangulation + linear gradient.
Definition interpolate2d.hpp:51
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:319
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_saleve
void hydraulic_saleve(TerrainTriMesh &mesh, const std::vector< float > &erodibility, const std::vector< float > &max_slope, float m_exp=0.8f, float uplift_rate=1.f, float tolerance=1e-3f, int max_iterations=200, float noise_strength=0.f, uint seed=0, bool enable_post_slope_limiter=false, float post_slope_limit=0.f, bool enable_post_smoothing=false)
Perform hydraulic erosion on a triangulated terrain mesh.
Definition hydraulic_saleve.cpp:16
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::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:21
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::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, int post_filter_iterations=3, const Array *p_noise=nullptr, Array *p_shore_mask=nullptr)
Applies a coastal erosion profile to a terrain elevation field.
Definition coastal_erosion.cpp:43
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
terrain_tri_mesh.hpp