@srsergio/taptapp-ar 1.0.61 → 1.0.64

package/dist/compiler/detector/crop-detector.js

@@ -8,7 +8,7 @@ class CropDetector {
         let minDimension = Math.min(width, height) / 2;
         let cropSize = Math.pow(2, Math.round(Math.log(minDimension) / Math.log(2)));
         this.cropSize = cropSize;
-        this.detector = new DetectorLite(cropSize, cropSize, { useLSH: true, maxOctaves: 1 });
+        this.detector = new DetectorLite(cropSize, cropSize, { useLSH: true });
         this.lastRandomIndex = 4;
     }
     detect(input) {

package/dist/compiler/node-worker.js

@@ -64,15 +64,40 @@ parentPort.on('message', async (msg) => {
     else if (msg.type === 'match') {
         const { targetImage, percentPerImage, basePercent } = msg;
         try {
-            const { buildImageList } = await import('./image-list.js');
-            const imageList = buildImageList(targetImage);
-            const percentPerScale = percentPerImage / imageList.length;
+            // 🚀 MOONSHOT: Only run detector ONCE on full-res image.
+            // DetectorLite internally builds a pyramid (octaves 1.0, 0.5, 0.25, etc.)
+            const detector = new DetectorLite(targetImage.width, targetImage.height, {
+                useLSH: true
+            });
+            parentPort.postMessage({ type: 'progress', percent: basePercent + percentPerImage * 0.1 });
+            const { featurePoints: allPoints } = detector.detect(targetImage.data);
+            parentPort.postMessage({ type: 'progress', percent: basePercent + percentPerImage * 0.5 });
+            // Group points by their scale (octave)
+            const scalesMap = new Map();
+            for (const p of allPoints) {
+                const octaveScale = p.scale;
+                let list = scalesMap.get(octaveScale);
+                if (!list) {
+                    list = [];
+                    scalesMap.set(octaveScale, list);
+                }
+                // Coordinates in p are already full-res. 
+                // We need them relative to the scaled image for the keyframe.
+                list.push({
+                    ...p,
+                    x: p.x / octaveScale,
+                    y: p.y / octaveScale,
+                    scale: 1.0 // Keypoint scale is always 1.0 relative to its own keyframe image
+                });
+            }
+            // Optional: Run another detector pass at an intermediate scale to improve coverage
+            // (e.g. at 1/1.41 ratio) if tracking robustness suffers. 
+            // For now, let's stick to octaves for MAXIMUM speed.
             const keyframes = [];
-            for (let i = 0; i < imageList.length; i++) {
-                const image = imageList[i];
-                // Disable internal pyramid (maxOctaves: 1) as we are already processing a scale list
-                const detector = new DetectorLite(image.width, image.height, { useLSH: true, maxOctaves: 1 });
-                const { featurePoints: ps } = detector.detect(image.data);
+            const sortedScales = Array.from(scalesMap.keys()).sort((a, b) => a - b);
+            const percentPerScale = (percentPerImage * 0.4) / sortedScales.length;
+            for (const s of sortedScales) {
+                const ps = scalesMap.get(s);
                 const sortedPs = sortPoints(ps);
                 const maximaPoints = sortedPs.filter((p) => p.maxima);
                 const minimaPoints = sortedPs.filter((p) => !p.maxima);
@@ -83,13 +108,13 @@ parentPort.on('message', async (msg) => {
                     minimaPoints,
                     maximaPointsCluster,
                     minimaPointsCluster,
-                    width: image.width,
-                    height: image.height,
-                    scale: image.scale,
+                    width: Math.round(targetImage.width / s),
+                    height: Math.round(targetImage.height / s),
+                    scale: 1.0 / s, // keyframe.scale is relative to full target image
                 });
                 parentPort.postMessage({
                     type: 'progress',
-                    percent: basePercent + (i + 1) * percentPerScale
+                    percent: basePercent + percentPerImage * 0.6 + keyframes.length * percentPerScale
                 });
             }
             parentPort.postMessage({

package/dist/compiler/offline-compiler.d.ts

@@ -12,10 +12,7 @@ export declare class OfflineCompiler {
     constructor();
     _initNodeWorkers(): Promise<void>;
     compileImageTargets(images: any[], progressCallback: (p: number) => void): Promise<any>;
-    _compileTarget(targetImages: any[], progressCallback: (p: number) => void): Promise<{
-        matchingData: any;
-        trackingData: any;
-    }[]>;
+    _compileTarget(targetImages: any[], progressCallback: (p: number) => void): Promise<any[]>;
     _compileMatch(targetImages: any[], progressCallback: (p: number) => void): Promise<any[]>;
     _compileTrack(targetImages: any[], progressCallback: (p: number) => void): Promise<any[]>;
     compileTrack({ progressCallback, targetImages, basePercent }: {

package/dist/compiler/offline-compiler.js

@@ -88,8 +88,22 @@ export class OfflineCompiler {
     async _compileTarget(targetImages, progressCallback) {
         if (isNode)
             await this._initNodeWorkers();
-        // Reverted: 'compile-all' combined task was causing issues with pyramid processing
-        // We go back to sequential match and track for reliability
+        if (this.workerPool) {
+            const progressMap = new Float32Array(targetImages.length);
+            const wrappedPromises = targetImages.map((targetImage, index) => {
+                return this.workerPool.runTask({
+                    type: 'compile-all', // 🚀 MOONSHOT: Combined task
+                    targetImage,
+                    onProgress: (p) => {
+                        progressMap[index] = p;
+                        const sum = progressMap.reduce((a, b) => a + b, 0);
+                        progressCallback(sum / targetImages.length);
+                    }
+                });
+            });
+            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) => ({
@@ -126,8 +140,7 @@ export class OfflineCompiler {
             const percentPerImageScale = percentPerImage / imageList.length;
             const keyframes = [];
             for (const image of imageList) {
-                // Disabling internal pyramid (maxOctaves: 1) as we are already processing a scale list
-                const detector = new DetectorLite(image.width, image.height, { useLSH: true, maxOctaves: 1 });
+                const detector = new DetectorLite(image.width, image.height, { useLSH: true });
                 const { featurePoints: ps } = detector.detect(image.data);
                 const maximaPoints = ps.filter((p) => p.maxima);
                 const minimaPoints = ps.filter((p) => !p.maxima);

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@srsergio/taptapp-ar",
-    "version": "1.0.61",
+    "version": "1.0.64",
     "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/detector/crop-detector.js

@@ -11,7 +11,7 @@ class CropDetector {
     let cropSize = Math.pow(2, Math.round(Math.log(minDimension) / Math.log(2)));
     this.cropSize = cropSize;
 
-    this.detector = new DetectorLite(cropSize, cropSize, { useLSH: true, maxOctaves: 1 });
+    this.detector = new DetectorLite(cropSize, cropSize, { useLSH: true });
 
     this.lastRandomIndex = 4;
   }

package/src/compiler/node-worker.js

@@ -71,17 +71,49 @@ parentPort.on('message', async (msg) => {
         const { targetImage, percentPerImage, basePercent } = msg;
 
         try {
-            const { buildImageList } = await import('./image-list.js');
-            const imageList = buildImageList(targetImage);
-            const percentPerScale = percentPerImage / imageList.length;
+            // 🚀 MOONSHOT: Only run detector ONCE on full-res image.
+            // DetectorLite internally builds a pyramid (octaves 1.0, 0.5, 0.25, etc.)
+            const detector = new DetectorLite(targetImage.width, targetImage.height, {
+                useLSH: true
+            });
+
+            parentPort.postMessage({ type: 'progress', percent: basePercent + percentPerImage * 0.1 });
+
+            const { featurePoints: allPoints } = detector.detect(targetImage.data);
+
+            parentPort.postMessage({ type: 'progress', percent: basePercent + percentPerImage * 0.5 });
+
+            // Group points by their scale (octave)
+            const scalesMap = new Map();
+            for (const p of allPoints) {
+                const octaveScale = p.scale;
+                let list = scalesMap.get(octaveScale);
+                if (!list) {
+                    list = [];
+                    scalesMap.set(octaveScale, list);
+                }
+
+                // Coordinates in p are already full-res. 
+                // We need them relative to the scaled image for the keyframe.
+                list.push({
+                    ...p,
+                    x: p.x / octaveScale,
+                    y: p.y / octaveScale,
+                    scale: 1.0 // Keypoint scale is always 1.0 relative to its own keyframe image
+                });
+            }
+
+            // Optional: Run another detector pass at an intermediate scale to improve coverage
+            // (e.g. at 1/1.41 ratio) if tracking robustness suffers. 
+            // For now, let's stick to octaves for MAXIMUM speed.
+
             const keyframes = [];
+            const sortedScales = Array.from(scalesMap.keys()).sort((a, b) => a - b);
 
-            for (let i = 0; i < imageList.length; i++) {
-                const image = imageList[i];
-                // Disable internal pyramid (maxOctaves: 1) as we are already processing a scale list
-                const detector = new DetectorLite(image.width, image.height, { useLSH: true, maxOctaves: 1 });
-                const { featurePoints: ps } = detector.detect(image.data);
+            const percentPerScale = (percentPerImage * 0.4) / sortedScales.length;
 
+            for (const s of sortedScales) {
+                const ps = scalesMap.get(s);
                 const sortedPs = sortPoints(ps);
                 const maximaPoints = sortedPs.filter((p) => p.maxima);
                 const minimaPoints = sortedPs.filter((p) => !p.maxima);
@@ -94,14 +126,14 @@ parentPort.on('message', async (msg) => {
                     minimaPoints,
                     maximaPointsCluster,
                     minimaPointsCluster,
-                    width: image.width,
-                    height: image.height,
-                    scale: image.scale,
+                    width: Math.round(targetImage.width / s),
+                    height: Math.round(targetImage.height / s),
+                    scale: 1.0 / s, // keyframe.scale is relative to full target image
                 });
 
                 parentPort.postMessage({
                     type: 'progress',
-                    percent: basePercent + (i + 1) * percentPerScale
+                    percent: basePercent + percentPerImage * 0.6 + keyframes.length * percentPerScale
                 });
             }
 

package/src/compiler/offline-compiler.ts

@@ -110,8 +110,23 @@ export class OfflineCompiler {
     async _compileTarget(targetImages: any[], progressCallback: (p: number) => void) {
         if (isNode) await this._initNodeWorkers();
 
-        // Reverted: 'compile-all' combined task was causing issues with pyramid processing
-        // We go back to sequential match and track for reliability
+        if (this.workerPool) {
+            const progressMap = new Float32Array(targetImages.length);
+            const wrappedPromises = targetImages.map((targetImage: any, index: number) => {
+                return this.workerPool!.runTask({
+                    type: 'compile-all', // 🚀 MOONSHOT: Combined task
+                    targetImage,
+                    onProgress: (p: number) => {
+                        progressMap[index] = p;
+                        const sum = progressMap.reduce((a, b) => a + b, 0);
+                        progressCallback(sum / targetImages.length);
+                    }
+                });
+            });
+            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));
 
@@ -155,8 +170,7 @@ export class OfflineCompiler {
             const keyframes = [];
 
             for (const image of imageList as any[]) {
-                // Disabling internal pyramid (maxOctaves: 1) as we are already processing a scale list
-                const detector = new DetectorLite(image.width, image.height, { useLSH: true, maxOctaves: 1 });
+                const detector = new DetectorLite(image.width, image.height, { useLSH: true });
                 const { featurePoints: ps } = detector.detect(image.data);
 
                 const maximaPoints = ps.filter((p: any) => p.maxima);