csk-gis-frame-work 4.0.0

package/mapboxgl/js/pipenet/PipenetAnalystProvider.js

@@ -0,0 +1,393 @@
+import DataUtils from '../utils/DataUtils';
+import PipenetUpstreamProvider from './PipenetUpstreamProvider';
+import PipenetDownstreamProvider from './PipenetDownstreamProvider';
+import PipenetUpdownstreamProvider from './PipenetUpdownstreamProvider';
+import PipenetWhereaboutsProvider from './PipenetWhereaboutsProvider';
+import PipenetServiceRangeProvider from './PipenetServiceRangeProvider';
+import PipenetConnectivityProvider from './PipenetConnectivityProvider';
+
+/**
+ * 定义管网分析提供类
+ *
+ * @alias PipenetAnalystProvider
+ *
+ * @summary <用于加载管网分析图层>
+ */
+export default class PipenetAnalystProvider {
+  /**
+   * 构造函数
+   * @param {Object} options -图层选项
+   */
+  constructor(options) {
+    /**
+     * 地图对象
+     * @type {Object}
+     */
+    this._map = options.map;
+
+    /**
+     * 最小缩放层级
+     * @type {Number}
+     */
+    this._minzoom = DataUtils.default(options.minzoom, 10);
+
+    /**
+     * 是否查询错误管网
+     * @type {Boolean}
+     */
+    this._withError = DataUtils.default(options.error, false);
+    /**
+     * 是否查询结果
+     * @type {Boolean}
+     */
+    this._withResult = DataUtils.default(options.result, false);
+    /**
+     * 是否查询设备
+     * @type {Boolean}
+     */
+    this._withDevice = DataUtils.default(options.device, false);
+
+    // 管线颜色
+    this._lineColor = '#96143C'; // 2E8B57
+
+    // 线宽
+    this._lineWidth = 4.0;
+
+    /** 图层 **/
+    this._upstreamProvider = null;    // 上游分析
+    this._downstreamProvider = null;  // 下游分析
+    this._whereaboutsProvider = null; // 去向分析
+
+    this._updownstreamProvider = null; // 上下游分析(追溯分析)
+    this._serviceRangeProvider = null; // 服务范围分析
+
+    this._connectivityProvider = null; // 连通分析
+  }
+
+  /** 公有方法 **/
+  /**
+   * 设置管线路径颜色
+   * @param {String} color -16进制颜色字符串
+   */
+  setColor(color) {
+    this._lineColor = color;
+  }
+
+  /**
+   * 管网分析
+   * @param {String} type -分析类型
+   * @param {String} code -编码/编码串(管线、检查井、排水户、水厂、泵站)
+   * @param {String} layerType -图层类型('pipeline'、'manhole'、'drainentity'、'plant'、'pump')   *
+   * @param {Function} callback -回调函数
+   *
+   * @summery <type参数：
+   *   upstream -上游分析;
+   *   downstream -下游分析;
+   *   updownstream -上下游分析;
+   *   whereabouts -去向分析
+   *   servicerange -服务范围
+   *   connectivity -连通性
+   * >
+   */
+  analyse(type, code, layerType, callback=null) {
+    switch (type) {
+      case 'upstream': { // 上游分析
+        this.upstreamAnalysis(code, layerType, callback);
+        break;
+      }
+      case 'downstream': { // 下游分析
+        this.downstreamAnalysis(code, layerType, callback);
+        break;
+      }
+      case 'updownstream': { // 上下游分析(追溯分析)
+        this.updownstreamAnalysis(code, layerType, callback);
+        break;
+      }
+      case 'tracingsource': { // 溯源分析
+        this.tracingsourceAnalysis(code, layerType, callback);
+        break;
+      }
+      case 'whereabouts': { // 去向分析
+        this.whereaboutsAnalysis(code, callback);
+        break;
+      }
+      case 'servicerange': { // 服务范围
+        this.serviceRangeAnalysis(code, layerType, callback);
+        break;
+      }
+      case 'connectivity': { // 连通分析
+        const pipeIds = code.split(',');
+        if (pipeIds.length < 2) return;
+
+        this.connectivityAnalysis(pipeIds[0], pipeIds[1], callback);
+        break;
+      }
+      default:
+        break;
+    }
+  }
+
+  /**
+   * 停止
+   */
+  stop(type) {
+    switch (type) {
+      case 'upstream': { // 上游分析
+        if (this._upstreamProvider) {
+          this._upstreamProvider.stop();
+        }
+        break;
+      }
+      case 'downstream': { // 下游分析
+        if (this._downstreamProvider) {
+          this._downstreamProvider.stop();
+        }
+        break;
+      }
+      case 'updownstream':    // 上下游分析
+      case 'tracingsource': { // 溯源分析
+        if (this._updownstreamProvider) {
+          this._updownstreamProvider.stop();
+        }
+        break;
+      }
+      case 'whereabouts': { // 去向分析
+        if (this._whereaboutsProvider) {
+          this._whereaboutsProvider.stop();
+        }
+        break;
+      }
+      case 'servicerange': { // 服务范围
+        if (this._serviceRangeProvider) {
+          this._serviceRangeProvider.stop();
+        }
+        break;
+      }
+      case 'connectivity': { // 连通分析
+        if (this._connectivityProvider) {
+          this._connectivityProvider.stop();
+        }
+        break;
+      }
+      default:
+        break;
+    }
+  }
+
+  /**
+   * 上游分析
+   * @param {String} code -管线/检查井编码
+   * @param {String} layerType - 图层类型
+   * @param {Function} callback -回调函数
+   */
+  upstreamAnalysis(code, layerType, callback=null) {
+    if (!this._upstreamProvider) {
+      this._upstreamProvider = new PipenetUpstreamProvider({
+        map: this._map,
+        minzoom: this._minzoom,
+        color: this._lineColor,
+        width: this._lineWidth
+      });
+    }
+    // 设置管网颜色
+    this._upstreamProvider.setColor(this._lineColor);
+    // 停止管网分析
+    this._upstreamProvider.stop();
+
+    // 查询管网分析数据
+    this._upstreamProvider.queryData(code, layerType, callback);
+  }
+
+  /**
+   * 下游分析
+   * @param {String} code -管线/检查井编码
+   * @param {String} layerType - 图层类型
+   * @param {Function} callback -回调函数
+   */
+  downstreamAnalysis(code, layerType, callback=null) {
+    if (!this._downstreamProvider) {
+      this._downstreamProvider = new PipenetDownstreamProvider({
+        map: this._map,
+        minzoom: this._minzoom,
+        color: this._lineColor,
+        width: this._lineWidth,
+        layerId: 'map_nh_village'
+      });
+    }
+    // 设置管网颜色
+    this._downstreamProvider.setColor(this._lineColor);
+    // 停止管线流向
+    this._downstreamProvider.stop();
+
+    // 查询管网分析数据
+    this._downstreamProvider.queryData(code, layerType, callback);
+  }
+
+  /**
+   * 去向分析
+   * @param {String} drainCode -排水户编码
+   * @param {Function} callback -回调函数
+   */
+  whereaboutsAnalysis(drainCode, callback=null) {
+    if (!this._whereaboutsProvider) {
+      this._whereaboutsProvider = new PipenetWhereaboutsProvider({
+        map: this._map,
+        minzoom: this._minzoom,
+        color: this._lineColor,
+        width: this._lineWidth,
+        error: this._withError,
+        result: this._withResult
+      });
+    }
+    // 设置管网颜色
+    this._whereaboutsProvider.setColor(this._lineColor);
+    // 停止管线流向
+    this._whereaboutsProvider.stop();
+
+    // 查询管网分析数据
+    this._whereaboutsProvider.queryData(drainCode, callback);
+  }
+
+  /**
+   * 上下游分析
+   * @param {String} code -管线/检查井编码
+   * @param {String} layerType - 图层类型
+   * @param {Function} callback -回调函数
+   */
+  updownstreamAnalysis(code, layerType, callback=null) {
+    if (this._updownstreamProvider) {
+      this._updownstreamProvider.stop();
+      this._updownstreamProvider = null;
+    }
+
+    this._updownstreamProvider = new PipenetUpdownstreamProvider({
+      map: this._map,
+      minzoom: this._minzoom,
+      color: this._lineColor,
+      width: this._lineWidth,
+      error: this._withError,
+      result: this._withResult,
+      device: this._withDevice
+    });
+    // 设置管网颜色
+    this._updownstreamProvider.setColor(this._lineColor);
+
+    // 查询管网分析数据
+    this._updownstreamProvider.queryData(code, layerType, callback);
+  }
+
+  /**
+   * 溯源分析
+   * @param {String} code -管线/检查井编码
+   * @param {String} layerType - 图层类型
+   * @param {Function} callback -回调函数
+   */
+  tracingsourceAnalysis(code, layerType, callback=null) {
+    if (this._updownstreamProvider) {
+      this._updownstreamProvider.stop();
+      this._updownstreamProvider = null;
+    }
+
+    this._updownstreamProvider = new PipenetUpdownstreamProvider({
+      map: this._map,
+      minzoom: this._minzoom,
+      color: this._lineColor,
+      width: this._lineWidth,
+      error: this._withError,
+      //result: true
+      result: this._withResult
+    });
+    // 设置管网颜色
+    this._updownstreamProvider.setColor(this._lineColor);
+
+    // 查询管网分析数据
+    this._updownstreamProvider.queryData(code, layerType, callback);
+  }
+
+  /**
+   * 服务范围分析
+   * @param {String} code -管线/检查井编码
+   * @param {String} layerType - 图层类型
+   * @param {Function} callback -回调函数
+   */
+  serviceRangeAnalysis(code, layerType, callback=null) {
+    if (!this._serviceRangeProvider) {
+      this._serviceRangeProvider = new PipenetServiceRangeProvider({
+        map: this._map,
+        minzoom: this._minzoom,
+        color: this._lineColor,
+        width: this._lineWidth,
+        error: this._withError,
+        result: this._withResult
+      });
+    }
+    // 设置管网颜色
+    this._serviceRangeProvider.setColor(this._lineColor);
+    // 停止管线流向
+    this._serviceRangeProvider.stop();
+
+    // 查询管网分析数据
+    this._serviceRangeProvider.queryData(code, layerType, callback);
+  }
+
+  /**
+   * 连通性分析
+   * @param {String} pipeId -起始管线编码
+   * @param {String} pipeId2 -终止管线编码
+   * @param {Function} callback -回调函数
+   */
+  connectivityAnalysis(pipeId, pipeId2, callback=null) {
+    if (!this._connectivityProvider) {
+      this._connectivityProvider = new PipenetConnectivityProvider({
+        map: this._map,
+        minzoom: this._minzoom,
+        color: this._lineColor,
+        width: this._lineWidth
+      });
+    }
+    // 设置管网颜色
+    this._connectivityProvider.setColor(this._lineColor);
+    // 停止管线流向
+    this._connectivityProvider.stop();
+
+    // 查询管网分析数据
+    this._connectivityProvider.queryData(pipeId, pipeId2, callback);
+  }
+
+  /**
+   * 移除各图层
+   */
+  removeAllLayers() {
+    // 上游分析
+    if (this._upstreamProvider) {
+      this._upstreamProvider.removeLayer();
+    }
+    // 下游分析
+    if (this._downstreamProvider) {
+      this._downstreamProvider.removeLayer();
+    }
+    // 去向分析
+    if (this._whereaboutsProvider) {
+      this._whereaboutsProvider.removeLayer();
+    }
+
+    // 上下游分析
+    if (this._updownstreamProvider) {
+      this._updownstreamProvider.removeLayer();
+    }
+    // 服务范围分析
+    if (this._serviceRangeProvider) {
+      this._serviceRangeProvider.removeLayer();
+    }
+  }
+
+  /**
+   * 显示/隐藏社区图层
+   * @param {Boolean} isShow -是否显示
+   */
+  showCoverageLayer(isShow) {
+    if (this._downstreamProvider) {
+      this._downstreamProvider._villageLayer.showLayer(isShow);
+    }
+  }
+}

