@srsergio/taptapp-ar 1.1.1 → 1.1.3

package/dist/core/estimation/utils.js

@@ -1,67 +1 @@
-const buildModelViewProjectionTransform = (projectionTransform, modelViewTransform) => {
-    // assume the projectTransform has the following format:
-    // [[fx, 0, cx],
-    //  [0, fy, cy]
-    //  [0, 0, 1]]
-    const modelViewProjectionTransform = [
-        [
-            projectionTransform[0][0] * modelViewTransform[0][0] +
-                projectionTransform[0][2] * modelViewTransform[2][0],
-            projectionTransform[0][0] * modelViewTransform[0][1] +
-                projectionTransform[0][2] * modelViewTransform[2][1],
-            projectionTransform[0][0] * modelViewTransform[0][2] +
-                projectionTransform[0][2] * modelViewTransform[2][2],
-            projectionTransform[0][0] * modelViewTransform[0][3] +
-                projectionTransform[0][2] * modelViewTransform[2][3],
-        ],
-        [
-            projectionTransform[1][1] * modelViewTransform[1][0] +
-                projectionTransform[1][2] * modelViewTransform[2][0],
-            projectionTransform[1][1] * modelViewTransform[1][1] +
-                projectionTransform[1][2] * modelViewTransform[2][1],
-            projectionTransform[1][1] * modelViewTransform[1][2] +
-                projectionTransform[1][2] * modelViewTransform[2][2],
-            projectionTransform[1][1] * modelViewTransform[1][3] +
-                projectionTransform[1][2] * modelViewTransform[2][3],
-        ],
-        [
-            modelViewTransform[2][0],
-            modelViewTransform[2][1],
-            modelViewTransform[2][2],
-            modelViewTransform[2][3],
-        ],
-    ];
-    return modelViewProjectionTransform;
-    /*
-    // this is the full computation if the projectTransform does not look like the expected format, but more computations
-    //
-    const modelViewProjectionTransform = [[],[],[]];
-    for (let j = 0; j < 3; j++ ) {
-      for (let i = 0; i < 4; i++) {
-        modelViewProjectionTransform[j][i] = projectionTransform[j][0] * modelViewTransform[0][i]
-                                           + projectionTransform[j][1] * modelViewTransform[1][i]
-                                           + projectionTransform[j][2] * modelViewTransform[2][i];
-      }
-    }
-    return modelViewProjectionTransform;
-    */
-};
-const applyModelViewProjectionTransform = (modelViewProjectionTransform, x, y, _z) => {
-    // assume z is zero
-    const ux = modelViewProjectionTransform[0][0] * x +
-        modelViewProjectionTransform[0][1] * y +
-        modelViewProjectionTransform[0][3];
-    const uy = modelViewProjectionTransform[1][0] * x +
-        modelViewProjectionTransform[1][1] * y +
-        modelViewProjectionTransform[1][3];
-    const uz = modelViewProjectionTransform[2][0] * x +
-        modelViewProjectionTransform[2][1] * y +
-        modelViewProjectionTransform[2][3];
-    return { x: ux, y: uy, z: uz };
-};
-const computeScreenCoordiate = (modelViewProjectionTransform, x, y, z) => {
-    const { x: ux, y: uy, z: uz, } = applyModelViewProjectionTransform(modelViewProjectionTransform, x, y, z);
-    //if( Math.abs(uz) < 0.000001 ) return null;
-    return { x: ux / uz, y: uy / uz };
-};
-export { buildModelViewProjectionTransform, applyModelViewProjectionTransform, computeScreenCoordiate, };
+const t=(t,x)=>[[t[0][0]*x[0][0]+t[0][2]*x[2][0],t[0][0]*x[0][1]+t[0][2]*x[2][1],t[0][0]*x[0][2]+t[0][2]*x[2][2],t[0][0]*x[0][3]+t[0][2]*x[2][3]],[t[1][1]*x[1][0]+t[1][2]*x[2][0],t[1][1]*x[1][1]+t[1][2]*x[2][1],t[1][1]*x[1][2]+t[1][2]*x[2][2],t[1][1]*x[1][3]+t[1][2]*x[2][3]],[x[2][0],x[2][1],x[2][2],x[2][3]]],x=(t,x,n,o)=>({x:t[0][0]*x+t[0][1]*n+t[0][3],y:t[1][0]*x+t[1][1]*n+t[1][3],z:t[2][0]*x+t[2][1]*n+t[2][3]}),n=(t,n,o,r)=>{const{x:y,y:c,z:e}=x(t,n,o);return{x:y/e,y:c/e}};export{t as buildModelViewProjectionTransform,x as applyModelViewProjectionTransform,n as computeScreenCoordiate};

