csk-gis-frame-work 4.0.0

package/mapboxgl/js/utils/GeoJsonUtils.js

@@ -0,0 +1,357 @@
+import VerifyUtils from "./VerifyUtils";
+
+/**
+ * GeoJSON定义工具类
+ */
+const GeoJsonUtils = {
+  /**
+   * 获取空要素集
+   * 
+   * @returns {Object} GeoJson根对象
+   */
+  getEmptyFC() {
+    return {
+      type: 'FeatureCollection',
+      features: []
+    };
+  },
+  
+  /**
+   * 获取要素集
+   * @param {Array} features -要素列表
+   * 
+   * @returns {Object} GeoJson根对象
+   */
+  getFC(features) {
+    const fc = this.getEmptyFC();
+
+    if (VerifyUtils.isArray(features) && features.length > 0 && 
+        VerifyUtils.isFeature(features[0])) {
+      fc.features = features;
+    }
+
+    return fc;
+  },
+
+  /**
+   * 获取空要素
+   * 
+   * @returns {Object} GeoJson要素对象
+   */
+  getEmptyFeature(type) {
+    return {
+      type: 'Feature',
+      properties: {},
+      geometry: {
+        type: type,
+        coordinates: []
+      }
+    };
+  },
+
+  /**
+   * 获取要素
+   * @param {Object} geometry -几何图形
+   * @param {Object} properties -属性
+   * 
+   * @returns {Object} GeoJson要素对象
+   */
+  getFeature(geometry, properties = {}) {
+    if (!geometry) return null;
+    
+    return {
+      id: properties.id,
+      type: 'Feature',
+      geometry: geometry,
+      properties: properties || {}
+    };
+  },
+
+  /**
+   * 获取点要素
+   * @param {Number[]} lonLat -经纬度
+   * @param {Object} props -属性
+   * 
+   * @summary <lonlat参数: [lon, lat]>
+   *
+   * @returns {Object} GeoJson点要素对象
+   */
+  getPointFeature(lonLat, props = null) {
+    let feature = this.getEmptyFeature('Point');
+    // 几何图形
+    if (lonLat && lonLat.length > 1) {
+      feature.geometry.coordinates = lonLat;
+    }
+    // 属性
+    if (props) {
+      feature.properties = props;
+    }
+
+    return feature;
+  },
+
+  /**
+   * 获取折线要素
+   * @param {Number[][]} lonLats -经纬度数组
+   * @param {Object} props -属性
+   * 
+   * @summary <lonlats参数: [[lon, lat], [lon2, lat2],...]>
+   * 
+   * @returns {Object} GeoJson折线要素对象 
+   */
+  getLineStringFeature(lonLats, props = null) {
+    let feature = this.getEmptyFeature('LineString');
+    // 几何图形
+    if (lonLats && lonLats.length > 1) {
+      feature.geometry.coordinates = lonLats;
+    }
+    // 属性
+    if (props) {
+      feature.properties = props;
+    }
+
+    return feature;
+  },
+
+  /**
+   * 获取多边形要素
+   * @param {Number[][][]} rings -环数组
+   * @param {Object} props -属性
+   * 
+   * @summary <rings参数: [[[lon, lat],[lon2, lat2],...],
+   *                       [[lon, lat],[lon2, lat2],...],
+   *                       ...] />
+   * 
+   * @returns {Object} GeoJson多边形要素对象
+   */
+  getPolygonFeature(rings, props = null) {
+    let feature = this.getEmptyFeature('Polygon');
+    // 几何图形
+    if (rings && rings.length > 0) {
+      feature.geometry.coordinates = rings;
+    }
+    // 属性
+    if (props) {
+      feature.properties = props;
+    }
+
+    return feature;
+  },
+
+  /**
+   * 获取多点要素
+   * @param {Number[]} lonLats -经纬度数组
+   * @param {Object} props -属性
+   * 
+   * @summary <lonlats参数: [[lon, lat], [lon2, lat2],...]>
+   * 
+   * @returns {Object} GeoJson点要素对象
+   */
+  getMultiPointFeature(lonLats, props = null) {
+    let feature = this.getEmptyFeature('MultiPoint');
+    // 几何图形
+    if (lonLats && lonLats.length > 0) {
+      feature.geometry.coordinates = lonLats;
+    }
+    // 属性
+    if (props) {
+      feature.properties = props;
+    }
+
+    return feature;
+  },
+
+  /**
+   * 获取多折线要素
+   * @param {Number[][]} lineStrings -折线数组
+   * @param {Object} props -属性
+   * 
+   * @summary <lineStrings参数: [[[lon, lat],[lon2, lat2],...],
+   *                             [[lon, lat],[lon2, lat2],...],
+   *                             ...] />
+   * 
+   * @returns {Object} GeoJson多折线要素对象
+   */
+  getMultiLineStringFeature(lineStrings, props = null) {
+    let feature = this.getEmptyFeature('MultiLineString');
+    // 几何图形
+    if (lineStrings && lineStrings.length > 0) {
+      feature.geometry.coordinates = lineStrings;
+    }
+    // 属性
+    if (props) {
+      feature.properties = props;
+    }
+
+    return feature;
+  },
+
+  /**
+   * 获取多多边形要素
+   * @param {Number[][][]} polygons -多边形数组
+   * @param {Object} props -属性
+   * 
+   * @summary <polygons参数: [[[[lon, lat],[lon2, lat2],...],[[lon, lat],[lon2, lat2],...],...],
+   *                          [[[lon, lat],[lon2, lat2],...],[[lon, lat],[lon2, lat2],...],...],
+   *                          ...]>
+   * 
+   * @returns {Object} GeoJson多多边形要素对象
+   */
+  getMultiPolygonFeature(polygons, props = null) {
+    let feature = this.getEmptyFeature('MultiPolygon');
+    // 几何图形
+    if (polygons && polygons.length > 0) {
+      feature.geometry.coordinates = polygons;
+    }
+    // 属性
+    if (props) {
+      feature.properties = props;
+    }
+
+    return feature;
+  },
+  
+  /**
+   * 获取Geometry类型
+   * @param {Object} feature -要素
+   * 
+   * @return {String}
+   */
+  getGeometryType(feature) {
+    return feature.geometry.type;
+  },
+
+  /**
+   * 克隆要素
+   * @param {Object} feature -原要素
+   * 
+   * @returns {Object}
+   */
+  cloneFeature(feature) {
+    if (!feature) return null;
+
+    let newFeature = this.getEmptyFeature(feature.geometry.type);
+    newFeature.id = feature.id;
+    
+    // 拷贝坐标数组
+    let [...coordinates] = feature.geometry.coordinates;
+    newFeature.geometry.coordinates = coordinates;
+    
+    for (let key in feature.properties) {
+      newFeature.properties[key] = feature.properties[key];
+    }
+
+    return newFeature;
+  },
+
+  /**
+   * 获取唯一要素集合
+   * @param {Array} features -要素集合
+   * @param {String} name -属性名称
+   * 
+   * @returns {Array} 唯一要素集合
+   */
+  getUniqueFeatures(features, name) {
+    let existingFeatureKeys = {};
+    // Because features come from tiled vector data, feature geometries may be split
+    // or duplicated across tile boundaries and, as a result, features may appear
+    // multiple times in query results.
+    let uniqueFeatures = features.filter(function (feature) {
+      if (existingFeatureKeys[feature.properties[name]]) {
+        return false;
+      } else {
+        existingFeatureKeys[feature.properties[name]] = true;
+        return true;
+      }
+    });
+
+    return uniqueFeatures;
+  },
+
+  /**
+   * 数组转点要素集合
+   * @param {Array|Object} data -JSON集合
+   * 
+   * @returns {FeatureCollection}
+   */
+  array2PointFC(data) {
+    const fc = this.getEmptyFC();
+
+    if (VerifyUtils.isArray(data)) {
+      /*
+      fc.features = data.map((pt) => {
+        let lon = Number(pt.lng || pt.longitude || pt.lon);
+        let lat = Number(pt.lat || pt.latitude);
+
+        // 获取点要素
+        return this.getPointFeature([lon, lat], pt);
+      });
+      */
+      data.forEach((pt) => {
+        let lon = pt.lng || pt.longitude || pt.lon || pt.Longitude;
+        let lat = pt.lat || pt.latitude || pt.Latitude;
+        
+        if (lon && lat && lon !== 'null' && lat !== 'null') {
+          // 添加点要素
+          const feature = this.getPointFeature([Number(lon), Number(lat)], pt);
+          fc.features.push(feature);
+        }
+      });
+    }
+
+    return fc;
+  },
+
+  /**
+   * 对象转点要素
+   * @param {Object} data -点位对象
+   * 
+   * @returns {Feature}
+   */
+  object2PointFeature(data) {
+    let lon = data.lng || data.longitude || data.lon;
+    let lat = data.lat || data.latitude;
+
+    if (lon && lat && lon !== 'null' && lat !== 'null') {
+      return this.getPointFeature([Number(lon), Number(lat)], data);
+    }
+
+    return null;
+  },
+
+  /**
+   * 点要素转多边形要素
+   * @param {Object|Array} data -GeoJSON要素/经纬度
+   * 
+   * @returns {Object}
+   */
+  point2PolygonFeature(data) {
+    let feature = null;
+    
+    if (VerifyUtils.isGeoJsonFC(data)) {
+      feature = data.features[0];
+    } else if (VerifyUtils.isGeoJsonFeature(data)) {
+      feature = data;
+    } else if (VerifyUtils.isArray(data)) {
+      feature = this.getPointFeature(data);
+    }
+    if (!feature) return null;
+
+    // 点查询转换为小矩形查询
+    let lonLat = feature.geometry.coordinates;
+    let lon = lonLat[0], lat = lonLat[1];
+    let os = 0.00001;
+
+    let ring = [
+      [lon - os, lat - os], 
+      [lon - os, lat + os], 
+      [lon + os, lat + os], 
+      [lon + os, lat - os], 
+      [lon - os, lat - os]
+    ];
+
+    return this.getPolygonFeature([ring], feature.properties);
+  }
+}
+
+export default GeoJsonUtils;

