gisviewer-vue3-arcgis 1.0.85

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

@@ -0,0 +1,271 @@
+import h from "@arcgis/core/Graphic";
+import m from "@arcgis/core/layers/FeatureLayer";
+import w from "axios";
+import f from "pako";
+class I {
+  constructor(e) {
+    this.view = e, this.laneLayer = new m({
+      id: "OpenDriveLane",
+      fields: [
+        {
+          name: "ObjectID",
+          alias: "ObjectID",
+          type: "oid"
+        },
+        {
+          name: "id",
+          alias: "编号",
+          type: "string"
+        },
+        {
+          name: "roadId",
+          alias: "道路号",
+          type: "string"
+        },
+        {
+          name: "roadName",
+          alias: "道路名称",
+          type: "string"
+        },
+        {
+          name: "sectionId",
+          alias: "路段号",
+          type: "string"
+        },
+        {
+          name: "laneId",
+          alias: "车道号",
+          type: "string"
+        },
+        {
+          name: "type",
+          alias: "类型",
+          type: "string"
+        }
+      ],
+      objectIdField: "ObjectID",
+      geometryType: "polygon",
+      spatialReference: { wkid: 4326 },
+      source: [],
+      outFields: ["*"],
+      renderer: {
+        type: "unique-value",
+        field: "type",
+        defaultSymbol: {
+          type: "simple-fill",
+          color: [100, 100, 100],
+          style: "solid",
+          outline: {
+            color: "white",
+            width: 1
+          }
+        },
+        uniqueValueInfos: [
+          {
+            value: "shoulder",
+            label: "路肩",
+            symbol: {
+              type: "simple-fill",
+              color: "#008000",
+              style: "solid",
+              outline: {
+                color: "white",
+                width: 1
+              }
+            }
+          },
+          {
+            value: "border",
+            label: "路沿",
+            symbol: {
+              type: "simple-fill",
+              color: "#DCDCDC",
+              style: "solid",
+              outline: {
+                color: "white",
+                width: 1
+              }
+            }
+          },
+          {
+            value: "driving",
+            label: "机动车道",
+            symbol: {
+              type: "simple-fill",
+              color: "#2F4F4F",
+              style: "solid",
+              outline: {
+                color: "white",
+                width: 1
+              }
+            }
+          },
+          {
+            value: "none",
+            label: "无",
+            symbol: {
+              type: "simple-fill",
+              color: [111, 120, 135],
+              style: "none",
+              outline: {
+                color: "white",
+                width: 1
+              }
+            }
+          },
+          {
+            value: "restricted",
+            label: "禁行区",
+            symbol: {
+              type: "simple-fill",
+              color: "yellow",
+              style: "solid",
+              outline: {
+                color: "yellow",
+                width: 2
+              }
+            }
+          },
+          {
+            value: "parking",
+            label: "停车区",
+            symbol: {
+              type: "simple-fill",
+              color: [115, 115, 115],
+              style: "solid",
+              outline: {
+                color: "white",
+                width: 1
+              }
+            }
+          },
+          {
+            value: "median",
+            label: "中央隔离带",
+            symbol: {
+              type: "simple-fill",
+              color: "#008000",
+              style: "solid",
+              outline: {
+                color: "white",
+                width: 1
+              }
+            }
+          },
+          {
+            value: "biking",
+            label: "非机动车道",
+            symbol: {
+              type: "simple-fill",
+              color: "#D3D3D3",
+              style: "solid",
+              outline: {
+                color: "white",
+                width: 1
+              }
+            }
+          },
+          {
+            value: "sidewalk",
+            label: "人行道",
+            symbol: {
+              type: "simple-fill",
+              color: "#C0C0C0",
+              style: "solid",
+              outline: {
+                color: "white",
+                width: 1
+              }
+            }
+          },
+          {
+            value: "junction",
+            label: "路口区域",
+            symbol: {
+              type: "simple-fill",
+              color: "#2F4F4F",
+              style: "solid",
+              outline: {
+                color: "white",
+                width: 1
+              }
+            }
+          },
+          {
+            value: "selected",
+            label: "选中车道",
+            symbol: {
+              type: "simple-fill",
+              color: [141, 168, 211],
+              style: "solid",
+              outline: {
+                color: "white",
+                width: 1
+              }
+            }
+          }
+        ]
+      }
+    }), this.view.map.add(this.laneLayer);
+  }
+  async showOpenDrive(e, i) {
+    const t = `http://${e}/api/openDrive/analyzeXodr`, o = await w.get(t, {
+      headers: {
+        projectName: i
+      },
+      params: {
+        analyze: !1,
+        compressed: !0
+      }
+    });
+    if (o.status !== 200)
+      throw new Error(`OpenDriveRenderer: ${o.statusText}`);
+    let l = o.data.result.json;
+    l.startsWith("http") || (l = `http://${e}${l}`);
+    const r = await (await fetch(l)).arrayBuffer(), n = f.inflate(r, { to: "string" }), a = JSON.parse(n);
+    this.showRoad(a);
+  }
+  async showRoad(e) {
+    const i = await this.laneLayer.queryFeatures();
+    i.features.length > 0 && this.laneLayer.applyEdits({
+      deleteFeatures: i.features
+    });
+    for (const t of e) {
+      const o = t.id, l = [];
+      for (const s of t.laneSections) {
+        const r = s.id;
+        for (const n of s.lanePaths) {
+          const { id: a, type: y, innerPath: d, outerPath: c } = n, p = d.concat(c.reverse());
+          p.push(d[0]);
+          const u = new h({
+            geometry: {
+              type: "polygon",
+              rings: [p]
+            },
+            attributes: {
+              id: a,
+              roadId: o,
+              roadName: t.name,
+              sectionId: r,
+              laneId: a,
+              type: y
+            }
+          });
+          l.push(u);
+        }
+      }
+      await this.laneLayer.applyEdits({
+        addFeatures: l
+      });
+    }
+  }
+  async hideOpenDrive() {
+    const e = await this.laneLayer.queryFeatures();
+    e.features.length > 0 && this.laneLayer.applyEdits({
+      deleteFeatures: e.features
+    });
+  }
+}
+export {
+  I as default
+};

