gisviewer-vue3-arcgis 1.0.85

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

@@ -0,0 +1,193 @@
+import c from "@arcgis/core/Graphic";
+import { Point as y } from "@arcgis/core/geometry";
+import p from "@arcgis/core/geometry/Polyline";
+import * as n from "@arcgis/core/geometry/support/webMercatorUtils.js";
+import m from "@arcgis/core/layers/GraphicsLayer";
+import u from "./renderer/greenWaveline.mjs";
+function h(...l) {
+  const i = {}, t = (e) => {
+    for (const r in e)
+      e.hasOwnProperty(r) && (Object.prototype.toString.call(e[r]) === "[object Object]" ? i[r] = h(i[r], e[r]) : i[r] = e[r]);
+  };
+  for (let e = 0; e < l.length; e++)
+    t(l[e]);
+  return i;
+}
+class d {
+  constructor(i) {
+    this.defaultAnimationOptions = {
+      isAnimation: !1,
+      positive: !0,
+      positiveColor: [0, 255, 0],
+      negative: !0,
+      negativeColor: [0, 255, 0]
+    }, this.viewer = i.viewer, this.overlayLayer = new m({
+      ...i.graphicsLayerOptions
+    }), this.customGreenWaveLineView = new u({
+      graphics: []
+    }), this.viewer.map.layers.add(this.customGreenWaveLineView), this.viewer.map.layers.add(this.overlayLayer);
+  }
+  addGreenWaveLine(i, t = {
+    isAnimation: !1,
+    positive: !0,
+    positiveColor: [0, 255, 0],
+    negative: !0,
+    negativeColor: [0, 255, 0]
+  }) {
+    const e = [], r = [];
+    t = h(this.defaultAnimationOptions, t), i.map((a) => {
+      const o = a.visible == null ? !0 : a.visible;
+      if (t.isAnimation) {
+        const s = [...a.paths];
+        r.push(...this.getAnimationPath(s, t));
+      }
+      e.push(this.createLine(a.paths, a.symbol, a.attributes, o));
+    }), this.overlayLayer.addMany(e), t.isAnimation && this.customGreenWaveLineView.addMany(r);
+  }
+  getAnimationPath(i, t = {
+    isAnimation: !1,
+    positive: !0,
+    positiveColor: [0, 255, 0],
+    negative: !0,
+    negativeColor: [0, 255, 0]
+  }) {
+    const e = [];
+    return t.positive && e.push({
+      attributes: {
+        color: t.positiveColor
+      },
+      geometry: n.geographicToWebMercator({
+        //@ts-ignore
+        paths: [i],
+        type: "polyline"
+      })
+    }), t.negative && e.push({
+      attributes: {
+        color: t.negativeColor
+      },
+      geometry: n.geographicToWebMercator({
+        //@ts-ignore
+        paths: [i.reverse()],
+        type: "polyline"
+      })
+    }), e;
+  }
+  createLine(i, t, e = {}, r) {
+    const a = {
+      type: "simple-line",
+      color: [0, 0, 255, 0.5],
+      width: 2,
+      ...t
+    }, o = new p({
+      paths: i
+    }), s = n.geographicToWebMercator(o);
+    return new c({
+      geometry: s,
+      // Add the geometry created in step 3
+      symbol: a,
+      // Add the symbol created in step 4
+      attributes: {
+        type: "greenWaveLine",
+        ...e
+      },
+      visible: r
+    });
+  }
+  addPointText(i) {
+    const t = [];
+    i.map((e) => {
+      const r = e.visible == null ? !0 : e.visible;
+      t.push(
+        this.createPointText(e.point, e.symbol, e.attributes, r)
+      );
+    }), this.overlayLayer.addMany(t);
+  }
+  createPointText(i, t, e = {}, r) {
+    const a = {
+      type: "text",
+      // autocasts as new TextSymbol()
+      color: "white",
+      haloColor: "black",
+      haloSize: "1px",
+      xoffset: 3,
+      yoffset: 3,
+      font: {
+        size: 12,
+        family: "Josefin Slab",
+        weight: "bold"
+      },
+      ...t
+    }, o = new y({
+      x: i[0],
+      y: i[1]
+    }), s = n.geographicToWebMercator(o);
+    return new c({
+      geometry: s,
+      // Add the geometry created in step 3
+      symbol: a,
+      // Add the symbol created in step 4
+      attributes: {
+        type: "greenWaveLine-Text",
+        ...e
+      },
+      visible: r
+    });
+  }
+  /**
+   * 隐藏覆盖物
+   *
+   * @param {string[]} [ids]
+   * @memberof GreenWaveLine
+   */
+  hideWaveLine(i) {
+    i ? this.overlayLayer.graphics.filter((e) => {
+      const r = e.getAttribute("id");
+      return i.includes(r);
+    }).forEach((e) => {
+      e.visible = !1;
+    }) : this.overlayLayer.graphics.map((t) => {
+      t.visible = !1;
+    });
+  }
+  /**
+   * 显示覆盖物
+   *
+   * @param {string[]} [ids]
+   * @memberof GreenWaveLine
+   */
+  showWaveLine(i) {
+    i ? this.overlayLayer.graphics.filter((e) => {
+      const r = e.getAttribute("id");
+      return i.includes(r);
+    }).forEach((e) => {
+      e.visible = !0;
+    }) : this.overlayLayer.graphics.map((t) => {
+      t.visible = !0;
+    });
+  }
+  /**
+   * 隐藏图层
+   *
+   * @memberof GreenWaveLine
+   */
+  hideLayer() {
+    this.overlayLayer.visible = !1, this.customGreenWaveLineView.visible = !1;
+  }
+  /**
+   * 显示图层
+   *
+   * @memberof Overlay
+   */
+  showLayer() {
+    this.overlayLayer.visible = !0, this.customGreenWaveLineView.visible = !0;
+  }
+  clearGreenWaveLine() {
+    this.overlayLayer.removeAll(), this.customGreenWaveLineView.removeAll();
+  }
+  destroy() {
+    this.overlayLayer.removeAll(), this.customGreenWaveLineView.removeAll(), this.viewer.map.layers.remove(this.customGreenWaveLineView), this.viewer.map.layers.remove(this.overlayLayer);
+  }
+}
+export {
+  d as default
+};

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

