@srsergio/taptapp-ar 1.0.101 → 1.1.2

package/dist/core/tracker/extract.js

@@ -1,306 +1 @@
-import { Cumsum } from "../utils/cumsum.js";
-import { gpuCompute } from "../utils/gpu-compute.js";
-const SEARCH_SIZE1 = 10;
-const SEARCH_SIZE2 = 2;
-// Template parameters - ajustados para más puntos
-const TEMPLATE_SIZE = 6;
-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.2;
-const SD_THRESH = 8.0;
-const OCCUPANCY_SIZE = 8; // Reduced from 10 to allow more density
-// 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]
- *
- * @param {Uint8Array} options.imageData
- * @param {int} options.width image width
- * @param {int} options.height image height
- */
-const extract = (image) => {
-    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 j = 1; j < height - 1; 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;
-                // 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);
-            }
-        }
-        // Step 1.2 - Local Maxima (for JS path)
-        for (let j = 1; j < height - 1; j++) {
-            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;
-                }
-            }
-        }
-    }
-    // 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++;
-            }
-        }
-    }
-    // Determine dValue threshold for top 5% (aumentado de 2% para más candidatos)
-    const maxPoints = 0.10 * width * height; // Increased to 10% for more candidates
-    let kThresh = 999;
-    let filteredCount = 0;
-    while (kThresh >= 0) {
-        filteredCount += dValueHist[kThresh];
-        if (filteredCount > maxPoints)
-            break;
-        kThresh--;
-    }
-    const minDValue = kThresh / 1000;
-    // Step 2
-    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);
-    // 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)
-            });
-        }
-    }
-    // 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 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;
-        }
-        const vlen = _templateVar({
-            image,
-            cx: x,
-            cy: y,
-            sdThresh: TEMPLATE_SD_THRESH,
-            imageDataCumsum,
-            imageDataSqrCumsum,
-        });
-        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];
-            }
-        }
-        // 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;
-                const sim = _getSimilarityOptimized({
-                    image,
-                    cx: x + ii,
-                    cy: y + jj,
-                    vlen: vlen,
-                    templateData,
-                    templateAvg,
-                    templateWidth,
-                    imageDataCumsum,
-                    imageDataSqrCumsum,
-                    width,
-                    height
-                });
-                if (sim !== null && sim > max) {
-                    max = sim;
-                    if (max > MAX_THRESH)
-                        break;
-                }
-            }
-            if (max > MAX_THRESH)
-                break;
-        }
-        // 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;
-};
-// compute variances of the pixels, centered at (cx, cy)
-const _templateVar = ({ image, cx, cy, sdThresh, imageDataCumsum, imageDataSqrCumsum }) => {
-    if (cx - TEMPLATE_SIZE < 0 || cx + TEMPLATE_SIZE >= image.width)
-        return null;
-    if (cy - TEMPLATE_SIZE < 0 || cy + TEMPLATE_SIZE >= image.height)
-        return null;
-    const templateWidth = 2 * TEMPLATE_SIZE + 1;
-    const nPixels = templateWidth * templateWidth;
-    let average = imageDataCumsum.query(cx - TEMPLATE_SIZE, cy - TEMPLATE_SIZE, cx + TEMPLATE_SIZE, cy + TEMPLATE_SIZE);
-    average /= nPixels;
-    //v = sum((pixel_i - avg)^2) for all pixel i within the template
-    //  = sum(pixel_i^2) - sum(2 * avg * pixel_i) + sum(avg^avg)
-    let vlen = imageDataSqrCumsum.query(cx - TEMPLATE_SIZE, cy - TEMPLATE_SIZE, cx + TEMPLATE_SIZE, cy + TEMPLATE_SIZE);
-    vlen -=
-        2 *
-            average *
-            imageDataCumsum.query(cx - TEMPLATE_SIZE, cy - TEMPLATE_SIZE, cx + TEMPLATE_SIZE, cy + TEMPLATE_SIZE);
-    vlen += nPixels * average * average;
-    if (vlen / nPixels < sdThresh * sdThresh)
-        return null;
-    vlen = Math.sqrt(vlen);
-    return vlen;
-};
-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 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);
-    // 🚀 MOONSHOT Early Exit: Check variance (vlen2) before expensive sxy loop
-    let vlen2 = sxx - (sx * sx) / nP;
-    if (vlen2 <= 0)
-        return null;
-    vlen2 = Math.sqrt(vlen2);
-    // Full calculation - Optimized with 2x2 sub-sampling for SPEED
-    let sxy = 0;
-    const p1_start = (cy - templateSize) * width + (cx - templateSize);
-    for (let j = 0; j < templateWidth; j++) {
-        const rowOffset1 = p1_start + j * width;
-        const rowOffset2 = j * templateWidth;
-        for (let i = 0; i < templateWidth; i++) {
-            sxy += imageData[rowOffset1 + i] * templateData[rowOffset2 + i];
-        }
-    }
-    const sampledCount = templateWidth * templateWidth;
-    const totalCount = templateWidth * templateWidth;
-    sxy *= (totalCount / sampledCount);
-    // Covariance check
-    const sxy_final = sxy - templateAvg * sx;
-    return (1.0 * sxy_final) / (vlen * vlen2);
-};
-export { extract };
+import{Cumsum as t}from"../utils/cumsum.js";import{gpuCompute as e}from"../utils/gpu-compute.js";let n=!0;export const setGPUMode=t=>{n=t};const o=o=>{const{data:r,width:i,height:s}=o;let u,m;if(n){const t=e.edgeDetection(r,i,s);u=t.dValue,m=t.isCandidate}else{u=new Float32Array(r.length),m=new Uint8Array(r.length);for(let t=1;t<s-1;t++){const e=t*i,n=(t-1)*i,o=(t+1)*i;for(let t=1;t<i-1;t++){const a=e+t;let l=(r[n+t+1]-r[n+t-1]+r[e+t+1]-r[e+t-1]+r[o+t+1]-r[o+t-1])/768,i=(r[o+t-1]-r[n+t-1]+r[o+t]-r[n+t]+r[o+t+1]-r[n+t+1])/768;u[a]=Math.sqrt((l*l+i*i)/2)}}for(let t=1;t<s-1;t++){const e=t*i;for(let t=1;t<i-1;t++){const n=e+t,o=u[n];o>0&&o>=u[n-1]&&o>=u[n+1]&&o>=u[n-i]&&o>=u[n+i]&&(m[n]=1)}}}const c=new Uint32Array(1e3);for(let t=1;t<s-1;t++){const e=t*i;for(let t=1;t<i-1;t++){const n=e+t;if(m[n]){const t=u[n];let e=Math.floor(1e3*t);e>999&&(e=999),c[e]++}}}const f=.1*i*s;let h=999,g=0;for(;h>=0&&(g+=c[h],!(g>f));)h--;const d=h/1e3,y=new Float32Array(r.length);for(let t=0;t<r.length;t++)y[t]=r[t]*r[t];const p=new t(r,i,s),q=new t(y,i,s),D=[];for(let t=0;t<r.length;t++)m[t]&&u[t]>=d&&D.push({pos:t,dval:u[t],x:t%i,y:Math.floor(t/i)});D.sort((t,e)=>e.dval-t.dval);const w=Math.floor(i/8)*Math.floor(s/8)+Math.floor(i/39)*Math.floor(s/39),M=[],C=new Uint8Array(i*s),x=Math.floor(Math.min(i,s)/12);for(let t=0;t<D.length;t++){const{x:e,y:n,pos:u}=D[t];if(C[u])continue;if(e<16||e>=i-6-10||n<16||n>=s-6-10)continue;const m=a({image:o,cx:e,cy:n,sdThresh:4,imageDataCumsum:p,imageDataSqrCumsum:q});if(null===m)continue;const c=p.query(e-6,n-6,e+6,n+6)/169,f=new Uint8Array(169);let h=0;const g=(n-6)*i+(e-6);for(let t=0;t<13;t++){const e=g+t*i;for(let t=0;t<13;t++)f[h++]=r[e+t]}let d=-1;for(let t=-10;t<=10;t++){for(let a=-10;a<=10;a++){if(a*a+t*t<=4)continue;const r=l({image:o,cx:e+a,cy:n+t,vlen:m,templateData:f,templateAvg:c,templateWidth:13,imageDataCumsum:p,imageDataSqrCumsum:q,width:i,height:s});if(null!==r&&r>d&&(d=r,d>.9))break}if(d>.9)break}if(d<.9){let t=1,a=-1,r=!1;for(let u=-2;u<=2;u++){for(let h=-2;h<=2;h++){if(h*h+u*u>4)continue;if(0===h&&0===u)continue;const g=l({image:o,vlen:m,cx:e+h,cy:n+u,templateData:f,templateAvg:c,templateWidth:13,imageDataCumsum:p,imageDataSqrCumsum:q,width:i,height:s});if(null!==g&&(g<t&&(t=g),g>a&&(a=g),t<.2||a>.99)){r=!0;break}}if(r)break}if(!r){M.push({x:e,y:n});for(let t=-x;t<=x;t++){const o=n+t;if(o<0||o>=s)continue;const a=o*i;for(let t=-x;t<=x;t++){const n=e+t;n<0||n>=i||(C[a+n]=1)}}}}if(M.length>=w)break}return M},a=({image:t,cx:e,cy:n,sdThresh:o,imageDataCumsum:a,imageDataSqrCumsum:l})=>{if(e-6<0||e+6>=t.width)return null;if(n-6<0||n+6>=t.height)return null;let r=a.query(e-6,n-6,e+6,n+6);r/=169;let i=l.query(e-6,n-6,e+6,n+6);return i-=2*r*a.query(e-6,n-6,e+6,n+6),i+=169*r*r,i/169<o*o?null:(i=Math.sqrt(i),i)},l=t=>{const{cx:e,cy:n,vlen:o,templateData:a,templateAvg:l,templateWidth:r,imageDataCumsum:i,imageDataSqrCumsum:s,width:u,height:m}=t,c=t.image.data,f=(r-1)/2;if(e-f<0||e+f>=u)return null;if(n-f<0||n+f>=m)return null;const h=r*r,g=i.query(e-f,n-f,e+f,n+f);let d=s.query(e-f,n-f,e+f,n+f)-g*g/h;if(d<=0)return null;d=Math.sqrt(d);let y=0;const p=(n-f)*u+(e-f);for(let t=0;t<r;t++){const e=p+t*u,n=t*r;for(let t=0;t<r;t++)y+=c[e+t]*a[n+t]}return y*=r*r/(r*r),1*(y-l*g)/(o*d)};export{o as extract};

