@srsergio/taptapp-ar 1.1.1 → 1.1.3

package/dist/core/perception/saliency-map.js

@@ -1,254 +1 @@
-/**
- * Saliency Map Computation
- *
- * Computes visual saliency - regions that "pop out" and attract attention.
- * Used to guide saccadic attention to visually important areas.
- *
- * Implements a simplified Itti-Koch saliency model:
- * - Intensity contrast
- * - Edge density
- * - Local complexity
- *
- * For AR tracking, high-saliency regions often contain:
- * - Corners and edges (good for feature detection)
- * - High-contrast areas (robust to lighting changes)
- * - Texture-rich regions (distinctive for matching)
- */
-class SaliencyMap {
-    /**
-     * @param {number} width - Image width
-     * @param {number} height - Image height
-     */
-    constructor(width, height) {
-        this.width = width;
-        this.height = height;
-        // Downsampled dimensions for efficiency
-        this.scale = 8; // Process at 1/8 resolution
-        this.scaledW = Math.ceil(width / this.scale);
-        this.scaledH = Math.ceil(height / this.scale);
-        // Pre-allocate buffers
-        this.intensityMap = new Float32Array(this.scaledW * this.scaledH);
-        this.contrastMap = new Float32Array(this.scaledW * this.scaledH);
-        this.edgeMap = new Float32Array(this.scaledW * this.scaledH);
-        this.saliencyBuffer = new Float32Array(this.scaledW * this.scaledH);
-        // Peak detection parameters
-        this.maxPeaks = 5;
-        this.suppressionRadius = Math.max(this.scaledW, this.scaledH) * 0.15;
-    }
-    /**
-     * Compute saliency map for input image
-     *
-     * @param {Uint8Array} inputData - Grayscale input image
-     * @returns {Object} Saliency result with peaks
-     */
-    compute(inputData) {
-        // Step 1: Downsample and compute intensity
-        this._downsample(inputData);
-        // Step 2: Compute features
-        this._computeContrast();
-        this._computeEdges();
-        // Step 3: Combine into saliency map
-        this._combineSaliency();
-        // Step 4: Find peaks
-        const peaks = this._findPeaks();
-        return {
-            map: this.saliencyBuffer,
-            width: this.scaledW,
-            height: this.scaledH,
-            peaks,
-            maxSaliency: peaks.length > 0 ? peaks[0].value : 0,
-        };
-    }
-    /**
-     * Downsample input to working resolution
-     * @private
-     */
-    _downsample(inputData) {
-        const s = this.scale;
-        const w = this.width;
-        for (let sy = 0; sy < this.scaledH; sy++) {
-            const yStart = sy * s;
-            const yEnd = Math.min(yStart + s, this.height);
-            for (let sx = 0; sx < this.scaledW; sx++) {
-                const xStart = sx * s;
-                const xEnd = Math.min(xStart + s, this.width);
-                let sum = 0;
-                let count = 0;
-                for (let y = yStart; y < yEnd; y++) {
-                    const rowOffset = y * w;
-                    for (let x = xStart; x < xEnd; x++) {
-                        sum += inputData[rowOffset + x];
-                        count++;
-                    }
-                }
-                this.intensityMap[sy * this.scaledW + sx] = sum / count / 255;
-            }
-        }
-    }
-    /**
-     * Compute local contrast map
-     * @private
-     */
-    _computeContrast() {
-        const w = this.scaledW;
-        const h = this.scaledH;
-        const intensity = this.intensityMap;
-        const contrast = this.contrastMap;
-        // 3x3 local contrast using center-surround
-        for (let y = 1; y < h - 1; y++) {
-            for (let x = 1; x < w - 1; x++) {
-                const idx = y * w + x;
-                const center = intensity[idx];
-                // Compute average of 8 neighbors
-                let surround = 0;
-                surround += intensity[(y - 1) * w + (x - 1)];
-                surround += intensity[(y - 1) * w + x];
-                surround += intensity[(y - 1) * w + (x + 1)];
-                surround += intensity[y * w + (x - 1)];
-                surround += intensity[y * w + (x + 1)];
-                surround += intensity[(y + 1) * w + (x - 1)];
-                surround += intensity[(y + 1) * w + x];
-                surround += intensity[(y + 1) * w + (x + 1)];
-                surround /= 8;
-                // Contrast is absolute difference
-                contrast[idx] = Math.abs(center - surround);
-            }
-        }
-        // Handle borders
-        for (let y = 0; y < h; y++) {
-            contrast[y * w] = 0;
-            contrast[y * w + w - 1] = 0;
-        }
-        for (let x = 0; x < w; x++) {
-            contrast[x] = 0;
-            contrast[(h - 1) * w + x] = 0;
-        }
-    }
-    /**
-     * Compute edge density map using Sobel-like operator
-     * @private
-     */
-    _computeEdges() {
-        const w = this.scaledW;
-        const h = this.scaledH;
-        const intensity = this.intensityMap;
-        const edges = this.edgeMap;
-        for (let y = 1; y < h - 1; y++) {
-            for (let x = 1; x < w - 1; x++) {
-                // Simplified Sobel
-                const gx = -intensity[(y - 1) * w + (x - 1)] + intensity[(y - 1) * w + (x + 1)] +
-                    -2 * intensity[y * w + (x - 1)] + 2 * intensity[y * w + (x + 1)] +
-                    -intensity[(y + 1) * w + (x - 1)] + intensity[(y + 1) * w + (x + 1)];
-                const gy = -intensity[(y - 1) * w + (x - 1)] - 2 * intensity[(y - 1) * w + x] - intensity[(y - 1) * w + (x + 1)] +
-                    intensity[(y + 1) * w + (x - 1)] + 2 * intensity[(y + 1) * w + x] + intensity[(y + 1) * w + (x + 1)];
-                edges[y * w + x] = Math.sqrt(gx * gx + gy * gy) / 4; // Normalize
-            }
-        }
-        // Handle borders
-        for (let y = 0; y < h; y++) {
-            edges[y * w] = 0;
-            edges[y * w + w - 1] = 0;
-        }
-        for (let x = 0; x < w; x++) {
-            edges[x] = 0;
-            edges[(h - 1) * w + x] = 0;
-        }
-    }
-    /**
-     * Combine features into final saliency map
-     * @private
-     */
-    _combineSaliency() {
-        const n = this.saliencyBuffer.length;
-        const contrast = this.contrastMap;
-        const edges = this.edgeMap;
-        const saliency = this.saliencyBuffer;
-        // Weight: 60% contrast, 40% edges
-        for (let i = 0; i < n; i++) {
-            saliency[i] = contrast[i] * 0.6 + edges[i] * 0.4;
-        }
-        // Normalize to [0, 1]
-        let max = 0;
-        for (let i = 0; i < n; i++) {
-            max = Math.max(max, saliency[i]);
-        }
-        if (max > 0) {
-            for (let i = 0; i < n; i++) {
-                saliency[i] /= max;
-            }
-        }
-    }
-    /**
-     * Find peaks in saliency map using non-maximum suppression
-     * @private
-     */
-    _findPeaks() {
-        const w = this.scaledW;
-        const h = this.scaledH;
-        const saliency = this.saliencyBuffer;
-        const peaks = [];
-        const r = this.suppressionRadius;
-        const r2 = r * r;
-        // Find all local maxima
-        const candidates = [];
-        for (let y = 1; y < h - 1; y++) {
-            for (let x = 1; x < w - 1; x++) {
-                const idx = y * w + x;
-                const val = saliency[idx];
-                // Check if local maximum (8-connected)
-                if (val > saliency[(y - 1) * w + (x - 1)] &&
-                    val > saliency[(y - 1) * w + x] &&
-                    val > saliency[(y - 1) * w + (x + 1)] &&
-                    val > saliency[y * w + (x - 1)] &&
-                    val > saliency[y * w + (x + 1)] &&
-                    val > saliency[(y + 1) * w + (x - 1)] &&
-                    val > saliency[(y + 1) * w + x] &&
-                    val > saliency[(y + 1) * w + (x + 1)]) {
-                    candidates.push({ x, y, value: val });
-                }
-            }
-        }
-        // Sort by value descending
-        candidates.sort((a, b) => b.value - a.value);
-        // Non-maximum suppression
-        for (const cand of candidates) {
-            if (peaks.length >= this.maxPeaks)
-                break;
-            // Check if too close to existing peaks
-            let suppress = false;
-            for (const peak of peaks) {
-                const dx = cand.x - peak.x;
-                const dy = cand.y - peak.y;
-                if (dx * dx + dy * dy < r2) {
-                    suppress = true;
-                    break;
-                }
-            }
-            if (!suppress) {
-                // Convert to original image coordinates
-                peaks.push({
-                    x: (cand.x + 0.5) * this.scale,
-                    y: (cand.y + 0.5) * this.scale,
-                    value: cand.value,
-                });
-            }
-        }
-        return peaks;
-    }
-    /**
-     * Get saliency value at a specific location
-     *
-     * @param {number} x - X coordinate in original image
-     * @param {number} y - Y coordinate in original image
-     * @returns {number} Saliency value (0-1)
-     */
-    getSaliencyAt(x, y) {
-        const sx = Math.floor(x / this.scale);
-        const sy = Math.floor(y / this.scale);
-        if (sx < 0 || sx >= this.scaledW || sy < 0 || sy >= this.scaledH) {
-            return 0;
-        }
-        return this.saliencyBuffer[sy * this.scaledW + sx];
-    }
-}
-export { SaliencyMap };
+class t{constructor(t,s){this.width=t,this.height=s,this.scale=8,this.scaledW=Math.ceil(t/this.scale),this.scaledH=Math.ceil(s/this.scale),this.intensityMap=new Float32Array(this.scaledW*this.scaledH),this.contrastMap=new Float32Array(this.scaledW*this.scaledH),this.edgeMap=new Float32Array(this.scaledW*this.scaledH),this.saliencyBuffer=new Float32Array(this.scaledW*this.scaledH),this.maxPeaks=5,this.suppressionRadius=.15*Math.max(this.scaledW,this.scaledH)}compute(t){this._downsample(t),this._computeContrast(),this._computeEdges(),this._combineSaliency();const s=this._findPeaks();return{map:this.saliencyBuffer,width:this.scaledW,height:this.scaledH,peaks:s,maxSaliency:s.length>0?s[0].value:0}}_downsample(t){const s=this.scale,e=this.width;for(let i=0;i<this.scaledH;i++){const a=i*s,h=Math.min(a+s,this.height);for(let l=0;l<this.scaledW;l++){const c=l*s,o=Math.min(c+s,this.width);let n=0,r=0;for(let s=a;s<h;s++){const i=s*e;for(let s=c;s<o;s++)n+=t[i+s],r++}this.intensityMap[i*this.scaledW+l]=n/r/255}}}_computeContrast(){const t=this.scaledW,s=this.scaledH,e=this.intensityMap,i=this.contrastMap;for(let a=1;a<s-1;a++)for(let s=1;s<t-1;s++){const h=a*t+s,l=e[h];let c=0;c+=e[(a-1)*t+(s-1)],c+=e[(a-1)*t+s],c+=e[(a-1)*t+(s+1)],c+=e[a*t+(s-1)],c+=e[a*t+(s+1)],c+=e[(a+1)*t+(s-1)],c+=e[(a+1)*t+s],c+=e[(a+1)*t+(s+1)],c/=8,i[h]=Math.abs(l-c)}for(let e=0;e<s;e++)i[e*t]=0,i[e*t+t-1]=0;for(let e=0;e<t;e++)i[e]=0,i[(s-1)*t+e]=0}_computeEdges(){const t=this.scaledW,s=this.scaledH,e=this.intensityMap,i=this.edgeMap;for(let a=1;a<s-1;a++)for(let s=1;s<t-1;s++){const h=-e[(a-1)*t+(s-1)]+e[(a-1)*t+(s+1)]+-2*e[a*t+(s-1)]+2*e[a*t+(s+1)]+-e[(a+1)*t+(s-1)]+e[(a+1)*t+(s+1)],l=-e[(a-1)*t+(s-1)]-2*e[(a-1)*t+s]-e[(a-1)*t+(s+1)]+e[(a+1)*t+(s-1)]+2*e[(a+1)*t+s]+e[(a+1)*t+(s+1)];i[a*t+s]=Math.sqrt(h*h+l*l)/4}for(let e=0;e<s;e++)i[e*t]=0,i[e*t+t-1]=0;for(let e=0;e<t;e++)i[e]=0,i[(s-1)*t+e]=0}_combineSaliency(){const t=this.saliencyBuffer.length,s=this.contrastMap,e=this.edgeMap,i=this.saliencyBuffer;for(let a=0;a<t;a++)i[a]=.6*s[a]+.4*e[a];let a=0;for(let s=0;s<t;s++)a=Math.max(a,i[s]);if(a>0)for(let s=0;s<t;s++)i[s]/=a}_findPeaks(){const t=this.scaledW,s=this.scaledH,e=this.saliencyBuffer,i=[],a=this.suppressionRadius,h=a*a,l=[];for(let i=1;i<s-1;i++)for(let s=1;s<t-1;s++){const a=e[i*t+s];a>e[(i-1)*t+(s-1)]&&a>e[(i-1)*t+s]&&a>e[(i-1)*t+(s+1)]&&a>e[i*t+(s-1)]&&a>e[i*t+(s+1)]&&a>e[(i+1)*t+(s-1)]&&a>e[(i+1)*t+s]&&a>e[(i+1)*t+(s+1)]&&l.push({x:s,y:i,value:a})}l.sort((t,s)=>s.value-t.value);for(const t of l){if(i.length>=this.maxPeaks)break;let s=!1;for(const e of i){const i=t.x-e.x,a=t.y-e.y;if(i*i+a*a<h){s=!0;break}}s||i.push({x:(t.x+.5)*this.scale,y:(t.y+.5)*this.scale,value:t.value})}return i}getSaliencyAt(t,s){const e=Math.floor(t/this.scale),i=Math.floor(s/this.scale);return e<0||e>=this.scaledW||i<0||i>=this.scaledH?0:this.saliencyBuffer[i*this.scaledW+e]}}export{t as SaliencyMap};

