@srsergio/taptapp-ar 1.0.92 → 1.0.94

package/dist/runtime/bio-inspired-controller.js

@@ -0,0 +1,358 @@
+/**
+ * Bio-Inspired Controller Adapter
+ *
+ * Wraps the standard Controller with Bio-Inspired Perception capabilities.
+ * Provides significant performance improvements while maintaining API compatibility.
+ *
+ * Key features:
+ * - Foveal attention: Processes only regions of interest at full resolution
+ * - Predictive coding: Skips processing when scene is static
+ * - Saccadic sampling: Strategic "glances" at high-saliency regions
+ *
+ * Usage:
+ * ```javascript
+ * import { BioInspiredController } from './bio-inspired-controller.js';
+ *
+ * const controller = new BioInspiredController({
+ *   inputWidth: 640,
+ *   inputHeight: 480,
+ *   onUpdate: (data) => console.log(data),
+ *   bioInspired: {
+ *     enabled: true,
+ *     aggressiveSkipping: true,
+ *   }
+ * });
+ * ```
+ */
+import { Controller } from './controller.js';
+import { BioInspiredEngine } from '../core/perception/index.js';
+/**
+ * Bio-Inspired Controller
+ *
+ * Extends the standard Controller with bio-inspired perception capabilities.
+ */
+class BioInspiredController extends Controller {
+    bioEngine = null;
+    bioEnabled = true;
+    bioMetricsInterval = null;
+    lastBioResult = null;
+    constructor(options) {
+        super(options);
+        const bioOptions = options.bioInspired || {};
+        this.bioEnabled = bioOptions.enabled !== false;
+        if (this.bioEnabled) {
+            // Initialize Bio-Inspired Engine
+            const bioConfig = {};
+            if (bioOptions.foveaRadiusRatio !== undefined) {
+                bioConfig.FOVEA_RADIUS_RATIO = bioOptions.foveaRadiusRatio;
+            }
+            if (bioOptions.maxSaccades !== undefined) {
+                bioConfig.MAX_SACCADES_PER_FRAME = bioOptions.maxSaccades;
+            }
+            if (bioOptions.aggressiveSkipping !== undefined) {
+                bioConfig.ENABLE_SKIP_FRAMES = bioOptions.aggressiveSkipping;
+                if (bioOptions.aggressiveSkipping) {
+                    bioConfig.CHANGE_THRESHOLD = 0.03; // More aggressive
+                }
+            }
+            this.bioEngine = new BioInspiredEngine(options.inputWidth, options.inputHeight, bioConfig);
+        }
+    }
+    /**
+     * Override processVideo to add bio-inspired perception
+     */
+    processVideo(input) {
+        if (!this.bioEnabled || !this.bioEngine) {
+            return super.processVideo(input);
+        }
+        if (this.processingVideo)
+            return;
+        this.processingVideo = true;
+        // Reset tracking states
+        this.trackingStates = [];
+        for (let i = 0; i < (this.markerDimensions?.length || 0); i++) {
+            this.trackingStates.push({
+                showing: false,
+                isTracking: false,
+                currentModelViewTransform: null,
+                trackCount: 0,
+                trackMiss: 0,
+            });
+        }
+        const startProcessing = async () => {
+            while (this.processingVideo) {
+                const inputData = this.inputLoader.loadInput(input);
+                // Get current tracking state for bio engine
+                const activeTracking = this.trackingStates.find(s => s.isTracking);
+                const trackingState = activeTracking ? {
+                    isTracking: true,
+                    activeOctave: activeTracking.lastOctaveIndex, // Tracked octave index
+                    worldMatrix: activeTracking.currentModelViewTransform
+                        ? this._flattenMatrix(activeTracking.currentModelViewTransform)
+                        : null
+                } : null;
+                // Process through bio-inspired engine
+                const bioResult = this.bioEngine.process(inputData, trackingState || undefined);
+                this.lastBioResult = bioResult;
+                // If bio engine says we can skip, use prediction
+                if (bioResult.skipped && activeTracking?.isTracking) {
+                    // Use predicted state
+                    this._handleSkippedFrame(activeTracking, bioResult);
+                }
+                else {
+                    // Normal processing with attention regions
+                    await this._processWithAttention(input, inputData, bioResult);
+                }
+                // Wait for next frame
+                if (typeof requestAnimationFrame !== 'undefined') {
+                    await new Promise(requestAnimationFrame);
+                }
+                else {
+                    await new Promise(resolve => setTimeout(resolve, 16));
+                }
+            }
+        };
+        startProcessing();
+    }
+    /**
+     * Handle a skipped frame using prediction
+     * @private
+     */
+    _handleSkippedFrame(trackingState, bioResult) {
+        // Use predicted matrix
+        if (bioResult.prediction && bioResult.prediction.worldMatrix) {
+            trackingState.currentModelViewTransform = this._unflattenMatrix(bioResult.prediction.worldMatrix);
+        }
+        // Notify with skipped status
+        const worldMatrix = trackingState.currentModelViewTransform
+            ? this._glModelViewMatrix(trackingState.currentModelViewTransform, 0)
+            : null;
+        this.onUpdate?.({
+            type: 'updateMatrix',
+            targetIndex: 0,
+            worldMatrix: worldMatrix ? this.featureManager.applyWorldMatrixFilters(0, worldMatrix, { stability: 0.9 }) : null,
+            skipped: true,
+            bioMetrics: this.bioEngine?.getMetrics(),
+        });
+        this.onUpdate?.({ type: 'processDone' });
+    }
+    /**
+     * Process frame using bio-inspired attention regions
+     * @private
+     */
+    async _processWithAttention(input, inputData, bioResult) {
+        const nTracking = this.trackingStates.reduce((acc, s) => acc + (s.isTracking ? 1 : 0), 0);
+        // Detection phase - use primary attention region for efficiency
+        if (nTracking < this.maxTrack) {
+            const matchingIndexes = this.trackingStates
+                .map((s, i) => ({ state: s, index: i }))
+                .filter(({ state, index }) => !state.isTracking &&
+                (this.interestedTargetIndex === -1 || this.interestedTargetIndex === index))
+                .map(({ index }) => index);
+            if (matchingIndexes.length > 0) {
+                // Use full input for detection (bio engine already optimized upstream processing)
+                const { targetIndex: matchedTargetIndex, modelViewTransform, featurePoints } = await this._detectAndMatch(inputData, matchingIndexes, bioResult.octavesToProcess || null);
+                if (matchedTargetIndex !== -1) {
+                    this.trackingStates[matchedTargetIndex].isTracking = true;
+                    this.trackingStates[matchedTargetIndex].currentModelViewTransform = modelViewTransform;
+                    // Update bio engine fovea to focus on detected target
+                    if (bioResult.attentionRegions?.[0]) {
+                        this.bioEngine?.reset();
+                    }
+                }
+                this.onUpdate?.({ type: 'featurePoints', featurePoints });
+            }
+        }
+        // Tracking phase
+        for (let i = 0; i < this.trackingStates.length; i++) {
+            const trackingState = this.trackingStates[i];
+            if (trackingState.isTracking) {
+                const result = await this._trackAndUpdate(inputData, trackingState.currentModelViewTransform, i);
+                if (!result || !result.modelViewTransform) {
+                    trackingState.isTracking = false;
+                    trackingState.screenCoords = result?.screenCoords || [];
+                    trackingState.reliabilities = result?.reliabilities || [];
+                    trackingState.stabilities = result?.stabilities || [];
+                }
+                else {
+                    trackingState.currentModelViewTransform = result.modelViewTransform;
+                    trackingState.screenCoords = result.screenCoords;
+                    trackingState.reliabilities = result.reliabilities;
+                    trackingState.stabilities = result.stabilities;
+                    trackingState.deformedMesh = result.deformedMesh;
+                }
+            }
+            const wasShowing = trackingState.showing;
+            trackingState.showing = this.featureManager.shouldShow(i, trackingState.isTracking);
+            if (wasShowing && !trackingState.showing) {
+                trackingState.trackingMatrix = null;
+                this.featureManager.notifyUpdate({ type: 'reset', targetIndex: i });
+            }
+            // Emit update
+            if (trackingState.showing || trackingState.screenCoords?.length > 0 || (wasShowing && !trackingState.showing)) {
+                const worldMatrix = trackingState.showing
+                    ? this._glModelViewMatrix(trackingState.currentModelViewTransform, i)
+                    : null;
+                let finalMatrix = null;
+                if (worldMatrix) {
+                    const stabilities = trackingState.stabilities || [];
+                    const avgStability = stabilities.length > 0
+                        ? stabilities.reduce((a, b) => a + b, 0) / stabilities.length
+                        : 0;
+                    finalMatrix = this.featureManager.applyWorldMatrixFilters(i, worldMatrix, { stability: avgStability });
+                    trackingState.trackingMatrix = finalMatrix;
+                    const isInputRotated = input.width === this.inputHeight && input.height === this.inputWidth;
+                    if (isInputRotated) {
+                        const rotationFeature = this.featureManager.getFeature('auto-rotation');
+                        if (rotationFeature) {
+                            finalMatrix = rotationFeature.rotate(finalMatrix);
+                        }
+                    }
+                }
+                this.onUpdate?.({
+                    type: 'updateMatrix',
+                    targetIndex: i,
+                    worldMatrix: finalMatrix,
+                    modelViewTransform: trackingState.currentModelViewTransform,
+                    screenCoords: trackingState.screenCoords,
+                    reliabilities: trackingState.reliabilities,
+                    stabilities: trackingState.stabilities,
+                    deformedMesh: trackingState.deformedMesh,
+                    bioMetrics: this.bioEngine?.getMetrics(),
+                    foveaCenter: bioResult.foveaCenter,
+                    pixelsSaved: bioResult.pixelsSaved,
+                });
+            }
+        }
+        this.onUpdate?.({ type: 'processDone' });
+    }
+    /**
+     * Detect and match features, optionally limited to specific octaves
+     */
+    async _detectAndMatch(inputData, targetIndexes, octavesToProcess = null) {
+        // 🚀 NANITE-STYLE: Estimate scale for filtered matching
+        let predictedScale = undefined;
+        for (const state of this.trackingStates) {
+            if (state.isTracking && state.currentModelViewTransform) {
+                const m = state.currentModelViewTransform;
+                predictedScale = Math.sqrt(m[0][0] ** 2 + m[1][0] ** 2 + m[2][0] ** 2);
+                break;
+            }
+        }
+        const { targetIndex, modelViewTransform, screenCoords, worldCoords, featurePoints } = await this._workerMatch(null, // No feature points, worker will detect from inputData
+        targetIndexes, inputData, predictedScale, octavesToProcess);
+        return { targetIndex, modelViewTransform, screenCoords, worldCoords, featurePoints };
+    }
+    /**
+     * Communicate with worker for matching phase
+     */
+    _workerMatch(featurePoints, targetIndexes, inputData = null, expectedScale, octavesToProcess = null) {
+        return new Promise((resolve) => {
+            if (!this.worker) {
+                // If no feature points but we have input data, detect first
+                let fpPromise;
+                if (!featurePoints && inputData) {
+                    fpPromise = Promise.resolve(this.fullDetector.detect(inputData, { octavesToProcess }).featurePoints);
+                }
+                else {
+                    fpPromise = Promise.resolve(featurePoints);
+                }
+                fpPromise.then(fp => {
+                    this._matchOnMainThread(fp, targetIndexes, expectedScale).then(resolve);
+                }).catch(() => resolve({ targetIndex: -1 }));
+                return;
+            }
+            const timeout = setTimeout(() => {
+                this.workerMatchDone = null;
+                resolve({ targetIndex: -1 });
+            }, 1000);
+            this.workerMatchDone = (data) => {
+                clearTimeout(timeout);
+                this.workerMatchDone = null;
+                resolve(data);
+            };
+            if (inputData) {
+                this.worker.postMessage({ type: "match", inputData, targetIndexes, octavesToProcess, expectedScale });
+            }
+            else {
+                this.worker.postMessage({ type: "match", featurePoints: featurePoints, targetIndexes, expectedScale });
+            }
+        });
+    }
+    /**
+     * Override _trackAndUpdate to capture active octave for the next frame's orchestration
+     */
+    async _trackAndUpdate(inputData, lastModelViewTransform, targetIndex) {
+        const result = await super._trackAndUpdate(inputData, lastModelViewTransform, targetIndex);
+        if (result && result.octaveIndex !== undefined) {
+            this.trackingStates[targetIndex].lastOctaveIndex = result.octaveIndex;
+        }
+        return result;
+    }
+    /**
+     * Flatten a 3x4 matrix to Float32Array
+     * @private
+     */
+    _flattenMatrix(matrix) {
+        const result = new Float32Array(16);
+        for (let i = 0; i < 3; i++) {
+            for (let j = 0; j < 4; j++) {
+                result[i * 4 + j] = matrix[i][j];
+            }
+        }
+        result[12] = 0;
+        result[13] = 0;
+        result[14] = 0;
+        result[15] = 1;
+        return result;
+    }
+    /**
+     * Unflatten Float32Array to 3x4 matrix
+     * @private
+     */
+    _unflattenMatrix(flat) {
+        return [
+            [flat[0], flat[1], flat[2], flat[3]],
+            [flat[4], flat[5], flat[6], flat[7]],
+            [flat[8], flat[9], flat[10], flat[11]],
+        ];
+    }
+    /**
+     * Get bio-inspired engine metrics
+     */
+    getBioMetrics() {
+        return this.bioEngine?.getMetrics() || null;
+    }
+    /**
+     * Get last bio processing result
+     */
+    getLastBioResult() {
+        return this.lastBioResult;
+    }
+    /**
+     * Enable/disable bio-inspired processing dynamically
+     */
+    setBioEnabled(enabled) {
+        this.bioEnabled = enabled;
+        if (enabled && !this.bioEngine) {
+            this.bioEngine = new BioInspiredEngine(this.inputWidth, this.inputHeight);
+        }
+    }
+    /**
+     * Configure bio-inspired engine at runtime
+     */
+    configureBio(options) {
+        this.bioEngine?.configure(options);
+    }
+    /**
+     * Override dispose to clean up bio engine
+     */
+    dispose() {
+        super.dispose();
+        this.bioEngine = null;
+        if (this.bioMetricsInterval) {
+            clearInterval(this.bioMetricsInterval);
+        }
+    }
+}
+export { BioInspiredController };