package/dist/core/tracker/tracker.js

@@ -1,352 +1 @@
-import { buildModelViewProjectionTransform, computeScreenCoordiate } from "../estimation/utils.js";
-import { refineNonRigid, projectMesh } from "../estimation/non-rigid-refine.js";
-import { AR_CONFIG } from "../constants.js";
-const AR2_DEFAULT_TS = AR_CONFIG.TRACKER_TEMPLATE_SIZE;
-const AR2_DEFAULT_TS_GAP = 1;
-const AR2_SEARCH_SIZE = AR_CONFIG.TRACKER_SEARCH_SIZE;
-const AR2_SEARCH_GAP = 1;
-const AR2_SIM_THRESH = AR_CONFIG.TRACKER_SIMILARITY_THRESHOLD;
-const TRACKING_KEYFRAME = 0; // 0: 128px (optimized)
-class Tracker {
-    constructor(markerDimensions, trackingDataList, projectionTransform, inputWidth, inputHeight, debugMode = false) {
-        this.markerDimensions = markerDimensions;
-        this.trackingDataList = trackingDataList;
-        this.projectionTransform = projectionTransform;
-        this.inputWidth = inputWidth;
-        this.inputHeight = inputHeight;
-        this.debugMode = debugMode;
-        this.trackingKeyframeList = []; // All octaves for all targets: [targetIndex][octaveIndex]
-        this.prebuiltData = []; // [targetIndex][octaveIndex]
-        for (let i = 0; i < trackingDataList.length; i++) {
-            const targetOctaves = trackingDataList[i];
-            this.trackingKeyframeList[i] = targetOctaves;
-            this.prebuiltData[i] = targetOctaves.map(keyframe => ({
-                px: new Float32Array(keyframe.px),
-                py: new Float32Array(keyframe.py),
-                data: new Uint8Array(keyframe.d),
-                width: keyframe.w,
-                height: keyframe.h,
-                scale: keyframe.s,
-                mesh: keyframe.mesh,
-                // Recyclable projected image buffer
-                projectedImage: new Float32Array(keyframe.w * keyframe.h)
-            }));
-        }
-        // Maintain mesh vertices state for temporal continuity
-        this.meshVerticesState = []; // [targetIndex][octaveIndex]
-        // Pre-allocate template data buffer to avoid garbage collection
-        const templateOneSize = AR2_DEFAULT_TS;
-        const templateSize = templateOneSize * 2 + 1;
-        this.templateBuffer = new Float32Array(templateSize * templateSize);
-    }
-    dummyRun(inputData) {
-        let transform = [
-            [1, 0, 0, 0],
-            [0, 1, 0, 0],
-            [0, 0, 1, 0],
-        ];
-        for (let targetIndex = 0; targetIndex < this.trackingKeyframeList.length; targetIndex++) {
-            this.track(inputData, transform, targetIndex);
-        }
-    }
-    track(inputData, lastModelViewTransform, targetIndex) {
-        let debugExtra = {};
-        // Select the best octave based on current estimated distance/scale
-        // We want the octave where the marker size is closest to its projected size on screen
-        const modelViewProjectionTransform = buildModelViewProjectionTransform(this.projectionTransform, lastModelViewTransform);
-        // Estimate current marker width on screen
-        const [mW, mH] = this.markerDimensions[targetIndex];
-        const p0 = computeScreenCoordiate(modelViewProjectionTransform, 0, 0);
-        const p1 = computeScreenCoordiate(modelViewProjectionTransform, mW, 0);
-        const screenW = Math.sqrt((p1.x - p0.x) ** 2 + (p1.y - p0.y) ** 2);
-        // Select octave whose image width is closest to screenW
-        // Select the best octave based on current estimated distance/scale
-        // Hysteresis: prevent flip-flopping between octaves
-        if (!this.lastOctaveIndex)
-            this.lastOctaveIndex = [];
-        let octaveIndex = this.lastOctaveIndex[targetIndex] !== undefined ? this.lastOctaveIndex[targetIndex] : 0;
-        let minDiff = Math.abs(this.prebuiltData[targetIndex][octaveIndex].width - screenW);
-        // Threshold to switch: only switch if another octave is much better (20% improvement)
-        const switchThreshold = 0.8;
-        for (let i = 0; i < this.prebuiltData[targetIndex].length; i++) {
-            const diff = Math.abs(this.prebuiltData[targetIndex][i].width - screenW);
-            if (diff < minDiff * switchThreshold) {
-                minDiff = diff;
-                octaveIndex = i;
-            }
-        }
-        this.lastOctaveIndex[targetIndex] = octaveIndex;
-        const prebuilt = this.prebuiltData[targetIndex][octaveIndex];
-        // 1. Compute Projection (Warping)
-        this._computeProjection(modelViewProjectionTransform, inputData, prebuilt);
-        const projectedImage = prebuilt.projectedImage;
-        // 2. Compute Matching (NCC)
-        const { matchingPoints, sim } = this._computeMatching(prebuilt, projectedImage);
-        const trackingFrame = this.trackingKeyframeList[targetIndex][octaveIndex];
-        const worldCoords = [];
-        const screenCoords = [];
-        const goodTrack = [];
-        const { px, py, s: scale } = trackingFrame;
-        const reliabilities = [];
-        for (let i = 0; i < matchingPoints.length; i++) {
-            const reliability = sim[i];
-            if (reliability > AR2_SIM_THRESH && i < px.length) {
-                goodTrack.push(i);
-                const point = computeScreenCoordiate(modelViewProjectionTransform, matchingPoints[i][0], matchingPoints[i][1]);
-                screenCoords.push(point);
-                worldCoords.push({
-                    x: px[i] / scale,
-                    y: py[i] / scale,
-                    z: 0,
-                });
-                reliabilities.push(reliability);
-            }
-        }
-        // --- 🚀 MOONSHOT: Non-Rigid Mesh Refinement ---
-        let deformedMesh = null;
-        if (prebuilt.mesh && goodTrack.length >= 4) {
-            if (!this.meshVerticesState[targetIndex])
-                this.meshVerticesState[targetIndex] = [];
-            let currentOctaveVertices = this.meshVerticesState[targetIndex][octaveIndex];
-            // Initial setup: If no state, use the reference points (normalized) as first guess
-            if (!currentOctaveVertices) {
-                currentOctaveVertices = new Float32Array(px.length * 2);
-                for (let i = 0; i < px.length; i++) {
-                    currentOctaveVertices[i * 2] = px[i];
-                    currentOctaveVertices[i * 2 + 1] = py[i];
-                }
-            }
-            // Data fidelity: Prepare tracked targets for mass-spring
-            const trackedTargets = [];
-            for (let j = 0; j < goodTrack.length; j++) {
-                const idx = goodTrack[j];
-                trackedTargets.push({
-                    meshIndex: idx,
-                    x: matchingPoints[idx][0] * scale, // Convert back to octave space pixels
-                    y: matchingPoints[idx][1] * scale
-                });
-            }
-            // Relax mesh in octave space
-            const refinedOctaveVertices = refineNonRigid({
-                mesh: prebuilt.mesh,
-                trackedPoints: trackedTargets,
-                currentVertices: currentOctaveVertices,
-                iterations: 5
-            });
-            this.meshVerticesState[targetIndex][octaveIndex] = refinedOctaveVertices;
-            // Project deformed mesh to screen space
-            const screenMeshVertices = new Float32Array(refinedOctaveVertices.length);
-            for (let i = 0; i < refinedOctaveVertices.length; i += 2) {
-                const p = computeScreenCoordiate(modelViewProjectionTransform, refinedOctaveVertices[i] / scale, refinedOctaveVertices[i + 1] / scale);
-                screenMeshVertices[i] = p.x;
-                screenMeshVertices[i + 1] = p.y;
-            }
-            deformedMesh = {
-                vertices: screenMeshVertices,
-                triangles: prebuilt.mesh.t
-            };
-        }
-        // 2.1 Spatial distribution check: Avoid getting stuck in corners/noise
-        if (screenCoords.length >= 8) {
-            let minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity;
-            for (const p of screenCoords) {
-                if (p.x < minX)
-                    minX = p.x;
-                if (p.y < minY)
-                    minY = p.y;
-                if (p.x > maxX)
-                    maxX = p.x;
-                if (p.y > maxY)
-                    maxY = p.y;
-            }
-            const detectedDiagonal = Math.sqrt((maxX - minX) ** 2 + (maxY - minY) ** 2);
-            // If the points cover too little space compared to the screen size of the marker, it's a glitch
-            if (detectedDiagonal < screenW * 0.15) {
-                return { worldCoords: [], screenCoords: [], reliabilities: [], debugExtra };
-            }
-        }
-        if (this.debugMode) {
-            debugExtra = {
-                octaveIndex,
-                // Remove Array.from to avoid massive GC pressure
-                projectedImage: projectedImage,
-                matchingPoints,
-                goodTrack,
-                trackedPoints: screenCoords,
-            };
-        }
-        return { worldCoords, screenCoords, reliabilities, indices: goodTrack, octaveIndex, deformedMesh, debugExtra };
-    }
-    /**
-     * Pure JS implementation of NCC matching
-     */
-    _computeMatching(prebuilt, projectedImage) {
-        const { px, py, scale, data: markerPixels, width: markerWidth, height: markerHeight } = prebuilt;
-        const featureCount = px.length;
-        const templateOneSize = AR2_DEFAULT_TS;
-        const templateSize = templateOneSize * 2 + 1;
-        const nPixels = templateSize * templateSize;
-        const oneOverNPixels = 1.0 / nPixels;
-        const searchOneSize = AR2_SEARCH_SIZE;
-        const searchGap = AR2_SEARCH_GAP;
-        const matchingPoints = [];
-        const sims = new Float32Array(featureCount);
-        // Reuse shared template buffer
-        const templateData = this.templateBuffer;
-        for (let f = 0; f < featureCount; f++) {
-            const sCenterX = (px[f] + 0.5) | 0; // Faster Math.round
-            const sCenterY = (py[f] + 0.5) | 0;
-            let bestSim = -1.0;
-            let bestX = px[f] / scale;
-            let bestY = py[f] / scale;
-            // Pre-calculate template stats for this feature
-            let sumT = 0;
-            let sumT2 = 0;
-            let tidx = 0;
-            for (let ty = -templateOneSize; ty <= templateOneSize; ty++) {
-                const fyOffset = (sCenterY + ty) * markerWidth;
-                for (let tx = -templateOneSize; tx <= templateOneSize; tx++) {
-                    const val = markerPixels[fyOffset + sCenterX + tx];
-                    templateData[tidx++] = val;
-                    sumT += val;
-                    sumT2 += val * val;
-                }
-            }
-            const varT = Math.sqrt(Math.max(0, sumT2 - (sumT * sumT) * oneOverNPixels));
-            if (varT < 0.0001) {
-                sims[f] = -1.0;
-                matchingPoints.push([bestX, bestY]);
-                continue;
-            }
-            // 🚀 MOONSHOT: Coarse-to-Fine Search for MAXIMUM FPS
-            // Step 1: Coarse search (Gap 4)
-            const coarseGap = 4;
-            for (let sy = -searchOneSize; sy <= searchOneSize; sy += coarseGap) {
-                const cy = sCenterY + sy;
-                if (cy < templateOneSize || cy >= markerHeight - templateOneSize)
-                    continue;
-                for (let sx = -searchOneSize; sx <= searchOneSize; sx += coarseGap) {
-                    const cx = sCenterX + sx;
-                    if (cx < templateOneSize || cx >= markerWidth - templateOneSize)
-                        continue;
-                    let sumI = 0, sumI2 = 0, sumIT = 0;
-                    for (let ty = -templateOneSize; ty <= templateOneSize; ty++) {
-                        const rowOffset = (cy + ty) * markerWidth;
-                        const tRowOffset = (ty + templateOneSize) * templateSize;
-                        for (let tx = -templateOneSize; tx <= templateOneSize; tx++) {
-                            const valI = projectedImage[rowOffset + (cx + tx)];
-                            const valT = templateData[tRowOffset + (tx + templateOneSize)];
-                            sumI += valI;
-                            sumI2 += valI * valI;
-                            sumIT += valI * valT;
-                        }
-                    }
-                    const varI = Math.sqrt(Math.max(0, sumI2 - (sumI * sumI) * oneOverNPixels));
-                    if (varI < 0.0001)
-                        continue;
-                    const sim = (sumIT - (sumI * sumT) * oneOverNPixels) / (varI * varT);
-                    if (sim > bestSim) {
-                        bestSim = sim;
-                        bestX = cx / scale;
-                        bestY = cy / scale;
-                    }
-                }
-            }
-            // Step 2: Fine refinement (Gap 1) only around the best coarse match
-            if (bestSim > AR2_SIM_THRESH) {
-                const fineCenterX = (bestX * scale) | 0;
-                const fineCenterY = (bestY * scale) | 0;
-                const fineSearch = coarseGap;
-                for (let sy = -fineSearch; sy <= fineSearch; sy++) {
-                    const cy = fineCenterY + sy;
-                    if (cy < templateOneSize || cy >= markerHeight - templateOneSize)
-                        continue;
-                    for (let sx = -fineSearch; sx <= fineSearch; sx++) {
-                        const cx = fineCenterX + sx;
-                        if (cx < templateOneSize || cx >= markerWidth - templateOneSize)
-                            continue;
-                        let sumI = 0, sumI2 = 0, sumIT = 0;
-                        for (let ty = -templateOneSize; ty <= templateOneSize; ty++) {
-                            const rowOffset = (cy + ty) * markerWidth;
-                            const tRowOffset = (ty + templateOneSize) * templateSize;
-                            for (let tx = -templateOneSize; tx <= templateOneSize; tx++) {
-                                const valI = projectedImage[rowOffset + (cx + tx)];
-                                const valT = templateData[tRowOffset + (tx + templateOneSize)];
-                                sumI += valI;
-                                sumI2 += valI * valI;
-                                sumIT += valI * valT;
-                            }
-                        }
-                        const varI = Math.sqrt(Math.max(0, sumI2 - (sumI * sumI) * oneOverNPixels));
-                        if (varI < 0.0001)
-                            continue;
-                        const sim = (sumIT - (sumI * sumT) * oneOverNPixels) / (varI * varT);
-                        if (sim > bestSim) {
-                            bestSim = sim;
-                            bestX = cx / scale;
-                            bestY = cy / scale;
-                        }
-                    }
-                }
-            }
-            sims[f] = bestSim;
-            matchingPoints.push([bestX, bestY]);
-        }
-        return { matchingPoints, sim: sims };
-    }
-    /**
-     * Pure JS implementation of Bilinear Warping
-     */
-    _computeProjection(M, inputData, prebuilt) {
-        const { width: markerWidth, height: markerHeight, scale: markerScale, projectedImage } = prebuilt;
-        const invScale = 1.0 / markerScale;
-        const inputW = this.inputWidth;
-        const inputH = this.inputHeight;
-        const m00 = M[0][0];
-        const m01 = M[0][1];
-        const m03 = M[0][3];
-        const m10 = M[1][0];
-        const m11 = M[1][1];
-        const m13 = M[1][3];
-        const m20 = M[2][0];
-        const m21 = M[2][1];
-        const m23 = M[2][3];
-        for (let j = 0; j < markerHeight; j++) {
-            const y = j * invScale;
-            const jOffset = j * markerWidth;
-            for (let i = 0; i < markerWidth; i++) {
-                const x = i * invScale;
-                const uz = (x * m20) + (y * m21) + m23;
-                const invZ = 1.0 / uz;
-                const ux = ((x * m00) + (y * m01) + m03) * invZ;
-                const uy = ((x * m10) + (y * m11) + m13) * invZ;
-                // Bilinear interpolation
-                const x0 = ux | 0; // Faster Math.floor
-                const y0 = uy | 0;
-                const x1 = x0 + 1;
-                const y1 = y0 + 1;
-                if (x0 >= 0 && x1 < inputW && y0 >= 0 && y1 < inputH) {
-                    const dx = ux - x0;
-                    const dy = uy - y0;
-                    const omDx = 1.0 - dx;
-                    const omDy = 1.0 - dy;
-                    const y0Offset = y0 * inputW;
-                    const y1Offset = y1 * inputW;
-                    const v00 = inputData[y0Offset + x0];
-                    const v10 = inputData[y0Offset + x1];
-                    const v01 = inputData[y1Offset + x0];
-                    const v11 = inputData[y1Offset + x1];
-                    projectedImage[jOffset + i] =
-                        v00 * omDx * omDy +
-                            v10 * dx * omDy +
-                            v01 * omDx * dy +
-                            v11 * dx * dy;
-                }
-                else {
-                    projectedImage[jOffset + i] = 0;
-                }
-            }
-        }
-    }
-}
-export { Tracker };
+import{buildModelViewProjectionTransform as t,computeScreenCoordiate as e}from"../estimation/utils.js";import{refineNonRigid as s,projectMesh as i}from"../estimation/non-rigid-refine.js";import{AR_CONFIG as o}from"../constants.js";const n=o.TRACKER_TEMPLATE_SIZE,r=o.TRACKER_SEARCH_SIZE,a=o.TRACKER_SIMILARITY_THRESHOLD;class h{constructor(t,e,s,i,o,r=!1){this.markerDimensions=t,this.trackingDataList=e,this.projectionTransform=s,this.inputWidth=i,this.inputHeight=o,this.debugMode=r,this.trackingKeyframeList=[],this.prebuiltData=[];for(let t=0;t<e.length;t++){const s=e[t];this.trackingKeyframeList[t]=s,this.prebuiltData[t]=s.map(t=>({px:new Float32Array(t.px),py:new Float32Array(t.py),data:new Uint8Array(t.d),width:t.w,height:t.h,scale:t.s,mesh:t.mesh,projectedImage:new Float32Array(t.w*t.h)}))}this.meshVerticesState=[];const a=2*n+1;this.templateBuffer=new Float32Array(a*a)}dummyRun(t){let e=[[1,0,0,0],[0,1,0,0],[0,0,1,0]];for(let s=0;s<this.trackingKeyframeList.length;s++)this.track(t,e,s)}track(i,o,n){let r={};const h=t(this.projectionTransform,o),[c,l]=this.markerDimensions[n],m=e(h,0,0),f=e(h,c,0),d=Math.sqrt((f.x-m.x)**2+(f.y-m.y)**2);this.lastOctaveIndex||(this.lastOctaveIndex=[]);let p=void 0!==this.lastOctaveIndex[n]?this.lastOctaveIndex[n]:0,u=Math.abs(this.prebuiltData[n][p].width-d);for(let t=0;t<this.prebuiltData[n].length;t++){const e=Math.abs(this.prebuiltData[n][t].width-d);e<.8*u&&(u=e,p=t)}this.lastOctaveIndex[n]=p;const g=this.prebuiltData[n][p];this._computeProjection(h,i,g);const x=g.projectedImage,{matchingPoints:y,sim:w}=this._computeMatching(g,x),I=this.trackingKeyframeList[n][p],M=[],b=[],A=[],{px:k,py:j,s:E}=I,D=[];for(let t=0;t<y.length;t++){const s=w[t];if(s>a&&t<k.length){A.push(t);const i=e(h,y[t][0],y[t][1]);b.push(i),M.push({x:k[t]/E,y:j[t]/E,z:0}),D.push(s)}}let R=null;if(g.mesh&&A.length>=4){this.meshVerticesState[n]||(this.meshVerticesState[n]=[]);let t=this.meshVerticesState[n][p];if(!t){t=new Float32Array(2*k.length);for(let e=0;e<k.length;e++)t[2*e]=k[e],t[2*e+1]=j[e]}const i=[];for(let t=0;t<A.length;t++){const e=A[t];i.push({meshIndex:e,x:y[e][0]*E,y:y[e][1]*E})}const o=s({mesh:g.mesh,trackedPoints:i,currentVertices:t,iterations:5});this.meshVerticesState[n][p]=o;const r=new Float32Array(o.length);for(let t=0;t<o.length;t+=2){const s=e(h,o[t]/E,o[t+1]/E);r[t]=s.x,r[t+1]=s.y}R={vertices:r,triangles:g.mesh.t}}if(b.length>=8){let t=1/0,e=1/0,s=-1/0,i=-1/0;for(const o of b)o.x<t&&(t=o.x),o.y<e&&(e=o.y),o.x>s&&(s=o.x),o.y>i&&(i=o.y);if(Math.sqrt((s-t)**2+(i-e)**2)<.15*d)return{worldCoords:[],screenCoords:[],reliabilities:[],debugExtra:r}}return this.debugMode&&(r={octaveIndex:p,projectedImage:x,matchingPoints:y,goodTrack:A,trackedPoints:b}),{worldCoords:M,screenCoords:b,reliabilities:D,indices:A,octaveIndex:p,deformedMesh:R,debugExtra:r}}_computeMatching(t,e){const{px:s,py:i,scale:o,data:h,width:c,height:l}=t,m=s.length,f=n,d=2*f+1,p=1/(d*d),u=r,g=[],x=new Float32Array(m),y=this.templateBuffer;for(let t=0;t<m;t++){const n=s[t]+.5|0,r=i[t]+.5|0;let m=-1,w=s[t]/o,I=i[t]/o,M=0,b=0,A=0;for(let t=-f;t<=f;t++){const e=(r+t)*c;for(let t=-f;t<=f;t++){const s=h[e+n+t];y[A++]=s,M+=s,b+=s*s}}const k=Math.sqrt(Math.max(0,b-M*M*p));if(k<1e-4){x[t]=-1,g.push([w,I]);continue}const j=4;for(let t=-u;t<=u;t+=j){const s=r+t;if(!(s<f||s>=l-f))for(let t=-u;t<=u;t+=j){const i=n+t;if(i<f||i>=c-f)continue;let r=0,a=0,h=0;for(let t=-f;t<=f;t++){const o=(s+t)*c,n=(t+f)*d;for(let t=-f;t<=f;t++){const s=e[o+(i+t)];r+=s,a+=s*s,h+=s*y[n+(t+f)]}}const l=Math.sqrt(Math.max(0,a-r*r*p));if(l<1e-4)continue;const u=(h-r*M*p)/(l*k);u>m&&(m=u,w=i/o,I=s/o)}}if(m>a){const t=w*o|0,s=I*o|0,i=j;for(let n=-i;n<=i;n++){const r=s+n;if(!(r<f||r>=l-f))for(let s=-i;s<=i;s++){const i=t+s;if(i<f||i>=c-f)continue;let n=0,a=0,h=0;for(let t=-f;t<=f;t++){const s=(r+t)*c,o=(t+f)*d;for(let t=-f;t<=f;t++){const r=e[s+(i+t)];n+=r,a+=r*r,h+=r*y[o+(t+f)]}}const l=Math.sqrt(Math.max(0,a-n*n*p));if(l<1e-4)continue;const u=(h-n*M*p)/(l*k);u>m&&(m=u,w=i/o,I=r/o)}}}x[t]=m,g.push([w,I])}return{matchingPoints:g,sim:x}}_computeProjection(t,e,s){const{width:i,height:o,scale:n,projectedImage:r}=s,a=1/n,h=this.inputWidth,c=this.inputHeight,l=t[0][0],m=t[0][1],f=t[0][3],d=t[1][0],p=t[1][1],u=t[1][3],g=t[2][0],x=t[2][1],y=t[2][3];for(let t=0;t<o;t++){const s=t*a,o=t*i;for(let t=0;t<i;t++){const i=t*a,n=1/(i*g+s*x+y),w=(i*l+s*m+f)*n,I=(i*d+s*p+u)*n,M=0|w,b=0|I,A=M+1,k=b+1;if(M>=0&&A<h&&b>=0&&k<c){const s=w-M,i=I-b,n=1-s,a=1-i,c=b*h,l=k*h,m=e[c+M],f=e[c+A],d=e[l+M],p=e[l+A];r[o+t]=m*n*a+f*s*a+d*n*i+p*s*i}else r[o+t]=0}}}}export{h as Tracker};