flo-mat 4.0.3 → 4.1.0

package/src/get-medial-points/double-double/dd-get-medial-point-coeffs-bez0.ts

@@ -0,0 +1,61 @@
+import { ddAddDd, ddMultDd, ddMultBy2, ddDiffDouble } from 'double-double';
+
+const qaq = ddAddDd;
+const qmq = ddMultDd;
+const qm2 = ddMultBy2;
+const qdd = ddDiffDouble;
+
+
+// TODO - move all these upstream to flo-bezier3
+
+/**
+ * Returns the coefficients `a0` and `b0` for the linear equation
+ * `a0⋅t + b0 = 0`, so the ray parameter can be recovered as `t = -b0/a0`.
+ * That parameter value makes `q(t) = p + t⋅v` equidistant from `p` and `P`.
+ * 
+ * Let `p` be a fixed point in the plane.\
+ * Let `v` be a direction vector defining the ray `q(t) = p + t⋅v`.\
+ * Let `P` be another point.\
+ *
+ * In other words, this function returns the coefficients needed to solve for
+ * the ray parameter of the medial point on the ray.
+ *
+ * @param p base point
+ * @param v ray direction from `p`
+ * @param P another "target" point, e.g. `[1,2]`
+ */
+function ddGetMedialPointCoeffsBez0(
+        p: number[][],
+        v: number[][],
+        P: number[]) {
+
+    // -----------------------------------------------------
+    // See get-medial-points.md for implementation details.
+    // -----------------------------------------------------
+
+    const [px, py] = p;
+    const [vx, vy] = v;
+    const [x0, y0] = P;
+
+    // Constant bezier in power basis: b(s) = c
+    // u(s) = p - b(s) = u0
+
+    // const u0x = px - x0;
+    // const u0y = py - y0;
+    const u0x = qdd(px,x0);
+    const u0y = qdd(py,y0);
+
+    // E2(s,t): |t⋅v|² - |u(s) + t⋅v|² = 0
+    //         => 2⋅(v⋅u(s))⋅t + |u(s)|² = 0
+    //         => A(s)⋅t + B(s) = 0
+
+    // const a0 = 2*(vx*u0x + vy*u0y);
+    // const b0 = u0x*u0x + u0y*u0y;
+    const a0 = qaq(qmq(qm2(vx),u0x),qmq(qm2(vy),u0y));
+    const b0 = qaq(qmq(u0x,u0x), qmq(u0y,u0y));
+
+    return { a0, b0 };
+}
+
+
+export { ddGetMedialPointCoeffsBez0 }

package/src/get-medial-points/double-double/dd-get-medial-point-coeffs-bez1.ts