package/dist/core/features/auto-rotation-feature.js

@@ -1,30 +1 @@
-export class AutoRotationFeature {
-    id = "auto-rotation";
-    name = "Auto Rotation Matrix";
-    description = "Automatically adjusts the world matrix if the input video is rotated (e.g. portrait mode).";
-    enabled = true;
-    inputWidth = 0;
-    inputHeight = 0;
-    init(context) {
-        this.inputWidth = context.inputWidth;
-        this.inputHeight = context.inputHeight;
-    }
-    filterWorldMatrix(targetIndex, worldMatrix) {
-        if (!this.enabled)
-            return worldMatrix;
-        // Check if input is rotated (this logic might need the actual current input dimensions)
-        // For now, we'll assume the controller passes the 'isRotated' info or we detect it
-        // But since this is a matrix post-process, we can just apply it if needed.
-        return worldMatrix;
-    }
-    // We might need a way to pass the 'currentInput' to the feature.
-    // Actually, the controller can just call this if it detects rotation.
-    rotate(m) {
-        return [
-            -m[1], m[0], m[2], m[3],
-            -m[5], m[4], m[6], m[7],
-            -m[9], m[8], m[10], m[11],
-            -m[13], m[12], m[14], m[15],
-        ];
-    }
-}
+export class AutoRotationFeature{id="auto-rotation";name="Auto Rotation Matrix";description="Automatically adjusts the world matrix if the input video is rotated (e.g. portrait mode).";enabled=!0;inputWidth=0;inputHeight=0;init(t){this.inputWidth=t.inputWidth,this.inputHeight=t.inputHeight}filterWorldMatrix(t,i){return this.enabled,i}rotate(t){return[-t[1],t[0],t[2],t[3],-t[5],t[4],t[6],t[7],-t[9],t[8],t[10],t[11],-t[13],t[12],t[14],t[15]]}}

package/dist/core/features/crop-detection-feature.js

@@ -1,26 +1 @@
-import { CropDetector } from "../detector/crop-detector.js";
-export class CropDetectionFeature {
-    id = "crop-detection";
-    name = "Crop Detection";
-    description = "Optimizes detection by focusing on areas with motion, reducing CPU usage.";
-    enabled = true;
-    cropDetector = null;
-    debugMode = false;
-    init(context) {
-        this.debugMode = context.debugMode;
-        this.cropDetector = new CropDetector(context.inputWidth, context.inputHeight, this.debugMode);
-    }
-    detect(inputData, isMoving = true) {
-        if (!this.enabled || !this.cropDetector) {
-            // Fallback to full detection if disabled? 
-            // Actually CropDetector.detect is just full detection.
-            // We'll expose the methods here.
-        }
-        if (isMoving && this.enabled) {
-            return this.cropDetector.detectMoving(inputData);
-        }
-        else {
-            return this.cropDetector.detect(inputData);
-        }
-    }
-}
+import{CropDetector as e}from"../detector/crop-detector.js";export class CropDetectionFeature{id="crop-detection";name="Crop Detection";description="Optimizes detection by focusing on areas with motion, reducing CPU usage.";enabled=!0;cropDetector=null;debugMode=!1;init(t){this.debugMode=t.debugMode,this.cropDetector=new e(t.inputWidth,t.inputHeight,this.debugMode)}detect(e,t=!0){return!this.enabled||this.cropDetector,t&&this.enabled?this.cropDetector.detectMoving(e):this.cropDetector.detect(e)}}

package/dist/core/features/feature-base.js

@@ -1 +1 @@
-export {};
+export{};

package/dist/core/features/feature-manager.js

