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 <array>
#include <cstddef>
#include <functional>
#include <map>
#include <string>
#include <utility>
#include <vector>
 
#include "point_sampler.hpp"
#include "point_sampler/point.hpp"
 
#include "highmap/array.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 glm::vec4 &bbox);
 
void expand_points_domain(std::vector<float> &x,
                          std::vector<float> &y,
                          std::vector<float> &value,
                          glm::vec4           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,
                                        glm::vec4 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,
                                  glm::vec4 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 glm::vec4 &bbox);
 
std::array<std::vector<float>, 2> random_points(
    size_t                     count,
    std::uint32_t              seed,
    const PointSamplingMethod &method = PointSamplingMethod::RND_RANDOM,
    const glm::vec4           &bbox = {0.f, 1.f, 0.f, 1.f});
 
std::array<std::vector<float>, 2> random_points_density(
    size_t           count,
    const Array     &density,
    std::uint32_t    seed,
    const glm::vec4 &bbox = {0.f, 1.f, 0.f, 1.f});
 
std::array<std::vector<float>, 2> random_points_distance(
    float            min_dist,
    std::uint32_t    seed,
    const glm::vec4 &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,
    std::uint32_t    seed,
    const glm::vec4 &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,
    std::uint32_t    seed,
    const glm::vec4 &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,
    std::uint32_t    seed,
    const glm::vec4 &bbox = {0.f, 1.f, 0.f, 1.f});
 
std::array<std::vector<float>, 2> random_points_jittered(
    size_t           count,
    const glm::vec2 &jitter_amount,
    const glm::vec2 &stagger_ratio,
    std::uint32_t    seed,
    const glm::vec4 &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,
                                glm::vec4 bbox = {0.f, 1.f, 0.f, 1.f});
 
void rescale_points_to_unit_square(std::vector<float> &x,
                                   std::vector<float> &y,
                                   glm::vec4           bbox);
 
} // namespace hmap