@kq_npm/client3d_webgl_vue 0.0.1-beta

package/scenceview/index.js

@@ -0,0 +1,1775 @@
+/******/ (function() { // webpackBootstrap
+/******/ 	"use strict";
+/******/ 	var __webpack_modules__ = ({
+
+/***/ 159:
+/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
+
+__webpack_require__.r(__webpack_exports__);
+/* harmony default export */ __webpack_exports__["default"] = ("data:image/png;base64,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");
+
+/***/ })
+
+/******/ 	});
+/************************************************************************/
+/******/ 	// The module cache
+/******/ 	var __webpack_module_cache__ = {};
+/******/ 	
+/******/ 	// The require function
+/******/ 	function __webpack_require__(moduleId) {
+/******/ 		// Check if module is in cache
+/******/ 		var cachedModule = __webpack_module_cache__[moduleId];
+/******/ 		if (cachedModule !== undefined) {
+/******/ 			return cachedModule.exports;
+/******/ 		}
+/******/ 		// Create a new module (and put it into the cache)
+/******/ 		var module = __webpack_module_cache__[moduleId] = {
+/******/ 			// no module.id needed
+/******/ 			// no module.loaded needed
+/******/ 			exports: {}
+/******/ 		};
+/******/ 	
+/******/ 		// Execute the module function
+/******/ 		__webpack_modules__[moduleId](module, module.exports, __webpack_require__);
+/******/ 	
+/******/ 		// Return the exports of the module
+/******/ 		return module.exports;
+/******/ 	}
+/******/ 	
+/************************************************************************/
+/******/ 	/* webpack/runtime/compat get default export */
+/******/ 	!function() {
+/******/ 		// getDefaultExport function for compatibility with non-harmony modules
+/******/ 		__webpack_require__.n = function(module) {
+/******/ 			var getter = module && module.__esModule ?
+/******/ 				function() { return module['default']; } :
+/******/ 				function() { return module; };
+/******/ 			__webpack_require__.d(getter, { a: getter });
+/******/ 			return getter;
+/******/ 		};
+/******/ 	}();
+/******/ 	
+/******/ 	/* webpack/runtime/define property getters */
+/******/ 	!function() {
+/******/ 		// define getter functions for harmony exports
+/******/ 		__webpack_require__.d = function(exports, definition) {
+/******/ 			for(var key in definition) {
+/******/ 				if(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {
+/******/ 					Object.defineProperty(exports, key, { enumerable: true, get: definition[key] });
+/******/ 				}
+/******/ 			}
+/******/ 		};
+/******/ 	}();
+/******/ 	
+/******/ 	/* webpack/runtime/hasOwnProperty shorthand */
+/******/ 	!function() {
+/******/ 		__webpack_require__.o = function(obj, prop) { return Object.prototype.hasOwnProperty.call(obj, prop); }
+/******/ 	}();
+/******/ 	
+/******/ 	/* webpack/runtime/make namespace object */
+/******/ 	!function() {
+/******/ 		// define __esModule on exports
+/******/ 		__webpack_require__.r = function(exports) {
+/******/ 			if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {
+/******/ 				Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+/******/ 			}
+/******/ 			Object.defineProperty(exports, '__esModule', { value: true });
+/******/ 		};
+/******/ 	}();
+/******/ 	
+/************************************************************************/
+var __webpack_exports__ = {};
+// This entry need to be wrapped in an IIFE because it need to be isolated against other modules in the chunk.
+!function() {
+// ESM COMPAT FLAG
+__webpack_require__.r(__webpack_exports__);
+
+// EXPORTS
+__webpack_require__.d(__webpack_exports__, {
+  "ScenceViewViewModel": function() { return /* reexport */ ScenceViewViewModel; },
+  "default": function() { return /* reexport */ ScenceView; }
+});
+
+;// CONCATENATED MODULE: external {"root":"Vue","commonjs":"vue","commonjs2":"vue","amd":"vue"}
+var external_root_Vue_commonjs_vue_commonjs2_vue_amd_vue_namespaceObject = require("vue");
+;// CONCATENATED MODULE: external "@zpc_npm/vue-iclient-icons"
+var vue_iclient_icons_namespaceObject = require("@zpc_npm/vue-iclient-icons");
+;// CONCATENATED MODULE: external "@element-plus/icons-vue"
+var icons_vue_namespaceObject = require("@element-plus/icons-vue");
+;// CONCATENATED MODULE: ./node_modules/@babel/runtime/helpers/esm/defineProperty.js
+function _defineProperty(obj, key, value) {
+  if (key in obj) {
+    Object.defineProperty(obj, key, {
+      value: value,
+      enumerable: true,
+      configurable: true,
+      writable: true
+    });
+  } else {
+    obj[key] = value;
+  }
+
+  return obj;
+}
+;// CONCATENATED MODULE: external "@zpc_npm/vue-iclient-common/_utils/mitt"
+var mitt_namespaceObject = require("@zpc_npm/vue-iclient-common/_utils/mitt");
+var mitt_default = /*#__PURE__*/__webpack_require__.n(mitt_namespaceObject);
+;// CONCATENATED MODULE: external "core-js/modules/es.array.includes.js"
+var es_array_includes_js_namespaceObject = require("core-js/modules/es.array.includes.js");
+;// CONCATENATED MODULE: external "@turf/turf"
+var turf_namespaceObject = require("@turf/turf");
+;// CONCATENATED MODULE: ./src/webgl/scenceview/DrawManager.js
+
+
+ //绘制操作类
+
+class DrawManager {
+  //图层分组
+  // 默认绘制样式提供给绘图组件绑定
+  // 默认绘制样式
+  constructor(viewer) {
+    _defineProperty(this, "_viewer", null);
+
+    _defineProperty(this, "_drawHandler", null);
+
+    _defineProperty(this, "_drawLayer", null);
+
+    _defineProperty(this, "_layerGroup", []);
+
+    _defineProperty(this, "_defaultStyle", {
+      color: "#ff0000",
+      fillColor: "#1E90FF",
+      weight: 2,
+      fillOpacity: 0.3,
+      dashArray: "0"
+    });
+
+    _defineProperty(this, "drawFinishedEvent", null);
+
+    _defineProperty(this, "editSelectedEvent", null);
+
+    _defineProperty(this, "_drawStyle", {
+      //文本样式
+      text: {
+        text: "文字标注",
+        //文字内容
+        fontSize: 30,
+        //文字大小
+        color: "#ff0000",
+        //文字颜色
+        opacity: 0.5,
+        //文字颜色透明度
+        clampToGround: false //是否贴地
+
+      },
+      //点-图标样式
+      marker: {
+        image: __webpack_require__(159),
+        //图标路径
+        width: 32,
+        //图标宽度
+        height: 32,
+        //图标高度
+        clampToGround: false //是否贴地
+
+      },
+      //折线样式
+      polyline: {
+        width: 2,
+        //线宽
+        color: "#ff0000",
+        //线颜色
+        opacity: 0.5,
+        //线颜色透明度
+        arcType: 1,
+        clampToGround: true //是否贴地
+
+      },
+      //多边形样式
+      polygon: {
+        fill: true,
+        //是否填充颜色
+        fillColor: "#1E90FF",
+        //填充颜色
+        fillOpacity: 0.3,
+        //填充颜色透明度
+        width: 2,
+        //边框宽度
+        color: "#ff0000",
+        //边框颜色
+        opacity: 0.5,
+        //边框颜色透明度
+        clampToGround: true //是否贴地
+
+      }
+    });
+
+    _defineProperty(this, "_geojsonStyle", {
+      label: {
+        style: Cesium.LabelStyle.FILL_AND_OUTLINE,
+        outlineWidth: 2,
+        fillColor: "#ff0000",
+        opacity: 1,
+        pixelOffset: [0, -16],
+        express: "name",
+        font: "25px 微软雅黑"
+      },
+      billboard: {
+        image: __webpack_require__(159),
+        width: 32,
+        height: 32
+      },
+      polyline: {
+        color: "#ff0000",
+        opacity: 1.0,
+        width: 2
+      },
+      polygon: {
+        color: "#0000ff",
+        opacity: 0.3,
+        outline: true,
+        outlineColor: "#ff0000",
+        perPositionHeight: true
+      }
+    });
+
+    this._viewer = viewer;
+    this._drawHandler = Cesium.Kq3dPlotHandler; // 创建绘制图形图层
+
+    this._drawLayer = this._drawHandler.createShapeLayer({
+      name: "Drawing"
+    }); // 添加绘制图形图层到场景
+
+    this._viewer.scene.primitives.add(this._drawLayer); // 初始化绘制函数集对象
+
+
+    this._drawHandler.initialize(this._viewer.scene, this._drawLayer); // 默认禁用编辑操作
+
+
+    this.enableEdit(false); // 绘制结束事件
+
+    this.drawFinishedEvent = this._drawHandler.drawHandler.drawFinished; // 编辑拾取事件
+
+    this.editSelectedEvent = this._drawHandler.editHandler.editSelected; // 关闭双击旋转交互
+
+    if (this._viewer.roadingHandler) {
+      this._viewer.roadingHandler.cameraRotatePointer.enableMouseAutoStart = false;
+    } //复制样式
+
+
+    this._drawStyle.freehandline = this._drawStyle.polyline; //手绘线
+
+    this._drawStyle.concentricCircle = this._drawStyle.polyline; //同心圆
+
+    this._drawStyle.circle = this._drawStyle.polygon; //圆
+
+    this._drawStyle.ellipse = this._drawStyle.polygon; //椭圆
+
+    this._drawStyle.freehandpolygon = this._drawStyle.polygon; //手绘面
+
+    this._drawStyle.rectangle = this._drawStyle.polygon; //矩形
+  } //开始绘制
+
+
+  startDraw(type, options, callback) {
+    this._viewer.scene.globe.depthTestAgainstTerrain = true;
+
+    if (type === "point") {
+      type = "marker";
+      this._viewer.scene.globe.depthTestAgainstTerrain = false;
+    }
+
+    if (!options) options = {};
+    var unionOptions = JSON.parse(JSON.stringify(this._drawStyle[type]));
+
+    for (var key in options) {
+      unionOptions[key] = options[key];
+    }
+
+    if (unionOptions.hasOwnProperty("color")) {
+      unionOptions.color = Cesium.Color.fromCssColorString(unionOptions.color).withAlpha(unionOptions.opacity);
+    }
+
+    if (unionOptions.hasOwnProperty("fillColor")) {
+      unionOptions.fillColor = Cesium.Color.fromCssColorString(unionOptions.fillColor).withAlpha(unionOptions.fillOpacity);
+    }
+
+    this._drawHandler.startDraw(type, type, unionOptions);
+
+    if (callback) {
+      var that = this;
+      var removeEventListener = this.drawFinishedEvent.addEventListener(shape => {
+        var feature = that.shapeToGeoFeature(shape);
+        callback(feature.geometry);
+        removeEventListener();
+      });
+    }
+  }
+
+  stopDraw() {
+    this._drawHandler.stopDraw();
+  } //是否启用连续绘制
+
+
+  enableMultiDraw(isEnable) {
+    this._drawHandler.drawHandler.enableMultiDraw = isEnable;
+  } //是否启用编辑
+
+
+  enableEdit(isEnable) {
+    if (isEnable) {
+      this._drawHandler.editHandler.activate();
+    } else {
+      this._drawHandler.editHandler.deactivate();
+    }
+  } //清除全部手动绘图
+
+
+  clear() {
+    this._drawLayer && this._drawLayer.removeAll();
+  } //销毁
+
+
+  destroy() {
+    this._viewer = null;
+    this._drawHandler = null;
+    this.clear();
+  } //笛卡尔坐标转经纬度
+
+
+  transformPosition(position) {
+    // 转坐标
+    if (position) {
+      let ellipsoid = this._viewer.scene.globe.ellipsoid;
+      let cartographic = ellipsoid.cartesianToCartographic(position);
+      let lon = Cesium.Math.toDegrees(cartographic.longitude);
+      let lat = Cesium.Math.toDegrees(cartographic.latitude);
+      let lonLat = [lon, lat];
+      return lonLat;
+    }
+  } //绘制返回结果转换为GeoFeature
+
+
+  shapeToGeoFeature(shape) {
+    var geoFeature = null;
+    var that = this;
+
+    if (shape) {
+      if (shape.type === that._drawHandler.ShapeTypes.MARKER.type) {
+        let position = that.transformPosition(shape._position);
+        geoFeature = turf_namespaceObject.point(position);
+      } else if (shape.type === that._drawHandler.ShapeTypes.CIRCLE.type) {
+        let center = that.transformPosition(shape.center);
+        geoFeature = turf_namespaceObject.circle(center, shape.radius, {
+          steps: 64,
+          units: "meters"
+        });
+      } else if (shape.type === that._drawHandler.ShapeTypes.POLYLINE.type) {
+        let position = [[]];
+        shape.controlPoints.forEach(function (val) {
+          position[0].push(that.transformPosition(val));
+        });
+        geoFeature = turf_namespaceObject.lineStrings(position).features[0];
+      } else if (shape.type === that._drawHandler.ShapeTypes.RECTANGLE.type) {
+        let minX = shape.rectangle.west / Math.PI * 180;
+        let maxX = shape.rectangle.east / Math.PI * 180;
+        let minY = shape.rectangle.south / Math.PI * 180;
+        let maxY = shape.rectangle.north / Math.PI * 180;
+        let positions1 = [[[minX, minY], [minX, maxY], [maxX, maxY], [maxX, minY], [minX, minY]]];
+        geoFeature = turf_namespaceObject.polygon(positions1);
+      } else if (shape.type === that._drawHandler.ShapeTypes.POLYGON.type) {
+        let positions = [[]];
+        let posi;
+        shape.controlPoints.forEach(function (val, dex) {
+          // 存坐标
+          positions[0].push(that.transformPosition(val)); // 闭合坐标
+
+          if (dex === 0) {
+            posi = that.transformPosition(val);
+          }
+
+          if (dex === shape.controlPoints.length - 1) {
+            positions[0].push(posi);
+          }
+        });
+        geoFeature = turf_namespaceObject.polygon(positions);
+      }
+    }
+
+    return geoFeature || shape;
+  } //通过geojson进行绘制，支持定位
+
+
+  drawFromGeojson(geojsonData, idCustom = "result", callFun, geojsonStyle, isLocation) {
+    if (!geojsonStyle) geojsonStyle = {};
+    let style = JSON.parse(JSON.stringify(this._geojsonStyle));
+
+    for (var type in geojsonStyle) {
+      if (style.hasOwnProperty(type)) {
+        for (var key in geojsonStyle[type]) {
+          style[type][key] = geojsonStyle[type][key];
+        }
+      } else {
+        style[type] = geojsonStyle[type];
+      }
+    }
+
+    for (var type in style) {
+      if (style[type].hasOwnProperty("color")) {
+        style[type].material = Cesium.Color.fromCssColorString(style[type].color).withAlpha(style[type].opacity);
+      }
+
+      if (style[type].hasOwnProperty("fillColor")) {
+        style[type].fillColor = Cesium.Color.fromCssColorString(style[type].fillColor).withAlpha(style[type].opacity);
+      }
+
+      if (style[type].hasOwnProperty("outlineColor")) {
+        style[type].outlineColor = Cesium.Color.fromCssColorString(style[type].outlineColor);
+      }
+
+      if (style[type].hasOwnProperty("pixelOffset")) {
+        style[type].pixelOffset = new Cesium.Cartesian2(style[type].pixelOffset[0], style[type].pixelOffset[1]);
+      }
+    }
+
+    this._viewer.scene.globe.depthTestAgainstTerrain = false;
+    let geojsonDs = new Cesium.Kq3dGeoJsonDataSource(idCustom);
+    let that = this;
+    geojsonDs.load(geojsonData, style).then(ds => {
+      that._viewer.dataSources.add(ds);
+
+      if (!that._layerGroup.includes(idCustom)) {
+        that._layerGroup.push(idCustom);
+      }
+
+      if (isLocation) {
+        that._viewer.flyTo(ds, {
+          duration: 1.5
+        });
+      }
+
+      callFun && callFun();
+    });
+  } //删除指定绘图分组的所有图形
+
+
+  removeGeojsonByIdCustom(idCustom) {
+    let dsList = this._viewer.dataSources.getByName(idCustom);
+
+    for (let i = 0; i < dsList.length; i++) {
+      this._viewer.dataSources.remove(dsList[i], true);
+    }
+
+    let index = this._layerGroup.indexOf(idCustom);
+
+    if (index > -1) {
+      this._layerGroup.splice(index, 1);
+    }
+  } //删除所有geojson绘图
+
+
+  removeAll() {
+    let that = this;
+
+    this._layerGroup.forEach(group => {
+      let dsList = that._viewer.dataSources.getByName(group);
+
+      for (let i = 0; i < dsList.length; i++) {
+        that._viewer.dataSources.remove(dsList[i], true);
+      }
+    });
+
+    this._layerGroup = [];
+  } //清除所有，包含手动绘图和geojson绘图
+
+
+  clearAll() {
+    this.clear();
+    this.removeAll();
+  }
+
+}
+;// CONCATENATED MODULE: external "@zpc_npm/vue-iclient-common/_utils/webmapservice"
+var webmapservice_namespaceObject = require("@zpc_npm/vue-iclient-common/_utils/webmapservice");
+var webmapservice_default = /*#__PURE__*/__webpack_require__.n(webmapservice_namespaceObject);
+;// CONCATENATED MODULE: external "@zpc_npm/vue-iclient-common/_utils/util"
+var util_namespaceObject = require("@zpc_npm/vue-iclient-common/_utils/util");
+;// CONCATENATED MODULE: ./src/webgl/scenceview/LayerManager.js
+
+
+ //图层管理类
+
+class LayerManager {
+  //图层树数据
+  //图层列表数据（不包含文件夹节点,不包含融合子图层），特殊图层数据（BaseLayer、OnLineLayer）除外
+  //图层原数据列表（包含文件夹节点，融合子图层）
+  //影像图层guid集合
+  //置顶图层guid
+  //地形集合
+  constructor(scenceView) {
+    _defineProperty(this, "_scenceView", null);
+
+    _defineProperty(this, "_viewer", null);
+
+    _defineProperty(this, "_layerTreeData", []);
+
+    _defineProperty(this, "_layerListData", []);
+
+    _defineProperty(this, "_layerListData_old", []);
+
+    _defineProperty(this, "_imageryLayerGuids", []);
+
+    _defineProperty(this, "_frontLayerGuid", null);
+
+    _defineProperty(this, "_emptyTerrainProvider", new Cesium.EllipsoidTerrainProvider({}));
+
+    _defineProperty(this, "_terrainProviders", []);
+
+    this._scenceView = scenceView;
+    this._viewer = scenceView._viewer;
+  } //添加服务数据
+
+
+  addServiceData(service) {
+    if (service && service.name && service.url && service.type) {
+      var that = this;
+
+      if (service.type === "kqmapserver") {
+        //KQGIS地图服务
+        service.serviceUrl = service.url;
+        let webMapService = new (webmapservice_default())(service.name, service);
+        let serviceUrl = webMapService.handleServerUrl(service.url);
+        webMapService.getMapInfo().then(mapInfo => {
+          mapInfo = mapInfo.result || mapInfo; // 存储地图的名称以及描述等信息，返回给用户
+
+          let mapServerInfo = (0,util_namespaceObject.formatKQMapInfo)(mapInfo, serviceUrl, service.name, service.token, service.defaultShowLayerNames, service.isShowAllLayers === undefined ? true : service.isShowAllLayers);
+          mapServerInfo.layerTreeData.forEach(node => {
+            that._layerTreeData.push(node);
+          });
+          mapServerInfo.layers_old.forEach(layer => {
+            that._layerListData_old.push(layer);
+          });
+          let showLayers = [];
+          showLayers = showLayers.concat(mapServerInfo.layers_show);
+          showLayers.reverse();
+          that._layerListData = that._layerListData.concat(showLayers); // console.log(that._layerTreeData);
+          // console.log(that._layerListData);
+
+          that.addMapServerLayers(showLayers, mapInfo.rect84);
+        }, error => {
+          throw error;
+        }).catch(error => {
+          console.error(error);
+        });
+      } else if (service.type === "kq3dserver") {//KQGIS三维服务
+      } else if (service.type === "3dtiles") {
+        //3dtiles
+        that.add3DTilesData(service.name, service.url);
+      }
+    }
+  } //添加KQGIS服务图层
+
+
+  addMapServerLayers(layers, rect) {
+    var that = this;
+    layers.forEach(layer => {
+      //不显示的图层不加载
+      if (layer.visible) {
+        var imageryProvider = new Cesium.Kq3dKQGISMapServerImageryProviderExt({
+          url: layer.url,
+          ua_token: layer.accessToken,
+          layers: layer.id + ""
+        });
+        var imageryLayer = new Cesium.ImageryLayer(imageryProvider);
+        imageryLayer.name = layer.guid;
+
+        that._viewer.imageryLayers.add(imageryLayer);
+      }
+
+      that._imageryLayerGuids.push(layer.guid);
+    });
+
+    if (rect) {
+      that._viewer.camera.flyTo({
+        destination: Cesium.Rectangle.fromDegrees(rect.minx, rect.miny, rect.maxx, rect.maxy)
+      });
+    }
+
+    that._scenceView.fire("resetLayerDatas");
+  } //添加3dtiles数据
+
+
+  add3DTilesData(name, url) {
+    let that = this;
+
+    let tileset = that._viewer.scene.primitives.add(new Cesium.Cesium3DTileset({
+      name: name,
+      url: url
+    }));
+
+    tileset.readyPromise.then(function (tileset) {
+      that._viewer.zoomTo(tileset); //that._viewer.zoomTo(tileset, new Cesium.HeadingPitchRange(0.5, -0.6, tileset.boundingSphere.radius));
+
+    });
+
+    this._layerTreeData.push({
+      guid: tileset.guid,
+      name: name,
+      visible: true,
+      serverType: "3dtiles",
+      shapeType: "model"
+    });
+
+    this._layerListData.push({
+      guid: tileset.guid,
+      name: name,
+      visible: true,
+      serverType: "3dtiles"
+    });
+  }
+  /**
+   * 设置多个图层的显示与隐藏 且控制树的勾选
+   * @param ids 图层的GUID数组
+   * @param visible true, false
+   * @param eventTarget 触发方法的对象。该方法有执行其他监听事件，为防止方法死循环，该参数会传给监听事件
+   */
+
+
+  setLayerVisibleStateByIds(ids, visible, eventTarget) {
+    if (!(ids && ids.length > 0)) return;
+    let layer;
+
+    for (let z = 0; z < ids.length; z++) {
+      for (let i = 0; i < this._layerListData.length; i++) {
+        if (this._layerListData[i].guid === ids[z]) {
+          this._layerListData[i].visible = visible;
+          layer = this.getLayerByGuid(ids[z], this._layerListData[i].serverType);
+
+          if (layer) {
+            if (this._layerListData[i].serverType === "terrainprovider") {
+              if (visible) {
+                this.setTerrain(layer);
+              } else {
+                this._viewer.terrainProvider = this._emptyTerrainProvider;
+              }
+            } else {
+              layer.show = visible;
+            }
+          } else if (visible) {
+            //如果不存在该图层则添加
+            if (this._layerListData[i].serverType === "kqserver") {
+              var imageryProvider = new Cesium.Kq3dKQGISMapServerImageryProviderExt({
+                url: this._layerListData[i].url,
+                ua_token: this._layerListData[i].accessToken,
+                layers: this._layerListData[i].id + ""
+              });
+              var imageryLayer = new Cesium.ImageryLayer(imageryProvider);
+              imageryLayer.name = this._layerListData[i].guid;
+
+              this._viewer.imageryLayers.add(imageryLayer);
+            }
+          }
+        }
+      }
+    }
+  } //通过guid获取ImageryLayer图层添加的index
+
+
+  getImageryLayerAddIndex(guid) {
+    let layers = [];
+    let layerListIndex = -1;
+    let data = this._layerListData; //从_layerListData中找出所有ImageryLayer图层
+
+    data.forEach((layer, index) => {
+      if (layer.serverType === "kqserver" || layer.serverType === "imagerylayer") {
+        layers.push(layer);
+
+        if (layer.guid === guid) {
+          layerListIndex = index;
+        }
+      }
+    });
+
+    if (layerListIndex > -1) {
+      //搜索左边相邻显示的图层
+      let isLeftLayerShow = false;
+
+      for (var i = layerListIndex - 1; i >= 0; i--) {
+        if (data[i].visible) {}
+      }
+    }
+  } //通过guid获取图层对象
+
+
+  getLayerByGuid(guid, type) {
+    if (!type) {
+      type = this.getLayerTypeByGuid(guid);
+    }
+
+    if (type === "kqserver") {
+      let imageryLayers = this._viewer.imageryLayers._layers;
+      let layer = imageryLayers.find(item => {
+        return item.name === guid;
+      });
+      return layer;
+    } else if (type === "imagerylayer") {
+      let imageryLayers = this._viewer.imageryLayers._layers;
+      let layer = imageryLayers.find(item => {
+        return item.guid === guid;
+      });
+      return layer;
+    } else if (type === "terrainprovider") {
+      let layer = this._terrainProviders.find(item => {
+        return item.guid === guid;
+      });
+
+      return layer;
+    } else if (type === "3dtiles") {
+      let primitives = this._viewer.scene.primitives._primitives;
+      let layer = primitives.find(item => {
+        return item.guid === guid && item instanceof Cesium.Cesium3DTileset;
+      });
+      return layer;
+    } else if (type === "datasource") {
+      let dataSources = this._viewer.dataSources._dataSources;
+      let layer = dataSources.find(item => {
+        return item.guid === guid;
+      });
+      return layer;
+    }
+  } //通过guid获取图层类型
+
+
+  getLayerTypeByGuid(guid) {
+    let listLayer = this._layerListData.find(item => {
+      return item.guid === guid;
+    });
+
+    if (listLayer) {
+      return listLayer.serverType;
+    }
+  } // 获取所有图层原数据（包括adddata组件的临时图层数据，不包括底图baselayer）
+
+
+  getLayerData() {
+    return JSON.parse(JSON.stringify(this._layerListData));
+  } // 获取所有图层的key（包括adddata组件的临时图层数据，不包括底图baselayer）
+
+
+  getLayerDataKey() {
+    let keys = [];
+
+    this._layerListData.forEach(item => {
+      keys.push(item.guid);
+    });
+
+    return keys;
+  } //获取所有图层的树形结构数据
+
+
+  getLayerTreeData() {
+    return JSON.parse(JSON.stringify(this._layerTreeData));
+  } //获取选中图层集合
+
+
+  getLayerCheckedList() {
+    let checkedLayers = [];
+
+    this._layerListData.forEach(layer => {
+      if (layer.visible) {
+        checkedLayers.push(layer);
+      }
+    });
+
+    return checkedLayers;
+  } //获取选中图层key集合
+
+
+  getLayerCheckedListKey() {
+    let checkedKeys = [];
+
+    this._layerListData.forEach(layer => {
+      if (layer.visible) {
+        checkedKeys.push(layer.guid);
+      }
+    });
+
+    return checkedKeys;
+  }
+  /**
+   * 获取勾选图层的图层数据，如果是有融合图层，则只返回融合图层的子图层
+   */
+
+
+  getLayerDataByLayerChecked() {
+    let layerData = [];
+    const layers_checked = this.getLayerCheckedList();
+    const layers_old = this._layerListData_old;
+
+    for (let i = 0; i < layers_checked.length; i++) {
+      if (layers_checked[i].combined) {
+        getChildren(layers_checked[i].id);
+      } else {
+        layerData.push(layers_checked[i]);
+      }
+    }
+
+    return layerData;
+
+    function getChildren(parentId) {
+      for (let z = 0; z < layers_old.length; z++) {
+        if (layers_old[z].parentLayerId === parentId) {
+          // 分组节点
+          if (layers_old[z].groupLayer) {
+            getChildren(layers_old[z].id);
+          } else {
+            layerData.push(layers_old[z]);
+          }
+        }
+      }
+    }
+  } //缩放至图层
+
+
+  flyToBounds(guid) {
+    let viewer = this._viewer;
+    let layer = this.getLayerByGuid(guid);
+
+    if (layer instanceof Cesium.ImageryLayer) {
+      layer.getViewableRectangle().then(function (rectangle) {
+        viewer.camera.flyTo({
+          destination: rectangle
+        });
+      });
+    } else if (layer instanceof Cesium.Cesium3DTileset) {
+      viewer.zoomTo(layer);
+    } else if (layer instanceof Cesium.GeoJsonDataSource || layer instanceof Cesium.Kq3dGeoJsonDataSource || layer instanceof Cesium.KmlDataSource || layer instanceof Cesium.CzmlDataSource) {
+      viewer.flyTo(layer);
+    } else if (layer instanceof Cesium.Kq3dKQGISServerTerrainProvider || layer instanceof Cesium.Kq3dFileTerrainProvider || layer instanceof Cesium.CesiumTerrainProvider) {
+      layer.getViewableRectangle().then(function (rectangle) {
+        if (layer.ExtentSource) {
+          var rectangle = Cesium.Rectangle.fromDegrees(layer.ExtentSource.left, layer.ExtentSource.bottom, layer.ExtentSource.right, layer.ExtentSource.top);
+          viewer.scene.camera.flyTo({
+            destination: rectangle
+          });
+        } else if (rectangle) {
+          viewer.camera.flyTo({
+            destination: rectangle
+          });
+        }
+      });
+    }
+  } //获取基础图层Index
+
+
+  getBaseLayerIndex() {
+    // let baseIndex = 0;
+    // this._viewer.imageryLayers._layers.forEach(layer => {
+    //   if (layer._isBaseLayer) {
+    //     baseIndex++;
+    //   }
+    // });
+    // return baseIndex;
+    return 1;
+  } //获取图层原始Index
+
+
+  getLayerOldIndex(guid) {
+    let baseIndex = this.getBaseLayerIndex();
+
+    let layerIndex = this._imageryLayerGuids.indexOf(guid);
+
+    return baseIndex + layerIndex;
+  } //设置图层置顶或取消置顶
+
+
+  setLayerBringToFrontById(guid, isFront) {
+    let layer = this.getLayerByGuid(guid);
+
+    if (layer) {
+      if (isFront) {
+        //置顶
+        if (this._frontLayerGuid === guid) return;
+
+        if (this._frontLayerGuid) {
+          // 如果已经有置顶图层 先把已经置顶的图层还原 再继续操作
+          let frontLayer = this.getLayerByGuid(this._frontLayerGuid);
+          let frontOldIndex = this.getLayerOldIndex(this._frontLayerGuid);
+          var length = frontLayer._layerIndex - frontOldIndex;
+
+          for (let i = 0; i < length; i++) {
+            if (frontLayer instanceof Cesium.ImageryLayer) {
+              this._viewer.imageryLayers.lower(frontLayer);
+            }
+          }
+        }
+
+        if (layer instanceof Cesium.ImageryLayer) {
+          this._viewer.imageryLayers.raiseToTop(layer);
+        }
+
+        this._frontLayerGuid = guid;
+      } else {
+        //取消置顶
+        if (this._frontLayerGuid !== guid) return;
+        let oldIndex = this.getLayerOldIndex(guid);
+        let length = layer._layerIndex - oldIndex;
+
+        for (let j = 0; j < length; j++) {
+          if (layer instanceof Cesium.ImageryLayer) {
+            this._viewer.imageryLayers.lower(layer);
+          }
+        }
+
+        this._frontLayerGuid = null;
+      }
+    }
+  } //图层上移
+
+
+  raiseLayerById(guid) {
+    let layer = this.getLayerByGuid(guid);
+
+    if (layer instanceof Cesium.ImageryLayer) {
+      this._viewer.imageryLayers.raise(layer);
+    }
+  } //图层下移
+
+
+  lowerLayerById(guid) {
+    let layer = this.getLayerByGuid(guid);
+
+    if (layer instanceof Cesium.ImageryLayer) {
+      let baseIndex = this.getBaseLayerIndex(); //防止图层下移到底图下面
+
+      if (layer._layerIndex > baseIndex) {
+        this._viewer.imageryLayers.lower(layer);
+      }
+    }
+  } //重置图层顺序
+
+
+  resetLayerIndex() {
+    let that = this;
+    let oldIndex, layer; //重置影像图层顺序
+
+    that._imageryLayerGuids.forEach(guid => {
+      oldIndex = that.getLayerOldIndex(guid);
+      layer = that.getLayerByGuid(guid);
+      let length = layer._layerIndex - oldIndex;
+
+      for (let j = 0; j < length; j++) {
+        that._viewer.imageryLayers.lower(layer);
+      }
+    });
+  } //设置图层透明度
+
+
+  setLayerOpacityById(guid, opacity) {
+    let layer = this.getLayerByGuid(guid);
+
+    if (layer instanceof Cesium.ImageryLayer) {
+      layer.alpha = opacity;
+    } else if (layer instanceof Cesium.Cesium3DTileset) {
+      layer.style = new Cesium.Cesium3DTileStyle({
+        color: "color('rgba(255,255,255," + opacity + ")')"
+      });
+    }
+  } //添加临时图层树节点
+
+
+  addTempLayerNode(layer, type = 0) {
+    let tempLayer = null;
+
+    for (let i = 0; i < this._layerTreeData.length; i++) {
+      if (this._layerTreeData[i].guid === "134f6h768tha23_3d") {
+        tempLayer = this._layerTreeData[i];
+        break;
+      }
+    }
+
+    if (!tempLayer) {
+      tempLayer = {
+        guid: "134f6h768tha23_3d",
+        name: "临时图层",
+        children: []
+      };
+
+      this._layerTreeData.push(tempLayer);
+    }
+
+    tempLayer.children.push(layer);
+
+    if (type === 0) {
+      if (layer.children) {
+        layer.children.forEach(child => {
+          this._layerListData.push(child);
+        }, this);
+      } else {
+        this._layerListData.push(layer);
+      }
+    }
+
+    this._scenceView.fire("resetLayerDatas");
+  } //设置地形
+
+
+  setTerrain(terrainProvider) {
+    if (this._viewer.terrainProvider) {
+      let guid = this._viewer.terrainProvider.guid;
+
+      if (guid) {
+        //取消树节点勾选
+        function uncheckNode(node, id) {
+          if (node.children) {
+            node.children.forEach(child => {
+              uncheckNode(child, id);
+            });
+          } else {
+            if (node.guid === id) {
+              node.visible = false;
+            }
+          }
+        }
+
+        this._layerTreeData.forEach(item => {
+          uncheckNode(item, guid);
+        });
+
+        this._scenceView.fire("resetLayerDatas");
+      }
+    }
+
+    this._viewer.terrainProvider = terrainProvider;
+  }
+  /**
+   * 删除临时添加数据
+   * 移除渲染图层
+   * 删除 _layerTreeData的临时图层数据
+   * 删除 _layerListData的临时图层数据
+   * @param guid
+   */
+
+
+  delTempData(guid) {
+    if (guid) {
+      let guids = []; //获取需要删除的图层guid集合
+
+      getChildrenByGuid(this._layerTreeData, guid, guids); //删除_layerTreeData数据
+
+      delTreeDataByGuid(this._layerTreeData, guid);
+      guids.forEach(id => {
+        //移除渲染图层
+        this.removeLayerByGuid(id); //删除_layerListData数据
+
+        for (var i = 0; i < this._layerListData.length; i++) {
+          if (id === this._layerListData[i].guid) {
+            this._layerListData.splice(i, 1);
+
+            break;
+          }
+        }
+      }, this);
+    }
+  } //通过guid移除图层
+
+
+  removeLayerByGuid(guid) {
+    let type = this.getLayerTypeByGuid(guid);
+    let layer = this.getLayerByGuid(guid, type);
+
+    if (layer) {
+      switch (type) {
+        case "kqserver":
+        case "imagerylayer":
+          this._viewer.imageryLayers.remove(layer);
+
+          break;
+
+        case "terrainprovider":
+          //删除地形集合数据
+          for (let i = 0; i < this._terrainProviders.length; i++) {
+            if (this._terrainProviders[i].guid === guid) {
+              this._terrainProviders.splice(i, 1);
+
+              break;
+            }
+          }
+
+          this._viewer.terrainProvider = this._emptyTerrainProvider;
+          break;
+
+        case "3dtiles":
+          this._viewer.scene.primitives.remove(layer);
+
+          break;
+
+        case "datasource":
+          this._viewer.dataSources.remove(layer);
+
+          break;
+
+        default:
+          break;
+      }
+    }
+  } //通过guid刷新图层
+
+
+  refreshLayerByGuid(guid) {
+    let layer = this.getLayerByGuid(guid);
+
+    if (layer) {
+      if (layer.imageryProvider && layer.imageryProvider._reload) {
+        layer.imageryProvider._reload();
+      }
+    }
+  } //销毁
+
+
+  destroy() {
+    this._viewer = null;
+    this._scenceView = null;
+  }
+
+}
+/**
+ * 根据guid获取子节点guid集合
+ * @param data
+ * @param guid
+ */
+
+function getChildrenByGuid(data, guid, guids, addChildren = false) {
+  for (let i = 0; i < data.length; i++) {
+    if (data[i].children) {
+      if (data[i].guid === guid || addChildren) {
+        getChildrenByGuid(data[i].children, guid, guids, true);
+      } else {
+        getChildrenByGuid(data[i].children, guid, guids);
+      }
+    } else {
+      if (data[i].guid === guid || addChildren) {
+        guids.push(data[i].guid);
+      }
+    }
+  }
+}
+/**
+ * 根据guid删除树节点数据，包含子节点也删除
+ * @param data
+ * @param guid
+ */
+
+
+function delTreeDataByGuid(data, guid) {
+  var hasGuid = false;
+
+  for (var i = 0; i < data.length; i++) {
+    if (data[i].guid === guid) {
+      data.splice(i, 1);
+      hasGuid = true;
+      break;
+    }
+  }
+
+  if (!hasGuid) {
+    for (var i = 0; i < data.length; i++) {
+      if (data[i].children) {
+        delTreeDataByGuid(data[i].children, guid);
+      }
+    }
+  }
+}
+;// CONCATENATED MODULE: external "@zpc_npm/vue-iclient-common/_types/global-event"
+var global_event_namespaceObject = require("@zpc_npm/vue-iclient-common/_types/global-event");
+var global_event_default = /*#__PURE__*/__webpack_require__.n(global_event_namespaceObject);
+;// CONCATENATED MODULE: ./src/webgl/scenceview/ScenceViewViewModel.js
+
+//ScenceView逻辑类
+
+
+
+
+class ScenceViewViewModel extends (mitt_default()) {
+  // 三维球div id
+  // 三维viewer对象
+  // 语言
+  //绘制管理对象
+  //图层管理对象
+  //底图集合
+  constructor(props, _language) {
+    super();
+
+    _defineProperty(this, "_viewerId", "");
+
+    _defineProperty(this, "_viewer", null);
+
+    _defineProperty(this, "_language", null);
+
+    _defineProperty(this, "_drawManager", null);
+
+    _defineProperty(this, "_layerManager", null);
+
+    _defineProperty(this, "_props", null);
+
+    _defineProperty(this, "_removeEventListener", null);
+
+    _defineProperty(this, "_baseLayers", {});
+
+    this._viewerId = props.target;
+    this._props = props;
+    this._language = _language;
+  } //初始化三维球
+
+
+  initViewer() {
+    var defaultOptions = {
+      imageryProvider: new Cesium.SingleTileImageryProvider({
+        url: Cesium.buildModuleUrl("Assets/Textures/earth_color_low_4096.jpg")
+      }),
+      animation: false,
+      timeline: false,
+      baseLayerPicker: false,
+      geocoder: false,
+      homeButton: false,
+      fullscreenButton: false,
+      selectionIndicator: false,
+      navigation: false,
+      sceneModePicker: false,
+      infoBox: false,
+      //languageStyle: _LANG_, 'zh-cn/en'
+      navigationHelpButton: false
+    };
+
+    for (var key in this._props.options) {
+      if (this._props.options.hasOwnProperty(key)) {
+        defaultOptions[key] = this._props.options[key];
+      }
+    }
+
+    this._viewer = new Cesium.Viewer(this._viewerId, defaultOptions); // this._viewer.scene.globe.depthTestAgainstTerrain = true;
+
+    this.initManagerClass();
+    global_event_default().setWebMap(this._viewerId, "cesium", this);
+    global_event_default().fire("load-viewer", {
+      eventMapTarget: this._viewerId
+    });
+    global_event_default().off("load-viewer");
+    this._layerManager && this._layerManager.addServiceData(this._props.service);
+    this.fire("mounted", {
+      eventMapTarget: this
+    });
+  } //初始化操作类
+
+
+  initManagerClass() {
+    if (this._viewer) {
+      this._drawManager = new DrawManager(this._viewer);
+      this._layerManager = new LayerManager(this);
+    }
+  } //销毁
+
+
+  destroy() {
+    if (this._removeEventListener) {
+      this._removeEventListener();
+
+      this._removeEventListener = null;
+    }
+
+    this._viewer = null;
+    this._drawManager = null;
+    this._layerManager = null;
+  } //获取相机焦点
+
+
+  getCameraFocus() {
+    var scene = this._viewer.scene;
+    var camera = scene.camera;
+    var rayScratch = new Cesium.Ray();
+    rayScratch.origin = camera.positionWC;
+    rayScratch.direction = camera.directionWC;
+    var result = new Cesium.Cartesian3();
+    result = scene.globe.pick(rayScratch, scene, result);
+
+    if (result) {
+      result = camera.worldToCameraCoordinatesPoint(result, result);
+    }
+
+    return result;
+  } //地图缩放
+
+
+  zoom(scale) {
+    var scene = this._viewer.scene;
+    var camera = scene.camera;
+    var focus = this.getCameraFocus();
+    var orientation;
+
+    if (!focus) {
+      // Camera direction is not pointing at the globe, so use the ellipsoid horizon point as
+      // the focal point.
+      var ray = new Cesium.Ray(camera.worldToCameraCoordinatesPoint(scene.globe.ellipsoid.cartographicToCartesian(camera.positionCartographic)), camera.directionWC);
+      focus = Cesium.IntersectionTests.grazingAltitudeLocation(ray, scene.globe.ellipsoid);
+      orientation = {
+        heading: camera.heading,
+        pitch: camera.pitch,
+        roll: camera.roll
+      };
+    } else {
+      orientation = {
+        direction: camera.direction,
+        up: camera.up
+      };
+    }
+
+    var cartesian3Scratch = new Cesium.Cartesian3();
+    var direction = Cesium.Cartesian3.subtract(camera.position, focus, cartesian3Scratch);
+    var movementVector = Cesium.Cartesian3.multiplyByScalar(direction, scale, direction);
+    var endPosition = Cesium.Cartesian3.add(focus, movementVector, focus);
+    camera.flyTo({
+      destination: endPosition,
+      orientation: orientation,
+      duration: 0.5,
+      convert: false
+    });
+  } //地图放大
+
+
+  zoomIn() {
+    this.zoom(0.5);
+  } //地图缩小
+
+
+  zoomOut() {
+    this.zoom(2);
+  } //重置视角
+
+
+  resetView() {//this._viewer.camera.flyHome(1);
+  } //重置方向
+
+
+  resetOrientation() {
+    var camera = this._viewer.camera;
+    var scene = this._viewer.scene;
+    var depthTestAgainstTerrain = scene.globe.depthTestAgainstTerrain;
+
+    if (!depthTestAgainstTerrain) {
+      scene.globe.depthTestAgainstTerrain = true;
+    }
+
+    var canvas = scene.canvas;
+    var windowCenter = new Cesium.Cartesian2(canvas.clientWidth / 2, canvas.clientHeight / 2);
+    setTimeout(() => {
+      var center = scene.pickPosition(windowCenter);
+
+      if (!center) {
+        center = scene.camera.pickEllipsoid(windowCenter, scene.globe.ellipsoid);
+      }
+
+      scene.globe.depthTestAgainstTerrain = depthTestAgainstTerrain;
+      var distance = Cesium.Cartesian3.distance(center, camera.positionWC);
+      var heading = 6.28319;
+      var pitch = camera.pitch;
+      var hpr = new Cesium.HeadingPitchRange(heading, pitch, distance);
+      camera.lookAt(center, hpr);
+      camera.lookAtTransform(Cesium.Matrix4.IDENTITY);
+    }, 300);
+  } //绑定指南针
+
+
+  bindCompassEvent(heading) {
+    var camera = this._viewer.camera;
+    this._removeEventListener = camera.changed.addEventListener(function () {
+      heading.value = camera.heading;
+    });
+  } //获取三维视角
+
+
+  getViewPosition() {
+    var camera = this._viewer.camera;
+    var position = {
+      x: camera.position.x,
+      y: camera.position.y,
+      z: camera.position.z
+    };
+    return {
+      position: position,
+      heading: camera.heading,
+      pitch: camera.pitch,
+      roll: camera.roll
+    };
+  } //设置三维视角
+
+
+  setViewPosition(view) {
+    this._viewer.camera.flyTo({
+      destination: view.position,
+      orientation: {
+        heading: view.heading,
+        pitch: view.pitch,
+        roll: view.roll
+      }
+    });
+  } //创建底图
+
+
+  _createBaseLayer(layerConfig) {
+    let layer = null;
+    let index = 1;
+    let layerType = layerConfig.serverType.toLowerCase();
+
+    switch (layerType) {
+      case "kqserver":
+        layer = this._viewer.imageryLayers.addImageryProvider(new Cesium.Kq3dKQGISMapServerImageryProviderExt({
+          url: layerConfig.url,
+          ua_token: layerConfig.accessToken
+        }), index);
+        break;
+
+      case "wmts":
+        let options = {
+          url: layerConfig.url,
+          layer: layerConfig.id,
+          tileMatrixSetID: layerConfig.tilematrixSet || "default028mm",
+          tileMatrixLabels: layerConfig.tileMatrixLabels,
+          style: layerConfig.style || "default",
+          format: layerConfig.format || "image/png",
+          minimumLevel: layerConfig.minZoom,
+          maximumLevel: layerConfig.maxZoom,
+          subdomains: layerConfig.subdomains,
+          tilingScheme: layerConfig.epsg === "4326" ? new Cesium.GeographicTilingScheme() : new Cesium.WebMercatorTilingScheme()
+        };
+        layer = this._viewer.imageryLayers.addImageryProvider(new Cesium.WebMapTileServiceImageryProvider(options), index);
+        break;
+
+      case "wms":
+        layer = this._viewer.imageryLayers.addImageryProvider(new Cesium.WebMapServiceImageryProvider({
+          url: layerConfig.url,
+          layers: layerConfig.id,
+          parameters: {
+            transparent: "true",
+            format: "image/png"
+          }
+        }), index);
+        break;
+
+      case "tianditu":
+        layer = this._viewer.imageryLayers.addImageryProvider(new Cesium.Kq3dTiandituImageryProvider({
+          mapStyle: layerConfig.layerType + "_c"
+        }), index);
+        break;
+
+      case "baidu":
+        layer = this._viewer.imageryLayers.addImageryProvider(new Cesium.Kq3dBaiduMapsImageryProvider({
+          mapStyle: layerConfig.layerType
+        }), index);
+        break;
+
+      case "gaode":
+        layer = this._viewer.imageryLayers.addImageryProvider(new Cesium.Kq3dAMapsImageryProvider({
+          mapStyle: layerConfig.layerType
+        }), index);
+        break;
+
+      case "tencent":
+        layer = this._viewer.imageryLayers.addImageryProvider(new Cesium.Kq3dQQMapsImageryProvider({
+          mapStyle: layerConfig.layerType
+        }), index);
+        break;
+
+      case "bing":
+        layer = this._viewer.imageryLayers.addImageryProvider(new Cesium.BingMapsImageryProvider({
+          url: layerConfig.url || "https://dev.virtualearth.net",
+          key: layerConfig.key || "AmXdbd8UeUJtaRSn7yVwyXgQlBBUqliLbHpgn2c76DfuHwAXfRrgS5qwfHU6Rhm8",
+          mapStyle: layerConfig.layerType
+        }), index);
+        break;
+
+      case "arcgisonline":
+        layer = this._viewer.imageryLayers.addImageryProvider(new Cesium.Kq3dArcGISMapServerImageryProvider({
+          url: layerConfig.url
+        }), index);
+        break;
+
+      case "mapbox":
+        layer = this._viewer.imageryLayers.addImageryProvider(new Cesium.MapboxImageryProvider({
+          mapId: "mapbox." + layerConfig.layerType,
+          accessToken: layerConfig.key || "pk.eyJ1IjoiZXhhbXBsZXMiLCJhIjoiY2p1dHRybDR5MGJuZjQzcGhrZ2doeGgwNyJ9.a-vxW4UaxOoUMWUTGnEArw"
+        }), index);
+        break;
+
+      case "osm":
+        layer = this._viewer.imageryLayers.addImageryProvider(new Cesium.createOpenStreetMapImageryProvider({
+          url: layerConfig.url
+        }), index);
+        break;
+    }
+
+    return layer;
+  }
+  /**
+   * 操作底图显隐的方法
+   * @param layerKey 存储图层信息的key
+   * @param layerInfo 创建图层的参数信息对象
+   * @param visible 显隐
+   */
+
+
+  showBaseLayer(layerKey, layerInfo, visible) {
+    let layers = this._baseLayers[layerKey];
+
+    if (!layers) {
+      layers = [];
+
+      for (let i = 0; i < layerInfo.layers.length; i++) {
+        let layer = this._createBaseLayer(layerInfo.layers[i]);
+
+        if (layer) {
+          layer.show = visible;
+          layer.layerkey = layerInfo.layers[i].layerkey;
+          layers.push(layer);
+        }
+      }
+
+      this._baseLayers[layerKey] = layers;
+    } else {
+      for (let i = 0; i < layerInfo.layers.length; i++) {
+        layers.forEach(layer => {
+          if (layerInfo.layers[i].layerkey === layer.layerkey) {
+            layer.show = visible;
+          }
+        });
+      }
+    }
+  }
+
+}
+;// CONCATENATED MODULE: ./node_modules/babel-loader/lib/index.js!./node_modules/vue-loader/dist/index.js??ruleSet[0]!./src/webgl/scenceview/ScenceView.vue?vue&type=script&setup=true&lang=js
+
+const _hoisted_1 = {
+  class: "kq-scence-view",
+  ondragstart: "return false;",
+  oncontextmenu: "return false;"
+};
+const _hoisted_2 = ["id"];
+const _hoisted_3 = {
+  class: "view-left-tools"
+};
+
+
+
+
+const __default__ = {
+  name: "KqScenceView"
+};
+/* harmony default export */ var ScenceViewvue_type_script_setup_true_lang_js = (/*#__PURE__*/Object.assign(__default__, {
+  props: {
+    target: {
+      type: String,
+      default: "cesiumContainer"
+    },
+    options: {
+      type: Object,
+
+      default() {
+        return {};
+      }
+
+    },
+    service: {
+      type: Object,
+      default: {
+        name: null,
+        //服务名称
+        url: null,
+        //服务地址
+        token: null,
+        //服务token
+        type: "kqmapserver",
+        //服务类型  kqmapserver或者kq3dserver
+        isShowAllLayers: true,
+        defaultShowLayerNames: []
+      }
+    },
+    showToolButtons: {
+      type: Boolean,
+      default: true
+    }
+  },
+
+  setup(__props) {
+    const props = __props;
+    const {
+      proxy
+    } = (0,external_root_Vue_commonjs_vue_commonjs2_vue_amd_vue_namespaceObject.getCurrentInstance)();
+    /**
+     * 支持传入属性：
+     *   target - viewer对象渲染的div的id
+     *   options - 三维球初始化属性设置
+     *   scenceUrl - 场景地址
+     *   showToolButtons - 是否显示左侧工具栏按钮
+     */
+
+    let language = (0,external_root_Vue_commonjs_vue_commonjs2_vue_amd_vue_namespaceObject.ref)({});
+    let viewModel = null;
+    let heading = (0,external_root_Vue_commonjs_vue_commonjs2_vue_amd_vue_namespaceObject.ref)(0);
+    let removeEventListener = null;
+    (0,external_root_Vue_commonjs_vue_commonjs2_vue_amd_vue_namespaceObject.onMounted)(() => {
+      //设置语言
+      let _lang = proxy.$i18n.locale;
+      let _language = proxy.$i18n.messages[_lang]['webgl'];
+      language.value = _language; //初始化逻辑类
+
+      viewModel = new ScenceViewViewModel(props, _language);
+      viewModel.initViewer();
+
+      if (props.showToolButtons) {
+        //绑定指南针事件
+        viewModel.bindCompassEvent(heading);
+      }
+    }); // 销毁
+
+    (0,external_root_Vue_commonjs_vue_commonjs2_vue_amd_vue_namespaceObject.onBeforeUnmount)(() => {
+      viewModel && viewModel.destroy();
+    }); //地图放大
+
+    function zoomIn() {
+      viewModel && viewModel.zoomIn();
+    } //地图缩小
+
+
+    function zoomOut() {
+      viewModel && viewModel.zoomOut();
+    } //重置视角
+
+
+    function resetView() {
+      viewModel && viewModel.resetView();
+    } //重置方向
+
+
+    function resetOrientation() {
+      viewModel && viewModel.resetOrientation();
+    }
+
+    return (_ctx, _cache) => {
+      const _component_kq_icon = (0,external_root_Vue_commonjs_vue_commonjs2_vue_amd_vue_namespaceObject.resolveComponent)("kq-icon");
+
+      const _component_kq_button = (0,external_root_Vue_commonjs_vue_commonjs2_vue_amd_vue_namespaceObject.resolveComponent)("kq-button");
+
+      return (0,external_root_Vue_commonjs_vue_commonjs2_vue_amd_vue_namespaceObject.openBlock)(), (0,external_root_Vue_commonjs_vue_commonjs2_vue_amd_vue_namespaceObject.createElementBlock)("div", _hoisted_1, [(0,external_root_Vue_commonjs_vue_commonjs2_vue_amd_vue_namespaceObject.renderSlot)(_ctx.$slots, "default"), (0,external_root_Vue_commonjs_vue_commonjs2_vue_amd_vue_namespaceObject.createElementVNode)("div", {
+        id: props.target,
+        class: "view-container"
+      }, [(0,external_root_Vue_commonjs_vue_commonjs2_vue_amd_vue_namespaceObject.withDirectives)((0,external_root_Vue_commonjs_vue_commonjs2_vue_amd_vue_namespaceObject.createElementVNode)("div", _hoisted_3, [(0,external_root_Vue_commonjs_vue_commonjs2_vue_amd_vue_namespaceObject.createVNode)(_component_kq_button, {
+        onClick: zoomIn,
+        title: (0,external_root_Vue_commonjs_vue_commonjs2_vue_amd_vue_namespaceObject.unref)(language).zoomIn
+      }, {
+        default: (0,external_root_Vue_commonjs_vue_commonjs2_vue_amd_vue_namespaceObject.withCtx)(() => [(0,external_root_Vue_commonjs_vue_commonjs2_vue_amd_vue_namespaceObject.createVNode)(_component_kq_icon, {
+          size: 16
+        }, {
+          default: (0,external_root_Vue_commonjs_vue_commonjs2_vue_amd_vue_namespaceObject.withCtx)(() => [(0,external_root_Vue_commonjs_vue_commonjs2_vue_amd_vue_namespaceObject.createVNode)((0,external_root_Vue_commonjs_vue_commonjs2_vue_amd_vue_namespaceObject.unref)(icons_vue_namespaceObject.Plus))]),
+          _: 1
+          /* STABLE */
+
+        })]),
+        _: 1
+        /* STABLE */
+
+      }, 8
+      /* PROPS */
+      , ["title"]), (0,external_root_Vue_commonjs_vue_commonjs2_vue_amd_vue_namespaceObject.createVNode)(_component_kq_button, {
+        onClick: zoomOut,
+        title: (0,external_root_Vue_commonjs_vue_commonjs2_vue_amd_vue_namespaceObject.unref)(language).zoomOut,
+        style: {
+          "margin-top": "0px"
+        }
+      }, {
+        default: (0,external_root_Vue_commonjs_vue_commonjs2_vue_amd_vue_namespaceObject.withCtx)(() => [(0,external_root_Vue_commonjs_vue_commonjs2_vue_amd_vue_namespaceObject.createVNode)(_component_kq_icon, {
+          size: 16
+        }, {
+          default: (0,external_root_Vue_commonjs_vue_commonjs2_vue_amd_vue_namespaceObject.withCtx)(() => [(0,external_root_Vue_commonjs_vue_commonjs2_vue_amd_vue_namespaceObject.createVNode)((0,external_root_Vue_commonjs_vue_commonjs2_vue_amd_vue_namespaceObject.unref)(icons_vue_namespaceObject.Minus))]),
+          _: 1
+          /* STABLE */
+
+        })]),
+        _: 1
+        /* STABLE */
+
+      }, 8
+      /* PROPS */
+      , ["title"]), (0,external_root_Vue_commonjs_vue_commonjs2_vue_amd_vue_namespaceObject.createVNode)(_component_kq_button, {
+        onClick: resetView,
+        title: (0,external_root_Vue_commonjs_vue_commonjs2_vue_amd_vue_namespaceObject.unref)(language).resetView
+      }, {
+        default: (0,external_root_Vue_commonjs_vue_commonjs2_vue_amd_vue_namespaceObject.withCtx)(() => [(0,external_root_Vue_commonjs_vue_commonjs2_vue_amd_vue_namespaceObject.createVNode)(_component_kq_icon, {
+          size: 20
+        }, {
+          default: (0,external_root_Vue_commonjs_vue_commonjs2_vue_amd_vue_namespaceObject.withCtx)(() => [(0,external_root_Vue_commonjs_vue_commonjs2_vue_amd_vue_namespaceObject.createVNode)((0,external_root_Vue_commonjs_vue_commonjs2_vue_amd_vue_namespaceObject.unref)(icons_vue_namespaceObject.RefreshLeft))]),
+          _: 1
+          /* STABLE */
+
+        })]),
+        _: 1
+        /* STABLE */
+
+      }, 8
+      /* PROPS */
+      , ["title"]), (0,external_root_Vue_commonjs_vue_commonjs2_vue_amd_vue_namespaceObject.createVNode)(_component_kq_button, {
+        onClick: resetOrientation,
+        title: (0,external_root_Vue_commonjs_vue_commonjs2_vue_amd_vue_namespaceObject.unref)(language).resetOrientation,
+        class: "compass"
+      }, {
+        default: (0,external_root_Vue_commonjs_vue_commonjs2_vue_amd_vue_namespaceObject.withCtx)(() => [(0,external_root_Vue_commonjs_vue_commonjs2_vue_amd_vue_namespaceObject.createVNode)(_component_kq_icon, {
+          size: 20,
+          style: (0,external_root_Vue_commonjs_vue_commonjs2_vue_amd_vue_namespaceObject.normalizeStyle)('transform: rotate(-' + (0,external_root_Vue_commonjs_vue_commonjs2_vue_amd_vue_namespaceObject.unref)(heading) + 'rad);-webkit-transform: rotate(-' + (0,external_root_Vue_commonjs_vue_commonjs2_vue_amd_vue_namespaceObject.unref)(heading) + 'rad)')
+        }, {
+          default: (0,external_root_Vue_commonjs_vue_commonjs2_vue_amd_vue_namespaceObject.withCtx)(() => [(0,external_root_Vue_commonjs_vue_commonjs2_vue_amd_vue_namespaceObject.createVNode)((0,external_root_Vue_commonjs_vue_commonjs2_vue_amd_vue_namespaceObject.unref)(vue_iclient_icons_namespaceObject.IconCompass3D))]),
+          _: 1
+          /* STABLE */
+
+        }, 8
+        /* PROPS */
+        , ["style"])]),
+        _: 1
+        /* STABLE */
+
+      }, 8
+      /* PROPS */
+      , ["title"])], 512
+      /* NEED_PATCH */
+      ), [[external_root_Vue_commonjs_vue_commonjs2_vue_amd_vue_namespaceObject.vShow, __props.showToolButtons]])], 8
+      /* PROPS */
+      , _hoisted_2)]);
+    };
+  }
+
+}));
+;// CONCATENATED MODULE: ./src/webgl/scenceview/ScenceView.vue?vue&type=script&setup=true&lang=js
+ 
+;// CONCATENATED MODULE: ./src/webgl/scenceview/ScenceView.vue
+
+
+
+const __exports__ = ScenceViewvue_type_script_setup_true_lang_js;
+
+/* harmony default export */ var ScenceView = (__exports__);
+;// CONCATENATED MODULE: external "@zpc_npm/vue-iclient-common/init.js"
+var init_js_namespaceObject = require("@zpc_npm/vue-iclient-common/init.js");
+var init_js_default = /*#__PURE__*/__webpack_require__.n(init_js_namespaceObject);
+;// CONCATENATED MODULE: ./src/webgl/scenceview/index.js
+
+
+
+
+ScenceView.install = (Vue, opts) => {
+  init_js_default()(Vue, opts);
+  Vue.component(ScenceView.name, ScenceView);
+};
+
+
+}();
+module.exports = __webpack_exports__;
+/******/ })()
+;