@@ -1,55 +1 @@
-export class FeatureManager {
-    features = [];
-    addFeature(feature) {
-        this.features.push(feature);
-    }
-    getFeature(id) {
-        return this.features.find(f => f.id === id);
-    }
-    init(context) {
-        for (const feature of this.features) {
-            if (feature.enabled && feature.init) {
-                feature.init(context);
-            }
-        }
-    }
-    beforeProcess(inputData) {
-        for (const feature of this.features) {
-            if (feature.enabled && feature.beforeProcess) {
-                feature.beforeProcess(inputData);
-            }
-        }
-    }
-    applyWorldMatrixFilters(targetIndex, worldMatrix, context) {
-        let result = worldMatrix;
-        for (const feature of this.features) {
-            if (feature.enabled && feature.filterWorldMatrix) {
-                result = feature.filterWorldMatrix(targetIndex, result, context);
-            }
-        }
-        return result;
-    }
-    shouldShow(targetIndex, isTracking) {
-        let show = isTracking;
-        for (const feature of this.features) {
-            if (feature.enabled && feature.shouldShow) {
-                show = feature.shouldShow(targetIndex, isTracking);
-            }
-        }
-        return show;
-    }
-    notifyUpdate(data) {
-        for (const feature of this.features) {
-            if (feature.enabled && feature.onUpdate) {
-                feature.onUpdate(data);
-            }
-        }
-    }
-    dispose() {
-        for (const feature of this.features) {
-            if (feature.dispose) {
-                feature.dispose();
-            }
-        }
-    }
-}
+export class FeatureManager{features=[];addFeature(e){this.features.push(e)}getFeature(e){return this.features.find(t=>t.id===e)}init(e){for(const t of this.features)t.enabled&&t.init&&t.init(e)}beforeProcess(e){for(const t of this.features)t.enabled&&t.beforeProcess&&t.beforeProcess(e)}applyWorldMatrixFilters(e,t,s){let r=t;for(const t of this.features)t.enabled&&t.filterWorldMatrix&&(r=t.filterWorldMatrix(e,r,s));return r}shouldShow(e,t){let s=t;for(const r of this.features)r.enabled&&r.shouldShow&&(s=r.shouldShow(e,t));return s}notifyUpdate(e){for(const t of this.features)t.enabled&&t.onUpdate&&t.onUpdate(e)}dispose(){for(const e of this.features)e.dispose&&e.dispose()}}

package/dist/core/features/one-euro-filter-feature.js

@@ -1,44 +1 @@
-import { OneEuroFilter } from "../../libs/one-euro-filter.js";
-export class OneEuroFilterFeature {
-    id = "one-euro-filter";
-    name = "One Euro Filter";
-    description = "Smooths the tracking matrix to reduce jitter using a One Euro Filter.";
-    enabled = true;
-    filters = [];
-    minCutOff;
-    beta;
-    constructor(minCutOff = 0.5, beta = 0.1) {
-        this.minCutOff = minCutOff;
-        this.beta = beta;
-    }
-    init(context) {
-        // We'll initialize filters lazily or based on target count if known
-    }
-    getFilter(targetIndex) {
-        if (!this.filters[targetIndex]) {
-            this.filters[targetIndex] = new OneEuroFilter({
-                minCutOff: this.minCutOff,
-                beta: this.beta
-            });
-        }
-        return this.filters[targetIndex];
-    }
-    filterWorldMatrix(targetIndex, worldMatrix, context) {
-        if (!this.enabled)
-            return worldMatrix;
-        const filter = this.getFilter(targetIndex);
-        const stability = context?.stability ?? 1.0;
-        // Dynamic Cutoff: If points are very stable (1.0), use higher cutoff (less responsiveness loss).
-        // If points are unstable (0.3), use much lower cutoff (heavy smoothing).
-        // We use a squared curve for even more aggressive suppression of jitter on unstable points.
-        const dynamicMinCutOff = this.minCutOff * (0.05 + Math.pow(stability, 2) * 0.95);
-        filter.minCutOff = dynamicMinCutOff;
-        filter.beta = this.beta;
-        return filter.filter(Date.now(), worldMatrix);
-    }
-    onUpdate(data) {
-        if (data.type === "reset" && data.targetIndex !== undefined) {
-            this.filters[data.targetIndex]?.reset();
-        }
-    }
-}
+import{OneEuroFilter as t}from"../../libs/one-euro-filter.js";export class OneEuroFilterFeature{id="one-euro-filter";name="One Euro Filter";description="Smooths the tracking matrix to reduce jitter using a One Euro Filter.";enabled=!0;filters=[];minCutOff;beta;constructor(t=.5,e=.1){this.minCutOff=t,this.beta=e}init(t){}getFilter(e){return this.filters[e]||(this.filters[e]=new t({minCutOff:this.minCutOff,beta:this.beta})),this.filters[e]}filterWorldMatrix(t,e,i){if(!this.enabled)return e;const r=this.getFilter(t),s=i?.stability??1,n=this.minCutOff*(.05+.95*Math.pow(s,2));return r.minCutOff=n,r.beta=this.beta,r.filter(Date.now(),e)}onUpdate(t){"reset"===t.type&&void 0!==t.targetIndex&&this.filters[t.targetIndex]?.reset()}}

