@srsergio/taptapp-ar 1.0.0 → 1.0.3

package/src/compiler/detector/kernels/cpu/binomialFilter.js

@@ -2,7 +2,6 @@ import * as FakeShader from "./fakeShader.js";
 
 function GetKernels(image) {
   const imageWidth = image.shape[1];
-  const key = "w" + imageWidth;
 
   const imageHeight = image.shape[0];
   const kernel1 = {

package/src/compiler/detector/kernels/cpu/computeLocalization.js

@@ -38,10 +38,6 @@ function GetProgram(numDogPyramidImages, extremasListLength) {
   return program;
 }
 
-const int = Math.trunc;
-function clamp(n, min, max) {
-  return Math.min(Math.max(min, n), max - 1);
-}
 
 export const computeLocalization = (args) => {
   /** @type {import('@tensorflow/tfjs').TensorInfo} */

package/src/compiler/detector/kernels/cpu/computeOrientationHistograms.js

@@ -2,24 +2,12 @@ import * as FakeShader from "./fakeShader.js";
 const oneOver2PI = 0.159154943091895;
 const ORIENTATION_NUM_BINS = 36;
 
-const cache = {};
 function GetPrograms(prunedExtremasT, radialPropertiesT, pyramidImagesLength) {
-  const key = `${pyramidImagesLength}|${prunedExtremasT.shape[0]}|${radialPropertiesT.shape[0]}`;
-  //if (!cache.hasOwnProperty(key)) {
   const imageVariableNames = [];
   for (let i = 1; i < pyramidImagesLength; i++) {
     imageVariableNames.push("image" + i);
   }
 
-  /*  let kernel1SubCodes = `float getPixel(int octave, int y, int x) {`;
-    for (let i = 1; i < pyramidImagesLength; i++) {
-        kernel1SubCodes += `
-              if (octave == ${i}) {
-                  return getImage${i}(y, x);
-              }
-              `;
-    }
-    kernel1SubCodes += `}`; */
 
   const kernel1 = {
     variableNames: [...imageVariableNames, "extrema", "radial"],
@@ -34,11 +22,6 @@ function GetPrograms(prunedExtremasT, radialPropertiesT, pyramidImagesLength) {
         }
         return this[k](y, x);
       };
-      /** replicated undefined behavior like you have on OpenGL */
-      function atan(x, y) {
-        if (x == 0 && y == 0) return 1.57;
-        return Math.atan2(x, y);
-      }
       //void main() {
       const coords = this.getOutputCoords();
       const featureIndex = coords[0];

package/src/compiler/detector/kernels/cpu/fakeShader.js

@@ -38,7 +38,7 @@ function runCode(backend, kernel, inputs, dtype) {
   //const temp = new Matrix();
   //console.log("Creating output shape:",kernel.outputShape);
   const temp = zeros(kernel.outputShape); //reshape([0,0,0],kernel.outputShape);
-  const output = map(temp, (value, index, matrix) => {
+  const output = map(temp, (_value, index) => {
     tempData.getOutputCoords = () => {
       return index;
     };

package/src/compiler/detector/kernels/cpu/prune.js

@@ -1,40 +1,4 @@
-import * as FakeShader from "./fakeShader.js";
-/*
-const kernel = {
-	  variableNames: ['extrema'],
-	  outputShape: [Math.floor(extremaHeight/2), Math.floor(extremaWidth/2)],
-	  userCode: `
-	    void main() {
-	      ivec2 coords = getOutputCoords();
-	      int y = coords[0] * 2;
-	      int x = coords[1] * 2;
 
-	      float location = 0.0;
-	      float values = getExtrema(y, x);
-
-	      if (getExtrema(y+1, x) != 0.0) {
-	        location = 1.0;
-		values = getExtrema(y+1, x);
-	      }
-	      else if (getExtrema(y, x+1) != 0.0) {
-	        location = 2.0;
-		values = getExtrema(y, x+1);
-	      }
-	      else if (getExtrema(y+1, x+1) != 0.0) {
-	        location = 3.0;
-		values = getExtrema(y+1, x+1);
-	      }
-
-	      if (values < 0.0) {
-	        setOutput(location * -1000.0 + values);
-	      } else {
-	        setOutput(location * 1000.0 + values);
-	      }
-	    }
-	  `
-	}
-
-*/
 function clamp(n, min, max) {
   return Math.min(Math.max(min, n), max - 1);
 }
@@ -107,7 +71,7 @@ const pruneConfig = {
   kernelFunc: prune, // as {} as KernelFunc,
 };
 
-module.exports = {
+export {
   pruneConfig,
   prune,
   pruneImpl,

package/src/compiler/detector/kernels/webgl/upsampleBilinear.js

@@ -1,7 +1,7 @@
 import { MathBackendWebGL } from "@tensorflow/tfjs-backend-webgl";
 
 const cache = {};
-function GetProgram(image, targetImage) {
+function GetProgram(targetImage) {
   const targetImageWidth = targetImage.shape[1];
   const targetImageHeight = targetImage.shape[0];
   const kernelKey = "w" + targetImageWidth + "h" + targetImageHeight;
@@ -50,7 +50,7 @@ export const upsampleBilinear = (args) => {
   /** @type {MathBackendWebGL} */
   const backend = args.backend;
 
-  const program = GetProgram(image, targetImage);
+  const program = GetProgram(targetImage);
   return backend.runWebGLProgram(program, [image], image.dtype);
 };
 

package/src/compiler/estimation/refine-estimate.js

@@ -10,7 +10,6 @@ const K2_FACTOR = 4.0; // Question: should it be relative to the size of the scr
 const ICP_MAX_LOOP = 10;
 const ICP_BREAK_LOOP_ERROR_THRESH = 0.1;
 const ICP_BREAK_LOOP_ERROR_RATIO_THRESH = 0.99;
-const ICP_BREAK_LOOP_ERROR_THRESH2 = 4.0;
 
 // some temporary/intermediate variables used later. Declare them beforehand to reduce new object allocations
 let mat = [[], [], []];

package/src/compiler/estimation/utils.js

@@ -6,23 +6,23 @@ const buildModelViewProjectionTransform = (projectionTransform, modelViewTransfo
   const modelViewProjectionTransform = [
     [
       projectionTransform[0][0] * modelViewTransform[0][0] +
-        projectionTransform[0][2] * modelViewTransform[2][0],
+      projectionTransform[0][2] * modelViewTransform[2][0],
       projectionTransform[0][0] * modelViewTransform[0][1] +
-        projectionTransform[0][2] * modelViewTransform[2][1],
+      projectionTransform[0][2] * modelViewTransform[2][1],
       projectionTransform[0][0] * modelViewTransform[0][2] +
-        projectionTransform[0][2] * modelViewTransform[2][2],
+      projectionTransform[0][2] * modelViewTransform[2][2],
       projectionTransform[0][0] * modelViewTransform[0][3] +
-        projectionTransform[0][2] * modelViewTransform[2][3],
+      projectionTransform[0][2] * modelViewTransform[2][3],
     ],
     [
       projectionTransform[1][1] * modelViewTransform[1][0] +
-        projectionTransform[1][2] * modelViewTransform[2][0],
+      projectionTransform[1][2] * modelViewTransform[2][0],
       projectionTransform[1][1] * modelViewTransform[1][1] +
-        projectionTransform[1][2] * modelViewTransform[2][1],
+      projectionTransform[1][2] * modelViewTransform[2][1],
       projectionTransform[1][1] * modelViewTransform[1][2] +
-        projectionTransform[1][2] * modelViewTransform[2][2],
+      projectionTransform[1][2] * modelViewTransform[2][2],
       projectionTransform[1][1] * modelViewTransform[1][3] +
-        projectionTransform[1][2] * modelViewTransform[2][3],
+      projectionTransform[1][2] * modelViewTransform[2][3],
     ],
     [
       modelViewTransform[2][0],
@@ -48,7 +48,7 @@ const buildModelViewProjectionTransform = (projectionTransform, modelViewTransfo
   */
 };
 
-const applyModelViewProjectionTransform = (modelViewProjectionTransform, x, y, z) => {
+const applyModelViewProjectionTransform = (modelViewProjectionTransform, x, y, _z) => {
   // assume z is zero
   const ux =
     modelViewProjectionTransform[0][0] * x +
@@ -75,21 +75,6 @@ const computeScreenCoordiate = (modelViewProjectionTransform, x, y, z) => {
   return { x: ux / uz, y: uy / uz };
 };
 
-const screenToMarkerCoordinate = (modelViewProjectionTransform, sx, sy) => {
-  const c11 = modelViewProjectionTransform[2][0] * sx - modelViewProjectionTransform[0][0];
-  const c12 = modelViewProjectionTransform[2][1] * sx - modelViewProjectionTransform[0][1];
-  const c21 = modelViewProjectionTransform[2][0] * sy - modelViewProjectionTransform[1][0];
-  const c22 = modelViewProjectionTransform[2][1] * sy - modelViewProjectionTransform[1][1];
-  const b1 = modelViewProjectionTransform[0][3] - modelViewProjectionTransform[2][3] * sx;
-  const b2 = modelViewProjectionTransform[1][3] - modelViewProjectionTransform[2][3] * sy;
-
-  const m = c11 * c22 - c12 * c21;
-  return {
-    x: (c22 * b1 - c12 * b2) / m,
-    y: (c11 * b2 - c21 * b1) / m,
-  };
-};
-
 export {
   buildModelViewProjectionTransform,
   applyModelViewProjectionTransform,

package/src/compiler/image-list.js

@@ -19,7 +19,9 @@ const buildImageList = (inputImage) => {
   let c = minScale;
   while (true) {
     scaleList.push(c);
-    c *= Math.pow(2.0, 1.0 / 3.0);
+    // 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);
     if (c >= 0.95) {
       c = 1;
       break;
@@ -30,8 +32,6 @@ const buildImageList = (inputImage) => {
 
   const imageList = [];
   for (let i = 0; i < scaleList.length; i++) {
-    const w = inputImage.width * scaleList[i];
-    const h = inputImage.height * scaleList[i];
     imageList.push(
       Object.assign(resize({ image: inputImage, ratio: scaleList[i] }), { scale: scaleList[i] }),
     );
@@ -49,7 +49,7 @@ const buildTrackingImageList = (inputImage) => {
   const minDimension = Math.min(inputImage.width, inputImage.height);
   const scaleList = [];
   const imageList = [];
-  scaleList.push(256.0 / minDimension);
+  // Solo generamos la versión de 128px para ahorrar espacio (antes generaba 256px y 128px)
   scaleList.push(128.0 / minDimension);
   for (let i = 0; i < scaleList.length; i++) {
     imageList.push(

package/src/compiler/input-loader.js

@@ -95,12 +95,12 @@ class InputLoader {
 
   _compileAndRun(program, inputs) {
     const outInfo = tf.backend().compileAndRun(program, inputs);
-    return tf.engine().makeTensorFromDataId(outInfo.dataId, outInfo.shape, outInfo.dtype);
+    return tf.engine().makeTensor(outInfo.dataId, outInfo.shape, outInfo.dtype);
   }
 
   _runWebGLProgram(program, inputs, outputType) {
     const outInfo = tf.backend().runWebGLProgram(program, inputs, outputType);
-    return tf.engine().makeTensorFromDataId(outInfo.dataId, outInfo.shape, outInfo.dtype);
+    return tf.engine().makeTensor(outInfo.dataId, outInfo.shape, outInfo.dtype);
   }
 }
 

package/src/compiler/matching/hamming-distance.js

@@ -1,23 +1,19 @@
-// Fast computation on number of bit sets
-// Ref: https://graphics.stanford.edu/~seander/bithacks.html#CountBitsSetParallel
+// Precomputed bit count lookup table for Uint8Array (Much faster than bit manipulation)
+const BIT_COUNT_8 = new Uint8Array(256);
+for (let i = 0; i < 256; i++) {
+  let c = 0, n = i;
+  while (n > 0) { n &= (n - 1); c++; }
+  BIT_COUNT_8[i] = c;
+}
+
 const compute = (options) => {
   const { v1, v2 } = options;
   let d = 0;
-
-  for (let i = 0; i < v1.length; i++) {
-    let x = (v1[i] ^ v2[i]) >>> 0;
-    d += bitCount(x);
+  const len = v1.length;
+  for (let i = 0; i < len; i++) {
+    d += BIT_COUNT_8[v1[i] ^ v2[i]];
   }
   return d;
 };
 
-const bitCount = (v) => {
-  var c = v - ((v >> 1) & 0x55555555);
-  c = ((c >> 2) & 0x33333333) + (c & 0x33333333);
-  c = ((c >> 4) + c) & 0x0f0f0f0f;
-  c = ((c >> 8) + c) & 0x00ff00ff;
-  c = ((c >> 16) + c) & 0x0000ffff;
-  return c;
-};
-
 export { compute };

package/src/compiler/matching/hierarchical-clustering.js

@@ -2,7 +2,7 @@ import { compute as hammingCompute } from "./hamming-distance.js";
 import { createRandomizer } from "../utils/randomizer.js";
 
 const MIN_FEATURE_PER_NODE = 16;
-const NUM_ASSIGNMENT_HYPOTHESES = 128;
+const NUM_ASSIGNMENT_HYPOTHESES = 64;
 const NUM_CENTERS = 8;
 
 const _computeKMedoids = (options) => {

package/src/compiler/matching/matching.js

@@ -17,42 +17,58 @@ const match = ({ keyframe, querypoints, querywidth, queryheight, debugMode }) =>
   const matches = [];
   for (let j = 0; j < querypoints.length; j++) {
     const querypoint = querypoints[j];
-    const keypoints = querypoint.maxima ? keyframe.maximaPoints : keyframe.minimaPoints;
-    if (keypoints.length === 0) continue;
+    const col = querypoint.maxima ? keyframe.max : keyframe.min;
+    if (!col || col.x.length === 0) continue;
 
-    const rootNode = querypoint.maxima
-      ? keyframe.maximaPointsCluster.rootNode
-      : keyframe.minimaPointsCluster.rootNode;
+    const rootNode = col.t;
 
     const keypointIndexes = [];
     const queue = new TinyQueue([], (a1, a2) => {
       return a1.d - a2.d;
     });
 
-    // query all potential keypoints
-    _query({ node: rootNode, keypoints, querypoint, queue, keypointIndexes, numPop: 0 });
+    // query potential candidates from the columnar tree
+    _query({
+      node: rootNode,
+      descriptors: col.d,
+      querypoint,
+      queue,
+      keypointIndexes,
+      numPop: 0
+    });
 
     let bestIndex = -1;
     let bestD1 = Number.MAX_SAFE_INTEGER;
     let bestD2 = Number.MAX_SAFE_INTEGER;
 
     for (let k = 0; k < keypointIndexes.length; k++) {
-      const keypoint = keypoints[keypointIndexes[k]];
+      const idx = keypointIndexes[k];
+
+      // Access descriptor directly from binary buffer (Zero-copy)
+      const keypointDescriptor = col.d.subarray(idx * 84, (idx + 1) * 84);
 
-      const d = hammingCompute({ v1: keypoint.descriptors, v2: querypoint.descriptors });
+      const d = hammingCompute({ v1: keypointDescriptor, v2: querypoint.descriptors });
       if (d < bestD1) {
         bestD2 = bestD1;
         bestD1 = d;
-        bestIndex = keypointIndexes[k];
+        bestIndex = idx;
       } else if (d < bestD2) {
         bestD2 = d;
       }
     }
+
     if (
       bestIndex !== -1 &&
       (bestD2 === Number.MAX_SAFE_INTEGER || (1.0 * bestD1) / bestD2 < HAMMING_THRESHOLD)
     ) {
-      matches.push({ querypoint, keypoint: keypoints[bestIndex] });
+      matches.push({
+        querypoint,
+        keypoint: {
+          x: col.x[bestIndex],
+          y: col.y[bestIndex],
+          angle: col.a[bestIndex]
+        }
+      });
     }
   }
 
@@ -63,8 +79,8 @@ const match = ({ keyframe, querypoints, querywidth, queryheight, debugMode }) =>
   if (matches.length < MIN_NUM_INLIERS) return { debugExtra };
 
   const houghMatches = computeHoughMatches({
-    keywidth: keyframe.width,
-    keyheight: keyframe.height,
+    keywidth: keyframe.w, // Protocol V3 uses .w, .h
+    keyheight: keyframe.h,
     querywidth,
     queryheight,
     matches,
@@ -77,7 +93,7 @@ const match = ({ keyframe, querypoints, querywidth, queryheight, debugMode }) =>
   const H = computeHomography({
     srcPoints: houghMatches.map((m) => [m.keypoint.x, m.keypoint.y]),
     dstPoints: houghMatches.map((m) => [m.querypoint.x, m.querypoint.y]),
-    keyframe,
+    keyframe: { width: keyframe.w, height: keyframe.h },
   });
 
   if (H === null) return { debugExtra };
@@ -94,10 +110,11 @@ const match = ({ keyframe, querypoints, querywidth, queryheight, debugMode }) =>
 
   if (inlierMatches.length < MIN_NUM_INLIERS) return { debugExtra };
 
-  // do another loop of match using the homography
+  // Second pass with homography guided matching
   const HInv = matrixInverse33(H, 0.00001);
   const dThreshold2 = 10 * 10;
   const matches2 = [];
+
   for (let j = 0; j < querypoints.length; j++) {
     const querypoint = querypoints[j];
     const mapquerypoint = multiplyPointHomographyInhomogenous([querypoint.x, querypoint.y], HInv);
@@ -106,18 +123,19 @@ const match = ({ keyframe, querypoints, querywidth, queryheight, debugMode }) =>
     let bestD1 = Number.MAX_SAFE_INTEGER;
     let bestD2 = Number.MAX_SAFE_INTEGER;
 
-    const keypoints = querypoint.maxima ? keyframe.maximaPoints : keyframe.minimaPoints;
+    const col = querypoint.maxima ? keyframe.max : keyframe.min;
+    if (!col) continue;
 
-    for (let k = 0; k < keypoints.length; k++) {
-      const keypoint = keypoints[k];
+    for (let k = 0; k < col.x.length; k++) {
+      const dx = col.x[k] - mapquerypoint[0];
+      const dy = col.y[k] - mapquerypoint[1];
+      const d2 = dx * dx + dy * dy;
 
-      // check distance threshold
-      const d2 =
-        (keypoint.x - mapquerypoint[0]) * (keypoint.x - mapquerypoint[0]) +
-        (keypoint.y - mapquerypoint[1]) * (keypoint.y - mapquerypoint[1]);
       if (d2 > dThreshold2) continue;
 
-      const d = hammingCompute({ v1: keypoint.descriptors, v2: querypoint.descriptors });
+      const keypointDescriptor = col.d.subarray(k * 84, (k + 1) * 84);
+      const d = hammingCompute({ v1: keypointDescriptor, v2: querypoint.descriptors });
+
       if (d < bestD1) {
         bestD2 = bestD1;
         bestD1 = d;
@@ -131,7 +149,14 @@ const match = ({ keyframe, querypoints, querywidth, queryheight, debugMode }) =>
       bestIndex !== -1 &&
       (bestD2 === Number.MAX_SAFE_INTEGER || (1.0 * bestD1) / bestD2 < HAMMING_THRESHOLD)
     ) {
-      matches2.push({ querypoint, keypoint: keypoints[bestIndex] });
+      matches2.push({
+        querypoint,
+        keypoint: {
+          x: col.x[bestIndex],
+          y: col.y[bestIndex],
+          angle: col.a[bestIndex]
+        }
+      });
     }
   }
 
@@ -140,8 +165,8 @@ const match = ({ keyframe, querypoints, querywidth, queryheight, debugMode }) =>
   }
 
   const houghMatches2 = computeHoughMatches({
-    keywidth: keyframe.width,
-    keyheight: keyframe.height,
+    keywidth: keyframe.w,
+    keyheight: keyframe.h,
     querywidth,
     queryheight,
     matches: matches2,
@@ -154,7 +179,7 @@ const match = ({ keyframe, querypoints, querywidth, queryheight, debugMode }) =>
   const H2 = computeHomography({
     srcPoints: houghMatches2.map((m) => [m.keypoint.x, m.keypoint.y]),
     dstPoints: houghMatches2.map((m) => [m.querypoint.x, m.querypoint.y]),
-    keyframe,
+    keyframe: { width: keyframe.w, height: keyframe.h },
   });
 
   if (H2 === null) return { debugExtra };
@@ -172,45 +197,50 @@ const match = ({ keyframe, querypoints, querywidth, queryheight, debugMode }) =>
   return { H: H2, matches: inlierMatches2, debugExtra };
 };
 
-const _query = ({ node, keypoints, querypoint, queue, keypointIndexes, numPop }) => {
-  if (node.leaf) {
-    for (let i = 0; i < node.pointIndexes.length; i++) {
-      keypointIndexes.push(node.pointIndexes[i]);
+const _query = ({ node, descriptors, querypoint, queue, keypointIndexes, numPop }) => {
+  const isLeaf = node[0] === 1;
+  const centerIdx = node[1];
+  const childrenOrIndices = node[2];
+
+  if (isLeaf) {
+    for (let i = 0; i < childrenOrIndices.length; i++) {
+      keypointIndexes.push(childrenOrIndices[i]);
     }
     return;
   }
 
   const distances = [];
-  for (let i = 0; i < node.children.length; i++) {
-    const childNode = node.children[i];
-    const centerPointIndex = childNode.centerPointIndex;
+  for (let i = 0; i < childrenOrIndices.length; i++) {
+    const childNode = childrenOrIndices[i];
+    const cIdx = childNode[1];
+
     const d = hammingCompute({
-      v1: keypoints[centerPointIndex].descriptors,
+      v1: descriptors.subarray(cIdx * 84, (cIdx + 1) * 84),
       v2: querypoint.descriptors,
     });
     distances.push(d);
   }
 
   let minD = Number.MAX_SAFE_INTEGER;
-  for (let i = 0; i < node.children.length; i++) {
+  for (let i = 0; i < childrenOrIndices.length; i++) {
     minD = Math.min(minD, distances[i]);
   }
 
-  for (let i = 0; i < node.children.length; i++) {
+  for (let i = 0; i < childrenOrIndices.length; i++) {
     if (distances[i] !== minD) {
-      queue.push({ node: node.children[i], d: distances[i] });
+      queue.push({ node: childrenOrIndices[i], d: distances[i] });
     }
   }
-  for (let i = 0; i < node.children.length; i++) {
+  for (let i = 0; i < childrenOrIndices.length; i++) {
     if (distances[i] === minD) {
-      _query({ node: node.children[i], keypoints, querypoint, queue, keypointIndexes, numPop });
+      _query({ node: childrenOrIndices[i], descriptors, querypoint, queue, keypointIndexes, numPop });
     }
   }
 
   if (numPop < CLUSTER_MAX_POP && queue.length > 0) {
-    const { node, d } = queue.pop();
+    const { node } = queue.pop();
     numPop += 1;
-    _query({ node, keypoints, querypoint, queue, keypointIndexes, numPop });
+    _query({ node, descriptors, querypoint, queue, keypointIndexes, numPop });
   }
 };
 

package/src/compiler/matching/ransacHomography.js

@@ -1,4 +1,3 @@
-import { Matrix, inverse } from "ml-matrix";
 import { createRandomizer } from "../utils/randomizer.js";
 import {
   quadrilateralConvex,
@@ -7,7 +6,6 @@ import {
   multiplyPointHomographyInhomogenous,
   checkThreePointsConsistent,
   checkFourPointsConsistent,
-  determinant,
 } from "../utils/geometry.js";
 import { solveHomography } from "../utils/homography.js";
 

package/src/compiler/node-worker.js

@@ -0,0 +1,93 @@
+/**
+ * Worker Node.js para compilación de imágenes AR
+ * 
+ * OPTIMIZADO: Sin TensorFlow para evitar bloqueos de inicialización.
+ * Usa JavaScript puro para máxima velocidad.
+ */
+import { parentPort } from 'node:worker_threads';
+import { extractTrackingFeatures } from './tracker/extract-utils.js';
+import { buildTrackingImageList, buildImageList } from './image-list.js';
+import { DetectorLite } from './detector/detector-lite.js';
+import { build as hierarchicalClusteringBuild } from './matching/hierarchical-clustering.js';
+
+if (!parentPort) {
+    throw new Error('This file must be run as a worker thread.');
+}
+
+parentPort.on('message', async (msg) => {
+    if (msg.type === 'compile') {
+        const { targetImage, percentPerImage, basePercent } = msg;
+
+        try {
+            const imageList = buildTrackingImageList(targetImage);
+            const percentPerAction = percentPerImage / imageList.length;
+            let localPercent = 0;
+
+            const trackingData = extractTrackingFeatures(imageList, (index) => {
+                localPercent += percentPerAction;
+                parentPort.postMessage({
+                    type: 'progress',
+                    percent: basePercent + localPercent
+                });
+            });
+
+            parentPort.postMessage({
+                type: 'compileDone',
+                trackingData
+            });
+        } catch (error) {
+            parentPort.postMessage({
+                type: 'error',
+                error: error.message
+            });
+        }
+    } else if (msg.type === 'match') {
+        const { targetImage, percentPerImage, basePercent } = msg;
+
+        try {
+            const imageList = buildImageList(targetImage);
+            const percentPerAction = percentPerImage / imageList.length;
+            let localPercent = 0;
+
+            const keyframes = [];
+            for (let i = 0; i < imageList.length; i++) {
+                const image = imageList[i];
+                const detector = new DetectorLite(image.width, image.height);
+
+                // Detectar features usando JS puro (sin TensorFlow)
+                const { featurePoints: ps } = detector.detect(image.data);
+
+                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: image.width,
+                    height: image.height,
+                    scale: image.scale,
+                });
+
+                localPercent += percentPerAction;
+                parentPort.postMessage({
+                    type: 'progress',
+                    percent: basePercent + localPercent
+                });
+            }
+
+            parentPort.postMessage({
+                type: 'matchDone',
+                matchingData: keyframes
+            });
+        } catch (error) {
+            parentPort.postMessage({
+                type: 'error',
+                error: error.message
+            });
+        }
+    }
+});