csk-gis-frame-work 4.0.0

package/mapboxgl/js/geog/LayerProvider.js

@@ -0,0 +1,275 @@
+/**
+ * 定义地图图层提供类
+ */
+export default class LayerProvider {
+  constructor() { }
+
+  /**
+   * 获取基础图层查询url
+   * @param {Object} map -地图对象
+   * @param {String} category -图层类型
+   * @param {String|Numner} value -值
+   * @param {String|Numner} value2 -值2
+   *
+   * @returns {String}
+   */
+  static getBaseLayerQueryUrl(map, category, value, value2=null) {
+    if (!map._baseQueryLayers) return null;
+
+    const queryLayers = map._baseQueryLayers.filter(layer => {
+      return layer.id === category;
+    });
+    if (queryLayers.length === 0) return null;
+
+    let url = queryLayers[0].url;
+
+    switch (category) {
+      case 'town':
+      case 'town_stats': { // 街镇/街镇统计点
+        return value ? url + "&cql_filter=code='" + value.toString() + "'" : url;
+      }
+      case 'poi':
+      case 'road': { // POI/道路
+        return url + "&featureID=" + parseInt(value);
+      }
+      case 'plant': { // 水厂
+        return value ? url + "&cql_filter=plant_id='" + value.toString() + "'" : url;
+      }
+      case 'pumpwaste': { // 污水泵站
+        return value
+               ? url + "&cql_filter=pump_id='" + value.toString() + "'"
+               : url + "&cql_filter=category='2'";
+      }
+      case 'drainer-connhole': // 接驳井函数
+      case 'drainer-drainunit': { // 排水单元函数
+        return url + '&viewparams=draincode:' + value.toString();
+      }
+      case 'drainer-drainentity': { // 排水户函数
+        return url + '&viewparams=nodeid:' + value.toString();
+      }
+      case 'drainunit': { // 排水单元
+        return value ? url + "&cql_filter=unit_code='" + value.toString() + "'" : url;
+      }
+      case 'drainentity': { // 排水户
+        return url + "&cql_filter=drain_code='" + value.toString() + "'";
+      }
+      case 'liquid-plant':         // 水厂范围内的液位计
+      case "servicerange-plant": { // 水厂服务范围
+        return value ? url + "&cql_filter=plant_id='" + value.toString() + "'" : url;
+      }
+      case 'liquid-pump':         // 泵站范围内的液位计
+      case "servicerange-pump": { // 泵站服务范围
+        return value ? url + "&cql_filter=pump_id='" + value.toString() + "'" : url;
+      }
+      case "manhole": { // 检查井
+        return url + "&cql_filter=node_id='" + value.toString() + "'";
+      }
+      case "manhole-in": // 排水单元内管网
+      case "pipeline-in": {
+        return url + "&cql_filter=unit_code='" + value.toString() + "'";
+      }
+      case "pipeline":  // 管线
+      case 'pipenet': { // 管网
+        return url + "&cql_filter=pipe_id='" + value.toString() + "'";
+      }
+      case 'pipe-mixing': { // 管网雨污混接
+        return url + "&cql_filter=pipe_id='" + value.toString() + "'";
+      }
+      case 'pipenet-equ': { // 设备管网
+        return url;
+      }
+      case 'pipenet-down': { // 管网-检查井下游分析
+        //return url + "&cql_filter=in_nodeid='" + value.toString() + "'";
+        return url + '&viewparams=updown:down;nodecode:' + value.toString();
+      }
+      case 'pipenet-up': { // 管网-检查井上游分析
+        //return url + "&cql_filter=out_nodeid='" + value.toString() + "'";
+        return url + '&viewparams=updown:up;nodecode:' + value.toString();
+      }
+      case 'pipenet-plant': { // 管网分析-水厂
+        return url + "&cql_filter=in_plantid='" + value.toString() + "'";
+      }
+      case 'pipenet-pump': { // 管网分析-泵站
+        return url + "&cql_filter=in_pumpid='" + value.toString() + "'";
+      }
+      case 'pipenet-error':    // 管网分析-上下游错误
+      case 'pipenet-errorup':
+      case 'pipenet-errordown':
+      case 'pipenet-delete':   // 管网分析-结果删除
+      case 'pipenet-deviceup': // 管网分析-上下游设备
+      case 'pipenet-devicedown': {
+        return url + '&viewparams=udid:' + value.toString();
+      }
+      case 'pipenet-downstream':
+      case 'pipenet-coverage':
+      case 'pipenet-plantpump': { // 管网分析-下游/下游覆盖范围/上下游厂站
+        return url + '&viewparams=sourceid:' + value.toString();
+      }
+      case 'pipenet-upstream':
+      case 'pipenet-drainentity':
+      case 'pipenet-drainunit': { // 管网分析-上游/排水户/排水单元
+        return url + '&viewparams=targetid:' + value.toString();
+      }
+      case 'pipenet-dijkstra': { // 管网分析-最短路径
+        if (value && value2) {
+          return url + '&viewparams=sourceid:' + value.toString() + ';targetid:' + value2.toString();
+        } else {
+          return null;
+        }
+      }
+      default:
+        return null;
+    }
+  }
+
+  /**
+   * 过滤图层
+   * @param {Object} map -地图对象
+   * @param {String} id -图层Id
+   * @param {Array} filter -过滤数组
+   *
+   * @summary <filter参数示例：['==', 'fld', 'val']>
+   */
+  static filterLayer(map, id, filter) {
+    if (!map.getLayer(id)) return;
+
+    map.setFilter(id, filter);
+  }
+
+  /**
+   * 判断图层是否加载
+   * @param {Object} map -地图对象
+   * @param {String} id -图层Id
+   *
+   * @returns {Boolean}
+   */
+  static hasLayer(map, id) {
+    if (map.getLayer(id)) {
+      return true;
+    }
+
+    return false;
+  }
+
+  static has3DBuildingLayer(map, id='map_nh_building-3d') {
+    let layer = map.getLayer(id);
+    if (layer) {
+      console.log(layer);
+      return true;
+    }
+
+    return false;
+  }
+
+  /**
+   * 判断图层是显示
+   * @param {Object} map -地图对象
+   * @param {String} id -图层Id
+   *
+   * @returns {Boolean}
+   */
+  static isLayerVisible(map, id) {
+    return ('visible' === map.getLayoutProperty(id, 'visibility'));
+  }
+
+  /**
+   * 显示/隐藏图层
+   * @param {Object} map -地图对象
+   * @param {String} id -图层Id
+   * @param {Boolean} isShow -是否显示
+   */
+  static showLayer(map, id, isShow = true) {
+    let visible = isShow ? 'visible' : 'none';
+
+    if (map.getLayer(id)) {
+      map.setLayoutProperty(id, 'visibility', visible);
+    }
+  }
+
+  /**
+   * 移动图层
+   * @param {Object} map -地图对象
+   * @param {String} id -需要移动的图层Id
+   * @param {String} beforeId -现有图层Id
+   *
+   * @summary <id图层将显示到beforeId图层之下>
+   */
+  static moveLayer(map, id, beforeId) {
+    if (map.getLayer(id)) {
+      map.moveLayer(id, beforeId);
+    }
+  }
+
+  /**
+   * 移除图层
+   * @param {Object} map -地图对象
+   * @param {String} id -图层Id
+   */
+  static removeLayer(map, id) {
+    if (map.getLayer(id)) {
+      map.removeLayer(id);
+    }
+  }
+
+  /**
+   * 绑定事件
+   * @param {Object} map -地图对象
+   * @param {String} layerId -图层Id
+   * @param {String} name -事件
+   * @param {function} func -函数对象
+   */
+  static onEvent(map, layerId, name, func) {
+    map.on(name, layerId, func);
+  }
+
+  /**
+   * 解除事件绑定
+   * @param {Object} map -地图对象
+   * @param {String} layerId -图层Id
+   * @param {String} name -事件
+   * @param {function} func -函数对象
+   */
+  static offEvent(map, layerId, name, func) {
+    map.off(name, layerId, func);
+  }
+
+  /**
+   * 判断数据源是否加载
+   * @param {Object} map -地图对象
+   * @param {String} id -数据源Id
+   *
+   * @returns {Boolean}
+   */
+  static hasSource(map, id) {
+    if (map.getSource(id)) {
+      return true;
+    }
+
+    return false;
+  }
+
+  /**
+   * 设置数据源
+   * @param {Object} map -地图对象
+   * @param {String} id -数据源Id
+   * @param {String|Object} data -数据源
+   *
+   * @summary <data参数：数据的url或GeoJSON对象>
+   */
+  static updateSource(map, id, data) {
+    if (map.getSource(id)) {
+      map.getSource(id).setData(data);
+    }
+  }
+
+  /**
+   * 移除数据源
+   * @param {Object} map -地图对象
+   * @param {String} id -数据源Id
+   */
+  static removeSource(map, id) {
+    if (map.getSource(id)) {
+      map.removeSource(id);
+    }
+  }
+}

