@agrotools1/at-components 0.3.5 → 0.3.6

package/dist/PointCloudWorker-a23b7173.js

@@ -0,0 +1,212 @@
+import { fp as D, B as S, bR as v, b7 as C, fq as x } from "./index-4ead5b97.js";
+import { O as R } from "./quat-c6160033.js";
+import { e as k } from "./quatf64-bec1af25.js";
+import { t as A, n as w } from "./vec3f32-304a6a9c.js";
+import { a as F, b as B, d as U } from "./PointCloudUniqueValueRenderer-8fd8d64d.js";
+import { w as q, l as J, c as N, I as V } from "./I3SBinaryReader-dc3251f3.js";
+import { O as T } from "./orientedBoundingBox-57ea94d0.js";
+import "vue";
+import "./mat3f64-03233387.js";
+import "./vec42-689e76ac.js";
+import "./ColorStop-6fd09765.js";
+import "./VertexAttribute-faad30bf.js";
+import "./mat4f64-cce69db4.js";
+import "./vec4f64-043e974c.js";
+import "./computeTranslationToOriginAndRotation-204021f3.js";
+import "./plane-e6309fb6.js";
+function _(c, t, s, n) {
+  const { rendererJSON: i, isRGBRenderer: p } = c;
+  let r = null, a = null;
+  if (t && p)
+    r = t;
+  else if (t && (i == null ? void 0 : i.type) === "pointCloudUniqueValueRenderer") {
+    a = F.fromJSON(i);
+    const e = a.colorUniqueValueInfos;
+    r = new Uint8Array(3 * n);
+    const f = g(a.fieldTransformType);
+    for (let o = 0; o < n; o++) {
+      const u = (f ? f(t[o]) : t[o]) + "";
+      for (let l = 0; l < e.length; l++)
+        if (e[l].values.includes(u)) {
+          r[3 * o] = e[l].color.r, r[3 * o + 1] = e[l].color.g, r[3 * o + 2] = e[l].color.b;
+          break;
+        }
+    }
+  } else if (t && (i == null ? void 0 : i.type) === "pointCloudStretchRenderer") {
+    a = B.fromJSON(i);
+    const e = a.stops;
+    r = new Uint8Array(3 * n);
+    const f = g(a.fieldTransformType);
+    for (let o = 0; o < n; o++) {
+      const u = f ? f(t[o]) : t[o], l = e.length - 1;
+      if (u < e[0].value)
+        r[3 * o] = e[0].color.r, r[3 * o + 1] = e[0].color.g, r[3 * o + 2] = e[0].color.b;
+      else if (u >= e[l].value)
+        r[3 * o] = e[l].color.r, r[3 * o + 1] = e[l].color.g, r[3 * o + 2] = e[l].color.b;
+      else
+        for (let b = 1; b < e.length; b++)
+          if (u < e[b].value) {
+            const m = (u - e[b - 1].value) / (e[b].value - e[b - 1].value);
+            r[3 * o] = e[b].color.r * m + e[b - 1].color.r * (1 - m), r[3 * o + 1] = e[b].color.g * m + e[b - 1].color.g * (1 - m), r[3 * o + 2] = e[b].color.b * m + e[b - 1].color.b * (1 - m);
+            break;
+          }
+    }
+  } else if (t && (i == null ? void 0 : i.type) === "pointCloudClassBreaksRenderer") {
+    a = U.fromJSON(i);
+    const e = a.colorClassBreakInfos;
+    r = new Uint8Array(3 * n);
+    const f = g(a.fieldTransformType);
+    for (let o = 0; o < n; o++) {
+      const u = f ? f(t[o]) : t[o];
+      for (let l = 0; l < e.length; l++)
+        if (u >= e[l].minValue && u <= e[l].maxValue) {
+          r[3 * o] = e[l].color.r, r[3 * o + 1] = e[l].color.g, r[3 * o + 2] = e[l].color.b;
+          break;
+        }
+    }
+  } else
+    r = new Uint8Array(3 * n).fill(255);
+  if (s && (a != null && a.colorModulation)) {
+    const e = a.colorModulation.minValue, f = a.colorModulation.maxValue, o = 0.3;
+    for (let u = 0; u < n; u++) {
+      const l = s[u], b = l >= f ? 1 : l <= e ? o : o + (1 - o) * (l - e) / (f - e);
+      r[3 * u] = b * r[3 * u], r[3 * u + 1] = b * r[3 * u + 1], r[3 * u + 2] = b * r[3 * u + 2];
+    }
+  }
+  return r;
+}
+function E(c, t) {
+  if (c.encoding == null || c.encoding === "") {
+    const s = q(t, c);
+    if (s.vertexAttributes.position == null)
+      return;
+    const n = J(t, s.vertexAttributes.position), i = s.header.fields, p = [i.offsetX, i.offsetY, i.offsetZ], r = [i.scaleX, i.scaleY, i.scaleZ], a = n.length / 3, e = new Float64Array(3 * a);
+    for (let f = 0; f < a; f++)
+      e[3 * f] = n[3 * f] * r[0] + p[0], e[3 * f + 1] = n[3 * f + 1] * r[1] + p[1], e[3 * f + 2] = n[3 * f + 2] * r[2] + p[2];
+    return e;
+  }
+  if (c.encoding === "lepcc-xyz")
+    return N(t).result;
+}
+function h(c, t, s) {
+  return c != null && c.attributeInfo.useElevation ? t ? z(t, s) : null : c != null && c.attributeInfo.storageInfo ? V(c.attributeInfo.storageInfo, c.buffer, s) : null;
+}
+function z(c, t) {
+  const s = new Float64Array(t);
+  for (let n = 0; n < t; n++)
+    s[n] = c[3 * n + 2];
+  return s;
+}
+function P(c, t, s, n, i) {
+  const p = c.length / 3;
+  let r = 0;
+  for (let a = 0; a < p; a++) {
+    let e = !0;
+    for (let f = 0; f < n.length && e; f++) {
+      const { filterJSON: o } = n[f], u = i[f].values[a];
+      switch (o.type) {
+        case "pointCloudValueFilter": {
+          const l = o.mode === "exclude";
+          o.values.includes(u) === l && (e = !1);
+          break;
+        }
+        case "pointCloudBitfieldFilter": {
+          const l = M(o.requiredSetBits), b = M(o.requiredClearBits);
+          (u & l) === l && !(u & b) || (e = !1);
+          break;
+        }
+        case "pointCloudReturnFilter": {
+          const l = 15 & u, b = u >>> 4 & 15, m = b > 1, $ = l === 1, I = l === b;
+          let y = !1;
+          for (const d of o.includedReturns)
+            if (d === "last" && I || d === "firstOfMany" && $ && m || d === "lastOfMany" && I && m || d === "single" && !m) {
+              y = !0;
+              break;
+            }
+          y || (e = !1);
+          break;
+        }
+      }
+    }
+    e && (s[r] = a, c[3 * r] = c[3 * a], c[3 * r + 1] = c[3 * a + 1], c[3 * r + 2] = c[3 * a + 2], t[3 * r] = t[3 * a], t[3 * r + 1] = t[3 * a + 1], t[3 * r + 2] = t[3 * a + 2], r++);
+  }
+  return r;
+}
+function g(c) {
+  switch (c) {
+    default:
+    case null:
+    case "none":
+      return (t) => t;
+    case "low-four-bit":
+      return (t) => 15 & t;
+    case "high-four-bit":
+      return (t) => (240 & t) >> 4;
+    case "absolute-value":
+      return (t) => Math.abs(t);
+    case "modulo-ten":
+      return (t) => t % 10;
+  }
+}
+function M(c) {
+  let t = 0;
+  for (const s of c || [])
+    t |= 1 << s;
+  return t;
+}
+class X {
+  transform(t) {
+    const s = this._transform(t), n = [s.points.buffer, s.rgb.buffer];
+    s.pointIdFilterMap != null && n.push(s.pointIdFilterMap.buffer);
+    for (const i of s.attributes)
+      "buffer" in i.values && D(i.values.buffer) && i.values.buffer !== s.rgb.buffer && n.push(i.values.buffer);
+    return Promise.resolve({ result: s, transferList: n });
+  }
+  _transform(t) {
+    const s = E(t.schema, t.geometryBuffer);
+    let n = s.length / 3, i = null;
+    const p = new Array(), r = h(t.primaryAttributeData, s, n);
+    t.primaryAttributeData != null && r && p.push({ attributeInfo: t.primaryAttributeData.attributeInfo, values: r });
+    const a = h(t.modulationAttributeData, s, n);
+    t.modulationAttributeData != null && a && p.push({ attributeInfo: t.modulationAttributeData.attributeInfo, values: a });
+    let e = _(t.rendererInfo, r, a, n);
+    if (t.filterInfo && t.filterInfo.length > 0 && t.filterAttributesData != null) {
+      const o = t.filterAttributesData.filter(S).map((u) => {
+        const l = h(u, s, n), b = { attributeInfo: u.attributeInfo, values: l };
+        return p.push(b), b;
+      });
+      i = new Uint32Array(n), n = P(s, e, i, t.filterInfo, o);
+    }
+    for (const o of t.userAttributesData) {
+      const u = h(o, s, n);
+      p.push({ attributeInfo: o.attributeInfo, values: u });
+    }
+    3 * n < e.length && (e = new Uint8Array(e.buffer.slice(0, 3 * n))), this._applyElevationOffsetInPlace(s, n, t.elevationOffset);
+    const f = this._transformCoordinates(s, n, T.fromData(t.obbData), v.fromJSON(t.inSR), v.fromJSON(t.outSR));
+    return { obbData: t.obbData, points: f, rgb: e, attributes: p, pointIdFilterMap: i };
+  }
+  _transformCoordinates(t, s, n, i, p) {
+    if (!C(t, i, 0, t, p, 0, s))
+      throw new Error("Can't reproject");
+    const r = A(n.center), a = w(), e = w(), f = A(n.halfSize);
+    R(O, n.quaternion);
+    const o = new Float32Array(3 * s);
+    for (let u = 0; u < s; u++) {
+      let l = 3 * u;
+      a[0] = t[l] - r[0], a[1] = t[l + 1] - r[1], a[2] = t[l + 2] - r[2], x(e, a, O), f[0] = Math.max(f[0], Math.abs(e[0])), f[1] = Math.max(f[1], Math.abs(e[1])), f[2] = Math.max(f[2], Math.abs(e[2])), o[l++] = a[0], o[l++] = a[1], o[l] = a[2];
+    }
+    return n.halfSize = f, o;
+  }
+  _applyElevationOffsetInPlace(t, s, n) {
+    if (n !== 0)
+      for (let i = 0; i < s; i++)
+        t[3 * i + 2] += n;
+  }
+}
+const O = k();
+function st() {
+  return new X();
+}
+export {
+  st as default
+};

