@srsergio/taptapp-ar 1.1.1 → 1.1.3

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

@@ -1,455 +1 @@
-/**
- * Detector Lite - Pure JavaScript Feature Detector
- *
- * Un detector de características simplificado que no depende de TensorFlow.
- * Optimizado para velocidad en compilación offline.
- *
- * Implementa:
- * - Construcción de pirámide gaussiana (con aceleración GPU opcional)
- * - Diferencia de Gaussianas (DoG) para detección de extremos
- * - Descriptores FREAK simplificados
- */
-import { FREAKPOINTS } from "./freak.js";
-import { gpuCompute } from "../utils/gpu-compute.js";
-import { computeLSH64, computeFullFREAK, packLSHIntoDescriptor } from "../utils/lsh-direct.js";
-import { HDC_SEED } from "../protocol.js";
-const PYRAMID_MIN_SIZE = 4; // Restored to 4 for better small-scale detection
-// PYRAMID_MAX_OCTAVE ya no es necesario, el límite lo da PYRAMID_MIN_SIZE
-const NUM_BUCKETS_PER_DIMENSION = 15; // Increased from 10 to 15 for better local detail
-const DEFAULT_MAX_FEATURES_PER_BUCKET = 12; // Increased from 8 to 12
-const ORIENTATION_NUM_BINS = 36;
-const FREAK_EXPANSION_FACTOR = 7.0;
-// Global GPU mode flag
-let globalUseGPU = true;
-/**
- * Set global GPU mode for all DetectorLite instances
- * @param {boolean} enabled - Whether to use GPU acceleration
- */
-export const setDetectorGPUMode = (enabled) => {
-    globalUseGPU = enabled;
-};
-/**
- * Detector de características sin TensorFlow
- */
-export class DetectorLite {
-    constructor(width, height, options = {}) {
-        this.width = width;
-        this.height = height;
-        this.useGPU = options.useGPU !== undefined ? options.useGPU : globalUseGPU;
-        // Protocol V6 (Moonshot): 64-bit LSH is the standard descriptor format
-        this.useLSH = options.useLSH !== undefined ? options.useLSH : true;
-        this.useHDC = options.useHDC !== undefined ? options.useHDC : true; // Enabled by default for Moonshot
-        this.maxFeaturesPerBucket = options.maxFeaturesPerBucket !== undefined ? options.maxFeaturesPerBucket : DEFAULT_MAX_FEATURES_PER_BUCKET;
-        let numOctaves = 0;
-        let w = width, h = height;
-        while (w >= PYRAMID_MIN_SIZE && h >= PYRAMID_MIN_SIZE) {
-            w = Math.floor(w / 2);
-            h = Math.floor(h / 2);
-            numOctaves++;
-            // Límite de seguridad razonable para evitar bucles infinitos en imágenes gigantes
-            if (numOctaves === 10)
-                break;
-        }
-        this.numOctaves = options.maxOctaves !== undefined ? Math.min(numOctaves, options.maxOctaves) : numOctaves;
-    }
-    /**
-     * Detecta características en una imagen en escala de grises
-     * @param {Float32Array|Uint8Array} imageData - Datos de imagen (width * height)
-     * @param {Object} options - Opciones de detección (ej. octavesToProcess)
-     * @returns {{featurePoints: Array}} Puntos de características detectados
-     */
-    detect(imageData, options = {}) {
-        const octavesToProcess = options.octavesToProcess || Array.from({ length: this.numOctaves }, (_, i) => i);
-        // Normalizar a Float32Array si es necesario
-        let data;
-        if (imageData instanceof Float32Array) {
-            data = imageData;
-        }
-        else {
-            data = new Float32Array(imageData.length);
-            for (let i = 0; i < imageData.length; i++) {
-                data[i] = imageData[i];
-            }
-        }
-        // 1. Construir pirámide gaussiana (solo octavas solicitadas)
-        const pyramidImages = this._buildGaussianPyramid(data, this.width, this.height, octavesToProcess);
-        // 2. Construir pirámide DoG (Difference of Gaussians)
-        const dogPyramid = this._buildDogPyramid(pyramidImages, octavesToProcess);
-        // 3. Encontrar extremos locales
-        const extremas = this._findExtremas(dogPyramid, pyramidImages);
-        // 4. Aplicar pruning por buckets
-        const prunedExtremas = this._applyPrune(extremas);
-        // 5. Calcular orientaciones
-        this._computeOrientations(prunedExtremas, pyramidImages);
-        // 6. Calcular descriptores FREAK
-        this._computeFreakDescriptors(prunedExtremas, pyramidImages);
-        // Convertir a formato de salida
-        const featurePoints = prunedExtremas.map(ext => {
-            const scale = Math.pow(2, ext.octave);
-            return {
-                maxima: ext.score > 0,
-                x: ext.x * scale + scale * 0.5 - 0.5,
-                y: ext.y * scale + scale * 0.5 - 0.5,
-                scale: scale,
-                angle: ext.angle || 0,
-                score: ext.absScore, // Pass through score for sorting in Matcher
-                descriptors: (this.useLSH && ext.lsh) ? ext.lsh : (ext.descriptors || []),
-                imageData: data // Pass source image for refinement
-            };
-        });
-        return { featurePoints, pyramid: pyramidImages };
-    }
-    /**
-     * Construye una pirámide gaussiana
-     */
-    _buildGaussianPyramid(data, width, height, octavesToProcess = null) {
-        // Use GPU-accelerated pyramid if available
-        if (this.useGPU) {
-            try {
-                const gpuPyramid = gpuCompute.buildPyramid(data, width, height, this.numOctaves);
-                // Convert GPU pyramid format to expected format
-                const pyramid = [];
-                for (let i = 0; i < gpuPyramid.length && i < this.numOctaves; i++) {
-                    if (octavesToProcess && !octavesToProcess.includes(i)) {
-                        pyramid.push(null);
-                        continue;
-                    }
-                    const level = gpuPyramid[i];
-                    // Apply second blur for DoG computation
-                    const img2 = this._applyGaussianFilter(level.data, level.width, level.height);
-                    pyramid.push([
-                        { data: level.data, width: level.width, height: level.height },
-                        { data: img2.data, width: level.width, height: level.height }
-                    ]);
-                }
-                return pyramid;
-            }
-            catch (e) {
-                // Fall back to CPU if GPU fails
-                console.warn("GPU pyramid failed, falling back to CPU:", e.message);
-            }
-        }
-        // Buffer management: Reuse arrays if dimensions match to reduce GC
-        if (!this._pyramidBuffers || this._pyramidBuffers.width !== width || this._pyramidBuffers.height !== height) {
-            this._pyramidBuffers = { width, height, temp: new Float32Array(width * height) };
-        }
-        const pyramid = [];
-        let currentData = data;
-        let currentWidth = width;
-        let currentHeight = height;
-        for (let i = 0; i < this.numOctaves; i++) {
-            const shouldProcess = !octavesToProcess || octavesToProcess.includes(i);
-            if (shouldProcess) {
-                const img1 = this._applyGaussianFilter(currentData, currentWidth, currentHeight);
-                const img2 = this._applyGaussianFilter(img1.data, currentWidth, currentHeight);
-                pyramid.push([
-                    { data: img1.data, width: currentWidth, height: currentHeight },
-                    { data: img2.data, width: currentWidth, height: currentHeight }
-                ]);
-            }
-            else {
-                pyramid.push(null);
-            }
-            if (i < this.numOctaves - 1) {
-                // For CPU downsampling, we STILL need to downsample even if we skip processing the current octave
-                // UNLESS the next octave is also skipped. But for simplicity and safety, we downsample if needed by ANY future octave.
-                const needsDownsample = !octavesToProcess || octavesToProcess.some(o => o > i);
-                if (needsDownsample) {
-                    // If current octave was processed, we use img1.data (or original data if i=0 and not processed?). 
-                    // Wait, standard is to downsample from the blurred image of previous octave.
-                    const sourceData = shouldProcess ? pyramid[i][0].data : currentData;
-                    const downsampled = this._downsample(sourceData, currentWidth, currentHeight);
-                    currentData = downsampled.data;
-                    currentWidth = downsampled.width;
-                    currentHeight = downsampled.height;
-                }
-                else {
-                    // Optimization: if no more octaves are needed, we can stop here
-                    break;
-                }
-            }
-        }
-        return pyramid;
-    }
-    /**
-     * Aplica un filtro gaussiano binomial [1,4,6,4,1] - Optimizado
-     */
-    _applyGaussianFilter(data, width, height) {
-        const output = new Float32Array(width * height);
-        const temp = this._pyramidBuffers?.temp || new Float32Array(width * height);
-        const k0 = 0.0625, k1 = 0.25, k2 = 0.375; // 1/16, 4/16, 6/16
-        const w1 = width - 1;
-        // Horizontal pass - Speed optimized with manual border handling
-        for (let y = 0; y < height; y++) {
-            const rowOffset = y * width;
-            // Left border (Normalized)
-            const sumL0 = k0 + k1 + k2 + k1 + k0; // Ideal sum
-            temp[rowOffset] = (data[rowOffset] * (k0 + k1 + k2) + data[rowOffset + 1] * k1 + data[rowOffset + 2] * k0) * (1.0 / (k0 + k1 + k2));
-            temp[rowOffset + 1] = (data[rowOffset] * k1 + data[rowOffset + 1] * k2 + data[rowOffset + 2] * k1 + data[rowOffset + 3] * k0) * (1.0 / (k1 + k2 + k1 + k0));
-            // Main loop - NO boundary checks
-            for (let x = 2; x < width - 2; x++) {
-                const pos = rowOffset + x;
-                temp[pos] = data[pos - 2] * k0 + data[pos - 1] * k1 + data[pos] * k2 + data[pos + 1] * k1 + data[pos + 2] * k0;
-            }
-            // Right border (Normalized)
-            const r2 = rowOffset + width - 2;
-            const r1 = rowOffset + width - 1;
-            temp[r2] = (data[r2 - 2] * k0 + data[r2 - 1] * k1 + data[r2] * k2 + data[r1] * k1) * (1.0 / (k0 + k1 + k2 + k1));
-            temp[r1] = (data[r1 - 2] * k0 + data[r1 - 1] * k1 + data[r1] * (k2 + k1 + k0)) * (1.0 / (k0 + k1 + k2));
-        }
-        // Vertical pass - Speed optimized
-        for (let x = 0; x < width; x++) {
-            // Top border (Normalized)
-            output[x] = (temp[x] * (k0 + k1 + k2) + temp[x + width] * k1 + temp[x + width * 2] * k0) * (1.0 / (k0 + k1 + k2));
-            output[x + width] = (temp[x] * k1 + temp[x + width] * k2 + temp[x + width * 2] * k1 + temp[x + width * 3] * k0) * (1.0 / (k1 + k2 + k1 + k0));
-            // Main loop - NO boundary checks
-            for (let y = 2; y < height - 2; y++) {
-                const p = y * width + x;
-                output[p] = temp[p - width * 2] * k0 + temp[p - width] * k1 + temp[p] * k2 + temp[p + width] * k1 + temp[p + width * 2] * k0;
-            }
-            // Bottom border (Normalized)
-            const b2 = (height - 2) * width + x;
-            const b1 = (height - 1) * width + x;
-            output[b2] = (temp[b2 - width * 2] * k0 + temp[b2 - width] * k1 + temp[b2] * k2 + temp[b1] * k1) * (1.0 / (k0 + k1 + k2 + k1));
-            output[b1] = (temp[b1 - width * 2] * k0 + temp[b1 - width] * k1 + temp[b1] * (k2 + k1 + k0)) * (1.0 / (k0 + k1 + k2));
-        }
-        return { data: output, width, height };
-    }
-    /**
-     * Downsample imagen por factor de 2
-     */
-    _downsample(data, width, height) {
-        const newWidth = width >> 1;
-        const newHeight = height >> 1;
-        const output = new Float32Array(newWidth * newHeight);
-        for (let y = 0; y < newHeight; y++) {
-            const r0 = (y * 2) * width;
-            const r1 = r0 + width;
-            const dr = y * newWidth;
-            for (let x = 0; x < newWidth; x++) {
-                const i2 = x * 2;
-                output[dr + x] = (data[r0 + i2] + data[r0 + i2 + 1] + data[r1 + i2] + data[r1 + i2 + 1]) * 0.25;
-            }
-        }
-        return { data: output, width: newWidth, height: newHeight };
-    }
-    /**
-     * Construye pirámide de diferencia de gaussianas
-     */
-    _buildDogPyramid(pyramidImages, octavesToProcess = null) {
-        const dogPyramid = [];
-        for (let i = 0; i < pyramidImages.length; i++) {
-            if (!pyramidImages[i]) {
-                dogPyramid.push(null);
-                continue;
-            }
-            const img1 = pyramidImages[i][0];
-            const img2 = pyramidImages[i][1];
-            const width = img1.width;
-            const height = img1.height;
-            const dog = new Float32Array(width * height);
-            for (let j = 0; j < dog.length; j++) {
-                dog[j] = img2.data[j] - img1.data[j];
-            }
-            dogPyramid.push({ data: dog, width, height });
-        }
-        return dogPyramid;
-    }
-    /**
-     * Encuentra extremos locales en la pirámide DoG
-     */
-    _findExtremas(dogPyramid, pyramidImages) {
-        const extremas = [];
-        for (let octave = 0; octave < dogPyramid.length; octave++) {
-            const curr = dogPyramid[octave];
-            if (!curr)
-                continue;
-            const prev = octave > 0 ? dogPyramid[octave - 1] : null;
-            const next = octave < dogPyramid.length - 1 ? dogPyramid[octave + 1] : null;
-            const width = curr.width;
-            const height = curr.height;
-            for (let y = 1; y < height - 1; y++) {
-                for (let x = 1; x < width - 1; x++) {
-                    const val = curr.data[y * width + x];
-                    if (Math.abs(val) < 0.003)
-                        continue; // Aggressively lowered threshold to 0.003 for max sensitivity
-                    let isMaxima = true;
-                    let isMinima = true;
-                    // Check 3x3 neighborhood in current scale
-                    for (let dy = -1; dy <= 1 && (isMaxima || isMinima); dy++) {
-                        for (let dx = -1; dx <= 1 && (isMaxima || isMinima); dx++) {
-                            if (dx === 0 && dy === 0)
-                                continue;
-                            const neighbor = curr.data[(y + dy) * width + (x + dx)];
-                            if (neighbor >= val)
-                                isMaxima = false;
-                            if (neighbor <= val)
-                                isMinima = false;
-                        }
-                    }
-                    // Check previous scale (scaled coordinates) - skip if no prev layer
-                    if ((isMaxima || isMinima) && prev) {
-                        const px = x << 1;
-                        const py = y << 1;
-                        const prevWidth = prev.width;
-                        for (let dy = -1; dy <= 1 && (isMaxima || isMinima); dy++) {
-                            for (let dx = -1; dx <= 1 && (isMaxima || isMinima); dx++) {
-                                const xx = Math.max(0, Math.min(prevWidth - 1, px + dx));
-                                const yy = Math.max(0, Math.min(prev.height - 1, py + dy));
-                                const neighbor = prev.data[yy * prevWidth + xx];
-                                if (neighbor >= val)
-                                    isMaxima = false;
-                                if (neighbor <= val)
-                                    isMinima = false;
-                            }
-                        }
-                    }
-                    // Check next scale (scaled coordinates) - skip if no next layer
-                    if ((isMaxima || isMinima) && next) {
-                        const nx = x >> 1;
-                        const ny = y >> 1;
-                        const nextWidth = next.width;
-                        for (let dy = -1; dy <= 1 && (isMaxima || isMinima); dy++) {
-                            for (let dx = -1; dx <= 1 && (isMaxima || isMinima); dx++) {
-                                const xx = Math.max(0, Math.min(nextWidth - 1, nx + dx));
-                                const yy = Math.max(0, Math.min(next.height - 1, ny + dy));
-                                const neighbor = next.data[yy * nextWidth + xx];
-                                if (neighbor >= val)
-                                    isMaxima = false;
-                                if (neighbor <= val)
-                                    isMinima = false;
-                            }
-                        }
-                    }
-                    if (isMaxima || isMinima) {
-                        extremas.push({
-                            score: isMaxima ? Math.abs(val) : -Math.abs(val),
-                            octave,
-                            x,
-                            y,
-                            absScore: Math.abs(val)
-                        });
-                    }
-                }
-            }
-        }
-        return extremas;
-    }
-    /**
-     * Aplica pruning para mantener solo los mejores features por bucket
-     */
-    _applyPrune(extremas) {
-        const nBuckets = NUM_BUCKETS_PER_DIMENSION;
-        const nFeatures = this.maxFeaturesPerBucket;
-        // Agrupar por buckets
-        const buckets = [];
-        for (let i = 0; i < nBuckets * nBuckets; i++) {
-            buckets.push([]);
-        }
-        for (const ext of extremas) {
-            const bucketX = Math.min(nBuckets - 1, Math.floor(ext.x / (this.width / Math.pow(2, ext.octave)) * nBuckets));
-            const bucketY = Math.min(nBuckets - 1, Math.floor(ext.y / (this.height / Math.pow(2, ext.octave)) * nBuckets));
-            const bucketIdx = bucketY * nBuckets + bucketX;
-            if (bucketIdx >= 0 && bucketIdx < buckets.length) {
-                buckets[bucketIdx].push(ext);
-            }
-        }
-        // Seleccionar top features por bucket
-        const result = [];
-        for (const bucket of buckets) {
-            bucket.sort((a, b) => b.absScore - a.absScore);
-            for (let i = 0; i < Math.min(nFeatures, bucket.length); i++) {
-                result.push(bucket[i]);
-            }
-        }
-        return result;
-    }
-    /**
-     * Calcula la orientación de cada feature
-     */
-    _computeOrientations(extremas, pyramidImages) {
-        for (const ext of extremas) {
-            if (ext.octave < 0 || ext.octave >= pyramidImages.length) {
-                ext.angle = 0;
-                continue;
-            }
-            const img = pyramidImages[ext.octave][1];
-            const width = img.width;
-            const height = img.height;
-            const data = img.data;
-            const x = Math.floor(ext.x);
-            const y = Math.floor(ext.y);
-            // Compute gradient histogram
-            const histogram = new Float32Array(ORIENTATION_NUM_BINS);
-            const radius = 4;
-            for (let dy = -radius; dy <= radius; dy++) {
-                for (let dx = -radius; dx <= radius; dx++) {
-                    const yy = y + dy;
-                    const xx = x + dx;
-                    if (yy <= 0 || yy >= height - 1 || xx <= 0 || xx >= width - 1)
-                        continue;
-                    const gradY = data[(yy + 1) * width + xx] - data[(yy - 1) * width + xx];
-                    const gradX = data[yy * width + xx + 1] - data[yy * width + xx - 1];
-                    const mag = Math.sqrt(gradX * gradX + gradY * gradY);
-                    const angle = Math.atan2(gradY, gradX) + Math.PI; // 0 to 2*PI
-                    const bin = Math.floor(angle / (2 * Math.PI) * ORIENTATION_NUM_BINS) % ORIENTATION_NUM_BINS;
-                    const weight = Math.exp(-(dx * dx + dy * dy) / (2 * radius * radius));
-                    histogram[bin] += mag * weight;
-                }
-            }
-            // Find peak
-            let maxBin = 0;
-            for (let i = 1; i < ORIENTATION_NUM_BINS; i++) {
-                if (histogram[i] > histogram[maxBin]) {
-                    maxBin = i;
-                }
-            }
-            ext.angle = (maxBin + 0.5) * 2 * Math.PI / ORIENTATION_NUM_BINS - Math.PI;
-        }
-    }
-    /**
-     * Calcula descriptores FREAK
-     */
-    _computeFreakDescriptors(extremas, pyramidImages) {
-        for (const ext of extremas) {
-            if (ext.octave < 0 || ext.octave >= pyramidImages.length) {
-                ext.descriptors = new Uint8Array(8);
-                continue;
-            }
-            const img = pyramidImages[ext.octave][1];
-            const width = img.width;
-            const height = img.height;
-            const data = img.data;
-            const cos = Math.cos(ext.angle || 0) * FREAK_EXPANSION_FACTOR;
-            const sin = Math.sin(ext.angle || 0) * FREAK_EXPANSION_FACTOR;
-            // Sample FREAK points
-            const samples = new Float32Array(FREAKPOINTS.length);
-            for (let i = 0; i < FREAKPOINTS.length; i++) {
-                const [, fx, fy] = FREAKPOINTS[i];
-                const xp = ext.x + fx * cos - fy * sin;
-                const yp = ext.y + fx * sin + fy * cos;
-                const x0 = Math.max(0, Math.min(width - 2, Math.floor(xp)));
-                const y0 = Math.max(0, Math.min(height - 2, Math.floor(yp)));
-                const x1 = x0 + 1;
-                const y1 = y0 + 1;
-                const fracX = xp - x0;
-                const fracY = yp - y0;
-                samples[i] =
-                    data[y0 * width + x0] * (1 - fracX) * (1 - fracY) +
-                        data[y0 * width + x1] * fracX * (1 - fracY) +
-                        data[y1 * width + x0] * (1 - fracX) * fracY +
-                        data[y1 * width + x1] * fracX * fracY;
-            }
-            // 🚀 MOONSHOT: Direct LSH computation
-            // Avoids computing 672 bits of FREAK just to sample 64.
-            if (this.useLSH) {
-                ext.lsh = computeLSH64(samples);
-                // Pack LSH into 8-byte descriptors for compatibility
-                ext.descriptors = packLSHIntoDescriptor(ext.lsh);
-            }
-            else {
-                ext.descriptors = computeFullFREAK(samples);
-            }
-        }
-    }
-}
+import{FREAKPOINTS as t}from"./freak.js";import{gpuCompute as e}from"../utils/gpu-compute.js";import{computeLSH64 as a,computeFullFREAK as s,packLSHIntoDescriptor as o}from"../utils/lsh-direct.js";import{HDC_SEED as i}from"../protocol.js";let h=!0;export const setDetectorGPUMode=t=>{h=t};export class DetectorLite{constructor(t,e,a={}){this.width=t,this.height=e,this.useGPU=void 0!==a.useGPU?a.useGPU:h,this.useLSH=void 0===a.useLSH||a.useLSH,this.useHDC=void 0===a.useHDC||a.useHDC,this.maxFeaturesPerBucket=void 0!==a.maxFeaturesPerBucket?a.maxFeaturesPerBucket:12;let s=0,o=t,i=e;for(;o>=4&&i>=4&&(o=Math.floor(o/2),i=Math.floor(i/2),s++,10!==s););this.numOctaves=void 0!==a.maxOctaves?Math.min(s,a.maxOctaves):s}detect(t,e={}){const a=e.octavesToProcess||Array.from({length:this.numOctaves},(t,e)=>e);let s;if(t instanceof Float32Array)s=t;else{s=new Float32Array(t.length);for(let e=0;e<t.length;e++)s[e]=t[e]}const o=this._buildGaussianPyramid(s,this.width,this.height,a),i=this._buildDogPyramid(o,a),h=this._findExtremas(i,o),r=this._applyPrune(h);return this._computeOrientations(r,o),this._computeFreakDescriptors(r,o),{featurePoints:r.map(t=>{const e=Math.pow(2,t.octave);return{maxima:t.score>0,x:t.x*e+.5*e-.5,y:t.y*e+.5*e-.5,scale:e,angle:t.angle||0,score:t.absScore,descriptors:this.useLSH&&t.lsh?t.lsh:t.descriptors||[],imageData:s}}),pyramid:o}}_buildGaussianPyramid(t,a,s,o=null){if(this.useGPU)try{const i=e.buildPyramid(t,a,s,this.numOctaves),h=[];for(let t=0;t<i.length&&t<this.numOctaves;t++){if(o&&!o.includes(t)){h.push(null);continue}const e=i[t],a=this._applyGaussianFilter(e.data,e.width,e.height);h.push([{data:e.data,width:e.width,height:e.height},{data:a.data,width:e.width,height:e.height}])}return h}catch(t){console.warn("GPU pyramid failed, falling back to CPU:",t.message)}this._pyramidBuffers&&this._pyramidBuffers.width===a&&this._pyramidBuffers.height===s||(this._pyramidBuffers={width:a,height:s,temp:new Float32Array(a*s)});const i=[];let h=t,r=a,n=s;for(let t=0;t<this.numOctaves;t++){const e=!o||o.includes(t);if(e){const t=this._applyGaussianFilter(h,r,n),e=this._applyGaussianFilter(t.data,r,n);i.push([{data:t.data,width:r,height:n},{data:e.data,width:r,height:n}])}else i.push(null);if(t<this.numOctaves-1){if(o&&!o.some(e=>e>t))break;{const a=e?i[t][0].data:h,s=this._downsample(a,r,n);h=s.data,r=s.width,n=s.height}}}return i}_applyGaussianFilter(t,e,a){const s=new Float32Array(e*a),o=this._pyramidBuffers?.temp||new Float32Array(e*a),i=.0625,h=.25,r=.375;for(let s=0;s<a;s++){const a=s*e;o[a]=(.6875*t[a]+t[a+1]*h+t[a+2]*i)*(1/.6875),o[a+1]=(t[a]*h+t[a+1]*r+t[a+2]*h+t[a+3]*i)*(1/.9375);for(let s=2;s<e-2;s++){const e=a+s;o[e]=t[e-2]*i+t[e-1]*h+t[e]*r+t[e+1]*h+t[e+2]*i}const n=a+e-2,l=a+e-1;o[n]=(t[n-2]*i+t[n-1]*h+t[n]*r+t[l]*h)*(1/.9375),o[l]=(t[l-2]*i+t[l-1]*h+.6875*t[l])*(1/.6875)}for(let t=0;t<e;t++){s[t]=(.6875*o[t]+o[t+e]*h+o[t+2*e]*i)*(1/.6875),s[t+e]=(o[t]*h+o[t+e]*r+o[t+2*e]*h+o[t+3*e]*i)*(1/.9375);for(let n=2;n<a-2;n++){const a=n*e+t;s[a]=o[a-2*e]*i+o[a-e]*h+o[a]*r+o[a+e]*h+o[a+2*e]*i}const n=(a-2)*e+t,l=(a-1)*e+t;s[n]=(o[n-2*e]*i+o[n-e]*h+o[n]*r+o[l]*h)*(1/.9375),s[l]=(o[l-2*e]*i+o[l-e]*h+.6875*o[l])*(1/.6875)}return{data:s,width:e,height:a}}_downsample(t,e,a){const s=e>>1,o=a>>1,i=new Float32Array(s*o);for(let a=0;a<o;a++){const o=2*a*e,h=o+e,r=a*s;for(let e=0;e<s;e++){const a=2*e;i[r+e]=.25*(t[o+a]+t[o+a+1]+t[h+a]+t[h+a+1])}}return{data:i,width:s,height:o}}_buildDogPyramid(t,e=null){const a=[];for(let e=0;e<t.length;e++){if(!t[e]){a.push(null);continue}const s=t[e][0],o=t[e][1],i=s.width,h=s.height,r=new Float32Array(i*h);for(let t=0;t<r.length;t++)r[t]=o.data[t]-s.data[t];a.push({data:r,width:i,height:h})}return a}_findExtremas(t,e){const a=[];for(let e=0;e<t.length;e++){const s=t[e];if(!s)continue;const o=e>0?t[e-1]:null,i=e<t.length-1?t[e+1]:null,h=s.width,r=s.height;for(let t=1;t<r-1;t++)for(let r=1;r<h-1;r++){const n=s.data[t*h+r];if(Math.abs(n)<.003)continue;let l=!0,c=!0;for(let e=-1;e<=1&&(l||c);e++)for(let a=-1;a<=1&&(l||c);a++){if(0===a&&0===e)continue;const o=s.data[(t+e)*h+(r+a)];o>=n&&(l=!1),o<=n&&(c=!1)}if((l||c)&&o){const e=r<<1,a=t<<1,s=o.width;for(let t=-1;t<=1&&(l||c);t++)for(let i=-1;i<=1&&(l||c);i++){const h=Math.max(0,Math.min(s-1,e+i)),r=Math.max(0,Math.min(o.height-1,a+t)),u=o.data[r*s+h];u>=n&&(l=!1),u<=n&&(c=!1)}}if((l||c)&&i){const e=r>>1,a=t>>1,s=i.width;for(let t=-1;t<=1&&(l||c);t++)for(let o=-1;o<=1&&(l||c);o++){const h=Math.max(0,Math.min(s-1,e+o)),r=Math.max(0,Math.min(i.height-1,a+t)),u=i.data[r*s+h];u>=n&&(l=!1),u<=n&&(c=!1)}}(l||c)&&a.push({score:l?Math.abs(n):-Math.abs(n),octave:e,x:r,y:t,absScore:Math.abs(n)})}}return a}_applyPrune(t){const e=this.maxFeaturesPerBucket,a=[];for(let t=0;t<225;t++)a.push([]);for(const e of t){const t=Math.min(14,Math.floor(e.x/(this.width/Math.pow(2,e.octave))*15)),s=15*Math.min(14,Math.floor(e.y/(this.height/Math.pow(2,e.octave))*15))+t;s>=0&&s<a.length&&a[s].push(e)}const s=[];for(const t of a){t.sort((t,e)=>e.absScore-t.absScore);for(let a=0;a<Math.min(e,t.length);a++)s.push(t[a])}return s}_computeOrientations(t,e){for(const a of t){if(a.octave<0||a.octave>=e.length){a.angle=0;continue}const t=e[a.octave][1],s=t.width,o=t.height,i=t.data,h=Math.floor(a.x),r=Math.floor(a.y),n=new Float32Array(36),l=4;for(let t=-l;t<=l;t++)for(let e=-l;e<=l;e++){const a=r+t,c=h+e;if(a<=0||a>=o-1||c<=0||c>=s-1)continue;const u=i[(a+1)*s+c]-i[(a-1)*s+c],d=i[a*s+c+1]-i[a*s+c-1],f=Math.sqrt(d*d+u*u),m=Math.atan2(u,d)+Math.PI,p=Math.floor(m/(2*Math.PI)*36)%36,g=Math.exp(-(e*e+t*t)/(2*l*l));n[p]+=f*g}let c=0;for(let t=1;t<36;t++)n[t]>n[c]&&(c=t);a.angle=2*(c+.5)*Math.PI/36-Math.PI}}_computeFreakDescriptors(e,i){for(const h of e){if(h.octave<0||h.octave>=i.length){h.descriptors=new Uint8Array(8);continue}const e=i[h.octave][1],r=e.width,n=e.height,l=e.data,c=7*Math.cos(h.angle||0),u=7*Math.sin(h.angle||0),d=new Float32Array(t.length);for(let e=0;e<t.length;e++){const[,a,s]=t[e],o=h.x+a*c-s*u,i=h.y+a*u+s*c,f=Math.max(0,Math.min(r-2,Math.floor(o))),m=Math.max(0,Math.min(n-2,Math.floor(i))),p=f+1,g=m+1,M=o-f,w=i-m;d[e]=l[m*r+f]*(1-M)*(1-w)+l[m*r+p]*M*(1-w)+l[g*r+f]*(1-M)*w+l[g*r+p]*M*w}this.useLSH?(h.lsh=a(d),h.descriptors=o(h.lsh)):h.descriptors=s(d)}}}