package/dist/runtime/controller.d.ts

@@ -68,17 +68,26 @@ declare class Controller {
         featurePoints: any;
     }>;
     _trackAndUpdate(inputData: any, lastModelViewTransform: number[][], targetIndex: number): Promise<{
+        modelViewTransform: null;
+        screenCoords: never[];
+        reliabilities: never[];
+        stabilities: never[];
+        deformedMesh: null;
+        octaveIndex?: undefined;
+    } | {
         modelViewTransform: null;
         screenCoords: any[];
         reliabilities: number[];
         stabilities: number[];
         deformedMesh?: undefined;
+        octaveIndex?: undefined;
     } | {
         modelViewTransform: any;
         screenCoords: any[];
         reliabilities: number[];
         stabilities: number[];
         deformedMesh: any;
+        octaveIndex: any;
     }>;
     processVideo(input: any): void;
     stopProcessVideo(): void;
@@ -121,9 +130,9 @@ declare class Controller {
         debugExtra: {};
     }>;
     trackUpdate(modelViewTransform: number[][], trackFeatures: any): Promise<any>;
-    _workerMatch(featurePoints: any, targetIndexes: number[], inputData?: any): Promise<any>;
+    _workerMatch(featurePoints: any, targetIndexes: number[], inputData?: any, expectedScale?: number): Promise<any>;
     _workerTrack(inputData: any, lastModelViewTransform: number[][], targetIndex: number): Promise<any>;
