@srsergio/taptapp-ar 1.0.9 → 1.0.10

package/dist/compiler/detector/kernels/webgl/computeFreakDescriptors.js

@@ -1,52 +0,0 @@
-import { FREAKPOINTS } from "../../freak.js";
-const FREAK_CONPARISON_COUNT = ((FREAKPOINTS.length - 1) * FREAKPOINTS.length) / 2;
-const descriptorCount = Math.ceil(FREAK_CONPARISON_COUNT / 8);
-const cache = {};
-function GetProgram(extremaFreaks) {
-    const key = `${extremaFreaks.shape[0]}`;
-    if (!cache.hasOwnProperty(key)) {
-        const kernel = {
-            variableNames: ["freak", "p"],
-            outputShape: [extremaFreaks.shape[0], descriptorCount],
-            userCode: `
-  void main() {
-    ivec2 coords = getOutputCoords();
-    int featureIndex = coords[0];
-    int descIndex = coords[1] * 8;
-
-    int sum = 0;
-    for (int i = 0; i < 8; i++) {
-      if (descIndex + i >= ${FREAK_CONPARISON_COUNT}) {
-        continue;
-      }
-
-      int p1 = int(getP(descIndex + i, 0));
-      int p2 = int(getP(descIndex + i, 1));
-
-      float v1 = getFreak(featureIndex, p1);
-      float v2 = getFreak(featureIndex, p2);
-
-      if (v1 < v2 + 0.01) {
-        sum += int(pow(2.0, float(7 - i)));
-      }
-    }
-    setOutput(float(sum));
-  }
-`,
-        };
-        cache[key] = kernel;
-    }
-    return cache[key];
-}
-export const computeFreakDescriptor = (args) => {
-    const { extremaFreaks, positionT } = args.inputs;
-    const { backend } = args;
-    const program = GetProgram(extremaFreaks);
-    return backend.runWebGLProgram(program, [extremaFreaks, positionT], "int32");
-};
-export const computeFreakDescriptorConfig = {
-    //: KernelConfig
-    kernelName: "ComputeFreakDescriptors",
-    backendName: "webgl",
-    kernelFunc: computeFreakDescriptor, // as {} as KernelFunc,
-};

package/dist/compiler/detector/kernels/webgl/computeLocalization.d.ts

@@ -1,6 +0,0 @@
-export function computeLocalization(args: any): any;
-export namespace computeLocalizationConfig {
-    export let kernelName: string;
-    export let backendName: string;
-    export { computeLocalization as kernelFunc };
-}

package/dist/compiler/detector/kernels/webgl/computeLocalization.js

@@ -1,58 +0,0 @@
-import { tensor } from "@tensorflow/tfjs";
-const cache = {};
-function GetProgram(numDogPyramidImages, extremasListLength) {
-    const kernelKey = `${numDogPyramidImages}|${extremasListLength}`;
-    if (!cache.hasOwnProperty(kernelKey)) {
-        const dogVariableNames = [];
-        let dogSubCodes = `float getPixel(int octave, int y, int x) {`;
-        for (let i = 1; i < numDogPyramidImages; i++) {
-            // extrema starts from second octave
-            dogVariableNames.push("image" + i);
-            dogSubCodes += `
-				if (octave == ${i}) {
-					return getImage${i}(y, x);
-				}
-			`;
-        }
-        dogSubCodes += `}`;
-        cache[kernelKey] = {
-            variableNames: [...dogVariableNames, "extrema"],
-            outputShape: [extremasListLength, 3, 3], // 3x3 pixels around the extrema
-            userCode: `
-			${dogSubCodes}
-		
-			void main() {
-				ivec3 coords = getOutputCoords();
-				int featureIndex = coords[0];
-				float score = getExtrema(featureIndex, 0);
-				if (score == 0.0) {
-					return;
-				}
-		
-				int dy = coords[1]-1;
-				int dx = coords[2]-1;
-				int octave = int(getExtrema(featureIndex, 1));
-				int y = int(getExtrema(featureIndex, 2));
-				int x = int(getExtrema(featureIndex, 3));
-				setOutput(getPixel(octave, y+dy, x+dx));
-			}
-			`,
-        };
-    }
-    return cache[kernelKey];
-}
-export const computeLocalization = (args) => {
-    /** @type {import('@tensorflow/tfjs').TensorInfo} */
-    const { prunedExtremasList, dogPyramidImagesT } = args.inputs;
-    /** @type {MathBackendWebGL} */
-    const backend = args.backend;
-    const program = GetProgram(dogPyramidImagesT.length, prunedExtremasList.length);
-    const prunedExtremasT = tensor(prunedExtremasList, [prunedExtremasList.length, prunedExtremasList[0].length], "int32");
-    return backend.runWebGLProgram(program, [...dogPyramidImagesT.slice(1), prunedExtremasT], dogPyramidImagesT[0].dtype);
-};
-export const computeLocalizationConfig = {
-    //: KernelConfig
-    kernelName: "ComputeLocalization",
-    backendName: "webgl",
-    kernelFunc: computeLocalization, // as {} as KernelFunc,
-};

