gisviewer-vue3-arcgis 1.0.115 → 1.0.117

package/es/src/gis-map/utils/open-drive-renderer/lane-section.mjs

@@ -0,0 +1,82 @@
+import a from "../common-utils.mjs";
+import g from "./lane.mjs";
+class m {
+  constructor(s, r) {
+    this.s0 = s.s0, this.road = r, this.idToLane = /* @__PURE__ */ new Map(), a.getStdVecEntries(
+      s.odr_lanes,
+      !0
+    ).forEach((l) => {
+      const n = new g(l, r, this);
+      this.idToLane.set(n.id, n);
+    }), this.borders = this.getBorderLine();
+    const e = [];
+    e.push(...this.borders.right), e.push(...this.borders.top), e.push(...[...this.borders.left].reverse()), e.push(...[...this.borders.bottom].reverse()), e.push(e[0]), this.polygon = e;
+  }
+  /**
+   * 获取一个车道
+   * @param id
+   * @returns
+   */
+  getLane(s) {
+    return this.idToLane.get(s);
+  }
+  /**
+   * 获取所有车道
+   * @returns
+   */
+  get allLanes() {
+    return [...this.idToLane.values()];
+  }
+  get laneNumber() {
+    return this.idToLane.size;
+  }
+  /**
+   * 获取所有车道id，id升序排列
+   * @returns
+   */
+  get allLaneIds() {
+    return [...this.idToLane.keys()].sort((s, r) => s - r);
+  }
+  /**
+   * 路段采样后的数据
+   */
+  get sampledLaneSection() {
+    const s = this.allLanes.filter((r) => r.id !== 0);
+    return {
+      id: this.s0,
+      lanePaths: s.map((r) => r.sampledLane)
+    };
+  }
+  /**
+   * 计算路段上下左右边框
+   * @returns
+   */
+  getBorderLine() {
+    let s = [], r = [];
+    const t = [], e = [], l = this.allLaneIds;
+    return l.filter((n) => n !== 0).forEach((n, p) => {
+      const o = this.getLane(n), i = o.innerBorder[o.innerBorder.length - 1], u = o.outerBorder[o.outerBorder.length - 1], h = o.innerBorder[0], d = o.outerBorder[0];
+      p === 0 ? (r = o.outerBorder, t.push(i), e.push(h)) : p === l.length - 2 ? (s = o.outerBorder, t.push(i), e.push(h)) : o.id < 0 ? (a.pointsEqual(
+        u,
+        t[t.length - 1]
+      ) || t.push(u), t.push(i), a.pointsEqual(
+        d,
+        e[e.length - 1]
+      ) || e.push(d), e.push(h)) : (a.pointsEqual(
+        i,
+        t[t.length - 1]
+      ) || t.push(i), t.push(u), a.pointsEqual(
+        h,
+        e[e.length - 1]
+      ) || e.push(h), e.push(d));
+    }), {
+      left: s,
+      right: r,
+      top: t,
+      bottom: e
+    };
+  }
+}
+export {
+  m as default
+};

package/es/src/gis-map/utils/open-drive-renderer/lane-utils.d.ts

@@ -0,0 +1,29 @@
+import { ILaneInfo } from '../../../types';
+import Lane from './lane';
+export default class LaneUtils {
+    private static shpLanePolygonMap;
+    private static shpArrowPositionMap;
+    /**
+     * 判断车道航向角是否和参考线方向一致，
+     * 道路两端都连接到道路时无法计算，默认为true
+     * @param lane
+     * @returns
+     */
+    static isLaneDirEqualDriveDir(lane: Lane): boolean;
+    /**
+     * 计算车道航向角
+     * @param lane
+     * @returns
+     */
+    static getDriveAngle(lane: Lane): number;
+    /**
+     * 获取车道首尾端点，包括内侧、中间、外侧
+     * @param type
+     * @returns
+     */
+    static getLaneEndPoints(lane: Lane, type?: string): number[][];
+    static getPrevAndNext(lane: Lane): {
+        predecessorLanes: ILaneInfo[];
+        successorLanes: ILaneInfo[];
+    };
+}

package/es/src/gis-map/utils/open-drive-renderer/lane-utils.mjs