@@ -0,0 +1,31 @@
+import Layer from '@arcgis/core/layers/Layer';
+import MapView from '@arcgis/core/views/MapView';
+import SceneView from '@arcgis/core/views/SceneView';
+interface LayersOptions {
+    viewer: MapView | SceneView;
+    graphicsLayerOptions: {
+        id: string;
+    };
+}
+interface layerDataFace {
+    url: string;
+    id: string;
+    title: string;
+    visible?: boolean;
+    type: string;
+    options?: any;
+}
+export default class BaseLayers {
+    private viewer;
+    private layerList;
+    constructor(options: LayersOptions);
+    getLayerById(id: string): Layer | undefined;
+    getLayers(): Map<string, Layer>;
+    getTileInfo(): {};
+    addLayer(layerData: layerDataFace | layerDataFace[], index?: number): void;
+    createLayer(layerData: layerDataFace): Layer | null;
+    removeLayerById(ids: string | string[]): void;
+    hideLayerById(ids: string | string[]): void;
+    showLayerById(ids: string | string[]): void;
+}
+export {};

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

@@ -0,0 +1,99 @@
+import y from "@arcgis/core/layers/GeoJSONLayer";
+import l from "@arcgis/core/layers/TileLayer";
+import o from "@arcgis/core/layers/WebTileLayer";
+class f {
+  constructor(e) {
+    this.layerList = /* @__PURE__ */ new Map(), this.viewer = e.viewer;
+    const i = this.viewer.map.findLayerById("dark-gray-base-layer");
+    i && this.layerList.set("dark-gray-base-layer", i);
+  }
+  getLayerById(e) {
+    return this.layerList.get(e);
+  }
+  getLayers() {
+    return this.layerList;
+  }
+  getTileInfo() {
+    return {};
+  }
+  addLayer(e, i) {
+    const r = [];
+    if (Array.isArray(e))
+      e.map((t) => {
+        const s = this.createLayer(t);
+        s && (this.layerList.set(t.id, s), r.push(this.createLayer(t)));
+      });
+    else {
+      const t = this.createLayer(e);
+      if (!t)
+        return;
+      this.layerList.set(e.id, t), r.push(this.createLayer(e));
+    }
+    r.map((t) => {
+      this.viewer.map.add(t, i);
+    });
+  }
+  createLayer(e) {
+    let i = null;
+    switch (e.type) {
+      case "webTile":
+        i = new o({
+          urlTemplate: e.url,
+          ...e.options,
+          title: e.options.id,
+          visible: e.visible
+        });
+        break;
+      case "hdLayers":
+        i = new y({
+          url: e.url,
+          ...e.options,
+          title: e.options.id,
+          visible: e.visible
+        });
+        break;
+      case "tile":
+        i = new l({
+          url: e.url,
+          ...e.options,
+          title: e.options.id,
+          visible: e.visible
+        });
+        break;
+    }
+    return i;
+  }
+  removeLayerById(e) {
+    if (typeof e == "string") {
+      const i = this.layerList.get(e);
+      i && (this.viewer.map.remove(i), this.layerList.delete(e));
+    }
+    Array.isArray(e) && e.forEach((i) => {
+      const r = this.layerList.get(i);
+      r && (this.viewer.map.remove(r), this.layerList.delete(i));
+    });
+  }
+  hideLayerById(e) {
+    if (typeof e == "string") {
+      const i = this.layerList.get(e);
+      i && (i.visible = !1);
+    }
+    Array.isArray(e) && e.forEach((i) => {
+      const r = this.layerList.get(i);
+      r && (r.visible = !1);
+    });
+  }
+  showLayerById(e) {
+    if (typeof e == "string") {
+      const i = this.layerList.get(e);
+      i && (i.visible = !0);
+    }
+    Array.isArray(e) && e.forEach((i) => {
+      const r = this.layerList.get(i);
+      r && (r.visible = !0);
+    });
+  }
+}
+export {
+  f as default
+};

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