package/es/src/gis-map/utils/overlay.d.ts

@@ -0,0 +1,83 @@
+import Graphic from '@arcgis/core/Graphic';
+import GraphicsLayer from '@arcgis/core/layers/GraphicsLayer';
+import MapView from '@arcgis/core/views/MapView';
+import SceneView from '@arcgis/core/views/SceneView';
+import { IOverlay, IOverlayParam, IPointSymbol, IResult } from '../../types';
+interface IOverlayOptions {
+    id: string;
+}
+export default class Overlay {
+    private view;
+    overlayLayer: GraphicsLayer;
+    constructor(view: MapView | SceneView, options?: IOverlayOptions);
+    private defaultPointSymbol;
+    /**
+     * 添加覆盖物
+     * @param params
+     */
+    addOverlays(params: IOverlayParam): IResult;
+    /**
+     * 按type移除覆盖物
+     * @param types
+     */
+    removeOverlaysByType(types: string[]): IResult;
+    /**
+     * 按id移除覆盖物
+     * @param ids
+     */
+    removeOverlaysById(ids: string[]): IResult;
+    /**
+     * 按id显示或隐藏覆盖物
+     * @param ids
+     * @param isShow
+     */
+    isShowOverlaysByIds(ids: string[], isShow: boolean): void;
+    /**
+     * 显示全部覆盖物
+     *
+     * @memberof Overlay
+     */
+    showAllOverlays(): void;
+    /**
+     * 删除全部覆盖物
+     * @returns
+     */
+    removeAllOverlays(): IResult;
+    /**
+     * 销毁
+     *
+     * @memberof Overlay
+     */
+    destroy(): void;
+    removeGraphics(graphics: Graphic | Graphic[]): void;
+    /**
+     * 查找当前点击是否有覆盖物在当前图层
+     *
+     * @param {((MouseEvent | __esri.MapViewScreenPoint) &
+     *       (__esri.SceneViewScreenPoint | MouseEvent))} event
+     * @returns
+     * @memberof Overlay
+     */
+    findGraphic(event: (MouseEvent | __esri.MapViewScreenPoint) & (__esri.SceneViewScreenPoint | MouseEvent)): Promise<__esri.ViewHit[]>;
+    /**
+     * 隐藏图层
+     *
+     * @memberof Overlay
+     */
+    hideLayer(): void;
+    /**
+     * 显示图层
+     *
+     * @memberof Overlay
+     */
+    showLayer(): void;
+    /**
+     * 添加点覆盖物
+     * @param overlay
+     * @param symbol
+     * @param properties
+     */
+    addPoint(overlay: IOverlay, symbol: IPointSymbol, properties: any, visible?: boolean): IResult;
+    private addOverlay;
+}
+export {};

package/es/src/gis-map/utils/overlay.mjs