@@ -0,0 +1,265 @@
+import h from "@turf/bearing";
+import * as I from "@turf/helpers";
+import a from "./wasm-loader.mjs";
+const L = class {
+  /**
+   * 判断车道航向角是否和参考线方向一致，
+   * 道路两端都连接到道路时无法计算，默认为true
+   * @param lane
+   * @returns
+   */
+  static isLaneDirEqualDriveDir(e) {
+    var s, i;
+    let t = 0;
+    if (((s = e.road.predecessor) == null ? void 0 : s.elementType) === "junction") {
+      const c = e.road.predecessor.elementId, n = a.getInstance().junctionList.get(c);
+      if (n) {
+        for (const d of n.laneLinks)
+          if (d.outgoing.roadId === e.road.id) {
+            t = d.outgoing.laneId;
+            break;
+          }
+      }
+    } else if (((i = e.road.successor) == null ? void 0 : i.elementType) === "junction") {
+      const c = e.road.successor.elementId, n = a.getInstance().junctionList.get(c);
+      if (n) {
+        for (const d of n.laneLinks)
+          if (d.incoming.roadId === e.road.id) {
+            t = d.incoming.laneId;
+            break;
+          }
+      }
+    }
+    return t === 0 ? !0 : t * e.id > 0;
+  }
+  /**
+   * 计算车道航向角
+   * @param lane
+   * @returns
+   */
+  static getDriveAngle(e) {
+    const t = L.getLaneEndPoints(e), s = I.point(t[0]), i = I.point(t[1]);
+    return h(s, i);
+  }
+  /**
+   * 获取车道首尾端点，包括内侧、中间、外侧
+   * @param type
+   * @returns
+   */
+  static getLaneEndPoints(e, t = "middle") {
+    let s, i, c, n;
+    switch (e.isDirEqual ? (s = e.innerBorder[0], i = e.innerBorder[e.innerBorder.length - 1], c = e.outerBorder[0], n = e.outerBorder[e.outerBorder.length - 1]) : (s = e.innerBorder[e.innerBorder.length - 1], i = e.innerBorder[0], c = e.outerBorder[e.outerBorder.length - 1], n = e.outerBorder[0]), t) {
+      case "inner":
+        return [s, i];
+      case "outer":
+        return [c, n];
+      default: {
+        const d = [
+          (s[0] + c[0]) / 2,
+          (s[1] + c[1]) / 2
+        ], f = [
+          (i[0] + n[0]) / 2,
+          (i[1] + n[1]) / 2
+        ];
+        return [d, f];
+      }
+    }
+  }
+  static getPrevAndNext(e) {
+    var n, d, f, p;
+    const t = [], s = [], i = e.laneSection.s0 === 0, c = e.road.isLastLaneSection(e.laneSection.s0);
+    if (i) {
+      if (((n = e.road.predecessor) == null ? void 0 : n.elementType) === "junction") {
+        const o = a.getInstance().junctionList.get(
+          e.road.predecessor.elementId
+        );
+        if (o) {
+          const r = o.getSuccessorForIncoming(
+            e.road.id,
+            e.id
+          );
+          if (r.length > 0)
+            s.push(...r);
+          else {
+            const u = o.getPredecessorForOutgoing(
+              e.road.id,
+              e.id
+            );
+            t.push(...u);
+          }
+        }
+      } else if (((d = e.road.predecessor) == null ? void 0 : d.elementType) === "road" && e.predecessor !== 0) {
+        const o = e.road.predecessor.elementId;
+        let r = 0;
+        if (e.road.predecessor.contactPoint === "end") {
+          const g = a.getInstance().roadList.get(o);
+          g && (r = g.getLastLaneSection().s0);
+        }
+        const u = {
+          roadId: o,
+          sectionId: r,
+          laneId: e.predecessor
+        };
+        e.isDirEqual ? t.push(u) : s.push(u);
+      }
+    } else if (e.predecessor !== 0) {
+      const o = e.road.getPrevLaneSection(e.laneSection.s0);
+      if (o) {
+        const r = {
+          roadId: e.road.id,
+          sectionId: o.s0,
+          laneId: e.predecessor
+        };
+        e.isDirEqual ? t.push(r) : s.push(r);
+      }
+    }
+    if (c) {
+      if (((f = e.road.successor) == null ? void 0 : f.elementType) === "junction") {
+        const o = a.getInstance().junctionList.get(
+          e.road.successor.elementId
+        );
+        if (o) {
+          const r = o.getSuccessorForIncoming(
+            e.road.id,
+            e.id
+          );
+          if (r.length > 0)
+            s.push(...r);
+          else {
+            const u = o.getPredecessorForOutgoing(
+              e.road.id,
+              e.id
+            );
+            t.push(...u);
+          }
+        }
+      } else if (((p = e.road.successor) == null ? void 0 : p.elementType) === "road" && e.successor !== 0) {
+        const o = e.road.successor.elementId;
+        let r = 0;
+        if (e.road.successor.contactPoint === "end") {
+          const g = a.getInstance().roadList.get(o);
+          g && (r = g.getLastLaneSection().s0);
+        }
+        const u = {
+          roadId: o,
+          sectionId: r,
+          laneId: e.successor
+        };
+        e.isDirEqual ? s.push(u) : t.push(u);
+      }
+    } else if (e.successor !== 0) {
+      const o = e.road.getNextLaneSection(e.laneSection.s0);
+      if (o) {
+        const r = {
+          roadId: e.road.id,
+          sectionId: o.s0,
+          laneId: e.successor
+        };
+        e.isDirEqual ? s.push(r) : t.push(r);
+      }
+    }
+    return { predecessorLanes: t, successorLanes: s };
+  }
+  /**
+   * 获取OpenDrive车道对应的高精地图中的车道面
+   * @param lane
+   */
+  // public static getShpLanePolygonOfXodrLane(lane: Lane) {
+  //   const xodrLanePolygon = turf.polygon([lane.polygon]);
+  //   const xodrLaneCenter = centerOfMass(xodrLanePolygon);
+  //   const shpLanePolygons = LaneUtils.getShpLanePolygonsInProject("road");
+  //   // xodr车道的中心点在哪个shp车道面内
+  //   const shpLanePolygon = shpLanePolygons.find((shpLanePolygon) =>
+  //     booleanWithin(xodrLaneCenter, shpLanePolygon)
+  //   );
+  //   return shpLanePolygon;
+  // }
+  /**
+   * 获取此项目的车道面
+   * @param projectName
+   * @returns
+   */
+  // private static getShpLanePolygonsInProject(
+  //   projectName: string
+  // ): turf.Feature<turf.Polygon, turf.Properties>[] {
+  //   let polygons = LaneUtils.shpLanePolygonMap.get(projectName);
+  //   // 尚未加载车道面图层
+  //   if (!polygons) {
+  //     // 车道面图层地址
+  //     const layerFilePath = path.join(
+  //       __dirname,
+  //       // 默认项目名为"road"
+  //       projectName === "road"
+  //         ? "../../../public/files/layers/LanePolygon.json"
+  //         : `../../../public/files/layers/${projectName}_LanePolygon.json`
+  //     );
+  //     const dataString = readFileSync(layerFilePath, "utf8");
+  //     const layerObj = JSON.parse(dataString);
+  //     const polygons: turf.Feature<turf.Polygon, turf.Properties>[] =
+  //       layerObj.features.map((feature: any) =>
+  //         turf.polygon(
+  //           feature.geometry.coordinates,
+  //           { type: feature.properties.Type },
+  //           { id: feature.properties.ID }
+  //         )
+  //       );
+  //     LaneUtils.shpLanePolygonMap.set(projectName, polygons);
+  //     return polygons;
+  //   }
+  //   return polygons;
+  // }
+  /**
+   * 获取车道内地面转向箭头中心点的位置
+   * @param lane
+   * @returns
+   */
+  // public static getArrowPositionsInLane(lane: Lane) {
+  //   const shpLanePolygon = lane.getShpPolygon();
+  //   if (shpLanePolygon) {
+  //     const projectName = "road";
+  //     const shpArrowPositions =
+  //       LaneUtils.getShpArrowPositionsInProject(projectName);
+  //     const positionsInLane = shpArrowPositions
+  //       .filter((position) => booleanWithin(position, shpLanePolygon))
+  //       .map((position) => ({
+  //         id: position.id,
+  //         type: position.properties?.type,
+  //         coordinates: position.geometry.coordinates,
+  //       }));
+  //     return positionsInLane;
+  //   }
+  // }
+  // private static getShpArrowPositionsInProject(projectName: string) {
+  //   let positions = LaneUtils.shpArrowPositionMap.get(projectName);
+  //   // 尚未加载转向箭头中心点图层
+  //   if (!positions) {
+  //     // 转向箭头中心点图层地址
+  //     const layerFilePath = path.join(
+  //       __dirname,
+  //       // 默认项目名为"road"
+  //       projectName === "road"
+  //         ? "../../../public/files/layers/DirectionArrowPoint.json"
+  //         : `../../../public/files/layers/${projectName}_DirectionArrowPoint.json`
+  //     );
+  //     const dataString = readFileSync(layerFilePath, "utf8");
+  //     const layerObj = JSON.parse(dataString);
+  //     const positions: turf.Feature<turf.Point, turf.Properties>[] =
+  //       layerObj.features.map((feature: any) =>
+  //         turf.point(
+  //           feature.geometry.coordinates,
+  //           { type: feature.properties.Type },
+  //           { id: feature.properties.ID }
+  //         )
+  //       );
+  //     LaneUtils.shpArrowPositionMap.set(projectName, positions);
+  //     return positions;
+  //   }
+  //   return positions;
+  // }
+};
+let m = L;
+m.shpLanePolygonMap = /* @__PURE__ */ new Map();
+m.shpArrowPositionMap = /* @__PURE__ */ new Map();
+export {
+  m as default
+};

