HighMap/filters_8hpp_source.html

/* 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/primitives.hpp"


namespace hmap

{


// clang-format off


enum neighborhood : int

{

    MOORE,

    VON_NEUMANN,

    // orthogonal neighbors (N, S, E, W).

    CROSS

    // neighbors.

};


// clang-format on


Array bulkify(const Array         &z,

              const PrimitiveType &primitive_type,

              float                amp = 1.f,

              const Array         *p_noise_x = nullptr,

              const Array         *p_noise_y = nullptr,

              glm::vec2            center = {0.5f, 0.5f},

              glm::vec4            bbox = {0.f, 1.f, 0.f, 1.f});


Array dequantize(const Array  &array,

                 std::uint32_t seed,

                 float         dither_amplitude = 0.01f,

                 int           filtering_iterations = 1);


void equalize(Array &array);


void equalize(Array &array, const Array *p_mask);


void expand(Array &array, int ir, const Array *p_mask, int iterations = 1);


void expand(Array &array, int ir, int iterations = 1);


void expand(Array &array, const Array &kernel, int iterations = 1);


void expand(Array       &array,

            const Array &kernel,

            const Array *p_mask,

            int          iterations = 1);


void expand_directional(Array       &array,

                        int          ir,

                        float        angle,

                        float        aspect_ratio,

                        float        anisotropy = 1.f,

                        const Array *p_mask = nullptr);


void expand_talus(Array        &z,

                  const Array  &mask,

                  float         talus,

                  std::uint32_t seed,

                  int           ir = 1,

                  float         noise_ratio = 0.2f);

void fill_talus(Array        &z,

                float         talus,

                std::uint32_t seed,

                int           ir = 1,

                float         noise_ratio = 0.2f,

                const Array  *p_seed_mask = nullptr);


void fill_talus(Array        &z,

                const Array  &talus,

                std::uint32_t seed,

                int           ir = 1,

                float         noise_ratio = 0.2f,

                const Array  *p_seed_mask = nullptr);


void fold(Array &array,

          float  vmin,

          float  vmax,

          int    iterations = 3,

          float  k = 0.05f);


void fold(Array &array, int iterations = 3, float k = 0.05f);


void gain(Array &array, float factor, const Array *p_mask);


void gain(Array &array, float factor);


void gamma_correction(Array &array, float gamma, const Array *p_mask);


void gamma_correction(Array &array, float gamma);


void gamma_correction_local(Array &array, float gamma, int ir, float k = 0.1f);


void gamma_correction_local(Array       &array,

                            float        gamma,

                            int          ir,

                            const Array *p_mask,

                            float        k = 0.1f);


void kuwahara(Array &array, int ir, float mix_ratio = 1.f);


void kuwahara(Array &array, int ir, const Array *p_mask, float mix_ratio = 1.f);


void laplace(Array &array, float sigma = 0.125f, int iterations = 3);


void laplace(Array       &array,

             const Array *p_mask,

             float        sigma = 0.125f,

             int          iterations = 3);


void laplace1d(std::vector<float> &v, float sigma = 0.5f, int iterations = 1);


void laplace_edge_preserving(Array &array,

                             float  talus,

                             float  sigma = 0.2f,

                             int    iterations = 3);


void laplace_edge_preserving(Array       &array,

                             float        talus,

                             const Array *p_mask,

                             float        sigma = 0.2f,

                             int          iterations = 3);


void low_pass_high_order(Array &array, int order = 9, float sigma = 1.f);


void make_binary(Array &array, float threshold = 0.f);


void match_histogram(Array &array, const Array &array_reference);


Array mean_shift(const Array &array,

                 int          ir,

                 float        talus,

                 int          iterations = 1,

                 bool         talus_weighted = true);


Array mean_shift(const Array &array,

                 int          ir,

                 float        talus,

                 const Array *p_mask,

                 int          iterations = 1,

                 bool         talus_weighted = true);


void median_3x3(Array &array, const Array *p_mask);


void median_3x3(Array &array);


Array median_pseudo(const Array &array, int ir);


void normal_displacement(Array &array,

                         float  amount = 0.1f,

                         int    ir = 0,

                         bool   reverse = false);


void normal_displacement(Array       &array,

                         const Array *p_mask,

                         float        amount = 0.1f,

                         int          ir = 0,

                         bool         reverse = false);


void plateau(Array &array, const Array *p_mask, int ir, float factor);


void plateau(Array &array, int ir, float factor);


Array quantize(const Array &array, int nlevels, float vmin, float vmax);


Array quantize(const Array &array, int nlevels);


void recast_billow(Array &array, float vref, float k);


void recast_canyon(Array &array, const Array &vcut, float gamma = 4.f);


void recast_canyon(Array       &array,

                   const Array &vcut,

                   const Array *p_mask,

                   float        gamma = 4.f);


void recast_canyon(Array       &array,

                   float        vcut,

                   const Array *p_mask,

                   float        gamma = 4.f,

                   const Array *p_noise = nullptr);


void recast_canyon(Array       &array,

                   float        vcut,

                   float        gamma = 4.f,

                   const Array *p_noise = nullptr);


void recast_cliff(Array &array,

                  float  talus,

                  int    ir,

                  float  amplitude,

                  float  gain = 2.f);


void recast_cliff(Array       &array,

                  float        talus,

                  int          ir,

                  float        amplitude,

                  const Array *p_mask,

                  float        gain = 2.f);


void recast_cliff_directional(Array &array,

                              float  talus,

                              int    ir,

                              float  amplitude,

                              float  angle,

                              float  gain = 2.f);


void recast_cliff_directional(Array       &array,

                              float        talus,

                              int          ir,

                              float        amplitude,

                              float        angle,

                              const Array *p_mask,

                              float        gain = 2.f);


void recast_cracks(Array &array,

                   float  cut_min = 0.05f,

                   float  cut_max = 0.5f,

                   float  k_smoothing = 0.01f,

                   float  vmin = 0.f,

                   float  vmax = -1.f);


void recast_escarpment(Array &array,

                       int    ir = 16,

                       float  ratio = 0.1f,

                       float  scale = 1.f,

                       bool   reverse = false,

                       bool   transpose_effect = false,

                       float  global_scaling = 0.f);


void recast_escarpment(Array       &array,

                       const Array *p_mask,

                       int          ir = 16,

                       float        ratio = 0.1f,

                       float        scale = 1.f,

                       bool         reverse = false,

                       bool         transpose_effect = false,

                       float        global_scaling = 0.f);


void recast_peak(Array &array, int ir, float gamma = 2.f, float k = 0.1f);


void recast_peak(Array       &array,

                 int          ir,

                 const Array *p_mask,

                 float        gamma = 2.f,

                 float        k = 0.1f);


void recast_rocky_slopes(Array        &array,

                         float         talus,

                         int           ir,

                         float         amplitude,

                         std::uint32_t seed,

                         float         kw,

                         float         gamma = 0.5f,

                         const Array  *p_noise = nullptr,

                         glm::vec4     bbox = {0.f, 1.f, 0.f, 1.f});


void recast_rocky_slopes(Array        &array,

                         float         talus,

                         int           ir,

                         float         amplitude,

                         std::uint32_t seed,

                         float         kw,

                         const Array  *p_mask,

                         float         gamma = 0.5f,

                         const Array  *p_noise = nullptr,

                         glm::vec4 bbox = {0.f, 1.f, 0.f, 1.f});


void recast_sag(Array &array, float vref, float k);


void recast_sag(Array       &array,

                float        vref,

                float        k,

                const Array *p_mask);


void recurve(Array                    &array,

             const std::vector<float> &t,

             const std::vector<float> &v);


void recurve(Array                    &array,

             const std::vector<float> &t,

             const std::vector<float> &v,

             const Array              *p_mask);


void recurve_bexp(Array &array, float tau = 0.5f);


void recurve_bexp(Array       &array,

                  const Array *p_mask,

                  float        tau = 0.5f);


void recurve_exp(Array &array, float tau = 0.5f);


void recurve_exp(Array       &array,

                 const Array *p_mask,

                 float        tau = 0.5f);


void recurve_kura(Array &array, float a, float b);


void recurve_kura(Array       &array,

                  float        a,

                  float        b,

                  const Array *p_mask);


void recurve_s(Array &array);


void recurve_s(Array &array, const Array *p_mask);


void recurve_smoothstep_rational(Array &array, float n);


void recurve_smoothstep_rational(Array       &array,

                                 float        n,

                                 const Array *p_mask);


void reverse_above_theshold(Array       &array,

                            const Array &threshold,

                            float        scaling = 1.f,

                            float        transition_extent = 0.f);


void reverse_above_theshold(Array &array,

                            float  threshold,

                            float  scaling = 1.f,

                            float  transition_extent = 0.f);


void reverse_above_theshold(Array       &array,

                            const Array &threshold,

                            const Array *p_mask,

                            float        scaling = 1.f,

                            float transition_extent = 0.f);


void reverse_above_theshold(Array       &array,

                            float        threshold,

                            const Array *p_mask,

                            float        scaling = 1.f,

                            float transition_extent = 0.f);


void saturate(Array &array,

              float  vmin,

              float  vmax,

              float  from_min,

              float  from_max,

              float  k = 0.f);


void saturate(Array &array, float vmin, float vmax, float k = 0.f);

// @overload


void saturate_percentile(Array &array,

                         float  percentile_low,

                         float  percentile_high,

                         float  k = 0.f);


void sharpen(Array &array, float ratio = 1.f);


void sharpen(Array       &array,

             const Array *p_mask,

             float        ratio = 1.f);


void sharpen_cone(Array &array, int ir, float intensity = 0.5f);


void sharpen_cone(Array       &array,

                  const Array *p_mask,

                  int          ir,

                  float        scale = 0.5f);


void shrink(Array &array, int ir, int iterations = 1);

void shrink(Array       &array,

            int          ir,

            const Array *p_mask,

            int          iterations = 1);

void shrink(Array       &array,

            const Array &kernel,

            int          iterations = 1);

void shrink(Array       &array,

            const Array &kernel,

            const Array *p_mask,

            int          iterations = 1);


void shrink_directional(Array       &array,

                        int          ir,

                        float        angle,

                        float        aspect_ratio,

                        float        anisotropy = 1.f,

                        const Array *p_mask = nullptr);


void smooth_cone(Array &array, int ir);

void smooth_cone(Array &array, int ir, const Array *p_mask);


void smooth_cpulse(Array &array, int ir);

void smooth_cpulse(Array &array, int ir, const Array *p_mask);


void smooth_cpulse_edge_removing(Array &array,

                                 float  talus,

                                 float  talus_width,

                                 int    ir);


void smooth_flat(Array &array, int ir);


void smooth_gaussian(Array &array, int ir);

void smooth_gaussian(Array &array, int ir, const Array *p_mask);

void smooth_fill(Array &array,

                 int    ir,

                 float  k = 0.1f,

                 Array *p_deposition_map = nullptr);


void smooth_fill(Array       &array,

                 int          ir,

                 const Array *p_mask,

                 float        k = 0.1f,

                 Array       *p_deposition_map = nullptr);


void smooth_fill_holes(Array &array, int ir);

void smooth_fill_holes(Array       &array,

                       int          ir,

                       const Array *p_mask);


void smooth_fill_smear_peaks(Array &array, int ir);

void smooth_fill_smear_peaks(Array       &array,

                             int          ir,

                             const Array *p_mask);


void smoothstep_local(Array &array, int ir);


void smoothstep_local(Array &array, int ir, const Array *p_mask);


void steepen(Array &array, float scale, int ir = 8);

void steepen(Array       &array,

             float        scale,

             const Array *p_mask,

             int          ir = 8);


void steepen_convective(Array &array,

                        float  angle,

                        int    iterations = 1,

                        int    ir = 0,

                        float  dt = 0.1f);


void steepen_convective(Array       &array,

                        float        angle,

                        const Array *p_mask,

                        int          iterations = 1,

                        int          ir = 0,

                        float        dt = 0.1f);


void terrace(Array        &array,

             std::uint32_t seed,

             int           nlevels,

             float         gain = 0.9f,

             float         noise_ratio = 0.f,

             const Array  *p_noise = nullptr,

             float         vmin = 0.f,

             float         vmax = -1.f);


void terrace(Array        &array,

             std::uint32_t seed,

             int           nlevels,

             const Array  *p_mask,

             float         gain = 0.9f,

             float         noise_ratio = 0.f,

             const Array  *p_noise = nullptr,

             float         vmin = 0.f,

             float         vmax = -1.f);


} // namespace hmap


namespace hmap::gpu

{


Array bilateral_filter(const Array &array,

                       const Array &kernel2d,

                       const Array &kernel1d,

                       float        kernel1d_value_scaling);


Array bilateral_filter(const Array &array,

                       int          ir,

                       float        kernel1d_value_scaling);


void directional_blur(Array       &array,

                      float        radius,

                      const Array &angle,

                      int          steps = 32);


void directional_blur(Array       &array,

                      float        radius,

                      const Array &angle,

                      const Array *p_mask,

                      int          steps = 32);


void expand(Array &array, int ir, int iterations = 1);

void expand(Array       &array,

            int          ir,

            const Array *p_mask,

            int          iterations = 1);

void expand(Array       &array,

            const Array &kernel,

            int          iterations = 1);

void expand(Array       &array,

            const Array &kernel,

            const Array *p_mask,

            int          iterations = 1);


void gamma_correction_local(Array &array, float gamma, int ir, float k = 0.1f);

void gamma_correction_local(Array       &array,

                            float        gamma,

                            int          ir,

                            const Array *p_mask,

                            float        k = 0.1f);


void laplace(Array &array, float sigma = 0.2f, int iterations = 3);

void laplace(Array       &array,

             const Array *p_mask,

             float        sigma = 0.2f,

             int          iterations = 3);


Array mean_shift(const Array &array,

                 int          ir,

                 float        talus,

                 int          iterations = 1,

                 bool         talus_weighted = true);


Array mean_shift(const Array &array,

                 int          ir,

                 float        talus,

                 const Array *p_mask,

                 int          iterations = 1,

                 bool         talus_weighted = true);


void median_3x3(Array &array);

void median_3x3(Array &array, const Array *p_mask);


Array median_pseudo(const Array &array, int ir);


void normal_displacement(Array &array,

                         float  amount = 0.1f,

                         int    ir = 0,

                         bool   reverse = false);

void normal_displacement(Array       &array,

                         const Array *p_mask,

                         float        amount = 0.1f,

                         int          ir = 0,

                         bool         reverse = false);


void plateau(Array &array, const Array *p_mask, int ir, float factor);

void plateau(Array &array, int ir, float factor);


Array project_talus_along_direction(const Array &array,

                                    const Array &talus,

                                    int          direction = 0,

                                    float        vmin = -FLT_MAX);


Array project_talus_along_direction(const Array &array,

                                    const Array &talus,

                                    const Array *p_mask,

                                    int          direction = 0,

                                    float        vmin = -FLT_MAX);


void shrink(Array &array, int ir, int iterations = 1);

void shrink(Array       &array,

            int          ir,

            const Array *p_mask,

            int          iterations = 1);

void shrink(Array       &array,

            const Array &kernel,

            int          iterations = 1);

void shrink(Array       &array,

            const Array &kernel,

            const Array *p_mask,

            int          iterations = 1);


void smooth_cpulse(Array &array, int ir);


void smooth_cpulse(Array &array, int ir, const Array *p_mask);


void smooth_cpulse_edge_removing(Array &array,

                                 float  talus,

                                 float  talus_width,

                                 int    ir);


void smooth_fill(Array &array,

                 int    ir,

                 float  k = 0.1f,

                 Array *p_deposition_map = nullptr);

void smooth_fill(Array       &array,

                 int          ir,

                 const Array *p_mask,

                 float        k = 0.1f,

                 Array       *p_deposition_map = nullptr);


void smooth_fill_holes(Array &array, int ir);

void smooth_fill_holes(Array       &array,

                       int          ir,

                       const Array *p_mask);


void smooth_fill_smear_peaks(Array &array, int ir);

void smooth_fill_smear_peaks(Array       &array,

                             int          ir,

                             const Array *p_mask);


Array spectral_equalizer(const Array              &array,

                         const std::vector<float> &weights,

                         int                       ir_min,

                         int                       ir_max);


Array spectral_equalizer(const Array              &array,

                         const std::vector<float> &weights,

                         int                       ir_min,

                         int                       ir_max,

                         const Array              *p_mask);


} // namespace hmap::gpu

array.hpp
Declaration of the Array class for 2D floating-point arrays with various mathematical operations and ...

hmap::Array
Array class, helper to manipulate 2D float array with "(i, j)" indexing.
Definition array.hpp:32

hmap::gpu
Definition blending.hpp:186

hmap::gpu::project_talus_along_direction
Array project_talus_along_direction(const Array &array, const Array &talus, int direction=0, float vmin=-FLT_MAX)
Projects array values along a given direction using talus attenuation.
Definition filters_gpu.cpp:280

hmap::gpu::laplace
void laplace(Array &array, float sigma=0.2f, int iterations=3)
See hmap::laplace.
Definition filters_gpu.cpp:122

hmap::gpu::median_pseudo
Array median_pseudo(const Array &array, int ir)
See hmap::median_pseudo.
Definition filters_gpu.cpp:209

hmap::gpu::spectral_equalizer
Array spectral_equalizer(const Array &array, const std::vector< float > &weights, int ir_min, int ir_max)
Spectral equalizer for 2D fields using a multiscale Gaussian pyramid.
Definition spectral_equalizer.cpp:17

hmap::gpu::expand
void expand(Array &array, int ir, int iterations=1)
See hmap::expand.
Definition filters_gpu.cpp:23

hmap::gpu::smooth_fill_smear_peaks
void smooth_fill_smear_peaks(Array &array, int ir)
See hmap::smooth_fill_smear_peaks.
Definition filters_gpu.cpp:512

hmap::gpu::smooth_cpulse_edge_removing
void smooth_cpulse_edge_removing(Array &array, float talus, float talus_width, int ir)
See hmap::smooth_cpulse_edge_removing.
Definition filters_gpu.cpp:456

hmap::gpu::smooth_fill_holes
void smooth_fill_holes(Array &array, int ir)
See hmap::smooth_fill_holes.
Definition filters_gpu.cpp:489

hmap::gpu::mean_shift
Array mean_shift(const Array &array, int ir, float talus, int iterations=1, bool talus_weighted=true)
See hmap::mean_shift.
Definition filters_gpu.cpp:144

hmap::gpu::shrink
void shrink(Array &array, int ir, int iterations=1)
See hmap::shrink.
Definition filters_gpu.cpp:341

hmap::gpu::directional_blur
void directional_blur(Array &array, float radius, const Array &angle, int steps=32)
Applies a directional blur to the input array.
Definition directional_blur.cpp:14

hmap::gpu::gamma_correction_local
void gamma_correction_local(Array &array, float gamma, int ir, float k=0.1f)
See hmap::gamma_correction_local.
Definition filters_gpu.cpp:77

hmap::gpu::smooth_cpulse
void smooth_cpulse(Array &array, int ir)
See hmap::smooth_cpulse.
Definition filters_gpu.cpp:403

hmap::gpu::normal_displacement
void normal_displacement(Array &array, float amount=0.1f, int ir=0, bool reverse=false)
See hmap::normal_displacement.
Definition filters_gpu.cpp:216

hmap::gpu::smooth_fill
void smooth_fill(Array &array, int ir, float k=0.1f, Array *p_deposition_map=nullptr)
See hmap::smooth_fill.
Definition filters_gpu.cpp:467

hmap::gpu::bilateral_filter
Array bilateral_filter(const Array &array, const Array &kernel2d, const Array &kernel1d, float kernel1d_value_scaling)
Apply a bilateral filter to an array.
Definition bilateral_filter.cpp:13

hmap::gpu::plateau
void plateau(Array &array, const Array *p_mask, int ir, float factor)
See hmap::plateau.
Definition filters_gpu.cpp:247

hmap::gpu::median_3x3
void median_3x3(Array &array)
See hmap::median_3x3.
Definition filters_gpu.cpp:191

hmap
Definition algebra.hpp:23

hmap::recast_rocky_slopes
void recast_rocky_slopes(Array &array, float talus, int ir, float amplitude, std::uint32_t seed, float kw, float gamma=0.5f, const Array *p_noise=nullptr, glm::vec4 bbox={0.f, 1.f, 0.f, 1.f})
Transform heightmap by adding "rock-like" features at higher slopes.
Definition recast.cpp:311

hmap::laplace_edge_preserving
void laplace_edge_preserving(Array &array, float talus, float sigma=0.2f, int iterations=3)
Apply a low-pass anisotropic Laplace filter to the input array.
Definition filters.cpp:333

hmap::median_pseudo
Array median_pseudo(const Array &array, int ir)
Computes a fast pseudo-median approximation of a local neighborhood in an array.
Definition filters.cpp:551

hmap::equalize
void equalize(Array &array)
Apply histogram equalization to the array values.
Definition filters.cpp:33

hmap::smooth_fill_holes
void smooth_fill_holes(Array &array, int ir)
Apply smoothing to fill holes (elliptic concave surfaces).
Definition filters.cpp:913

hmap::terrace
void terrace(Array &array, std::uint32_t seed, int nlevels, float gain=0.9f, float noise_ratio=0.f, const Array *p_noise=nullptr, float vmin=0.f, float vmax=-1.f)
Applies a terrace effect to the values in an array.
Definition filters.cpp:1040

hmap::fold
void fold(Array &array, float vmin, float vmax, int iterations=3, float k=0.05f)
Apply a "folding" filter (successive absolute values) to the array elements.
Definition filters.cpp:143

hmap::saturate
void saturate(Array &array, float vmin, float vmax, float from_min, float from_max, float k=0.f)
Saturate the array values based on the input interval [vmin, vmax] (the output amplitude is not modif...
Definition recurve.cpp:122

hmap::threshold
Array threshold(const Array &array, float x0, float x1)
Linear threshold.
Definition math.cpp:400

hmap::steepen
void steepen(Array &array, float scale, int ir=8)
Steepen (or flatten) the array map.
Definition filters.cpp:978

hmap::make_binary
void make_binary(Array &array, float threshold=0.f)
Convert array values to binary using a threshold.
Definition filters.cpp:406

hmap::smooth_gaussian
void smooth_gaussian(Array &array, int ir)
Apply Gaussian filtering to the array.
Definition filters.cpp:849

hmap::PrimitiveType
PrimitiveType
Defines the primitive shape used for synthesis.
Definition functions.hpp:23

hmap::plateau
void plateau(Array &array, const Array *p_mask, int ir, float factor)
Apply a plateau-shape filter to the input array.
Definition filters.cpp:617

hmap::recast_cliff
void recast_cliff(Array &array, float talus, int ir, float amplitude, float gain=2.f)
Transform heightmap to add cliffs where gradients are steep enough.
Definition recast.cpp:94

hmap::shrink_directional
void shrink_directional(Array &array, int ir, float angle, float aspect_ratio, float anisotropy=1.f, const Array *p_mask=nullptr)
Apply directional shrinking, or "deflating", to emphasize the ridges in the terrain.
Definition filters.cpp:749

hmap::sharpen_cone
void sharpen_cone(Array &array, int ir, float intensity=0.5f)
Apply a sharpening filter based on a smooth cone filter.
Definition filters.cpp:706

hmap::laplace
void laplace(Array &array, float sigma=0.125f, int iterations=3)
Applies an iterative 8-neighbor Laplacian smoothing filter on an array.
Definition filters.cpp:290

hmap::recurve_exp
void recurve_exp(Array &array, float tau=0.5f)
Apply a curve adjustment filter using a "sharp exponential-shape" curve.
Definition recurve.cpp:54

hmap::dequantize
Array dequantize(const Array &array, std::uint32_t seed, float dither_amplitude=0.01f, int filtering_iterations=1)
Reduce quantization artifacts using dithering and smoothing.
Definition dequantize.cpp:14

hmap::sharpen
void sharpen(Array &array, float ratio=1.f)
Apply a sharpening filter based on the Laplace operator.
Definition filters.cpp:687

hmap::smooth_flat
void smooth_flat(Array &array, int ir)
Applies a smoothing average filter to the given 2D array in both dimensions.
Definition filters.cpp:836

hmap::low_pass_high_order
void low_pass_high_order(Array &array, int order=9, float sigma=1.f)
Apply a low-pass high-order filter to the input array.
Definition filters.cpp:365

hmap::quantize
Array quantize(const Array &array, int nlevels, float vmin, float vmax)
Quantize array values into discrete levels.
Definition dequantize.cpp:30

hmap::steepen_convective
void steepen_convective(Array &array, float angle, int iterations=1, int ir=0, float dt=0.1f)
Steepen array values by applying a nonlinear convection operator in a given direction.
Definition filters.cpp:994

hmap::mean_shift
Array mean_shift(const Array &array, int ir, float talus, int iterations=1, bool talus_weighted=true)
Applies the mean shift algorithm to the input array.
Definition filters.cpp:437

hmap::match_histogram
void match_histogram(Array &array, const Array &array_reference)
Transform the input array elevation to match the histogram of a reference array.
Definition filters.cpp:416

hmap::expand_talus
void expand_talus(Array &z, const Array &mask, float talus, std::uint32_t seed, int ir=1, float noise_ratio=0.2f)
Expand heights outward from a masked region with a talus slope limit.
Definition expand_talus.cpp:18

hmap::median_3x3
void median_3x3(Array &array, const Array *p_mask)
Apply a 3x3 median filter to the input array.
Definition filters.cpp:546

hmap::smooth_cpulse
void smooth_cpulse(Array &array, int ir)
Apply filtering to the array using convolution with a cubic pulse kernel.
Definition filters.cpp:794

hmap::fill_talus
void fill_talus(Array &z, float talus, std::uint32_t seed, int ir=1, float noise_ratio=0.2f, const Array *p_seed_mask=nullptr)
Enforce a talus slope constraint on a height field.
Definition fill_talus.cpp:95

hmap::recurve
void recurve(Array &array, const std::vector< float > &t, const std::vector< float > &v)
Apply a curve adjustment filter to the array.
Definition recurve.cpp:16

hmap::neighborhood
neighborhood
Enum representing different types of neighborhood lattices.
Definition filters.hpp:34

hmap::VON_NEUMANN
@ VON_NEUMANN
Von Neumann neighborhood: includes only the four.
Definition filters.hpp:36

hmap::CROSS
@ CROSS
Cross-shaped neighborhood: includes only the diagonal.
Definition filters.hpp:38

hmap::MOORE
@ MOORE
Moore neighborhood: includes all eight surrounding cells.
Definition filters.hpp:35

hmap::smoothstep_local
void smoothstep_local(Array &array, int ir)
Applies a localized smoothstep operation to the provided array.
Definition filters.cpp:957

hmap::recurve_s
void recurve_s(Array &array)
Apply a curve adjustment filter using a smooth "S-shape" curve.
Definition recurve.cpp:86

hmap::smooth_cpulse_edge_removing
void smooth_cpulse_edge_removing(Array &array, float talus, float talus_width, int ir)
Smooths an array while attenuating edges using a gradient-based pulse.
Definition filters.cpp:825

hmap::saturate_percentile
void saturate_percentile(Array &array, float percentile_low, float percentile_high, float k=0.f)
Saturate values based on percentile range.
Definition recurve.cpp:150

hmap::angle
float angle(const Point &p1, const Point &p2)
Computes the angle between two points relative to the x-axis.
Definition points.cpp:46

hmap::normal_displacement
void normal_displacement(Array &array, float amount=0.1f, int ir=0, bool reverse=false)
Apply a displacement to the terrain along the normal direction.
Definition filters.cpp:557

hmap::gain
void gain(Array &array, float factor, const Array *p_mask)
Apply a gain correction to the array elements.
Definition filters.cpp:173

hmap::reverse_above_theshold
void reverse_above_theshold(Array &array, const Array &threshold, float scaling=1.f, float transition_extent=0.f)
Applies a smooth reversal of values above a given threshold.
Definition filters.cpp:622

hmap::gamma_correction
void gamma_correction(Array &array, float gamma, const Array *p_mask)
Apply gamma correction to the input array.
Definition filters.cpp:188

hmap::smooth_cone
void smooth_cone(Array &array, int ir)
Apply a convolution filter with a cone kernel to smooth the array.
Definition filters.cpp:763

hmap::recast_sag
void recast_sag(Array &array, float vref, float k)
Transform heightmap to give a "cliff" like appearance.
Definition recast.cpp:378

hmap::laplace1d
void laplace1d(std::vector< float > &v, float sigma=0.5f, int iterations=1)
Apply a low-pass Laplace filter to a vector.
Definition vector.cpp:30

hmap::recast_peak
void recast_peak(Array &array, int ir, float gamma=2.f, float k=0.1f)
Transform heightmap to give a "peak" like appearance.
Definition recast.cpp:291

hmap::shrink
void shrink(Array &array, int ir, int iterations=1)
Apply shrinking, or "deflating", to emphasize the ridges in the heightmap.
Definition filters.cpp:718

hmap::recast_cliff_directional
void recast_cliff_directional(Array &array, float talus, int ir, float amplitude, float angle, float gain=2.f)
Transform heightmap to add directional cliffs where gradients are steep enough.
Definition recast.cpp:140

hmap::gamma_correction_local
void gamma_correction_local(Array &array, float gamma, int ir, float k=0.1f)
Apply a "local" gamma correction to the input array.
Definition filters.cpp:193

hmap::recast_billow
void recast_billow(Array &array, float vref, float k)
Transform heightmap to give a "billow" like appearance.
Definition recast.cpp:25

hmap::kuwahara
void kuwahara(Array &array, int ir, float mix_ratio=1.f)
Applies the Kuwahara filter to an array with optional per-pixel masking.
Definition filters.cpp:237

hmap::recast_escarpment
void recast_escarpment(Array &array, int ir=16, float ratio=0.1f, float scale=1.f, bool reverse=false, bool transpose_effect=false, float global_scaling=0.f)
Applies an escarpment effect to the given 2D array, modifying its values based on cumulative displace...
Definition recast.cpp:222

hmap::expand
void expand(Array &array, int ir, const Array *p_mask, int iterations=1)
Apply expansion, or "inflation", to emphasize the bulk of the terrain.
Definition filters.cpp:75

hmap::bulkify
Array bulkify(const Array &z, const PrimitiveType &primitive_type, float amp=1.f, const Array *p_noise_x=nullptr, const Array *p_noise_y=nullptr, glm::vec2 center={0.5f, 0.5f}, glm::vec4 bbox={0.f, 1.f, 0.f, 1.f})
Applies a primitive-based displacement to an array.
Definition bulkify.cpp:10

hmap::recast_canyon
void recast_canyon(Array &array, const Array &vcut, float gamma=4.f)
Transform heightmap to give a "canyon" like appearance.
Definition recast.cpp:30

hmap::smooth_fill
void smooth_fill(Array &array, int ir, float k=0.1f, Array *p_deposition_map=nullptr)
Apply cubic pulse smoothing to fill lower flat regions while preserving some sharpness.
Definition filters.cpp:883

hmap::recurve_kura
void recurve_kura(Array &array, float a, float b)
Apply a curve adjustment filter using Kumaraswamy's cumulative distribution function (CDF).
Definition recurve.cpp:70

hmap::recast_cracks
void recast_cracks(Array &array, float cut_min=0.05f, float cut_max=0.5f, float k_smoothing=0.01f, float vmin=0.f, float vmax=-1.f)
Definition recast.cpp:198

hmap::recurve_bexp
void recurve_bexp(Array &array, float tau=0.5f)
Apply a curve adjustment filter using a "bumpy exponential-shape" curve.
Definition recurve.cpp:38

hmap::smooth_fill_smear_peaks
void smooth_fill_smear_peaks(Array &array, int ir)
Apply smoothing to smear peaks (elliptic convex surfaces).
Definition filters.cpp:934

hmap::recurve_smoothstep_rational
void recurve_smoothstep_rational(Array &array, float n)
Apply a curve adjustment filter using an nth-order smoothstep curve.
Definition recurve.cpp:101

hmap::expand_directional
void expand_directional(Array &array, int ir, float angle, float aspect_ratio, float anisotropy=1.f, const Array *p_mask=nullptr)
Apply expansion, or "inflation", to emphasize the bulk of the terrain, using a directional kernel.
Definition filters.cpp:124

primitives.hpp