@equinor/videx-3d 1.1.1 → 2.0.0

package/dist/generators.js

@@ -1,29 +1,29 @@
 import { transfer as x } from "comlink";
 import "p-limit";
-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 { h as A, d as b, p as ot, ac as ct, q as nt, a3 as ut, ab as E, b as N, g as st, U as lt, S as mt, af as pt, I as gt, J as ft, F as ht, a2 as dt, m as yt, al as wt } from "./chunk-61X6qE5N.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 { Sphere as Tt, Box3 as Mt, Vector3 as v, Matrix4 as P, Color as rt, BufferGeometry as bt, BufferAttribute as W } from "three";
 import "proj4";
-import { clamp as bt } from "curve-interpolator";
-import { group as vt } from "d3-array";
+import { clamp as vt } from "curve-interpolator";
+import { group as At } 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, f as Bt, a as $t } from "./chunk-BlPg4RjP.js";
-async function Kt(o, c, l = 0, r, m = !1) {
+import { a as xt } from "./chunk-DuRASjkF.js";
+import { d as O, t as Bt, f as Lt, a as $t } from "./chunk-M-Pcc_Yg.js";
+async function Qt(o, i, l = 0, r, p = !1) {
   const t = await this.get("position-logs", o), e = A(o, t);
   if (!e) return null;
   const n = r !== void 0 ? b(
     (r - e.measuredTop) / e.measuredLength,
     0,
     1
-  ) : 0, p = ot(
+  ) : 0, m = ot(
     e.curve,
     n,
     1,
-    c,
+    i,
     l
-  ), s = new Float32Array(p.length * 3), g = m ? new Float32Array(p.length) : null;
-  p.forEach((f, h) => {
+  ), s = new Float32Array(m.length * 3), g = p ? new Float32Array(m.length) : null;
+  m.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);
   });
@@ -37,14 +37,14 @@ async function Kt(o, c, l = 0, r, m = !1) {
     array: g,
     itemSize: 1
   });
-  const [i, a] = ct({ attributes: u });
-  return x(i, a);
+  const [c, a] = ct({ attributes: u });
+  return x(c, a);
 }
