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"
#include "highmap/interpolate/interpolate1d.hpp"
 
namespace hmap
{
 
class Path : public Cloud
{
public:
  enum class EdgeDivisionMode : int
  {
    EDM_PER_EDGE,
    EDM_FULL_ARC,
  };
 
  // ==========================================================================
  //  Constructors
  // ==========================================================================
 
  Path() = default;
 
  Path(int npoints, std::uint32_t seed, glm::vec4 bbox = {0.f, 1.f, 0.f, 1.f})
      : Cloud(npoints, seed, bbox){};
 
  Path(std::vector<Point> points) : Cloud(points){};
 
  Path(std::vector<float> x, std::vector<float> y) : Cloud(x, y){};
 
  Path(std::vector<float> x, std::vector<float> y, std::vector<float> v)
      : Cloud(x, y, v){};
 
  Path(const std::vector<glm::ivec2> &indices,
       const glm::ivec2              &shape,
       const glm::vec4               &bbox = {0.f, 1.f, 0.f, 1.f})
      : Cloud(indices, shape, bbox){};
 
  Path(const std::vector<glm::vec3> &xyv) : Cloud(xyv){};
 
  // ==========================================================================
  //  Accessors
  // ==========================================================================
 
  std::vector<float> get_arc_length() const;
 
  std::vector<float> get_cumulative_distance() const;
 
  std::vector<float> get_curvature(bool normalized = false) const;
 
  std::vector<Point> get_edge_centers() const;
 
  std::vector<glm::vec2> get_normals() const;
 
  std::vector<glm::vec2> get_tangents() const;
 
  std::vector<float> get_values() const;
 
  std::vector<float> get_x() const;
 
  std::vector<float> get_xy() const;
 
  std::vector<float> get_y() const;
 
  bool is_closed() const;
 
  void set_closed(bool new_value);
 
  // ==========================================================================
  //  Basic Ops
  // ==========================================================================
 
  void clear();
 
  void enforce_monotonic_values(bool decreasing = true);
 
  void reorder_nns(int start_index = 0);
 
  void reverse();
 
  // ==========================================================================
  //  Sampling
  // ==========================================================================
 
  void divide();
 
  void resample_by_spacing(
      float                 delta,
      InterpolationMethod1D itp_method = InterpolationMethod1D::LINEAR);
 
  void resample_interp(
      int                   npoints,
      InterpolationMethod1D itp_method = InterpolationMethod1D::CUBIC);
 
  void resample_uniform(
      InterpolationMethod1D itp_method = InterpolationMethod1D::LINEAR);
 
  glm::vec3 sample_at(float                     t,
                      const std::vector<float> *p_arc = nullptr,
                      glm::vec2                *p_tangent = nullptr) const;
 
  void subsample(int step);
 
  // ==========================================================================
  //  Conversion / IO
  // ==========================================================================
 
  void to_array(Array    &array,
                glm::vec4 bbox = {0.f, 1.f, 0.f, 1.f},
                bool      filled = false) const;
 
  Array to_array(glm::ivec2 shape,
                 glm::vec4  bbox = {0.f, 1.f, 0.f, 1.f},
                 bool       filled = false) const;
 
  void to_array_mask(Array    &array,
                     glm::vec4 bbox = {0.f, 1.f, 0.f, 1.f},
                     bool      filled = false) const;
 
  void to_png(std::string fname, glm::ivec2 shape = {512, 512});
 
private:
  enum class PathClosure : int
  {
    PT_OPEN,
    PT_CLOSE,
  } path_closure = PathClosure::PT_OPEN;
};
 
// ==========================================================================
//  Functions
// ==========================================================================
 
Path bezier(const Path            &path,
            float                  curvature_ratio = 0.3f,
            int                    edge_divisions = 10,
            Path::EdgeDivisionMode edm = Path::EdgeDivisionMode::EDM_PER_EDGE);
 
Path bezier_round(
    const Path            &path,
    float                  curvature_ratio = 0.3f,
    int                    edge_divisions = 10,
    Path::EdgeDivisionMode edm = Path::EdgeDivisionMode::EDM_PER_EDGE);
 
Path bspline(const Path            &path,
             int                    edge_divisions = 10,
             Path::EdgeDivisionMode edm = Path::EdgeDivisionMode::EDM_PER_EDGE);
 
Path catmullrom(
    const Path            &path,
    int                    edge_divisions = 10,
    Path::EdgeDivisionMode edm = Path::EdgeDivisionMode::EDM_PER_EDGE);
 
Path decasteljau(
    const Path            &path,
    int                    edge_divisions = 10,
    Path::EdgeDivisionMode edm = Path::EdgeDivisionMode::EDM_PER_EDGE);
 
Path decimate_vw(const Path &path, int n_points_target = 3);
 
Path fractalize(const Path   &path,
                int           iterations,
                std::uint32_t seed,
                float         sigma = 0.2f,
                int           orientation = 0,
                float         persistence = 1.f,
                Array        *p_control_field = nullptr,
                glm::vec4     bbox = {0.f, 1.f, 0.f, 1.f},
                bool          bounded = false);
 
Path inflate(const Path &path, float strength, bool resample = true);
 
Path meanderize(
    const Path            &path,
    float                  ratio,
    float                  noise_ratio = 0.1f,
    std::uint32_t          seed = 1,
    int                    iterations = 1,
    int                    edge_divisions = 10,
    Path::EdgeDivisionMode edm = Path::EdgeDivisionMode::EDM_PER_EDGE);
 
Array path_sdf_to_array(const Path  &path,
                        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);
 
Path remove_geometric_loops(const Path &path);
 
Path scale(const Path &path, glm::vec2 scale, glm::vec2 center = {0.5f, 0.5f});
 
Path scale(const Path &path, float scale, glm::vec2 center = {0.5f, 0.5f});
 
Path smooth(const Path &path,
            int         navg = 1,
            float       averaging_intensity = 1.f,
            float       inertia = 0.f);
 
Path squiggle(const Path   &path,
              int           iterations = 4,
              std::uint32_t seed = 0,
              float         height_ratio = 0.5f,
              int           orientation = 0,
              const Array  *p_weights = nullptr,
              const Array  *p_mask = nullptr,
              glm::vec4     bbox = {0.f, 1.f, 0.f, 1.f});
 
std::vector<Path> squiggle_branches(const Path   &path,
                                    int           iterations = 4,
                                    std::uint32_t seed = 0,
                                    float         branch_probability = 0.3f,
                                    int           max_branches = 8,
                                    float         height_ratio = 0.5f,
                                    int           orientation = 0,
                                    const Array  *p_weights = nullptr,
                                    const Array  *p_mask = nullptr,
                                    glm::vec4     bbox = {0.f, 1.f, 0.f, 1.f});
 
// ==========================================================================
//  Verification Functions
// ==========================================================================
 
bool assert_start_end_points(const Path &path1,
                             const Path &path2,
                             float       tol = 1e-6f,
                             bool        verbose = false);
 
float chamfer_distance(const Path &a, const Path &b);
 
bool has_duplicates(const Path &path, float tol = 1e-6f);
 
} // namespace hmap