@@ -0,0 +1,116 @@
+import { twoDiff, ddAddDd, ddMultDd, ddNegativeOf, ddMultByNeg2, ddDiffDouble, ddMultBy2 } from 'double-double';
+
+const td = twoDiff;
+const qaq = ddAddDd;
+const qmq = ddMultDd;
+const qno = ddNegativeOf;
+const qmn2 = ddMultByNeg2;
+const qm2 = ddMultBy2;
+const qdd = ddDiffDouble;
+
+
+/**
+ * Returns the polynomial coefficients used to recover ray parameter values `t`
+ * for a ray `q(t) = p + t⋅v` and an order-1 bezier curve `ps`.
+ *
+ * The returned polynomials encode the medial-condition equations in `s` and
+ * `t`. For any valid solution, `t` is recovered by eliminating `s` and solving
+ * the resulting ray equation, or equivalently by using the linear form
+ * `A(s)⋅t + B(s) = 0`, which gives `t = -B(s)/A(s)`.
+ *
+ * More specifically, the returned values represent:
+ * * `A` and `B`: the coefficients of `E2(s,t) = A(s)⋅t + B(s)`
+ * * `C` and `D`: the coefficients of `E1(s,t) = C(s)⋅t + D(s)`
+ * * `H`: the eliminated polynomial `A(s)⋅D(s) - B(s)⋅C(s)` whose roots are
+ *   candidate `s` values for medial points
+ *
+ * @param p base point
+ * @param v ray direction vector starting from `p`
+ * @param ps order 1 bezier control points, i.e. a line segment
+ * given as an array of control points, e.g. `[[0,0],[2,1]]`
+ */
+function ddGetMedialPointCoeffsBez1(
+        p: number[][],
+        v: number[][],
+        ps: number[][]) {
+
+    // -----------------------------------------------------
+    // See get-medial-points.md for implementation details.
+    // -----------------------------------------------------
+    const [px, py] = p;
+    const [vx, vy] = v;
+    const [[x0, y0], [x1, y1]] = ps;
+
+    // Linear bezier in power basis: b(s) = b*s + c
+    // We can also use: `const [[bx,by], [cx,cy]] = toPowerBasis1(ps)`
+    // const bx = x1 - x0;
+    // const by = y1 - y0;
+    const bx = td(x1,x0);
+    const by = td(y1,y0);
+
+    // u(s) = p - b(s) = u1*s + u0
+    // const u0x = px - x0;
+    // const u0y = py - y0;
+    const u0x = qdd(px,x0);
+    const u0y = qdd(py,y0);
+
+    // b'(s) = w(s) = w0
+
+    // -----------------------------------------------------
+    // E1(s,t): (u(s) + t⋅v) ⋅ b'(s) = 0
+    // => C(s)⋅t + D(s) = 0
+    // const c0 = vx*bx + vy*by;
+    const c0 = qaq(qmq(vx,bx),qmq(vy,by));
+    // -----------------------------------------------------
+
+    // -----------------------------------------------------
+    // const d1 = -(bx*bx + by*by);
+    // const d0 = bx*u0x + by*u0y;
+    // const d1 = qmd(-1,qaq(qmq(bx,bx),qmq(by,by)));
+    const d1 = qno(qaq(qmq(bx,bx), qmq(by,by)));
+    const d0 = qaq(qmq(bx,u0x), qmq(by,u0y));
+    // -----------------------------------------------------
+
+    // -----------------------------------------------------
+    // E2(s,t): |t⋅v|² - |u(s) + t⋅v|² = 0
+    //         => 2⋅(v⋅u(s))⋅t + |u(s)|² = 0
+    //         => A(s)⋅t + B(s) = 0
+    // const a1 = -2*c0;
+    // const a0 = 2*(vx*u0x + vy*u0y);
+    const a1 = qmn2(c0);
+    const a0 = qaq(qmq(qm2(vx),u0x), qmq(qm2(vy),u0y));
+    // -----------------------------------------------------
+
+    // -----------------------------------------------------
+    // const b2 = -d1;
+    // const b1 = -2*d0;
+    // const b0 = u0x*u0x + u0y*u0y;
+    const b2 = qno(d1);
+    const b1 = qmn2(d0);
+    const b0 = qaq(qmq(u0x,u0x), qmq(u0y,u0y));
+    // -----------------------------------------------------
+
+
+    // Eliminate t from:
+    //   A(s)⋅t + B(s) = 0
+    //   C(s)⋅t + D(s) = 0
+    // by taking A(s)⋅D(s) - B(s)⋅C(s) = 0 (degree ≤ 2 in s)
+
+    // const H2 = b2*c0;
+    // const H1 = a0*d1;
+    // const H0 = a0*d0 - b0*c0;
+    const H2 = qmq(b2,c0);
+    const H1 = qmq(a0,d1);
+    const H0 = qaq(qmq(a0,d0), qno(qmq(b0,c0)));
+
+    return {
+        A: [a1, a0],
+        B: [b2, b1, b0],
+        C: [c0],
+        D: [d1, d0],
+        H: [H2, H1, H0]
+    };
+}
+
+
+export { ddGetMedialPointCoeffsBez1 }

package/src/get-medial-points/double-double/dd-get-medial-point-coeffs-bez2-same-curve.ts

