@srsergio/taptapp-ar 1.0.3 → 1.0.4

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

@@ -1,7 +1,7 @@
 export class CompilerBase {
     data: any[] | null;
     compileImageTargets(images: any, progressCallback: any): Promise<any>;
-    exportData(): Uint8Array<ArrayBuffer>;
+    exportData(): any;
     importData(buffer: any): any[];
     createProcessCanvas(): void;
     compileTrack(): Promise<never[]>;

package/dist/compiler/controller.d.ts

@@ -60,12 +60,12 @@ export class Controller {
             descriptors: any[];
         }[];
         debugExtra: {
-            pyramidImages: (number | number[] | number[][] | number[][][] | number[][][][] | number[][][][][] | number[][][][][][])[][];
-            dogPyramidImages: (number | number[] | number[][] | number[][][] | number[][][][] | number[][][][][] | number[][][][][][] | null)[];
-            extremasResults: (number | number[] | number[][] | number[][][] | number[][][][] | number[][][][][] | number[][][][][][])[];
+            pyramidImages: any[][];
+            dogPyramidImages: any[];
+            extremasResults: any[];
             extremaAngles: any;
             prunedExtremas: number[][];
-            localizedExtremas: number | number[] | number[][] | number[][][] | number[][][][] | number[][][][][] | number[][][][][][];
+            localizedExtremas: any;
         } | null;
     }>;
     match(featurePoints: any, targetIndex: any): Promise<{

package/dist/compiler/detector/crop-detector.d.ts

@@ -17,12 +17,12 @@ export class CropDetector {
             descriptors: any[];
         }[];
         debugExtra: {
-            pyramidImages: (number | number[] | number[][] | number[][][] | number[][][][] | number[][][][][] | number[][][][][][])[][];
-            dogPyramidImages: (number | number[] | number[][] | number[][][] | number[][][][] | number[][][][][] | number[][][][][][] | null)[];
-            extremasResults: (number | number[] | number[][] | number[][][] | number[][][][] | number[][][][][] | number[][][][][][])[];
+            pyramidImages: any[][];
+            dogPyramidImages: any[];
+            extremasResults: any[];
             extremaAngles: any;
             prunedExtremas: number[][];
-            localizedExtremas: number | number[] | number[][] | number[][][] | number[][][][] | number[][][][][] | number[][][][][][];
+            localizedExtremas: any;
         } | null;
     };
     detectMoving(inputImageT: any): {
@@ -35,12 +35,12 @@ export class CropDetector {
             descriptors: any[];
         }[];
         debugExtra: {
-            pyramidImages: (number | number[] | number[][] | number[][][] | number[][][][] | number[][][][][] | number[][][][][][])[][];
-            dogPyramidImages: (number | number[] | number[][] | number[][][] | number[][][][] | number[][][][][] | number[][][][][][] | null)[];
-            extremasResults: (number | number[] | number[][] | number[][][] | number[][][][] | number[][][][][] | number[][][][][][])[];
+            pyramidImages: any[][];
+            dogPyramidImages: any[];
+            extremasResults: any[];
             extremaAngles: any;
             prunedExtremas: number[][];
-            localizedExtremas: number | number[] | number[][] | number[][][] | number[][][][] | number[][][][][] | number[][][][][][];
+            localizedExtremas: any;
         } | null;
     };
     _detect(inputImageT: any, startX: any, startY: any): {
@@ -53,12 +53,12 @@ export class CropDetector {
             descriptors: any[];
         }[];
         debugExtra: {
-            pyramidImages: (number | number[] | number[][] | number[][][] | number[][][][] | number[][][][][] | number[][][][][][])[][];
-            dogPyramidImages: (number | number[] | number[][] | number[][][] | number[][][][] | number[][][][][] | number[][][][][][] | null)[];
-            extremasResults: (number | number[] | number[][] | number[][][] | number[][][][] | number[][][][][] | number[][][][][][])[];
+            pyramidImages: any[][];
+            dogPyramidImages: any[];
+            extremasResults: any[];
             extremaAngles: any;
             prunedExtremas: number[][];
-            localizedExtremas: number | number[] | number[][] | number[][][] | number[][][][] | number[][][][][] | number[][][][][][];
+            localizedExtremas: any;
         } | null;
     };
 }

package/dist/compiler/detector/detector.d.ts

@@ -16,12 +16,12 @@ export class Detector {
             descriptors: any[];
         }[];
         debugExtra: {
-            pyramidImages: (number | number[] | number[][] | number[][][] | number[][][][] | number[][][][][] | number[][][][][][])[][];
-            dogPyramidImages: (number | number[] | number[][] | number[][][] | number[][][][] | number[][][][][] | number[][][][][][] | null)[];
-            extremasResults: (number | number[] | number[][] | number[][][] | number[][][][] | number[][][][][] | number[][][][][][])[];
+            pyramidImages: any[][];
+            dogPyramidImages: any[];
+            extremasResults: any[];
             extremaAngles: any;
             prunedExtremas: number[][];
-            localizedExtremas: number | number[] | number[][] | number[][][] | number[][][][] | number[][][][][] | number[][][][][][];
+            localizedExtremas: any;
         } | null;
     };
     /**
@@ -39,60 +39,59 @@ export class Detector {
             descriptors: any[];
         }[];
         debugExtra: {
-            pyramidImages: (number | number[] | number[][] | number[][][] | number[][][][] | number[][][][][] | number[][][][][][])[][];
-            dogPyramidImages: (number | number[] | number[][] | number[][][] | number[][][][] | number[][][][][] | number[][][][][][] | null)[];
-            extremasResults: (number | number[] | number[][] | number[][][] | number[][][][] | number[][][][][] | number[][][][][][])[];
+            pyramidImages: any[][];
+            dogPyramidImages: any[];
+            extremasResults: any[];
             extremaAngles: any;
             prunedExtremas: number[][];
-            localizedExtremas: number | number[] | number[][] | number[][][] | number[][][][] | number[][][][][] | number[][][][][][];
+            localizedExtremas: any;
         } | null;
     };
-    _computeFreakDescriptors(extremaFreaks: any): tf.Tensor<tf.Rank> | tf.Tensor<tf.Rank>[];
-    _computeExtremaFreak(pyramidImagesT: any, prunedExtremas: any, prunedExtremasAngles: any): tf.Tensor<tf.Rank> | tf.Tensor<tf.Rank>[];
+    _computeFreakDescriptors(extremaFreaks: any): any;
+    _computeExtremaFreak(pyramidImagesT: any, prunedExtremas: any, prunedExtremasAngles: any): any;
     /**
      *
      * @param {tf.Tensor<tf.Rank>} histograms
      * @returns
      */
-    _computeExtremaAngles(histograms: tf.Tensor<tf.Rank>): tf.Tensor<tf.Rank> | tf.Tensor<tf.Rank>[];
+    _computeExtremaAngles(histograms: tf.Tensor<tf.Rank>): any;
     /**
      *
      * @param {tf.Tensor<tf.Rank>} prunedExtremasT
      * @param {tf.Tensor<tf.Rank>[]} pyramidImagesT
      * @returns
      */
-    _computeOrientationHistograms(prunedExtremasT: tf.Tensor<tf.Rank>, pyramidImagesT: tf.Tensor<tf.Rank>[]): tf.Tensor<tf.Rank> | tf.Tensor<tf.Rank>[];
-    _smoothHistograms(histograms: any): tf.Tensor<tf.Rank> | tf.Tensor<tf.Rank>[];
+    _computeOrientationHistograms(prunedExtremasT: tf.Tensor<tf.Rank>, pyramidImagesT: tf.Tensor<tf.Rank>[]): any;
+    _smoothHistograms(histograms: any): any;
     /**
      *
      * @param {number[][]} prunedExtremasList
      * @param {tf.Tensor<tf.Rank>[]} dogPyramidImagesT
      * @returns
      */
-    _computeLocalization(prunedExtremasList: number[][], dogPyramidImagesT: tf.Tensor<tf.Rank>[]): tf.Tensor<tf.Rank>;
+    _computeLocalization(prunedExtremasList: number[][], dogPyramidImagesT: tf.Tensor<tf.Rank>[]): any;
     /**
      *
      * @param {tf.Tensor<tf.Rank>[]} extremasResultsT
      * @returns
      */
     _applyPrune(extremasResultsT: tf.Tensor<tf.Rank>[]): number[][];
-    _buildExtremas(image0: any, image1: any, image2: any): tf.Tensor<tf.Rank> | tf.Tensor<tf.Rank>[];
+    _buildExtremas(image0: any, image1: any, image2: any): any;
     /**
      *
      * @param {tf.Tensor<tf.Rank>} image1
      * @param {tf.Tensor<tf.Rank>} image2
      * @returns
      */
-    _differenceImageBinomial(image1: tf.Tensor<tf.Rank>, image2: tf.Tensor<tf.Rank>): tf.Tensor<tf.Rank>;
-    _applyFilter(image: any): tf.Tensor<tf.Rank> | tf.Tensor<tf.Rank>[];
-    _downsampleBilinear(image: any): tf.Tensor<tf.Rank> | tf.Tensor<tf.Rank>[];
+    _differenceImageBinomial(image1: tf.Tensor<tf.Rank>, image2: tf.Tensor<tf.Rank>): any;
+    _applyFilter(image: any): any;
+    _downsampleBilinear(image: any): any;
     /**
      *
      * @param {tf.MathBackendWebGL.GPGPUProgram} program
      * @param {*} inputs
      * @returns
      */