package/dist/core/features/temporal-filter-feature.js

@@ -1,57 +1 @@
-export class TemporalFilterFeature {
-    id = "temporal-filter";
-    name = "Temporal Filter";
-    description = "Provides warmup tolerance (to avoid false positives) and miss tolerance (to maintain tracking during brief occlusions).";
-    enabled = true;
-    states = [];
-    warmupTolerance;
-    missTolerance;
-    onToggleShowing;
-    constructor(warmup = 2, miss = 5, onToggleShowing) {
-        this.warmupTolerance = warmup;
-        this.missTolerance = miss;
-        this.onToggleShowing = onToggleShowing;
-    }
-    getState(targetIndex) {
-        if (!this.states[targetIndex]) {
-            this.states[targetIndex] = {
-                showing: false,
-                trackCount: 0,
-                trackMiss: 0,
-            };
-        }
-        return this.states[targetIndex];
-    }
-    shouldShow(targetIndex, isTracking) {
-        if (!this.enabled)
-            return isTracking;
-        const state = this.getState(targetIndex);
-        if (!state.showing) {
-            if (isTracking) {
-                state.trackMiss = 0;
-                state.trackCount += 1;
-                if (state.trackCount > this.warmupTolerance) {
-                    state.showing = true;
-                    this.onToggleShowing?.(targetIndex, true);
-                }
-            }
-            else {
-                state.trackCount = 0;
-            }
-        }
-        else {
-            if (!isTracking) {
-                state.trackCount = 0;
-                state.trackMiss += 1;
-                if (state.trackMiss > this.missTolerance) {
-                    state.showing = false;
-                    this.onToggleShowing?.(targetIndex, false);
-                }
-            }
-            else {
-                state.trackMiss = 0;
-            }
-        }
-        return state.showing;
-    }
-}
+export class TemporalFilterFeature{id="temporal-filter";name="Temporal Filter";description="Provides warmup tolerance (to avoid false positives) and miss tolerance (to maintain tracking during brief occlusions).";enabled=!0;states=[];warmupTolerance;missTolerance;onToggleShowing;constructor(t=2,s=5,e){this.warmupTolerance=t,this.missTolerance=s,this.onToggleShowing=e}getState(t){return this.states[t]||(this.states[t]={showing:!1,trackCount:0,trackMiss:0}),this.states[t]}shouldShow(t,s){if(!this.enabled)return s;const e=this.getState(t);return e.showing?s?e.trackMiss=0:(e.trackCount=0,e.trackMiss+=1,e.trackMiss>this.missTolerance&&(e.showing=!1,this.onToggleShowing?.(t,!1))):s?(e.trackMiss=0,e.trackCount+=1,e.trackCount>this.warmupTolerance&&(e.showing=!0,this.onToggleShowing?.(t,!0))):e.trackCount=0,e.showing}}

package/dist/core/image-list.js

