Merge remote-tracking branch 'origin/main' into clang-tidy-fixes

# Conflicts:
#	src/base/geom/circle.cpp
#	src/base/geom/circle.h
#	src/base/geom/rect.cpp
#	src/base/geom/triangle.cpp

Author: schaumb

CHANGELOG.md

@@ -2,6 +2,10 @@
 
 ## [Unreleased]
 
+### Fixed 
+
+- Area charts with data series started with zero: tooltip fixed.
+
 ## [0.12.0] - 2024-07-29
 
 ### Fixed

src/base/geom/circle.cpp

@@ -15,22 +15,6 @@
 namespace Geom
 {
 
-Circle::Circle(const Rect &rect, FromRect fromRect) :
-    center(rect.pos + rect.size / 2.0)
-{
-	switch (fromRect) {
-	case FromRect::inscribed:
-		radius = rect.size.minSize() / 2.0;
-		break;
-	case FromRect::sameWidth: radius = rect.size.x / 2.0; break;
-	case FromRect::sameHeight: radius = rect.size.y / 2.0; break;
-	case FromRect::outscribed:
-		radius = rect.size.diagonal() / 2.0;
-		break;
-	default: throw std::logic_error("invalid circle parameter");
-	}
-}
-
 Circle::Circle(const Circle &c0,
     const Circle &c1,
     double radius,
@@ -52,30 +36,16 @@ bool Circle::concentric(const Circle &c) const
 	return center == c.center;
 }
 
-bool Circle::colateral(const Circle &c, double tolerance) const
-{
-	return Math::AddTolerance(centerDistance(c), tolerance)
-	    == (radius + c.radius);
-}
-
 double Circle::area() const
 {
 	return std::numbers::pi * radius * radius;
 }
 
-bool Circle::overlaps(const Circle &c, double tolerance) const
+bool Circle::overlaps(const Circle &c) const
 {
 	auto d = c.center - center;
 	auto sumRadius = radius + c.radius;
-	return Math::AddTolerance(d.sqrAbs(), tolerance)
-	     < sumRadius * sumRadius;
-}
-
-double Circle::overlapFactor(const Circle &c) const
-{
-	auto d = centerDistance(c);
-	auto r = radius + c.radius;
-	return d == 0 ? 0 : r / d;
+	return Math::AddTolerance(d.sqrAbs()) < sumRadius * sumRadius;
 }
 
 Rect Circle::boundary() const
@@ -89,6 +59,13 @@ bool Circle::contains(const Point &point) const
 	return (point - center).sqrAbs() <= radius * radius;
 }
 