@@ -0,0 +1,65 @@
+import { Point, Polygon, Polyline } from '@arcgis/core/geometry';
+export default class CommonUtils {
+    /**
+     * 得到某个点在一定方向、距离之外的另一个点
+     * @param point
+     * @param angel
+     * @param distance
+     * @returns
+     */
+    static destinationWithPoint(point: Point, angel: number, distance: number): Point;
+    /**
+     * 线段与正北方向夹角
+     * @param line
+     * @returns
+     */
+    static angleOfLine(line: Polyline): number;
+    /**
+     * 在头尾两个方向上延长折线
+     * @param line
+     * @param distance
+     */
+    static extendLineInTowDir(line: Polyline, distance: number): Polyline;
+    /**
+     * 两条线的交点
+     * @param line1
+     * @param line2
+     * @returns
+     */
+    static getIntersectPointOfTwoLines(line1: Polyline, line2: Polyline): Promise<Point | undefined>;
+    /**
+     * 获取停止线与车道面的交点
+     * @param stopLine
+     * @param lanePolygon
+     * @param offsetDistances
+     * @returns
+     */
+    static getIntersectPointsOfStopLineAndLane(stopLine: Polyline, lanePolygon: Polygon, offsetDistances?: number[]): Promise<number[][]>;
+    /**
+     * 两个点之间的距离
+     * @param points
+     * @returns
+     */
+    private static pointDistance;
+    /**
+     * 线按一定距离平移之后，与面相交的两个端点
+     * @param line
+     * @param polygon
+     * @param offsetDistance 线平移的距离
+     * @returns 线面交线的头尾端点
+     */
+    static getIntersectPointOfLineAndPolygon(line: Polyline, polygon: Polygon, offsetDistance?: number): Promise<number[][]>;
+    /**
+     * 对polyline做平移
+     * @param line
+     * @param offsetDistance
+     * @returns 平移后的polyline
+     */
+    static getOffsetLine(line: Polyline, offsetDistance: number): Promise<Polyline>;
+    /**
+     * 解压
+     * @param key
+     * @returns
+     */
+    static unzip(key: string): string | undefined;
+}

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

