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"


namespace hmap

{


enum neighborhood : int

{

  MOORE,

  VON_NEUMANN,

  // orthogonal

  CROSS

        // neighbors.

};


Array diffusion_retargeting(const Array &array_before,

                            const Array &array_after,

                            int          ir);


void directional_blur(Array &array,

                      int    ir,

                      float  angle,

                      float  intensity,

                      float  stretch = 1.f,

                      float  spread = 1.f);


void directional_blur(Array       &array,

                      int          ir,

                      const Array &angle,

                      float        intensity,

                      float        stretch = 1.f,

                      float        spread = 1.f);


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,

                  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, float noise_ratio = 0.2f);


void fill_talus_fast(Array    &z,

                     Vec2<int> shape_coarse,

                     float     talus,

                     uint      seed,

                     float     noise_ratio = 0.2f);


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.2f, int iterations = 3);


void laplace(Array       &array,

             const Array *p_mask,

             float        sigma = 0.2f,

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


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


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


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


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


Array minimum_local_disk(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,

                         Vec4<float>  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,

    Vec4<float>  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_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,

             Vec4<float>  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,

             Vec4<float> bbox = {0.f, 1.f, 0.f, 1.f});


} // namespace hmap


namespace hmap::gpu

{


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 maximum_local(const Array &array, int ir);


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


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


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


Array minimum_local_disk(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 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_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:151

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

hmap
Definition algebra.hpp:28

hmap::expand_talus
void expand_talus(Array &z, const Array &mask, float talus, uint seed, float noise_ratio=0.2f)
Definition filters.cpp:167

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

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

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

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

hmap::directional_blur
void directional_blur(Array &array, int ir, float angle, float intensity, float stretch=1.f, float spread=1.f)
Applies a directional blur to a 2D array based on a spatially varying angle field.
Definition directional_blur.cpp:55

hmap::maximum_local_disk
Array maximum_local_disk(const Array &array, int ir)
Return the local maxima based on a maximum filter using a disk kernel.
Definition range.cpp:237

hmap::minimum_local_disk
Array minimum_local_disk(const Array &array, int ir)
Return the local minima based on a maximum filter using a disk kernel.
Definition range.cpp:321

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

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::steepen
void steepen(Array &array, float scale, int ir=8)
Steepen (or flatten) the array map.
Definition filters.cpp:1234

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

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

hmap::maximum_local
Array maximum_local(const Array &array, int ir)
Return the local maxima based on a maximum filter with a square kernel.
Definition range.cpp:200

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

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

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

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

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

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

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

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

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

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

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

hmap::fill_talus_fast
void fill_talus_fast(Array &z, Vec2< int > shape_coarse, float talus, uint seed, float noise_ratio=0.2f)
Fill terrain values with a given downslope talus, optimized using a coarse mesh for faster computatio...
Definition filters.cpp:284

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

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

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

hmap::CROSS
@ CROSS
neighbors (N, S, E, W).
Definition filters.hpp:37

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

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

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

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

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

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

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

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

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

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

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::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, Vec4< float > bbox={0.f, 1.f, 0.f, 1.f})
Apply wrinkle effect to the array, creating wrinkled or bumpy features.
Definition filters.cpp:1428

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

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

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

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::minimum_local
Array minimum_local(const Array &array, int ir)
Return the local minima based on a maximum filter with a square kernel.
Definition range.cpp:316

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

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::laplace
void laplace(Array &array, float sigma=0.2f, int iterations=3)
Apply a low-pass Laplace filter to the input array.
Definition filters.cpp:489

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

hmap::fill_talus
void fill_talus(Array &z, float talus, uint seed, float noise_ratio=0.2f)
Modifies a terrain array by filling it with talus slopes.
Definition filters.cpp:231

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::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, Vec4< float > bbox={0.f, 1.f, 0.f, 1.f})
Transform heightmap by adding "rock-like" features at higher slopes.
Definition recast.cpp:333

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

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

hmap::Vec4
Vec4 class for basic manipulation of 4D vectors.
Definition algebra.hpp:564