package/es/src/gis-map/utils/open-drive-renderer/lane.d.ts

@@ -0,0 +1,77 @@
+import { ISampledLane } from '../../../types';
+import LaneSection from './lane-section';
+import Road from './road';
+export default class Lane {
+    /** 车道id:
+     * 车道在路段中的序号，-2,-1,0,1,2,...
+     */
+    id: number;
+    /** 车道类型, driving/walk/bike... */
+    type: string;
+    /** 内侧边线采样点坐标 */
+    innerBorder: number[][];
+    /** 外侧边线采样点坐标 */
+    outerBorder: number[][];
+    centerLine: number[][];
+    road: Road;
+    laneSection: LaneSection;
+    predecessor: number;
+    successor: number;
+    /** 车道行车方向与正北夹角 */
+    private angle;
+    /** 车道行车方向是否与参考线方向一致 */
+    private _isDirEqual;
+    /**
+     * 行车方向是否已计算
+     * 存在无法计算行车方向， isDirEqual = undefined的情况，额外加一个标志
+     * */
+    private isDirEqualReady;
+    /**
+     * 车道面
+     */
+    ring: number[][];
+    constructor(odrLane: any, road: Road, lanesection: LaneSection);
+    get isDirEqual(): boolean | undefined;
+    /**
+     * 车道代码：道路id_路段id_车道id
+     */
+    get laneCode(): string;
+    /**
+     * 车道边线采样后的数据
+     */
+    get sampledLane(): ISampledLane;
+    /**
+     * 获取路段内同方向最外侧车道
+     */
+    get outerMostLaneInTheSameDir(): Lane;
+    /**
+     * 车道航向角
+     * @returns
+     */
+    get drivingAngle(): number;
+    /**
+     * 根据左右边线生成车道中心线
+     * @param left
+     * @param right
+     */
+    private getCenterLineFromBorder;
+    /**
+     * 获取车道按行车方向的起点、终点，可选择内侧、中间、外侧
+     * @param type
+     * @returns
+     */
+    getLaneEndPoints(type?: string): number[][];
+    /**
+     * 获取车道的前驱车道和后继车道
+     * @returns
+     */
+    getLink(): {
+        predecessorLanes: import("../../../types").ILaneInfo[];
+        successorLanes: import("../../../types").ILaneInfo[];
+    };
+    /**
+     * 获取车道停止线
+     * @returns
+     */
+    getStopLine(): number[][];
+}

