@srsergio/taptapp-ar 1.1.1 → 1.1.3

package/dist/core/estimation/morph-refinement.js

@@ -1,116 +1 @@
-/**
- * Morphological Refinement - "Active Edge Alignment"
- *
- * This Moonshot algorithm snaps the projected target to the real image edges.
- * It solves the "Small Box / Drift" problem by maximizing alignment with
- * local image gradients using a Spring-Mass optimization system.
- */
-import { Matrix, SingularValueDecomposition } from "ml-matrix";
-export function refineWithMorphology({ imageData, width, height, targetData, initialH, iterations = 3 }) {
-    let currentH = [...initialH];
-    // 1. Boundary Points (The "Anchors" of our elastic malla)
-    const boundaryPoints = [];
-    const step = 0.05;
-    for (let i = 0; i <= 1.0; i += step) {
-        boundaryPoints.push({ x: i * targetData.w, y: 0 });
-        boundaryPoints.push({ x: i * targetData.w, y: targetData.h });
-        boundaryPoints.push({ x: 0, y: i * targetData.h });
-        boundaryPoints.push({ x: targetData.w, y: i * targetData.h });
-    }
-    for (let iter = 0; iter < iterations; iter++) {
-        const correspondences = [];
-        for (const pt of boundaryPoints) {
-            // Project
-            const w = currentH[6] * pt.x + currentH[7] * pt.y + currentH[8];
-            const sx = (currentH[0] * pt.x + currentH[1] * pt.y + currentH[2]) / w;
-            const sy = (currentH[3] * pt.x + currentH[4] * pt.y + currentH[5]) / w;
-            if (sx < 2 || sx >= width - 2 || sy < 2 || sy >= height - 2)
-                continue;
-            // 2. Local Gradient Search (The "Pull" of the image)
-            const searchDist = 10;
-            let bestX = sx;
-            let bestY = sy;
-            let maxGrad = -1;
-            for (let dy = -searchDist; dy <= searchDist; dy += 2) {
-                for (let dx = -searchDist; dx <= searchDist; dx += 2) {
-                    const nx = Math.floor(sx + dx);
-                    const ny = Math.floor(sy + dy);
-                    const idx = ny * width + nx;
-                    // Sobel-like gradient magnitude
-                    const gx = imageData[idx + 1] - imageData[idx - 1];
-                    const gy = imageData[idx + width] - imageData[idx - width];
-                    const grad = gx * gx + gy * gy;
-                    if (grad > maxGrad) {
-                        maxGrad = grad;
-                        bestX = nx;
-                        bestY = ny;
-                    }
-                }
-            }
-            if (maxGrad > 500) {
-                correspondences.push({
-                    src: pt,
-                    dst: { x: bestX, y: bestY },
-                    weight: Math.min(1.0, maxGrad / 15000)
-                });
-            }
-        }
-        if (correspondences.length < 10)
-            break;
-        // 3. Solve for best Homography using SVD
-        const nextH = solveDLTWeight(correspondences);
-        if (nextH) {
-            // Soft-Update (Momentum)
-            for (let i = 0; i < 9; i++) {
-                currentH[i] = currentH[i] * 0.5 + nextH[i] * 0.5;
-            }
-        }
-    }
-    return currentH;
-}
-/**
- * Direct Linear Transform with Weights
- */
-function solveDLTWeight(pairs) {
-    const n = pairs.length;
-    const A = new Matrix(n * 2, 9);
-    for (let i = 0; i < n; i++) {
-        const { src, dst, weight: w } = pairs[i];
-        const x = src.x;
-        const y = src.y;
-        const xp = dst.x;
-        const yp = dst.y;
-        // Row 1
-        A.set(i * 2, 0, 0);
-        A.set(i * 2, 1, 0);
-        A.set(i * 2, 2, 0);
-        A.set(i * 2, 3, -x * w);
-        A.set(i * 2, 4, -y * w);
-        A.set(i * 2, 5, -w);
-        A.set(i * 2, 6, yp * x * w);
-        A.set(i * 2, 7, yp * y * w);
-        A.set(i * 2, 8, yp * w);
-        // Row 2
-        A.set(i * 2 + 1, 0, x * w);
-        A.set(i * 2 + 1, 1, y * w);
-        A.set(i * 2 + 1, 2, w);
-        A.set(i * 2 + 1, 3, 0);
-        A.set(i * 2 + 1, 4, 0);
-        A.set(i * 2 + 1, 5, 0);
-        A.set(i * 2 + 1, 6, -xp * x * w);
-        A.set(i * 2 + 1, 7, -xp * y * w);
-        A.set(i * 2 + 1, 8, -xp * w);
-    }
-    try {
-        const svd = new SingularValueDecomposition(A);
-        const V = svd.rightSingularVectors;
-        // Last column of V is the solution
-        const h = V.getColumn(8);
-        // Normalize H[8] to 1
-        const scale = 1.0 / h[8];
-        return h.map(v => v * scale);
-    }
-    catch (e) {
-        return null;
-    }
-}
+import{Matrix as t,SingularValueDecomposition as e}from"ml-matrix";export function refineWithMorphology({imageData:t,width:e,height:o,targetData:n,initialH:r,iterations:i=3}){let h=[...r];const l=[];for(let t=0;t<=1;t+=.05)l.push({x:t*n.w,y:0}),l.push({x:t*n.w,y:n.h}),l.push({x:0,y:t*n.h}),l.push({x:n.w,y:t*n.h});for(let n=0;n<i;n++){const n=[];for(const s of l){const r=h[6]*s.x+h[7]*s.y+h[8],i=(h[0]*s.x+h[1]*s.y+h[2])/r,l=(h[3]*s.x+h[4]*s.y+h[5])/r;if(i<2||i>=e-2||l<2||l>=o-2)continue;const c=10;let f=i,a=l,u=-1;for(let s=-c;s<=c;s+=2)for(let o=-c;o<=c;o+=2){const n=Math.floor(i+o),r=Math.floor(l+s),h=r*e+n,c=t[h+1]-t[h-1],x=t[h+e]-t[h-e],y=c*c+x*x;y>u&&(u=y,f=n,a=r)}u>500&&n.push({src:s,dst:{x:f,y:a},weight:Math.min(1,u/15e3)})}if(n.length<10)break;const r=s(n);if(r)for(let t=0;t<9;t++)h[t]=.5*h[t]+.5*r[t]}return h}function s(s){const o=s.length,n=new t(2*o,9);for(let t=0;t<o;t++){const{src:e,dst:o,weight:r}=s[t],i=e.x,h=e.y,l=o.x,c=o.y;n.set(2*t,0,0),n.set(2*t,1,0),n.set(2*t,2,0),n.set(2*t,3,-i*r),n.set(2*t,4,-h*r),n.set(2*t,5,-r),n.set(2*t,6,c*i*r),n.set(2*t,7,c*h*r),n.set(2*t,8,c*r),n.set(2*t+1,0,i*r),n.set(2*t+1,1,h*r),n.set(2*t+1,2,r),n.set(2*t+1,3,0),n.set(2*t+1,4,0),n.set(2*t+1,5,0),n.set(2*t+1,6,-l*i*r),n.set(2*t+1,7,-l*h*r),n.set(2*t+1,8,-l*r)}try{const t=new e(n).rightSingularVectors.getColumn(8),s=1/t[8];return t.map(t=>t*s)}catch(t){return null}}