@@ -0,0 +1,159 @@
+import { Point as y, Polyline as f } from "@arcgis/core/geometry";
+import * as g from "@arcgis/core/geometry/geometryEngineAsync";
+import * as u from "@arcgis/core/geometry/support/webMercatorUtils";
+import h from "@turf/bearing";
+import p from "@turf/destination";
+import * as a from "@turf/helpers";
+import w from "pako";
+class s {
+  /**
+   * 得到某个点在一定方向、距离之外的另一个点
+   * @param point
+   * @param angel
+   * @param distance
+   * @returns
+   */
+  static destinationWithPoint(t, e, n) {
+    const i = a.point([t.x, t.y]), o = p(i, n, e, {
+      units: "meters"
+    });
+    return new y({
+      x: o.geometry.coordinates[0],
+      y: o.geometry.coordinates[1]
+    });
+  }
+  /**
+   * 线段与正北方向夹角
+   * @param line
+   * @returns
+   */
+  static angleOfLine(t) {
+    const e = t.paths[0], n = a.point(e[0]), i = a.point(e[e.length - 1]);
+    return h(n, i);
+  }
+  /**
+   * 在头尾两个方向上延长折线
+   * @param line
+   * @param distance
+   */
+  static extendLineInTowDir(t, e) {
+    const n = t.paths[0], i = a.point(n[0]), o = a.point(n[1]), r = h(o, i), c = p(i, e, r, {
+      units: "meters"
+    }), l = r > 0 ? r - 180 : r + 180, P = p(o, e, l, {
+      units: "meters"
+    });
+    return new f({
+      paths: [
+        [c.geometry.coordinates, P.geometry.coordinates]
+      ]
+    });
+  }
+  /**
+   * 两条线的交点
+   * @param line1
+   * @param line2
+   * @returns
+   */
+  static async getIntersectPointOfTwoLines(t, e) {
+    const n = await g.intersectLinesToPoints(
+      t,
+      e
+    );
+    if (n.length)
+      return n[0];
+  }
+  /**
+   * 获取停止线与车道面的交点
+   * @param stopLine
+   * @param lanePolygon
+   * @param offsetDistances
+   * @returns
+   */
+  static async getIntersectPointsOfStopLineAndLane(t, e, n) {
+    let i = await s.getIntersectPointOfLineAndPolygon(
+      t,
+      e
+    );
+    if (await s.pointDistance(i) < 3 && n) {
+      for (const o of n)
+        if (i = await s.getIntersectPointOfLineAndPolygon(
+          t,
+          e,
+          o
+        ), await s.pointDistance(i) > 2.5) {
+          const r = new f({ paths: [i] });
+          return (await s.getOffsetLine(
+            r,
+            -o
+          )).paths[0];
+        }
+    } else
+      return i;
+    return [];
+  }
+  /**
+   * 两个点之间的距离
+   * @param points
+   * @returns
+   */
+  static async pointDistance(t) {
+    if (t.length < 2)
+      return 0;
+    const e = new f({ paths: [t] });
+    return await g.geodesicLength(e, "meters");
+  }
+  /**
+   * 线按一定距离平移之后，与面相交的两个端点
+   * @param line
+   * @param polygon
+   * @param offsetDistance 线平移的距离
+   * @returns 线面交线的头尾端点
+   */
+  static async getIntersectPointOfLineAndPolygon(t, e, n = 0) {
+    n !== 0 && (t = await s.getOffsetLine(t, n));
+    const i = await g.intersect(t, e);
+    if (i instanceof f) {
+      const o = i.paths[0], r = o[0], c = o[o.length - 1];
+      return [r, c];
+    }
+    return [];
+  }
+  /**
+   * 对polyline做平移
+   * @param line
+   * @param offsetDistance
+   * @returns 平移后的polyline
+   */
+  static async getOffsetLine(t, e) {
+    const n = u.geographicToWebMercator(t), i = await g.offset(
+      n,
+      e,
+      "meters"
+    );
+    return u.webMercatorToGeographic(
+      i,
+      !1
+    );
+  }
+  /**
+   * 解压
+   * @param key
+   * @returns
+   */
+  static unzip(t) {
+    try {
+      const e = [], n = t.split("");
+      for (let o = 0; o < n.length; o++) {
+        const r = n[o];
+        e.push(r.charCodeAt(0));
+      }
+      const i = new Uint8Array(e);
+      return w.inflate(i, { to: "string" });
+    } catch {
+      console.log(`非压缩内容: ${t}`);
+    }
+  }
+}
+export {
+  s as default
+};

