three-slicer-viewer 0.2.5 → 0.3.1

package/dist/sla_reconstruct-CXkYhux2.js

@@ -1,176 +0,0 @@
-const U = new Int8Array(8), W = new Int8Array(8), G = new Int8Array(8);
-for (let t = 0; t < 8; t++)
-  U[t] = t & 1, W[t] = t >> 1 & 1, G[t] = t >> 2 & 1;
-const T = [], rt = [];
-for (let t = 0; t < 8; t++) for (let l = t + 1; l < 8; l++)
-  Math.abs(U[t] - U[l]) + Math.abs(W[t] - W[l]) + Math.abs(G[t] - G[l]) === 1 && (T.push(t), rt.push(l));
-const ot = 127.5, q = (t) => t > ot, x = (t) => {
-  const l = [];
-  let A = new t(1048576), r = 0, m = 0;
-  return {
-    push3(u, C, h) {
-      r + 3 > A.length && (l.push(A.subarray(0, r)), m += r, A = new t(1 << 20), r = 0), A[r++] = u, A[r++] = C, A[r++] = h;
-    },
-    concat() {
-      l.push(A.subarray(0, r)), m += r;
-      const u = new t(m);
-      let C = 0;
-      for (const h of l)
-        u.set(h, C), C += h.length;
-      return u;
-    }
-  };
-}, ct = { 0: [0.68, 0.238, 0.023], 5: [0.328, 0.188, 0.687], 6: [0.434, 0.352, 0.144] };
-function ht(t, l, A, r, m, u, C, h) {
-  const b = t + 1, a = l + 1;
-  let o = new Int32Array(b * a).fill(-1), i = new Int32Array(b * a).fill(-1);
-  const N = null;
-  let F = N, w = N, H = null, P = null, J = null, d = null, at = 0;
-  const tt = x(Float32Array), Y = x(Uint32Array), et = x(Float32Array);
-  let nt = 0, Q = !1;
-  const S = (g, c, n) => !g || c < 0 || n < 0 || c >= t || n >= l ? 0 : g[c + t * n], O = new Float64Array(8);
-  function lt(g, c, n, R, s, k, y, p) {
-    const e = c + 1 + b * (n + 1), M = g[e];
-    if (M >= 0) return M;
-    O[0] = S(s, c, n), O[1] = S(s, c + 1, n), O[2] = S(s, c, n + 1), O[3] = S(s, c + 1, n + 1), O[4] = S(k, c, n), O[5] = S(k, c + 1, n), O[6] = S(k, c, n + 1), O[7] = S(k, c + 1, n + 1);
-    let z = 0, f = 0, I = 0, v = 0;
-    for (let E = 0; E < T.length; E++) {
-      const B = T[E], L = rt[E];
-      if (q(O[B]) === q(O[L])) continue;
-      const X = Math.min(1, Math.max(0, (ot - O[B]) / (O[L] - O[B])));
-      z += U[B] + X * (U[L] - U[B]), f += W[B] + X * (W[L] - W[B]), I += G[B] + X * (G[L] - G[B]), v++;
-    }
-    const K = v ? z / v : 0.5, j = v ? f / v : 0.5, D = v ? I / v : 0.5;
-    if (tt.push3(u + (c + K + 0.5) * A, C + (n + j + 0.5) * r, h + (R + D + 0.5) * m), Q) {
-      let E = 0;
-      for (let L = 0; L < 8; L++) {
-        if (!q(O[L])) continue;
-        const X = S(G[L] ? p : y, c + U[L], n + W[L]);
-        if (X === 5) {
-          E = 5;
-          break;
-        }
-        X === 6 && (E = 6);
-      }
-      const B = ct[E];
-      et.push3(B[0], B[1], B[2]);
-    }
-    return g[e] = nt, nt++;
-  }
-  const Z = (g, c, n) => c === N || n < 0 || n >= l ? t : g ? g[n * 2] : 0, _ = (g, c, n) => c === N || n < 0 || n >= l ? -1 : g ? g[n * 2 + 1] : t - 1;
-  function V(g, c, n) {
-    const R = at++, s = (e, M) => lt(o, e, M, R - 1, F, w, H, P), k = (e, M) => lt(i, e, M, R, w, g, P, c), y = (e, M, z, f, I) => {
-      I ? (Y.push3(f, z, M), Y.push3(f, M, e)) : (Y.push3(e, M, z), Y.push3(e, z, f));
-    };
-    for (let e = 0; e < l; e++) {
-      const M = Math.min(Z(J, F, e), Z(d, w, e)), z = Math.max(_(J, F, e), _(d, w, e));
-      for (let f = M; f <= z; f++) {
-        const I = q(S(F, f, e)), v = q(S(w, f, e));
-        I !== v && y(s(f - 1, e - 1), s(f, e - 1), s(f, e), s(f - 1, e), !I);
-      }
-    }
-    for (let e = 0; e < l; e++) {
-      const M = Z(d, w, e), z = _(d, w, e);
-      for (let f = M - 1; f <= z; f++) {
-        const I = q(S(w, f, e)), v = q(S(w, f + 1, e));
-        I !== v && y(s(f, e - 1), s(f, e), k(f, e), k(f, e - 1), !I);
-      }
-    }
-    for (let e = -1; e < l; e++) {
-      const M = Math.min(Z(d, w, e), Z(d, w, e + 1)), z = Math.max(_(d, w, e), _(d, w, e + 1));
-      for (let f = M; f <= z; f++) {
-        const I = q(S(w, f, e)), v = q(S(w, f, e + 1));
-        I !== v && y(s(f - 1, e), k(f - 1, e), k(f, e), s(f, e), !I);
-      }
-    }
-    const p = o;
-    o = i, i = p.fill(-1);
-  }
-  let $ = !1;
-  return {
-    // Slices arrive bottom-up. Layer s can only be processed once s+1 is known (its cells' upper corners live
-    //  there), so the first slice just primes the window and every later push runs the step one layer behind.
-    //  `roles` is an optional parallel Uint8Array (0=model, 5=support, 6=pad) that turns on vertex colours;
-    //  `ranges` the per-row occupancy spans fillSliceFromRGBA returns, which confine the sweep to the model.
-    pushSlice(g, c = null, n = null) {
-      if (c && (Q = !0), !$) {
-        $ = !0, w = g, P = c, d = n;
-        return;
-      }
-      V(g, c), F = w, w = g, H = P, P = c, J = d, d = n;
-    },
-    finish({ smoothRounds: g = 0, normalRounds: c = 0 } = {}) {
-      $ && (V(N, null), F = w, w = N, H = P, P = null, J = d, d = null), V(N, null);
-      const n = tt.concat(), R = Y.concat();
-      g > 0 && st(n, R, g);
-      const s = new Float32Array(n.length);
-      for (let k = 0; k < R.length; k += 3) {
-        const y = R[k] * 3, p = R[k + 1] * 3, e = R[k + 2] * 3, M = n[p] - n[y], z = n[p + 1] - n[y + 1], f = n[p + 2] - n[y + 2], I = n[e] - n[y], v = n[e + 1] - n[y + 1], K = n[e + 2] - n[y + 2], j = z * K - f * v, D = f * I - M * K, E = M * v - z * I;
-        s[y] += j, s[y + 1] += D, s[y + 2] += E, s[p] += j, s[p + 1] += D, s[p + 2] += E, s[e] += j, s[e + 1] += D, s[e + 2] += E;
-      }
-      return ft(s), c > 0 && ut(s, R, c), { positions: n, indices: R, normals: s, colors: Q ? et.concat() : null };
-    }
-  };
-}
-function ft(t) {
-  for (let l = 0; l < t.length; l += 3) {
-    const A = Math.hypot(t[l], t[l + 1], t[l + 2]) || 1;
-    t[l] /= A, t[l + 1] /= A, t[l + 2] /= A;
-  }
-}
-function ut(t, l, A = 2) {
-  const r = new Float32Array(t.length);
-  for (let m = 0; m < A; m++) {
-    r.fill(0);
-    for (let u = 0; u < l.length; u += 3) {
-      const C = l[u] * 3, h = l[u + 1] * 3, b = l[u + 2] * 3;
-      for (const [a, o] of [[C, h], [h, b], [b, C]])
-        r[a] += t[o], r[a + 1] += t[o + 1], r[a + 2] += t[o + 2], r[o] += t[a], r[o + 1] += t[a + 1], r[o + 2] += t[a + 2];
-    }
-    for (let u = 0; u < t.length; u += 3)
-      t[u] += 0.5 * r[u], t[u + 1] += 0.5 * r[u + 1], t[u + 2] += 0.5 * r[u + 2];
-    ft(t);
-  }
-}
-function st(t, l, A = 4) {
-  const r = new Float32Array(t.length), m = new Float32Array(t.length / 3), u = (h, b) => {
-    const a = h * 3, o = b * 3, i = Math.abs(t[o + 2] - t[a + 2]) + 0.05 * (Math.abs(t[o] - t[a]) + Math.abs(t[o + 1] - t[a + 1])) + 1e-6;
-    r[a] += i * t[o], r[a + 1] += i * t[o + 1], r[a + 2] += i * t[o + 2], r[o] += i * t[a], r[o + 1] += i * t[a + 1], r[o + 2] += i * t[a + 2], m[h] += i, m[b] += i;
-  }, C = (h) => {
-    r.fill(0), m.fill(0);
-    for (let b = 0; b < l.length; b += 3) {
-      const a = l[b], o = l[b + 1], i = l[b + 2];
-      u(a, o), u(o, i), u(i, a);
-    }
-    for (let b = 0; b < m.length; b++) {
-      const a = m[b];
-      if (!a) continue;
-      const o = b * 3;
-      t[o] += h * (r[o] / a - t[o]), t[o + 1] += h * (r[o + 1] / a - t[o + 1]), t[o + 2] += h * (r[o + 2] / a - t[o + 2]);
-    }
-  };
-  for (let h = 0; h < A; h++)
-    C(0.5), C(-0.53);
-}
-function bt(t, l, A, r, m) {
-  const u = new Uint32Array(l.buffer, l.byteOffset, l.byteLength >> 2), C = new Int32Array(r * 2);
-  for (let h = 0; h < r; h++) {
-    const b = r - 1 - h, a = h * A * 4 >> 2, o = A * (b + r * m);
-    let i = A, N = -1;
-    for (let F = 0; F < A; F++) {
-      const w = u[a + F];
-      if (w === 0) {
-        t[o + F] = 0;
-        continue;
-      }
-      const H = w >> 8 & 255;
-      t[o + F] = H, H && (F < i && (i = F), F > N && (N = F));
-    }
-    C[b * 2] = i, C[b * 2 + 1] = N;
-  }
-  return C;
-}
-export {
-  bt as f,
-  ht as m
-};