@srsergio/taptapp-ar 1.0.89 → 1.0.90

package/dist/core/matching/hdc.js

@@ -0,0 +1,102 @@
+/**
+ * Hyperdimensional Computing (HDC) Core for AR
+ *
+ * Provides ultra-fast, ultra-compressed feature matching using
+ * High-Dimensional Random Vectors.
+ */
+export const HDC_DIMENSION = 1024; // bits
+export const HDC_WORDS = HDC_DIMENSION / 32;
+/**
+ * Deterministic Random Number Generator (PCG-like)
+ */
+class PRNG {
+    state;
+    constructor(seed) {
+        this.state = seed;
+    }
+    next() {
+        this.state = (this.state * 1664525 + 1013904223) >>> 0;
+        return this.state / 0xFFFFFFFF;
+    }
+}
+/**
+ * Generates a deterministic basis of Hypervectors
+ */
+export function generateBasis(seed, count) {
+    const prng = new PRNG(seed);
+    const basis = [];
+    for (let i = 0; i < count; i++) {
+        const hv = new Uint32Array(HDC_WORDS);
+        for (let j = 0; j < HDC_WORDS; j++) {
+            hv[j] = (prng.next() * 0xFFFFFFFF) >>> 0;
+        }
+        basis.push(hv);
+    }
+    return basis;
+}
+/**
+ * Projects a 64-bit descriptor into the Hyperdimensional Space
+ * Uses "Random Projection" logic (Locality Sensitive Hashing in HDC)
+ */
+export function projectDescriptor(desc, basis) {
+    const result = new Uint32Array(HDC_WORDS);
+    // For each bit in the HDC space
+    for (let i = 0; i < HDC_DIMENSION; i++) {
+        const wordIdx = i >>> 5;
+        const bitIdx = i & 31;
+        // This is a simplified random projection
+        // In a real HDC system, we'd use more complex binding
+        // But for Vanilla JS performance, we use bitwise voting
+        let sum = 0;
+        const b = basis[i % basis.length];
+        // Dot product between descriptor and basis vector (subset)
+        // desc[0] and desc[1] are the 64 bits
+        for (let j = 0; j < 2; j++) {
+            sum += popcount(desc[j] & b[j]);
+        }
+        if (sum > 16) { // Threshold for "firing"
+            result[wordIdx] |= (1 << bitIdx);
+        }
+    }
+    return result;
+}
+/**
+ * Compresses an HDC vector into an "Ultra-Short Signature" (32 bits)
+ * This allows storing 1000 points in just 4KB of descriptors.
+ */
+export function compressToSignature(hv) {
+    // FNV-1a Hash for robust 32-bit compression
+    let h1 = 0x811c9dc5;
+    for (let i = 0; i < hv.length; i++) {
+        h1 ^= hv[i];
+        h1 = Math.imul(h1, 0x01000193);
+    }
+    return h1 >>> 0;
+}
+function popcount(n) {
+    n = n - ((n >> 1) & 0x55555555);
+    n = (n & 0x33333333) + ((n >> 2) & 0x33333333);
+    return (((n + (n >> 4)) & 0x0F0F0F0F) * 0x01010101) >> 24;
+}
+/**
+ * Bundles multiple points into a single Global Hypervector (The "Image DNA")
+ * This allows checking if an image is present with ONE vector comparison.
+ */
+export function bundle(hvs) {
+    const global = new Uint32Array(HDC_WORDS);
+    const threshold = hvs.length / 2;
+    const counters = new Uint16Array(HDC_DIMENSION);
+    for (const hv of hvs) {
+        for (let i = 0; i < HDC_DIMENSION; i++) {
+            if (hv[i >>> 5] & (1 << (i & 31))) {
+                counters[i]++;
+            }
+        }
+    }
+    for (let i = 0; i < HDC_DIMENSION; i++) {
+        if (counters[i] > threshold) {
+            global[i >>> 5] |= (1 << (i & 31));
+        }
+    }
+    return global;
+}

package/dist/core/matching/hierarchical-clustering.d.ts

