任务新增导出

zhongrj

2023-06-27 d74b495736f0c04522ec54274b70fed0ded2878d

 public/map/core/utils/LayerUtil.js

New file
@@ -0,0 +1,178 @@
define([
"dojo/_base/declare", "dojo/_base/array", "dojo/_base/lang",
"dojo/request", "dojo/topic",
"esri/layers/ArcGISTiledMapServiceLayer", "esri/geometry/Extent",
"esrichina/TianDiTuLayer", "esrichina/GoogleMapLayer", "esri/layers/ArcGISDynamicMapServiceLayer"
    ],
    function (declare, arrayUtil, lang,
              request, topic,
              ArcGISTiledMapServiceLayer, Extent,
              TianDiTuLayer, GoogleMapLayer, ArcGISDynamicMapServiceLayer) {
        return {
            /**
             *图层类型
             */
            AGS_TILE: "arcgis tiled",
            AGS_DYNAMIC: "arcgis dynamic",
            WMTS: "wmts",
            TIANDITU: "tianditu",
            GOOGLE: "google",

            EVENT_LOADCONFIGANDPARSE_SUCCESS: "event_layerUtil_loadconfigAndParse_success",
            EVENT_LOADCONFIGANDPARSE_ERROR: "event_layerUtil_loadconfigAndParse_error",

            loadconfigAndParse: function (url) {
                request.get(url, {
                    handleAs: "json"
                }).then(lang.hitch(this, function (result) {
                    var _parseResult = this.parse(result);
                    topic.publish(this.EVENT_LOADCONFIGANDPARSE_SUCCESS, _parseResult);
                }), lang.hitch(this, function (err) {
                    topic.publish(this.EVENT_LOADCONFIGANDPARSE_ERROR, err);
                }));
            },

            parse: function (config) {
                _parseResult = {};
                _parseResult.extent = _getStartExtent(config.initExtent, config.wkid);
                _parseResult.maplogo = config.maplogo;
                _parseResult.gallerys = config.gallerys;
                _parseResult.multidate = config.multidate;
                _parseResult.swipe = config.swipe;
                _parseResult.tkey = config.tkey;//天地图服务开发者key
                _groupsParseResult = this.parseGroups(config.grouplayers);
                declare.safeMixin(_parseResult, _groupsParseResult);
                return _parseResult;

                function _getStartExtent(initExtent, wkid) {
                    return new esri.geometry.Extent({
                        "xmin": initExtent[0],
                        "ymin": initExtent[1],
                        "xmax": initExtent[2],
                        "ymax": initExtent[3],
                        "spatialReference": {
                            "wkid": wkid
                        }
                    });
                }
            },
            parseGroups: function (groupsConfig) {
                var groups = {};
                var groupsInOrder = [];
                var curGroupId = null;
                var curSetId = null;

                for (var key in groupsConfig) {
                    var group = _parseGroup.call(this, groupsConfig[key]);
                    groups[group.id] = group;
                    groupsInOrder.push(group.id);
                }
                return {
                    groups: groups,
                    curGroupId: curGroupId,
                    curSetId: curSetId,
                    groupsInOrder: groupsInOrder
                };

                function _parseGroup(groupConfig) {
                    var group = new Object();
                    group.id = groupConfig.id;
                    group.galleryId = groupConfig.gallery;
                    group.icon = groupConfig.icon;
                    group.label = groupConfig.label;
                    if (groupConfig.visible)
                        curGroupId = group.id;
                    //group.baselayers = _parseLayers.call(this, groupConfig.baselayers);
                    group.baselayers = null;
                    group.baselayersConfig = groupConfig.baselayers;
                    _parseLayerSet.call(this, groupConfig.layerset);
                    return group;

                    function _parseLayerSet(layersetConfig) {
                        layerset = {};
                        layersetInOrder = [];
                        for (var key in layersetConfig) {
                            layersetItemConfig = layersetConfig[key];
                            var layersetItem = new Object();
                            layersetItem.id = layersetItemConfig.id;
                            layersetItem.type = layersetItemConfig.type;
                            layersetItem.label = layersetItemConfig.label;
                            layersetItem.layers = null;
                            layersetItem.layersConfig = layersetItemConfig.layers;
                            //layersetItem.layers = _parseLayers.call(this, layersetItemConfig.layers);
                            if (layersetItemConfig.visible) {
                                curSetId = layersetItem.id;
                            }
                            if (layersetItemConfig["default"]) {
                                group.defaultset = layersetItem.id;
                            }
                            layerset[layersetItem.id] = layersetItem;
                            layersetInOrder.push(layersetItem.id);
                        }
                        group.layerset = layerset;
                        group.layersetInOrder = layersetInOrder;
                        if (!group.defaultset && layersetInOrder.length != 0) {
                            group.defaultset = layersetInOrder[0];
                        }
                    }
                }
            },
            /**
             * 解析图层，创建图层对象
             * @param {Object} layersConfig
             */
            parseLayers: function (layersConfig) {
                _layers = [];
                for (var key in layersConfig) {
                    var layer = this._parseLayer.call(this, layersConfig[key]);
                    //layer.copyForOverview = this._parseLayer.call(this, layersConfig[key]);
                    _layers.push(layer);
                    //layers.push(layer);
                }
                return _layers;
            },

            _parseLayer: function (layerConfig) {
                layerConfig.type = layerConfig.type.toLowerCase();
                var layer = null;
                switch (layerConfig.type) {
                    case this.AGS_TILE:
                        layer = new ArcGISTiledMapServiceLayer(
                            layerConfig.url, {
                                displayLevels: layerConfig.displaylevels
                            });
                        break;
                    case this.AGS_DYNAMIC:
                        layer = new ArcGISDynamicMapServiceLayer(layerConfig.url);
                        if (layerConfig.layer == 'border')
                            layer.setVisibleLayers([0, 1,2]);
                        break;
                    case this.TIANDITU:
                        var option = {
                            displayLevels: layerConfig.displaylevels,
                            tkey:_parseResult.tkey
                        }
                        if (layerConfig.TILEMATRIXSET)
                            option._tilematrixSet = layerConfig.TILEMATRIXSET;
                        if (layerConfig.FORMAT)
                            option.format = layerConfig.FORMAT;
                        layer = new TianDiTuLayer(
                            "geo",
                            layerConfig.url,
                            layerConfig.layer,
                            option
                        );
                        layer.id = layerConfig.layer;
                        if (layer.id=='cia'||layer.id=='cva'){//默认不显示标记图层
                            layer.opacity = 1;
                        }
                        break;
                    case this.GOOGLE:
                        layer = new GoogleMapLayer(layerConfig);
                        break;
                }
                //layerIndex[layer.id] = layers.length - 1;
                return layer;
            }
        };
    });