@srsergio/taptapp-ar 1.0.0 → 1.0.3

package/src/compiler/tracker/extract.js

@@ -1,18 +1,29 @@
 import { Cumsum } from "../utils/cumsum.js";
+import { gpuCompute } from "../utils/gpu-compute.js";
 
 const SEARCH_SIZE1 = 10;
 const SEARCH_SIZE2 = 2;
 
-//const TEMPLATE_SIZE = 22 // DEFAULT
+// Template parameters - ajustados para más puntos
 const TEMPLATE_SIZE = 6;
-const TEMPLATE_SD_THRESH = 5.0;
+const TEMPLATE_SD_THRESH = 4.0;  // Reducido de 5.0 para aceptar más candidatos
 const MAX_SIM_THRESH = 0.95;
 
 const MAX_THRESH = 0.9;
-//const MIN_THRESH = 0.55;
 const MIN_THRESH = 0.2;
 const SD_THRESH = 8.0;
-const OCCUPANCY_SIZE = (24 * 2) / 3;
+const OCCUPANCY_SIZE = 10;  // Reducido de 16 para permitir puntos más cercanos
+
+// GPU mode flag - set to false to use original JS implementation
+let useGPU = true;
+
+/**
+ * Set GPU mode for extraction
+ * @param {boolean} enabled - Whether to use GPU acceleration
+ */
+export const setGPUMode = (enabled) => {
+  useGPU = enabled;
+};
 
 /*
  * Input image is in grey format. the imageData array size is width * height. value range from 0-255
@@ -23,292 +34,241 @@ const OCCUPANCY_SIZE = (24 * 2) / 3;
  * @param {int} options.height image height
  */
 const extract = (image) => {
-  const { data: imageData, width, height, scale } = image;
-
-  // Step 1 - filter out interesting points. Interesting points have strong pixel value changed across neighbours
-  const isPixelSelected = [width * height];
-  for (let i = 0; i < isPixelSelected.length; i++) isPixelSelected[i] = false;
-
-  // Step 1.1 consider a pixel at position (x, y). compute:
-  //   dx = ((data[x+1, y-1] - data[x-1, y-1]) + (data[x+1, y] - data[x-1, y]) + (data[x+1, y+1] - data[x-1, y-1])) / 256 / 3
-  //   dy = ((data[x+1, y+1] - data[x+1, y-1]) + (data[x, y+1] - data[x, y-1]) + (data[x-1, y+1] - data[x-1, y-1])) / 256 / 3
-  //   dValue =  sqrt(dx^2 + dy^2) / 2;
-  const dValue = new Float32Array(imageData.length);
-  for (let i = 0; i < width; i++) {
-    dValue[i] = -1;
-    dValue[width * (height - 1) + i] = -1;
-  }
-  for (let j = 0; j < height; j++) {
-    dValue[j * width] = -1;
-    dValue[j * width + width - 1] = -1;
-  }
+  const { data: imageData, width, height } = image;
+
+  let dValue, isCandidate;
+
+  if (useGPU) {
+    // GPU-accelerated edge detection
+    const result = gpuCompute.edgeDetection(imageData, width, height);
+    dValue = result.dValue;
+    isCandidate = result.isCandidate;
+  } else {
+    // Original JS implementation
+    dValue = new Float32Array(imageData.length);
+    isCandidate = new Uint8Array(imageData.length);
 
-  for (let i = 1; i < width - 1; i++) {
     for (let j = 1; j < height - 1; j++) {
-      let pos = i + width * j;
+      const rowOffset = j * width;
+      const prevRowOffset = (j - 1) * width;
+      const nextRowOffset = (j + 1) * width;
+
+      for (let i = 1; i < width - 1; i++) {
+        const pos = rowOffset + i;
 
-      let dx = 0.0;
-      let dy = 0.0;
-      for (let k = -1; k <= 1; k++) {
-        dx += imageData[pos + width * k + 1] - imageData[pos + width * k - 1];
-        dy += imageData[pos + width + k] - imageData[pos - width + k];
+        // dx/dy with tight loops
+        let dx = (imageData[prevRowOffset + i + 1] - imageData[prevRowOffset + i - 1] +
+          imageData[rowOffset + i + 1] - imageData[rowOffset + i - 1] +
+          imageData[nextRowOffset + i + 1] - imageData[nextRowOffset + i - 1]) / 768;
+
+        let dy = (imageData[nextRowOffset + i - 1] - imageData[prevRowOffset + i - 1] +
+          imageData[nextRowOffset + i] - imageData[prevRowOffset + i] +
+          imageData[nextRowOffset + i + 1] - imageData[prevRowOffset + i + 1]) / 768;
+
+        dValue[pos] = Math.sqrt((dx * dx + dy * dy) / 2);
       }
-      dx /= 3 * 256;
-      dy /= 3 * 256;
-      dValue[pos] = Math.sqrt((dx * dx + dy * dy) / 2);
     }
-  }
 
-  // Step 1.2 - select all pixel which is dValue largest than all its neighbour as "potential" candidate
-  //  the number of selected points is still too many, so we use the value to further filter (e.g. largest the dValue, the better)
-  const dValueHist = new Uint32Array(1000); // histogram of dvalue scaled to [0, 1000)
-  for (let i = 0; i < 1000; i++) dValueHist[i] = 0;
-  const neighbourOffsets = [-1, 1, -width, width];
-  let allCount = 0;
-  for (let i = 1; i < width - 1; i++) {
+    // Step 1.2 - Local Maxima (for JS path)
     for (let j = 1; j < height - 1; j++) {
-      let pos = i + width * j;
-      let isMax = true;
-      for (let d = 0; d < neighbourOffsets.length; d++) {
-        if (dValue[pos] <= dValue[pos + neighbourOffsets[d]]) {
-          isMax = false;
-          break;
+      const rowOffset = j * width;
+      for (let i = 1; i < width - 1; i++) {
+        const pos = rowOffset + i;
+        const val = dValue[pos];
+        if (val > 0 &&
+          val >= dValue[pos - 1] && val >= dValue[pos + 1] &&
+          val >= dValue[pos - width] && val >= dValue[pos + width]) {
+          isCandidate[pos] = 1;
         }
       }
-      if (isMax) {
-        let k = Math.floor(dValue[pos] * 1000);
-        if (k > 999) k = 999; // k>999 should not happen if computaiton is correction
-        if (k < 0) k = 0; // k<0 should not happen if computaiton is correction
-        dValueHist[k] += 1;
-        allCount += 1;
-        isPixelSelected[pos] = true;
+    }
+  }
+
+  // Step 1.2 - Build Histogram from detected candidates
+  const dValueHist = new Uint32Array(1000);
+  let allCount = 0;
+  for (let j = 1; j < height - 1; j++) {
+    const rowOffset = j * width;
+    for (let i = 1; i < width - 1; i++) {
+      const pos = rowOffset + i;
+      if (isCandidate[pos]) {
+        const val = dValue[pos];
+        let k = Math.floor(val * 1000);
+        if (k > 999) k = 999;
+        dValueHist[k]++;
+        allCount++;
       }
     }
   }
 
-  // reduce number of points according to dValue.
-  // actually, the whole Step 1. might be better to just sort the dvalues and pick the top (0.02 * width * height) points
-  const maxPoints = 0.02 * width * height;
-  let k = 999;
+  // Determine dValue threshold for top 5% (aumentado de 2% para más candidatos)
+  const maxPoints = 0.05 * width * height;
+  let kThresh = 999;
   let filteredCount = 0;
-  while (k >= 0) {
-    filteredCount += dValueHist[k];
+  while (kThresh >= 0) {
+    filteredCount += dValueHist[kThresh];
     if (filteredCount > maxPoints) break;
-    k--;
-  }
-
-  //console.log("image size: ", width * height);
-  //console.log("extracted featues: ", allCount);
-  //console.log("filtered featues: ", filteredCount);
-
-  for (let i = 0; i < isPixelSelected.length; i++) {
-    if (isPixelSelected[i]) {
-      if (dValue[i] * 1000 < k) isPixelSelected[i] = false;
-    }
+    kThresh--;
   }
-
-  //console.log("selected count: ", isPixelSelected.reduce((a, b) => {return a + (b?1:0);}, 0));
+  const minDValue = kThresh / 1000;
 
   // Step 2
-  // prebuild cumulative sum matrix for fast computation
-  const imageDataSqr = [];
+  const imageDataSqr = new Float32Array(imageData.length);
   for (let i = 0; i < imageData.length; i++) {
     imageDataSqr[i] = imageData[i] * imageData[i];
   }
   const imageDataCumsum = new Cumsum(imageData, width, height);
   const imageDataSqrCumsum = new Cumsum(imageDataSqr, width, height);
 
-  // holds the max similariliy value computed within SEARCH area of each pixel
-  //   idea: if there is high simliarity with another pixel in nearby area, then it's not a good feature point
-  //         next step is to find pixel with low similarity
-  const featureMap = new Float32Array(imageData.length);
-
-  for (let i = 0; i < width; i++) {
-    for (let j = 0; j < height; j++) {
-      const pos = j * width + i;
-      if (!isPixelSelected[pos]) {
-        featureMap[pos] = 1.0;
-        continue;
-      }
-
-      const vlen = _templateVar({
-        image,
-        cx: i,
-        cy: j,
-        sdThresh: TEMPLATE_SD_THRESH,
-        imageDataCumsum,
-        imageDataSqrCumsum,
+  // Collect candidates above threshold
+  const candidates = [];
+  for (let i = 0; i < imageData.length; i++) {
+    if (isCandidate[i] && dValue[i] >= minDValue) {
+      candidates.push({
+        pos: i,
+        dval: dValue[i],
+        x: i % width,
+        y: Math.floor(i / width)
       });
-      if (vlen === null) {
-        featureMap[pos] = 1.0;
-        continue;
-      }
-
-      let max = -1.0;
-      for (let jj = -SEARCH_SIZE1; jj <= SEARCH_SIZE1; jj++) {
-        for (let ii = -SEARCH_SIZE1; ii <= SEARCH_SIZE1; ii++) {
-          if (ii * ii + jj * jj <= SEARCH_SIZE2 * SEARCH_SIZE2) continue;
-          const sim = _getSimilarity({
-            image,
-            cx: i + ii,
-            cy: j + jj,
-            vlen: vlen,
-            tx: i,
-            ty: j,
-            imageDataCumsum,
-            imageDataSqrCumsum,
-          });
-
-          if (sim === null) continue;
-
-          if (sim > max) {
-            max = sim;
-            if (max > MAX_SIM_THRESH) break;
-          }
-        }
-        if (max > MAX_SIM_THRESH) break;
-      }
-      featureMap[pos] = max;
     }
   }
+  // Sort by dValue DESCENDING
+  candidates.sort((a, b) => b.dval - a.dval);
 
-  // Step 2.2 select feature
-  const coords = _selectFeature({
-    image,
-    featureMap,
-    templateSize: TEMPLATE_SIZE,
-    searchSize: SEARCH_SIZE2,
-    occSize: OCCUPANCY_SIZE,
-    maxSimThresh: MAX_THRESH,
-    minSimThresh: MIN_THRESH,
-    sdThresh: SD_THRESH,
-    imageDataCumsum,
-    imageDataSqrCumsum,
-  });
+  // Step 3 - On-Demand Feature Selection (The 10x Win)
+  const divSize = (TEMPLATE_SIZE * 2 + 1) * 3;
+  const maxFeatureNum = Math.floor(width / OCCUPANCY_SIZE) * Math.floor(height / OCCUPANCY_SIZE) +
+    Math.floor(width / divSize) * Math.floor(height / divSize);
 
-  return coords;
-};
+  const coords = [];
+  const invalidated = new Uint8Array(width * height);
+  const templateWidth = 2 * TEMPLATE_SIZE + 1;
+  const nPixels = templateWidth * templateWidth;
 
-const _selectFeature = (options) => {
-  let {
-    image,
-    featureMap,
-    templateSize,
-    searchSize,
-    occSize,
-    maxSimThresh,
-    minSimThresh,
-    sdThresh,
-    imageDataCumsum,
-    imageDataSqrCumsum,
-  } = options;
-  const { data: imageData, width, height, scale } = image;
-
-  //console.log("params: ", templateSize, templateSize, occSize, maxSimThresh, minSimThresh, sdThresh);
-
-  //occSize *= 2;
-  occSize = Math.floor(Math.min(image.width, image.height) / 10);
-
-  const divSize = (templateSize * 2 + 1) * 3;
-  const xDiv = Math.floor(width / divSize);
-  const yDiv = Math.floor(height / divSize);
-
-  let maxFeatureNum = Math.floor(width / occSize) * Math.floor(height / occSize) + xDiv * yDiv;
-  //console.log("max feature num: ", maxFeatureNum);
+  const actualOccSize = Math.floor(Math.min(width, height) / 12);  // Reducido de 10 para más densidad
 
-  const coords = [];
-  const image2 = new Float32Array(imageData.length);
-  for (let i = 0; i < image2.length; i++) {
-    image2[i] = featureMap[i];
-  }
+  for (let i = 0; i < candidates.length; i++) {
+    const { x, y, pos } = candidates[i];
+    if (invalidated[pos]) continue;
 
-  let num = 0;
-  while (num < maxFeatureNum) {
-    let minSim = maxSimThresh;
-    let cx = -1;
-    let cy = -1;
-    for (let j = 0; j < height; j++) {
-      for (let i = 0; i < width; i++) {
-        if (image2[j * width + i] < minSim) {
-          minSim = image2[j * width + i];
-          cx = i;
-          cy = j;
-        }
-      }
+    // Boundary safety for template
+    if (x < TEMPLATE_SIZE + SEARCH_SIZE1 || x >= width - TEMPLATE_SIZE - SEARCH_SIZE1 ||
+      y < TEMPLATE_SIZE + SEARCH_SIZE1 || y >= height - TEMPLATE_SIZE - SEARCH_SIZE1) {
+      continue;
     }
-    if (cx === -1) break;
 
     const vlen = _templateVar({
       image,
-      cx: cx,
-      cy: cy,
-      sdThresh: 0,
+      cx: x,
+      cy: y,
+      sdThresh: TEMPLATE_SD_THRESH,
       imageDataCumsum,
       imageDataSqrCumsum,
     });
-    if (vlen === null) {
-      image2[cy * width + cx] = 1.0;
-      continue;
-    }
-    if (vlen / (templateSize * 2 + 1) < sdThresh) {
-      image2[cy * width + cx] = 1.0;
-      continue;
+    if (vlen === null) continue;
+
+    const templateAvg = imageDataCumsum.query(
+      x - TEMPLATE_SIZE,
+      y - TEMPLATE_SIZE,
+      x + TEMPLATE_SIZE,
+      y + TEMPLATE_SIZE,
+    ) / nPixels;
+
+    // Optimization: Cache template once per candidate
+    const templateData = new Uint8Array(templateWidth * templateWidth);
+    let tidx = 0;
+    const tStart = (y - TEMPLATE_SIZE) * width + (x - TEMPLATE_SIZE);
+    for (let tj = 0; tj < templateWidth; tj++) {
+      const rowOffset = tStart + tj * width;
+      for (let ti = 0; ti < templateWidth; ti++) {
+        templateData[tidx++] = imageData[rowOffset + ti];
+      }
     }
 
-    let min = 1.0;
+    // Step 2.1: Find max similarity in search area (On demand!)
     let max = -1.0;
+    for (let jj = -SEARCH_SIZE1; jj <= SEARCH_SIZE1; jj++) {
+      for (let ii = -SEARCH_SIZE1; ii <= SEARCH_SIZE1; ii++) {
+        if (ii * ii + jj * jj <= SEARCH_SIZE2 * SEARCH_SIZE2) continue;
 
-    for (let j = -searchSize; j <= searchSize; j++) {
-      for (let i = -searchSize; i <= searchSize; i++) {
-        if (i * i + j * j > searchSize * searchSize) continue;
-        if (i === 0 && j === 0) continue;
-
-        const sim = _getSimilarity({
+        const sim = _getSimilarityOptimized({
           image,
-          vlen,
-          cx: cx + i,
-          cy: cy + j,
-          tx: cx,
-          ty: cy,
+          cx: x + ii,
+          cy: y + jj,
+          vlen: vlen,
+          templateData,
+          templateAvg,
+          templateWidth,
           imageDataCumsum,
           imageDataSqrCumsum,
+          width,
+          height
         });
-        if (sim === null) continue;
 
-        if (sim < min) {
-          min = sim;
-          if (min < minSimThresh && min < minSim) break;
-        }
-        if (sim > max) {
+        if (sim !== null && sim > max) {
           max = sim;
-          if (max > 0.99) break;
+          if (max > MAX_THRESH) break;
         }
       }
-      if ((min < minSimThresh && min < minSim) || max > 0.99) break;
+      if (max > MAX_THRESH) break;
     }
 
-    if ((min < minSimThresh && min < minSim) || max > 0.99) {
-      image2[cy * width + cx] = 1.0;
-      continue;
-    }
+    // Now decide if we select it
+    if (max < MAX_THRESH) {
+      // Uniqueness check (Step 2.2 sub-loop)
+      let minUnique = 1.0;
+      let maxUnique = -1.0;
+      let failedUnique = false;
 
-    coords.push({ x: cx, y: cy });
-    //coords.push({
-    //mx: 1.0 * cx / scale,
-    //my: 1.0 * (height - cy) / scale,
-    //})
+      for (let jj = -SEARCH_SIZE2; jj <= SEARCH_SIZE2; jj++) {
+        for (let ii = -SEARCH_SIZE2; ii <= SEARCH_SIZE2; ii++) {
+          if (ii * ii + jj * jj > SEARCH_SIZE2 * SEARCH_SIZE2) continue;
+          if (ii === 0 && jj === 0) continue;
 
-    num += 1;
-    //console.log(num, '(', cx, ',', cy, ')', minSim, 'min = ', min, 'max = ', max, 'sd = ', vlen/(templateSize*2+1));
+          const sim = _getSimilarityOptimized({
+            image,
+            vlen,
+            cx: x + ii,
+            cy: y + jj,
+            templateData,
+            templateAvg,
+            templateWidth,
+            imageDataCumsum,
+            imageDataSqrCumsum,
+            width,
+            height
+          });
 
-    // no other feature points within occSize square
-    for (let j = -occSize; j <= occSize; j++) {
-      for (let i = -occSize; i <= occSize; i++) {
-        if (cy + j < 0 || cy + j >= height || cx + i < 0 || cx + i >= width) continue;
-        image2[(cy + j) * width + (cx + i)] = 1.0;
+          if (sim === null) continue;
+          if (sim < minUnique) minUnique = sim;
+          if (sim > maxUnique) maxUnique = sim;
+          if (minUnique < MIN_THRESH || maxUnique > 0.99) {
+            failedUnique = true;
+            break;
+          }
+        }
+        if (failedUnique) break;
+      }
+
+      if (!failedUnique) {
+        coords.push({ x, y });
+        // Invalidate neighbors
+        for (let jj = -actualOccSize; jj <= actualOccSize; jj++) {
+          const yy = y + jj;
+          if (yy < 0 || yy >= height) continue;
+          const rowStart = yy * width;
+          for (let ii = -actualOccSize; ii <= actualOccSize; ii++) {
+            const xx = x + ii;
+            if (xx < 0 || xx >= width) continue;
+            invalidated[rowStart + xx] = 1;
+          }
+        }
       }
     }
+
+    if (coords.length >= maxFeatureNum) break;
   }
+
   return coords;
 };
 
@@ -353,67 +313,51 @@ const _templateVar = ({ image, cx, cy, sdThresh, imageDataCumsum, imageDataSqrCu
   return vlen;
 };
 
-const _getSimilarity = (options) => {
-  const { image, cx, cy, vlen, tx, ty, imageDataCumsum, imageDataSqrCumsum } = options;
-  const { data: imageData, width, height } = image;
-  const templateSize = TEMPLATE_SIZE;
+const _getSimilarityOptimized = (options) => {
+  const { cx, cy, vlen, templateData, templateAvg, templateWidth, imageDataCumsum, imageDataSqrCumsum, width, height } = options;
+  const imageData = options.image.data;
+  const templateSize = (templateWidth - 1) / 2;
 
   if (cx - templateSize < 0 || cx + templateSize >= width) return null;
   if (cy - templateSize < 0 || cy + templateSize >= height) return null;
 
-  const templateWidth = 2 * templateSize + 1;
-
-  let sx = imageDataCumsum.query(
+  const nP = templateWidth * templateWidth;
+  const sx = imageDataCumsum.query(
     cx - templateSize,
     cy - templateSize,
     cx + templateSize,
     cy + templateSize,
   );
-  let sxx = imageDataSqrCumsum.query(
+  const sxx = imageDataSqrCumsum.query(
     cx - templateSize,
     cy - templateSize,
     cx + templateSize,
     cy + templateSize,
   );
-  let sxy = 0;
 
-  // !! This loop is the performance bottleneck. Use moving pointers to optimize
-  //
-  //   for (let i = cx - templateSize, i2 = tx - templateSize; i <= cx + templateSize; i++, i2++) {
-  //     for (let j = cy - templateSize, j2 = ty - templateSize; j <= cy + templateSize; j++, j2++) {
-  //       sxy += imageData[j*width + i] * imageData[j2*width + i2];
-  //     }
-  //   }
-  //
+  // Full calculation
+  let sxy = 0;
   let p1 = (cy - templateSize) * width + (cx - templateSize);
-  let p2 = (ty - templateSize) * width + (tx - templateSize);
-  let nextRowOffset = width - templateWidth;
+  let p2 = 0;
+  const nextRowOffset = width - templateWidth;
+
   for (let j = 0; j < templateWidth; j++) {
     for (let i = 0; i < templateWidth; i++) {
-      sxy += imageData[p1] * imageData[p2];
-      p1 += 1;
-      p2 += 1;
+      sxy += imageData[p1++] * templateData[p2++];
     }
     p1 += nextRowOffset;
-    p2 += nextRowOffset;
   }
 
-  let templateAverage = imageDataCumsum.query(
-    tx - templateSize,
-    ty - templateSize,
-    tx + templateSize,
-    ty + templateSize,
-  );
-  templateAverage /= templateWidth * templateWidth;
-  sxy -= templateAverage * sx;
+  // Covariance check
+  // E[(X-EX)(Y-EY)] = E[XY] - EX*EY
+  // sum((Xi - avgX)(Yi - avgY)) = sum(XiYi) - avgY * sum(Xi)
+  const sxy_final = sxy - templateAvg * sx;
 
-  let vlen2 = sxx - (sx * sx) / (templateWidth * templateWidth);
-  if (vlen2 == 0) return null;
+  let vlen2 = sxx - (sx * sx) / (nP);
+  if (vlen2 <= 0) return null;
   vlen2 = Math.sqrt(vlen2);
 
-  // covariance between template and current pixel
-  const sim = (1.0 * sxy) / (vlen * vlen2);
-  return sim;
+  return (1.0 * sxy_final) / (vlen * vlen2);
 };
 
 export { extract };