package/dist/core/detector/freak.js

@@ -1,89 +1 @@
-// 37 points = 6 rings x 6 points per ring + 1 center
-const FREAK_RINGS = [
-    // ring 5
-    {
-        sigma: 0.55,
-        points: [
-            [-1.0, 0.0],
-            [-0.5, -0.866025],
-            [0.5, -0.866025],
-            [1.0, -0.0],
-            [0.5, 0.866025],
-            [-0.5, 0.866025],
-        ],
-    },
-    // ring 4
-    {
-        sigma: 0.475,
-        points: [
-            [0.0, 0.930969],
-            [-0.806243, 0.465485],
-            [-0.806243, -0.465485],
-            [-0.0, -0.930969],
-            [0.806243, -0.465485],
-            [0.806243, 0.465485],
-        ],
-    },
-    // ring 3
-    {
-        sigma: 0.4,
-        points: [
-            [0.847306, -0.0],
-            [0.423653, 0.733789],
-            [-0.423653, 0.733789],
-            [-0.847306, 0.0],
-            [-0.423653, -0.733789],
-            [0.423653, -0.733789],
-        ],
-    },
-    // ring 2
-    {
-        sigma: 0.325,
-        points: [
-            [-0.0, -0.741094],
-            [0.641806, -0.370547],
-            [0.641806, 0.370547],
-            [0.0, 0.741094],
-            [-0.641806, 0.370547],
-            [-0.641806, -0.370547],
-        ],
-    },
-    // ring 1
-    {
-        sigma: 0.25,
-        points: [
-            [-0.595502, 0.0],
-            [-0.297751, -0.51572],
-            [0.297751, -0.51572],
-            [0.595502, -0.0],
-            [0.297751, 0.51572],
-            [-0.297751, 0.51572],
-        ],
-    },
-    // ring 0
-    {
-        sigma: 0.175,
-        points: [
-            [0.0, 0.362783],
-            [-0.314179, 0.181391],
-            [-0.314179, -0.181391],
-            [-0.0, -0.362783],
-            [0.314179, -0.181391],
-            [0.314179, 0.181391],
-        ],
-    },
-    // center
-    {
-        sigma: 0.1,
-        points: [[0, 0]],
-    },
-];
-const FREAKPOINTS = [];
-for (let r = 0; r < FREAK_RINGS.length; r++) {
-    const sigma = FREAK_RINGS[r].sigma;
-    for (let i = 0; i < FREAK_RINGS[r].points.length; i++) {
-        const point = FREAK_RINGS[r].points[i];
-        FREAKPOINTS.push([sigma, point[0], point[1]]);
-    }
-}
-export { FREAKPOINTS };
+const s=[{sigma:.55,points:[[-1,0],[-.5,-.866025],[.5,-.866025],[1,-0],[.5,.866025],[-.5,.866025]]},{sigma:.475,points:[[0,.930969],[-.806243,.465485],[-.806243,-.465485],[-0,-.930969],[.806243,-.465485],[.806243,.465485]]},{sigma:.4,points:[[.847306,-0],[.423653,.733789],[-.423653,.733789],[-.847306,0],[-.423653,-.733789],[.423653,-.733789]]},{sigma:.325,points:[[-0,-.741094],[.641806,-.370547],[.641806,.370547],[0,.741094],[-.641806,.370547],[-.641806,-.370547]]},{sigma:.25,points:[[-.595502,0],[-.297751,-.51572],[.297751,-.51572],[.595502,-0],[.297751,.51572],[-.297751,.51572]]},{sigma:.175,points:[[0,.362783],[-.314179,.181391],[-.314179,-.181391],[-0,-.362783],[.314179,-.181391],[.314179,.181391]]},{sigma:.1,points:[[0,0]]}],i=[];for(let t=0;t<s.length;t++){const o=s[t].sigma;for(let n=0;n<s[t].points.length;n++){const p=s[t].points[n];i.push([o,p[0],p[1]])}}export{i as FREAKPOINTS};

