@srsergio/taptapp-ar 1.0.85 → 1.0.87

package/dist/compiler/node-worker.js

@@ -5,27 +5,14 @@
  * Usa JavaScript puro para máxima velocidad.
  */
 import { parentPort } from 'node:worker_threads';
-import { extractTrackingFeatures } from './tracker/extract-utils.js';
-import { buildTrackingImageList } from './image-list.js';
-import { DetectorLite } from './detector/detector-lite.js';
-import { build as hierarchicalClusteringBuild } from './matching/hierarchical-clustering.js';
+import { extractTrackingFeatures } from '../core/tracker/extract-utils.js';
+import { buildTrackingImageList } from '../core/image-list.js';
+import { DetectorLite } from '../core/detector/detector-lite.js';
+import { build as hierarchicalClusteringBuild } from '../core/matching/hierarchical-clustering.js';
+import { getMorton } from '../core/protocol.js';
 if (!parentPort) {
     throw new Error('This file must be run as a worker thread.');
 }
-// Helper for Morton Order sorting inside worker
-function getMorton(x, y) {
-    let x_int = x | 0;
-    let y_int = y | 0;
-    x_int = (x_int | (x_int << 8)) & 0x00FF00FF;
-    x_int = (x_int | (x_int << 4)) & 0x0F0F0F0F;
-    x_int = (x_int | (x_int << 2)) & 0x33333333;
-    x_int = (x_int | (x_int << 1)) & 0x55555555;
-    y_int = (y_int | (y_int << 8)) & 0x00FF00FF;
-    y_int = (y_int | (y_int << 4)) & 0x0F0F0F0F;
-    y_int = (y_int | (y_int << 2)) & 0x33333333;
-    y_int = (y_int | (y_int << 1)) & 0x55555555;
-    return x_int | (y_int << 1);
-}
 const mortonCache = new Int32Array(2048); // Cache for sorting stability
 function sortPoints(points) {
     if (points.length <= 1)

package/dist/compiler/offline-compiler.d.ts

@@ -5,10 +5,8 @@
  * que NO depende de TensorFlow, eliminando todos los problemas de
  * inicialización, bloqueos y compatibilidad.
  */
-import { FourierEncoder } from "./utils/fourier-encoder.js";
 export declare class OfflineCompiler {
     data: any;
-    fourierEncoder: FourierEncoder;
     constructor();
     compileImageTargets(images: any[], progressCallback: (p: number) => void): Promise<any>;
     _compileTarget(targetImages: any[], progressCallback: (p: number) => void): Promise<{
@@ -112,55 +110,9 @@ export declare class OfflineCompiler {
         scale: any;
     }[][]>;
     exportData(): Uint8Array<ArrayBuffer>;
-    _getMorton(x: number, y: number): number;
-    _columnarize(points: any[], tree: any, width: number, height: number): {
-        x: Uint16Array<ArrayBuffer>;
-        y: Uint16Array<ArrayBuffer>;
-        a: Int16Array<ArrayBuffer>;
-        s: Uint8Array<ArrayBuffer>;
-        d: Uint32Array<ArrayBuffer>;
-        f: Int8Array<ArrayBuffer>;
-        t: any;
-    };
-    _compactTree(node: any): any;
     importData(buffer: ArrayBuffer | Uint8Array): {
         version: any;
         dataList: any;
     };
-    _unpackKeyframe(kf: any): {
-        width: any;
-        height: any;
-        scale: any;
-        maximaPoints: {
-            x: number;
-            y: number;
-            angle: any;
-            scale: any;
-            descriptors: any;
-        }[];
-        minimaPoints: {
-            x: number;
-            y: number;
-            angle: any;
-            scale: any;
-            descriptors: any;
-        }[];
-        maximaPointsCluster: {
-            rootNode: any;
-        };
-        minimaPointsCluster: {
-            rootNode: any;
-        };
-    };
-    _decolumnarize(col: any, width: number, height: number): {
-        x: number;
-        y: number;
-        angle: any;
-        scale: any;
-        descriptors: any;
-    }[];
-    _expandTree(node: any): any;
     destroy(): Promise<void>;
-    _pack4Bit(data: Uint8Array): Uint8Array<ArrayBufferLike>;
-    _unpack4Bit(packed: Uint8Array, width: number, height: number): Uint8Array<ArrayBuffer>;
 }

package/dist/compiler/offline-compiler.js

@@ -5,20 +5,17 @@
  * que NO depende de TensorFlow, eliminando todos los problemas de
  * inicialización, bloqueos y compatibilidad.
  */
-import { buildTrackingImageList, buildImageList } from "./image-list.js";
-import { extractTrackingFeatures } from "./tracker/extract-utils.js";
-import { DetectorLite } from "./detector/detector-lite.js";
-import { build as hierarchicalClusteringBuild } from "./matching/hierarchical-clustering.js";
-import { FourierEncoder } from "./utils/fourier-encoder.js";
-import * as msgpack from "@msgpack/msgpack";
+import { buildTrackingImageList, buildImageList } from "../core/image-list.js";
+import { extractTrackingFeatures } from "../core/tracker/extract-utils.js";
+import { DetectorLite } from "../core/detector/detector-lite.js";
+import { build as hierarchicalClusteringBuild } from "../core/matching/hierarchical-clustering.js";
+import * as protocol from "../core/protocol.js";
 // Detect environment
 const isNode = typeof process !== "undefined" &&
     process.versions != null &&
     process.versions.node != null;
-const CURRENT_VERSION = 7; // Protocol v7: Moonshot - 4-bit Packed Tracking Data
 export class OfflineCompiler {
     data = null;
-    fourierEncoder = new FourierEncoder(4);
     constructor() {
         console.log("⚡ OfflineCompiler: Main thread mode (no workers)");
     }
@@ -78,7 +75,7 @@ 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 });
+                const detector = new DetectorLite(image.width, image.height, { useLSH: true, maxFeaturesPerBucket: 20 });
                 const { featurePoints: ps } = detector.detect(image.data);
                 const maximaPoints = ps.filter((p) => p.maxima);
                 const minimaPoints = ps.filter((p) => !p.maxima);
@@ -157,212 +154,19 @@ export class OfflineCompiler {
                     w: kf.width,
                     h: kf.height,
                     s: kf.scale,
-                    max: this._columnarize(kf.maximaPoints, kf.maximaPointsCluster, kf.width, kf.height),
-                    min: this._columnarize(kf.minimaPoints, kf.minimaPointsCluster, kf.width, kf.height),
+                    max: protocol.columnarize(kf.maximaPoints, kf.maximaPointsCluster, kf.width, kf.height),
+                    min: protocol.columnarize(kf.minimaPoints, kf.minimaPointsCluster, kf.width, kf.height),
                 })),
             };
         });