@@ -1,54 +1 @@
-import { resize } from "./utils/images.js";
-import { AR_CONFIG } from "./constants.js";
-/**
- * Tamaño mínimo de píxeles para el procesamiento de imágenes
- * Un valor más bajo permite detectar imágenes más pequeñas pero aumenta el tiempo de procesamiento
- * @constant {number}
- */
-const MIN_IMAGE_PIXEL_SIZE = AR_CONFIG.MIN_IMAGE_PIXEL_SIZE;
-/**
- * Construye una lista de imágenes con diferentes escalas para detección de características
- * @param {{width: number, height: number, data: any}} inputImage - Imagen de entrada con propiedades width, height y data
- * @returns {Array<{data: Uint8Array, width: number, height: number, scale: number}>} Lista de imágenes escaladas con propiedades data, width, height y scale
- */
-const buildImageList = (inputImage) => {
-    const minScale = MIN_IMAGE_PIXEL_SIZE / Math.min(inputImage.width, inputImage.height);
-    const scaleList = [];
-    let c = minScale;
-    while (true) {
-        scaleList.push(c);
-        // Optimization: Paso balanceado (aprox 1.5)
-        // Mejor cobertura que 2.0, pero mucho más ligero que 1.41 o 1.26
-        c *= Math.pow(2.0, AR_CONFIG.SCALE_STEP_EXPONENT);
-        if (c >= 0.95) {
-            c = 1;
-            break;
-        }
-    }
-    scaleList.push(c);
-    scaleList.reverse();
-    const imageList = [];
-    for (let i = 0; i < scaleList.length; i++) {
-        imageList.push(Object.assign(resize({ image: inputImage, ratio: scaleList[i] }), { scale: scaleList[i] }));
-    }
-    return imageList;
-};
-/**
- * Construye una lista optimizada de imágenes para tracking
- * Genera dos versiones escaladas (256px y 128px) para tracking eficiente
- * @param {{width: number, height: number, data: any}} inputImage - Imagen de entrada con propiedades width, height y data
- * @returns {Array<{data: Uint8Array, width: number, height: number, scale: number}>} Lista de imágenes escaladas para tracking
- */
-const buildTrackingImageList = (inputImage) => {
-    const minDimension = Math.min(inputImage.width, inputImage.height);
-    const scaleList = [];
-    const imageList = [];
-    // Generamos versiones de 256px y 128px para tracking robusto a diferentes distancias
-    scaleList.push(AR_CONFIG.TRACKING_DOWNSCALE_LEVEL_1 / minDimension);
-    scaleList.push(AR_CONFIG.TRACKING_DOWNSCALE_LEVEL_2 / minDimension);
-    for (let i = 0; i < scaleList.length; i++) {
-        imageList.push(Object.assign(resize({ image: inputImage, ratio: scaleList[i] }), { scale: scaleList[i] }));
-    }
-    return imageList;
-};
-export { buildImageList, buildTrackingImageList };
+import{resize as t}from"./utils/images.js";import{AR_CONFIG as s}from"./constants.js";const e=s.MIN_IMAGE_PIXEL_SIZE,h=h=>{const i=[];let r=e/Math.min(h.width,h.height);for(;;)if(i.push(r),r*=Math.pow(2,s.SCALE_STEP_EXPONENT),r>=.95){r=1;break}i.push(r),i.reverse();const o=[];for(let s=0;s<i.length;s++)o.push(Object.assign(t({image:h,ratio:i[s]}),{scale:i[s]}));return o},i=e=>{const h=Math.min(e.width,e.height),i=[],r=[];i.push(s.TRACKING_DOWNSCALE_LEVEL_1/h),i.push(s.TRACKING_DOWNSCALE_LEVEL_2/h);for(let s=0;s<i.length;s++)r.push(Object.assign(t({image:e,ratio:i[s]}),{scale:i[s]}));return r};export{h as buildImageList,i as buildTrackingImageList};

package/dist/core/input-loader.js