-    _compileAndRun(program: tf.MathBackendWebGL.GPGPUProgram, inputs: any): tf.Tensor<tf.Rank>;
-    _runWebGLProgram(program: any, inputs: any, outputType: any): tf.Tensor<tf.Rank>;
+    _compileAndRun(program: tf.MathBackendWebGL.GPGPUProgram, inputs: any): any;
+    _runWebGLProgram(program: any, inputs: any, outputType: any): any;
 }
-import * as tf from "@tensorflow/tfjs";

package/dist/compiler/detector/kernels/cpu/computeExtremaAngles.d.ts

@@ -1,5 +1,5 @@
 export function computeExtremaAnglesImpl(histogram: any): Float32Array<any>;
-export function computeExtremaAngles(args: any): import("@tensorflow/tfjs-core").Tensor<import("@tensorflow/tfjs-core").Rank>;
+export function computeExtremaAngles(args: any): any;
 export namespace computeExtremaAnglesConfig {
     export let kernelName: string;
     export let backendName: string;

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

@@ -1,4 +1,4 @@
-export function upsampleBilinear(args: any): import("@tensorflow/tfjs-core").TensorInfo;
+export function upsampleBilinear(args: any): any;
 export namespace upsampleBilinearConfig {
     export let kernelName: string;
     export let backendName: string;

package/dist/compiler/input-loader.d.ts

@@ -10,14 +10,13 @@ export class InputLoader {
         userCode: string;
     };
     tempPixelHandle: any;
-    _loadInput(input: any): tf.Tensor3D;
-    loadInput(input: any): tf.Tensor<tf.Rank>;
+    _loadInput(input: any): any;
+    loadInput(input: any): any;
     buildProgram(width: any, height: any): {
         variableNames: string[];
         outputShape: any[];
         userCode: string;
     };
-    _compileAndRun(program: any, inputs: any): tf.Tensor<tf.Rank>;
-    _runWebGLProgram(program: any, inputs: any, outputType: any): tf.Tensor<tf.Rank>;
+    _compileAndRun(program: any, inputs: any): any;
+    _runWebGLProgram(program: any, inputs: any, outputType: any): any;
 }
-import * as tf from "@tensorflow/tfjs";

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

@@ -76,7 +76,7 @@ export class OfflineCompiler {
     /**
      * Exporta datos compilados en formato binario columnar optimizado
      */
-    exportData(): Uint8Array<ArrayBuffer>;
+    exportData(): any;
     _packKeyframe(kf: any): {
         w: any;
         h: any;

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

@@ -4,4 +4,3 @@
  */
 export function setupTensorFlow(): Promise<string>;
 export { tf };
-import * as tf from "@tensorflow/tfjs";

package/dist/compiler/three.d.ts

@@ -24,17 +24,17 @@ export class MindARThree {
     userDeviceId: any;
     environmentDeviceId: any;
     shouldFaceUser: boolean;
-    scene: Scene;
-    cssScene: Scene;
-    renderer: WebGLRenderer;
-    cssRenderer: CSS3DRenderer;
-    camera: PerspectiveCamera;
+    scene: any;
+    cssScene: any;
+    renderer: any;
+    cssRenderer: any;
+    camera: any;
     anchors: any[];
     start(): Promise<void>;
     stop(): void;
     switchCamera(): void;
     addAnchor(targetIndex: any): {
-        group: Group<import("three").Object3DEventMap>;
+        group: any;
         targetIndex: any;
         onTargetFound: null;
         onTargetLost: null;
@@ -43,7 +43,7 @@ export class MindARThree {
         visible: boolean;
     };
     addCSSAnchor(targetIndex: any): {
-        group: Group<import("three").Object3DEventMap>;
+        group: any;
         targetIndex: any;
         onTargetFound: null;
         onTargetLost: null;
@@ -58,9 +58,4 @@ export class MindARThree {
     postMatrixs: any[] | undefined;
     resize(): void;
 }
-import { Scene } from "three";
-import { WebGLRenderer } from "three";
-import { CSS3DRenderer } from "three/addons/renderers/CSS3DRenderer.js";
-import { PerspectiveCamera } from "three";
-import { Group } from "three";
 import { Controller } from "./controller.js";

package/dist/compiler/tracker/tracker.d.ts

@@ -5,9 +5,9 @@ export class Tracker {
     projectionTransform: any;
     debugMode: boolean;
     trackingKeyframeList: any[];
-    featurePointsListT: tf.Tensor<tf.Rank>[];
-    imagePixelsListT: tf.Tensor<tf.Rank>[];
-    imagePropertiesListT: tf.Tensor<tf.Rank>[];
+    featurePointsListT: any[];
+    imagePixelsListT: any[];
+    imagePropertiesListT: any[];
     kernelCaches: {};
     dummyRun(inputT: any): void;
     track(inputImageT: any, lastModelViewTransform: any, targetIndex: any): {
@@ -22,17 +22,9 @@ export class Tracker {
         }[];
         debugExtra: {};
     };
-    _computeMatching(featurePointsT: any, imagePixelsT: any, imagePropertiesT: any, projectedImageT: any): {
-        matchingPointsT: tf.Tensor<tf.Rank>;
-        simT: tf.Tensor<tf.Rank>;
-    };
-    _computeProjection(modelViewProjectionTransformT: any, inputImageT: any, targetIndex: any): tf.Tensor<tf.Rank>;
-    _buildAdjustedModelViewTransform(modelViewProjectionTransform: any): tf.Tensor<tf.Rank>;
-    _prebuild(trackingFrame: any, maxCount: any): {
-        featurePoints: tf.Tensor<tf.Rank>;
-        imagePixels: tf.Tensor<tf.Rank>;
-        imageProperties: tf.Tensor<tf.Rank>;
-    };
-    _compileAndRun(program: any, inputs: any): tf.Tensor<tf.Rank>;
+    _computeMatching(featurePointsT: any, imagePixelsT: any, imagePropertiesT: any, projectedImageT: any): any;
+    _computeProjection(modelViewProjectionTransformT: any, inputImageT: any, targetIndex: any): any;
+    _buildAdjustedModelViewTransform(modelViewProjectionTransform: any): any;
+    _prebuild(trackingFrame: any, maxCount: any): any;
+    _compileAndRun(program: any, inputs: any): any;
 }
-import * as tf from "@tensorflow/tfjs";

package/dist/compiler/utils/worker-pool.d.ts

@@ -1,14 +1,13 @@
 export class WorkerPool {
-    constructor(workerPath: any, poolSize?: number);
+    constructor(workerPath: any, poolSize?: any);
     workerPath: any;
-    poolSize: number;
+    poolSize: any;
     workers: any[];
     queue: any[];
     activeWorkers: number;
     runTask(taskData: any): Promise<any>;
-    _createWorker(): Worker;
+    _createWorker(): any;
     _executeTask(worker: any, task: any): void;
     _finishTask(worker: any, callback: any, result: any): void;
     destroy(): Promise<void>;
 }
-import { Worker } from 'node:worker_threads';

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@srsergio/taptapp-ar",
-    "version": "1.0.3",
+    "version": "1.0.4",
     "description": "AR Visualizer and Compiler for Astro and React",
     "repository": {
         "type": "git",
@@ -56,4 +56,4 @@
     "publishConfig": {
         "access": "public"
     }
-}
+}

package/dist/compiler/estimation/esimate-experiment.d.ts

@@ -1,5 +0,0 @@
-export function estimate({ screenCoords, worldCoords, projectionTransform }: {
-    screenCoords: any;
-    worldCoords: any;
-    projectionTransform: any;
-}): never[][] | null;

package/dist/compiler/estimation/esimate-experiment.js

@@ -1,267 +0,0 @@
-// try to implement https://hal.inria.fr/inria-00174036/PDF/RR-6303.pdf
-import { Matrix, inverse } from "ml-matrix";
-import { SVD } from "svd-js";
-import { solveHomography } from "../utils/homography";
-import { computeScreenCoordiate } from "./utils";
-const opposites_of_minors = (M, row, col) => {
-    let x1 = col === 0 ? 1 : 0;
-    let x2 = col === 2 ? 1 : 2;
-    let y1 = row === 0 ? 1 : 0;
-    let y2 = row === 2 ? 1 : 2;
-    return M[y1][x2] * M[y2][x1] - M[y1][x1] * M[y2][x2];
-};
-const findRmatFrom_tstar_n = (H, tstar, n, v) => {
-    // computes R = H( I - (2/v)*te_star*ne_t )
-    const twoDivV = 2 / v;
-    const tmp = [
-        [1 - twoDivV * tstar[0] * n[0], 0 - twoDivV * tstar[0] * n[1], 0 - twoDivV * tstar[0] * n[2]],
-        [0 - twoDivV * tstar[1] * n[0], 1 - twoDivV * tstar[1] * n[1], 0 - twoDivV * tstar[1] * n[2]],
-        [0 - twoDivV * tstar[2] * n[0], 0 - twoDivV * tstar[2] * n[1], 1 - twoDivV * tstar[2] * n[2]],
-    ];
-    const R = [
-        [0, 0, 0],
-        [0, 0, 0],
-        [0, 0, 0],
-    ];
-    for (let i = 0; i < 3; i++) {
-        for (let j = 0; j < 3; j++) {
-            for (let k = 0; k < 3; k++) {
-                R[i][j] += H[i][k] * tmp[k][j];
-            }
-        }
-    }
-    //const R = H.mmul( new Matrix(tmp));
-    return R;
-};
-const estimate = ({ screenCoords, worldCoords, projectionTransform }) => {
-    const Harray = solveHomography(worldCoords.map((p) => [p.x, p.y]), screenCoords.map((p) => [p.x, p.y]));
-    const G = new Matrix([
-        [Harray[0], Harray[1], Harray[2]],
-        [Harray[3], Harray[4], Harray[5]],
-        [Harray[6], Harray[7], Harray[8]],
-    ]);
-    const K = new Matrix(projectionTransform);
-    const KInv = inverse(K);
-    const KInvArr = KInv.to2DArray();
-    const KArr = K.to2DArray();
-    const Hhat = KInv.mmul(G).mmul(K);
-    const { q } = SVD(Hhat.to2DArray());
-    const H = Hhat.div(q[1]);
-    const HTH = H.transpose().mmul(H);
-    const S = Matrix.sub(HTH, Matrix.eye(3, 3)).to2DArray();
-    console.log("G", G);
-    console.log("svd q", q);
-    console.log("Hhat", Hhat);
-    console.log("H", H);
-    console.log("HTH", HTH);
-    console.log("S", S);
-    // M00, M11, M22
-    const M00 = opposites_of_minors(S, 0, 0);
-    const M11 = opposites_of_minors(S, 1, 1);
-    const M22 = opposites_of_minors(S, 2, 2);
-    const rtM00 = Math.sqrt(M00);
-    const rtM11 = Math.sqrt(M11);
-    const rtM22 = Math.sqrt(M22);
-    // M01, M12, M02
-    const M01 = opposites_of_minors(S, 0, 1);
-    const e01 = M01 >= 0 ? 1 : -1;
-    const M12 = opposites_of_minors(S, 1, 2);
-    const e12 = M12 >= 0 ? 1 : -1;
-    const M02 = opposites_of_minors(S, 0, 2);
-    const e02 = M02 >= 0 ? 1 : -1;
-    let maxIndex = 0;
-    if (Math.abs(S[1][1]) > Math.abs(S[maxIndex][maxIndex]))
-        maxIndex = 1;
-    if (Math.abs(S[2][2]) > Math.abs(S[maxIndex][maxIndex]))
-        maxIndex = 2;
-    console.log("rtM00", rtM00, rtM11, rtM22);
-    console.log("M01", M01, M12, M02, e01, e12, e02);
-    let npa = [0, 0, 0];
-    let npb = [0, 0, 0];
-    console.log("max index", maxIndex);
-    if (maxIndex === 0) {
-        npa[0] = npb[0] = S[0][0];
-        npa[1] = S[0][1] + rtM22;
-        npb[1] = S[0][1] - rtM22;
-        npa[2] = S[0][2] + e12 * rtM11;
-        npb[2] = S[0][2] - e12 * rtM11;
-    }
-    else if (maxIndex === 1) {
-        npa[0] = S[0][1] + rtM22;
-        npb[0] = S[0][1] - rtM22;
-        npa[1] = npb[1] = S[1][1];
-        npa[2] = S[1][2] - e02 * rtM00;
-        npb[2] = S[1][2] + e02 * rtM00;
-    }
-    else if (maxIndex === 2) {
-        npa[0] = S[0][2] + e01 * rtM11;
-        npb[0] = S[0][2] - e01 * rtM11;
-        npa[1] = S[1][2] + rtM00;
-        npb[1] = S[1][2] - rtM00;
-        npa[2] = npb[2] = S[2][2];
-    }
-    console.log("npa", npa);
-    console.log("npb", npb);
-    const traceS = S[0][0] + S[1][1] + S[2][2];
-    const v = 2.0 * Math.sqrt(1 + traceS - M00 - M11 - M22);
-    const ESii = S[maxIndex][maxIndex] >= 0 ? 1 : -1;
-    const r_2 = 2 + traceS + v;
-    const nt_2 = 2 + traceS - v;
-    const r = Math.sqrt(r_2);
-    const n_t = Math.sqrt(nt_2);
-    console.log("r n_t", r, n_t);
-    const npaNorm = Math.sqrt(npa[0] * npa[0] + npa[1] * npa[1] + npa[2] * npa[2]);
-    const npbNorm = Math.sqrt(npb[0] * npb[0] + npb[1] * npb[1] + npb[2] * npb[2]);
-    const na = [npa[0] / npaNorm, npa[1] / npaNorm, npa[2] / npaNorm];
-    const nb = [npb[0] / npbNorm, npb[1] / npbNorm, npb[2] / npbNorm];
-    console.log("na nb", na, nb);
-    const half_nt = 0.5 * n_t;
-    const esii_t_r = ESii * r;
-    const ta_star = [];
-    for (let i = 0; i < 3; i++) {
-        ta_star[i] = half_nt * (esii_t_r * nb[i] - n_t * na[i]);
-    }
-    const tb_star = [];
-    for (let i = 0; i < 3; i++) {
-        tb_star[i] = half_nt * (esii_t_r * na[i] - n_t * nb[i]);
-    }
-    const HArr = H.to2DArray();
-    console.log("ta_star", ta_star, tb_star);
-    /*
-      """solutions = []
-      # Ra, ta
-      R = findRmatFrom_tstar_n(H, ta_star, na, v)
-      t = R.dot(ta_star)
-      solutions.append((R, t, na))
-      # Ra, -ta
-      solutions.append((R, -t, -na))
-      # Rb, tb
-      R = findRmatFrom_tstar_n(H, tb_star, nb, v)
-      t = R.dot(tb_star)
-      solutions.append((R, t, nb))
-      # Rb, -tb
-      solutions.append((R, -t, -nb))
-    */
-    const findT = (R1, ta_star) => {
-        const t = [
-            R1[0][0] * ta_star[0] + R1[0][1] * ta_star[1] + R1[0][2] * ta_star[2],
-            R1[1][0] * ta_star[0] + R1[1][1] * ta_star[1] + R1[1][2] * ta_star[2],
-            R1[2][0] * ta_star[0] + R1[2][1] * ta_star[1] + R1[2][2] * ta_star[2],
-        ];
-        return t;
-    };
-    const Ra = findRmatFrom_tstar_n(HArr, ta_star, na, v);
-    const ta = findT(Ra, ta_star);
-    const nta = [-ta[0], -ta[1], -ta[2]];
-    console.log("RaTRa", new Matrix(Ra).transpose().mmul(new Matrix(Ra)));
-    const Rb = findRmatFrom_tstar_n(HArr, tb_star, nb, v);
-    const tb = findT(Rb, tb_star);
-    const ntb = [-tb[0], -tb[1], -tb[2]];
-    const findModelViewProjectionTransform = (R, t) => {
-        const transform = [
-            [R[0][0], R[0][1], R[0][2], t[0]],
-            [R[1][0], R[1][1], R[1][2], t[1]],
-            [R[2][0], R[2][1], R[2][2], t[2]],
-        ];
-        return transform;
-        const modelViewProjectionTransform = [[], [], []];
-        for (let j = 0; j < 3; j++) {
-            for (let i = 0; i < 4; i++) {
-                modelViewProjectionTransform[j][i] =
-                    KArr[j][0] * transform[0][i] +
-                        KArr[j][1] * transform[1][i] +
-                        KArr[j][2] * transform[2][i];
-            }
-        }
-        return modelViewProjectionTransform;
-    };
-    console.log("Ra ta", Ra, ta);
-    console.log("Rb tb", Rb, tb);
-    const tnT = new Matrix([
-        [ta[0] * na[0], ta[0] * na[1], ta[0] * na[2]],
-        [ta[1] * na[0], ta[1] * na[1], ta[1] * na[2]],
-        [ta[2] * na[0], ta[2] * na[1], ta[2] * na[2]],
-    ]);
-    const RtnT = new Matrix(Ra).add(tnT);
-    console.log("tnT", tnT);
-    console.log("RtnT", RtnT);
-    const modelViewProjectionTransforms = [];
-    modelViewProjectionTransforms.push(findModelViewProjectionTransform(Ra, ta));
-    modelViewProjectionTransforms.push(findModelViewProjectionTransform(Ra, nta));
-    modelViewProjectionTransforms.push(findModelViewProjectionTransform(Rb, tb));
-    modelViewProjectionTransforms.push(findModelViewProjectionTransform(Rb, ntb));
-    const applyMatrix = (K, pt) => {
-        let kx = K[0][0] * pt[0] + K[0][1] * pt[1] + K[0][2];
-        let ky = K[1][0] * pt[0] + K[1][1] * pt[1] + K[1][2];
-        let kz = K[2][0] * pt[0] + K[2][1] * pt[1] + K[2][2];
-        kx /= kz;
-        ky /= kz;
-        return [kx, ky];
-    };
-    for (let s = 0; s < modelViewProjectionTransforms.length; s++) {
-        console.log("solution", s);
-        const modelViewProjectionTransform = modelViewProjectionTransforms[s];
-        for (let i = 0; i < worldCoords.length; i++) {
-            let world = applyMatrix(KInvArr, [worldCoords[i].x, worldCoords[i].y]);
-            let world2 = applyMatrix(RtnT.to2DArray(), world);
-            let screen = applyMatrix(KInvArr, [screenCoords[i].x, screenCoords[i].y]);
-            console.log("map", worldCoords[i], screenCoords[i]);
-            console.log("mapped", world, world2, screen);
-            //const mapped = computeScreenCoordiate(modelViewProjectionTransform, worldCoords[i].x, worldCoords[i].y, 0);
-            //console.log("mapped", worldCoords[i], screenCoords[i], mapped);
-            //console.log("mapped", worldCoords[i], screenCoords[i], kx2, ky2, mapped);
-        }
-    }
-    for (let s = 0; s < modelViewProjectionTransforms.length; s++) {
-        console.log("mvp solution", s);
-        const modelViewProjectionTransform = modelViewProjectionTransforms[s];
-        for (let i = 0; i < worldCoords.length; i++) {
-            let world = applyMatrix(KInvArr, [worldCoords[i].x, worldCoords[i].y]);
-            let screen = applyMatrix(KInvArr, [screenCoords[i].x, screenCoords[i].y]);
-            //const mapped = computeScreenCoordiate(modelViewProjectionTransform, worldCoords[i].x, worldCoords[i].y, 0);
-            const mapped = computeScreenCoordiate(modelViewProjectionTransform, world[0], world[1], 0);
-            console.log("mapped", worldCoords[i], screenCoords[i], world, screen, mapped);
-        }
-    }
-    return null;
-    /*
-  
-    const R1 = findRmatFrom_tstar_n(HArr, ta_star, na, v);
-    const R2 = findRmatFrom_tstar_n(HArr, tb_star, nb, v);
-    console.log("R1", R1);
-    console.log("R2", R2);
-  
-    const t = [
-      R1[0][0] * ta_star[0] + R1[0][1] * ta_star[1] + R1[0][2] * ta_star[2],
-      R1[1][0] * ta_star[0] + R1[1][1] * ta_star[1] + R1[1][2] * ta_star[2],
-      R1[2][0] * ta_star[0] + R1[2][1] * ta_star[1] + R1[2][2] * ta_star[2]
-    ]
-  
-    const R = R2;
-  
-    const modelViewProjectionTransform = [
-      [R[0][0], R[0][1], R[0][2], t[0]],
-      [R[1][0], R[1][1], R[1][2], t[0]],
-      [R[2][0], R[2][1], R[2][2], t[0]],
-    ];
-    */
-    for (let i = 0; i < worldCoords.length; i++) {
-        const mapped = computeScreenCoordiate(modelViewProjectionTransform, worldCoords[i].x, worldCoords[i].y, 0);
-        console.log("mapped", worldCoords[i], screenCoords[i], mapped);
-    }
-    // this is the full computation if the projectTransform does not look like the expected format, but more computations
-    const modelViewTransform = [[], [], []];
-    for (let j = 0; j < 3; j++) {
-        for (let i = 0; i < 4; i++) {
-            modelViewTransform[j][i] =
-                KInvArr[j][0] * modelViewProjectionTransform[0][i] +
-                    KInvArr[j][1] * modelViewProjectionTransform[1][i] +
-                    KInvArr[j][2] * modelViewProjectionTransform[2][i];
-        }
-    }
-    console.log("KInvArr", KInvArr);
-    console.log("modelViewProjectionTransform", modelViewProjectionTransform);
-    console.log("modelViewTransform", modelViewTransform);
-    return modelViewTransform;
-};
-export { estimate };

package/dist/compiler/estimation/refine-estimate-experiment.d.ts

@@ -1,6 +0,0 @@
-export function refineEstimate({ initialModelViewTransform, projectionTransform, worldCoords: inWorldCoords, screenCoords: inScreenCoords, }: {
-    initialModelViewTransform: any;
-    projectionTransform: any;
-    worldCoords: any;
-    screenCoords: any;
-}): any[][] | null;

package/dist/compiler/estimation/refine-estimate-experiment.js

@@ -1,429 +0,0 @@
-/**
- * Trying to do normalization before running ICP
- *   i.e. make coodinates centroid at origin and avg distance from origin is sqrt(2)
- *
- * can we get rid of projectionTransform, and just do ICP on modelViewTransform?
- *
- * but couldn't make it work yet. Can someone with theoretical knowledge on ICP reach out to help?, particularly Multiview Levenberg-Marquardt ICP
- *   I have problem understanding the jacobian and things like that
- *
- */
-import { Matrix, inverse } from "ml-matrix";
-import { applyModelViewProjectionTransform, buildModelViewProjectionTransform, computeScreenCoordiate, } from "./utils.js";
-const TRACKING_THRESH = 5.0; // default
-const K2_FACTOR = 4.0; // Question: should it be relative to the size of the screen instead of hardcoded?
-const ICP_MAX_LOOP = 10;
-const ICP_BREAK_LOOP_ERROR_THRESH = 0.1;
-const ICP_BREAK_LOOP_ERROR_RATIO_THRESH = 0.99;
-const ICP_BREAK_LOOP_ERROR_THRESH2 = 4.0;
-// some temporary/intermediate variables used later. Declare them beforehand to reduce new object allocations
-let mat = [[], [], []];
-let J_U_Xc = [[], []]; // 2x3
-let J_Xc_S = [[], [], []]; // 3x6
-const refineEstimate = ({ initialModelViewTransform, projectionTransform, worldCoords: inWorldCoords, screenCoords: inScreenCoords, }) => {
-    const { normalizedCoords: worldCoords, param: worldParam } = normalizePoints(inWorldCoords);
-    const { normalizedCoords: screenCoords, param: screenParam } = normalizePoints(inScreenCoords);
-    const modelViewProjectionTransform = buildModelViewProjectionTransform(projectionTransform, initialModelViewTransform);
-    const normModelViewProjectionTransform = _getNormalizedModelViewTransform(modelViewProjectionTransform, worldParam, screenParam);
-    /*
-     * porjection matrix
-     *     [k00,   0, k02]
-     * K = [  0, k11, k12]
-     *     [  0,   0,   1]
-     *
-     *          [1/k00,      0,  -k02/k00]
-     * inv(K) = [    0,  1/k11,  -k12/k11]
-     * 	      [    0,      0,         1]
-     *
-     *
-     * denote modelViewProjectionTransform as A,
-     * since A = K * M,   M = inv(K) * A
-     *
-     *     [a00 / k00 - a20 * k02/k00,  a01 / k00 - k02/k00 * a21,  a02 / k00 - k02/k00 * a22,  a03 / k00 - k02/k00 * a23]
-     * M = [a10 / k11 - a20 * k12/k11,  a11 / k11 - k12/k11 * a21,  a13 / k11 - k12/k11 * a22,  a13 / k11 - k12/111 * a23]
-     *     [            a20          ,  			    a21,			a22, 		            a23]
-     */
-    const a = normModelViewProjectionTransform;
-    const k = projectionTransform;
-    const normModelViewTransform = [
-        [
-            a[0][0] / k[0][0] - (a[2][0] * k[0][2]) / k[0][0],
-            a[0][1] / k[0][0] - (a[2][1] * k[0][2]) / k[0][0],
-            a[0][2] / k[0][0] - (a[2][2] * k[0][2]) / k[0][0],
-            a[0][3] / k[0][0] - (a[2][3] * k[0][2]) / k[0][0],
-        ],
-        [
-            a[1][0] / k[1][1] - (a[2][0] * k[1][2]) / k[1][1],
-            a[1][1] / k[1][1] - (a[2][1] * k[1][2]) / k[1][1],
-            a[1][2] / k[1][1] - (a[2][2] * k[1][2]) / k[1][1],
-            a[1][3] / k[1][1] - (a[2][3] * k[1][2]) / k[1][1],
-        ],
-        [a[2][0], a[2][1], a[2][2], a[2][3]],
-    ];
-    const inlierProbs = [1.0, 0.8, 0.6, 0.4, 0.0];
-    let updatedModelViewTransform = normModelViewTransform;
-    let finalModelViewTransform = null;
-    for (let i = 0; i < inlierProbs.length; i++) {
-        const ret = _doICP({
-            initialModelViewTransform: updatedModelViewTransform,
-            projectionTransform,
-            worldCoords,
-            screenCoords,
-            inlierProb: inlierProbs[i],
-        });
-        updatedModelViewTransform = ret.modelViewTransform;
-        if (ret.err < TRACKING_THRESH) {
-            finalModelViewTransform = updatedModelViewTransform;
-            break;
-        }
-    }
-    if (finalModelViewTransform === null)
-        return null;
-    const denormModelViewTransform = _getDenormalizedModelViewTransform(finalModelViewTransform, worldParam, screenParam);
-    return denormModelViewTransform;
-};
-// ICP iteration
-// Question: can someone provide theoretical reference / mathematical proof for the following computations?
-// 	     I'm unable to derive the Jacobian
-const _doICP = ({ initialModelViewTransform, projectionTransform, worldCoords, screenCoords, inlierProb, }) => {
-    const isRobustMode = inlierProb < 1;
-    let modelViewTransform = initialModelViewTransform;
-    let err0 = 0.0;
-    let err1 = 0.0;
-    let E = new Array(worldCoords.length);
-    let E2 = new Array(worldCoords.length);
-    let dxs = new Array(worldCoords.length);
-    let dys = new Array(worldCoords.length);
-    for (let l = 0; l <= ICP_MAX_LOOP; l++) {
-        const modelViewProjectionTransform = buildModelViewProjectionTransform(projectionTransform, modelViewTransform);
-        for (let n = 0; n < worldCoords.length; n++) {
-            const u = computeScreenCoordiate(modelViewProjectionTransform, worldCoords[n].x, worldCoords[n].y, worldCoords[n].z);
-            const dx = screenCoords[n].x - u.x;
-            const dy = screenCoords[n].y - u.y;
-            console.log("icp err", worldCoords[n], u, screenCoords[n]);
-            dxs[n] = dx;
-            dys[n] = dy;
-            E[n] = dx * dx + dy * dy;
-        }
-        let K2; // robust mode only
-        err1 = 0.0;
-        if (isRobustMode) {
-            const inlierNum = Math.max(3, Math.floor(worldCoords.length * inlierProb) - 1);
-            for (let n = 0; n < worldCoords.length; n++) {
-                E2[n] = E[n];
-            }
-            E2.sort((a, b) => {
-                return a - b;
-            });
-            K2 = Math.max(E2[inlierNum] * K2_FACTOR, 16.0);
-            for (let n = 0; n < worldCoords.length; n++) {
-                if (E2[n] > K2)
-                    err1 += K2 / 6;
-                else
-                    err1 += (K2 / 6.0) * (1.0 - (1.0 - E2[n] / K2) * (1.0 - E2[n] / K2) * (1.0 - E2[n] / K2));
-            }
-        }
-        else {
-            for (let n = 0; n < worldCoords.length; n++) {
-                err1 += E[n];
-            }
-        }
-        err1 /= worldCoords.length;
-        console.log("icp loop", inlierProb, l, err1);
-        if (err1 < ICP_BREAK_LOOP_ERROR_THRESH)
-            break;
-        //if (l > 0 && err1 < ICP_BREAK_LOOP_ERROR_THRESH2 && err1/err0 > ICP_BREAK_LOOP_ERROR_RATIO_THRESH) break;
-        if (l > 0 && err1 / err0 > ICP_BREAK_LOOP_ERROR_RATIO_THRESH)
-            break;
-        if (l === ICP_MAX_LOOP)
-            break;
-        err0 = err1;
-        const dU = [];
-        const allJ_U_S = [];
-        for (let n = 0; n < worldCoords.length; n++) {
-            if (isRobustMode && E[n] > K2) {
-                continue;
-            }
-            const J_U_S = _getJ_U_S({
-                modelViewProjectionTransform,
-                modelViewTransform,
-                projectionTransform,
-                worldCoord: worldCoords[n],
-            });
-            if (isRobustMode) {
-                const W = (1.0 - E[n] / K2) * (1.0 - E[n] / K2);
-                for (let j = 0; j < 2; j++) {
-                    for (let i = 0; i < 6; i++) {
-                        J_U_S[j][i] *= W;
-                    }
-                }
-                dU.push([dxs[n] * W]);
-                dU.push([dys[n] * W]);
-            }
-            else {
-                dU.push([dxs[n]]);
-                dU.push([dys[n]]);
-            }
-            for (let i = 0; i < J_U_S.length; i++) {
-                allJ_U_S.push(J_U_S[i]);
-            }
-        }
-        const dS = _getDeltaS({ dU, J_U_S: allJ_U_S });
-        if (dS === null)
-            break;
-        modelViewTransform = _updateModelViewTransform({ modelViewTransform, dS });
-    }
-    return { modelViewTransform, err: err1 };
-};
-const _updateModelViewTransform = ({ modelViewTransform, dS }) => {
-    let ra = dS[0] * dS[0] + dS[1] * dS[1] + dS[2] * dS[2];
-    let q0, q1, q2;
-    if (ra < 0.000001) {
-        q0 = 1.0;
-        q1 = 0.0;
-        q2 = 0.0;
-        ra = 0.0;
-    }
-    else {
-        ra = Math.sqrt(ra);
-        q0 = dS[0] / ra;
-        q1 = dS[1] / ra;
-        q2 = dS[2] / ra;
-    }
-    const cra = Math.cos(ra);
-    const sra = Math.sin(ra);
-    const one_cra = 1.0 - cra;
-    mat[0][0] = q0 * q0 * one_cra + cra;
-    mat[0][1] = q0 * q1 * one_cra - q2 * sra;
-    mat[0][2] = q0 * q2 * one_cra + q1 * sra;
-    mat[0][3] = dS[3];
-    mat[1][0] = q1 * q0 * one_cra + q2 * sra;
-    mat[1][1] = q1 * q1 * one_cra + cra;
-    mat[1][2] = q1 * q2 * one_cra - q0 * sra;
-    mat[1][3] = dS[4];
-    mat[2][0] = q2 * q0 * one_cra - q1 * sra;
-    mat[2][1] = q2 * q1 * one_cra + q0 * sra;
-    mat[2][2] = q2 * q2 * one_cra + cra;
-    mat[2][3] = dS[5];
-    const mat2 = [[], [], []];
-    for (let j = 0; j < 3; j++) {
-        for (let i = 0; i < 4; i++) {
-            mat2[j][i] =
-                modelViewTransform[j][0] * mat[0][i] +
-                    modelViewTransform[j][1] * mat[1][i] +
-                    modelViewTransform[j][2] * mat[2][i];
-        }
-        mat2[j][3] += modelViewTransform[j][3];
-    }
-    return mat2;
-};
-const _getDeltaS = ({ dU, J_U_S }) => {
-    const J = new Matrix(J_U_S);
-    const U = new Matrix(dU);
-    const JT = J.transpose();
-    const JTJ = JT.mmul(J);
-    const JTU = JT.mmul(U);
-    let JTJInv;
-    try {
-        JTJInv = inverse(JTJ);
-    }
-    catch (e) {
-        return null;
-    }
-    const S = JTJInv.mmul(JTU);
-    return S.to1DArray();
-};
-const _getJ_U_S = ({ modelViewProjectionTransform, modelViewTransform, projectionTransform, worldCoord, }) => {
-    const T = modelViewTransform;
-    const { x, y, z } = worldCoord;
-    const u = applyModelViewProjectionTransform(modelViewProjectionTransform, x, y, z);
-    const z2 = u.z * u.z;
-    J_U_Xc[0][0] = (projectionTransform[0][0] * u.z - projectionTransform[2][0] * u.x) / z2;
-    J_U_Xc[0][1] = (projectionTransform[0][1] * u.z - projectionTransform[2][1] * u.x) / z2;
-    J_U_Xc[0][2] = (projectionTransform[0][2] * u.z - projectionTransform[2][2] * u.x) / z2;
-    J_U_Xc[1][0] = (projectionTransform[1][0] * u.z - projectionTransform[2][0] * u.y) / z2;
-    J_U_Xc[1][1] = (projectionTransform[1][1] * u.z - projectionTransform[2][1] * u.y) / z2;
-    J_U_Xc[1][2] = (projectionTransform[1][2] * u.z - projectionTransform[2][2] * u.y) / z2;
-    J_Xc_S[0][0] = T[0][2] * y;
-    J_Xc_S[0][1] = -T[0][2] * x;
-    J_Xc_S[0][2] = T[0][1] * x - T[0][0] * y;
-    J_Xc_S[0][3] = T[0][0];
-    J_Xc_S[0][4] = T[0][1];
-    J_Xc_S[0][5] = T[0][2];
-    J_Xc_S[1][0] = T[1][2] * y;
-    J_Xc_S[1][1] = -T[1][2] * x;
-    J_Xc_S[1][2] = T[1][1] * x - T[1][0] * y;
-    J_Xc_S[1][3] = T[1][0];
-    J_Xc_S[1][4] = T[1][1];
-    J_Xc_S[1][5] = T[1][2];
-    J_Xc_S[2][0] = T[2][2] * y;
-    J_Xc_S[2][1] = -T[2][2] * x;
-    J_Xc_S[2][2] = T[2][1] * x - T[2][0] * y;
-    J_Xc_S[2][3] = T[2][0];
-    J_Xc_S[2][4] = T[2][1];
-    J_Xc_S[2][5] = T[2][2];
-    const J_U_S = [[], []];
-    for (let j = 0; j < 2; j++) {
-        for (let i = 0; i < 6; i++) {
-            J_U_S[j][i] = 0.0;
-            for (let k = 0; k < 3; k++) {
-                J_U_S[j][i] += J_U_Xc[j][k] * J_Xc_S[k][i];
-            }
-        }
-    }
-    return J_U_S;
-};
-const _getNormalizedModelViewTransform = (modelViewTransform, worldParam, screenParam) => {
-    /*
-     *  notations:
-     *    m: modelViewTransform,
-     *    [x,y,z,1]: world coordinates
-     *    [x',y',z',1]: screen coordinates
-     *
-     *  By normalizing coordinates with meanX, meanY and scale s, it means to transform the coordinates to
-     *  note that z doesn't scale up, otherwise screen point doesn't scale, e.g.   x' = x / z
-     *    [s*(x-meanX)]
-     *    [s*(y-meanY)]
-     *    [z          ]
-     *    [1          ]
-     *
-     *  Let's define transformation T, such that
-     *  `normalizedP = T * P`
-     *
-     *    [s * (x - meanX)]   [s, 0,   0, -s*meanX]   [x]
-     *    [s * (y - meanY)] = [0, s,   0, -s*meanY] * [y]
-     *    [z              ]   [0, 0,   1,        0]   [z]
-     *    [1              ]   [0, 0,   0,        1]   [1]
-     *
-     *  and `P = inv(T) * normalizedP`
-     *
-     *    [x]   [1/s, 0  , 0, meanX]   [s * (x - meanX)]
-     *    [y] = [0  , 1/s, 0, meanY] * [s * (y - meanY)]
-     *    [z]   [0  , 0  , 1,     0]   [z              ]
-     *    [1]   [0  , 0  , 0,     1]   [1              ]
-     *
-     *
-     * Before normalizating coordinates, the following holds:
-     *  M * P = P'   (P is world coordinate, and P' is screen coordinate)
-     *
-     *  -> M * inv(T) * T * P = inv(T') * T' * P'
-     *  -> T' * M * inv(T) * T * P = T' * P'
-     *  here, T * P, and T' * P' are normalized coordaintes for world and screen, so, the modelViewTransform for normalized coordinates would be:
-     *
-     *  Mnorm = T' * M * inv(T) =
-     *
-     *  [s',  0,   0, -s'*meanX']   [m00, m01, m02, m03]   [1/s,   0, 0, meanX]
-     *  [ 0, s',   0, -s'*meanY'] * [m10, m11, m12, m13] * [  0, 1/s, 0, meanY]
-     *  [ 0,  0,   1,          0]   [m20, m21, m22, m23]   [  0,   0, 1,     0]
-     *  [ 0,  0,   0,          1]   [0,   0,   0,     1]   [  0,   0, 0,     1]
-     *
-     *  =
-     *
-     *  [m00 * s'/s, m01 * s'/s, m02 * s', m00*s'*meanX + m01*s'*meanY + m03*s' - meanX'*s']
-     *  [m10 * s'/s, m11 * s'/s, m12 * s', m10*s'*meanX + m11*s'*meanY + m13*s' - meanY'*s']
-     *  [m20 / s   , m21 / s   , m22     , m20   *meanX + m21   *meanY + m23               ]
-     *  [         0,          0,        0,                	        		1]
-     *
-     */
-    const m = modelViewTransform;
-    const ss = screenParam.s / worldParam.s;
-    const normModelViewTransform = [
-        [
-            m[0][0] * ss,
-            m[0][1] * ss,
-            m[0][2] * screenParam.s,
-            (m[0][0] * worldParam.meanX + m[0][1] * worldParam.meanY + m[0][3] - screenParam.meanX) *
-                screenParam.s,
-        ],
-        [
-            m[1][0] * ss,
-            m[1][1] * ss,
-            m[1][2] * screenParam.s,
-            (m[1][0] * worldParam.meanX + m[1][1] * worldParam.meanY + m[1][3] - screenParam.meanY) *
-                screenParam.s,
-        ],
-        [
-            m[2][0] / worldParam.s,
-            m[2][1] / worldParam.s,
-            m[2][2],
-            m[2][0] * worldParam.meanX + m[2][1] * worldParam.meanY + m[2][3],
-        ],
-    ];
-    return normModelViewTransform;
-};
-const _getDenormalizedModelViewTransform = (modelViewTransform, worldParam, screenParam) => {
-    /*
-     *  Refer to _getNormalizedModelViewTransform, we have
-     *
-     *  Mnorm = T' * M * inv(T)
-     *
-     *  Therefore,
-     *
-     *  M = inv(T') * Mnorm * T
-     *
-     *  [1/s',    0, 0, meanX']   [m00, m01, m02, m03]   [s, 0, 0, -s*meanX]
-     *  [0   , 1/s', 0, meanY'] * [m10, m11, m12, m13] * [0, s, 0, -s*meanY]
-     *  [0   , 0   , 1,      0]   [m20, m21, m22, m23]   [0, 0, 1,        0]
-     *  [0   , 0   , 0,      1]   [0,   0,   0,     1]   [0, 0, 0,        1]
-     *
-     *  =
-     *
-     *  [m00*s/s', m01*s/s', m02/s', (-m00*s*meanX -m01*s*meanY+m03)/s' + meanX'],
-     *  [m10*s/s', m11*s/s', m12/s', (-m10*s*meanX -m11*s*meanY+m13)/s' + meanY'],
-     *  [m20*s  ', m21*s  ', m22   ,  -m20*s*meanX -m21*s*meanY+m23)            ],
-     *  [0       ,        0,      0,                                            1]
-     *
-     */
-    const m = modelViewTransform;
-    const ss = worldParam.s / screenParam.s;
-    const sMeanX = worldParam.s * worldParam.meanX;
-    const sMeanY = worldParam.s * worldParam.meanY;
-    const denormModelViewTransform = [
-        [
-            m[0][0] * ss,
-            m[0][1] * ss,
-            m[0][2] / screenParam.s,
-            (-m[0][0] * sMeanX - m[0][1] * sMeanY + m[0][3]) / screenParam.s + screenParam.meanX,
-        ],
-        [
-            m[1][0] * ss,
-            m[1][1] * ss,
-            m[1][2] / screenParam.s,
-            (-m[1][0] * sMeanX - m[1][1] * sMeanY + m[1][3]) / screenParam.s + screenParam.meanY,
-        ],
-        [
-            m[2][0] * worldParam.s,
-            m[2][1] * worldParam.s,
-            m[2][2],
-            -m[2][0] * sMeanX - m[2][1] * sMeanY + m[2][3],
-        ],
-    ];
-    return denormModelViewTransform;
-};
-// centroid at origin and avg distance from origin is sqrt(2)
-const normalizePoints = (coords) => {
-    let sumX = 0;
-    let sumY = 0;
-    for (let i = 0; i < coords.length; i++) {
-        sumX += coords[i].x;
-        sumY += coords[i].y;
-    }
-    let meanX = sumX / coords.length;
-    let meanY = sumY / coords.length;
-    let sumDiff = 0;
-    for (let i = 0; i < coords.length; i++) {
-        const diffX = coords[i].x - meanX;
-        const diffY = coords[i].y - meanY;
-        sumDiff += Math.sqrt(diffX * diffX + diffY * diffY);
-    }
-    let s = (Math.sqrt(2) * coords.length) / sumDiff;
-    const normalizedCoords = [];
-    for (let i = 0; i < coords.length; i++) {
-        normalizedCoords.push({
-            x: (coords[i].x - meanX) * s,
-            y: (coords[i].y - meanY) * s,
-        });
-    }
-    return { normalizedCoords, param: { meanX, meanY, s } };
-};
-export { refineEstimate };

package/dist/react/AREditor.d.ts

@@ -1,5 +0,0 @@
-interface AREditorProps {
-    adminId: string;
-}
-export declare const AREditor: React.FC<AREditorProps>;
-export {};

package/dist/react/AREditor.js

@@ -1,159 +0,0 @@
-import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { useState, useRef, useCallback } from "react";
-import { customAlphabet } from "nanoid";
-import { Image, Video, Upload, Camera, LoaderCircle } from "lucide-react";
-const ALLOWED_MIME_TYPES = ["image/jpeg", "image/png", "image/webp"];
-const ALLOWED_VIDEO_TYPES = ["video/mp4", "video/webm"];
-const useFileUpload = (allowedTypes) => {
-    const [fileState, setFileState] = useState({ file: null, preview: "" });
-    const [dimensions, setDimensions] = useState({});
-    const fileInputRef = useRef(null);
-    const handleFileChange = useCallback((file) => {
-        if (fileState.preview) {
-            URL.revokeObjectURL(fileState.preview);
-        }
-        if (!file) {
-            setFileState({ file: null, preview: "" });
-            return;
-        }
-        // Para archivos .mind, validar la extensión en lugar del tipo MIME
-        if (allowedTypes.includes(".mind")) {
-            if (!file.name.toLowerCase().endsWith(".mind")) {
-                throw new Error("El archivo debe tener extensión .mind");
-            }
-        }
-        else if (!allowedTypes.includes(file.type)) {
-            throw new Error("Tipo de archivo no permitido");
-        }
-        if (file.type.includes("video")) {
-            const video = document.createElement("video");
-            video.src = URL.createObjectURL(file);
-        }
-        console.log("Archivo cargado:", {
-            nombre: file.name,
-            tamaño: (file.size / 1024).toFixed(2) + " KB",
-            tipo: file.type || "application/octet-stream",
-        });
-        const preview = URL.createObjectURL(file);
-        if (file.type.includes("video")) {
-            const video = document.createElement("video");
-            video.src = URL.createObjectURL(file);
-            video.addEventListener("loadedmetadata", () => {
-                const width = video.videoWidth;
-                const height = video.videoHeight;
-                setDimensions({ width, height });
-                console.log("Ancho y alto del video:", width, height);
-            });
-        }
-        setFileState({ file, preview });
-    }, [allowedTypes, fileState.preview]);
-    const reset = useCallback(() => {
-        if (fileState.preview) {
-            URL.revokeObjectURL(fileState.preview);
-        }
-        setFileState({ file: null, preview: "" });
-        if (fileInputRef.current) {
-            fileInputRef.current.value = "";
-        }
-    }, [fileState.preview]);
-    return { fileState, handleFileChange, reset, fileInputRef, dimensions };
-};
-const useUploadFile = () => {
-    const uploadFile = async (file, type) => {
-        const customNanoid = customAlphabet("1234567890ABCDEFGHIJKLMNOPQRSTUVWXYZ", 21);
-        const id = customNanoid();
-        const formData = new FormData();
-        formData.append("file", file);
-        const endpoint = type === "video"
-            ? `https://r2-worker.sergiolazaromondargo.workers.dev/video/${id}`
-            : type === "mind"
-                ? `https://r2-worker.sergiolazaromondargo.workers.dev/mind/${id}`
-                : `https://r2-worker.sergiolazaromondargo.workers.dev/${id}`;
-        const response = await fetch(endpoint, {
-            method: "PUT",
-            body: formData,
-        });
-        if (!response.ok) {
-            throw new Error(`Error al subir ${type}: ${response.status} ${response.statusText}`);
-        }
-        return await response.json();
-    };
-    return { uploadFile };
-};
-export const AREditor = ({ adminId }) => {
-    const { fileState: imageState, handleFileChange: handleImageChange, reset: resetImage, fileInputRef: imageInputRef, } = useFileUpload(ALLOWED_MIME_TYPES);
-    const { fileState: mindState, handleFileChange: handleMindChange, reset: resetMind, fileInputRef: mindInputRef, } = useFileUpload([".mind"]);
-    const { fileState: videoState, handleFileChange: handleVideoChange, reset: resetVideo, fileInputRef: videoInputRef, dimensions: videoDimensions, } = useFileUpload(ALLOWED_VIDEO_TYPES);
-    const [videoScale, setVideoScale] = useState(1);
-    const [loading, setLoading] = useState(false);
-    const [error, setError] = useState("");
-    const { uploadFile } = useUploadFile();
-    const handleSave = async () => {
-        try {
-            setLoading(true);
-            setError("");
-            if (!imageState.file || !mindState.file || !videoState.file) {
-                throw new Error("Se requieren una imagen, un archivo .mind y un video");
-            }
-            const [imageResult, mindResult, videoResult] = await Promise.all([
-                uploadFile(imageState.file, "image"),
-                uploadFile(mindState.file, "mind"),
-                uploadFile(videoState.file, "video"),
-            ]);
-            const data = {
-                adminId,
-                data: [
-                    {
-                        id: `photos-${Date.now()}`,
-                        type: "photos",
-                        images: [{ image: imageResult.url, fileId: imageResult.fileId }],
-                    },
-                    {
-                        id: `videoNative-${Date.now()}`,
-                        type: "videoNative",
-                        url: videoResult.url,
-                        fileId: videoResult.fileId,
-                        scale: videoScale,
-                        width: videoDimensions.width,
-                        height: videoDimensions.height,
-                    },
-                    {
-                        id: `ar-${Date.now()}`,
-                        type: "ar",
-                        url: mindResult.url,
-                        fileId: mindResult.fileId,
-                    },
-                ],
-                type: "ar",
-            };
-            const response = await fetch("/api/updateadmin.json", {
-                method: "POST",
-                headers: { "Content-Type": "application/json" },
-                body: JSON.stringify(data),
-            });
-            if (!response.ok) {
-                throw new Error(`Error actualizando datos AR: ${response.status}`);
-            }
-            alert("¡Guardado exitosamente!");
-            resetImage();
-            resetMind();
-            resetVideo();
-        }
-        catch (error) {
-            setError(error.message);
-        }
-        finally {
-            setLoading(false);
-        }
-    };
-    const FileUploadSection = ({ type, icon: Icon, fileState, inputRef, onFileChange, allowedTypes, label, }) => (_jsxs("div", { className: "group relative overflow-hidden rounded-xl shadow-lg bg-white/80 backdrop-blur-sm transition-all duration-300 hover:shadow-xl hover:scale-[1.02] border border-gray-100", children: [_jsx("input", { ref: inputRef, type: "file", accept: allowedTypes.join(","), onChange: (e) => {
-                    try {
-                        const file = e.target.files?.[0] || null;
-                        onFileChange(file);
-                    }
-                    catch (error) {
-                        setError(error.message);
-                    }
-                }, className: "hidden" }), !fileState.file ? (_jsxs("label", { htmlFor: inputRef.current?.id, onClick: () => inputRef.current?.click(), className: "flex cursor-pointer flex-col items-center justify-center p-10 bg-gradient-to-br from-gray-50 to-white transition-colors group-hover:from-blue-50 group-hover:to-purple-50", children: [_jsx("div", { className: "transform transition-transform duration-300 group-hover:scale-110", children: _jsx(Icon, { className: "h-16 w-16 text-gray-400 group-hover:text-blue-500" }) }), _jsx("span", { className: "mt-4 text-lg font-medium bg-gradient-to-r from-gray-600 to-gray-800 bg-clip-text text-transparent group-hover:from-blue-600 group-hover:to-purple-600", children: label }), _jsx("span", { className: "mt-2 text-sm text-gray-400 group-hover:text-gray-500", children: allowedTypes.join(", ") })] })) : (_jsxs("div", { className: "p-6 space-y-4", children: [_jsx("div", { className: "relative aspect-video w-full overflow-hidden rounded-lg ring-1 ring-gray-100", children: type === "video" ? (_jsx("video", { src: fileState.preview, controls: true, className: "h-full w-full object-cover", children: "Tu navegador no soporta la reproducci\u00F3n de videos." })) : type === "image" ? (_jsx("img", { src: fileState.preview, alt: "Preview", className: "h-full w-full object-cover" })) : (_jsxs("div", { className: "flex h-full flex-col items-center justify-center space-y-3 bg-gradient-to-br from-blue-50 to-purple-50 p-4", children: [_jsx("div", { className: "flex items-center justify-center rounded-full bg-gradient-to-r from-blue-400 to-purple-400 p-3", children: _jsx(Upload, { className: "h-6 w-6 text-white" }) }), _jsxs("div", { className: "text-center space-y-2", children: [_jsx("span", { className: "block text-lg font-medium text-gray-600", children: fileState.file.name }), _jsxs("span", { className: "block text-sm text-gray-500", children: ["Tama\u00F1o: ", (fileState.file.size / 1024).toFixed(2), " KB"] }), _jsx("span", { className: "mt-1 block text-sm font-medium text-green-600", children: "\u2713 Archivo AR cargado correctamente" })] })] })) }), _jsxs("div", { className: "flex items-center justify-between", children: [_jsxs("div", { className: "flex items-center space-x-3", children: [_jsx(Icon, { className: "h-5 w-5 text-blue-500" }), _jsx("span", { className: "text-sm font-medium text-gray-600", children: fileState.file.name })] }), _jsx("button", { onClick: () => onFileChange(null), className: "rounded-full bg-gradient-to-r from-blue-500 to-purple-500 px-4 py-2 text-sm font-medium text-white shadow-md transition-all hover:from-blue-600 hover:to-purple-600 hover:shadow-lg active:scale-95", children: "Cambiar" })] })] }))] }));
-    return (_jsx("div", { className: "min-h-screen w-full bg-gradient-to-br from-blue-50 via-white to-purple-50 p-4 md:p-8", children: _jsxs("div", { className: "mx-auto max-w-3xl rounded-3xl bg-white/90 backdrop-blur-md p-6 md:p-10 shadow-2xl ring-1 ring-black/10", children: [_jsxs("div", { className: "flex flex-col items-center justify-center space-y-8", children: [_jsx("div", { className: "rounded-2xl bg-gradient-to-br from-blue-500 to-purple-500 p-6 shadow-xl shadow-blue-300/30 hover:scale-105 transition-transform", children: _jsx(Camera, { className: "h-12 w-12 text-white" }) }), _jsx("h1", { className: "bg-gradient-to-r from-blue-600 to-purple-600 bg-clip-text text-5xl font-bold text-transparent text-center", children: "Editor de Experiencia AR" }), _jsx("p", { className: "text-2xl text-gray-600 text-center font-light", children: "Crea una experiencia de realidad aumentada \u00FAnica" })] }), _jsxs("div", { className: "mt-12 space-y-8", children: [_jsx(FileUploadSection, { type: "image", icon: Image, fileState: imageState, inputRef: imageInputRef, onFileChange: handleImageChange, allowedTypes: ALLOWED_MIME_TYPES, label: "Haz clic para seleccionar una imagen" }), _jsx(FileUploadSection, { type: "mind", icon: Upload, fileState: mindState, inputRef: mindInputRef, onFileChange: handleMindChange, allowedTypes: [".mind"], label: "Haz clic para seleccionar archivo .mind" }), _jsx(FileUploadSection, { type: "video", icon: Video, fileState: videoState, inputRef: videoInputRef, onFileChange: handleVideoChange, allowedTypes: ALLOWED_VIDEO_TYPES, label: "Haz clic para seleccionar un video" }), _jsxs("div", { className: "space-y-4 rounded-2xl border border-gray-200/50 bg-white/90 backdrop-blur-md p-8 shadow-lg ring-1 ring-black/10", children: [_jsxs("label", { className: "flex items-center justify-between text-2xl font-semibold text-gray-800", children: [_jsx("span", { children: "Escala del Video" }), _jsxs("span", { className: "bg-gradient-to-r from-blue-600 to-purple-600 bg-clip-text text-transparent font-bold", children: [videoScale, "x"] })] }), _jsxs("div", { className: "relative py-8", children: [_jsx("div", { className: "absolute h-3 w-full rounded-full bg-gradient-to-r from-blue-400 to-purple-400 opacity-20" }), _jsx("div", { className: "absolute h-3 rounded-full bg-gradient-to-r from-blue-400 to-purple-400 shadow-lg", style: { width: `${(videoScale / 2) * 100}%` } }), _jsx("input", { type: "range", min: "0.1", max: "2", step: "0.1", value: videoScale, onChange: (e) => setVideoScale(Number(e.target.value)), className: "relative h-3 w-full cursor-pointer appearance-none rounded-lg bg-transparent focus:outline-none focus:ring-2 focus:ring-blue-400 focus:ring-offset-4", style: { WebkitAppearance: "none" } })] })] })] }), error && (_jsx("div", { className: "mt-6 rounded-xl bg-red-50 p-4 text-red-700 shadow-sm ring-1 ring-red-100", children: error })), _jsx("button", { onClick: handleSave, disabled: loading, className: "mt-10 w-full rounded-xl bg-gradient-to-r from-blue-600 to-purple-600 py-5 text-xl font-semibold text-white shadow-xl transition-all hover:from-blue-700 hover:to-purple-700 disabled:from-gray-400 disabled:to-gray-400 disabled:shadow-none focus:outline-none focus:ring-2 focus:ring-blue-400 focus:ring-offset-4", children: loading ? (_jsxs("div", { className: "flex items-center justify-center space-x-3", children: [_jsx(LoaderCircle, { className: "h-7 w-7 animate-spin" }), _jsx("span", { children: "Guardando..." })] })) : ("Guardar") })] }) }));
-};

package/dist/react/ProgressDialog.d.ts

@@ -1,13 +0,0 @@
-interface ProgressDialogProps {
-    open: boolean;
-    imageStatus: "pending" | "processing" | "completed" | "error";
-    videoStatus: "pending" | "processing" | "completed" | "error";
-    arProcessingStatus: "pending" | "processing" | "completed" | "error";
-    arUploadStatus: "pending" | "processing" | "completed" | "error";
-    imageProgress?: number;
-    videoProgress?: number;
-    arProcessingProgress?: number;
-    arUploadProgress?: number;
-}
-export declare function ProgressDialog({ open, imageStatus, videoStatus, arProcessingStatus, arUploadStatus, imageProgress, videoProgress, arProcessingProgress, arUploadProgress, }: ProgressDialogProps): import("react/jsx-runtime").JSX.Element | null;
-export {};

package/dist/react/ProgressDialog.js

@@ -1,57 +0,0 @@
-import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { useEffect } from "react";
-import { CheckCircle2, Loader2, Upload, Image as ImageIcon, Video as VideoIcon, } from "lucide-react";
-export function ProgressDialog({ open, imageStatus, videoStatus, arProcessingStatus, arUploadStatus, imageProgress = 0, videoProgress = 0, arProcessingProgress = 0, arUploadProgress = 0, }) {
-    // Configurar las etapas del progreso
-    const stages = [
-        {
-            label: "Subiendo imagen",
-            status: imageStatus,
-            progress: imageProgress,
-            icon: _jsx(ImageIcon, { className: "h-5 w-5" }),
-        },
-        {
-            label: "Subiendo video",
-            status: videoStatus,
-            progress: videoProgress,
-            icon: _jsx(VideoIcon, { className: "h-5 w-5" }),
-        },
-        {
-            label: "Procesando imagen para AR",
-            status: arProcessingStatus,
-            progress: arProcessingProgress,
-            icon: _jsx(Loader2, { className: "h-5 w-5" }),
-        },
-        {
-            label: "Subiendo experiencia AR",
-            status: arUploadStatus,
-            progress: arUploadProgress,
-            icon: _jsx(Upload, { className: "h-5 w-5" }),
-        },
-    ];
-    // Calcular el progreso total (promedio de todos los procesos)
-    const completedSteps = stages.filter((stage) => stage.status === "completed").length;
-    const totalProgress = (imageProgress + videoProgress + arProcessingProgress + arUploadProgress) / 4;
-    const overallProgress = Math.min(Math.max(totalProgress, completedSteps * 25), 100);
-    // Bloquear el scroll cuando el modal está abierto
-    useEffect(() => {
-        if (open) {
-            document.body.style.overflow = "hidden";
-        }
-        else {
-            document.body.style.overflow = "auto";
-        }
-        return () => {
-            document.body.style.overflow = "auto";
-        };
-    }, [open]);
-    if (!open)
-        return null;
-    return (_jsx("div", { className: "fixed inset-0 z-50 flex items-center justify-center overflow-y-auto bg-black bg-opacity-50 p-4", children: _jsxs("div", { className: "relative max-h-full w-full max-w-md overflow-hidden rounded-lg bg-white p-6 shadow-xl", children: [_jsx("div", { className: "mb-4 flex items-center justify-between", children: _jsx("h2", { className: "text-center font-semibold text-xl", children: "Guardando experiencia AR" }) }), _jsx("div", { className: "mt-2", children: _jsx("div", { className: "relative pt-1", children: _jsxs("div", { className: "mb-6", children: [_jsx("div", { className: "h-2 w-full rounded-full bg-gray-200", children: _jsx("div", { className: "h-2 rounded-full bg-blue-600 transition-all duration-500", style: { width: `${overallProgress}%` } }) }), _jsxs("div", { className: "mt-2 text-center text-gray-600 text-sm", children: ["Progreso total: ", Math.round(overallProgress), "%"] })] }) }) }), _jsx("div", { className: "mt-2 space-y-5", children: stages.map((stage, index) => (_jsx("div", { className: "relative", children: _jsxs("div", { className: "flex items-center", children: [_jsx("div", { className: `mr-3 flex h-10 w-10 flex-shrink-0 items-center justify-center rounded-full ${stage.status === "completed"
-                                        ? "bg-green-100"
-                                        : stage.status === "processing"
-                                            ? "bg-blue-100"
-                                            : stage.status === "error"
-                                                ? "bg-red-100"
-                                                : "bg-gray-100"}`, children: stage.status === "completed" ? (_jsx(CheckCircle2, { className: "h-6 w-6 text-green-600" })) : stage.status === "processing" ? (_jsx("div", { className: "text-blue-600", children: stage.icon })) : stage.status === "error" ? (_jsx("div", { className: "text-red-600", children: stage.icon })) : (_jsx("div", { className: "text-gray-400", children: stage.icon })) }), _jsxs("div", { className: "min-w-0 flex-1", children: [_jsx("div", { className: "font-medium text-sm", children: stage.label }), stage.status === "processing" && (_jsxs("div", { className: "mt-1", children: [_jsx("div", { className: "h-1.5 w-full rounded-full bg-gray-200", children: _jsx("div", { className: "h-1.5 rounded-full bg-blue-600 transition-all duration-300", style: { width: `${stage.progress || 0}%` } }) }), _jsxs("div", { className: "mt-1 text-gray-500 text-xs", children: [Math.round(stage.progress || 0), "%"] })] })), stage.status === "completed" && (_jsx("div", { className: "mt-1 text-green-600 text-xs", children: "Completado" })), stage.status === "error" && (_jsx("div", { className: "mt-1 text-red-600 text-xs", children: "Error" })), stage.status === "pending" && (_jsx("div", { className: "mt-1 text-gray-500 text-xs", children: "Pendiente" }))] })] }) }, index))) }), completedSteps === stages.length && (_jsxs("div", { className: "mt-4 rounded-lg bg-green-50 p-4 text-center", children: [_jsx(CheckCircle2, { className: "mx-auto mb-2 h-8 w-8 text-green-500" }), _jsx("p", { className: "font-medium text-green-800", children: "\u00A1Experiencia AR guardada con \u00E9xito!" }), _jsx("p", { className: "text-green-700 text-sm", children: "Tu contenido est\u00E1 listo para ser visualizado." })] }))] }) }));
-}