-        return msgpack.encode({
-            v: CURRENT_VERSION,
-            dataList,
-        });
-    }
-    _getMorton(x, y) {
-        let x_int = x | 0;
-        let y_int = y | 0;
-        x_int = (x_int | (x_int << 8)) & 0x00FF00FF;
-        x_int = (x_int | (x_int << 4)) & 0x0F0F0F0F;
-        x_int = (x_int | (x_int << 2)) & 0x33333333;
-        x_int = (x_int | (x_int << 1)) & 0x55555555;
-        y_int = (y_int | (y_int << 8)) & 0x00FF00FF;
-        y_int = (y_int | (y_int << 4)) & 0x0F0F0F0F;
-        y_int = (y_int | (y_int << 2)) & 0x33333333;
-        y_int = (y_int | (y_int << 1)) & 0x55555555;
-        return x_int | (y_int << 1);
-    }
-    // Keyframe packing is now minimal, most work moved to Workers
-    _columnarize(points, tree, width, height) {
-        const count = points.length;
-        const x = new Uint16Array(count);
-        const y = new Uint16Array(count);
-        const angle = new Int16Array(count);
-        const scale = new Uint8Array(count);
-        const descriptors = new Uint32Array(count * 2);
-        const fourier = new Int8Array(count * 16); // 4 frequencies * 4 components (sin/cos x/y)
-        for (let i = 0; i < count; i++) {
-            x[i] = Math.round((points[i].x / width) * 65535);
-            y[i] = Math.round((points[i].y / height) * 65535);
-            angle[i] = Math.round((points[i].angle / Math.PI) * 32767);
-            scale[i] = Math.round(Math.log2(points[i].scale || 1));
-            if (points[i].descriptors && points[i].descriptors.length >= 2) {
-                descriptors[i * 2] = points[i].descriptors[0];
-                descriptors[(i * 2) + 1] = points[i].descriptors[1];
-            }
-            // 🚀 MOONSHOT: Fourier Positional Encoding
-            const feat = this.fourierEncoder.encode(points[i].x / width, points[i].y / height);
-            for (let j = 0; j < 16; j++) {
-                fourier[i * 16 + j] = Math.round(feat[j] * 127);
-            }
-        }
-        return {
-            x,
-            y,
-            a: angle,
-            s: scale,
-            d: descriptors,
-            f: fourier,
-            t: this._compactTree(tree.rootNode),
-        };
-    }
-    _compactTree(node) {
-        if (node.leaf) {
-            return [1, node.centerPointIndex || 0, node.pointIndexes];
-        }
-        return [0, node.centerPointIndex || 0, node.children.map((c) => this._compactTree(c))];
+        return protocol.encodeTaar(dataList);
     }
     importData(buffer) {
-        const content = msgpack.decode(new Uint8Array(buffer));
-        const version = content.v || 0;
-        if (version !== CURRENT_VERSION && version !== 5) {
-            console.error(`Incompatible .taar version: ${version}. This engine only supports Protocol V5/V6.`);
-            return { version, dataList: [] };
-        }
-        const dataList = content.dataList;
-        for (let i = 0; i < dataList.length; i++) {
-            const item = dataList[i];
-            for (const td of item.trackingData) {
-                let px = td.px;
-                let py = td.py;
-                if (px instanceof Uint8Array) {
-                    px = new Float32Array(px.buffer.slice(px.byteOffset, px.byteOffset + px.byteLength));
-                }
-                if (py instanceof Uint8Array) {
-                    py = new Float32Array(py.buffer.slice(py.byteOffset, py.byteOffset + py.byteLength));
-                }
-                td.px = px;
-                td.py = py;
-                // No longer unpacking 4-bit, keeping original data
-                if (td.data && td.data.length === (td.width * td.height) / 2) {
-                    td.data = this._unpack4Bit(td.data, td.width, td.height);
-                }
-                if (td.d && td.d.length === (td.w * td.h) / 2) {
-                    td.d = this._unpack4Bit(td.d, td.w, td.h);
-                }
-            }
-            for (const kf of item.matchingData) {
-                for (const col of [kf.max, kf.min]) {
-                    let xRaw = col.x;
-                    let yRaw = col.y;
-                    if (xRaw instanceof Uint8Array) {
-                        xRaw = new Uint16Array(xRaw.buffer.slice(xRaw.byteOffset, xRaw.byteOffset + xRaw.byteLength));
-                    }
-                    if (yRaw instanceof Uint8Array) {
-                        yRaw = new Uint16Array(yRaw.buffer.slice(yRaw.byteOffset, yRaw.byteOffset + yRaw.byteLength));
-                    }
-                    const count = xRaw.length;
-                    const x = new Float32Array(count);
-                    const y = new Float32Array(count);
-                    for (let k = 0; k < count; k++) {
-                        x[k] = (xRaw[k] / 65535) * kf.w;
-                        y[k] = (yRaw[k] / 65535) * kf.h;
-                    }
-                    col.x = x;
-                    col.y = y;
-                    if (col.a instanceof Uint8Array) {
-                        const aRaw = new Int16Array(col.a.buffer.slice(col.a.byteOffset, col.a.byteOffset + col.a.byteLength));
-                        const a = new Float32Array(count);
-                        for (let k = 0; k < count; k++) {
-                            a[k] = (aRaw[k] / 32767) * Math.PI;
-                        }
-                        col.a = a;
-                    }
-                    if (col.s instanceof Uint8Array) {
-                        const sRaw = col.s;
-                        const s = new Float32Array(count);
-                        for (let k = 0; k < count; k++) {
-                            s[k] = Math.pow(2, sRaw[k]);
-                        }
-                        col.s = s;
-                    }
-                    if (col.d instanceof Uint8Array) {
-                        col.d = new Uint32Array(col.d.buffer.slice(col.d.byteOffset, col.d.byteOffset + col.d.byteLength));
-                    }
-                    if (col.f instanceof Uint8Array) {
-                        col.f = new Int8Array(col.f.buffer.slice(col.f.byteOffset, col.f.byteOffset + col.f.byteLength));
-                    }
-                }
-            }
-        }
-        this.data = dataList;
-        return { version, dataList };
-    }
-    _unpackKeyframe(kf) {
-        return {
-            width: kf.w,
-            height: kf.h,
-            scale: kf.s,
-            maximaPoints: this._decolumnarize(kf.max, kf.w, kf.h),
-            minimaPoints: this._decolumnarize(kf.min, kf.w, kf.h),
-            maximaPointsCluster: { rootNode: this._expandTree(kf.max.t) },
-            minimaPointsCluster: { rootNode: this._expandTree(kf.min.t) },
-        };
-    }
-    _decolumnarize(col, width, height) {
-        const points = [];
-        const count = col.x.length;
-        const descSize = col.d.length / count;
-        for (let i = 0; i < count; i++) {
-            points.push({
-                x: (col.x[i] / 65535) * width,
-                y: (col.y[i] / 65535) * height,
-                angle: col.a[i],
-                scale: col.s ? col.s[i] : 1.0,
-                descriptors: col.d.slice(i * descSize, (i + 1) * descSize),
-            });
-        }
-        return points;
-    }
-    _expandTree(node) {
-        const isLeaf = node[0] === 1;
-        if (isLeaf) {
-            return {
-                leaf: true,
-                centerPointIndex: node[1],
-                pointIndexes: node[2],
-            };
-        }
-        return {
-            leaf: false,
-            centerPointIndex: node[1],
-            children: node[2].map((c) => this._expandTree(c)),
-        };
+        const result = protocol.decodeTaar(buffer);
+        this.data = result.dataList;
+        return result;
     }
     async destroy() {
         // No workers to destroy
     }
