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/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, uint 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);
 
  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,
                uint        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});
 
Path inflate(const Path &path, float strength, bool resample = true);
 
Path meanderize(
    const Path            &path,
    float                  ratio,
    float                  noise_ratio = 0.1f,
    uint                   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 smooth(const Path &path,
            int         navg = 1,
            float       averaging_intensity = 1.f,
            float       inertia = 0.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