@srsergio/taptapp-ar 1.0.2 → 1.0.3

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

@@ -1,7 +1,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 = {
         variableNames: ["p"],

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

@@ -33,10 +33,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} */
     const { prunedExtremasList, dogPyramidImagesT } = args.inputs;

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

@@ -1,23 +1,11 @@
 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"],
         outputShape: [prunedExtremasT.shape[0], radialPropertiesT.shape[0], 2], // last dimension: [fbin, magnitude]
@@ -31,12 +19,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/dist/compiler/detector/kernels/cpu/fakeShader.js

@@ -36,7 +36,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/dist/compiler/detector/kernels/cpu/prune.d.ts

@@ -1 +1,7 @@
-export {};
+export namespace pruneConfig {
+    export let kernelName: string;
+    export let backendName: string;
+    export { prune as kernelFunc };
+}
+export function prune(args: any): any;
+export function pruneImpl(vals: any, width: any, height: any): Float32Array<ArrayBuffer>;

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

@@ -1,40 +1,3 @@
-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);
 }
@@ -96,8 +59,4 @@ const pruneConfig = {
     backendName: "cpu",
     kernelFunc: prune, // as {} as KernelFunc,
 };
-module.exports = {
-    pruneConfig,
-    prune,
-    pruneImpl,
-};
+export { pruneConfig, prune, pruneImpl, };

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

@@ -1,6 +1,6 @@
 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;
@@ -45,7 +45,7 @@ export const upsampleBilinear = (args) => {
     const { image, targetImage } = args.inputs;
     /** @type {MathBackendWebGL} */
     const backend = args.backend;
-    const program = GetProgram(image, targetImage);
+    const program = GetProgram(targetImage);
     return backend.runWebGLProgram(program, [image], image.dtype);
 };
 export const upsampleBilinearConfig = {

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

@@ -5,7 +5,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 = [[], [], []];
 let J_U_Xc = [[], []]; // 2x3

package/dist/compiler/estimation/utils.d.ts

@@ -1,5 +1,5 @@
 export function buildModelViewProjectionTransform(projectionTransform: any, modelViewTransform: any): any[][];
-export function applyModelViewProjectionTransform(modelViewProjectionTransform: any, x: any, y: any, z: any): {
+export function applyModelViewProjectionTransform(modelViewProjectionTransform: any, x: any, y: any, _z: any): {
     x: any;
     y: any;
     z: any;

package/dist/compiler/estimation/utils.js

@@ -46,7 +46,7 @@ const buildModelViewProjectionTransform = (projectionTransform, modelViewTransfo
     return modelViewProjectionTransform;
     */
 };
-const applyModelViewProjectionTransform = (modelViewProjectionTransform, x, y, z) => {
+const applyModelViewProjectionTransform = (modelViewProjectionTransform, x, y, _z) => {
     // assume z is zero
     const ux = modelViewProjectionTransform[0][0] * x +
         modelViewProjectionTransform[0][1] * y +
@@ -64,17 +64,4 @@ const computeScreenCoordiate = (modelViewProjectionTransform, x, y, z) => {
     //if( Math.abs(uz) < 0.000001 ) return null;
     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, computeScreenCoordiate, };

package/dist/compiler/image-list.js

@@ -16,7 +16,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;
@@ -26,8 +28,6 @@ const buildImageList = (inputImage) => {
     scaleList.reverse();
     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] }));
     }
     return imageList;
@@ -42,7 +42,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(Object.assign(resize({ image: inputImage, ratio: scaleList[i] }), { scale: scaleList[i] }));

package/dist/compiler/input-loader.js

@@ -78,11 +78,11 @@ 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);
     }
 }
 export { InputLoader };

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

@@ -1,20 +1,20 @@
-// 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/dist/compiler/matching/hierarchical-clustering.js

