Implemented project(line, circle)

Author: Illia

TEST_Geometry2D.cpp

@@ -98,7 +98,10 @@ class Test_Geometry2D : public olc::PixelGameEngine
 	// The clever bit (and a bit new to me - jx9)
 	using ShapeWrap = std::variant<Point, Line, Rect, Circle, Triangle, Ray>;
 
-	
+	enum Mode
+	{
+		CircleProject, LineProject, NoProject
+	};
 
 	bool CheckOverlaps(const ShapeWrap& s1, const ShapeWrap& s2)
 	{
@@ -172,14 +175,21 @@ class Test_Geometry2D : public olc::PixelGameEngine
 			},
 
 			[](const Circle& s1, const Triangle& s2, const Ray& s3)
+			{
+				return project(make_internal(s1), make_internal(s2), make_internal(s3));
+			},
+
+			[](const Line& s1, const Circle& s2, const Ray& s3)
 			{
 				return project(make_internal(s1), make_internal(s2), make_internal(s3));
 			}
+
 		};
 
 		return std::visit(dispatch, s1, s2, s3);
 	}
 
+
 	std::optional<ray<float>> CheckReflect(const olc::utils::geom2d::ray<float>& s1, const ShapeWrap& s2)
 	{
 		const auto dispatch = overloads{
@@ -252,6 +262,7 @@ class Test_Geometry2D : public olc::PixelGameEngine
 
 	size_t nSelectedShapeIndex = -1;
 	olc::vi2d vOldMousePos;
+	Mode mode = Mode::NoProject;
 
 public: 
 	bool OnUserCreate() override
@@ -283,6 +294,10 @@ class Test_Geometry2D : public olc::PixelGameEngine
 		if (GetMouse(0).bReleased)
 			nSelectedShapeIndex = -1;
 
+		if (GetKey(olc::Key::C).bPressed) mode = Mode::CircleProject;
+		if (GetKey(olc::Key::L).bPressed) mode = Mode::LineProject;
+		if (GetKey(olc::Key::N).bPressed) mode = Mode::NoProject;
+
 		// Check for mouse hovered shapes
 		ShapeWrap mouse{ Point{olc::vf2d(GetMousePos())} };
 
@@ -345,6 +360,10 @@ class Test_Geometry2D : public olc::PixelGameEngine
 		bool bRayMode = false;
 		std::vector<std::optional<olc::v_2d<float>>> projected_circle_left_ray;
 		std::vector<std::optional<olc::v_2d<float>>> projected_circle_right_ray;
+		std::vector<std::optional<olc::v_2d<float>>> projected_line_left_ray;
+		std::vector<std::optional<olc::v_2d<float>>> projected_line_right_ray;
+		const Line line_to_project{ { { 100.0f, 100.0f }, {140.0f, 70.0f} } };
+
 
 		if (GetMouse(1).bHeld)
 		{
@@ -373,11 +392,17 @@ class Test_Geometry2D : public olc::PixelGameEngine
 
 			for (const auto& shape : vecShapes)
 			{
-				if(std::holds_alternative<Rect>(shape) || std::holds_alternative<Triangle>(shape))
+				if(mode == Mode::CircleProject && (std::holds_alternative<Rect>(shape) || std::holds_alternative<Triangle>(shape)))
 				{
 					projected_circle_left_ray.push_back(CheckProject(Circle{ { { 130.0f, 20.0f }, {150.0f, 20.0f} } }, shape, ray1));
 					projected_circle_right_ray.push_back(CheckProject(Circle{ { { 130.0f, 20.0f }, {150.0f, 20.0f} } }, shape, ray2));
 				}
+
+				if (mode == Mode::LineProject && (std::holds_alternative<Circle>(shape)))
+				{
+					projected_line_left_ray.push_back(CheckProject(line_to_project, shape, ray1));
+					projected_line_right_ray.push_back(CheckProject(line_to_project, shape, ray2));
+				}
 			}
 
 		}
@@ -412,19 +437,45 @@ class Test_Geometry2D : public olc::PixelGameEngine
 
 			for(const auto& projection : projected_circle_left_ray)
 			{
-				if (projection.has_value())
+				if (mode == Mode::CircleProject && projection.has_value())
 				{
 					DrawCircle(projection.value(), 20.0f, olc::CYAN);
 				}
 			}
 
 			for (const auto& projection : projected_circle_right_ray)
 			{
-				if (projection.has_value())
+				if (mode == Mode::CircleProject && projection.has_value())
 				{
 					DrawCircle(projection.value(), 20.0f, olc::RED);
 				}
 			}
+
+			for (const auto& projection : projected_line_left_ray)
+			{
+				if (mode == Mode::LineProject && projection.has_value())
+				{
+					const auto& vec = make_internal(line_to_project).vector().norm();
+					const auto& half_length = 0.5 * make_internal(line_to_project).vector().mag();
+					const olc::vf2d start = projection.value() - vec * half_length;
+					const olc::vf2d end = projection.value() + vec * half_length;
+					Line line_to_draw{ {{start}, {end}} };
+					DrawShape(line_to_draw, olc::CYAN);
+				}
+			}
+
+			for (const auto& projection : projected_line_right_ray)
+			{
+				if (mode == Mode::LineProject && projection.has_value())
+				{
+					const auto& vec = make_internal(line_to_project).vector().norm();
+					const auto& half_length = 0.5 * make_internal(line_to_project).vector().mag();
+					const olc::vf2d start = projection.value() - vec * half_length;
+					const olc::vf2d end = projection.value() + vec * half_length;
+					Line line_to_draw{ {{start}, {end}} };
+					DrawShape(line_to_draw, olc::RED);
+				}
+			}
 		}
 
 		// Laser beam		

olcUTIL_Geometry2D.h

@@ -1406,7 +1406,102 @@ namespace olc::utils::geom2d
 	}
 
 