package/dist/compiler/detector/kernels/webgl/computeOrientationHistograms.d.ts

@@ -1,6 +0,0 @@
-export function computeOrientationHistograms(args: any): any;
-export namespace computeOrientationHistogramsConfig {
-    export let kernelName: string;
-    export let backendName: string;
-    export { computeOrientationHistograms as kernelFunc };
-}

package/dist/compiler/detector/kernels/webgl/computeOrientationHistograms.js

@@ -1,116 +0,0 @@
-const oneOver2PI = 0.159154943091895;
-const ORIENTATION_NUM_BINS = 36;
-const cache = {};
-function GetPrograms(prunedExtremasT, radialPropertiesT, pyramidImagesLength) {
-    const key = `${pyramidImagesLength}|${prunedExtremasT.shape[0]}|${radialPropertiesT.shape[0]}`;
-    if (!cache.hasOwnProperty(key)) {
-        const imageVariableNames = [];
-        for (let i = 1; i < pyramidImagesLength; i++) {
-            imageVariableNames.push("image" + i);
-        }
-        let kernel1SubCodes = `float getPixel(int octave, int y, int x) {`;
-        for (let i = 1; i < pyramidImagesLength; i++) {
-            kernel1SubCodes += `
-            if (octave == ${i}) {
-                return getImage${i}(y, x);
-            }
-            `;
-        }
-        kernel1SubCodes += `}`;
-        const kernel1 = {
-            variableNames: [...imageVariableNames, "extrema", "radial"],
-            outputShape: [prunedExtremasT.shape[0], radialPropertiesT.shape[0], 2], // last dimension: [fbin, magnitude]
-            userCode: `
-                ${kernel1SubCodes}
-
-                void main() {
-                    ivec3 coords = getOutputCoords();
-                    int featureIndex = coords[0];
-                    int radialIndex = coords[1];
-                    int propertyIndex = coords[2];
-
-                    int radialY = int(getRadial(radialIndex, 0));
-                    int radialX = int(getRadial(radialIndex, 1));
-                    float radialW = getRadial(radialIndex, 2);
-
-                    int octave = int(getExtrema(featureIndex, 1));
-                    int y = int(getExtrema(featureIndex, 2));
-                    int x = int(getExtrema(featureIndex, 3));
-
-                    int xp = x + radialX;
-                    int yp = y + radialY;
-
-                    float dy = getPixel(octave, yp+1, xp) - getPixel(octave, yp-1, xp);
-                    float dx = getPixel(octave, yp, xp+1) - getPixel(octave, yp, xp-1);
-
-                    if (propertyIndex == 0) {
-                    // be careful that atan(0, 0) gives 1.57 instead of 0 (different from js), but doesn't matter here, coz magnitude is 0
-                    
-                    float angle = atan(dy, dx) + ${Math.PI};
-                    float fbin = angle * ${ORIENTATION_NUM_BINS}. * ${oneOver2PI};
-                    setOutput(fbin);
-                    return;
-                    }
-
-                    if (propertyIndex == 1) {
-                        float mag = sqrt(dx * dx + dy * dy);
-                        float magnitude = radialW * mag;
-                        setOutput(magnitude);
-                        return;
-                    }
-                }
-
-                `,
-        };
-        const kernel2 = {
-            variableNames: ["fbinMag"],
-            outputShape: [prunedExtremasT.shape[0], ORIENTATION_NUM_BINS],
-            userCode: `
-            void main() {
-                ivec2 coords = getOutputCoords();
-                int featureIndex = coords[0];
-                int binIndex = coords[1];
-
-                float sum = 0.;
-                for (int i = 0; i < ${radialPropertiesT.shape[0]}; i++) {
-                    float fbin = getFbinMag(featureIndex, i, 0);
-                    int bin = int(floor(fbin - 0.5));
-                    int b1 = imod(bin + ${ORIENTATION_NUM_BINS}, ${ORIENTATION_NUM_BINS});
-                    int b2 = imod(bin + 1 + ${ORIENTATION_NUM_BINS}, ${ORIENTATION_NUM_BINS});
-
-                    if (b1 == binIndex || b2 == binIndex) {
-                        float magnitude = getFbinMag(featureIndex, i, 1);
-                        float w2 = fbin - float(bin) - 0.5;
-                        float w1 = w2 * -1. + 1.;
-
-                        if (b1 == binIndex) {
-                            sum += w1 * magnitude;
-                        }
-                        if (b2 == binIndex) {
-                            sum += w2 * magnitude;
-                        }
-                    }
-                }
-                setOutput(sum);
-            }
-            `,
-        };
-        cache[key] = [kernel1, kernel2];
-    }
-    return cache[key];
-}
-export const computeOrientationHistograms = (args) => {
-    const { gaussianImagesT, prunedExtremasT, radialPropertiesT, pyramidImagesLength } = args.inputs;
-    /** @type {MathBackendWebGL} */
-    const backend = args.backend;
-    const [program1, program2] = GetPrograms(prunedExtremasT, radialPropertiesT, pyramidImagesLength);
-    const result1 = backend.runWebGLProgram(program1, [...gaussianImagesT, prunedExtremasT, radialPropertiesT], radialPropertiesT.dtype);
-    const result2 = backend.runWebGLProgram(program2, [result1], radialPropertiesT.dtype);
-    backend.disposeIntermediateTensorInfo(result1);
-    return result2;
-};
-export const computeOrientationHistogramsConfig = {
-    kernelName: "ComputeOrientationHistograms",
-    backendName: "webgl",
-    kernelFunc: computeOrientationHistograms, // as {} as KernelFunc,
-};

