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
90void coastal_erosion_diffusion(Array &z,
91 Array &water_depth,
92 float additional_depth,
93 int iterations = 10,
94 Array *p_water_mask = nullptr);
95
113void depression_filling(Array &z, int iterations = 1000, float epsilon = 1e-4f);
114
131void erosion_maps(Array &z_before,
132 Array &z_after,
133 Array &erosion_map,
134 Array &deposition_map,
135 float tolerance = 0.f);
136
161void hydraulic_algebric(Array &z,
162 Array *p_mask,
163 float talus_ref,
164 int ir,
165 Array *p_bedrock = nullptr,
166 Array *p_erosion_map = nullptr,
167 Array *p_deposition_map = nullptr,
168 float c_erosion = 0.05f,
169 float c_deposition = 0.05f,
170 int iterations = 1);
171
172void hydraulic_algebric(Array &z,
173 float talus_ref,
174 int ir,
175 Array *p_bedrock = nullptr,
176 Array *p_erosion_map = nullptr,
177 Array *p_deposition_map = nullptr,
178 float c_erosion = 0.05f,
179 float c_deposition = 0.05f,
180 int iterations = 1);
181
212void hydraulic_benes(Array &z,
213 Array *p_mask,
214 int iterations = 50,
215 Array *p_bedrock = nullptr,
216 Array *p_moisture_map = nullptr,
217 Array *p_erosion_map = nullptr,
218 Array *p_deposition_map = nullptr,
219 float c_capacity = 40.f,
220 float c_erosion = 0.2f,
221 float c_deposition = 0.8f,
222 float water_level = 0.005f,
223 float evap_rate = 0.01f,
224 float rain_rate = 0.5f);
225
226void hydraulic_benes(Array &z,
227 int iterations = 50,
228 Array *p_bedrock = nullptr,
229 Array *p_moisture_map = nullptr,
230 Array *p_erosion_map = nullptr,
231 Array *p_deposition_map = nullptr,
232 float c_capacity = 40.f,
233 float c_erosion = 0.2f,
234 float c_deposition = 0.8f,
235 float water_level = 0.005f,
236 float evap_rate = 0.01f,
237 float rain_rate = 0.5f);
238
252void hydraulic_blur(Array &z,
253 float radius,
254 float vmax,
255 float k_smoothing = 0.1f);
256
274void hydraulic_diffusion(Array &z,
275 float c_diffusion,
276 float talus,
277 int iterations);
301void hydraulic_musgrave(Array &z,
302 Array &moisture_map,
303 int iterations = 100,
304 float c_capacity = 1.f,
305 float c_erosion = 0.1f,
306 float c_deposition = 0.1f,
307 float water_level = 0.01f,
308 float evap_rate = 0.01f);
309
310void hydraulic_musgrave(Array &z,
311 int iterations = 100,
312 float c_capacity = 1.f,
313 float c_erosion = 0.1f,
314 float c_deposition = 0.1f,
315 float water_level = 0.01f,
316 float evap_rate = 0.01f);
317
348void hydraulic_particle(Array &z,
349 Array *p_mask,
350 int nparticles,
351 int seed,
352 Array *p_bedrock = nullptr,
353 Array *p_moisture_map = nullptr,
354 Array *p_erosion_map = nullptr, // -> out
355 Array *p_deposition_map = nullptr, // -> out
356 float c_capacity = 10.f,
357 float c_erosion = 0.05f,
358 float c_deposition = 0.05f,
359 float c_inertia = 0.3f,
360 float drag_rate = 0.001f,
361 float evap_rate = 0.001f,
362 bool post_filtering = false);
363
364void hydraulic_particle(Array &z,
365 int nparticles,
366 int seed,
367 Array *p_bedrock = nullptr,
368 Array *p_moisture_map = nullptr,
369 Array *p_erosion_map = nullptr, // -> out
370 Array *p_deposition_map = nullptr, // -> out
371 float c_capacity = 10.f,
372 float c_erosion = 0.05f,
373 float c_deposition = 0.05f,
374 float c_inertia = 0.3f,
375 float drag_rate = 0.001f,
376 float evap_rate = 0.001f,
377 bool post_filtering = false);
378
412void hydraulic_particle_multiscale(Array &z,
413 float particle_density,
414 int seed,
415 Array *p_bedrock = nullptr,
416 Array *p_moisture_map = nullptr,
417 Array *p_erosion_map = nullptr, // -> out
418 Array *p_deposition_map = nullptr, // -> out
419 float c_capacity = 10.f,
420 float c_erosion = 0.05f,
421 float c_deposition = 0.01f,
422 float c_inertia = 0.3f,
423 float drag_rate = 0.01f,
424 float evap_rate = 0.001f,
425 int pyramid_finest_level = 0);
426
475void hydraulic_procedural(
476 Array &z,
477 uint seed,
478 float ridge_wavelength,
479 float ridge_scaling = 0.1f,
480 ErosionProfile erosion_profile = ErosionProfile::TRIANGLE_SMOOTH,
481 float delta = 0.02f,
482 float noise_ratio = 0.2f,
483 int prefilter_ir = -1,
484 float density_factor = 1.f,
485 float kernel_width_ratio = 2.f,
486 float phase_smoothing = 2.f,
487 float phase_noise_amp = M_PI,
488 bool reverse_phase = false,
489 bool rotate90 = false,
490 bool use_default_mask = true,
491 float talus_mask = 0.f,
492 Array *p_mask = nullptr,
493 Array *p_ridge_mask = nullptr,
494 float vmin = 0.f,
495 float vmax = -1.f);
496
524void hydraulic_stream(Array &z,
525 float c_erosion,
526 float talus_ref,
527 Array *p_bedrock = nullptr,
528 Array *p_moisture_map = nullptr,
529 Array *p_erosion_map = nullptr, // -> out
530 int ir = 1,
531 float clipping_ratio = 10.f);
532
533void hydraulic_stream(Array &z,
534 Array *p_mask,
535 float c_erosion,
536 float talus_ref,
537 Array *p_bedrock = nullptr,
538 Array *p_moisture_map = nullptr,
539 Array *p_erosion_map = nullptr, // -> out
540 int ir = 1,
541 float clipping_ratio = 10.f);
542
575void hydraulic_stream_upscale_amplification(Array &z,
576 float c_erosion,
577 float talus_ref,
578 int upscaling_levels = 1,
579 float persistence = 1.f,
580 int ir = 1,
581 float clipping_ratio = 10.f);
582
616void hydraulic_stream_upscale_amplification(
617 Array &z,
618 Array *p_mask,
619 float c_erosion,
620 float talus_ref,
621 int upscaling_levels = 1,
622 float persistence = 1.f,
623 int ir = 1,
624 float clipping_ratio = 10.f);
625
664void hydraulic_stream_log(Array &z,
665 float c_erosion,
666 float talus_ref,
667 int deposition_ir = 32,
668 float deposition_scale_ratio = 1.f,
669 float gradient_power = 0.8f,
670 float gradient_scaling_ratio = 1.f,
671 int gradient_prefilter_ir = 16,
672 float saturation_ratio = 1.f,
673 Array *p_bedrock = nullptr,
674 Array *p_moisture_map = nullptr,
675 Array *p_erosion_map = nullptr,
676 Array *p_deposition_map = nullptr,
677 Array *p_flow_map = nullptr);
678
679void hydraulic_stream_log(Array &z,
680 float c_erosion,
681 float talus_ref,
682 Array *p_mask,
683 int deposition_ir = 32,
684 float deposition_scale_ratio = 1.f,
685 float gradient_power = 0.8f,
686 float gradient_scaling_ratio = 1.f,
687 int gradient_prefilter_ir = 16,
688 float saturation_ratio = 1.f,
689 Array *p_bedrock = nullptr,
690 Array *p_moisture_map = nullptr,
691 Array *p_erosion_map = nullptr,
692 Array *p_deposition_map = nullptr,
693 Array *p_flow_map = nullptr);
694
723void hydraulic_vpipes(Array &z,
724 Array *p_mask,
725 int iterations,
726 Array *p_bedrock = nullptr,
727 Array *p_moisture_map = nullptr,
728 Array *p_erosion_map = nullptr,
729 Array *p_deposition_map = nullptr,
730 float water_height = 0.1f,
731 float c_capacity = 0.1f,
732 float c_erosion = 0.05f,
733 float c_deposition = 0.05f,
734 float rain_rate = 0.f,
735 float evap_rate = 0.01f);
736
737void hydraulic_vpipes(Array &z,
738 int iterations,
739 Array *p_bedrock = nullptr,
740 Array *p_moisture_map = nullptr,
741 Array *p_erosion_map = nullptr,
742 Array *p_deposition_map = nullptr,
743 float water_height = 0.1f,
744 float c_capacity = 0.1f,
745 float c_erosion = 0.05f,
746 float c_deposition = 0.05f,
747 float rain_rate = 0.f,
748 float evap_rate = 0.01f);
749
772void sediment_deposition(Array &z,
773 Array *p_mask,
774 const Array &talus,
775 Array *p_deposition_map = nullptr,
776 float max_deposition = 0.01,
777 int iterations = 5,
778 int thermal_subiterations = 10);
779
780void sediment_deposition(Array &z,
781 const Array &talus,
782 Array *p_deposition_map = nullptr,
783 float max_deposition = 0.01,
784 int iterations = 5,
785 int thermal_subiterations = 10);
786
810void sediment_deposition_particle(Array &z,
811 Array *p_mask,
812 int nparticles,
813 int ir,
814 int seed = 1,
815 Array *p_spawning_map = nullptr,
816 Array *p_deposition_map = nullptr,
817 float particle_initial_sediment = 0.1f,
818 float deposition_velocity_limit = 0.01f,
819 float drag_rate = 0.001f);
820
821void sediment_deposition_particle(Array &z,
822 int nparticles,
823 int ir,
824 int seed = 1,
825 Array *p_spawning_map = nullptr,
826 Array *p_deposition_map = nullptr,
827 float particle_initial_sediment = 0.1f,
828 float deposition_velocity_limit = 0.01f,
829 float drag_rate = 0.001f);
830
831void sediment_layer(Array &z,
832 const Array &talus_layer,
833 const Array &talus_upper_limit,
834 int iterations,
835 bool apply_post_filter = true,
836 Array *p_deposition_map = nullptr);
837
857void stratify(Array &z,
858 Array *p_mask,
859 std::vector<float> hs,
860 std::vector<float> gamma,
861 Array *p_noise = nullptr);
862
863void stratify(Array &z,
864 std::vector<float> hs,
865 std::vector<float> gamma,
866 Array *p_noise = nullptr);
867
868void stratify(Array &z,
869 std::vector<float> hs,
870 float gamma = 0.5f,
871 Array *p_noise = nullptr);
872
873void stratify(Array &z,
874 Array &partition,
875 int nstrata,
876 float strata_noise,
877 float gamma,
878 float gamma_noise,
879 int npartitions,
880 uint seed,
881 float mixing_gain_factor = 1.f,
882 Array *p_noise = nullptr,
883 float vmin = 1.f,
884 float vmax = 0.f);
885
909void stratify_multiscale(Array &z,
910 float zmin,
911 float zmax,
912 std::vector<int> n_strata,
913 std::vector<float> strata_noise,
914 std::vector<float> gamma_list,
915 std::vector<float> gamma_noise,
916 uint seed,
917 Array *p_mask = nullptr,
918 Array *p_noise = nullptr);
919
940void stratify_oblique(Array &z,
941 Array *p_mask,
942 std::vector<float> hs,
943 std::vector<float> gamma,
944 float talus,
945 float angle,
946 Array *p_noise = nullptr);
947
948void stratify_oblique(Array &z,
949 std::vector<float> hs,
950 std::vector<float> gamma,
951 float talus,
952 float angle,
953 Array *p_noise = nullptr);
954
974void thermal(Array &z,
975 Array *p_mask,
976 const Array &talus,
977 int iterations = 10,
978 Array *p_bedrock = nullptr,
979 Array *p_deposition_map = nullptr);
980
981void thermal(Array &z,
982 const Array &talus,
983 int iterations = 10,
984 Array *p_bedrock = nullptr,
985 Array *p_deposition_map = nullptr);
986
987void thermal(Array &z,
988 float talus,
989 int iterations = 10,
990 Array *p_bedrock = nullptr,
991 Array *p_deposition_map = nullptr);
992
1014void thermal_auto_bedrock(Array &z,
1015 const Array &talus,
1016 int iterations = 10,
1017 Array *p_deposition_map = nullptr);
1018
1019void thermal_auto_bedrock(Array &z,
1020 float talus,
1021 int iterations = 10,
1022 Array *p_deposition_map = nullptr);
1023
1024void thermal_auto_bedrock(Array &z,
1025 Array *p_mask,
1026 float talus,
1027 int iterations = 10,
1028 Array *p_deposition_map = nullptr);
1029
1047void thermal_flatten(Array &z,
1048 const Array &talus,
1049 const Array &bedrock,
1050 int iterations = 10,
1051 int post_filter_ir = 1);
1052
1053void thermal_flatten(Array &z,
1054 float talus,
1055 int iterations = 10,
1056 int post_filter_ir = 1);
1057
1077void thermal_olsen(Array &z,
1078 const Array &talus,
1079 int iterations = 10,
1080 Array *p_bedrock = nullptr,
1081 Array *p_deposition_map = nullptr);
1082
1095void thermal_rib(Array &z, int iterations, Array *p_bedrock = nullptr);
1096
1120void thermal_schott(Array &z,
1121 const Array &talus,
1122 int iterations = 10,
1123 float intensity = 0.001f);
1124
1125void thermal_schott(Array &z,
1126 const Array &talus,
1127 Array *p_mask,
1128 int iterations = 10,
1129 float intensity = 0.001f);
1130
1152void thermal_schott(Array &z,
1153 const float talus,
1154 int iterations = 10,
1155 float intensity = 0.001f);
1156
1157void thermal_schott(Array &z,
1158 const float talus,
1159 Array *p_mask,
1160 int iterations = 10,
1161 float intensity = 0.001f);
1162
1163} // namespace hmap
1164
1165namespace hmap::gpu
1166{
1167
1169void hydraulic_particle(Array &z,
1170 int nparticles,
1171 int seed,
1172 Array *p_bedrock = nullptr,
1173 Array *p_moisture_map = nullptr,
1174 Array *p_erosion_map = nullptr,
1175 Array *p_deposition_map = nullptr,
1176 float c_capacity = 10.f,
1177 float c_erosion = 0.05f,
1178 float c_deposition = 0.05f,
1179 float c_inertia = 0.3f,
1180 float drag_rate = 0.001f,
1181 float evap_rate = 0.001f,
1182 bool post_filtering = false);
1183
1185void hydraulic_particle(Array &z,
1186 Array *p_mask,
1187 int nparticles,
1188 int seed,
1189 Array *p_bedrock = nullptr,
1190 Array *p_moisture_map = nullptr,
1191 Array *p_erosion_map = nullptr,
1192 Array *p_deposition_map = nullptr,
1193 float c_capacity = 10.f,
1194 float c_erosion = 0.05f,
1195 float c_deposition = 0.05f,
1196 float c_inertia = 0.3f,
1197 float drag_rate = 0.001f,
1198 float evap_rate = 0.001f,
1199 bool post_filtering = false);
1200
1247void hydraulic_schott(Array &z,
1248 int iterations,
1249 const Array &talus,
1250 float c_erosion = 1.f,
1251 float c_thermal = 0.1f,
1252 float c_deposition = 0.2f,
1253 float flow_acc_exponent = 0.8f,
1254 float flow_acc_exponent_depo = 0.8f,
1255 float flow_routing_exponent = 1.3f,
1256 float thermal_weight = 1.5f,
1257 float deposition_weight = 2.5f,
1258 Array *p_flow = nullptr);
1259
1260void hydraulic_schott(Array &z,
1261 int iterations,
1262 const Array &talus,
1263 Array *p_mask,
1264 float c_erosion = 1.f,
1265 float c_thermal = 0.1f,
1266 float c_deposition = 0.2f,
1267 float flow_acc_exponent = 0.8f,
1268 float flow_acc_exponent_depo = 0.8f,
1269 float flow_routing_exponent = 1.3f,
1270 float thermal_weight = 1.5f,
1271 float deposition_weight = 2.5f,
1272 Array *p_flow = nullptr);
1273
1275void hydraulic_stream_log(Array &z,
1276 float c_erosion,
1277 float talus_ref,
1278 int deposition_ir = 32,
1279 float deposition_scale_ratio = 1.f,
1280 float gradient_power = 0.8f,
1281 float gradient_scaling_ratio = 1.f,
1282 int gradient_prefilter_ir = 16,
1283 float saturation_ratio = 1.f,
1284 Array *p_bedrock = nullptr,
1285 Array *p_moisture_map = nullptr,
1286 Array *p_erosion_map = nullptr,
1287 Array *p_deposition_map = nullptr,
1288 Array *p_flow_map = nullptr);
1289
1290void hydraulic_stream_log(Array &z,
1291 float c_erosion,
1292 float talus_ref,
1293 Array *p_mask,
1294 int deposition_ir = 32,
1295 float deposition_scale_ratio = 1.f,
1296 float gradient_power = 0.8f,
1297 float gradient_scaling_ratio = 1.f,
1298 int gradient_prefilter_ir = 16,
1299 float saturation_ratio = 1.f,
1300 Array *p_bedrock = nullptr,
1301 Array *p_moisture_map = nullptr,
1302 Array *p_erosion_map = nullptr,
1303 Array *p_deposition_map = nullptr,
1304 Array *p_flow_map = nullptr);
1305
1357void rifts(Array &z,
1358 const Vec2<float> &kw, // = {4.f, 1.2f},
1359 float angle, // degs
1360 float amplitude,
1361 uint seed,
1362 float elevation_noise_shift = 0.f,
1363 float k_smooth_bottom = 0.05f,
1364 float k_smooth_top = 0.05f,
1365 float radial_spread_amp = 0.2f,
1366 float elevation_noise_amp = 0.1f,
1367 float clamp_vmin = 0.f,
1368 float remap_vmin = 0.f,
1369 bool apply_mask = true,
1370 bool reverse_mask = false,
1371 float mask_gamma = 1.f,
1372 const Array *p_noise_x = nullptr,
1373 const Array *p_noise_y = nullptr,
1374 const Array *p_mask = nullptr,
1375 const Vec2<float> &center = {0.5f, 0.5f},
1376 const Vec4<float> &bbox = {0.f, 1.f, 0.f, 1.f});
1377
1435void strata(Array &z,
1436 float angle,
1437 float slope,
1438 float gamma, // e.g 0.5f or 1.5f
1439 uint seed,
1440 bool linear_gamma = true,
1441 float kz = 1.f,
1442 int octaves = 4,
1443 float lacunarity = 2.f,
1444 float gamma_noise_ratio = 0.5f,
1445 float noise_amp = 0.4f,
1446 const Vec2<float> &noise_kw = {4.f, 4.f},
1447 const Vec2<float> &ridge_noise_kw = {4.f, 1.2f},
1448 float ridge_angle_shift = 45.f,
1449 float ridge_noise_amp = 0.5f,
1450 float ridge_clamp_vmin = 0.f,
1451 float ridge_remap_vmin = 0.f,
1452 bool apply_elevation_mask = true,
1453 bool apply_ridge_mask = true,
1454 float mask_gamma = 0.4f,
1455 const Array *p_mask = nullptr,
1456 const Vec4<float> &bbox = {0.f, 1.f, 0.f, 1.f});
1457
1459void thermal(Array &z,
1460 const Array &talus,
1461 int iterations = 10,
1462 Array *p_bedrock = nullptr,
1463 Array *p_deposition_map = nullptr);
1464
1466void thermal(Array &z,
1467 Array *p_mask,
1468 const Array &talus,
1469 int iterations = 10,
1470 Array *p_bedrock = nullptr,
1471 Array *p_deposition_map = nullptr);
1472
1474void thermal(Array &z,
1475 float talus,
1476 int iterations = 10,
1477 Array *p_bedrock = nullptr,
1478 Array *p_deposition_map = nullptr);
1479
1481void thermal_auto_bedrock(Array &z,
1482 const Array &talus,
1483 int iterations = 10,
1484 Array *p_deposition_map = nullptr);
1485
1487void thermal_auto_bedrock(Array &z,
1488 Array *p_mask,
1489 const Array &talus,
1490 int iterations = 10,
1491 Array *p_deposition_map = nullptr);
1492
1494void thermal_auto_bedrock(Array &z,
1495 float,
1496 int iterations = 10,
1497 Array *p_deposition_map = nullptr);
1498
1516void thermal_inflate(Array &z, const Array &talus, int iterations = 10);
1517
1518void thermal_inflate(Array &z,
1519 const Array *p_mask,
1520 const Array &talus,
1521 int iterations = 10);
1522
1524void thermal_rib(Array &z, int iterations, Array *p_bedrock = nullptr);
1525
1545void thermal_ridge(Array &z,
1546 const Array &talus,
1547 int iterations = 10,
1548 Array *p_deposition_map = nullptr);
1549
1550void thermal_ridge(Array &z,
1551 const Array *p_mask,
1552 const Array &talus,
1553 int iterations = 10,
1554 Array *p_deposition_map = nullptr);
1555
1577void thermal_scree(Array &z,
1578 const Array &talus,
1579 const Array &zmax,
1580 int iterations = 10,
1581 bool talus_constraint = true,
1582 Array *p_deposition_map = nullptr);
1583
1584void thermal_scree(Array &z,
1585 const Array *p_mask,
1586 const Array &talus,
1587 const Array &zmax,
1588 int iterations = 10,
1589 bool talus_constraint = true,
1590 Array *p_deposition_map = nullptr);
1591
1592} // 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::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::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:11
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:332
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:148
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