@srsergio/taptapp-ar 1.0.59 → 1.0.60

package/dist/compiler/offline-compiler.js

@@ -103,13 +103,76 @@ export class OfflineCompiler {
             });
             return Promise.all(wrappedPromises);
         }
-        // Fallback or non-worker implementation: run match and track sequentially
-        const matchingResults = await this._compileMatch(targetImages, (p) => progressCallback(p * 0.5));
-        const trackingResults = await this._compileTrack(targetImages, (p) => progressCallback(50 + p * 0.5));
-        return targetImages.map((_, i) => ({
-            matchingData: matchingResults[i],
-            trackingData: trackingResults[i]
-        }));
+        // 🚀 MOONSHOT BROWSER FALLBACK:
+        // Combined detection to avoid redundant pyramid processing
+        const results = [];
+        for (let i = 0; i < targetImages.length; i++) {
+            const targetImage = targetImages[i];
+            // 1. Single Pass Detection + Pyramid Generation
+            const detector = new DetectorLite(targetImage.width, targetImage.height, { useLSH: true });
+            progressCallback((i / targetImages.length) * 100 + 10);
+            const { featurePoints, pyramid } = detector.detect(targetImage.data);
+            progressCallback((i / targetImages.length) * 100 + 40);
+            // 2. Extract Tracking Data using the ALREADY BLURRED pyramid
+            const trackingImageList = [];
+            const targetSizes = [256, 128];
+            for (const targetSize of targetSizes) {
+                let bestLevel = 0;
+                let minDiff = Math.abs(Math.min(targetImage.width, targetImage.height) - targetSize);
+                for (let l = 1; l < pyramid.length; l++) {
+                    const img = pyramid[l][0];
+                    const diff = Math.abs(Math.min(img.width, img.height) - targetSize);
+                    if (diff < minDiff) {
+                        minDiff = diff;
+                        bestLevel = l;
+                    }
+                }
+                const levelImg = pyramid[bestLevel][0];
+                trackingImageList.push({
+                    data: levelImg.data,
+                    width: levelImg.width,
+                    height: levelImg.height,
+                    scale: levelImg.width / targetImage.width
+                });
+            }
+            const trackingData = extractTrackingFeatures(trackingImageList, () => { });
+            progressCallback((i / targetImages.length) * 100 + 60);
+            // 3. Build Keyframes for Matching (Group by scale)
+            const scalesMap = new Map();
+            for (const p of featurePoints) {
+                const s = p.scale;
+                let list = scalesMap.get(s);
+                if (!list) {
+                    list = [];
+                    scalesMap.set(s, list);
+                }
+                list.push({ ...p, x: p.x / s, y: p.y / s, scale: 1.0 });
+            }
+            const keyframes = [];
+            const sortedScales = Array.from(scalesMap.keys()).sort((a, b) => a - b);
+            for (const s of sortedScales) {
+                const ps = scalesMap.get(s);
+                const maximaPoints = ps.filter((p) => p.maxima);
+                const minimaPoints = ps.filter((p) => !p.maxima);
+                const maximaPointsCluster = hierarchicalClusteringBuild({ points: maximaPoints });
+                const minimaPointsCluster = hierarchicalClusteringBuild({ points: minimaPoints });
+                keyframes.push({
+                    maximaPoints,
+                    minimaPoints,
+                    maximaPointsCluster,
+                    minimaPointsCluster,
+                    width: Math.round(targetImage.width / s),
+                    height: Math.round(targetImage.height / s),
+                    scale: 1.0 / s,
+                });
+            }
+            results.push({
+                matchingData: keyframes,
+                trackingData: trackingData
+            });
+            progressCallback(((i + 1) / targetImages.length) * 100);
+        }
+        return results;
     }
     async _compileMatch(targetImages, progressCallback) {
         const percentPerImage = 100 / targetImages.length;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@srsergio/taptapp-ar",
-    "version": "1.0.59",
+    "version": "1.0.60",
     "author": "Sergio Lazaro <srsergiolazaro@gmail.com>",
     "license": "GPL-3.0",
     "description": "Ultra-fast, lightweight Augmented Reality Image Tracking SDK for the web. Features an optimized offline compiler, React components, and compatibility with Three.js/A-Frame. No heavy ML frameworks required.",

package/src/compiler/offline-compiler.ts

@@ -126,14 +126,87 @@ export class OfflineCompiler {
             return Promise.all(wrappedPromises);
         }
 
-        // Fallback or non-worker implementation: run match and track sequentially
-        const matchingResults = await this._compileMatch(targetImages, (p) => progressCallback(p * 0.5));
-        const trackingResults = await this._compileTrack(targetImages, (p) => progressCallback(50 + p * 0.5));
+        // 🚀 MOONSHOT BROWSER FALLBACK:
+        // Combined detection to avoid redundant pyramid processing
+        const results = [];
+        for (let i = 0; i < targetImages.length; i++) {
+            const targetImage = targetImages[i];
 
-        return targetImages.map((_, i) => ({
-            matchingData: matchingResults[i],
-            trackingData: trackingResults[i]
-        }));
+            // 1. Single Pass Detection + Pyramid Generation
+            const detector = new DetectorLite(targetImage.width, targetImage.height, { useLSH: true });
+            progressCallback((i / targetImages.length) * 100 + 10);
+
+            const { featurePoints, pyramid }: any = detector.detect(targetImage.data);
+            progressCallback((i / targetImages.length) * 100 + 40);
+
+            // 2. Extract Tracking Data using the ALREADY BLURRED pyramid
+            const trackingImageList: any[] = [];
+            const targetSizes = [256, 128];
+            for (const targetSize of targetSizes) {
+                let bestLevel = 0;
+                let minDiff = Math.abs(Math.min(targetImage.width, targetImage.height) - targetSize);
+
+                for (let l = 1; l < pyramid.length; l++) {
+                    const img = pyramid[l][0];
+                    const diff = Math.abs(Math.min(img.width, img.height) - targetSize);
+                    if (diff < minDiff) {
+                        minDiff = diff;
+                        bestLevel = l;
+                    }
+                }
+
+                const levelImg = pyramid[bestLevel][0];
+                trackingImageList.push({
+                    data: levelImg.data,
+                    width: levelImg.width,
+                    height: levelImg.height,
+                    scale: levelImg.width / targetImage.width
+                });
+            }
+
+            const trackingData = extractTrackingFeatures(trackingImageList, () => { });
+            progressCallback((i / targetImages.length) * 100 + 60);
+
+            // 3. Build Keyframes for Matching (Group by scale)
+            const scalesMap = new Map();
+            for (const p of featurePoints) {
+                const s = p.scale;
+                let list = scalesMap.get(s);
+                if (!list) {
+                    list = [];
+                    scalesMap.set(s, list);
+                }
+                list.push({ ...p, x: p.x / s, y: p.y / s, scale: 1.0 });
+            }
+
+            const keyframes = [];
+            const sortedScales = Array.from(scalesMap.keys()).sort((a, b) => a - b);
+            for (const s of sortedScales) {
+                const ps = scalesMap.get(s);
+                const maximaPoints = ps.filter((p: any) => p.maxima);
+                const minimaPoints = ps.filter((p: any) => !p.maxima);
+                const maximaPointsCluster = hierarchicalClusteringBuild({ points: maximaPoints });
+                const minimaPointsCluster = hierarchicalClusteringBuild({ points: minimaPoints });
+
+                keyframes.push({
+                    maximaPoints,
+                    minimaPoints,
+                    maximaPointsCluster,
+                    minimaPointsCluster,
+                    width: Math.round(targetImage.width / s),
+                    height: Math.round(targetImage.height / s),
+                    scale: 1.0 / s,
+                });
+            }
+
+            results.push({
+                matchingData: keyframes,
+                trackingData: trackingData
+            });
+            progressCallback(((i + 1) / targetImages.length) * 100);
+        }
+
+        return results;
     }
 
     async _compileMatch(targetImages: any[], progressCallback: (p: number) => void) {