package/mapboxgl/js/pipenet/PipenetConnectivityProvider.js

@@ -0,0 +1,166 @@
+import DataUtils from '../utils/DataUtils';
+import GeoJsonProvider from '../geog/GeoJsonProvider';
+import LayerProvider from '../geog/LayerProvider';
+import FlowingLayer from '../common/FlowingLayer';
+import PipenetFlowingLayer from './PipenetFlowingLayer';
+
+import { pipenetMergeAnalystResult } from '../utils/PipenetUtils';
+import { getApi } from '../../api/http';
+
+/**
+ * 定义管网连通分析提供类
+ *
+ * @alias PipenetConnectivityProvider
+ *
+ * @summary <用于加载管网连通分析图层>
+ */
+export default class PipenetConnectivityProvider {
+  /**
+   * 构造函数
+   * @param {Object} options -图层选项
+   */
+  constructor(options) {
+    /**
+     * 地图对象
+     * @type {Object}
+     */
+    this._map = options.map;
+
+    /**
+     * 最小缩放层级
+     * @type {Number}
+     */
+    this._minzoom = DataUtils.default(options.minzoom, 10);
+
+    /**
+     * 管线颜色
+     * @type {String}
+     */
+    this._lineColor = DataUtils.default(options.color, '#2E8B57');
+
+    /**
+     * 线宽
+     * @type {Number}
+     */
+    this._lineWidth = DataUtils.default(options.width, 10.5);
+
+    // 管网流向图层
+    //this._flowingLayer = new FlowingLayer({
+    this._flowingLayer = new PipenetFlowingLayer({
+      map: this._map,
+      minzoom: this._minzoom,
+      color: this._lineColor,
+      width: this._lineWidth,
+      sourceId: 'pipe_flowing-dijkstra'
+    });
+  }
+
+  /**
+   * 设置管线路径颜色
+   * @param {String} color -16进制颜色字符串
+   */
+  setColor(color) {
+    this._flowingLayer.setColor(color);
+  }
+
+  /**
+   * 查询流向数据
+   * @param {String} pipeId -起点管线编码
+   * @param {String} pipeId2 -终点管线编码
+   * @param {Function} callback -回调函数
+   */
+  queryData(pipeId, pipeId2, callback=null) {
+    const map = this._map;
+    const that = this;
+
+    /**
+     * 查询流向
+     * @param {Function} callback -回调函数
+     *
+     * @returns {Boolean}
+     */
+    async function _query(callback=null) {
+      // 获取管线网络查询url
+      let urlFlow = LayerProvider.getBaseLayerQueryUrl(map, 'pipenet', pipeId);
+      let urlFlow2 = LayerProvider.getBaseLayerQueryUrl(map, 'pipenet', pipeId2);
+      if (!urlFlow || !urlFlow2) return false;
+
+      let result = null, fc = null, fc2 = null;
+      let sourceId = 0;
+      let targetId = 0;
+      // 查询起点
+      result = await getApi(urlFlow);
+      fc = result.data
+      if (fc && fc.features && fc.features.length > 0) {
+        sourceId = fc.features[0].properties.source;
+      }
+      if (sourceId < 1) return false;
+
+      // 查询终点
+      result = await getApi(urlFlow2);
+      fc2 = result.data
+      if (fc2 && fc2.features && fc2.features.length > 0) {
+        targetId = fc2.features[0].properties.target;
+      }
+      if (targetId < 1) return false;
+
+      // 获取管线最短路径查询url
+      let urlQuery = LayerProvider.getBaseLayerQueryUrl(map, 'pipenet-dijkstra', sourceId, targetId);
+      if (!urlQuery) return false;
+
+      // 获取地图服务接口数据
+      await getApi(urlQuery).then((res) => {
+        const resultFC = res.data;
+        if (resultFC.features && resultFC.features.length > 0) {
+          // 获取唯一要素集合
+          resultFC.features = GeoJsonProvider.getUniqueFeatures(resultFC.features, 'path');
+
+          // 合并管线数据
+          const mergedFC = GeoJsonProvider.getEmptyFC();
+          mergedFC.features = pipenetMergeAnalystResult(resultFC.features);
+
+          // 设置流向数据
+          that._flowingLayer.setData(mergedFC);
+          // 开始动画
+          that._flowingLayer.start();
+        } else {
+          resultFC.features = [fc.features[0], fc2.features[0]];
+        }
+
+        // 回调
+        if (callback) {
+          callback('connectivity', resultFC);
+        }
+
+      }).catch((err) => {
+        console.log('connectivity', err);
+      });
+    }
+
+    _query(callback);
+  }
+
+  /**
+   * 停止流向
+   */
+  stop() {
+    this._flowingLayer.stop();
+    // 移除图层
+    this.removeLayer();
+  }
+
+  /**
+   * 移除图层
+   */
+  removeLayer() {
+    this._flowingLayer.removeLayer();
+  }
+
+  /**
+   * 显示/隐藏图层
+   * @param {Boolean} isShow -是否显示
+   */
+  showLayer(isShow = true) {
+    this._flowingLayer.showLayer(isShow);
+  }
+}