@srsergio/taptapp-ar 1.0.2 → 1.0.4

package/dist/compiler/node-worker.js

@@ -0,0 +1,84 @@
+/**
+ * Worker Node.js para compilación de imágenes AR
+ *
+ * OPTIMIZADO: Sin TensorFlow para evitar bloqueos de inicialización.
+ * Usa JavaScript puro para máxima velocidad.
+ */
+import { parentPort } from 'node:worker_threads';
+import { extractTrackingFeatures } from './tracker/extract-utils.js';
+import { buildTrackingImageList, buildImageList } from './image-list.js';
+import { DetectorLite } from './detector/detector-lite.js';
+import { build as hierarchicalClusteringBuild } from './matching/hierarchical-clustering.js';
+if (!parentPort) {
+    throw new Error('This file must be run as a worker thread.');
+}
+parentPort.on('message', async (msg) => {
+    if (msg.type === 'compile') {
+        const { targetImage, percentPerImage, basePercent } = msg;
+        try {
+            const imageList = buildTrackingImageList(targetImage);
+            const percentPerAction = percentPerImage / imageList.length;
+            let localPercent = 0;
+            const trackingData = extractTrackingFeatures(imageList, (index) => {
+                localPercent += percentPerAction;
+                parentPort.postMessage({
+                    type: 'progress',
+                    percent: basePercent + localPercent
+                });
+            });
+            parentPort.postMessage({
+                type: 'compileDone',
+                trackingData
+            });
+        }
+        catch (error) {
+            parentPort.postMessage({
+                type: 'error',
+                error: error.message
+            });
+        }
+    }
+    else if (msg.type === 'match') {
+        const { targetImage, percentPerImage, basePercent } = msg;
+        try {
+            const imageList = buildImageList(targetImage);
+            const percentPerAction = percentPerImage / imageList.length;
+            let localPercent = 0;
+            const keyframes = [];
+            for (let i = 0; i < imageList.length; i++) {
+                const image = imageList[i];
+                const detector = new DetectorLite(image.width, image.height);
+                // Detectar features usando JS puro (sin TensorFlow)
+                const { featurePoints: ps } = detector.detect(image.data);
+                const maximaPoints = ps.filter((p) => p.maxima);
+                const minimaPoints = ps.filter((p) => !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,
+                });
+                localPercent += percentPerAction;
+                parentPort.postMessage({
+                    type: 'progress',
+                    percent: basePercent + localPercent
+                });
+            }
+            parentPort.postMessage({
+                type: 'matchDone',
+                matchingData: keyframes
+            });
+        }
+        catch (error) {
+            parentPort.postMessage({
+                type: 'error',
+                error: error.message
+            });
+        }
+    }
+});

package/dist/compiler/offline-compiler.d.ts