@@ -0,0 +1,129 @@
+import { toPowerBasisDd } from 'flo-bezier3';
+import { ddMultDouble2, ddAddDd, ddMultDd, ddNegativeOf, ddMultBy2 } from 'double-double';
+
+const qmd = ddMultDouble2;
+const qaq = ddAddDd;
+const qmq = ddMultDd;
+const qno = ddNegativeOf;
+const qm2 = ddMultBy2;
+
+
+/**
+ * Returns polynomial coefficients for the same-curve quadratic medial-point
+ * case, where `p = b(t)` on the same quadratic bezier `ps` and `v` is normal
+ * to the curve at that parameter `t`.
+ *
+ * The returned coefficients encode:
+ * * `A`, `B`: `E2(s, τ) = (s - t)^2⋅(A(s)⋅τ + B(s))`
+//  * * `C`, `D`: `E1(s, τ) = C(s)⋅τ + D(s)`
+ * * `H`: the reduced eliminant in `s`
+ *
+ * Here `τ` is the ray parameter in `q(τ) = p + τ⋅v`.
+ * For a candidate root `s` of `H`, recover `τ` from
+ * `A(s)⋅τ + B(s) = 0`, i.e. `τ = -B(s)/A(s)` when `A(s) ≠ 0`.
+ *
+ * In this same-curve setup, the full eliminant has the form
+ * `H_full(s) = (s - t)^4*(l1*s + l0)`. This function returns only the reduced
+ * factor `H(s) = l1*s + l0` (the repeated `(s - t)^4` factor is omitted).
+ *
+ * @param t parameter on `ps` where `p = b(t)`
+ * @param v ray direction from `p`; assumed normal to `ps` at `t`
+ * @param ps order 2 bezier control points, e.g. `[[0,0],[1,1],[2,1]]`
+ */
+function ddGetMedialPointCoeffsBez2_SameCurve(
+        t: number,
+        v: number[][],
+        ps: number[][]) {
+
+    // -----------------------------------------------------
+    // See get-medial-points.md for implementation details.
+    // -----------------------------------------------------
+    // Quadratic bezier in power basis: b(s) = a⋅s² + b⋅s + c
+    const [[ax,bx], [ay,by]] = toPowerBasisDd(ps);
+
+    const [vx,vy] = v;
+
+    // Same-curve assumption with explicit parameter `t`:
+    // p = b(t) => u0 = p - c = t*(a*t + b).
+    // const g0x = ax*t + bx;
+    // const g0y = ay*t + by;
+    const g0x = qaq(qmd(t,ax),bx);
+    const g0y = qaq(qmd(t,ay),by);
+
+    // Reuse core quadratic-form terms to reduce repeated multiplications.
+    // const br2 = ax*ax + ay*ay;
+    // const ab = ax*bx + ay*by;
+    // const bb = bx*bx + by*by;
+    // const ag = ax*g0x + ay*g0y;
+    const br2 = qaq(qmq(ax,ax),qmq(ay,ay));
+    const ab = qaq(qmq(ax,bx),qmq(ay,by));
+    const ag = qaq(qmq(ax,g0x),qmq(ay,g0y));
+
+    // -----------------------------------------------------
+    // E1(s,t): (u(s) + t⋅v) ⋅ b'(s) = 0
+    // => C(s)⋅t + D(s) = 0
+    // const c1 = 2*(vx*ax + vy*ay);
+    const c1 = qm2(qaq(qmq(vx,ax),qmq(vy,ay)));
+    // v is normal at parameter t, so C(t) = v⋅w(t) = 0.
+    // Since C(s) = c1*s + c0, enforce c0 = -c1*t exactly.
+    // const c0 = -c1*t;
+
+    // const d3 = -2*br2;
+    // const d2 = -3*ab;
+    // const d1 = 2*t*ag - bb;
+    // p = b(t) => D(t) = u(t)⋅w(t) = 0.
+    // const d0 = -t*(t*(d3*t + d2) + d1);
+    // -----------------------------------------------------
+
+    // -----------------------------------------------------
+    // E2(s,t): |t⋅v|² - |u(s) + t⋅v|² = 0
+    //         => 2⋅(v⋅u(s))⋅t + |u(s)|² = 0
+    //         => (s - t)^2⋅(A(s)⋅t + B(s)) = 0
+    // Return only the reduced constant A(s) = ar0.
+    // const ar0 = -c1;
+    const ar0 = qno(c1);
+
+    // Full B(s) factorizes as: B_full(s) = (s - t)^2*B_reduced(s).
+    // Return only B_reduced(s) = br2*s^2 + br1*s + br0.
+    // const br1 = 2*ag;
+    // const br0 = g0x*g0x + g0y*g0y;
+    const br1 = qm2(ag);
+    const br0 = qaq(qmq(g0x,g0x),qmq(g0y,g0y));
+    // -----------------------------------------------------
+
+
+    // Eliminate t from:
+    //   A(s)⋅t + B(s) = 0
+    //   C(s)⋅t + D(s) = 0
+    // by taking A(s)⋅D(s) - B(s)⋅C(s) = 0 (degree ≤ 5 in s)
+
+    // For this same-curve quadratic case:
+    //   d3 = -2*b4, d2 = -(3/2)*b3, a2 = -c1, a1 = -2*c0.
+    // Therefore H5 and H4 reduce to:
+    //   H5 = b4*c1
+    //   H4 = 3*b4*c0 + (1/2)*b3*c1
+    // const H5 = br2*c1;
+    const H5 = qmq(br2,c1);
+
+    // In the same-curve quadratic case the full eliminant has the form
+    // H_full(s) = (s - t)^4*(l1*s + l0).
+    // Match the leading coefficients of H_full(s):
+    //   H5 = l1
+    //   H4 = l0 - 4*t*l1
+    // const l1 = H5;
+    // const l0 = H4 + 4*t*l1;
+    // Using c0 = -c1*t and b3 = 2*ab, this simplifies to l0 = c1*(br2*t + ab).
+    // const l0 = c1*(br2*t + ab);
+    const l0 = qmq(c1,qaq(qmd(t,br2),ab));
+
+    return {
+        A: [ar0],
+        B: [br2, br1, br0],
+        // C: [c1, c0],
+        // D: [d3, d2, d1, d0],
+        H: [H5, l0]
+    };
+}
+
+
+export { ddGetMedialPointCoeffsBez2_SameCurve }

