@realsee/dnalogel 3.69.13-alpha-2 → 3.69.13-alpha.1

package/libs/shared-utils/Object3DHelper/utils/dashGuide.js

@@ -1,123 +0,0 @@
-var N = Object.defineProperty;
-var C = Object.getOwnPropertySymbols;
-var Q = Object.prototype.hasOwnProperty, X = Object.prototype.propertyIsEnumerable;
-var b = Math.pow, L = (n, t, e) => t in n ? N(n, t, { enumerable: !0, configurable: !0, writable: !0, value: e }) : n[t] = e, f = (n, t) => {
-  for (var e in t || (t = {}))
-    Q.call(t, e) && L(n, e, t[e]);
-  if (C)
-    for (var e of C(t))
-      X.call(t, e) && L(n, e, t[e]);
-  return n;
-};
-var P = (n, t, e) => (L(n, typeof t != "symbol" ? t + "" : t, e), e);
-import * as u from "three";
-function E(n, t, e) {
-  const l = (t == null ? void 0 : t.clientWidth) || 1280, s = (t == null ? void 0 : t.clientHeight) || 720, c = e.clone().project(n), i = (c.x + 1) * 0.5 * l, r = (1 - (c.y + 1) * 0.5) * s;
-  return new u.Vector2(i, r);
-}
-function A(n, t, e, l) {
-  const s = l.clone().normalize(), c = 1, i = e.clone().sub(s.clone().multiplyScalar(c)), r = e.clone().add(s.clone().multiplyScalar(c)), h = E(n, t, i), o = E(n, t, r), d = h.distanceTo(o);
-  return d < 1e-3 ? void 0 : 2 * c / d;
-}
-function j(n, t) {
-  let e = 10, l = 10;
-  const s = n.isPerspectiveCamera, c = n.isOrthographicCamera;
-  if (s) {
-    const a = n, m = a.position.distanceTo(t), g = a.fov * Math.PI / 180;
-    l = 2 * Math.tan(g / 2) * m, e = l * a.aspect;
-  } else if (c) {
-    const a = n;
-    e = Math.abs(a.right - a.left), l = Math.abs(a.top - a.bottom);
-  }
-  const i = Math.sqrt(e * e + l * l), r = i * 0.8, h = Math.min(e, l) * 0.25, o = i * 1.2;
-  return Math.max(h, Math.min(r, o));
-}
-function I(n, t, e, l, s) {
-  var g, x, p, y;
-  const c = (t == null ? void 0 : t.clientWidth) || 1280, i = (t == null ? void 0 : t.clientHeight) || 720, h = Math.sqrt(c * c + i * i) * ((g = s == null ? void 0 : s.lengthFactorPx) != null ? g : 1.5), o = (x = s == null ? void 0 : s.dashPx) != null ? x : 3, d = (p = s == null ? void 0 : s.gapPx) != null ? p : 2, a = A(n, t, e, l);
-  return a ? { length: h * a, dashPx: o, gapPx: d } : { length: j(n, e) * ((y = s == null ? void 0 : s.lengthFactorPx) != null ? y : 1.5), dashPx: o, gapPx: d };
-}
-function q(n, t, e, l, s, c, i, r) {
-  var z, W, v, B, F;
-  const h = l.clone().normalize(), o = s, d = [];
-  let a = -o, m = 0;
-  const g = Math.sqrt(b((t == null ? void 0 : t.clientWidth) || 1280, 2) + b((t == null ? void 0 : t.clientHeight) || 720, 2)), x = (z = A(n, t, e, l)) != null ? z : s / (g * 1.5), p = Math.max(1e-6, c * x), y = Math.max(0, i * x), w = p + y, R = 2 * o, U = w > 0 ? Math.ceil(R / w) : 0, V = Math.max(
-    8,
-    Math.min(
-      (W = r == null ? void 0 : r.segmentsCap) != null ? W : 2048,
-      Math.floor(U * ((v = r == null ? void 0 : r.expectedSegmentsSafety) != null ? v : 1.5) + ((B = r == null ? void 0 : r.expectedSegmentsMargin) != null ? B : 16))
-    )
-  );
-  for (; a < o && m < V; ) {
-    const k = e.clone().add(h.clone().multiplyScalar(a)), J = A(n, t, k, l) || x, G = (F = r == null ? void 0 : r.wppClampFactor) != null ? F : 2, T = Math.max(x / G, Math.min(x * G, J)), H = c * T, K = i * T, O = Math.max(a, -o), D = Math.min(a + H, o);
-    if (D > O) {
-      const M = e.clone().add(h.clone().multiplyScalar(O)), S = e.clone().add(h.clone().multiplyScalar(D));
-      d.push(M.x, M.y, M.z, S.x, S.y, S.z);
-    }
-    a += H + K, m++;
-  }
-  return new Float32Array(d);
-}
-class Z {
-  constructor(t, e, l) {
-    P(this, "camera");
-    P(this, "container");
-    P(this, "defaults");
-    this.camera = t, this.container = e, this.defaults = f({}, l || {});
-  }
-  /** 创建虚线（LineSegments + LineBasicMaterial），控制器负责添加到场景 */
-  create(t, e, l) {
-    var m, g;
-    const s = f(f({}, this.defaults), l || {}), { length: c, dashPx: i, gapPx: r } = I(this.camera, this.container, t, e, s), h = q(this.camera, this.container, t, e, c, i, r, s), o = new u.BufferGeometry();
-    o.setAttribute("position", new u.BufferAttribute(h, 3));
-    const d = new u.LineBasicMaterial({
-      color: (m = s.color) != null ? m : 16777215,
-      depthTest: !1,
-      depthWrite: !1,
-      transparent: !0
-      // 双面线段在 three 中不存在，依赖于 depthTest 关闭与 renderOrder 提升
-    }), a = new u.LineSegments(o, d);
-    return a.renderOrder = (g = s.renderOrder) != null ? g : 1e3, a;
-  }
-  /** 更新已创建的虚线，使其保持像素恒定 */
-  update(t, e, l, s) {
-    const c = f(f({}, this.defaults), s || {}), { length: i, dashPx: r, gapPx: h } = I(this.camera, this.container, e, l, c), o = q(this.camera, this.container, e, l, i, r, h, c), d = t.geometry, a = d.getAttribute("position");
-    a && a.itemSize === 3 && a.array.length === o.length ? (a.array.set(o), a.needsUpdate = !0) : d.setAttribute("position", new u.BufferAttribute(o, 3));
-  }
-  /** 创建无限长直线（Line + LineBasicMaterial），穿过整个平面 */
-  createSolidLine(t, e, l) {
-    const s = f({ color: 16777215, renderOrder: 1e3 }, l || {}), c = e.clone().normalize(), i = this.computeInfiniteLineLength(t), r = t.clone().add(c.clone().multiplyScalar(-i)), h = t.clone().add(c.clone().multiplyScalar(i)), o = new Float32Array([r.x, r.y, r.z, h.x, h.y, h.z]), d = new u.BufferGeometry();
-    d.setAttribute("position", new u.BufferAttribute(o, 3));
-    const a = new u.LineBasicMaterial({
-      color: s.color,
-      depthTest: !1,
-      depthWrite: !1,
-      transparent: !0
-    }), m = new u.Line(d, a);
-    return m.renderOrder = s.renderOrder, m;
-  }
-  /** 更新已创建的直线，使其始终穿过整个平面 */
-  updateSolidLine(t, e, l, s) {
-    const c = l.clone().normalize(), i = this.computeInfiniteLineLength(e), r = e.clone().add(c.clone().multiplyScalar(-i)), h = e.clone().add(c.clone().multiplyScalar(i)), o = new Float32Array([r.x, r.y, r.z, h.x, h.y, h.z]), d = t.geometry, a = d.getAttribute("position");
-    a && a.itemSize === 3 && a.array.length === o.length ? (a.array.set(o), a.needsUpdate = !0) : d.setAttribute("position", new u.BufferAttribute(o, 3)), (s == null ? void 0 : s.color) !== void 0 && t.material.color.setHex(s.color);
-  }
-  /** 计算"无限"直线的长度，确保穿过整个可视区域 */
-  computeInfiniteLineLength(t) {
-    return j(this.camera, t) * 10;
-  }
-  /** 释放虚线的几何与材质 */
-  dispose(t) {
-    if (!t)
-      return;
-    t.geometry.dispose();
-    const e = t.material;
-    Array.isArray(e) ? e.forEach((l) => l.dispose()) : e.dispose();
-  }
-  /** 更新默认配置 */
-  updateDefaults(t) {
-    this.defaults = f(f({}, this.defaults), t);
-  }
-}
-export {
-  Z as DashGuideLine
-};

