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 "highmap/array.hpp"
#include "highmap/geometry/point.hpp"
#include "highmap/geometry/point_sampling.hpp"
#include "highmap/interpolate2d.hpp"
 
namespace hmap
{
 
class Graph;
 
class Cloud
{
public:
  std::vector<Point> points = {}; 
 
  Cloud(){};
 
  virtual ~Cloud() = default;
 
  Cloud(int npoints, uint 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);
 
  void add_point(const Point &p);
 
  void clear();
 
  bool from_csv(const std::string &fname);
 
  glm::vec4 get_bbox() const;
 
  Point get_center() const;
 
  std::vector<int> get_convex_hull_point_indices() const;
 
  size_t get_npoints() const;
 
  std::vector<float> get_values() const;
 
  float get_values_max() const;
 
  float get_values_min() const;
 
  virtual std::vector<float> get_x() const;
 
  virtual std::vector<float> get_xy() const;
 
  virtual std::vector<float> get_y() const;
 
  std::vector<float> interpolate_values_from_array(const Array &array,
                                                   glm::vec4    bbox);
 
  void print();
 
  void randomize(uint seed, glm::vec4 bbox = {0.f, 1.f, 0.f, 1.f});
 
  void rejection_filter_density(const Array     &density_mask,
                                uint             seed,
                                const glm::vec4 &bbox = {0.f, 1.f, 0.f, 1.f});
 
  void remap_values(float vmin, float vmax);
 
  void remove_point(int point_idx);
 
  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();
 
  void shuffle(float dx, float dy, uint seed, float dv = 0.f);
 
  void to_array(Array &array, glm::vec4 bbox = {0.f, 1.f, 0.f, 1.f}) const;
 
  Array to_array_sdf(glm::ivec2 shape,
                     glm::vec4  bbox,
                     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_array_interp(Array                &array,
                       glm::vec4             bbox = {0.f, 1.f, 0.f, 1.f},
                       InterpolationMethod2D interpolation_method =
                           InterpolationMethod2D::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});
};
 
Cloud merge_cloud(const Cloud &cloud1, const Cloud &cloud2);
Cloud merge_clouds(const std::vector<Cloud> &clouds);
 
Cloud random_cloud(
    size_t                     count,
    uint                       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,
                           uint             seed,
                           const glm::vec4 &bbox = {0.f, 1.f, 0.f, 1.f});
 
Cloud random_cloud_distance(float            min_dist,
                            uint             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,
                            uint             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,
    uint             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,
    uint             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,
                            uint             seed,
                            const glm::vec4 &bbox = {0.f, 1.f, 0.f, 1.f});
 
} // namespace hmap