package/mapboxgl/js/utils/GeogUtils.js

@@ -0,0 +1,300 @@
+import * as turf from "@turf/turf";
+import GeoJsonProvider from "../geog/GeoJsonProvider";
+
+/**
+ * 地理工具类
+ */
+const GeogUtils = {
+
+  /**
+   * 经纬度转弧度
+   * @param {Number} degrees -经纬度
+   *
+   * @returns {Number} 弧度
+   */
+  toRadians(degrees) {
+    return degrees * Math.PI / 180;
+  },
+
+  /**
+   * 弧度转经纬度
+   * @param {Number} degrees -弧度
+   *
+   * @returns {Number} 经纬度
+   */
+  toDegrees(radians) {
+    return radians * 180 / Math.PI;
+  },
+
+  /**
+   * 缓冲区
+   * @param {Object} data -GeoJSON要素
+   * @param {Number} radius -半径
+   *
+   * @returns {Object} GeoJSON要素
+   */
+  buffer(data, radius = 0.02) {
+    let coordinates = data.geometry.coordinates;
+    let steps = 16;
+
+    // 构造缓冲区
+    let feature;
+    switch (data.geometry.type) {
+      case 'Point': {
+        steps = 16;
+        feature = turf.point(coordinates);
+        break;
+      }
+      case 'LineString': {
+        steps = 8;
+        feature = turf.lineString(coordinates);
+        break;
+      }
+      default:
+        break;
+    }
+    if (!feature) return null;
+
+    // 创建缓冲区
+    return turf.buffer(feature, radius, {
+      units: 'kilometers',
+      steps: steps
+    });
+  },
+
+  /**
+   * 反转线要素图形
+   * @param {Object} feature -要素
+   */
+  reverse(feature) {
+    if (feature.geometry.type !== 'LineString') {
+      return feature;
+    }
+    // 反转数组
+    feature.geometry.coordinates.reverse();
+  },
+
+  /**
+   * 计算方位角
+   * @param {Number[]} lonLat -起点经纬度
+   * @param {Number[]} lonLat2 -终点经纬度
+   *
+   * @returns {Number} 方位角
+   * @summary<返回值单位是°>
+   */
+  calcBearing(lonLat, lonLat2) {
+    // 经纬度转弧度
+    let startLon = this.toRadians(lonLat[0]);
+    let startLat = this.toRadians(lonLat[1]);
+    let destLon = this.toRadians(lonLat2[0]);
+    let destLat = this.toRadians(lonLat2[1]);
+
+    let y = Math.sin(destLon - startLon) * Math.cos(destLat);
+    let x = Math.cos(startLat) * Math.sin(destLat) - Math.sin(startLat) * Math.cos(destLat) * Math.cos(destLon - startLon);
+    let brng = Math.atan2(y, x);
+    let brngDgr = this.toDegrees(brng);
+
+    return (brngDgr + 360) % 360;
+  },
+
+  /**
+   * 计算方位角（Mapbox-gl）
+   * @param {Number[]} lonLat -起点经纬度
+   * @param {Number[]} lonLat2 -终点经纬度
+   *
+   * @returns {Number} 方位角
+   * @summary<返回值单位是°>
+   */
+  bearing(lonLat, lonLat2) {
+    return turf.bearing(turf.point(lonLat), turf.point(lonLat2)) - 90;
+  },
+
+  /**
+   * 根据起终点计算Bezier曲线控制点
+   * @param {Array} start -起点
+   * @param {Array} end -终点
+   * @param {Number} arc -弧度(0-1)
+   *
+   * @returns {Array}
+   */
+  calcControlPoint(lonLat, lonLat2, arc = 0.25) {
+    const deltaX = lonLat2[0] - lonLat[0];
+    const deltaY = lonLat2[1] - lonLat[1];
+
+    const theta = Math.atan(deltaY / deltaX);
+    const len = Math.sqrt((deltaX * deltaX) + (deltaY * deltaY)) / 2 * arc;
+    const newTheta = theta - Math.PI / 2;
+
+    return [
+      (lonLat[0] + lonLat2[0]) / 2 + len * Math.cos(newTheta),
+      (lonLat[1] + lonLat2[1]) / 2 + len * Math.sin(newTheta),
+    ];
+  },
+
+  /**
+   * 计算边界框
+   * @param {Object} data -GeoJSON要素集/要素
+   *
+   * @returns {Number[][]}
+   */
+  calcBBox(data) {
+    let bbox = turf.bbox(data);
+
+    return bbox ? [[bbox[0], bbox[1]], [bbox[2], bbox[3]]] : null;
+  },
+
+  /**
+   * 计算两点间距离
+   * @param {Number[]} lonLat -起点坐标
+   * @param {Number[]} lonLat2 -终点坐标
+   *
+   * @returns {Number} 两点间距离(单位：m)
+   */
+  calcDistance(lonLat, lonLat2) {
+    return turf.distance(turf.point(lonLat), turf.point(lonLat2), {
+      units: 'kilometers'
+    }) * 1000.0;
+  },
+
+  /**
+   * 获取折线长度
+   * @param {Object} feature -GeoJSON要素
+   *
+   * @returns {Number} 单位:m
+   */
+  calcLength(feature) {
+    return turf.length(feature) * 1000;
+  },
+
+  /**
+   * 计算中点/中心点
+   * @param {Object} feature -GeoJSON要素
+   *
+   * @returns {Number[]}
+   */
+  calcCenter(feature) {
+    switch (feature.geometry.type.toLowerCase()) {
+      case 'point': {
+        return feature.geometry.coordinates;
+      }
+      case 'multipoint': {
+        // 计算中心点
+        const centerFea = turf.center(feature);
+
+        return centerFea.geometry.coordinates;
+      }
+      case 'linestring': {
+        // 获取折线长度
+        let len = turf.length(feature);
+        // 获取沿折线的点
+        const centerFea = turf.along(feature, len / 2, {
+          units: 'kilometers'
+        });
+
+        return centerFea.geometry.coordinates;
+      }
+      case 'multilinestring': {
+        const ls = feature.geometry.coordinates[0];
+        const lsFea = GeoJsonProvider.getLineStringFeature(ls, feature.properties);
+
+        // 获取折线长度
+        let len = turf.length(lsFea);
+        // 获取沿折线的点
+        const centerFea = turf.along(lsFea, len / 2, {
+          units: 'kilometers'
+        });
+
+        return centerFea.geometry.coordinates;
+      }
+      case 'polygon': {
+        // 计算多边形中心
+        const centerFea = turf.centerOfMass(feature);
+
+        return centerFea.geometry.coordinates;
+      }
+      case 'multipolygon': {
+        const poly = feature.geometry.coordinates[0];
+        const polyFea = GeoJsonProvider.getPolygonFeature(poly, feature.properties);
+        // 计算多边形中心
+        const centerFea = turf.centerOfMass(polyFea);
+
+        return centerFea.geometry.coordinates;
+      }
+      default:
+        return null;
+    }
+  },
+
+  /**
+   * 计算多边形外边环最北边的点坐标
+   * @param {Object} feature -GeoJSON要素
+   *
+   * @returns {Number[]}
+   */
+  calcNorthLonLatOfPolygon(feature) {
+    let ls = feature.geometry.coordinates[0];
+
+    let lon = -180, lat = -90;
+    for (let i = 0; i < ls.length; i++) {
+      if (lat < ls[i][1]) {
+        lon = ls[i][0];
+        lat = ls[i][1];
+      }
+    }
+
+    return [lon, lat];
+  },
+
+  /**
+   * 计算在多边形内的点集
+   * @param {Object} pointFC -点GeoJSON要素集合
+   * @param {Object} polygonFeature -多边形要素
+   */
+  calcPointsWithinPolygon(pointFC, polygonFeature) {
+    return turf.pointsWithinPolygon(pointFC, polygonFeature);
+  },
+
+  /**
+   * 计算线与线要素的交点
+   * @param {Object} feature -线要素
+   * @param {Object} feature2 -线要素
+   *
+   * @returns {Array} 点要素集合
+   */
+  calcLineIntersect(feature, feature2) {
+    return turf.lineIntersect(feature, feature2);
+  },
+
+  /**
+   * 判断点是否在多边形内
+   * @param {Number[]} lonLat -经纬度坐标
+   * @param {Object} feature -GeoJSON要素
+   *
+   * @returns {Boolean}
+   */
+  isPointInPolygon(lonLat, feature) {
+    let pt = turf.point(lonLat);
+
+    return turf.booleanPointInPolygon(pt, feature);
+  },
+
+  /**
+   * 判断other是否包含在feature内
+   *
+   * @returns {Boolean}
+   */
+  isContains(feature, other) {
+    return turf.booleanContains(feature, other);
+  },
+
+  /**
+   * 判断other和feature是否相离
+   *
+   * @returns {Boolean}
+   */
+  isDisjoint(feature, other) {
+    return turf.booleanDisjoint(feature, other);
+  }
+};
+
+export default GeogUtils;