package/dist/PooledRBush-20fefa83.js

@@ -0,0 +1,272 @@
+import { bH as w, cQ as F, cR as A, cS as D } from "./index-4ead5b97.js";
+class N {
+  constructor(t = 9, n) {
+    this._compareMinX = R, this._compareMinY = j, this._toBBox = (e) => e, this._maxEntries = Math.max(4, t || 9), this._minEntries = Math.max(2, Math.ceil(0.4 * this._maxEntries)), n && (typeof n == "function" ? this._toBBox = n : this._initFormat(n)), this.clear();
+  }
+  destroy() {
+    this.clear(), _.prune(), X.prune(), d.prune(), Y.prune();
+  }
+  all(t) {
+    this._all(this._data, t);
+  }
+  search(t, n) {
+    let e = this._data;
+    const i = this._toBBox;
+    if (M(t, e))
+      for (_.clear(); e; ) {
+        for (let s = 0, a = e.children.length; s < a; s++) {
+          const r = e.children[s], o = e.leaf ? i(r) : r;
+          M(t, o) && (e.leaf ? n(r) : S(t, o) ? this._all(r, n) : _.push(r));
+        }
+        e = _.pop();
+      }
+  }
+  collides(t) {
+    let n = this._data;
+    const e = this._toBBox;
+    if (!M(t, n))
+      return !1;
+    for (_.clear(); n; ) {
+      for (let i = 0, s = n.children.length; i < s; i++) {
+        const a = n.children[i], r = n.leaf ? e(a) : a;
+        if (M(t, r)) {
+          if (n.leaf || S(t, r))
+            return !0;
+          _.push(a);
+        }
+      }
+      n = _.pop();
+    }
+    return !1;
+  }
+  load(t) {
+    if (!t.length)
+      return this;
+    if (t.length < this._minEntries) {
+      for (let e = 0, i = t.length; e < i; e++)
+        this.insert(t[e]);
+      return this;
+    }
+    let n = this._build(t.slice(0, t.length), 0, t.length - 1, 0);
+    if (this._data.children.length)
+      if (this._data.height === n.height)
+        this._splitRoot(this._data, n);
+      else {
+        if (this._data.height < n.height) {
+          const e = this._data;
+          this._data = n, n = e;
+        }
+        this._insert(n, this._data.height - n.height - 1, !0);
+      }
+    else
+      this._data = n;
+    return this;
+  }
+  insert(t) {
+    return t && this._insert(t, this._data.height - 1), this;
+  }
+  clear() {
+    return this._data = new B([]), this;
+  }
+  remove(t) {
+    if (!t)
+      return this;
+    let n, e = this._data, i = null, s = 0, a = !1;
+    const r = this._toBBox(t);
+    for (d.clear(), Y.clear(); e || d.length > 0; ) {
+      if (e || (e = d.pop(), i = d.data[d.length - 1], s = Y.pop() ?? 0, a = !0), e.leaf && (n = F(e.children, t, e.children.length, e.indexHint), n !== -1))
+        return e.children.splice(n, 1), d.push(e), this._condense(d), this;
+      a || e.leaf || !S(e, r) ? i ? (s++, e = i.children[s], a = !1) : e = null : (d.push(e), Y.push(s), s = 0, i = e, e = e.children[0]);
+    }
+    return this;
+  }
+  toJSON() {
+    return this._data;
+  }
+  fromJSON(t) {
+    return this._data = t, this;
+  }
+  _all(t, n) {
+    let e = t;
+    for (X.clear(); e; ) {
+      if (e.leaf === !0)
+        for (const i of e.children)
+          n(i);
+      else
+        X.pushArray(e.children);
+      e = X.pop() ?? null;
+    }
+  }
+  _build(t, n, e, i) {
+    const s = e - n + 1;
+    let a = this._maxEntries;
+    if (s <= a) {
+      const l = new B(t.slice(n, e + 1));
+      return x(l, this._toBBox), l;
+    }
+    i || (i = Math.ceil(Math.log(s) / Math.log(a)), a = Math.ceil(s / a ** (i - 1)));
+    const r = new E([]);
+    r.height = i;
+    const o = Math.ceil(s / a), c = o * Math.ceil(Math.sqrt(a));
+    v(t, n, e, c, this._compareMinX);
+    for (let l = n; l <= e; l += c) {
+      const m = Math.min(l + c - 1, e);
+      v(t, l, m, o, this._compareMinY);
+      for (let u = l; u <= m; u += o) {
+        const y = Math.min(u + o - 1, m);
+        r.children.push(this._build(t, u, y, i - 1));
+      }
+    }
+    return x(r, this._toBBox), r;
+  }
+  _chooseSubtree(t, n, e, i) {
+    for (; i.push(n), n.leaf !== !0 && i.length - 1 !== e; ) {
+      let s, a = 1 / 0, r = 1 / 0;
+      for (let o = 0, c = n.children.length; o < c; o++) {
+        const l = n.children[o], m = b(l), u = P(t, l) - m;
+        u < r ? (r = u, a = m < a ? m : a, s = l) : u === r && m < a && (a = m, s = l);
+      }
+      n = s || n.children[0];
+    }
+    return n;
+  }
+  _insert(t, n, e) {
+    const i = this._toBBox, s = e ? t : i(t);
+    d.clear();
+    const a = this._chooseSubtree(s, this._data, n, d);
+    for (a.children.push(t), p(a, s); n >= 0 && d.data[n].children.length > this._maxEntries; )
+      this._split(d, n), n--;
+    this._adjustParentBBoxes(s, d, n);
+  }
+  _split(t, n) {
+    const e = t.data[n], i = e.children.length, s = this._minEntries;
+    this._chooseSplitAxis(e, s, i);
+    const a = this._chooseSplitIndex(e, s, i);
+    if (!a)
+      return void console.log("  Error: assertion failed at PooledRBush._split: no valid split index");
+    const r = e.children.splice(a, e.children.length - a), o = e.leaf ? new B(r) : new E(r);
+    o.height = e.height, x(e, this._toBBox), x(o, this._toBBox), n ? t.data[n - 1].children.push(o) : this._splitRoot(e, o);
+  }
+  _splitRoot(t, n) {
+    this._data = new E([t, n]), this._data.height = t.height + 1, x(this._data, this._toBBox);
+  }
+  _chooseSplitIndex(t, n, e) {
+    let i, s, a;
+    i = s = 1 / 0;
+    for (let r = n; r <= e - n; r++) {
+      const o = f(t, 0, r, this._toBBox), c = f(t, r, e, this._toBBox), l = $(o, c), m = b(o) + b(c);
+      l < i ? (i = l, a = r, s = m < s ? m : s) : l === i && m < s && (s = m, a = r);
+    }
+    return a;
+  }
+  _chooseSplitAxis(t, n, e) {
+    const i = t.leaf ? this._compareMinX : R, s = t.leaf ? this._compareMinY : j;
+    this._allDistMargin(t, n, e, i) < this._allDistMargin(t, n, e, s) && t.children.sort(i);
+  }
+  _allDistMargin(t, n, e, i) {
+    t.children.sort(i);
+    const s = this._toBBox, a = f(t, 0, n, s), r = f(t, e - n, e, s);
+    let o = g(a) + g(r);
+    for (let c = n; c < e - n; c++) {
+      const l = t.children[c];
+      p(a, t.leaf ? s(l) : l), o += g(a);
+    }
+    for (let c = e - n - 1; c >= n; c--) {
+      const l = t.children[c];
+      p(r, t.leaf ? s(l) : l), o += g(r);
+    }
+    return o;
+  }
+  _adjustParentBBoxes(t, n, e) {
+    for (let i = e; i >= 0; i--)
+      p(n.data[i], t);
+  }
+  _condense(t) {
+    for (let n = t.length - 1; n >= 0; n--) {
+      const e = t.data[n];
+      if (e.children.length === 0)
+        if (n > 0) {
+          const i = t.data[n - 1], s = i.children;
+          s.splice(F(s, e, s.length, i.indexHint), 1);
+        } else
+          this.clear();
+      else
+        x(e, this._toBBox);
+    }
+  }
+  _initFormat(t) {
+    const n = ["return a", " - b", ";"];
+    this._compareMinX = new Function("a", "b", n.join(t[0])), this._compareMinY = new Function("a", "b", n.join(t[1])), this._toBBox = new Function("a", "return {minX: a" + t[0] + ", minY: a" + t[1] + ", maxX: a" + t[2] + ", maxY: a" + t[3] + "};");
+  }
+}
+function x(h, t) {
+  f(h, 0, h.children.length, t, h);
+}
+function f(h, t, n, e, i) {
+  i || (i = new B([])), i.minX = 1 / 0, i.minY = 1 / 0, i.maxX = -1 / 0, i.maxY = -1 / 0;
+  for (let s, a = t; a < n; a++)
+    s = h.children[a], p(i, h.leaf ? e(s) : s);
+  return i;
+}
+function p(h, t) {
+  h.minX = Math.min(h.minX, t.minX), h.minY = Math.min(h.minY, t.minY), h.maxX = Math.max(h.maxX, t.maxX), h.maxY = Math.max(h.maxY, t.maxY);
+}
+function R(h, t) {
+  return h.minX - t.minX;
+}
+function j(h, t) {
+  return h.minY - t.minY;
+}
+function b(h) {
+  return (h.maxX - h.minX) * (h.maxY - h.minY);
+}
+function g(h) {
+  return h.maxX - h.minX + (h.maxY - h.minY);
+}
+function P(h, t) {
+  return (Math.max(t.maxX, h.maxX) - Math.min(t.minX, h.minX)) * (Math.max(t.maxY, h.maxY) - Math.min(t.minY, h.minY));
+}
+function $(h, t) {
+  const n = Math.max(h.minX, t.minX), e = Math.max(h.minY, t.minY), i = Math.min(h.maxX, t.maxX), s = Math.min(h.maxY, t.maxY);
+  return Math.max(0, i - n) * Math.max(0, s - e);
+}
+function S(h, t) {
+  return h.minX <= t.minX && h.minY <= t.minY && t.maxX <= h.maxX && t.maxY <= h.maxY;
+}
+function M(h, t) {
+  return t.minX <= h.maxX && t.minY <= h.maxY && t.maxX >= h.minX && t.maxY >= h.minY;
+}
+function v(h, t, n, e, i) {
+  const s = [t, n];
+  for (; s.length; ) {
+    const a = s.pop(), r = s.pop();
+    if (a - r <= e)
+      continue;
+    const o = r + Math.ceil((a - r) / e / 2) * e;
+    A(h, o, r, a, i), s.push(r, o, o, a);
+  }
+}
+const _ = new w(), X = new w(), d = new w(), Y = new w({ deallocator: void 0 });
+class I {
+  constructor() {
+    this.minX = 1 / 0, this.minY = 1 / 0, this.maxX = -1 / 0, this.maxY = -1 / 0;
+  }
+}
+class H extends I {
+  constructor() {
+    super(...arguments), this.height = 1, this.indexHint = new D();
+  }
+}
+class B extends H {
+  constructor(t) {
+    super(), this.children = t, this.leaf = !0;
+  }
+}
+class E extends H {
+  constructor(t) {
+    super(), this.children = t, this.leaf = !1;
+  }
+}
+export {
+  N as s
+};