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, Vec4<float> 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);
 
  Vec4<float> 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,
                                                   Vec4<float>  bbox);
 
  void print();
 
  void randomize(uint seed, Vec4<float> bbox = {0.f, 1.f, 0.f, 1.f});
 
  void rejection_filter_density(const Array       &density_mask,
                                uint               seed,
                                const Vec4<float> &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 Vec4<float> &bbox = {0.f, 1.f, 0.f, 1.f});
 
  void set_values_from_border_distance(
      const Vec4<float> &bbox = {0.f, 1.f, 0.f, 1.f});
 
  void set_values_from_chull_distance();
 
  void set_values_from_min_distance();
 
  void to_array(Array &array, Vec4<float> bbox = {0.f, 1.f, 0.f, 1.f}) const;
 
  Array to_array_sdf(Vec2<int>   shape,
                     Vec4<float> bbox,
                     Array      *p_noise_x = nullptr,
                     Array      *p_noise_y = nullptr,
                     Vec4<float> bbox_array = {0.f, 1.f, 0.f, 1.f}) const;
 
  void to_array_interp(Array                &array,
                       Vec4<float>           bbox = {0.f, 1.f, 0.f, 1.f},
                       InterpolationMethod2D interpolation_method =
                           InterpolationMethod2D::DELAUNAY,
                       Array      *p_noise_x = nullptr,
                       Array      *p_noise_y = nullptr,
                       Vec4<float> 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,
              Vec4<float>        bbox = {0.f, 1.f, 0.f, 1.f},
              int                depth = CV_8U,
              Vec2<int>          shape = {512, 512});
};
 
Cloud merge_cloud(const Cloud &cloud1, const Cloud &cloud2);
 
Cloud random_cloud(
    size_t                     count,
    uint                       seed,
    const PointSamplingMethod &method = PointSamplingMethod::RND_LHS,
    const Vec4<float>         &bbox = {0.f, 1.f, 0.f, 1.f});
 
Cloud random_cloud_density(size_t             count,
                           const Array       &density,
                           uint               seed,
                           const Vec4<float> &bbox = {0.f, 1.f, 0.f, 1.f});
 
Cloud random_cloud_distance(float              min_dist,
                            uint               seed,
                            const Vec4<float> &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 Vec4<float> &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 Vec4<float> &bbox = {0.f, 1.f, 0.f, 1.f});
 
Cloud random_cloud_distance_weibull(
    float              dist_min,
    float              lambda,
    float              k,
    uint               seed,
    const Vec4<float> &bbox = {0.f, 1.f, 0.f, 1.f});
 
Cloud random_cloud_jittered(size_t             count,
                            const Vec2<float> &jitter_amount,
                            const Vec2<float> &stagger_ratio,
                            uint               seed,
                            const Vec4<float> &bbox = {0.f, 1.f, 0.f, 1.f});
 
} // namespace hmap