operator.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/internal/validation.hpp"
#include "highmap/math/array.hpp"
 
namespace hmap
{
 
void add_kernel(Array &array, const Array &kernel, int i, int j);
 
void add_kernel_maximum_smooth(Array       &array,
                               const Array &kernel,
                               float        k_smooth,
                               int          i,
                               int          j);
 
Array compare(const Array &a,
              const Array &b,
              float        slice_x_pos,
              float        slice_y_pos);
 
Array hstack(const Array &array1, const Array &array2);
 
Array inpainting_diffusion(const Array &array,
                           const Array &mask,
                           int          iterations);
 
std::vector<float> linspace(float start,
                            float stop,
                            int   num,
                            bool  endpoint = true);
 
std::vector<float> linspace_jitted(float start,
                                   float stop,
                                   int   num,
                                   float ratio,
                                   int   seed,
                                   bool  endpoint = true);
 
std::vector<float> logspace(float start,
                            float stop,
                            int   num,
                            bool  endpoint = true);
 
void fill_array_using_xy_function(
    Array                                    &array,
    glm::vec4                                 bbox,
    const Array                              *p_ctrl_param,
    const Array                              *p_noise_x,
    const Array                              *p_noise_y,
    const Array                              *p_stretching,
    std::function<float(float, float, float)> fct_xy);
 
void fill_array_using_xy_function(
    Array                                    &array,
    glm::vec4                                 bbox,
    const Array                              *p_ctrl_param,
    const Array                              *p_noise_x,
    const Array                              *p_noise_y,
    const Array                              *p_stretching,
    std::function<float(float, float, float)> fct_xy,
    int                                       subsampling); 
 
void find_vertical_cut_path(const Array &error, std::vector<int> &path_i);
 
Array generate_mask(glm::ivec2 shape, std::vector<int> cut_path_i, int ir);
 
Array get_random_patch(const Array          &array,
                       glm::ivec2            patch_shape,
                       std::mt19937         &gen,
                       bool                  patch_flip = false,
                       bool                  patch_rotate = false,
                       bool                  patch_transpose = false,
                       std::vector<Array *> *p_secondary_arrays = nullptr,
                       std::vector<Array>   *p_secondary_patches = nullptr);
 
std::vector<float> random_vector(float min, float max, int num, int seed);
 
void rescale_vector(std::vector<float> &vec, float vmin, float vmax);
 
std::vector<float> rescaled_vector(const std::vector<float> &vec,
                                   float                     vmin,
                                   float vmax); 
 
void swap(Array &a, Array &b);
 
Array vstack(const Array &array1, const Array &array2);
 
// === HELPERS
 
template <typename Fn>
void apply_with_mask(Array &array, const Array *p_mask, Fn &&fn)
{
  if (!validate_non_empty(array)) return;
  if (p_mask && !validate_same_shape(array, *p_mask)) return;
 
  if (!p_mask)
  {
    fn(array);
  }
  else
  {
    Array result = array;
    fn(result);
    array = lerp(array, result, *p_mask);
  }
}
 
template <typename Fn>
Array transform_with_mask(const Array &array, const Array *p_mask, Fn &&fn)
{
  if (!validate_non_empty(array)) return Array();
  if (p_mask && !validate_same_shape(array, *p_mask)) return Array(array.shape);
 
  Array result = fn(array);
 
  if (p_mask)
    return lerp(array, result, *p_mask);
  else
    return result;
}
 
} // namespace hmap