package/src/get-medial-points/double-double/dd-get-medial-point-coeffs-bez2.ts

@@ -0,0 +1,142 @@
+import { toPowerBasisDd } from 'flo-bezier3';
+import { ddMultDouble2, ddAddDd, ddMultDd, ddNegativeOf, ddMultByNeg2, ddMultBy2, ddDiffDouble } from 'double-double';
+
+const qmd = ddMultDouble2;
+const qaq = ddAddDd;
+const qmq = ddMultDd;
+const qno = ddNegativeOf;
+const qmn2 = ddMultByNeg2;
+const qm2 = ddMultBy2;
+const qdd = ddDiffDouble;
+
+
+/**
+ * Returns the polynomial coefficients for the ray parameter `t` and the
+ * curve parameter `s` that encode the medial condition for `q(t) = p + t⋅v`
+ * and a quadratic bezier curve `ps`.
+ *
+ * The returned coefficients describe the equations whose common solutions
+ * satisfy:
+ * * `q(t)` is equidistant from `p` and the nearest point on `ps`
+ * * that common distance is locally minimal among such candidates
+ *
+ * More specifically, this function returns:
+ * * `A` and `B`: the coefficients of `E2(s,t) = A(s)⋅t + B(s)`
+ * * `C` and `D`: the coefficients of `E1(s,t) = C(s)⋅t + D(s)`
+ * * `H`: the eliminated polynomial `A(s)⋅D(s) - B(s)⋅C(s)` whose roots are
+ *   candidate `s` values for medial points
+ *
+ * @param p base point
+ * @param v ray direction from `p`
+ * @param ps quadratic bezier control points, i.e. an order 2 bezier curve
+ * given as an array of control points, e.g. `[[0,0],[1,1],[2,1]]`
+ */
+function ddGetMedialPointCoeffsBez2(
+        p: number[][],
+        v: number[][],
+        ps: number[][]) {
+
+    // -----------------------------------------------------
+    // See get-medial-points.md for implementation details.
+    // -----------------------------------------------------
+    const [px, py] = p;
+    const [vx, vy] = v;
+    const [[x0, y0]] = ps;
+
+    // Quadratic bezier in power basis: b(s) = a⋅s² + b⋅s + c
+    const [[ax, bx], [ay, by]] = toPowerBasisDd(ps);
+
+    // u(s) = p - b(s) = u2⋅s² + u1⋅s + u0
+    // const u0x = px - x0;
+    // const u0y = py - y0;
+    const u0x = qdd(px,x0);
+    const u0y = qdd(py,y0);
+
+    // Shared dot products.
+    // const c1 = 2*(vx*ax + vy*ay);
+    // const c0 = vx*bx + vy*by;
+    // const vu0 = vx*u0x + vy*u0y;
+    // const b4 = ax*ax + ay*ay;
+    // const ab = ax*bx + ay*by;
+    // const bb = bx*bx + by*by;
+    // const u0a = u0x*ax + u0y*ay;
+    // const d0 = u0x*bx + u0y*by;
+    // const b0 = u0x*u0x + u0y*u0y;
+    const c1 = qm2(qaq(qmq(vx,ax),qmq(vy,ay)));
+    const c0 = qaq(qmq(vx,bx),qmq(vy,by));
+    const vu0 = qaq(qmq(vx,u0x),qmq(vy,u0y));
+    const b4 = qaq(qmq(ax,ax),qmq(ay,ay));
+    const ab = qaq(qmq(bx,ax),qmq(by,ay));
+    const bb = qaq(qmq(bx,bx),qmq(by,by));
+    const u0a = qaq(qmq(u0x,ax),qmq(u0y,ay));
+    const d0 = qaq(qmq(bx,u0x),qmq(by,u0y));
+    const b0 = qaq(qmq(u0x,u0x),qmq(u0y,u0y));
+
+    // -----------------------------------------------------
+    // E1(s,t): (u(s) + t⋅v) ⋅ b'(s) = 0
+    // => C(s)⋅t + D(s) = 0
+    // -----------------------------------------------------
+
+    // -----------------------------------------------------
+    // const d3 = -2*b4;
+    // const d2 = -3*ab;
+    // const d1 = 2*u0a - bb;
+    const d3 = qmn2(b4);
+    const d2 = qmd(-3,ab);
+    const d1 = qaq(qm2(u0a),qno(bb));
+    // -----------------------------------------------------
+
+    // -----------------------------------------------------
+    // E2(s,t): |t⋅v|² - |u(s) + t⋅v|² = 0
+    //         => 2⋅(v⋅u(s))⋅t + |u(s)|² = 0
+    //         => A(s)⋅t + B(s) = 0
+    // const a2 = -c1;
+    // const a1 = -2*c0;
+    // const a0 = 2*vu0;
+    const a2 = qno(c1);
+    const a1 = qmn2(c0);
+    const a0 = qm2(vu0);
+    // -----------------------------------------------------
+
+    // -----------------------------------------------------
+    // const b3 = 2*ab;
+    // const b2 = -d1;
+    // const b1 = -2*d0;
+    const b3 = qm2(ab);
+    const b2 = qno(d1);
+    const b1 = qmn2(d0);
+    // -----------------------------------------------------
+
+
+    // Eliminate t from:
+    //   A(s)⋅t + B(s) = 0
+    //   C(s)⋅t + D(s) = 0
+    // by taking A(s)⋅D(s) - B(s)⋅C(s) = 0 (degree ≤ 5 in s)
+
+    // Using:
+    //   a2 = -c1, d3 = -2*b4, d1 = -b2, b1 = -2*d0
+    // we can compute H = A⋅D - B⋅C directly.
+    // const H5 = b4*c1;
+    // const H4 = ab*c1 + 3*b4*c0;
+    // const H3 = 4*(ab*c0 - vu0*b4);
+    // const H2 = c1*d0 + c0*b2 - 6*vu0*ab;
+    // const H1 = -2*vu0*b2 - c1*b0;
+    // const H0 = 2*vu0*d0 - c0*b0;
+    const H5 = qmq(b4,c1);
+    const H4 = qaq(qmq(ab,c1),qmd(3,qmq(b4,c0)));
+    const H3 = qm2(qm2(qaq(qmq(ab,c0),qno(qmq(vu0,b4)))));
+    const H2 = qaq(qaq(qmq(c1,d0),qmq(c0,b2)),qno(qmd(6,qmq(vu0,ab))));
+    const H1 = qaq(qmn2(qmq(vu0,b2)),qno(qmq(c1,b0)));
+    const H0 = qaq(qm2(qmq(vu0,d0)),qno(qmq(c0,b0)));
+
+    return {
+        A: [a2, a1, a0],
+        B: [b4, b3, b2, b1, b0],
+        C: [c1, c0],
+        D: [d3, d2, d1, d0],
+        H: [H5, H4, H3, H2, H1, H0]
+    };
+}
+
+
+export { ddGetMedialPointCoeffsBez2 }