-    _matchOnMainThread(featurePoints: any, targetIndexes: number[]): Promise<{
+    _matchOnMainThread(featurePoints: any, targetIndexes: number[], expectedScale?: number): Promise<{
         targetIndex: number;
         modelViewTransform: any;
         screenCoords: any;

package/dist/runtime/controller.js

@@ -192,8 +192,19 @@ class Controller {
         return this._glModelViewMatrix(modelViewTransform, targetIndex);
     }
     async _detectAndMatch(inputData, targetIndexes) {
+        // 🚀 NANITE-STYLE: Estimate scale for filtered matching
+        // If we were already tracking a target, use its scale as a hint for faster matching
+        let predictedScale = undefined;
+        for (const state of this.trackingStates) {
+            if (state.isTracking && state.currentModelViewTransform) {
+                const m = state.currentModelViewTransform;
+                // Vector magnitude of the first column is a good approximation of the scale
+                predictedScale = Math.sqrt(m[0][0] ** 2 + m[1][0] ** 2 + m[2][0] ** 2);
+                break;
+            }
+        }
         const { targetIndex, modelViewTransform, screenCoords, worldCoords, featurePoints } = await this._workerMatch(null, // No feature points, worker will detect from inputData
-        targetIndexes, inputData);
+        targetIndexes, inputData, predictedScale);
         return { targetIndex, modelViewTransform, screenCoords, worldCoords, featurePoints };
     }
     async _trackAndUpdate(inputData, lastModelViewTransform, targetIndex) {
@@ -279,7 +290,8 @@ class Controller {
             screenCoords: finalScreenCoords,
             reliabilities: finalReliabilities,
             stabilities: finalStabilities,
-            deformedMesh
+            deformedMesh,
+            octaveIndex // Pass this up for the orchestrator
         };
     }
     processVideo(input) {
@@ -414,7 +426,7 @@ class Controller {
             return null;
         return this._workerTrackUpdate(modelViewTransform, trackFeatures);
     }
-    _workerMatch(featurePoints, targetIndexes, inputData = null) {
+    _workerMatch(featurePoints, targetIndexes, inputData = null, expectedScale) {
         return new Promise((resolve) => {
             if (!this.worker) {
                 // If no feature points but we have input data, detect first
@@ -426,7 +438,7 @@ class Controller {
                     fpPromise = Promise.resolve(featurePoints);
                 }
                 fpPromise.then(fp => {
-                    this._matchOnMainThread(fp, targetIndexes).then(resolve);
+                    this._matchOnMainThread(fp, targetIndexes, expectedScale).then(resolve);
                 }).catch(() => resolve({ targetIndex: -1 }));
                 return;
             }
@@ -447,10 +459,10 @@ class Controller {
                 });
             };
             if (inputData) {
-                this.worker.postMessage({ type: "match", inputData, targetIndexes });
+                this.worker.postMessage({ type: "match", inputData, targetIndexes, expectedScale });
             }
             else {
-                this.worker.postMessage({ type: "match", featurePoints: featurePoints, targetIndexes });
+                this.worker.postMessage({ type: "match", featurePoints: featurePoints, targetIndexes, expectedScale });
             }
         });
     }
@@ -477,7 +489,7 @@ class Controller {
             });
         });
     }
