map-tool/src/components/mapJK.vue

<template>
  <div id="map_jk">
    <div id="mapDiv" ref="map">
      <div id="viewDiv" ref="view">
        <div id="menu" class="esri-widget">
        </div>
      </div>
      <div id="viewDiv_2D" ref="view_2D">
        <div id="menu" class="esri-widget">
        </div>
      </div>
      <div id = "overviewDiv" ref = "overview" >

      </div>
    </div>
  </div>
</template>

<script>
import $ from 'jquery';
import {getCurrentInstance, onMounted} from "vue";
import SetMapConfig from "../units/map/SetMapConfig.js"
import InitMap from "../units/map/InitMap.js";
import AddBaseMapLayer from "../units/map/AddBaseMapLayer.js";
import AddSingleLayer from "../units/map/AddSingleLayer.js";
import WaterEffect from "../units/map/WaterEffect.js";
import Measurement from "../units/map/Measurement.js";
import SunshineAnalysis from "../units/map/SunshineAnalysis.js";
import AddPointEvent from "../units/map/AddPointEvent.js";
import SetPopupOptions from "../units/map/SetPopuopOptions";
import AddScaleEvent from "../units/map/AddScaleEvent";
import ViewShedAnalysisWidget from "../units/map/ViewShedAnalysis.js";
import AddLightBallEvent from "../units/map/AddLightBallEvent.js";
import AddThreeGridEvent from "../units/map/addThreeGridEvent.js";
import LimitHeightAnalysis from "../units/map/LimitHeightAnalysis.js";
import SetLocation from "../units/map/SetLocation.js";
import GeometryMeshPrismEffect from "../units/map/GeometryMeshPrismEffect.js";
import ReRenderingEvent from "../units/map/ReRenderingEvent.js";
import PathPipeEvent from "../units/map/PathPipeEvent.js";
import FlyGLTFEvent from "../units/map/FlyGLTFEvent.js";
import AddDrawEvent from "../units/map/addDrawEvent.js";
import SymbolPathPipeEvent from "../units/map/SymbolPathPipeEvent.js";
import SymbolPointCubeEvent from "../units/map/SymbolPointCubeEvent.js";
import AddThreeCubeEvent from "../units/map/AddThreeCubeEvent.js";
import AddThreeCubeDetailEvent from "../units/map/AddThreeCubeDetailEvent.js";
import AddThreeNetEvent from "../units/map/AddThreeNetEvent.js";
import ws from 'ws';

import Path from '../config/path_wjc.json'
import routeList from '../config/routeList.json'