package/dist/core/estimation/estimate.js

@@ -1,16 +1 @@
-import { solvePosePnP } from "./pnp-solver.js";
-/**
- * 🚀 MOONSHOT: Direct PnP Solver for AR
- *
- * Instead of estimating a 2D Homography and decomposing it,
- * we solve for the 3D Pose [R|t] directly using the
- * Perspective-n-Point algorithm.
- */
-const estimate = ({ screenCoords, worldCoords, projectionTransform }) => {
-    return solvePosePnP({
-        screenCoords,
-        worldCoords,
-        projectionTransform
-    });
-};
-export { estimate };
+import{solvePosePnP as o}from"./pnp-solver.js";const r=({screenCoords:r,worldCoords:s,projectionTransform:e})=>o({screenCoords:r,worldCoords:s,projectionTransform:e});export{r as estimate};

package/dist/core/estimation/estimator.js

@@ -1,30 +1 @@
-import { estimate } from "./estimate.js";
-import { refineEstimate } from "./refine-estimate.js";
-class Estimator {
-    constructor(projectionTransform) {
-        this.projectionTransform = projectionTransform;
-    }
-    // Solve homography between screen points and world points using Direct Linear Transformation
-    // then decompose homography into rotation and translation matrix (i.e. modelViewTransform)
-    estimate({ screenCoords, worldCoords }) {
-        const modelViewTransform = estimate({
-            screenCoords,
-            worldCoords,
-            projectionTransform: this.projectionTransform,
-        });
-        return modelViewTransform;
-    }
-    // Given an initial guess of the modelViewTransform and new pairs of screen-world coordinates,
-    // use Iterative Closest Point to refine the transformation
-    //refineEstimate({initialModelViewTransform, screenCoords, worldCoords}) {
-    refineEstimate({ initialModelViewTransform, worldCoords, screenCoords }) {
-        const updatedModelViewTransform = refineEstimate({
-            initialModelViewTransform,
-            worldCoords,
-            screenCoords,
-            projectionTransform: this.projectionTransform,
-        });
-        return updatedModelViewTransform;
-    }
-}
-export { Estimator };
+import{estimate as r}from"./estimate.js";import{refineEstimate as o}from"./refine-estimate.js";class e{constructor(r){this.projectionTransform=r}estimate({screenCoords:o,worldCoords:e}){return r({screenCoords:o,worldCoords:e,projectionTransform:this.projectionTransform})}refineEstimate({initialModelViewTransform:r,worldCoords:e,screenCoords:s}){return o({initialModelViewTransform:r,worldCoords:e,screenCoords:s,projectionTransform:this.projectionTransform})}}export{e as Estimator};