+double Circle::distance(const Point &point) const
+{
+	return std::max(0.0,
+	    (point - center).abs() - radius,
+	    Math::Floating::less);
+}
+
 double Circle::centerDistance(const Circle &c) const
 {
 	return (center - c.center).abs();

src/base/geom/circle.h

@@ -13,13 +13,6 @@ namespace Geom
 class Circle
 {
 public:
-	enum class FromRect : std::uint8_t {
-		inscribed,
-		sameWidth,
-		sameHeight,
-		outscribed
-	};
-
 	Point center;
 	double radius;
 
@@ -30,8 +23,6 @@ class Circle
 	    radius(radius)
 	{}
 
-	Circle(const Rect &rect, FromRect fromRect);
-
 	Circle(const Circle &c0,
 	    const Circle &c1,
 	    double radius,
@@ -48,13 +39,10 @@ class Circle
 	}
 
 	[[nodiscard]] double area() const;
-	[[nodiscard]] bool overlaps(const Circle &c,
-	    double tolerance) const;
-	[[nodiscard]] double overlapFactor(const Circle &c) const;
-	[[nodiscard]] bool colateral(const Circle &c,
-	    double tolerance) const;
+	[[nodiscard]] bool overlaps(const Circle &c) const;
 	[[nodiscard]] Rect boundary() const;
 	[[nodiscard]] bool contains(const Point &point) const;
+	[[nodiscard]] double distance(const Point &point) const;
 	[[nodiscard]] double distance(const Circle &c) const;
 	[[nodiscard]] Solutions<Point, 2> intersection(
 	    const Circle &c) const;

src/base/geom/line.h

@@ -19,7 +19,7 @@ struct Line
 
 	[[nodiscard]] bool isPoint() const { return begin == end; }
 
-	[[nodiscard]] Geom::Line extend(double length) const
+	[[nodiscard]] Line extend(double length) const
 	{
 		auto p = end - begin;
 		auto d = p.abs();
@@ -28,28 +28,28 @@ struct Line
 		return {begin, begin + (p * m)};
 	}
 
-	Geom::Line operator*(double value) const
+	Line operator*(double value) const
 	{
 		return {begin * value, end * value};
 	}
 
-	Geom::Line operator+(const Geom::Line &other) const
+	Line operator+(const Line &other) const
 	{
 		return {begin + other.begin, end + other.end};
 	}
 
-	void shift(const Geom::Point &offset)
+	void shift(const Point &offset)
 	{
 		begin = begin + offset;
 		end = end + offset;
 	}
 
-	[[nodiscard]] Geom::Point at(double t) const
+	[[nodiscard]] Point at(double t) const
 	{
 		return begin + (end - begin) * t;
 	}
 
-	[[nodiscard]] Geom::Line segment(double t0, double t1) const
+	[[nodiscard]] Line segment(double t0, double t1) const
 	{
 		return {at(t0), at(t1)};
 	}
@@ -61,7 +61,9 @@ struct Line
 
 	[[nodiscard]] double distance(const Point &point) const
 	{
-		auto projection = ((point - begin).dot(getDirection()))
+		if (isPoint()) return (point - begin).abs();
+
+		auto projection = (point - begin).dot(getDirection())
 		                / (length() * length());
 
 		projection =

src/base/geom/point.h

@@ -19,56 +19,56 @@ struct Point
 	double x{0.0};
 	double y{0.0};
 
-	static Point Invalid() { return {NAN, NAN}; }
+	[[nodiscard]] static Point Invalid() { return {NAN, NAN}; }
 
-	static Point Max()
+	[[nodiscard]] static Point Max()
 	{
 		return {std::numeric_limits<double>::max(),
 		    std::numeric_limits<double>::max()};
 	}
 
-	static Point Min()
+	[[nodiscard]] static Point Min()
 	{
 		return {std::numeric_limits<double>::lowest(),
 		    std::numeric_limits<double>::lowest()};
 	}
 
-	static Point Ident(bool horizontal)
+	[[nodiscard]] static Point Ident(bool horizontal)
 	{
 		return {horizontal ? 1.0 : 0.0, horizontal ? 0.0 : 1.0};
 	}
 
-	static Point Polar(double radius, double angle)
+	[[nodiscard]] static Point Polar(double radius, double angle)
 	{
 		return {radius * cos(angle), radius * sin(angle)};
 	}
 
-	static Point X(double x) { return {x, 0}; }
+	[[nodiscard]] static Point X(double x) { return {x, 0}; }
 
-	static Point Y(double y) { return {0, y}; }
+	[[nodiscard]] static Point Y(double y) { return {0, y}; }
 
-	Point operator*(double factor) const
+	[[nodiscard]] Point operator*(double factor) const
 	{
 		return {x * factor, y * factor};
 	}
 
-	Point operator/(double divisor) const
+	[[nodiscard]] Point operator/(double divisor) const
 	{
 		if (Math::Floating::is_zero(divisor)) return Invalid();
 		return {x / divisor, y / divisor};
 	}
 
-	Point operator+(const Point &other) const
+	[[nodiscard]] Point operator+(const Point &other) const
 	{
 		return {x + other.x, y + other.y};
 	}
 
-	Point operator-(const Point &other) const
+	[[nodiscard]] Point operator-(const Point &other) const
 	{
 		return {x - other.x, y - other.y};
 	}
 
-	Point operator*(const Point &other) const
+	[[nodiscard]] Point operator*(const Point &other) const
 	{
 		return {x * other.x, y * other.y};
 	}
@@ -78,18 +78,65 @@ struct Point
 		return x * other.x + y * other.y;
 	}
 
-	Point operator/(const Point &other) const
+	[[nodiscard]] Point operator/(const Point &other) const
 	{
 		using Math::Floating::is_zero;
 		if (is_zero(other.x) || is_zero(other.y)) return Invalid();
 		return {x / other.x, y / other.y};
 	}
 
-	double operator^(const Point &p) const
+	[[nodiscard]] double operator^(const Point &p) const
 	{
 		return x * p.y - y * p.x;
 	}
 
+	Point &operator+=(const Point &other)
+	{
+		x += other.x;
+		y += other.y;
+		return *this;
+	}
+
+	Point &operator-=(const Point &other)
+	{
+		x -= other.x;
+		y -= other.y;
+		return *this;
+	}
+
+	Point &operator*=(double factor)
+	{
+		x *= factor;
+		y *= factor;
+		return *this;
+	}
+
+	Point &operator/=(double divisor)
+	{
+		if (Math::Floating::is_zero(divisor))
+			return *this = Invalid();
+		x /= divisor;
+		y /= divisor;
+		return *this;
+	}
+
+	Point &operator*=(const Point &other)
+	{
+		x *= other.x;
+		y *= other.y;
+		return *this;
+	}
+
+	Point &operator/=(const Point &other)
+	{
+		using Math::Floating::is_zero;
+		if (is_zero(other.x) || is_zero(other.y))
+			return *this = Invalid();
+		x /= other.x;
+		y /= other.y;
+		return *this;
+	}
+
 	[[nodiscard]] Point flip() const { return {y, x}; }
 
 	[[nodiscard]] Point flipX() const { return {-x, y}; }
@@ -215,7 +262,7 @@ struct Size : Point
 		    std::min(s1.y, s2.y, less)};
 	}
 
