@srsergio/taptapp-ar 1.1.1 → 1.1.2

package/dist/compiler/node-worker.js

@@ -1,197 +1 @@
-/**
- * Worker Node.js para compilación de imágenes AR
- *
- * OPTIMIZADO: Sin TensorFlow para evitar bloqueos de inicialización.
- * Usa JavaScript puro para máxima velocidad.
- */
-import { parentPort } from 'node:worker_threads';
-import { extractTrackingFeatures } from '../core/tracker/extract-utils.js';
-import { buildTrackingImageList } from '../core/image-list.js';
-import { DetectorLite } from '../core/detector/detector-lite.js';
-import { build as hierarchicalClusteringBuild } from '../core/matching/hierarchical-clustering.js';
-import { getMorton } from '../core/protocol.js';
-if (!parentPort) {
-    throw new Error('This file must be run as a worker thread.');
-}
-const mortonCache = new Int32Array(2048); // Cache for sorting stability
-function sortPoints(points) {
-    if (points.length <= 1)
-        return points;
-    // Sort in-place to avoid allocations
-    return points.sort((a, b) => {
-        return getMorton(a.x, a.y) - getMorton(b.x, b.y);
-    });
-}
-parentPort.on('message', async (msg) => {
-    if (msg.type === 'compile') {
-        const { targetImage, percentPerImage, basePercent } = msg;
-        try {
-            const imageList = buildTrackingImageList(targetImage);
-            const percentPerAction = percentPerImage / imageList.length;
-            let localPercent = 0;
-            const trackingData = extractTrackingFeatures(imageList, (index) => {
-                localPercent += percentPerAction;
-                parentPort.postMessage({
-                    type: 'progress',
-                    percent: basePercent + localPercent
-                });
-            });
-            parentPort.postMessage({
-                type: 'compileDone',
-                trackingData
-            });
-        }
-        catch (error) {
-            parentPort.postMessage({
-                type: 'error',
-                error: error.message + '\n' + error.stack
-            });
-        }
-    }
-    else if (msg.type === 'match') {
-        const { targetImage, percentPerImage, basePercent } = msg;
-        try {
-            // 🚀 MOONSHOT: Only run detector ONCE on full-res image.
-            // DetectorLite internally builds a pyramid (octaves 1.0, 0.5, 0.25, etc.)
-            const detector = new DetectorLite(targetImage.width, targetImage.height, {
-                useLSH: true
-            });
-            parentPort.postMessage({ type: 'progress', percent: basePercent + percentPerImage * 0.1 });
-            const { featurePoints: allPoints } = detector.detect(targetImage.data);
-            parentPort.postMessage({ type: 'progress', percent: basePercent + percentPerImage * 0.5 });
-            // Group points by their scale (octave)
-            const scalesMap = new Map();
-            for (const p of allPoints) {
-                const octaveScale = p.scale;
-                let list = scalesMap.get(octaveScale);
-                if (!list) {
-                    list = [];
-                    scalesMap.set(octaveScale, list);
-                }
-                // Coordinates in p are already full-res. 
-                // We need them relative to the scaled image for the keyframe.
-                list.push({
-                    ...p,
-                    x: p.x / octaveScale,
-                    y: p.y / octaveScale,
-                    scale: 1.0 // Keypoint scale is always 1.0 relative to its own keyframe image
-                });
-            }
-            // Optional: Run another detector pass at an intermediate scale to improve coverage
-            // (e.g. at 1/1.41 ratio) if tracking robustness suffers. 
-            // For now, let's stick to octaves for MAXIMUM speed.
-            const keyframes = [];
-            const sortedScales = Array.from(scalesMap.keys()).sort((a, b) => a - b);
-            const percentPerScale = (percentPerImage * 0.4) / sortedScales.length;
-            for (const s of sortedScales) {
-                const ps = scalesMap.get(s);
-                const sortedPs = sortPoints(ps);
-                const maximaPoints = sortedPs.filter((p) => p.maxima);
-                const minimaPoints = sortedPs.filter((p) => !p.maxima);
-                const maximaPointsCluster = hierarchicalClusteringBuild({ points: maximaPoints });
-                const minimaPointsCluster = hierarchicalClusteringBuild({ points: minimaPoints });
-                keyframes.push({
-                    maximaPoints,
-                    minimaPoints,
-                    maximaPointsCluster,
-                    minimaPointsCluster,
-                    width: Math.round(targetImage.width / s),
-                    height: Math.round(targetImage.height / s),
-                    scale: 1.0 / s, // keyframe.scale is relative to full target image
-                });
-                parentPort.postMessage({
-                    type: 'progress',
-                    percent: basePercent + percentPerImage * 0.6 + keyframes.length * percentPerScale
-                });
-            }
-            parentPort.postMessage({
-                type: 'matchDone',
-                matchingData: keyframes
-            });
-        }
-        catch (error) {
-            parentPort.postMessage({
-                type: 'error',
-                error: error.message + '\n' + error.stack
-            });
-        }
-    }
-    else if (msg.type === 'compile-all') {
-        const { targetImage } = msg;
-        try {
-            // 1. Single Pass Detection + Pyramid Generation
-            const detector = new DetectorLite(targetImage.width, targetImage.height, { useLSH: true });
-            parentPort.postMessage({ type: 'progress', percent: 10 });
-            const { featurePoints, pyramid } = detector.detect(targetImage.data);
-            parentPort.postMessage({ type: 'progress', percent: 40 });
-            // 2. Extract Tracking Data using the ALREADY BLURRED pyramid
-            // We need 2 levels closest to 256 and 128
-            const trackingImageList = [];
-            // Octave 0 is Original blured. Octave 1 is 0.5x. Octave 2 is 0.25x.
-            // We'll pick the best ones.
-            const targetSizes = [256, 128];
-            for (const targetSize of targetSizes) {
-                let bestLevel = 0;
-                let minDiff = Math.abs(Math.min(targetImage.width, targetImage.height) - targetSize);
-                for (let l = 1; l < pyramid.length; l++) {
-                    const img = pyramid[l][0];
-                    const diff = Math.abs(Math.min(img.width, img.height) - targetSize);
-                    if (diff < minDiff) {
-                        minDiff = diff;
-                        bestLevel = l;
-                    }
-                }
-                const levelImg = pyramid[bestLevel][0];
-                trackingImageList.push({
-                    data: levelImg.data,
-                    width: levelImg.width,
-                    height: levelImg.height,
-                    scale: levelImg.width / targetImage.width
-                });
-            }
-            const trackingData = extractTrackingFeatures(trackingImageList, () => { });
-            parentPort.postMessage({ type: 'progress', percent: 60 });
-            // 3. Build Keyframes for Matching
-            const scalesMap = new Map();
-            for (const p of featurePoints) {
-                const s = p.scale;
-                let list = scalesMap.get(s);
-                if (!list) {
-                    list = [];
-                    scalesMap.set(s, list);
-                }
-                list.push({ ...p, x: p.x / s, y: p.y / s, scale: 1.0 });
-            }
-            const keyframes = [];
-            const sortedScales = Array.from(scalesMap.keys()).sort((a, b) => a - b);
-            for (const s of sortedScales) {
-                const ps = scalesMap.get(s);
-                const sortedPs = sortPoints(ps);
-                const maximaPoints = sortedPs.filter((p) => p.maxima);
-                const minimaPoints = sortedPs.filter((p) => !p.maxima);
-                const maximaPointsCluster = hierarchicalClusteringBuild({ points: maximaPoints });
-                const minimaPointsCluster = hierarchicalClusteringBuild({ points: minimaPoints });
-                keyframes.push({
-                    maximaPoints,
-                    minimaPoints,
-                    maximaPointsCluster,
-                    minimaPointsCluster,
-                    width: Math.round(targetImage.width / s),
-                    height: Math.round(targetImage.height / s),
-                    scale: 1.0 / s,
-                });
-            }
-            parentPort.postMessage({
-                type: 'compileDone', // Reusing message type for compatibility with WorkerPool
-                matchingData: keyframes,
-                trackingData: trackingData
-            });
-        }
-        catch (error) {
-            parentPort.postMessage({
-                type: 'error',
-                error: error.message + '\n' + error.stack
-            });
-        }
-    }
-});
+import{parentPort as t}from"node:worker_threads";import{extractTrackingFeatures as e}from"../core/tracker/extract-utils.js";import{buildTrackingImageList as s}from"../core/image-list.js";import{DetectorLite as r}from"../core/detector/detector-lite.js";import{build as o}from"../core/matching/hierarchical-clustering.js";import{getMorton as a}from"../core/protocol.js";if(!t)throw new Error("This file must be run as a worker thread.");function n(t){return t.length<=1?t:t.sort((t,e)=>a(t.x,t.y)-a(e.x,e.y))}new Int32Array(2048),t.on("message",async a=>{if("compile"===a.type){const{targetImage:r,percentPerImage:o,basePercent:n}=a;try{const a=s(r),i=o/a.length;let c=0;const p=e(a,e=>{c+=i,t.postMessage({type:"progress",percent:n+c})});t.postMessage({type:"compileDone",trackingData:p})}catch(e){t.postMessage({type:"error",error:e.message+"\n"+e.stack})}}else if("match"===a.type){const{targetImage:e,percentPerImage:s,basePercent:i}=a;try{const a=new r(e.width,e.height,{useLSH:!0});t.postMessage({type:"progress",percent:i+.1*s});const{featurePoints:c}=a.detect(e.data);t.postMessage({type:"progress",percent:i+.5*s});const p=new Map;for(const t of c){const e=t.scale;let s=p.get(e);s||(s=[],p.set(e,s)),s.push({...t,x:t.x/e,y:t.y/e,scale:1})}const h=[],m=Array.from(p.keys()).sort((t,e)=>t-e),g=.4*s/m.length;for(const r of m){const a=n(p.get(r)),c=a.filter(t=>t.maxima),m=a.filter(t=>!t.maxima),l=o({points:c}),y=o({points:m});h.push({maximaPoints:c,minimaPoints:m,maximaPointsCluster:l,minimaPointsCluster:y,width:Math.round(e.width/r),height:Math.round(e.height/r),scale:1/r}),t.postMessage({type:"progress",percent:i+.6*s+h.length*g})}t.postMessage({type:"matchDone",matchingData:h})}catch(e){t.postMessage({type:"error",error:e.message+"\n"+e.stack})}}else if("compile-all"===a.type){const{targetImage:s}=a;try{const a=new r(s.width,s.height,{useLSH:!0});t.postMessage({type:"progress",percent:10});const{featurePoints:i,pyramid:c}=a.detect(s.data);t.postMessage({type:"progress",percent:40});const p=[],h=[256,128];for(const t of h){let e=0,r=Math.abs(Math.min(s.width,s.height)-t);for(let s=1;s<c.length;s++){const o=c[s][0],a=Math.abs(Math.min(o.width,o.height)-t);a<r&&(r=a,e=s)}const o=c[e][0];p.push({data:o.data,width:o.width,height:o.height,scale:o.width/s.width})}const m=e(p,()=>{});t.postMessage({type:"progress",percent:60});const g=new Map;for(const t of i){const e=t.scale;let s=g.get(e);s||(s=[],g.set(e,s)),s.push({...t,x:t.x/e,y:t.y/e,scale:1})}const l=[],y=Array.from(g.keys()).sort((t,e)=>t-e);for(const t of y){const e=n(g.get(t)),r=e.filter(t=>t.maxima),a=e.filter(t=>!t.maxima),i=o({points:r}),c=o({points:a});l.push({maximaPoints:r,minimaPoints:a,maximaPointsCluster:i,minimaPointsCluster:c,width:Math.round(s.width/t),height:Math.round(s.height/t),scale:1/t})}t.postMessage({type:"compileDone",matchingData:l,trackingData:m})}catch(e){t.postMessage({type:"error",error:e.message+"\n"+e.stack})}}});

