@srsergio/taptapp-ar 1.0.43 → 1.0.50

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

@@ -12,14 +12,14 @@
 
 import { FREAKPOINTS } from "./freak.js";
 import { gpuCompute } from "../utils/gpu-compute.js";
-import { binarizeFREAK32 } from "../utils/lsh-binarizer.js";
+import { computeLSH64, computeFullFREAK, packLSHIntoDescriptor } from "../utils/lsh-direct.js";
 
-const PYRAMID_MIN_SIZE = 4; // Reducido de 8 a 4 para exprimir al máximo la resolución
+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;
@@ -57,7 +57,7 @@ export class DetectorLite {
             if (numOctaves === 10) break;
         }
 
-        this.numOctaves = numOctaves;
+        this.numOctaves = options.maxOctaves !== undefined ? Math.min(numOctaves, options.maxOctaves) : numOctaves;
     }
 
     /**
@@ -96,16 +96,19 @@ export class DetectorLite {
         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 };
     }
 
     /**
@@ -143,6 +146,10 @@ export class DetectorLite {
 
         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([
@@ -150,7 +157,7 @@ export class DetectorLite {
                 { 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;
@@ -168,44 +175,47 @@ 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 };
@@ -215,36 +225,19 @@ 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 };
     }
 
@@ -277,21 +270,19 @@ 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;
@@ -306,10 +297,11 @@ export class DetectorLite {
                         }
                     }
 
-                    // 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));
@@ -321,10 +313,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));
@@ -391,7 +384,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;
             }
@@ -444,8 +437,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;
             }
 
@@ -479,28 +472,15 @@ export class DetectorLite {
                     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/src/compiler/index.js

@@ -2,10 +2,10 @@ 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,
 };

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

@@ -7,25 +7,51 @@ for (let i = 0; i < 256; i++) {
 }
 
 /**
- * Optimized popcount for 32-bit integers
+ * 🚀 Moonshot Optimized Popcount
+ * Uses a slightly faster bitwise sequence 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;
+  n = n >>> 0; // Force unsigned
+  n -= (n >>> 1) & 0x55555555;
+  n = (n & 0x33333333) + ((n >>> 2) & 0x33333333);
+  return (((n + (n >>> 4)) & 0x0F0F0F0F) * 0x01010101) >>> 24;
 }
 
+/**
+ * Super-optimized Hamming distance for 64-bit LSH (2x Uint32)
+ * NO OBJECTS, NO OPTIONS, JUST PURE SPEED.
+ */
+const compute64 = (v1, v1Idx, v2, v2Idx) => {
+  // Inline XOR and popcount for maximum speed
+  let x1 = (v1[v1Idx] ^ v2[v2Idx]) >>> 0;
+  let x2 = (v1[v1Idx + 1] ^ v2[v2Idx + 1]) >>> 0;
+
+  // Popcount 1
+  x1 -= (x1 >>> 1) & 0x55555555;
+  x1 = (x1 & 0x33333333) + ((x1 >>> 2) & 0x33333333);
+  const count1 = (((x1 + (x1 >>> 4)) & 0x0F0F0F0F) * 0x01010101) >>> 24;
+
+  // Popcount 2
+  x2 -= (x2 >>> 1) & 0x55555555;
+  x2 = (x2 & 0x33333333) + ((x2 >>> 2) & 0x33333333);
+  const count2 = (((x2 + (x2 >>> 4)) & 0x0F0F0F0F) * 0x01010101) >>> 24;
+
+  return count1 + count2;
+};
+
+/**
+ * Generic compute for backward compatibility
+ */
 const compute = (options) => {
   const { v1, v2, v1Offset = 0, v2Offset = 0 } = options;
+  const v2Len = v2.length - v2Offset;
 
-  // 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 (v2Len === 2) {
+    return compute64(v1, v1Offset, v2, v2Offset);
   }
 