package/dist/compiler/detector/kernels/webgl/downsampleBilinear.d.ts

@@ -1,6 +0,0 @@
-export function downsampleBilinear(args: any): any;
-export namespace downsampleBilinearConfig {
-    export let kernelName: string;
-    export let backendName: string;
-    export { downsampleBilinear as kernelFunc };
-}

package/dist/compiler/detector/kernels/webgl/downsampleBilinear.js

@@ -1,46 +0,0 @@
-const cache = {};
-/**
- *
- * @param {TensorInfo} image
- * @returns {GPGPUProgram}
- */
-function GetProgram(image) {
-    const imageWidth = image.shape[1];
-    const imageHeight = image.shape[0];
-    const kernelKey = "w" + imageWidth + "h" + imageHeight;
-    if (!cache.hasOwnProperty(kernelKey)) {
-        const kernel = {
-            variableNames: ["p"],
-            outputShape: [Math.floor(imageHeight / 2), Math.floor(imageWidth / 2)],
-            userCode: `
-            void main() {
-                ivec2 coords = getOutputCoords();
-                int y = coords[0] * 2;
-                int x = coords[1] * 2;
-        
-                float sum = getP(y, x) * 0.25;
-                sum += getP(y+1,x) * 0.25; 
-                sum += getP(y, x+1) * 0.25; 
-                sum += getP(y+1,x+1) * 0.25;
-                setOutput(sum);
-            }
-            `,
-        };
-        cache[kernelKey] = kernel;
-    }
-    return cache[kernelKey];
-}
-export const downsampleBilinear = (args) => {
-    /** @type {import('@tensorflow/tfjs').TensorInfo} */
-    const image = args.inputs.image;
-    /** @type {MathBackendWebGL} */
-    const backend = args.backend;
-    const program = GetProgram(image);
-    return backend.runWebGLProgram(program, [image], image.dtype);
-};
-export const downsampleBilinearConfig = {
-    //: KernelConfig
-    kernelName: "DownsampleBilinear",
-    backendName: "webgl",
-    kernelFunc: downsampleBilinear, // as {} as KernelFunc,
-};

package/dist/compiler/detector/kernels/webgl/extremaReduction.d.ts

@@ -1,6 +0,0 @@
-export function extremaReduction(args: any): any;
-export namespace extremaReductionConfig {
-    export let kernelName: string;
-    export let backendName: string;
-    export { extremaReduction as kernelFunc };
-}

package/dist/compiler/detector/kernels/webgl/extremaReduction.js

