File size: 11,254 Bytes
ab0a0fc
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
// Post-proceso geométrico de MoGe-2 portado a JS (sin dependencias).
// Referencia: microsoft/MoGe@74fbce0 moge/model/v2.py::infer y moge/utils/geometry_torch.py (MIT).
// El ONNX oficial sólo devuelve la salida cruda: mapa de puntos afín-invariante, normales, máscara y escala métrica.

/** UV del plano de imagen normalizado (MoGe normalized_view_plane_uv): esquinas ±(W/diag, H/diag). */
export function uvGrid(W, H) {
  const ar = W / H;
  const sx = ar / Math.sqrt(1 + ar * ar), sy = 1 / Math.sqrt(1 + ar * ar);
  const u = new Float64Array(W), v = new Float64Array(H);
  const lin = (a, b, n, i) => (n === 1 ? a : a + ((b - a) * i) / (n - 1));
  for (let j = 0; j < W; j++) u[j] = lin(-sx * (W - 1) / W, sx * (W - 1) / W, W, j);
  for (let i = 0; i < H; i++) v[i] = lin(-sy * (H - 1) / H, sy * (H - 1) / H, H, i);
  return { u, v };
}

/** Índices de F.interpolate(mode='nearest'): src = floor(dst * in/out). */
export function nearestIdx(nIn, nOut) {
  const r = new Int32Array(nOut);
  for (let k = 0; k < nOut; k++) r[k] = Math.min(Math.floor(k * (nIn / nOut)), nIn - 1);
  return r;
}

/** Residuo de MoGe solve_optimal_focal_shift para un shift dado. Devuelve {cost, focal}. */
export function focalShiftCost(uv, xyz, shift) {
  const n = uv.length / 2;
  let num = 0, den = 0;
  const px = new Float64Array(n), py = new Float64Array(n);
  for (let k = 0; k < n; k++) {
    const z = xyz[3 * k + 2] + shift;
    px[k] = xyz[3 * k] / z; py[k] = xyz[3 * k + 1] / z;
    num += px[k] * uv[2 * k] + py[k] * uv[2 * k + 1];
    den += px[k] * px[k] + py[k] * py[k];
  }
  const f = num / den;
  let cost = 0;
  for (let k = 0; k < n; k++) {
    const ex = f * px[k] - uv[2 * k], ey = f * py[k] - uv[2 * k + 1];
    cost += ex * ex + ey * ey;
  }
  return { cost: 0.5 * cost, focal: f };
}

/**
 * Minimiza el residuo respecto a `shift` (escalar). MoGe usa scipy least_squares(method='lm', x0=0, ftol=1e-3);
 * aquí: Gauss-Newton/Levenberg-Marquardt 1-D con derivada numérica, restringido a z+shift>0, hasta convergencia.
 */
export function solveFocalShift(uv, xyz, { maxIter = 100 } = {}) {
  const n = uv.length / 2;
  let zmin = Infinity;
  for (let k = 0; k < n; k++) zmin = Math.min(zmin, xyz[3 * k + 2]);
  const lo = -zmin + 1e-6; // z + shift > 0
  let s = Math.max(0, lo + 1e-6);
  let { cost } = focalShiftCost(uv, xyz, s);
  let lambda = 1e-3;
  for (let it = 0; it < maxIter; it++) {
    const h = 1e-6 * Math.max(1, Math.abs(s));
    const c1 = focalShiftCost(uv, xyz, s + h).cost, c0 = focalShiftCost(uv, xyz, Math.max(lo, s - h)).cost;
    const g = (c1 - c0) / (s + h - Math.max(lo, s - h));
    const H2 = (c1 - 2 * cost + c0) / (h * h);
    let improved = false;
    for (let tries = 0; tries < 30; tries++) {
      const step = -g / (Math.max(H2, 1e-12) * (1 + lambda) + lambda);
      const sn = Math.max(lo, s + step);
      const cn = focalShiftCost(uv, xyz, sn).cost;
      if (cn < cost) {
        const rel = (cost - cn) / Math.max(cost, 1e-30);
        s = sn; cost = cn; lambda = Math.max(lambda / 10, 1e-9); improved = true;
        if (rel < 1e-10 || Math.abs(step) < 1e-12) return { shift: s, focal: focalShiftCost(uv, xyz, s).focal, iters: it + 1 };
        break;
      }
      lambda *= 10;
    }
    if (!improved) break;
  }
  return { shift: s, focal: focalShiftCost(uv, xyz, s).focal, iters: maxIter };
}

/**
 * Pipeline completo de MoGeModel.infer (force_projection=True, apply_mask=True, fov_x desconocido).
 * points: Float32Array H*W*3 (afín), mask: Float32Array H*W (sigmoide), scale: escalar métrico.
 */
