@aibee/owlly 1.0.25

package/src/owlly/utils/path-utils.ts

@@ -0,0 +1,837 @@
+import smooth from 'chaikin-smooth';
+import Bezier from 'bezier-js';
+import { Externals, NS_THREE } from '../stage/externals';
+import { FloorModel, GroundParameters } from '../element/floor-model';
+import { EventHub } from './event-hub';
+import { OwllyEvents } from './events';
+import { NumberUtils } from './number-utils';
+
+class PathUtils {
+  public static PathMeshOffsetZ = 0.1;
+
+  public static ArrowMeshOffsetZ = 0.2;
+
+  static getAngle(vec0: NS_THREE.Vector2, vec1: NS_THREE.Vector2): number {
+    const v0 = vec0.clone().normalize();
+    const v1 = vec1.clone().normalize();
+    return Math.acos(v0.dot(v1));
+  }
+
+  /**
+   * 路径简化
+   * @param path 路径点集数组
+   * @param ignoreFirst 是否在简化过程中忽略第一个点
+   * @param smoothingOptimization 是否针对平滑对路径进行插值
+   * @param simplifyDistanceThreshold 简化时路径最短保留的距离, 默认为5
+   * @param maximumTurningDegree 简化时三点夹角认定为转弯的最大角度，默认为150
+   * @param smoothingDistance 平滑时使用的转角最大距离
+   */
+  static simplify(
+    path: { x: number; y: number }[],
+    ignoreFirst = false,
+    smoothingOptimization = true,
+    simplifyDistanceThreshold = 5,
+    maximumTurningDegree = 150,
+    smoothingDistance = 3,
+  ): { x: number; y: number }[] {
+    // TODO 目前存在问题
+    const { THREE } = Externals.getInstance();
+    const joints = [];
+    let firstIgnored = !ignoreFirst;
+    joints.push(path[0]);
+    if (path.length < 2) return joints;
+    for (let i = 0; i < path.length - 2; i += 1) {
+      const p0 = path[i];
+      const p1 = path[i + 1];
+      const p2 = path[i + 2];
+      const v0 = new THREE.Vector2(p0.x - p1.x, p0.y - p1.y);
+      const v1 = new THREE.Vector2(p2.x - p1.x, p2.y - p1.y);
+      const deg = PathUtils.getAngle(v0, v1) / Math.PI * 180;
+      const dist = v0.length() + v1.length();
+
+      if (!firstIgnored || (deg < maximumTurningDegree && dist > 0.01) || dist > simplifyDistanceThreshold) {
+        joints.push(path[i + 1]);
+        firstIgnored = true;
+      }
+    }
+    joints.push(path[path.length - 1]);
+    if (!smoothingOptimization) return joints;
+
+    const simplifiedPath = [];
+    simplifiedPath.push(joints[0]);
+    for (let i = 0; i < joints.length - 2; i += 1) {
+      const head = new THREE.Vector2(joints[i].x, joints[i].y);
+      const mid = new THREE.Vector2(joints[i + 1].x, joints[i + 1].y);
+      const tail = new THREE.Vector2(joints[i + 2].x, joints[i + 2].y);
+
+      const halfHeadMidDist = head.distanceTo(mid) / 2;
+      const halfMidTailDist = tail.distanceTo(mid) / 2;
+
+      const curveHead = mid.clone();
+      const curveTail = mid.clone();
+
+      curveHead.add(head.clone().sub(mid).normalize().multiplyScalar(
+        halfHeadMidDist > smoothingDistance ? smoothingDistance / 2 : halfHeadMidDist,
+      ));
+      curveTail.add(tail.clone().sub(mid).normalize().multiplyScalar(
+        halfMidTailDist > smoothingDistance ? smoothingDistance / 2 : halfMidTailDist,
+      ));
+
+      const curveToSmooth: [number, number][] = [
+        [curveHead.x, curveHead.y],
+        [mid.x, mid.y],
+        [curveTail.x, curveTail.y],
+      ];
+      simplifiedPath.push(
+        ...PathUtils.smoothPath(
+          curveToSmooth,
+          smoothingDistance / 25,
+        ).map((p) => ({ x: p[0], y: p[1] })),
+      );
+    }
+    simplifiedPath.push(joints[joints.length - 1]);
+    const checkedPath: { x: number; y: number }[] = [];
+    let lastCheckedPoint: {x: number; y: number};
+    (simplifiedPath as { x: number; y: number }[]).forEach(({ x, y }) => {
+      if (!lastCheckedPoint) {
+        lastCheckedPoint = { x, y };
+        checkedPath.push({ x, y });
+      } else if (!(x === lastCheckedPoint.x && y === lastCheckedPoint.y)) {
+        lastCheckedPoint = { x, y };
+        checkedPath.push({ x, y });
+      }
+    });
+    return checkedPath;
+  }
+
+  static averageStepLength(path: [number, number][]): number {
+    let sum = 0;
+    path.reduce(([x0, y0], [x1, y1]) => {
+      sum += Math.sqrt(((x1 - x0) ** 2) + ((y1 - y0) ** 2));
+      return [x1, y1];
+    });
+    return sum / path.length;
+  }
+
+  static smoothPath(path: [number, number][], threshold = 0.25): [number, number][] {
+    if (PathUtils.averageStepLength(path) < threshold) return path;
+    const result = smooth(path);
+    return PathUtils.smoothPath(result, threshold);
+  }
+
+  static smoothPathBezier(path: [number, number][], bezierLength: number, segment = 10): [number, number][] {
+    const { THREE } = Externals.getInstance();
+
+    const tpath = path.map(([x, y]) => new THREE.Vector2(x, y));
+    PathUtils.mergeSamePoint2(tpath);
+    PathUtils.mergePathSameVectorPoint2(tpath);
+    const segs = [] as THREE.Vector2[][];
+    let seg = [] as THREE.Vector2[];
+    segs.push(seg);
+    const tlength = tpath.length;
+    for (let i = 1; i < tlength; i++) {
+      const q = tpath[i - i];
+      const h = tpath[i];
+      const v = h.clone().sub(q).normalize().multiplyScalar(bezierLength);
+      if (q.distanceTo(h) > bezierLength) {
+        seg.push(q);
+        if (i !== 1) {
+          seg.push(q.clone().add(v));
+        }
+        seg = [] as THREE.Vector2[];
+        segs.push(seg);
+        if (i !== tlength - 1) {
+          seg.push(h.clone().add(v.multiplyScalar(-1)));
+        }
+        seg.push(h);
+      } else {
+        seg.push(q);
+      }
+    }
+
+    let result = [] as [number, number][];
+
+    const tSegs = segs.map((segv) => {
+      const tv = segv.map((v) => [v.x, v.y]);
+      if (tv.length < 3) {
+        return tv;
+      }
+      const bt = [] as number[];
+      tv.forEach((t) => {
+        bt.push(...t);
+      });
+      const bezier = new Bezier(bt);
+      const points = bezier.getLUT(segment);
+      return points.map((p) => [p.x, p.y]);
+    }) as [number, number][][];
+
+    tSegs.forEach((tseg) => {
+      result = result.concat(tseg);
+    });
+
+    return result;
+  }
+
+  // [-0.000750322172, -0.000666618331, 0.668945366, 0.743310898]
+  // [a, b, c, d]
+  // ax + by + cz + d = 0
+  // z = -(ax + by + d) / c
+  static getRenderHeight(expression: number[], x: number, y: number): number {
+    const [a, b, c, d] = expression;
+    const commonHeight = -(a * x + b * y + d) / c + 0.2;
+    return commonHeight;
+  }
+
+  static getPointHash(x: number, y: number, minX: number, minY: number, dist = 1): [number, number] {
+    const tx = x - minX;
+    const ty = y - minY;
+    return [
+      (tx - (tx % dist)) / dist,
+      (ty - (ty % dist)) / dist,
+    ];
+  }
+
+  // TODO
+  /**
+   * @deprecated
+   * @param path 路径点二维坐标数组
+   * @param params 其它可选参数
+   * @param arrowImageRatio 箭头图像的宽高比，用于生成纹理坐标
+   * @param arrowImageURL 箭头图像URL
+   * @param floorModel FloorModel对象，用于计算地面高度坐标
+   * @param groundParams GroundParameters对象，用于计算地面高度坐标
+   * @param color 路劲的颜色
+   * 当存在groundParams时优先用它计算，忽略floorModel
+   */
+  static generatePathMesh(
+    path: { x: number; y: number }[],
+    params?: {
+      viewDistance?: number;
+      gradientDistance?: number;
+      arrowImageRatio?: number;
+      arrowImageURL?: string;
+      floorModel?: FloorModel;
+      groundParams?: GroundParameters;
+      color?: string;
+      dynamicPathEnabled?: boolean;
+      width?: number;
+    },
+  ): {
+    mesh: NS_THREE.Mesh;
+    arrowMeshes: { arrowMesh: NS_THREE.Mesh; index: number }[];
+    newPath: [number, number][];
+    pointMap: Map<string, Map<string, number[][]>>;
+    pathMinX: number;
+    pathMinY: number;
+    progressBuffer: Float32Array;
+    pathDistance: number[];
+  } {
+    const { THREE } = Externals.getInstance();
+    const {
+      viewDistance = 10,
+      gradientDistance = 2,
+      arrowImageRatio = 1,
+      arrowImageURL,
+      floorModel,
+      groundParams,
+      color,
+      dynamicPathEnabled,
+      width = 0.3,
+    } = params || {};
+    // const simplifiedPath = PathUtils.simplify(path, true).map((p) => ({ x: p.x, y: -p.y }));
+    const simplifiedPath = PathUtils.simplify(path, true);
+    // const smoothedPath = PathUtils.smoothPath(simplifiedPath.map((p) => ([p.x, p.y])));
+    const smoothedPath = simplifiedPath.map((p) => ([p.x, p.y]));
+    const centerNormals: NS_THREE.Vector2[] = [];
+    const pathDistance = [0];
+    const pathProgress = [0];
+    smoothedPath.reduce(([x0, y0], [x1, y1], i) => {
+      centerNormals.push(new THREE.Vector2(y0 - y1, x1 - x0).normalize());
+      const len = Math.sqrt(((x0 - x1) ** 2) + ((y0 - y1) ** 2));
+      pathDistance.push(pathDistance[i - 1] + len);
+      return [x1, y1];
+    });
+    for (let i = 0, pathLen = pathDistance.length; i < pathLen; i += 1) {
+      pathProgress[i] = pathDistance[i] / pathDistance[pathLen - 1];
+    }
+
+    const sideAPath: [number, number][] = [];
+    const sideBPath: [number, number][] = [];
+    const halfWidth = width;
+    centerNormals.forEach((n, i) => {
+      if (i === 0) {
+        const [x0, y0] = smoothedPath[0];
+        sideAPath.push([x0 + n.x * halfWidth, y0 + n.y * halfWidth]);
+        sideBPath.push([x0 - n.x * halfWidth, y0 - n.y * halfWidth]);
+        // console.log(`#Path# SideA[${i}]=(${x0 + n.x * halfWidth}, ${y0 + n.y * halfWidth}), SideB[${i}]=(${x0 - n.x * halfWidth}, ${y0 - n.y * halfWidth})`);
+      }
+      const [x, y] = smoothedPath[i + 1];
+      sideAPath.push([x + n.x * halfWidth, y + n.y * halfWidth]);
+      sideBPath.push([x - n.x * halfWidth, y - n.y * halfWidth]);
+      // console.log(`#Path# SideA[${i}+1]=(${x + n.x * halfWidth}, ${y + n.y * halfWidth}), SideB[${i}+1]=(${x - n.x * halfWidth}, ${y - n.y * halfWidth})`);
+    });
+    sideBPath.reverse();
+    const shape = new THREE.Shape();
+    shape.moveTo(...sideAPath[0]);
+    sideAPath.forEach((p, i) => {
+      if (i === 0) return;
+      shape.lineTo(...p);
+    });
+    sideBPath.forEach((p) => {
+      shape.lineTo(...p);
+    });
+    shape.lineTo(...sideAPath[0]);
+
+    const geometry = new THREE.ShapeBufferGeometry(shape);
+    const arrowTexcoordScaleT = arrowImageRatio / halfWidth * 0.5;
+
+    let dynamicPath = false;
+    if (dynamicPathEnabled) {
+      dynamicPath = true;
+    }
+
+    const uniforms: { [uniform: string]: NS_THREE.IUniform } = {
+      // arrowTexture: {
+      //   value: null,
+      // },
+      arrowTexcoordScaleT: {
+        value: arrowTexcoordScaleT,
+      },
+      current: { value: 0.0 },
+      dynamic: { value: dynamicPath },
+      /* eslint-disable @typescript-eslint/camelcase */
+      full_length: { value: pathDistance[pathDistance.length - 1] },
+      view_distance: { value: viewDistance },
+      gradient_distance: { value: gradientDistance },
+      /* eslint-enable @typescript-eslint/camelcase */
+    };
+    if (arrowImageURL) {
+      new THREE.TextureLoader().load(arrowImageURL, (texture: THREE.Texture) => {
+        texture.wrapS = THREE.RepeatWrapping;
+        texture.wrapT = THREE.RepeatWrapping;
+        texture.generateMipmaps = true;
+        texture.minFilter = THREE.LinearMipMapLinearFilter;
+        texture.magFilter = THREE.LinearMipMapLinearFilter;
+        // uniforms.arrowTexture.value = texture;
+        if (texture.image && texture.image.width && texture.image.height) {
+          uniforms.arrowTexcoordScaleT.value = texture.image.width / texture.image.height / halfWidth * 0.5;
+        }
+      });
+    }
+    const material = new THREE.ShaderMaterial({
+      vertexShader: `
+        attribute vec3 a_color;
+        attribute vec2 a_texcoord;
+        attribute float progress;
+        varying float vProgress;
+        varying vec3 vColor;
+        varying vec2 vTexcoord;
+        void main() {
+            gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
+            vProgress = progress;
+            vColor = a_color;
+            vTexcoord = a_texcoord;
+        }
+        `,
+      fragmentShader: `
+        precision mediump float;
+        varying float vProgress;
+        varying vec3 vColor;
+        varying vec2 vTexcoord;
+        uniform float current;
+        uniform bool dynamic;
+        uniform float full_length;
+        uniform float view_distance;
+        uniform float gradient_distance;
+        // uniform sampler2D arrowTexture;
+        uniform float arrowTexcoordScaleT;
+        float alpha;
+        float cur;
+        bool dy;
+        void main() {
+            alpha = 0.8;
+            cur = current;
+            dy = dynamic;
+            if (vProgress < cur) {
+            alpha = 0.0;
+            } else {
+            if (vProgress > cur + view_distance) {
+                alpha = 0.0;
+            } else {
+                if (vProgress > cur + gradient_distance) {
+                  alpha = 0.8;
+                  if (cur > full_length - view_distance) {
+                      cur = full_length - view_distance;
+                  }
+                  if (vProgress > cur + view_distance - gradient_distance) {
+                      alpha = abs(cur + view_distance - vProgress) / gradient_distance * 0.8;
+                  }
+                } else {
+                  alpha = abs(vProgress - cur) / gradient_distance * 0.8;
+                }
+            }
+            }
+
+            // vec4 textureColor = texture2D(arrowTexture, vec2(vTexcoord.s, vTexcoord.t * arrowTexcoordScaleT));
+            // gl_FragColor = vec4((1.0 - textureColor.a) * vColor + textureColor.a * textureColor.rgb, 0.8);
+            if(dy) {
+              gl_FragColor = vec4(vColor,alpha);
+            } else {
+              gl_FragColor = vec4(vColor,0.8);
+            }
+
+        }
+        `,
+      uniforms,
+      side: THREE.DoubleSide,
+      depthTest: !dynamicPath,
+    });
+
+    let minX = Number.MAX_SAFE_INTEGER;
+    let minY = Number.MAX_SAFE_INTEGER;
+    const { array, count } = geometry.attributes.position;
+    for (let i = 0, j = 0; i < count; i += 1, j += 3) {
+      const x = array[j];
+      const y = array[j + 1];
+      if (array[j] < minX) minX = x;
+      if (array[j + 1] < minY) minY = y;
+    }
+    // const { index: indices } = geometry;
+    if (groundParams && groundParams.groundPlane) {
+      for (let i = 0, j = 0; i < count; i += 1, j += 3) {
+        const x = array[j];
+        const y = array[j + 1];
+        let z = 0.5;
+        const groundPoint = FloorModel.intersectWithGroundPlane(new THREE.Vector3(x, y, z), groundParams);
+        if (groundPoint) {
+          z = groundPoint.z + PathUtils.PathMeshOffsetZ;
+        }
+        (array as number[])[j + 2] = z;
+      }
+    } else {
+      const updateZWithFloorModel = (): void => {
+        if (!floorModel || !floorModel.isModelLoaded()) return;
+        for (let i = 0, j = 0; i < count; i += 1, j += 3) {
+          const x = array[j];
+          const y = array[j + 1];
+          let z = 0.5;
+          const groundPoint = floorModel.intersectGround(new THREE.Vector3(x, y, z));
+          // console.info('#PathArrow# groundPoint:', groundPoint);
+          if (groundPoint) {
+            z = groundPoint.z + PathUtils.PathMeshOffsetZ;
+          }
+          (array as number[])[j + 2] = z;
+        }
+        (geometry.attributes.position as THREE.BufferAttribute).needsUpdate = true;
+      };
+
+      if (floorModel && floorModel.isModelLoaded()) {
+        updateZWithFloorModel();
+      }
+      EventHub.on(OwllyEvents.ELEMENT_LOADED, (element: Element) => {
+        if (!(element instanceof FloorModel)) return;
+        if ((element as FloorModel) !== floorModel) return;
+        updateZWithFloorModel();
+      });
+    }
+    (geometry.attributes.position as THREE.BufferAttribute).needsUpdate = true;
+
+    // TODO(jyfang): arrow meshes not needed now
+    const arrowMeshes = [];
+    if (arrowImageURL) {
+      const geom = new THREE.PlaneBufferGeometry(0.5 * halfWidth / 0.3, 0.5 * halfWidth / 0.3);
+      const materialTop = new THREE.MeshBasicMaterial({
+        color: 0xFFFFFF,
+        transparent: true,
+        opacity: 0.8,
+        blending: NS_THREE.NormalBlending,
+        side: NS_THREE.DoubleSide,
+        depthTest: !dynamicPath,
+      });
+      const texture = new THREE.TextureLoader().load(arrowImageURL);
+      texture.needsUpdate = true;
+      materialTop.needsUpdate = true;
+      materialTop.map = texture;
+      const baseArrowMesh = new THREE.Mesh(geom, materialTop);
+      for (let i = 0, threshold = 0.8, pathLen = smoothedPath.length; i < pathLen; i += 1) {
+        if (pathDistance[i] > threshold) {
+          threshold += 0.8;
+          const [x, y] = smoothedPath[i];
+          const { x: nx, y: ny } = centerNormals[i === pathLen - 1 ? i - 1 : i];
+          const newMesh = baseArrowMesh.clone();
+          newMesh.position.set(x, y, -0.5);
+          if (groundParams) {
+            const floorPos = FloorModel.intersectWithGroundPlane(new THREE.Vector3(x, y, 2), groundParams);
+            if (floorPos) {
+              floorPos.z += PathUtils.ArrowMeshOffsetZ;
+              newMesh.position.copy(floorPos);
+            }
+          } else if (floorModel) {
+            const floorPos = floorModel.intersectGround(new THREE.Vector3(x, y, 2));
+            if (floorPos) {
+              floorPos.z += PathUtils.ArrowMeshOffsetZ;
+              newMesh.position.copy(floorPos);
+            }
+          }
+          newMesh.material = materialTop.clone();
+          newMesh.rotateZ(new THREE.Vector2(ny, -nx).angle() - 0.5 * Math.PI);
+          arrowMeshes.push({ arrowMesh: newMesh, index: i });
+        }
+      }
+    }
+
+    const pathMinX = Math.floor(minX);
+    const pathMinY = Math.floor(minY);
+    const pointMap = new Map<string, Map<string, number[][]>>();
+    smoothedPath.forEach(([x, y], i) => {
+      const [row, col] = PathUtils.getPointHash(
+        x, y, pathMinX, pathMinY, 25,
+      );
+      if (!pointMap.has(`${row}`)) pointMap.set(`${row}`, new Map<string, number[][]>());
+      const mapRow = pointMap.get(`${row}`)!;
+      if (!mapRow.has(`${col}`)) mapRow.set(`${col}`, []);
+      mapRow.get(`${col}`)!.push([i, x, y]);
+    });
+
+    // TODO(jyfang): no floating arrows right now.
+    // const floatingArrows = [];
+    // let lastTurnIndex = 0;
+    // for (let i = 0; i < simplifiedPath.length - 2; i += 1) {
+    //     const p0 = simplifiedPath[i];
+    //     const p1 = simplifiedPath[i + 1];
+    //     const p2 = simplifiedPath[i + 2];
+    //     const v0 = new Vector2(p0.x - p1.x, p0.y - p1.y);
+    //     const v1 = new Vector2(p2.x - p1.x, p2.y - p1.y);
+    //     const deg = NavigationPath.getAngle(v0, v1) / Math.PI * 180;
+
+    //     if (deg < 135) {
+    //     const newMesh = this.baseFloatingArrowMesh.clone();
+    //     newMesh.position.setX(p1.x);
+    //     newMesh.position.setY(p1.y);
+    //     newMesh.material = this.baseFloatingArrowMesh.material.clone();
+    //     newMesh.up.set(0, 0, 1);
+    //     newMesh.rotateZ(Math.PI + v1.angle());
+    //     newMesh.rotateX(Math.PI / 2);
+    //     newMesh.renderOrder = 250;
+    //     newMesh.scale.set(2, 2, 2);
+    //     const pathPointIndex = NavigationPath.findNeareastPathPoint(
+    //         p1.x, p1.y, pathMinX, pathMinY, pointMap, true,
+    //     );
+    //     if (pathDistance[pathPointIndex] - pathDistance[lastTurnIndex] > this.jointHintDistance) {
+    //         floatingArrows.push({ mesh: newMesh, index: pathPointIndex });
+    //         lastTurnIndex = pathPointIndex;
+    //     }
+    //     }
+    // }
+
+    const progressBuffer = new Float32Array(count);
+    const colorBuffer = new Float32Array(count * 3);
+    // rgb(255, 140, 0) rgb(240, 68, 55)
+    /* eslint-disable */
+
+    let rs = 1.0, gs = 140 / 255, bs = 0;
+    let rd = 240 / 255, gd = 68 / 255, bd = 55 / 255;
+    if(color)
+    {
+      const colorChange: Array<any> = [];
+      for (let i = 2; i < 8; i += 2) {
+        colorChange.push(parseInt(`0x${color.slice(i, i + 2)}`));
+      }
+      rs = colorChange[0] / 255, gs = colorChange[1] / 255, bs = colorChange[2] / 255;
+      rd = colorChange[0] / 255, gd = colorChange[1] / 255, bd = colorChange[2] / 255;
+    }
+
+
+    const rdiff = rd - rs, gdiff = gd - gs, bdiff = bd - bs;
+    /* eslint-enable */
+    for (let i = 0, j = 0; i < count; i += 1, j += 3) {
+      const px = array[j];
+      const py = array[j + 1];
+      const [row, col] = PathUtils.getPointHash(
+        px, py, pathMinX, pathMinY, 25,
+      );
+      let dist = Number.MAX_SAFE_INTEGER;
+      if (
+        pointMap.has(`${row}`)
+        && pointMap.get(`${row}`)!.has(`${col}`)
+      ) {
+        pointMap.get(`${row}`)!.get(`${col}`)!.forEach(([index, x, y]) => {
+          const d2 = ((px - x) ** 2) + ((py - y) ** 2);
+          if (d2 > dist) return;
+          dist = d2;
+          const l = pathDistance[index];
+          const p = pathProgress[index];
+          progressBuffer[i] = l;
+          colorBuffer[i * 3] = rs + p * rdiff;
+          colorBuffer[i * 3 + 1] = gs + p * gdiff;
+          colorBuffer[i * 3 + 2] = bs + p * bdiff;
+        });
+      }
+    }
+    // const texcoordBuffer = new Float32Array(count * 2);
+    // let x0 = (array[0] + array[(count - 1) * 3]) / 2;
+    // let y0 = (array[1] + array[(count - 1) * 3 + 1]) / 2;
+    // let totalDistance = 0;
+    // for (let i = 0; i < count / 2; i += 1) {
+    //   const x1 = (array[i * 3] + array[(count - 1 - i) * 3]) / 2;
+    //   const y1 = (array[i * 3 + 1] + array[(count - 1 - i) * 3 + 1]) / 2;
+    //   totalDistance += Math.sqrt((x1 - x0) * (x1 - x0) + (y1 - y0) * (y1 - y0));
+    //   x0 = x1;
+    //   y0 = y1;
+
+    //   texcoordBuffer[i * 2] = 0.0;
+    //   texcoordBuffer[(count - 1 - i) * 2] = 1.0;
+
+    //   if (i === count / 2 - 1) {
+    //     texcoordBuffer[i * 2 + 1] = totalDistance;
+    //     texcoordBuffer[(count - 1 - i) * 2 + 1] = totalDistance;
+    //   } else {
+    //     const vAB = new Vector2(
+    //       array[(count - 1 - i) * 3] - array[i * 3],
+    //       array[(count - 1 - i) * 3 + 1] - array[i * 3 + 1],
+    //     );
+    //     const crossProduct = vAB.cross(centerNormals[i]);
+    //     const offset = crossProduct / 2;
+    //     texcoordBuffer[i * 2 + 1] = totalDistance - offset;
+    //     texcoordBuffer[(count - 1 - i) * 2 + 1] = totalDistance + offset;
+    //   }
+
+    //   // if (i % 2 === 0) {
+    //   //   texcoordBuffer[i * 2 + 1] = 0.0;
+    //   //   texcoordBuffer[(count - 1 - i) * 2 + 1] = 0.0;
+    //   // } else {
+    //   //   texcoordBuffer[i * 2 + 1] = 1.0;
+    //   //   texcoordBuffer[(count - 1 - i) * 2 + 1] = 1.0;
+    //   // }
+    // }
+    // geometry.addAttribute('a_texcoord', new BufferAttribute(texcoordBuffer, 2));
+    geometry.addAttribute('progress', new THREE.BufferAttribute(progressBuffer, 1));
+    geometry.addAttribute('a_color', new THREE.BufferAttribute(colorBuffer, 3));
+
+    material.transparent = true;
+    const mesh = new THREE.Mesh(geometry, material);
+    return {
+      mesh,
+      arrowMeshes,
+      newPath: smoothedPath as [number, number][],
+      pointMap,
+      pathMinX,
+      pathMinY,
+      progressBuffer,
+      pathDistance,
+    };
+  }
+
+  static nearlyEqualsV2(v1: NS_THREE.Vector2, v2: NS_THREE.Vector2, tolerance = 0.0001): boolean {
+    return Math.abs(v1.x - v2.x) < tolerance && Math.abs(v1.y - v2.y) < tolerance;
+  }
+
+  static nearlyEqualsV3(v1: NS_THREE.Vector3, v2: NS_THREE.Vector3, tolerance = 0.0001): boolean {
+    return Math.abs(v1.x - v2.x) < tolerance && Math.abs(v1.y - v2.y) < tolerance && Math.abs(v1.z - v2.z) < tolerance;
+  }
+
+  static mergePathSameVectorPoint3(path: NS_THREE.Vector3[], tolerance = 0.0001): void{
+    for (let i = 1; i < path.length - 1; i++) {
+      const qv = path[i].clone().sub(path[i - 1]).normalize();
+      const hv = path[i + 1].clone().sub(path[i]).normalize();
+      if (PathUtils.nearlyEqualsV3(qv, hv, tolerance)) {
+        path.splice(i, 1);
+        i--;
+      }
+    }
+  }
+
+  static mergePathSameVectorPoint2(path: NS_THREE.Vector2[], tolerance = 0.0001): void{
+    for (let i = 1; i < path.length - 1; i++) {
+      const qv = path[i].clone().sub(path[i - 1]).normalize();
+      const hv = path[i + 1].clone().sub(path[i]).normalize();
+      if (PathUtils.nearlyEqualsV2(qv, hv, tolerance)) {
+        path.splice(i, 1);
+        i--;
+      }
+    }
+  }
+
+  static mergeSamePoint3(path: NS_THREE.Vector3[], tolerance = 0.0001): void{
+    for (let i = 1; i < path.length; i++) {
+      if (PathUtils.nearlyEqualsV3(path[i - 1], path[i], tolerance)) {
+        path.splice(i, 1);
+        i--;
+      }
+    }
+  }
+
+  static mergeSamePoint2(path: NS_THREE.Vector2[], tolerance = 0.0001): void{
+    for (let i = 1; i < path.length; i++) {
+      if (PathUtils.nearlyEqualsV2(path[i - 1], path[i], tolerance)) {
+        path.splice(i, 1);
+        i--;
+      }
+    }
+  }
+
+  static splitPathByPoints(
+    path: NS_THREE.Vector3[], closed: boolean, points: NS_THREE.Vector3[], widths: number|number[], tolerance = 0.0001,
+  ): {paths: NS_THREE.Vector3[][]; split: boolean} {
+    const tPaths = [] as NS_THREE.Vector3[][];
+    let tws = [] as number[];
+    if (!Array.isArray(widths)) {
+      points.forEach(() => {
+        tws.push(widths);
+      });
+    } else {
+      tws = widths;
+    }
+    if (closed) {
+      if (!PathUtils.nearlyEqualsV3(path[0], path[path.length - 1], tolerance)) {
+        // eslint-disable-next-line no-param-reassign
+        path = Array.from(path);
+        path.push(path[0]);
+      }
+    }
+    let split = false;
+    const distances = PathUtils.getDistances(path);
+    const subDistances = [] as [number, number][];
+    const end = distances[distances.length - 1];
+    for (let i = 0; i < points.length; i++) {
+      const point = points[i];
+      const width = tws[i];
+      const indexs = PathUtils.findPointIndexByPath(path, point, tolerance);
+      if (indexs.length) {
+        const q = indexs[0];
+        let d = distances[q];
+        const hf = width / 2;
+        if (indexs.length === 2) {
+          d += point.distanceTo(path[q]);
+        }
+        let ms = d - hf;
+        let me = d + hf;
+        if (closed) {
+          if (ms < 0) {
+            subDistances.push([end + ms, end]);
+            ms = 0;
+          }
+          if (me > end) {
+            subDistances.push([0, me - end]);
+            me = end;
+          }
+        }
+        subDistances.push([ms, me]);
+      }
+    }
+    const tDistances = NumberUtils.rangeSub([distances[0], distances[distances.length - 1]], subDistances, tolerance);
+    if (tDistances.length) {
+      split = true;
+      let tp = [] as NS_THREE.Vector3[];
+      tPaths.push(tp);
+      let m = 0;
+      let put = false;
+      let tDistance = tDistances[m++];
+      const pathCount = path.length;
+      for (let i = 0; i < pathCount; i++) {
+        const p = path[i];
+        const d = distances[i];
+        // const dq = distances[i - 1];
+        // const ph = path[(i + 1) % pathCount];
+        // const v1 = ph.clone().sub(p).normalize();
+        const pq = path[(i + pathCount - 1) % pathCount];
+        const v2 = p.clone().sub(pq).normalize();
+        if (tDistance) {
+          const [mq, mh] = tDistance;
+          if (NumberUtils.nearlyThan(d, mq, true, tolerance)) {
+            if (!put) {
+              tp.push(v2.clone().multiplyScalar(mq - d).add(p));
+              put = true;
+            }
+            if (NumberUtils.nearlyLess(d, mh, false, tolerance)) {
+              tp.push(p);
+            }
+            if (NumberUtils.nearlyThan(d, mh, true, tolerance)) {
+              tp.push(v2.clone().multiplyScalar(mh - d).add(p));
+              if (PathUtils.invalidPath(tp)) {
+                tPaths.pop();
+              }
+              tp = [];
+              tPaths.push(tp);
+              tDistance = tDistances[m++];
+              i--;
+              put = false;
+            }
+          }
+        }
+      }
+      if (PathUtils.invalidPath(tp)) {
+        tPaths.pop();
+      }
+      if (closed) {
+        const tps = tPaths[0];
+        const tpe = tPaths[tPaths.length - 1];
+        if (PathUtils.nearlyEqualsV3(tps[0], tpe[tpe.length - 1], tolerance)) {
+          tPaths.pop();
+          tpe.pop();
+          tPaths[0] = tpe.concat(tps);
+        }
+      }
+    } else {
+      tPaths.push(path);
+    }
+    return { paths: tPaths, split };
+  }
+
+  static invalidPath(path: NS_THREE.Vector3[]): boolean {
+    const dis = PathUtils.getDistances(path);
+    return !path.length || NumberUtils.nearlyEquals(0, dis[dis.length - 1]);
+  }
+
+  static getDistances(path: NS_THREE.Vector3[]): number[] {
+    const distances = [] as number[];
+    if (!path || !path.length) {
+      return distances;
+    }
+    let count = 0;
+    distances.push(count);
+    for (let i = 1; i < path.length; i++) {
+      count += path[i].distanceTo(path[i - 1]);
+      distances.push(count);
+    }
+    return distances;
+  }
+
+  static findPointIndexByPath(path: NS_THREE.Vector3[], point: NS_THREE.Vector3, tolerance = 0.0001): number[] {
+    for (let j = 0; j < path.length; j++) {
+      const c = path[j];
+      if (PathUtils.nearlyEqualsV3(c, point, tolerance)) {
+        return [j];
+      }
+      const q = path[j - 1];
+      if (q && PathUtils.pointInLine(point, q, c, tolerance)) {
+        return [j - 1, j];
+      }
+    }
+    return [];
+  }
+
+  static pointInLine(
+    point: NS_THREE.Vector3, lineP1: NS_THREE.Vector3, lineP2: NS_THREE.Vector3, tolerance = 0.0001,
+  ): boolean {
+    return Math.abs(point.distanceTo(lineP1) + point.distanceTo(lineP2) - lineP1.distanceTo(lineP2)) < tolerance;
+  }
+
+  // static findNeareastPathPoint(px, py, pathMinX, pathMinY, pointMap) {
+  //   const [row, col] = NavigationPath.getPointHash(
+  //     px, py, pathMinX, pathMinY, 25,
+  //   );
+  //   let result = null;
+  //   let dist = Number.MAX_SAFE_INTEGER;
+  //   if (!pointMap[row] || !pointMap[row][col]) return result;
+  //   pointMap[row][col].forEach(([index, x, y]) => {
+  //     const d2 = ((px - x) ** 2) + ((py - y) ** 2);
+  //     if (d2 > dist) return;
+  //     dist = d2;
+  //     result = index;
+  //   });
+  //   return result;
+  // }
+}
+
+export { PathUtils };