path.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 "highmap/geometry/cloud.hpp"
 
namespace hmap
{
 
class Path : public Cloud
{
public:
  bool closed;
 
  Path(bool closed = false) : Cloud(), closed(closed){};
 
  Path(int         npoints,
       uint        seed,
       Vec4<float> bbox = {0.f, 1.f, 0.f, 1.f},
       bool        closed = false)
      : Cloud(npoints, seed, bbox), closed(closed){};
 
  Path(std::vector<Point> points, bool closed = false)
      : Cloud(points), closed(closed){};
 
  Path(std::vector<float> x, std::vector<float> y, bool closed = false)
      : Cloud(x, y), closed(closed){};
 
  Path(std::vector<float> x,
       std::vector<float> y,
       std::vector<float> v,
       bool               closed = false)
      : Cloud(x, y, v), closed(closed){};
 
  void bezier(float curvature_ratio = 0.3f, int edge_divisions = 10);
 
  void bezier_round(float curvature_ratio = 0.3f, int edge_divisions = 10);
 
  void bspline(int edge_divisions = 10);
 
  void catmullrom(int edge_divisions = 10);
 
  void clear();
 
  void decasteljau(int edge_divisions = 10);
 
  void decimate_cfit(int n_points_target = 3);
 
  void decimate_vw(int n_points_target = 3);
 
  void dijkstra(Array      &array,
                Vec4<float> bbox,
                float       elevation_ratio = 0.f,
                float       distance_exponent = 0.5f,
                float       upward_penalization = 1.f,
                Array      *p_mask_nogo = nullptr);
 
  void divide();
 
  void fractalize(int         iterations,
                  uint        seed,
                  float       sigma = 0.3f,
                  int         orientation = 0,
                  float       persistence = 1.f,
                  Array      *p_control_field = nullptr,
                  Vec4<float> bbox = {0.f, 1.f, 0.f, 1.f});
 
  std::vector<float> get_arc_length();
 
  std::vector<float> get_cumulative_distance();
 
  std::vector<float> get_values() const;
 
  std::vector<float> get_x() const;
 
  std::vector<float> get_xy() const;
 
  std::vector<float> get_y() const;
 
  void enforce_monotonic_values(bool decreasing = true);
 
  void meanderize(float ratio,
                  float noise_ratio = 0.1f,
                  uint  seed = 1,
                  int   iterations = 1,
                  int   edge_divisions = 10);
 
  void reorder_nns(int start_index = 0);
 
  void resample(float delta);
 
  void resample_uniform();
 
  void reverse();
 
  float sdf_angle_closed(float x, float y);
 
  float sdf_angle_open(float x, float y);
 
  float sdf_closed(float x, float y);
 
  float sdf_elevation_closed(float x, float y, float slope);
 
  float sdf_elevation_open(float x, float y, float slope);
 
  float sdf_open(float x, float y);
 
  void smooth(int   navg = 1,
              float averaging_intensity = 1.f,
              float inertia = 0.f);
 
  void subsample(int step);
 
  void to_array(Array &array, Vec4<float> bbox, bool filled = false) 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});
 
  void to_png(std::string fname, Vec2<int> shape = {512, 512});
};
 
void dig_path(Array      &z,
              Path       &path,
              int         width = 1,
              int         decay = 2,
              int         flattening_radius = 16,
              bool        force_downhill = false,
              Vec4<float> bbox = {0.f, 1.f, 0.f, 1.f},
              float       depth = 0.f);
 
void dig_river(Array                   &z,
               const std::vector<Path> &path_list,
               float                    riverbank_talus,
               int                      river_width = 0,
               int                      merging_width = 0,
               float                    depth = 0.f,
               float                    riverbed_talus = 0.f,
               float                    noise_ratio = 0.9f,
               uint                     seed = 0,
               Array                   *p_mask = nullptr);
 
void dig_river(Array      &z,
               const Path &path,
               float       riverbank_talus,
               int         river_width = 0,
               int         merging_width = 0,
               float       depth = 0.f,
               float       riverbed_talus = 0.f,
               float       noise_ratio = 0.9f,
               uint        seed = 0,
               Array      *p_mask = nullptr);
 
} // namespace hmap