@srsergio/taptapp-ar 1.1.1 → 1.1.3

package/dist/core/perception/bio-inspired-engine.js

@@ -1,232 +1 @@
-/**
- * Bio-Inspired Perception Engine
- *
- * Inspired by human visual system:
- * - Foveal attention: High resolution in center, low in periphery
- * - Saccadic sampling: Strategic "glances" at areas of interest
- * - Predictive coding: Only process what's unexpected/changed
- *
- * Expected improvements:
- * - ~75% reduction in pixels processed per frame
- * - ~80% reduction in latency for static scenes
- * - ~70% reduction in energy consumption
- */
-import { FovealAttention } from './foveal-attention.js';
-import { SaccadicController } from './saccadic-controller.js';
-import { PredictiveCoding } from './predictive-coding.js';
-import { SaliencyMap } from './saliency-map.js';
-import { ScaleOrchestrator } from './scale-orchestrator.js';
-/**
- * Configuration for Bio-Inspired Engine
- */
-const BIO_CONFIG = {
-    // Foveal region (high resolution center)
-    FOVEA_RADIUS_RATIO: 0.15, // 15% of image dimension
-    PARAFOVEA_RADIUS_RATIO: 0.30, // 30% of image dimension
-    // Resolution multipliers
-    FOVEA_RESOLUTION: 1.0, // Full resolution
-    PARAFOVEA_RESOLUTION: 0.5, // Half resolution
-    PERIPHERY_RESOLUTION: 0.25, // Quarter resolution
-    // Saccadic behavior
-    MAX_SACCADES_PER_FRAME: 3, // Maximum "glances" per frame
-    SACCADE_COOLDOWN_MS: 50, // Minimum time between saccades
-    SALIENCY_THRESHOLD: 0.3, // Threshold for triggering saccade
-    // Predictive coding
-    CHANGE_THRESHOLD: 0.05, // 5% pixel difference to trigger processing
-    PREDICTION_CONFIDENCE: 0.8, // Confidence to skip processing
-    MOTION_HISTORY_FRAMES: 3, // Frames to consider for motion prediction
-    // Performance
-    ENABLE_SKIP_FRAMES: true, // Skip processing if nothing changed
-    MIN_PROCESSING_INTERVAL_MS: 8, // Minimum 8ms (~120fps cap)
-    NUM_OCTAVES: 5, // Default number of octaves
-};
-/**
- * Main Bio-Inspired Perception Engine
- * Integrates all bio-inspired components for efficient AR processing
- */
-class BioInspiredEngine {
-    /**
-     * @param {number} width - Input image width
-     * @param {number} height - Input image height
-     * @param {Object} options - Configuration options
-     */
-    constructor(width, height, options = {}) {
-        this.width = width;
-        this.height = height;
-        this.config = { ...BIO_CONFIG, ...options };
-        // Initialize sub-components
-        this.fovealAttention = new FovealAttention(width, height, this.config);
-        this.saccadicController = new SaccadicController(width, height, this.config);
-        this.predictiveCoding = new PredictiveCoding(width, height, this.config);
-        this.saliencyMap = new SaliencyMap(width, height);
-        this.scaleOrchestrator = new ScaleOrchestrator(this.config.NUM_OCTAVES, {
-            debug: options.debugMode
-        });
-        // State tracking
-        this.currentFoveaCenter = { x: width / 2, y: height / 2 };
-        this.frameCount = 0;
-        this.lastProcessTime = 0;
-        this.skipCount = 0;
-        // Performance metrics
-        this.metrics = {
-            totalFrames: 0,
-            skippedFrames: 0,
-            avgPixelsProcessed: 0,
-            avgLatency: 0,
-            saccadeCount: 0,
-        };
-        // Pre-allocate buffers
-        this._initBuffers();
-    }
-    /**
-     * Initialize pre-allocated buffers for efficient processing
-     * @private
-     */
-    _initBuffers() {
-        const fullSize = this.width * this.height;
-        const foveaSize = Math.ceil(fullSize * this.config.FOVEA_RADIUS_RATIO ** 2 * Math.PI);
-        // Multi-resolution output buffer
-        this.outputBuffer = {
-            fovea: new Uint8Array(foveaSize),
-            parafovea: new Uint8Array(Math.ceil(foveaSize * 4)),
-            periphery: new Uint8Array(Math.ceil(fullSize * 0.25)),
-        };
-        // Change detection buffer
-        this.changeBuffer = new Float32Array(Math.ceil(fullSize / 64)); // 8x8 blocks
-    }
-    /**
-     * Process an input frame using bio-inspired techniques
-     *
-     * @param {Uint8Array} inputData - Grayscale input image
-     * @param {Object} trackingState - Current tracking state (optional)
-     * @returns {Object} Processed result with attention regions
-     */
-    process(inputData, trackingState = null) {
-        const startTime = performance.now();
-        this.frameCount++;
-        this.metrics.totalFrames++;
-        // Step 1: Predictive Coding - Check if we can skip processing
-        const prediction = this.predictiveCoding.predict(inputData, trackingState);
-        if (prediction.canSkip && this.config.ENABLE_SKIP_FRAMES) {
-            this.metrics.skippedFrames++;
-            this.skipCount++;
-            return {
-                skipped: true,
-                prediction: prediction.predictedState,
-                confidence: prediction.confidence,
-                pixelsProcessed: 0,
-                latency: performance.now() - startTime,
-            };
-        }
-        this.skipCount = 0;
-        // Step 2: Compute Saliency Map for attention guidance
-        const saliency = this.saliencyMap.compute(inputData);
-        // Step 3: Saccadic Controller - Decide where to "look"
-        const saccadeTargets = this.saccadicController.computeTargets(saliency, this.currentFoveaCenter, trackingState);
-        // Step 4: Extract foveal regions at different resolutions
-        const attentionRegions = [];
-        let totalPixelsProcessed = 0;
-        for (const target of saccadeTargets) {
-            const region = this.fovealAttention.extract(inputData, target.x, target.y, target.priority);
-            attentionRegions.push(region);
-            totalPixelsProcessed += region.pixelCount;
-            this.metrics.saccadeCount++;
-        }
-        // Step 5: Update fovea center based on highest priority target
-        if (saccadeTargets.length > 0) {
-            const primary = saccadeTargets[0];
-            this.currentFoveaCenter = { x: primary.x, y: primary.y };
-        }
-        // Step 6: Scale Orchestrator - Determine octaves to process
-        const octavesToProcess = this.scaleOrchestrator.getOctavesToProcess(trackingState);
-        // Step 7: Store frame for prediction
-        this.predictiveCoding.storeFrame(inputData, trackingState);
-        // Compute metrics
-        const latency = performance.now() - startTime;
-        this._updateMetrics(totalPixelsProcessed, latency);
-        return {
-            skipped: false,
-            attentionRegions,
-            foveaCenter: this.currentFoveaCenter,
-            saliencyPeaks: saliency.peaks,
-            octavesToProcess,
-            pixelsProcessed: totalPixelsProcessed,
-            pixelsSaved: this.width * this.height - totalPixelsProcessed,
-            savingsPercent: ((1 - totalPixelsProcessed / (this.width * this.height)) * 100).toFixed(1),
-            latency,
-        };
-    }
-    /**
-     * Get the primary attention region (highest resolution)
-     * This is the region that should be used for feature detection
-     *
-     * @param {Object} processResult - Result from process()
-     * @returns {Object} Primary attention region with data
-     */
-    getPrimaryRegion(processResult) {
-        if (processResult.skipped || !processResult.attentionRegions?.length) {
-            return null;
-        }
-        return processResult.attentionRegions[0];
-    }
-    /**
-     * Suggest optimal processing based on change detection
-     *
-     * @param {Uint8Array} inputData - Current frame
-     * @returns {Object} Processing suggestion
-     */
-    suggestProcessing(inputData) {
-        const changeLevel = this.predictiveCoding.getChangeLevel(inputData);
-        return {
-            shouldProcessFull: changeLevel > 0.3,
-            shouldProcessPartial: changeLevel > 0.05,
-            canSkip: changeLevel < 0.02,
-            changeLevel,
-            recommendedSaccades: Math.ceil(changeLevel * this.config.MAX_SACCADES_PER_FRAME),
-        };
-    }
-    /**
-     * Update performance metrics
-     * @private
-     */
-    _updateMetrics(pixelsProcessed, latency) {
-        const alpha = 0.1; // Exponential moving average factor
-        this.metrics.avgPixelsProcessed =
-            this.metrics.avgPixelsProcessed * (1 - alpha) + pixelsProcessed * alpha;
-        this.metrics.avgLatency =
-            this.metrics.avgLatency * (1 - alpha) + latency * alpha;
-    }
-    /**
-     * Get current performance metrics
-     * @returns {Object} Performance metrics
-     */
-    getMetrics() {
-        return {
-            ...this.metrics,
-            skipRate: ((this.metrics.skippedFrames / this.metrics.totalFrames) * 100).toFixed(1) + '%',
-            avgSavings: ((1 - this.metrics.avgPixelsProcessed / (this.width * this.height)) * 100).toFixed(1) + '%',
-            currentFovea: this.currentFoveaCenter,
-        };
-    }
-    /**
-     * Reset engine state (e.g., when target changes)
-     */
-    reset() {
-        this.currentFoveaCenter = { x: this.width / 2, y: this.height / 2 };
-        this.frameCount = 0;
-        this.skipCount = 0;
-        this.predictiveCoding.reset();
-        this.saccadicController.reset();
-    }
-    /**
-     * Configure engine at runtime
-     * @param {Object} options - Configuration options to update
-     */
-    configure(options) {
-        this.config = { ...this.config, ...options };
-        this.fovealAttention.configure(this.config);
-        this.saccadicController.configure(this.config);
-        this.predictiveCoding.configure(this.config);
-    }
-}
-export { BioInspiredEngine, BIO_CONFIG };
+import{FovealAttention as t}from"./foveal-attention.js";import{SaccadicController as e}from"./saccadic-controller.js";import{PredictiveCoding as i}from"./predictive-coding.js";import{SaliencyMap as s}from"./saliency-map.js";import{ScaleOrchestrator as r}from"./scale-orchestrator.js";const o={FOVEA_RADIUS_RATIO:.15,PARAFOVEA_RADIUS_RATIO:.3,FOVEA_RESOLUTION:1,PARAFOVEA_RESOLUTION:.5,PERIPHERY_RESOLUTION:.25,MAX_SACCADES_PER_FRAME:3,SACCADE_COOLDOWN_MS:50,SALIENCY_THRESHOLD:.3,CHANGE_THRESHOLD:.05,PREDICTION_CONFIDENCE:.8,MOTION_HISTORY_FRAMES:3,ENABLE_SKIP_FRAMES:!0,MIN_PROCESSING_INTERVAL_MS:8,NUM_OCTAVES:5};class c{constructor(c,n,a={}){this.width=c,this.height=n,this.config={...o,...a},this.fovealAttention=new t(c,n,this.config),this.saccadicController=new e(c,n,this.config),this.predictiveCoding=new i(c,n,this.config),this.saliencyMap=new s(c,n),this.scaleOrchestrator=new r(this.config.NUM_OCTAVES,{debug:a.debugMode}),this.currentFoveaCenter={x:c/2,y:n/2},this.frameCount=0,this.lastProcessTime=0,this.skipCount=0,this.metrics={totalFrames:0,skippedFrames:0,avgPixelsProcessed:0,avgLatency:0,saccadeCount:0},this._initBuffers()}_initBuffers(){const t=this.width*this.height,e=Math.ceil(t*this.config.FOVEA_RADIUS_RATIO**2*Math.PI);this.outputBuffer={fovea:new Uint8Array(e),parafovea:new Uint8Array(Math.ceil(4*e)),periphery:new Uint8Array(Math.ceil(.25*t))},this.changeBuffer=new Float32Array(Math.ceil(t/64))}process(t,e=null){const i=performance.now();this.frameCount++,this.metrics.totalFrames++;const s=this.predictiveCoding.predict(t,e);if(s.canSkip&&this.config.ENABLE_SKIP_FRAMES)return this.metrics.skippedFrames++,this.skipCount++,{skipped:!0,prediction:s.predictedState,confidence:s.confidence,pixelsProcessed:0,latency:performance.now()-i};this.skipCount=0;const r=this.saliencyMap.compute(t),o=this.saccadicController.computeTargets(r,this.currentFoveaCenter,e),c=[];let n=0;for(const e of o){const i=this.fovealAttention.extract(t,e.x,e.y,e.priority);c.push(i),n+=i.pixelCount,this.metrics.saccadeCount++}if(o.length>0){const t=o[0];this.currentFoveaCenter={x:t.x,y:t.y}}const a=this.scaleOrchestrator.getOctavesToProcess(e);this.predictiveCoding.storeFrame(t,e);const h=performance.now()-i;return this._updateMetrics(n,h),{skipped:!1,attentionRegions:c,foveaCenter:this.currentFoveaCenter,saliencyPeaks:r.peaks,octavesToProcess:a,pixelsProcessed:n,pixelsSaved:this.width*this.height-n,savingsPercent:(100*(1-n/(this.width*this.height))).toFixed(1),latency:h}}getPrimaryRegion(t){return t.skipped||!t.attentionRegions?.length?null:t.attentionRegions[0]}suggestProcessing(t){const e=this.predictiveCoding.getChangeLevel(t);return{shouldProcessFull:e>.3,shouldProcessPartial:e>.05,canSkip:e<.02,changeLevel:e,recommendedSaccades:Math.ceil(e*this.config.MAX_SACCADES_PER_FRAME)}}_updateMetrics(t,e){this.metrics.avgPixelsProcessed=.9*this.metrics.avgPixelsProcessed+.1*t,this.metrics.avgLatency=.9*this.metrics.avgLatency+.1*e}getMetrics(){return{...this.metrics,skipRate:(this.metrics.skippedFrames/this.metrics.totalFrames*100).toFixed(1)+"%",avgSavings:(100*(1-this.metrics.avgPixelsProcessed/(this.width*this.height))).toFixed(1)+"%",currentFovea:this.currentFoveaCenter}}reset(){this.currentFoveaCenter={x:this.width/2,y:this.height/2},this.frameCount=0,this.skipCount=0,this.predictiveCoding.reset(),this.saccadicController.reset()}configure(t){this.config={...this.config,...t},this.fovealAttention.configure(this.config),this.saccadicController.configure(this.config),this.predictiveCoding.configure(this.config)}}export{c as BioInspiredEngine,o as BIO_CONFIG};