export function postprocess(points, maskProb, W, H, scale, { lr = 64 } = {}) {
  const { u, v } = uvGrid(W, H);
  const ri = nearestIdx(H, lr), ci = nearestIdx(W, lr);
  const uvs = [], xyzs = [];
  for (const i of ri) for (const j of ci) {
    const p = i * W + j;
    if (maskProb[p] > 0.5) { uvs.push(u[j], v[i]); xyzs.push(points[3 * p], points[3 * p + 1], points[3 * p + 2]); }
  }
  let shift = 0, focal = 1;
  if (uvs.length >= 4) ({ shift, focal } = solveFocalShift(Float64Array.from(uvs), Float64Array.from(xyzs)));
  const ar = W / H;
  const fx = (focal / 2) * Math.sqrt(1 + ar * ar) / ar, fy = (focal / 2) * Math.sqrt(1 + ar * ar);
  const N = W * H;
  const out = new Float32Array(N * 3), depth = new Float32Array(N), valid = new Uint8Array(N);
  for (let i = 0; i < H; i++) {
    const vv = (i + 0.5) / H - 0.5;
    for (let j = 0; j < W; j++) {
      const p = i * W + j;
      const d = points[3 * p + 2] + shift;
      const ok = maskProb[p] > 0.5 && d > 0;
      valid[p] = ok ? 1 : 0;
      const dm = d * scale;
      depth[p] = ok ? dm : NaN;
      out[3 * p] = ok ? (((j + 0.5) / W - 0.5) / fx) * dm : NaN;
      out[3 * p + 1] = ok ? (vv / fy) * dm : NaN;
      out[3 * p + 2] = ok ? dm : NaN;
    }
  }
  const fovX = (2 * Math.atan(0.5 / fx) * 180) / Math.PI, fovY = (2 * Math.atan(0.5 / fy) * 180) / Math.PI;
  return { points: out, depth, valid, W, H, shift, focal, fx, fy, fxPx: fx * W, fyPx: fy * H, fovX, fovY, scale };
}

/** Estadísticos de profundidad (m) sobre píxeles válidos. */
export function depthStats(depth) {
  const a = [];
  for (const d of depth) if (Number.isFinite(d)) a.push(d);
  if (!a.length) return { validPct: 0 };
  a.sort((x, y) => x - y);
  const q = (t) => a[Math.min(a.length - 1, Math.floor(t * (a.length - 1)))];
  return { min: a[0], p05: q(0.05), median: q(0.5), p95: q(0.95), max: a[a.length - 1], validPct: (100 * a.length) / depth.length };
}

/** Punto 3D robusto en (x,y) de la imagen de trabajo: mediana por componente en una ventana (2r+1)². */
export function samplePoint(geo, x, y, r = 1) {
  const { W, H, points } = geo;
  const cx = Math.round(x), cy = Math.round(y);
  const xs = [], ys = [], zs = [];
  for (let i = Math.max(0, cy - r); i <= Math.min(H - 1, cy + r); i++)
    for (let j = Math.max(0, cx - r); j <= Math.min(W - 1, cx + r); j++) {
      const p = i * W + j;
      if (Number.isFinite(points[3 * p + 2])) { xs.push(points[3 * p]); ys.push(points[3 * p + 1]); zs.push(points[3 * p + 2]); }
    }
  if (!zs.length) return null;
  const med = (a) => { a.sort((m, n) => m - n); return a[a.length >> 1]; };
  return [med(xs), med(ys), med(zs)];
}

export const dist3 = (a, b) => Math.hypot(a[0] - b[0], a[1] - b[1], a[2] - b[2]);

/** Mide un segmento entre dos píxeles (coordenadas de la imagen ORIGINAL), aplicando factor de calibración. */
export function measure(geo, aPx, bPx, origW, origH, factor = 1) {
  const sx = geo.W / origW, sy = geo.H / origH;
  const A = samplePoint(geo, aPx[0] * sx - 0.5, aPx[1] * sy - 0.5), B = samplePoint(geo, bPx[0] * sx - 0.5, bPx[1] * sy - 0.5);
  if (!A || !B) return null;
  return { a3d: A.map((t) => t * factor), b3d: B.map((t) => t * factor), length: dist3(A, B) * factor, depthA: A[2] * factor, depthB: B[2] * factor };
}

/** Factor de calibración: longitud real conocida / longitud medida. */
export function calibrationFactor(measuredM, knownM) {
  if (!(measuredM > 0) || !(knownM > 0) || !Number.isFinite(knownM)) throw new Error('Longitudes no válidas');
  return knownM / measuredM;
}

/** Dimensiones de trabajo: lado largo = longSide (múltiplo entero), manteniendo aspecto. */
export function workSize(w, h, longSide) {
  const s = Math.min(1, longSide / Math.max(w, h));
  return [Math.max(1, Math.round(w * s)), Math.max(1, Math.round(h * s))];
}