@@ -1,48 +0,0 @@
-export const extremaReduction = (args) => {
-    /** @type {import('@tensorflow/tfjs').TensorInfo[]} */
-    const { extremasResultT } = args.inputs;
-    /** @type {MathBackendWebGL} */
-    const backend = args.backend;
-    const extremaHeight = extremasResultT.shape[0];
-    const extremaWidth = extremasResultT.shape[1];
-    const kernel = {
-        variableNames: ["extrema"],
-        outputShape: [Math.floor(extremaHeight / 2), Math.floor(extremaWidth / 2)],
-        userCode: `
-		  void main() {
-			ivec2 coords = getOutputCoords();
-			int y = coords[0] * 2;
-			int x = coords[1] * 2;
-  
-			float location = 0.0;
-			float values = getExtrema(y, x);
-  
-			if (getExtrema(y+1, x) != 0.0) {
-			  location = 1.0;
-		  values = getExtrema(y+1, x);
-			}
-			else if (getExtrema(y, x+1) != 0.0) {
-			  location = 2.0;
-		  values = getExtrema(y, x+1);
-			}
-			else if (getExtrema(y+1, x+1) != 0.0) {
-			  location = 3.0;
-		  values = getExtrema(y+1, x+1);
-			}
-  
-			if (values < 0.0) {
-			  setOutput(location * -1000.0 + values);
-			} else {
-			  setOutput(location * 1000.0 + values);
-			}
-		  }
-		`,
-    };
-    return backend.runWebGLProgram(kernel, [extremasResultT], extremasResultT.dtype);
-};
-export const extremaReductionConfig = {
-    //: KernelConfig
-    kernelName: "ExtremaReduction",
-    backendName: "webgl",
-    kernelFunc: extremaReduction, // as {} as KernelFunc,
-};

package/dist/compiler/detector/kernels/webgl/index.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/compiler/detector/kernels/webgl/index.js

@@ -1,25 +0,0 @@
-import { registerKernel } from "@tensorflow/tfjs";
-import { binomialFilterConfig } from "./binomialFilter.js";
-import { buildExtremasConfig } from "./buildExtremas.js";
-import { computeExtremaAnglesConfig } from "./computeExtremaAngles.js";
-import { computeExtremaFreakConfig } from "./computeExtremaFreak.js";
-import { computeFreakDescriptorConfig } from "./computeFreakDescriptors.js";
-import { computeLocalizationConfig } from "./computeLocalization.js";
-import { computeOrientationHistogramsConfig } from "./computeOrientationHistograms.js";
-import { downsampleBilinearConfig } from "./downsampleBilinear.js";
-import { extremaReductionConfig } from "./extremaReduction.js";
-import { smoothHistogramsConfig } from "./smoothHistograms.js";
-import { upsampleBilinearConfig } from "./upsampleBilinear.js";
-//export function Register(){
-registerKernel(binomialFilterConfig);
-registerKernel(buildExtremasConfig);
-registerKernel(computeExtremaAnglesConfig);
-registerKernel(computeExtremaFreakConfig);
-registerKernel(computeFreakDescriptorConfig);
-registerKernel(computeLocalizationConfig);
-registerKernel(computeOrientationHistogramsConfig);
-registerKernel(downsampleBilinearConfig);
-registerKernel(extremaReductionConfig);
-registerKernel(smoothHistogramsConfig);
-registerKernel(upsampleBilinearConfig);
-//}

package/dist/compiler/detector/kernels/webgl/smoothHistograms.d.ts

@@ -1,6 +0,0 @@
-export function smoothHistograms(args: any): any;
-export namespace smoothHistogramsConfig {
-    export let kernelName: string;
-    export let backendName: string;
-    export { smoothHistograms as kernelFunc };
-}

package/dist/compiler/detector/kernels/webgl/smoothHistograms.js