package/mapboxgl/js/geog/LocationProvider.js

@@ -0,0 +1,227 @@
+import DataUtils from '../utils/DataUtils';
+import GeogUtils from '../utils/GeogUtils';
+import MapProvider from './MapProvider';
+import GeoJsonProvider from './GeoJsonProvider';
+import LocationLayer from '../common/LocationLayer';
+
+/**
+ * 定位(+聚焦)图层对象类
+ * @alias LocationProvider
+ *
+ * @summary <用于定位/聚焦的点/线加载>
+ */
+export default class LocationProvider {
+  /**
+   * 构造函数
+   * @param {Object} options -图层选项
+   */
+  constructor(options) {
+    /**
+     * 地图对象
+     * @type {Object}
+     */
+    this._map = options.map;
+
+    /**
+     * 最小缩放层级
+     * @type {Number}
+     */
+    this._minzoom = DataUtils.default(options.minzoom, 10);
+
+    /**
+     * 图标偏移
+     * @type {Array}
+     */
+    this._offset = DataUtils.default(options.offset, [0, -22]);
+
+    /**
+     * 线宽
+     */
+    this._lineWidth = DataUtils.default(options.lineWidth, 7.5);
+
+    /**
+     * 字段名
+     * @type {String}
+     */
+    this._fieldName = DataUtils.default(options.field, undefined);
+
+    /**
+     * 文本偏移
+     * @type {Array}
+     */
+    this._textOffset = DataUtils.default(options.textOffset, [0, -2.0]);
+
+    // 创建图层对象
+    this._locationLayer = new LocationLayer({
+      map: this._map,
+      minzoom: this._minzoom,
+      lineWidth: this._lineWidth,
+      offset: this._offset,
+      field: this._fieldName,
+      textOffset: this._textOffset
+    });
+  }
+
+  /**
+   * 缩放至要素集合
+   * @param {Object} map -地图对象
+   * @param {Array} features -GeoJson要素集合
+   * @param {Number} zoom - 缩放层级
+   */
+  static fitToFeatures(map, features, zoom = 15.75) {
+    if (!features || features.length === 0) return;
+
+    const pointFC = GeoJsonProvider.getEmptyFC();
+    pointFC.features = features.filter((fea) => {
+      return fea.geometry.type.toLowerCase() === 'point';
+    });
+
+    const lineFC = GeoJsonProvider.getEmptyFC();
+    lineFC.features = features.filter((fea) => {
+      return fea.geometry.type.toLowerCase() === 'linestring' ||
+             fea.geometry.type.toLowerCase() === 'multilinestring';
+    });
+
+    // 计算包围盒
+    let bboxP = [], bboxL = [];
+    if (pointFC.features.length > 0) {
+      let pntFea = pointFC.features[0]
+      bboxP = pointFC.features.length === 1
+              ? [pntFea.geometry.coordinates, pntFea.geometry.coordinates]
+              : GeogUtils.calcBBox(pointFC);
+    }
+    if (lineFC.features.length > 0) {
+      bboxL = GeogUtils.calcBBox(lineFC);
+    }
+
+    // 缩放至要素范围
+    if (bboxP.length > 0 || bboxL.length > 0) {
+      let bbox = [];
+      let isJumpTo = false;
+      if (bboxP.length === 1 && bboxL.length === 0) {
+        isJumpTo = true;
+      } else if (bboxP.length > 0 && bboxL.length === 0) {
+        bbox = bboxP;
+      } else if (bboxP.length === 0 && bboxL.length > 0) {
+        bbox = bboxL;
+      } else {
+        bbox = [
+          [Math.min(bboxP[0][0], bboxL[0][0]), Math.min(bboxP[0][1], bboxL[0][1])],
+          [Math.max(bboxP[1][0], bboxL[1][0]), Math.max(bboxP[1][1], bboxL[1][1])]
+        ];
+      }
+
+      if (isJumpTo) {
+        MapProvider.jumpTo(map, bboxP[0], zoom);
+      } else {
+        MapProvider.fitBounds(map, bbox, zoom, true);
+      }
+    }
+  }
+
+  /**
+   * 定位
+   * @param {Array} center -经纬度
+   * @param {Number} zoom -缩放层级
+   */
+  locate(center, zoom = null, jump = false) {
+    this._locationLayer.locate(center, zoom, jump);
+  }
+
+  /**
+   * 添加定位
+   * @param {Array|Object} data -数据
+   * @param {Number} zoom -缩放层级
+   */
+  addLocate(data, zoom = null, jump = false) {
+    this._locationLayer.addData(data, zoom, jump);
+  }
+
+  /**
+   * 定位数据
+   * @param {Array|Object} data -数据
+   * @param {Number} zoom -缩放层级
+   * @param {Boolean} jump -是否直接定位
+   */
+  setLocate(data, zoom = null, jump = false) {
+    this._locationLayer.setData(data, zoom, jump);
+  }
+
+  /**
+   * 聚焦数据
+   * @param {Array|Object} data -数据
+   * @param {Number} zoom -缩放层级
+   * @param {Boolean} jump -是否直接定位
+   */
+  setFocus(data, zoom = null, jump = false) {
+    this._locationLayer.setFocus(data, zoom, jump);
+  }
+
+  /**
+   * 设置选中
+   * @param {Object} data -GeoJSON要素集
+   */
+  setSelection(data) {
+    this._locationLayer.setSelection(data);
+  }
+
+  /**
+   * 开始拖拽
+   */
+  startDragging() {
+    this._locationLayer.startDragging();
+  }
+
+  /**
+   * 停止拖拽
+   */
+  stopDragging() {
+    this._locationLayer.stopDragging();
+  }
+
+  /**
+   * 获取拖拽要素
+   *
+   * @returns {Object}
+   */
+  getDraggingFeature() {
+    return this._locationLayer._draggingFeature;
+  }
+
+  /**
+   * 获取数据
+   *
+   * @returns {Object}
+   */
+  getData() {
+    // 判断返回折线要素集 or 点要素集
+    const lineFC = this._locationLayer._lineFC;
+    if (lineFC && lineFC.features && lineFC.features.length > 0) {
+      return lineFC;
+    }
+
+    return this._locationLayer._fc;
+  }
+
+  /**
+   * 清除数据
+   */
+  clearData() {
+    this._locationLayer.clearData();
+  }
+
+  /**
+   * 显示/隐藏图层
+   * @param {Boolean} isShow -是否显示图层
+   */
+  showLayer(isShow = true) {
+    this._locationLayer.showLayer(isShow);
+  }
+
+  /**
+   * 移除图层
+   */
+  removeLayer() {
+    this._locationLayer.removeLayer();
+  }
+}

