@srsergio/taptapp-ar 1.0.84 → 1.0.86

package/dist/core/protocol.js

@@ -0,0 +1,195 @@
+import * as msgpack from "@msgpack/msgpack";
+export const CURRENT_VERSION = 7;
+/**
+ * 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) {
+    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 * 2);
+    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) {
+            descriptors[i * 2] = points[i].descriptors[0];
+            descriptors[(i * 2) + 1] = points[i].descriptors[1];
+        }
+    }
+    return {
+        x,
+        y,
+        a: angle,
+        s: scale,
+        d: 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;
+            }
+        }
+        // 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) {
+                    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,
+    });
+}

package/dist/{compiler → core}/tracker/tracker.js

@@ -1,7 +1,7 @@
 import { buildModelViewProjectionTransform, computeScreenCoordiate } from "../estimation/utils.js";
 const AR2_DEFAULT_TS = 6;
 const AR2_DEFAULT_TS_GAP = 1;
-const AR2_SEARCH_SIZE = 25; // Reduced from 34 to 25 to prevent background latching
+const AR2_SEARCH_SIZE = 12; // Reduced from 25 to 12 for high-speed tracking (25 is overkill)
 const AR2_SEARCH_GAP = 1;
 const AR2_SIM_THRESH = 0.65; // Increased from 0.6 to reduce false positives
 const TRACKING_KEYFRAME = 0; // 0: 128px (optimized)
@@ -118,7 +118,8 @@ class Tracker {
         if (this.debugMode) {
             debugExtra = {
                 octaveIndex,
-                projectedImage: Array.from(projectedImage),
+                // Remove Array.from to avoid massive GC pressure
+                projectedImage: projectedImage,
                 matchingPoints,
                 goodTrack,
                 trackedPoints: screenCoords,

package/dist/index.d.ts

@@ -2,5 +2,6 @@ export * from "./react/types.js";
 export * from "./react/TaptappAR.js";
 export * from "./react/use-ar.js";
 export * from "./compiler/offline-compiler.js";
-export { Controller } from "./compiler/controller.js";
-export { SimpleAR } from "./compiler/simple-ar.js";
+export { Controller } from "./runtime/controller.js";
+export { SimpleAR } from "./runtime/simple-ar.js";
+export * as protocol from "./core/protocol.js";

package/dist/index.js

@@ -2,5 +2,6 @@ export * from "./react/types.js";
 export * from "./react/TaptappAR.js";
 export * from "./react/use-ar.js";
 export * from "./compiler/offline-compiler.js";
-export { Controller } from "./compiler/controller.js";
-export { SimpleAR } from "./compiler/simple-ar.js";
+export { Controller } from "./runtime/controller.js";
+export { SimpleAR } from "./runtime/simple-ar.js";
+export * as protocol from "./core/protocol.js";

package/dist/react/use-ar.js

@@ -31,7 +31,7 @@ export const useAR = (config) => {
         const initAR = async () => {
             try {
                 // Safe hybrid import for SSR + Speed
-                const { SimpleAR } = await import("../compiler/simple-ar.js");
+                const { SimpleAR } = await import("../runtime/simple-ar.js");
                 if (!isMounted)
                     return;
                 const instance = new SimpleAR({

package/dist/{compiler → runtime}/controller.d.ts

@@ -1,7 +1,7 @@
-import { Tracker } from "./tracker/tracker.js";
-import { InputLoader } from "./input-loader.js";
-import { FeatureManager } from "./features/feature-manager.js";
-import { DetectorLite } from "./detector/detector-lite.js";
+import { Tracker } from "../core/tracker/tracker.js";
+import { InputLoader } from "../core/input-loader.js";
+import { FeatureManager } from "../core/features/feature-manager.js";
+import { DetectorLite } from "../core/detector/detector-lite.js";
 export interface ControllerOptions {
     inputWidth: number;
     inputHeight: number;
@@ -32,6 +32,7 @@ declare class Controller {
     matchingDataList: any;
     workerMatchDone: ((data: any) => void) | null;
     workerTrackDone: ((data: any) => void) | null;
+    workerFullTrackDone: ((data: any) => void) | null;
     mainThreadMatcher: any;
     mainThreadEstimator: any;
     featureManager: FeatureManager;
@@ -62,7 +63,9 @@ declare class Controller {
     _detectAndMatch(inputData: any, targetIndexes: number[]): Promise<{
         targetIndex: any;
         modelViewTransform: any;
-        featurePoints: any[];
+        screenCoords: any;
+        worldCoords: any;
+        featurePoints: any;
     }>;
     _trackAndUpdate(inputData: any, lastModelViewTransform: number[][], targetIndex: number): Promise<{
         modelViewTransform: any;
@@ -106,7 +109,8 @@ declare class Controller {
         debugExtra: {};
     }>;
     trackUpdate(modelViewTransform: number[][], trackFeatures: any): Promise<any>;
-    _workerMatch(featurePoints: any, targetIndexes: number[]): Promise<any>;
+    _workerMatch(featurePoints: any, targetIndexes: number[], inputData?: any): Promise<any>;
+    _workerTrack(inputData: any, lastModelViewTransform: number[][], targetIndex: number): Promise<any>;
     _matchOnMainThread(featurePoints: any, targetIndexes: number[]): Promise<{
         targetIndex: number;
         modelViewTransform: any;

package/dist/{compiler → runtime}/controller.js

@@ -1,11 +1,11 @@
-import { Tracker } from "./tracker/tracker.js";
-import { OfflineCompiler as Compiler } from "./offline-compiler.js";
-import { InputLoader } from "./input-loader.js";
-import { FeatureManager } from "./features/feature-manager.js";
-import { OneEuroFilterFeature } from "./features/one-euro-filter-feature.js";
-import { TemporalFilterFeature } from "./features/temporal-filter-feature.js";
-import { AutoRotationFeature } from "./features/auto-rotation-feature.js";
-import { DetectorLite } from "./detector/detector-lite.js";
+import { Tracker } from "../core/tracker/tracker.js";
+import { InputLoader } from "../core/input-loader.js";
+import { FeatureManager } from "../core/features/feature-manager.js";
+import { OneEuroFilterFeature } from "../core/features/one-euro-filter-feature.js";
+import { TemporalFilterFeature } from "../core/features/temporal-filter-feature.js";
+import { AutoRotationFeature } from "../core/features/auto-rotation-feature.js";
+import { DetectorLite } from "../core/detector/detector-lite.js";
+import * as protocol from "../core/protocol.js";
 let ControllerWorker;
 // Conditional import for worker to avoid crash in non-vite environments
 const getControllerWorker = async () => {
@@ -45,6 +45,7 @@ class Controller {
     matchingDataList;
     workerMatchDone = null;
     workerTrackDone = null;
+    workerFullTrackDone = null;
     mainThreadMatcher;
     mainThreadEstimator;
     featureManager;
@@ -102,6 +103,9 @@ class Controller {
             if (e.data.type === "matchDone" && this.workerMatchDone !== null) {
                 this.workerMatchDone(e.data);
             }
+            if (e.data.type === "trackDone" && this.workerFullTrackDone !== null) {
+                this.workerFullTrackDone(e.data);
+            }
             if (e.data.type === "trackUpdateDone" && this.workerTrackDone !== null) {
                 this.workerTrackDone(e.data);
             }
@@ -128,8 +132,7 @@ class Controller {
         const allMatchingData = [];
         const allDimensions = [];
         for (const buffer of buffers) {
-            const compiler = new Compiler();
-            const result = compiler.importData(buffer);
+            const result = protocol.decodeTaar(buffer);
             const dataList = result.dataList || [];
             for (const item of dataList) {
                 allMatchingData.push(item.matchingData);
@@ -147,6 +150,8 @@ class Controller {
                 projectionTransform: this.projectionTransform,
                 debugMode: this.debugMode,
                 matchingDataList: allMatchingData,
+                trackingDataList: allTrackingData,
+                markerDimensions: allDimensions
             });
         }
         this.markerDimensions = allDimensions;
@@ -183,12 +188,15 @@ class Controller {
         return this._glModelViewMatrix(modelViewTransform, targetIndex);
     }
     async _detectAndMatch(inputData, targetIndexes) {
-        const { featurePoints } = this.fullDetector.detect(inputData);
-        const { targetIndex: matchedTargetIndex, modelViewTransform } = await this._workerMatch(featurePoints, targetIndexes);
-        return { targetIndex: matchedTargetIndex, modelViewTransform, featurePoints };
+        const { targetIndex, modelViewTransform, screenCoords, worldCoords, featurePoints } = await this._workerMatch(null, // No feature points, worker will detect from inputData
+        targetIndexes, inputData);
+        return { targetIndex, modelViewTransform, screenCoords, worldCoords, featurePoints };
     }
     async _trackAndUpdate(inputData, lastModelViewTransform, targetIndex) {
-        const { worldCoords, screenCoords, reliabilities, indices = [], octaveIndex = 0 } = this.tracker.track(inputData, lastModelViewTransform, targetIndex);
+        const { worldCoords, screenCoords, reliabilities, indices = [], octaveIndex = 0 } = await this._workerTrack(inputData, lastModelViewTransform, targetIndex);
+        if (!worldCoords || worldCoords.length === 0) {
+            return { modelViewTransform: null, screenCoords: [], reliabilities: [], stabilities: [] };
+        }
         const state = this.trackingStates[targetIndex];
         if (!state.pointStabilities)
             state.pointStabilities = [];
@@ -221,7 +229,11 @@ class Controller {
         for (let i = 0; i < stabilities.length; i++) {
             if (stabilities[i] > 0) {
                 const isCurrentlyTracked = indices.includes(i);
-                finalScreenCoords.push(lastCoords[i]);
+                finalScreenCoords.push({
+                    x: lastCoords[i].x,
+                    y: lastCoords[i].y,
+                    id: i // Unique index from tracker
+                });
                 finalStabilities.push(stabilities[i]);
                 if (isCurrentlyTracked) {
                     const idxInResult = indices.indexOf(i);
@@ -292,11 +304,14 @@ class Controller {
                             continue;
                         matchingIndexes.push(i);
                     }
-                    const { targetIndex: matchedTargetIndex, modelViewTransform } = await this._detectAndMatch(inputData, matchingIndexes);
+                    const { targetIndex: matchedTargetIndex, modelViewTransform, featurePoints } = await this._detectAndMatch(inputData, matchingIndexes);
                     if (matchedTargetIndex !== -1) {
                         this.trackingStates[matchedTargetIndex].isTracking = true;
                         this.trackingStates[matchedTargetIndex].currentModelViewTransform = modelViewTransform;
                     }
+                    // If we have feature points, we can store them in a special "lastSeenFeatures" 
+                    // or just pass them in processDone for general visualization
+                    this.onUpdate && this.onUpdate({ type: "featurePoints", featurePoints });
                 }
                 for (let i = 0; i < this.trackingStates.length; i++) {
                     const trackingState = this.trackingStates[i];
@@ -388,10 +403,20 @@ class Controller {
             return null;
         return this._workerTrackUpdate(modelViewTransform, trackFeatures);
     }
-    _workerMatch(featurePoints, targetIndexes) {
+    _workerMatch(featurePoints, targetIndexes, inputData = null) {
         return new Promise((resolve) => {
             if (!this.worker) {
-                this._matchOnMainThread(featurePoints, targetIndexes).then(resolve).catch(() => resolve({ targetIndex: -1 }));
+                // If no feature points but we have input data, detect first
+                let fpPromise;
+                if (!featurePoints && inputData) {
+                    fpPromise = Promise.resolve(this.fullDetector.detect(inputData).featurePoints);
+                }
+                else {
+                    fpPromise = Promise.resolve(featurePoints);
+                }
+                fpPromise.then(fp => {
+                    this._matchOnMainThread(fp, targetIndexes).then(resolve);
+                }).catch(() => resolve({ targetIndex: -1 }));
                 return;
             }
             const timeout = setTimeout(() => {
@@ -406,16 +431,45 @@ class Controller {
                     modelViewTransform: data.modelViewTransform,
                     screenCoords: data.screenCoords,
                     worldCoords: data.worldCoords,
+                    featurePoints: data.featurePoints,
                     debugExtra: data.debugExtra,
                 });
             };
-            this.worker.postMessage({ type: "match", featurePoints: featurePoints, targetIndexes });
+            if (inputData) {
+                this.worker.postMessage({ type: "match", inputData, targetIndexes });
+            }
+            else {
+                this.worker.postMessage({ type: "match", featurePoints: featurePoints, targetIndexes });
+            }
+        });
+    }
+    _workerTrack(inputData, lastModelViewTransform, targetIndex) {
+        return new Promise((resolve) => {
+            if (!this.worker) {
+                resolve(this.tracker.track(inputData, lastModelViewTransform, targetIndex));
+                return;
+            }
+            const timeout = setTimeout(() => {
+                this.workerFullTrackDone = null;
+                resolve({ worldCoords: [], screenCoords: [], reliabilities: [] });
+            }, WORKER_TIMEOUT_MS);
+            this.workerFullTrackDone = (data) => {
+                clearTimeout(timeout);
+                this.workerFullTrackDone = null;
+                resolve(data);
+            };
+            this.worker.postMessage({
+                type: "track",
+                inputData,
+                lastModelViewTransform,
+                targetIndex
+            });
         });
     }
     async _matchOnMainThread(featurePoints, targetIndexes) {
         if (!this.mainThreadMatcher) {
-            const { Matcher } = await import("./matching/matcher.js");
-            const { Estimator } = await import("./estimation/estimator.js");
+            const { Matcher } = await import("../core/matching/matcher.js");
+            const { Estimator } = await import("../core/estimation/estimator.js");
             this.mainThreadMatcher = new Matcher(this.inputWidth, this.inputHeight, this.debugMode);
             this.mainThreadEstimator = new Estimator(this.projectionTransform);
         }
@@ -474,7 +528,7 @@ class Controller {
     }
     async _trackUpdateOnMainThread(modelViewTransform, trackingFeatures) {
         if (!this.mainThreadEstimator) {
-            const { Estimator } = await import("./estimation/estimator.js");
+            const { Estimator } = await import("../core/estimation/estimator.js");
             this.mainThreadEstimator = new Estimator(this.projectionTransform);
         }
         const { worldCoords, screenCoords, stabilities } = trackingFeatures;

package/dist/{compiler → runtime}/controller.worker.js

@@ -1,9 +1,13 @@
-import { Matcher } from "./matching/matcher.js";
-import { Estimator } from "./estimation/estimator.js";
+import { Matcher } from "../core/matching/matcher.js";
+import { Estimator } from "../core/estimation/estimator.js";
+import { Tracker } from "../core/tracker/tracker.js";
+import { DetectorLite } from "../core/detector/detector-lite.js";
 let matchingDataList = null;
 let debugMode = false;
 let matcher = null;
 let estimator = null;
+let tracker = null;
+let detector = null;
 onmessage = (msg) => {
     const { data } = msg;
     switch (data.type) {
@@ -12,21 +16,35 @@ onmessage = (msg) => {
             debugMode = data.debugMode;
             matcher = new Matcher(data.inputWidth, data.inputHeight, debugMode);
             estimator = new Estimator(data.projectionTransform);
+            if (data.trackingDataList && data.markerDimensions) {
+                tracker = new Tracker(data.markerDimensions, data.trackingDataList, data.projectionTransform, data.inputWidth, data.inputHeight, debugMode);
+            }
+            detector = new DetectorLite(data.inputWidth, data.inputHeight, { useLSH: true });
             break;
         case "match":
             const interestedTargetIndexes = data.targetIndexes;
             let matchedTargetIndex = -1;
             let matchedModelViewTransform = null;
+            let matchedScreenCoords = null;
+            let matchedWorldCoords = null;
             let matchedDebugExtra = null;
+            // New: If the worker received image data, run detector here too
+            let featurePoints = data.featurePoints;
+            if (data.inputData) {
+                const detectionResult = detector.detect(data.inputData);
+                featurePoints = detectionResult.featurePoints;
+            }
             for (let i = 0; i < interestedTargetIndexes.length; i++) {
                 const matchingIndex = interestedTargetIndexes[i];
-                const { keyframeIndex, screenCoords, worldCoords, debugExtra } = matcher.matchDetection(matchingDataList[matchingIndex], data.featurePoints);
+                const { keyframeIndex, screenCoords, worldCoords, debugExtra } = matcher.matchDetection(matchingDataList[matchingIndex], featurePoints);
                 matchedDebugExtra = debugExtra;
                 if (keyframeIndex !== -1) {
                     const modelViewTransform = estimator.estimate({ screenCoords, worldCoords });
                     if (modelViewTransform) {
                         matchedTargetIndex = matchingIndex;
                         matchedModelViewTransform = modelViewTransform;
+                        matchedScreenCoords = screenCoords;
+                        matchedWorldCoords = worldCoords;
                     }
                     break;
                 }
@@ -35,9 +53,21 @@ onmessage = (msg) => {
                 type: "matchDone",
                 targetIndex: matchedTargetIndex,
                 modelViewTransform: matchedModelViewTransform,
+                screenCoords: matchedScreenCoords,
+                worldCoords: matchedWorldCoords,
+                featurePoints: featurePoints,
                 debugExtra: matchedDebugExtra,
             });
             break;
+        case "track":
+            const { inputData: trackInput, lastModelViewTransform, targetIndex } = data;
+            const trackResult = tracker.track(trackInput, lastModelViewTransform, targetIndex);
+            postMessage({
+                type: "trackDone",
+                targetIndex,
+                ...trackResult
+            });
+            break;
         case "trackUpdate":
             const { modelViewTransform, worldCoords, screenCoords, stabilities } = data;
             const finalModelViewTransform = estimator.refineEstimate({

package/dist/runtime/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./controller.js";
+export * from "./simple-ar.js";
+export * from "./three.js";
+export * from "./aframe.js";

package/dist/runtime/index.js

@@ -0,0 +1,4 @@
+export * from "./controller.js";
+export * from "./simple-ar.js";
+export * from "./three.js";
+export * from "./aframe.js";

package/dist/{compiler → runtime}/simple-ar.js

@@ -1,5 +1,5 @@
 import { Controller } from "./controller.js";
-import { projectToScreen } from "./utils/projection.js";
+import { projectToScreen } from "../core/utils/projection.js";
 class SimpleAR {
     container;
     targetSrc;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@srsergio/taptapp-ar",
-    "version": "1.0.84",
+    "version": "1.0.86",
     "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/node-worker.js

@@ -5,30 +5,16 @@
  * Usa JavaScript puro para máxima velocidad.
  */
 import { parentPort } from 'node:worker_threads';
-import { extractTrackingFeatures } from './tracker/extract-utils.js';
-import { buildTrackingImageList } from './image-list.js';
-import { DetectorLite } from './detector/detector-lite.js';
-import { build as hierarchicalClusteringBuild } from './matching/hierarchical-clustering.js';
+import { extractTrackingFeatures } from '../core/tracker/extract-utils.js';
+import { buildTrackingImageList } from '../core/image-list.js';
+import { DetectorLite } from '../core/detector/detector-lite.js';
+import { build as hierarchicalClusteringBuild } from '../core/matching/hierarchical-clustering.js';
+import { getMorton } from '../core/protocol.js';
 
 if (!parentPort) {
     throw new Error('This file must be run as a worker thread.');
 }
 
-// Helper for Morton Order sorting inside worker
-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);
-}
-
 const mortonCache = new Int32Array(2048); // Cache for sorting stability
 
 function sortPoints(points) {