@realsee/dnalogel 2.1.0-alpha.2 → 2.1.0-alpha.21

package/libs/GuideLinePlugin/utils/getLineGeometries.js

@@ -1,183 +1,118 @@
-import * as THREE from 'three';
-import { Vector3 } from 'three';
-import getNormals from 'polyline-normals';
-import './getPoint';
-// 定义常量
-const TRIANGLE_NUMBER_OF_RECTANGLE = 2; // 每个矩形有两个三角形
-const VERTEX_NUMBER_OF_TRIANGLE = 3; // 每个三角形有三个顶点
-const AXIS_NUMBER_OF_VERTEX = 3; // 每个顶点有三个轴坐标
-const UV_NUMBER_OF_VERTEX = 2; // 每个顶点有两个 UV 轴坐标
-/**
- * @description: 根据坐标获取平滑曲线
- * @param {Vector3[]} positionList 坐标点数组
- * @param {number} config.unitWidth 宽
- * @param {number} config.unitHeight 高
- * @param {boolean} config.skipPosition 是否越过点位。如果点位上有其他物体，比如点位圆环，可以开启此选项来使越过点位，使其不会重叠显示
- * @return {THREE.BufferGeometry[]} THREE.BufferGeometry[]
- */
-export default function getLineGeometries(positionList, config) {
-    var _a, _b, _c;
-    if (positionList.length < 2) {
-        console.warn('positionList length must be greater than 1');
-        return [];
-    }
-    const unitWidth = (_a = config === null || config === void 0 ? void 0 : config.unitWidth) !== null && _a !== void 0 ? _a : 0.5;
-    const unitHeight = (_b = config === null || config === void 0 ? void 0 : config.unitHeight) !== null && _b !== void 0 ? _b : 0.5;
-    const skipPosition = (_c = config === null || config === void 0 ? void 0 : config.skipPosition) !== null && _c !== void 0 ? _c : false;
-    // 点位组成的平滑曲线
-    const curve = new THREE.CatmullRomCurve3(positionList, false, 'catmullrom', 1);
-    if (skipPosition) {
-        // 曲线切片数
-        const divisions = Math.ceil((curve.getLength() / unitHeight) * 1.5); // 一个箭头切1.5点（切几个随意，越多越精准）
-        const curvePoints = curve.getPoints(divisions);
-        const geometries = [];
-        let startIndex = 0;
-        // curvePoints.forEach((point) => {
-        //   const p1 = getPoint(point, 1)
-        //   ;(window as any).five.scene.add(p1)
-        // })
-        const originPositions = positionList;
-        // eslint-disable-next-line complexity
-        originPositions.forEach((originPosition, index) => {
-            let nearestCurvePointIndex = 0;
-            let distance = 99999999;
-            // 获取离panoIndex最近的曲线点curvePoint
-            curvePoints.forEach((curvePoint, curvePointIndex) => {
-                const curvePointDistanceToOriginPosition = curvePoint.distanceTo(originPosition);
-                if (curvePointDistanceToOriginPosition < distance) {
-                    nearestCurvePointIndex = curvePointIndex;
-                    distance = curvePointDistanceToOriginPosition;
-                }
-            });
-            const nextCurvePoint = curvePoints[nearestCurvePointIndex + 1];
-            const nextCurvePointDistanceToOriginPosition = nextCurvePoint === null || nextCurvePoint === void 0 ? void 0 : nextCurvePoint.distanceTo(originPosition);
-            const lastCurvePoint = curvePoints[nearestCurvePointIndex - 1];
-            const lastCurvePointDistanceToOriginPosition = lastCurvePoint === null || lastCurvePoint === void 0 ? void 0 : lastCurvePoint.distanceTo(originPosition);
-            if (nearestCurvePointIndex > startIndex && nearestCurvePointIndex - startIndex > 1) {
-                let endIndex = nearestCurvePointIndex;
-                // endIndex
-                if (lastCurvePoint !== undefined && lastCurvePointDistanceToOriginPosition > 0.8) {
-                    endIndex = nearestCurvePointIndex + 1;
-                }
-                if (lastCurvePoint !== undefined &&
-                    lastCurvePointDistanceToOriginPosition > 0.2 &&
-                    lastCurvePointDistanceToOriginPosition < 0.3) {
-                    endIndex = nearestCurvePointIndex;
-                }
-                else if (distance > 0.2 && distance < 0.3) {
-                    endIndex = nearestCurvePointIndex + 1;
-                }
-                // end
-                // startIndex
-                let _startIndex = startIndex;
-                if (nextCurvePoint !== undefined &&
-                    nextCurvePointDistanceToOriginPosition > 0.2 &&
-                    nextCurvePointDistanceToOriginPosition < 0.3) {
-                    _startIndex = startIndex + 1;
-                }
-                else if (distance > 0.2 && distance < 0.3) {
-                    _startIndex = startIndex;
-                }
-                if (curvePoints[_startIndex] && curvePoints[_startIndex + 1]) {
-                    const pano = originPositions[index - 1];
-                    if (pano) {
-                        if (pano.equals(curvePoints[_startIndex]))
-                            _startIndex += 1;
-                        else {
-                            const normal = new Vector3().subVectors(curvePoints[_startIndex + 1], curvePoints[_startIndex]);
-                            const panoPosition = new Vector3().subVectors(pano, curvePoints[_startIndex]);
-                            const isBehind = normal.angleTo(panoPosition) < Math.PI / 2;
-                            if (isBehind)
-                                _startIndex += 1;
-                        }
-                    }
-                    // const p0 = getPoint(pano, 0)
-                    // const p1 = getPoint(curvePoints[_startIndex]!, 1)
-                    // const p2 = getPoint(curvePoints[_startIndex + 1]!, 2)
-                    // ;(window as any).five.scene.add(p0, p1, p2)
-                }
-                // end
-                if (endIndex < _startIndex || endIndex - _startIndex <= 1)
-                    return;
-                const slicedCurvePoints = curvePoints.slice(_startIndex, endIndex);
-                const geometry = getLineGeometry(slicedCurvePoints, unitWidth, unitHeight);
-                geometries.push(geometry);
-                startIndex = nearestCurvePointIndex;
-            }
-        });
-        return geometries;
-    }
+import * as B from "three";
+import { Vector3 as z } from "three";
+var U = {}, D = H;
+function H(e, t, r) {
+  return e[0] = t[0] + r[0], e[1] = t[1] + r[1], e;
+}
+var k = q;
+function q(e, t, r) {
+  return e[0] = t, e[1] = r, e;
+}
+var S = W;
+function W(e, t) {
+  var r = t[0], o = t[1], i = r * r + o * o;
+  return i > 0 && (i = 1 / Math.sqrt(i), e[0] = t[0] * i, e[1] = t[1] * i), e;
+}
+var Y = Z;
+function Z(e, t, r) {
+  return e[0] = t[0] - r[0], e[1] = t[1] - r[1], e;
+}
+var j = J;
+function J(e, t) {
+  return e[0] * t[0] + e[1] * t[1];
+}
+var K = D, O = k, C = S, Q = Y, ee = j, V = [0, 0];
+U.computeMiter = function(t, r, o, i, a) {
+  return K(t, o, i), C(t, t), O(r, -t[1], t[0]), O(V, -o[1], o[0]), a / ee(r, V);
+};
+U.normal = function(t, r) {
+  return O(t, -r[1], r[0]), t;
+};
+U.direction = function(t, r, o) {
+  return Q(t, r, o), C(t, t), t;
+};
+var f = U, b = [0, 0], P = [0, 0], F = [0, 0], A = [0, 0], te = function(e, t) {
+  var r = null, o = [];
+  t && (e = e.slice(), e.push(e[0]));
+  for (var i = e.length, a = 1; a < i; a++) {
+    var y = e[a - 1], M = e[a], x = a < e.length - 1 ? e[a + 1] : null;
+    if (f.direction(b, M, y), r || (r = [0, 0], f.normal(r, b)), a === 1 && L(o, r, 1), !x)
+      f.normal(r, b), L(o, r, 1);
     else {
-        // 曲线切片数
-        const divisions = Math.ceil(curve.getLength()); // 一米切一个点
-        const curvePoints = curve.getPoints(divisions);
-        const geometry = getLineGeometry(curvePoints, unitWidth, unitHeight);
-        return [geometry];
+      f.direction(P, x, M);
+      var h = f.computeMiter(F, A, b, P, 1);
+      L(o, A, h);
     }
+  }
+  if (e.length > 2 && t) {
+    var c = e[i - 2], E = e[0], l = e[1];
+    f.direction(b, E, c), f.direction(P, l, E), f.normal(r, b);
+    var v = f.computeMiter(F, A, b, P, 1);
+    o[0][0] = A.slice(), o[i - 1][0] = A.slice(), o[0][1] = v, o[i - 1][1] = v, o.pop();
+  }
+  return o;
+};
+function L(e, t, r) {
+  e.push([[t[0], t[1]], r]);
 }
-function getLineGeometry(curvePoints, unitWidth, unitHeight) {
-    const halfUnitWidth = unitWidth / 2;
-    const aspect = unitHeight / unitWidth; // 纵横比 height / width
-    const curvePointsLength = curvePoints.length;
-    const normals = getNormals(curvePoints.map((p) => [p.x, p.z])); // curvePoints：每个点切线的向量「二维」
-    const rectangleNumber = curvePoints.length - 1; // 曲线上 N 个点，构成了 N - 1 个矩形
-    const indexNumber = rectangleNumber * TRIANGLE_NUMBER_OF_RECTANGLE * VERTEX_NUMBER_OF_TRIANGLE;
-    const verticesNumber = 2 * curvePointsLength; // 顶点数量（包含公用）：每个曲线点对应两个顶点，N 个 点有 2N 个顶点
-    const positionNumber = verticesNumber * AXIS_NUMBER_OF_VERTEX; // 坐标点数量
-    const uvNumber = verticesNumber * UV_NUMBER_OF_VERTEX; // uv 数量
-    const index = new Uint32Array(indexNumber);
-    const positions = new Float32Array(positionNumber);
-    const uv = new Float32Array(uvNumber);
-    curvePoints.forEach((point, i) => {
-        // if (i === curvePoints.length - 1) {
-        //   const p1 = getPoint(point, 1)
-        //   ;(window as any).five.scene.add(p1)
-        // } else {
-        //   // const p1 = getPoint(point, 0)
-        //   // ;(window as any).five.scene.add(p1)
-        // }
-        if (i === 0) {
-            // const p1 = getPoint(point, 3)
-            // ;(window as any).five.scene.add(p1)
-        }
-        else {
-            // const p1 = getPoint(point, 0)
-            // ;(window as any).five.scene.add(p1)
+const ne = 2, re = 3, oe = 3, se = 2;
+function ce(e, t) {
+  var y, M, x;
+  if (e.length < 2)
+    return console.warn("positionList length must be greater than 1"), [];
+  const r = (y = t == null ? void 0 : t.unitWidth) != null ? y : 0.5, o = (M = t == null ? void 0 : t.unitHeight) != null ? M : 0.5, i = (x = t == null ? void 0 : t.skipPanoIndexMesh) != null ? x : !1, a = new B.CatmullRomCurve3(e, !1, "catmullrom", 1);
+  if (i) {
+    const h = Math.ceil(a.getLength() / o * 1.5), c = a.getPoints(h), E = [];
+    let l = 0;
+    const v = e;
+    return v.forEach((m, I) => {
+      let u = 0, n = 99999999;
+      c.forEach((d, s) => {
+        const g = d.distanceTo(m);
+        g < n && (u = s, n = g);
+      });
+      const _ = c[u + 1], R = _ == null ? void 0 : _.distanceTo(m), N = c[u - 1], T = N == null ? void 0 : N.distanceTo(m);
+      if (u > l && u - l > 1) {
+        let d = u;
+        N !== void 0 && T > 0.8 && (d = u + 1), N !== void 0 && T > 0.2 && T < 0.3 ? d = u : n > 0.2 && n < 0.3 && (d = u + 1);
+        let s = l;
+        if (_ !== void 0 && R > 0.2 && R < 0.3 ? s = l + 1 : n > 0.2 && n < 0.3 && (s = l), c[s] && c[s + 1]) {
+          const w = v[I - 1];
+          if (w)
+            if (w.equals(c[s]))
+              s += 1;
+            else {
+              const X = new z().subVectors(c[s + 1], c[s]), $ = new z().subVectors(w, c[s]);
+              X.angleTo($) < Math.PI / 2 && (s += 1);
+            }
         }
-    });
-    let totalLength = 0;
-    for (let i = 0; i < curvePoints.length; i++) {
-        const [nx, nz] = normals[i][0];
-        const curvePoint = curvePoints[i];
-        const { x: curvePointX, y: curvePointY, z: curvePointZ } = curvePoint;
-        // vertices[2i]
-        const vertices2i = new Vector3(curvePointX + nx * halfUnitWidth, curvePointY + 0.05, curvePointZ + nz * halfUnitWidth);
-        positions[i * 6 + 0] = vertices2i.x;
-        positions[i * 6 + 1] = vertices2i.y;
-        positions[i * 6 + 2] = vertices2i.z;
-        // vertices[2i + 1]
-        const vertices2i1 = new Vector3(curvePointX - nx * halfUnitWidth, curvePointY + 0.05, curvePointZ - nz * halfUnitWidth);
-        positions[i * 6 + 3] = vertices2i1.x;
-        positions[i * 6 + 4] = vertices2i1.y;
-        positions[i * 6 + 5] = vertices2i1.z;
-        totalLength += i > 0 ? curvePoints[i - 1].clone().sub(curvePoints[i]).length() : 0;
-        const end = totalLength / unitWidth / aspect;
-        uv[i * 4 + 0] = 0;
-        uv[i * 4 + 1] = end;
-        uv[i * 4 + 2] = 1;
-        uv[i * 4 + 3] = end;
-        if (i === curvePoints.length - 1)
-            continue;
-        index[i * 6 + 0] = i * 2 + 0;
-        index[i * 6 + 1] = i * 2 + 2;
-        index[i * 6 + 2] = i * 2 + 1;
-        index[i * 6 + 3] = i * 2 + 2;
-        index[i * 6 + 4] = i * 2 + 3;
-        index[i * 6 + 5] = i * 2 + 1;
-    }
-    const geometry = new THREE.BufferGeometry();
-    geometry.setAttribute('position', new THREE.BufferAttribute(positions, 3));
-    geometry.setAttribute('uv', new THREE.BufferAttribute(uv, 2));
-    geometry.setIndex(new THREE.BufferAttribute(index, 1));
-    return geometry;
+        if (d < s || d - s <= 1)
+          return;
+        const g = c.slice(s, d), p = G(g, r, o);
+        E.push(p), l = u;
+      }
+    }), E;
+  } else {
+    const h = Math.ceil(a.getLength()), c = a.getPoints(h);
+    return [G(c, r, o)];
+  }
+}
+function G(e, t, r) {
+  const o = t / 2, i = r / t, a = e.length, y = te(e.map((n) => [n.x, n.z])), x = (e.length - 1) * ne * re, h = 2 * a, c = h * oe, E = h * se, l = new Uint32Array(x), v = new Float32Array(c), m = new Float32Array(E);
+  e.forEach((n, _) => {
+  });
+  let I = 0;
+  for (let n = 0; n < e.length; n++) {
+    const [_, R] = y[n][0], N = e[n], { x: T, y: d, z: s } = N, g = new z(T + _ * o, d + 0.05, s + R * o);
+    v[n * 6 + 0] = g.x, v[n * 6 + 1] = g.y, v[n * 6 + 2] = g.z;
+    const p = new z(T - _ * o, d + 0.05, s - R * o);
+    v[n * 6 + 3] = p.x, v[n * 6 + 4] = p.y, v[n * 6 + 5] = p.z, I += n > 0 ? e[n - 1].clone().sub(e[n]).length() : 0;
+    const w = I / t / i;
+    m[n * 4 + 0] = 0, m[n * 4 + 1] = w, m[n * 4 + 2] = 1, m[n * 4 + 3] = w, n !== e.length - 1 && (l[n * 6 + 0] = n * 2 + 0, l[n * 6 + 1] = n * 2 + 2, l[n * 6 + 2] = n * 2 + 1, l[n * 6 + 3] = n * 2 + 2, l[n * 6 + 4] = n * 2 + 3, l[n * 6 + 5] = n * 2 + 1);
+  }
+  const u = new B.BufferGeometry();
+  return u.setAttribute("position", new B.BufferAttribute(v, 3)), u.setAttribute("uv", new B.BufferAttribute(m, 2)), u.setIndex(new B.BufferAttribute(l, 1)), u;
 }
+export {
+  ce as default
+};

package/libs/GuideLinePlugin/utils/getPoint.js

@@ -1,23 +1,18 @@
-import * as THREE from 'three';
-const meshes = [];
-export default function getPoint(position = new THREE.Vector3(1, 1, 1), colorIndex = 0) {
-    const geometry = new THREE.SphereGeometry(0.02, 16, 16);
-    const materials = [
-        new THREE.MeshBasicMaterial({ color: 0xffff00 }),
-        new THREE.MeshBasicMaterial({ color: 0xff00ff }),
-        new THREE.MeshBasicMaterial({ color: 0xff0000 }),
-        new THREE.MeshBasicMaterial({ color: 0x00ffff }), // 蓝
-    ];
-    const material = materials[colorIndex];
-    const sphere = new THREE.Mesh(geometry, material);
-    material.depthTest = false;
-    material.transparent = true;
-    material.opacity = 0.6;
-    material.side = THREE.DoubleSide;
-    sphere.position.copy(position);
-    meshes.push(sphere);
-    return sphere;
+import * as e from "three";
+const o = [];
+function c(r = new e.Vector3(1, 1, 1), a = 0) {
+  const n = new e.SphereGeometry(0.02, 16, 16), t = [
+    new e.MeshBasicMaterial({ color: 16776960 }),
+    new e.MeshBasicMaterial({ color: 16711935 }),
+    new e.MeshBasicMaterial({ color: 16711680 }),
+    new e.MeshBasicMaterial({ color: 65535 })
+  ][a], s = new e.Mesh(n, t);
+  return t.depthTest = !1, t.transparent = !0, t.opacity = 0.6, t.side = e.DoubleSide, s.position.copy(r), o.push(s), s;
 }
-export function getAllMesh() {
-    return meshes;
+function l() {
+  return o;
 }
+export {
+  c as default,
+  l as getAllMesh
+};

package/libs/GuideLinePlugin/utils/polyline-normals.d.js

@@ -0,0 +1 @@
+