@srsergio/taptapp-ar 1.0.8 → 1.0.10

package/dist/compiler/offline-compiler.js

@@ -19,6 +19,7 @@ import { extractTrackingFeatures } from "./tracker/extract-utils.js";
 import { DetectorLite } from "./detector/detector-lite.js";
 import { build as hierarchicalClusteringBuild } from "./matching/hierarchical-clustering.js";
 import * as msgpack from "@msgpack/msgpack";
+import { WorkerPool } from "./utils/worker-pool.js";
 // Detect environment
 const isNode = typeof process !== "undefined" &&
     process.versions != null &&
@@ -41,21 +42,27 @@ export class OfflineCompiler {
     }
     async _initNodeWorkers() {
         try {
-            const [os, path, url, workerModule] = await Promise.all([
-                import("os"),
-                import("path"),
-                import("url"),
-                import("./utils/worker-pool.js")
+            // Use variables to prevent bundlers from trying to bundle these
+            const pathModule = "path";
+            const urlModule = "url";
+            const osModule = "os";
+            const workerThreadsModule = "node:worker_threads";
+            const [path, url, os, { Worker }] = await Promise.all([
+                import(pathModule),
+                import(urlModule),
+                import(osModule),
+                import(workerThreadsModule)
             ]);
             const __filename = url.fileURLToPath(import.meta.url);
             const __dirname = path.dirname(__filename);
             const workerPath = path.join(__dirname, "node-worker.js");
+            // Limit workers to avoid freezing system
             const numWorkers = Math.min(os.cpus().length, 4);
-            this.workerPool = new workerModule.WorkerPool(workerPath, numWorkers);
+            this.workerPool = new WorkerPool(workerPath, numWorkers, Worker);
             console.log(`🚀 OfflineCompiler: Node.js mode with ${numWorkers} workers`);
         }
         catch (e) {
-            console.log("⚡ OfflineCompiler: Running without workers");
+            console.log("⚡ OfflineCompiler: Running without workers (initialization failed)", e);
         }
     }
     /**
@@ -89,40 +96,48 @@ export class OfflineCompiler {
             }
             targetImages.push({
                 data: greyImageData,
-                height: img.height,
                 width: img.width,
+                height: img.height,
             });
         }
-        // Fase 1: Matching (50%)
-        console.time("⏱️ Fase Matching");
-        const matchingDataList = await this._compileMatch(targetImages, (percent) => {
-            progressCallback(percent * 0.5);
+        // Compilar Match y Track por separado
+        const matchingDataList = await this._compileMatch(targetImages, (p) => {
+            progressCallback(p * 0.7); // 70% Match
         });
-        console.timeEnd("⏱️ Fase Matching");
-        // Fase 2: Tracking (50%)
-        console.time("⏱️ Fase Tracking");
-        const trackingDataList = await this._compileTrack(targetImages, (percent) => {
-            progressCallback(50 + percent * 0.5);
+        const trackingDataList = await this._compileTrack(targetImages, (p) => {
+            progressCallback(70 + p * 0.3); // 30% Track
         });
-        console.timeEnd("⏱️ Fase Tracking");
-        // Compilar resultado
-        this.data = targetImages.map((targetImage, i) => ({
-            targetImage: { width: targetImage.width, height: targetImage.height },
-            trackingData: trackingDataList[i],
+        this.data = targetImages.map((img, i) => ({
+            targetImage: img,
             matchingData: matchingDataList[i],
+            trackingData: trackingDataList[i],
         }));
         console.timeEnd("⏱️ Compilación total");
         return this.data;
     }
-    /**
-     * Compila datos de matching usando DetectorLite (JS puro)
-     */
     async _compileMatch(targetImages, progressCallback) {
         const percentPerImage = 100 / targetImages.length;
         let currentPercent = 0;
+        // Use workers if available
+        if (this.workerPool) {
+            const progressMap = new Float32Array(targetImages.length);
+            const wrappedPromises = targetImages.map((targetImage, index) => {
+                return this.workerPool.runTask({
+                    type: 'match',
+                    targetImage,
+                    percentPerImage,
+                    basePercent: 0,
+                    onProgress: (p) => {
+                        progressMap[index] = p;
+                        const sum = progressMap.reduce((a, b) => a + b, 0);
+                        progressCallback(sum);
+                    }
+                });
+            });
+            return Promise.all(wrappedPromises);
+        }
+        // Serial Fallback
         const results = [];
-        // Procesar secuencialmente para evitar overhead de workers
-        // (los workers son útiles para muchas imágenes, pero añaden latencia)
         for (let i = 0; i < targetImages.length; i++) {
             const targetImage = targetImages[i];
             const imageList = buildImageList(targetImage);
@@ -151,12 +166,27 @@ export class OfflineCompiler {
         }
         return results;
     }
-    /**
-     * Compila datos de tracking usando extractTrackingFeatures (JS puro)
-     */
     async _compileTrack(targetImages, progressCallback) {
         const percentPerImage = 100 / targetImages.length;
         let currentPercent = 0;
+        if (this.workerPool) {
+            const progressMap = new Float32Array(targetImages.length);
+            const wrappedPromises = targetImages.map((targetImage, index) => {
+                return this.workerPool.runTask({
+                    type: 'compile',
+                    targetImage,
+                    percentPerImage,
+                    basePercent: 0,
+                    onProgress: (p) => {
+                        progressMap[index] = p;
+                        const sum = progressMap.reduce((a, b) => a + b, 0);
+                        progressCallback(sum);
+                    }
+                });
+            });
+            return Promise.all(wrappedPromises);
+        }
+        // Serial Fallback
         const results = [];
         for (let i = 0; i < targetImages.length; i++) {
             const targetImage = targetImages[i];
@@ -170,38 +200,22 @@ export class OfflineCompiler {
         }
         return results;
     }
-    /**
-     * Método público para compilar tracking (compatibilidad con API anterior)
-     * @param {Object} options - Opciones de compilación
-     * @param {Function} options.progressCallback - Callback de progreso
-     * @param {Array} options.targetImages - Lista de imágenes objetivo
-     * @param {number} options.basePercent - Porcentaje base
-     * @returns {Promise<Array>} Datos de tracking
-     */
     async compileTrack({ progressCallback, targetImages, basePercent = 0 }) {
         return this._compileTrack(targetImages, (percent) => {
             progressCallback(basePercent + percent * (100 - basePercent) / 100);
         });
     }
-    /**
-     * Método público para compilar matching (compatibilidad con API anterior)
-     */
     async compileMatch({ progressCallback, targetImages, basePercent = 0 }) {
         return this._compileMatch(targetImages, (percent) => {
             progressCallback(basePercent + percent * (50 - basePercent) / 100);
         });
     }
-    /**
-     * Exporta datos compilados en formato binario columnar optimizado
-     */
     exportData() {
         if (!this.data) {
             throw new Error("No hay datos compilados para exportar");
         }
         const dataList = this.data.map((item) => {
-            // Optimizamos MatchingData convirtiéndolo a formato columnar
             const matchingData = item.matchingData.map((kf) => this._packKeyframe(kf));
-            // Optimizamos TrackingData (Zero-copy layout)
             const trackingData = item.trackingData.map((td) => {
                 const count = td.points.length;
                 const px = new Float32Array(count);
@@ -247,17 +261,20 @@ export class OfflineCompiler {
         const x = new Float32Array(count);
         const y = new Float32Array(count);
         const angle = new Float32Array(count);
+        const scale = new Float32Array(count);
         const descriptors = new Uint8Array(count * 84); // 84 bytes per point (FREAK)
         for (let i = 0; i < count; i++) {
             x[i] = points[i].x;
             y[i] = points[i].y;
             angle[i] = points[i].angle;
+            scale[i] = points[i].scale;
             descriptors.set(points[i].descriptors, i * 84);
         }
         return {
             x,
             y,
             a: angle,
+            s: scale,
             d: descriptors,
             t: this._compactTree(tree.rootNode),
         };
@@ -268,18 +285,34 @@ export class OfflineCompiler {
         }
         return [0, node.centerPointIndex || 0, node.children.map((c) => this._compactTree(c))];
     }
-    /**
-     * Importa datos - Mantiene el formato columnar para máximo rendimiento (Zero-copy)
-     */
     importData(buffer) {
         const content = msgpack.decode(new Uint8Array(buffer));
         if (!content.v || content.v !== CURRENT_VERSION) {
             console.error("Incompatible .mind version. Required: " + CURRENT_VERSION);
             return [];
         }
-        // Ya no de-columnarizamos aquí. Los motores (Tracker/Matcher)
-        // ahora están optimizados para leer directamente de los buffers.
-        this.data = content.dataList;
+        // Restore Float32Arrays from Uint8Arrays returned by msgpack
+        const dataList = content.dataList;
+        for (let i = 0; i < dataList.length; i++) {
+            const item = dataList[i];
+            for (const kf of item.matchingData) {
+                for (const col of [kf.max, kf.min]) {
+                    if (col.x instanceof Uint8Array) {
+                        col.x = new Float32Array(col.x.buffer.slice(col.x.byteOffset, col.x.byteOffset + col.x.byteLength));
+                    }
+                    if (col.y instanceof Uint8Array) {
+                        col.y = new Float32Array(col.y.buffer.slice(col.y.byteOffset, col.y.byteOffset + col.y.byteLength));
+                    }
+                    if (col.a instanceof Uint8Array) {
+                        col.a = new Float32Array(col.a.buffer.slice(col.a.byteOffset, col.a.byteOffset + col.a.byteLength));
+                    }
+                    if (col.s instanceof Uint8Array) {
+                        col.s = new Float32Array(col.s.buffer.slice(col.s.byteOffset, col.s.byteOffset + col.s.byteLength));
+                    }
+                }
+            }
+        }
+        this.data = dataList;
         return this.data;
     }
     _unpackKeyframe(kf) {
@@ -301,6 +334,7 @@ export class OfflineCompiler {
                 x: col.x[i],
                 y: col.y[i],
                 angle: col.a[i],
+                scale: col.s ? col.s[i] : 1.0,
                 descriptors: col.d.slice(i * 84, (i + 1) * 84),
             });
         }
@@ -321,9 +355,6 @@ export class OfflineCompiler {
             children: node[2].map((c) => this._expandTree(c)),
         };
     }
-    /**
-     * Destruye el pool de workers
-     */
     async destroy() {
         if (this.workerPool) {
             await this.workerPool.destroy();

package/dist/compiler/three.js

@@ -1,6 +1,4 @@
 import { Matrix4, Vector3, Quaternion, Scene, WebGLRenderer, PerspectiveCamera, Group, sRGBEncoding, } from "three";
-import * as tf from "@tensorflow/tfjs";
-//import { CSS3DRenderer } from '../libs/CSS3DRenderer.js';
 import { CSS3DRenderer } from "three/addons/renderers/CSS3DRenderer.js";
 import { Controller } from "./controller.js";
 import { UI } from "../ui/ui.js";
@@ -304,5 +302,3 @@ if (!window.MINDAR.IMAGE) {
     window.MINDAR.IMAGE = {};
 }
 window.MINDAR.IMAGE.MindARThree = MindARThree;
-//window.MINDAR.IMAGE.THREE = THREE;
-window.MINDAR.IMAGE.tf = tf;

package/dist/compiler/tracker/tracker.d.ts

@@ -1,16 +1,24 @@
 export class Tracker {
-    constructor(markerDimensions: any, trackingDataList: any, projectionTransform: any, debugMode?: boolean);
+    constructor(markerDimensions: any, trackingDataList: any, projectionTransform: any, inputWidth: any, inputHeight: any, debugMode?: boolean);
     markerDimensions: any;
     trackingDataList: any;
     projectionTransform: any;
+    inputWidth: any;
+    inputHeight: any;
     debugMode: boolean;
     trackingKeyframeList: any[];
-    featurePointsListT: any[];
-    imagePixelsListT: any[];
-    imagePropertiesListT: any[];
-    kernelCaches: {};
-    dummyRun(inputT: any): void;
-    track(inputImageT: any, lastModelViewTransform: any, targetIndex: any): {
+    prebuiltData: {
+        px: Float32Array<any>;
+        py: Float32Array<any>;
+        data: Uint8Array<any>;
+        width: any;
+        height: any;
+        scale: any;
+        projectedImage: Float32Array<ArrayBuffer>;
+    }[];
+    templateBuffer: Float32Array<ArrayBuffer>;
+    dummyRun(inputData: any): void;
+    track(inputData: any, lastModelViewTransform: any, targetIndex: any): {
         worldCoords: {
             x: number;
             y: number;
@@ -22,9 +30,15 @@ export class Tracker {
         }[];
         debugExtra: {};
     };
-    _computeMatching(featurePointsT: any, imagePixelsT: any, imagePropertiesT: any, projectedImageT: any): any;
-    _computeProjection(modelViewProjectionTransformT: any, inputImageT: any, targetIndex: any): any;
-    _buildAdjustedModelViewTransform(modelViewProjectionTransform: any): any;
-    _prebuild(trackingFrame: any, maxCount: any): any;
-    _compileAndRun(program: any, inputs: any): any;
+    /**
+     * Pure JS implementation of NCC matching
+     */
+    _computeMatching(prebuilt: any, projectedImage: any): {
+        matchingPoints: number[][];
+        sim: Float32Array<any>;
+    };
+    /**
+     * Pure JS implementation of Bilinear Warping
+     */
+    _computeProjection(M: any, inputData: any, prebuilt: any): void;
 }