/** HWC RGBA uint8 -> NCHW float32 [0,1] (el modelo normaliza internamente con media/desv. de ImageNet). */
export function rgbaToNCHW(rgba, W, H) {
  const N = W * H, out = new Float32Array(3 * N);
  for (let p = 0; p < N; p++) {
    out[p] = rgba[4 * p] / 255; out[N + p] = rgba[4 * p + 1] / 255; out[2 * N + p] = rgba[4 * p + 2] / 255;
  }
  return out;
}

// Paleta propia (cerca = cálido, lejos = frío). Interpolación lineal entre anclas.
const PAL = [[255, 245, 160], [253, 174, 97], [215, 48, 39], [116, 41, 138], [49, 54, 149], [15, 20, 60]];
export function colormap(t) {
  t = Math.min(1, Math.max(0, t)) * (PAL.length - 1);
  const i = Math.min(PAL.length - 2, Math.floor(t)), f = t - i;
  return PAL[i].map((c, k) => Math.round(c + (PAL[i + 1][k] - c) * f));
}

/** Imagen RGBA del mapa de profundidad (escala log entre p05 y p95; inválido = gris). */
export function depthToRGBA(depth, stats) {
  const out = new Uint8ClampedArray(depth.length * 4);
  const lo = Math.log(stats.p05), hi = Math.log(Math.max(stats.p95, stats.p05 * 1.0001));
  for (let p = 0; p < depth.length; p++) {
    const d = depth[p];
    const c = Number.isFinite(d) ? colormap((Math.log(d) - lo) / (hi - lo)) : [128, 128, 128];
    out[4 * p] = c[0]; out[4 * p + 1] = c[1]; out[4 * p + 2] = c[2]; out[4 * p + 3] = 255;
  }
  return out;
}

/** Normales (OpenCV: x der., y abajo, z adelante) -> RGB: R=x, G=-y, B=-z (hacia la cámara = azul). */
export function normalsToRGBA(normal, valid) {
  const N = valid.length, out = new Uint8ClampedArray(N * 4);
  for (let p = 0; p < N; p++) {
    if (!valid[p]) { out[4 * p] = out[4 * p + 1] = out[4 * p + 2] = 128; out[4 * p + 3] = 255; continue; }
    out[4 * p] = Math.round((normal[3 * p] * 0.5 + 0.5) * 255);
    out[4 * p + 1] = Math.round((-normal[3 * p + 1] * 0.5 + 0.5) * 255);
    out[4 * p + 2] = Math.round((-normal[3 * p + 2] * 0.5 + 0.5) * 255);
    out[4 * p + 3] = 255;
  }
  return out;
}

/** PLY binario (little-endian) con xyz float32 (metros, OpenCV) + rgb uint8. step = submuestreo. */
export function toPLY(geo, rgba, factor = 1, step = 1) {
  const idx = [];
  for (let i = 0; i < geo.H; i += step) for (let j = 0; j < geo.W; j += step) { const p = i * geo.W + j; if (geo.valid[p]) idx.push(p); }
  const header = `ply\nformat binary_little_endian 1.0\ncomment Geometria3D Lab - MoGe-2 ViT-S (metros, ejes OpenCV x der. y abajo z adelante)\nelement vertex ${idx.length}\nproperty float x\nproperty float y\nproperty float z\nproperty uchar red\nproperty uchar green\nproperty uchar blue\nend_header\n`;
  const hb = new TextEncoder().encode(header);
  const buf = new ArrayBuffer(hb.length + idx.length * 15);
  new Uint8Array(buf).set(hb);
  const dv = new DataView(buf);
  let o = hb.length;
  for (const p of idx) {
    dv.setFloat32(o, geo.points[3 * p] * factor, true); dv.setFloat32(o + 4, geo.points[3 * p + 1] * factor, true); dv.setFloat32(o + 8, geo.points[3 * p + 2] * factor, true);
    dv.setUint8(o + 12, rgba[4 * p]); dv.setUint8(o + 13, rgba[4 * p + 1]); dv.setUint8(o + 14, rgba[4 * p + 2]);
    o += 15;
  }
  return { buffer: buf, count: idx.length };
}

/** Validación de archivo de entrada. */
export function validateFile({ type, size }, { maxBytes, types }) {
  if (!types.includes(type)) return `Formato no admitido (${type || 'desconocido'}). Usa JPG, PNG o WebP.`;
  if (size > maxBytes) return `Archivo demasiado grande (${(size / 1e6).toFixed(1)} MB). Máximo ${(maxBytes / 1e6).toFixed(0)} MB.`;
  return null;
}
export function validateDims(w, h, maxPixels) {
  if (w * h > maxPixels) return `Imagen demasiado grande (${((w * h) / 1e6).toFixed(1)} MP). Máximo ${(maxPixels / 1e6).toFixed(0)} MP.`;
  if (Math.min(w, h) < 64) return 'Imagen demasiado pequeña (mínimo 64 px de lado).';
  if (Math.max(w, h) / Math.min(w, h) > 4) return 'Relación de aspecto extrema (máx. 4:1).';
  return null;
}