@sword916/vae-map-plus 1.0.0 → 1.0.1

package/plugins/L.FootageCalculator.Line/index.js

@@ -0,0 +1,416 @@
+import x from "@turf/buffer";
+function m(t, e, n = {}) {
+  const o = { type: "Feature" };
+  return (n.id === 0 || n.id) && (o.id = n.id), n.bbox && (o.bbox = n.bbox), o.properties = {}, o.geometry = t, o;
+}
+function w(t, e, n = {}) {
+  if (!t)
+    throw new Error("coordinates is required");
+  if (!Array.isArray(t))
+    throw new Error("coordinates must be an Array");
+  if (t.length < 2)
+    throw new Error("coordinates must be at least 2 numbers long");
+  if (!p(t[0]) || !p(t[1]))
+    throw new Error("coordinates must contain numbers");
+  return m({
+    type: "Point",
+    coordinates: t
+  }, e, n);
+}
+function O(t, e, n = {}) {
+  for (const r of t) {
+    if (r.length < 4)
+      throw new Error(
+        "Each LinearRing of a Polygon must have 4 or more Positions."
+      );
+    if (r[r.length - 1].length !== r[0].length)
+      throw new Error("First and last Position are not equivalent.");
+    for (let s = 0; s < r[r.length - 1].length; s++)
+      if (r[r.length - 1][s] !== r[0][s])
+        throw new Error("First and last Position are not equivalent.");
+  }
+  return m({
+    type: "Polygon",
+    coordinates: t
+  }, e, n);
+}
+function R(t, e, n = {}) {
+  if (t.length < 2)
+    throw new Error("coordinates must be an array of two or more positions");
+  return m({
+    type: "LineString",
+    coordinates: t
+  }, e, n);
+}
+function p(t) {
+  return !isNaN(t) && t !== null && !Array.isArray(t);
+}
+const P = (t) => {
+  let e = [];
+  return t.geometry.coordinates.forEach((o) => {
+    e.push(o.map((r) => ({
+      lat: r[1],
+      lng: r[0]
+    })));
+  }), e;
+}, A = {
+  /**
+   * 点缓冲分析
+   * @param {L.LatLng} center 中心点
+   * @param {Number} distance 缓冲距离
+   * @param {String} units 单位
+   * @returns {Array<Array<L.LatLng>>} 缓冲区经纬度序列
+   */
+  bufferPoint(t, e, n = "meters") {
+    const o = [t.lng, t.lat], r = x(w(o), e, { units: n });
+    return P(r);
+  },
+  /**
+   * 路径缓冲分析
+   * @param {Array<L.LatLng>} latLngs 路径经纬度序列
+   * @param {Number} distance 缓冲距离
+   * @param {String} units 单位
+   * @returns {Array<Array<L.LatLng>>} 缓冲区经纬度序列
+   */
+  bufferLine(t, e, n = "meters") {
+    const o = t.map((s) => [s.lng, s.lat]), r = x(R(o), e, { units: n });
+    return P(r);
+  },
+  /**
+   * 区域缓冲分析
+   * @param {Array<L.LatLng>} latLngs 区域经纬度序列
+   * @param {Number} distance 缓冲距离
+   * @param {String} units 单位
+   * @returns {Array<Array<L.LatLng>>} 缓冲区经纬度序列
+   */
+  bufferArea(t, e, n = "meters") {
+    let o = t.map((s) => [s.lng, s.lat]);
+    o.push(o[0]);
+    const r = x(O([o]), e, { units: n });
+    return P(r);
+  }
+}, U = {
+  /**
+   * 角度转弧度
+   * @param {角度} angle
+   */
+  angleToRad(t) {
+    return t * Math.PI / 180;
+  },
+  /**
+   * 弧度转角度
+   * @param {弧度} rad
+   */
+  radToAngle(t) {
+    return t * 180 / Math.PI;
+  },
+  /**
+   * 水平角度转顺时针角
+   * @param {角度} angle
+   */
+  toClockwiseAngle(t) {
+    let e = 90 - t;
+    return e < 0 && (e += 360), e;
+  },
+  /**
+   * 求两点水平弧度
+   * @param {L.Point} a 起点
+   * @param {L.Point} b 终点
+   */
+  computeRad(t, e) {
+    return Math.atan2(e.y - t.y, e.x - t.x);
+  },
+  /**
+   * 求两点水平角度
+   * @param {L.Point} a 起点
+   * @param {L.Point} b 终点
+   */
+  computeAngle(t, e) {
+    return this.radToAngle(this.computeRad(t, e));
+  },
+  /**
+   * 获取线段夹角弧度
+   * @param {L.Point} a 交点
+   * @param {L.Point} b 终点一
+   * @param {L.Point} c 终点二
+   */
+  segmentsRad(t, e, n) {
+    const o = e.x - t.x, r = e.y - t.y, s = n.x - t.x, i = n.y - t.y, l = o * s + r * i, a = o * i - r * s;
+    return Math.atan2(a, l);
+  },
+  /**
+   * 获取点到线段所在直线的垂足
+   * @param {L.Point} a 点
+   * @param {L.Point} m 线段起点
+   * @param {L.Point} n 线段终点
+   */
+  footPointOnLine(t, e, n) {
+    const o = (e.x - n.x) * (e.x - n.x) + (e.y - n.y) * (e.y - n.y), s = ((t.x - e.x) * (n.x - e.x) + (t.y - e.y) * (n.y - e.y)) / o, i = e.x + s * (n.x - e.x), l = e.y + s * (n.y - e.y);
+    return L.point(i, l);
+  },
+  /**
+   * 两线段所在直线的交点坐标，平行或共线时不返回
+   * @param {L.Point} a 线段一起点
+   * @param {L.Point} b 线段一终点
+   * @param {L.Point} c 线段二起点
+   * @param {L.Point} d 线段二终点
+   */
+  linesIntersection(t, e, n, o) {
+    const r = (e.y - t.y) * (o.x - n.x) - (t.x - e.x) * (n.y - o.y);
+    if (r) {
+      const s = ((e.x - t.x) * (o.x - n.x) * (n.y - t.y) + (e.y - t.y) * (o.x - n.x) * t.x - (o.y - n.y) * (e.x - t.x) * n.x) / r, i = -((e.y - t.y) * (o.y - n.y) * (n.x - t.x) + (e.x - t.x) * (o.y - n.y) * t.y - (o.x - n.x) * (e.y - t.y) * n.y) / r;
+      return L.point(s, i);
+    }
+  },
+  /**
+   * 根据经纬度计算累计距离，单位米
+   * @param {Array<L.LatLng>} latLngs
+   * @param {L.CRS} 坐标系，默认使用L.CRS.EPSG3857
+   */
+  distanceByLatLngs(t, e = L.CRS.EPSG3857) {
+    typeof e.distance != "function" && (e = L.CRS.EPSG3857);
+    let n = 0;
+    if (Array.isArray(t) && t.length > 1)
+      for (let o = 0; o < t.length - 1; o++)
+        n += e.distance(t[o], t[o + 1]);
+    return n;
+  },
+  /**
+   * 根据经纬度计算面积，单位平方米
+   * @param {Array<L.LatLng>} latLngs
+   */
+  areaByLatLngs(t) {
+    let e = t.length, n = 0, o = Math.PI / 180, r, s;
+    if (e > 2) {
+      for (let i = 0; i < e; i++)
+        r = t[i], s = t[(i + 1) % e], n += (s.lng - r.lng) * o * (2 + Math.sin(r.lat * o) + Math.sin(s.lat * o));
+      n = n * 6378137 * 6378137 / 2;
+    }
+    return Math.abs(n);
+  },
+  /**
+   * 根据坐标点计算面积
+   * @param {Array<L.Point>} points
+   */
+  areaByPoints(t) {
+    let e = 0;
+    if (Array.isArray(t) && t.length > 2) {
+      let n = 0;
+      for (let o = 0; o < t.length; o++)
+        o + 1 == t.length ? n += t[o].x * t[0].y - t[0].x * t[o].y : n += t[o].x * t[o + 1].y - t[o + 1].x * t[o].y;
+      e = 1 / 2 * Math.abs(n);
+    }
+    return e;
+  },
+  /**
+   * 转换面积，增加单位
+   * @param {number} area 面积数字，单位平方米
+   */
+  readableArea(t) {
+    let e = 0;
+    return t > 1e3 * 1e3 ? e = (t / (1e3 * 1e3)).toFixed(2) + " km²" : e = Math.ceil(t) + " m²", e;
+  },
+  /**
+   * 点是否在多边形内，射线法
+   * @param {L.Point} point 给定点
+   * @param {Array<L.Point>} points 多边形坐标
+   * @returns {Boolean} 是否置于多边形内或边界上
+   */
+  isPointInPoly(t, e) {
+    const n = t.x, o = t.y;
+    let r = !1, s = !1;
+    const i = e.length;
+    for (let l = 0, a = i - 1; l < i; a = l, l++) {
+      const c = e[l].x, u = e[l].y, h = e[a].x, f = e[a].y;
+      if ((c === n && u === o || h === n && f === o) && (s = !0), u < o && f >= o || u >= o && f < o) {
+        const g = c + (o - u) * (h - c) / (f - u);
+        s = g === n, g > n && (r = !r);
+      }
+      if (s)
+        break;
+    }
+    return s || r;
+  },
+  /**
+   * 点到面的距离，在内部视为0
+   * @param {L.Point} point 给定点
+   * @param {Array<L.Point>} points 多边形坐标
+   * @param {L.CRS} crs 地图CRS
+   * @returns {Boolean} 距离数值，若CRS可用，单位为米
+  */
+  distanceToPoly(t, e, n) {
+    let o = 0;
+    if (!this.isPointInPoly(t, e)) {
+      let r = [], s = [];
+      const i = e.length;
+      for (let c = 0, u = i - 1; c < i; u = c, c++)
+        r.push(L.LineUtil.pointToSegmentDistance(t, e[c], e[u])), s.push(L.LineUtil.closestPointOnSegment(t, e[c], e[u]));
+      o = _.min(r);
+      const l = _.indexOf(r, o), a = s[l];
+      if (n && n.unproject) {
+        const c = n.unproject(t), u = n.unproject(a);
+        o = n.distance(c, u);
+      }
+    }
+    return o;
+  },
+  /**
+   * 点到折线的距离
+   * @param {L.Point} point 给定点
+   * @param {Array<L.Point>} points 折线坐标
+   * @param {L.CRS} crs 地图CRS
+   * @param {Boolean} 距离数值，若CRS可用，单位为米
+   */
+  distanceToLine(t, e, n) {
+    let o = 0, r = [], s = [];
+    if (Array.isArray(e) && e.length > 1) {
+      for (let a = 0; a < e.length - 1; a++)
+        r.push(L.LineUtil.pointToSegmentDistance(t, e[a], e[a + 1])), s.push(L.LineUtil.closestPointOnSegment(t, e[a], e[a + 1]));
+      o = _.min(r);
+      const i = _.indexOf(r, o), l = s[i];
+      if (n && n.unproject) {
+        const a = n.unproject(t), c = n.unproject(l);
+        o = n.distance(a, c);
+      }
+    }
+    return o;
+  }
+};
+L.GeoUtil = L.extend(L.GeoUtil || {}, _.assign(U, A));
+L.FootageCalculator = L.FootageCalculator || {};
+L.FootageCalculator.Line = L.Evented.extend({
+  options: {
+    crs: L.CRS.EPSG3857,
+    // 坐标转换类
+    latlngs: [],
+    // 中心线
+    width: 0
+    // 巷道宽度
+  },
+  initialize(t) {
+    L.setOptions(this, t);
+    const e = this.options.crs;
+    if (e && e.project && e.unproject)
+      this.crs = e;
+    else
+      throw new Error("请传入正确的crs参数");
+    const n = this.options.latlngs, o = this.options.width;
+    if (Array.isArray(n) && n.length > 1 && o > 0)
+      this.latlngs = n, this.width = o;
+    else
+      throw new Error("请传入正确的latlngs和width参数");
+    this.initParams();
+  },
+  // 初始化参数
+  initParams() {
+    this.points = this.latlngs.map((t) => (t instanceof L.LatLng || (t = L.latLng(t)), this.crs.project(t))), this.segments = [], this.points.forEach((t, e) => {
+      if (e > 0) {
+        let n = 0;
+        e > 1 && (n = this.calcOffsetDistance(
+          this.points[e - 2],
+          this.points[e - 1],
+          this.points[e],
+          this.width / 2
+        )), this.segments.push({
+          start: this.points[e - 1],
+          end: t,
+          offsetDistance: n
+        });
+      }
+    });
+  },
+  /**
+   * 执行计算
+   * @param {L.LatLng} start 起点
+   * @param {Number} distance 推进距离，米
+   */
+  doCalculate({ start: t, distance: e }) {
+    if (e > 0) {
+      t instanceof L.LatLng || (t = L.latLng(t));
+      const n = this.crs.project(t), { path: o, remainingPath: r, endRad: s } = this.calcWorkPath(n, this.segments, e), i = this.calcWorkArea({ path: o, width: this.width / 2 }), l = o.map((h) => this.crs.unproject(h)), a = i.map((h) => this.crs.unproject(h)), c = r.map((h) => this.crs.unproject(h)), u = L.GeoUtil.toClockwiseAngle(L.GeoUtil.radToAngle(s));
+      return { path: l, remainingPath: c, area: a, endAngle: u };
+    } else
+      throw new Error("distance参数必须大于0");
+  },
+  /**
+   * 计算一次推进的结果
+   * @param {L.Point} start 起点
+   * @param {Array} segments 线段
+   * @param {Number} distance 推进距离
+   */
+  calcWorkPath(t, e, n) {
+    let o = 0, r = -1, s = -1, i;
+    e.forEach((f, g) => {
+      if (s < 0) {
+        n += f.offsetDistance;
+        let y = f.start;
+        r < 0 && L.LineUtil.pointToSegmentDistance(t, f.start, f.end) < 0.01 && (r = g, y = t);
+        let d = 0;
+        r >= 0 && (d = y.distanceTo(f.end)), o + d >= n && (s = g, i = this.calcEndPointOnLine(y, f.end, n - o)), o += d;
+      }
+    });
+    let l = s;
+    s < 0 && (l = e.length - 1, i = _.last(e).end);
+    let a = [t];
+    for (let f = r; f < l; f++)
+      a.push(e[f].end);
+    if (a.push(i), a.length == 2 && a[0].x == a[1].x && a[0].y == a[1].y) {
+      const f = _.last(e), g = L.GeoUtil.computeRad(f.start, f.end);
+      a[0] = a[1].subtract(L.point(0.01 * Math.cos(g), 0.01 * Math.sin(g)));
+    }
+    let c = [];
+    if (l == s) {
+      c = [i];
+      for (let f = l; f < e.length - 1; f++)
+        c.push(e[f].end);
+      c.push(_.last(e).end);
+    }
+    let u = e[s];
+    s < 0 && (u = _.last(e));
+    let h = L.GeoUtil.computeRad(u.start, u.end);
+    return { path: a, remainingPath: c, endRad: h };
+  },
+  /**
+   * 根据中心线路径和法线长度，计算推进范围
+   * @param {Array<L.Point>} path 推进路径
+   * @param {Number} width 法线长度
+   */
+  calcWorkArea({ path: t, width: e }) {
+    let n = [], o = [];
+    return t.map((s, i) => {
+      if (i == 0) {
+        const l = L.GeoUtil.computeRad(t[i], t[i + 1]);
+        return this.calcVerticalOffestPoints(s, l, e);
+      } else if (i == t.length - 1) {
+        const l = L.GeoUtil.computeRad(t[i - 1], t[i]);
+        return this.calcVerticalOffestPoints(s, l, e);
+      } else {
+        const l = L.GeoUtil.computeRad(t[i - 1], t[i]), a = L.GeoUtil.computeRad(t[i], t[i + 1]), c = this.calcVerticalOffestPoints(t[i - 1], l, e), u = this.calcVerticalOffestPoints(t[i], l, e), h = this.calcVerticalOffestPoints(t[i], a, e), f = this.calcVerticalOffestPoints(t[i + 1], a, e), g = L.GeoUtil.linesIntersection(c[0], u[0], h[0], f[0]), y = L.GeoUtil.linesIntersection(c[1], u[1], h[1], f[1]);
+        if (g && y)
+          return [g, y];
+      }
+    }).forEach((s) => {
+      s && (n.push(s[0]), o.push(s[1]));
+    }), _.concat(n, _.reverse(o));
+  },
+  // 获取a点向b点方向延伸distance后的坐标
+  calcEndPointOnLine(t, e, n) {
+    const o = L.GeoUtil.computeRad(t, e), r = n * Math.cos(o), s = n * Math.sin(o);
+    return t.add(L.point(r, s));
+  },
+  // 计算补足距离
+  calcOffsetDistance(t, e, n, o) {
+    const r = L.GeoUtil.segmentsRad(e, t, n, o), s = L.GeoUtil.computeRad(t, e), i = L.GeoUtil.computeRad(e, n), l = this.calcVerticalOffestPoints(t, s, o), a = this.calcVerticalOffestPoints(e, s, o), c = this.calcVerticalOffestPoints(e, i, o), u = this.calcVerticalOffestPoints(n, i, o);
+    let h = null;
+    return r > 0 ? h = L.GeoUtil.linesIntersection(l[1], a[1], c[1], u[1]) : h = L.GeoUtil.linesIntersection(l[0], a[0], c[0], u[0]), h ? L.GeoUtil.footPointOnLine(h, e, n).distanceTo(e) : 0;
+  },
+  // 获取目标点的在给定方向的法线上的两个偏移点
+  calcVerticalOffestPoints(t, e, n) {
+    const o = e - Math.PI / 2, r = L.point(n * Math.cos(o), n * Math.sin(o));
+    return [t.add(r), t.subtract(r)];
+  }
+});
+L.footageCalculator = L.footageCalculator || {};
+L.footageCalculator.line = function(t) {
+  return new L.FootageCalculator(t);
+};

package/plugins/L.GeoUtil/index.html

@@ -0,0 +1,30 @@
+<!DOCTYPE html>
+<html lang="en">
+
+<head>
+  <meta charset="utf-8">
+  <meta http-equiv="X-UA-Compatible" content="IE=edge">
+  <meta name="viewport" content="width=device-width,initial-scale=1.0">
+  <link rel="icon" href="<%= BASE_URL %>favicon.ico">
+  <style type="text/css">
+    html {
+      width: 100%;
+      height: 100%;
+    }
+
+    body {
+      width: 100%;
+      height: 100%;
+      margin: 0;
+      padding: 0;
+      overflow: hidden;
+    }
+  </style>
+  <title>...</title>
+</head>
+
+<body>
+  <div id="app"></div>
+</body>
+
+</html>