package/libs/shared-utils/math/quaternionUtils.d.ts

@@ -1,333 +0,0 @@
-import * as THREE from 'three';
-/**
- * 四元数相关的工具函数
- */
-/**
- * 计算从原始四元数到目标四元数的差值四元数
- * @param originQuaternion 原始四元数
- * @param targetQuaternion 目标四元数
- * @returns 差值四元数，满足 originQuaternion * result = targetQuaternion
- *
- * @example
- * ```typescript
- * const q1 = new THREE.Quaternion(0, 0, 0, 1) // 初始旋转
- * const q2 = new THREE.Quaternion().setFromAxisAngle(new THREE.Vector3(0, 1, 0), Math.PI / 4) // 绕Y轴旋转45度
- * const qDiff = calculateQuaternionDifference(q1, q2)
- *
- * // 验证：q1 * qDiff 应该等于 q2
- * const result = q1.clone().multiply(qDiff)
- * console.log('验证结果:', result.equals(q2)) // 应该为 true
- * ```
- */
-export declare function calculateQuaternionDifference(originQuaternion: THREE.Quaternion, targetQuaternion: THREE.Quaternion): THREE.Quaternion;
-/**
- * 将四元数差值应用到对象上
- * @param object3D 要旋转的对象
- * @param quaternionDiff 差值四元数
- * @param rotateCenter 旋转中心点（可选，如果不提供则以对象中心旋转）
- *
- * @example
- * ```typescript
- * const mesh = new THREE.Mesh(geometry, material)
- * const qDiff = calculateQuaternionDifference(currentQuat, targetQuat)
- * applyQuaternionDifference(mesh, qDiff, new THREE.Vector3(0, 0, 0))
- * ```
- */
-export declare function applyQuaternionDifference(object3D: THREE.Object3D, quaternionDiff: THREE.Quaternion, rotateCenter?: THREE.Vector3): void;
-/**
- * 从原始四元数旋转到目标四元数的完整操作
- * @param object3D 要旋转的对象
- * @param targetQuaternion 目标四元数
- * @param rotateCenter 旋转中心点（可选）
- * @returns 应用的差值四元数
- *
- * @example
- * ```typescript
- * const mesh = new THREE.Mesh(geometry, material)
- * const targetQuat = new THREE.Quaternion().setFromAxisAngle(new THREE.Vector3(0, 1, 0), Math.PI / 2)
- * const appliedDiff = rotateToQuaternion(mesh, targetQuat)
- * ```
- */
-export declare function rotateToQuaternion(object3D: THREE.Object3D, targetQuaternion: THREE.Quaternion, rotateCenter?: THREE.Vector3): THREE.Quaternion;
-/**
- * 验证四元数计算是否正确
- * @param originQuaternion 原始四元数
- * @param targetQuaternion 目标四元数
- * @param quaternionDiff 计算得到的差值四元数
- * @param tolerance 容差值（默认为 1e-6）
- * @returns 验证是否通过
- */
-export declare function verifyQuaternionDifference(originQuaternion: THREE.Quaternion, targetQuaternion: THREE.Quaternion, quaternionDiff: THREE.Quaternion, tolerance?: number): boolean;
-/**
- * 获取四元数之间的角度差（弧度）
- * @param q1 第一个四元数
- * @param q2 第二个四元数
- * @returns 角度差（弧度）
- */
-export declare function getQuaternionAngleDifference(q1: THREE.Quaternion, q2: THREE.Quaternion): number;
-/**
- * 从四元数和原始向量反推目标向量
- * @param quaternion 通过setFromUnitVectors(p1, p2)创建的四元数
- * @param p1 原始向量（已知）
- * @returns 目标向量p2
- *
- * @description
- * 当四元数是通过 setFromUnitVectors(p1, p2) 创建时，
- * 可以使用此函数从已知的四元数和p1向量反推出p2向量
- *
- * @example
- * ```typescript
- * // 已知两个向量
- * const p1 = new THREE.Vector3(1, 0, 0).normalize()
- * const p2 = new THREE.Vector3(0, 1, 0).normalize()
- *
- * // 创建四元数
- * const quaternion = new THREE.Quaternion().setFromUnitVectors(p1, p2)
- *
- * // 反推p2（已知quaternion和p1）
- * const reconstructedP2 = reverseVectorFromQuaternion(quaternion, p1)
- *
- * // 验证结果
- * console.log('原始p2:', p2)
- * console.log('反推p2:', reconstructedP2)
- * console.log('是否相等:', p2.distanceTo(reconstructedP2) < 0.0001)
- * ```
- */
-export declare function reverseVectorFromQuaternion(quaternion: THREE.Quaternion, p1: THREE.Vector3): THREE.Vector3;
-/**
- * 验证向量反推的准确性
- * @param originalP1 原始向量p1
- * @param originalP2 原始向量p2
- * @param reconstructedP2 反推得到的p2
- * @param tolerance 容差值（默认为 1e-6）
- * @returns 验证是否通过
- *
- * @example
- * ```typescript
- * const p1 = new THREE.Vector3(1, 0, 0).normalize()
- * const p2 = new THREE.Vector3(0, 1, 0).normalize()
- * const quaternion = new THREE.Quaternion().setFromUnitVectors(p1, p2)
- * const reconstructedP2 = reverseVectorFromQuaternion(quaternion, p1)
- *
- * const isValid = verifyVectorReconstruction(p1, p2, reconstructedP2)
- * console.log('反推验证结果:', isValid)
- * ```
- */
-export declare function verifyVectorReconstruction(originalP1: THREE.Vector3, originalP2: THREE.Vector3, reconstructedP2: THREE.Vector3, tolerance?: number): boolean;
-/**
- * 修改四元数的转动角度并反推计算新的目标向量
- * @param quaternion 原始四元数（从startVector到currentVector的转动）
- * @param startVector 起始向量
- * @param newAngleRadians 新的转动角度（弧度）
- * @returns 新的目标向量
- *
- * @description
- * 这个函数用于修改一个四元数的转动角度，同时保持转动轴不变，
- * 然后计算应用新四元数后startVector会转动到的新位置
- *
- * @example
- * ```typescript
- * // 已知从startVector到currentVector的转动四元数
- * const startVector = new THREE.Vector3(1, 0, 0).normalize()
- * const currentVector = new THREE.Vector3(0, 1, 0).normalize()
- * const quaternion = new THREE.Quaternion().setFromUnitVectors(startVector, currentVector)
- *
- * // 修改转动角度为60度（原来可能是90度）
- * const newAngle = Math.PI / 3 // 60度
- * const newCurrentVector = modifyQuaternionAngleAndReversVector(quaternion, startVector, newAngle)
- *
- * console.log('新的目标向量:', newCurrentVector)
- * ```
- */
-export declare function modifyQuaternionAngleAndReversVector(quaternion: THREE.Quaternion, startVector: THREE.Vector3, newAngleRadians: number): THREE.Vector3;
-/**
- * 从四元数中提取转动轴
- * @param quaternion 四元数
- * @returns 归一化的转动轴向量
- *
- * @description
- * 根据四元数的数学定义：q = [cos(θ/2), sin(θ/2) * axis]
- * 其中 axis 是转动轴的单位向量，θ 是转动角度
- */
-export declare function extractAxisFromQuaternion(quaternion: THREE.Quaternion): THREE.Vector3;
-/**
- * 从四元数中提取转动角度
- * @param quaternion 四元数
- * @returns 转动角度（弧度）
- *
- * @description
- * 根据四元数的数学定义：q = [cos(θ/2), sin(θ/2) * axis]
- * 角度 θ = 2 * acos(|w|)
- */
-export declare function extractAngleFromQuaternion(quaternion: THREE.Quaternion): number;
-/**
- * 修改四元数的转动角度（保持轴不变）
- * @param quaternion 原始四元数
- * @param newAngleRadians 新的转动角度（弧度）
- * @returns 新的四元数
- *
- * @example
- * ```typescript
- * const originalQuat = new THREE.Quaternion().setFromAxisAngle(
- *   new THREE.Vector3(0, 1, 0),
- *   Math.PI / 2 // 90度
- * )
- *
- * // 修改为60度，保持转动轴不变
- * const newQuat = modifyQuaternionAngle(originalQuat, Math.PI / 3)
- * ```
- */
-export declare function modifyQuaternionAngle(quaternion: THREE.Quaternion, newAngleRadians: number): THREE.Quaternion;
-/**
- * 获取四元数的详细信息（轴和角度）
- * @param quaternion 四元数
- * @returns 包含轴向量和角度的对象
- *
- * @example
- * ```typescript
- * const quat = new THREE.Quaternion().setFromAxisAngle(
- *   new THREE.Vector3(0, 1, 0),
- *   Math.PI / 4
- * )
- *
- * const info = getQuaternionInfo(quat)
- * console.log('转动轴:', info.axis)
- * console.log('转动角度（度）:', info.angleDegrees)
- * console.log('转动角度（弧度）:', info.angleRadians)
- * ```
- */
-export declare function getQuaternionInfo(quaternion: THREE.Quaternion): {
-    axis: THREE.Vector3;
-    angleRadians: number;
-    angleDegrees: number;
-};
-/**
- * 获取向量在指定轴方向旋转为0的向量
- * @param startVec 起始向量
- * @param axis 轴向量
- * @returns 移除了在axis方向旋转分量的向量
- *
- * @description
- * 这个函数通过向量投影的方法，移除startVec在axis轴方向上的旋转分量，
- * 返回垂直于axis的投影向量。数学原理：
- * 1. 计算startVec在axis上的投影：projection = axis * (startVec · axis)
- * 2. 从startVec中减去投影得到垂直分量：perpendicular = startVec - projection
- * 3. 垂直分量就是在axis方向旋转为0的向量
- *
- * @example
- * ```typescript
- * // 示例：将一个倾斜的向量投影到垂直于Y轴的平面上
- * const startVec = new THREE.Vector3(1, 1, 1).normalize()
- * const axis = new THREE.Vector3(0, 1, 0) // Y轴
- *
- * const result = getVectorWithZeroRotationOnAxis(startVec, axis)
- * console.log('原始向量:', startVec)
- * console.log('轴向量:', axis)
- * console.log('移除Y轴旋转后的向量:', result)
- *
- * // 验证结果向量与轴垂直
- * const dotProduct = result.dot(axis)
- * console.log('垂直验证(应该接近0):', dotProduct)
- * ```
- */
-export declare function getVectorWithZeroRotationOnAxis(startVec: THREE.Vector3, axis: THREE.Vector3): THREE.Vector3;
-/**
- * 验证向量是否与指定轴垂直
- * @param vector 要验证的向量
- * @param axis 轴向量
- * @param tolerance 容差值（默认为 1e-6）
- * @returns 是否垂直
- *
- * @example
- * ```typescript
- * const startVec = new THREE.Vector3(1, 1, 1)
- * const axis = new THREE.Vector3(0, 1, 0)
- * const result = getVectorWithZeroRotationOnAxis(startVec, axis)
- *
- * const isVertical = isVectorPerpendicularToAxis(result, axis)
- * console.log('是否垂直:', isVertical) // 应该为 true
- * ```
- */
-export declare function isVectorPerpendicularToAxis(vector: THREE.Vector3, axis: THREE.Vector3, tolerance?: number): boolean;
-/**
- * 获取四元数在某个轴向量的旋转角度
- * @param quaternion 四元数
- * @param axis 指定的轴向量
- * @returns 旋转角度（弧度）
- *
- * @description
- * 这个函数计算四元数在指定轴方向上的旋转分量。
- * 通过将四元数分解为轴角表示，然后计算该轴在指定轴上的投影角度。
- *
- * 数学原理：
- * 1. 从四元数中提取转动轴和角度
- * 2. 计算转动轴与指定轴的夹角
- * 3. 根据投影关系计算在指定轴上的旋转角度
- *
- * @example
- * ```typescript
- * // 创建一个绕Y轴旋转45度的四元数
- * const quat = new THREE.Quaternion().setFromAxisAngle(
- *   new THREE.Vector3(0, 1, 0),
- *   Math.PI / 4 // 45度
- * )
- *
- * // 获取在Y轴上的旋转角度
- * const yAxisAngle = getQuaternionAngleOnAxis(quat, new THREE.Vector3(0, 1, 0))
- * console.log('Y轴旋转角度（弧度）:', yAxisAngle)
- * console.log('Y轴旋转角度（度）:', (yAxisAngle * 180) / Math.PI)
- *
- * // 获取在X轴上的旋转角度（应该接近0）
- * const xAxisAngle = getQuaternionAngleOnAxis(quat, new THREE.Vector3(1, 0, 0))
- * console.log('X轴旋转角度（度）:', (xAxisAngle * 180) / Math.PI)
- *
- * // 获取在Z轴上的旋转角度（应该接近0）
- * const zAxisAngle = getQuaternionAngleOnAxis(quat, new THREE.Vector3(0, 0, 1))
- * console.log('Z轴旋转角度（度）:', (zAxisAngle * 180) / Math.PI)
- * ```
- */
-export declare function getQuaternionAngleOnAxis(quaternion: THREE.Quaternion, axis: THREE.Vector3): number;
-/**
- * 获取四元数在某个轴向量的旋转角度（度）
- * @param quaternion 四元数
- * @param axis 指定的轴向量
- * @returns 旋转角度（度）
- *
- * @example
- * ```typescript
- * const quat = new THREE.Quaternion().setFromAxisAngle(
- *   new THREE.Vector3(0, 1, 0),
- *   Math.PI / 4
- * )
- *
- * const yAxisAngleDegrees = getQuaternionAngleOnAxisDegrees(quat, new THREE.Vector3(0, 1, 0))
- * console.log('Y轴旋转角度（度）:', yAxisAngleDegrees) // 应该接近45度
- * ```
- */
-export declare function getQuaternionAngleOnAxisDegrees(quaternion: THREE.Quaternion, axis: THREE.Vector3): number;
-/**
- * 获取四元数在多个轴上的旋转角度
- * @param quaternion 四元数
- * @param axes 轴向量数组
- * @returns 包含各轴旋转角度的对象
- *
- * @example
- * ```typescript
- * const quat = new THREE.Quaternion().setFromAxisAngle(
- *   new THREE.Vector3(0, 1, 0),
- *   Math.PI / 4
- * )
- *
- * const axes = [
- *   new THREE.Vector3(1, 0, 0), // X轴
- *   new THREE.Vector3(0, 1, 0), // Y轴
- *   new THREE.Vector3(0, 0, 1)  // Z轴
- * ]
- *
- * const angles = getQuaternionAnglesOnAxes(quat, axes)
- * console.log('X轴角度:', angles[0], '度')
- * console.log('Y轴角度:', angles[1], '度')
- * console.log('Z轴角度:', angles[2], '度')
- * ```
- */
-export declare function getQuaternionAnglesOnAxes(quaternion: THREE.Quaternion, axes: THREE.Vector3[]): number[];