@srsergio/taptapp-ar 1.1.1 → 1.1.3

package/dist/core/matching/hierarchical-clustering.js

@@ -1,130 +1 @@
-import { compute64 as hammingCompute64 } from "./hamming-distance.js";
-import { createRandomizer } from "../utils/randomizer.js";
-const MIN_FEATURE_PER_NODE = 32;
-const NUM_ASSIGNMENT_HYPOTHESES = 12;
-const NUM_CENTERS = 8;
-export function popcount32(n) {
-    n = n - ((n >> 1) & 0x55555555);
-    n = (n & 0x33333333) + ((n >> 2) & 0x33333333);
-    return (((n + (n >> 4)) & 0x0F0F0F0F) * 0x01010101) >> 24;
-}
-const _computeKMedoids = (options) => {
-    const { descriptors, pointIndexes, randomizer, useHDC } = options;
-    const numPointIndexes = pointIndexes.length;
-    const randomPointIndexes = new Int32Array(numPointIndexes);
-    for (let i = 0; i < numPointIndexes; i++) {
-        randomPointIndexes[i] = i;
-    }
-    let bestSumD = Number.MAX_SAFE_INTEGER;
-    let bestAssignment = null;
-    const centerPointIndices = new Int32Array(NUM_CENTERS);
-    for (let i = 0; i < NUM_ASSIGNMENT_HYPOTHESES; i++) {
-        randomizer.arrayShuffle({ arr: randomPointIndexes, sampleSize: NUM_CENTERS });
-        for (let k = 0; k < NUM_CENTERS; k++) {
-            centerPointIndices[k] = pointIndexes[randomPointIndexes[k]];
-        }
-        let sumD = 0;
-        const currentAssignment = new Int32Array(numPointIndexes);
-        for (let j = 0; j < numPointIndexes; j++) {
-            const pIdx = pointIndexes[j];
-            let bestD = 255;
-            let bestCenterIdx = -1;
-            for (let k = 0; k < NUM_CENTERS; k++) {
-                const cIdx = centerPointIndices[k];
-                let d;
-                if (useHDC) {
-                    d = popcount32(descriptors[pIdx] ^ descriptors[cIdx]);
-                }
-                else {
-                    d = hammingCompute64(descriptors, pIdx * 2, descriptors, cIdx * 2);
-                }
-                if (d < bestD) {
-                    bestCenterIdx = randomPointIndexes[k];
-                    bestD = d;
-                }
-            }
-            currentAssignment[j] = bestCenterIdx;
-            sumD += bestD;
-        }
-        if (sumD < bestSumD) {
-            bestSumD = sumD;
-            bestAssignment = currentAssignment;
-        }
-    }
-    return bestAssignment;
-};
-const build = ({ points }) => {
-    const numPoints = points.length;
-    if (numPoints === 0)
-        return { rootNode: { leaf: true, pointIndexes: [], centerPointIndex: null } };
-    const useHDC = points[0] && points[0].hdcSignature !== undefined;
-    const descriptors = new Uint32Array(useHDC ? numPoints : numPoints * 2);
-    for (let i = 0; i < numPoints; i++) {
-        if (useHDC) {
-            descriptors[i] = points[i].hdcSignature;
-        }
-        else {
-            const d = points[i].descriptors;
-            descriptors[i * 2] = d[0];
-            descriptors[i * 2 + 1] = d[1];
-        }
-    }
-    const pointIndexes = new Int32Array(numPoints);
-    for (let i = 0; i < numPoints; i++) {
-        pointIndexes[i] = i;
-    }
-    const randomizer = createRandomizer();
-    const rootNode = _build({
-        descriptors,
-        pointIndexes,
-        centerPointIndex: null,
-        randomizer,
-        useHDC
-    });
-    return { rootNode };
-};
-const _build = (options) => {
-    const { descriptors, pointIndexes, centerPointIndex, randomizer, useHDC } = options;
-    const numPoints = pointIndexes.length;
-    let isLeaf = false;
-    if (numPoints <= NUM_CENTERS || numPoints <= MIN_FEATURE_PER_NODE) {
-        isLeaf = true;
-    }
-    const clusters = new Map();
-    if (!isLeaf) {
-        const assignment = _computeKMedoids({ descriptors, pointIndexes, randomizer, useHDC });
-        for (let i = 0; i < assignment.length; i++) {
-            const centerIdx = pointIndexes[assignment[i]];
-            let cluster = clusters.get(centerIdx);
-            if (cluster === undefined) {
-                cluster = [];
-                clusters.set(centerIdx, cluster);
-            }
-            cluster.push(pointIndexes[i]);
-        }
-        if (clusters.size === 1) {
-            isLeaf = true;
-        }
-    }
-    const node = {
-        centerPointIndex: centerPointIndex,
-    };
-    if (isLeaf) {
-        node.leaf = true;
-        node.pointIndexes = new Int32Array(pointIndexes);
-        return node;
-    }
-    node.leaf = false;
-    node.children = [];
-    for (const [cIdx, clusterPoints] of clusters) {
-        node.children.push(_build({
-            descriptors,
-            pointIndexes: new Int32Array(clusterPoints),
-            centerPointIndex: cIdx,
-            randomizer,
-            useHDC
-        }));
-    }
-    return node;
-};
-export { build };
+import{compute64 as e}from"./hamming-distance.js";import{createRandomizer as n}from"../utils/randomizer.js";export function popcount32(e){return 16843009*((e=(858993459&(e-=e>>1&1431655765))+(e>>2&858993459))+(e>>4)&252645135)>>24}const t=({points:e})=>{const t=e.length;if(0===t)return{rootNode:{leaf:!0,pointIndexes:[],centerPointIndex:null}};const o=e[0]&&void 0!==e[0].hdcSignature,s=new Uint32Array(o?t:2*t);for(let n=0;n<t;n++)if(o)s[n]=e[n].hdcSignature;else{const t=e[n].descriptors;s[2*n]=t[0],s[2*n+1]=t[1]}const i=new Int32Array(t);for(let e=0;e<t;e++)i[e]=e;const c=n();return{rootNode:r({descriptors:s,pointIndexes:i,centerPointIndex:null,randomizer:c,useHDC:o})}},r=n=>{const{descriptors:t,pointIndexes:o,centerPointIndex:s,randomizer:i,useHDC:c}=n,d=o.length;let l=!1;(d<=8||d<=32)&&(l=!0);const p=new Map;if(!l){const n=(n=>{const{descriptors:t,pointIndexes:r,randomizer:o,useHDC:s}=n,i=r.length,c=new Int32Array(i);for(let e=0;e<i;e++)c[e]=e;let d=Number.MAX_SAFE_INTEGER,l=null;const p=new Int32Array(8);for(let n=0;n<12;n++){o.arrayShuffle({arr:c,sampleSize:8});for(let e=0;e<8;e++)p[e]=r[c[e]];let n=0;const a=new Int32Array(i);for(let o=0;o<i;o++){const i=r[o];let d=255,l=-1;for(let n=0;n<8;n++){const r=p[n];let o;o=s?popcount32(t[i]^t[r]):e(t,2*i,t,2*r),o<d&&(l=c[n],d=o)}a[o]=l,n+=d}n<d&&(d=n,l=a)}return l})({descriptors:t,pointIndexes:o,randomizer:i,useHDC:c});for(let e=0;e<n.length;e++){const t=o[n[e]];let r=p.get(t);void 0===r&&(r=[],p.set(t,r)),r.push(o[e])}1===p.size&&(l=!0)}const a={centerPointIndex:s};if(l)return a.leaf=!0,a.pointIndexes=new Int32Array(o),a;a.leaf=!1,a.children=[];for(const[e,n]of p)a.children.push(r({descriptors:t,pointIndexes:new Int32Array(n),centerPointIndex:e,randomizer:i,useHDC:c}));return a};export{t as build};