@@ -1,87 +1 @@
-/**
- * InputLoader - Maneja la carga de imágenes y video sin TensorFlow
- */
-class InputLoader {
-    constructor(width, height) {
-        this.width = width;
-        this.height = height;
-        this.grayscaleBuffer = new Uint8Array(width * height);
-        if (typeof document !== "undefined") {
-            const canvas = document.createElement("canvas");
-            canvas.width = width;
-            canvas.height = height;
-            this.context = canvas.getContext("2d", { willReadFrequently: true, alpha: false });
-        }
-    }
-    /**
-     * Carga una imagen o video y devuelve los datos en escala de grises
-     * @param {HTMLVideoElement|HTMLImageElement|ImageData|Uint8Array} input - La fuente de entrada
-     * @returns {Uint8Array} Datos de imagen en escala de grises (width * height)
-     */
-    loadInput(input) {
-        // Si ya es un Uint8Array de escala de grises, lo devolvemos
-        if (input instanceof Uint8Array && input.length === this.width * this.height) {
-            return input;
-        }
-        // Si es ImageData, convertimos a escala de grises directamente
-        if (typeof ImageData !== "undefined" && input instanceof ImageData) {
-            this._convertToGrayscale(input.data, input.width, input.height);
-            return this.grayscaleBuffer;
-        }
-        // En el navegador, usamos canvas para procesar video/imágenes
-        if (this.context) {
-            this.context.clearRect(0, 0, this.width, this.height);
-            const isInputRotated = input.width === this.height && input.height === this.width;
-            const inputW = isInputRotated ? input.height : input.width;
-            const inputH = isInputRotated ? input.width : input.height;
-            const inputAspect = inputW / inputH;
-            const canvasAspect = this.width / this.height;
-            let sx = 0, sy = 0, sw = inputW, sh = inputH;
-            if (inputAspect > canvasAspect) {
-                // Input is wider than canvas - crop sides
-                sw = inputH * canvasAspect;
-                sx = (inputW - sw) / 2;
-            }
-            else if (inputAspect < canvasAspect) {
-                // Input is taller than canvas - crop top/bottom
-                sh = inputW / canvasAspect;
-                sy = (inputH - sh) / 2;
-            }
-            if (isInputRotated) {
-                this.context.save();
-                this.context.translate(this.width / 2, this.height / 2);
-                this.context.rotate(Math.PI / 2);
-                // Map source crop (relative to rotated input)
-                // Since input is already rotated, we crop based on the rotated dimensions
-                this.context.drawImage(input, sx, sy, sw, sh, -this.height / 2, -this.width / 2, this.height, this.width);
-                this.context.restore();
-            }
-            else {
-                this.context.drawImage(input, sx, sy, sw, sh, 0, 0, this.width, this.height);
-            }
-            const imageData = this.context.getImageData(0, 0, this.width, this.height);
-            this._convertToGrayscale(imageData.data, this.width, this.height);
-            return this.grayscaleBuffer;
-        }
-        // Fallback para Node.js o entornos sin DOM
-        if (input.data && input.data instanceof Uint8Array) {
-            this._convertToGrayscale(input.data, input.width || this.width, input.height || this.height);
-            return this.grayscaleBuffer;
-        }
-        throw new Error("Input no soportado o entorno sin Canvas");
-    }
-    /**
-     * Convierte datos RGBA a escala de grises optimizada (reutilizando buffer)
-     */
-    _convertToGrayscale(rgbaData, width, height) {
-        const grayscale = this.grayscaleBuffer;
-        const len = (width * height);
-        // Optimized loop with bitwise ops
-        for (let i = 0; i < len; i++) {
-            const offset = i << 2;
-            // Formula de luminosidad estándar: 0.299R + 0.587G + 0.114B (scaled by 256)
-            grayscale[i] = (rgbaData[offset] * 77 + rgbaData[offset + 1] * 150 + rgbaData[offset + 2] * 29) >> 8;
-        }
-    }
-}
-export { InputLoader };
+class t{constructor(t,h){if(this.width=t,this.height=h,this.grayscaleBuffer=new Uint8Array(t*h),"undefined"!=typeof document){const i=document.createElement("canvas");i.width=t,i.height=h,this.context=i.getContext("2d",{willReadFrequently:!0,alpha:!1})}}loadInput(t){if(t instanceof Uint8Array&&t.length===this.width*this.height)return t;if("undefined"!=typeof ImageData&&t instanceof ImageData)return this._convertToGrayscale(t.data,t.width,t.height),this.grayscaleBuffer;if(this.context){this.context.clearRect(0,0,this.width,this.height);const h=t.width===this.height&&t.height===this.width,i=h?t.height:t.width,e=h?t.width:t.height,s=i/e,a=this.width/this.height;let n=0,r=0,o=i,c=e;s>a?(o=e*a,n=(i-o)/2):s<a&&(c=i/a,r=(e-c)/2),h?(this.context.save(),this.context.translate(this.width/2,this.height/2),this.context.rotate(Math.PI/2),this.context.drawImage(t,n,r,o,c,-this.height/2,-this.width/2,this.height,this.width),this.context.restore()):this.context.drawImage(t,n,r,o,c,0,0,this.width,this.height);const d=this.context.getImageData(0,0,this.width,this.height);return this._convertToGrayscale(d.data,this.width,this.height),this.grayscaleBuffer}if(t.data&&t.data instanceof Uint8Array)return this._convertToGrayscale(t.data,t.width||this.width,t.height||this.height),this.grayscaleBuffer;throw new Error("Input no soportado o entorno sin Canvas")}_convertToGrayscale(t,h,i){const e=this.grayscaleBuffer,s=h*i;for(let h=0;h<s;h++){const i=h<<2;e[h]=77*t[i]+150*t[i+1]+29*t[i+2]>>8}}}export{t as InputLoader};

package/dist/core/matching/hamming-distance.js

