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 diffusion_retargeting(const Array &array_before,

                            const Array &array_after,

                            int          ir);


Array diffusion_retargeting(const Array &array_before,

                            const Array &array_after,

                            const Array &mask,

                            int          iterations);


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,

                  uint         seed,

                  int          ir = 1,

                  float        noise_ratio = 0.2f);


Array faceted(const Array &array,

              int          neighborhood = 0,

              const Array *p_noise_x = nullptr,

              const Array *p_noise_y = nullptr);


void fill_talus(Array       &z,

                float        talus,

                uint         seed,

                int          ir = 1,

                float        noise_ratio = 0.2f,

                const Array *p_seed_mask = nullptr);


void fill_talus(Array       &z,

                const Array &talus,

                uint         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);

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,

                         uint         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,

                         uint         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);


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,

             uint         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,

             uint         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);


Array tessellate(Array       &array,

                 uint         seed,

                 float        node_density = 0.001f,

                 const Array *p_weight = nullptr);


void wrinkle(Array       &array,

             float        wrinkle_amplitude,

             const Array *p_mask,

             float        wrinkle_angle = 0.f,

             float        displacement_amplitude = 1.f,

             int          ir = 0,

             float        kw = 2.f,

             uint         seed = 1,

             int          octaves = 8,

             float        weight = 0.7f,

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


void wrinkle(Array    &array,

             float     wrinkle_amplitude,

             float     wrinkle_angle = 0.f,

             float     displacement_amplitude = 1.f,

             int       ir = 0,

             float     kw = 2.f,

             uint      seed = 1,

             int       octaves = 8,

             float     weight = 0.7f,

             glm::vec4 bbox = {0.f, 1.f, 0.f, 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,

                                    float        talus,

                                    int          direction = 0);


Array project_talus_along_direction(const Array &array,

                                    float        talus,

                                    const Array *p_mask,

                                    int          direction = 0);


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);


} // 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::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, float talus, int direction=0)
Projects array values along a given direction using talus attenuation.
Definition filters_gpu.cpp:348

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

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

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

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:669

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:606

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

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:183

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

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:13

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:95

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

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:265

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:617

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:9

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

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

hmap
Definition algebra.hpp:23

hmap::expand_talus
void expand_talus(Array &z, const Array &mask, float talus, uint 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::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:379

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:599

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

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

hmap::threshold
float threshold(float x, float x0, float x1)
Applies a linear threshold to a scalar value.
Definition math.cpp:498

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:159

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:178

hmap::wrinkle
void wrinkle(Array &array, float wrinkle_amplitude, const Array *p_mask, float wrinkle_angle=0.f, float displacement_amplitude=1.f, int ir=0, float kw=2.f, uint seed=1, int octaves=8, float weight=0.7f, glm::vec4 bbox={0.f, 1.f, 0.f, 1.f})
Apply wrinkle effect to the array, creating wrinkled or bumpy features.
Definition filters.cpp:1307

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

hmap::tessellate
Array tessellate(Array &array, uint seed, float node_density=0.001f, const Array *p_weight=nullptr)
Apply tessellation to the array with random node placement.
Definition tesselate.cpp:18

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

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

hmap::fill_talus
void fill_talus(Array &z, float talus, uint 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:98

hmap::PrimitiveType
PrimitiveType
Defines the primitive shape used for synthesis.
Definition primitives.hpp:53

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:669

hmap::terrace
void terrace(Array &array, uint 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:1186

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:96

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:840

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:778

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:331

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:76

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

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:941

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:415

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:1136

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:475

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:466

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

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:892

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:20

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:1085

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

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:930

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::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:605

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

hmap::diffusion_retargeting
Array diffusion_retargeting(const Array &array_before, const Array &array_after, int ir)
Applies diffusion retargeting by detecting local maxima and adjusting based on the difference between...
Definition diffusion_retargeting.cpp:17

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:681

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

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:854

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

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:32

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:308

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:797

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:146

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:223

hmap::faceted
Array faceted(const Array &array, int neighborhood=0, const Array *p_noise_x=nullptr, const Array *p_noise_y=nullptr)
Generate a faceted heightmap that retains the main features of the input heightmap.
Definition faceted.cpp:17

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

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:272

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:231

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:79

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:11

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:27

hmap::recast_rocky_slopes
void recast_rocky_slopes(Array &array, float talus, int ir, float amplitude, uint 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:333

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:994

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:101

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:207

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:51

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:1057

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:150

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:140

primitives.hpp
Core procedural primitives for heightmap generation, including noise functions (Perlin,...