-    _pack4Bit(data) {
-        const length = data.length;
-        if (length % 2 !== 0)
-            return data; // Only pack even lengths
-        const packed = new Uint8Array(length / 2);
-        for (let i = 0; i < length; i += 2) {
-            // Take top 4 bits of each byte
-            const p1 = (data[i] & 0xF0) >> 4;
-            const p2 = (data[i + 1] & 0xF0) >> 4;
-            packed[i / 2] = (p1 << 4) | p2;
-        }
-        return packed;
-    }
-    _unpack4Bit(packed, width, height) {
-        const length = width * height;
-        const data = new Uint8Array(length);
-        for (let i = 0; i < packed.length; i++) {
-            const byte = packed[i];
-            const p1 = (byte & 0xF0); // First pixel (already in high position)
-            const p2 = (byte & 0x0F) << 4; // Second pixel (move to high position)
-            data[i * 2] = p1;
-            data[i * 2 + 1] = p2;
-        }
-        return data;
-    }
 }

package/dist/{compiler → core}/detector/detector-lite.d.ts

@@ -8,6 +8,7 @@ export class DetectorLite {
     height: any;
     useGPU: any;
     useLSH: any;
+    maxFeaturesPerBucket: any;
     numOctaves: number;
     /**
      * Detecta características en una imagen en escala de grises
@@ -25,6 +26,11 @@ export class DetectorLite {
         width: any;
         height: any;
     }[][];
+    _pyramidBuffers: {
+        width: any;
+        height: any;
+        temp: Float32Array<ArrayBuffer>;
+    } | undefined;
     /**
      * Aplica un filtro gaussiano binomial [1,4,6,4,1] - Optimizado
      */

package/dist/{compiler → core}/detector/detector-lite.js

@@ -15,7 +15,7 @@ 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 DEFAULT_MAX_FEATURES_PER_BUCKET = 8;
 const ORIENTATION_NUM_BINS = 36;
 const FREAK_EXPANSION_FACTOR = 7.0;
 // Global GPU mode flag
@@ -37,6 +37,7 @@ export class DetectorLite {
         this.useGPU = options.useGPU !== undefined ? options.useGPU : globalUseGPU;
         // Protocol V6 (Moonshot): 64-bit LSH is the standard descriptor format
         this.useLSH = options.useLSH !== undefined ? options.useLSH : true;
+        this.maxFeaturesPerBucket = options.maxFeaturesPerBucket !== undefined ? options.maxFeaturesPerBucket : DEFAULT_MAX_FEATURES_PER_BUCKET;
         let numOctaves = 0;
         let w = width, h = height;
         while (w >= PYRAMID_MIN_SIZE && h >= PYRAMID_MIN_SIZE) {
@@ -87,7 +88,7 @@ export class DetectorLite {
                 y: ext.y * scale + scale * 0.5 - 0.5,
                 scale: scale,
                 angle: ext.angle || 0,
-                descriptors: (this.useLSH && ext.lsh) ? ext.descriptors : (ext.descriptors || [])
+                descriptors: (this.useLSH && ext.lsh) ? ext.lsh : (ext.descriptors || [])
             };
         });
         return { featurePoints, pyramid: pyramidImages };
@@ -118,22 +119,21 @@ export class DetectorLite {
                 console.warn("GPU pyramid failed, falling back to CPU:", e.message);
             }
         }