+	// project(t,c)
+	// project a line, onto a circle, via a ray (i.e. how far along the ray can the line travel until it contacts the circle?)
+	template<typename T1, typename T2, typename T3>
+	inline std::optional<olc::v_2d<T1>> project(const line<T1>& l, const circle<T2>& c, const ray<T3>& q)
+	{
+		// The ray intersects the line in the midpoint at all times
+		// The function returns a projected midpoint
+		
+		// initialize variables for readable mathematics
+		const auto& [a, b] = c.pos;
+		const auto& r = c.radius;
+		auto [rx, ry] = q.direction;
+		const auto& [ox, oy] = q.origin;
+		const auto& [slope, intercept] = l.coefficients();
+		const auto& length = l.vector().mag();
+
+		// First, we find two points on the cirlce that correspond to the tangent of the same slope
+		// as the given line
+		const double y_t1 = r / std::sqrt(slope * slope + 1) + b;
+		const double y_t2 = - r / std::sqrt(slope * slope + 1) + b;
+		std::vector<olc::v_2d<double>> tangent_points{ { {a - (y_t1 - b) * slope, y_t1}, {a - (y_t2 - b) * slope, y_t2} } };
+		
+		// Check if the ray intersects the tangent line along its way and not from behind
+		const auto& v = (tangent_points[0] - q.origin).norm();
+		if (v.dot(q.direction) < 0) return{};
+
+		// The line is first being projected onto both tangent lines, the tangent point and the intersections between the ray and
+		// the tangent line are stored as well 
+		std::vector<std::pair<olc::v_2d<double>, std::pair<olc::v_2d<double>, olc::v_2d<double>>>> side_points;
+		std::vector<olc::v_2d<T1>> possible_points;
+
+		for (const auto& tangent_point : tangent_points)
+		{	
+			const auto& [xt, yt] = tangent_point;
+			const double xl = (ry / rx * ox - xt * slope + yt - oy) / (ry / rx - slope);
+			const double yl = (xl - xt) * slope + yt;
+			// Creating two points on a tangent line that correspond to the start and the end of a projected line  
+			const double x_side_1 = xl - 0.5 * length * l.vector().norm().x;
+			const double x_side_2 = xl + 0.5 * length * l.vector().norm().x;
+			const double y_side_1 = (x_side_1 - xl) * slope + yl;
+			const double y_side_2 = (x_side_2 - xl) * slope + yl;
+
+			side_points.push_back({ {x_side_1, y_side_1}, {{xl, yl}, {xt, yt}} });
+			side_points.push_back({ {x_side_2, y_side_2}, {{xl, yl}, {xt, yt}} });
+		}
+
+
+		for (const auto& [side_point, pair] : side_points)
+		{
+			const auto& [x1, y1] = side_point;
+			const auto& tangent_intersection_point = pair.first;
+			const auto& tangent_point = pair.second;
+
+			// We search for a scalar s such that:
+			// x_new = x_side + s * rx
+			// y_new = y_side + s * ry
+			// (x_new - a)^2 + (y_new - b)^2 = r^2
+			//
+			// Where (x_new, y_new) is a point on the circle that is obtained by transporting a line projected onto the
+			// tangent via a ray q
+			//
+			// For each tangent line and for each side of the line being transported, there can be up to 4 transported lines
+			
+			const double D = (2 * rx * (x1 - a) + 2 * ry * (y1 - b)) * (2 * rx * (x1 - a) + 2 * ry * (y1 - b)) -
+						4 * (rx * rx + ry * ry) * ((x1 - a) * (x1 - a) + (y1 - b) * (y1 - b) - r * r);
+			if (D > 0)
+			{
+				const double s1 = (-2 * rx * (x1 - a) - 2 * ry * (y1 - b) + std::sqrt(D)) / (2 * (rx * rx + ry * ry));
+				const double s2 = (-2 * rx * (x1 - a) - 2 * ry * (y1 - b) - std::sqrt(D)) / (2 * (rx * rx + ry * ry));
+				const olc::v_2d<T1> p1{ tangent_intersection_point + s1 * q.direction };
+				const olc::v_2d<T1> p2{ tangent_intersection_point + s2 * q.direction };
+				// Only add a point is it is not inside the circle
+				!contains(c, p1) ? possible_points.push_back(p1) : (void)0;
+				!contains(c, p2) ? possible_points.push_back(p2) : (void)0;
+				// Only add a tangent-ray intersection point if the distance between it and the tangent point is less than of equal 
+				// half length of the line. It means the line can lie on the tangent
+				(tangent_intersection_point - tangent_point).mag() <= 0.5 * length ? possible_points.push_back(tangent_intersection_point) : (void)0;
+			}
+			else if (D == 0)
+			{
+				const double s = (-2 * rx * (x1 - a) - 2 * ry * (y1 - b)) / (2 * (rx * rx + ry * ry));
+				const olc::v_2d<T1> p{ tangent_intersection_point + s * q.direction };
+				!contains(c, p) ? possible_points.push_back(p): (void)0;
+			}
+		}
 
+		if (possible_points.empty()) return {};
+		
+		// Compare by the distance to the origin
+		return *std::min_element(possible_points.begin(), possible_points.end(),
+			[&q](const auto& lhs, const auto& rhs)
+			{
+				return (lhs - q.origin).mag2() < (rhs - q.origin).mag2();
+			});
+
+	}
 
 
 
@@ -1923,6 +2018,14 @@ namespace olc::utils::geom2d
 		return internal::filter_duplicate_points(intersections);
 	}
 
+	// project(t,c)
+	// project a triangle, onto a circle, via a ray (i.e. how far along the ray can the triangle travel until it contacts the circle?)
+	template<typename T1, typename T2, typename T3>
+	inline std::optional<olc::v_2d<T1>> project(const triangle<T1>& t, const circle<T2>& c, const ray<T3> q)
+	{
+		
+	}
+
 
 	// envelope_c(c)
 	// Return circle that fully encapsulates a point