@srsergio/taptapp-ar 1.0.0 → 1.0.3

package/dist/compiler/tensorflow-setup.js

@@ -5,6 +5,24 @@ import "@tensorflow/tfjs-backend-webgl";
 // Registrar kernels personalizados
 import "./detector/kernels/cpu/index.js";
 import "./detector/kernels/webgl/index.js";
+/**
+ * Intenta cargar el backend de Node.js si está disponible
+ */
+const loadNodeBackend = async () => {
+    if (typeof process !== "undefined" && process.versions && process.versions.node) {
+        try {
+            // Usar import dinámico para evitar errores en el navegador
+            await import("@tensorflow/tfjs-node");
+            console.log("🚀 TensorFlow Node.js backend cargado correctamente");
+            return true;
+        }
+        catch (e) {
+            console.warn("⚠️ No se pudo cargar @tensorflow/tfjs-node, usando fallback");
+            return false;
+        }
+    }
+    return false;
+};
 /**
  * Configuración optimizada de TensorFlow para diferentes entornos
  * @returns {Promise<string>} El backend activo ('webgl', 'cpu')
@@ -12,14 +30,22 @@ import "./detector/kernels/webgl/index.js";
 export async function setupTensorFlow() {
     console.log("🔧 Iniciando configuración optimizada de TensorFlow.js...");
     try {
+        // Intentar cargar backend de Node.js primero
+        const nodeBackendLoaded = await loadNodeBackend();
         // Optimizaciones base para todos los backends
         tf.ENV.set("DEBUG", false);
         tf.ENV.set("WEBGL_CPU_FORWARD", false);
         tf.ENV.set("WEBGL_FORCE_F16_TEXTURES", true);
         // Configuración adaptativa de memoria según el entorno
         const isServerless = typeof window === "undefined";
-        const memoryThreshold = isServerless ? 1024 * 1024 * 4 : 1024 * 1024 * 8; // 4MB en serverless, 8MB en cliente
+        const memoryThreshold = isServerless ? 1024 * 1024 * 4 : 1024 * 1024 * 8;
         tf.ENV.set("CPU_HANDOFF_SIZE_THRESHOLD", memoryThreshold);
+        if (nodeBackendLoaded) {
+            await tf.setBackend("tensorflow");
+            console.log("🚀 Backend TensorFlow (Node.js) activado");
+            await tf.ready();
+            return "tensorflow";
+        }
         // Configuración específica para entorno serverless
         if (isServerless) {
             try {

package/dist/compiler/three.js

@@ -87,7 +87,7 @@ export class MindARThree {
         return anchor;
     }
     _startVideo() {
-        return new Promise((resolve, reject) => {
+        return new Promise((resolve) => {
             this.video = document.createElement("video");
             this.video.setAttribute("autoplay", "");
             this.video.setAttribute("muted", "");
@@ -139,9 +139,8 @@ export class MindARThree {
         });
     }
     _startAR() {
-        return new Promise(async (resolve, reject) => {
+        return new Promise(async (resolve) => {
             const video = this.video;
-            const container = this.container;
             this.controller = new Controller({
                 inputWidth: video.videoWidth,
                 inputHeight: video.videoHeight,
@@ -221,7 +220,7 @@ export class MindARThree {
                 postMatrix.compose(position, quaternion, scale);
                 this.postMatrixs.push(postMatrix);
             }
-            await this.controller.dummyRun(this.video);
+            this.controller.dummyRun(this.video);
             this.ui.hideLoading();
             this.ui.showScanning();
             this.controller.processVideo(this.video);
@@ -273,7 +272,6 @@ export class MindARThree {
         const fov = (2 * Math.atan((1 / proj[5]) * fovAdjust) * 180) / Math.PI; // vertical fov
         const near = proj[14] / (proj[10] - 1.0);
         const far = proj[14] / (proj[10] + 1.0);
-        const ratio = proj[5] / proj[0]; // (r-l) / (t-b)
         camera.fov = fov;
         camera.near = near;
         camera.far = far;

package/dist/compiler/tracker/extract.d.ts

@@ -1,3 +1,4 @@
+export function setGPUMode(enabled: boolean): void;
 export function extract(image: any): {
     x: number;
     y: number;

package/dist/compiler/tracker/extract.js

@@ -1,15 +1,24 @@
 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
  * pixel value at row r and c = imageData[r * width + c]
@@ -19,264 +28,222 @@ 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;
     }
-    for (let i = 1; i < width - 1; i++) {
+    else {
+        // Original JS implementation
+        dValue = new Float32Array(imageData.length);
+        isCandidate = new Uint8Array(imageData.length);
         for (let j = 1; j < height - 1; j++) {
-            let pos = i + width * j;
-            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];
+            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;
+                // 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);
+        }
+    }
+    // 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; // 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;
+                    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;
         }
     }
-    // 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,
-    });
-    return coords;
-};
-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);
+    // Sort by dValue DESCENDING
+    candidates.sort((a, b) => b.dval - a.dval);
+    // 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);
     const coords = [];
-    const image2 = new Float32Array(imageData.length);
-    for (let i = 0; i < image2.length; i++) {
-        image2[i] = featureMap[i];
-    }
-    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;
-                }
-            }
+    const invalidated = new Uint8Array(width * height);
+    const templateWidth = 2 * TEMPLATE_SIZE + 1;
+    const nPixels = templateWidth * templateWidth;
+    const actualOccSize = Math.floor(Math.min(width, height) / 12); // Reducido de 10 para más densidad
+    for (let i = 0; i < candidates.length; i++) {
+        const { x, y, pos } = candidates[i];
+        if (invalidated[pos])
+            continue;
+        // 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;
+        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 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)
+        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({
+                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)
+                    if (max > MAX_THRESH)
                         break;
                 }
             }
-            if ((min < minSimThresh && min < minSim) || max > 0.99)
+            if (max > MAX_THRESH)
                 break;
         }
-        if ((min < minSimThresh && min < minSim) || max > 0.99) {
-            image2[cy * width + cx] = 1.0;
-            continue;
-        }
-        coords.push({ x: cx, y: cy });
-        //coords.push({
-        //mx: 1.0 * cx / scale,
-        //my: 1.0 * (height - cy) / scale,
-        //})
-        num += 1;
-        //console.log(num, '(', cx, ',', cy, ')', minSim, 'min = ', min, 'max = ', max, 'sd = ', vlen/(templateSize*2+1));
-        // 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;
+        // 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;
+            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;
+                    const sim = _getSimilarityOptimized({
+                        image,
+                        vlen,
+                        cx: x + ii,
+                        cy: y + jj,
+                        templateData,
+                        templateAvg,
+                        templateWidth,
+                        imageDataCumsum,
+                        imageDataSqrCumsum,
+                        width,
+                        height
+                    });
+                    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;
 };
@@ -303,47 +270,36 @@ const _templateVar = ({ image, cx, cy, sdThresh, imageDataCumsum, imageDataSqrCu
     vlen = Math.sqrt(vlen);
     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(cx - templateSize, cy - templateSize, cx + templateSize, cy + templateSize);
-    let sxx = imageDataSqrCumsum.query(cx - templateSize, cy - templateSize, cx + templateSize, cy + templateSize);
+    const nP = templateWidth * templateWidth;
+    const sx = imageDataCumsum.query(cx - templateSize, cy - templateSize, cx + templateSize, cy + templateSize);
+    const sxx = imageDataSqrCumsum.query(cx - templateSize, cy - templateSize, cx + templateSize, cy + templateSize);
+    // Full calculation
     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];
-    //     }
-    //   }
-    //
     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;
-    let vlen2 = sxx - (sx * sx) / (templateWidth * templateWidth);
-    if (vlen2 == 0)
+    // 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) / (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 };

package/dist/compiler/tracker/tracker.d.ts

@@ -1,5 +1,5 @@
 export class Tracker {
-    constructor(markerDimensions: any, trackingDataList: any, projectionTransform: any, inputWidth: any, inputHeight: any, debugMode?: boolean);
+    constructor(markerDimensions: any, trackingDataList: any, projectionTransform: any, debugMode?: boolean);
     markerDimensions: any;
     trackingDataList: any;
     projectionTransform: any;