@srsergio/taptapp-ar 1.1.1 → 1.1.3

package/dist/core/perception/predictive-coding.js

@@ -1,278 +1 @@
-/**
- * Predictive Coding System
- *
- * Inspired by the brain's predictive processing theory:
- * - The brain constantly predicts incoming sensory data
- * - Only "prediction errors" (unexpected changes) are processed fully
- * - If prediction matches reality, minimal processing is needed
- *
- * For AR tracking:
- * - Predict next frame based on motion model
- * - Compare prediction to actual frame
- * - Skip or minimize processing if difference is below threshold
- * - In static scenes, ~90% of frames can be skipped
- */
-class PredictiveCoding {
-    /**
-     * @param {number} width - Image width
-     * @param {number} height - Image height
-     * @param {Object} config - Configuration
-     */
-    constructor(width, height, config) {
-        this.width = width;
-        this.height = height;
-        this.config = config;
-        // Frame history for prediction
-        this.frameHistory = [];
-        this.stateHistory = [];
-        // Motion model parameters
-        this.motionModel = {
-            vx: 0, // Velocity X
-            vy: 0, // Velocity Y
-            vtheta: 0, // Angular velocity
-            vscale: 0, // Scale velocity
-            confidence: 0, // Model confidence
-        };
-        // Block-based change detection (8x8 blocks)
-        this.blockSize = 8;
-        this.blocksX = Math.ceil(width / this.blockSize);
-        this.blocksY = Math.ceil(height / this.blockSize);
-        this.blockMeans = new Float32Array(this.blocksX * this.blocksY);
-        this.prevBlockMeans = new Float32Array(this.blocksX * this.blocksY);
-        // Statistics
-        this.consecutiveSkips = 0;
-        this.maxConsecutiveSkips = 10; // Force processing every N frames
-    }
-    /**
-     * Predict whether current frame can be skipped
-     *
-     * @param {Uint8Array} inputData - Current frame grayscale data
-     * @param {Object} trackingState - Current tracking state
-     * @returns {Object} Prediction result
-     */
-    predict(inputData, trackingState) {
-        // Always process first few frames
-        if (this.frameHistory.length < 2) {
-            return { canSkip: false, confidence: 0, reason: 'insufficient_history' };
-        }
-        // Force processing periodically
-        if (this.consecutiveSkips >= this.maxConsecutiveSkips) {
-            return { canSkip: false, confidence: 0, reason: 'forced_refresh' };
-        }
-        // Compute change level
-        const changeLevel = this.getChangeLevel(inputData);
-        // If not tracking, be more conservative
-        const threshold = trackingState?.isTracking
-            ? this.config.CHANGE_THRESHOLD
-            : this.config.CHANGE_THRESHOLD * 0.5;
-        // Decision
-        const canSkip = changeLevel < threshold;
-        const confidence = canSkip
-            ? Math.min(1, (threshold - changeLevel) / threshold)
-            : 0;
-        // Predict state if skipping
-        let predictedState = null;
-        if (canSkip && trackingState) {
-            predictedState = this._predictState(trackingState);
-        }
-        if (canSkip) {
-            this.consecutiveSkips++;
-        }
-        return {
-            canSkip,
-            confidence,
-            changeLevel,
-            predictedState,
-            reason: canSkip ? 'low_change' : 'significant_change',
-        };
-    }
-    /**
-     * Compute change level between current and previous frame
-     * Uses block-based comparison for efficiency
-     *
-     * @param {Uint8Array} inputData - Current frame
-     * @returns {number} Change level (0-1)
-     */
-    getChangeLevel(inputData) {
-        if (this.frameHistory.length === 0) {
-            return 1.0; // Assume maximum change for first frame
-        }
-        // Compute block means for current frame
-        this._computeBlockMeans(inputData, this.blockMeans);
-        // Compare with previous block means
-        let totalDiff = 0;
-        let maxDiff = 0;
-        const numBlocks = this.blocksX * this.blocksY;
-        for (let i = 0; i < numBlocks; i++) {
-            const diff = Math.abs(this.blockMeans[i] - this.prevBlockMeans[i]) / 255;
-            totalDiff += diff;
-            maxDiff = Math.max(maxDiff, diff);
-        }
-        // Combine average and max differences
-        const avgDiff = totalDiff / numBlocks;
-        const changeLevel = avgDiff * 0.7 + maxDiff * 0.3;
-        return Math.min(1, changeLevel);
-    }
-    /**
-     * Compute mean intensity for each block
-     * @private
-     */
-    _computeBlockMeans(data, output) {
-        const bs = this.blockSize;
-        const w = this.width;
-        for (let by = 0; by < this.blocksY; by++) {
-            const yStart = by * bs;
-            const yEnd = Math.min(yStart + bs, this.height);
-            for (let bx = 0; bx < this.blocksX; bx++) {
-                const xStart = bx * bs;
-                const xEnd = Math.min(xStart + bs, 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 += data[rowOffset + x];
-                        count++;
-                    }
-                }
-                output[by * this.blocksX + bx] = sum / count;
-            }
-        }
-    }
-    /**
-     * Predict next tracking state based on motion model
-     * @private
-     */
-    _predictState(currentState) {
-        if (!currentState.worldMatrix)
-            return null;
-        // Extract current parameters
-        const matrix = currentState.worldMatrix;
-        // Apply motion model
-        const predictedMatrix = new Float32Array(16);
-        for (let i = 0; i < 16; i++) {
-            predictedMatrix[i] = matrix[i];
-        }
-        // Add predicted motion
-        predictedMatrix[12] += this.motionModel.vx;
-        predictedMatrix[13] += this.motionModel.vy;
-        // Apply scale change (to diagonal elements)
-        const scaleFactor = 1 + this.motionModel.vscale;
-        predictedMatrix[0] *= scaleFactor;
-        predictedMatrix[5] *= scaleFactor;
-        predictedMatrix[10] *= scaleFactor;
-        return {
-            worldMatrix: predictedMatrix,
-            isTracking: true,
-            isPredicted: true,
-            predictionConfidence: this.motionModel.confidence,
-        };
-    }
-    /**
-     * Store frame for future prediction
-     *
-     * @param {Uint8Array} inputData - Frame data
-     * @param {Object} trackingState - Tracking state
-     */
-    storeFrame(inputData, trackingState) {
-        // Copy current block means to previous before computing new
-        for (let i = 0; i < this.blockMeans.length; i++) {
-            this.prevBlockMeans[i] = this.blockMeans[i];
-        }
-        // Compute new block means
-        this._computeBlockMeans(inputData, this.blockMeans);
-        // Store state
-        if (trackingState?.worldMatrix) {
-            this.stateHistory.push({
-                timestamp: Date.now(),
-                matrix: new Float32Array(trackingState.worldMatrix),
-            });
-            // Update motion model
-            this._updateMotionModel();
-            // Keep history bounded
-            while (this.stateHistory.length > this.config.MOTION_HISTORY_FRAMES) {
-                this.stateHistory.shift();
-            }
-        }
-        // Reset skip counter
-        this.consecutiveSkips = 0;
-        // Keep frame count bounded
-        this.frameHistory.push(Date.now());
-        while (this.frameHistory.length > this.config.MOTION_HISTORY_FRAMES) {
-            this.frameHistory.shift();
-        }
-    }
-    /**
-     * Update motion model from state history
-     * @private
-     */
-    _updateMotionModel() {
-        const history = this.stateHistory;
-        if (history.length < 2) {
-            this.motionModel.confidence = 0;
-            return;
-        }
-        // Compute velocity from recent frames
-        const n = history.length;
-        const latest = history[n - 1].matrix;
-        const prev = history[n - 2].matrix;
-        const dt = (history[n - 1].timestamp - history[n - 2].timestamp) / 1000;
-        if (dt > 0) {
-            // Position velocity
-            this.motionModel.vx = (latest[12] - prev[12]) / dt * 0.016; // Normalize to ~60fps
-            this.motionModel.vy = (latest[13] - prev[13]) / dt * 0.016;
-            // Scale velocity (from diagonal average)
-            const prevScale = (Math.abs(prev[0]) + Math.abs(prev[5])) / 2;
-            const currScale = (Math.abs(latest[0]) + Math.abs(latest[5])) / 2;
-            this.motionModel.vscale = (currScale - prevScale) / prevScale / dt * 0.016;
-            // Compute confidence based on consistency
-            if (history.length >= 3) {
-                const older = history[n - 3].matrix;
-                const expectedVx = (prev[12] - older[12]) / dt * 0.016;
-                const expectedVy = (prev[13] - older[13]) / dt * 0.016;
-                const errorX = Math.abs(this.motionModel.vx - expectedVx);
-                const errorY = Math.abs(this.motionModel.vy - expectedVy);
-                const error = Math.sqrt(errorX * errorX + errorY * errorY);
-                this.motionModel.confidence = Math.max(0, 1 - error / 10);
-            }
-            else {
-                this.motionModel.confidence = 0.5;
-            }
-        }
-    }
-    /**
-     * Check if we're in a static scene (good candidate for aggressive skipping)
-     * @returns {boolean} True if scene appears static
-     */
-    isStaticScene() {
-        if (this.stateHistory.length < 3)
-            return false;
-        const velocity = Math.sqrt(this.motionModel.vx ** 2 +
-            this.motionModel.vy ** 2);
-        return velocity < 0.5 && Math.abs(this.motionModel.vscale) < 0.01;
-    }
-    /**
-     * Reset prediction state
-     */
-    reset() {
-        this.frameHistory = [];
-        this.stateHistory = [];
-        this.consecutiveSkips = 0;
-        this.motionModel = {
-            vx: 0,
-            vy: 0,
-            vtheta: 0,
-            vscale: 0,
-            confidence: 0,
-        };
-        this.blockMeans.fill(0);
-        this.prevBlockMeans.fill(0);
-    }
-    /**
-     * Update configuration
-     */
-    configure(config) {
-        this.config = { ...this.config, ...config };
-    }
-}
-export { PredictiveCoding };
+class t{constructor(t,i,s){this.width=t,this.height=i,this.config=s,this.frameHistory=[],this.stateHistory=[],this.motionModel={vx:0,vy:0,vtheta:0,vscale:0,confidence:0},this.blockSize=8,this.blocksX=Math.ceil(t/this.blockSize),this.blocksY=Math.ceil(i/this.blockSize),this.blockMeans=new Float32Array(this.blocksX*this.blocksY),this.prevBlockMeans=new Float32Array(this.blocksX*this.blocksY),this.consecutiveSkips=0,this.maxConsecutiveSkips=10}predict(t,i){if(this.frameHistory.length<2)return{canSkip:!1,confidence:0,reason:"insufficient_history"};if(this.consecutiveSkips>=this.maxConsecutiveSkips)return{canSkip:!1,confidence:0,reason:"forced_refresh"};const s=this.getChangeLevel(t),e=i?.isTracking?this.config.CHANGE_THRESHOLD:.5*this.config.CHANGE_THRESHOLD,o=s<e,n=o?Math.min(1,(e-s)/e):0;let h=null;return o&&i&&(h=this._predictState(i)),o&&this.consecutiveSkips++,{canSkip:o,confidence:n,changeLevel:s,predictedState:h,reason:o?"low_change":"significant_change"}}getChangeLevel(t){if(0===this.frameHistory.length)return 1;this._computeBlockMeans(t,this.blockMeans);let i=0,s=0;const e=this.blocksX*this.blocksY;for(let t=0;t<e;t++){const e=Math.abs(this.blockMeans[t]-this.prevBlockMeans[t])/255;i+=e,s=Math.max(s,e)}const o=i/e*.7+.3*s;return Math.min(1,o)}_computeBlockMeans(t,i){const s=this.blockSize,e=this.width;for(let o=0;o<this.blocksY;o++){const n=o*s,h=Math.min(n+s,this.height);for(let c=0;c<this.blocksX;c++){const a=c*s,r=Math.min(a+s,this.width);let l=0,M=0;for(let i=n;i<h;i++){const s=i*e;for(let i=a;i<r;i++)l+=t[s+i],M++}i[o*this.blocksX+c]=l/M}}}_predictState(t){if(!t.worldMatrix)return null;const i=t.worldMatrix,s=new Float32Array(16);for(let t=0;t<16;t++)s[t]=i[t];s[12]+=this.motionModel.vx,s[13]+=this.motionModel.vy;const e=1+this.motionModel.vscale;return s[0]*=e,s[5]*=e,s[10]*=e,{worldMatrix:s,isTracking:!0,isPredicted:!0,predictionConfidence:this.motionModel.confidence}}storeFrame(t,i){for(let t=0;t<this.blockMeans.length;t++)this.prevBlockMeans[t]=this.blockMeans[t];if(this._computeBlockMeans(t,this.blockMeans),i?.worldMatrix)for(this.stateHistory.push({timestamp:Date.now(),matrix:new Float32Array(i.worldMatrix)}),this._updateMotionModel();this.stateHistory.length>this.config.MOTION_HISTORY_FRAMES;)this.stateHistory.shift();for(this.consecutiveSkips=0,this.frameHistory.push(Date.now());this.frameHistory.length>this.config.MOTION_HISTORY_FRAMES;)this.frameHistory.shift()}_updateMotionModel(){const t=this.stateHistory;if(t.length<2)return void(this.motionModel.confidence=0);const i=t.length,s=t[i-1].matrix,e=t[i-2].matrix,o=(t[i-1].timestamp-t[i-2].timestamp)/1e3;if(o>0){this.motionModel.vx=(s[12]-e[12])/o*.016,this.motionModel.vy=(s[13]-e[13])/o*.016;const n=(Math.abs(e[0])+Math.abs(e[5]))/2,h=(Math.abs(s[0])+Math.abs(s[5]))/2;if(this.motionModel.vscale=(h-n)/n/o*.016,t.length>=3){const s=t[i-3].matrix,n=(e[12]-s[12])/o*.016,h=(e[13]-s[13])/o*.016,c=Math.abs(this.motionModel.vx-n),a=Math.abs(this.motionModel.vy-h),r=Math.sqrt(c*c+a*a);this.motionModel.confidence=Math.max(0,1-r/10)}else this.motionModel.confidence=.5}}isStaticScene(){return!(this.stateHistory.length<3)&&(Math.sqrt(this.motionModel.vx**2+this.motionModel.vy**2)<.5&&Math.abs(this.motionModel.vscale)<.01)}reset(){this.frameHistory=[],this.stateHistory=[],this.consecutiveSkips=0,this.motionModel={vx:0,vy:0,vtheta:0,vscale:0,confidence:0},this.blockMeans.fill(0),this.prevBlockMeans.fill(0)}configure(t){this.config={...this.config,...t}}}export{t as PredictiveCoding};

