@srsergio/taptapp-ar 1.0.8 → 1.0.10

package/src/compiler/matching/matching.js

@@ -15,17 +15,18 @@ const match = ({ keyframe, querypoints, querywidth, queryheight, debugMode }) =>
   let debugExtra = {};
 
   const matches = [];
-  for (let j = 0; j < querypoints.length; j++) {
+  const qlen = querypoints.length;
+  const kmax = keyframe.max;
+  const kmin = keyframe.min;
+
+  for (let j = 0; j < qlen; j++) {
     const querypoint = querypoints[j];
-    const col = querypoint.maxima ? keyframe.max : keyframe.min;
+    const col = querypoint.maxima ? kmax : kmin;
     if (!col || col.x.length === 0) continue;
 
     const rootNode = col.t;
-
     const keypointIndexes = [];
-    const queue = new TinyQueue([], (a1, a2) => {
-      return a1.d - a2.d;
-    });
+    const queue = new TinyQueue([], (a1, a2) => a1.d - a2.d);
 
     // query potential candidates from the columnar tree
     _query({
@@ -41,13 +42,15 @@ const match = ({ keyframe, querypoints, querywidth, queryheight, debugMode }) =>
     let bestD1 = Number.MAX_SAFE_INTEGER;
     let bestD2 = Number.MAX_SAFE_INTEGER;
 
+    const qDesc = querypoint.descriptors;
+    const cDesc = col.d;
+
     for (let k = 0; k < keypointIndexes.length; k++) {
       const idx = keypointIndexes[k];
 
-      // Access descriptor directly from binary buffer (Zero-copy)
-      const keypointDescriptor = col.d.subarray(idx * 84, (idx + 1) * 84);
+      // Use offsets to avoid subarray allocation
+      const d = hammingCompute({ v1: cDesc, v1Offset: idx * 84, v2: qDesc });
 
-      const d = hammingCompute({ v1: keypointDescriptor, v2: querypoint.descriptors });
       if (d < bestD1) {
         bestD2 = bestD1;
         bestD1 = d;
@@ -59,36 +62,31 @@ const match = ({ keyframe, querypoints, querywidth, queryheight, debugMode }) =>
 
     if (
       bestIndex !== -1 &&
-      (bestD2 === Number.MAX_SAFE_INTEGER || (1.0 * bestD1) / bestD2 < HAMMING_THRESHOLD)
+      (bestD2 === Number.MAX_SAFE_INTEGER || (bestD1 / bestD2) < HAMMING_THRESHOLD)
     ) {
       matches.push({
         querypoint,
         keypoint: {
           x: col.x[bestIndex],
           y: col.y[bestIndex],
-          angle: col.a[bestIndex]
+          angle: col.a[bestIndex],
+          scale: col.s ? col.s[bestIndex] : keyframe.s
         }
       });
     }
   }
 
-  if (debugMode) {
-    debugExtra.matches = matches;
-  }
-
   if (matches.length < MIN_NUM_INLIERS) return { debugExtra };
 
   const houghMatches = computeHoughMatches({
-    keywidth: keyframe.w, // Protocol V3 uses .w, .h
+    keywidth: keyframe.w,
     keyheight: keyframe.h,
     querywidth,
     queryheight,
     matches,
   });
 
-  if (debugMode) {
-    debugExtra.houghMatches = houghMatches;
-  }
+  if (debugMode) debugExtra.houghMatches = houghMatches;
 
   const H = computeHomography({
     srcPoints: houghMatches.map((m) => [m.keypoint.x, m.keypoint.y]),
@@ -104,37 +102,46 @@ const match = ({ keyframe, querypoints, querywidth, queryheight, debugMode }) =>
     threshold: INLIER_THRESHOLD,
   });
 
-  if (debugMode) {
-    debugExtra.inlierMatches = inlierMatches;
-  }
-
+  if (debugMode) debugExtra.inlierMatches = inlierMatches;
   if (inlierMatches.length < MIN_NUM_INLIERS) return { debugExtra };
 
   // Second pass with homography guided matching
   const HInv = matrixInverse33(H, 0.00001);
-  const dThreshold2 = 10 * 10;
+  const dThreshold2 = 100; // 10 * 10
   const matches2 = [];
 
-  for (let j = 0; j < querypoints.length; j++) {
+  const hi00 = HInv[0], hi01 = HInv[1], hi02 = HInv[2];
+  const hi10 = HInv[3], hi11 = HInv[4], hi12 = HInv[5];
+  const hi20 = HInv[6], hi21 = HInv[7], hi22 = HInv[8];
+
+  for (let j = 0; j < qlen; j++) {
     const querypoint = querypoints[j];
-    const mapquerypoint = multiplyPointHomographyInhomogenous([querypoint.x, querypoint.y], HInv);
+    const qx = querypoint.x, qy = querypoint.y;
+
+    // Inline multiplyPointHomographyInhomogenous
+    const uz = (qx * hi20) + (qy * hi21) + hi22;
+    const invZ = 1.0 / uz;
+    const mapX = ((qx * hi00) + (qy * hi01) + hi02) * invZ;
+    const mapY = ((qx * hi10) + (qy * hi11) + hi12) * invZ;
 
     let bestIndex = -1;
     let bestD1 = Number.MAX_SAFE_INTEGER;
     let bestD2 = Number.MAX_SAFE_INTEGER;
 
-    const col = querypoint.maxima ? keyframe.max : keyframe.min;
+    const col = querypoint.maxima ? kmax : kmin;
     if (!col) continue;
 
-    for (let k = 0; k < col.x.length; k++) {
-      const dx = col.x[k] - mapquerypoint[0];
-      const dy = col.y[k] - mapquerypoint[1];
+    const cx = col.x, cy = col.y, cd = col.d;
+    const qDesc = querypoint.descriptors;
+
+    for (let k = 0, clen = cx.length; k < clen; k++) {
+      const dx = cx[k] - mapX;
+      const dy = cy[k] - mapY;
       const d2 = dx * dx + dy * dy;
 
       if (d2 > dThreshold2) continue;
 
-      const keypointDescriptor = col.d.subarray(k * 84, (k + 1) * 84);
-      const d = hammingCompute({ v1: keypointDescriptor, v2: querypoint.descriptors });
+      const d = hammingCompute({ v1: cd, v1Offset: k * 84, v2: qDesc });
 
       if (d < bestD1) {
         bestD2 = bestD1;
@@ -147,22 +154,21 @@ const match = ({ keyframe, querypoints, querywidth, queryheight, debugMode }) =>
 
     if (
       bestIndex !== -1 &&
-      (bestD2 === Number.MAX_SAFE_INTEGER || (1.0 * bestD1) / bestD2 < HAMMING_THRESHOLD)
+      (bestD2 === Number.MAX_SAFE_INTEGER || (bestD1 / bestD2) < HAMMING_THRESHOLD)
     ) {
       matches2.push({
         querypoint,
         keypoint: {
           x: col.x[bestIndex],
           y: col.y[bestIndex],
-          angle: col.a[bestIndex]
+          angle: col.a[bestIndex],
+          scale: col.s ? col.s[bestIndex] : keyframe.s
         }
       });
     }
   }
 
-  if (debugMode) {
-    debugExtra.matches2 = matches2;
-  }
+  if (debugMode) debugExtra.matches2 = matches2;
 
   const houghMatches2 = computeHoughMatches({
     keywidth: keyframe.w,
@@ -172,9 +178,7 @@ const match = ({ keyframe, querypoints, querywidth, queryheight, debugMode }) =>
     matches: matches2,
   });
 
-  if (debugMode) {
-    debugExtra.houghMatches2 = houghMatches2;
-  }
+  if (debugMode) debugExtra.houghMatches2 = houghMatches2;
 
   const H2 = computeHomography({
     srcPoints: houghMatches2.map((m) => [m.keypoint.x, m.keypoint.y]),
@@ -190,16 +194,13 @@ const match = ({ keyframe, querypoints, querywidth, queryheight, debugMode }) =>
     threshold: INLIER_THRESHOLD,
   });
 
-  if (debugMode) {
-    debugExtra.inlierMatches2 = inlierMatches2;
-  }
+  if (debugMode) debugExtra.inlierMatches2 = inlierMatches2;
 
   return { H: H2, matches: inlierMatches2, debugExtra };
 };
 
 const _query = ({ node, descriptors, querypoint, queue, keypointIndexes, numPop }) => {
   const isLeaf = node[0] === 1;
-  const centerIdx = node[1];
   const childrenOrIndices = node[2];
 
   if (isLeaf) {
@@ -209,56 +210,63 @@ const _query = ({ node, descriptors, querypoint, queue, keypointIndexes, numPop
     return;
   }
 
-  const distances = [];
-  for (let i = 0; i < childrenOrIndices.length; i++) {
+  const qDesc = querypoint.descriptors;
+  let minD = Number.MAX_SAFE_INTEGER;
+  const clen = childrenOrIndices.length;
+  const distances = new Int32Array(clen);
+
+  for (let i = 0; i < clen; i++) {
     const childNode = childrenOrIndices[i];
     const cIdx = childNode[1];
 
     const d = hammingCompute({
-      v1: descriptors.subarray(cIdx * 84, (cIdx + 1) * 84),
-      v2: querypoint.descriptors,
+      v1: descriptors,
+      v1Offset: cIdx * 84,
+      v2: qDesc,
     });
-    distances.push(d);
-  }
-
-  let minD = Number.MAX_SAFE_INTEGER;
-  for (let i = 0; i < childrenOrIndices.length; i++) {
-    minD = Math.min(minD, distances[i]);
+    distances[i] = d;
+    if (d < minD) minD = d;
   }
 
-  for (let i = 0; i < childrenOrIndices.length; i++) {
-    if (distances[i] !== minD) {
-      queue.push({ node: childrenOrIndices[i], d: distances[i] });
-    }
-  }
-  for (let i = 0; i < childrenOrIndices.length; i++) {
-    if (distances[i] === minD) {
+  for (let i = 0; i < clen; i++) {
+    const dist = distances[i];
+    if (dist !== minD) {
+      queue.push({ node: childrenOrIndices[i], d: dist });
+    } else {
       _query({ node: childrenOrIndices[i], descriptors, querypoint, queue, keypointIndexes, numPop });
     }
   }
 
   if (numPop < CLUSTER_MAX_POP && queue.length > 0) {
     const { node } = queue.pop();
-    numPop += 1;
-    _query({ node, descriptors, querypoint, queue, keypointIndexes, numPop });
+    _query({ node, descriptors, querypoint, queue, keypointIndexes, numPop: numPop + 1 });
   }
 };
 
 const _findInlierMatches = (options) => {
   const { H, matches, threshold } = options;
-
   const threshold2 = threshold * threshold;
 
+  const h00 = H[0], h01 = H[1], h02 = H[2];
+  const h10 = H[3], h11 = H[4], h12 = H[5];
+  const h20 = H[6], h21 = H[7], h22 = H[8];
+
   const goodMatches = [];
   for (let i = 0; i < matches.length; i++) {
-    const querypoint = matches[i].querypoint;
-    const keypoint = matches[i].keypoint;
-    const mp = multiplyPointHomographyInhomogenous([keypoint.x, keypoint.y], H);
-    const d2 =
-      (mp[0] - querypoint.x) * (mp[0] - querypoint.x) +
-      (mp[1] - querypoint.y) * (mp[1] - querypoint.y);
-    if (d2 <= threshold2) {
-      goodMatches.push(matches[i]);
+    const m = matches[i];
+    const qp = m.querypoint;
+    const kp = m.keypoint;
+
+    // Inline multiplyPointHomographyInhomogenous
+    const uz = (kp.x * h20) + (kp.y * h21) + h22;
+    const invZ = 1.0 / uz;
+    const mx = ((kp.x * h00) + (kp.y * h01) + h02) * invZ;
+    const my = ((kp.x * h10) + (kp.y * h11) + h12) * invZ;
+
+    const dx = mx - qp.x;
+    const dy = my - qp.y;
+    if (dx * dx + dy * dy <= threshold2) {
+      goodMatches.push(m);
     }
   }
   return goodMatches;

package/src/compiler/offline-compiler.js

@@ -20,6 +20,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" &&
@@ -46,22 +47,30 @@ 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);
     }
   }
 
@@ -104,48 +113,57 @@ 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;
 
-    const results = [];
+    // 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);
+    }
 
-    // Procesar secuencialmente para evitar overhead de workers
-    // (los workers son útiles para muchas imágenes, pero añaden latencia)
+    // Serial Fallback
+    const results = [];
     for (let i = 0; i < targetImages.length; i++) {
       const targetImage = targetImages[i];
       const imageList = buildImageList(targetImage);
@@ -182,15 +200,30 @@ 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;
 
-    const results = [];
+    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];
       const imageList = buildTrackingImageList(targetImage);
@@ -207,42 +240,26 @@ 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);
@@ -292,12 +309,14 @@ 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);
     }
 
@@ -305,6 +324,7 @@ export class OfflineCompiler {
       x,
       y,
       a: angle,
+      s: scale,
       d: descriptors,
       t: this._compactTree(tree.rootNode),
     };
@@ -317,9 +337,6 @@ 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));
 
@@ -328,10 +345,29 @@ export class OfflineCompiler {
       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;
   }
 
@@ -355,6 +391,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),
       });
     }
@@ -377,9 +414,6 @@ export class OfflineCompiler {
     };
   }
 
-  /**
-   * Destruye el pool de workers
-   */
   async destroy() {
     if (this.workerPool) {
       await this.workerPool.destroy();

package/src/compiler/three.js

@@ -8,8 +8,6 @@ import {
   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";
@@ -362,5 +360,3 @@ if (!window.MINDAR.IMAGE) {
 }
 
 window.MINDAR.IMAGE.MindARThree = MindARThree;
-//window.MINDAR.IMAGE.THREE = THREE;
-window.MINDAR.IMAGE.tf = tf;