@aibee/owlly 1.0.25 → 1.0.29

package/lib/owlly/utils/path-utils.js

@@ -0,0 +1,728 @@
+import smooth from 'chaikin-smooth';
+import Bezier from 'bezier-js';
+import { Externals, NS_THREE } from '../stage/externals';
+import { FloorModel } from '../element/floor-model';
+import { EventHub } from './event-hub';
+import { OwllyEvents } from './events';
+import { NumberUtils } from './number-utils';
+class PathUtils {
+    static getAngle(vec0, vec1) {
+        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, ignoreFirst = false, smoothingOptimization = true, simplifyDistanceThreshold = 5, maximumTurningDegree = 150, smoothingDistance = 3) {
+        // 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 = [
+                [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 = [];
+        let lastCheckedPoint;
+        simplifiedPath.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) {
+        let sum = 0;
+        path.reduce(([x0, y0], [x1, y1]) => {
+            sum += Math.sqrt((Math.pow((x1 - x0), 2)) + (Math.pow((y1 - y0), 2)));
+            return [x1, y1];
+        });
+        return sum / path.length;
+    }
+    static smoothPath(path, threshold = 0.25) {
+        if (PathUtils.averageStepLength(path) < threshold)
+            return path;
+        const result = smooth(path);
+        return PathUtils.smoothPath(result, threshold);
+    }
+    static smoothPathBezier(path, bezierLength, segment = 10) {
+        const { THREE } = Externals.getInstance();
+        const tpath = path.map(([x, y]) => new THREE.Vector2(x, y));
+        PathUtils.mergeSamePoint2(tpath);
+        PathUtils.mergePathSameVectorPoint2(tpath);
+        const segs = [];
+        let seg = [];
+        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 = [];
+                segs.push(seg);
+                if (i !== tlength - 1) {
+                    seg.push(h.clone().add(v.multiplyScalar(-1)));
+                }
+                seg.push(h);
+            }
+            else {
+                seg.push(q);
+            }
+        }
+        let result = [];
+        const tSegs = segs.map((segv) => {
+            const tv = segv.map((v) => [v.x, v.y]);
+            if (tv.length < 3) {
+                return tv;
+            }
+            const bt = [];
+            tv.forEach((t) => {
+                bt.push(...t);
+            });
+            const bezier = new Bezier(bt);
+            const points = bezier.getLUT(segment);
+            return points.map((p) => [p.x, p.y]);
+        });
+        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, x, y) {
+        const [a, b, c, d] = expression;
+        const commonHeight = -(a * x + b * y + d) / c + 0.2;
+        return commonHeight;
+    }
+    static getPointHash(x, y, minX, minY, dist = 1) {
+        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, params) {
+        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 = [];
+        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((Math.pow((x0 - x1), 2)) + (Math.pow((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 = [];
+        const sideBPath = [];
+        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 = {
+            // 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 },
+        };
+        if (arrowImageURL) {
+            new THREE.TextureLoader().load(arrowImageURL, (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[j + 2] = z;
+            }
+        }
+        else {
+            const updateZWithFloorModel = () => {
+                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[j + 2] = z;
+                }
+                geometry.attributes.position.needsUpdate = true;
+            };
+            if (floorModel && floorModel.isModelLoaded()) {
+                updateZWithFloorModel();
+            }
+            EventHub.on(OwllyEvents.ELEMENT_LOADED, (element) => {
+                if (!(element instanceof FloorModel))
+                    return;
+                if (element !== floorModel)
+                    return;
+                updateZWithFloorModel();
+            });
+        }
+        geometry.attributes.position.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();
+        smoothedPath.forEach(([x, y], i) => {
+            const [row, col] = PathUtils.getPointHash(x, y, pathMinX, pathMinY, 25);
+            if (!pointMap.has(`${row}`))
+                pointMap.set(`${row}`, new Map());
+            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 = [];
+            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 = (Math.pow((px - x), 2)) + (Math.pow((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,
+            pointMap,
+            pathMinX,
+            pathMinY,
+            progressBuffer,
+            pathDistance,
+        };
+    }
+    static nearlyEqualsV2(v1, v2, tolerance = 0.0001) {
+        return Math.abs(v1.x - v2.x) < tolerance && Math.abs(v1.y - v2.y) < tolerance;
+    }
+    static nearlyEqualsV3(v1, v2, tolerance = 0.0001) {
+        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, tolerance = 0.0001) {
+        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, tolerance = 0.0001) {
+        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, tolerance = 0.0001) {
+        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, tolerance = 0.0001) {
+        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, closed, points, widths, tolerance = 0.0001) {
+        const tPaths = [];
+        let tws = [];
+        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 = [];
+        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 = [];
+            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) {
+        const dis = PathUtils.getDistances(path);
+        return !path.length || NumberUtils.nearlyEquals(0, dis[dis.length - 1]);
+    }
+    static getDistances(path) {
+        const distances = [];
+        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, point, tolerance = 0.0001) {
+        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, lineP1, lineP2, tolerance = 0.0001) {
+        return Math.abs(point.distanceTo(lineP1) + point.distanceTo(lineP2) - lineP1.distanceTo(lineP2)) < tolerance;
+    }
+}
+PathUtils.PathMeshOffsetZ = 0.1;
+PathUtils.ArrowMeshOffsetZ = 0.2;
+export { PathUtils };