selector.hpp

Go to the documentation of this file.

/* Copyright (c) 2023 Otto Link. Distributed under the terms of the GNU General
   Public License. The full license is in the file LICENSE, distributed with
   this software. */
 
#pragma once
 
#include "highmap/array.hpp"
#include "highmap/range.hpp"
 
namespace hmap
{
 
Array perturb_mask_contour(const Array &mask,
                           const Array &noise,
                           float        max_displacement,
                           int          ir = 1);
 
Array scan_mask(const Array &array,
                float        contrast = 0.5f,
                float        brightness = 0.5f);
 
Array select_angle(const Array &array, float angle, float sigma, int ir = 0);
 
Array select_blob_log(const Array &array, int ir);
 
Array select_cavities(const Array &array, int ir, bool concave = true);
 
Array select_elevation_slope(const Array &array, float gradient_scale);
Array select_elevation_slope(const Array &array,
                             float        gradient_scale,
                             float        vmax); 
 
Array select_eq(const Array &array, float value);
 
Array select_gradient_angle(const Array &array, float angle);
 
Array select_gradient_binary(const Array &array, float talus_center);
 
Array select_gradient_exp(const Array &array,
                          float        talus_center,
                          float        talus_sigma);
 
Array select_gradient_inv(const Array &array,
                          float        talus_center,
                          float        talus_sigma);
 
Array select_gt(const Array &array, float value);
 
Array select_interval(const Array &array, float value1, float value2);
 
Array select_inward_outward_slope(const Array &array,
                                  Vec2<float>  center = {0.5f, 0.5f},
                                  Vec4<float>  bbox = {0.f, 1.f, 0.f, 1.f});
 
Array select_lt(const Array &array, float value);
 
Array select_midrange(const Array &array, float gain, float vmin, float vmax);
 
Array select_midrange(const Array &array, float gain);
 
void select_multiband3(const Array &array,
                       Array       &band_low,
                       Array       &band_mid,
                       Array       &band_high,
                       float        ratio1,
                       float        ratio2,
                       float        overlap,
                       float        vmin,
                       float        vmax);
 
void select_multiband3(const Array &array,
                       Array       &band_low,
                       Array       &band_mid,
                       Array       &band_high,
                       float        ratio1,
                       float        ratio2,
                       float        overlap);
 
Array select_pulse(const Array &array, float value, float sigma);
 
Array select_rivers(const Array &array, float talus_ref, float clipping_ratio);
 
Array select_transitions(const Array &array1,
                         const Array &array2,
                         const Array &array_blend);
 
Array select_valley(const Array &z,
                    int          ir,
                    bool         zero_at_borders = true,
                    bool         ridge_select = false);
 
} // namespace hmap
 
namespace hmap::gpu
{
 
Array select_soil_flow(const Array &z,
                       int          ir_gradient = 1,
                       float        gradient_weight = 1.f,
                       float        gradient_scaling_factor = 0.f,
                       float        flow_weight = 0.05f,
                       float        talus_ref = 0.f,
                       float        clipping_ratio = 50.f,
                       float        flow_gamma = 1.f,
                       float        k_smooth = 0.01f);
 
Array select_soil_rocks(
    const Array &z,
    int          ir_max = 64,
    int          ir_min = 0,
    int          steps = 4,
    float        smaller_scales_weight = 1.f,
    ClampMode    curvature_clamp_mode = ClampMode::POSITIVE_ONLY,
    float        curvature_clamping = 1.f);
 
Array select_soil_weathered(
    const Array &z,
    int          ir_curvature = 0,
    int          ir_gradient = 4,
    ClampMode    curvature_clamp_mode = ClampMode::POSITIVE_ONLY,
    float        curvature_clamping = 10.f,
    float        curvature_weight = 1.f,
    float        gradient_weight = 1.f,
    float        gradient_scaling_factor = 0.f);
 
// if the gradient norm is known before-hand
Array select_soil_weathered(const Array &z,
                            const Array &gradient_norm, // in [0, 1]
                            int          ir_curvature,
                            ClampMode    curvature_clamp_mode,
                            float        curvature_clamping,
                            float        curvature_weight,
                            float        gradient_weight,
                            float gradient_scaling_factor); // for curvature
 
Array select_valley(const Array &z,
                    int          ir,
                    bool         zero_at_borders = true,
                    bool         ridge_select = false);
 
} // namespace hmap::gpu