package/dist/core/estimation/non-rigid-refine.js

@@ -1,70 +1 @@
-/**
- * 🚀 Moonshot: Non-Rigid Surface Refinement (Mass-Spring System)
- *
- * Instead of a single homography, we relax a triangle mesh to match tracked points
- * while preserving edge lengths (Isometric constraint).
- */
-export function refineNonRigid({ mesh, trackedPoints, currentVertices, iterations = 5 }) {
-    const { e: edges, rl: restLengths } = mesh;
-    const numVertices = currentVertices.length / 2;
-    const vertices = new Float32Array(currentVertices); // copy
-    // lambda for stiffness
-    const stiffness = 0.8;
-    const dataFidelity = 0.5;
-    for (let iter = 0; iter < iterations; iter++) {
-        // 1. Edge Length Constraints (Isometric term)
-        for (let i = 0; i < restLengths.length; i++) {
-            const idx1 = edges[i * 2];
-            const idx2 = edges[i * 2 + 1];
-            const restL = restLengths[i];
-            const vx1 = vertices[idx1 * 2];
-            const vy1 = vertices[idx1 * 2 + 1];
-            const vx2 = vertices[idx2 * 2];
-            const vy2 = vertices[idx2 * 2 + 1];
-            const dx = vx2 - vx1;
-            const dy = vy2 - vy1;
-            const currentL = Math.sqrt(dx * dx + dy * dy);
-            if (currentL < 0.0001)
-                continue;
-            const diff = (currentL - restL) / currentL;
-            const moveX = dx * 0.5 * diff * stiffness;
-            const moveY = dy * 0.5 * diff * stiffness;
-            vertices[idx1 * 2] += moveX;
-            vertices[idx1 * 2 + 1] += moveY;
-            vertices[idx2 * 2] -= moveX;
-            vertices[idx2 * 2 + 1] -= moveY;
-        }
-        // 2. Data Fidelity Constraints (Alignment with NCC tracker)
-        for (const tp of trackedPoints) {
-            const idx = tp.meshIndex;
-            if (idx === undefined)
-                continue;
-            const targetX = tp.x;
-            const targetY = tp.y;
-            vertices[idx * 2] += (targetX - vertices[idx * 2]) * dataFidelity;
-            vertices[idx * 2 + 1] += (targetY - vertices[idx * 2 + 1]) * dataFidelity;
-        }
-    }
-    return vertices;
-}
-/**
- * Maps a mesh from reference space to screen space using a homography
- */
-export function projectMesh(mesh, homography, width, height) {
-    const { px, py } = mesh; // original octave points used as mesh vertices
-    const numVertices = px.length;
-    const projected = new Float32Array(numVertices * 2);
-    const h = homography;
-    const h00 = h[0][0], h01 = h[0][1], h02 = h[0][3];
-    const h10 = h[1][0], h11 = h[1][1], h12 = h[1][3];
-    const h20 = h[2][0], h21 = h[2][1], h22 = h[2][3];
-    for (let i = 0; i < numVertices; i++) {
-        const x = px[i];
-        const y = py[i];
-        const uz = (x * h20) + (y * h21) + h22;
-        const invZ = 1.0 / uz;
-        projected[i * 2] = ((x * h00) + (y * h01) + h02) * invZ;
-        projected[i * 2 + 1] = ((x * h10) + (y * h11) + h12) * invZ;
-    }
-    return projected;
-}
+export function refineNonRigid({mesh:t,trackedPoints:n,currentVertices:e,iterations:o=5}){const{e:r,rl:c}=t,s=(e.length,new Float32Array(e));for(let t=0;t<o;t++){for(let t=0;t<c.length;t++){const n=r[2*t],e=r[2*t+1],o=c[t],i=s[2*n],f=s[2*n+1],l=s[2*e]-i,a=s[2*e+1]-f,h=Math.sqrt(l*l+a*a);if(h<1e-4)continue;const u=(h-o)/h,p=.5*l*u*.8,x=.5*a*u*.8;s[2*n]+=p,s[2*n+1]+=x,s[2*e]-=p,s[2*e+1]-=x}for(const t of n){const n=t.meshIndex;if(void 0===n)continue;const e=t.x,o=t.y;s[2*n]+=.5*(e-s[2*n]),s[2*n+1]+=.5*(o-s[2*n+1])}}return s}export function projectMesh(t,n,e,o){const{px:r,py:c}=t,s=r.length,i=new Float32Array(2*s),f=n,l=f[0][0],a=f[0][1],h=f[0][3],u=f[1][0],p=f[1][1],x=f[1][3],d=f[2][0],g=f[2][1],y=f[2][3];for(let t=0;t<s;t++){const n=r[t],e=c[t],o=1/(n*d+e*g+y);i[2*t]=(n*l+e*a+h)*o,i[2*t+1]=(n*u+e*p+x)*o}return i}

