@srsergio/taptapp-ar 1.1.1 → 1.1.3

package/dist/core/matching/matching.js

@@ -1,401 +1 @@
-import TinyQueue from "tinyqueue";
-import { compute as hammingCompute } from "./hamming-distance.js";
-import { computeHoughMatches } from "./hough.js";
-import { computeHomography } from "./ransacHomography.js";
-import { multiplyPointHomographyInhomogenous, matrixInverse33 } from "../utils/geometry.js";
-import { refineWithMorphology } from "../estimation/morph-refinement.js";
-import { popcount32 } from "./hierarchical-clustering.js";
-import { AR_CONFIG } from "../constants.js";
-const INLIER_THRESHOLD = AR_CONFIG.INLIER_THRESHOLD;
-const MIN_NUM_INLIERS = AR_CONFIG.MIN_NUM_INLIERS;
-const CLUSTER_MAX_POP = AR_CONFIG.CLUSTER_MAX_POP;
-const HAMMING_THRESHOLD = AR_CONFIG.HAMMING_THRESHOLD;
-const HDC_RATIO_THRESHOLD = AR_CONFIG.HDC_RATIO_THRESHOLD;
-const MAX_MATCH_QUERY_POINTS = AR_CONFIG.MAX_MATCH_QUERY_POINTS;
-// match list of querpoints against pre-built list of keyframes
-const match = ({ keyframe, querypoints: rawQuerypoints, querywidth, queryheight, debugMode, expectedScale }) => {
-    let debugExtra = {};
-    // 🎯 Performance Optimizer: Use only the most "salient" points (highest response)
-    const querypoints = rawQuerypoints.length > MAX_MATCH_QUERY_POINTS
-        ? [...rawQuerypoints].sort((a, b) => (b.score || b.response || 0) - (a.score || a.response || 0)).slice(0, MAX_MATCH_QUERY_POINTS)
-        : rawQuerypoints;
-    const matches = [];
-    const qlen = querypoints.length;
-    const kmax = keyframe.max;
-    const kmin = keyframe.min;
-    // Detect descriptor mode: HDC (32-bit signature), Compact (32-bit XOR folded), or Raw (64-bit)
-    const isHDC = keyframe.hdc === true || (kmax && kmax.hdc === 1);
-    const isCompact = (kmax && kmax.compact === 1) || (kmin && kmin.compact === 1);
-    const descSize = (isHDC || isCompact) ? 1 : 2; // Compact uses 32-bit like HDC
-    const currentRatioThreshold = isHDC ? HDC_RATIO_THRESHOLD : HAMMING_THRESHOLD;
-    for (let j = 0; j < qlen; j++) {
-        const querypoint = querypoints[j];
-        const col = querypoint.maxima ? kmax : kmin;
-        if (!col || col.x.length === 0)
-            continue;
-        const rootNode = col.t;
-        const keypointIndexes = [];
-        const queue = new TinyQueue([], (a1, a2) => a1.d - a2.d);
-        _query({
-            node: rootNode,
-            descriptors: col.d,
-            querypoint,
-            queue,
-            keypointIndexes,
-            numPop: 0,
-            isHDC,
-            descSize,
-            isCompact
-        });
-        let bestIndex = -1;
-        let bestD1 = Number.MAX_SAFE_INTEGER;
-        let bestD2 = Number.MAX_SAFE_INTEGER;
-        const qDesc = querypoint.descriptors;
-        const cDesc = col.d;
-        // For compact mode: pre-compute XOR folded query descriptor (64-bit → 32-bit)
-        const qDescCompact = isCompact && qDesc && qDesc.length >= 2
-            ? (qDesc[0] ^ qDesc[1]) >>> 0
-            : 0;
-        for (let k = 0; k < keypointIndexes.length; k++) {
-            const idx = keypointIndexes[k];
-            // 🚀 NANITE-STYLE: Dynamic scale filtering
-            // If we have an expected scale, skip points that are outside the resolution range
-            if (expectedScale !== undefined && col.s) {
-                const featureScale = col.s[idx]; // Octave scale (1, 2, 4...)
-                const idealKeyScale = (querypoint.scale || 1.0) / expectedScale;
-                // allow ~1 octave of margin
-                if (featureScale < idealKeyScale * 0.4 || featureScale > idealKeyScale * 2.5) {
-                    continue;
-                }
-            }
-            let d;
-            if (isHDC) {
-                d = popcount32(cDesc[idx] ^ querypoint.hdcSignature);
-            }
-            else if (isCompact) {
-                // Compact mode: compare 32-bit XOR folded descriptors
-                d = popcount32(cDesc[idx] ^ qDescCompact);
-            }
-            else {
-                d = hammingCompute({ v1: cDesc, v1Offset: idx * descSize, v2: qDesc });
-            }
-            if (d < bestD1) {
-                bestD2 = bestD1;
-                bestD1 = d;
-                bestIndex = idx;
-            }
-            else if (d < bestD2) {
-                bestD2 = d;
-            }
-        }
-        if (bestIndex !== -1) {
-            if (bestD2 === Number.MAX_SAFE_INTEGER || (bestD1 / bestD2) < currentRatioThreshold) {
-                matches.push({
-                    querypoint,
-                    keypoint: {
-                        x: col.x[bestIndex],
-                        y: col.y[bestIndex],
-                        angle: col.a[bestIndex],
-                        scale: col.s ? col.s[bestIndex] : keyframe.s
-                    },
-                    d: bestD1
-                });
-            }
-        }
-    }
-    if (matches.length < MIN_NUM_INLIERS) {
-        return { debugExtra };
-    }
-    // 🌌 Moonshot: Constellation matching disabled for performance calibration
-    const constellationMatches = matches;
-    if (debugMode)
-        debugExtra.constellationMatches = constellationMatches;
-    const houghMatches = computeHoughMatches({
-        keywidth: keyframe.w || keyframe.width,
-        keyheight: keyframe.h || keyframe.height,
-        querywidth,
-        queryheight,
-        matches: constellationMatches,
-    });
-    if (debugMode) {
-        debugExtra.houghMatches = houghMatches;
-    }
-    if (houghMatches.length < MIN_NUM_INLIERS) {
-        return { debugExtra };
-    }
-    const H = computeHomography({
-        srcPoints: houghMatches.map((m) => [m.keypoint.x, m.keypoint.y]),
-        dstPoints: houghMatches.map((m) => [m.querypoint.x, m.querypoint.y]),
-        keyframe: { width: keyframe.w || keyframe.width, height: keyframe.h || keyframe.height },
-    });
-    if (H === null) {
-        return { debugExtra };
-    }
-    const inlierMatches = _findInlierMatches({
-        H,
-        matches: houghMatches,
-        threshold: INLIER_THRESHOLD,
-    });
-    if (debugMode)
-        debugExtra.inlierMatches = inlierMatches;
-    if (inlierMatches.length < MIN_NUM_INLIERS) {
-        return { debugExtra };
-    }
-    if (debugMode && Math.random() < 0.02) {
-        console.log(`MATCH: Homography success with ${inlierMatches.length} inliers`);
-    }
-    const HInv = matrixInverse33(H, 0.00001);
-    const dThreshold2 = 100;
-    const matches2 = [];
-    const hi00 = HInv[0], hi01 = HInv[1], hi02 = HInv[2];
-    const hi10 = HInv[3], hi11 = HInv[4], hi12 = HInv[5];
-    const hi20 = HInv[6], hi21 = HInv[7], hi22 = HInv[8];
-    for (let j = 0; j < qlen; j++) {
-        const querypoint = querypoints[j];
-        const qx = querypoint.x, qy = querypoint.y;
-        const uz = (qx * hi20) + (qy * hi21) + hi22;
-        const invZ = 1.0 / uz;
-        const mapX = ((qx * hi00) + (qy * hi01) + hi02) * invZ;
-        const mapY = ((qx * hi10) + (qy * hi11) + hi12) * invZ;
-        let bestIndex = -1;
-        let bestD1 = Number.MAX_SAFE_INTEGER;
-        let bestD2 = Number.MAX_SAFE_INTEGER;
-        const col = querypoint.maxima ? kmax : kmin;
-        if (!col)
-            continue;
-        const cx = col.x, cy = col.y, cd = col.d;
-        const qDesc = querypoint.descriptors;
-        // For compact mode: XOR fold query descriptor
-        const qDescCompact = isCompact && qDesc && qDesc.length >= 2
-            ? (qDesc[0] ^ qDesc[1]) >>> 0
-            : 0;
-        for (let k = 0, clen = cx.length; k < clen; k++) {
-            const dx = cx[k] - mapX;
-            const dy = cy[k] - mapY;
-            const d2 = dx * dx + dy * dy;
-            if (d2 > dThreshold2)
-                continue;
-            let d;
-            if (isHDC) {
-                d = popcount32(cd[k] ^ querypoint.hdcSignature);
-            }
-            else if (isCompact) {
-                d = popcount32(cd[k] ^ qDescCompact);
-            }
-            else {
-                d = hammingCompute({ v1: cd, v1Offset: k * descSize, v2: qDesc });
-            }
-            if (d < bestD1) {
-                bestD2 = bestD1;
-                bestD1 = d;
-                bestIndex = k;
-            }
-            else if (d < bestD2) {
-                bestD2 = d;
-            }
-        }
-        if (bestIndex !== -1 &&
-            (bestD2 === Number.MAX_SAFE_INTEGER || (bestD1 / bestD2) < currentRatioThreshold)) {
-            matches2.push({
-                querypoint,
-                keypoint: {
-                    x: col.x[bestIndex],
-                    y: col.y[bestIndex],
-                    angle: col.a[bestIndex],
-                    scale: col.s ? col.s[bestIndex] : keyframe.s
-                }
-            });
-        }
-    }
-    if (debugMode)
-        debugExtra.matches2 = matches2;
-    const houghMatches2 = computeHoughMatches({
-        keywidth: keyframe.w || keyframe.width,
-        keyheight: keyframe.h || keyframe.height,
-        querywidth,
-        queryheight,
-        matches: matches2,
-    });
-    if (debugMode)
-        debugExtra.houghMatches2 = houghMatches2;
-    const H2 = computeHomography({
-        srcPoints: houghMatches2.map((m) => [m.keypoint.x, m.keypoint.y]),
-        dstPoints: houghMatches2.map((m) => [m.querypoint.x, m.querypoint.y]),
-        keyframe: { width: keyframe.w || keyframe.width, height: keyframe.h || keyframe.height },
-    });
-    if (H2 === null)
-        return { debugExtra };
-    const inlierMatches2 = _findInlierMatches({
-        H: H2,
-        matches: houghMatches2,
-        threshold: INLIER_THRESHOLD,
-    });
-    if (debugMode)
-        debugExtra.inlierMatches2 = inlierMatches2;
-    const refinedH = refineWithMorphology({
-        imageData: rawQuerypoints[0].imageData,
-        width: querywidth,
-        height: queryheight,
-        targetData: { w: keyframe.w || keyframe.width, h: keyframe.h || keyframe.height },
-        initialH: H2,
-        iterations: 3
-    });
-    return { H: refinedH || H2, matches: inlierMatches2, debugExtra };
-};
-const _query = ({ node, descriptors, querypoint, queue, keypointIndexes, numPop, isHDC, descSize, isCompact }) => {
-    const isLeaf = node[0] === 1;
-    const childrenOrIndices = node[2];
-    if (isLeaf) {
-        for (let i = 0; i < childrenOrIndices.length; i++) {
-            keypointIndexes.push(childrenOrIndices[i]);
-        }
-        return;
-    }
-    const qDesc = querypoint.descriptors;
-    // For compact mode: XOR fold query descriptor
-    const qDescCompact = isCompact && qDesc && qDesc.length >= 2
-        ? (qDesc[0] ^ qDesc[1]) >>> 0
-        : 0;
-    let minD = Number.MAX_SAFE_INTEGER;
-    const clen = childrenOrIndices.length;
-    const distances = new Int32Array(clen);
-    for (let i = 0; i < clen; i++) {
-        const childNode = childrenOrIndices[i];
-        const cIdx = childNode[1];
-        let d;
-        if (isHDC) {
-            d = popcount32(descriptors[cIdx] ^ querypoint.hdcSignature);
-        }
-        else if (isCompact) {
-            d = popcount32(descriptors[cIdx] ^ qDescCompact);
-        }
-        else {
-            d = hammingCompute({
-                v1: descriptors,
-                v1Offset: cIdx * descSize,
-                v2: qDesc,
-            });
-        }
-        distances[i] = d;
-        if (d < minD)
-            minD = d;
-    }
-    for (let i = 0; i < clen; i++) {
-        const dist = distances[i];
-        if (dist <= minD) {
-            _query({ node: childrenOrIndices[i], descriptors, querypoint, queue, keypointIndexes, numPop: numPop + 1, isHDC, descSize, isCompact });
-        }
-        else {
-            queue.push({ node: childrenOrIndices[i], d: dist });
-        }
-    }
-    if (numPop < CLUSTER_MAX_POP && queue.length > 0) {
-        const { node } = queue.pop();
-        _query({ node, descriptors, querypoint, queue, keypointIndexes, numPop: numPop + 1, isHDC, descSize, isCompact });
-    }
-};
-const _findInlierMatches = (options) => {
-    const { H, matches, threshold } = options;
-    const threshold2 = threshold * threshold;
-    const h00 = H[0], h01 = H[1], h02 = H[2];
-    const h10 = H[3], h11 = H[4], h12 = H[5];
-    const h20 = H[6], h21 = H[7], h22 = H[8];
-    const goodMatches = [];
-    for (let i = 0; i < matches.length; i++) {
-        const m = matches[i];
-        const qp = m.querypoint;
-        const kp = m.keypoint;
-        const uz = (kp.x * h20) + (kp.y * h21) + h22;
-        const invZ = 1.0 / uz;
-        const mx = ((kp.x * h00) + (kp.y * h01) + h02) * invZ;
-        const my = ((kp.x * h10) + (kp.y * h11) + h12) * invZ;
-        const dx = mx - qp.x;
-        const dy = my - qp.y;
-        if (dx * dx + dy * dy <= threshold2) {
-            goodMatches.push(m);
-        }
-    }
-    return goodMatches;
-};
-const _applyConstellationFilter = (matches) => {
-    const len = matches.length;
-    if (len < 3)
-        return matches;
-    const pool = matches.slice().sort((a, b) => a.d - b.d).slice(0, 1500);
-    const RATIO_TOLERANCE = 0.25;
-    const COSINE_TOLERANCE = 0.2;
-    const MAX_NEIGHBORS = 6;
-    const MIN_VERIFICATIONS = 1;
-    const gridSize = 50;
-    const grid = new Map();
-    const getGridKey = (x, y) => `${Math.floor(x / gridSize)},${Math.floor(y / gridSize)}`;
-    for (let i = 0; i < pool.length; i++) {
-        const qp = pool[i].querypoint;
-        const key = getGridKey(qp.x, qp.y);
-        if (!grid.has(key))
-            grid.set(key, []);
-        grid.get(key).push(i);
-    }
-    const scores = new Int32Array(pool.length);
-    for (let i = 0; i < pool.length; i++) {
-        const m1 = pool[i];
-        const qp1 = m1.querypoint;
-        const neighbors = [];
-        const gx = Math.floor(qp1.x / gridSize);
-        const gy = Math.floor(qp1.y / gridSize);
-        for (let dx = -1; dx <= 1; dx++) {
-            for (let dy = -1; dy <= 1; dy++) {
-                const cell = grid.get(`${gx + dx},${gy + dy}`);
-                if (!cell)
-                    continue;
-                for (const idx of cell) {
-                    if (idx === i)
-                        continue;
-                    const m2 = pool[idx];
-                    const distSq = Math.pow(m2.querypoint.x - qp1.x, 2) + Math.pow(m2.querypoint.y - qp1.y, 2);
-                    neighbors.push({ index: idx, d2: distSq });
-                }
-            }
-        }
-    }
-    const filtered = [];
-    // Dummy logic just to keep the structure
-    for (let i = 0; i < pool.length; i++) {
-        filtered.push(pool[i]);
-    }
-    return filtered;
-};
-const _checkTriadConsistency = (m1, m2, m3, ratioTol, cosTol) => {
-    const q1x = m1.querypoint.x, q1y = m1.querypoint.y;
-    const q2x = m2.querypoint.x, q2y = m2.querypoint.y;
-    const q3x = m3.querypoint.x, q3y = m3.querypoint.y;
-    const v21q = [q2x - q1x, q2y - q1y];
-    const v31q = [q3x - q1x, q3y - q1y];
-    const k1x = m1.keypoint.x, k1y = m1.keypoint.y;
-    const k2x = m2.keypoint.x, k2y = m2.keypoint.y;
-    const k3x = m3.keypoint.x, k3y = m3.keypoint.y;
-    const v21k = [k2x - k1x, k2y - k1y];
-    const v31k = [k3x - k1x, k3y - k1y];
-    const d21q2 = v21q[0] * v21q[0] + v21q[1] * v21q[1];
-    const d31q2 = v31q[0] * v31q[0] + v31q[1] * v31q[1];
-    const d21k2 = v21k[0] * v21k[0] + v21k[1] * v21k[1];
-    const d31k2 = v31k[0] * v31k[0] + v31k[1] * v31k[1];
-    if (d31q2 < 1e-4 || d31k2 < 1e-4)
-        return false;
-    const ratioQ = d21q2 / d31q2;
-    const ratioK = d21k2 / d31k2;
-    if (Math.abs(ratioQ - ratioK) / (ratioK + 1e-6) > ratioTol * 2)
-        return false;
-    const dotQ = v21q[0] * v31q[0] + v21q[1] * v31q[1];
-    const cosQ = dotQ / Math.sqrt(d21q2 * d31q2);
-    const dotK = v21k[0] * v31k[0] + v21k[1] * v31k[1];
-    const cosK = dotK / Math.sqrt(d21k2 * d31k2);
-    if (Math.abs(cosQ - cosK) > cosTol)
-        return false;
-    const crossQ = v21q[0] * v31q[1] - v21q[1] * v31q[0];
-    const crossK = v21k[0] * v31k[1] - v21k[1] * v31k[0];
-    if ((crossQ > 0) !== (crossK > 0))
-        return false;
-    return true;
-};
-export { match };
+import e from"tinyqueue";import{compute as t}from"./hamming-distance.js";import{computeHoughMatches as o}from"./hough.js";import{computeHomography as n}from"./ransacHomography.js";import{multiplyPointHomographyInhomogenous as s,matrixInverse33 as i}from"../utils/geometry.js";import{refineWithMorphology as r}from"../estimation/morph-refinement.js";import{popcount32 as h}from"./hierarchical-clustering.js";import{AR_CONFIG as c}from"../constants.js";const u=c.INLIER_THRESHOLD,a=c.MIN_NUM_INLIERS,p=c.CLUSTER_MAX_POP,m=c.HAMMING_THRESHOLD,d=c.HDC_RATIO_THRESHOLD,l=c.MAX_MATCH_QUERY_POINTS,y=({keyframe:s,querypoints:c,querywidth:p,queryheight:y,debugMode:E,expectedScale:x})=>{let _={};const q=c.length>l?[...c].sort((e,t)=>(t.score||t.response||0)-(e.score||e.response||0)).slice(0,l):c,w=[],M=q.length,A=s.max,H=s.min,S=!0===s.hdc||A&&1===A.hdc,I=A&&1===A.compact||H&&1===H.compact,N=S||I?1:2,k=S?d:m;for(let o=0;o<M;o++){const n=q[o],i=n.maxima?A:H;if(!i||0===i.x.length)continue;const r=i.t,c=[],u=new e([],(e,t)=>e.d-t.d);g({node:r,descriptors:i.d,querypoint:n,queue:u,keypointIndexes:c,numPop:0,isHDC:S,descSize:N,isCompact:I});let a=-1,p=Number.MAX_SAFE_INTEGER,m=Number.MAX_SAFE_INTEGER;const d=n.descriptors,l=i.d,y=I&&d&&d.length>=2?(d[0]^d[1])>>>0:0;for(let e=0;e<c.length;e++){const o=c[e];if(void 0!==x&&i.s){const e=i.s[o],t=(n.scale||1)/x;if(e<.4*t||e>2.5*t)continue}let s;s=S?h(l[o]^n.hdcSignature):I?h(l[o]^y):t({v1:l,v1Offset:o*N,v2:d}),s<p?(m=p,p=s,a=o):s<m&&(m=s)}-1!==a&&(m===Number.MAX_SAFE_INTEGER||p/m<k)&&w.push({querypoint:n,keypoint:{x:i.x[a],y:i.y[a],angle:i.a[a],scale:i.s?i.s[a]:s.s},d:p})}if(w.length<a)return{debugExtra:_};const R=w;E&&(_.constellationMatches=R);const T=o({keywidth:s.w||s.width,keyheight:s.h||s.height,querywidth:p,queryheight:y,matches:R});if(E&&(_.houghMatches=T),T.length<a)return{debugExtra:_};const b=n({srcPoints:T.map(e=>[e.keypoint.x,e.keypoint.y]),dstPoints:T.map(e=>[e.querypoint.x,e.querypoint.y]),keyframe:{width:s.w||s.width,height:s.h||s.height}});if(null===b)return{debugExtra:_};const C=f({H:b,matches:T,threshold:u});if(E&&(_.inlierMatches=C),C.length<a)return{debugExtra:_};E&&Math.random()<.02&&console.log(`MATCH: Homography success with ${C.length} inliers`);const D=i(b,1e-5),P=[],v=D[0],O=D[1],X=D[2],G=D[3],j=D[4],F=D[5],L=D[6],z=D[7],U=D[8];for(let e=0;e<M;e++){const o=q[e],n=o.x,i=o.y,r=1/(n*L+i*z+U),c=(n*v+i*O+X)*r,u=(n*G+i*j+F)*r;let a=-1,p=Number.MAX_SAFE_INTEGER,m=Number.MAX_SAFE_INTEGER;const d=o.maxima?A:H;if(!d)continue;const l=d.x,y=d.y,g=d.d,f=o.descriptors,E=I&&f&&f.length>=2?(f[0]^f[1])>>>0:0;for(let e=0,n=l.length;e<n;e++){const n=l[e]-c,s=y[e]-u;if(n*n+s*s>100)continue;let i;i=S?h(g[e]^o.hdcSignature):I?h(g[e]^E):t({v1:g,v1Offset:e*N,v2:f}),i<p?(m=p,p=i,a=e):i<m&&(m=i)}-1!==a&&(m===Number.MAX_SAFE_INTEGER||p/m<k)&&P.push({querypoint:o,keypoint:{x:d.x[a],y:d.y[a],angle:d.a[a],scale:d.s?d.s[a]:s.s}})}E&&(_.matches2=P);const Q=o({keywidth:s.w||s.width,keyheight:s.h||s.height,querywidth:p,queryheight:y,matches:P});E&&(_.houghMatches2=Q);const Y=n({srcPoints:Q.map(e=>[e.keypoint.x,e.keypoint.y]),dstPoints:Q.map(e=>[e.querypoint.x,e.querypoint.y]),keyframe:{width:s.w||s.width,height:s.h||s.height}});if(null===Y)return{debugExtra:_};const $=f({H:Y,matches:Q,threshold:u});return E&&(_.inlierMatches2=$),{H:r({imageData:c[0].imageData,width:p,height:y,targetData:{w:s.w||s.width,h:s.h||s.height},initialH:Y,iterations:3})||Y,matches:$,debugExtra:_}},g=({node:e,descriptors:o,querypoint:n,queue:s,keypointIndexes:i,numPop:r,isHDC:c,descSize:u,isCompact:a})=>{const m=1===e[0],d=e[2];if(m){for(let e=0;e<d.length;e++)i.push(d[e]);return}const l=n.descriptors,y=a&&l&&l.length>=2?(l[0]^l[1])>>>0:0;let f=Number.MAX_SAFE_INTEGER;const E=d.length,x=new Int32Array(E);for(let e=0;e<E;e++){const s=d[e][1];let i;i=c?h(o[s]^n.hdcSignature):a?h(o[s]^y):t({v1:o,v1Offset:s*u,v2:l}),x[e]=i,i<f&&(f=i)}for(let e=0;e<E;e++){const t=x[e];t<=f?g({node:d[e],descriptors:o,querypoint:n,queue:s,keypointIndexes:i,numPop:r+1,isHDC:c,descSize:u,isCompact:a}):s.push({node:d[e],d:t})}if(r<p&&s.length>0){const{node:e}=s.pop();g({node:e,descriptors:o,querypoint:n,queue:s,keypointIndexes:i,numPop:r+1,isHDC:c,descSize:u,isCompact:a})}},f=e=>{const{H:t,matches:o,threshold:n}=e,s=n*n,i=t[0],r=t[1],h=t[2],c=t[3],u=t[4],a=t[5],p=t[6],m=t[7],d=t[8],l=[];for(let e=0;e<o.length;e++){const t=o[e],n=t.querypoint,y=t.keypoint,g=1/(y.x*p+y.y*m+d),f=(y.x*i+y.y*r+h)*g,E=(y.x*c+y.y*u+a)*g,x=f-n.x,_=E-n.y;x*x+_*_<=s&&l.push(t)}return l};export{y as match};