package/es/src/gis-map/utils/holo-flow/index.d.ts

@@ -0,0 +1,15 @@
+import View from '@arcgis/core/views/View';
+export default class Index {
+    private readonly view;
+    private traceHoloFlow;
+    private signalHoloFlow;
+    constructor(view: View);
+    /**
+     * 处理全息流轨迹数据
+     * */
+    handleVehicleTraceData(data: any): void;
+    clearHoloTrace(): void;
+    updatePanelContent(contentType: string): void;
+    handleSignalData(data: any): Promise<void>;
+    clearHoloSignal(): void;
+}

package/es/src/gis-map/utils/holo-flow/index.mjs

@@ -0,0 +1,50 @@
+import { EVehiclePlateState as l } from "../../../types/index.mjs";
+import t from "./signal-holo-flow.mjs";
+import i from "./trace-holo-flow.mjs";
+class h {
+  constructor(a) {
+    this.view = a;
+  }
+  /**
+   * 处理全息流轨迹数据
+   * */
+  handleVehicleTraceData(a) {
+    this.traceHoloFlow || (this.traceHoloFlow = new i(this.view)), this.traceHoloFlow.handleVehicleTraceData(a);
+  }
+  clearHoloTrace() {
+    var a;
+    (a = this.traceHoloFlow) == null || a.clearTrace();
+  }
+  // public toggleVehiclePlate(visible: boolean): void {
+  //   this.traceHoloFlow?.togglePlateLayer(visible);
+  // }
+  updatePanelContent(a) {
+    var o;
+    let e = l.None;
+    switch (a) {
+      case "none":
+        e = l.None;
+        break;
+      case "plateNumber":
+        e = l.PlateNumber;
+        break;
+      case "vehicleId":
+        e = l.Id;
+        break;
+      case "mix":
+        e = l.Mix;
+        break;
+    }
+    (o = this.traceHoloFlow) == null || o.updatePanelContent(e);
+  }
+  async handleSignalData(a) {
+    this.signalHoloFlow || (this.signalHoloFlow = new t(this.view)), await this.signalHoloFlow.initializeLayer(), await this.signalHoloFlow.handleSignalData(a);
+  }
+  clearHoloSignal() {
+    var a;
+    (a = this.signalHoloFlow) == null || a.clearSignal();
+  }
+}
+export {
+  h as default
+};

package/es/src/gis-map/utils/holo-flow/signal-holo-flow.d.ts

@@ -0,0 +1,40 @@
+import View from '@arcgis/core/views/View';
+export default class SignalHoloFlow {
+    private view;
+    private mapConfig;
+    /** 显示停止线的图层 */
+    private phaseLineLayer;
+    /** 每个路口的当前相位 */
+    private currentPhaseMap;
+    /** 每个路口倒计时canvas */
+    private countdownCanvasMap;
+    private countdownWatchHandel;
+    private lastDataTime;
+    constructor(view: View);
+    /**
+     * 初始化相位线图层
+     * */
+    initializeLayer(): Promise<void>;
+    handleSignalData(data: any): Promise<void>;
+    /**
+     * 清除实时信号相关图层
+     * */
+    clearSignal(): void;
+    private isDeletingCanvas;
+    /**
+     * 获取显示倒计时的canvas
+     * */
+    private updateCountdown;
+    private drawCountdownText;
+    private updatePhaseLine;
+    /**
+     * 车道是否在通道中
+     * @param laneCode 车道编码
+     * @param channels 通道列表
+     * @returns
+     */
+    private isLaneInChannels;
+    private readonly canvasWidth;
+    private readonly canvasHeight;
+    private createCountdownCanvas;
+}