package/dist/compiler/offline-compiler.js

@@ -1,207 +1 @@
-/**
- * @fileoverview Compilador Offline Optimizado - Sin TensorFlow para máxima velocidad
- *
- * Este módulo implementa un compilador de imágenes AR ultrarrápido
- * que NO depende de TensorFlow, eliminando todos los problemas de
- * inicialización, bloqueos y compatibilidad.
- */
-import { buildTrackingImageList } from "../core/image-list.js";
-import { extractTrackingFeatures } from "../core/tracker/extract-utils.js";
-import { DetectorLite } from "../core/detector/detector-lite.js";
-import { build as hierarchicalClusteringBuild } from "../core/matching/hierarchical-clustering.js";
-import * as protocol from "../core/protocol.js";
-import { triangulate, getEdges } from "../core/utils/delaunay.js";
-import { AR_CONFIG } from "../core/constants.js";
-// Detect environment
-const isNode = typeof process !== "undefined" &&
-    process.versions != null &&
-    process.versions.node != null;
-export class OfflineCompiler {
-    data = null;
-    constructor() {
-        console.log("⚡ OfflineCompiler: Main thread mode (no workers)");
-    }
-    async compileImageTargets(images, progressCallback) {
-        console.time("⏱️ Compilación total");
-        const targetImages = [];
-        // Preparar imágenes
-        for (let i = 0; i < images.length; i++) {
-            const img = images[i];
-            if (!img || !img.width || !img.height || !img.data) {
-                throw new Error(`Imagen inválida en posición ${i}. Debe tener propiedades width, height y data.`);
-            }
-            const greyImageData = new Uint8Array(img.width * img.height);
-            if (img.data.length === img.width * img.height) {
-                greyImageData.set(img.data);
-            }
-            else if (img.data.length === img.width * img.height * 4) {
-                for (let j = 0; j < greyImageData.length; j++) {
-                    const offset = j * 4;
-                    greyImageData[j] = Math.floor((img.data[offset] + img.data[offset + 1] + img.data[offset + 2]) / 3);
-                }
-            }
-            else {
-                throw new Error(`Formato de datos de imagen no soportado en posición ${i}`);
-            }
-            targetImages.push({
-                data: greyImageData,
-                width: img.width,
-                height: img.height,
-            });
-        }
-        const results = await this._compileTarget(targetImages, progressCallback);
-        this.data = targetImages.map((img, i) => ({
-            targetImage: img,
-            matchingData: results[i].matchingData,
-            trackingData: results[i].trackingData,
-        }));
-        console.timeEnd("⏱️ Compilación total");
-        return this.data;
-    }
-    async _compileTarget(targetImages, progressCallback) {
-        // Run match and track sequentially to match browser behavior exactly
-        const matchingResults = await this._compileMatch(targetImages, (p) => progressCallback(p * 0.5));
-        const trackingResults = await this._compileTrack(targetImages, (p) => progressCallback(50 + p * 0.5));
-        return targetImages.map((_, i) => ({
-            matchingData: matchingResults[i],
-            trackingData: trackingResults[i]
-        }));
-    }
-    async _compileMatch(targetImages, progressCallback) {
-        const percentPerImage = 100 / targetImages.length;
-        let currentPercent = 0;
-        const results = [];
-        for (let i = 0; i < targetImages.length; i++) {
-            const targetImage = targetImages[i];
-            // 🚀 NANITE-STYLE: Only process the target at scale 1.0
-            // The DetectorLite already builds its own pyramid and finds features at all octaves (virtualized LOD)
-            const detector = new DetectorLite(targetImage.width, targetImage.height, {
-                useLSH: AR_CONFIG.USE_LSH,
-                maxFeaturesPerBucket: AR_CONFIG.MAX_FEATURES_PER_BUCKET
-            });
-            const { featurePoints: rawPs } = detector.detect(targetImage.data);
-            // 🎯 Stratified Sampling: Ensure we have features from ALL scales
-            // We take the top N features per octave to guarantee scale coverage (Nanite-style)
-            const octaves = [0, 1, 2, 3, 4, 5];
-            const ps = [];
-            const featuresPerOctave = 300;
-            for (const oct of octaves) {
-                const octScale = Math.pow(2, oct);
-                const octFeatures = rawPs
-                    .filter(p => Math.abs(p.scale - octScale) < 0.1)
-                    .sort((a, b) => (b.score || 0) - (a.score || 0))
-                    .slice(0, featuresPerOctave);
-                ps.push(...octFeatures);
-            }
-            const maximaPoints = ps.filter((p) => p.maxima);
-            const minimaPoints = ps.filter((p) => !p.maxima);
-            const maximaPointsCluster = hierarchicalClusteringBuild({ points: maximaPoints });
-            const minimaPointsCluster = hierarchicalClusteringBuild({ points: minimaPoints });
-            const keyframe = {
-                maximaPoints,
-                minimaPoints,
-                maximaPointsCluster,
-                minimaPointsCluster,
-                width: targetImage.width,
-                height: targetImage.height,
-                scale: 1.0,
-            };
-            // Wrapped in array because the protocol expects matchingData to be an array of keyframes
-            // We provide only one keyframe containing features from all octaves
-            results.push([keyframe]);
-            currentPercent += percentPerImage;
-            progressCallback(currentPercent);
-        }
-        return results;
-    }
-    async _compileTrack(targetImages, progressCallback) {
-        const percentPerImage = 100 / targetImages.length;
-        let currentPercent = 0;
-        const results = [];
-        for (let i = 0; i < targetImages.length; i++) {
-            const targetImage = targetImages[i];
-            const imageList = buildTrackingImageList(targetImage);
-            const percentPerScale = percentPerImage / imageList.length;
-            const trackingData = extractTrackingFeatures(imageList, () => {
-                currentPercent += percentPerScale;
-                progressCallback(currentPercent);
-            });
-            results.push(trackingData);
-        }
-        return results;
-    }
-    async compileTrack({ progressCallback, targetImages, basePercent = 0 }) {
-        return this._compileTrack(targetImages, (percent) => {
-            progressCallback(basePercent + percent * (100 - basePercent) / 100);
-        });
-    }
-    async compileMatch({ progressCallback, targetImages, basePercent = 0 }) {
-        return this._compileMatch(targetImages, (percent) => {
-            progressCallback(basePercent + percent * (50 - basePercent) / 100);
-        });
-    }
-    exportData() {
-        if (!this.data) {
-            throw new Error("No hay datos compilados para exportar");
-        }
-        const dataList = this.data.map((item) => {
-            return {
-                targetImage: {
-                    width: item.targetImage.width,
-                    height: item.targetImage.height,
-                },
-                trackingData: item.trackingData.map((td) => {
-                    const count = td.points.length;
-                    const px = new Float32Array(count);
-                    const py = new Float32Array(count);
-                    for (let i = 0; i < count; i++) {
-                        px[i] = td.points[i].x;
-                        py[i] = td.points[i].y;
-                    }
-                    const triangles = triangulate(td.points);
-                    const edges = getEdges(triangles);
-                    const restLengths = new Float32Array(edges.length);
-                    for (let j = 0; j < edges.length; j++) {
-                        const p1 = td.points[edges[j][0]];
-                        const p2 = td.points[edges[j][1]];
-                        restLengths[j] = Math.sqrt((p1.x - p2.x) ** 2 + (p1.y - p2.y) ** 2);
-                    }
-                    return {
-                        w: td.width,
-                        h: td.height,
-                        s: td.scale,
-                        px,
-                        py,
-                        d: td.data,
-                        mesh: {
-                            t: new Uint16Array(triangles.flat()),
-                            e: new Uint16Array(edges.flat()),
-                            rl: restLengths
-                        }
-                    };
-                }),
-                matchingData: item.matchingData.map((kf) => {
-                    const useCompact = AR_CONFIG.USE_COMPACT_DESCRIPTORS;
-                    const columnarizeFn = useCompact ? protocol.columnarizeCompact : protocol.columnarize;
-                    return {
-                        w: kf.width,
-                        h: kf.height,
-                        s: kf.scale,
-                        hdc: false,
-                        max: columnarizeFn(kf.maximaPoints, kf.maximaPointsCluster, kf.width, kf.height),
-                        min: columnarizeFn(kf.minimaPoints, kf.minimaPointsCluster, kf.width, kf.height),
-                    };
-                }),
-            };
-        });
-        return protocol.encodeTaar(dataList);
-    }
-    importData(buffer) {
-        const result = protocol.decodeTaar(buffer);
-        this.data = result.dataList;
-        return result;
-    }
-    async destroy() {
-        // No workers to destroy
-    }
-}
+import{buildTrackingImageList as t}from"../core/image-list.js";import{extractTrackingFeatures as a}from"../core/tracker/extract-utils.js";import{DetectorLite as e}from"../core/detector/detector-lite.js";import{build as i}from"../core/matching/hierarchical-clustering.js";import*as o from"../core/protocol.js";import{triangulate as r,getEdges as n}from"../core/utils/delaunay.js";import{AR_CONFIG as s}from"../core/constants.js";"undefined"!=typeof process&&null!=process.versions&&process.versions.node;export class OfflineCompiler{data=null;constructor(){console.log("⚡ OfflineCompiler: Main thread mode (no workers)")}async compileImageTargets(t,a){console.time("⏱️ Compilación total");const e=[];for(let a=0;a<t.length;a++){const i=t[a];if(!(i&&i.width&&i.height&&i.data))throw new Error(`Imagen inválida en posición ${a}. Debe tener propiedades width, height y data.`);const o=new Uint8Array(i.width*i.height);if(i.data.length===i.width*i.height)o.set(i.data);else{if(i.data.length!==i.width*i.height*4)throw new Error(`Formato de datos de imagen no soportado en posición ${a}`);for(let t=0;t<o.length;t++){const a=4*t;o[t]=Math.floor((i.data[a]+i.data[a+1]+i.data[a+2])/3)}}e.push({data:o,width:i.width,height:i.height})}const i=await this._compileTarget(e,a);return this.data=e.map((t,a)=>({targetImage:t,matchingData:i[a].matchingData,trackingData:i[a].trackingData})),console.timeEnd("⏱️ Compilación total"),this.data}async _compileTarget(t,a){const e=await this._compileMatch(t,t=>a(.5*t)),i=await this._compileTrack(t,t=>a(50+.5*t));return t.map((t,a)=>({matchingData:e[a],trackingData:i[a]}))}async _compileMatch(t,a){const o=100/t.length;let r=0;const n=[];for(let c=0;c<t.length;c++){const h=t[c],l=new e(h.width,h.height,{useLSH:s.USE_LSH,maxFeaturesPerBucket:s.MAX_FEATURES_PER_BUCKET}),{featurePoints:m}=l.detect(h.data),g=[0,1,2,3,4,5],p=[],d=300;for(const t of g){const a=Math.pow(2,t),e=m.filter(t=>Math.abs(t.scale-a)<.1).sort((t,a)=>(a.score||0)-(t.score||0)).slice(0,d);p.push(...e)}const w=p.filter(t=>t.maxima),u=p.filter(t=>!t.maxima),f={maximaPoints:w,minimaPoints:u,maximaPointsCluster:i({points:w}),minimaPointsCluster:i({points:u}),width:h.width,height:h.height,scale:1};n.push([f]),r+=o,a(r)}return n}async _compileTrack(e,i){const o=100/e.length;let r=0;const n=[];for(let s=0;s<e.length;s++){const c=e[s],h=t(c),l=o/h.length,m=a(h,()=>{r+=l,i(r)});n.push(m)}return n}async compileTrack({progressCallback:t,targetImages:a,basePercent:e=0}){return this._compileTrack(a,a=>{t(e+a*(100-e)/100)})}async compileMatch({progressCallback:t,targetImages:a,basePercent:e=0}){return this._compileMatch(a,a=>{t(e+a*(50-e)/100)})}exportData(){if(!this.data)throw new Error("No hay datos compilados para exportar");const t=this.data.map(t=>({targetImage:{width:t.targetImage.width,height:t.targetImage.height},trackingData:t.trackingData.map(t=>{const a=t.points.length,e=new Float32Array(a),i=new Float32Array(a);for(let o=0;o<a;o++)e[o]=t.points[o].x,i[o]=t.points[o].y;const o=r(t.points),s=n(o),c=new Float32Array(s.length);for(let a=0;a<s.length;a++){const e=t.points[s[a][0]],i=t.points[s[a][1]];c[a]=Math.sqrt((e.x-i.x)**2+(e.y-i.y)**2)}return{w:t.width,h:t.height,s:t.scale,px:e,py:i,d:t.data,mesh:{t:new Uint16Array(o.flat()),e:new Uint16Array(s.flat()),rl:c}}}),matchingData:t.matchingData.map(t=>{const a=s.USE_COMPACT_DESCRIPTORS?o.columnarizeCompact:o.columnarize;return{w:t.width,h:t.height,s:t.scale,hdc:!1,max:a(t.maximaPoints,t.maximaPointsCluster,t.width,t.height),min:a(t.minimaPoints,t.minimaPointsCluster,t.width,t.height)}})}));return o.encodeTaar(t)}importData(t){const a=o.decodeTaar(t);return this.data=a.dataList,a}async destroy(){}}