-	[[nodiscard]] bool isSquare(double toleranceFactor = 0.0) const
+	[[nodiscard]] bool isSquare(double toleranceFactor) const
 	{
 		using Math::Floating::is_zero;
 		if (is_zero(y)) return false;

src/base/geom/quadrilateral.cpp

@@ -9,33 +9,12 @@
 namespace Geom
 {
 
-ConvexQuad::ConvexQuad(const Rect &rect)
-{
-	points[0] = rect.pos;
-	points[1] = rect.pos + Point{rect.size.x, 0.0};
-	points[2] = rect.pos + rect.size;
-	points[3] = rect.pos + Point{0.0, rect.size.y};
-}
-
-Rect ConvexQuad::boundary() const { return Rect::Boundary(points); }
-
-ConvexQuad ConvexQuad::Square(Point p0, Point p2)
-{
-	auto center = (p0 + p2) / 2;
-	auto halfDiagonal = (p2 - p0) / 2;
-	auto p1 = center + halfDiagonal.normal(false);
-	auto p3 = center + halfDiagonal.normal(true);
-	return ConvexQuad({p0, p1, p2, p3});
-}
-
 ConvexQuad ConvexQuad::Isosceles(Point base0Middle,
     Point base1Middle,
     double base0Length,
     double base1Length)
 {
-	auto dir = base1Middle == base0Middle
-	             ? Point{0, 1}
-	             : (base1Middle - base0Middle).normalized();
+	auto dir = (base1Middle - base0Middle).normalized();
 
 	return ConvexQuad(
 	    {base0Middle + dir.normal(false) * (base0Length / 2),
@@ -44,20 +23,12 @@ ConvexQuad ConvexQuad::Isosceles(Point base0Middle,
 	        base1Middle + dir.normal(false) * (base1Length / 2)});
 }
 
-bool ConvexQuad::contains(const Point &p, double tolerance) const
-{
-	auto boundaryArea = Triangle{{points[0], points[1], p}}.area()
-	                  + Triangle{{points[1], points[2], p}}.area()
-	                  + Triangle{{points[2], points[3], p}}.area()
-	                  + Triangle{{points[3], points[0], p}}.area();
-
-	return Math::AddTolerance(boundaryArea, tolerance) <= area();
-}
-
-double ConvexQuad::area() const
+double ConvexQuad::distance(const Point &point) const
 {
-	return Triangle{{points[0], points[1], points[2]}}.area()
-	     + Triangle{{points[2], points[3], points[0]}}.area();
+	return std::min(
+	    Triangle{{points[0], points[1], points[2]}}.distance(point),
+	    Triangle{{points[2], points[3], points[0]}}.distance(point),
+	    Math::Floating::less);
 }
 
 }