-async function Qt(o) {
-  const c = await this.get("casings", o);
-  if (!c) return null;
+async function Zt(o) {
+  const i = await this.get("casings", o);
+  if (!i) 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) => {
+  return r ? i.filter((t) => t.mdBottomMsl > r.measuredTop).map((t) => {
     const e = b(
       (t.mdTopMsl + (t.mdBottomMsl - t.mdTopMsl) / 2 - r.measuredTop) / r.measuredLength,
       0,
@@ -59,23 +59,23 @@ async function Qt(o) {
     };
   }) : null;
 }
-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);
+const U = new Tt();
+function Pt(o, i, l) {
+  if (i[0] === l[0]) return l[1];
+  const r = l[0] - i[0], p = b((o - i[0]) / r, 0, 1);
+  return ut(i[1], l[1], p);
 }
-function Pt(o, c, l, r, m, t) {
+function Dt(o, i, l, r, p, t) {
   const e = [];
   r.sort((a, f) => a[0] - f[0]);
-  const n = [], p = ot(
+  const n = [], m = ot(
     o,
-    c,
+    i,
     l,
-    m,
+    p,
     t
   );
-  let s = 0, g = p[s];
+  let s = 0, g = m[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([
@@ -83,24 +83,24 @@ function Pt(o, c, l, r, m, t) {
       // 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++];
+    ]); g <= h && s < m.length - 1; )
+      g = m[++s];
+    for (; g < d && s < m.length; ) {
+      const T = Pt(g, r[a], r[f]);
+      n.push([g, T]), g = m[s++];
     }
     f === r.length - 1 && n.push([d, y]);
   }
   const u = nt(
     o,
     n.map((a) => a[0])
-  ), i = l - c;
+  ), c = l - i;
   return u.forEach((a, f) => {
     e.push(
       ...a.position,
       ...a.normal,
       ...a.tangent,
-      b((a.curvePosition - c) / i, 0, 1),
+      b((a.curvePosition - i) / c, 0, 1),
       // segment length 0-1
       a.curvePosition,
       // position on curve 0-1
@@ -109,17 +109,17 @@ function Pt(o, c, l, r, m, t) {
     );
   }), Float32Array.from(e);
 }
-async function Zt(o, c, l = 2, r = 0.1, m = 0) {
+async function zt(o, i, l = 2, r = 0.1, p = 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 = c !== void 0 ? b(
-    (c - n.measuredTop) / n.measuredLength,
+  const m = i !== void 0 ? b(
+    (i - n.measuredTop) / n.measuredLength,
     0,
     1
   ) : 0, s = t.filter(
-    (a) => a.mdBottomMsl > n.measuredTop && (c === void 0 || a.mdBottomMsl > c)
+    (a) => a.mdBottomMsl > n.measuredTop && (i === void 0 || a.mdBottomMsl > i)
   ).map((a) => ({
     ...a,
     mdTopMsl: Math.max(a.mdTopMsl, n.measuredTop)
@@ -127,14 +127,14 @@ async function Zt(o, c, l = 2, r = 0.1, m = 0) {
     (a, f) => a.outerDiameter - f.outerDiameter || a.mdTopMsl - f.mdTopMsl
   );
   if (s.length === 0) return null;
-  const g = 1 / n.measuredLength, u = [], i = [];
+  const g = 1 / n.measuredLength, u = [], c = [];
   return s.forEach((a) => {
     const f = b(
       a.mdBottomMsl - a.mdTopMsl,
       1e-4,
       n.measuredLength
     ), h = Math.max(
-      p,
+      m,
       b(
         (a.mdTopMsl - n.measuredTop) / n.measuredLength,
         0,
@@ -146,47 +146,47 @@ async function Zt(o, c, l = 2, r = 0.1, m = 0) {
       1
     ), d = a.outerDiameter / 2, y = a.innerDiameter ? a.innerDiameter / 2 : d * 0.95, T = [];
     if (a.isShoe) {
-      const $ = d * l;
+      const L = d * l;
       T.push(
         [h, d],
         [h + (w - h) / 4, d],
-        [w, $]
+        [w, L]
       );
     } 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 = d - (d - y) / 4;
+      T.push([h, L]);
+      const I = Math.min((d - L) * 2, f / 3) * g;
+      T.push([h + I, d]), T.push([w - I, d]), T.push([w, L]);
     }
-    const L = Pt(
+    const $ = Dt(
       n.curve,
       h,
       w,
       T,
       r,
-      m
+      p
     ), M = n.curve.getBoundingBox(h, w);
-    new Tt(new v(...M.min), new v(...M.max)).getBoundingSphere(X), i.push({
+    new Mt(new v(...M.min), new v(...M.max)).getBoundingSphere(U), c.push({
       type: a.type,
       radius: d,
       innerRadius: y,
       length: f,
       top: h,
       bottom: w,
-      attributesBuffer: L,
-      segments: L.length / 12,
+      attributesBuffer: $,
+      segments: $.length / 12,
       boundingSphere: {
-        center: X.center.toArray(),
-        radius: X.radius
+        center: U.center.toArray(),
+        radius: U.radius
       }
-    }), u.push(L.buffer);
-  }), x(i, u);
+    }), u.push($.buffer);
+  }), x(c, u);
 }
-async function zt(o) {
-  const c = await this.get("completion-tools", o);
-  if (!c) return null;
+async function te(o) {
+  const i = await this.get("completion-tools", o);
+  if (!i) 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) => {
+  return r ? i.filter((t) => t.mdBottomMsl > r.measuredTop).map((t) => {
     const e = b(
       (t.mdTopMsl + t.length / 2 - r.measuredTop) / r.measuredLength,
       0,
@@ -201,21 +201,21 @@ async function zt(o) {
     };
   }) : null;
 }
-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,
+function Ft(o, i, l, r, p) {
+  const t = b(i.length, 1e-4, o.measuredLength), e = 1 / o.measuredLength, n = [], m = b(
+    (i.mdTopMsl - o.measuredTop) / o.measuredLength,
     0,
     1
   ), s = b(
-    (c.mdBottomMsl - o.measuredTop) / o.measuredLength,
+    (i.mdBottomMsl - o.measuredTop) / o.measuredLength,
     0,
     1
-  ), 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),
+  ), g = l * ((i.diameterTop || i.diameterBottom) / 2), u = l * ((i.diameterBottom || i.diameterTop) / 2), c = l * ((i.diameterMax || i.diameterTop) / 2), a = Math.min(g, u, c);
+  n.push([m, g]);
+  const f = Math.min((c - a) * 2, t / 3) * e;
+  return c > a && (n.push([m + f, c]), n.push([s - f, c])), n.push([s, u]), O(o.curve, {
+    ...p,
+    from: Math.max(m, r),
     to: s,
     computeLengths: !0,
     radiusModifier: {
@@ -224,38 +224,38 @@ function Dt(o, c, l, r, m) {
     }
   });
 }
-async function te(o, c, l = 16, r = 1, m = 0.1, t = 0) {
+async function ee(o, i, l = 16, r = 1, p = 0.1, t = 0) {
   const e = await this.get("completion-tools", o);
   if (!e) return null;
-  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,
+  const n = await this.get("position-logs", o), m = A(o, n);
+  if (!m) return null;
+  const s = i !== void 0 ? b(
+    (i - m.measuredTop) / m.measuredLength,
     0,
     1
   ) : 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 = {
+    (y) => y.mdBottomMsl > m.measuredTop && (i === void 0 || y.mdBottomMsl > i)
+  ).sort((y, T) => y.mdTopMsl - T.mdTopMsl), u = At(g, (y) => y.category), c = {
     startCap: !0,
     endCap: !0,
     radialSegments: l,
     computeNormals: !0,
     computeUvs: !0,
-    segmentsPerMeter: m,
+    segmentsPerMeter: p,
     simplificationThreshold: t,
     radius: 0
   }, a = [], f = [];
   if (u.forEach((y, T) => {
-    const L = y.map((B) => Dt(
-      p,
+    const $ = y.map((B) => Ft(
+      m,
       B,
       r,
       s,
-      i
+      c
     )).filter((B) => B);
-    f.push(At[T]);
+    f.push(xt[T]);
     const M = Y(
-      L,
+      $,
       !1
     );
     M && a.push(M);
@@ -268,23 +268,23 @@ async function te(o, c, l = 16, r = 1, m = 0.1, t = 0) {
   const [w, d] = E(h);
   return x(w, d);
 }
-async function ee(o, c, l = "MSL", r) {
-  const m = await this.get("position-logs", o);
-  if (!m || m.length < 8) return null;
+async function oe(o, i, l = "MSL", r) {
+  const p = await this.get("position-logs", o);
+  if (!p || p.length < 8) return null;
   let t = 0;
   if (l === "RT") {
     const a = await this.get("wellbore-headers", o);
     a && (t = a.depthReferenceElevation);
   }
-  const e = A(o, m);
+  const e = A(o, p);
   if (!e) return null;
-  const n = m[m.length - 1] + t, s = Math.max(
+  const n = p[p.length - 1] + t, s = Math.max(
     e.measuredTop,
     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;
+  let u = Math.floor(s / i) * i;
+  for (u <= s && (u += i); u < n; )
+    g.push(u), u += i;
   return g.push(n), g.map((a) => {
     const f = b(
       (a - t - e.measuredTop) / e.measuredLength,
@@ -299,45 +299,45 @@ async function ee(o, c, l = "MSL", r) {
     };
   });
 }
-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(
+const D = new v(), H = new v(), J = new v(), Vt = new v(0, 1, 0), F = new P(), Ct = new P().makeRotationX(N), K = new rt();
+async function ne(o, i, l, r = 10) {
+  const p = await st(
     o,
-    c,
+    i,
     this,
     l
   );
-  if (!m) return null;
-  const t = lt(m);
+  if (!p) return null;
+  const t = lt(p);
   if (!t.length) return null;
   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,
+  const m = t.map((c) => {
+    const a = vt(
+      (c.mdMsl - n.measuredTop) / n.measuredLength,
       0,
       1
     );
     return {
-      ...i,
+      ...c,
       position: n.curve.getPointAt(a),
       direction: n.curve.getTangentAt(a)
     };
-  }), s = new Float32Array(p.length * 16), g = new Float32Array(p.length * 3), u = [];
-  return p.forEach((i, a) => {
-    D.set(...i.position), F.identity();
+  }), s = new Float32Array(m.length * 16), g = new Float32Array(m.length * 3), u = [];
+  return m.forEach((c, a) => {
+    D.set(...c.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] = {
+    J.set(f, f, f), H.set(
+      D.x + c.direction[0],
+      D.y + c.direction[1],
+      D.z + c.direction[2]
+    ), F.lookAt(D, H, Vt), F.multiply(Ct), F.setPosition(D), F.scale(J), F.toArray(s, a * 16), K.set(c.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
+      name: `${c.name} ${Bt(c.type)}`,
+      depth: c.mdMsl,
+      tvd: c.tvdMsl,
+      level: c.level,
+      direction: c.direction
     };
   }), x(
     {
@@ -348,80 +348,80 @@ async function oe(o, c, l, r = 10) {
     [s.buffer]
   );
 }
-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 V = new v(), Q = new v(), X = new v(), Rt = new v(0, 1, 0), C = new P(), kt = new P().makeRotationX(N);
+async function se(o, i, l = 1) {
   const r = await this.get(
     "perforations",
     o
   );
   if (!r) return null;
-  const m = await this.get("position-logs", o), t = A(o, m);
+  const p = await this.get("position-logs", o), t = A(o, p);
   if (!t) return null;
-  U.set(
+  X.set(
     Math.max(1, l / 2),
     l,
     Math.max(1, l / 2)
   );
   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);
+    (u) => u.status === "Open" && u.mdBottomMsl > t.measuredTop && (i === void 0 || u.mdBottomMsl > i)
+  ).sort((u, c) => u.mdTopMsl - c.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,
+    const c = n[u];
+    c.mdBottomMsl <= t.measuredTop || (!e.length || e[e.length - 1].bottom !== c.mdTopMsl ? e.push({
+      type: c.type,
+      top: Math.max(t.measuredTop, c.mdTopMsl),
+      bottom: c.mdBottomMsl,
+      density: mt(c.density || 0),
+      phase: c.phase || 0,
       innerDiameter: 0,
       outerDiameter: 0
-    }) : e.length && (e[e.length - 1].bottom = i.mdBottomMsl));
+    }) : e.length && (e[e.length - 1].bottom = c.mdBottomMsl));
   }
-  const p = [];
+  const m = [];
   for (let u = 0; u < e.length; u++) {
-    const i = e[u], a = i.bottom - i.top, f = Math.max(
+    const c = e[u], a = c.bottom - c.top, f = Math.max(
       1,
-      Math.floor(a * i.density)
+      Math.floor(a * c.density)
     ), h = b(
-      (i.top - t.measuredTop) / t.measuredLength,
+      (c.top - t.measuredTop) / t.measuredLength,
       0,
       1
     ), d = (b(
-      (i.bottom - t.measuredTop) / t.measuredLength,
+      (c.bottom - t.measuredTop) / t.measuredLength,
       0,
       1
     ) - h) / f, y = [];
     for (let M = 0; M < f; M++)
       y.push(h + d * M);
     const T = nt(t.curve, y);
-    let L = N;
+    let $ = N;
     for (let M = 0; M < T.length; M++) {
-      const B = T[M], $ = pt(
+      const B = T[M], L = pt(
         gt(B.tangent, [0, -1, 0]),
         B.tangent,
-        L
+        $
       );
-      p.push({
-        name: i.type,
+      m.push({
+        name: c.type,
         position: B.position,
-        normal: $,
+        normal: L,
         tangent: B.tangent
-      }), L += ft(i.phase);
+      }), $ += ft(c.phase);
     }
   }
-  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(
+  const s = new Float32Array(m.length * 16), g = [];
+  for (let u = 0; u < m.length; u++) {
+    const c = m[u];
+    V.set(...c.position), Q.set(
+      V.x + c.normal[0],
+      V.y + c.normal[1],
+      V.z + c.normal[2]
+    ), X.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] = {
+    ), C.identity(), C.lookAt(V, Q, Rt), C.multiply(kt), C.setPosition(V), C.scale(X), C.toArray(s, u * 16), g[u] = {
       id: `${o}_${u}`,
-      name: i.name,
-      direction: i.tangent
+      name: c.name,
+      direction: c.tangent
     };
   }
   return x(
@@ -432,8 +432,8 @@ async function ne(o, c, l = 1) {
     [s.buffer]
   );
 }
-async function se(o, c, l = 0.1, r = 0) {
-  const m = await this.get("position-logs", o), t = A(o, m);
+async function re(o, i, l = 0.1, r = 0) {
+  const p = await this.get("position-logs", o), t = A(o, p);
   if (!t) return null;
   const e = {
     from: 0,
@@ -445,15 +445,15 @@ async function se(o, c, l = 0.1, r = 0) {
     computeUvs: !0,
     segmentsPerMeter: l,
     simplificationThreshold: r,
-    radius: c
-  }, n = W(t.curve, e);
+    radius: i
+  }, n = O(t.curve, e);
   if (!n) return null;
-  const [p, s] = E(n);
-  return x(p, s);
+  const [m, s] = E(n);
+  return x(m, s);
 }
-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);
+const R = new v(), Z = new v(), z = new v(), jt = new v(0, 1, 0), k = new P(), Gt = new P().makeRotationX(N);
+async function ae(o, i, l, r) {
+  const p = await this.get("position-logs", o), t = A(o, p);
   if (!t) return null;
   const e = t.measuredBottom, n = t.measuredLength, s = Math.max(
     t.measuredTop,
@@ -463,16 +463,16 @@ async function re(o, c, l, r) {
   for (u <= s && (u += l); u < e; )
     g.push(u), u += l;
   g.push(e);
-  const i = new Float32Array(g.length * 16), a = [];
+  const c = 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;
+    const T = i + 2 / i;
     z.set(T, T, T), Z.set(
       R.x + y[0],
       R.y + y[1],
       R.z + y[2]
-    ), k.lookAt(R, Z, kt), k.multiply(jt), k.setPosition(R), k.scale(z), k.toArray(i, h * 16), a[h] = {
+    ), k.lookAt(R, Z, jt), k.multiply(Gt), k.setPosition(R), k.scale(z), k.toArray(c, h * 16), a[h] = {
       id: `${o}_${h}`,
       depth: f,
       position: d
@@ -480,19 +480,19 @@ async function re(o, c, l, r) {
   }), x(
     {
       data: a,
-      transformations: i
+      transformations: c
     },
-    [i.buffer]
+    [c.buffer]
   );
 }
-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 j = new v(), tt = new v(), et = new v(), Et = new v(0, 1, 0), G = new P(), It = new P().makeRotationX(N);
+async function ie(o, i, l) {
   const r = await this.get("casings", o);
   if (!r) return null;
-  const m = await this.get("position-logs", o), t = A(o, m);
+  const p = await this.get("position-logs", o), t = A(o, p);
   if (!t) return null;
   const e = r.filter(
-    (s) => s.isShoe && s.mdBottomMsl > t.measuredTop && (c === void 0 || s.mdBottomMsl > c)
+    (s) => s.isShoe && s.mdBottomMsl > t.measuredTop && (i === void 0 || s.mdBottomMsl > i)
   ).map((s) => {
     const g = b(
       (s.mdBottomMsl - t.measuredTop) / t.measuredLength,
@@ -506,7 +506,7 @@ async function ae(o, c, l) {
       direction: t.curve.getTangentAt(g),
       radius: s.outerDiameter / 2
     };
-  }), n = new Float32Array(e.length * 16), p = [];
+  }), n = new Float32Array(e.length * 16), m = [];
   return e.forEach((s, g) => {
     j.set(...s.position), G.identity();
     const u = s.radius * (l || 1);
@@ -514,71 +514,82 @@ async function ae(o, c, l) {
       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] = {
+    ), G.lookAt(j, tt, Et), G.multiply(It), G.setPosition(j), G.scale(et), G.toArray(n, g * 16), m[g] = {
       id: `${o}_${g}`,
       name: s.name,
       direction: s.direction
     };
   }), x(
     {
-      data: p,
+      data: m,
       transformations: n
     },
     [n.buffer]
   );
 }
 const St = -1;
-async function ie(o) {
-  if (!await this.get("surface-meta", o)) return null;
-  const l = await this.get("surface-values", o);
+async function ce(o, i = !1) {
+  const l = await this.get("surface-meta", o);
   if (!l) return null;
-  const r = l;
-  return x({
-    elevationImageBuffer: r
-  }, [r.buffer]);
+  const r = await this.get("surface-values", o);
+  if (!r) return null;
+  const p = r, { header: t } = l, e = {
+    elevationImageBuffer: p
+  }, n = [p.buffer];
+  if (i) {
+    const m = ht(
+      r,
+      t.nx,
+      t.ny,
+      t.xinc,
+      t.yinc
+    );
+    e.normalImageBuffer = m, n.push(m.buffer);
+  }
+  return x(e, n);
 }
-async function ce(o, c = 5) {
+async function ue(o, i = 5) {
   const l = await this.get("surface-meta", o);
   if (!l) return null;
-  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,
+  const r = l.max, p = await this.get("surface-values", o);
+  if (!p) return null;
+  const { header: t } = l, e = new bt(), { positions: n, uvs: m, indices: s } = Lt(
+    p,
     t.nx,
     t.xinc,
     t.yinc,
     St,
-    c
+    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);
+  e.setAttribute("position", new W(n, 3)), e.setAttribute("uv", new W(m, 2)), e.setIndex(new W(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 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;
+async function le(o, i, l = 0, r, p = 0.5, t = 16, e = !1) {
+  const n = await this.get("position-logs", o), m = A(o, n);
+  if (!m) return null;
   const g = {
     from: r !== void 0 ? b(
-      (r - p.measuredTop) / p.measuredLength,
+      (r - m.measuredTop) / m.measuredLength,
       0,
       1
     ) : 0,
-    radius: m,
+    radius: p,
     startCap: !0,
     endCap: !0,
-    segmentsPerMeter: c,
+    segmentsPerMeter: i,
     simplificationThreshold: l,
     computeNormals: !0,
     computeUvs: !0,
     computeLengths: !!e,
     radialSegments: t
-  }, u = W(p.curve, g);
+  }, u = O(m.curve, g);
   if (!u) return null;
-  const [i, a] = E(u);
-  return x(i, a);
+  const [c, a] = E(u);
+  return x(c, a);
 }
-async function le(o, c, l = 250) {
-  const r = await this.get("position-logs", o), m = {
+async function me(o, i, l = 250) {
+  const r = await this.get("position-logs", o), p = {
     main: {
       center: [0, 0, 0],
       radius: 10
@@ -588,52 +599,52 @@ async function le(o, c, l = 250) {
   if (r) {
     const n = A(o, r);
     if (n) {
-      const p = c !== void 0 ? b(
-        (c - n.measuredTop) / n.measuredLength,
+      const m = i !== void 0 ? b(
+        (i - n.measuredTop) / n.measuredLength,
         0,
         1
-      ) : 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 = [
+      ) : 0, s = n.curve.getBoundingBox(m), g = (s.max[0] - s.min[0]) / 2, u = (s.max[1] - s.min[1]) / 2, c = (s.max[2] - s.min[2]) / 2, a = dt([g, u, c]) + l * 2, f = [
         s.min[0] + g,
         s.min[1] + u,
-        s.min[2] + i
+        s.min[2] + c
       ];
-      if (m.main.center = f, m.main.radius = a, l > 0) {
+      if (p.main.center = f, p.main.radius = a, l > 0) {
         const h = Math.max(
           2,
-          Math.ceil((1 - p) * n.curve.length / l)
-        ), w = n.curve.getPoints(h, p, 1), d = [];
+          Math.ceil((1 - m) * n.curve.length / l)
+        ), w = n.curve.getPoints(h, m, 1), d = [];
         w.forEach((y) => {
           d.push({
             center: y,
             radius: l
           });
-        }), m.sampled = d;
+        }), p.sampled = d;
       }
     }
   }
-  const t = new Float32Array(4 + m.sampled.length * 4);
+  const t = new Float32Array(4 + p.sampled.length * 4);
   let e = 0;
-  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;
+  t[e] = p.main.center[0], t[e + 1] = p.main.center[1], t[e + 2] = p.main.center[2], t[e + 3] = p.main.radius, e = 4;
+  for (let n = 0; n < p.sampled.length; n++, e += 4)
+    t[e] = p.sampled[n].center[0], t[e + 1] = p.sampled[n].center[1], t[e + 2] = p.sampled[n].center[2], t[e + 3] = p.sampled[n].radius;
   return x(t, [t.buffer]);
 }
-async function me(o, c, l, r, m, t, e = 0.5, n = 2, p = !0, s = 16, g = 0) {
+async function pe(o, i, l, r, p, t, e = 0.5, n = 2, m = !0, s = 16, g = 0) {
   const u = await st(
     o,
-    c,
+    i,
     this
   );
   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))
+  const c = u.filter(
+    (M) => (t === void 0 || M.type && t.includes(M.type)) && (p === void 0 || p.includes(M.name))
   );
-  if (!i.length) return null;
-  const a = dt(i), f = await this.get("position-logs", o), h = A(o, f);
+  if (!c.length) return null;
+  const a = yt(c), f = await this.get("position-logs", o), h = A(o, f);
   if (!h) return null;
   const w = {
-    startCap: p,
-    endCap: p,
+    startCap: m,
+    endCap: m,
     segmentsPerMeter: l,
     simplificationThreshold: g,
     radialSegments: s,
@@ -643,46 +654,46 @@ async function me(o, c, l, r, m, t, e = 0.5, n = 2, p = !0, s = 16, g = 0) {
     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, {
+      const L = h.getPositionAtDepth(B, !0), I = h.getPositionAtDepth(M.mdMslTo, !0);
+      if (L !== null && I !== null) {
+        const at = n + e, it = new rt(M.color), S = O(h.curve, {
           ...w,
           radius: at,
-          from: $,
-          to: S
+          from: L,
+          to: I
         });
-        if (I?.attributes.position.count) {
-          const H = new Float32Array(
-            I.attributes.position.count * 3
+        if (S?.attributes.position.count) {
+          const q = new Float32Array(
+            S.attributes.position.count * 3
           );
-          for (let _ = 0; _ < I.attributes.position.count; _++)
-            it.toArray(H, _ * 3);
-          I.attributes.color = new O(H, 3), d.push(I);
+          for (let _ = 0; _ < S.attributes.position.count; _++)
+            it.toArray(q, _ * 3);
+          S.attributes.color = new W(q, 3), d.push(S);
         }
       }
     }
   }), !d.length) return null;
   const y = Y(d, !1);
   if (!y) return null;
-  const [T, L] = E(y);
-  return x(T, L);
+  const [T, $] = E(y);
+  return x(T, $);
 }
-async function pe(o, c, l) {
+async function ge(o, i, 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);
+  const p = await this.get("position-logs", o), t = A(o, p);
   if (!t) return null;
   let e = 1;
-  const { measuredTop: n, measuredLength: p, curve: s } = t;
-  if (c === "top")
+  const { measuredTop: n, measuredLength: m, curve: s } = t;
+  if (i === "top")
     e = b(
-      ((l || n) - n) / p,
+      ((l || n) - n) / m,
       0,
       1
     );
-  else if (c === "center") {
-    const u = (l || n) + (p - (l || n)) / 2;
-    e = b((u - n) / p, 0, 1);
+  else if (i === "center") {
+    const u = (l || n) + (m - (l || n)) / 2;
+    e = b((u - n) / m, 0, 1);
   }
   return [{
     id: o,
@@ -691,19 +702,19 @@ async function pe(o, c, l) {
     direction: s.getTangentAt(e)
   }];
 }
-async function ge(o, c = 3, l = 1e3, r = 1e3, m = 0) {
+async function fe(o, i = 3, l = 1e3, r = 1e3, p = 0) {
   const t = {
-    stepSize: c,
+    stepSize: i,
     minSize: l,
     extension: r,
-    defaultExtensionAngle: m
+    defaultExtensionAngle: p
   }, e = await this.get(
     "wellbore-seismic-section",
     o,
     t
   );
   if (e === null || e.trajectory === null) return null;
-  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 = {
+  const { positions: n } = e.trajectory, m = -e.depthRange[0], s = -e.depthRange[1], g = wt(n), u = $t(g, m, s), [c, a] = E(u), f = {
     data: {
       array: e.values,
       width: e.samples[0],
@@ -711,27 +722,27 @@ async function ge(o, c = 3, l = 1e3, r = 1e3, m = 0) {
       min: e.valueRange[0],
       max: e.valueRange[1]
     },
-    geometry: i
+    geometry: c
   }, h = [f.data.array.buffer, ...a];
   return x(f, h);
 }
 export {
-  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
+  me as calculateWellboreBounds,
+  Qt as generateBasicTrajectory,
+  Zt as generateCasingAnnotations,
+  zt as generateCasings,
+  te as generateCompletionToolAnnotations,
+  ee as generateCompletionTools,
+  oe as generateDepthMarkers,
+  ne as generateFormationMarkers,
+  se as generatePerforations,
+  re as generatePerimeterGeometry,
+  ae as generatePositionMarkers,
+  ie as generateShoes,
+  ue as generateSurfaceGeometry,
+  ce as generateSurfaceTexturesData,
+  le as generateTubeTrajectory,
+  pe as generateWellboreFormationColumnGeometries,
+  ge as generateWellboreLabel,
+  fe as generateWellboreSeismicSection
 };