@srsergio/taptapp-ar 1.0.60 → 1.0.62

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/detector/detector-lite.d.ts

@@ -9,6 +9,7 @@ export class DetectorLite {
     useGPU: any;
     useLSH: any;
     numOctaves: number;
+    maxFeaturesPerBucket: any;
     /**
      * Detecta características en una imagen en escala de grises
      * @param {Float32Array|Uint8Array} imageData - Datos de imagen (width * height)

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

@@ -15,7 +15,6 @@ import { computeLSH64, computeFullFREAK, packLSHIntoDescriptor } from "../utils/
 const PYRAMID_MIN_SIZE = 4; // Restored to 4 for better small-scale detection
 // PYRAMID_MAX_OCTAVE ya no es necesario, el límite lo da PYRAMID_MIN_SIZE
 const NUM_BUCKETS_PER_DIMENSION = 10;
-const MAX_FEATURES_PER_BUCKET = 30; // Maximized to ensure robustness in Moonshot mode
 const ORIENTATION_NUM_BINS = 36;
 const FREAK_EXPANSION_FACTOR = 7.0;
 // Global GPU mode flag
@@ -48,6 +47,9 @@ export class DetectorLite {
                 break;
         }
         this.numOctaves = options.maxOctaves !== undefined ? Math.min(numOctaves, options.maxOctaves) : numOctaves;
+        // 🚀 SMART BITRATE (VBR): Internal logic to decide feature density based on scale
+        const scale = options.scale !== undefined ? options.scale : 1.0;
+        this.maxFeaturesPerBucket = options.maxFeaturesPerBucket || Math.max(4, Math.floor(12 * Math.sqrt(scale)));
     }
     /**
      * Detecta características en una imagen en escala de grises
@@ -305,7 +307,7 @@ export class DetectorLite {
      */
     _applyPrune(extremas) {
         const nBuckets = NUM_BUCKETS_PER_DIMENSION;
-        const nFeatures = MAX_FEATURES_PER_BUCKET;
+        const nFeatures = this.maxFeaturesPerBucket;
         // Agrupar por buckets
         const buckets = [];
         for (let i = 0; i < nBuckets * nBuckets; i++) {

package/dist/compiler/image-list.js

@@ -4,7 +4,7 @@ import { resize } from "./utils/images.js";
  * Un valor más bajo permite detectar imágenes más pequeñas pero aumenta el tiempo de procesamiento
  * @constant {number}
  */
-const MIN_IMAGE_PIXEL_SIZE = 32;
+const MIN_IMAGE_PIXEL_SIZE = 40; // Increased to 40 to skip extremely small, noisy layers and reduce size
 /**
  * Construye una lista de imágenes con diferentes escalas para detección de características
  * @param {Object} inputImage - Imagen de entrada con propiedades width, height y data
@@ -16,9 +16,8 @@ const buildImageList = (inputImage) => {
     let c = minScale;
     while (true) {
         scaleList.push(c);
-        // Optimization: Paso balanceado (aprox 1.5)
-        // Mejor cobertura que 2.0, pero mucho más ligero que 1.41 o 1.26
-        c *= Math.pow(2.0, 0.6);
+        // Optimization: More aggressive step (pow(2, 0.75) approx 1.68) for smaller exports
+        c *= Math.pow(2.0, 0.75);
         if (c >= 0.95) {
             c = 1;
             break;

package/dist/compiler/node-worker.js

@@ -64,40 +64,19 @@ 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];
+                // 🚀 SMART BITRATE (VBR): Now handled internally by DetectorLite via 'scale'
+                const detector = new DetectorLite(image.width, image.height, {
+                    useLSH: true,
+                    maxOctaves: 1,
+                    scale: image.scale
+                });
+                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 +87,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,12 @@ 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 });
+                // 🚀 SMART BITRATE (VBR): Internalized in DetectorLite
+                const detector = new DetectorLite(image.width, image.height, {
+                    useLSH: true,
+                    maxOctaves: 1,
+                    scale: image.scale
+                });
                 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.62",
     "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/detector/detector-lite.js

@@ -19,7 +19,6 @@ const PYRAMID_MIN_SIZE = 4; // Restored to 4 for better small-scale detection
 
 
 const NUM_BUCKETS_PER_DIMENSION = 10;
-const MAX_FEATURES_PER_BUCKET = 30; // Maximized to ensure robustness in Moonshot mode
 
 
 const ORIENTATION_NUM_BINS = 36;
@@ -58,6 +57,10 @@ export class DetectorLite {
         }
 
         this.numOctaves = options.maxOctaves !== undefined ? Math.min(numOctaves, options.maxOctaves) : numOctaves;
+
+        // 🚀 SMART BITRATE (VBR): Internal logic to decide feature density based on scale
+        const scale = options.scale !== undefined ? options.scale : 1.0;
+        this.maxFeaturesPerBucket = options.maxFeaturesPerBucket || Math.max(4, Math.floor(12 * Math.sqrt(scale)));
     }
 
     /**
@@ -350,7 +353,7 @@ export class DetectorLite {
      */
     _applyPrune(extremas) {
         const nBuckets = NUM_BUCKETS_PER_DIMENSION;
-        const nFeatures = MAX_FEATURES_PER_BUCKET;
+        const nFeatures = this.maxFeaturesPerBucket;
 
         // Agrupar por buckets
         const buckets = [];

package/src/compiler/image-list.js

@@ -5,7 +5,7 @@ import { resize } from "./utils/images.js";
  * Un valor más bajo permite detectar imágenes más pequeñas pero aumenta el tiempo de procesamiento
  * @constant {number}
  */
-const MIN_IMAGE_PIXEL_SIZE = 32;
+const MIN_IMAGE_PIXEL_SIZE = 40; // Increased to 40 to skip extremely small, noisy layers and reduce size
 
 
 
@@ -21,9 +21,8 @@ const buildImageList = (inputImage) => {
   let c = minScale;
   while (true) {
     scaleList.push(c);
-    // Optimization: Paso balanceado (aprox 1.5)
-    // Mejor cobertura que 2.0, pero mucho más ligero que 1.41 o 1.26
-    c *= Math.pow(2.0, 0.6);
+    // Optimization: More aggressive step (pow(2, 0.75) approx 1.68) for smaller exports
+    c *= Math.pow(2.0, 0.75);
     if (c >= 0.95) {
       c = 1;
       break;

package/src/compiler/node-worker.js

@@ -71,49 +71,22 @@ 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 });
+            const { buildImageList } = await import('./image-list.js');
+            const imageList = buildImageList(targetImage);
+            const percentPerScale = percentPerImage / imageList.length;
+            const keyframes = [];
 
-            // 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);
-                }
+            for (let i = 0; i < imageList.length; i++) {
+                const image = imageList[i];
 
-                // 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
+                // 🚀 SMART BITRATE (VBR): Now handled internally by DetectorLite via 'scale'
+                const detector = new DetectorLite(image.width, image.height, {
+                    useLSH: true,
+                    maxOctaves: 1,
+                    scale: image.scale
                 });
-            }
+                const { featurePoints: ps } = detector.detect(image.data);
 
-            // 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);
-
-            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);
@@ -126,14 +99,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,12 @@ export class OfflineCompiler {
             const keyframes = [];
 
             for (const image of imageList as any[]) {
-                const detector = new DetectorLite(image.width, image.height, { useLSH: true });
+                // 🚀 SMART BITRATE (VBR): Internalized in DetectorLite
+                const detector = new DetectorLite(image.width, image.height, {
+                    useLSH: true,
+                    maxOctaves: 1,
+                    scale: image.scale
+                });
                 const { featurePoints: ps } = detector.detect(image.data);
 
                 const maximaPoints = ps.filter((p: any) => p.maxima);