package/dist/core/perception/scale-orchestrator.js

@@ -1,68 +1 @@
-/**
- * Scale Orchestrator
- *
- * Manages which octaves should be processed based on the current tracking state.
- * Implements temporal consistency and interleave strategies to optimize performance.
- */
-export class ScaleOrchestrator {
-    constructor(numOctaves, options = {}) {
-        this.numOctaves = numOctaves;
-        this.options = {
-            interleaveInterval: 10,
-            hysteresis: 1, // Number of adjacent octaves to keep
-            ...options
-        };
-        this.frameCount = 0;
-        this.lastActiveOctave = -1;
-        this.interleaveOctave = 0;
-    }
-    /**
-     * Determine which octaves should be processed in the current frame
-     *
-     * @param {Object} trackingState - Current state of tracking
-     * @returns {number[]} Array of octave indices to process
-     */
-    getOctavesToProcess(trackingState = null) {
-        this.frameCount++;
-        // Case 1: No tracking or lost tracking -> Process all octaves
-        if (!trackingState || !trackingState.isTracking || trackingState.activeOctave === undefined) {
-            this.lastActiveOctave = -1;
-            return Array.from({ length: this.numOctaves }, (_, i) => i);
-        }
-        const activeScale = trackingState.activeOctave;
-        this.lastActiveOctave = activeScale;
-        // Case 2: Active tracking -> Focus on current scale and neighbors
-        const octaves = new Set();
-        // Add current and adjacent scales (Hysteresis)
-        for (let i = -this.options.hysteresis; i <= this.options.hysteresis; i++) {
-            const octave = activeScale + i;
-            if (octave >= 0 && octave < this.numOctaves) {
-                octaves.add(octave);
-            }
-        }
-        // Case 3: Interleave - Periodically check a distant octave to ensure we don't "drift"
-        if (this.frameCount % this.options.interleaveInterval === 0) {
-            this.interleaveOctave = (this.interleaveOctave + 1) % this.numOctaves;
-            // If the interleave octave is already being processed, pick the next one
-            if (octaves.has(this.interleaveOctave)) {
-                this.interleaveOctave = (this.interleaveOctave + 1) % this.numOctaves;
-            }
-            octaves.add(this.interleaveOctave);
-            if (this.options.debug) {
-                console.log(`[ScaleOrchestrator] Interleave check on octave ${this.interleaveOctave}`);
-            }
-        }
-        const result = Array.from(octaves).sort((a, b) => a - b);
-        if (this.options.debug) {
-            console.log(`[ScaleOrchestrator] Active: ${activeScale}, Processing: [${result.join(', ')}]`);
-        }
-        return result;
-    }
-    /**
-     * Reset orchestrator state
-     */
-    reset() {
-        this.frameCount = 0;
-        this.lastActiveOctave = -1;
-    }
-}
+export class ScaleOrchestrator{constructor(t,e={}){this.numOctaves=t,this.options={interleaveInterval:10,hysteresis:1,...e},this.frameCount=0,this.lastActiveOctave=-1,this.interleaveOctave=0}getOctavesToProcess(t=null){if(this.frameCount++,!t||!t.isTracking||void 0===t.activeOctave)return this.lastActiveOctave=-1,Array.from({length:this.numOctaves},(t,e)=>e);const e=t.activeOctave;this.lastActiveOctave=e;const s=new Set;for(let t=-this.options.hysteresis;t<=this.options.hysteresis;t++){const i=e+t;i>=0&&i<this.numOctaves&&s.add(i)}this.frameCount%this.options.interleaveInterval===0&&(this.interleaveOctave=(this.interleaveOctave+1)%this.numOctaves,s.has(this.interleaveOctave)&&(this.interleaveOctave=(this.interleaveOctave+1)%this.numOctaves),s.add(this.interleaveOctave),this.options.debug&&console.log(`[ScaleOrchestrator] Interleave check on octave ${this.interleaveOctave}`));const i=Array.from(s).sort((t,e)=>t-e);return this.options.debug&&console.log(`[ScaleOrchestrator] Active: ${e}, Processing: [${i.join(", ")}]`),i}reset(){this.frameCount=0,this.lastActiveOctave=-1}}

