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);
 
Array phase_field(const Array &array,
                  float        kw,
                  int          width,
                  uint         seed,
                  float        noise_amp = 0.f,
                  int          prefilter_ir = -1,
                  float        density_factor = 1.f,
                  bool         rotate90 = false,
                  Array       *p_gnoise_x = nullptr,
                  Array       *p_gnoise_y = nullptr);
 
void solve_poisson_gauss_seidel(const Array &rhs,
                                Array       &h,
                                int          iterations = 500,
                                float        omega = 1.0f);
 
Array unwrap_phase(const Array &alpha);
 
} // namespace hmap
 
namespace hmap::gpu
{
 
Array gradient_norm(const Array &array);
 
} // namespace hmap::gpu