authoring.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/geometry/path.hpp"
 
namespace hmap
{
 
class Cloud; // from highmap/geometry.hpp
 
enum StampingBlendMethod : int
{
  ADD,            
  MAXIMUM,        
  MAXIMUM_SMOOTH, 
  MINIMUM,        
  MINIMUM_SMOOTH, 
  MULTIPLY,       
  SUBSTRACT,      
};
 
void alter_elevation(Array       &array,
                     const Cloud &cloud,
                     int          ir,
                     float        footprint_ratio = 1.f,
                     glm::vec2    shift = {0.f, 0.f},
                     glm::vec2    scale = {1.f, 1.f});
 
Array base_elevation(glm::ivec2                             shape,
                     const std::vector<std::vector<float>> &values,
                     float                                  width_factor = 1.f,
                     const Array                           *p_noise_x = nullptr,
                     const Array                           *p_noise_y = nullptr,
                     const Array *p_stretching = nullptr,
                     glm::vec4    bbox = {0.f, 1.f, 0.f, 1.f});
 
Array elevation_from_sparse_constraints(const Array &mountains,
                                        const Array *p_coastline = nullptr,
                                        const Array *p_boundary = nullptr,
                                        float        mountain_elevation = 1.0f,
                                        float        coastline_elevation = 0.0f,
                                        float        boundary_elevation = -1.0f,
                                        int          iterations_max = 500,
                                        float        tolerance = 1e-5f,
                                        const Array *p_noise = nullptr,
                                        float        noise_amplitude = 0.0f);
 
Array reverse_midpoint(const Array  &array,
                       std::uint32_t seed,
                       float         noise_scale = 1.f,
                       float         threshold = 0.f);
 
Array ridgelines(glm::ivec2                shape,
                 const std::vector<float> &xr,
                 const std::vector<float> &yr,
                 const std::vector<float> &zr,
                 float                     slope,
                 float                     k_smoothing = 1.f,
                 float                     width = 0.1f,
                 float                     vmin = 0.f,
                 glm::vec4                 bbox = {0.f, 1.f, 0.f, 1.f},
                 const Array              *p_noise_x = nullptr,
                 const Array              *p_noise_y = nullptr,
                 const Array              *p_stretching = nullptr,
                 glm::vec4                 bbox_array = {0.f, 1.f, 0.f, 1.f});
 
Array ridgelines_bezier(glm::ivec2                shape,
                        const std::vector<float> &xr,
                        const std::vector<float> &yr,
                        const std::vector<float> &zr,
                        float                     slope,
                        float                     k_smoothing = 1.f,
                        float                     width = 0.1f,
                        float                     vmin = 0.f,
                        glm::vec4                 bbox = {0.f, 1.f, 0.f, 1.f},
                        const Array              *p_noise_x = nullptr,
                        const Array              *p_noise_y = nullptr,
                        const Array              *p_stretching = nullptr,
                        glm::vec4 bbox_array = {0.f, 1.f, 0.f, 1.f});
 
Array stamping(glm::ivec2                shape,
               const std::vector<float> &xr,
               const std::vector<float> &yr,
               const std::vector<float> &zr,
               Array                     kernel,
               int                       kernel_ir,
               bool                      kernel_scale_radius,
               bool                      kernel_scale_amplitude,
               StampingBlendMethod       blend_method,
               std::uint32_t             seed,
               float                     k_smoothing = 0.1f,
               bool                      kernel_flip = true,
               bool                      kernel_rotate = false,
               glm::vec4                 bbox_array = {0.f, 1.f, 0.f, 1.f});
 
} // namespace hmap