-    async _matchOnMainThread(featurePoints, targetIndexes) {
+    async _matchOnMainThread(featurePoints, targetIndexes, expectedScale) {
         if (!this.mainThreadMatcher) {
             const { Matcher } = await import("../core/matching/matcher.js");
             const { Estimator } = await import("../core/estimation/estimator.js");
@@ -491,7 +503,7 @@ class Controller {
         let matchedDebugExtra = null;
         for (let i = 0; i < targetIndexes.length; i++) {
             const matchingIndex = targetIndexes[i];
-            const { keyframeIndex, screenCoords, worldCoords, debugExtra } = this.mainThreadMatcher.matchDetection(this.matchingDataList[matchingIndex], featurePoints);
+            const { keyframeIndex, screenCoords, worldCoords, debugExtra } = this.mainThreadMatcher.matchDetection(this.matchingDataList[matchingIndex], featurePoints, expectedScale);
             matchedDebugExtra = debugExtra;
             if (keyframeIndex !== -1) {
                 const modelViewTransform = this.mainThreadEstimator.estimate({ screenCoords, worldCoords });

package/dist/runtime/controller.worker.js

@@ -34,12 +34,12 @@ onmessage = (msg) => {
             // New: If the worker received image data, run detector here too
             let featurePoints = data.featurePoints;
             if (data.inputData) {
-                const detectionResult = detector.detect(data.inputData);
+                const detectionResult = detector.detect(data.inputData, { octavesToProcess: data.octavesToProcess });
                 featurePoints = detectionResult.featurePoints;
             }
             for (let i = 0; i < interestedTargetIndexes.length; i++) {
                 const matchingIndex = interestedTargetIndexes[i];
-                const { keyframeIndex, screenCoords, worldCoords, debugExtra } = matcher.matchDetection(matchingDataList[matchingIndex], featurePoints);
+                const { keyframeIndex, screenCoords, worldCoords, debugExtra } = matcher.matchDetection(matchingDataList[matchingIndex], featurePoints, data.expectedScale);
                 matchedDebugExtra = debugExtra;
                 if (keyframeIndex !== -1) {
                     const modelViewTransform = estimator.estimate({ screenCoords, worldCoords });

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@srsergio/taptapp-ar",
-    "version": "1.0.92",
+    "version": "1.0.94",
     "description": "Ultra-fast Augmented Reality (AR) SDK for Node.js and Browser. Image tracking with 100% pure JavaScript, zero-dependencies, and high-performance compilation.",
     "keywords": [
         "augmented reality",

package/src/compiler/offline-compiler.ts

@@ -94,36 +94,51 @@ export class OfflineCompiler {
         const results = [];
         for (let i = 0; i < targetImages.length; i++) {
             const targetImage = targetImages[i];
-            const fullImageList = buildImageList(targetImage);
-            // 🚀 MOONSHOT: Keep many scales for better robustness
-            const imageList = fullImageList;
-            const percentPerImageScale = percentPerImage / imageList.length;
-
-            const keyframes = [];
-
-            for (const image of imageList as any[]) {
-                const detector = new DetectorLite(image.width, image.height, { useLSH: AR_CONFIG.USE_LSH, maxFeaturesPerBucket: AR_CONFIG.MAX_FEATURES_PER_BUCKET });
-                const { featurePoints: ps } = detector.detect(image.data);
-
-                const maximaPoints = ps.filter((p: any) => p.maxima);
-                const minimaPoints = ps.filter((p: any) => !p.maxima);
-                const maximaPointsCluster = hierarchicalClusteringBuild({ points: maximaPoints });
-                const minimaPointsCluster = hierarchicalClusteringBuild({ points: minimaPoints });
-
-                keyframes.push({
-                    maximaPoints,
-                    minimaPoints,
-                    maximaPointsCluster,
-                    minimaPointsCluster,
-                    width: image.width,
-                    height: image.height,
-                    scale: image.scale,
-                });
-                currentPercent += percentPerImageScale;
-                progressCallback(currentPercent);
+
+            // 🚀 NANITE-STYLE: Only process the target at scale 1.0
+            // The DetectorLite already builds its own pyramid and finds features at all octaves (virtualized LOD)
+            const detector = new DetectorLite(targetImage.width, targetImage.height, {
+                useLSH: AR_CONFIG.USE_LSH,
+                maxFeaturesPerBucket: AR_CONFIG.MAX_FEATURES_PER_BUCKET
+            });
+            const { featurePoints: rawPs } = detector.detect(targetImage.data);
+
+            // 🎯 Stratified Sampling: Ensure we have features from ALL scales
+            // We take the top N features per octave to guarantee scale coverage (Nanite-style)
+            const octaves = [0, 1, 2, 3, 4, 5];
+            const ps: any[] = [];
+            const featuresPerOctave = 300;
+
+            for (const oct of octaves) {
+                const octScale = Math.pow(2, oct);
+                const octFeatures = rawPs
+                    .filter(p => Math.abs(p.scale - octScale) < 0.1)
+                    .sort((a, b) => (b.score || 0) - (a.score || 0))
+                    .slice(0, featuresPerOctave);
+                ps.push(...octFeatures);
             }
 
-            results.push(keyframes);
+            const maximaPoints = ps.filter((p: any) => p.maxima);
+            const minimaPoints = ps.filter((p: any) => !p.maxima);
+            const maximaPointsCluster = hierarchicalClusteringBuild({ points: maximaPoints });
+            const minimaPointsCluster = hierarchicalClusteringBuild({ points: minimaPoints });
+
+            const keyframe = {
+                maximaPoints,
+                minimaPoints,
+                maximaPointsCluster,
+                minimaPointsCluster,
+                width: targetImage.width,
+                height: targetImage.height,
+                scale: 1.0,
+            };
+
+            // Wrapped in array because the protocol expects matchingData to be an array of keyframes
+            // We provide only one keyframe containing features from all octaves
+            results.push([keyframe]);
+
+            currentPercent += percentPerImage;
+            progressCallback(currentPercent);
         }
 
         return results;
@@ -204,14 +219,19 @@ export class OfflineCompiler {
                         }
                     };
                 }),
-                matchingData: item.matchingData.map((kf: any) => ({
-                    w: kf.width,
-                    h: kf.height,
-                    s: kf.scale,
-                    hdc: false,
-                    max: protocol.columnarize(kf.maximaPoints, kf.maximaPointsCluster, kf.width, kf.height, false),
-                    min: protocol.columnarize(kf.minimaPoints, kf.minimaPointsCluster, kf.width, kf.height, false),
-                })),
+                matchingData: item.matchingData.map((kf: any) => {
+                    const useCompact = AR_CONFIG.USE_COMPACT_DESCRIPTORS;
+                    const columnarizeFn = useCompact ? protocol.columnarizeCompact : protocol.columnarize;
+                    return {
+                        w: kf.width,
+                        h: kf.height,
+                        s: kf.scale,
+                        hdc: false,
+                        max: columnarizeFn(kf.maximaPoints, kf.maximaPointsCluster, kf.width, kf.height),
+                        min: columnarizeFn(kf.minimaPoints, kf.minimaPointsCluster, kf.width, kf.height),
+                    };
+                }),
+
             };
         });
 

package/src/core/constants.ts

@@ -29,7 +29,7 @@ export const AR_CONFIG = {
 
     // Image processing / Scale list
     MIN_IMAGE_PIXEL_SIZE: 32,
-    SCALE_STEP_EXPONENT: 0.6,
+    SCALE_STEP_EXPONENT: 1.0,  // Optimized: was 0.6, now 1.0 (reduces scales from ~7 to ~4)
     TRACKING_DOWNSCALE_LEVEL_1: 256.0,
     TRACKING_DOWNSCALE_LEVEL_2: 128.0,
 
@@ -38,4 +38,8 @@ export const AR_CONFIG = {
     MISS_TOLERANCE: 1,
     ONE_EURO_FILTER_CUTOFF: 0.5,
     ONE_EURO_FILTER_BETA: 0.1,
+
+    // TAAR Size Optimization
+    USE_COMPACT_DESCRIPTORS: true,  // 32-bit XOR folded descriptors vs 64-bit raw
+    COMPACT_HAMMING_THRESHOLD: 8,   // Threshold for 32-bit descriptors (vs 15 for 64-bit)
 };