package/dist/core/constants.js

@@ -1,38 +1 @@
-/**
- * @fileoverview Centralized constants for the AR Engine
- */
-export const AR_CONFIG = {
-    // Camera settings
-    VIEWPORT_WIDTH: 640,
-    VIEWPORT_HEIGHT: 480,
-    DEFAULT_FOVY: 60.0,
-    DEFAULT_NEAR: 1.0,
-    DEFAULT_FAR: 10000.0,
-    // Detection settings
-    MAX_FEATURES_PER_BUCKET: 24,
-    USE_LSH: true,
-    // Matching settings
-    HAMMING_THRESHOLD: 0.85,
-    HDC_RATIO_THRESHOLD: 0.85,
-    INLIER_THRESHOLD: 15.0,
-    MIN_NUM_INLIERS: 6,
-    MAX_MATCH_QUERY_POINTS: 800,
-    CLUSTER_MAX_POP: 25,
-    // Tracker / NCC settings
-    TRACKER_TEMPLATE_SIZE: 6,
-    TRACKER_SEARCH_SIZE: 12,
-    TRACKER_SIMILARITY_THRESHOLD: 0.65,
-    // Image processing / Scale list
-    MIN_IMAGE_PIXEL_SIZE: 32,
-    SCALE_STEP_EXPONENT: 1.0, // Optimized: was 0.6, now 1.0 (reduces scales from ~7 to ~4)
-    TRACKING_DOWNSCALE_LEVEL_1: 256.0,
-    TRACKING_DOWNSCALE_LEVEL_2: 128.0,
-    // Tracker settings
-    WARMUP_TOLERANCE: 2,
-    MISS_TOLERANCE: 1,
-    ONE_EURO_FILTER_CUTOFF: 0.5,
-    ONE_EURO_FILTER_BETA: 0.1,
-    // TAAR Size Optimization
-    USE_COMPACT_DESCRIPTORS: true, // 32-bit XOR folded descriptors vs 64-bit raw
-    COMPACT_HAMMING_THRESHOLD: 8, // Threshold for 32-bit descriptors (vs 15 for 64-bit)
-};
+export const AR_CONFIG={VIEWPORT_WIDTH:640,VIEWPORT_HEIGHT:480,DEFAULT_FOVY:60,DEFAULT_NEAR:1,DEFAULT_FAR:1e4,MAX_FEATURES_PER_BUCKET:24,USE_LSH:!0,HAMMING_THRESHOLD:.85,HDC_RATIO_THRESHOLD:.85,INLIER_THRESHOLD:15,MIN_NUM_INLIERS:6,MAX_MATCH_QUERY_POINTS:800,CLUSTER_MAX_POP:25,TRACKER_TEMPLATE_SIZE:6,TRACKER_SEARCH_SIZE:12,TRACKER_SIMILARITY_THRESHOLD:.65,MIN_IMAGE_PIXEL_SIZE:32,SCALE_STEP_EXPONENT:1,TRACKING_DOWNSCALE_LEVEL_1:256,TRACKING_DOWNSCALE_LEVEL_2:128,WARMUP_TOLERANCE:2,MISS_TOLERANCE:1,ONE_EURO_FILTER_CUTOFF:.5,ONE_EURO_FILTER_BETA:.1,USE_COMPACT_DESCRIPTORS:!0,COMPACT_HAMMING_THRESHOLD:8};