@@ -1,49 +0,0 @@
-const ORIENTATION_NUM_BINS = 36;
-const ORIENTATION_SMOOTHING_ITERATIONS = 5;
-const cache = {};
-function GetProgram(histograms) {
-    const kernelKey = `h${histograms.shape[0]}`;
-    if (!cache.hasOwnProperty(kernelKey)) {
-        const kernel = {
-            variableNames: ["histogram"],
-            outputShape: [histograms.shape[0], ORIENTATION_NUM_BINS],
-            userCode: `
-            void main() {
-                ivec2 coords = getOutputCoords();
-
-                int featureIndex = coords[0];
-                int binIndex = coords[1];
-
-                int prevBin = imod(binIndex - 1 + ${ORIENTATION_NUM_BINS}, ${ORIENTATION_NUM_BINS});
-                int nextBin = imod(binIndex + 1, ${ORIENTATION_NUM_BINS});
-                float result = 0.274068619061197 * getHistogram(featureIndex, prevBin) + 0.451862761877606 * getHistogram(featureIndex, binIndex) + 0.274068619061197 * getHistogram(featureIndex, nextBin);
-
-                setOutput(result);
-            }
-            `,
-        };
-        cache[kernelKey] = kernel;
-    }
-    return cache[kernelKey];
-}
-export const smoothHistograms = (args) => {
-    /** @type {import('@tensorflow/tfjs').TensorInfo} */
-    let { histograms } = args.inputs;
-    /** @type {MathBackendWebGL} */
-    const backend = args.backend;
-    const program = GetProgram(histograms);
-    for (let i = 0; i < ORIENTATION_SMOOTHING_ITERATIONS; i++) {
-        const _histograms = histograms;
-        histograms = backend.runWebGLProgram(program, [histograms], histograms.dtype); //this._compileAndRun(program, [histograms]);
-        if (i > 0) {
-            backend.disposeIntermediateTensorInfo(_histograms);
-        }
-    }
-    return histograms;
-};
-export const smoothHistogramsConfig = {
-    //: KernelConfig
-    kernelName: "SmoothHistograms",
-    backendName: "webgl",
-    kernelFunc: smoothHistograms, // as {} as KernelFunc,
-};

package/dist/compiler/detector/kernels/webgl/upsampleBilinear.d.ts

@@ -1,6 +0,0 @@
-export function upsampleBilinear(args: any): any;
-export namespace upsampleBilinearConfig {
-    export let kernelName: string;
-    export let backendName: string;
-    export { upsampleBilinear as kernelFunc };
-}

package/dist/compiler/detector/kernels/webgl/upsampleBilinear.js

@@ -1,56 +0,0 @@
-import { MathBackendWebGL } from "@tensorflow/tfjs-backend-webgl";
-const cache = {};
-function GetProgram(targetImage) {
-    const targetImageWidth = targetImage.shape[1];
-    const targetImageHeight = targetImage.shape[0];
-    const kernelKey = "w" + targetImageWidth + "h" + targetImageHeight;
-    if (!cache.hasOwnProperty(kernelKey)) {
-        const kernel = {
-            variableNames: ["p"],
-            outputShape: [targetImageHeight, targetImageWidth],
-            userCode: `
-              void main() {
-                ivec2 coords = getOutputCoords();
-                int j = coords[0];
-                int i = coords[1];
-        
-                float sj = 0.5 * float(j) - 0.25; 
-                float si = 0.5 * float(i) - 0.25;
-        
-                float sj0 = floor(sj);
-                float sj1 = ceil(sj);
-                float si0 = floor(si);
-                float si1 = ceil(si);
-        
-                int sj0I = int(sj0);
-                int sj1I = int(sj1);
-                int si0I = int(si0);
-                int si1I = int(si1);
-        
-                float sum = 0.0;
-                sum += getP(sj0I, si0I) * (si1 - si) * (sj1 - sj);
-                sum += getP(sj1I, si0I) * (si1 - si) * (sj - sj0);
-                sum += getP(sj0I, si1I) * (si - si0) * (sj1 - sj);
-                sum += getP(sj1I, si1I) * (si - si0) * (sj - sj0);
-                setOutput(sum);
-              }
-            `,
-        };
-        cache[kernelKey] = kernel;
-    }
-    return cache[kernelKey];
-}
-export const upsampleBilinear = (args) => {
-    /** @type {import('@tensorflow/tfjs').TensorInfo} */
-    const { image, targetImage } = args.inputs;
-    /** @type {MathBackendWebGL} */
-    const backend = args.backend;
-    const program = GetProgram(targetImage);
-    return backend.runWebGLProgram(program, [image], image.dtype);
-};
-export const upsampleBilinearConfig = {
-    //: KernelConfig
-    kernelName: "UpsampleBilinear",
-    backendName: "webgl",
-    kernelFunc: upsampleBilinear, // as {} as KernelFunc,
-};

package/dist/compiler/tensorflow-setup.d.ts

@@ -1,6 +0,0 @@
-/**
- * Configuración optimizada de TensorFlow para diferentes entornos
- * @returns {Promise<string>} El backend activo ('webgl', 'cpu')
- */
-export function setupTensorFlow(): Promise<string>;
-export { tf };

package/dist/compiler/tensorflow-setup.js