@@ -1,7 +1,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) => {
     const { points, pointIndexes, randomizer } = options;

package/dist/compiler/matching/matching.d.ts

@@ -8,13 +8,21 @@ export function match({ keyframe, querypoints, querywidth, queryheight, debugMod
     debugExtra: {
         matches: {
             querypoint: any;
-            keypoint: any;
+            keypoint: {
+                x: any;
+                y: any;
+                angle: any;
+            };
         }[];
         houghMatches: any[];
         inlierMatches: any[];
         matches2: {
             querypoint: any;
-            keypoint: any;
+            keypoint: {
+                x: any;
+                y: any;
+                angle: any;
+            };
         }[];
         houghMatches2: any[];
         inlierMatches2: any[];
@@ -27,13 +35,21 @@ export function match({ keyframe, querypoints, querywidth, queryheight, debugMod
     debugExtra: {
         matches: {
             querypoint: any;
-            keypoint: any;
+            keypoint: {
+                x: any;
+                y: any;
+                angle: any;
+            };
         }[];
         houghMatches: any[];
         inlierMatches: any[];
         matches2: {
             querypoint: any;
-            keypoint: any;
+            keypoint: {
+                x: any;
+                y: any;
+                angle: any;
+            };
         }[];
         houghMatches2: any[];
         inlierMatches2: any[];

package/dist/compiler/matching/matching.js

@@ -14,28 +14,35 @@ 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)
+        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 d = hammingCompute({ v1: keypoint.descriptors, v2: querypoint.descriptors });
+            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: keypointDescriptor, v2: querypoint.descriptors });
             if (d < bestD1) {
                 bestD2 = bestD1;
                 bestD1 = d;
-                bestIndex = keypointIndexes[k];
+                bestIndex = idx;
             }
             else if (d < bestD2) {
                 bestD2 = d;
@@ -43,7 +50,14 @@ const match = ({ keyframe, querypoints, querywidth, queryheight, debugMode }) =>
         }
         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]
+                }
+            });
         }
     }
     if (debugMode) {
@@ -52,8 +66,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,
@@ -64,7 +78,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 };
@@ -78,7 +92,7 @@ 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 = [];
@@ -88,15 +102,17 @@ const match = ({ keyframe, querypoints, querywidth, queryheight, debugMode }) =>
         let bestIndex = -1;
         let bestD1 = Number.MAX_SAFE_INTEGER;
         let bestD2 = Number.MAX_SAFE_INTEGER;
-        const keypoints = querypoint.maxima ? keyframe.maximaPoints : keyframe.minimaPoints;
-        for (let k = 0; k < keypoints.length; k++) {
-            const keypoint = keypoints[k];
-            // check distance threshold
-            const d2 = (keypoint.x - mapquerypoint[0]) * (keypoint.x - mapquerypoint[0]) +
-                (keypoint.y - mapquerypoint[1]) * (keypoint.y - mapquerypoint[1]);
+        const col = querypoint.maxima ? keyframe.max : keyframe.min;
+        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 d2 = dx * dx + dy * dy;
             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;
@@ -108,15 +124,22 @@ const match = ({ keyframe, querypoints, querywidth, queryheight, debugMode }) =>
         }
         if (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]
+                }
+            });
         }
     }
     if (debugMode) {
         debugExtra.matches2 = matches2;
     }
     const houghMatches2 = computeHoughMatches({
-        keywidth: keyframe.width,
-        keyheight: keyframe.height,
+        keywidth: keyframe.w,
+        keyheight: keyframe.h,
         querywidth,
         queryheight,
         matches: matches2,
@@ -127,7 +150,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 };
@@ -141,41 +164,44 @@ 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 });
     }
 };
 const _findInlierMatches = (options) => {

package/dist/compiler/matching/ransacHomography.js

@@ -1,6 +1,5 @@
-import { Matrix, inverse } from "ml-matrix";
 import { createRandomizer } from "../utils/randomizer.js";
-import { quadrilateralConvex, matrixInverse33, smallestTriangleArea, multiplyPointHomographyInhomogenous, checkThreePointsConsistent, checkFourPointsConsistent, determinant, } from "../utils/geometry.js";
+import { quadrilateralConvex, matrixInverse33, smallestTriangleArea, multiplyPointHomographyInhomogenous, checkThreePointsConsistent, checkFourPointsConsistent, } from "../utils/geometry.js";
 import { solveHomography } from "../utils/homography.js";
 const CAUCHY_SCALE = 0.01;
 const CHUNK_SIZE = 10;

package/dist/compiler/node-worker.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/compiler/node-worker.js

@@ -0,0 +1,84 @@
+/**
+ * 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
+            });
+        }
+    }
+});