package/dist/core/matching/hough.js

@@ -1,170 +1 @@
-const kHoughBinDelta = 1;
-// mathces [querypointIndex:x, keypointIndex: x]
-const computeHoughMatches = (options) => {
-    const { keywidth, keyheight, querywidth, queryheight, matches } = options;
-    const maxX = querywidth * 1.2;
-    const minX = -maxX;
-    const maxY = queryheight * 1.2;
-    const minY = -maxY;
-    const numAngleBins = 12;
-    const numScaleBins = 12; // 🚀 Increased bins
-    const minScale = -2; // 📐 Support 1% scale (10^-2)
-    const maxScale = 1; // 📐 Support 1000% scale (10^1)
-    const scaleK = 10.0;
-    const scaleOneOverLogK = 1.0 / Math.log(scaleK);
-    const maxDim = Math.max(keywidth, keyheight);
-    const keycenterX = Math.floor(keywidth / 2);
-    const keycenterY = Math.floor(keyheight / 2);
-    // compute numXBins and numYBins based on matches
-    const projectedDims = [];
-    for (let i = 0; i < matches.length; i++) {
-        const queryscale = matches[i].querypoint.scale;
-        const keyscale = matches[i].keypoint.scale;
-        if (keyscale == 0)
-            console.log("ERROR divide zero");
-        const scale = queryscale / keyscale;
-        projectedDims.push(scale * maxDim);
-    }
-    // TODO optimize median
-    //   weird. median should be [Math.floor(projectedDims.length/2) - 1] ?
-    projectedDims.sort((a1, a2) => {
-        return a1 - a2;
-    });
-    const medianProjectedDim = projectedDims[Math.floor(projectedDims.length / 2) - (projectedDims.length % 2 == 0 ? 1 : 0) - 1];
-    const binSize = Math.max(20, 0.25 * medianProjectedDim); // 🚀 Ensure bins aren't too small for noise
-    const numXBins = Math.max(5, Math.min(40, Math.ceil((maxX - minX) / binSize))); // 🎯 Cap bins to keep voting dense
-    const numYBins = Math.max(5, Math.min(40, Math.ceil((maxY - minY) / binSize)));
-    const numXYBins = numXBins * numYBins;
-    const numXYAngleBins = numXYBins * numAngleBins;
-    // do voting
-    const querypointValids = [];
-    const querypointBinLocations = [];
-    const votes = {};
-    for (let i = 0; i < matches.length; i++) {
-        const querypoint = matches[i].querypoint;
-        const keypoint = matches[i].keypoint;
-        const { x, y, scale, angle } = _mapCorrespondence({
-            querypoint,
-            keypoint,
-            keycenterX,
-            keycenterY,
-            scaleOneOverLogK,
-        });
-        // Check that the vote is within range
-        if (x < minX ||
-            x >= maxX ||
-            y < minY ||
-            y >= maxY ||
-            angle <= -Math.PI ||
-            angle > Math.PI ||
-            scale < minScale ||
-            scale >= maxScale) {
-            querypointValids[i] = false;
-            continue;
-        }
-        // map properties to bins
-        let fbinX = (numXBins * (x - minX)) / (maxX - minX);
-        let fbinY = (numYBins * (y - minY)) / (maxY - minY);
-        let fbinAngle = (numAngleBins * (angle + Math.PI)) / (2.0 * Math.PI);
-        let fbinScale = (numScaleBins * (scale - minScale)) / (maxScale - minScale);
-        querypointBinLocations[i] = {
-            binX: fbinX,
-            binY: fbinY,
-            binAngle: fbinAngle,
-            binScale: fbinScale,
-        };
-        let binX = Math.floor(fbinX - 0.5);
-        let binY = Math.floor(fbinY - 0.5);
-        let binScale = Math.floor(fbinScale - 0.5);
-        let binAngle = (Math.floor(fbinAngle - 0.5) + numAngleBins) % numAngleBins;
-        // check can vote all 16 bins
-        if (binX < 0 ||
-            binX + 1 >= numXBins ||
-            binY < 0 ||
-            binY + 1 >= numYBins ||
-            binScale < 0 ||
-            binScale + 1 >= numScaleBins) {
-            querypointValids[i] = false;
-            continue;
-        }
-        for (let dx = 0; dx < 2; dx++) {
-            let binX2 = binX + dx;
-            for (let dy = 0; dy < 2; dy++) {
-                let binY2 = binY + dy;
-                for (let dangle = 0; dangle < 2; dangle++) {
-                    let binAngle2 = (binAngle + dangle) % numAngleBins;
-                    for (let dscale = 0; dscale < 2; dscale++) {
-                        let binScale2 = binScale + dscale;
-                        const binIndex = binX2 + binY2 * numXBins + binAngle2 * numXYBins + binScale2 * numXYAngleBins;
-                        if (votes[binIndex] === undefined)
-                            votes[binIndex] = 0;
-                        votes[binIndex] += 1;
-                    }
-                }
-            }
-        }
-        querypointValids[i] = true;
-    }
-    let maxVotes = 0;
-    let maxVoteIndex = -1;
-    Object.keys(votes).forEach((index) => {
-        if (votes[index] > maxVotes) {
-            maxVotes = votes[index];
-            maxVoteIndex = index;
-        }
-    });
-    if (maxVotes < 3)
-        return [];
-    // get back bins from vote index
-    const binX = Math.floor(((maxVoteIndex % numXYAngleBins) % numXYBins) % numXBins);
-    const binY = Math.floor((((maxVoteIndex - binX) % numXYAngleBins) % numXYBins) / numXBins);
-    const binAngle = Math.floor(((maxVoteIndex - binX - binY * numXBins) % numXYAngleBins) / numXYBins);
-    const binScale = Math.floor((maxVoteIndex - binX - binY * numXBins - binAngle * numXYBins) / numXYAngleBins);
-    // console.log(`[Hough] Peak votes: ${maxVotes} out of ${matches.length} matches.`);
-    const houghMatches = [];
-    const relaxedDelta = 2.0; // 🚀 Increased for better cluster robustness
-    for (let i = 0; i < matches.length; i++) {
-        if (!querypointValids[i])
-            continue;
-        const queryBins = querypointBinLocations[i];
-        // compute bin difference
-        const distBinX = Math.abs(queryBins.binX - (binX + 0.5));
-        if (distBinX >= relaxedDelta)
-            continue;
-        const distBinY = Math.abs(queryBins.binY - (binY + 0.5));
-        if (distBinY >= relaxedDelta)
-            continue;
-        const distBinScale = Math.abs(queryBins.binScale - (binScale + 0.5));
-        if (distBinScale >= relaxedDelta)
-            continue;
-        const temp = Math.abs(queryBins.binAngle - (binAngle + 0.5));
-        const distBinAngle = Math.min(temp, numAngleBins - temp);
-        if (distBinAngle >= relaxedDelta)
-            continue;
-        houghMatches.push(matches[i]);
-    }
-    return houghMatches;
-};
-const _mapCorrespondence = ({ querypoint, keypoint, keycenterX, keycenterY, scaleOneOverLogK }) => {
-    // map angle to (-pi, pi]
-    let angle = querypoint.angle - keypoint.angle;
-    if (angle <= -Math.PI)
-        angle += 2 * Math.PI;
-    else if (angle > Math.PI)
-        angle -= 2 * Math.PI;
-    const scale = querypoint.scale / keypoint.scale;
-    // 2x2 similarity
-    const cos = scale * Math.cos(angle);
-    const sin = scale * Math.sin(angle);
-    const S = [cos, -sin, sin, cos];
-    const tp = [S[0] * keypoint.x + S[1] * keypoint.y, S[2] * keypoint.x + S[3] * keypoint.y];
-    const tx = querypoint.x - tp[0];
-    const ty = querypoint.y - tp[1];
-    return {
-        x: S[0] * keycenterX + S[1] * keycenterY + tx,
-        y: S[2] * keycenterX + S[3] * keycenterY + ty,
-        angle: angle,
-        scale: Math.log(scale) * scaleOneOverLogK,
-    };
-};
-export { computeHoughMatches };
+const t=t=>{const{keywidth:o,keyheight:n,querywidth:a,queryheight:l,matches:h}=t,i=1.2*a,r=-i,c=1.2*l,M=-c,s=12,f=1/Math.log(10),y=Math.max(o,n),g=Math.floor(o/2),u=Math.floor(n/2),b=[];for(let t=0;t<h.length;t++){const e=h[t].querypoint.scale,o=h[t].keypoint.scale;0==o&&console.log("ERROR divide zero");const n=e/o;b.push(n*y)}b.sort((t,e)=>t-e);const k=b[Math.floor(b.length/2)-(b.length%2==0?1:0)-1],p=Math.max(20,.25*k),x=Math.max(5,Math.min(40,Math.ceil((i-r)/p))),m=Math.max(5,Math.min(40,Math.ceil((c-M)/p))),I=x*m,P=I*s,q=[],O=[],d={};for(let t=0;t<h.length;t++){const o=h[t].querypoint,n=h[t].keypoint,{x:a,y:l,scale:y,angle:b}=e({querypoint:o,keypoint:n,keycenterX:g,keycenterY:u,scaleOneOverLogK:f});if(a<r||a>=i||l<M||l>=c||b<=-Math.PI||b>Math.PI||y<-2||y>=1){q[t]=!1;continue}let k=x*(a-r)/(i-r),p=m*(l-M)/(c-M),v=s*(b+Math.PI)/(2*Math.PI),X=12*(y- -2)/3;O[t]={binX:k,binY:p,binAngle:v,binScale:X};let Y=Math.floor(k-.5),R=Math.floor(p-.5),w=Math.floor(X-.5),A=(Math.floor(v-.5)+s)%s;if(Y<0||Y+1>=x||R<0||R+1>=m||w<0||w+1>=12)q[t]=!1;else{for(let t=0;t<2;t++){let e=Y+t;for(let t=0;t<2;t++){let o=R+t;for(let t=0;t<2;t++){let n=(A+t)%s;for(let t=0;t<2;t++){const a=e+o*x+n*I+(w+t)*P;void 0===d[a]&&(d[a]=0),d[a]+=1}}}}q[t]=!0}}let v=0,X=-1;if(Object.keys(d).forEach(t=>{d[t]>v&&(v=d[t],X=t)}),v<3)return[];const Y=Math.floor(X%P%I%x),R=Math.floor((X-Y)%P%I/x),w=Math.floor((X-Y-R*x)%P/I),A=Math.floor((X-Y-R*x-w*I)/P),E=[];for(let t=0;t<h.length;t++){if(!q[t])continue;const e=O[t];if(Math.abs(e.binX-(Y+.5))>=2)continue;if(Math.abs(e.binY-(R+.5))>=2)continue;if(Math.abs(e.binScale-(A+.5))>=2)continue;const o=Math.abs(e.binAngle-(w+.5));Math.min(o,s-o)>=2||E.push(h[t])}return E},e=({querypoint:t,keypoint:e,keycenterX:o,keycenterY:n,scaleOneOverLogK:a})=>{let l=t.angle-e.angle;l<=-Math.PI?l+=2*Math.PI:l>Math.PI&&(l-=2*Math.PI);const h=t.scale/e.scale,i=h*Math.cos(l),r=h*Math.sin(l),c=[i,-r,r,i],M=[c[0]*e.x+c[1]*e.y,c[2]*e.x+c[3]*e.y],s=t.x-M[0],f=t.y-M[1];return{x:c[0]*o+c[1]*n+s,y:c[2]*o+c[3]*n+f,angle:l,scale:Math.log(h)*a}};export{t as computeHoughMatches};