@@ -1,99 +0,0 @@
-import * as tf from "@tensorflow/tfjs";
-// Registrar backends básicos
-import "@tensorflow/tfjs-backend-cpu";
-import "@tensorflow/tfjs-backend-webgl";
-// Registrar kernels personalizados
-import "./detector/kernels/cpu/index.js";
-import "./detector/kernels/webgl/index.js";
-/**
- * Intenta cargar el backend de Node.js si está disponible
- */
-const loadNodeBackend = async () => {
-    if (typeof process !== "undefined" && process.versions && process.versions.node) {
-        try {
-            // Usar import dinámico para evitar errores en el navegador
-            await import("@tensorflow/tfjs-node");
-            console.log("🚀 TensorFlow Node.js backend cargado correctamente");
-            return true;
-        }
-        catch (e) {
-            console.warn("⚠️ No se pudo cargar @tensorflow/tfjs-node, usando fallback");
-            return false;
-        }
-    }
-    return false;
-};
-/**
- * Configuración optimizada de TensorFlow para diferentes entornos
- * @returns {Promise<string>} El backend activo ('webgl', 'cpu')
- */
-export async function setupTensorFlow() {
-    console.log("🔧 Iniciando configuración optimizada de TensorFlow.js...");
-    try {
-        // Intentar cargar backend de Node.js primero
-        const nodeBackendLoaded = await loadNodeBackend();
-        // Optimizaciones base para todos los backends
-        tf.ENV.set("DEBUG", false);
-        tf.ENV.set("WEBGL_CPU_FORWARD", false);
-        tf.ENV.set("WEBGL_FORCE_F16_TEXTURES", true);
-        // Configuración adaptativa de memoria según el entorno
-        const isServerless = typeof window === "undefined";
-        const memoryThreshold = isServerless ? 1024 * 1024 * 4 : 1024 * 1024 * 8;
-        tf.ENV.set("CPU_HANDOFF_SIZE_THRESHOLD", memoryThreshold);
-        if (nodeBackendLoaded) {
-            await tf.setBackend("tensorflow");
-            console.log("🚀 Backend TensorFlow (Node.js) activado");
-            await tf.ready();
-            return "tensorflow";
-        }
-        // Configuración específica para entorno serverless
-        if (isServerless) {
-            try {
-                await tf.setBackend("cpu");
-                console.log("🚀 Backend CPU optimizado para entorno serverless");
-                // Optimizaciones específicas para CPU en serverless
-                tf.ENV.set("CPU_HANDOFF_SIZE_THRESHOLD", 1024 * 1024 * 2); // 2MB
-                tf.ENV.set("WEBGL_DELETE_TEXTURE_THRESHOLD", 0);
-                // Precalentar el backend
-                await tf.ready();
-                return "cpu";
-            }
-            catch (cpuError) {
-                console.error("❌ Error crítico en configuración CPU:", cpuError);
-                throw new Error("No se pudo inicializar TensorFlow.js en modo serverless");
-            }
-        }
-        // Configuración optimizada para navegador (WebGL)
-        try {
-            // Optimizaciones avanzadas para WebGL
-            tf.ENV.set("WEBGL_PACK", true);
-            tf.ENV.set("WEBGL_PACK_DEPTHWISECONV", true);
-            tf.ENV.set("WEBGL_MAX_TEXTURE_SIZE", 4096);
-            tf.ENV.set("WEBGL_USE_SHAPES_UNIFORMS", true);
-            tf.ENV.set("WEBGL_CONV_IM2COL", true);
-            await tf.setBackend("webgl");
-            console.log("🎮 Backend WebGL activado con optimizaciones avanzadas");
-            // Precalentar el backend
-            await tf.ready();
-            return "webgl";
-        }
-        catch (webglError) {
-            console.warn(`No se pudo activar WebGL: ${webglError.message}, usando CPU como último recurso`);
-        }
-        // CPU Backend (más lento, último recurso)
-        await tf.setBackend("cpu");
-        console.log("⚠️ Backend CPU activado (rendimiento sub-óptimo)");
-        // Optimizaciones específicas para CPU
-        tf.ENV.set("CPU_HANDOFF_SIZE_THRESHOLD", 1024 * 1024 * 2); // 2MB
-    }
-    catch (error) {
-        console.error("Error crítico configurando backends de TensorFlow:", error);
-        throw new Error("No se pudo inicializar TensorFlow.js con ningún backend");
-    }
-    // Registrar kernels específicos para el backend activo
-    const backend = tf.getBackend();
-    console.log(`Backend activo: ${backend}`);
-    return backend;
-}
-// Exportamos tf para poder usarlo en otros archivos
-export { tf };