@@ -1,66 +1 @@
-// Precomputed bit count lookup table for Uint8Array
-const BIT_COUNT_8 = new Uint8Array(256);
-for (let i = 0; i < 256; i++) {
-    let c = 0, n = i;
-    while (n > 0) {
-        n &= (n - 1);
-        c++;
-    }
-    BIT_COUNT_8[i] = c;
-}
-/**
- * 🚀 Moonshot Optimized Popcount
- * Uses a slightly faster bitwise sequence for 32-bit integers
- */
-function popcount32(n) {
-    n = n >>> 0; // Force unsigned
-    n -= (n >>> 1) & 0x55555555;
-    n = (n & 0x33333333) + ((n >>> 2) & 0x33333333);
-    return (((n + (n >>> 4)) & 0x0F0F0F0F) * 0x01010101) >>> 24;
-}
-/**
- * Super-optimized Hamming distance for 64-bit LSH (2x Uint32)
- * NO OBJECTS, NO OPTIONS, JUST PURE SPEED.
- */
-const compute64 = (v1, v1Idx, v2, v2Idx) => {
-    // Inline XOR and popcount for maximum speed
-    let x1 = (v1[v1Idx] ^ v2[v2Idx]) >>> 0;
-    let x2 = (v1[v1Idx + 1] ^ v2[v2Idx + 1]) >>> 0;
-    // Popcount 1
-    x1 -= (x1 >>> 1) & 0x55555555;
-    x1 = (x1 & 0x33333333) + ((x1 >>> 2) & 0x33333333);
-    const count1 = (((x1 + (x1 >>> 4)) & 0x0F0F0F0F) * 0x01010101) >>> 24;
-    // Popcount 2
-    x2 -= (x2 >>> 1) & 0x55555555;
-    x2 = (x2 & 0x33333333) + ((x2 >>> 2) & 0x33333333);
-    const count2 = (((x2 + (x2 >>> 4)) & 0x0F0F0F0F) * 0x01010101) >>> 24;
-    return count1 + count2;
-};
-/**
- * Generic compute for backward compatibility
- */
-const compute = (options) => {
-    const { v1, v2, v1Offset = 0, v2Offset = 0 } = options;
-    const v2Len = v2.length - v2Offset;
-    if (v2Len === 2) {
-        return compute64(v1, v1Offset, v2, v2Offset);
-    }
-    // Protocol V4: 84-byte descriptors (Uint8Array)
-    if (v2Len === 84) {
-        let d = 0;
-        for (let i = 0; i < 84; i++) {
-            d += BIT_COUNT_8[v1[v1Offset + i] ^ v2[v2Offset + i]];
-        }
-        return d;
-    }
-    // Protocol V5.1: 128-bit LSH (4 x Uint32)
-    if (v2Len === 4) {
-        return popcount32(v1[v1Offset] ^ v2[v2Offset]) +
-            popcount32(v1[v1Offset + 1] ^ v2[v2Offset + 1]) +
-            popcount32(v1[v1Offset + 2] ^ v2[v2Offset + 2]) +
-            popcount32(v1[v1Offset + 3] ^ v2[v2Offset + 3]);
-    }
-    return popcount32(v1[v1Offset] ^ v2[v2Offset]) +
-        popcount32(v1[v1Offset + 1] ^ v2[v2Offset + 1]);
-};
-export { compute, compute64 };
+const t=new Uint8Array(256);for(let r=0;r<256;r++){let e=0,n=r;for(;n>0;)n&=n-1,e++;t[r]=e}function r(t){return t>>>=0,16843009*((t=(858993459&(t-=t>>>1&1431655765))+(t>>>2&858993459))+(t>>>4)&252645135)>>>24}const e=(t,r,e,n)=>{let f=(t[r]^e[n])>>>0,o=(t[r+1]^e[n+1])>>>0;return f-=f>>>1&1431655765,f=(858993459&f)+(f>>>2&858993459),o-=o>>>1&1431655765,o=(858993459&o)+(o>>>2&858993459),(16843009*(f+(f>>>4)&252645135)>>>24)+(16843009*(o+(o>>>4)&252645135)>>>24)},n=n=>{const{v1:f,v2:o,v1Offset:l=0,v2Offset:u=0}=n,s=o.length-u;if(2===s)return e(f,l,o,u);if(84===s){let r=0;for(let e=0;e<84;e++)r+=t[f[l+e]^o[u+e]];return r}return 4===s?r(f[l]^o[u])+r(f[l+1]^o[u+1])+r(f[l+2]^o[u+2])+r(f[l+3]^o[u+3]):r(f[l]^o[u])+r(f[l+1]^o[u+1])};export{n as compute,e as compute64};

package/dist/core/matching/hdc.js

