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/math.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 detrend_reg(const Array &array);
 
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> random_vector(float min, float max, int num, int seed);
 
void fill_array_using_xy_function(
    Array                                    &array,
    Vec4<float>                               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,
    Vec4<float>                               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(hmap::Vec2<int> shape, std::vector<int> cut_path_i, int ir);
 
Array get_random_patch(const Array          &array,
                       hmap::Vec2<int>       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);
 
Array vstack(const Array &array1, const Array &array2);
 
} // namespace hmap