import {
  getAvoidRoute,
  getBuildingPoint,
  getNoFlyPointInterface, getPowerInterface, getPowerPoint,
  getRiverPointInterface,
  getRoadPointInterface, gridBaseInfo
} from "../service/http.js";
import FeaturePointsPlottingEvent from "../units/map/FeaturePointsPlottingEvent.js";
import FeaturePolygonPlottingEvent from "../units/map/FeaturePolygonPlottingEvent.js";
import HeatMap from "../units/map/HeatMap.js";
export default {
  name: "mapJK",
  setup(){
    let socket = null;
    let virtualSocket = null;
    const ctx = getCurrentInstance();
    const bus = ctx?.appContext.config.globalProperties.$bus;
    let MapReady = null;
    let m_spatialReference = null;
    let m_fullExtent = null;
    let m_initialExtent = null;
    let m_view;
    let m_map;
    let measureWidget = null;
    let sunshineWidget = null;
    let m_handles = [];
    let viewShedAnalysisWidget = null;
    let addLightBallEvent = null;
    let addThreeGridEvent = null;
    let addThreeCubeEvent = null;
    //let addThreeCubeDetailEvent = null;
    let powerDataList = [];
    let addThreeCubeDetailInstance = {};
    let addThreeNetEvent = null;
    let limitHeightAnalysisEvent = null;
    let reRenderingEvent = null;
    let pathPipeInstance = {};
    let flyGLTFInstances = {};
    let addDrawEvent = null;
    let draw_GeometryMeshPrismEffectEvent = null;
    let symbolPathPipeEvent = null;
    let symbolPointCubeEvent = null;
    let featurePointsPlottingEvent = null;
    let currentShowGridId = null;
    onMounted(() =>{
      bus.on('CreateMap',() =>{
        MapReady = $.Deferred();
        createMap();
        $.when((MapReady).done(()=>{
          //发送消息
          bus.emit('SendMessage',{
            action:"MapIsReady",
            data:{
              "message":"地图初始化完成"
            }
          })
        }))
      })
      //调用方法
      bus.on('InvokeMethod',(data) =>{
        invokeMethod(data);
      })
      function createMap(){
        let setMapConfig = new SetMapConfig({
          m_spatialReference,
          m_fullExtent,
          m_initialExtent,
          m_handles
        })
        m_spatialReference = setMapConfig.m_spatialReference;
        m_fullExtent = setMapConfig.m_fullExtent;
        m_initialExtent = setMapConfig.m_initialExtent;
        m_handles = setMapConfig.m_handles;
        let initMap = new InitMap({
          m_map,
          m_view,
          m_spatialReference,
          bus
        });
        m_map = initMap.m_map;
        m_view = initMap.m_view;
      }
      function invokeMethod(data){
        //后续设置验证token
        runMethod(data);
      }
      function runMethod(data){
        let methodname = data.methodname;
        let params = data.params;
        if(typeof (params) != "string"&& params)
          params = eval(params);
        switch (methodname) {
          case "SetBackground":
            setBackground(params);
            break;
          case "SetLocation":
            setLocation(params);
            break;
          case "AddBaseMapLayer":
            addBaseMapLayer(params);
            break;
          case "AddSingleLayer":
            addSingleLayer(params);
            break;
          case "ReRendering":
            reRendering(params);
            break;
          case "WaterEffect":
            waterEffect(params);
            break;
          case "HeatMap":
            heatMap(params);
            break;
          case "Measurement":
            measurement(params);
            break;
          case "SunshineAnalysis":
            sunshineAnalysis(params);
            break
          case "AccessFeaturesWithPointEvents":
            accessFeaturesWithPointEvents(params);
            break;
          case "ShowLayersWithScaleEvents":
            showLayersWithScaleEvents(params);
            break;
          case "ViewshedAnalysis":
            viewshedAnalysis(params);
            break;
          case "FeatureLayerThreeDimension":
            featureLayerThreeDimension(params);
            break;
          case "AddLightBall":
            addLightBall(params);
            break;
          case "ThreeGrid":
            threeGrid(params);
            break;
          case "ShowThreeCube":
            showThreeCube(params);
            break;
          case "ShowThreeCubeDetail":
            showThreeCubeDetail(params);
            break;
          case "GetAllPowerPoints":
            getAllPowerPoints(params);
            break;
          case "ShowBuildingThreeCubeByInterface":
            showBuildingThreeCubeByInterface(params);
            break;
          case "ShowNoFlyThreeCubeByInterface":
            showNoFlyThreeCubeByInterface(params);
            break;
          case "ShowNoFlyThreeCubeDetailByInterface":
            showNoFlyThreeCubeDetailByInterface(params);
            break;
          case "ShowRoadThreeCubeByInterface":
            showRoadThreeCubeByInterface(params);
            break;
          case "ShowRoadThreeCubeDetailByInterface":
            showRoadThreeCubeDetailByInterface(params);
            break;
          case "ShowRiverThreeCubeByInterface":
            showRiverThreeCubeByInterface(params);
            break;
          case "ShowRiverThreeCubeDetailByInterface":
            showRiverThreeCubeDetailByInterface(params);
            break;
          case "ShowThreeNet":
            showThreeNet(params);
            break;
          case "RealPositionGrid":
            realPositionGrid(params);
            break;
          case "LimitHeightAnalysis":
            limitHeightAnalysis(params);
            break;
          case "GeometryMeshPrismEffect":
            geometryMeshPrismEffect(params);
            break;
          case "PathPipe":
            pathPipe(params);
            break;
          case "FlyGLTF":
            flyGLTF(params);
            break;
          case "Draw":
            draw(params);
            break;
          case "Draw_GeometryMeshPrismEffect":
            draw_GeometryMeshPrismEffect(params);
            break;
          case "SymbolPathPipe":
            symbolPathPipe(params);
            break;
          case "SymbolPointCube":
            symbolPointCube(params);
            break;
          case "FeaturePointsPlotting":
            featurePointsPlotting(params);
            break;
          case "FeaturePolygonPlotting":
            featurePolygonPlotting(params);
            break;
          case "GetRealFlyPoint":
            getRealFlyPoint(params);
            break;
          case "GetVirtualFlyPoint":
            getVirtualFlyPoint(params);
            break;
          case "ChangePointStatus":
            changePointStatus(params);
            break;
          case "GetRealPower":
            getRealPower(params);
            break;
          case "GetRealPower2":
            getRealPower2(params);
            break;
          case "PathConflict":
            pathConflict(params);
            break;
          case "UavBatteryWarning":
            uavBatteryWarning(params);
            break;
          case "UavYawWarning":
            uavYawWarning(params);
            break;
          case "Conflict_fly":
            conflict_fly(params);
            break;
          case "SituationAssessment":
            situationAssessment(params);
            break;

        }
      }
      function setBackground(params){

      }
      function setLocation(params){
        let setLocation = new SetLocation({
          view:m_view,
          x:params.x,
          y:params.y,
          z:params.z,
          heading:params.heading,
          tilt:params.tilt,
          isfly:params.isfly,
        });
        setLocation.start();
      }
      function addBaseMapLayer(params){
        let addBaseMapLayer = new AddBaseMapLayer({
          id:params.id,
          title:params.title,
          visible:params.visible,
          opacity:params.opacity,
          url:params.url,
          m_spatialReference,
          m_fullExtent,
        })
        m_view.map.basemap = addBaseMapLayer.basemap;
      }
      function addSingleLayer(params){
        let addSingleLayer = new AddSingleLayer({
          m_map,
          type:params.type,
          id:params.id,
          title:params.title,
          visible:params.visible,
          opacity:params.opacity,
          url:params.url,
          popupEnabled:params.popupEnabled,
          renderer:params.renderer,
          elevationInfo:params.elevationInfo
        })
        let layer = addSingleLayer.layer;
        m_map.add(layer);
      }
      function getSymbol(params){
        return {
          type: "mesh-3d",
          symbolLayers: [{
            type: "fill",
            material: {
              color: params.color
            },
            edges: {
              type: "solid",
              color:[255, 255, 255],
            }
          }]
        };
      }
      function reRendering(params){
        let ids_1 = [];
        for(let i=0;i<10000;i++){
          ids_1.push(i);
        }
        let ids_2 = [];
        for(let i=10000;i<20000;i++){
          ids_2.push(i);
        }
        let renderer = {
          type:"unique-value",
          defaultSymbol: getSymbol({color: [0, 255, 0,0.8]}),
          defaultLabel: "Other",
          field: "OBJECTID",
          uniqueValueInfos: [
          ]
        };
        // 每秒更新一次网格颜色
        setInterval(() => {
          renderer.uniqueValueInfos = []
        // 定义分组和对应的颜色
        const groups = {
          group1: {
            ids: ids_1, // 分组1的 ID 列表
            color: [Math.floor(Math.random() * 256), Math.floor(Math.random() * 256), Math.floor(Math.random() * 256), 0.8] // 红色
          },
          group2: {
            ids: ids_2, // 分组3的 ID 列表
            color: [Math.floor(Math.random() * 256), Math.floor(Math.random() * 256), Math.floor(Math.random() * 256), 0.8] // 蓝色
          }
        };
        // 遍历分组，动态生成渲染规则
        Object.keys(groups).forEach(groupKey => {
          const group = groups[groupKey];
          group.ids.forEach(id => {
            renderer.uniqueValueInfos.push({
              value: id, // 对应的 ID
              symbol: getSymbol(group)
            });
          });
        });
        if(reRenderingEvent == null){
          reRenderingEvent = new ReRenderingEvent({
            m_map,
            type:"scene",
            id:"WhiteMold",
            renderer:renderer
          });
        }
        reRenderingEvent.ReRendering();
        }, 5000);
      }
      function waterEffect(params){
        params.id = "waterLayer";
        if(params.status === "hide"){
          let layer = m_map.layers.find(item => item.id === params.id);
          m_map.remove(layer);
          return
        }
        if(params.status === "show"){
          let layer = m_map.layers.find(item => item.id === params.id);
          if(typeof layer === "undefined"){
            let waterEffect = new WaterEffect({
              id:params.id,
              url:params.url,
              waveDirection:params.waveDirection,
              waveStrength:params.waveStrength,
              color:params.color
            })
            layer = waterEffect.layer;
            m_map.add(layer);
          }else{
            m_view.environment.lighting.waterReflectionEnabled = true;
            const renderer = layer.renderer.clone();
            renderer.symbol.symbolLayers.getItemAt(0).waveDirection = params.waveDirection;
            renderer.symbol.symbolLayers.getItemAt(0).waveStrength = params.waveStrength;
            renderer.symbol.symbolLayers.getItemAt(0).color = params.color;
            layer.renderer = renderer;
          }
        }
      }

      function heatMap(params){
        params.id = "heatMap";
        if(!params.visible){
          let layer = m_map.layers.find(item => item.id === params.id);
          m_map.remove(layer);
          return
        }
        if(params.visible){
          let layer = m_map.layers.find(item => item.id === params.id);
          if(typeof layer === "undefined"){
            let heatMap = new HeatMap({
              id:params.id,
              url:params.url,
              waveDirection:params.waveDirection,
              waveStrength:params.waveStrength,
              color:params.color
            })
            layer = heatMap.layer;
            m_map.add(layer);
          }
        }
      }

      function measurement(params){
        let status = params.status;
        let type = params.type;
        let position = params.position;
        if(status === "hide"){
          if(measureWidget !== null){
            m_view.ui.remove(measureWidget);
            measureWidget.destroy();
            measureWidget = null;
          }
          return
        }
        if(status === "show"){
          if(measureWidget === null){
            let measurement = new Measurement({
              view:m_view,
              type
            })
            measureWidget = measurement.widget;
          }
          m_view.ui.add(measureWidget,position);
        }
      }
      function sunshineAnalysis(params){
        let status = params.status;
        let position = params.position;
        if(status === "hide"){
          if(sunshineWidget !== null){
            m_view.ui.remove(sunshineWidget);
            sunshineWidget.destroy();
            sunshineWidget = null;
          }
          return
        }
        if(status === "show"){
          if(sunshineWidget === null){
            let sunshineAnalysis = new SunshineAnalysis({
              view:m_view
            })
            sunshineWidget = sunshineAnalysis.widget;
          }
          m_view.ui.add(sunshineWidget,position);
        }
      }
      function accessFeaturesWithPointEvents(params){
        let status = params.status;
        let mouse_handle_id = params.mouse_handle_id;
        let highlight_handle_id = params.highlight_handle_id;
        if(status === "hide"){
          if(m_handles.has(mouse_handle_id)){
            m_handles.remove(mouse_handle_id);
          }
          if(m_handles.has(highlight_handle_id)){
            m_handles.remove(highlight_handle_id);
          }
          return
        }
        if(status === "show"){
          let type = params.type;
          let mouseTime = params.mouse_time;
          let popupTitle = params.popup_title;
          if(m_handles.has(mouse_handle_id)){
            m_handles.remove(mouse_handle_id);
          }
          if(m_handles.has(highlight_handle_id)){
            m_handles.remove(highlight_handle_id);
          }
          let addPointEvent = new AddPointEvent({
            m_view,
            type,
            highlightHandleId:highlight_handle_id,
            mouseTime,
            popupTitle,
            callbackFunction:accessFeaturesWithPointEventsReturn
          });
          m_handles.add(addPointEvent.mouseHandle,mouse_handle_id);
        }
      }
      function accessFeaturesWithPointEventsReturn(screenPoint,handleId,popupTitle){
        if(m_handles.has(handleId)){
          m_handles.remove(handleId);
        }
        m_view.hitTest(screenPoint).then((response) =>{
          if(response.results.length > 0){
            let result = response.results[0];
            m_view.whenLayerView(result.graphic.layer).then((lyrView) =>{
              let highlightHandle = lyrView.highlight(result.graphic);
              m_handles.add(highlightHandle,handleId);
            })
            let setPopupOptions = new SetPopupOptions({
              title:popupTitle,
              location:m_view.toMap(screenPoint),
              content:result.graphic.attributes
            })
            m_view.popup.open(setPopupOptions.popupOptions());
          }
        })
      }
      function showLayersWithScaleEvents(params){
        let status = params.status;
        let scale_handle_id = params.scale_handle_id;
        if(status === "hide"){
          if(m_handles.has(scale_handle_id)){
            m_handles.remove(scale_handle_id);
          }
          return
        }
        if(status === "show"){
          if(m_handles.has(scale_handle_id)){
            m_handles.remove(scale_handle_id);
          }
          let addScaleEvent = new AddScaleEvent({
            m_view,
            callBackFunction:showLayersWithScaleEventsReturn
          });
          m_handles.add(addScaleEvent.scaleHandle,scale_handle_id);
        }
      }

      function showThreeCube(params){
        let status = params.status;
        if(status == "hide"){
          if(addThreeCubeEvent){
            addThreeCubeEvent.clear();
            addThreeCubeEvent = null;
          }
          return
        }
        let size = params.size;
        let points = params.points;
        // 初始化 AddThreeCubeEvent，暂时不启动
        addThreeCubeEvent = new AddThreeCubeEvent({
          view: m_view,
          points:points,
          size,
        });
        addThreeCubeEvent.init();
      }




      function showThreeCubeDetail(params){
        let status = params.status;
        let id = params.id;
        let depthTest = params.depthTest;
        if(depthTest == undefined){
          depthTest = true;
        }
        if(status == "hide"){
          if(addThreeCubeDetailInstance[id]){
            addThreeCubeDetailInstance[id].clear();
            addThreeCubeDetailInstance[id] = null;
          }
          return
        }
        let size = params.size;
        if(addThreeCubeDetailInstance[id]){
          addThreeCubeDetailInstance[id].add(params.points);
        }else{
          let addThreeCubeDetailEvent = new AddThreeCubeDetailEvent({
            view: m_view,
            points:params.points,
            size,
            bus,
            depthTest
          });
          addThreeCubeDetailEvent.start();
          addThreeCubeDetailInstance[id] = addThreeCubeDetailEvent;
        }
      }


      // 递归获取所有建筑点的辅助函数
      function getAllPowerPoints(level,scrollId = null) {
        getPowerInterface({
          x: m_view.camera.position.x,
          y: m_view.camera.position.y,
          //level: level,
          scrollId: scrollId,
        }).then(res =>{
          if(res.data.data.list?.length >= 10000 && res.data.data.scrollId){
            powerDataList =  powerDataList.concat(res.data.data.list);
            getAllPowerPoints(level,res.data.data.scrollId);
          }else{
            powerDataList =  powerDataList.concat(res.data.data.list);
            // 初始化 AddThreeCubeEvent，暂时不启动
            powerDataList.forEach((item)=>{
              item.color = getColor(item.averageValue, -100, 0);
            })

            let size = {
              x:13.223015683766334,
              y:15.404125436905815,
              z:13.471596544164798
            }
            let para = {
              id:"1",
              status:"show",
              size,
              points:powerDataList
            }
            //symbolPointCube(para)
            showThreeCubeDetail(para);
          }
        })
      }


      function getColor(value, minValue, maxValue) {
        // 边界处理
        if (value < minValue) value = minValue;
        if (value > maxValue) value = maxValue;
        // 映射到 [0, 1]
        let t = (value - minValue) / (maxValue - minValue);
        // 定义颜色
        let r, g, b;
        if (t <= 0.5) {
          // 从红色到黄色
          r = 1;
          g = t * 2; // 线性插值增加绿色
          b = 0;
        } else {
          // 从黄色到绿色
          r = 2 * (1 - t); // 线性插值减少红色
          g = 1;
          b = 0;
        }
        return [r, g, b];
      }


      function showBuildingThreeCubeByInterface(params){
        let status = params.status;
        let size = params.size;
        if(addThreeCubeEvent){
          addThreeCubeEvent.clear();
          addThreeCubeEvent = null;
        }
        if(status == "hide"){
          return
        }
        let level = params.level;
        // 初始化 AddThreeCubeEvent，暂时不启动
        addThreeCubeEvent = new AddThreeCubeEvent({
          view: m_view,
          size,
        });
        addThreeCubeEvent.start();
        // 获取所有建筑点数据
        getAllBuildingPoints(level);
      }

      function showNoFlyThreeCubeDetailByInterface(params){
        let status = params.status;
        let size = params.size;
        if(addThreeCubeEvent){
          addThreeCubeEvent.clear();
          addThreeCubeEvent = null;
        }
        if(status == "hide"){
          return
        }
        let level = params.level;
        getNoFlyPointInterface({
          x: m_view.camera.position.x,
          y: m_view.camera.position.y,
          level: level,
          scrollId: "",
        }).then(res =>{
          res.data.data.list.forEach(item =>{
            item.color = [1,0,0]
          })
          // 初始化 AddThreeCubeEvent，暂时不启动
          let addThreeCubeDetailEvent = new AddThreeCubeDetailEvent({
            view: m_view,
            points:res.data.data.list,
            size,
            bus
          });
          addThreeCubeDetailEvent.start();
        })
      }

      function showNoFlyThreeCubeByInterface(params){
        let status = params.status;
        let size = params.size;
        if(addThreeCubeEvent){
          addThreeCubeEvent.clear();
          addThreeCubeEvent = null;
        }
        if(status == "hide"){
          return
        }
        let level = params.level;
        // 初始化 AddThreeCubeEvent，暂时不启动
        addThreeCubeEvent = new AddThreeCubeEvent({
          view: m_view,
          size,
        });
        addThreeCubeEvent.start();
        // 获取所有建筑点数据
        getNoFlyPoint(level);
      }

      function showRoadThreeCubeByInterface(params){
        let status = params.status;
        let size = params.size;
        if(addThreeCubeEvent){
          addThreeCubeEvent.clear();
          addThreeCubeEvent = null;
        }
        if(status == "hide"){
          return
        }
        let level = params.level;
        // 初始化 AddThreeCubeEvent，暂时不启动
        addThreeCubeEvent = new AddThreeCubeEvent({
          view: m_view,
          size,
        });
        addThreeCubeEvent.start();
        // 获取所有建筑点数据
        getRoadPoint(level);
      }

      function showRoadThreeCubeDetailByInterface(params){
        let status = params.status;
        let size = params.size;
        if(addThreeCubeEvent){
          addThreeCubeEvent.clear();
          addThreeCubeEvent = null;
        }
        if(status == "hide"){
          return
        }
        let level = params.level;
        getRoadPointInterface({
          x: m_view.camera.position.x,
          y: m_view.camera.position.y,
          level: level,
          scrollId: "",
        }).then(res =>{
          res.data.data.list.forEach(item =>{
            item.color = [0,0,1]
          })
          // 初始化 AddThreeCubeEvent，暂时不启动
          let addThreeCubeDetailEvent = new AddThreeCubeDetailEvent({
            view: m_view,
            points:res.data.data.list,
            size,
            bus
          });
          addThreeCubeDetailEvent.start();
        })
      }


      function showRiverThreeCubeByInterface(params){
        let status = params.status;
        let size = params.size;
        if(addThreeCubeEvent){
          addThreeCubeEvent.clear();
          addThreeCubeEvent = null;
        }
        if(status == "hide"){
          return
        }
        let level = params.level;
        // 初始化 AddThreeCubeEvent，暂时不启动
        addThreeCubeEvent = new AddThreeCubeEvent({
          view: m_view,
          size,
        });
        addThreeCubeEvent.start();
        // 获取所有建筑点数据
        getRiverPoint(level);
      }

      function showRiverThreeCubeDetailByInterface(params){
        let status = params.status;
        let size = params.size;
        if(addThreeCubeEvent){
          addThreeCubeEvent.clear();
          addThreeCubeEvent = null;
        }
        if(status == "hide"){
          return
        }
        let level = params.level;
        getRiverPointInterface({
          x: m_view.camera.position.x,
          y: m_view.camera.position.y,
          level: level,
          scrollId: "",
        }).then(res =>{
          res.data.data.list.forEach(item =>{
            item.color = [1,1,0]
          })
          // 初始化 AddThreeCubeEvent，暂时不启动
          let addThreeCubeDetailEvent = new AddThreeCubeDetailEvent({
            view: m_view,
            points:res.data.data.list,
            size,
            bus
          });
          addThreeCubeDetailEvent.start();
        })
      }


      function showThreeNet(params){
        let status = params.status;
        if(addThreeNetEvent){
          addThreeNetEvent.clear();
          addThreeNetEvent = null;
        }
        if(status == "hide"){
          return
        }
        let size = params.size;
        let origin = params.origin;
        let buffer = params.buffer;
        let maxHeight = params.maxHeight;
        let minHeight = params.minHeight;
        //另一类是网加载（网只根据范围变化）
        addThreeNetEvent = new AddThreeNetEvent({
          view: m_view,
          size,
          origin,
          buffer,
          maxHeight,
          minHeight
        });
        addThreeNetEvent.start();
      }

      // 递归获取所有建筑点的辅助函数
      function getAllBuildingPoints(level,scrollId = null) {
        getBuildingPoint({
          x: m_view.camera.position.x,
          y: m_view.camera.position.y,
          level: level,
          scrollId: scrollId,
        }).then(res =>{
          if(res.data.data.list?.length >= 10000 && res.data.data.scrollId){
            addThreeCubeEvent.addPoints(res.data.data.list);
            getAllBuildingPoints(level,res.data.data.scrollId);
          }else{
            addThreeCubeEvent.addPoints(res.data.data.list);
          }
        })
      }


      // 递归获取所有建筑点的辅助函数
      function getNoFlyPoint(level,scrollId = null) {
        getNoFlyPointInterface({
          x: m_view.camera.position.x,
          y: m_view.camera.position.y,
          level: level,
          scrollId: scrollId,
        }).then(res =>{
          if(res.data.data.list?.length >= 10000 && res.data.data.scrollId){
            addThreeCubeEvent.addPoints(res.data.data.list);
            getNoFlyPoint(level,res.data.data.scrollId);
          }else{
            addThreeCubeEvent.addPoints(res.data.data.list);
          }
        })
      }


      // 递归获取所有道路点的辅助函数
      function getRoadPoint(level,scrollId = null) {
        getRoadPointInterface({
          x: m_view.camera.position.x,
          y: m_view.camera.position.y,
          level: level,
          scrollId: scrollId,
        }).then(res =>{
          if(res.data.data.list?.length >= 10000 && res.data.data.scrollId){
            addThreeCubeEvent.addPoints(res.data.data.list);
            getRoadPoint(level,res.data.data.scrollId);
          }else{
            addThreeCubeEvent.addPoints(res.data.data.list);
          }
        })
      }

      // 递归获取所有河流点的辅助函数
      function getRiverPoint(level,scrollId = null) {
        getRiverPointInterface({
          x: m_view.camera.position.x,
          y: m_view.camera.position.y,
          level: level,
          scrollId: scrollId,
        }).then(res =>{
          if(res.data.data.list?.length >= 10000 && res.data.data.scrollId){
            addThreeCubeEvent.addPoints(res.data.data.list);
            getRiverPoint(level,res.data.data.scrollId);
          }else{
            addThreeCubeEvent.addPoints(res.data.data.list);
          }
        })
      }

      //全市格网自定义分割效果加载
      // function showLayersWithScaleEventsReturn(scaleValue){
      //   let eyeExtent = getEyeExtent();
      //   if(!eyeExtent){
      //     return
      //   }
      //   let height = m_view.camera.position.z;
      //   console.log("height",height,"scale",m_view.scale);
      //   let sizeObj = extentGridLimit({
      //     eyeExtent,
      //     height
      //   });
      //   let size = sizeObj.size;
      //   let opacity = sizeObj.opacity;
      //   let layerHeight;
      //   if(size > 400){
      //     layerHeight = 400;
      //   }else{
      //     layerHeight = size;
      //   }
      //   if(addThreeGridEvent){
      //     addThreeGridEvent.extent = {minX:eyeExtent.xmin,maxX:eyeExtent.xmax,minY:eyeExtent.ymin,maxY:eyeExtent.ymax};
      //     addThreeGridEvent.height = height>1200?1200:height;
      //     addThreeGridEvent.size = size;
      //     addThreeGridEvent.layerHeight = layerHeight;
      //     addThreeGridEvent.gridEnabled = true;
      //     addThreeGridEvent.netEnabled = true;
      //     addThreeGridEvent.opacity = opacity;
      //     addThreeGridEvent.start();
      //   }else{
      //     addThreeGridEvent = new AddThreeGridEvent({
      //       view:m_view,
      //       extent: {minX:eyeExtent.xmin,maxX:eyeExtent.xmax,minY:eyeExtent.ymin,maxY:eyeExtent.ymax},
      //       height:height>1200?1200:height,
      //       size:size,
      //       gridEnabled : true,
      //       netEnabled : true,
      //       opacity:opacity,
      //       layerHeight:layerHeight,
      //     })
      //     addThreeGridEvent.start();
      //   }
      //
      // }
      //
      //格网范围限制
      // function extentGridLimit(params){
      //   try{
      //     //let size = [7.73,61.84,123.69,1850];
      //     let size = [
      //       {
      //         value:7.73,
      //         opacity:0.05
      //       },
      //       {
      //         value:61.84,
      //         opacity:0.05
      //       },
      //       {
      //         value:123.69,
      //         opacity:0.15
      //       },
      //       {
      //         value:1850,
      //         opacity:0.3
      //       }
      //     ]
      //     params.eyeExtent = {
      //       xmin: params.eyeExtent.xmin < -60000?-60000:params.eyeExtent.xmin,
      //       ymin: params.eyeExtent.ymin < -60000?-60000:params.eyeExtent.ymin,
      //       xmax: params.eyeExtent.xmax > 60000?60000:params.eyeExtent.xmax,
      //       ymax: params.eyeExtent.ymax > 70000?70000:params.eyeExtent.ymax,
      //     }
      //     params.height = params.height < 1200?params.height:1200;
      //     for(let i = 0;i<size.length;i++){
      //       let xCount = Math.floor((params.eyeExtent.xmax - params.eyeExtent.xmin) / size[i].value);
      //       let yCount = Math.floor((params.eyeExtent.ymax - params.eyeExtent.ymin) / size[i].value);
      //       let zCount = Math.floor(params.height / size[i].value);
      //       let count = xCount * yCount * zCount;
      //       if(count < 200000){
      //         return {
      //           size: size[i].value,
      //           opacity: size[i].opacity
      //         }
      //       }
      //     }
      //   }catch(e){
      //     console.log("params",params)
      //   }
      // }
      // function getEyeExtent() {
      //   const screenWidth = m_view.width;
      //   const screenHeight = m_view.height;
      //
      //   // 四个角的像素坐标
      //   const screenCorners = [
      //     { x: 0, y: 0 }, // 左上角
      //     { x: screenWidth, y: 0 }, // 右上角
      //     { x: screenWidth, y: screenHeight }, // 右下角
      //     { x: 0, y: screenHeight }, // 左下角
      //   ];
      //
      //   // 将屏幕角坐标转为地图坐标
      //   const mapPoints = screenCorners.map((screenPoint) => m_view.toMap(screenPoint)).filter(p => p);
      //
      //   // 添加 camera.position 到 mapPoints
      //   const cameraPoint = m_view.camera.position;
      //
      //   if (mapPoints.length < 4) {
      //     if (cameraPoint) {
      //       const bufferDistance = 2000; // 2公里
      //       const spatialReference = m_view.spatialReference;
      //
      //       const screenExtent = {
      //         xmin: cameraPoint.x - bufferDistance,
      //         ymin: cameraPoint.y - bufferDistance,
      //         xmax: cameraPoint.x + bufferDistance,
      //         ymax: cameraPoint.y + bufferDistance,
      //         spatialReference: spatialReference,
      //       };
      //       console.warn("视图范围不足4个有效点，使用摄像机位置生成的2公里范围。");
      //       console.log(screenExtent);
      //       return screenExtent;
      //     } else {
      //       console.warn("无法获取摄像机位置，请检查视图状态。");
      //       return null;
      //     }
      //   } else {
      //     try {
      //       // 获取最小和最大坐标值
      //       const xmin = Math.min(...mapPoints.map((p) => p.x));
      //       const ymin = Math.min(...mapPoints.map((p) => p.y));
      //       const xmax = Math.max(...mapPoints.map((p) => p.x));
      //       const ymax = Math.max(...mapPoints.map((p) => p.y));
      //
      //       const screenExtent = {
      //         xmin: xmin,
      //         ymin: ymin,
      //         xmax: xmax,
      //         ymax: ymax,
      //         spatialReference: m_view.spatialReference,
      //       };
      //       console.log(screenExtent);
      //       return screenExtent;
      //     } catch (e) {
      //       console.error("获取地图范围时出错：", e);
      //       return null;
      //     }
      //   }
      // }



      //不同比例尺加载白膜
      function showLayersWithScaleEventsReturn(scaleValue){
        let layer = m_map.layers.find(item => item.id === "WhiteMold");
        if(scaleValue > 50000){
          if(layer){
            layer.visible = false;
          }
        }else{
          if(layer){
            layer.visible = true;
          }
        }
      }
      function viewshedAnalysis(params){
        let status = params.status;
        if(status === "hide"){
          if(viewShedAnalysisWidget !== null){
            viewShedAnalysisWidget.clearAnalysis();
          }
          return
        }
        if(status === "show"){
          if(viewShedAnalysisWidget === null){
            viewShedAnalysisWidget = new ViewShedAnalysisWidget({  view:m_view  });
            viewShedAnalysisWidget.startAnalysis();
          }
        }
      }
      function featureLayerThreeDimension(params){
        let status = params.status;

      }
      function addLightBall(params){
        let status = params.status;
        if(addLightBallEvent){
          addLightBallEvent.clear();
          addLightBallEvent = null;
        }
        if(status === "hide"){
          return
        }
        addLightBallEvent = new AddLightBallEvent({
          view:m_view
        })
        addLightBallEvent.start()
      }
      function threeGrid(params){
        let status = params.status;
        if(status == "hide"){
          if(addThreeGridEvent){
            addThreeGridEvent.clear();
            addThreeGridEvent = null;
          }
          return
        }
        let animationEnabled = false;
        if(params.animationEnabled){
          animationEnabled = params.animationEnabled;
        }
        if(addThreeGridEvent){
          addThreeGridEvent.height = params.height;
          addThreeGridEvent.size = params.size;
          addThreeGridEvent.layerHeight = params.layerHeight;
          addThreeGridEvent.animationEnabled = animationEnabled;
          addThreeGridEvent.gridEnabled = true;
          addThreeGridEvent.netEnabled = true;
          addThreeGridEvent.start();
        }else{
          addThreeGridEvent = new AddThreeGridEvent({
            view:m_view,
            extent : {minX:2176,maxX:6048,minY:-1024,maxY:1352},
            height : params.height,
            size : params.size,
            layerHeight :params.layerHeight,
            gridEnabled:true,
            netEnabled:true,
            animationEnabled
          })
          addThreeGridEvent.start();
        }
      }

      function threeGridDetail(params){

      }

      function realPositionGrid(params){
        let status = params.status;

      }

      function limitHeightAnalysis(params){
        let status = params.status;
        if(limitHeightAnalysisEvent){
          limitHeightAnalysisEvent.clear();
          limitHeightAnalysisEvent =null;
        }
        if(status == "hide"){
          return
        }
        limitHeightAnalysisEvent = new LimitHeightAnalysis({
          view:m_view,
          map:m_map,
          layerId:params.layerId,
          limitH:params.limitH,
          maxLimitH:params.maxLimitH,
          rings:params.rings,
        });
        limitHeightAnalysisEvent.start()
      }

      function geometryMeshPrismEffect(params){
        let status = params.status;
        let f_layer = m_map.layers.find(item => item.id === "geometryMeshPrismEffect");
        if (f_layer) {
          m_map.remove(f_layer);
        }
        if(status == "hide"){
          return
        }
        let geometryMeshPrismEffect = new GeometryMeshPrismEffect({
          view:m_view,
          m_map,
          items:params.items,
          startHeight:params.startHeight,
          rings:params.rings
        });
        m_map.add(geometryMeshPrismEffect.graphicsLayer);
      }

      // 路径冲突
      function pathConflict(params){

        pathPipe({
          "id": "conflict1",
          "status": "show",
          "paths":Path.path_conflict_1,
          "color": "#438EDB",
          "intensity": 1.2,
          "pipeRadius": 5
        });
        pathPipe({
          "id": "conflict2",
          "status": "show",
          "paths":Path.path_conflict_2,
          "color": "#438EDB",
          "intensity": 1.2,
          "pipeRadius": 5
        });

        getRealFlyPoint({
          flyList:[
            {
              "id": "67513a6e-7ce2-4121-9b11-cd6f1d28e02c",
              "speed":40,
              "uavid": "87066700-f12d-4b3e-ac77-a55a409dd30b"
            },
            {
              "id": "fba073d1-def3-4f85-9326-dff8a1ac6ea6",
              "speed":25,
              "uavid": "9556344a-c055-4156-86d4-bc57930275a2"
            }
          ]
        })


      }

      // 无人机电量预警
      function uavBatteryWarning(params){
        pathPipe({
          "id": "conflict1",
          "status": "show",
          "paths":Path.path_conflict_1,
          "color": "#438EDB",
          "intensity": 1.2,
          "pipeRadius": 10
        });
        getRealFlyPoint({
          flyList:[
            {
              "id": "67513a6e-7ce2-4121-9b11-cd6f1d28e02c",
              "speed":40,
              "uavid": "02d47b30-003c-4e7e-89ec-72255c1ebdaf"
            }
          ]
        })
      }

      //无人机偏航
      function uavYawWarning(params){
        pathPipe({
          "id": "yaw",
          "status": "show",
          "paths":Path.yaw_path,
          "color": "#438EDB",
          "intensity": 1.2,
          "pipeRadius": 10
        });
        getRealFlyPoint({
          flyList:[
            {
              "id": "6fd0fa45-de0b-4008-8d4d-afaaa15064f3",
              "speed":40,
              "uavid": "7e080fe7-dbd4-4be2-aa45-72a28da7f26c"
            }
          ]
        })
      }


      function pathPipe(params){
        let id = params.id;
        let status = params.status;
        if(pathPipeInstance[id]){
          pathPipeInstance[id].clear();
          pathPipeInstance[id] = null;
        }
        if(status == "hide"){
          return
        }
        //优化数据
        //params.paths = Path.paths;
        let pathPipeEvent = new PathPipeEvent({
          view:m_view,
          paths:params.paths,
          color:params.color,
          pipeRadius:params.pipeRadius,
          intensity:params.intensity
        });
        pathPipeEvent.start();
        // 保存实例
        pathPipeInstance[id] = pathPipeEvent;
      }
      function flyGLTF(params){
        let id = params.id;
        let uavid = params.uavid;
        let status = params.status;
        if(status == "hide"){
          if(flyGLTFInstances[uavid]){
            flyGLTFInstances[uavid].clear();
            delete flyGLTFInstances[uavid];
          }
          return
        }
        let point = params.point;
        let duration = params.duration;
        let uavInfo = params.uavInfo;
        if(flyGLTFInstances[uavid]){
          flyGLTFInstances[uavid].updatePath(point,duration);
          if(uavInfo){
            flyGLTFInstances[uavid].updateUavInfo(uavInfo);
          }
        }else{
          let flyGLTFEvent = new FlyGLTFEvent({
            view:m_view,
            uavid,
            bus,
          })
          flyGLTFEvent.start();
          flyGLTFEvent.updatePath(point,duration);
          if(params.uavInfo){
            flyGLTFEvent.updateUavInfo(uavInfo);
          }
          flyGLTFInstances[uavid] = flyGLTFEvent;
        }
      }


      function getVirtualFlyPoint(params){
        let status = params.status;
        const connectVirtualWebSocket = (status) => {
          if(status == "show"){
            if(virtualSocket){
              virtualSocket.send(JSON.stringify(params.flyList));
            }else{
              virtualSocket = new WebSocket('ws://58.34.215.19:19259/simulate/getRouteInfoWebSocket');
              virtualSocket.onopen = () => {
                console.log('WebSocket 连接成功');
                virtualSocket.send(JSON.stringify(params.flyList));
              };
              virtualSocket.onmessage = (messageEvent) => {
                let messages = JSON.parse(messageEvent.data).data;
                messages.forEach(message => {
                  flyGLTF({
                    id:message.id,
                    uavid:message.uavid,
                    status:message.routeInfoVO.status == 3?"hide":"show",
                    duration:2100,
                    //duration:3000,
                    point:message.position_cj,
                    uavInfo: {
                      type:"safe",
                      data:message.routeInfoVO
                    }
                  });
                })
              };

              virtualSocket.onerror = (error) => {
                console.error('WebSocket 出错:', error);
              };

              virtualSocket.onclose = () => {
                console.log('WebSocket 连接已关闭');
              };
            }
          }else{
            if(virtualSocket){
              virtualSocket.close();
            }
          }
        };
        connectVirtualWebSocket(status);
      }



      function getRealFlyPoint(params){
        const connectWebSocket = () => {
          if(socket){
            socket.send(JSON.stringify(params.flyList));
          }else{
            socket = new WebSocket('ws://58.34.215.19:19259/aircraftRouteSpeedWebSocket');
            socket.onopen = () => {
              console.log('WebSocket 连接成功');
              socket.send(JSON.stringify(params.flyList));
            };
            socket.onmessage = (messageEvent) => {
              let messages = JSON.parse(messageEvent.data).data;
              debugger
              //发送消息
              bus.emit('SendMessage',{
                action:"RealTimeUAVList",
                data:{
                  "message":messages
                }
              })
              messages.forEach(message => {
                if(message.overall == "SAFE"){
                  pathPipe({
                    "id": message.uavid+'_conflict',
                    "status": "hide"
                  });
                  flyGLTF({
                    id:message.id,
                    uavid:message.uavid,
                    status:message.routeInfoVO.status == 3?"hide":"show",
                    duration:message.time + 1000,
                    //duration:3000,
                    point:message.position_cj,
                    uavInfo: {
                      type:"safe",
                      data:message.routeInfoVO
                    }
                  });
                }else{
                  if(message.nearestAircraft.status !="SAFE"){ //碰撞
                    flyGLTF({
                      id:message.id,
                      uavid:message.uavid,
                      status:message.routeInfoVO.status == 3?"hide":"show",
                      duration:message.time + 1000,
                      //duration:3000,
                      point:message.position_cj,
                      uavInfo: {
                        type:"conflict",
                        data:message.nearestAircraft
                      }
                    });
                    pathPipe({
                      "id": message.uavid+'_conflict',
                      "status": "show",
                      "paths":[message.nearestAircraft.conflictPath],
                      "color": "#FF0000",
                      "intensity": 1.5,
                      "pipeRadius": 6
                    });
                  }else{
                    pathPipe({
                      "id": message.uavid+'_conflict',
                      "status": "hide"
                    });
                    flyGLTF({
                      id:message.id,
                      uavid:message.uavid,
                      status:message.routeInfoVO.status == 3?"hide":"show",
                      duration:message.time + 1000,
                      //duration:3000,
                      point:message.position_cj,
                      uavInfo: {
                        type:"safe",
                        data:message.routeInfoVO
                      }
                    });
                  }
                }
                  // if(message.nearestAircraft.status != "SAFE"){  //碰撞
                  //   showThreeCubeDetail({
                  //     "id":message.uavid,
                  //     "status": "hide",
                  //   })
                  //   showThreeCubeDetail({
                  //     "id":message.uavid,
                  //     "status": "show",
                  //     "size": {
                  //       "x":message.nearestAircraft.gridPath[0].boxSize.latLength,
                  //       "y":message.nearestAircraft.gridPath[0].boxSize.lonLength,
                  //       "z":message.nearestAircraft.gridPath[0].boxSize.height,
                  //     },
                  //     "points": message.nearestAircraft.gridPath
                  //   })
                  //   bus.emit('SendMessage',{
                  //     action:"CurrentUavInfo",
                  //     data:{
                  //       "isConflict":true,
                  //       "status": "show",
                  //       "uavid": "87066700-f12d-4b3e-ac77-a55a409dd30b",
                  //       "skip_route_id": "fba073d1-def3-4f85-9326-dff8a1ac6ea6",
                  //       "distance": 1280,
                  //     }
                  //   })
                  //
                  // }else if(message.noFlyZone != "SAFE"){
                  //   console.log("无人机禁飞区信息",message);
                  // }else if(message.routeDeviate != "SAFE"){
                  //   console.log("无人机偏航异常信息",message);
                  // }else if(message.electricityWarning != "SAFE"){
                  //   console.log("无人机电量异常信息",message);
                  // }
              })

            };

            socket.onerror = (error) => {
              console.error('WebSocket 出错:', error);
            };

            socket.onclose = () => {
              console.log('WebSocket 连接已关闭');
            };
          }
        };
        connectWebSocket();
      }

      //如果是等待，就要设置另一台无人机继续飞行
      function conflict_wait(){

      }

      function conflict_fly(params){
        let uavid = params.uavid;
        let skip_route_id = params.skip_route_id;
        let distance = params.distance;
        getAvoidRoute({
          uavid:uavid,
          skip_route_id:skip_route_id,
          distance:distance
        }).then(res =>{
          console.log("临时路线",res);
          pathPipe({
            "id": uavid+'_change',
            "status": "show",
            "paths":[res.data.data.pathAll],
            "color": "#438EDB",
            "intensity": 1.2,
            "pipeRadius": 5
          });
          debugger
          getRealFlyPoint({
            flyList:{
              "path": res.data.data.pathAll,
              "avoidanceType":"avoid",
              "uavid": uavid
            }
          })
        })
      }


      function changePointStatus(params){
        flyGLTFInstances[params.uavid].followPath(params.isFollow);
      }



      //ws 推送方法
      function getRealPower(params){
        const connectWebSocket = () => {
          socket = new WebSocket('ws://58.34.215.19:19259/gridSearchWebSocket');
          socket.onopen = () => {
            console.log('WebSocket 连接成功');
            socket.send(JSON.stringify({
              "locationPoint": {
                "mapX":  6454.080981250964,
                "mapY": 5487.978352845347
              },
              "radiusInMeters": 5000,
              "minZ": 1,
              "maxZ": 120,
              "routes": [
              ],
              "fields":["gridCode","x","y","z"],
              "scrollPage": {
                "pageIndex": 1,
                "pageSize": 10000,
                "scrollId": ""
              },
              "level":20,
              "className":"LowAltitudeGrid"
            }));
          };

          socket.onmessage = (messageEvent) => {
            let messages = JSON.parse(messageEvent.data);
            messages.data.list.forEach((point) =>{
              point.color = [0, 1, 1];
            });
            console.log("messages.data.list",messages.data.list)
            let para = {
              "id":"1",
              "status":"show",
              "size":{
                x:46,
                y:54,
                z:53
              },
              "points":messages.data.list,
            }
            showThreeCubeDetail(para);
          };

          socket.onerror = (error) => {
            console.error('WebSocket 出错:', error);
          };

          socket.onclose = () => {
            console.log('WebSocket 连接已关闭');
          };
        };
        connectWebSocket();
      }


      function getRealPower2(params){
        let id = params.id;
        let lastId = params.lastId;
        let status = params.status;
        let level = params.level;
        let center = params.center;
        let radius = params.radius;
        let minZ = params.minZ;
        let maxZ = params.maxZ;
        let size = params.size;
        let fields = params.fields;
        currentShowGridId = id;
        showThreeCubeDetail({
          id:id,
          status:"hide"
        });
        showThreeCubeDetail({
          id:lastId,
          status:"hide"
        });
        if(status == "hide"){
          currentShowGridId = null;
          return
        }
        getSixPowerPoints({
          id,
          "x": center.x,
          "y": center.y,
          status,
          radius,
          size,
          minZ,
          maxZ,
          level,
          fields,
          scrollId:""
        });
      }

      // 递归获取权重数据
      function getSixPowerPoints(params) {
        getPowerPoint({
          x: params.x,
          y: params.y,
          radius:params.radius,
          minZ:params.minZ,
          maxZ:params.maxZ,
          level: params.level,
          fields: params.fields,
          scrollId: params.scrollId,
        }).then(res =>{
          if(currentShowGridId == params.id){
            if(res.data.data.list?.length >= 100000 && res.data.data.scrollId){
              // res.data.data.list.forEach((point) =>{
              //   point.color = [0, 1, 1];
              // });
              // res.data.data.list.forEach((item)=>{
              //   item.color = getColor(item.averageValue, -50, 50);
              // })
              showThreeCubeDetail({
                "id":params.id,
                "status":params.status,
                "size":params.size,
                "points":res.data.data.list,
              })
              params.scrollId = res.data.data.scrollId;

              getSixPowerPoints(params);
            }else{
              if(res.data.data.list?.length > 0){
                showThreeCubeDetail({
                  "id":params.id,
                  "status":params.status,
                  "size":params.size,
                  "points":res.data.data.list,
                })
              }
            }
          }
        })
      }


      //需要添加初始路径（手动绘制和自动绘制）结果
      function draw(params){
        let id = params.id;
        let geometryType = params.type;
        let status = params.status;
        let path = params.path;
        let hasZ = params.hasZ;
        let symbol = params.symbol;
        let clear = true;
        if(params.clear !== undefined){
          clear = params.clear;
        }
        if(clear){
          if(addDrawEvent){
            addDrawEvent.clear();
            addDrawEvent = null;
          }
        }
        if(status == "hide"){
          return
        }
        if(!addDrawEvent){
          addDrawEvent = new AddDrawEvent({
            view:m_view,
            type:geometryType,
            symbol,
            path:path,
            hasZ
          });
          addDrawEvent.start(symbol,geometryType);
        }else{
          addDrawEvent.start(symbol,geometryType);
        }
        if(path){
          addDrawEvent.update();
        }
        addDrawEvent.createListenerEvent((geometry) =>{
          bus.emit('SendMessage',{
            action:"DrawComplete",
            data:{
              "geometry":geometry
            }
          })
        });
        addDrawEvent.updateListenerEvent((geometry) =>{
          bus.emit('SendMessage',{
            action:"DrawComplete",
            data:{
              "geometry":geometry
            }
          })
        });
      }


      //态势评估
      function situationAssessment(params){
        routeList.list.forEach((item) =>{
          pathPipe({
            id: item.id,
            paths: [item.path],
            color:item.color,
            status: params.status,
            "intensity": 1.2,
            "pipeRadius": 10
          })
        })
        featurePointsPlotting({
          status: params.status,
          data:routeList.points
        });
        routeList.uavList.forEach((item) =>{
          item.status = params.status =="show"?1:3
        })
        //先加载所有的无人机和航线
        getRealFlyPoint({
          status: params.status,
          flyList:params.status=="show"?[]:routeList.uavList
        })

      }


      function draw_GeometryMeshPrismEffect(params){
        let geometryType = params.type;
        let status = params.status;
        let startHeight = params.startHeight;
        let items = params.items;
        if(addDrawEvent){
          addDrawEvent.clear();
          addDrawEvent = null;
        }
        if(draw_GeometryMeshPrismEffectEvent){
          draw_GeometryMeshPrismEffectEvent.clear();
          draw_GeometryMeshPrismEffectEvent = null;
        }
        let f_layer = m_map.layers.find(item => item.id === "geometryMeshPrismEffect");
        if (f_layer) {
          m_map.remove(f_layer);
        }
        if(status == "hide"){
          return
        }
        addDrawEvent = new AddDrawEvent({
          view:m_view,
          type:geometryType
        })
        addDrawEvent.start();
        addDrawEvent.createListenerEvent((geometry)=>{
          if(draw_GeometryMeshPrismEffectEvent){
            draw_GeometryMeshPrismEffectEvent.clear();
            draw_GeometryMeshPrismEffectEvent = null;
          }
          draw_GeometryMeshPrismEffectEvent = new GeometryMeshPrismEffect({
            view:m_view,
            m_map,
            items:items,
            startHeight:startHeight,
            rings:geometry.rings
          });
          m_map.add(draw_GeometryMeshPrismEffectEvent.graphicsLayer);
        })
        addDrawEvent.updateListenerEvent((geometry)=>{
          if(draw_GeometryMeshPrismEffectEvent){
            draw_GeometryMeshPrismEffectEvent.clear();
            draw_GeometryMeshPrismEffectEvent = null;
          }
          draw_GeometryMeshPrismEffectEvent = new GeometryMeshPrismEffect({
            view:m_view,
            m_map,
            items:items,
            startHeight:startHeight,
            rings:geometry.rings
          });
          m_map.add(draw_GeometryMeshPrismEffectEvent.graphicsLayer);
        })
      }

      function symbolPathPipe(params){
        let status = params.status;
        let f_layer = m_map.layers.find(item => item.id === "symbolPathPipeEvent");
        if (f_layer) {
          m_map.remove(f_layer);
        }
        if(status == "hide"){
          return
        }
        // params.paths = Path.paths
        symbolPathPipeEvent = new SymbolPathPipeEvent({
          view:m_view,
          paths:params.paths,
        })
        m_map.add(symbolPathPipeEvent.graphicsLayer);
      }

      function symbolPointCube(params){
        let status = params.status;
        let f_layer = m_map.layers.find(item => item.id === "symbolPointCubeEvent");
        if (f_layer) {
          m_map.remove(f_layer);
        }
        if(status == "hide"){
          return
        }
        symbolPointCubeEvent = new SymbolPointCubeEvent({
          view:m_view,
          points:params.points,
          size:params.size,
        })
        m_map.add(symbolPointCubeEvent.graphicsLayer);
      }
      function featurePointsPlotting(params){
        let status = params.status;
        let f_layer = m_map.layers.find(item => item.id === "featurePointsPlottingEvent");
        if (f_layer) {
          m_map.remove(f_layer);
        }
        if(status == "hide"){
          return
        }
        //params.data = Path.paths_point;
        featurePointsPlottingEvent = new FeaturePointsPlottingEvent({
          view:m_view,
          data:params.data
        })
        m_map.add(featurePointsPlottingEvent.featureLayer);
      }


      function featurePolygonPlotting(params){
        let status = params.status;
        let id = params.id;
        let f_layer = m_map.layers.find(item => item.id === id);
        if (f_layer) {
          m_map.remove(f_layer);
        }
        if(status == "hide"){
          return
        }
        featurePointsPlottingEvent = new FeaturePolygonPlottingEvent({
          id,
          view:m_view,
          data:params.data
        });
      }

    })
  }
}
</script>

<style scoped lang="scss">
#map_jk,#mapDiv,#viewDiv{
  height: 100%;
}
:deep(.esri-view-surface--touch-none::after){
  outline: none !important;
}
</style>