Refactor tolerance and marker bounds check

Author: schaumb

src/base/geom/circle.cpp

@@ -7,18 +7,6 @@
 namespace Geom
 {
 
-Circle::Circle(const Rect &rect, FromRect fromRect)
-{
-	radius = fromRect == FromRect::inscribed
-	           ? rect.size.minSize() / 2.0
-	       : fromRect == FromRect::sameWidth  ? rect.size.x / 2.0
-	       : fromRect == FromRect::sameHeight ? rect.size.y / 2.0
-	       : fromRect == FromRect::outscribed
-	           ? rect.size.diagonal() / 2.0
-	           : throw std::logic_error("invalid circle parameter");
-	center = rect.pos + rect.size / 2.0;
-}
-
 Circle::Circle(const Circle &c0,
     const Circle &c1,
     double radius,
@@ -40,29 +28,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 M_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)
+	return Math::AddTolerance(d.sqrAbs())
 	     < sumRadius * sumRadius;
 }
 
-double Circle::overlapFactor(const Circle &c) const
-{
-	auto d = centerDistance(c);
-	auto r = radius + c.radius;
-	return d == 0 ? 0 : r / d;
-}
-
 Rect Circle::boundary() const
 {
 	return {center - Point{1, 1} * radius,
@@ -74,6 +49,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 {
-		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

@@ -61,6 +61,9 @@ struct Line
 
 	[[nodiscard]] double distance(const Point &point) const
 	{
+		if (isPoint())
+			return (point - begin).abs();
+
 		auto projection = ((point - begin).dot(getDirection()))
 		                / (length() * length());
 

src/base/geom/point.h

@@ -261,7 +261,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

@@ -7,23 +7,12 @@
 namespace Geom
 {
 
-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),
@@ -32,20 +21,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);
 }
 
 }

src/base/geom/quadrilateral.h

@@ -17,14 +17,12 @@ class ConvexQuad
 
 	ConvexQuad() = default;
 	explicit ConvexQuad(const Points &points) : points(points) {}
-	[[nodiscard]] static ConvexQuad Square(Point p0, Point p2);
 	[[nodiscard]] static ConvexQuad Isosceles(Point base0Middle,
 	    Point base1Middle,
 	    double base0Length,
 	    double base1Length);
-	[[nodiscard]] bool contains(const Point &p,
-	    double tolerance = 0.0) const;
-	[[nodiscard]] double area() const;
+
+	[[nodiscard]] double distance(const Point& point) const;
 };
 
 }

src/base/geom/rect.cpp

@@ -7,11 +7,6 @@ namespace Geom
 
 Rect Rect::Ident() { return {Geom::Point(), Geom::Size::Identity()}; }
 
-Rect Rect::CenteredMax()
-{
-	return {Geom::Point::Min() / 2, {Geom::Size::Max()}};
-}
-
 Rect Rect::boundary(const Rect &rect) const
 {
 	using Math::Floating::less;
@@ -24,17 +19,6 @@ Rect Rect::boundary(const Rect &rect) const
 	return res;
 }
 
-Rect Rect::boundary(const Point &p) const
-{
-	using Math::Floating::less;
-	Rect res = positive();
-	res.setLeft(std::min(res.left(), p.x, less));
-	res.setBottom(std::min(res.bottom(), p.y, less));
-	res.setRight(std::max(res.right(), p.x, less));
-	res.setTop(std::max(res.top(), p.y, less));
-	return res;
-}
-
 Point Rect::normalize(const Point &p) const
 {
 	using Math::Floating::is_zero;

src/base/geom/rect.h

@@ -2,6 +2,8 @@
 #define GEOM_RECT
 
 #include <array>
+#include <functional>
+#include <ranges>
 #include <tuple>
 #include <vector>
 
@@ -22,10 +24,8 @@ struct Rect
 	static Rect Boundary(const Container &points);
 
 	static Rect Ident();
-	static Rect CenteredMax();
 
 	[[nodiscard]] Rect boundary(const Rect &rect) const;
-	[[nodiscard]] Rect boundary(const Point &p) const;
 	[[nodiscard]] Point normalize(const Point &p) const;
 	[[nodiscard]] Size normalize(const Size &s) const;
 	[[nodiscard]] Rect normalize(const Rect &rect) const;
@@ -157,9 +157,13 @@ struct Rect
 template <class Container>
 Rect Rect::Boundary(const Container &points)
 {
-	Rect boundary{points[0]};
-	for (auto &point : points) boundary = boundary.boundary(point);
-	return boundary;
+	auto &&[minx, maxx] = std::ranges::minmax(
+	    std::ranges::views::transform(points, std::mem_fn(&Point::x)),
+	    Math::Floating::less);
+	auto &&[miny, maxy] = std::ranges::minmax(
+	    std::ranges::views::transform(points, std::mem_fn(&Point::y)),
+	    Math::Floating::less);
+	return Rect{{minx, miny}, {maxx - minx, maxy - miny}};
 }
 
 }

src/base/geom/triangle.cpp

@@ -1,5 +1,7 @@
 #include "triangle.h"
 
+#include "line.h"
+
 namespace Geom
 {
 
@@ -10,4 +12,22 @@ double Triangle::area() const
 	return fabs(A ^ B) / 2;
 }
 
+double Triangle::distance(const Point &point) const
+{
+	const auto A = points[2] - points[1];
+	const auto B = points[0] - points[1];
+	const auto C = points[2] - points[0];
+	const auto dA = Geom::Line{points[1], points[2]}.distance(point);
+	const auto dB = Geom::Line{points[0], points[1]}.distance(point);
+	const auto dC = Geom::Line{points[2], points[0]}.distance(point);
+	if (const auto double_area = fabs(A ^ B);
+	    !Math::Floating::is_zero(double_area)
+	    && Math::AddTolerance(
+	           A.abs() * dA + B.abs() * dB + C.abs() * dC)
+	           == double_area) {
+		return 0.0;
+	}
+	return std::min({dA, dB, dC}, Math::Floating::less);
+}
+
 }

src/base/geom/triangle.h

@@ -14,6 +14,8 @@ class Triangle
 	std::array<Point, 3> points;
 
 	[[nodiscard]] double area() const;
+
+	[[nodiscard]] double distance(const Point& point) const;
 };
 
 }