cloud.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 <cmath>
#include <optional>
 
#include "highmap/array.hpp"
#include "highmap/geometry/point.hpp"
#include "highmap/geometry/point_sampling.hpp"
#include "highmap/interpolate/interpolate2d.hpp"
 
namespace hmap
{
 
class Graph;
 
class Cloud
{
public:
  std::vector<Point> points = {}; 
 
  // ==========================================================================
  //  Constructors
  // ==========================================================================
 
  Cloud(){};
 
  virtual ~Cloud() = default;
 
  Cloud(int npoints, std::uint32_t seed, glm::vec4 bbox = {0.f, 1.f, 0.f, 1.f});
 
  Cloud(const std::vector<Point> &points) : points(points){};
 
  Cloud(const std::vector<float> &x,
        const std::vector<float> &y,
        float                     default_value = 0.f);
 
  Cloud(const std::vector<float> &x,
        const std::vector<float> &y,
        const std::vector<float> &v);
 
  Cloud(const std::vector<glm::ivec2> &indices,
        const glm::ivec2              &shape,
        const glm::vec4               &bbox = {0.f, 1.f, 0.f, 1.f});
 
  Cloud(const std::vector<glm::vec3> &xyv);
 
  void add_point(const Point &p);
 
  void remove_point(int point_idx);
 
  // ==========================================================================
  //  Accessors
  // ==========================================================================
 
  glm::vec4 get_bbox() const;
 
  Point get_center() const;
 
  std::vector<int> get_convex_hull() const;
 
  std::vector<float> get_values() const;
 
  float get_values_max() const;
 
  float get_values_min() const;
 
  std::vector<float> get_x() const;
 
  std::vector<float> get_xy() const;
 
  std::vector<float> get_y() const;
 
  size_t nearest_point(const glm::vec2 &xy) const;
 
  void set_points(const std::vector<float> &x, const std::vector<float> &y);
 
  void set_values(const std::vector<float> &new_values);
 
  void set_values(float new_value);
 
  void set_values_from_array(const Array     &array,
                             const glm::vec4 &bbox = {0.f, 1.f, 0.f, 1.f});
 
  void set_values_from_border_distance(
      const glm::vec4 &bbox = {0.f, 1.f, 0.f, 1.f});
 
  void set_values_from_chull_distance();
 
  void set_values_from_min_distance();
 
  bool empty() const;
 
  size_t size() const;
 
  // ==========================================================================
  //  Basic Ops
  // ==========================================================================
 
  void clear();
 
  void print();
 
  void randomize(std::uint32_t seed, glm::vec4 bbox = {0.f, 1.f, 0.f, 1.f});
 
  void remap_values(float vmin, float vmax);
 
  void shuffle(float dx, float dy, std::uint32_t seed, float dv = 0.f);
 
  void snap_points_to_bounding_box(const glm::vec4 &bbox = {0.f, 1.f, 0.f, 1.f},
                                   float            tolerance_ratio = 1.f);
 
  // ==========================================================================
  //  Conversion / IO
  // ==========================================================================
 
  bool from_csv(const std::string &fname);
 
  void to_array(Array &array, glm::vec4 bbox = {0.f, 1.f, 0.f, 1.f}) const;
 
  Array to_array(glm::ivec2 shape, glm::vec4 bbox) const;
 
  void to_array_interp(Array                &array,
                       glm::vec4             bbox = {0.f, 1.f, 0.f, 1.f},
                       InterpolationMethod2D interpolation_method =
                           InterpolationMethod2D::ITP2D_DELAUNAY,
                       Array    *p_noise_x = nullptr,
                       Array    *p_noise_y = nullptr,
                       glm::vec4 bbox_array = {0.f, 1.f, 0.f, 1.f}) const;
 
  void to_csv(const std::string &fname) const;
 
  Graph to_graph_delaunay();
 
  void to_png(const std::string &fname,
              int                cmap,
              glm::vec4          bbox = {0.f, 1.f, 0.f, 1.f},
              int                depth = CV_8U,
              glm::ivec2         shape = {512, 512});
 
  std::vector<glm::vec3> to_vec3() const;
};
 
// ==========================================================================
//  Functions
// ==========================================================================
 
Array cloud_sdf_to_array(const Cloud &cloud,
                         glm::ivec2   shape,
                         glm::vec4    bbox_array = {0.f, 1.f, 0.f, 1.f},
                         const Array *p_noise_x = nullptr,
                         const Array *p_noise_y = nullptr);
 
bool has_duplicates(const Cloud &cloud, float eps = 1e-9f, bool xy_only = true);
 
std::vector<float> interpolate_values_from_array(const Cloud &cloud,
                                                 const Array &array,
                                                 glm::vec4    bbox);
 
Cloud merge_cloud(const Cloud &cloud1, const Cloud &cloud2);
 
Cloud merge_clouds(const std::vector<Cloud> &clouds);
 
Cloud random_cloud(
    size_t                     count,
    std::uint32_t              seed,
    const PointSamplingMethod &method = PointSamplingMethod::RND_LHS,
    const glm::vec4           &bbox = {0.f, 1.f, 0.f, 1.f});
 
Cloud random_cloud_density(size_t           count,
                           const Array     &density,
                           std::uint32_t    seed,
                           const glm::vec4 &bbox = {0.f, 1.f, 0.f, 1.f});
 
Cloud random_cloud_distance(float            min_dist,
                            std::uint32_t    seed,
                            const glm::vec4 &bbox = {0.f, 1.f, 0.f, 1.f});
 
Cloud random_cloud_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});
 
Cloud random_cloud_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});
 
Cloud random_cloud_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});
 
Cloud random_cloud_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 rejection_filter_density(Cloud           &cloud,
                              const Array     &density_mask,
                              std::uint32_t    seed,
                              const glm::vec4 &bbox = {0.f, 1.f, 0.f, 1.f});
 
Cloud scale(const Cloud &cloud,
            glm::vec2    scale,
            glm::vec2    center = {0.5f, 0.5f});
 
Cloud scale(const Cloud &cloud, float scale, glm::vec2 center = {0.5f, 0.5f});
 
} // namespace hmap