package/dist/core/estimation/pnp-solver.js

@@ -1,109 +1 @@
-/**
- * Direct PnP (Perspective-n-Point) Solver for Planar Targets
- *
- * This Moonshot algorithm ignores octave-relative scales and works
- * purely in Physical World Units. It uses the Camera Matrix (K)
- * to deduce the real-world distance (Z).
- */
-import { Matrix, SingularValueDecomposition } from "ml-matrix";
-export function solvePosePnP({ screenCoords, worldCoords, projectionTransform }) {
-    const K = new Matrix(projectionTransform);
-    const n = screenCoords.length;
-    // 1. Build the DLT matrix for Pose (Directly estimating [R|t])
-    // We assume worldCoords are [X, Y, 0]
-    // Eq: x = K * [R|t] * X
-    // K^-1 * x = [r1 r2 t] * [X Y 1]^T
-    const KI = Inverse3x3(projectionTransform);
-    const A = new Matrix(n * 2, 9);
-    for (let i = 0; i < n; i++) {
-        const sci = screenCoords[i];
-        const wci = worldCoords[i];
-        // Normalized camera coordinates
-        const nx = KI[0] * sci.x + KI[1] * sci.y + KI[2];
-        const ny = KI[3] * sci.x + KI[4] * sci.y + KI[5];
-        const nz = KI[6] * sci.x + KI[7] * sci.y + KI[8];
-        const unx = nx / nz;
-        const uny = ny / nz;
-        // DLT equations for [r11 r12 r21 r22 r31 r32 t1 t2 t3]
-        const X = wci.x;
-        const Y = wci.y;
-        // Row 1: X*r11 + Y*r12 + t1 - unx*(X*r31 + Y*r32 + t3) = 0
-        A.set(i * 2, 0, X);
-        A.set(i * 2, 1, Y);
-        A.set(i * 2, 2, 1);
-        A.set(i * 2, 3, 0);
-        A.set(i * 2, 4, 0);
-        A.set(i * 2, 5, 0);
-        A.set(i * 2, 6, -unx * X);
-        A.set(i * 2, 7, -unx * Y);
-        A.set(i * 2, 8, -unx);
-        // Row 2: X*r21 + Y*r22 + t2 - uny*(X*r31 + Y*r32 + t3) = 0
-        A.set(i * 2 + 1, 0, 0);
-        A.set(i * 2 + 1, 1, 0);
-        A.set(i * 2 + 1, 2, 0);
-        A.set(i * 2 + 1, 3, X);
-        A.set(i * 2 + 1, 4, Y);
-        A.set(i * 2 + 1, 5, 1);
-        A.set(i * 2 + 1, 6, -uny * X);
-        A.set(i * 2 + 1, 7, -uny * Y);
-        A.set(i * 2 + 1, 8, -uny);
-    }
-    // Solve via SVD
-    const svd = new SingularValueDecomposition(A);
-    const V = svd.rightSingularVectors;
-    const sol = V.getColumn(8); // last column
-    // 3. Extract r1, r2 and t from the DLT solution
-    // Standard DLT has an overall sign ambiguity. We force sol[8] (t3) to be positive.
-    if (sol[8] < 0) {
-        for (let i = 0; i < 9; i++)
-            sol[i] = -sol[i];
-    }
-    const r1_raw = [sol[0], sol[3], sol[6]];
-    const r2_raw = [sol[1], sol[4], sol[7]];
-    const t_raw = [sol[2], sol[5], sol[8]];
-    const scale1 = Math.sqrt(r1_raw[0] ** 2 + r1_raw[1] ** 2 + r1_raw[2] ** 2);
-    const scale2 = Math.sqrt(r2_raw[0] ** 2 + r2_raw[1] ** 2 + r2_raw[2] ** 2);
-    const scale = (scale1 + scale2) / 2;
-    // 4. Construct Rotation Matrix and orthogonalize via SVD
-    const R_approx = new Matrix([
-        [r1_raw[0] / scale1, r2_raw[0] / scale2, 0],
-        [r1_raw[1] / scale1, r2_raw[1] / scale2, 0],
-        [r1_raw[2] / scale1, r2_raw[2] / scale2, 0]
-    ]);
-    // R3 = R1 x R2
-    R_approx.set(0, 2, R_approx.get(1, 0) * R_approx.get(2, 1) - R_approx.get(2, 0) * R_approx.get(1, 1));
-    R_approx.set(1, 2, R_approx.get(2, 0) * R_approx.get(0, 1) - R_approx.get(0, 0) * R_approx.get(2, 1));
-    R_approx.set(2, 2, R_approx.get(0, 0) * R_approx.get(1, 1) - R_approx.get(1, 0) * R_approx.get(0, 1));
-    const svdRot = new SingularValueDecomposition(R_approx);
-    const U = svdRot.leftSingularVectors;
-    const Vrot = svdRot.rightSingularVectors;
-    let R = U.mmul(Vrot.transpose());
-    const getDet3 = (m) => {
-        return m.get(0, 0) * (m.get(1, 1) * m.get(2, 2) - m.get(1, 2) * m.get(2, 1)) -
-            m.get(0, 1) * (m.get(1, 0) * m.get(2, 2) - m.get(1, 2) * m.get(2, 0)) +
-            m.get(0, 2) * (m.get(1, 0) * m.get(2, 1) - m.get(1, 1) * m.get(2, 0));
-    };
-    if (getDet3(R) < 0) {
-        const U_mat = U.clone();
-        for (let i = 0; i < 3; i++)
-            U_mat.set(i, 2, -U_mat.get(i, 2));
-        R = U_mat.mmul(Vrot.transpose());
-    }
-    return [
-        [R.get(0, 0), R.get(0, 1), R.get(0, 2), t_raw[0] / scale],
-        [R.get(1, 0), R.get(1, 1), R.get(1, 2), t_raw[1] / scale],
-        [R.get(2, 0), R.get(2, 1), R.get(2, 2), t_raw[2] / scale]
-    ];
-}
-function Inverse3x3(m) {
-    const k00 = m[0][0], k01 = m[0][1], k02 = m[0][2];
-    const k10 = m[1][0], k11 = m[1][1], k12 = m[1][2];
-    const k20 = m[2][0], k21 = m[2][1], k22 = m[2][2];
-    const det = k00 * (k11 * k22 - k21 * k12) - k01 * (k10 * k22 - k12 * k20) + k02 * (k10 * k21 - k11 * k20);
-    const invDet = 1.0 / det;
-    return [
-        (k11 * k22 - k12 * k21) * invDet, (k02 * k21 - k01 * k22) * invDet, (k01 * k12 - k02 * k11) * invDet,
-        (k12 * k20 - k10 * k22) * invDet, (k00 * k22 - k02 * k20) * invDet, (k10 * k02 - k00 * k12) * invDet,
-        (k10 * k21 - k11 * k20) * invDet, (k20 * k01 - k21 * k00) * invDet, (k00 * k11 - k10 * k01) * invDet
-    ];
-}
+import{Matrix as t,SingularValueDecomposition as e}from"ml-matrix";export function solvePosePnP({screenCoords:g,worldCoords:s,projectionTransform:o}){new t(o);const r=g.length,n=function(t){const e=t[0][0],g=t[0][1],s=t[0][2],o=t[1][0],r=t[1][1],n=t[1][2],l=t[2][0],c=t[2][1],i=t[2][2],a=1/(e*(r*i-c*n)-g*(o*i-n*l)+s*(o*c-r*l));return[(r*i-n*c)*a,(s*c-g*i)*a,(g*n-s*r)*a,(n*l-o*i)*a,(e*i-s*l)*a,(o*s-e*n)*a,(o*c-r*l)*a,(l*g-c*e)*a,(e*r-o*g)*a]}(o),l=new t(2*r,9);for(let t=0;t<r;t++){const e=g[t],o=s[t],r=n[0]*e.x+n[1]*e.y+n[2],c=n[3]*e.x+n[4]*e.y+n[5],i=n[6]*e.x+n[7]*e.y+n[8],a=r/i,f=c/i,m=o.x,u=o.y;l.set(2*t,0,m),l.set(2*t,1,u),l.set(2*t,2,1),l.set(2*t,3,0),l.set(2*t,4,0),l.set(2*t,5,0),l.set(2*t,6,-a*m),l.set(2*t,7,-a*u),l.set(2*t,8,-a),l.set(2*t+1,0,0),l.set(2*t+1,1,0),l.set(2*t+1,2,0),l.set(2*t+1,3,m),l.set(2*t+1,4,u),l.set(2*t+1,5,1),l.set(2*t+1,6,-f*m),l.set(2*t+1,7,-f*u),l.set(2*t+1,8,-f)}const c=new e(l).rightSingularVectors.getColumn(8);if(c[8]<0)for(let t=0;t<9;t++)c[t]=-c[t];const i=[c[0],c[3],c[6]],a=[c[1],c[4],c[7]],f=[c[2],c[5],c[8]],m=Math.sqrt(i[0]**2+i[1]**2+i[2]**2),u=Math.sqrt(a[0]**2+a[1]**2+a[2]**2),w=(m+u)/2,x=new t([[i[0]/m,a[0]/u,0],[i[1]/m,a[1]/u,0],[i[2]/m,a[2]/u,0]]);x.set(0,2,x.get(1,0)*x.get(2,1)-x.get(2,0)*x.get(1,1)),x.set(1,2,x.get(2,0)*x.get(0,1)-x.get(0,0)*x.get(2,1)),x.set(2,2,x.get(0,0)*x.get(1,1)-x.get(1,0)*x.get(0,1));const h=new e(x),p=h.leftSingularVectors,y=h.rightSingularVectors;let d=p.mmul(y.transpose());if((C=d).get(0,0)*(C.get(1,1)*C.get(2,2)-C.get(1,2)*C.get(2,1))-C.get(0,1)*(C.get(1,0)*C.get(2,2)-C.get(1,2)*C.get(2,0))+C.get(0,2)*(C.get(1,0)*C.get(2,1)-C.get(1,1)*C.get(2,0))<0){const t=p.clone();for(let e=0;e<3;e++)t.set(e,2,-t.get(e,2));d=t.mmul(y.transpose())}var C;return[[d.get(0,0),d.get(0,1),d.get(0,2),f[0]/w],[d.get(1,0),d.get(1,1),d.get(1,2),f[1]/w],[d.get(2,0),d.get(2,1),d.get(2,2),f[2]/w]]}