-  // If descriptors are 84 bytes (Protocol V4)
-  if (v1.length >= v1Offset + 84 && v2.length >= v2Offset + 84 && v1[v1Offset + 83] !== undefined) {
+  // Protocol V4: 84-byte descriptors (Uint8Array)
+  if (v2Len === 84) {
     let d = 0;
     for (let i = 0; i < 84; i++) {
       d += BIT_COUNT_8[v1[v1Offset + i] ^ v2[v2Offset + i]];
@@ -33,19 +59,16 @@ const compute = (options) => {
     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) {
+  // Protocol V5.1: 128-bit LSH (4 x Uint32)
+  if (v2Len === 4) {
     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]);
   }
 
-  // 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 };
+export { compute, compute64 };

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

@@ -1,101 +1,133 @@
-import { compute as hammingCompute } from "./hamming-distance.js";
+import { compute64 as hammingCompute64 } from "./hamming-distance.js";
 import { createRandomizer } from "../utils/randomizer.js";
 
-const MIN_FEATURE_PER_NODE = 16;
-const NUM_ASSIGNMENT_HYPOTHESES = 64;
+const MIN_FEATURE_PER_NODE = 32; // Increased from 16 for speed
+const NUM_ASSIGNMENT_HYPOTHESES = 12; // Reduced from 16 for speed
 const NUM_CENTERS = 8;
 
+/**
+ * 🚀 Moonshot Optimized K-Medoids
+ * 
+ * Major Optimizations:
+ * 1. Flattened Memory: Operates on a single Uint32Array block instead of objects.
+ * 2. Zero Property Access: Avoids .descriptors lookup in the tightest loop.
+ * 3. Cache-Friendly: Accesses contiguous descriptor data.
+ */
 const _computeKMedoids = (options) => {
-  const { points, pointIndexes, randomizer } = options;
+  const { descriptors, pointIndexes, randomizer } = options;
+  const numPointIndexes = pointIndexes.length;
 
-  const randomPointIndexes = [];
-  for (let i = 0; i < pointIndexes.length; i++) {
-    randomPointIndexes.push(i);
+  const randomPointIndexes = new Int32Array(numPointIndexes);
+  for (let i = 0; i < numPointIndexes; i++) {
+    randomPointIndexes[i] = i;
   }
 
   let bestSumD = Number.MAX_SAFE_INTEGER;
-  let bestAssignmentIndex = -1;
+  let bestAssignment = null;
+
+  // Pre-fetch centers indices to avoid nested index lookups
+  const centerPointIndices = new Int32Array(NUM_CENTERS);
 
-  const assignments = [];
   for (let i = 0; i < NUM_ASSIGNMENT_HYPOTHESES; i++) {
     randomizer.arrayShuffle({ arr: randomPointIndexes, sampleSize: NUM_CENTERS });
 
+    // Set centers for this hypothesis
+    for (let k = 0; k < NUM_CENTERS; k++) {
+      centerPointIndices[k] = pointIndexes[randomPointIndexes[k]];
+    }
+
     let sumD = 0;
-    const assignment = [];
-    for (let j = 0; j < pointIndexes.length; j++) {
-      let bestD = Number.MAX_SAFE_INTEGER;
+    const currentAssignment = new Int32Array(numPointIndexes);
+
+    for (let j = 0; j < numPointIndexes; j++) {
+      const pIdx = pointIndexes[j];
+      const pOffset = pIdx * 2;
+
+      let bestD = 255; // Max possible Hamming for 64-bit is 64, but let's be safe
+      let bestCenterIdx = -1;
+
       for (let k = 0; k < NUM_CENTERS; k++) {
-        const centerIndex = pointIndexes[randomPointIndexes[k]];
-        const d = hammingCompute({
-          v1: points[pointIndexes[j]].descriptors,
-          v2: points[centerIndex].descriptors,
-        });
+        const cIdx = centerPointIndices[k];
+        const cOffset = cIdx * 2;
+
+        // DIRECT CALL TO INLINED HAMMING
+        const d = hammingCompute64(descriptors, pOffset, descriptors, cOffset);
+
         if (d < bestD) {
-          assignment[j] = randomPointIndexes[k];
+          bestCenterIdx = randomPointIndexes[k];
           bestD = d;
         }
       }
+      currentAssignment[j] = bestCenterIdx;
       sumD += bestD;
     }
-    assignments.push(assignment);
 
     if (sumD < bestSumD) {
       bestSumD = sumD;
-      bestAssignmentIndex = i;
+      bestAssignment = currentAssignment;
     }
   }
-  return assignments[bestAssignmentIndex];
+  return bestAssignment;
 };
 
-// kmedoids clustering of points, with hamming distance of FREAK descriptor
-//
-// node = {
-//   isLeaf: bool,
-//   children: [], list of children node
-//   pointIndexes: [], list of int, point indexes
-//   centerPointIndex: int
-// }
+/**
+ * Build hierarchical clusters
+ */
 const build = ({ points }) => {
-  const pointIndexes = [];
-  for (let i = 0; i < points.length; i++) {
-    pointIndexes.push(i);
+  const numPoints = points.length;
+  if (numPoints === 0) return { rootNode: { leaf: true, pointIndexes: [], centerPointIndex: null } };
+
+  // 🚀 MOONSHOT: Flatten all descriptors into a single Uint32Array
+  // This is the key to sub-second performance.
+  const descriptors = new Uint32Array(numPoints * 2);
+  for (let i = 0; i < numPoints; i++) {
+    const d = points[i].descriptors;
+    descriptors[i * 2] = d[0];
+    descriptors[i * 2 + 1] = d[1];
+  }
+
+  const pointIndexes = new Int32Array(numPoints);
+  for (let i = 0; i < numPoints; i++) {
+    pointIndexes[i] = i;
   }
 
   const randomizer = createRandomizer();
 
   const rootNode = _build({
-    points: points,
-    pointIndexes: pointIndexes,
+    descriptors,
+    pointIndexes,
     centerPointIndex: null,
     randomizer,
   });
   return { rootNode };
 };
 
-// recursive build hierarchy clusters
 const _build = (options) => {
-  const { points, pointIndexes, centerPointIndex, randomizer } = options;
+  const { descriptors, pointIndexes, centerPointIndex, randomizer } = options;
+  const numPoints = pointIndexes.length;
 
   let isLeaf = false;
-
-  if (pointIndexes.length <= NUM_CENTERS || pointIndexes.length <= MIN_FEATURE_PER_NODE) {
+  if (numPoints <= NUM_CENTERS || numPoints <= MIN_FEATURE_PER_NODE) {
     isLeaf = true;
   }
 
-  const clusters = {};
+  const clusters = new Map();
   if (!isLeaf) {
-    // compute clusters
-    const assignment = _computeKMedoids({ points, pointIndexes, randomizer });
+    const assignment = _computeKMedoids({ descriptors, pointIndexes, randomizer });
 
     for (let i = 0; i < assignment.length; i++) {
-      if (clusters[pointIndexes[assignment[i]]] === undefined) {
-        clusters[pointIndexes[assignment[i]]] = [];
+      const centerIdx = pointIndexes[assignment[i]];
+      let cluster = clusters.get(centerIdx);
+      if (cluster === undefined) {
+        cluster = [];
+        clusters.set(centerIdx, cluster);
       }
-      clusters[pointIndexes[assignment[i]]].push(pointIndexes[i]);
+      cluster.push(pointIndexes[i]);
+    }
+
+    if (clusters.size === 1) {
+      isLeaf = true;
     }
-  }
-  if (Object.keys(clusters).length === 1) {
-    isLeaf = true;
   }
 
   const node = {
@@ -104,27 +136,23 @@ const _build = (options) => {
 
   if (isLeaf) {
     node.leaf = true;
-    node.pointIndexes = [];
-    for (let i = 0; i < pointIndexes.length; i++) {
-      node.pointIndexes.push(pointIndexes[i]);
-    }
+    node.pointIndexes = new Int32Array(pointIndexes);
     return node;
   }
 
-  // recursive build children
   node.leaf = false;
   node.children = [];
 
-  Object.keys(clusters).forEach((centerIndex) => {
+  for (const [cIdx, clusterPoints] of clusters) {
     node.children.push(
       _build({
-        points: points,
-        pointIndexes: clusters[centerIndex],
-        centerPointIndex: centerIndex,
+        descriptors,
+        pointIndexes: new Int32Array(clusterPoints),
+        centerPointIndex: cIdx,
         randomizer,
       }),
     );
-  });
+  }
   return node;
 };
 

package/src/compiler/matching/matching.js

@@ -4,11 +4,11 @@ import { computeHoughMatches } from "./hough.js";
 import { computeHomography } from "./ransacHomography.js";
 import { multiplyPointHomographyInhomogenous, matrixInverse33 } from "../utils/geometry.js";
 
-const INLIER_THRESHOLD = 3;
+const INLIER_THRESHOLD = 10; // Relaxed from 3 to 10 for better robustness with LSH
 //const MIN_NUM_INLIERS = 8;  //default
 const MIN_NUM_INLIERS = 6;
-const CLUSTER_MAX_POP = 8;
-const HAMMING_THRESHOLD = 0.7;
+const CLUSTER_MAX_POP = 20; // Increased to explore more candidate clusters
+const HAMMING_THRESHOLD = 0.85; // Relaxed ratio test for binary descriptors
 
 // match list of querpoints against pre-built list of keyframes
 const match = ({ keyframe, querypoints, querywidth, queryheight, debugMode }) => {