【SDK】【新增】【Cesium设置6大模块分类】

Author: 潘卓然Y7000P

src/cesiumjs/layer/BaseLayer.js

@@ -4,9 +4,9 @@ import { CesiumZondy } from '../core/Base';
  * @author 基础平台研发中心·冯桂英
  * @class BaseLayer
  * @category BaseLayer
- * @classdesc BaseLayer
+ * @classdesc BaseLayer 数据服务基类
  * @description 图层管理基类,实现图层公共方法
- * @param option.viewer = viewer 场景视图
+ * @param option.viewer 场景视图
  */
 export default class BaseLayer {
     constructor(option) {
@@ -35,7 +35,7 @@ export default class BaseLayer {
     }
 
     /**
-     * 场景 
+     * 场景
      * @memberof BaseLayer.prototype
      * @type {Scene}
      * @readonly
@@ -49,58 +49,70 @@ export default class BaseLayer {
      * @param {Object} layer 图层对象
      */
     zoomToM3dLayer(layer) {
-        let boundingSphere = layer.boundingSphere;
-        this.viewer.camera.viewBoundingSphere(
-            boundingSphere,
-            new Cesium.HeadingPitchRange(0.0, -0.5, boundingSphere.radius)
-        );
+        const { boundingSphere } = layer;
+        this.viewer.camera.viewBoundingSphere(boundingSphere, new Cesium.HeadingPitchRange(0.0, -0.5, boundingSphere.radius));
         this.viewer.camera.lookAtTransform(Cesium.Matrix4.IDENTITY);
     }
 
-    /***
+    /**
      * 移除m3d 图层
      */
     removeM3dLayer(layer) {
         this.viewer.scene.primitives.remove(layer);
     }
 
     /**
-     * 移除添加的所有m3d文档，layers为图层数组
+     * 移除添加的文档
      */
     removeDocs(layers) {
         if (!Cesium.defined(layers)) {
             return;
         }
-        for (var i in layers) {
+        for (let i = 0; i < layers.length; i += 1) {
             this.viewer.scene.primitives.remove(layers[i]);
         }
-        return;
+    }
+
+    /**
+     * 通用添加影像图层
+     * @param {Imagelayer} google等图层
+     * @returns {Imagelayer} 返回瓦片层
+     */
+    addImageLayer(imagelayer) {
+        const imagelayers = this.viewer.imageryLayers;
+        if (imagelayers !== null && imagelayers !== undefined) {
+            if (!imagelayers.contains(imagelayer)) {
+                return imagelayers.addImageryProvider(imagelayer);
+            }
+        }
+        return undefined;
     }
 
     /**
      * 添加全球网格信息
-     * @returns 网格图层
+     * @returns {ImageryLayer} 网格图层
      */
     addGridInfo() {
         if (undefined === this._tileGridLayer) {
-            let tileGridLayer = new Cesium.TileCoordinatesImageryProvider({
+            const tileGridLayer = new Cesium.TileCoordinatesImageryProvider({
                 showLonlats: true
             });
-            let imagelayers = this.viewer.imageryLayers;
+            const imagelayers = this.viewer.imageryLayers;
             if (imagelayers !== null && imagelayers !== undefined) {
                 if (!imagelayers.contains(tileGridLayer)) {
                     return imagelayers.addImageryProvider(tileGridLayer);
                 }
             }
         }
+        return undefined;
     }
 
     /**
      * 移除全球网格信息
-     * @param {Object} gridlayers 网格图层
+     * @param {ImageryLayer} gridlayers 网格图层
      */
     removeGridInfo(gridlayers) {
-        let imagelayers = this.viewer.imageryLayers;
+        const imagelayers = this.viewer.imageryLayers;
         if (imagelayers !== null && imagelayers !== undefined) {
             if (imagelayers.contains(gridlayers)) {
                 imagelayers.remove(gridlayers, true);
@@ -110,14 +122,14 @@ export default class BaseLayer {
 
     /**
      * 通用删除影像图层
-     * @param  {imagelayer} google等图层,其为addImageryProvider返回的值
-     * @param  {boolean}    isdestroy,是否销毁图层 在图层需要频繁切换的情况下，isdestroy最好取false
+     * @param {Imagelayer} google等图层其为addImageryProvider返回的值
+     * @param {Boolean} isdestroy 是否销毁图层 在图层需要频繁切换的情况下，isdestroy最好取false
      * @example
      * let tilelayer = tile.appendGoogleMap({ptype:'m@207000000'});
      * tile.removeImageLayer(tilelayer, true);
      */
     removeImageLayer(imagelayer, isdestroy) {
-        let imagelayers = this.viewer.imageryLayers;
+        const imagelayers = this.viewer.imageryLayers;
         if (imagelayers !== null && imagelayers !== undefined) {
             if (imagelayers.contains(imagelayer)) {
                 imagelayers.remove(imagelayer, isdestroy);
@@ -127,14 +139,52 @@ export default class BaseLayer {
 
     /**
      * 清空影像图层,包括地球表面
-     * @param  {boolean}    isdestroy,是否销毁图层
+     * @param {Boolean} isdestroy 是否销毁图层
      */
     removeAllImageLayers(isdestroy) {
-        var imagelayers = this.viewer.imageryLayers;
+        const imagelayers = this.viewer.imageryLayers;
         if (imagelayers !== null && imagelayers !== undefined) {
             imagelayers.removeAll(isdestroy);
         }
     }
+
+    /**
+     * 移除实体
+     * @param  {Entity} entity 实体对象
+     */
+    removeEntity(entity) {
+        this.viewer.entities.remove(entity);
+    }
+
+    /**
+     * 移除所有实体
+     */
+    removeAllEntities() {
+        this.viewer.entities.removeAll();
+    }
+
+    /**
+     * 移除primitive实体
+     * @param {Primitive} 移除对象
+     */
+    removePrimitive(primitive) {
+        this.scene.primitives.remove(primitive);
+    }
+
+    /**
+     * 移除全部实体
+     */
+    removeAllPrimitives() {
+        this.scene.primitives.removeAll();
+    }
+
+    /**
+     * 移除地形图层
+     */
+    removeTerrain() {
+        const ElliProvider = new Cesium.EllipsoidTerrainProvider();
+        this.viewer.terrainProvider = ElliProvider;
+    }
 }
 
 CesiumZondy.Layer.BaseLayer = BaseLayer;

src/cesiumjs/layer/LayerManager.js

@@ -0,0 +1,137 @@
+import { CesiumZondy } from '../core/Base';
+
+import LayerType from './LayerType';
+import M3DLayer from './M3DLayer';
+import TerrainLayer from './TerrainLayer';
+import TilesLayer from './TilesLayer';
+import BaseLayer from './BaseLayer';
+
+/**
+ * @author 三维基础平台研发中心·冯桂英
+ * @class module:客户端数据服务.LayerManager
+ * @category LayerManager
+ * @classdesc LayerManager 图层管理类
+ * @description 图层管理类,处理场景相关操作
+ * @param options.viewer 场景视图
+ */
+export default class LayerManager extends BaseLayer {
+    constructor(optionsParam) {
+        const options = Cesium.defaultValue(optionsParam, {});
+        super(options);
+    }
+
+    /**
+     * 添加三维场景文档服务
+     * @function module:客户端数据服务.LayerManager.prototype.append
+     * @param {String} url 文档地址
+     * @param {Object} optionsParam 参数
+     * @param {Boolean} [optionsParam.autoReset = true] 是否自动定位
+     * @param {Boolean} [optionsParam.synchronous = true] 是否异步请求
+     * @param {Function} [optionsParam.loaded = function] 回调函数
+     * @param {DefaultProxy} [optionsParam.proxy = defaultProxy] 代理
+     * @example
+     * let layerManager = new LayerManager(view);
+     * function callBackfunction(layer){
+     * console.log(layer)
+     * }
+     * layerManager.append('http://192.168.90.102:6163/igs/rest/g3d/1218示例', {
+     * autoReset:false,
+     * synchronous:true,
+     * loaded:callBackfunction
+     * });
+     * //添加地形
+     * let terrainProivder = layerManager.append('http://develop.smaryun.com:6163/igs/rest/g3d/terrain');
+     */
+    append(url, optionsParam) {
+        if (!Cesium.defined(url)) {
+            return new Cesium.DeveloperError('必须指定url');
+        }
+        const options = Cesium.defaultValue(optionsParam, {});
+        let synchronous = true;
+        const baseUrl = url;
+        let resource;
+        let proxy;
+        const docLayers = [];
+
+        if (Cesium.defined(options)) {
+            if (Cesium.defined(options.proxy)) {
+                // 不放在defaultValue中 new 会影响性能
+                proxy = new Cesium.DefaultProxy(options.proxy);
+            }
+            Cesium.defaultValue(options.proxy, undefined);
+            synchronous = Cesium.defaultValue(options.synchronous, true);
+        }
+
+        const _callBack = (params) => {
+            const _params = params;
+            if (Cesium.defined(options.loaded) && typeof options.loaded === 'function') {
+                options.loaded(_params);
+            }
+        };
+
+        let tileset = null;
+        const parseDocInfo = (info) => {
+            if (info !== undefined && info.sceneInfos.length > 0) {
+                const { layers } = info.sceneInfos[0];
+                layers.forEach((layer) => {
+                    const { layerRenderIndex, layerIndex, gdbpUrl, layerType, isVisible } = layer;
+                    const type = parseInt(layerType, 10);
+                    switch (type) {
+                        case LayerType.TERRAINLAYER: {
+                            const terrainLayer = new TerrainLayer({
+                                viewer: this.viewer
+                            });
+                            const opt = {
+                                range: layer.range,
+                                scale: layer.terrainLayer.elevationScale
+                            };
+                            Object.extend(options, opt);
+                            const layerRes = terrainLayer.appendTerrainLayer(baseUrl, 0, layerRenderIndex, proxy, options);
+                            docLayers.push(layerRes);
+                            break;
+                        }
+                        case LayerType.TILEIMAGELAYER: {
+                            const tileLayer = new TilesLayer({
+                                viewer: this.viewer
+                            });
+                            const doc = tileLayer.append3DDocTileLayer(baseUrl, 0, layerRenderIndex, proxy);
+                            docLayers.push(doc);
+                            break;
+                        }
+                        case LayerType.MODELLAYER:
+                        case LayerType.M3DLAYER: {
+                            const m3d = new M3DLayer({ viewer: this.viewer });
+                            tileset = m3d.appendM3DLayer(baseUrl, layerRenderIndex, layerIndex, gdbpUrl, isVisible, true, options);
+                            docLayers.push(tileset);
+                            tileset.readyPromise.then(_callBack);
+                            break;
+                        }
+                        default:
+                            break;
+                    }
+                });
+            }
+        };
+
+        if (synchronous) {
+            resource = new Cesium.Resource({
+                url: `${baseUrl}/GetDocInfo`,
+                proxy
+            });
+            resource.fetchJson().then((json) => parseDocInfo(json));
+        } else {
+            const request = new Cesium.XMLHttpRequest();
+            request.open('GET', `${baseUrl}/GetDocInfo`, false);
+            request.send(null);
+            if (request.status === 200) {
+                const info = Cesium.JSON.parse(request.responseText);
+                if (info) {
+                    parseDocInfo(info);
+                }
+            }
+        }
+        return docLayers;
+    }
+}
+
+CesiumZondy.Layer.LayerManager = LayerManager;

src/cesiumjs/layer/LayerType.js

@@ -1,4 +1,4 @@
-import {CesiumZondy} from "../core/Base";
+import { CesiumZondy } from '../core/Base';
 
 /**
  * 描述图层类型.
@@ -8,7 +8,7 @@ import {CesiumZondy} from "../core/Base";
  *
  * @see Layer#type
  */
-let LayerType = {
+const LayerType = {
     /**
      * 未知类型.
      *
@@ -55,7 +55,7 @@ let LayerType = {
      * @type {Number}
      * @constant
      */
-    M3DLAYER: 10,
+    M3DLAYER: 10
 };
 
 export default Object.freeze(LayerType);