package/dist/core/protocol.js

@@ -1,254 +1 @@
-import * as msgpack from "@msgpack/msgpack";
-export const CURRENT_VERSION = 11; // Bumped for Nanite virtualized features support
-export const HDC_SEED = 0x1337BEEF; // Default system seed
-/**
- * Morton Order calculation for spatial sorting
- */
-export function getMorton(x, y) {
-    let x_int = x | 0;
-    let y_int = y | 0;
-    x_int = (x_int | (x_int << 8)) & 0x00FF00FF;
-    x_int = (x_int | (x_int << 4)) & 0x0F0F0F0F;
-    x_int = (x_int | (x_int << 2)) & 0x33333333;
-    x_int = (x_int | (x_int << 1)) & 0x55555555;
-    y_int = (y_int | (y_int << 8)) & 0x00FF00FF;
-    y_int = (y_int | (y_int << 4)) & 0x0F0F0F0F;
-    y_int = (y_int | (y_int << 2)) & 0x33333333;
-    y_int = (y_int | (y_int << 1)) & 0x55555555;
-    return x_int | (y_int << 1);
-}
-/**
- * Packs 8-bit image data into 4-bit packed data
- */
-export function pack4Bit(data) {
-    const length = data.length;
-    if (length % 2 !== 0)
-        return data;
-    const packed = new Uint8Array(length / 2);
-    for (let i = 0; i < length; i += 2) {
-        const p1 = (data[i] & 0xF0) >> 4;
-        const p2 = (data[i + 1] & 0xF0) >> 4;
-        packed[i / 2] = (p1 << 4) | p2;
-    }
-    return packed;
-}
-/**
- * Unpacks 4-bit data back to 8-bit image data
- */
-export function unpack4Bit(packed, width, height) {
-    const length = width * height;
-    const data = new Uint8Array(length);
-    for (let i = 0; i < packed.length; i++) {
-        const byte = packed[i];
-        const p1 = (byte & 0xF0);
-        const p2 = (byte & 0x0F) << 4;
-        data[i * 2] = p1;
-        data[i * 2 + 1] = p2;
-    }
-    return data;
-}
-/**
- * Columnarizes point data for efficient storage and transfer
- */
-export function columnarize(points, tree, width, height, useHDC = false) {
-    const count = points.length;
-    const x = new Uint16Array(count);
-    const y = new Uint16Array(count);
-    const angle = new Int16Array(count);
-    const scale = new Uint8Array(count);
-    let descriptors;
-    if (useHDC) {
-        descriptors = new Uint32Array(count); // HDC Signatures (32-bit)
-    }
-    else {
-        descriptors = new Uint32Array(count * 2); // Raw Descriptors (64-bit)
-    }
-    for (let i = 0; i < count; i++) {
-        x[i] = Math.round((points[i].x / width) * 65535);
-        y[i] = Math.round((points[i].y / height) * 65535);
-        angle[i] = Math.round((points[i].angle / Math.PI) * 32767);
-        scale[i] = Math.round(Math.log2(points[i].scale || 1));
-        if (points[i].descriptors && points[i].descriptors.length >= 2) {
-            if (useHDC) {
-                // For HDC, we'd normally call project + compress here
-                // But protocol.ts should be agnostic of the generator.
-                // We'll assume points[i].hdcSignature exists if pre-calculated
-                descriptors[i] = points[i].hdcSignature || 0;
-            }
-            else {
-                descriptors[i * 2] = points[i].descriptors[0];
-                descriptors[(i * 2) + 1] = points[i].descriptors[1];
-            }
-        }
-    }
-    return {
-        x,
-        y,
-        a: angle,
-        s: scale,
-        d: descriptors,
-        hdc: useHDC ? 1 : 0, // HDC Flag (renamed from h to avoid collision with height)
-        t: compactTree(tree.rootNode),
-    };
-}
-/**
- * Columnarizes point data with COMPACT 32-bit descriptors (XOR folding)
- * Reduces descriptor storage by 50% with minimal accuracy loss
- */
-export function columnarizeCompact(points, tree, width, height) {
-    const count = points.length;
-    const x = new Uint16Array(count);
-    const y = new Uint16Array(count);
-    const angle = new Int16Array(count);
-    const scale = new Uint8Array(count);
-    const descriptors = new Uint32Array(count); // 32-bit compact descriptors
-    for (let i = 0; i < count; i++) {
-        x[i] = Math.round((points[i].x / width) * 65535);
-        y[i] = Math.round((points[i].y / height) * 65535);
-        angle[i] = Math.round((points[i].angle / Math.PI) * 32767);
-        scale[i] = Math.round(Math.log2(points[i].scale || 1));
-        if (points[i].descriptors && points[i].descriptors.length >= 2) {
-            // XOR folding: Combine two 32-bit values into one 32-bit value
-            // This preserves discriminative power while halving storage
-            descriptors[i] = (points[i].descriptors[0] ^ points[i].descriptors[1]) >>> 0;
-        }
-    }
-    return {
-        x,
-        y,
-        a: angle,
-        s: scale,
-        d: descriptors,
-        compact: 1, // Flag to indicate compact 32-bit descriptors
-        t: compactTree(tree.rootNode),
-    };
-}
-/**
- * Compacts hierarchical clustering tree into a minimal array structure
- */
-export function compactTree(node) {
-    if (node.leaf) {
-        return [1, node.centerPointIndex || 0, node.pointIndexes];
-    }
-    return [0, node.centerPointIndex || 0, node.children.map((c) => compactTree(c))];
-}
-/**
- * Expands a compacted tree back into an object structure
- */
-export function expandTree(node) {
-    const isLeaf = node[0] === 1;
-    if (isLeaf) {
-        return {
-            leaf: true,
-            centerPointIndex: node[1],
-            pointIndexes: node[2],
-        };
-    }
-    return {
-        leaf: false,
-        centerPointIndex: node[1],
-        children: node[2].map((c) => expandTree(c)),
-    };
-}
-/**
- * Deserializes and normalizes .taar data from a buffer
- */
-export function decodeTaar(buffer) {
-    const content = msgpack.decode(new Uint8Array(buffer));
-    const version = content.v || 0;
-    // Support Protocol V5/V6/V7
-    if (version < 5 || version > CURRENT_VERSION) {
-        console.warn(`Potential incompatible .taar version: ${version}. Standard is ${CURRENT_VERSION}.`);
-    }
-    const dataList = content.dataList;
-    for (let i = 0; i < dataList.length; i++) {
-        const item = dataList[i];
-        // 1. Process Tracking Data
-        for (const td of item.trackingData) {
-            // Helper to ensure we have the right TypedArray if it was decoded as Uint8Array by msgpack
-            const normalizeBuffer = (arr, Type) => {
-                if (arr instanceof Uint8Array && Type !== Uint8Array) {
-                    return new Type(arr.buffer.slice(arr.byteOffset, arr.byteOffset + arr.byteLength));
-                }
-                return arr;
-            };
-            td.px = normalizeBuffer(td.px, Float32Array);
-            td.py = normalizeBuffer(td.py, Float32Array);
-            // Backwards compatibility for fields named 'd' vs 'data'
-            const rawData = td.data || td.d;
-            const w = td.width || td.w;
-            const h = td.height || td.h;
-            if (rawData && rawData.length === (w * h) / 2) {
-                const unpacked = unpack4Bit(rawData, w, h);
-                if (td.data)
-                    td.data = unpacked;
-                if (td.d)
-                    td.d = unpacked;
-            }
-            if (td.mesh) {
-                td.mesh.t = normalizeBuffer(td.mesh.t, Uint16Array);
-                td.mesh.e = normalizeBuffer(td.mesh.e, Uint16Array);
-                td.mesh.rl = normalizeBuffer(td.mesh.rl, Float32Array);
-            }
-        }
-        // 2. Process Matching Data
-        for (const kf of item.matchingData) {
-            for (const col of [kf.max, kf.min]) {
-                if (!col)
-                    continue;
-                let xRaw = col.x;
-                let yRaw = col.y;
-                if (xRaw instanceof Uint8Array) {
-                    xRaw = new Uint16Array(xRaw.buffer.slice(xRaw.byteOffset, xRaw.byteOffset + xRaw.byteLength));
-                }
-                if (yRaw instanceof Uint8Array) {
-                    yRaw = new Uint16Array(yRaw.buffer.slice(yRaw.byteOffset, yRaw.byteOffset + yRaw.byteLength));
-                }
-                const count = xRaw.length;
-                const x = new Float32Array(count);
-                const y = new Float32Array(count);
-                for (let k = 0; k < count; k++) {
-                    x[k] = (xRaw[k] / 65535) * kf.w;
-                    y[k] = (yRaw[k] / 65535) * kf.h;
-                }
-                col.x = x;
-                col.y = y;
-                if (col.a instanceof Uint8Array) {
-                    const aRaw = new Int16Array(col.a.buffer.slice(col.a.byteOffset, col.a.byteOffset + col.a.byteLength));
-                    const a = new Float32Array(count);
-                    for (let k = 0; k < count; k++) {
-                        a[k] = (aRaw[k] / 32767) * Math.PI;
-                    }
-                    col.a = a;
-                }
-                if (col.s instanceof Uint8Array) {
-                    const sRaw = col.s;
-                    const s = new Float32Array(count);
-                    for (let k = 0; k < count; k++) {
-                        s[k] = Math.pow(2, sRaw[k]);
-                    }
-                    col.s = s;
-                }
-                if (col.d instanceof Uint8Array) {
-                    // Check if it's HDC (Uint32) or Raw (Uint32 x 2)
-                    if (col.hdc === 1) {
-                        col.d = new Uint32Array(col.d.buffer.slice(col.d.byteOffset, col.d.byteOffset + col.d.byteLength));
-                    }
-                    else {
-                        col.d = new Uint32Array(col.d.buffer.slice(col.d.byteOffset, col.d.byteOffset + col.d.byteLength));
-                    }
-                }
-            }
-        }
-    }
-    return { version, dataList };
-}
-/**
- * Serializes target data into a .taar binary buffer
- */
-export function encodeTaar(dataList) {
-    return msgpack.encode({
-        v: CURRENT_VERSION,
-        dataList,
-    });
-}
+import*as t from"@msgpack/msgpack";export const CURRENT_VERSION=11;export const HDC_SEED=322420463;export function getMorton(t,e){let n=0|t,r=0|e;return n=16711935&(n|n<<8),n=252645135&(n|n<<4),n=858993459&(n|n<<2),n=1431655765&(n|n<<1),r=16711935&(r|r<<8),r=252645135&(r|r<<4),r=858993459&(r|r<<2),r=1431655765&(r|r<<1),n|r<<1}export function pack4Bit(t){const e=t.length;if(e%2!=0)return t;const n=new Uint8Array(e/2);for(let r=0;r<e;r+=2){const e=(240&t[r])>>4,a=(240&t[r+1])>>4;n[r/2]=e<<4|a}return n}export function unpack4Bit(t,e,n){const r=new Uint8Array(e*n);for(let e=0;e<t.length;e++){const n=t[e],a=240&n,o=(15&n)<<4;r[2*e]=a,r[2*e+1]=o}return r}export function columnarize(t,e,n,r,a=!1){const o=t.length,c=new Uint16Array(o),i=new Uint16Array(o),s=new Int16Array(o),f=new Uint8Array(o);let d;d=a?new Uint32Array(o):new Uint32Array(2*o);for(let e=0;e<o;e++)c[e]=Math.round(t[e].x/n*65535),i[e]=Math.round(t[e].y/r*65535),s[e]=Math.round(t[e].angle/Math.PI*32767),f[e]=Math.round(Math.log2(t[e].scale||1)),t[e].descriptors&&t[e].descriptors.length>=2&&(a?d[e]=t[e].hdcSignature||0:(d[2*e]=t[e].descriptors[0],d[2*e+1]=t[e].descriptors[1]));return{x:c,y:i,a:s,s:f,d:d,hdc:a?1:0,t:compactTree(e.rootNode)}}export function columnarizeCompact(t,e,n,r){const a=t.length,o=new Uint16Array(a),c=new Uint16Array(a),i=new Int16Array(a),s=new Uint8Array(a),f=new Uint32Array(a);for(let e=0;e<a;e++)o[e]=Math.round(t[e].x/n*65535),c[e]=Math.round(t[e].y/r*65535),i[e]=Math.round(t[e].angle/Math.PI*32767),s[e]=Math.round(Math.log2(t[e].scale||1)),t[e].descriptors&&t[e].descriptors.length>=2&&(f[e]=(t[e].descriptors[0]^t[e].descriptors[1])>>>0);return{x:o,y:c,a:i,s:s,d:f,compact:1,t:compactTree(e.rootNode)}}export function compactTree(t){return t.leaf?[1,t.centerPointIndex||0,t.pointIndexes]:[0,t.centerPointIndex||0,t.children.map(t=>compactTree(t))]}export function expandTree(t){return 1===t[0]?{leaf:!0,centerPointIndex:t[1],pointIndexes:t[2]}:{leaf:!1,centerPointIndex:t[1],children:t[2].map(t=>expandTree(t))}}export function decodeTaar(e){const n=t.decode(new Uint8Array(e)),r=n.v||0;(r<5||r>11)&&console.warn(`Potential incompatible .taar version: ${r}. Standard is 11.`);const a=n.dataList;for(let t=0;t<a.length;t++){const e=a[t];for(const t of e.trackingData){const e=(t,e)=>t instanceof Uint8Array&&e!==Uint8Array?new e(t.buffer.slice(t.byteOffset,t.byteOffset+t.byteLength)):t;t.px=e(t.px,Float32Array),t.py=e(t.py,Float32Array);const n=t.data||t.d,r=t.width||t.w,a=t.height||t.h;if(n&&n.length===r*a/2){const e=unpack4Bit(n,r,a);t.data&&(t.data=e),t.d&&(t.d=e)}t.mesh&&(t.mesh.t=e(t.mesh.t,Uint16Array),t.mesh.e=e(t.mesh.e,Uint16Array),t.mesh.rl=e(t.mesh.rl,Float32Array))}for(const t of e.matchingData)for(const e of[t.max,t.min]){if(!e)continue;let n=e.x,r=e.y;n instanceof Uint8Array&&(n=new Uint16Array(n.buffer.slice(n.byteOffset,n.byteOffset+n.byteLength))),r instanceof Uint8Array&&(r=new Uint16Array(r.buffer.slice(r.byteOffset,r.byteOffset+r.byteLength)));const a=n.length,o=new Float32Array(a),c=new Float32Array(a);for(let e=0;e<a;e++)o[e]=n[e]/65535*t.w,c[e]=r[e]/65535*t.h;if(e.x=o,e.y=c,e.a instanceof Uint8Array){const t=new Int16Array(e.a.buffer.slice(e.a.byteOffset,e.a.byteOffset+e.a.byteLength)),n=new Float32Array(a);for(let e=0;e<a;e++)n[e]=t[e]/32767*Math.PI;e.a=n}if(e.s instanceof Uint8Array){const t=e.s,n=new Float32Array(a);for(let e=0;e<a;e++)n[e]=Math.pow(2,t[e]);e.s=n}e.d instanceof Uint8Array&&(e.hdc,e.d=new Uint32Array(e.d.buffer.slice(e.d.byteOffset,e.d.byteOffset+e.d.byteLength)))}}return{version:r,dataList:a}}export function encodeTaar(e){return t.encode({v:11,dataList:e})}

