@srsergio/taptapp-ar 1.0.43 → 1.0.50

package/dist/compiler/controller.js

@@ -5,21 +5,49 @@ import { InputLoader } from "./input-loader.js";
 import { OneEuroFilter } from "../libs/one-euro-filter.js";
 let ControllerWorker;
 // Conditional import for worker to avoid crash in non-vite environments
-try {
-    const workerModule = await import("./controller.worker.js?worker&inline");
-    ControllerWorker = workerModule.default;
-}
-catch (e) {
-    // Fallback for tests or other environments
-    ControllerWorker = null;
-}
-const DEFAULT_FILTER_CUTOFF = 0.1; // Menor cutoff para filtrar más ruidos cuando está quieto
-const DEFAULT_FILTER_BETA = 0.01; // Beta bajo para suavizar movimientos rápidos
-const DEFAULT_WARMUP_TOLERANCE = 8; // Más frames de calentamiento para asegurar estabilidad inicial
-const DEFAULT_MISS_TOLERANCE = 2; // Reducido para que el objeto desaparezca más rápido tras pérdida
+const getControllerWorker = async () => {
+    if (typeof Worker === 'undefined')
+        return null;
+    try {
+        // @ts-ignore
+        const workerModule = await import("./controller.worker.js?worker&inline");
+        return workerModule.default;
+    }
+    catch (e) {
+        return null;
+    }
+};
+ControllerWorker = await getControllerWorker();
+const DEFAULT_FILTER_CUTOFF = 0.1;
+const DEFAULT_FILTER_BETA = 0.01;
+const DEFAULT_WARMUP_TOLERANCE = 8;
+const DEFAULT_MISS_TOLERANCE = 2;
 class Controller {
-    constructor({ inputWidth, inputHeight, onUpdate = null, debugMode = false, maxTrack = 1, warmupTolerance = null, missTolerance = null, filterMinCF = null, filterBeta = null, worker = null, // Allow custom worker injection
-     }) {
+    inputWidth;
+    inputHeight;
+    maxTrack;
+    filterMinCF;
+    filterBeta;
+    warmupTolerance;
+    missTolerance;
+    cropDetector;
+    inputLoader;
+    markerDimensions = null;
+    onUpdate;
+    debugMode;
+    processingVideo = false;
+    interestedTargetIndex = -1;
+    trackingStates = [];
+    worker;
+    projectionTransform;
+    projectionMatrix;
+    tracker = null;
+    matchingDataList;
+    workerMatchDone = null;
+    workerTrackDone = null;
+    mainThreadMatcher;
+    mainThreadEstimator;
+    constructor({ inputWidth, inputHeight, onUpdate = null, debugMode = false, maxTrack = 1, warmupTolerance = null, missTolerance = null, filterMinCF = null, filterBeta = null, worker = null, }) {
         this.inputWidth = inputWidth;
         this.inputHeight = inputHeight;
         this.maxTrack = maxTrack;
@@ -27,14 +55,10 @@ 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, true);
+        this.cropDetector = new CropDetector(this.inputWidth, this.inputHeight, debugMode);
         this.inputLoader = new InputLoader(this.inputWidth, this.inputHeight);
-        this.markerDimensions = null;
         this.onUpdate = onUpdate;
         this.debugMode = debugMode;
-        this.processingVideo = false;
-        this.interestedTargetIndex = -1;
-        this.trackingStates = [];
         this.worker = worker;
         if (this.worker)
             this._setupWorkerListener();
@@ -70,37 +94,27 @@ class Controller {
     _ensureWorker() {
         if (this.worker)
             return;
-        if (ControllerWorker) {
+        if (ControllerWorker && typeof Worker !== 'undefined') {
             this.worker = new ControllerWorker();
             this._setupWorkerListener();
         }
     }
-    /**
-     * Load image targets from one or multiple .mind files
-     * @param {string|string[]} fileURLs - Single URL or array of URLs to .mind files
-     * @returns {Promise<{dimensions, matchingDataList, trackingDataList}>}
-     */
     async addImageTargets(fileURLs) {
         const urls = Array.isArray(fileURLs) ? fileURLs : [fileURLs];
-        // Fetch all .mind files in parallel
         const buffers = await Promise.all(urls.map(async (url) => {
             const response = await fetch(url);
             return response.arrayBuffer();
         }));
-        // Combine all buffers into a single target list
         return this.addImageTargetsFromBuffers(buffers);
     }
-    /**
-     * Load image targets from multiple ArrayBuffers
-     * @param {ArrayBuffer[]} buffers - Array of .mind file buffers
-     */
     addImageTargetsFromBuffers(buffers) {
         const allTrackingData = [];
         const allMatchingData = [];
         const allDimensions = [];
         for (const buffer of buffers) {
             const compiler = new Compiler();
-            const { dataList } = compiler.importData(buffer);
+            const result = compiler.importData(buffer);
+            const dataList = result.dataList || [];
             for (const item of dataList) {
                 allMatchingData.push(item.matchingData);
                 allTrackingData.push(item.trackingData);
@@ -120,13 +134,9 @@ class Controller {
             });
         }
         this.markerDimensions = allDimensions;
-        this.matchingDataList = allMatchingData; // Store for main-thread fallback
+        this.matchingDataList = allMatchingData;
         return { dimensions: allDimensions, matchingDataList: allMatchingData, trackingDataList: allTrackingData };
     }
-    /**
-     * Load image targets from a single ArrayBuffer (backward compatible)
-     * @param {ArrayBuffer} buffer - Single .mind file buffer
-     */
     addImageTargetsFromBuffer(buffer) {
         return this.addImageTargetsFromBuffers([buffer]);
     }
@@ -146,31 +156,12 @@ class Controller {
         return this.projectionMatrix;
     }
     getRotatedZ90Matrix(m) {
-        // rotate 90 degree along z-axis
-        // rotation matrix
-        // |  0  -1  0  0 |
-        // |  1   0  0  0 |
-        // |  0   0  1  0 |
-        // |  0   0  0  1 |
-        const rotatedMatrix = [
-            -m[1],
-            m[0],
-            m[2],
-            m[3],
-            -m[5],
-            m[4],
-            m[6],
-            m[7],
-            -m[9],
-            m[8],
-            m[10],
-            m[11],
-            -m[13],
-            m[12],
-            m[14],
-            m[15],
+        return [
+            -m[1], m[0], m[2], m[3],
+            -m[5], m[4], m[6], m[7],
+            -m[9], m[8], m[10], m[11],
+            -m[13], m[12], m[14], m[15],
         ];
-        return rotatedMatrix;
     }
     getWorldMatrix(modelViewTransform, targetIndex) {
         return this._glModelViewMatrix(modelViewTransform, targetIndex);
@@ -183,7 +174,7 @@ class Controller {
     async _trackAndUpdate(inputData, lastModelViewTransform, targetIndex) {
         const { worldCoords, screenCoords } = this.tracker.track(inputData, lastModelViewTransform, targetIndex);
         if (worldCoords.length < 6)
-            return null; // Umbral de puntos mínimos para mantener el seguimiento
+            return null;
         const modelViewTransform = await this._workerTrackUpdate(lastModelViewTransform, {
             worldCoords,
             screenCoords,
@@ -195,7 +186,7 @@ class Controller {
             return;
         this.processingVideo = true;
         this.trackingStates = [];
-        for (let i = 0; i < this.markerDimensions.length; i++) {
+        for (let i = 0; i < (this.markerDimensions?.length || 0); i++) {
             this.trackingStates.push({
                 showing: false,
                 isTracking: false,
@@ -210,10 +201,7 @@ class Controller {
                 if (!this.processingVideo)
                     break;
                 const inputData = this.inputLoader.loadInput(input);
-                const nTracking = this.trackingStates.reduce((acc, s) => {
-                    return acc + (!!s.isTracking ? 1 : 0);
-                }, 0);
-                // detect and match only if less then maxTrack
+                const nTracking = this.trackingStates.reduce((acc, s) => acc + (!!s.isTracking ? 1 : 0), 0);
                 if (nTracking < this.maxTrack) {
                     const matchingIndexes = [];
                     for (let i = 0; i < this.trackingStates.length; i++) {
@@ -230,7 +218,6 @@ class Controller {
                         this.trackingStates[matchedTargetIndex].currentModelViewTransform = modelViewTransform;
                     }
                 }
-                // tracking update
                 for (let i = 0; i < this.trackingStates.length; i++) {
                     const trackingState = this.trackingStates[i];
                     if (trackingState.isTracking) {
@@ -242,7 +229,6 @@ class Controller {
                             trackingState.currentModelViewTransform = modelViewTransform;
                         }
                     }
-                    // if not showing, then show it once it reaches warmup number of frames
                     if (!trackingState.showing) {
                         if (trackingState.isTracking) {
                             trackingState.trackMiss = 0;
@@ -254,7 +240,6 @@ class Controller {
                             }
                         }
                     }
-                    // if showing, then count miss, and hide it when reaches tolerance
                     if (trackingState.showing) {
                         if (!trackingState.isTracking) {
                             trackingState.trackCount = 0;
@@ -262,32 +247,30 @@ class Controller {
                             if (trackingState.trackMiss > this.missTolerance) {
                                 trackingState.showing = false;
                                 trackingState.trackingMatrix = null;
-                                this.onUpdate &&
-                                    this.onUpdate({ type: "updateMatrix", targetIndex: i, worldMatrix: null });
+                                this.onUpdate && this.onUpdate({ type: "updateMatrix", targetIndex: i, worldMatrix: null });
                             }
                         }
                         else {
                             trackingState.trackMiss = 0;
                         }
                     }
-                    // if showing, then call onUpdate, with world matrix
                     if (trackingState.showing) {
                         const worldMatrix = this._glModelViewMatrix(trackingState.currentModelViewTransform, i);
                         trackingState.trackingMatrix = trackingState.filter.filter(Date.now(), worldMatrix);
-                        let clone = [];
-                        for (let j = 0; j < trackingState.trackingMatrix.length; j++) {
-                            clone[j] = trackingState.trackingMatrix[j];
-                        }
+                        let clone = [...trackingState.trackingMatrix];
                         const isInputRotated = input.width === this.inputHeight && input.height === this.inputWidth;
                         if (isInputRotated) {
                             clone = this.getRotatedZ90Matrix(clone);
                         }
-                        this.onUpdate &&
-                            this.onUpdate({ type: "updateMatrix", targetIndex: i, worldMatrix: clone, modelViewTransform: trackingState.currentModelViewTransform });
+                        this.onUpdate && this.onUpdate({
+                            type: "updateMatrix",
+                            targetIndex: i,
+                            worldMatrix: clone,
+                            modelViewTransform: trackingState.currentModelViewTransform
+                        });
                     }
                 }
                 this.onUpdate && this.onUpdate({ type: "processDone" });
-                // Use requestAnimationFrame if available, otherwise just wait briefly
                 if (typeof requestAnimationFrame !== "undefined") {
                     await new Promise(requestAnimationFrame);
                 }
@@ -314,18 +297,15 @@ class Controller {
     }
     async track(input, modelViewTransform, targetIndex) {
         const inputData = this.inputLoader.loadInput(input);
-        const result = this.tracker.track(inputData, modelViewTransform, targetIndex);
-        return result;
+        return this.tracker.track(inputData, modelViewTransform, targetIndex);
     }
     async trackUpdate(modelViewTransform, trackFeatures) {
         if (trackFeatures.worldCoords.length < 4)
             return null;
-        const modelViewTransform2 = await this._workerTrackUpdate(modelViewTransform, trackFeatures);
-        return modelViewTransform2;
+        return this._workerTrackUpdate(modelViewTransform, trackFeatures);
     }
     _workerMatch(featurePoints, targetIndexes) {
         return new Promise((resolve) => {
-            // If no worker available, process on main thread
             if (!this.worker) {
                 this._matchOnMainThread(featurePoints, targetIndexes).then(resolve);
                 return;
@@ -343,7 +323,6 @@ class Controller {
         });
     }
     async _matchOnMainThread(featurePoints, targetIndexes) {
-        // Lazy initialize Matcher and Estimator for main thread
         if (!this.mainThreadMatcher) {
             const { Matcher } = await import("./matching/matcher.js");
             const { Estimator } = await import("./estimation/estimator.js");
@@ -380,7 +359,6 @@ class Controller {
     }
     _workerTrackUpdate(modelViewTransform, trackingFeatures) {
         return new Promise((resolve) => {
-            // If no worker available, process on main thread
             if (!this.worker) {
                 this._trackUpdateOnMainThread(modelViewTransform, trackingFeatures).then(resolve);
                 return;
@@ -398,55 +376,33 @@ class Controller {
         });
     }
     async _trackUpdateOnMainThread(modelViewTransform, trackingFeatures) {
-        // Lazy initialize Estimator for main thread
         if (!this.mainThreadEstimator) {
             const { Estimator } = await import("./estimation/estimator.js");
             this.mainThreadEstimator = new Estimator(this.projectionTransform);
         }
         const { worldCoords, screenCoords } = trackingFeatures;
-        const finalModelViewTransform = this.mainThreadEstimator.refineEstimate({
+        return this.mainThreadEstimator.refineEstimate({
             initialModelViewTransform: modelViewTransform,
             worldCoords,
             screenCoords,
         });
-        return finalModelViewTransform;
     }
     _glModelViewMatrix(modelViewTransform, targetIndex) {
         const height = this.markerDimensions[targetIndex][1];
-        const openGLWorldMatrix = [
-            modelViewTransform[0][0],
-            -modelViewTransform[1][0],
-            -modelViewTransform[2][0],
-            0,
-            -modelViewTransform[0][1],
-            modelViewTransform[1][1],
-            modelViewTransform[2][1],
-            0,
-            -modelViewTransform[0][2],
-            modelViewTransform[1][2],
-            modelViewTransform[2][2],
-            0,
+        return [
+            modelViewTransform[0][0], -modelViewTransform[1][0], -modelViewTransform[2][0], 0,
+            -modelViewTransform[0][1], modelViewTransform[1][1], modelViewTransform[2][1], 0,
+            -modelViewTransform[0][2], modelViewTransform[1][2], modelViewTransform[2][2], 0,
             modelViewTransform[0][1] * height + modelViewTransform[0][3],
             -(modelViewTransform[1][1] * height + modelViewTransform[1][3]),
             -(modelViewTransform[2][1] * height + modelViewTransform[2][3]),
             1,
         ];
-        return openGLWorldMatrix;
     }
     _glProjectionMatrix({ projectionTransform, width, height, near, far }) {
         const proj = [
-            [
-                (2 * projectionTransform[0][0]) / width,
-                0,
-                -((2 * projectionTransform[0][2]) / width - 1),
-                0,
-            ],
-            [
-                0,
-                (2 * projectionTransform[1][1]) / height,
-                -((2 * projectionTransform[1][2]) / height - 1),
-                0,
-            ],
+            [(2 * projectionTransform[0][0]) / width, 0, -((2 * projectionTransform[0][2]) / width - 1), 0],
+            [0, (2 * projectionTransform[1][1]) / height, -((2 * projectionTransform[1][2]) / height - 1), 0],
             [0, 0, -(far + near) / (far - near), (-2 * far * near) / (far - near)],
             [0, 0, -1, 0],
         ];

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

@@ -11,11 +11,11 @@
  */
 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
+import { computeLSH64, computeFullFREAK, packLSHIntoDescriptor } from "../utils/lsh-direct.js";
+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 = 8;
-const MAX_FEATURES_PER_BUCKET = 12; // Ajustado para un equilibrio óptimo entre densidad y estabilidad
+const NUM_BUCKETS_PER_DIMENSION = 10;
+const MAX_FEATURES_PER_BUCKET = 30; // Maximized to ensure robustness in Moonshot mode
 const ORIENTATION_NUM_BINS = 36;
 const FREAK_EXPANSION_FACTOR = 7.0;
 // Global GPU mode flag
@@ -47,7 +47,7 @@ export class DetectorLite {
             if (numOctaves === 10)
                 break;
         }
-        this.numOctaves = numOctaves;
+        this.numOctaves = options.maxOctaves !== undefined ? Math.min(numOctaves, options.maxOctaves) : numOctaves;
     }
     /**
      * Detecta características en una imagen en escala de grises
@@ -79,15 +79,18 @@ export class DetectorLite {
         // 6. Calcular descriptores FREAK
         this._computeFreakDescriptors(prunedExtremas, pyramidImages);
         // Convertir a formato de salida
-        const featurePoints = prunedExtremas.map(ext => ({
-            maxima: ext.score > 0,
-            x: ext.x * Math.pow(2, ext.octave) + Math.pow(2, ext.octave - 1) - 0.5,
-            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: (this.useLSH && ext.lsh) ? ext.lsh : (ext.descriptors || [])
-        }));
-        return { featurePoints };
+        const featurePoints = prunedExtremas.map(ext => {
+            const scale = Math.pow(2, ext.octave);
+            return {
+                maxima: ext.score > 0,
+                x: ext.x * scale + scale * 0.5 - 0.5,
+                y: ext.y * scale + scale * 0.5 - 0.5,
+                scale: scale,
+                angle: ext.angle || 0,
+                descriptors: (this.useLSH && ext.lsh) ? ext.descriptors : (ext.descriptors || [])
+            };
+        });
+        return { featurePoints, pyramid: pyramidImages };
     }
     /**
      * Construye una pirámide gaussiana
@@ -122,12 +125,15 @@ export class DetectorLite {
         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
+            // 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;
@@ -143,40 +149,40 @@ export class DetectorLite {
     _applyGaussianFilter(data, width, height) {
         const output = new Float32Array(width * height);
         const temp = new Float32Array(width * height);
-        const k0 = 1 / 16, k1 = 4 / 16, k2 = 6 / 16;
+        const k0 = 0.0625, k1 = 0.25, k2 = 0.375; // 1/16, 4/16, 6/16
         const w1 = width - 1;
-        const h1 = height - 1;
-        // Horizontal pass - unrolled kernel
+        // Horizontal pass - Speed optimized with manual border handling
         for (let y = 0; y < height; y++) {
             const rowOffset = y * width;
-            for (let x = 0; x < width; x++) {
-                const x0 = x < 2 ? 0 : x - 2;
-                const x1 = x < 1 ? 0 : x - 1;
-                const x3 = x > w1 - 1 ? w1 : x + 1;
-                const x4 = x > w1 - 2 ? w1 : x + 2;
-                temp[rowOffset + x] =
-                    data[rowOffset + x0] * k0 +
-                        data[rowOffset + x1] * k1 +
-                        data[rowOffset + x] * k2 +
-                        data[rowOffset + x3] * k1 +
-                        data[rowOffset + x4] * k0;
+            // Left border
+            temp[rowOffset] = data[rowOffset] * (k0 + k1 + k2) + data[rowOffset + 1] * k1 + data[rowOffset + 2] * k0;
+            temp[rowOffset + 1] = data[rowOffset] * k1 + data[rowOffset + 1] * k2 + data[rowOffset + 2] * k1 + data[rowOffset + 3] * k0;
+            // Main loop - NO boundary checks
+            for (let x = 2; x < width - 2; x++) {
+                const pos = rowOffset + x;
+                temp[pos] = data[pos - 2] * k0 + data[pos - 1] * k1 + data[pos] * k2 + data[pos + 1] * k1 + data[pos + 2] * k0;
             }
+            // Right border
+            const r2 = rowOffset + width - 2;
+            const r1 = rowOffset + width - 1;
+            temp[r2] = data[r2 - 2] * k0 + data[r2 - 1] * k1 + data[r2] * k2 + data[r1] * k1;
+            temp[r1] = data[r1 - 2] * k0 + data[r1 - 1] * k1 + data[r1] * (k2 + k1 + k0);
         }
-        // Vertical pass - unrolled kernel
-        for (let y = 0; y < height; y++) {
-            const y0 = (y < 2 ? 0 : y - 2) * width;
-            const y1 = (y < 1 ? 0 : y - 1) * width;
-            const y2 = y * width;
-            const y3 = (y > h1 - 1 ? h1 : y + 1) * width;
-            const y4 = (y > h1 - 2 ? h1 : y + 2) * width;
-            for (let x = 0; x < width; x++) {
-                output[y2 + x] =
-                    temp[y0 + x] * k0 +
-                        temp[y1 + x] * k1 +
-                        temp[y2 + x] * k2 +
-                        temp[y3 + x] * k1 +
-                        temp[y4 + x] * k0;
+        // Vertical pass - Speed optimized
+        for (let x = 0; x < width; x++) {
+            // Top border
+            output[x] = temp[x] * (k0 + k1 + k2) + temp[x + width] * k1 + temp[x + width * 2] * k0;
+            output[x + width] = temp[x] * k1 + temp[x + width] * k2 + temp[x + width * 2] * k1 + temp[x + width * 3] * k0;
+            // Main loop - NO boundary checks
+            for (let y = 2; y < height - 2; y++) {
+                const p = y * width + x;
+                output[p] = temp[p - width * 2] * k0 + temp[p - width] * k1 + temp[p] * k2 + temp[p + width] * k1 + temp[p + width * 2] * k0;
             }
+            // Bottom border
+            const b2 = (height - 2) * width + x;
+            const b1 = (height - 1) * width + x;
+            output[b2] = temp[b2 - width * 2] * k0 + temp[b2 - width] * k1 + temp[b2] * k2 + temp[b1] * k1;
+            output[b1] = temp[b1 - width * 2] * k0 + temp[b1 - width] * k1 + temp[b1] * (k2 + k1 + k0);
         }
         return { data: output, width, height };
     }
@@ -184,29 +190,16 @@ export class DetectorLite {
      * Downsample imagen por factor de 2
      */
     _downsample(data, width, height) {
-        const newWidth = Math.floor(width / 2);
-        const newHeight = Math.floor(height / 2);
+        const newWidth = width >> 1;
+        const newHeight = height >> 1;
         const output = new Float32Array(newWidth * newHeight);
         for (let y = 0; y < newHeight; y++) {
+            const r0 = (y * 2) * width;
+            const r1 = r0 + width;
+            const dr = y * newWidth;
             for (let x = 0; x < newWidth; x++) {
-                // Interpolación bilinear
-                const srcX = x * 2 + 0.5;
-                const srcY = y * 2 + 0.5;
-                const x0 = Math.floor(srcX);
-                const y0 = Math.floor(srcY);
-                const x1 = Math.min(x0 + 1, width - 1);
-                const y1 = Math.min(y0 + 1, height - 1);
-                const fx = srcX - x0;
-                const fy = srcY - y0;
-                const v00 = data[y0 * width + x0];
-                const v10 = data[y0 * width + x1];
-                const v01 = data[y1 * width + x0];
-                const v11 = data[y1 * width + x1];
-                output[y * newWidth + x] =
-                    v00 * (1 - fx) * (1 - fy) +
-                        v10 * fx * (1 - fy) +
-                        v01 * (1 - fx) * fy +
-                        v11 * fx * fy;
+                const i2 = x * 2;
+                output[dr + x] = (data[r0 + i2] + data[r0 + i2 + 1] + data[r1 + i2] + data[r1 + i2 + 1]) * 0.25;
             }
         }
         return { data: output, width: newWidth, height: newHeight };
@@ -234,19 +227,17 @@ export class DetectorLite {
      */
     _findExtremas(dogPyramid, pyramidImages) {
         const extremas = [];
-        for (let octave = 1; octave < dogPyramid.length - 1; octave++) {
+        for (let octave = 0; octave < dogPyramid.length; octave++) {
             const curr = dogPyramid[octave];
-            const prev = dogPyramid[octave - 1];
-            const next = dogPyramid[octave + 1];
+            const prev = octave > 0 ? dogPyramid[octave - 1] : null;
+            const next = octave < dogPyramid.length - 1 ? dogPyramid[octave + 1] : null;
             const width = curr.width;
             const height = curr.height;
-            const prevWidth = prev.width;
-            const nextWidth = next.width;
             for (let y = 1; y < height - 1; y++) {
                 for (let x = 1; x < width - 1; x++) {
                     const val = curr.data[y * width + x];
-                    if (Math.abs(val) < 0.01)
-                        continue; // Threshold reducido de 0.015 a 0.01 para mayor sensibilidad
+                    if (Math.abs(val) < 0.003)
+                        continue; // Aggressively lowered threshold to 0.003 for max sensitivity
                     let isMaxima = true;
                     let isMinima = true;
                     // Check 3x3 neighborhood in current scale
@@ -261,10 +252,11 @@ export class DetectorLite {
                                 isMinima = false;
                         }
                     }
-                    // Check previous scale (scaled coordinates)
-                    if (isMaxima || isMinima) {
-                        const px = Math.floor(x * 2);
-                        const py = Math.floor(y * 2);
+                    // Check previous scale (scaled coordinates) - skip if no prev layer
+                    if ((isMaxima || isMinima) && prev) {
+                        const px = x << 1;
+                        const py = y << 1;
+                        const prevWidth = prev.width;
                         for (let dy = -1; dy <= 1 && (isMaxima || isMinima); dy++) {
                             for (let dx = -1; dx <= 1 && (isMaxima || isMinima); dx++) {
                                 const xx = Math.max(0, Math.min(prevWidth - 1, px + dx));
@@ -277,10 +269,11 @@ export class DetectorLite {
                             }
                         }
                     }
-                    // Check next scale (scaled coordinates)
-                    if (isMaxima || isMinima) {
-                        const nx = Math.floor(x / 2);
-                        const ny = Math.floor(y / 2);
+                    // Check next scale (scaled coordinates) - skip if no next layer
+                    if ((isMaxima || isMinima) && next) {
+                        const nx = x >> 1;
+                        const ny = y >> 1;
+                        const nextWidth = next.width;
                         for (let dy = -1; dy <= 1 && (isMaxima || isMinima); dy++) {
                             for (let dx = -1; dx <= 1 && (isMaxima || isMinima); dx++) {
                                 const xx = Math.max(0, Math.min(nextWidth - 1, nx + dx));
@@ -341,7 +334,7 @@ export class DetectorLite {
      */
     _computeOrientations(extremas, pyramidImages) {
         for (const ext of extremas) {
-            if (ext.octave < 1 || ext.octave >= pyramidImages.length) {
+            if (ext.octave < 0 || ext.octave >= pyramidImages.length) {
                 ext.angle = 0;
                 continue;
             }
@@ -384,8 +377,8 @@ export class DetectorLite {
      */
     _computeFreakDescriptors(extremas, pyramidImages) {
         for (const ext of extremas) {
-            if (ext.octave < 1 || ext.octave >= pyramidImages.length) {
-                ext.descriptors = [];
+            if (ext.octave < 0 || ext.octave >= pyramidImages.length) {
+                ext.descriptors = new Uint8Array(8);
                 continue;
             }
             const img = pyramidImages[ext.octave][1];
@@ -412,26 +405,16 @@ export class DetectorLite {
                         data[y1 * width + x0] * (1 - fracX) * fracY +
                         data[y1 * width + x1] * fracX * fracY;
             }
-            // Pack pairs into Uint8Array (84 bytes per descriptor)
-            const descriptor = new Uint8Array(84);
-            let bitCount = 0;
-            let byteIdx = 0;
-            for (let i = 0; i < FREAKPOINTS.length; i++) {
-                for (let j = i + 1; j < FREAKPOINTS.length; j++) {
-                    if (samples[i] < samples[j]) {
-                        descriptor[byteIdx] |= (1 << (7 - bitCount));
-                    }
-                    bitCount++;
-                    if (bitCount === 8) {
-                        byteIdx++;
-                        bitCount = 0;
-                    }
-                }
-            }
+            // 🚀 MOONSHOT: Direct LSH computation
+            // Avoids computing 672 bits of FREAK just to sample 64.
             if (this.useLSH) {
-                ext.lsh = binarizeFREAK32(descriptor);
+                ext.lsh = computeLSH64(samples);
+                // Pack LSH into 8-byte descriptors for compatibility
+                ext.descriptors = packLSHIntoDescriptor(ext.lsh);
+            }
+            else {
+                ext.descriptors = computeFullFREAK(samples);
             }
-            ext.descriptors = descriptor;
         }
     }
 }

package/dist/compiler/index.js

@@ -1,8 +1,8 @@
 import { OfflineCompiler } from "./offline-compiler.js";
 export { OfflineCompiler };
-if (!window.MINDAR) {
-    window.MINDAR = {};
+if (!window.TAAR) {
+    window.TAAR = {};
 }
-window.MINDAR.IMAGE = {
+window.TAAR.IMAGE = {
     OfflineCompiler,
 };