@@ -1,6 +1,4 @@
-/**
- * Build hierarchical clusters
- */
+export function popcount32(n: any): number;
 export function build({ points }: {
     points: any;
 }): {

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

@@ -1,18 +1,15 @@
 import { compute64 as hammingCompute64 } from "./hamming-distance.js";
 import { createRandomizer } from "../utils/randomizer.js";
-const MIN_FEATURE_PER_NODE = 32; // Increased from 16 for speed
-const NUM_ASSIGNMENT_HYPOTHESES = 12; // Reduced from 16 for speed
+const MIN_FEATURE_PER_NODE = 32;
+const NUM_ASSIGNMENT_HYPOTHESES = 12;
 const NUM_CENTERS = 8;
-/**
- * 🚀 Moonshot Optimized K-Medoids
- *
- * Major Optimizations:
- * 1. Flattened Memory: Operates on a single Uint32Array block instead of objects.
- * 2. Zero Property Access: Avoids .descriptors lookup in the tightest loop.
- * 3. Cache-Friendly: Accesses contiguous descriptor data.
- */
+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 } = options;
+    const { descriptors, pointIndexes, randomizer, useHDC } = options;
     const numPointIndexes = pointIndexes.length;
     const randomPointIndexes = new Int32Array(numPointIndexes);
     for (let i = 0; i < numPointIndexes; i++) {
@@ -20,11 +17,9 @@ const _computeKMedoids = (options) => {
     }
     let bestSumD = Number.MAX_SAFE_INTEGER;
     let bestAssignment = null;
-    // Pre-fetch centers indices to avoid nested index lookups
     const centerPointIndices = new Int32Array(NUM_CENTERS);
     for (let i = 0; i < NUM_ASSIGNMENT_HYPOTHESES; i++) {
         randomizer.arrayShuffle({ arr: randomPointIndexes, sampleSize: NUM_CENTERS });
-        // Set centers for this hypothesis
         for (let k = 0; k < NUM_CENTERS; k++) {
             centerPointIndices[k] = pointIndexes[randomPointIndexes[k]];
         }
@@ -32,14 +27,17 @@ const _computeKMedoids = (options) => {
         const currentAssignment = new Int32Array(numPointIndexes);
         for (let j = 0; j < numPointIndexes; j++) {
             const pIdx = pointIndexes[j];
-            const pOffset = pIdx * 2;
-            let bestD = 255; // Max possible Hamming for 64-bit is 64, but let's be safe
+            let bestD = 255;
             let bestCenterIdx = -1;
             for (let k = 0; k < NUM_CENTERS; k++) {
                 const cIdx = centerPointIndices[k];
-                const cOffset = cIdx * 2;
-                // DIRECT CALL TO INLINED HAMMING
-                const d = hammingCompute64(descriptors, pOffset, descriptors, cOffset);
+                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;
@@ -55,20 +53,21 @@ const _computeKMedoids = (options) => {
     }
     return bestAssignment;
 };
-/**
- * Build hierarchical clusters
- */
 const build = ({ points }) => {
     const numPoints = points.length;
     if (numPoints === 0)
         return { rootNode: { leaf: true, pointIndexes: [], centerPointIndex: null } };
-    // 🚀 MOONSHOT: Flatten all descriptors into a single Uint32Array
-    // This is the key to sub-second performance.
-    const descriptors = new Uint32Array(numPoints * 2);
+    const useHDC = points[0] && points[0].hdcSignature !== undefined;
+    const descriptors = new Uint32Array(useHDC ? numPoints : numPoints * 2);
     for (let i = 0; i < numPoints; i++) {
-        const d = points[i].descriptors;
-        descriptors[i * 2] = d[0];
-        descriptors[i * 2 + 1] = d[1];
+        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++) {
@@ -80,11 +79,12 @@ const build = ({ points }) => {
         pointIndexes,
         centerPointIndex: null,
         randomizer,
+        useHDC
     });
     return { rootNode };
 };
 const _build = (options) => {
-    const { descriptors, pointIndexes, centerPointIndex, randomizer } = options;
+    const { descriptors, pointIndexes, centerPointIndex, randomizer, useHDC } = options;
     const numPoints = pointIndexes.length;
     let isLeaf = false;
     if (numPoints <= NUM_CENTERS || numPoints <= MIN_FEATURE_PER_NODE) {
@@ -92,7 +92,7 @@ const _build = (options) => {
     }
     const clusters = new Map();
     if (!isLeaf) {
-        const assignment = _computeKMedoids({ descriptors, pointIndexes, randomizer });
+        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);
@@ -122,6 +122,7 @@ const _build = (options) => {
             pointIndexes: new Int32Array(clusterPoints),
             centerPointIndex: cIdx,
             randomizer,
+            useHDC
         }));
     }
     return node;

package/dist/core/matching/hough.js

@@ -7,9 +7,9 @@ const computeHoughMatches = (options) => {
     const maxY = queryheight * 1.2;
     const minY = -maxY;
     const numAngleBins = 12;
-    const numScaleBins = 10;
-    const minScale = -1;
-    const maxScale = 1;
+    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);
@@ -31,9 +31,9 @@ const computeHoughMatches = (options) => {
         return a1 - a2;
     });
     const medianProjectedDim = projectedDims[Math.floor(projectedDims.length / 2) - (projectedDims.length % 2 == 0 ? 1 : 0) - 1];
-    const binSize = 0.25 * medianProjectedDim;
-    const numXBins = Math.max(5, Math.ceil((maxX - minX) / binSize));
-    const numYBins = Math.max(5, Math.ceil((maxY - minY) / binSize));
+    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
@@ -120,25 +120,26 @@ const computeHoughMatches = (options) => {
     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 voted: ", {binX, binY, binAngle, binScale, maxVoteIndex});
+    // 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 >= kHoughBinDelta)
+        if (distBinX >= relaxedDelta)
             continue;
         const distBinY = Math.abs(queryBins.binY - (binY + 0.5));
-        if (distBinY >= kHoughBinDelta)
+        if (distBinY >= relaxedDelta)
             continue;
         const distBinScale = Math.abs(queryBins.binScale - (binScale + 0.5));
-        if (distBinScale >= kHoughBinDelta)
+        if (distBinScale >= relaxedDelta)
             continue;
         const temp = Math.abs(queryBins.binAngle - (binAngle + 0.5));
         const distBinAngle = Math.min(temp, numAngleBins - temp);
-        if (distBinAngle >= kHoughBinDelta)
+        if (distBinAngle >= relaxedDelta)
             continue;
         houghMatches.push(matches[i]);
     }

package/dist/core/matching/matcher.d.ts

@@ -4,12 +4,14 @@ export class Matcher {
     queryHeight: any;
     debugMode: boolean;
     matchDetection(keyframes: any, featurePoints: any): {
+        targetIndex: number;
         keyframeIndex: number;
         debugExtra: {
             frames: never[];
         };
         screenCoords?: undefined;
         worldCoords?: undefined;
+        H?: undefined;
     } | {
         screenCoords: {
             x: any;
@@ -20,7 +22,9 @@ export class Matcher {
             y: number;
             z: number;
         }[];
+        targetIndex: number;
         keyframeIndex: number;
+        H: any[];
         debugExtra: {
             frames: never[];
         };

package/dist/core/matching/matcher.js

@@ -8,27 +8,35 @@ class Matcher {
     matchDetection(keyframes, featurePoints) {
         let debugExtra = { frames: [] };
         let bestResult = null;
-        for (let i = 0; i < keyframes.length; i++) {
+        // 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[i],
+                keyframe: keyframes[j],
                 querypoints: featurePoints,
                 querywidth: this.queryWidth,
                 queryheight: this.queryHeight,
                 debugMode: this.debugMode,
             });
-            debugExtra.frames.push(frameDebugExtra);
+            if (frameDebugExtra) {
+                frameDebugExtra.keyframeIndex = j;
+                debugExtra.frames.push(frameDebugExtra);
+            }
             if (H) {
                 if (bestResult === null || bestResult.matches.length < matches.length) {
-                    bestResult = { keyframeIndex: i, H, matches };
+                    bestResult = { keyframeIndex: j, H, matches };
                 }
             }
         }
         if (bestResult === null) {
-            return { keyframeIndex: -1, debugExtra };
+            return { targetIndex: -1, keyframeIndex: -1, debugExtra };
         }
         const screenCoords = [];
         const worldCoords = [];
         const keyframe = keyframes[bestResult.keyframeIndex];
+        const scale = 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;
@@ -37,12 +45,19 @@ class Matcher {
                 y: querypoint.y,
             });
             worldCoords.push({
-                x: (keypoint.x + 0.5) / (keyframe.s || keyframe.scale || 1.0),
-                y: (keypoint.y + 0.5) / (keyframe.s || keyframe.scale || 1.0),
+                x: (keypoint.x + 0.5) / scale,
+                y: (keypoint.y + 0.5) / scale,
                 z: 0,
             });
         }
-        return { screenCoords, worldCoords, keyframeIndex: bestResult.keyframeIndex, debugExtra };
+        return {
+            screenCoords,
+            worldCoords,
+            targetIndex: -1, // Caller knows the targetIndex
+            keyframeIndex: bestResult.keyframeIndex,
+            H: bestResult.H,
+            debugExtra
+        };
     }
 }
 export { Matcher };

package/dist/core/matching/matching.d.ts

@@ -1,4 +1,4 @@
-export function match({ keyframe, querypoints, querywidth, queryheight, debugMode }: {
+export function match({ keyframe, querypoints: rawQuerypoints, querywidth, queryheight, debugMode }: {
     keyframe: any;
     querypoints: any;
     querywidth: any;
@@ -6,6 +6,16 @@ export function match({ keyframe, querypoints, querywidth, queryheight, debugMod
     debugMode: any;
 }): {
     debugExtra: {
+        constellationMatches: {
+            querypoint: any;
+            keypoint: {
+                x: any;
+                y: any;
+                angle: any;
+                scale: any;
+            };
+            d: number;
+        }[];
         houghMatches: any[];
         inlierMatches: any[];
         matches2: {
@@ -23,9 +33,19 @@ export function match({ keyframe, querypoints, querywidth, queryheight, debugMod
     H?: undefined;
     matches?: undefined;
 } | {
-    H: number[];
+    H: any[];
     matches: any[];
     debugExtra: {
+        constellationMatches: {
+            querypoint: any;
+            keypoint: {
+                x: any;
+                y: any;
+                angle: any;
+                scale: any;
+            };
+            d: number;
+        }[];
         houghMatches: any[];
         inlierMatches: any[];
         matches2: {