package/dist/core/matching/matcher.js

@@ -1,66 +1 @@
-import { match } from "./matching.js";
-class Matcher {
-    constructor(queryWidth, queryHeight, debugMode = false) {
-        this.queryWidth = queryWidth;
-        this.queryHeight = queryHeight;
-        this.debugMode = debugMode;
-    }
-    matchDetection(keyframes, featurePoints, expectedScale) {
-        let debugExtra = { frames: [] };
-        let bestResult = null;
-        // keyframes is actually the matchingData array for a single target
-        if (!keyframes || !Array.isArray(keyframes)) {
-            return { targetIndex: -1, keyframeIndex: -1, debugExtra };
-        }
-        for (let j = 0; j < keyframes.length; j++) {
-            const { H, matches, debugExtra: frameDebugExtra, } = match({
-                keyframe: keyframes[j],
-                querypoints: featurePoints,
-                querywidth: this.queryWidth,
-                queryheight: this.queryHeight,
-                debugMode: this.debugMode,
-                expectedScale,
-            });
-            if (frameDebugExtra) {
-                frameDebugExtra.keyframeIndex = j;
-                debugExtra.frames.push(frameDebugExtra);
-            }
-            if (H) {
-                if (bestResult === null || bestResult.matches.length < matches.length) {
-                    bestResult = { keyframeIndex: j, H, matches };
-                }
-            }
-        }
-        if (bestResult === null) {
-            return { targetIndex: -1, keyframeIndex: -1, debugExtra };
-        }
-        const screenCoords = [];
-        const worldCoords = [];
-        const keyframe = keyframes[bestResult.keyframeIndex];
-        const kfScale = keyframe.s || keyframe.scale || 1.0;
-        for (let i = 0; i < bestResult.matches.length; i++) {
-            const querypoint = bestResult.matches[i].querypoint;
-            const keypoint = bestResult.matches[i].keypoint;
-            // 🚀 NANITE-STYLE: Use per-keypoint scale (octave) for accurate world mapping
-            const pointScale = keypoint.scale || kfScale;
-            screenCoords.push({
-                x: querypoint.x,
-                y: querypoint.y,
-            });
-            worldCoords.push({
-                x: (keypoint.x + 0.5) / kfScale,
-                y: (keypoint.y + 0.5) / kfScale,
-                z: 0,
-            });
-        }
-        return {
-            screenCoords,
-            worldCoords,
-            targetIndex: -1, // Caller knows the targetIndex
-            keyframeIndex: bestResult.keyframeIndex,
-            H: bestResult.H,
-            debugExtra
-        };
-    }
-}
-export { Matcher };
+import{match as e}from"./matching.js";class t{constructor(e,t,r=!1){this.queryWidth=e,this.queryHeight=t,this.debugMode=r}matchDetection(t,r,s){let a={frames:[]},n=null;if(!t||!Array.isArray(t))return{targetIndex:-1,keyframeIndex:-1,debugExtra:a};for(let h=0;h<t.length;h++){const{H:d,matches:u,debugExtra:y}=e({keyframe:t[h],querypoints:r,querywidth:this.queryWidth,queryheight:this.queryHeight,debugMode:this.debugMode,expectedScale:s});y&&(y.keyframeIndex=h,a.frames.push(y)),d&&(null===n||n.matches.length<u.length)&&(n={keyframeIndex:h,H:d,matches:u})}if(null===n)return{targetIndex:-1,keyframeIndex:-1,debugExtra:a};const h=[],d=[],u=t[n.keyframeIndex],y=u.s||u.scale||1;for(let e=0;e<n.matches.length;e++){const t=n.matches[e].querypoint,r=n.matches[e].keypoint;r.scale,h.push({x:t.x,y:t.y}),d.push({x:(r.x+.5)/y,y:(r.y+.5)/y,z:0})}return{screenCoords:h,worldCoords:d,targetIndex:-1,keyframeIndex:n.keyframeIndex,H:n.H,debugExtra:a}}}export{t as Matcher};