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/boundary.hpp"
#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,
       glm::vec4 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,
                glm::vec4 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,
                  glm::vec4 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,
                glm::vec4 bbox = {0.f, 1.f, 0.f, 1.f},
                bool      filled = false) 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});
 
  void to_png(std::string fname, glm::ivec2 shape = {512, 512});
};
 
void dig_path(Array    &z,
              Path     &path,
              int       width = 1,
              int       decay = 2,
              int       flattening_radius = 16,
              bool      force_downhill = false,
              glm::vec4 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);
 
Path find_cut_path_dijkstra(const Array   &z,
                            DomainBoundary start,
                            DomainBoundary end,
                            float          dijk_elevation_ratio = 0.9f,
                            float          dijk_distance_exponent = 2.f,
                            float          dijk_upward_penalization = 100.f);
 
Path find_cut_path_midpoint(const Array   &z,
                            DomainBoundary start,
                            DomainBoundary end,
                            uint           seed,
                            int            midp_iterations = 4,
                            float          midp_sigma = 0.2f);
 
} // namespace hmap