package/dist/core/matching/ransacHomography.js

@@ -1,132 +1 @@
-import { createRandomizer } from "../utils/randomizer.js";
-import { quadrilateralConvex, matrixInverse33, smallestTriangleArea, multiplyPointHomographyInhomogenous, checkThreePointsConsistent, checkFourPointsConsistent, } from "../utils/geometry.js";
-import { solveHomography } from "../utils/homography.js";
-const CAUCHY_SCALE = 0.01;
-const CHUNK_SIZE = 10;
-const NUM_HYPOTHESES = 100;
-const NUM_HYPOTHESES_QUICK = 50;
-// Using RANSAC to estimate homography
-const computeHomography = (options) => {
-    const { srcPoints, dstPoints, keyframe, quickMode } = options;
-    // testPoints is four corners of keyframe
-    const testPoints = [
-        [0, 0],
-        [keyframe.width, 0],
-        [keyframe.width, keyframe.height],
-        [0, keyframe.height],
-    ];
-    const sampleSize = 4; // use four points to compute homography
-    if (srcPoints.length < sampleSize)
-        return null;
-    const scale = CAUCHY_SCALE;
-    const oneOverScale2 = 1.0 / (scale * scale);
-    const chuckSize = Math.min(CHUNK_SIZE, srcPoints.length);
-    const randomizer = createRandomizer();
-    const perm = [];
-    for (let i = 0; i < srcPoints.length; i++) {
-        perm[i] = i;
-    }
-    randomizer.arrayShuffle({ arr: perm, sampleSize: perm.length });
-    const numHypothesis = quickMode ? NUM_HYPOTHESES_QUICK : NUM_HYPOTHESES;
-    const maxTrials = numHypothesis * 2;
-    // build numerous hypotheses by randoming draw four points
-    // TODO: optimize: if number of points is less than certain number, can brute force all combinations
-    let trial = 0;
-    const Hs = [];
-    while (trial < maxTrials && Hs.length < numHypothesis) {
-        trial += 1;
-        randomizer.arrayShuffle({ arr: perm, sampleSize: sampleSize });
-        // their relative positions match each other
-        if (!checkFourPointsConsistent(srcPoints[perm[0]], srcPoints[perm[1]], srcPoints[perm[2]], srcPoints[perm[3]], dstPoints[perm[0]], dstPoints[perm[1]], dstPoints[perm[2]], dstPoints[perm[3]])) {
-            continue;
-        }
-        const H = solveHomography([srcPoints[perm[0]], srcPoints[perm[1]], srcPoints[perm[2]], srcPoints[perm[3]]], [dstPoints[perm[0]], dstPoints[perm[1]], dstPoints[perm[2]], dstPoints[perm[3]]]);
-        if (H === null)
-            continue;
-        if (!_checkHomographyPointsGeometricallyConsistent({ H, testPoints })) {
-            continue;
-        }
-        Hs.push(H);
-    }
-    if (Hs.length === 0)
-        return null;
-    // pick the best hypothesis
-    const hypotheses = [];
-    for (let i = 0; i < Hs.length; i++) {
-        hypotheses.push({
-            H: Hs[i],
-            cost: 0,
-        });
-    }
-    let curChuckSize = chuckSize;
-    for (let i = 0; i < srcPoints.length && hypotheses.length > 2; i += curChuckSize) {
-        curChuckSize = Math.min(chuckSize, srcPoints.length - i);
-        let chuckEnd = i + curChuckSize;
-        for (let j = 0; j < hypotheses.length; j++) {
-            for (let k = i; k < chuckEnd; k++) {
-                const cost = _cauchyProjectiveReprojectionCost({
-                    H: hypotheses[j].H,
-                    srcPoint: srcPoints[k],
-                    dstPoint: dstPoints[k],
-                    oneOverScale2,
-                });
-                hypotheses[j].cost += cost;
-            }
-        }
-        hypotheses.sort((h1, h2) => {
-            return h1.cost - h2.cost;
-        });
-        hypotheses.splice(-Math.floor((hypotheses.length + 1) / 2)); // keep the best half
-    }
-    let finalH = null;
-    for (let i = 0; i < hypotheses.length; i++) {
-        const H = _normalizeHomography({ inH: hypotheses[i].H });
-        if (_checkHeuristics({ H: H, testPoints, keyframe })) {
-            finalH = H;
-            break;
-        }
-    }
-    return finalH;
-};
-const _checkHeuristics = ({ H, testPoints, keyframe }) => {
-    const mp = [];
-    for (let i = 0; i < testPoints.length; i++) {
-        // 4 test points, corner of keyframe
-        mp.push(multiplyPointHomographyInhomogenous(testPoints[i], H));
-    }
-    const smallArea = smallestTriangleArea(mp[0], mp[1], mp[2], mp[3]);
-    if (smallArea < keyframe.width * keyframe.height * 0.0001)
-        return false;
-    if (!quadrilateralConvex(mp[0], mp[1], mp[2], mp[3]))
-        return false;
-    return true;
-};
-const _normalizeHomography = ({ inH }) => {
-    const oneOver = 1.0 / inH[8];
-    const H = [];
-    for (let i = 0; i < 8; i++) {
-        H[i] = inH[i] * oneOver;
-    }
-    H[8] = 1.0;
-    return H;
-};
-const _cauchyProjectiveReprojectionCost = ({ H, srcPoint, dstPoint, oneOverScale2 }) => {
-    const x = multiplyPointHomographyInhomogenous(srcPoint, H);
-    const f = [x[0] - dstPoint[0], x[1] - dstPoint[1]];
-    return Math.log(1 + (f[0] * f[0] + f[1] * f[1]) * oneOverScale2);
-};
-const _checkHomographyPointsGeometricallyConsistent = ({ H, testPoints }) => {
-    const mappedPoints = [];
-    for (let i = 0; i < testPoints.length; i++) {
-        mappedPoints[i] = multiplyPointHomographyInhomogenous(testPoints[i], H);
-    }
-    for (let i = 0; i < testPoints.length; i++) {
-        const i1 = i;
-        const i2 = (i + 1) % testPoints.length;
-        const i3 = (i + 2) % testPoints.length;
-        if (!checkThreePointsConsistent(testPoints[i1], testPoints[i2], testPoints[i3], mappedPoints[i1], mappedPoints[i2], mappedPoints[i3]))
-            return false;
-    }
-    return true;
-};
-export { computeHomography };
+import{createRandomizer as t}from"../utils/randomizer.js";import{quadrilateralConvex as e,matrixInverse33 as n,smallestTriangleArea as o,multiplyPointHomographyInhomogenous as r,checkThreePointsConsistent as l,checkFourPointsConsistent as s}from"../utils/geometry.js";import{solveHomography as h}from"../utils/homography.js";const i=e=>{const{srcPoints:n,dstPoints:o,keyframe:r,quickMode:l}=e,i=[[0,0],[r.width,0],[r.width,r.height],[0,r.height]];if(n.length<4)return null;const a=Math.min(10,n.length),m=t(),p=[];for(let t=0;t<n.length;t++)p[t]=t;m.arrayShuffle({arr:p,sampleSize:p.length});const H=l?50:100,P=2*H;let d=0;const y=[];for(;d<P&&y.length<H;){if(d+=1,m.arrayShuffle({arr:p,sampleSize:4}),!s(n[p[0]],n[p[1]],n[p[2]],n[p[3]],o[p[0]],o[p[1]],o[p[2]],o[p[3]]))continue;const t=h([n[p[0]],n[p[1]],n[p[2]],n[p[3]]],[o[p[0]],o[p[1]],o[p[2]],o[p[3]]]);null!==t&&u({H:t,testPoints:i})&&y.push(t)}if(0===y.length)return null;const S=[];for(let t=0;t<y.length;t++)S.push({H:y[t],cost:0});let k=a;for(let t=0;t<n.length&&S.length>2;t+=k){k=Math.min(a,n.length-t);let e=t+k;for(let r=0;r<S.length;r++)for(let l=t;l<e;l++){const t=g({H:S[r].H,srcPoint:n[l],dstPoint:o[l],oneOverScale2:1e4});S[r].cost+=t}S.sort((t,e)=>t.cost-e.cost),S.splice(-Math.floor((S.length+1)/2))}let M=null;for(let t=0;t<S.length;t++){const e=c({inH:S[t].H});if(f({H:e,testPoints:i,keyframe:r})){M=e;break}}return M},f=({H:t,testPoints:n,keyframe:l})=>{const s=[];for(let e=0;e<n.length;e++)s.push(r(n[e],t));return!(o(s[0],s[1],s[2],s[3])<l.width*l.height*1e-4||!e(s[0],s[1],s[2],s[3]))},c=({inH:t})=>{const e=1/t[8],n=[];for(let o=0;o<8;o++)n[o]=t[o]*e;return n[8]=1,n},g=({H:t,srcPoint:e,dstPoint:n,oneOverScale2:o})=>{const l=r(e,t),s=[l[0]-n[0],l[1]-n[1]];return Math.log(1+(s[0]*s[0]+s[1]*s[1])*o)},u=({H:t,testPoints:e})=>{const n=[];for(let o=0;o<e.length;o++)n[o]=r(e[o],t);for(let t=0;t<e.length;t++){const o=t,r=(t+1)%e.length,s=(t+2)%e.length;if(!l(e[o],e[r],e[s],n[o],n[r],n[s]))return!1}return!0};export{i as computeHomography};