package/dist/core/detector/crop-detector.js

@@ -1,88 +1 @@
-import { DetectorLite } from "./detector-lite.js";
-class CropDetector {
-    constructor(width, height, debugMode = false) {
-        this.debugMode = debugMode;
-        this.width = width;
-        this.height = height;
-        // nearest power of 2, min dimensions
-        let minDimension = Math.min(width, height) / 2;
-        let cropSize = Math.pow(2, Math.round(Math.log(minDimension) / Math.log(2)));
-        this.cropSize = cropSize;
-        this.detector = new DetectorLite(cropSize, cropSize, { useLSH: true });
-        this.lastRandomIndex = 4;
-    }
-    detect(input) {
-        const imageData = input;
-        // crop center
-        const startY = Math.floor(this.height / 2 - this.cropSize / 2);
-        const startX = Math.floor(this.width / 2 - this.cropSize / 2);
-        const result = this._detect(imageData, startX, startY);
-        if (this.debugMode) {
-            result.debugExtra.crop = { startX, startY, cropSize: this.cropSize };
-        }
-        return result;
-    }
-    detectMoving(input) {
-        const imageData = input;
-        if (!this.frameCounter)
-            this.frameCounter = 0;
-        this.frameCounter++;
-        // Scan full screen every 2 frames
-        if (this.frameCounter % 2 === 0) {
-            return this._detectGlobal(imageData);
-        }
-        // Local crops: ensure we visit every single cell
-        const gridSize = 5;
-        const dx = this.lastRandomIndex % gridSize;
-        const dy = Math.floor(this.lastRandomIndex / gridSize);
-        const stepX = this.cropSize / 3;
-        const stepY = this.cropSize / 3;
-        let startY = Math.floor(this.height / 2 - this.cropSize / 2 + (dy - 2) * stepY);
-        let startX = Math.floor(this.width / 2 - this.cropSize / 2 + (dx - 2) * stepX);
-        startX = Math.max(0, Math.min(this.width - this.cropSize - 1, startX));
-        startY = Math.max(0, Math.min(this.height - this.cropSize - 1, startY));
-        this.lastRandomIndex = (this.lastRandomIndex + 1) % (gridSize * gridSize);
-        return this._detect(imageData, startX, startY);
-    }
-    _detectGlobal(imageData) {
-        const croppedData = new Float32Array(this.cropSize * this.cropSize);
-        const scaleX = this.width / this.cropSize;
-        const scaleY = this.height / this.cropSize;
-        // Use sharp sampling for better descriptors
-        for (let y = 0; y < this.cropSize; y++) {
-            const srcY = Math.floor(y * scaleY) * this.width;
-            const dstY = y * this.cropSize;
-            for (let x = 0; x < this.cropSize; x++) {
-                croppedData[dstY + x] = imageData[srcY + Math.floor(x * scaleX)];
-            }
-        }
-        const { featurePoints } = this.detector.detect(croppedData);
-        featurePoints.forEach((p) => {
-            p.x *= scaleX;
-            p.y *= scaleY;
-        });
-        return {
-            featurePoints,
-            debugExtra: this.debugMode ? { projectedImage: Array.from(croppedData), isGlobal: true } : {}
-        };
-    }
-    _detect(imageData, startX, startY) {
-        // Crop manually since imageData is now a flat array (width * height)
-        const croppedData = new Float32Array(this.cropSize * this.cropSize);
-        for (let y = 0; y < this.cropSize; y++) {
-            for (let x = 0; x < this.cropSize; x++) {
-                croppedData[y * this.cropSize + x] = imageData[(startY + y) * this.width + (startX + x)];
-            }
-        }
-        const { featurePoints } = this.detector.detect(croppedData);
-        featurePoints.forEach((p) => {
-            p.x += startX;
-            p.y += startY;
-        });
-        return {
-            featurePoints,
-            debugExtra: this.debugMode ? { projectedImage: Array.from(croppedData) } : {}
-        };
-    }
-}
-export { CropDetector };
+import{DetectorLite as t}from"./detector-lite.js";class e{constructor(e,i,o=!1){this.debugMode=o,this.width=e,this.height=i;let h=Math.min(e,i)/2,r=Math.pow(2,Math.round(Math.log(h)/Math.log(2)));this.cropSize=r,this.detector=new t(r,r,{useLSH:!0}),this.lastRandomIndex=4}detect(t){const e=t,i=Math.floor(this.height/2-this.cropSize/2),o=Math.floor(this.width/2-this.cropSize/2),h=this._detect(e,o,i);return this.debugMode&&(h.debugExtra.crop={startX:o,startY:i,cropSize:this.cropSize}),h}detectMoving(t){const e=t;if(this.frameCounter||(this.frameCounter=0),this.frameCounter++,this.frameCounter%2==0)return this._detectGlobal(e);const i=this.lastRandomIndex%5,o=Math.floor(this.lastRandomIndex/5),h=this.cropSize/3,r=this.cropSize/3;let s=Math.floor(this.height/2-this.cropSize/2+(o-2)*r),a=Math.floor(this.width/2-this.cropSize/2+(i-2)*h);return a=Math.max(0,Math.min(this.width-this.cropSize-1,a)),s=Math.max(0,Math.min(this.height-this.cropSize-1,s)),this.lastRandomIndex=(this.lastRandomIndex+1)%25,this._detect(e,a,s)}_detectGlobal(t){const e=new Float32Array(this.cropSize*this.cropSize),i=this.width/this.cropSize,o=this.height/this.cropSize;for(let h=0;h<this.cropSize;h++){const r=Math.floor(h*o)*this.width,s=h*this.cropSize;for(let o=0;o<this.cropSize;o++)e[s+o]=t[r+Math.floor(o*i)]}const{featurePoints:h}=this.detector.detect(e);return h.forEach(t=>{t.x*=i,t.y*=o}),{featurePoints:h,debugExtra:this.debugMode?{projectedImage:Array.from(e),isGlobal:!0}:{}}}_detect(t,e,i){const o=new Float32Array(this.cropSize*this.cropSize);for(let h=0;h<this.cropSize;h++)for(let r=0;r<this.cropSize;r++)o[h*this.cropSize+r]=t[(i+h)*this.width+(e+r)];const{featurePoints:h}=this.detector.detect(o);return h.forEach(t=>{t.x+=e,t.y+=i}),{featurePoints:h,debugExtra:this.debugMode?{projectedImage:Array.from(o)}:{}}}}export{e as CropDetector};