package/es/src/gis-map/utils/open-drive-renderer/lane.mjs

@@ -0,0 +1,110 @@
+import n from "../common-utils.mjs";
+import s from "./lane-utils.mjs";
+class c {
+  constructor(e, t, i) {
+    this.isDirEqualReady = !1, this.road = t, this.laneSection = i, this.id = e.id, this.type = e.type, this.predecessor = e.predecessor, this.successor = e.successor;
+    const o = n.getStdVecEntries(
+      e.inner_border,
+      !0
+    );
+    this.innerBorder = n.transformLineProjection(o);
+    const r = n.getStdVecEntries(
+      e.outer_border,
+      !0
+    );
+    this.outerBorder = n.transformLineProjection(r), this.centerLine = this.getCenterLineFromBorder(
+      this.innerBorder,
+      this.outerBorder
+    );
+    const h = this.innerBorder.concat([...this.outerBorder].reverse());
+    h.push(h[0]), this.ring = h;
+  }
+  get isDirEqual() {
+    return this.isDirEqualReady || (this._isDirEqual = s.isLaneDirEqualDriveDir(this), this.isDirEqualReady = !0), this._isDirEqual;
+  }
+  /**
+   * 车道代码：道路id_路段id_车道id
+   */
+  get laneCode() {
+    return `${this.road.id}_${this.laneSection.s0}_${this.id}`;
+  }
+  /**
+   * 车道边线采样后的数据
+   */
+  get sampledLane() {
+    return {
+      id: this.id,
+      type: this.type,
+      innerPath: this.innerBorder,
+      outerPath: this.outerBorder
+    };
+  }
+  /**
+   * 获取路段内同方向最外侧车道
+   */
+  get outerMostLaneInTheSameDir() {
+    const e = this.laneSection.allLaneIds, t = this.id > 0 ? e[e.length - 1] : e[0];
+    return this.laneSection.getLane(t);
+  }
+  /**
+   * 车道航向角
+   * @returns
+   */
+  get drivingAngle() {
+    if (!this.angle) {
+      const e = s.getDriveAngle(this);
+      this.angle = e;
+    }
+    return this.angle;
+  }
+  /**
+   * 根据左右边线生成车道中心线
+   * @param left
+   * @param right
+   */
+  getCenterLineFromBorder(e, t) {
+    const i = [], o = Math.min(e.length, t.length);
+    for (let r = 0; r < o; r++)
+      i.push([
+        (e[r][0] + t[r][0]) / 2,
+        (e[r][1] + t[r][1]) / 2
+      ]);
+    return i;
+  }
+  /**
+   * 获取车道按行车方向的起点、终点，可选择内侧、中间、外侧
+   * @param type
+   * @returns
+   */
+  getLaneEndPoints(e = "middle") {
+    return s.getLaneEndPoints(this, e);
+  }
+  /**
+   * 获取车道的前驱车道和后继车道
+   * @returns
+   */
+  getLink() {
+    return s.getPrevAndNext(this);
+  }
+  // /**
+  //  * 获取车道对应的高精地图要素
+  //  * @returns
+  //  */
+  // public getShpPolygon() {
+  //   return LaneUtils.getShpLanePolygonOfXodrLane(this);
+  // }
+  // public getArrowPositions() {
+  //   return LaneUtils.getArrowPositionsInLane(this);
+  // }
+  /**
+   * 获取车道停止线
+   * @returns
+   */
+  getStopLine() {
+    const e = this.getLaneEndPoints("inner"), t = this.getLaneEndPoints("outer");
+    return [e[1], t[1]];
+  }
+}
+export {
+  c as default
+};