@@ -1,102 +1 @@
-/**
- * Hyperdimensional Computing (HDC) Core for AR
- *
- * Provides ultra-fast, ultra-compressed feature matching using
- * High-Dimensional Random Vectors.
- */
-export const HDC_DIMENSION = 1024; // bits
-export const HDC_WORDS = HDC_DIMENSION / 32;
-/**
- * Deterministic Random Number Generator (PCG-like)
- */
-class PRNG {
-    state;
-    constructor(seed) {
-        this.state = seed;
-    }
-    next() {
-        this.state = (this.state * 1664525 + 1013904223) >>> 0;
-        return this.state / 0xFFFFFFFF;
-    }
-}
-/**
- * Generates a deterministic basis of Hypervectors
- */
-export function generateBasis(seed, count) {
-    const prng = new PRNG(seed);
-    const basis = [];
-    for (let i = 0; i < count; i++) {
-        const hv = new Uint32Array(HDC_WORDS);
-        for (let j = 0; j < HDC_WORDS; j++) {
-            hv[j] = (prng.next() * 0xFFFFFFFF) >>> 0;
-        }
-        basis.push(hv);
-    }
-    return basis;
-}
-/**
- * Projects a 64-bit descriptor into the Hyperdimensional Space
- * Uses "Random Projection" logic (Locality Sensitive Hashing in HDC)
- */
-export function projectDescriptor(desc, basis) {
-    const result = new Uint32Array(HDC_WORDS);
-    // For each bit in the HDC space
-    for (let i = 0; i < HDC_DIMENSION; i++) {
-        const wordIdx = i >>> 5;
-        const bitIdx = i & 31;
-        // This is a simplified random projection
-        // In a real HDC system, we'd use more complex binding
-        // But for Vanilla JS performance, we use bitwise voting
-        let sum = 0;
-        const b = basis[i % basis.length];
-        // Dot product between descriptor and basis vector (subset)
-        // desc[0] and desc[1] are the 64 bits
-        for (let j = 0; j < 2; j++) {
-            sum += popcount(desc[j] & b[j]);
-        }
-        if (sum > 16) { // Threshold for "firing"
-            result[wordIdx] |= (1 << bitIdx);
-        }
-    }
-    return result;
-}
-/**
- * Compresses an HDC vector into an "Ultra-Short Signature" (32 bits)
- * This allows storing 1000 points in just 4KB of descriptors.
- */
-export function compressToSignature(hv) {
-    // FNV-1a Hash for robust 32-bit compression
-    let h1 = 0x811c9dc5;
-    for (let i = 0; i < hv.length; i++) {
-        h1 ^= hv[i];
-        h1 = Math.imul(h1, 0x01000193);
-    }
-    return h1 >>> 0;
-}
-function popcount(n) {
-    n = n - ((n >> 1) & 0x55555555);
-    n = (n & 0x33333333) + ((n >> 2) & 0x33333333);
-    return (((n + (n >> 4)) & 0x0F0F0F0F) * 0x01010101) >> 24;
-}
-/**
- * Bundles multiple points into a single Global Hypervector (The "Image DNA")
- * This allows checking if an image is present with ONE vector comparison.
- */
-export function bundle(hvs) {
-    const global = new Uint32Array(HDC_WORDS);
-    const threshold = hvs.length / 2;
-    const counters = new Uint16Array(HDC_DIMENSION);
-    for (const hv of hvs) {
-        for (let i = 0; i < HDC_DIMENSION; i++) {
-            if (hv[i >>> 5] & (1 << (i & 31))) {
-                counters[i]++;
-            }
-        }
-    }
-    for (let i = 0; i < HDC_DIMENSION; i++) {
-        if (counters[i] > threshold) {
-            global[i >>> 5] |= (1 << (i & 31));
-        }
-    }
-    return global;
-}
+export const HDC_DIMENSION=1024;export const HDC_WORDS=32;class t{state;constructor(t){this.state=t}next(){return this.state=1664525*this.state+1013904223>>>0,this.state/4294967295}}export function generateBasis(e,n){const r=new t(e),o=[];for(let t=0;t<n;t++){const t=new Uint32Array(32);for(let e=0;e<32;e++)t[e]=4294967295*r.next()>>>0;o.push(t)}return o}export function projectDescriptor(t,n){const r=new Uint32Array(32);for(let o=0;o<1024;o++){const s=o>>>5,c=31&o;let i=0;const u=n[o%n.length];for(let n=0;n<2;n++)i+=e(t[n]&u[n]);i>16&&(r[s]|=1<<c)}return r}export function compressToSignature(t){let e=2166136261;for(let n=0;n<t.length;n++)e^=t[n],e=Math.imul(e,16777619);return e>>>0}function e(t){return 16843009*((t=(858993459&(t-=t>>1&1431655765))+(t>>2&858993459))+(t>>4)&252645135)>>24}export function bundle(t){const e=new Uint32Array(32),n=t.length/2,r=new Uint16Array(1024);for(const e of t)for(let t=0;t<1024;t++)e[t>>>5]&1<<(31&t)&&r[t]++;for(let t=0;t<1024;t++)r[t]>n&&(e[t>>>5]|=1<<(31&t));return e}