@srsergio/taptapp-ar 1.0.59 → 1.0.61

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 });
+        this.detector = new DetectorLite(cropSize, cropSize, { useLSH: true, maxOctaves: 1 });
         this.lastRandomIndex = 4;
     }
     detect(input) {

package/dist/compiler/node-worker.js

@@ -64,40 +64,15 @@ parentPort.on('message', async (msg) => {
     else if (msg.type === 'match') {
         const { targetImage, percentPerImage, basePercent } = msg;
         try {
-            // 🚀 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 { buildImageList } = await import('./image-list.js');
+            const imageList = buildImageList(targetImage);
+            const percentPerScale = percentPerImage / imageList.length;
             const keyframes = [];
-            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);
+            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 sortedPs = sortPoints(ps);
                 const maximaPoints = sortedPs.filter((p) => p.maxima);
                 const minimaPoints = sortedPs.filter((p) => !p.maxima);
@@ -108,13 +83,13 @@ parentPort.on('message', async (msg) => {
                     minimaPoints,
                     maximaPointsCluster,
                     minimaPointsCluster,
-                    width: Math.round(targetImage.width / s),
-                    height: Math.round(targetImage.height / s),
-                    scale: 1.0 / s, // keyframe.scale is relative to full target image
+                    width: image.width,
+                    height: image.height,
+                    scale: image.scale,
                 });
                 parentPort.postMessage({
                     type: 'progress',
-                    percent: basePercent + percentPerImage * 0.6 + keyframes.length * percentPerScale
+                    percent: basePercent + (i + 1) * percentPerScale
                 });
             }
             parentPort.postMessage({

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

@@ -12,7 +12,10 @@ 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<any[]>;
+    _compileTarget(targetImages: any[], progressCallback: (p: number) => void): Promise<{
+        matchingData: any;
+        trackingData: 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,22 +88,8 @@ export class OfflineCompiler {
     async _compileTarget(targetImages, progressCallback) {
         if (isNode)
             await this._initNodeWorkers();
-        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
+        // Reverted: 'compile-all' combined task was causing issues with pyramid processing
+        // We go back to sequential match and track for reliability
         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) => ({
@@ -140,7 +126,8 @@ export class OfflineCompiler {
             const percentPerImageScale = percentPerImage / imageList.length;
             const keyframes = [];
             for (const image of imageList) {
-                const detector = new DetectorLite(image.width, image.height, { useLSH: true });
+                // 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 { 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.59",
+    "version": "1.0.61",
     "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 });
+    this.detector = new DetectorLite(cropSize, cropSize, { useLSH: true, maxOctaves: 1 });
 
     this.lastRandomIndex = 4;
   }

package/src/compiler/node-worker.js

@@ -71,49 +71,17 @@ parentPort.on('message', async (msg) => {
         const { targetImage, percentPerImage, basePercent } = msg;
 
         try {
-            // 🚀 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 { buildImageList } = await import('./image-list.js');
+            const imageList = buildImageList(targetImage);
+            const percentPerScale = percentPerImage / imageList.length;
             const keyframes = [];
-            const sortedScales = Array.from(scalesMap.keys()).sort((a, b) => a - b);
 
-            const percentPerScale = (percentPerImage * 0.4) / sortedScales.length;
+            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);
 
-            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);
@@ -126,14 +94,14 @@ parentPort.on('message', async (msg) => {
                     minimaPoints,
                     maximaPointsCluster,
                     minimaPointsCluster,
-                    width: Math.round(targetImage.width / s),
-                    height: Math.round(targetImage.height / s),
-                    scale: 1.0 / s, // keyframe.scale is relative to full target image
+                    width: image.width,
+                    height: image.height,
+                    scale: image.scale,
                 });
 
                 parentPort.postMessage({
                     type: 'progress',
-                    percent: basePercent + percentPerImage * 0.6 + keyframes.length * percentPerScale
+                    percent: basePercent + (i + 1) * percentPerScale
                 });
             }
 

package/src/compiler/offline-compiler.ts

@@ -110,23 +110,8 @@ export class OfflineCompiler {
     async _compileTarget(targetImages: any[], progressCallback: (p: number) => void) {
         if (isNode) await this._initNodeWorkers();
 
-        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
+        // Reverted: 'compile-all' combined task was causing issues with pyramid processing
+        // We go back to sequential match and track for reliability
         const matchingResults = await this._compileMatch(targetImages, (p) => progressCallback(p * 0.5));
         const trackingResults = await this._compileTrack(targetImages, (p) => progressCallback(50 + p * 0.5));
 
@@ -170,7 +155,8 @@ export class OfflineCompiler {
             const keyframes = [];
 
             for (const image of imageList as any[]) {
-                const detector = new DetectorLite(image.width, image.height, { useLSH: true });
+                // 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 { featurePoints: ps } = detector.detect(image.data);
 
                 const maximaPoints = ps.filter((p: any) => p.maxima);