package/src/get-medial-points/double-double/dd-get-medial-point-coeffs-bez3-same-curve.ts

@@ -0,0 +1,199 @@
+import { toPowerBasisDd } from 'flo-bezier3';
+import { ddMultDouble2, ddAddDd, ddMultDd, ddNegativeOf, ddMultByNeg2, ddMultBy2 } from 'double-double';
+
+const qmd = ddMultDouble2;
+const qaq = ddAddDd;
+const qmq = ddMultDd;
+const qno = ddNegativeOf;
+const qmn2 = ddMultByNeg2;
+const qm2 = ddMultBy2;
+
+
+/**
+ * Returns polynomial coefficients for the same-curve cubic medial-point case,
+ * where `p = b(t)` on the same cubic bezier `ps` and `v` is normal to the
+ * curve at that parameter `t`.
+ *
+ * The returned coefficients encode:
+ * * `A`, `B`: `E2(s, τ) = (s - t)^2⋅(A(s)⋅τ + B(s))`
+ * * `C`, `D`: `E1(s, τ) = (s - t)⋅(C(s)⋅τ + D(s))`
+ * * `H`: the reduced eliminant in `s`
+ *
+ * Here `τ` is the ray parameter in `q(τ) = p + τ⋅v`.
+ * For a candidate root `s` of `H`, recover `τ` from `A(s)⋅τ + B(s) = 0`, i.e.
+ * `τ = -B(s)/A(s)` when `A(s) ≠ 0`.
+ *
+ * In this same-curve setup, the full eliminant has the form
+ * `H_full(s) = (s - t)^4*H(s)`. This function returns only the reduced factor
+ * `H(s)` (the repeated `(s - t)^4` factor is omitted).
+ *
+ * @param t parameter on `ps` where `p = b(t)`
+ * @param v ray direction from `p`; assumed normal to `ps` at `t`
+ * @param ps order 3 bezier control points, e.g. `[[0,0],[1,1],[2,1],[3,0]]`
+ */
+function ddGetMedialPointCoeffsBez3_SameCurve(
+        t: number,
+        v: number[][],
+        ps: number[][]) {
+
+    // -----------------------------------------------------
+    // See get-medial-points.md for implementation details.
+    // -----------------------------------------------------
+    const [vx, vy] = v;
+    // Cubic bezier in power basis: b(s) = a*s^3 + b*s^2 + c*s + d
+    const [[ax, bx, cx], [ay, by, cy]] = toPowerBasisDd(ps);
+
+    // Shared dot products to reduce repeated multiplications.
+    // const va = vx*ax + vy*ay;
+    // const vb = vx*bx + vy*by;
+    // const vc = vx*cx + vy*cy;
+    // const aa = ax*ax + ay*ay;
+    // const ab = ax*bx + ay*by;
+    // const ac = ax*cx + ay*cy;
+    // const bb = bx*bx + by*by;
+    // const bc = bx*cx + by*cy;
+    // const cc = cx*cx + cy*cy;
+    // const vu0 = t*(t*(t*va + vb) + vc);
+    // const u0a = t*(t*(t*aa + ab) + ac);
+    // const u0b = t*(t*(t*ab + bb) + bc);
+    const va = qaq(qmq(vx,ax),qmq(vy,ay));
+    const vb = qaq(qmq(vx,bx),qmq(vy,by));
+    const vc = qaq(qmq(vx,cx),qmq(vy,cy));
+    const aa = qaq(qmq(ax,ax),qmq(ay,ay));
+    const ab = qaq(qmq(ax,bx),qmq(ay,by));
+    const ac = qaq(qmq(ax,cx),qmq(ay,cy));
+    const bb = qaq(qmq(bx,bx),qmq(by,by));
+    const bc = qaq(qmq(bx,cx),qmq(by,cy));
+    const cc = qaq(qmq(cx,cx),qmq(cy,cy));
+    const vu0 = qmd(t,qaq(qmd(t,qaq(qmd(t,va),vb)),vc));
+    const u0a = qmd(t,qaq(qmd(t,qaq(qmd(t,aa),ab)),ac));
+    const u0b = qmd(t,qaq(qmd(t,qaq(qmd(t,ab),bb)),bc));
+
+    // -----------------------------------------------------
+    // E1(s,t): (u(s) + t*v) * b'(s) = 0
+    // => C(s)*t + D(s) = 0
+    // const c2 = 3*va;
+    // const c1 = 2*vb;
+    const c2 = qmd(3,va);
+    const c1 = qm2(vb);
+    // v is normal at parameter t, so C(t) = 0.
+    // const c0 = -t*(c2*t + c1);
+
+    // Return reduced C such that C_full(s) = (s - t)*C(s).
+    // const cr0 = c1 + t*c2;
+    const cr0 = qaq(c1,qmd(t,c2));
+    // -----------------------------------------------------
+
+    // -----------------------------------------------------
+    // const d5 = -3*aa;
+    // const d4 = -5*ab;
+    // const d3 = -4*ac - 2*bb;
+    // const d2 = -3*bc + 3*u0a;
+    // const d1 = -cc + 2*u0b;
+    const d5 = qmd(-3,aa);
+    const d4 = qmd(-5,ab);
+    const d3 = qaq(qmd(-4,ac),qmn2(bb));
+    const d2 = qaq(qmd(-3,bc),qmd(3,u0a));
+    const d1 = qaq(qno(cc),qm2(u0b));
+    // p = b(t) => D(t) = u(t)⋅w(t) = 0.
+
+    // Return reduced D such that D_full(s) = (s - t)*D(s).
+    const dr4 = d5;
+    // const dr3 = d4 + t*dr4;
+    // const dr2 = d3 + t*dr3;
+    // const dr1 = d2 + t*dr2;
+    // const dr0 = d1 + t*dr1;
+    const dr3 = qaq(d4,qmd(t,dr4));
+    const dr2 = qaq(d3,qmd(t,dr3));
+    const dr1 = qaq(d2,qmd(t,dr2));
+    const dr0 = qaq(d1,qmd(t,dr1));
+    // -----------------------------------------------------
+
+    // -----------------------------------------------------
+    // E2(s,t): |t*v|^2 - |u(s) + t*v|^2 = 0
+    //         => 2*(v*u(s))*t + |u(s)|^2 = 0
+    //         => A(s)*t + B(s) = 0
+    // A'(s) = -2*C(s) identically for bezier curves, hence:
+    // const a3 = -2*va;
+    // const a2 = -2*vb;
+    const a3 = qmn2(va);
+    const a2 = qmn2(vb);
+    // const a1 = -2*vc;
+    // p = b(t) => A(t) = 0.
+    // const a0 = 2*vu0;
+    // -----------------------------------------------------
+
+    // -----------------------------------------------------
+    const b6 = aa;
+    // const b5 = 2*ab;
+    // const b4 = 2*ac + bb;
+    // const b3 = 2*bc - 2*u0a;
+    // const b2 = cc - 2*u0b;
+    const b5 = qm2(ab);
+    const b4 = qaq(qm2(ac),bb);
+    const b3 = qaq(qm2(bc),qmn2(u0a));
+    const b2 = qaq(cc,qmn2(u0b));
+    // -----------------------------------------------------
+
+    // -----------------------------------------------------
+    // Return reduced A and B such that:
+    //   A_full(s) = (s - t)^2*A(s)
+    //   B_full(s) = (s - t)^2*B(s)
+    // where A is degree 1 and B is degree 4.
+    const ar1 = a3;
+    // const ar0 = a2 + 2*t*ar1;
+    const ar0 = qaq(a2,qm2(qmd(t,ar1)));
+
+    const br4 = b6;
+    // const br3 = b5 + 2*t*br4;
+    // const br2 = b4 + t*(2*br3 - t*br4);
+    // const br1 = b3 + t*(2*br2 - t*br3);
+    // const br0 = b2 + t*(2*br1 - t*br2);
+    const br3 = qaq(b5,qm2(qmd(t,br4)));
+    const br2 = qaq(b4,qmd(t,qaq(qm2(br3),qno(qmd(t,br4)))));
+    const br1 = qaq(b3,qmd(t,qaq(qm2(br2),qno(qmd(t,br3)))));
+    const br0 = qaq(b2,qmd(t,qaq(qm2(br1),qno(qmd(t,br2)))));
+    // -----------------------------------------------------
+
+
+    // Eliminate t from:
+    //   A(s)*t + B(s) = 0
+    //   C(s)*t + D(s) = 0
+    // by taking A(s)*D(s) - B(s)*C(s) = 0 (degree <= 8 in s)
+
+    // H8 = a3*d5 - b6*c2 = (-2*va)*(-3*aa) - aa*(3*va) = 3*va*aa.
+    // const H8 = 3*va*aa;
+    // const H7 = 4*(va*ab + vb*aa);
+    // const H6 = va*b4 + 6*vb*ab + 5*vc*aa;
+    // const H5 = 2*vb*b4 + 8*vc*ab - 6*vu0*aa;
+    // const H4 = -va*b2 + vb*b3 + 3*vc*b4 - 10*vu0*ab;
+    const H8 = qmd(3,qmq(va,aa));
+    const H7 = qm2(qm2(qaq(qmq(va,ab),qmq(vb,aa))));
+    const H6 = qaq(qaq(qmq(va,b4),qmd(6,qmq(vb,ab))),qmd(5,qmq(vc,aa)));
+    const H5 = qaq(qaq(qm2(qmq(vb,b4)),qmd(8,qmq(vc,ab))),qno(qmd(6,qmq(vu0,aa))));
+    const H4 = qaq(qaq(qno(qmq(va,b2)),qmq(vb,b3)),qaq(qmd(3,qmq(vc,b4)),qno(qmd(10,qmq(vu0,ab)))));
+
+    // Reduce H_full(s) by its guaranteed (s - t)^4 factor:
+    // H_full(s) = (s - t)^4*(q4*s^4 + q3*s^3 + q2*s^2 + q1*s + q0)
+    // Match the high-order coefficients of H_full(s) explicitly.
+    const q4 = H8;
+    // const q3 = H7 + 4*t*q4;
+    // const q2 = H6 + t*(4*q3 - 6*t*q4);
+    // const q1 = H5 + t*(4*q2 + t*(-6*q3 + 4*t*q4));
+    // const q0 = H4 + t*(4*q1 + t*(-6*q2 + t*(4*q3 - t*q4)));
+    const q3 = qaq(H7,qm2(qm2(qmd(t,q4))));
+    const q2 = qaq(H6,qmd(t,qaq(qm2(qm2(q3)),qno(qmd(6,qmd(t,q4))))));
+    const q1 = qaq(H5,qmd(t,qaq(qm2(qm2(q2)),qmd(t,qaq(qmd(-6,q3),qm2(qm2(qmd(t,q4))))))));
+    const q0 = qaq(H4,qmd(t,qaq(qm2(qm2(q1)),qmd(t,qaq(qmd(-6,q2),qmd(t,qaq(qm2(qm2(q3)),qno(qmd(t,q4)))))))));
+
+    return {
+        A: [ar1, ar0],
+        B: [br4, br3, br2, br1, br0],
+        C: [c2, cr0],
+        D: [dr4, dr3, dr2, dr1, dr0],
+        H: [q4, q3, q2, q1, q0]
+    };
+}
+
+
+export { ddGetMedialPointCoeffsBez3_SameCurve }