package/dist/core/perception/saccadic-controller.js

@@ -1,269 +1 @@
-/**
- * Saccadic Controller
- *
- * Mimics human eye saccades - rapid movements that redirect foveal attention
- * to areas of interest. The human eye makes 3-4 saccades per second to
- * build a complete picture of the visual scene.
- *
- * Strategy:
- * 1. Compute saliency map to find "interesting" regions
- * 2. Use tracking state to predict where features should be
- * 3. Generate priority-ordered list of "glance" targets
- * 4. Limit saccades per frame to balance coverage vs. efficiency
- */
-/**
- * A saccade target representing where attention should be directed
- * @typedef {Object} SaccadeTarget
- * @property {number} x - X coordinate
- * @property {number} y - Y coordinate
- * @property {number} priority - Priority (0 = highest)
- * @property {string} reason - Why this target was selected
- * @property {number} saliency - Saliency score at this location
- */
-class SaccadicController {
-    /**
-     * @param {number} width - Image width
-     * @param {number} height - Image height
-     * @param {Object} config - Configuration
-     */
-    constructor(width, height, config) {
-        this.width = width;
-        this.height = height;
-        this.config = config;
-        // Saccade history for inhibition of return
-        this.recentTargets = [];
-        this.inhibitionRadius = Math.min(width, height) * 0.1;
-        // Movement prediction
-        this.velocityHistory = [];
-        this.lastCenter = { x: width / 2, y: height / 2 };
-        // Grid for systematic coverage
-        this.gridCells = this._buildCoverageGrid(3, 3);
-        this.lastVisitedCell = 4; // Center
-        // State
-        this.lastSaccadeTime = 0;
-        this.saccadeCount = 0;
-    }
-    /**
-     * Build a grid for systematic coverage during tracking loss
-     * @private
-     */
-    _buildCoverageGrid(rows, cols) {
-        const cells = [];
-        const cellW = this.width / cols;
-        const cellH = this.height / rows;
-        for (let r = 0; r < rows; r++) {
-            for (let c = 0; c < cols; c++) {
-                cells.push({
-                    x: cellW * (c + 0.5),
-                    y: cellH * (r + 0.5),
-                    index: r * cols + c,
-                    lastVisit: 0,
-                });
-            }
-        }
-        return cells;
-    }
-    /**
-     * Compute saccade targets based on current state
-     *
-     * @param {Object} saliency - Saliency map result
-     * @param {Object} currentFovea - Current fovea center {x, y}
-     * @param {Object} trackingState - Current tracking state (optional)
-     * @returns {SaccadeTarget[]} Priority-ordered list of targets
-     */
-    computeTargets(saliency, currentFovea, trackingState = null) {
-        const targets = [];
-        const maxTargets = this.config.MAX_SACCADES_PER_FRAME;
-        // Strategy 1: Follow tracking prediction (highest priority)
-        if (trackingState && trackingState.isTracking) {
-            const predicted = this._predictTrackingCenter(trackingState);
-            if (predicted) {
-                targets.push({
-                    x: predicted.x,
-                    y: predicted.y,
-                    priority: 0,
-                    reason: 'tracking_prediction',
-                    saliency: 1.0,
-                });
-            }
-        }
-        // Strategy 2: High saliency regions
-        if (saliency && saliency.peaks) {
-            for (const peak of saliency.peaks) {
-                if (targets.length >= maxTargets)
-                    break;
-                // Skip if too close to existing targets (inhibition of return)
-                if (this._isInhibited(peak.x, peak.y, targets))
-                    continue;
-                if (peak.value > this.config.SALIENCY_THRESHOLD) {
-                    targets.push({
-                        x: peak.x,
-                        y: peak.y,
-                        priority: targets.length,
-                        reason: 'saliency_peak',
-                        saliency: peak.value,
-                    });
-                }
-            }
-        }
-        // Strategy 3: Systematic grid search (when not tracking)
-        if (!trackingState?.isTracking && targets.length < maxTargets) {
-            const gridTarget = this._getNextGridCell();
-            if (gridTarget && !this._isInhibited(gridTarget.x, gridTarget.y, targets)) {
-                targets.push({
-                    x: gridTarget.x,
-                    y: gridTarget.y,
-                    priority: targets.length,
-                    reason: 'grid_search',
-                    saliency: 0.5,
-                });
-            }
-        }
-        // Strategy 4: Stay at current center if no better options
-        if (targets.length === 0) {
-            targets.push({
-                x: currentFovea.x,
-                y: currentFovea.y,
-                priority: 0,
-                reason: 'maintain_position',
-                saliency: 0.3,
-            });
-        }
-        // Update history
-        this._updateHistory(targets);
-        return targets;
-    }
-    /**
-     * Predict center of tracking based on current state and velocity
-     * @private
-     */
-    _predictTrackingCenter(trackingState) {
-        if (!trackingState.worldMatrix)
-            return null;
-        // Extract center from world matrix
-        const matrix = trackingState.worldMatrix;
-        const cx = matrix[12] || this.width / 2;
-        const cy = matrix[13] || this.height / 2;
-        // Apply velocity-based prediction
-        if (this.velocityHistory.length >= 2) {
-            const vx = this._computeAverageVelocity('x');
-            const vy = this._computeAverageVelocity('y');
-            // Predict 1 frame ahead
-            return {
-                x: Math.max(0, Math.min(this.width - 1, cx + vx)),
-                y: Math.max(0, Math.min(this.height - 1, cy + vy)),
-            };
-        }
-        return { x: cx, y: cy };
-    }
-    /**
-     * Compute average velocity from history
-     * @private
-     */
-    _computeAverageVelocity(axis) {
-        if (this.velocityHistory.length < 2)
-            return 0;
-        let sum = 0;
-        for (let i = 1; i < this.velocityHistory.length; i++) {
-            sum += this.velocityHistory[i][axis] - this.velocityHistory[i - 1][axis];
-        }
-        return sum / (this.velocityHistory.length - 1);
-    }
-    /**
-     * Check if a location is inhibited (too close to recent targets)
-     * @private
-     */
-    _isInhibited(x, y, currentTargets) {
-        const r2 = this.inhibitionRadius ** 2;
-        // Check against current frame targets
-        for (const t of currentTargets) {
-            const dx = x - t.x;
-            const dy = y - t.y;
-            if (dx * dx + dy * dy < r2)
-                return true;
-        }
-        // Check against recent history
-        for (const t of this.recentTargets) {
-            const dx = x - t.x;
-            const dy = y - t.y;
-            if (dx * dx + dy * dy < r2)
-                return true;
-        }
-        return false;
-    }
-    /**
-     * Get next grid cell for systematic search
-     * @private
-     */
-    _getNextGridCell() {
-        // Find least recently visited cell
-        let oldest = this.gridCells[0];
-        let oldestTime = Infinity;
-        for (const cell of this.gridCells) {
-            if (cell.lastVisit < oldestTime) {
-                oldestTime = cell.lastVisit;
-                oldest = cell;
-            }
-        }
-        oldest.lastVisit = Date.now();
-        return oldest;
-    }
-    /**
-     * Update history with new targets
-     * @private
-     */
-    _updateHistory(targets) {
-        // Add to recent targets for inhibition of return
-        this.recentTargets.push(...targets);
-        // Keep only last N targets
-        const maxHistory = this.config.MOTION_HISTORY_FRAMES * this.config.MAX_SACCADES_PER_FRAME;
-        while (this.recentTargets.length > maxHistory) {
-            this.recentTargets.shift();
-        }
-        // Update velocity history
-        if (targets.length > 0) {
-            this.velocityHistory.push({ x: targets[0].x, y: targets[0].y });
-            while (this.velocityHistory.length > this.config.MOTION_HISTORY_FRAMES) {
-                this.velocityHistory.shift();
-            }
-            this.lastCenter = { x: targets[0].x, y: targets[0].y };
-        }
-        this.saccadeCount += targets.length;
-        this.lastSaccadeTime = Date.now();
-    }
-    /**
-     * Get the most likely location of interest based on history
-     * @returns {Object} {x, y} of predicted location
-     */
-    getPredictedLocation() {
-        if (this.velocityHistory.length >= 2) {
-            const vx = this._computeAverageVelocity('x');
-            const vy = this._computeAverageVelocity('y');
-            return {
-                x: Math.max(0, Math.min(this.width - 1, this.lastCenter.x + vx)),
-                y: Math.max(0, Math.min(this.height - 1, this.lastCenter.y + vy)),
-            };
-        }
-        return this.lastCenter;
-    }
-    /**
-     * Reset controller state
-     */
-    reset() {
-        this.recentTargets = [];
-        this.velocityHistory = [];
-        this.lastCenter = { x: this.width / 2, y: this.height / 2 };
-        this.saccadeCount = 0;
-        for (const cell of this.gridCells) {
-            cell.lastVisit = 0;
-        }
-    }
-    /**
-     * Update configuration
-     */
-    configure(config) {
-        this.config = { ...this.config, ...config };
-        this.inhibitionRadius = Math.min(this.width, this.height) * 0.1;
-    }
-}
-export { SaccadicController };
+class t{constructor(t,i,s){this.width=t,this.height=i,this.config=s,this.recentTargets=[],this.inhibitionRadius=.1*Math.min(t,i),this.velocityHistory=[],this.lastCenter={x:t/2,y:i/2},this.gridCells=this._buildCoverageGrid(3,3),this.lastVisitedCell=4,this.lastSaccadeTime=0,this.saccadeCount=0}_buildCoverageGrid(t,i){const s=[],e=this.width/i,h=this.height/t;for(let r=0;r<t;r++)for(let t=0;t<i;t++)s.push({x:e*(t+.5),y:h*(r+.5),index:r*i+t,lastVisit:0});return s}computeTargets(t,i,s=null){const e=[],h=this.config.MAX_SACCADES_PER_FRAME;if(s&&s.isTracking){const t=this._predictTrackingCenter(s);t&&e.push({x:t.x,y:t.y,priority:0,reason:"tracking_prediction",saliency:1})}if(t&&t.peaks)for(const i of t.peaks){if(e.length>=h)break;this._isInhibited(i.x,i.y,e)||i.value>this.config.SALIENCY_THRESHOLD&&e.push({x:i.x,y:i.y,priority:e.length,reason:"saliency_peak",saliency:i.value})}if(!s?.isTracking&&e.length<h){const t=this._getNextGridCell();t&&!this._isInhibited(t.x,t.y,e)&&e.push({x:t.x,y:t.y,priority:e.length,reason:"grid_search",saliency:.5})}return 0===e.length&&e.push({x:i.x,y:i.y,priority:0,reason:"maintain_position",saliency:.3}),this._updateHistory(e),e}_predictTrackingCenter(t){if(!t.worldMatrix)return null;const i=t.worldMatrix,s=i[12]||this.width/2,e=i[13]||this.height/2;if(this.velocityHistory.length>=2){const t=this._computeAverageVelocity("x"),i=this._computeAverageVelocity("y");return{x:Math.max(0,Math.min(this.width-1,s+t)),y:Math.max(0,Math.min(this.height-1,e+i))}}return{x:s,y:e}}_computeAverageVelocity(t){if(this.velocityHistory.length<2)return 0;let i=0;for(let s=1;s<this.velocityHistory.length;s++)i+=this.velocityHistory[s][t]-this.velocityHistory[s-1][t];return i/(this.velocityHistory.length-1)}_isInhibited(t,i,s){const e=this.inhibitionRadius**2;for(const h of s){const s=t-h.x,r=i-h.y;if(s*s+r*r<e)return!0}for(const s of this.recentTargets){const h=t-s.x,r=i-s.y;if(h*h+r*r<e)return!0}return!1}_getNextGridCell(){let t=this.gridCells[0],i=1/0;for(const s of this.gridCells)s.lastVisit<i&&(i=s.lastVisit,t=s);return t.lastVisit=Date.now(),t}_updateHistory(t){this.recentTargets.push(...t);const i=this.config.MOTION_HISTORY_FRAMES*this.config.MAX_SACCADES_PER_FRAME;for(;this.recentTargets.length>i;)this.recentTargets.shift();if(t.length>0){for(this.velocityHistory.push({x:t[0].x,y:t[0].y});this.velocityHistory.length>this.config.MOTION_HISTORY_FRAMES;)this.velocityHistory.shift();this.lastCenter={x:t[0].x,y:t[0].y}}this.saccadeCount+=t.length,this.lastSaccadeTime=Date.now()}getPredictedLocation(){if(this.velocityHistory.length>=2){const t=this._computeAverageVelocity("x"),i=this._computeAverageVelocity("y");return{x:Math.max(0,Math.min(this.width-1,this.lastCenter.x+t)),y:Math.max(0,Math.min(this.height-1,this.lastCenter.y+i))}}return this.lastCenter}reset(){this.recentTargets=[],this.velocityHistory=[],this.lastCenter={x:this.width/2,y:this.height/2},this.saccadeCount=0;for(const t of this.gridCells)t.lastVisit=0}configure(t){this.config={...this.config,...t},this.inhibitionRadius=.1*Math.min(this.width,this.height)}}export{t as SaccadicController};