VirtualPath: Export tangent from findClosestPointTo()

The tangent vector is essential for the move parallel tool where we
want to calculate the distance of the cursor from the tangent line
touching the path in question. Please note that we are generating a
"pseudo tangent" for corners and line ends to enable sensible
behavior during mouse drag events.

Author: lpechacek

src/core/objects/object.cpp

@@ -1160,7 +1160,7 @@ ClosestPathCoord PathObject::findClosestPointTo(
 
 	using distance_type = decltype(ClosestPathCoord::distance_squared);
 	return std::accumulate(begin(path_parts), end(path_parts),
-	                       ClosestPathCoord { {}, std::numeric_limits<distance_type>::max() },
+	                       ClosestPathCoord { {}, {}, std::numeric_limits<distance_type>::max() },
 	                       op);
 }
 

src/core/path_coord.h

@@ -158,11 +158,17 @@ class PathCoord
 
 
 /**
- * The structure returned when looking for closest coordinates on a path.
+ * The structure returned when looking for the closest coordinates on a path.
+ * The tangent element is defined even on corners and line ends. Following the
+ * intuitive view, the tangent line touches the corner, dividing the plane into
+ * the part with the corner and the part without it. At the line ends, the
+ * "tangent" is the direction of the neighboring segment. The "pseudo tangent"
+ * is generated to define the direction for mouse drag actions.
  */
 struct ClosestPathCoord
 {
 	PathCoord path_coord;
+	MapCoordF tangent;
 	double distance_squared;
 };
 

src/core/virtual_path.cpp

@@ -347,9 +347,11 @@ ClosestPathCoord VirtualPath::findClosestPointTo(
         size_type start_index,
         size_type end_index ) const
 {
-	Q_ASSERT(!path_coords.empty());
+	Q_ASSERT(path_coords.size() > 1);
 
-	auto result = ClosestPathCoord { path_coords.front(), distance_bound_squared };
+	auto result = ClosestPathCoord { path_coords.front(), 
+	              path_coords[1].pos - path_coords[0].pos,
+	              distance_bound_squared };
 
 	// Find upper bound for distance.
 	for (const auto& path_coord : path_coords)
@@ -364,6 +366,27 @@ ClosestPathCoord VirtualPath::findClosestPointTo(
 		if (dist_sq < result.distance_squared)
 		{
 			result.distance_squared = dist_sq;
+			// Here we create predictable behavior for corners and handle 
+			// the ends. Although corners do not have a tangent in 
+			// the mathematical sense, the humans intuitively expect the 
+			// "tangent" to go across the corner and divide the plane into the
+			// inner and outer parts.
+			bool in_ok = false;
+			bool out_ok = false;
+			auto const incoming = calculateIncomingTangent(path_coord.index, in_ok);
+			auto const outgoing = calculateOutgoingTangent(path_coord.index, out_ok);
+			if (in_ok && out_ok)
+			{
+				result.tangent = incoming + outgoing;
+			}
+			else if (in_ok)
+			{
+				result.tangent = incoming;
+			}
+			else if (out_ok)
+			{
+				result.tangent = outgoing;
+			}
 			result.path_coord = path_coord;
 		}
 	}
@@ -391,6 +414,7 @@ ClosestPathCoord VirtualPath::findClosestPointTo(
 			if (to_coord.lengthSquared() < result.distance_squared)
 			{
 				result.distance_squared = to_coord.lengthSquared();
+				result.tangent = tangent;
 				result.path_coord = *pc;
 			}
 			continue;
@@ -402,6 +426,7 @@ ClosestPathCoord VirtualPath::findClosestPointTo(
 			if (coord.distanceSquaredTo(next_pos) < result.distance_squared)
 			{
 				result.distance_squared = coord.distanceSquaredTo(next_pos);
+				result.tangent = tangent;
 				result.path_coord = *next_pc;
 			}
 			continue;
@@ -425,13 +450,16 @@ ClosestPathCoord VirtualPath::findClosestPointTo(
 			if (coords.flags[result.path_coord.index].isCurveStart())
 			{
 				MapCoordF unused;
+				MapCoordF curve2_control_point1;
 				PathCoord::splitBezierCurve(MapCoordF(coords.flags[result.path_coord.index]), MapCoordF(coords.flags[result.path_coord.index+1]),
 											MapCoordF(coords.flags[result.path_coord.index+2]), MapCoordF(coords.flags[result.path_coord.index+3]),
-											result.path_coord.param, unused, unused, result.path_coord.pos, unused, unused);
+											result.path_coord.param, unused, unused, result.path_coord.pos, curve2_control_point1, unused);
+				result.tangent = curve2_control_point1 - result.path_coord.pos;
 			}
 			else
 			{
-				result.path_coord.pos = pos + (next_pos - pos) * double(factor);
+				result.tangent = next_pos - pos;
+				result.path_coord.pos = pos + result.tangent * double(factor);
 			}
 		}
 	}