-        // Original CPU implementation
+        // Buffer management: Reuse arrays if dimensions match to reduce GC
+        if (!this._pyramidBuffers || this._pyramidBuffers.width !== width || this._pyramidBuffers.height !== height) {
+            this._pyramidBuffers = { width, height, temp: new Float32Array(width * height) };
+        }
         const pyramid = [];
         let currentData = data;
         let currentWidth = width;
         let currentHeight = height;
         for (let i = 0; i < this.numOctaves; i++) {
             const img1 = this._applyGaussianFilter(currentData, currentWidth, currentHeight);
-            // Only need the second blur if we are going to compute DoG with the NEXT layer
-            // or if we need it for this octave's DoG.
-            // Actually, for maxOctaves=1, we only need img1 and maybe img2 for one DoG layer.
             const img2 = this._applyGaussianFilter(img1.data, currentWidth, currentHeight);
             pyramid.push([
                 { data: img1.data, width: currentWidth, height: currentHeight },
                 { data: img2.data, width: currentWidth, height: currentHeight }
             ]);
-            // Downsample para siguiente octava - Only if we have more octaves to go
             if (i < this.numOctaves - 1) {
                 const downsampled = this._downsample(img2.data, currentWidth, currentHeight);
                 currentData = downsampled.data;
@@ -148,7 +148,7 @@ export class DetectorLite {
      */
     _applyGaussianFilter(data, width, height) {
         const output = new Float32Array(width * height);
-        const temp = new Float32Array(width * height);
+        const temp = this._pyramidBuffers?.temp || new Float32Array(width * height);
         const k0 = 0.0625, k1 = 0.25, k2 = 0.375; // 1/16, 4/16, 6/16
         const w1 = width - 1;
         // Horizontal pass - Speed optimized with manual border handling
@@ -305,7 +305,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 → core}/matching/matching.js

@@ -3,12 +3,10 @@ import { compute as hammingCompute } from "./hamming-distance.js";
 import { computeHoughMatches } from "./hough.js";
 import { computeHomography } from "./ransacHomography.js";
 import { multiplyPointHomographyInhomogenous, matrixInverse33 } from "../utils/geometry.js";
-import { FourierEncoder } from "../utils/fourier-encoder.js";
-const encoder = new FourierEncoder(4);
 const INLIER_THRESHOLD = 5.0; // Tightened from 10 to 5 for better precision
 const MIN_NUM_INLIERS = 8; // Restored to 8
 const CLUSTER_MAX_POP = 20;
-const HAMMING_THRESHOLD = 0.8; // Tightened from 0.85 to 0.8 for cleaner matches
+const HAMMING_THRESHOLD = 0.85; // Relaxed from 0.8 back to 0.85
 // match list of querpoints against pre-built list of keyframes
 const match = ({ keyframe, querypoints, querywidth, queryheight, debugMode }) => {
     let debugExtra = {};
@@ -96,7 +94,7 @@ const match = ({ keyframe, querypoints, querywidth, queryheight, debugMode }) =>
         return { debugExtra };
     // Second pass with homography guided matching
     const HInv = matrixInverse33(H, 0.00001);
-    const dThreshold2 = 400; // 20 * 20 - Expanded search window thanks to Fourier filtering
+    const dThreshold2 = 100; // 10 * 10
     const matches2 = [];
     const hi00 = HInv[0], hi01 = HInv[1], hi02 = HInv[2];
     const hi10 = HInv[3], hi11 = HInv[4], hi12 = HInv[5];
@@ -115,29 +113,14 @@ const match = ({ keyframe, querypoints, querywidth, queryheight, debugMode }) =>
         const col = querypoint.maxima ? kmax : kmin;
         if (!col)
             continue;
-        const cx = col.x, cy = col.y, cd = col.d, cf = col.f;
+        const cx = col.x, cy = col.y, cd = col.d;
         const qDesc = querypoint.descriptors;
-        // Fourier encoding of the mapped point (where it SHOULD be in the keyframe)
-        const qFourier = encoder.encode(mapX / keyframe.w, mapY / keyframe.h);
         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;
-            // 🚀 MOONSHOT: Fourier Spatial Harmony Check
-            // We check if the stored point's Fourier signature matches its predicted position
-            let fourierSim = 0;
-            if (cf) {
-                for (let fidx = 0; fidx < 16; fidx++) {
-                    fourierSim += (cf[k * 16 + fidx] / 127) * qFourier[fidx];
-                }
-            }
-            else {
-                fourierSim = 16; // Backward compatibility
-            }
-            if (fourierSim < 8)
-                continue; // Reject if spatially dissonant (low harmonic match)
             const d = hammingCompute({ v1: cd, v1Offset: k * descSize, v2: qDesc });
             if (d < bestD1) {
                 bestD2 = bestD1;

package/dist/core/protocol.d.ts

@@ -0,0 +1,43 @@
+export declare const CURRENT_VERSION = 7;
+/**
+ * Morton Order calculation for spatial sorting
+ */
+export declare function getMorton(x: number, y: number): number;
+/**
+ * Packs 8-bit image data into 4-bit packed data
+ */
+export declare function pack4Bit(data: Uint8Array): Uint8Array;
+/**
+ * Unpacks 4-bit data back to 8-bit image data
+ */
+export declare function unpack4Bit(packed: Uint8Array, width: number, height: number): Uint8Array;
+/**
+ * Columnarizes point data for efficient storage and transfer
+ */
+export declare function columnarize(points: any[], tree: any, width: number, height: number): {
+    x: Uint16Array<ArrayBuffer>;
+    y: Uint16Array<ArrayBuffer>;
+    a: Int16Array<ArrayBuffer>;
+    s: Uint8Array<ArrayBuffer>;
+    d: Uint32Array<ArrayBuffer>;
+    t: any;
+};
+/**
+ * Compacts hierarchical clustering tree into a minimal array structure
+ */
+export declare function compactTree(node: any): any;
+/**
+ * Expands a compacted tree back into an object structure
+ */
+export declare function expandTree(node: any): any;
+/**
+ * Deserializes and normalizes .taar data from a buffer
+ */
+export declare function decodeTaar(buffer: ArrayBuffer | Uint8Array): {
+    version: any;
+    dataList: any;
+};
+/**
+ * Serializes target data into a .taar binary buffer
+ */
+export declare function encodeTaar(dataList: any[]): Uint8Array<ArrayBuffer>;