@sword916/vae-map-plus 1.0.0 → 1.0.1

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

@@ -0,0 +1,418 @@
+import y from "@turf/buffer";
+function E(t, e, n = {}) {
+  const r = { type: "Feature" };
+  return (n.id === 0 || n.id) && (r.id = n.id), n.bbox && (r.bbox = n.bbox), r.properties = {}, r.geometry = t, r;
+}
+function m(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 E({
+    type: "Point",
+    coordinates: t
+  }, e, n);
+}
+function S(t, e, n = {}) {
+  for (const s of t) {
+    if (s.length < 4)
+      throw new Error(
+        "Each LinearRing of a Polygon must have 4 or more Positions."
+      );
+    if (s[s.length - 1].length !== s[0].length)
+      throw new Error("First and last Position are not equivalent.");
+    for (let i = 0; i < s[s.length - 1].length; i++)
+      if (s[s.length - 1][i] !== s[0][i])
+        throw new Error("First and last Position are not equivalent.");
+  }
+  return E({
+    type: "Polygon",
+    coordinates: t
+  }, e, n);
+}
+function w(t, e, n = {}) {
+  if (t.length < 2)
+    throw new Error("coordinates must be an array of two or more positions");
+  return E({
+    type: "LineString",
+    coordinates: t
+  }, e, n);
+}
+function P(t) {
+  return !isNaN(t) && t !== null && !Array.isArray(t);
+}
+const I = (t) => {
+  let e = [];
+  return t.geometry.coordinates.forEach((r) => {
+    e.push(r.map((s) => ({
+      lat: s[1],
+      lng: s[0]
+    })));
+  }), e;
+}, A = {
+  /**
+   * 点缓冲分析
+   * @param {L.LatLng} center 中心点
+   * @param {Number} distance 缓冲距离
+   * @param {String} units 单位
+   * @returns {Array<Array<L.LatLng>>} 缓冲区经纬度序列
+   */
+  bufferPoint(t, e, n = "meters") {
+    const r = [t.lng, t.lat], s = y(m(r), e, { units: n });
+    return I(s);
+  },
+  /**
+   * 路径缓冲分析
+   * @param {Array<L.LatLng>} latLngs 路径经纬度序列
+   * @param {Number} distance 缓冲距离
+   * @param {String} units 单位
+   * @returns {Array<Array<L.LatLng>>} 缓冲区经纬度序列
+   */
+  bufferLine(t, e, n = "meters") {
+    const r = t.map((i) => [i.lng, i.lat]), s = y(w(r), e, { units: n });
+    return I(s);
+  },
+  /**
+   * 区域缓冲分析
+   * @param {Array<L.LatLng>} latLngs 区域经纬度序列
+   * @param {Number} distance 缓冲距离
+   * @param {String} units 单位
+   * @returns {Array<Array<L.LatLng>>} 缓冲区经纬度序列
+   */
+  bufferArea(t, e, n = "meters") {
+    let r = t.map((i) => [i.lng, i.lat]);
+    r.push(r[0]);
+    const s = y(S([r]), e, { units: n });
+    return I(s);
+  }
+}, j = {
+  /**
+   * 角度转弧度
+   * @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 r = e.x - t.x, s = e.y - t.y, i = n.x - t.x, o = n.y - t.y, h = r * i + s * o, a = r * o - s * i;
+    return Math.atan2(a, h);
+  },
+  /**
+   * 获取点到线段所在直线的垂足
+   * @param {L.Point} a 点
+   * @param {L.Point} m 线段起点
+   * @param {L.Point} n 线段终点
+   */
+  footPointOnLine(t, e, n) {
+    const r = (e.x - n.x) * (e.x - n.x) + (e.y - n.y) * (e.y - n.y), i = ((t.x - e.x) * (n.x - e.x) + (t.y - e.y) * (n.y - e.y)) / r, o = e.x + i * (n.x - e.x), h = e.y + i * (n.y - e.y);
+    return L.point(o, h);
+  },
+  /**
+   * 两线段所在直线的交点坐标，平行或共线时不返回
+   * @param {L.Point} a 线段一起点
+   * @param {L.Point} b 线段一终点
+   * @param {L.Point} c 线段二起点
+   * @param {L.Point} d 线段二终点
+   */
+  linesIntersection(t, e, n, r) {
+    const s = (e.y - t.y) * (r.x - n.x) - (t.x - e.x) * (n.y - r.y);
+    if (s) {
+      const i = ((e.x - t.x) * (r.x - n.x) * (n.y - t.y) + (e.y - t.y) * (r.x - n.x) * t.x - (r.y - n.y) * (e.x - t.x) * n.x) / s, o = -((e.y - t.y) * (r.y - n.y) * (n.x - t.x) + (e.x - t.x) * (r.y - n.y) * t.y - (r.x - n.x) * (e.y - t.y) * n.y) / s;
+      return L.point(i, o);
+    }
+  },
+  /**
+   * 根据经纬度计算累计距离，单位米
+   * @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 r = 0; r < t.length - 1; r++)
+        n += e.distance(t[r], t[r + 1]);
+    return n;
+  },
+  /**
+   * 根据经纬度计算面积，单位平方米
+   * @param {Array<L.LatLng>} latLngs
+   */
+  areaByLatLngs(t) {
+    let e = t.length, n = 0, r = Math.PI / 180, s, i;
+    if (e > 2) {
+      for (let o = 0; o < e; o++)
+        s = t[o], i = t[(o + 1) % e], n += (i.lng - s.lng) * r * (2 + Math.sin(s.lat * r) + Math.sin(i.lat * r));
+      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 r = 0; r < t.length; r++)
+        r + 1 == t.length ? n += t[r].x * t[0].y - t[0].x * t[r].y : n += t[r].x * t[r + 1].y - t[r + 1].x * t[r].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, r = t.y;
+    let s = !1, i = !1;
+    const o = e.length;
+    for (let h = 0, a = o - 1; h < o; a = h, h++) {
+      const l = e[h].x, c = e[h].y, f = e[a].x, d = e[a].y;
+      if ((l === n && c === r || f === n && d === r) && (i = !0), c < r && d >= r || c >= r && d < r) {
+        const u = l + (r - c) * (f - l) / (d - c);
+        i = u === n, u > n && (s = !s);
+      }
+      if (i)
+        break;
+    }
+    return i || s;
+  },
+  /**
+   * 点到面的距离，在内部视为0
+   * @param {L.Point} point 给定点
+   * @param {Array<L.Point>} points 多边形坐标
+   * @param {L.CRS} crs 地图CRS
+   * @returns {Boolean} 距离数值，若CRS可用，单位为米
+  */
+  distanceToPoly(t, e, n) {
+    let r = 0;
+    if (!this.isPointInPoly(t, e)) {
+      let s = [], i = [];
+      const o = e.length;
+      for (let l = 0, c = o - 1; l < o; c = l, l++)
+        s.push(L.LineUtil.pointToSegmentDistance(t, e[l], e[c])), i.push(L.LineUtil.closestPointOnSegment(t, e[l], e[c]));
+      r = _.min(s);
+      const h = _.indexOf(s, r), a = i[h];
+      if (n && n.unproject) {
+        const l = n.unproject(t), c = n.unproject(a);
+        r = n.distance(l, c);
+      }
+    }
+    return r;
+  },
+  /**
+   * 点到折线的距离
+   * @param {L.Point} point 给定点
+   * @param {Array<L.Point>} points 折线坐标
+   * @param {L.CRS} crs 地图CRS
+   * @param {Boolean} 距离数值，若CRS可用，单位为米
+   */
+  distanceToLine(t, e, n) {
+    let r = 0, s = [], i = [];
+    if (Array.isArray(e) && e.length > 1) {
+      for (let a = 0; a < e.length - 1; a++)
+        s.push(L.LineUtil.pointToSegmentDistance(t, e[a], e[a + 1])), i.push(L.LineUtil.closestPointOnSegment(t, e[a], e[a + 1]));
+      r = _.min(s);
+      const o = _.indexOf(s, r), h = i[o];
+      if (n && n.unproject) {
+        const a = n.unproject(t), l = n.unproject(h);
+        r = n.distance(a, l);
+      }
+    }
+    return r;
+  }
+};
+L.GeoUtil = L.extend(L.GeoUtil || {}, _.assign(j, A));
+L.FootageCalculator = L.FootageCalculator || {};
+L.FootageCalculator.Area = L.Evented.extend({
+  options: {
+    crs: L.CRS.EPSG3857,
+    // 坐标转换类
+    latlngs: [],
+    // 边界经纬度
+    headStart: null,
+    // 机头经纬度
+    headEnd: null,
+    // 机头终点经纬度
+    tailStart: null,
+    // 机尾经纬度
+    tailEnd: null
+    /// 机尾终点经纬度
+  },
+  initialize(t) {
+    L.setOptions(this, t);
+    const { crs: e, latlngs: n, headStart: r, headEnd: s, tailStart: i, tailEnd: o } = this.options;
+    if (e && e.project && e.unproject)
+      this.crs = e;
+    else
+      throw new Error("请传入正确的crs参数");
+    if (Array.isArray(n) && n.length > 2)
+      this.latlngs = n;
+    else
+      throw new Error("请传入正确的latlngs参数");
+    function h(l, c) {
+      if (l < 0)
+        throw new Error(`请传入正确的${c}参数，此参数必须是latlngs的某个节点`);
+    }
+    if (this.hsIndex = _.findIndex(n, (l) => _.isEqual(l, r)), h(this.hsIndex, "headStart"), this.heIndex = _.findIndex(n, (l) => _.isEqual(l, s)), h(this.heIndex, "headEnd"), this.tsIndex = _.findIndex(n, (l) => _.isEqual(l, i)), h(this.tsIndex, "tailStart"), this.teIndex = _.findIndex(n, (l) => _.isEqual(l, o)), h(this.teIndex, "tailEnd"), _.uniq([this.hsIndex, this.heIndex, this.tsIndex, this.teIndex]).length < 4)
+      throw new Error("机头机尾坐标不允许重复");
+    const a = Math.abs(this.hsIndex - this.tsIndex);
+    if (a != 1 && a != n.length - 1)
+      throw new Error("机头和机尾起点必须相邻");
+    this.initParams();
+  },
+  // 初始化参数
+  initParams() {
+    this.points = this.latlngs.map((s) => this.crs.project(p(s)));
+    const t = this.latlngs.length;
+    let e = [], n = [], r = this.hsIndex < this.tsIndex;
+    if (Math.abs(this.hsIndex - this.tsIndex) == t - 1 && (r = this.tsIndex == 0), r) {
+      let s = this.hsIndex;
+      this.heIndex > this.hsIndex && (s += t);
+      for (let o = this.heIndex; o <= s; o++)
+        e.push(this.points[o >= t ? o - t : o]);
+      e.reverse();
+      let i = this.teIndex;
+      this.tsIndex > this.teIndex && (i += t);
+      for (let o = this.tsIndex; o <= i; o++)
+        n.push(this.points[o >= t ? o - t : o]);
+    } else {
+      let s = this.heIndex;
+      this.hsIndex > this.heIndex && (s += t);
+      for (let o = this.hsIndex; o <= s; o++)
+        e.push(this.points[o >= t ? o - t : o]);
+      let i = this.tsIndex;
+      this.teIndex > this.tsIndex && (i += t);
+      for (let o = this.teIndex; o <= i; o++)
+        n.push(this.points[o >= t ? o - t : o]);
+      n.reverse();
+    }
+    this.headSegments = [], e.forEach((s, i) => {
+      i > 0 && this.headSegments.push({ start: e[i - 1], end: s });
+    }), this.tailSegments = [], n.forEach((s, i) => {
+      i > 0 && this.tailSegments.push({ start: n[i - 1], end: s });
+    });
+  },
+  /**
+   * 执行计算
+   * @param {L.LatLng} headStart 机头起点
+   * @param {L.LatLng} tailStart 机尾起点
+   * @param {Number} headDistance 机头推进距离
+   * @param {Number} tailDistance 机尾推进距离
+   * @returns {L.LatLng} headEnd 推进后机头的经纬度
+   * @returns {L.LatLng} tailEnd 推进后机尾的经纬度
+   * @returns {Array<L.LatLng>} latlngs 推进的区域范围 
+   */
+  doCalculate({ headStart: t, tailStart: e, headDistance: n, tailDistance: r }) {
+    const s = this.crs.project(p(t)), i = this.crs.project(p(e)), o = this.calcWorkPath(s, this.headSegments, n), h = this.calcWorkPath(i, this.tailSegments, r), a = this.crs.unproject(_.last(o.path)), l = this.crs.unproject(_.last(h.path));
+    let c = [], f = o.path, d = h.path;
+    return d.reverse(), new Array(f, d).forEach((u) => {
+      u.forEach((x) => {
+        c.push(this.crs.unproject(x));
+      });
+    }), { headEnd: a, tailEnd: l, latlngs: c };
+  },
+  /**
+   * 计算一次推进的结果
+   * @param {L.Point} start 起点
+   * @param {Array} segments 线段
+   * @param {Number} distance 推进距离
+   */
+  calcWorkPath(t, e, n) {
+    let r = 0, s = -1, i = -1, o;
+    e.forEach((d, u) => {
+      if (i < 0) {
+        let x = d.start;
+        s < 0 && L.LineUtil.pointToSegmentDistance(t, d.start, d.end) < 0.01 && (s = u, x = t);
+        let g = 0;
+        s >= 0 && (g = x.distanceTo(d.end)), r + g >= n && (i = u, o = this.calcEndPointOnLine(x, d.end, n - r)), r += g;
+      }
+    });
+    let h = i;
+    i < 0 && (h = e.length - 1, o = _.last(e).end);
+    let a = [t];
+    for (let d = s; d < h; d++)
+      a.push(e[d].end);
+    if (a.push(o), a.length == 2 && a[0].x == a[1].x && a[0].y == a[1].y) {
+      const d = _.last(e), u = L.GeoUtil.computeRad(d.start, d.end);
+      a[0] = a[1].subtract(L.point(0.01 * Math.cos(u), 0.01 * Math.sin(u)));
+    }
+    let l = [];
+    if (h == i) {
+      l = [o];
+      for (let d = h; d < e.length - 1; d++)
+        l.push(e[d].end);
+      l.push(_.last(e).end);
+    }
+    let c = e[i];
+    i < 0 && (c = _.last(e));
+    let f = L.GeoUtil.computeRad(c.start, c.end);
+    return { path: a, remainingPath: l, endRad: f };
+  },
+  // 获取a点向b点方向延伸distance后的坐标
+  calcEndPointOnLine(t, e, n) {
+    const r = L.GeoUtil.computeRad(t, e), s = n * Math.cos(r), i = n * Math.sin(r);
+    return t.add(L.point(s, i));
+  }
+});
+function p(t) {
+  return t instanceof L.LatLng || (t = L.latLng(t)), t;
+}
+L.footageCalculator = L.footageCalculator || {};
+L.footageCalculator.area = function(t) {
+  return new L.FootageCalculator.Area(t);
+};

package/plugins/L.FootageCalculator.Line/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>