@equinor/videx-3d 1.0.0 → 1.0.2

package/dist/generators.js

@@ -1,419 +1,439 @@
-import { transfer as L } from "comlink";
+import { transfer as x } from "comlink";
 import "p-limit";
-import { i as x, d as T, o as at, a7 as it, a6 as F, b as _, g as et, O as ct, N as ut, p as mt, aa as lt, F as pt, G as gt, _ as dt, h as ft, ag as ht } from "./chunk-iY0wQ9Z6.js";
-import { Vector3 as b, Matrix4 as $, Color as ot, BufferGeometry as yt, BufferAttribute as j } from "three";
+import { i as A, d as b, o as ot, a7 as ct, p as nt, $ as ut, a6 as E, b as N, g as st, O as lt, N as mt, aa as pt, F as gt, G as ft, _ as ht, h as dt, ag as yt } from "./chunk-iY0wQ9Z6.js";
 import "three/src/math/MathUtils.js";
+import { Sphere as wt, Box3 as Tt, Vector3 as v, Matrix4 as P, Color as rt, BufferGeometry as Mt, BufferAttribute as O } from "three";
 import "proj4";
-import { clamp as Tt } from "curve-interpolator";
-import { group as nt } from "d3-array";
-import { mergeGeometries as W } from "three/examples/jsm/utils/BufferGeometryUtils.js";
-import { b as O, t as wt, d as Mt, a as bt } from "./chunk-MFzFdEWm.js";
-import { b as vt, d as At } from "./chunk-BX-cez1_.js";
-async function Ht(o, s, u = 0, c, l = !1) {
-  const t = await this.get("position-logs", o), e = x(o, t);
+import { clamp as bt } from "curve-interpolator";
+import { group as vt } from "d3-array";
+import { mergeBufferGeometries as Y } from "three-stdlib";
+import { a as At } from "./chunk-DuRASjkF.js";
+import { d as W, t as xt, e as Bt, a as $t } from "./chunk-BolRQZt9.js";
+async function Kt(o, c, l = 0, r, m = !1) {
+  const t = await this.get("position-logs", o), e = A(o, t);
   if (!e) return null;
-  const a = c !== void 0 ? T(
-    (c - e.measuredTop) / e.measuredLength,
+  const n = r !== void 0 ? b(
+    (r - e.measuredTop) / e.measuredLength,
     0,
     1
-  ) : 0, m = at(
+  ) : 0, p = ot(
     e.curve,
-    a,
+    n,
     1,
-    s,
-    u
-  ), n = new Float32Array(m.length * 3), p = l ? new Float32Array(m.length) : null;
-  m.forEach((d, f) => {
-    const M = e.curve.getPointAt(d);
-    n[f * 3] = M[0], n[f * 3 + 1] = M[1], n[f * 3 + 2] = M[2], p && (p[f] = d);
+    c,
+    l
+  ), s = new Float32Array(p.length * 3), g = m ? new Float32Array(p.length) : null;
+  p.forEach((f, h) => {
+    const w = e.curve.getPointAt(f);
+    s[h * 3] = w[0], s[h * 3 + 1] = w[1], s[h * 3 + 2] = w[2], g && (g[h] = f);
   });
-  const i = {
+  const u = {
     position: {
-      array: n,
+      array: s,
       itemSize: 3
     }
   };
-  p && (i.lengths = {
-    array: p,
+  g && (u.lengths = {
+    array: g,
     itemSize: 1
   });
-  const [r, g] = it({ attributes: i });
-  return L(r, g);
+  const [i, a] = ct({ attributes: u });
+  return x(i, a);
 }
-async function qt(o) {
-  const s = await this.get("casings", o);
-  if (!s) return null;
-  const u = await this.get("position-logs", o), c = x(o, u);
-  return c ? s.filter((t) => t.mdBottomMsl > c.measuredTop).map((t) => {
-    const e = T(
-      (t.mdTopMsl + (t.mdBottomMsl - t.mdTopMsl) / 2 - c.measuredTop) / c.measuredLength,
+async function Qt(o) {
+  const c = await this.get("casings", o);
+  if (!c) return null;
+  const l = await this.get("position-logs", o), r = A(o, l);
+  return r ? c.filter((t) => t.mdBottomMsl > r.measuredTop).map((t) => {
+    const e = b(
+      (t.mdTopMsl + (t.mdBottomMsl - t.mdTopMsl) / 2 - r.measuredTop) / r.measuredLength,
       0,
       1
     );
     return {
       name: `${t.properties.Diameter} ${t.properties.Type}`,
-      data: t.properties,
-      position: c.curve.getPointAt(e),
-      direction: c.curve.getTangentAt(e),
-      priority: t.type === "Shoe" ? 50 : t.innerDiameter
+      data: { ...t.properties, isShoe: t.isShoe },
+      position: r.curve.getPointAt(e),
+      direction: r.curve.getTangentAt(e),
+      priority: t.isShoe ? 50 : t.innerDiameter
     };
   }) : null;
 }
-function xt(o, s, u, c, l = 0) {
-  const t = T(
-    s.mdBottomMsl - s.mdTopMsl,
-    1e-4,
-    o.measuredLength
-  ), e = 1 / o.measuredLength, a = [], m = T(
-    (s.mdTopMsl - o.measuredTop) / o.measuredLength,
-    0,
-    1
-  ), n = T(
-    (s.mdBottomMsl - o.measuredTop) / o.measuredLength,
-    0,
-    1
-  ), p = u * (s.outerDiameter / 2), i = Math.max(
-    (s.innerDiameter + (s.outerDiameter - s.innerDiameter) / 4) / 2 * u,
-    p * 0.95
+const X = new wt();
+function Lt(o, c, l) {
+  if (c[0] === l[0]) return l[1];
+  const r = l[0] - c[0], m = b((o - c[0]) / r, 0, 1);
+  return ut(c[1], l[1], m);
+}
+function Pt(o, c, l, r, m, t) {
+  const e = [];
+  r.sort((a, f) => a[0] - f[0]);
+  const n = [], p = ot(
+    o,
+    c,
+    l,
+    m,
+    t
   );
-  a.push([m, i]);
-  const r = Math.min((p - i) * 2, t / 3) * e;
-  return a.push([m + r, p]), a.push([n - r, p]), a.push([n, i]), O(o.curve, {
-    ...c,
-    from: Math.max(m, l),
-    to: n,
-    innerRadius: s.innerDiameter / 2 * u,
-    radiusModifier: {
-      type: "linear",
-      steps: a
+  let s = 0, g = p[s];
+  for (let a = 0; a < r.length - 1; a++) {
+    const f = a + 1, [h, w] = r[a], [d, y] = r[f];
+    for (n.push([
+      h,
+      // curve position 0-1
+      w
+      // outer radius,
+    ]); g <= h && s < p.length - 1; )
+      g = p[++s];
+    for (; g < d && s < p.length; ) {
+      const T = Lt(g, r[a], r[f]);
+      n.push([g, T]), g = p[s++];
     }
-  });
-}
-function Lt(o, s, u, c, l, t = 0) {
-  const e = T(
-    (s.mdTopMsl - o.measuredTop) / o.measuredLength,
-    0,
-    1
-  ), a = T(
-    (s.mdBottomMsl - o.measuredTop) / o.measuredLength,
-    0,
-    1
-  ), m = s.outerDiameter / 2 * u, n = m * l, p = s.innerDiameter / 2 * u;
-  return O(o.curve, {
-    ...c,
-    from: Math.max(e, t),
-    to: a,
-    radiusModifier: {
-      type: "linear",
-      steps: [
-        [e, m],
-        [e + (a - e) / 4, m],
-        [a, n]
-      ]
-    },
-    innerRadius: p
-  });
+    f === r.length - 1 && n.push([d, y]);
+  }
+  const u = nt(
+    o,
+    n.map((a) => a[0])
+  ), i = l - c;
+  return u.forEach((a, f) => {
+    e.push(
+      ...a.position,
+      ...a.normal,
+      ...a.tangent,
+      b((a.curvePosition - c) / i, 0, 1),
+      // segment length 0-1
+      a.curvePosition,
+      // position on curve 0-1
+      n[f][1]
+      // outer radius
+    );
+  }), Float32Array.from(e);
 }
-async function Jt(o, s, u = 16, c = 1, l = 2, t = 0.1, e = 0) {
-  const a = await this.get("casings", o);
-  if (!a) return null;
-  const m = await this.get("position-logs", o), n = x(o, m);
+async function Zt(o, c, l = 2, r = 0.1, m = 0) {
+  const t = await this.get("casings", o);
+  if (!t) return null;
+  const e = await this.get("position-logs", o), n = A(o, e);
   if (!n) return null;
-  const p = s !== void 0 ? T(
-    (s - n.measuredTop) / n.measuredLength,
+  const p = c !== void 0 ? b(
+    (c - n.measuredTop) / n.measuredLength,
     0,
     1
-  ) : 0, i = {
-    startCap: !0,
-    endCap: !0,
-    radialSegments: u,
-    addGroups: !0,
-    computeNormals: !0,
-    computeUvs: !0,
-    simplificationThreshold: e,
-    segmentsPerMeter: t
-  }, r = [], g = [], d = a.filter(
-    (w) => w.mdBottomMsl > n.measuredTop && (s === void 0 || w.mdBottomMsl > s)
-  ).sort((w, h) => w.outerDiameter - h.outerDiameter);
-  if (d.length === 0) return null;
-  nt(d, (w) => ({
-    category: ["Shoe", "Casing"].includes(w.type) ? w.type : "Generic",
-    dimmension: w.outerDiameter
-  })).forEach((w, h) => {
-    const B = w.map((D) => {
-      let P;
-      return h.category === "Shoe" ? P = Lt(
-        n,
-        D,
-        c,
-        i,
-        l,
-        p
-      ) : P = xt(
-        n,
-        D,
-        c,
-        i,
-        p
-      ), P;
-    });
-    g.push(vt[h.category]), r.push(W(B, !1));
-  });
-  const M = W(r, !0);
-  M.groups.forEach((w, h) => {
-    w.materialIndex = g[h];
-  });
-  const [v, y] = F(M);
-  return L({
-    geometry: v
-  }, y);
+  ) : 0, s = t.filter(
+    (a) => a.mdBottomMsl > n.measuredTop && (c === void 0 || a.mdBottomMsl > c)
+  ).map((a) => ({
+    ...a,
+    mdTopMsl: Math.max(a.mdTopMsl, n.measuredTop)
+  })).sort(
+    (a, f) => a.outerDiameter - f.outerDiameter || a.mdTopMsl - f.mdTopMsl
+  );
+  if (s.length === 0) return null;
+  const g = 1 / n.measuredLength, u = [], i = [];
+  return s.forEach((a) => {
+    const f = b(
+      a.mdBottomMsl - a.mdTopMsl,
+      1e-4,
+      n.measuredLength
+    ), h = Math.max(
+      p,
+      b(
+        (a.mdTopMsl - n.measuredTop) / n.measuredLength,
+        0,
+        1
+      )
+    ), w = b(
+      (a.mdBottomMsl - n.measuredTop) / n.measuredLength,
+      0,
+      1
+    ), d = a.outerDiameter / 2, y = a.innerDiameter ? a.innerDiameter / 2 : d * 0.95, T = [];
+    if (a.isShoe) {
+      const $ = d * l;
+      T.push(
+        [h, d],
+        [h + (w - h) / 4, d],
+        [w, $]
+      );
+    } else {
+      const $ = d - (d - y) / 4;
+      T.push([h, $]);
+      const S = Math.min((d - $) * 2, f / 3) * g;
+      T.push([h + S, d]), T.push([w - S, d]), T.push([w, $]);
+    }
+    const L = Pt(
+      n.curve,
+      h,
+      w,
+      T,
+      r,
+      m
+    ), M = n.curve.getBoundingBox(h, w);
+    new Tt(new v(...M.min), new v(...M.max)).getBoundingSphere(X), i.push({
+      type: a.type,
+      radius: d,
+      innerRadius: y,
+      length: f,
+      top: h,
+      bottom: w,
+      attributesBuffer: L,
+      segments: L.length / 12,
+      boundingSphere: {
+        center: X.center.toArray(),
+        radius: X.radius
+      }
+    }), u.push(L.buffer);
+  }), x(i, u);
 }
-async function Kt(o) {
-  const s = await this.get("completion-tools", o);
-  if (!s) return null;
-  const u = await this.get("position-logs", o), c = x(o, u);
-  return c ? s.filter((t) => t.mdBottomMsl > c.measuredTop).map((t) => {
-    const e = T(
-      (t.mdTopMsl + t.length / 2 - c.measuredTop) / c.measuredLength,
+async function zt(o) {
+  const c = await this.get("completion-tools", o);
+  if (!c) return null;
+  const l = await this.get("position-logs", o), r = A(o, l);
+  return r ? c.filter((t) => t.mdBottomMsl > r.measuredTop).map((t) => {
+    const e = b(
+      (t.mdTopMsl + t.length / 2 - r.measuredTop) / r.measuredLength,
       0,
       1
     );
     return {
       name: t.name,
       //data: d,
-      position: c.curve.getPointAt(e),
-      direction: c.curve.getTangentAt(e),
+      position: r.curve.getPointAt(e),
+      direction: r.curve.getTangentAt(e),
       priority: t.diameterMax
     };
   }) : null;
 }
-function Bt(o, s, u, c, l) {
-  const t = T(s.length, 1e-4, o.measuredLength), e = 1 / o.measuredLength, a = [], m = T(
-    (s.mdTopMsl - o.measuredTop) / o.measuredLength,
+function Dt(o, c, l, r, m) {
+  const t = b(c.length, 1e-4, o.measuredLength), e = 1 / o.measuredLength, n = [], p = b(
+    (c.mdTopMsl - o.measuredTop) / o.measuredLength,
     0,
     1
-  ), n = T(
-    (s.mdBottomMsl - o.measuredTop) / o.measuredLength,
+  ), s = b(
+    (c.mdBottomMsl - o.measuredTop) / o.measuredLength,
     0,
     1
-  ), p = u * ((s.diameterTop || s.diameterBottom) / 2), i = u * ((s.diameterBottom || s.diameterTop) / 2), r = u * ((s.diameterMax || s.diameterTop) / 2), g = Math.min(p, i, r);
-  a.push([m, p]);
-  const d = Math.min((r - g) * 2, t / 3) * e;
-  return r > g && (a.push([m + d, r]), a.push([n - d, r])), a.push([n, i]), O(o.curve, {
-    ...l,
-    from: Math.max(m, c),
-    to: n,
+  ), g = l * ((c.diameterTop || c.diameterBottom) / 2), u = l * ((c.diameterBottom || c.diameterTop) / 2), i = l * ((c.diameterMax || c.diameterTop) / 2), a = Math.min(g, u, i);
+  n.push([p, g]);
+  const f = Math.min((i - a) * 2, t / 3) * e;
+  return i > a && (n.push([p + f, i]), n.push([s - f, i])), n.push([s, u]), W(o.curve, {
+    ...m,
+    from: Math.max(p, r),
+    to: s,
     computeLengths: !0,
     radiusModifier: {
       type: "linear",
-      steps: a
+      steps: n
     }
   });
 }
-async function Qt(o, s, u = 16, c = 1, l = 0.1, t = 0) {
+async function te(o, c, l = 16, r = 1, m = 0.1, t = 0) {
   const e = await this.get("completion-tools", o);
   if (!e) return null;
-  const a = await this.get("position-logs", o), m = x(o, a);
-  if (!m) return null;
-  const n = s !== void 0 ? T(
-    (s - m.measuredTop) / m.measuredLength,
+  const n = await this.get("position-logs", o), p = A(o, n);
+  if (!p) return null;
+  const s = c !== void 0 ? b(
+    (c - p.measuredTop) / p.measuredLength,
     0,
     1
-  ) : 0, p = e.filter(
-    (y) => y.mdBottomMsl > m.measuredTop && (s === void 0 || y.mdBottomMsl > s)
-  ).sort((y, A) => y.mdTopMsl - A.mdTopMsl), i = nt(p, (y) => y.category), r = {
+  ) : 0, g = e.filter(
+    (y) => y.mdBottomMsl > p.measuredTop && (c === void 0 || y.mdBottomMsl > c)
+  ).sort((y, T) => y.mdTopMsl - T.mdTopMsl), u = vt(g, (y) => y.category), i = {
     startCap: !0,
     endCap: !0,
-    radialSegments: u,
+    radialSegments: l,
     computeNormals: !0,
     computeUvs: !0,
-    segmentsPerMeter: l,
+    segmentsPerMeter: m,
     simplificationThreshold: t,
     radius: 0
-  }, g = [], d = [];
-  if (i.forEach((y, A) => {
-    const w = y.map((h) => Bt(
-      m,
-      h,
-      c,
-      n,
-      r
-    ));
-    d.push(At[A]), g.push(W(w, !1));
-  }), !g.length) return null;
-  const f = W(g, !0);
-  f.groups.forEach((y, A) => {
-    y.materialIndex = d[A];
+  }, a = [], f = [];
+  if (u.forEach((y, T) => {
+    const L = y.map((B) => Dt(
+      p,
+      B,
+      r,
+      s,
+      i
+    )).filter((B) => B);
+    f.push(At[T]);
+    const M = Y(
+      L,
+      !1
+    );
+    M && a.push(M);
+  }), !a.length) return null;
+  const h = Y(a, !0);
+  if (!h) return null;
+  h.groups.forEach((y, T) => {
+    y.materialIndex = f[T];
   });
-  const [M, v] = F(f);
-  return L(M, v);
+  const [w, d] = E(h);
+  return x(w, d);
 }
-async function Zt(o, s, u = "MSL", c) {
-  const l = await this.get("position-logs", o);
-  if (!l || l.length < 8) return null;
+async function ee(o, c, l = "MSL", r) {
+  const m = await this.get("position-logs", o);
+  if (!m || m.length < 8) return null;
   let t = 0;
-  if (u === "RT") {
-    const g = await this.get("wellbore-headers", o);
-    g && (t = g.depthReferenceElevation);
+  if (l === "RT") {
+    const a = await this.get("wellbore-headers", o);
+    a && (t = a.depthReferenceElevation);
   }
-  const e = x(o, l);
+  const e = A(o, m);
   if (!e) return null;
-  const a = l[l.length - 1] + t, n = Math.max(
+  const n = m[m.length - 1] + t, s = Math.max(
     e.measuredTop,
-    c && Number.isFinite(c) ? c : e.measuredTop
-  ) + t, p = [n];
-  let i = Math.floor(n / s) * s;
-  for (i <= n && (i += s); i < a; )
-    p.push(i), i += s;
-  return p.push(a), p.map((g) => {
-    const d = T(
-      (g - t - e.measuredTop) / e.measuredLength,
+    r && Number.isFinite(r) ? r : e.measuredTop
+  ) + t, g = [s];
+  let u = Math.floor(s / c) * c;
+  for (u <= s && (u += c); u < n; )
+    g.push(u), u += c;
+  return g.push(n), g.map((a) => {
+    const f = b(
+      (a - t - e.measuredTop) / e.measuredLength,
       0,
       1
-    ), f = e.curve.getPointAt(d), M = e.curve.getTangentAt(d);
+    ), h = e.curve.getPointAt(f), w = e.curve.getTangentAt(f);
     return {
-      id: `${o}_${g}`,
-      name: (Math.round(g * 10) / 10).toString(),
-      direction: M,
-      position: f
+      id: `${o}_${a}`,
+      name: (Math.round(a * 10) / 10).toString(),
+      direction: w,
+      position: h
     };
   });
 }
-const V = new b(), H = new b(), q = new b(), $t = new b(0, 1, 0), C = new $(), Dt = new $().makeRotationX(_), J = new ot();
-async function zt(o, s, u, c = 10) {
-  const l = await et(
+const D = new v(), q = new v(), J = new v(), Ft = new v(0, 1, 0), F = new P(), Vt = new P().makeRotationX(N), K = new rt();
+async function oe(o, c, l, r = 10) {
+  const m = await st(
     o,
-    s,
+    c,
     this,
-    u
+    l
   );
-  if (!l) return null;
-  const t = ct(l);
+  if (!m) return null;
+  const t = lt(m);
   if (!t.length) return null;
-  const e = await this.get("position-logs", o), a = x(o, e);
-  if (!a) return null;
-  const m = t.map((r) => {
-    const g = Tt(
-      (r.mdMsl - a.measuredTop) / a.measuredLength,
+  const e = await this.get("position-logs", o), n = A(o, e);
+  if (!n) return null;
+  const p = t.map((i) => {
+    const a = bt(
+      (i.mdMsl - n.measuredTop) / n.measuredLength,
       0,
       1
     );
     return {
-      ...r,
-      position: a.curve.getPointAt(g),
-      direction: a.curve.getTangentAt(g)
+      ...i,
+      position: n.curve.getPointAt(a),
+      direction: n.curve.getTangentAt(a)
     };
-  }), n = new Float32Array(m.length * 16), p = new Float32Array(m.length * 3), i = [];
-  return m.forEach((r, g) => {
-    V.set(...r.position), C.identity();
-    const d = c;
-    q.set(d, d, d), H.set(
-      V.x + r.direction[0],
-      V.y + r.direction[1],
-      V.z + r.direction[2]
-    ), C.lookAt(V, H, $t), C.multiply(Dt), C.setPosition(V), C.scale(q), C.toArray(n, g * 16), J.set(r.color), J.toArray(p, g * 3), i[g] = {
-      id: `${o}_${g}`,
-      name: `${r.name} ${wt(r.type)}`,
-      depth: r.mdMsl,
-      tvd: r.tvdMsl,
-      level: r.level,
-      direction: r.direction
+  }), s = new Float32Array(p.length * 16), g = new Float32Array(p.length * 3), u = [];
+  return p.forEach((i, a) => {
+    D.set(...i.position), F.identity();
+    const f = r;
+    J.set(f, f, f), q.set(
+      D.x + i.direction[0],
+      D.y + i.direction[1],
+      D.z + i.direction[2]
+    ), F.lookAt(D, q, Ft), F.multiply(Vt), F.setPosition(D), F.scale(J), F.toArray(s, a * 16), K.set(i.color), K.toArray(g, a * 3), u[a] = {
+      id: `${o}_${a}`,
+      name: `${i.name} ${xt(i.type)}`,
+      depth: i.mdMsl,
+      tvd: i.tvdMsl,
+      level: i.level,
+      direction: i.direction
     };
-  }), L(
+  }), x(
     {
-      data: i,
-      transformations: n,
-      colors: p
+      data: u,
+      transformations: s,
+      colors: g
     },
-    [n.buffer]
+    [s.buffer]
   );
 }
-const G = new b(), K = new b(), X = new b(), Ft = new b(0, 1, 0), k = new $(), Pt = new $().makeRotationX(_);
-async function te(o, s, u = 1) {
-  const c = await this.get(
+const V = new v(), Q = new v(), U = new v(), Ct = new v(0, 1, 0), C = new P(), Rt = new P().makeRotationX(N);
+async function ne(o, c, l = 1) {
+  const r = await this.get(
     "perforations",
     o
   );
-  if (!c) return null;
-  const l = await this.get("position-logs", o), t = x(o, l);
+  if (!r) return null;
+  const m = await this.get("position-logs", o), t = A(o, m);
   if (!t) return null;
-  X.set(
-    Math.max(1, u / 2),
-    u,
-    Math.max(1, u / 2)
+  U.set(
+    Math.max(1, l / 2),
+    l,
+    Math.max(1, l / 2)
   );
-  const e = [], a = c.filter(
-    (i) => i.status === "Open" && i.mdBottomMsl > t.measuredTop && (s === void 0 || i.mdBottomMsl > s)
-  ).sort((i, r) => i.mdTopMsl - r.mdTopMsl);
-  for (let i = 0; i < a.length; i++) {
-    const r = a[i];
-    r.mdBottomMsl <= t.measuredTop || (!e.length || e[e.length - 1].bottom !== r.mdTopMsl ? e.push({
-      type: r.type,
-      top: Math.max(t.measuredTop, r.mdTopMsl),
-      bottom: r.mdBottomMsl,
-      density: ut(r.density || 0),
-      phase: r.phase || 0,
+  const e = [], n = r.filter(
+    (u) => u.status === "Open" && u.mdBottomMsl > t.measuredTop && (c === void 0 || u.mdBottomMsl > c)
+  ).sort((u, i) => u.mdTopMsl - i.mdTopMsl);
+  for (let u = 0; u < n.length; u++) {
+    const i = n[u];
+    i.mdBottomMsl <= t.measuredTop || (!e.length || e[e.length - 1].bottom !== i.mdTopMsl ? e.push({
+      type: i.type,
+      top: Math.max(t.measuredTop, i.mdTopMsl),
+      bottom: i.mdBottomMsl,
+      density: mt(i.density || 0),
+      phase: i.phase || 0,
       innerDiameter: 0,
       outerDiameter: 0
-    }) : e.length && (e[e.length - 1].bottom = r.mdBottomMsl));
+    }) : e.length && (e[e.length - 1].bottom = i.mdBottomMsl));
   }
-  const m = [];
-  for (let i = 0; i < e.length; i++) {
-    const r = e[i], g = r.bottom - r.top, d = Math.max(
+  const p = [];
+  for (let u = 0; u < e.length; u++) {
+    const i = e[u], a = i.bottom - i.top, f = Math.max(
       1,
-      Math.floor(g * r.density)
-    ), f = T(
-      (r.top - t.measuredTop) / t.measuredLength,
+      Math.floor(a * i.density)
+    ), h = b(
+      (i.top - t.measuredTop) / t.measuredLength,
       0,
       1
-    ), v = (T(
-      (r.bottom - t.measuredTop) / t.measuredLength,
+    ), d = (b(
+      (i.bottom - t.measuredTop) / t.measuredLength,
       0,
       1
-    ) - f) / d, y = [];
-    for (let h = 0; h < d; h++)
-      y.push(f + v * h);
-    const A = mt(t.curve, y);
-    let w = _;
-    for (let h = 0; h < A.length; h++) {
-      const B = A[h], D = lt(
-        pt(B.tangent, [0, -1, 0]),
+    ) - h) / f, y = [];
+    for (let M = 0; M < f; M++)
+      y.push(h + d * M);
+    const T = nt(t.curve, y);
+    let L = N;
+    for (let M = 0; M < T.length; M++) {
+      const B = T[M], $ = pt(
+        gt(B.tangent, [0, -1, 0]),
         B.tangent,
-        w
+        L
       );
-      m.push({
-        name: r.type,
+      p.push({
+        name: i.type,
         position: B.position,
-        normal: D,
+        normal: $,
         tangent: B.tangent
-      }), w += gt(r.phase);
+      }), L += ft(i.phase);
     }
   }
-  const n = new Float32Array(m.length * 16), p = [];
-  for (let i = 0; i < m.length; i++) {
-    const r = m[i];
-    G.set(...r.position), K.set(
-      G.x + r.normal[0],
-      G.y + r.normal[1],
-      G.z + r.normal[2]
-    ), X.setY(
-      u + u * (Math.random() - 0.5) * 0.25
-    ), k.identity(), k.lookAt(G, K, Ft), k.multiply(Pt), k.setPosition(G), k.scale(X), k.toArray(n, i * 16), p[i] = {
-      id: `${o}_${i}`,
-      name: r.name,
-      direction: r.tangent
+  const s = new Float32Array(p.length * 16), g = [];
+  for (let u = 0; u < p.length; u++) {
+    const i = p[u];
+    V.set(...i.position), Q.set(
+      V.x + i.normal[0],
+      V.y + i.normal[1],
+      V.z + i.normal[2]
+    ), U.setY(
+      l + l * (Math.random() - 0.5) * 0.25
+    ), C.identity(), C.lookAt(V, Q, Ct), C.multiply(Rt), C.setPosition(V), C.scale(U), C.toArray(s, u * 16), g[u] = {
+      id: `${o}_${u}`,
+      name: i.name,
+      direction: i.tangent
     };
   }
-  return L(
+  return x(
     {
-      data: p,
-      transformations: n
+      data: g,
+      transformations: s
     },
-    [n.buffer]
+    [s.buffer]
   );
 }
-async function ee(o, s, u = 0.1, c = 0) {
-  const l = await this.get("position-logs", o), t = x(o, l);
+async function se(o, c, l = 0.1, r = 0) {
+  const m = await this.get("position-logs", o), t = A(o, m);
   if (!t) return null;
   const e = {
     from: 0,
@@ -423,261 +443,267 @@ async function ee(o, s, u = 0.1, c = 0) {
     radialSegments: 32,
     computeLengths: !0,
     computeUvs: !0,
-    segmentsPerMeter: u,
-    simplificationThreshold: c,
-    radius: s
-  }, a = O(t.curve, e), [m, n] = F(a);
-  return L(m, n);
+    segmentsPerMeter: l,
+    simplificationThreshold: r,
+    radius: c
+  }, n = W(t.curve, e);
+  if (!n) return null;
+  const [p, s] = E(n);
+  return x(p, s);
 }
-const R = new b(), Q = new b(), Z = new b(), Vt = new b(0, 1, 0), S = new $(), Ct = new $().makeRotationX(_);
-async function oe(o, s, u, c) {
-  const l = await this.get("position-logs", o), t = x(o, l);
+const R = new v(), Z = new v(), z = new v(), kt = new v(0, 1, 0), k = new P(), jt = new P().makeRotationX(N);
+async function re(o, c, l, r) {
+  const m = await this.get("position-logs", o), t = A(o, m);
   if (!t) return null;
-  const e = t.measuredBottom, a = t.measuredLength, n = Math.max(
+  const e = t.measuredBottom, n = t.measuredLength, s = Math.max(
     t.measuredTop,
-    c && Number.isFinite(c) ? c : t.measuredTop
-  ), p = [n];
-  let i = Math.floor(n / u) * u;
-  for (i <= n && (i += u); i < e; )
-    p.push(i), i += u;
-  p.push(e);
-  const r = new Float32Array(p.length * 16), g = [];
-  return p.forEach((d, f) => {
-    const M = T((d - t.measuredTop) / a, 0, 1), v = t.curve.getPointAt(M), y = t.curve.getTangentAt(M);
-    R.set(...v), S.identity();
-    const A = s + 2 / s;
-    Z.set(A, A, A), Q.set(
+    r && Number.isFinite(r) ? r : t.measuredTop
+  ), g = [s];
+  let u = Math.floor(s / l) * l;
+  for (u <= s && (u += l); u < e; )
+    g.push(u), u += l;
+  g.push(e);
+  const i = new Float32Array(g.length * 16), a = [];
+  return g.forEach((f, h) => {
+    const w = b((f - t.measuredTop) / n, 0, 1), d = t.curve.getPointAt(w), y = t.curve.getTangentAt(w);
+    R.set(...d), k.identity();
+    const T = c + 2 / c;
+    z.set(T, T, T), Z.set(
       R.x + y[0],
       R.y + y[1],
       R.z + y[2]
-    ), S.lookAt(R, Q, Vt), S.multiply(Ct), S.setPosition(R), S.scale(Z), S.toArray(r, f * 16), g[f] = {
-      id: `${o}_${f}`,
-      depth: d,
-      position: v
+    ), k.lookAt(R, Z, kt), k.multiply(jt), k.setPosition(R), k.scale(z), k.toArray(i, h * 16), a[h] = {
+      id: `${o}_${h}`,
+      depth: f,
+      position: d
     };
-  }), L(
+  }), x(
     {
-      data: g,
-      transformations: r
+      data: a,
+      transformations: i
     },
-    [r.buffer]
+    [i.buffer]
   );
 }
-const E = new b(), z = new b(), tt = new b(), Gt = new b(0, 1, 0), I = new $(), kt = new $().makeRotationX(_);
-async function ne(o, s, u) {
-  const c = await this.get("casings", o);
-  if (!c) return null;
-  const l = await this.get("position-logs", o), t = x(o, l);
+const j = new v(), tt = new v(), et = new v(), Gt = new v(0, 1, 0), G = new P(), Et = new P().makeRotationX(N);
+async function ae(o, c, l) {
+  const r = await this.get("casings", o);
+  if (!r) return null;
+  const m = await this.get("position-logs", o), t = A(o, m);
   if (!t) return null;
-  const e = c.filter(
-    (n) => n.type === "Shoe" && n.mdBottomMsl > t.measuredTop && (s === void 0 || n.mdBottomMsl > s)
-  ).map((n) => {
-    const p = T(
-      (n.mdBottomMsl - t.measuredTop) / t.measuredLength,
+  const e = r.filter(
+    (s) => s.isShoe && s.mdBottomMsl > t.measuredTop && (c === void 0 || s.mdBottomMsl > c)
+  ).map((s) => {
+    const g = b(
+      (s.mdBottomMsl - t.measuredTop) / t.measuredLength,
       0,
       1
     );
     return {
-      name: `${n.properties.Diameter} ${n.properties.Type}`,
-      data: n.properties,
-      position: t.curve.getPointAt(p),
-      direction: t.curve.getTangentAt(p),
-      radius: n.outerDiameter / 2
+      name: `${s.properties.Diameter} ${s.properties.Type}`,
+      data: s.properties,
+      position: t.curve.getPointAt(g),
+      direction: t.curve.getTangentAt(g),
+      radius: s.outerDiameter / 2
     };
-  }), a = new Float32Array(e.length * 16), m = [];
-  return e.forEach((n, p) => {
-    E.set(...n.position), I.identity();
-    const i = n.radius * (u || 1);
-    tt.set(i, i, i), z.set(
-      E.x + n.direction[0],
-      E.y + n.direction[1],
-      E.z + n.direction[2]
-    ), I.lookAt(E, z, Gt), I.multiply(kt), I.setPosition(E), I.scale(tt), I.toArray(a, p * 16), m[p] = {
-      id: `${o}_${p}`,
-      name: n.name,
-      direction: n.direction
+  }), n = new Float32Array(e.length * 16), p = [];
+  return e.forEach((s, g) => {
+    j.set(...s.position), G.identity();
+    const u = s.radius * (l || 1);
+    et.set(u, u, u), tt.set(
+      j.x + s.direction[0],
+      j.y + s.direction[1],
+      j.z + s.direction[2]
+    ), G.lookAt(j, tt, Gt), G.multiply(Et), G.setPosition(j), G.scale(et), G.toArray(n, g * 16), p[g] = {
+      id: `${o}_${g}`,
+      name: s.name,
+      direction: s.direction
     };
-  }), L(
+  }), x(
     {
-      data: m,
-      transformations: a
+      data: p,
+      transformations: n
     },
-    [a.buffer]
+    [n.buffer]
   );
 }
-const Rt = -1;
-async function se(o) {
+const St = -1;
+async function ie(o) {
   if (!await this.get("surface-meta", o)) return null;
-  const u = await this.get("surface-values", o);
-  if (!u) return null;
-  const c = u;
-  return L({
-    elevationImageBuffer: c
-  }, [c.buffer]);
+  const l = await this.get("surface-values", o);
+  if (!l) return null;
+  const r = l;
+  return x({
+    elevationImageBuffer: r
+  }, [r.buffer]);
 }
-async function re(o, s = 5) {
-  const u = await this.get("surface-meta", o);
-  if (!u) return null;
-  const c = u.max, l = await this.get("surface-values", o);
+async function ce(o, c = 5) {
+  const l = await this.get("surface-meta", o);
   if (!l) return null;
-  const { header: t } = u, e = new yt(), { positions: a, uvs: m, indices: n } = Mt(
-    l,
+  const r = l.max, m = await this.get("surface-values", o);
+  if (!m) return null;
+  const { header: t } = l, e = new Mt(), { positions: n, uvs: p, indices: s } = Bt(
+    m,
     t.nx,
     t.xinc,
     t.yinc,
-    Rt,
-    s
+    St,
+    c
   );
-  e.setAttribute("position", new j(a, 3)), e.setAttribute("uv", new j(m, 2)), e.setIndex(new j(n, 1)), e.translate(0, 0, -(t.ny - 1) * t.yinc), e.rotateY(t.rot * (Math.PI / 180)), e.translate(0, -c, 0);
-  const [p, i] = F(e);
-  return L(p, i);
+  e.setAttribute("position", new O(n, 3)), e.setAttribute("uv", new O(p, 2)), e.setIndex(new O(s, 1)), e.translate(0, 0, -(t.ny - 1) * t.yinc), e.rotateY(t.rot * (Math.PI / 180)), e.translate(0, -r, 0);
+  const [g, u] = E(e);
+  return x(g, u);
 }
-async function ae(o, s, u = 0, c, l = 0.5, t = 16, e = !1) {
-  const a = await this.get("position-logs", o), m = x(o, a);
-  if (!m) return null;
-  const p = {
-    from: c !== void 0 ? T(
-      (c - m.measuredTop) / m.measuredLength,
+async function ue(o, c, l = 0, r, m = 0.5, t = 16, e = !1) {
+  const n = await this.get("position-logs", o), p = A(o, n);
+  if (!p) return null;
+  const g = {
+    from: r !== void 0 ? b(
+      (r - p.measuredTop) / p.measuredLength,
       0,
       1
     ) : 0,
-    radius: l,
+    radius: m,
     startCap: !0,
     endCap: !0,
-    segmentsPerMeter: s,
-    simplificationThreshold: u,
+    segmentsPerMeter: c,
+    simplificationThreshold: l,
     computeNormals: !0,
     computeUvs: !0,
     computeLengths: !!e,
     radialSegments: t
-  }, i = O(m.curve, p), [r, g] = F(i);
-  return L(r, g);
+  }, u = W(p.curve, g);
+  if (!u) return null;
+  const [i, a] = E(u);
+  return x(i, a);
 }
-async function ie(o, s, u = 250) {
-  const c = await this.get("position-logs", o), l = {
+async function le(o, c, l = 250) {
+  const r = await this.get("position-logs", o), m = {
     main: {
       center: [0, 0, 0],
       radius: 10
     },
     sampled: []
   };
-  if (c) {
-    const a = x(o, c);
-    if (a) {
-      const m = s !== void 0 ? T(
-        (s - a.measuredTop) / a.measuredLength,
+  if (r) {
+    const n = A(o, r);
+    if (n) {
+      const p = c !== void 0 ? b(
+        (c - n.measuredTop) / n.measuredLength,
         0,
         1
-      ) : 0, n = a.curve.getBoundingBox(m), p = (n.max[0] - n.min[0]) / 2, i = (n.max[1] - n.min[1]) / 2, r = (n.max[2] - n.min[2]) / 2, g = dt([p, i, r]) + u * 2, d = [
-        n.min[0] + p,
-        n.min[1] + i,
-        n.min[2] + r
+      ) : 0, s = n.curve.getBoundingBox(p), g = (s.max[0] - s.min[0]) / 2, u = (s.max[1] - s.min[1]) / 2, i = (s.max[2] - s.min[2]) / 2, a = ht([g, u, i]) + l * 2, f = [
+        s.min[0] + g,
+        s.min[1] + u,
+        s.min[2] + i
       ];
-      if (l.main.center = d, l.main.radius = g, u > 0) {
-        const f = Math.max(
+      if (m.main.center = f, m.main.radius = a, l > 0) {
+        const h = Math.max(
           2,
-          Math.ceil((1 - m) * a.curve.length / u)
-        ), M = a.curve.getPoints(f, m, 1), v = [];
-        M.forEach((y) => {
-          v.push({
+          Math.ceil((1 - p) * n.curve.length / l)
+        ), w = n.curve.getPoints(h, p, 1), d = [];
+        w.forEach((y) => {
+          d.push({
             center: y,
-            radius: u
+            radius: l
           });
-        }), l.sampled = v;
+        }), m.sampled = d;
       }
     }
   }
-  const t = new Float32Array(4 + l.sampled.length * 4);
+  const t = new Float32Array(4 + m.sampled.length * 4);
   let e = 0;
-  t[e] = l.main.center[0], t[e + 1] = l.main.center[1], t[e + 2] = l.main.center[2], t[e + 3] = l.main.radius, e = 4;
-  for (let a = 0; a < l.sampled.length; a++, e += 4)
-    t[e] = l.sampled[a].center[0], t[e + 1] = l.sampled[a].center[1], t[e + 2] = l.sampled[a].center[2], t[e + 3] = l.sampled[a].radius;
-  return L(t, [t.buffer]);
+  t[e] = m.main.center[0], t[e + 1] = m.main.center[1], t[e + 2] = m.main.center[2], t[e + 3] = m.main.radius, e = 4;
+  for (let n = 0; n < m.sampled.length; n++, e += 4)
+    t[e] = m.sampled[n].center[0], t[e + 1] = m.sampled[n].center[1], t[e + 2] = m.sampled[n].center[2], t[e + 3] = m.sampled[n].radius;
+  return x(t, [t.buffer]);
 }
-async function ce(o, s, u, c, l, t, e = 0.5, a = 2, m = !0, n = 16, p = 0) {
-  const i = await et(
+async function me(o, c, l, r, m, t, e = 0.5, n = 2, p = !0, s = 16, g = 0) {
+  const u = await st(
     o,
-    s,
+    c,
     this
   );
-  if (!i) return null;
-  const r = i.filter(
-    (h) => (t === void 0 || h.type && t.includes(h.type)) && (l === void 0 || l.includes(h.name))
+  if (!u) return null;
+  const i = u.filter(
+    (M) => (t === void 0 || M.type && t.includes(M.type)) && (m === void 0 || m.includes(M.name))
   );
-  if (!r.length) return null;
-  const g = ft(r), d = await this.get("position-logs", o), f = x(o, d);
-  if (!f) return null;
-  const M = {
-    startCap: m,
-    endCap: m,
-    segmentsPerMeter: u,
-    simplificationThreshold: p,
-    radialSegments: n,
+  if (!i.length) return null;
+  const a = dt(i), f = await this.get("position-logs", o), h = A(o, f);
+  if (!h) return null;
+  const w = {
+    startCap: p,
+    endCap: p,
+    segmentsPerMeter: l,
+    simplificationThreshold: g,
+    radialSegments: s,
     computeRelativeLengths: !0
-  }, v = [];
-  if (g.forEach((h) => {
-    if (c === void 0 || h.mdMslTo > c) {
-      let B = h.mdMslFrom;
-      c !== void 0 && c > B && (B = c);
-      const D = f.getPositionAtDepth(B, !0), P = f.getPositionAtDepth(h.mdMslTo, !0);
-      if (D !== null && P !== null) {
-        const st = a + e, rt = new ot(h.color), N = O(f.curve, {
-          ...M,
-          radius: st,
-          from: D,
-          to: P
+  }, d = [];
+  if (a.forEach((M) => {
+    if (r === void 0 || M.mdMslTo > r) {
+      let B = M.mdMslFrom;
+      r !== void 0 && r > B && (B = r);
+      const $ = h.getPositionAtDepth(B, !0), S = h.getPositionAtDepth(M.mdMslTo, !0);
+      if ($ !== null && S !== null) {
+        const at = n + e, it = new rt(M.color), I = W(h.curve, {
+          ...w,
+          radius: at,
+          from: $,
+          to: S
         });
-        if (N.attributes.position.count) {
-          const Y = new Float32Array(
-            N.attributes.position.count * 3
+        if (I?.attributes.position.count) {
+          const H = new Float32Array(
+            I.attributes.position.count * 3
           );
-          for (let U = 0; U < N.attributes.position.count; U++)
-            rt.toArray(Y, U * 3);
-          N.attributes.color = new j(Y, 3), v.push(N);
+          for (let _ = 0; _ < I.attributes.position.count; _++)
+            it.toArray(H, _ * 3);
+          I.attributes.color = new O(H, 3), d.push(I);
         }
       }
     }
-  }), !v.length) return null;
-  const y = W(v, !1), [A, w] = F(y);
-  return L(A, w);
+  }), !d.length) return null;
+  const y = Y(d, !1);
+  if (!y) return null;
+  const [T, L] = E(y);
+  return x(T, L);
 }
-async function ue(o, s, u) {
-  const c = await this.get("wellbore-headers", o);
-  if (!c) return null;
-  const l = await this.get("position-logs", o), t = x(o, l);
+async function pe(o, c, l) {
+  const r = await this.get("wellbore-headers", o);
+  if (!r) return null;
+  const m = await this.get("position-logs", o), t = A(o, m);
   if (!t) return null;
   let e = 1;
-  const { measuredTop: a, measuredLength: m, curve: n } = t;
-  if (s === "top")
-    e = T(
-      ((u || a) - a) / m,
+  const { measuredTop: n, measuredLength: p, curve: s } = t;
+  if (c === "top")
+    e = b(
+      ((l || n) - n) / p,
       0,
       1
     );
-  else if (s === "center") {
-    const i = (u || a) + (m - (u || a)) / 2;
-    e = T((i - a) / m, 0, 1);
+  else if (c === "center") {
+    const u = (l || n) + (p - (l || n)) / 2;
+    e = b((u - n) / p, 0, 1);
   }
   return [{
     id: o,
-    name: `${c.name.replace("NO ", "")}`,
-    position: n.getPointAt(e),
-    direction: n.getTangentAt(e)
+    name: `${r.name.replace("NO ", "")}`,
+    position: s.getPointAt(e),
+    direction: s.getTangentAt(e)
   }];
 }
-async function me(o, s = 3, u = 1e3, c = 1e3, l = 0) {
+async function ge(o, c = 3, l = 1e3, r = 1e3, m = 0) {
   const t = {
-    stepSize: s,
-    minSize: u,
-    extension: c,
-    defaultExtensionAngle: l
+    stepSize: c,
+    minSize: l,
+    extension: r,
+    defaultExtensionAngle: m
   }, e = await this.get(
     "wellbore-seismic-section",
     o,
     t
   );
   if (e === null || e.trajectory === null) return null;
-  const { positions: a } = e.trajectory, m = -e.depthRange[0], n = -e.depthRange[1], p = ht(a), i = bt(p, m, n), [r, g] = F(i), d = {
+  const { positions: n } = e.trajectory, p = -e.depthRange[0], s = -e.depthRange[1], g = yt(n), u = $t(g, p, s), [i, a] = E(u), f = {
     data: {
       array: e.values,
       width: e.samples[0],
@@ -685,27 +711,27 @@ async function me(o, s = 3, u = 1e3, c = 1e3, l = 0) {
       min: e.valueRange[0],
       max: e.valueRange[1]
     },
-    geometry: r
-  }, f = [d.data.array.buffer, ...g];
-  return L(d, f);
+    geometry: i
+  }, h = [f.data.array.buffer, ...a];
+  return x(f, h);
 }
 export {
-  ie as calculateWellboreBounds,
-  Ht as generateBasicTrajectory,
-  qt as generateCasingAnnotations,
-  Jt as generateCasings,
-  Kt as generateCompletionToolAnnotations,
-  Qt as generateCompletionTools,
-  Zt as generateDepthMarkers,
-  zt as generateFormationMarkers,
-  te as generatePerforations,
-  ee as generatePerimeterGeometry,
-  oe as generatePositionMarkers,
-  ne as generateShoes,
-  re as generateSurfaceGeometry,
-  se as generateSurfaceTexturesData,
-  ae as generateTubeTrajectory,
-  ce as generateWellboreFormationColumnGeometries,
-  ue as generateWellboreLabel,
-  me as generateWellboreSeismicSection
+  le as calculateWellboreBounds,
+  Kt as generateBasicTrajectory,
+  Qt as generateCasingAnnotations,
+  Zt as generateCasings,
+  zt as generateCompletionToolAnnotations,
+  te as generateCompletionTools,
+  ee as generateDepthMarkers,
+  oe as generateFormationMarkers,
+  ne as generatePerforations,
+  se as generatePerimeterGeometry,
+  re as generatePositionMarkers,
+  ae as generateShoes,
+  ce as generateSurfaceGeometry,
+  ie as generateSurfaceTexturesData,
+  ue as generateTubeTrajectory,
+  me as generateWellboreFormationColumnGeometries,
+  pe as generateWellboreLabel,
+  ge as generateWellboreSeismicSection
 };