package/mapboxgl/js/geog/MapProvider.js

@@ -0,0 +1,179 @@
+import DataUtils from '../utils/DataUtils';
+import GeogUtils from '../utils/GeogUtils';
+
+/**
+ * 定义地图方法提供类
+ */
+export default class MapProvider {
+  constructor() { }
+
+  /**
+   * 获取地图对象
+   *
+   * @returns {Object}
+   */
+  static getMap() {
+    return window.gisMap;
+  }
+
+  /**
+   * 设置鼠标样式
+   * @param {Object} map -地图对象
+   * @param {String} cursor -鼠标样式
+   */
+  static setCursor(map, cursor = '') {
+    if (map.getCanvas().style.cursor !== 'crosshair') {
+      map.getCanvas().style.cursor = cursor;
+    }
+  }
+
+  /**
+   * 绑定仅一次响应事件
+   * @param {Object} map -地图对象
+   * @param {String} name -事件
+   * @param {function} func -函数对象
+   */
+  static onceEvent(map, name, func) {
+    map.once(name, func);
+  }
+
+  /**
+   * 绑定事件
+   * @param {Object} map -地图对象
+   * @param {String} name -事件
+   * @param {function} func -函数对象
+   */
+  static onEvent(map, name, func) {
+    map.on(name, func);
+  }
+
+  /**
+   * 解除事件绑定
+   * @param {Object} map -地图对象
+   * @param {String} name -事件
+   * @param {function} func -函数对象
+   */
+  static offEvent(map, name, func) {
+    map.off(name, func);
+  }
+
+  /**
+   * 适应边界框
+   * @param {Object} map -地图对象
+   * @param {Array} bbox -边界框
+   * @param {Number} zoom -缩放层级
+   * @param {Boolean} jump -是否直接定位
+   */
+  static fitBounds(map, bbox, zoom = null, jump = false) {
+    const currZoom = map.getZoom();
+
+    if (jump) {
+      if (zoom) {
+        map.fitBounds(bbox, {
+          animate: false,
+          padding: 25,
+          //maxZoom: zoom
+          maxZoom: zoom >= currZoom ? zoom : currZoom
+        });
+      } else {
+        map.fitBounds(bbox, {
+          animate: false,
+          padding: 25,
+        });
+      }
+    } else {
+      if (zoom) {
+        map.fitBounds(bbox, {
+          padding: 25,
+          //maxZoom: zoom
+          maxZoom: zoom >= currZoom ? zoom : currZoom
+        });
+      } else {
+        map.fitBounds(bbox, {
+          padding: 25,
+        });
+      }
+    }
+  }
+
+  /**
+   * 定位
+   * @param {Object} map -地图对象
+   * @param {Array} lonLat -经纬度
+   * @param {Number} zoom -缩放层级
+   */
+  static locate(map, lonLat, zoom) {
+    this.flyTo(map, lonLat, zoom);
+  }
+
+  /**
+   * 飞行至中心点
+   * @param {Object} map -地图对象
+   * @param {Array} lonLat -经纬度
+   * @param {Number} zoom -缩放层级
+   */
+  static flyTo(map, lonLat, zoom) {
+    map = DataUtils.default(map, this.getMap());
+    zoom = DataUtils.default(zoom, map.getZoom());
+    zoom = Math.max(zoom, map.getZoom());
+
+    map.flyTo({
+      center: lonLat,
+      speed: 1.0,
+      zoom: zoom,
+      essential: true, // 动画
+      easing: (t) => {
+        return t; // 飞行时间进度, (t === 1) 即飞行结束
+      }
+    }, {
+      // eventData 自定义的事件属性
+      moveend: 'FLYTO_END'
+    });
+  }
+
+  /**
+   * 跳至中心点
+   * @param {Object} map -地图对象
+   * @param {Array} lonLat -经纬度
+   * @param {Number} zoom -缩放层级
+   */
+  static jumpTo(map, lonLat, zoom) {
+    map = DataUtils.default(map, this.getMap());
+    zoom = DataUtils.default(zoom, map.getZoom());
+    zoom = Math.max(zoom, map.getZoom());
+
+    map.jumpTo({
+      center: lonLat,
+      zoom: zoom
+    });
+  }
+
+  /**
+   * 选中要素
+   * @param {Object} map -地图对象
+   * @param {String} sourceId -数据源Id
+   * @param {String} featureId -要素ID
+   * @param {Boolean} isHover -是否选中
+   */
+  static hoverFeature(map, sourceId, featureId, isHover = true) {
+    map.setFeatureState({
+      source: sourceId,
+      id: featureId
+    }, {
+      hover: isHover
+    });
+  }
+
+  /**
+   * 缩放到要素
+   * @param {Object} map -地图对象
+   * @param {Object} fc -要素集
+   * @param {Boolean} zoom -缩放层级
+   */
+  static zoomToFeatures(map, fc, zoom = 17, jump=false) {
+    // 计算边界盒
+    let bbox = GeogUtils.calcBBox(fc);
+    // 缩放至边界
+    this.fitBounds(map, bbox, zoom, jump);
+  }
+}