package/dist/core/perception/foveal-attention.js

@@ -1,280 +1 @@
-/**
- * Foveal Attention System
- *
- * Mimics the human eye's fovea-parafovea-periphery structure:
- * - Fovea (center 5°): Maximum resolution, ~50% of visual processing power
- * - Parafovea (5-10°): Medium resolution, pattern recognition
- * - Periphery (>10°): Low resolution, motion detection
- *
- * This allows processing ~75% fewer pixels while maintaining
- * high-quality tracking in the area of interest.
- */
-/**
- * A region extracted at a specific resolution
- * @typedef {Object} AttentionRegion
- * @property {number} x - Center X coordinate in original image
- * @property {number} y - Center Y coordinate in original image
- * @property {number} radius - Radius in original image pixels
- * @property {number} resolution - Resolution multiplier (1.0 = full)
- * @property {Uint8Array} data - Extracted pixel data
- * @property {number} width - Width of extracted region
- * @property {number} height - Height of extracted region
- * @property {number} pixelCount - Number of pixels in region
- * @property {string} type - 'fovea' | 'parafovea' | 'periphery'
- */
-class FovealAttention {
-    /**
-     * @param {number} width - Input image width
-     * @param {number} height - Input image height
-     * @param {Object} config - Configuration
-     */
-    constructor(width, height, config) {
-        this.width = width;
-        this.height = height;
-        this.config = config;
-        // Calculate region sizes
-        this.minDim = Math.min(width, height);
-        this.foveaRadius = Math.floor(this.minDim * config.FOVEA_RADIUS_RATIO);
-        this.parafoveaRadius = Math.floor(this.minDim * config.PARAFOVEA_RADIUS_RATIO);
-        // Pre-allocate buffers for each region type
-        this._initBuffers();
-    }
-    /**
-     * Initialize pre-allocated extraction buffers
-     * @private
-     */
-    _initBuffers() {
-        // Fovea buffer (full resolution, circular region)
-        const foveaDiam = this.foveaRadius * 2;
-        this.foveaBuffer = new Uint8Array(foveaDiam * foveaDiam);
-        // Parafovea buffer (half resolution)
-        const parafoveaDiam = this.parafoveaRadius * 2;
-        const parafoveaScaled = Math.ceil(parafoveaDiam * this.config.PARAFOVEA_RESOLUTION);
-        this.parafoveaBuffer = new Uint8Array(parafoveaScaled * parafoveaScaled);
-        // Periphery buffer (quarter resolution, full image)
-        const periphW = Math.ceil(this.width * this.config.PERIPHERY_RESOLUTION);
-        const periphH = Math.ceil(this.height * this.config.PERIPHERY_RESOLUTION);
-        this.peripheryBuffer = new Uint8Array(periphW * periphH);
-        this.peripheryDims = { width: periphW, height: periphH };
-        // Mask for circular extraction (reusable)
-        this._buildCircularMask();
-    }
-    /**
-     * Build a circular mask for foveal extraction
-     * @private
-     */
-    _buildCircularMask() {
-        const r = this.foveaRadius;
-        const size = r * 2;
-        this.circularMask = new Uint8Array(size * size);
-        for (let y = 0; y < size; y++) {
-            for (let x = 0; x < size; x++) {
-                const dx = x - r;
-                const dy = y - r;
-                const dist = Math.sqrt(dx * dx + dy * dy);
-                this.circularMask[y * size + x] = dist <= r ? 1 : 0;
-            }
-        }
-    }
-    /**
-     * Extract attention region at specified center
-     *
-     * @param {Uint8Array} inputData - Grayscale input image
-     * @param {number} centerX - X coordinate of attention center
-     * @param {number} centerY - Y coordinate of attention center
-     * @param {number} priority - Priority level (0=highest)
-     * @returns {AttentionRegion} Extracted region
-     */
-    extract(inputData, centerX, centerY, priority = 0) {
-        // Clamp center to valid range
-        centerX = Math.max(this.foveaRadius, Math.min(this.width - this.foveaRadius - 1, centerX));
-        centerY = Math.max(this.foveaRadius, Math.min(this.height - this.foveaRadius - 1, centerY));
-        // Priority 0 = full foveal extraction
-        // Priority 1 = parafoveal only
-        // Priority 2+ = periphery glimpse
-        if (priority === 0) {
-            return this._extractFovea(inputData, centerX, centerY);
-        }
-        else if (priority === 1) {
-            return this._extractParafovea(inputData, centerX, centerY);
-        }
-        else {
-            return this._extractPeriphery(inputData);
-        }
-    }
-    /**
-     * Extract foveal region at full resolution
-     * @private
-     */
-    _extractFovea(inputData, cx, cy) {
-        const r = this.foveaRadius;
-        const diam = r * 2;
-        const buffer = this.foveaBuffer;
-        let idx = 0;
-        let validPixels = 0;
-        for (let dy = -r; dy < r; dy++) {
-            const y = cy + dy;
-            const rowStart = y * this.width;
-            for (let dx = -r; dx < r; dx++) {
-                const maskIdx = (dy + r) * diam + (dx + r);
-                if (this.circularMask[maskIdx]) {
-                    const x = cx + dx;
-                    buffer[idx] = inputData[rowStart + x];
-                    validPixels++;
-                }
-                else {
-                    buffer[idx] = 0;
-                }
-                idx++;
-            }
-        }
-        return {
-            x: cx,
-            y: cy,
-            radius: r,
-            resolution: this.config.FOVEA_RESOLUTION,
-            data: buffer,
-            width: diam,
-            height: diam,
-            pixelCount: validPixels,
-            type: 'fovea',
-            // Transform helpers
-            toOriginalCoord: (localX, localY) => ({
-                x: cx - r + localX,
-                y: cy - r + localY,
-            }),
-            toLocalCoord: (origX, origY) => ({
-                x: origX - (cx - r),
-                y: origY - (cy - r),
-            }),
-        };
-    }
-    /**
-     * Extract parafoveal region at half resolution
-     * @private
-     */
-    _extractParafovea(inputData, cx, cy) {
-        const r = this.parafoveaRadius;
-        const res = this.config.PARAFOVEA_RESOLUTION;
-        const scaledR = Math.ceil(r * res);
-        const scaledDiam = scaledR * 2;
-        const buffer = this.parafoveaBuffer;
-        const step = Math.round(1 / res);
-        let idx = 0;
-        let validPixels = 0;
-        for (let sy = 0; sy < scaledDiam; sy++) {
-            const y = cy - r + Math.floor(sy / res);
-            if (y < 0 || y >= this.height)
-                continue;
-            const rowStart = y * this.width;
-            for (let sx = 0; sx < scaledDiam; sx++) {
-                const x = cx - r + Math.floor(sx / res);
-                if (x < 0 || x >= this.width) {
-                    buffer[idx++] = 0;
-                    continue;
-                }
-                // Sample with bilinear interpolation for smoother downscaling
-                buffer[idx++] = inputData[rowStart + x];
-                validPixels++;
-            }
-        }
-        return {
-            x: cx,
-            y: cy,
-            radius: r,
-            resolution: res,
-            data: buffer,
-            width: scaledDiam,
-            height: scaledDiam,
-            pixelCount: validPixels,
-            type: 'parafovea',
-            toOriginalCoord: (localX, localY) => ({
-                x: cx - r + localX / res,
-                y: cy - r + localY / res,
-            }),
-            toLocalCoord: (origX, origY) => ({
-                x: (origX - (cx - r)) * res,
-                y: (origY - (cy - r)) * res,
-            }),
-        };
-    }
-    /**
-     * Extract periphery at quarter resolution (motion detection only)
-     * @private
-     */
-    _extractPeriphery(inputData) {
-        const res = this.config.PERIPHERY_RESOLUTION;
-        const outW = this.peripheryDims.width;
-        const outH = this.peripheryDims.height;
-        const buffer = this.peripheryBuffer;
-        const step = Math.round(1 / res);
-        let idx = 0;
-        for (let y = 0; y < this.height; y += step) {
-            const rowStart = y * this.width;
-            for (let x = 0; x < this.width; x += step) {
-                if (idx < buffer.length) {
-                    buffer[idx++] = inputData[rowStart + x];
-                }
-            }
-        }
-        return {
-            x: this.width / 2,
-            y: this.height / 2,
-            radius: Math.max(this.width, this.height) / 2,
-            resolution: res,
-            data: buffer,
-            width: outW,
-            height: outH,
-            pixelCount: outW * outH,
-            type: 'periphery',
-            toOriginalCoord: (localX, localY) => ({
-                x: localX / res,
-                y: localY / res,
-            }),
-            toLocalCoord: (origX, origY) => ({
-                x: origX * res,
-                y: origY * res,
-            }),
-        };
-    }
-    /**
-     * Get combined multi-resolution representation
-     * Uses fovea at center, parafovea around it, periphery for the rest
-     *
-     * @param {Uint8Array} inputData - Input image
-     * @param {number} cx - Fovea center X
-     * @param {number} cy - Fovea center Y
-     * @returns {Object} Multi-resolution representation
-     */
-    extractMultiResolution(inputData, cx, cy) {
-        return {
-            fovea: this._extractFovea(inputData, cx, cy),
-            parafovea: this._extractParafovea(inputData, cx, cy),
-            periphery: this._extractPeriphery(inputData),
-            center: { x: cx, y: cy },
-            totalPixels: this._computeTotalPixels(),
-            originalPixels: this.width * this.height,
-        };
-    }
-    /**
-     * Compute total pixels in multi-resolution representation
-     * @private
-     */
-    _computeTotalPixels() {
-        const foveaPixels = Math.PI * this.foveaRadius ** 2;
-        const parafoveaPixels = Math.PI * this.parafoveaRadius ** 2 * this.config.PARAFOVEA_RESOLUTION ** 2;
-        const peripheryPixels = this.peripheryDims.width * this.peripheryDims.height;
-        return Math.ceil(foveaPixels + parafoveaPixels + peripheryPixels);
-    }
-    /**
-     * Update configuration
-     * @param {Object} config - New configuration
-     */
-    configure(config) {
-        this.config = { ...this.config, ...config };
-        this.foveaRadius = Math.floor(this.minDim * config.FOVEA_RADIUS_RATIO);
-        this.parafoveaRadius = Math.floor(this.minDim * config.PARAFOVEA_RADIUS_RATIO);
-        this._initBuffers();
-    }
-}
-export { FovealAttention };
+class t{constructor(t,i,h){this.width=t,this.height=i,this.config=h,this.minDim=Math.min(t,i),this.foveaRadius=Math.floor(this.minDim*h.FOVEA_RADIUS_RATIO),this.parafoveaRadius=Math.floor(this.minDim*h.PARAFOVEA_RADIUS_RATIO),this._initBuffers()}_initBuffers(){const t=2*this.foveaRadius;this.foveaBuffer=new Uint8Array(t*t);const i=2*this.parafoveaRadius,h=Math.ceil(i*this.config.PARAFOVEA_RESOLUTION);this.parafoveaBuffer=new Uint8Array(h*h);const a=Math.ceil(this.width*this.config.PERIPHERY_RESOLUTION),e=Math.ceil(this.height*this.config.PERIPHERY_RESOLUTION);this.peripheryBuffer=new Uint8Array(a*e),this.peripheryDims={width:a,height:e},this._buildCircularMask()}_buildCircularMask(){const t=this.foveaRadius,i=2*t;this.circularMask=new Uint8Array(i*i);for(let h=0;h<i;h++)for(let a=0;a<i;a++){const e=a-t,s=h-t,r=Math.sqrt(e*e+s*s);this.circularMask[h*i+a]=r<=t?1:0}}extract(t,i,h,a=0){return i=Math.max(this.foveaRadius,Math.min(this.width-this.foveaRadius-1,i)),h=Math.max(this.foveaRadius,Math.min(this.height-this.foveaRadius-1,h)),0===a?this._extractFovea(t,i,h):1===a?this._extractParafovea(t,i,h):this._extractPeriphery(t)}_extractFovea(t,i,h){const a=this.foveaRadius,e=2*a,s=this.foveaBuffer;let r=0,o=0;for(let f=-a;f<a;f++){const n=(h+f)*this.width;for(let h=-a;h<a;h++){const c=(f+a)*e+(h+a);if(this.circularMask[c]){const a=i+h;s[r]=t[n+a],o++}else s[r]=0;r++}}return{x:i,y:h,radius:a,resolution:this.config.FOVEA_RESOLUTION,data:s,width:e,height:e,pixelCount:o,type:"fovea",toOriginalCoord:(t,e)=>({x:i-a+t,y:h-a+e}),toLocalCoord:(t,e)=>({x:t-(i-a),y:e-(h-a)})}}_extractParafovea(t,i,h){const a=this.parafoveaRadius,e=this.config.PARAFOVEA_RESOLUTION,s=2*Math.ceil(a*e),r=this.parafoveaBuffer;Math.round(1/e);let o=0,f=0;for(let n=0;n<s;n++){const c=h-a+Math.floor(n/e);if(c<0||c>=this.height)continue;const u=c*this.width;for(let h=0;h<s;h++){const s=i-a+Math.floor(h/e);s<0||s>=this.width?r[o++]=0:(r[o++]=t[u+s],f++)}}return{x:i,y:h,radius:a,resolution:e,data:r,width:s,height:s,pixelCount:f,type:"parafovea",toOriginalCoord:(t,s)=>({x:i-a+t/e,y:h-a+s/e}),toLocalCoord:(t,s)=>({x:(t-(i-a))*e,y:(s-(h-a))*e})}}_extractPeriphery(t){const i=this.config.PERIPHERY_RESOLUTION,h=this.peripheryDims.width,a=this.peripheryDims.height,e=this.peripheryBuffer,s=Math.round(1/i);let r=0;for(let i=0;i<this.height;i+=s){const h=i*this.width;for(let i=0;i<this.width;i+=s)r<e.length&&(e[r++]=t[h+i])}return{x:this.width/2,y:this.height/2,radius:Math.max(this.width,this.height)/2,resolution:i,data:e,width:h,height:a,pixelCount:h*a,type:"periphery",toOriginalCoord:(t,h)=>({x:t/i,y:h/i}),toLocalCoord:(t,h)=>({x:t*i,y:h*i})}}extractMultiResolution(t,i,h){return{fovea:this._extractFovea(t,i,h),parafovea:this._extractParafovea(t,i,h),periphery:this._extractPeriphery(t),center:{x:i,y:h},totalPixels:this._computeTotalPixels(),originalPixels:this.width*this.height}}_computeTotalPixels(){const t=Math.PI*this.foveaRadius**2,i=Math.PI*this.parafoveaRadius**2*this.config.PARAFOVEA_RESOLUTION**2,h=this.peripheryDims.width*this.peripheryDims.height;return Math.ceil(t+i+h)}configure(t){this.config={...this.config,...t},this.foveaRadius=Math.floor(this.minDim*t.FOVEA_RADIUS_RATIO),this.parafoveaRadius=Math.floor(this.minDim*t.PARAFOVEA_RADIUS_RATIO),this._initBuffers()}}export{t as FovealAttention};

package/dist/core/perception/index.js

@@ -1,17 +1 @@
-/**
- * Bio-Inspired Perception Module
- *
- * Human visual system-inspired components for efficient AR processing.
- * Expected improvements over traditional frame-based processing:
- *
- * - ~75% reduction in pixels processed per frame (foveal attention)
- * - ~80% reduction in latency for static scenes (predictive coding)
- * - ~70% reduction in energy consumption
- * - Maintains tracking accuracy through strategic attention allocation
- */
-export { BioInspiredEngine, BIO_CONFIG } from './bio-inspired-engine.js';
-export { FovealAttention } from './foveal-attention.js';
-export { SaccadicController } from './saccadic-controller.js';
-export { PredictiveCoding } from './predictive-coding.js';
-export { SaliencyMap } from './saliency-map.js';
-export { ScaleOrchestrator } from './scale-orchestrator.js';
+export{BioInspiredEngine,BIO_CONFIG}from"./bio-inspired-engine.js";export{FovealAttention}from"./foveal-attention.js";export{SaccadicController}from"./saccadic-controller.js";export{PredictiveCoding}from"./predictive-coding.js";export{SaliencyMap}from"./saliency-map.js";export{ScaleOrchestrator}from"./scale-orchestrator.js";