point.hpp

Go to the documentation of this file.

/* Copyright (c) 2025 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 <optional>
 
#include "highmap/array.hpp"
 
namespace hmap
{
 
class Point
{
public:
  float x; 
  float y; 
  float v; 
 
  Point() : x(0.f), y(0.f), v(0.f)
  {
  }
 
  Point(float x, float y, float v = 0.f) : x(x), y(y), v(v)
  {
  }
 
  bool operator==(const Point &other) const
  {
    return (x == other.x && y == other.y && v == other.v);
  }
 
  bool operator!=(const Point &other) const
  {
    return !(*this == other);
  }
 
  Point operator+(const Point &other) const
  {
    return Point(x + other.x, y + other.y, v + other.v);
  }
 
  Point operator-(const Point &other) const
  {
    return Point(x - other.x, y - other.y, v - other.v);
  }
 
  Point operator*(float scalar) const
  {
    return Point(x * scalar, y * scalar, v * scalar);
  }
 
  Point operator/(float scalar) const
  {
    return Point(x / scalar, y / scalar, v / scalar);
  }
 
  friend Point operator*(float scalar, const Point &point)
  {
    return Point(scalar * point.x, scalar * point.y, scalar * point.v);
  }
 
  void print();
 
  void set_value_from_array(const Array &array, glm::vec4 bbox);
};
 
float angle(const Point &p1, const Point &p2);
 
float angle(const Point &p0, const Point &p1, const Point &p2);
 
float classify_point(const Point &p_prev,
                     const Point &p,
                     const Point &p_next,
                     const Point &pq);
 
float cross_product(const Point &p0, const Point &p1, const Point &p2);
float cross_product(const Point &p1, const Point &p2);
 
float curvature(const Point &p1, const Point &p2, const Point &p3);
 
/* see hmap::curvature */
float curvature_signed(const Point &p1, const Point &p2, const Point &p3);
 
float distance(const Point &p1, const Point &p2);
 
Point interp_bezier(const Point &p_start,
                    const Point &p_ctrl_start,
                    const Point &p_ctrl_end,
                    const Point &p_end,
                    float        t);
 
Point interp_bspline(const Point &p0,
                     const Point &p1,
                     const Point &p2,
                     const Point &p3,
                     float        t);
 
Point interp_catmullrom(const Point &p0,
                        const Point &p1,
                        const Point &p2,
                        const Point &p3,
                        float        t);
 
Point interp_decasteljau(const std::vector<Point> &points, float t);
 
glm::vec4 intersect_bounding_boxes(const glm::vec4 &bbox1,
                                   const glm::vec4 &bbox2);
 
bool is_point_within_bounding_box(Point p, glm::vec4 bbox);
 
bool is_point_within_bounding_box(float x, float y, glm::vec4 bbox);
 
Point lerp(const Point &p1, const Point &p2, float t);
 
Point midpoint(const Point &p1,
               const Point &p2,
               int          orientation,
               float        distance_ratio,
               float        t = 0.5f);
 
std::optional<Point> segment_intersection(const Point &p1,
                                          const Point &p2,
                                          const Point &q1,
                                          const Point &q2);
 
float side(const Point &p1,
           const Point &p2,
           const Point &p3,
           const Point &p_query);
 
void sort_points(std::vector<Point> &points);
 
float triangle_area(const Point &p1, const Point &p2, const Point &p3);
 
/* see hmap::triangle_area */
float triangle_area_signed(const Point &p1, const Point &p2, const Point &p3);
 
glm::vec4 unit_square_bbox();
 
} // namespace hmap