@srsergio/taptapp-ar 1.0.60 → 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,91 +88,14 @@ 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);
-        }
-        // 🚀 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;
+        // 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) => ({
+            matchingData: matchingResults[i],
+            trackingData: trackingResults[i]
+        }));
     }
     async _compileMatch(targetImages, progressCallback) {
         const percentPerImage = 100 / targetImages.length;
@@ -203,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.60",
+    "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,103 +110,15 @@ 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);
-        }
-
-        // 🚀 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 }: 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;
+        // 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) => ({
+            matchingData: matchingResults[i],
+            trackingData: trackingResults[i]
+        }));
     }
 
     async _compileMatch(targetImages: any[], progressCallback: (p: number) => void) {
@@ -243,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);