gradient.hpp

Go to the documentation of this file.

/* Copyright (c) 2023 Otto Link. Distributed under the terms of the GNU General
   Public License. The full license is in the file LICENSE, distributed with
   this software. */
 
#pragma once
 
#include "highmap/array.hpp"
#include "highmap/tensor.hpp"
 
namespace hmap
{
 
Array divergence_from_gradients(const Array &dx, const Array &dy);
 
std::vector<float> gradient1d(const std::vector<float> &v);
 
Array gradient_angle(const Array &array, bool downward = false);
 
Array gradient_angle_circular_smoothing(const Array &array,
                                        int          ir,
                                        bool         downward = false);
 
Array gradient_norm(const Array &array,
                    Array       *p_dx = nullptr,
                    Array       *p_dy = nullptr);
 
Array gradient_norm_prewitt(const Array &array,
                            Array       *p_dx = nullptr,
                            Array       *p_dy = nullptr);
 
Array gradient_norm_scharr(const Array &array,
                           Array       *p_dx = nullptr,
                           Array       *p_dy = nullptr);
 
Array gradient_norm_sobel(const Array &array,
                          Array       *p_dx = nullptr,
                          Array       *p_dy = nullptr);
 
Array gradient_talus(const Array &array);
 
void gradient_talus(const Array &array, Array &talus); 
 
Array gradient_x(const Array &array);
 
void gradient_x(const Array &array, Array &dx); 
 
Array gradient_y(const Array &array);
 
void gradient_y(const Array &array, Array &dy); 
 
Array laplacian(const Array &array);
 
Tensor normal_map(const Array &array);
 
Array normal_map_to_heightmap(const Tensor &nmap);
 
Array normal_map_to_heightmap_poisson(const Tensor &nmap,
                                      int           iterations = 500,
                                      float         omega = 1.5f);
 
void solve_poisson_gauss_seidel(const Array &rhs,
                                Array       &h,
                                int          iterations = 500,
                                float        omega = 1.0f);
 
Array unwrap_phase(const Array &alpha);
 
/* See unit tests: @ref test_gradient.cpp */
Array talus_jump_mask(const Array &z, float threshold, float sigma);
 
} // namespace hmap
 
namespace hmap::gpu
{
 
Array gradient_angle_circular_smoothing(const Array &array,
                                        int          ir,
                                        bool         downward = false);
 
Array gradient_norm(const Array &array);
 
Array laplacian_fract(const Array &array, float s, int ir);
 
void phase_averaging(Array &field_real, Array &field_imag, int ir);
 
Array phase_field(const Array     &array,
                  const glm::vec2 &kw,
                  uint             seed,
                  float            kp,
                  bool             rotate90 = false,
                  int              n_kernel_samples = 8,
                  const glm::vec2 &jitter = {0.5f, 0.5f},
                  int              angle_filter_ir = 8,
                  const Array     *p_ctrl_param = nullptr,
                  const Array     *p_noise_x = nullptr,
                  const Array     *p_noise_y = nullptr,
                  Array           *p_modulus = nullptr,
                  Array           *p_angle_jump_mask = nullptr,
                  glm::vec4        bbox = {0.f, 1.f, 0.f, 1.f});
 
Array phase_field(const Array     &array,
                  uint             seed,
                  float            kp_global,
                  bool             rotate90 = false,
                  int              n_kernel_samples = 8,
                  const glm::vec2 &jitter = {0.5f, 0.5f},
                  int              angle_filter_ir = 8,
                  const Array     *p_ctrl_param = nullptr,
                  const Array     *p_noise_x = nullptr,
                  const Array     *p_noise_y = nullptr,
                  Array           *p_modulus = nullptr,
                  Array           *p_angle_jump_mask = nullptr,
                  glm::vec4        bbox = {0.f, 1.f, 0.f, 1.f});
 
Array phase_field_angle(const Array     &angle, // rads
                        const glm::vec2 &kw,
                        uint             seed,
                        float            kp,
                        int              n_kernel_samples = 8,
                        const glm::vec2 &jitter = {0.5f, 0.5f},
                        int              angle_filter_ir = 8,
                        const Array     *p_ctrl_param = nullptr,
                        const Array     *p_noise_x = nullptr,
                        const Array     *p_noise_y = nullptr,
                        Array           *p_modulus = nullptr,
                        Array           *p_angle_jump_mask = nullptr,
                        glm::vec4        bbox = {0.f, 1.f, 0.f, 1.f});
 
} // namespace hmap::gpu