point_sampling.hpp

Go to the documentation of this file.

/* Copyright (c) 2025 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 <functional>
 
#include "point_sampler.hpp"
 
#include "highmap/functions.hpp"
#include "highmap/geometry/point.hpp"
 
namespace hmap
{
 
enum PointSamplingMethod : int
{
  RND_RANDOM,     
  RND_HALTON,     
  RND_HAMMERSLEY, 
  RND_LHS,        
};
 
static std::map<std::string, int> point_sampling_method_as_string = {
    {"Random", PointSamplingMethod::RND_RANDOM},
    {"Halton sequence", PointSamplingMethod::RND_HALTON},
    {"Hammersley sequence", PointSamplingMethod::RND_HAMMERSLEY},
    {"Latin Hypercube Sampling", PointSamplingMethod::RND_LHS},
};
 
std::array<std::pair<float, float>, 2> bbox_to_ranges2d(
    const Vec4<float> &bbox);
 
void expand_points_domain(std::vector<float> &x,
                          std::vector<float> &y,
                          std::vector<float> &value,
                          Vec4<float>         bbox = {0.f, 1.f, 0.f, 1.f});
 
void expand_points_at_domain_boundaries(std::vector<float> &x,
                                        std::vector<float> &y,
                                        std::vector<float> &value,
                                        Vec4<float> bbox = {0.f, 1.f, 0.f, 1.f},
                                        float       boundary_value = 0.f);
 
void expand_points_domain_corners(std::vector<float> &x,
                                  std::vector<float> &y,
                                  std::vector<float> &value,
                                  Vec4<float> bbox = {0.f, 1.f, 0.f, 1.f},
                                  float       corner_value = 0.f);
 
std::function<float(const ps::Point<float, 2> &)>
make_pointwise_function_from_array(const Array &array, const Vec4<float> &bbox);
 
std::array<std::vector<float>, 2> random_points(
    size_t                     count,
    uint                       seed,
    const PointSamplingMethod &method = PointSamplingMethod::RND_RANDOM,
    const Vec4<float>         &bbox = {0.f, 1.f, 0.f, 1.f});
 
std::array<std::vector<float>, 2> random_points_density(
    size_t             count,
    const Array       &density,
    uint               seed,
    const Vec4<float> &bbox = {0.f, 1.f, 0.f, 1.f});
 
std::array<std::vector<float>, 2> random_points_distance(
    float              min_dist,
    uint               seed,
    const Vec4<float> &bbox = {0.f, 1.f, 0.f, 1.f});
 
std::array<std::vector<float>, 2> random_points_distance(
    float              min_dist,
    float              max_dist,
    const Array       &density,
    uint               seed,
    const Vec4<float> &bbox = {0.f, 1.f, 0.f, 1.f});
 
std::array<std::vector<float>, 2> random_points_distance_power_law(
    float              dist_min,
    float              dist_max,
    float              alpha,
    uint               seed,
    const Vec4<float> &bbox = {0.f, 1.f, 0.f, 1.f});
 
std::array<std::vector<float>, 2> random_points_distance_weibull(
    float              dist_min,
    float              lambda,
    float              k,
    uint               seed,
    const Vec4<float> &bbox = {0.f, 1.f, 0.f, 1.f});
 
std::array<std::vector<float>, 2> random_points_jittered(
    size_t                   count,
    const hmap::Vec2<float> &jitter_amount,
    const hmap::Vec2<float> &stagger_ratio,
    uint                     seed,
    const Vec4<float>       &bbox = {0.f, 1.f, 0.f, 1.f});
 
void remove_points_outside_bbox(std::vector<float> &x,
                                std::vector<float> &y,
                                std::vector<float> &value,
                                Vec4<float> bbox = {0.f, 1.f, 0.f, 1.f});
 
void rescale_points_to_unit_square(std::vector<float> &x,
                                   std::vector<float> &y,
                                   Vec4<float>         bbox);
 
} // namespace hmap