package/es/src/gis-map/utils/open-drive-renderer/road.d.ts

@@ -0,0 +1,60 @@
+import { IRoadLink, ISampledRoad } from '../../../types';
+import LaneSection from './lane-section';
+export default class Road {
+    id: string;
+    name: string;
+    length: number;
+    junction: string;
+    successor: IRoadLink;
+    predecessor: IRoadLink;
+    /** 道路上下左右的边框 */
+    borders: {
+        left: number[][];
+        right: number[][];
+        top: number[][];
+        bottom: number[][];
+    };
+    /** 上下左右边框围成的多边形 */
+    polygon: number[][];
+    refLine: number[][];
+    private sToLaneSection;
+    constructor(odrRoad: any);
+    /**
+     * 获取一个路段
+     * @param s0
+     * @returns
+     */
+    getLaneSection(s0: number): LaneSection | undefined;
+    /**
+     * 获取第一个路段
+     * @returns
+     */
+    getFirstLaneSection(): LaneSection;
+    /**
+     * 获取最后一个路段
+     * @returns
+     */
+    getLastLaneSection(): LaneSection;
+    /**
+     * 是否是最后一个路段的里程值
+     * @param s
+     * @returns
+     */
+    isLastLaneSection(s: number): boolean;
+    /**
+     * 获取下一个路段
+     * @param s
+     */
+    getNextLaneSection(s: number): LaneSection | undefined;
+    /**
+     * 获取上一个路段
+     * @param s
+     * @returns
+     */
+    getPrevLaneSection(s: number): LaneSection | undefined;
+    /** 获取所有路段 */
+    get allLaneSections(): LaneSection[];
+    get laneSectionNumber(): number;
+    get sampledRoad(): ISampledRoad;
+    private getBorderLine;
+}