package/dist/core/tracker/extract-utils.js

@@ -1,29 +1 @@
-import { extract } from "./extract.js";
-/**
- * Extrae características de tracking de una lista de imágenes
- * Procesa cada imagen para obtener puntos característicos y datos de escala
- * @param {Array<Object>} imageList - Lista de imágenes a procesar
- * @param {Function} doneCallback - Función de callback para reportar progreso
- * @returns {Array<Object>} Conjunto de características extraídas
- */
-export const extractTrackingFeatures = (imageList, doneCallback) => {
-    const featureSets = [];
-    // Procesar cada imagen en la lista
-    for (let i = 0; i < imageList.length; i++) {
-        const image = imageList[i];
-        // Extraer puntos característicos
-        const points = extract(image);
-        // Construir conjunto de características
-        const featureSet = {
-            data: image.data,
-            scale: image.scale,
-            width: image.width,
-            height: image.height,
-            points,
-        };
-        featureSets.push(featureSet);
-        // Reportar progreso
-        doneCallback(i);
-    }
-    return featureSets;
-};
+import{extract as t}from"./extract.js";export const extractTrackingFeatures=(e,a)=>{const r=[];for(let s=0;s<e.length;s++){const c=e[s],h=t(c),o={data:c.data,scale:c.scale,width:c.width,height:c.height,points:h};r.push(o),a(s)}return r};