@@ -0,0 +1,149 @@
+import o from "@arcgis/core/Graphic";
+import l from "@arcgis/core/layers/GraphicsLayer";
+class v {
+  constructor(r, s) {
+    this.defaultPointSymbol = {
+      type: "simple-marker",
+      style: "circle",
+      color: "yellow",
+      size: 10
+    }, this.view = r, this.overlayLayer = new l({
+      ...s
+    }), this.view.map.layers.add(this.overlayLayer);
+  }
+  /**
+   * 添加覆盖物
+   * @param params
+   */
+  addOverlays(r) {
+    let s = 0, i = 0;
+    for (const e of r.overlays) {
+      e.properties ? (e.properties.type || (e.properties.type = r.type), e.properties.id || (e.properties.id = e.id)) : e.properties = { type: r.type, id: e.id };
+      const t = e.symbol || r.defaultSymbol || this.defaultPointSymbol;
+      this.addOverlay(
+        e,
+        t,
+        e.properties,
+        e.visible
+      ).message === "add" ? s++ : i++;
+    }
+    return { status: 0, message: `新增${s}, 更新${i}` };
+  }
+  /**
+   * 按type移除覆盖物
+   * @param types
+   */
+  removeOverlaysByType(r) {
+    const s = this.overlayLayer.graphics.filter((i) => {
+      const e = i.getAttribute("type");
+      return r.includes(e);
+    });
+    return this.overlayLayer.graphics.removeMany(s), { status: 0, message: `删除${s.length}` };
+  }
+  /**
+   * 按id移除覆盖物
+   * @param ids
+   */
+  removeOverlaysById(r) {
+    const s = this.overlayLayer.graphics.filter((i) => {
+      const e = i.getAttribute("id");
+      return r.includes(e);
+    });
+    return this.overlayLayer.graphics.removeMany(s), { status: 0, message: `删除${s.length}` };
+  }
+  /**
+   * 按id显示或隐藏覆盖物
+   * @param ids
+   * @param isShow
+   */
+  isShowOverlaysByIds(r, s) {
+    this.overlayLayer.graphics.map((i) => {
+      const e = i.getAttribute("id");
+      r.includes(e) ? i.visible = s : i.visible = !s;
+    });
+  }
+  /**
+   * 显示全部覆盖物
+   *
+   * @memberof Overlay
+   */
+  showAllOverlays() {
+    this.overlayLayer.graphics.forEach((r) => {
+      r.visible = !0;
+    });
+  }
+  /**
+   * 删除全部覆盖物
+   * @returns
+   */
+  removeAllOverlays() {
+    const r = this.overlayLayer.graphics.length;
+    return this.overlayLayer.removeAll(), { status: 0, message: `删除${r}` };
+  }
+  /**
+   * 销毁
+   *
+   * @memberof Overlay
+   */
+  destroy() {
+    this.view.map.remove(this.overlayLayer), this.overlayLayer.destroy();
+  }
+  removeGraphics(r) {
+    Array.isArray(r) || (r = [r]), this.overlayLayer.graphics.removeMany(r);
+  }
+  /**
+   * 查找当前点击是否有覆盖物在当前图层
+   *
+   * @param {((MouseEvent | __esri.MapViewScreenPoint) &
+   *       (__esri.SceneViewScreenPoint | MouseEvent))} event
+   * @returns
+   * @memberof Overlay
+   */
+  async findGraphic(r) {
+    var e;
+    return (e = (await this.view.hitTest(r)).results) == null ? void 0 : e.filter(
+      (t) => t.type === "graphic" && t.graphic.layer === this.overlayLayer
+    );
+  }
+  /**
+   * 隐藏图层
+   *
+   * @memberof Overlay
+   */
+  hideLayer() {
+    this.overlayLayer.visible = !1;
+  }
+  /**
+   * 显示图层
+   *
+   * @memberof Overlay
+   */
+  showLayer() {
+    this.overlayLayer.visible = !0;
+  }
+  /**
+   * 添加点覆盖物
+   * @param overlay
+   * @param symbol
+   * @param properties
+   */
+  addPoint(r, s, i, e) {
+    let t, a = !0;
+    return r.id && (t = this.overlayLayer.graphics.find(
+      (y) => y.getAttribute("id") === r.id
+    )), t ? t.visible = e ?? t.visible : (e = e ?? !0, t = new o({
+      visible: e
+    }), this.overlayLayer.add(t), a = !1), t.geometry = r.geometry, t.symbol = s, t.attributes = i, { status: 0, message: a ? "add" : "update" };
+  }
+  addOverlay(r, s, i, e) {
+    let t, a = !0;
+    return r.id && (t = this.overlayLayer.graphics.find(
+      (y) => y.getAttribute("id") === r.id
+    )), t ? t.visible = e ?? t.visible : (e = e ?? !0, t = new o({
+      visible: e
+    }), this.overlayLayer.add(t), a = !1), t.geometry = r.geometry, t.symbol = s, t.attributes = i, { status: 0, message: a ? "add" : "update" };
+  }
+}
+export {
+  v as default
+};

