@srsergio/taptapp-ar 1.0.32 → 1.0.33

package/dist/compiler/offline-compiler.js

@@ -24,7 +24,7 @@ import { WorkerPool } from "./utils/worker-pool.js";
 const isNode = typeof process !== "undefined" &&
     process.versions != null &&
     process.versions.node != null;
-const CURRENT_VERSION = 3; // Protocol v3: High-performance Columnar Binary Format
+const CURRENT_VERSION = 6; // Protocol v6: Moonshot - LSH 64-bit
 /**
  * Compilador offline optimizado sin TensorFlow
  */
@@ -32,9 +32,9 @@ export class OfflineCompiler {
     constructor() {
         this.data = null;
         this.workerPool = null;
-        // Workers solo en Node.js (no en browser)
+        // Workers only in Node.js (no en browser)
         if (isNode) {
-            this._initNodeWorkers();
+            // Lazy init workers only when needed
         }
         else {
             console.log("🌐 OfflineCompiler: Browser mode (no workers)");
@@ -59,7 +59,6 @@ export class OfflineCompiler {
             // Limit workers to avoid freezing system
             const numWorkers = Math.min(os.cpus().length, 4);
             this.workerPool = new WorkerPool(workerPath, numWorkers, Worker);
-            console.log(`🚀 OfflineCompiler: Node.js mode with ${numWorkers} workers`);
         }
         catch (e) {
             console.log("⚡ OfflineCompiler: Running without workers (initialization failed)", e);
@@ -119,6 +118,8 @@ export class OfflineCompiler {
         const percentPerImage = 100 / targetImages.length;
         let currentPercent = 0;
         // Use workers if available
+        if (isNode)
+            await this._initNodeWorkers();
         if (this.workerPool) {
             const progressMap = new Float32Array(targetImages.length);
             const wrappedPromises = targetImages.map((targetImage, index) => {
@@ -144,7 +145,7 @@ export class OfflineCompiler {
             const percentPerScale = percentPerImage / imageList.length;
             const keyframes = [];
             for (const image of imageList) {
-                const detector = new DetectorLite(image.width, image.height);
+                const detector = new DetectorLite(image.width, image.height, { useLSH: true });
                 const { featurePoints: ps } = detector.detect(image.data);
                 const maximaPoints = ps.filter((p) => p.maxima);
                 const minimaPoints = ps.filter((p) => !p.maxima);
@@ -216,8 +217,9 @@ export class OfflineCompiler {
         }
         const dataList = this.data.map((item) => {
             const matchingData = item.matchingData.map((kf) => this._packKeyframe(kf));
-            const trackingData = item.trackingData.map((td) => {
+            const trackingData = [item.trackingData[0]].map((td) => {
                 const count = td.points.length;
+                // Step 1: Packed Coords - Normalize width/height to 16-bit
                 const px = new Float32Array(count);
                 const py = new Float32Array(count);
                 for (let i = 0; i < count; i++) {
@@ -247,28 +249,60 @@ export class OfflineCompiler {
             dataList,
         });
     }
+    _getMorton(x, y) {
+        // Interleave bits of x and 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);
+    }
     _packKeyframe(kf) {
+        // Step 2.1: Morton Sorting - Sort points spatially to improve Delta-Descriptor XOR
+        const sortPoints = (points) => {
+            return [...points].sort((a, b) => {
+                return this._getMorton(a.x, a.y) - this._getMorton(b.x, b.y);
+            });
+        };
+        const sortedMaxima = sortPoints(kf.maximaPoints);
+        const sortedMinima = sortPoints(kf.minimaPoints);
+        // Rebuild clusters with sorted indices
+        const sortedMaximaCluster = hierarchicalClusteringBuild({ points: sortedMaxima });
+        const sortedMinimaCluster = hierarchicalClusteringBuild({ points: sortedMinima });
         return {
             w: kf.width,
             h: kf.height,
             s: kf.scale,
-            max: this._columnarize(kf.maximaPoints, kf.maximaPointsCluster),
-            min: this._columnarize(kf.minimaPoints, kf.minimaPointsCluster),
+            max: this._columnarize(sortedMaxima, sortedMaximaCluster, kf.width, kf.height),
+            min: this._columnarize(sortedMinima, sortedMinimaCluster, kf.width, kf.height),
         };
     }
-    _columnarize(points, tree) {
+    _columnarize(points, tree, width, height) {
         const count = points.length;
-        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)
+        // Step 1: Packed Coords - Normalize to 16-bit
+        const x = new Uint16Array(count);
+        const y = new Uint16Array(count);
+        // Step 1.1: Angle Quantization - Int16
+        const angle = new Int16Array(count);
+        // Step 1.2: Scale Indexing - Uint8
+        const scale = new Uint8Array(count);
+        // Step 3: LSH 64-bit Descriptors - Uint32Array (2 elements per point)
+        const descriptors = new Uint32Array(count * 2);
         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);
+            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];
+            }
         }
         return {
             x,
@@ -287,55 +321,98 @@ export class OfflineCompiler {
     }
     importData(buffer) {
         const content = msgpack.decode(new Uint8Array(buffer));
-        if (!content.v || content.v !== CURRENT_VERSION) {
-            console.error("Incompatible .mind version. Required: " + CURRENT_VERSION);
+        const version = content.v || 0;
+        if (version !== CURRENT_VERSION && version !== 5) {
+            console.error(`Incompatible .mind version: ${version}. This engine only supports Protocol V5/V6.`);
             return [];
         }
-        // Restore Float32Arrays from Uint8Arrays returned by msgpack
+        const descSize = version >= 6 ? 2 : 4;
+        // Restore TypedArrays from Uint8Arrays returned by msgpack
         const dataList = content.dataList;
         for (let i = 0; i < dataList.length; i++) {
             const item = dataList[i];
+            // Unpack Tracking Data
+            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;
+            }
+            // Unpack Matching Data
             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));
+                    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));
                     }
-                    if (col.y instanceof Uint8Array) {
-                        col.y = new Float32Array(col.y.buffer.slice(col.y.byteOffset, col.y.byteOffset + col.y.byteLength));
+                    // Rescale for compatibility with Matcher
+                    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) {
-                        col.a = new Float32Array(col.a.buffer.slice(col.a.byteOffset, col.a.byteOffset + col.a.byteLength));
+                        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) {
-                        col.s = new Float32Array(col.s.buffer.slice(col.s.byteOffset, col.s.byteOffset + col.s.byteLength));
+                        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;
+                    }
+                    // Restore LSH descriptors (Uint32Array)
+                    if (col.d instanceof Uint8Array) {
+                        col.d = new Uint32Array(col.d.buffer.slice(col.d.byteOffset, col.d.byteOffset + col.d.byteLength));
                     }
                 }
             }
         }
         this.data = dataList;
-        return this.data;
+        return { version, dataList };
     }
     _unpackKeyframe(kf) {
         return {
             width: kf.w,
             height: kf.h,
             scale: kf.s,
-            maximaPoints: this._decolumnarize(kf.max),
-            minimaPoints: this._decolumnarize(kf.min),
+            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) {
+    _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],
-                y: col.y[i],
+                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 * 84, (i + 1) * 84),
+                descriptors: col.d.slice(i * descSize, (i + 1) * descSize),
             });
         }
         return points;

package/dist/compiler/simple-ar.d.ts

@@ -77,12 +77,5 @@ export class SimpleAR {
     _initController(): void;
     _handleUpdate(data: any): void;
     _positionOverlay(mVT: any, targetIndex: any): void;
-    /**
-     * Projects a 3D marker-space point all the way to 2D screen CSS pixels
-     */
-    _projectToScreen(x: any, y: any, z: any, mVT: any, proj: any, videoW: any, videoH: any, containerRect: any, needsRotation: any): {
-        sx: number;
-        sy: number;
-    };
 }
 import { Controller } from "./controller.js";

package/dist/compiler/simple-ar.js

@@ -1,5 +1,6 @@
 import { Controller } from "./controller.js";
 import { OneEuroFilter } from "../libs/one-euro-filter.js";
+import { projectToScreen } from "./utils/projection.js";
 /**
  * 🍦 SimpleAR - Dead-simple vanilla AR for image overlays
  *
@@ -132,11 +133,11 @@ class SimpleAR {
             if (!this.filters[targetIndex]) {
                 this.filters[targetIndex] = new OneEuroFilter({ minCutOff: 0.1, beta: 0.01 });
             }
-            // Flatten mVT for filtering (3x4 matrix = 12 values)
+            // Flatten modelViewTransform for filtering (3x4 matrix = 12 values)
             const flatMVT = [
-                mVT[0][0], mVT[0][1], mVT[0][2], mVT[0][3],
-                mVT[1][0], mVT[1][1], mVT[1][2], mVT[1][3],
-                mVT[2][0], mVT[2][1], mVT[2][2], mVT[2][3]
+                modelViewTransform[0][0], modelViewTransform[0][1], modelViewTransform[0][2], modelViewTransform[0][3],
+                modelViewTransform[1][0], modelViewTransform[1][1], modelViewTransform[1][2], modelViewTransform[1][3],
+                modelViewTransform[2][0], modelViewTransform[2][1], modelViewTransform[2][2], modelViewTransform[2][3]
             ];
             const smoothedFlat = this.filters[targetIndex].filter(Date.now(), flatMVT);
             const smoothedMVT = [
@@ -173,8 +174,8 @@ class SimpleAR {
         const proj = this.controller.projectionTransform;
         // 3. Project 3 points to determine position, scale, and rotation
         // Points in Marker Space: Center, Right-Edge, and Down-Edge
-        const pMid = this._projectToScreen(markerW / 2, markerH / 2, 0, mVT, proj, videoW, videoH, containerRect, needsRotation);
-        const pRight = this._projectToScreen(markerW / 2 + 100, markerH / 2, 0, mVT, proj, videoW, videoH, containerRect, needsRotation);
+        const pMid = projectToScreen(markerW / 2, markerH / 2, 0, mVT, proj, videoW, videoH, containerRect, needsRotation);
+        const pRight = projectToScreen(markerW / 2 + 100, markerH / 2, 0, mVT, proj, videoW, videoH, containerRect, needsRotation);
         // 4. Calculate Screen Position
         const screenX = pMid.sx;
         const screenY = pMid.sy;
@@ -215,36 +216,5 @@ class SimpleAR {
             scale(${finalScale})
         `;
     }
-    /**
-     * Projects a 3D marker-space point all the way to 2D screen CSS pixels
-     */
-    _projectToScreen(x, y, z, mVT, proj, videoW, videoH, containerRect, needsRotation) {
-        // Marker -> Camera Space
-        const tx = mVT[0][0] * x + mVT[0][1] * y + mVT[0][2] * z + mVT[0][3];
-        const ty = mVT[1][0] * x + mVT[1][1] * y + mVT[1][2] * z + mVT[1][3];
-        const tz = mVT[2][0] * x + mVT[2][1] * y + mVT[2][2] * z + mVT[2][3];
-        // Camera -> Buffer Pixels (e.g. 1280x720)
-        const bx = (proj[0][0] * tx / tz) + proj[0][2];
-        const by = (proj[1][1] * ty / tz) + proj[1][2];
-        // Buffer -> Screen CSS Pixels
-        const vW = needsRotation ? videoH : videoW;
-        const vH = needsRotation ? videoW : videoH;
-        const perspectiveScale = Math.max(containerRect.width / vW, containerRect.height / vH);
-        const displayW = vW * perspectiveScale;
-        const displayH = vH * perspectiveScale;
-        const offsetX = (containerRect.width - displayW) / 2;
-        const offsetY = (containerRect.height - displayH) / 2;
-        let sx, sy;
-        if (needsRotation) {
-            // Mapping: Camera +X (Right) -> Screen +Y (Down), Camera +Y (Down) -> Screen -X (Left)
-            sx = offsetX + (displayW / 2) - (by - proj[1][2]) * perspectiveScale;
-            sy = offsetY + (displayH / 2) + (bx - proj[0][2]) * perspectiveScale;
-        }
-        else {
-            sx = offsetX + (displayW / 2) + (bx - proj[0][2]) * perspectiveScale;
-            sy = offsetY + (displayH / 2) + (by - proj[1][2]) * perspectiveScale;
-        }
-        return { sx, sy };
-    }
 }
 export { SimpleAR };

package/dist/compiler/tracker/tracker.js

@@ -3,7 +3,7 @@ const AR2_DEFAULT_TS = 6;
 const AR2_DEFAULT_TS_GAP = 1;
 const AR2_SEARCH_SIZE = 10;
 const AR2_SEARCH_GAP = 1;
-const AR2_SIM_THRESH = 0.8;
+const AR2_SIM_THRESH = 0.6;
 const TRACKING_KEYFRAME = 0; // 0: 128px (optimized)
 class Tracker {
     constructor(markerDimensions, trackingDataList, projectionTransform, inputWidth, inputHeight, debugMode = false) {

package/dist/compiler/utils/lsh-binarizer.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Converts an 84-byte FREAK descriptor into a Uint32Array of 2 elements (64 bits).
+ * @param {Uint8Array} descriptor - The 84-byte FREAK descriptor.
+ * @returns {Uint32Array} Array of two 32-bit integers.
+ */
+export function binarizeFREAK64(descriptor: Uint8Array): Uint32Array;
+/**
+ * Converts an 84-byte FREAK descriptor into a Uint32Array of 2 elements (64 bits).
+ * @param {Uint8Array} descriptor - The 84-byte FREAK descriptor.
+ * @returns {Uint32Array} Array of two 32-bit integers.
+ */
+export function binarizeFREAK128(descriptor: Uint8Array): Uint32Array;
+/**
+ * Converts an 84-byte FREAK descriptor into a Uint32Array of 2 elements (64 bits).
+ * @param {Uint8Array} descriptor - The 84-byte FREAK descriptor.
+ * @returns {Uint32Array} Array of two 32-bit integers.
+ */
+export function binarizeFREAK32(descriptor: Uint8Array): Uint32Array;

package/dist/compiler/utils/lsh-binarizer.js

@@ -0,0 +1,37 @@
+/**
+ * LSH Binarizer for FREAK descriptors.
+ *
+ * This utility implements Locality Sensitive Hashing (LSH) for binary descriptors.
+ * It uses simple Bit-Sampling to reduce the 672 bits (84 bytes) of a FREAK
+ * descriptor into a 64-bit (8-byte) fingerprint.
+ *
+ * Bit-sampling is chosen for maximum speed and zero memory overhead,
+ * which fits the Moonshot goal of an ultra-lightweight bundle.
+ */
+// For 64-bit LSH, we use a uniform sampling across the 672-bit descriptor.
+const SAMPLING_INDICES = new Int32Array(64);
+for (let i = 0; i < 64; i++) {
+    SAMPLING_INDICES[i] = Math.floor(i * (672 / 64));
+}
+/**
+ * Converts an 84-byte FREAK descriptor into a Uint32Array of 2 elements (64 bits).
+ * @param {Uint8Array} descriptor - The 84-byte FREAK descriptor.
+ * @returns {Uint32Array} Array of two 32-bit integers.
+ */
+export function binarizeFREAK64(descriptor) {
+    const result = new Uint32Array(2);
+    for (let i = 0; i < 64; i++) {
+        const bitIndex = SAMPLING_INDICES[i];
+        const byteIdx = bitIndex >> 3;
+        const bitIdx = 7 - (bitIndex & 7);
+        if ((descriptor[byteIdx] >> bitIdx) & 1) {
+            const uintIdx = i >> 5; // i / 32
+            const uintBitIdx = i & 31; // i % 32
+            result[uintIdx] |= (1 << uintBitIdx);
+        }
+    }
+    return result;
+}
+// Backward compatibility or for other uses
+export const binarizeFREAK128 = binarizeFREAK64;
+export const binarizeFREAK32 = binarizeFREAK64;

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

@@ -0,0 +1,22 @@
+/**
+ * 📐 AR Projection Utilities
+ * Common logic for projecting 3D marker-space points to 2D screen CSS pixels.
+ */
+/**
+ * Projects a 3D marker-space point (x, y, z) into 2D screen coordinates.
+ *
+ * @param {number} x - Marker X coordinate
+ * @param {number} y - Marker Y coordinate
+ * @param {number} z - Marker Z coordinate (height from surface)
+ * @param {number[][]} mVT - ModelViewTransform matrix (3x4)
+ * @param {number[][]} proj - Projection matrix (3x3)
+ * @param {number} videoW - Internal video width
+ * @param {number} videoH - Internal video height
+ * @param {Object} containerRect - {width, height} of the display container
+ * @param {boolean} needsRotation - Whether the feed needs 90deg rotation (e.g. portrait mobile)
+ * @returns {{sx: number, sy: number}} Screen coordinates [X, Y]
+ */
+export function projectToScreen(x: number, y: number, z: number, mVT: number[][], proj: number[][], videoW: number, videoH: number, containerRect: Object, needsRotation?: boolean): {
+    sx: number;
+    sy: number;
+};

package/dist/compiler/utils/projection.js

@@ -0,0 +1,51 @@
+/**
+ * 📐 AR Projection Utilities
+ * Common logic for projecting 3D marker-space points to 2D screen CSS pixels.
+ */
+/**
+ * Projects a 3D marker-space point (x, y, z) into 2D screen coordinates.
+ *
+ * @param {number} x - Marker X coordinate
+ * @param {number} y - Marker Y coordinate
+ * @param {number} z - Marker Z coordinate (height from surface)
+ * @param {number[][]} mVT - ModelViewTransform matrix (3x4)
+ * @param {number[][]} proj - Projection matrix (3x3)
+ * @param {number} videoW - Internal video width
+ * @param {number} videoH - Internal video height
+ * @param {Object} containerRect - {width, height} of the display container
+ * @param {boolean} needsRotation - Whether the feed needs 90deg rotation (e.g. portrait mobile)
+ * @returns {{sx: number, sy: number}} Screen coordinates [X, Y]
+ */
+export function projectToScreen(x, y, z, mVT, proj, videoW, videoH, containerRect, needsRotation = false) {
+    // 1. Marker Space -> Camera Space (3D)
+    const tx = mVT[0][0] * x + mVT[0][1] * y + mVT[0][2] * z + mVT[0][3];
+    const ty = mVT[1][0] * x + mVT[1][1] * y + mVT[1][2] * z + mVT[1][3];
+    const tz = mVT[2][0] * x + mVT[2][1] * y + mVT[2][2] * z + mVT[2][3];
+    // 2. Camera Space -> Buffer Pixels (2D)
+    // Using intrinsic projection from controller
+    const bx = (proj[0][0] * tx / tz) + proj[0][2];
+    const by = (proj[1][1] * ty / tz) + proj[1][2];
+    // 3. Buffer Pixels -> Screen CSS Pixels
+    const vW = needsRotation ? videoH : videoW;
+    const vH = needsRotation ? videoW : videoH;
+    // Calculate how the video is scaled to cover (object-fit: cover) the container
+    const perspectiveScale = Math.max(containerRect.width / vW, containerRect.height / vH);
+    const displayW = vW * perspectiveScale;
+    const displayH = vH * perspectiveScale;
+    // Centering offsets
+    const offsetX = (containerRect.width - displayW) / 2;
+    const offsetY = (containerRect.height - displayH) / 2;
+    let sx, sy;
+    if (needsRotation) {
+        // Rotation Mapping: 
+        // Camera +X (Right) -> Screen +Y (Down)
+        // Camera +Y (Down)  -> Screen -X (Left)
+        sx = offsetX + (displayW / 2) - (by - proj[1][2]) * perspectiveScale;
+        sy = offsetY + (displayH / 2) + (bx - proj[0][2]) * perspectiveScale;
+    }
+    else {
+        sx = offsetX + (displayW / 2) + (bx - proj[0][2]) * perspectiveScale;
+        sy = offsetY + (displayH / 2) + (by - proj[1][2]) * perspectiveScale;
+    }
+    return { sx, sy };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@srsergio/taptapp-ar",
-    "version": "1.0.32",
+    "version": "1.0.33",
     "description": "AR Compiler for Node.js and Browser",
     "repository": {
         "type": "git",

package/src/compiler/controller.js

@@ -42,7 +42,7 @@ class Controller {
     this.filterBeta = filterBeta === null ? DEFAULT_FILTER_BETA : filterBeta;
     this.warmupTolerance = warmupTolerance === null ? DEFAULT_WARMUP_TOLERANCE : warmupTolerance;
     this.missTolerance = missTolerance === null ? DEFAULT_MISS_TOLERANCE : missTolerance;
-    this.cropDetector = new CropDetector(this.inputWidth, this.inputHeight, debugMode);
+    this.cropDetector = new CropDetector(this.inputWidth, this.inputHeight, debugMode, true);
     this.inputLoader = new InputLoader(this.inputWidth, this.inputHeight);
     this.markerDimensions = null;
     this.onUpdate = onUpdate;
@@ -124,7 +124,7 @@ class Controller {
 
     for (const buffer of buffers) {
       const compiler = new Compiler();
-      const dataList = compiler.importData(buffer);
+      const { dataList } = compiler.importData(buffer);
 
       for (const item of dataList) {
         allMatchingData.push(item.matchingData);
@@ -378,10 +378,10 @@ class Controller {
   }
 
   async match(featurePoints, targetIndex) {
-    const { targetIndex: matchedTargetIndex, modelViewTransform, debugExtra } = await this._workerMatch(featurePoints, [
+    const { targetIndex: matchedTargetIndex, modelViewTransform, screenCoords, worldCoords, debugExtra } = await this._workerMatch(featurePoints, [
       targetIndex,
     ]);
-    return { targetIndex: matchedTargetIndex, modelViewTransform, debugExtra };
+    return { targetIndex: matchedTargetIndex, modelViewTransform, screenCoords, worldCoords, debugExtra };
   }
 
   async track(input, modelViewTransform, targetIndex) {
@@ -408,6 +408,8 @@ class Controller {
         resolve({
           targetIndex: data.targetIndex,
           modelViewTransform: data.modelViewTransform,
+          screenCoords: data.screenCoords,
+          worldCoords: data.worldCoords,
           debugExtra: data.debugExtra,
         });
       };
@@ -426,6 +428,8 @@ class Controller {
 
     let matchedTargetIndex = -1;
     let matchedModelViewTransform = null;
+    let matchedScreenCoords = null;
+    let matchedWorldCoords = null;
     let matchedDebugExtra = null;
 
     for (let i = 0; i < targetIndexes.length; i++) {
@@ -443,6 +447,8 @@ class Controller {
         if (modelViewTransform) {
           matchedTargetIndex = matchingIndex;
           matchedModelViewTransform = modelViewTransform;
+          matchedScreenCoords = screenCoords;
+          matchedWorldCoords = worldCoords;
         }
         break;
       }
@@ -451,6 +457,8 @@ class Controller {
     return {
       targetIndex: matchedTargetIndex,
       modelViewTransform: matchedModelViewTransform,
+      screenCoords: matchedScreenCoords,
+      worldCoords: matchedWorldCoords,
       debugExtra: matchedDebugExtra,
     };
   }

package/src/compiler/detector/crop-detector.js

@@ -11,7 +11,7 @@ class CropDetector {
     let cropSize = Math.pow(2, Math.round(Math.log(minDimension) / Math.log(2)));
     this.cropSize = cropSize;
 
-    this.detector = new DetectorLite(cropSize, cropSize);
+    this.detector = new DetectorLite(cropSize, cropSize, { useLSH: true });
 
     this.lastRandomIndex = 4;
   }

package/src/compiler/detector/detector-lite.js

@@ -12,6 +12,7 @@
 
 import { FREAKPOINTS } from "./freak.js";
 import { gpuCompute } from "../utils/gpu-compute.js";
+import { binarizeFREAK32 } from "../utils/lsh-binarizer.js";
 
 const PYRAMID_MIN_SIZE = 4; // Reducido de 8 a 4 para exprimir al máximo la resolución
 // PYRAMID_MAX_OCTAVE ya no es necesario, el límite lo da PYRAMID_MIN_SIZE
@@ -43,6 +44,8 @@ export class DetectorLite {
         this.width = width;
         this.height = height;
         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;
 
         let numOctaves = 0;
         let w = width, h = height;
@@ -99,7 +102,7 @@ export class DetectorLite {
             y: ext.y * Math.pow(2, ext.octave) + Math.pow(2, ext.octave - 1) - 0.5,
             scale: Math.pow(2, ext.octave),
             angle: ext.angle || 0,
-            descriptors: ext.descriptors || []
+            descriptors: (this.useLSH && ext.lsh) ? ext.lsh : (ext.descriptors || [])
         }));
 
         return { featurePoints };
@@ -494,6 +497,9 @@ export class DetectorLite {
                     }
                 }
             }
+            if (this.useLSH) {
+                ext.lsh = binarizeFREAK32(descriptor);
+            }
             ext.descriptors = descriptor;
         }
     }

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

@@ -1,4 +1,4 @@
-// Precomputed bit count lookup table for Uint8Array (Much faster than bit manipulation)
+// Precomputed bit count lookup table for Uint8Array
 const BIT_COUNT_8 = new Uint8Array(256);
 for (let i = 0; i < 256; i++) {
   let c = 0, n = i;
@@ -6,14 +6,46 @@ for (let i = 0; i < 256; i++) {
   BIT_COUNT_8[i] = c;
 }
 
+/**
+ * Optimized popcount for 32-bit integers
+ */
+function popcount32(n) {
+  n = n - ((n >> 1) & 0x55555555);
+  n = (n & 0x33333333) + ((n >> 2) & 0x33333333);
+  return (((n + (n >> 4)) & 0x0F0F0F0F) * 0x01010101) >> 24;
+}
+
 const compute = (options) => {
   const { v1, v2, v1Offset = 0, v2Offset = 0 } = options;
-  let d = 0;
-  // FREAK descriptors are 84 bytes
-  for (let i = 0; i < 84; i++) {
-    d += BIT_COUNT_8[v1[v1Offset + i] ^ v2[v2Offset + i]];
+
+  // Protocol V5 Path: 64-bit LSH (two Uint32)
+  if (v1.length === v2.length && (v1.length / (v1.buffer.byteLength / v1.length)) === 2) {
+    // This is a bit hacky check, better if we know the version. 
+    // Assuming if it's not 84 bytes, it's the new 8-byte format.
+  }
+
+  // If descriptors are 84 bytes (Protocol V4)
+  if (v1.length >= v1Offset + 84 && v2.length >= v2Offset + 84 && v1[v1Offset + 83] !== undefined) {
+    let d = 0;
+    for (let i = 0; i < 84; i++) {
+      d += BIT_COUNT_8[v1[v1Offset + i] ^ v2[v2Offset + i]];
+    }
+    return d;
+  }
+
+  // Protocol V5.1 Path: LSH 128-bit (4 x 32-bit)
+  // We expect v1 and v2 to be slices or offsets of Uint32Array
+  if (v1.length >= v1Offset + 4 && v2.length >= v2Offset + 4 && v1[v1Offset + 3] !== undefined) {
+    return popcount32(v1[v1Offset] ^ v2[v2Offset]) +
+      popcount32(v1[v1Offset + 1] ^ v2[v2Offset + 1]) +
+      popcount32(v1[v1Offset + 2] ^ v2[v2Offset + 2]) +
+      popcount32(v1[v1Offset + 3] ^ v2[v2Offset + 3]);
   }
-  return d;
+
+  // Protocol V5 Path: LSH 64-bit (2 x 32-bit)
+  // We expect v1 and v2 to be slices or offsets of Uint32Array
+  return popcount32(v1[v1Offset] ^ v2[v2Offset]) +
+    popcount32(v1[v1Offset + 1] ^ v2[v2Offset + 1]);
 };
 
 export { compute };