fix: Mid-point for rounded linears are not precisely centered (#9544)

packages/math/src/constants.ts

@@ -0,0 +1,57 @@
+export const PRECISION = 10e-5;
+
+// Legendre-Gauss abscissae (x values) and weights for n=24
+// Refeerence: https://pomax.github.io/bezierinfo/legendre-gauss.html
+export const LegendreGaussN24TValues = [
+  -0.0640568928626056260850430826247450385909,
+  0.0640568928626056260850430826247450385909,
+  -0.1911188674736163091586398207570696318404,
+  0.1911188674736163091586398207570696318404,
+  -0.3150426796961633743867932913198102407864,
+  0.3150426796961633743867932913198102407864,
+  -0.4337935076260451384870842319133497124524,
+  0.4337935076260451384870842319133497124524,
+  -0.5454214713888395356583756172183723700107,
+  0.5454214713888395356583756172183723700107,
+  -0.6480936519369755692524957869107476266696,
+  0.6480936519369755692524957869107476266696,
+  -0.7401241915785543642438281030999784255232,
+  0.7401241915785543642438281030999784255232,
+  -0.8200019859739029219539498726697452080761,
+  0.8200019859739029219539498726697452080761,
+  -0.8864155270044010342131543419821967550873,
+  0.8864155270044010342131543419821967550873,
+  -0.9382745520027327585236490017087214496548,
+  0.9382745520027327585236490017087214496548,
+  -0.9747285559713094981983919930081690617411,
+  0.9747285559713094981983919930081690617411,
+  -0.9951872199970213601799974097007368118745,
+  0.9951872199970213601799974097007368118745,
+];
+
+export const LegendreGaussN24CValues = [
+  0.1279381953467521569740561652246953718517,
+  0.1279381953467521569740561652246953718517,
+  0.1258374563468282961213753825111836887264,
+  0.1258374563468282961213753825111836887264,
+  0.121670472927803391204463153476262425607,
+  0.121670472927803391204463153476262425607,
+  0.1155056680537256013533444839067835598622,
+  0.1155056680537256013533444839067835598622,
+  0.1074442701159656347825773424466062227946,
+  0.1074442701159656347825773424466062227946,
+  0.0976186521041138882698806644642471544279,
+  0.0976186521041138882698806644642471544279,
+  0.086190161531953275917185202983742667185,
+  0.086190161531953275917185202983742667185,
+  0.0733464814110803057340336152531165181193,
+  0.0733464814110803057340336152531165181193,
+  0.0592985849154367807463677585001085845412,
+  0.0592985849154367807463677585001085845412,
+  0.0442774388174198061686027482113382288593,
+  0.0442774388174198061686027482113382288593,
+  0.0285313886289336631813078159518782864491,
+  0.0285313886289336631813078159518782864491,
+  0.0123412297999871995468056670700372915759,
+  0.0123412297999871995468056670700372915759,
+];

packages/math/src/curve.ts

@@ -2,6 +2,7 @@ import { doBoundsIntersect, type Bounds } from "@excalidraw/element";
 
 import { isPoint, pointDistance, pointFrom, pointFromVector } from "./point";
 import { vector, vectorNormal, vectorNormalize, vectorScale } from "./vector";
+import { LegendreGaussN24CValues, LegendreGaussN24TValues } from "./constants";
 
 import type { Curve, GlobalPoint, LineSegment, LocalPoint } from "./types";
 
@@ -406,3 +407,123 @@ export function offsetPointsForQuadraticBezier(
 
   return offsetPoints;
 }
+
+/**
+ * Implementation based on Legendre-Gauss quadrature for more accurate arc
+ * length calculation.
+ *
+ * Reference: https://pomax.github.io/bezierinfo/#arclength
+ *
+ * @param c The curve to calculate the length of
+ * @returns The approximated length of the curve
+ */
+export function curveLength<P extends GlobalPoint | LocalPoint>(
+  c: Curve<P>,
+): number {
+  const z2 = 0.5;
+  let sum = 0;
+
+  for (let i = 0; i < 24; i++) {
+    const t = z2 * LegendreGaussN24TValues[i] + z2;
+    const derivativeVector = curveTangent(c, t);
+    const magnitude = Math.sqrt(
+      derivativeVector[0] * derivativeVector[0] +
+        derivativeVector[1] * derivativeVector[1],
+    );
+    sum += LegendreGaussN24CValues[i] * magnitude;
+  }
+
+  return z2 * sum;
+}
+
+/**
+ * Calculates the curve length from t=0 to t=parameter using the same
+ * Legendre-Gauss quadrature method used in curveLength
+ *
+ * @param c The curve to calculate the partial length for
+ * @param t The parameter value (0 to 1) to calculate length up to
+ * @returns The length of the curve from beginning to parameter t
+ */
+export function curveLengthAtParameter<P extends GlobalPoint | LocalPoint>(
+  c: Curve<P>,
+  t: number,
+): number {
+  if (t <= 0) {
+    return 0;
+  }
+  if (t >= 1) {
+    return curveLength(c);
+  }
+
+  // Scale and shift the integration interval from [0,t] to [-1,1]
+  // which is what the Legendre-Gauss quadrature expects
+  const z1 = t / 2;
+  const z2 = t / 2;
+
+  let sum = 0;
+
+  for (let i = 0; i < 24; i++) {
+    const parameter = z1 * LegendreGaussN24TValues[i] + z2;
+    const derivativeVector = curveTangent(c, parameter);
+    const magnitude = Math.sqrt(
+      derivativeVector[0] * derivativeVector[0] +
+        derivativeVector[1] * derivativeVector[1],
+    );
+    sum += LegendreGaussN24CValues[i] * magnitude;
+  }
+
+  return z1 * sum; // Scale the result back to the original interval
+}
+
+/**
+ * Calculates the point at a specific percentage of a curve's total length
+ * using binary search for improved efficiency and accuracy.
+ *
+ * @param c The curve to calculate point on
+ * @param percent A value between 0 and 1 representing the percentage of the curve's length
+ * @returns The point at the specified percentage of curve length
+ */
+export function curvePointAtLength<P extends GlobalPoint | LocalPoint>(
+  c: Curve<P>,
+  percent: number,
+): P {
+  if (percent <= 0) {
+    return bezierEquation(c, 0);
+  }
+
+  if (percent >= 1) {
+    return bezierEquation(c, 1);
+  }
+
+  const totalLength = curveLength(c);
+  const targetLength = totalLength * percent;
+
+  // Binary search to find parameter t where length at t equals target length
+  let tMin = 0;
+  let tMax = 1;
+  let t = percent; // Start with a reasonable guess (t = percent)
+  let currentLength = 0;
+
+  // Tolerance for length comparison and iteration limit to avoid infinite loops
+  const tolerance = totalLength * 0.0001;
+  const maxIterations = 20;
+
+  for (let iteration = 0; iteration < maxIterations; iteration++) {
+    currentLength = curveLengthAtParameter(c, t);
+    const error = Math.abs(currentLength - targetLength);
+
+    if (error < tolerance) {
+      break;
+    }
+
+    if (currentLength < targetLength) {
+      tMin = t;
+    } else {
+      tMax = t;
+    }
+
+    t = (tMin + tMax) / 2;
+  }
+
+  return bezierEquation(c, t);
+}