package/es/src/gis-map/utils/queue-length.d.ts

@@ -0,0 +1,14 @@
+import View from '@arcgis/core/views/View';
+import { IQueueLengthParams } from '../../types';
+export default class QueueLength {
+    private view;
+    private mapConfig;
+    private readonly queueLengthLayer;
+    private initialized;
+    private lanePolygonMap;
+    constructor(view: View);
+    private initializeLaneGraphic;
+    updateQueueLength(params: IQueueLengthParams[]): Promise<void>;
+    removeQueueLength(): void;
+    private generateQueuePolygon;
+}

package/es/src/gis-map/utils/queue-length.mjs

@@ -0,0 +1,83 @@
+import L from "../stores/index.mjs";
+import d from "@arcgis/core/layers/GraphicsLayer";
+import * as u from "@turf/helpers";
+import C from "@turf/destination";
+import q from "@arcgis/core/Graphic";
+import P from "@turf/intersect";
+import w from "@turf/buffer";
+import h from "@turf/area";
+class $ {
+  constructor(e) {
+    this.initialized = !1, this.lanePolygonMap = /* @__PURE__ */ new Map(), this.view = e;
+    const t = L.useAppDataStore;
+    this.mapConfig = JSON.parse(JSON.stringify(t.mapConfig)), this.queueLengthLayer = new d(), this.view.map.add(this.queueLengthLayer);
+  }
+  async initializeLaneGraphic() {
+    if (!this.mapConfig.lanePolygonLayer)
+      return;
+    const e = `${this.mapConfig.assetsRoot}/${this.mapConfig.lanePolygonLayer}`, n = await (await fetch(e)).json(), { features: i } = n;
+    i.forEach((r) => {
+      const { properties: o, geometry: s } = r, p = u.polygon(s.coordinates, {
+        code: o.code,
+        laneDirection: o.laneDirection,
+        stopLineCenter: o.stopLineCenter
+      });
+      this.lanePolygonMap.set(o.code, p);
+    }), this.initialized = !0;
+  }
+  async updateQueueLength(e) {
+    if (this.initialized || await this.initializeLaneGraphic(), this.lanePolygonMap.size !== 0)
+      for (const t of e) {
+        const n = String(t.laneId), i = `${t.crossNo}+${n[0]}+${n[1]}`, r = this.lanePolygonMap.get(i);
+        if (!r)
+          continue;
+        const o = this.queueLengthLayer.graphics.find(
+          (s) => s.getAttribute("code") === i
+        );
+        o && this.queueLengthLayer.remove(o), t.queueLength !== 0 && this.generateQueuePolygon(r, t.queueLength);
+      }
+  }
+  removeQueueLength() {
+    this.queueLengthLayer.removeAll();
+  }
+  generateQueuePolygon(e, t) {
+    const n = e.properties.laneDirection, i = JSON.parse(
+      e.properties.stopLineCenter
+    ), r = u.point(i), o = n > 0 ? n - 180 : n + 180, s = C(r, t, o, {
+      units: "meters"
+    }), p = u.lineString([
+      i,
+      s.geometry.coordinates
+    ]), g = w(p, 10, { units: "meters" }), a = P(e, g);
+    if (!a)
+      return;
+    const f = h(a.geometry), m = h(e), l = f / m, c = l > 0.8 ? [139, 0, 0, 0.6] : l > 0.6 ? [255, 165, 0, 0.5] : [46, 139, 87, 0.5], y = new q({
+      geometry: {
+        type: "polygon",
+        rings: a == null ? void 0 : a.geometry.coordinates
+      },
+      symbol: {
+        type: "polygon-3d",
+        symbolLayers: [
+          {
+            type: "fill",
+            material: {
+              color: c
+            },
+            outline: {
+              color: [c[0], c[1], c[2]],
+              size: 3
+            }
+          }
+        ]
+      },
+      attributes: {
+        code: e.properties.code
+      }
+    });
+    this.queueLengthLayer.add(y);
+  }
+}
+export {
+  $ as default
+};

package/es/src/gis-map/utils/renderer/greenWaveline.d.ts

@@ -0,0 +1,2 @@
+declare const greenWavelineView: any;
+export default greenWavelineView;