@@ -1,10 +1,175 @@
-export class OfflineCompiler extends CompilerBase {
-    isServerless: string | undefined;
-    _ensureTensorflowReady(): Promise<any>;
+/**
+ * Compilador offline optimizado sin TensorFlow
+ */
+export class OfflineCompiler {
+    data: any;
+    workerPool: import("./utils/worker-pool.js").WorkerPool | null;
+    _initNodeWorkers(): Promise<void>;
+    /**
+     * Compila una lista de imágenes objetivo
+     * @param {Array} images - Lista de imágenes {width, height, data}
+     * @param {Function} progressCallback - Callback de progreso (0-100)
+     * @returns {Promise<Array>} Datos compilados
+     */
+    compileImageTargets(images: any[], progressCallback: Function): Promise<any[]>;
+    /**
+     * Compila datos de matching usando DetectorLite (JS puro)
+     */
+    _compileMatch(targetImages: any, progressCallback: any): Promise<{
+        maximaPoints: any[];
+        minimaPoints: any[];
+        maximaPointsCluster: {
+            rootNode: {
+                centerPointIndex: any;
+            };
+        };
+        minimaPointsCluster: {
+            rootNode: {
+                centerPointIndex: any;
+            };
+        };
+        width: any;
+        height: any;
+        scale: any;
+    }[][]>;
+    /**
+     * Compila datos de tracking usando extractTrackingFeatures (JS puro)
+     */
+    _compileTrack(targetImages: any, progressCallback: any): Promise<Object[][]>;
+    /**
+     * Método público para compilar tracking (compatibilidad con API anterior)
+     * @param {Object} options - Opciones de compilación
+     * @param {Function} options.progressCallback - Callback de progreso
+     * @param {Array} options.targetImages - Lista de imágenes objetivo
+     * @param {number} options.basePercent - Porcentaje base
+     * @returns {Promise<Array>} Datos de tracking
+     */
     compileTrack({ progressCallback, targetImages, basePercent }: {
+        progressCallback: Function;
+        targetImages: any[];
+        basePercent: number;
+    }): Promise<any[]>;
+    /**
+     * Método público para compilar matching (compatibilidad con API anterior)
+     */
+    compileMatch({ progressCallback, targetImages, basePercent }: {
         progressCallback: any;
         targetImages: any;
-        basePercent: any;
-    }): Promise<any>;
+        basePercent?: number | undefined;
+    }): Promise<{
+        maximaPoints: any[];
+        minimaPoints: any[];
+        maximaPointsCluster: {
+            rootNode: {
+                centerPointIndex: any;
+            };
+        };
+        minimaPointsCluster: {
+            rootNode: {
+                centerPointIndex: any;
+            };
+        };
+        width: any;
+        height: any;
+        scale: any;
+    }[][]>;
+    /**
+     * Exporta datos compilados en formato binario columnar optimizado
+     */
+    exportData(): any;
+    _packKeyframe(kf: any): {
+        w: any;
+        h: any;
+        s: any;
+        max: {
+            x: Float32Array<any>;
+            y: Float32Array<any>;
+            a: Float32Array<any>;
+            d: Uint8Array<ArrayBuffer>;
+            t: any[];
+        };
+        min: {
+            x: Float32Array<any>;
+            y: Float32Array<any>;
+            a: Float32Array<any>;
+            d: Uint8Array<ArrayBuffer>;
+            t: any[];
+        };
+    };
+    _columnarize(points: any, tree: any): {
+        x: Float32Array<any>;
+        y: Float32Array<any>;
+        a: Float32Array<any>;
+        d: Uint8Array<ArrayBuffer>;
+        t: any[];
+    };
+    _compactTree(node: any): any[];
+    /**
+     * Importa datos - Mantiene el formato columnar para máximo rendimiento (Zero-copy)
+     */
+    importData(buffer: any): any;
+    _unpackKeyframe(kf: any): {
+        width: any;
+        height: any;
+        scale: any;
+        maximaPoints: {
+            x: any;
+            y: any;
+            angle: any;
+            descriptors: any;
+        }[];
+        minimaPoints: {
+            x: any;
+            y: any;
+            angle: any;
+            descriptors: any;
+        }[];
+        maximaPointsCluster: {
+            rootNode: {
+                leaf: boolean;
+                centerPointIndex: any;
+                pointIndexes: any;
+                children?: undefined;
+            } | {
+                leaf: boolean;
+                centerPointIndex: any;
+                children: any;
+                pointIndexes?: undefined;
+            };
+        };
+        minimaPointsCluster: {
+            rootNode: {
+                leaf: boolean;
+                centerPointIndex: any;
+                pointIndexes: any;
+                children?: undefined;
+            } | {
+                leaf: boolean;
+                centerPointIndex: any;
+                children: any;
+                pointIndexes?: undefined;
+            };
+        };
+    };
+    _decolumnarize(col: any): {
+        x: any;
+        y: any;
+        angle: any;
+        descriptors: any;
+    }[];
+    _expandTree(node: any): {
+        leaf: boolean;
+        centerPointIndex: any;
+        pointIndexes: any;
+        children?: undefined;
+    } | {
+        leaf: boolean;
+        centerPointIndex: any;
+        children: any;
+        pointIndexes?: undefined;
+    };
+    /**
+     * Destruye el pool de workers
+     */
+    destroy(): Promise<void>;
 }
-import { CompilerBase } from "./compiler-base.js";