three-slicer-viewer 0.3.0 → 0.3.2

package/dist/sla_reconstruct-CRZ3TrI1.js

@@ -0,0 +1,178 @@
+import { T as V, h as ht } from "./theme-2oyfMuvf.js";
+import { R as at } from "./toolpath_encoding-BuYs95qZ.js";
+const U = new Int8Array(8), q = new Int8Array(8), H = new Int8Array(8);
+for (let t = 0; t < 8; t++)
+  U[t] = t & 1, q[t] = t >> 1 & 1, H[t] = t >> 2 & 1;
+const et = [], ft = [];
+for (let t = 0; t < 8; t++) for (let n = t + 1; n < 8; n++)
+  Math.abs(U[t] - U[n]) + Math.abs(q[t] - q[n]) + Math.abs(H[t] - H[n]) === 1 && (et.push(t), ft.push(n));
+const ct = 127.5, N = (t) => t > ct, $ = (t) => {
+  const n = [];
+  let i = new t(1048576), r = 0, m = 0;
+  return {
+    push3(u, C, h) {
+      r + 3 > i.length && (n.push(i.subarray(0, r)), m += r, i = new t(1 << 20), r = 0), i[r++] = u, i[r++] = C, i[r++] = h;
+    },
+    concat() {
+      n.push(i.subarray(0, r)), m += r;
+      const u = new t(m);
+      let C = 0;
+      for (const h of n)
+        u.set(h, C), C += h.length;
+      return u;
+    }
+  };
+}, tt = (t) => ht(t).map((n) => Math.round(n * 1e3) / 1e3), bt = { 0: tt(V.slaModel), [at.SUPPORT]: tt(V.slaSupport), [at.RAFT]: tt(V.slaPad) };
+function gt(t, n, i, r, m, u, C, h) {
+  const b = t + 1, f = n + 1;
+  let o = new Int32Array(b * f).fill(-1), M = new Int32Array(b * f).fill(-1);
+  const P = null;
+  let F = P, w = P, W = null, T = null, x = null, k = null, st = 0;
+  const nt = $(Float32Array), X = $(Uint32Array), lt = $(Float32Array);
+  let rt = 0, J = !1;
+  const O = (A, c, l) => !A || c < 0 || l < 0 || c >= t || l >= n ? 0 : A[c + t * l], v = new Float64Array(8);
+  function ot(A, c, l, z, s, R, d, B) {
+    const e = c + 1 + b * (l + 1), g = A[e];
+    if (g >= 0) return g;
+    v[0] = O(s, c, l), v[1] = O(s, c + 1, l), v[2] = O(s, c, l + 1), v[3] = O(s, c + 1, l + 1), v[4] = O(R, c, l), v[5] = O(R, c + 1, l), v[6] = O(R, c, l + 1), v[7] = O(R, c + 1, l + 1);
+    let p = 0, a = 0, S = 0, I = 0;
+    for (let E = 0; E < et.length; E++) {
+      const y = et[E], L = ft[E];
+      if (N(v[y]) === N(v[L])) continue;
+      const G = Math.min(1, Math.max(0, (ct - v[y]) / (v[L] - v[y])));
+      p += U[y] + G * (U[L] - U[y]), a += q[y] + G * (q[L] - q[y]), S += H[y] + G * (H[L] - H[y]), I++;
+    }
+    const D = I ? p / I : 0.5, _ = I ? a / I : 0.5, j = I ? S / I : 0.5;
+    if (nt.push3(u + (c + D + 0.5) * i, C + (l + _ + 0.5) * r, h + (z + j + 0.5) * m), J) {
+      let E = 0;
+      for (let L = 0; L < 8; L++) {
+        if (!N(v[L])) continue;
+        const G = O(H[L] ? B : d, c + U[L], l + q[L]);
+        if (G === 5) {
+          E = 5;
+          break;
+        }
+        G === 6 && (E = 6);
+      }
+      const y = bt[E];
+      lt.push3(y[0], y[1], y[2]);
+    }
+    return A[e] = rt, rt++;
+  }
+  const Y = (A, c, l) => c === P || l < 0 || l >= n ? t : A ? A[l * 2] : 0, Z = (A, c, l) => c === P || l < 0 || l >= n ? -1 : A ? A[l * 2 + 1] : t - 1;
+  function K(A, c, l) {
+    const z = st++, s = (e, g) => ot(o, e, g, z - 1, F, w, W, T), R = (e, g) => ot(M, e, g, z, w, A, T, c), d = (e, g, p, a, S) => {
+      S ? (X.push3(a, p, g), X.push3(a, g, e)) : (X.push3(e, g, p), X.push3(e, p, a));
+    };
+    for (let e = 0; e < n; e++) {
+      const g = Math.min(Y(x, F, e), Y(k, w, e)), p = Math.max(Z(x, F, e), Z(k, w, e));
+      for (let a = g; a <= p; a++) {
+        const S = N(O(F, a, e)), I = N(O(w, a, e));
+        S !== I && d(s(a - 1, e - 1), s(a, e - 1), s(a, e), s(a - 1, e), !S);
+      }
+    }
+    for (let e = 0; e < n; e++) {
+      const g = Y(k, w, e), p = Z(k, w, e);
+      for (let a = g - 1; a <= p; a++) {
+        const S = N(O(w, a, e)), I = N(O(w, a + 1, e));
+        S !== I && d(s(a, e - 1), s(a, e), R(a, e), R(a, e - 1), !S);
+      }
+    }
+    for (let e = -1; e < n; e++) {
+      const g = Math.min(Y(k, w, e), Y(k, w, e + 1)), p = Math.max(Z(k, w, e), Z(k, w, e + 1));
+      for (let a = g; a <= p; a++) {
+        const S = N(O(w, a, e)), I = N(O(w, a, e + 1));
+        S !== I && d(s(a - 1, e), R(a - 1, e), R(a, e), s(a, e), !S);
+      }
+    }
+    const B = o;
+    o = M, M = B.fill(-1);
+  }
+  let Q = !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(A, c = null, l = null) {
+      if (c && (J = !0), !Q) {
+        Q = !0, w = A, T = c, k = l;
+        return;
+      }
+      K(A, c), F = w, w = A, W = T, T = c, x = k, k = l;
+    },
+    finish({ smoothRounds: A = 0, normalRounds: c = 0 } = {}) {
+      Q && (K(P, null), F = w, w = P, W = T, T = null, x = k, k = null), K(P, null);
+      const l = nt.concat(), z = X.concat();
+      A > 0 && it(l, z, A);
+      const s = new Float32Array(l.length);
+      for (let R = 0; R < z.length; R += 3) {
+        const d = z[R] * 3, B = z[R + 1] * 3, e = z[R + 2] * 3, g = l[B] - l[d], p = l[B + 1] - l[d + 1], a = l[B + 2] - l[d + 2], S = l[e] - l[d], I = l[e + 1] - l[d + 1], D = l[e + 2] - l[d + 2], _ = p * D - a * I, j = a * S - g * D, E = g * I - p * S;
+        s[d] += _, s[d + 1] += j, s[d + 2] += E, s[B] += _, s[B + 1] += j, s[B + 2] += E, s[e] += _, s[e + 1] += j, s[e + 2] += E;
+      }
+      return ut(s), c > 0 && wt(s, z, c), { positions: l, indices: z, normals: s, colors: J ? lt.concat() : null };
+    }
+  };
+}
+function ut(t) {
+  for (let n = 0; n < t.length; n += 3) {
+    const i = Math.hypot(t[n], t[n + 1], t[n + 2]) || 1;
+    t[n] /= i, t[n + 1] /= i, t[n + 2] /= i;
+  }
+}
+function wt(t, n, i = 2) {
+  const r = new Float32Array(t.length);
+  for (let m = 0; m < i; m++) {
+    r.fill(0);
+    for (let u = 0; u < n.length; u += 3) {
+      const C = n[u] * 3, h = n[u + 1] * 3, b = n[u + 2] * 3;
+      for (const [f, o] of [[C, h], [h, b], [b, C]])
+        r[f] += t[o], r[f + 1] += t[o + 1], r[f + 2] += t[o + 2], r[o] += t[f], r[o + 1] += t[f + 1], r[o + 2] += t[f + 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];
+    ut(t);
+  }
+}
+function it(t, n, i = 4) {
+  const r = new Float32Array(t.length), m = new Float32Array(t.length / 3), u = (h, b) => {
+    const f = h * 3, o = b * 3, M = Math.abs(t[o + 2] - t[f + 2]) + 0.05 * (Math.abs(t[o] - t[f]) + Math.abs(t[o + 1] - t[f + 1])) + 1e-6;
+    r[f] += M * t[o], r[f + 1] += M * t[o + 1], r[f + 2] += M * t[o + 2], r[o] += M * t[f], r[o + 1] += M * t[f + 1], r[o + 2] += M * t[f + 2], m[h] += M, m[b] += M;
+  }, C = (h) => {
+    r.fill(0), m.fill(0);
+    for (let b = 0; b < n.length; b += 3) {
+      const f = n[b], o = n[b + 1], M = n[b + 2];
+      u(f, o), u(o, M), u(M, f);
+    }
+    for (let b = 0; b < m.length; b++) {
+      const f = m[b];
+      if (!f) continue;
+      const o = b * 3;
+      t[o] += h * (r[o] / f - t[o]), t[o + 1] += h * (r[o + 1] / f - t[o + 1]), t[o + 2] += h * (r[o + 2] / f - t[o + 2]);
+    }
+  };
+  for (let h = 0; h < i; h++)
+    C(0.5), C(-0.53);
+}
+function mt(t, n, i, r, m) {
+  const u = new Uint32Array(n.buffer, n.byteOffset, n.byteLength >> 2), C = new Int32Array(r * 2);
+  for (let h = 0; h < r; h++) {
+    const b = r - 1 - h, f = h * i * 4 >> 2, o = i * (b + r * m);
+    let M = i, P = -1;
+    for (let F = 0; F < i; F++) {
+      const w = u[f + F];
+      if (w === 0) {
+        t[o + F] = 0;
+        continue;
+      }
+      const W = w >> 8 & 255;
+      t[o + F] = W, W && (F < M && (M = F), F > P && (P = F));
+    }
+    C[b * 2] = M, C[b * 2 + 1] = P;
+  }
+  return C;
+}
+export {
+  mt as f,
+  gt as m
+};

package/dist/sla_reconstruct.worker.js

@@ -1,4 +1,4 @@
-import { m as c } from "./sla_reconstruct-CXkYhux2.js";
+import { m as c } from "./sla_reconstruct-CRZ3TrI1.js";
 let e = null, o = { nets: 0, finish: 0 };
 self.onmessage = (m) => {
   const s = m.data;

package/dist/sla_slice.worker.js

@@ -1,30 +1,31 @@
-import { f as D } from "./sla_reconstruct-CXkYhux2.js";
-import { d as H } from "./sl1_write-CvrNejbW.js";
+import { f as q } from "./sla_reconstruct-CRZ3TrI1.js";
+import { d as D } from "./sl1_write-BovHbg3k.js";
+import { R as H, S as T, r as E } from "./toolpath_encoding-BuYs95qZ.js";
 let i = 6;
-const M = (u, k) => {
+const M = (u, x) => {
   const m = [];
-  for (let l = 0; l + 7 < u.length; l += 8) if ((u[l + 3] & 15) === k) for (let e = 0; e < 8; e++) m.push(u[l + e]);
+  for (let l = 0; l + T - 1 < u.length; l += T) if (E(u[l + 3]) === x) for (let e = 0; e < T; e++) m.push(u[l + e]);
   return m;
 };
 self.onmessage = async (u) => {
-  const { indices: k, pngs: m, rolePaths: l, nx: e, ny: r, matrix: w, scale: d, width: B, height: O, batch: A } = u.data;
+  const { indices: x, pngs: m, rolePaths: l, nx: e, ny: r, matrix: w, scale: d, width: k, height: v, batch: A } = u.data;
   A > 0 && (i = A);
   try {
     const s = { decode: 0, draw: 0, read: 0, roles: 0, fill: 0 };
     let n = 0;
-    const y = new OffscreenCanvas(e, r * i).getContext("2d", { willReadFrequently: !0 }), f = (l ? new OffscreenCanvas(e, r * i) : null)?.getContext("2d", { willReadFrequently: !0 }), F = (a) => {
+    const y = new OffscreenCanvas(e, r * i).getContext("2d", { willReadFrequently: !0 }), f = (l ? new OffscreenCanvas(e, r * i) : null)?.getContext("2d", { willReadFrequently: !0 }), B = (a) => {
       const o = [];
       for (let p = 0; p < i && a + p < m.length; p++) {
         const g = a + p;
-        o.push(createImageBitmap(new Blob([m[g]], { type: "image/png" })).then((S) => (m[g] = null, S)));
+        o.push(createImageBitmap(new Blob([m[g]], { type: "image/png" })).then((I) => (m[g] = null, I)));
       }
       return o;
     };
-    let I = F(0);
+    let F = B(0);
     for (let a = 0; a < m.length; a += i) {
       n = performance.now();
-      const o = await Promise.all(I);
-      s.decode += performance.now() - n, I = F(a + i), n = performance.now(), y.setTransform(1, 0, 0, 1, 0, 0), y.clearRect(0, 0, e, r * i);
+      const o = await Promise.all(F);
+      s.decode += performance.now() - n, F = B(a + i), n = performance.now(), y.setTransform(1, 0, 0, 1, 0, 0), y.clearRect(0, 0, e, r * i);
       for (let t = 0; t < o.length; t++)
         y.setTransform(
           w[0] * d,
@@ -41,28 +42,28 @@ self.onmessage = async (u) => {
       if (f && l.slice(a, a + o.length).some((t) => t && t.length)) {
         f.setTransform(1, 0, 0, 1, 0, 0), f.clearRect(0, 0, e, r * i);
         for (let t = 0; t < o.length; t++) {
-          const h = l[a + t] ?? new Float32Array(0), b = t * r, c = { map: (C, v) => [(C + B / 2) / B * e, (O / 2 - v) / O * r + b] };
-          f.fillStyle = "#00f", H(f, M(h, 6), c), f.fillStyle = "#f00", H(f, M(h, 5), c);
+          const h = l[a + t] ?? new Float32Array(0), R = t * r, c = { map: (b, S) => [(b + k / 2) / k * e, (v / 2 - S) / v * r + R] };
+          f.fillStyle = "#00f", D(f, M(h, H.RAFT), c), f.fillStyle = "#f00", D(f, M(h, H.SUPPORT), c);
         }
         g = f.getImageData(0, 0, e, r * o.length).data, s.roles += performance.now() - n, n = performance.now();
       }
       n = performance.now();
       for (let t = 0; t < o.length; t++) {
-        const h = new Uint8Array(e * r), b = D(h, p.subarray(t * e * r * 4, (t + 1) * e * r * 4), e, r, 0);
+        const h = new Uint8Array(e * r), R = q(h, p.subarray(t * e * r * 4, (t + 1) * e * r * 4), e, r, 0);
         let c = null;
         if (g) {
           c = new Uint8Array(e * r);
-          const v = t * e * r * 4;
-          for (let R = 0; R < r; R++) {
-            const j = v + R * e * 4, q = e * (r - 1 - R);
-            for (let x = 0; x < e; x++) {
-              const T = j + x * 4;
-              c[q + x] = g[T] > 127 ? 5 : g[T + 2] > 127 ? 6 : 0;
+          const S = t * e * r * 4;
+          for (let O = 0; O < r; O++) {
+            const U = S + O * e * 4, j = e * (r - 1 - O);
+            for (let C = 0; C < e; C++) {
+              const P = U + C * 4;
+              c[j + C] = g[P] > 127 ? 5 : g[P + 2] > 127 ? 6 : 0;
             }
           }
         }
-        const C = [h.buffer, b.buffer];
-        c && C.push(c.buffer), self.postMessage({ index: k[a + t], slice: h, ranges: b, roles: c }, C);
+        const b = [h.buffer, R.buffer];
+        c && b.push(c.buffer), self.postMessage({ index: x[a + t], slice: h, ranges: R, roles: c }, b);
       }
       s.fill += performance.now() - n;
     }

package/dist/theme-2oyfMuvf.js

@@ -0,0 +1,97 @@
+const t = Object.freeze({
+  accent: "#00ae42",
+  // selection: the object, the selected plate, the scale handles, the box-select band
+  accentHover: "#1f5c34",
+  // emissive tint of the object under the pointer
+  sceneBackground: "#161a1e",
+  lightSky: "#ffffff",
+  lightGround: "#2a2f36",
+  gridMinor: "#232a31",
+  gridMajor: "#39434d",
+  plateBorder: "#4a5560",
+  plateLabel: "#5a6570",
+  travel: "#5a6270",
+  // travel moves in the toolpath preview
+  nozzle: "#ff7a1a",
+  overhang: "#ff4433",
+  // the brush's overhang-limit overlay
+  primeTower: "#4fd1c5",
+  slaModel: "#d7862a",
+  slaSupport: "#9b78d8",
+  slaPad: "#b0a06a",
+  inkOnLight: "#10141a",
+  // label text on a light swatch
+  inkOnDark: "#ffffff"
+});
+function i(r) {
+  const e = (a) => a <= 0.04045 ? a / 12.92 : ((a + 0.055) / 1.055) ** 2.4;
+  return [1, 3, 5].map((a) => e(parseInt(r.slice(a, a + 2), 16) / 255));
+}
+const c = Object.freeze({
+  // the brand green and its family
+  accent: t.accent,
+  accentHover: "#06c04d",
+  accentDeep: "#23402c",
+  // the busy pulse on a dark control
+  accentInk: "#167a3a",
+  // green text on a light surface
+  accentOnDark: "#9fe3bd",
+  // green text on a dark surface
+  accentSoft: "#e3f6ea",
+  // selected row / active tab on a light surface
+  accentSoftBorder: "#9adfb6",
+  onAccent: "#ffffff",
+  // text and marks on any filled status colour
+  // the dark chrome: top bar, rail, viewport overlays, menus
+  darkBase: "#0e1216",
+  darkSurface: "#161b21",
+  darkControl: "#1a2027",
+  darkControlHover: "#28313a",
+  darkBorder: "#2c353d",
+  darkBorderStrong: "#3a4550",
+  darkText: "#cdd6dd",
+  darkTextMuted: "#aebcc6",
+  darkTextFaint: "#8b98a2",
+  darkTextDisabled: t.plateLabel,
+  // the light sidebar and the settings panel
+  lightBg: "#eef0f2",
+  lightSurface: "#ffffff",
+  lightSubtle: "#f6f7f8",
+  lightControl: "#dfe6ea",
+  lightControlHover: "#d3dee4",
+  lightBorder: "#d5d8dd",
+  lightDivider: "#e3e6ea",
+  lightText: "#24282e",
+  lightTextMuted: "#5a6069",
+  lightTextFaint: "#8a9099",
+  // status
+  info: "#2b6cff",
+  infoInk: "#2563eb",
+  // the info blue as a filled badge under white text (4.5:1)
+  infoSoft: "#e6efff",
+  techBadge: "#6d7ce0",
+  // the resin marker on an object-list plate header
+  danger: "#e23b3b",
+  dangerInk: "#a33b37",
+  dangerSoft: "#fbeaea",
+  dangerOnDark: "#ff8b8b",
+  dangerDeep: "#4a2229",
+  warn: "#f0a542",
+  warnInk: "#a86a12",
+  warnSoft: "#fdf4e3",
+  warnSoftHover: "#f3e2cb",
+  warnBorder: "#d8b48a",
+  warnOnDark: "#f0c060",
+  warnDeep: "#3a2a10",
+  warnDeepBorder: "#7a5a1e"
+}), o = (r) => r.replace(/[A-Z]/g, (e) => "-" + e.toLowerCase()), d = ["accent", "darkBase", "darkSurface", "warnDeep"], f = (r) => [1, 3, 5].map((e) => parseInt(r.slice(e, e + 2), 16)).join(", "), l = (r, e) => `rgba(${f(r)}, ${e})`, b = `:host{${Object.entries(c).map(([r, e]) => {
+  const a = o(r), n = `--_${a}:var(--vp-${a},${e});`;
+  return d.includes(r) ? n + `--_${a}-rgb:var(--vp-${a}-rgb,${f(e)});` : n;
+}).join("")}}
+`;
+export {
+  t as T,
+  b as a,
+  i as h,
+  l as w
+};