package/dist/core/estimation/refine-estimate.js

@@ -1,311 +1 @@
-import { Matrix, inverse } from "ml-matrix";
-import { applyModelViewProjectionTransform, buildModelViewProjectionTransform, computeScreenCoordiate, } from "./utils.js";
-const TRACKING_THRESH = 5.0; // default
-const K2_FACTOR = 4.0; // Question: should it be relative to the size of the screen instead of hardcoded?
-const ICP_MAX_LOOP = 10;
-const ICP_BREAK_LOOP_ERROR_THRESH = 0.1;
-const ICP_BREAK_LOOP_ERROR_RATIO_THRESH = 0.99;
-// some temporary/intermediate variables used later. Declare them beforehand to reduce new object allocations
-let mat = [[], [], []];
-let J_U_Xc = [[], []]; // 2x3
-let J_Xc_S = [[], [], []]; // 3x6
-const refineEstimate = ({ initialModelViewTransform, projectionTransform, worldCoords, screenCoords, stabilities, // Stability-based weighting
- }) => {
-    // Question: shall we normlize the screen coords as well?
-    // Question: do we need to normlize the scale as well, i.e. make coords from -1 to 1
-    //
-    // normalize world coords - reposition them to center of mass
-    //   assume z coordinate is always zero (in our case, the image target is planar with z = 0
-    let dx = 0;
-    let dy = 0;
-    for (let i = 0; i < worldCoords.length; i++) {
-        dx += worldCoords[i].x;
-        dy += worldCoords[i].y;
-    }
-    dx /= worldCoords.length;
-    dy /= worldCoords.length;
-    const normalizedWorldCoords = [];
-    for (let i = 0; i < worldCoords.length; i++) {
-        normalizedWorldCoords.push({
-            x: worldCoords[i].x - dx,
-            y: worldCoords[i].y - dy,
-            z: worldCoords[i].z,
-        });
-    }
-    const diffModelViewTransform = [[], [], []];
-    for (let j = 0; j < 3; j++) {
-        for (let i = 0; i < 3; i++) {
-            diffModelViewTransform[j][i] = initialModelViewTransform[j][i];
-        }
-    }
-    diffModelViewTransform[0][3] =
-        initialModelViewTransform[0][0] * dx +
-            initialModelViewTransform[0][1] * dy +
-            initialModelViewTransform[0][3];
-    diffModelViewTransform[1][3] =
-        initialModelViewTransform[1][0] * dx +
-            initialModelViewTransform[1][1] * dy +
-            initialModelViewTransform[1][3];
-    diffModelViewTransform[2][3] =
-        initialModelViewTransform[2][0] * dx +
-            initialModelViewTransform[2][1] * dy +
-            initialModelViewTransform[2][3];
-    // use iterative closest point algorithm to refine the modelViewTransform
-    const inlierProbs = [1.0, 0.8, 0.6, 0.4, 0.0];
-    let updatedModelViewTransform = diffModelViewTransform; // iteratively update this transform
-    let finalModelViewTransform = null;
-    for (let i = 0; i < inlierProbs.length; i++) {
-        const ret = _doICP({
-            initialModelViewTransform: updatedModelViewTransform,
-            projectionTransform,
-            worldCoords: normalizedWorldCoords,
-            screenCoords,
-            stabilities, // Pass weights to ICP
-            inlierProb: inlierProbs[i],
-        });
-        updatedModelViewTransform = ret.modelViewTransform;
-        //console.log("err", ret.err);
-        if (ret.err < TRACKING_THRESH) {
-            finalModelViewTransform = updatedModelViewTransform;
-            break;
-        }
-    }
-    if (finalModelViewTransform === null)
-        return null;
-    // de-normalize
-    finalModelViewTransform[0][3] =
-        finalModelViewTransform[0][3] -
-            finalModelViewTransform[0][0] * dx -
-            finalModelViewTransform[0][1] * dy;
-    finalModelViewTransform[1][3] =
-        finalModelViewTransform[1][3] -
-            finalModelViewTransform[1][0] * dx -
-            finalModelViewTransform[1][1] * dy;
-    finalModelViewTransform[2][3] =
-        finalModelViewTransform[2][3] -
-            finalModelViewTransform[2][0] * dx -
-            finalModelViewTransform[2][1] * dy;
-    return finalModelViewTransform;
-};
-// ICP iteration
-// Question: can someone provide theoretical reference / mathematical proof for the following computations?
-const _doICP = ({ initialModelViewTransform, projectionTransform, worldCoords, screenCoords, stabilities, inlierProb, }) => {
-    const isRobustMode = inlierProb < 1;
-    let modelViewTransform = initialModelViewTransform;
-    let err0 = 0.0;
-    let err1 = 0.0;
-    let E = new Array(worldCoords.length);
-    let E2 = new Array(worldCoords.length);
-    let dxs = new Array(worldCoords.length);
-    let dys = new Array(worldCoords.length);
-    for (let l = 0; l <= ICP_MAX_LOOP; l++) {
-        const modelViewProjectionTransform = buildModelViewProjectionTransform(projectionTransform, modelViewTransform);
-        for (let n = 0; n < worldCoords.length; n++) {
-            const u = computeScreenCoordiate(modelViewProjectionTransform, worldCoords[n].x, worldCoords[n].y, worldCoords[n].z);
-            const dx = screenCoords[n].x - u.x;
-            const dy = screenCoords[n].y - u.y;
-            dxs[n] = dx;
-            dys[n] = dy;
-            E[n] = dx * dx + dy * dy;
-        }
-        let K2; // robust mode only
-        err1 = 0.0;
-        if (isRobustMode) {
-            const inlierNum = Math.max(3, Math.floor(worldCoords.length * inlierProb) - 1);
-            for (let n = 0; n < worldCoords.length; n++) {
-                E2[n] = E[n];
-            }
-            E2.sort((a, b) => {
-                return a - b;
-            });
-            K2 = Math.max(E2[inlierNum] * K2_FACTOR, 16.0);
-            for (let n = 0; n < worldCoords.length; n++) {
-                if (E2[n] > K2)
-                    err1 += K2 / 6;
-                else
-                    err1 += (K2 / 6.0) * (1.0 - (1.0 - E2[n] / K2) * (1.0 - E2[n] / K2) * (1.0 - E2[n] / K2));
-            }
-        }
-        else {
-            for (let n = 0; n < worldCoords.length; n++) {
-                err1 += E[n];
-            }
-        }
-        err1 /= worldCoords.length;
-        //console.log("icp loop", inlierProb, l, err1);
-        if (err1 < ICP_BREAK_LOOP_ERROR_THRESH)
-            break;
-        //if (l > 0 && err1 < ICP_BREAK_LOOP_ERROR_THRESH2 && err1/err0 > ICP_BREAK_LOOP_ERROR_RATIO_THRESH) break;
-        if (l > 0 && err1 / err0 > ICP_BREAK_LOOP_ERROR_RATIO_THRESH)
-            break;
-        if (l === ICP_MAX_LOOP)
-            break;
-        err0 = err1;
-        const dU = [];
-        const allJ_U_S = [];
-        for (let n = 0; n < worldCoords.length; n++) {
-            if (isRobustMode && E[n] > K2) {
-                continue;
-            }
-            const J_U_S = _getJ_U_S({
-                modelViewProjectionTransform,
-                modelViewTransform,
-                projectionTransform,
-                worldCoord: worldCoords[n],
-            });
-            if (isRobustMode) {
-                const robustW = (1.0 - E[n] / K2) * (1.0 - E[n] / K2);
-                // Log-weighted stability: suppresses vibrators aggressively but allows recovery
-                const s = stabilities ? stabilities[n] : 1.0;
-                const stabilityW = s * Math.log10(9 * s + 1);
-                const W = robustW * stabilityW;
-                for (let j = 0; j < 2; j++) {
-                    for (let i = 0; i < 6; i++) {
-                        J_U_S[j][i] *= W;
-                    }
-                }
-                dU.push([dxs[n] * W]);
-                dU.push([dys[n] * W]);
-            }
-            else {
-                const s = stabilities ? stabilities[n] : 1.0;
-                const W = s * Math.log10(9 * s + 1);
-                for (let j = 0; j < 2; j++) {
-                    for (let i = 0; i < 6; i++) {
-                        J_U_S[j][i] *= W;
-                    }
-                }
-                dU.push([dxs[n] * W]);
-                dU.push([dys[n] * W]);
-            }
-            for (let i = 0; i < J_U_S.length; i++) {
-                allJ_U_S.push(J_U_S[i]);
-            }
-        }
-        const dS = _getDeltaS({ dU, J_U_S: allJ_U_S });
-        if (dS === null)
-            break;
-        modelViewTransform = _updateModelViewTransform({ modelViewTransform, dS });
-    }
-    return { modelViewTransform, err: err1 };
-};
-const _updateModelViewTransform = ({ modelViewTransform, dS }) => {
-    /**
-     * dS has 6 paragrams, first half is rotation, second half is translation
-     * rotation is expressed in angle-axis,
-     *   [S[0], S[1] ,S[2]] is the axis of rotation, and the magnitude is the angle
-     */
-    let ra = dS[0] * dS[0] + dS[1] * dS[1] + dS[2] * dS[2];
-    let q0, q1, q2;
-    if (ra < 0.000001) {
-        q0 = 1.0;
-        q1 = 0.0;
-        q2 = 0.0;
-        ra = 0.0;
-    }
-    else {
-        ra = Math.sqrt(ra);
-        q0 = dS[0] / ra;
-        q1 = dS[1] / ra;
-        q2 = dS[2] / ra;
-    }
-    const cra = Math.cos(ra);
-    const sra = Math.sin(ra);
-    const one_cra = 1.0 - cra;
-    // mat is [R|t], 3D rotation and translation
-    mat[0][0] = q0 * q0 * one_cra + cra;
-    mat[0][1] = q0 * q1 * one_cra - q2 * sra;
-    mat[0][2] = q0 * q2 * one_cra + q1 * sra;
-    mat[0][3] = dS[3];
-    mat[1][0] = q1 * q0 * one_cra + q2 * sra;
-    mat[1][1] = q1 * q1 * one_cra + cra;
-    mat[1][2] = q1 * q2 * one_cra - q0 * sra;
-    mat[1][3] = dS[4];
-    mat[2][0] = q2 * q0 * one_cra - q1 * sra;
-    mat[2][1] = q2 * q1 * one_cra + q0 * sra;
-    mat[2][2] = q2 * q2 * one_cra + cra;
-    mat[2][3] = dS[5];
-    // the updated transform is the original transform x delta transform
-    const mat2 = [[], [], []];
-    for (let j = 0; j < 3; j++) {
-        for (let i = 0; i < 4; i++) {
-            mat2[j][i] =
-                modelViewTransform[j][0] * mat[0][i] +
-                    modelViewTransform[j][1] * mat[1][i] +
-                    modelViewTransform[j][2] * mat[2][i];
-        }
-        mat2[j][3] += modelViewTransform[j][3];
-    }
-    return mat2;
-};
-const _getDeltaS = ({ dU, J_U_S }) => {
-    const J = new Matrix(J_U_S);
-    const U = new Matrix(dU);
-    const JT = J.transpose();
-    const JTJ = JT.mmul(J);
-    const JTU = JT.mmul(U);
-    let JTJInv;
-    try {
-        JTJInv = inverse(JTJ);
-    }
-    catch (e) {
-        return null;
-    }
-    const S = JTJInv.mmul(JTU);
-    return S.to1DArray();
-};
-const _getJ_U_S = ({ modelViewProjectionTransform, modelViewTransform, projectionTransform, worldCoord, }) => {
-    const T = modelViewTransform;
-    const { x, y, z } = worldCoord;
-    const u = applyModelViewProjectionTransform(modelViewProjectionTransform, x, y, z);
-    const z2 = u.z * u.z;
-    // Question: This is the most confusing matrix to me. I've no idea how to derive this.
-    //J_U_Xc[0][0] = (projectionTransform[0][0] * u.z - projectionTransform[2][0] * u.x) / z2;
-    //J_U_Xc[0][1] = (projectionTransform[0][1] * u.z - projectionTransform[2][1] * u.x) / z2;
-    //J_U_Xc[0][2] = (projectionTransform[0][2] * u.z - projectionTransform[2][2] * u.x) / z2;
-    //J_U_Xc[1][0] = (projectionTransform[1][0] * u.z - projectionTransform[2][0] * u.y) / z2;
-    //J_U_Xc[1][1] = (projectionTransform[1][1] * u.z - projectionTransform[2][1] * u.y) / z2;
-    //J_U_Xc[1][2] = (projectionTransform[1][2] * u.z - projectionTransform[2][2] * u.y) / z2;
-    // The above is the original implementation, but simplify to below becuase projetionTransform[2][0] and [2][1] are zero
-    J_U_Xc[0][0] = (projectionTransform[0][0] * u.z) / z2;
-    J_U_Xc[0][1] = (projectionTransform[0][1] * u.z) / z2;
-    J_U_Xc[0][2] = (projectionTransform[0][2] * u.z - projectionTransform[2][2] * u.x) / z2;
-    J_U_Xc[1][0] = (projectionTransform[1][0] * u.z) / z2;
-    J_U_Xc[1][1] = (projectionTransform[1][1] * u.z) / z2;
-    J_U_Xc[1][2] = (projectionTransform[1][2] * u.z - projectionTransform[2][2] * u.y) / z2;
-    /*
-      J_Xc_S should be like this, but z is zero, so we can simplify
-      [T[0][2] * y - T[0][1] * z, T[0][0] * z - T[0][2] * x, T[0][1] * x - T[0][0] * y, T[0][0], T[0][1], T[0][2]],
-      [T[1][2] * y - T[1][1] * z, T[1][0] * z - T[1][2] * x, T[1][1] * x - T[1][0] * y, T[1][0], T[1][1], T[1][2]],
-      [T[2][2] * y - T[2][1] * z, T[2][0] * z - T[2][2] * x, T[2][1] * x - T[2][0] * y, T[2][0], T[2][1], T[2][2]],
-    */
-    J_Xc_S[0][0] = T[0][2] * y;
-    J_Xc_S[0][1] = -T[0][2] * x;
-    J_Xc_S[0][2] = T[0][1] * x - T[0][0] * y;
-    J_Xc_S[0][3] = T[0][0];
-    J_Xc_S[0][4] = T[0][1];
-    J_Xc_S[0][5] = T[0][2];
-    J_Xc_S[1][0] = T[1][2] * y;
-    J_Xc_S[1][1] = -T[1][2] * x;
-    J_Xc_S[1][2] = T[1][1] * x - T[1][0] * y;
-    J_Xc_S[1][3] = T[1][0];
-    J_Xc_S[1][4] = T[1][1];
-    J_Xc_S[1][5] = T[1][2];
-    J_Xc_S[2][0] = T[2][2] * y;
-    J_Xc_S[2][1] = -T[2][2] * x;
-    J_Xc_S[2][2] = T[2][1] * x - T[2][0] * y;
-    J_Xc_S[2][3] = T[2][0];
-    J_Xc_S[2][4] = T[2][1];
-    J_Xc_S[2][5] = T[2][2];
-    const J_U_S = [[], []];
-    for (let j = 0; j < 2; j++) {
-        for (let i = 0; i < 6; i++) {
-            J_U_S[j][i] = 0.0;
-            for (let k = 0; k < 3; k++) {
-                J_U_S[j][i] += J_U_Xc[j][k] * J_Xc_S[k][i];
-            }
-        }
-    }
-    return J_U_S;
-};
-export { refineEstimate };
+import{Matrix as r,inverse as o}from"ml-matrix";import{applyModelViewProjectionTransform as e,buildModelViewProjectionTransform as t,computeScreenCoordiate as l}from"./utils.js";let n=[[],[],[]],s=[[],[]],i=[[],[],[]];const f=({initialModelViewTransform:r,projectionTransform:o,worldCoords:e,screenCoords:t,stabilities:l})=>{let n=0,s=0;for(let r=0;r<e.length;r++)n+=e[r].x,s+=e[r].y;n/=e.length,s/=e.length;const i=[];for(let r=0;r<e.length;r++)i.push({x:e[r].x-n,y:e[r].y-s,z:e[r].z});const f=[[],[],[]];for(let o=0;o<3;o++)for(let e=0;e<3;e++)f[o][e]=r[o][e];f[0][3]=r[0][0]*n+r[0][1]*s+r[0][3],f[1][3]=r[1][0]*n+r[1][1]*s+r[1][3],f[2][3]=r[2][0]*n+r[2][1]*s+r[2][3];const m=[1,.8,.6,.4,0];let c=f,h=null;for(let r=0;r<m.length;r++){const e=a({initialModelViewTransform:c,projectionTransform:o,worldCoords:i,screenCoords:t,stabilities:l,inlierProb:m[r]});if(c=e.modelViewTransform,e.err<5){h=c;break}}return null===h?null:(h[0][3]=h[0][3]-h[0][0]*n-h[0][1]*s,h[1][3]=h[1][3]-h[1][0]*n-h[1][1]*s,h[2][3]=h[2][3]-h[2][0]*n-h[2][1]*s,h)},a=({initialModelViewTransform:r,projectionTransform:o,worldCoords:e,screenCoords:n,stabilities:s,inlierProb:i})=>{const f=i<1;let a=r,d=0,u=0,w=new Array(e.length),g=new Array(e.length),T=new Array(e.length),p=new Array(e.length);for(let r=0;r<=10;r++){const y=t(o,a);for(let r=0;r<e.length;r++){const o=l(y,e[r].x,e[r].y,e[r].z),t=n[r].x-o.x,s=n[r].y-o.y;T[r]=t,p[r]=s,w[r]=t*t+s*s}let x;if(u=0,f){const r=Math.max(3,Math.floor(e.length*i)-1);for(let r=0;r<e.length;r++)g[r]=w[r];g.sort((r,o)=>r-o),x=Math.max(4*g[r],16);for(let r=0;r<e.length;r++)g[r]>x?u+=x/6:u+=x/6*(1-(1-g[r]/x)*(1-g[r]/x)*(1-g[r]/x))}else for(let r=0;r<e.length;r++)u+=w[r];if(u/=e.length,u<.1)break;if(r>0&&u/d>.99)break;if(10===r)break;d=u;const z=[],M=[];for(let r=0;r<e.length;r++){if(f&&w[r]>x)continue;const t=h({modelViewProjectionTransform:y,modelViewTransform:a,projectionTransform:o,worldCoord:e[r]});if(f){const o=(1-w[r]/x)*(1-w[r]/x),e=s?s[r]:1,l=o*(e*Math.log10(9*e+1));for(let r=0;r<2;r++)for(let o=0;o<6;o++)t[r][o]*=l;z.push([T[r]*l]),z.push([p[r]*l])}else{const o=s?s[r]:1,e=o*Math.log10(9*o+1);for(let r=0;r<2;r++)for(let o=0;o<6;o++)t[r][o]*=e;z.push([T[r]*e]),z.push([p[r]*e])}for(let r=0;r<t.length;r++)M.push(t[r])}const V=c({dU:z,J_U_S:M});if(null===V)break;a=m({modelViewTransform:a,dS:V})}return{modelViewTransform:a,err:u}},m=({modelViewTransform:r,dS:o})=>{let e,t,l,s=o[0]*o[0]+o[1]*o[1]+o[2]*o[2];s<1e-6?(e=1,t=0,l=0,s=0):(s=Math.sqrt(s),e=o[0]/s,t=o[1]/s,l=o[2]/s);const i=Math.cos(s),f=Math.sin(s),a=1-i;n[0][0]=e*e*a+i,n[0][1]=e*t*a-l*f,n[0][2]=e*l*a+t*f,n[0][3]=o[3],n[1][0]=t*e*a+l*f,n[1][1]=t*t*a+i,n[1][2]=t*l*a-e*f,n[1][3]=o[4],n[2][0]=l*e*a-t*f,n[2][1]=l*t*a+e*f,n[2][2]=l*l*a+i,n[2][3]=o[5];const m=[[],[],[]];for(let o=0;o<3;o++){for(let e=0;e<4;e++)m[o][e]=r[o][0]*n[0][e]+r[o][1]*n[1][e]+r[o][2]*n[2][e];m[o][3]+=r[o][3]}return m},c=({dU:e,J_U_S:t})=>{const l=new r(t),n=new r(e),s=l.transpose(),i=s.mmul(l),f=s.mmul(n);let a;try{a=o(i)}catch(r){return null}return a.mmul(f).to1DArray()},h=({modelViewProjectionTransform:r,modelViewTransform:o,projectionTransform:t,worldCoord:l})=>{const n=o,{x:f,y:a,z:m}=l,c=e(r,f,a,m),h=c.z*c.z;s[0][0]=t[0][0]*c.z/h,s[0][1]=t[0][1]*c.z/h,s[0][2]=(t[0][2]*c.z-t[2][2]*c.x)/h,s[1][0]=t[1][0]*c.z/h,s[1][1]=t[1][1]*c.z/h,s[1][2]=(t[1][2]*c.z-t[2][2]*c.y)/h,i[0][0]=n[0][2]*a,i[0][1]=-n[0][2]*f,i[0][2]=n[0][1]*f-n[0][0]*a,i[0][3]=n[0][0],i[0][4]=n[0][1],i[0][5]=n[0][2],i[1][0]=n[1][2]*a,i[1][1]=-n[1][2]*f,i[1][2]=n[1][1]*f-n[1][0]*a,i[1][3]=n[1][0],i[1][4]=n[1][1],i[1][5]=n[1][2],i[2][0]=n[2][2]*a,i[2][1]=-n[2][2]*f,i[2][2]=n[2][1]*f-n[2][0]*a,i[2][3]=n[2][0],i[2][4]=n[2][1],i[2][5]=n[2][2];const d=[[],[]];for(let r=0;r<2;r++)for(let o=0;o<6;o++){d[r][o]=0;for(let e=0;e<3;e++)d[r][o]+=s[r][e]*i[e][o]}return d};export{f as refineEstimate};