boundary.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/distance_functions.hpp"
#include "highmap/math/profiles.hpp"
 
namespace hmap
{
 
// clang-format off
enum PeriodicityType : int
{
    PERIODICITY_X, 
    PERIODICITY_Y, 
    PERIODICITY_XY 
};
// clang-format on
 
// clang-format off
enum DomainBoundary : int
{
    BOUNDARY_LEFT, 
    BOUNDARY_RIGHT, 
    BOUNDARY_TOP, 
    BOUNDARY_BOTTOM 
};
// clang-format on
 
void extrapolate_borders(Array &array, int nbuffer = 1, float sigma = 0.f);
 
void falloff(Array           &array,
             float            strength = 1.f,
             DistanceFunction dist_fct = DistanceFunction::EUCLIDIAN,
             const Array     *p_noise = nullptr,
             glm::vec4        bbox = {0.f, 1.f, 0.f, 1.f});
 
void fill_borders(Array &array);
 
void fill_borders(Array &array, int nbuffer); 
 
Array generate_buffered_array(const Array &array,
                              glm::ivec4   buffers,
                              bool         zero_padding = false);
 
void make_periodic(
    Array                 &array,
    int                    nbuffer,
    const PeriodicityType &periodicity_type = PeriodicityType::PERIODICITY_XY);
 
Array make_periodic_stitching(const Array &array, float overlap);
 
Array make_periodic_tiling(const Array &array,
                           float        overlap,
                           glm::ivec2   tiling);
 
glm::ivec2 pick_boundary_cell(const Array   &z,
                              DomainBoundary boundary,
                              std::uint32_t  seed,
                              bool           favor_boundary_center = true,
                              bool           favor_lower_elevation = true,
                              bool           favor_sinks = true);
 
void set_borders(Array     &array,
                 glm::vec4  border_values,
                 glm::ivec4 buffer_sizes);
 
void set_borders(Array &array, float border_values, int buffer_sizes);
 
void sym_borders(Array &array, glm::ivec4 buffer_sizes);
 
void zeroed_borders(Array &array);
 
void zeroed_edges(Array        &array,
                  RadialProfile radial_profile = RadialProfile::RP_SMOOTHSTEP,
                  float         profile_param = 0.f,
                  float         amount = 1.f,
                  DistanceFunction     distance = DistanceFunction::EUCLIDIAN,
                  DistanceFunctionAxis dfa = DistanceFunctionAxis::DFA_XY,
                  glm::vec2            center = {0.5f, 0.5f},
                  float                radius = 0.5f,
                  const Array         *p_noise_r = nullptr,
                  glm::vec4            bbox = {0.f, 1.f, 0.f, 1.f});
 
} // namespace hmap