cesium-pocket 0.7.2-alpha → 0.7.4-alpha

package/src/drawer/CP2dDrawer.d.ts

@@ -44,6 +44,12 @@ export declare class CP2dDrawer extends DataCenter {
     private moveCtrlEvent;
     private measurePoint;
     protected editMoveFun(event: any, cartesian: Cartesian3): void;
+    /**
+     * 按当前顶点数创建预览图形。
+     * 顶点不够时不创建：面至少要 3 个点、线至少要 2 个点，
+     * 否则会生成无效几何，让 Cesium 报错甚至停止渲染。
+     */
+    private syncPreview;
     private createMainLine;
     private createMainPolygon;
     private createDashline;

package/src/drawer/DataCenter.d.ts

@@ -27,6 +27,18 @@ export declare class DataCenter extends DrawerStatus {
      * @returns Cartesian3[]
      */
     protected dsToMd(): Cartesian3[];
+    /**
+     * 复制成普通坐标对象。
+     * 一是去掉挂在上面的附加属性；二是万一外部把响应式代理传进来，
+     * 复制后就是普通对象，可以安全地 postMessage 给 Web Worker。
+     */
+    protected toPlainCartesian3(cartesian: Cartesian3): Cartesian3;
+    /**
+     * 过滤出合法坐标并复制成普通对象。
+     * 数组里可能混入 undefined（绘制过程中还没拾取到地表点），
+     * 直接交给 Cesium 会抛出 “Cannot set properties of undefined”。
+     */
+    protected toPlainPositions(positions: ReadonlyArray<Cartesian3 | undefined | null> | undefined | null): Cartesian3[];
     /**
    * 根据mainData更新dataSource
    * @returns Cartesian3[]

package/src/drawer/RectDrawer.d.ts

@@ -1,4 +1,4 @@
-import { Cartesian3, Viewer, PolylineGraphics, PolygonGraphics, PointGraphics } from 'cesium';
+import { Cartesian3, Viewer, Entity, PolylineGraphics, PolygonGraphics, PointGraphics } from 'cesium';
 import { DataCenter } from './DataCenter';
 export type RectMoveFn = (cartesians: Cartesian3[]) => void;
 export interface RectOptions {
@@ -22,7 +22,7 @@ export declare class RectDrawer extends DataCenter {
     private rectOverFun;
     constructor(viewer: Viewer, options?: RectOptions);
     start(): void;
-    getEntity(): void;
+    getEntity(): Entity | null;
     getPositions(): Cartesian3[];
     /**
      * 根据数据直接生成图形
@@ -37,6 +37,12 @@ export declare class RectDrawer extends DataCenter {
     private rect_moveEvent;
     private rectMove;
     private initMainData;
+    /**
+     * 按当前顶点数创建预览图形。
+     * 顶点不够时不创建：面至少要 3 个点、线至少要 2 个点，
+     * 否则会生成无效几何，让 Cesium 报错甚至停止渲染。
+     */
+    private syncPreview;
     private createLine;
     private createPolygon;
 }

package/src/gauger/util.d.ts

@@ -1,4 +1,16 @@
 import { Cartesian3 } from 'cesium';
+/**
+ * 取出 Vue 响应式对象的原始值。
+ * Cesium 生成几何体时会通过 postMessage 把参数发到 Web Worker，
+ * 而 Vue 的 Proxy 无法被结构化克隆，会抛 DataCloneError，
+ * 所以所有交给 Cesium 的对象都必须先去掉响应式代理。
+ */
+export declare const getRaw: <T>(value: T) => T;
+/**
+ * 复制成全新的 Cartesian3，去掉 Vue 代理以及挂在上面的附加属性，
+ * 保证进入 Cesium 几何参数的始终是纯净、可序列化的坐标。
+ */
+export declare const toPlainCartesian3: (position: Cartesian3) => Cartesian3;
 export declare const getGroundDistance: (cartesian1: Cartesian3, cartesian2: Cartesian3) => number;
 export declare const getCenterPosition: (cartesian1: Cartesian3, cartesian2: Cartesian3) => Cartesian3;
 export declare const getDistanceLabel: (distance: number) => string;
@@ -22,3 +34,15 @@ export declare const getAreaText: (area: number) => string;
  * @returns
  */
 export declare const calculatePlanarArea: (positions: Cartesian3[]) => string;
+/**
+ * 计算柱体体积，单位立方米。
+ * @param area 底面积，单位平方米
+ * @param height 向上拉伸的高度，单位米
+ */
+export declare const getSolidVolume: (area: number, height: number) => number;
+/**
+ * 把体积（立方米）换算成合适的单位显示。
+ * 1 立方公里 = 1e9 立方米，1 万立方公里 = 1e13 立方米。
+ * @param volume 体积，单位立方米
+ */
+export declare const getVolumeText: (volume: number) => string;

package/submerger-Bqh-bzY0.js

@@ -0,0 +1,294 @@
+import { Cartographic as f, Math as x, sampleTerrainMostDetailed as y, Cartesian3 as w, ClippingPolygonCollection as I, ClippingPolygon as E, Color as D, Transforms as b, Matrix4 as M, EllipsoidGeodesic as L, ImageMaterialProperty as A, Cartesian2 as B, CallbackProperty as T } from "cesium";
+class v {
+  constructor(t, n) {
+    this.viewer = t, this.positions = n;
+  }
+  cartesianToLonLats(t) {
+    return t.map((e) => {
+      const r = f.fromCartesian(e);
+      return [
+        x.toDegrees(r.longitude),
+        x.toDegrees(r.latitude)
+      ];
+    });
+  }
+}
+class j extends v {
+  constructor(t, n, e) {
+    super(t, n), this.lonLats = [], this.digDepth = 450, this.stepMeter = 20, this.wallGap = 5, this.topOffset = 20, this.minTerrainHeight = null, this.lonLats = super.cartesianToLonLats(this.positions), this.viewer.scene.globe.depthTestAgainstTerrain = !0, e && (this.digDepth = e.digDepth ?? 450, this.stepMeter = e.stepMeter ?? 20, this.wallGap = e.wallGap ?? 5, this.topOffset = e.topOffset ?? 20);
+  }
+  /**
+   * 
+   * @param terrainProvider 挖掘操作
+   * @returns 
+   */
+  clipping(t) {
+    return new Promise((n, e) => {
+      const r = this.insetPolygon(this.lonLats, this.wallGap), i = this.densifyBoundary(r, this.stepMeter);
+      return y(
+        t,
+        i.map((s) => s.carto)
+      ).then((s) => {
+        const a = s.map((l) => l.height);
+        this.minTerrainHeight = Math.min(...a);
+        const o = i.map(
+          (l) => w.fromDegrees(l.lon, l.lat)
+        );
+        n(o), this.viewer.scene.globe.clippingPolygons = new I({
+          polygons: [new E({ positions: this.positions })],
+          enabled: !0,
+          inverse: !1
+        }), this.generateEntities(o, a);
+      }).catch((s) => {
+        e(s);
+      });
+    });
+  }
+  generateEntities(t, n) {
+    const e = Math.min(...n) - this.digDepth;
+    this.viewer.entities.add({
+      name: "坑底",
+      polygon: {
+        hierarchy: t,
+        height: e,
+        material: this.soilMaterial(16, 16),
+        outline: !0,
+        outlineColor: D.fromCssColorString("#3d2914")
+      }
+    });
+    const r = [...t, t[0]], i = [...n, n[0]];
+    this.viewer.entities.add({
+      name: "侧面土层",
+      wall: {
+        positions: r,
+        maximumHeights: i.map((s) => s + this.topOffset),
+        minimumHeights: i.map(() => e),
+        material: this.soilMaterial(48, 6)
+      }
+    });
+  }
+  /**
+   * 规则部分体积，立方米。
+   * 边界最低点所在水平面到坑底是等高的柱体，高度就是 digDepth。
+   */
+  calcRegularVolume() {
+    return this.polygonArea(this.lonLats) * this.digDepth;
+  }
+  /**
+   * 整个开挖体积，立方米。
+   * 多边形内从地形表面挖到坑底，等于规则柱体再加上最低点以上的地形土方。
+   * 须先调用 clipping，或传入 terrainProvider。
+   */
+  calcTotalVolume(t, n = 4e3) {
+    if (!t)
+      return Promise.reject(new Error("计算开挖体积前请先调用 clipping，或传入 terrainProvider"));
+    const e = this.minTerrainHeight == null ? this.sampleBoundaryMinHeight(t) : Promise.resolve(this.minTerrainHeight);
+    return Promise.all([
+      e,
+      this.sampleMeanInteriorHeight(t, n)
+    ]).then(([r, i]) => {
+      const s = r - this.digDepth;
+      return (i - s) * this.polygonArea(this.lonLats);
+    });
+  }
+  /** 与坑壁同一套内缩边界上的最低高程，保证体积和坑底是同一个最低点 */
+  sampleBoundaryMinHeight(t) {
+    return new Promise((n, e) => {
+      const r = this.insetPolygon(this.lonLats, this.wallGap), i = this.densifyBoundary(r, this.stepMeter);
+      y(
+        t,
+        i.map((s) => s.carto)
+      ).then((s) => {
+        let a = Math.min(...s.map((o) => o.height));
+        n(a);
+      }).catch((s) => {
+        e(s);
+      });
+    });
+  }
+  /** 多边形内均匀取样的平均地面高程 */
+  sampleMeanInteriorHeight(t, n) {
+    const { enu: e, inverse: r } = this.createEnuFrame(this.lonLats), i = this.toLocalPoints(this.lonLats, r), s = Math.abs(this.shoelace(i)) / 2;
+    let a = 1 / 0, o = -1 / 0, l = 1 / 0, c = -1 / 0;
+    for (const h of i)
+      a = Math.min(a, h.x), o = Math.max(o, h.x), l = Math.min(l, h.y), c = Math.max(c, h.y);
+    const g = Math.min(500, Math.max(30, Math.sqrt(s / n))), u = [];
+    for (let h = a + g / 2; h <= o; h += g)
+      for (let m = l + g / 2; m <= c; m += g)
+        this.pointInPolygon(h, m, i) && u.push(this.localToCartographic(h, m, e));
+    if (u.length === 0) {
+      const h = i.reduce((p, d) => p + d.x, 0) / i.length, m = i.reduce((p, d) => p + d.y, 0) / i.length;
+      u.push(this.localToCartographic(h, m, e));
+    }
+    return new Promise((h, m) => {
+      y(t, u).then((p) => {
+        let d = 0, H = 0;
+        for (const P of p)
+          Number.isFinite(P.height) && (d += P.height, H++);
+        if (H === 0)
+          throw new Error("开挖范围内没有可用的地形高程");
+        h(d / H);
+      }).catch((p) => {
+        m(p);
+      });
+    });
+  }
+  /** 开挖多边形的水平面积，平方米。投影到质心的东北天平面后用鞋带公式 */
+  polygonArea(t) {
+    const { inverse: n } = this.createEnuFrame(t);
+    return Math.abs(this.shoelace(this.toLocalPoints(t, n))) / 2;
+  }
+  createEnuFrame(t) {
+    const n = t.reduce((a, o) => a + o[0], 0) / t.length, e = t.reduce((a, o) => a + o[1], 0) / t.length, r = w.fromDegrees(n, e), i = b.eastNorthUpToFixedFrame(r), s = M.inverse(i, new M());
+    return { enu: i, inverse: s };
+  }
+  toLocalPoints(t, n) {
+    return t.map(([e, r]) => {
+      const i = M.multiplyByPoint(
+        n,
+        w.fromDegrees(e, r),
+        new w()
+      );
+      return { x: i.x, y: i.y };
+    });
+  }
+  localToCartographic(t, n, e) {
+    const r = M.multiplyByPoint(e, new w(t, n, 0), new w());
+    return f.fromCartesian(r);
+  }
+  shoelace(t) {
+    let n = 0;
+    for (let e = 0; e < t.length; e++) {
+      const r = (e + 1) % t.length;
+      n += t[e].x * t[r].y - t[r].x * t[e].y;
+    }
+    return n;
+  }
+  pointInPolygon(t, n, e) {
+    let r = !1;
+    for (let i = 0, s = e.length - 1; i < e.length; s = i++) {
+      const a = e[i].y, o = e[s].y;
+      a > n != o > n && t < (e[s].x - e[i].x) * (n - a) / (o - a) + e[i].x && (r = !r);
+    }
+    return r;
+  }
+  /** 多边形向质心内收固定米数，避免按比例内缩在大范围上留出宽缝 */
+  insetPolygon(t, n) {
+    const e = t.reduce((i, s) => i + s[0], 0) / t.length, r = t.reduce((i, s) => i + s[1], 0) / t.length;
+    return t.map(([i, s]) => {
+      const a = s * Math.PI / 180, o = (i - e) * 111320 * Math.cos(a), l = (s - r) * 110540, c = Math.hypot(o, l);
+      if (c <= n) return [i, s];
+      const g = (c - n) / c;
+      return [e + (i - e) * g, r + (s - r) * g];
+    });
+  }
+  /** 沿闭合边线按间距加密 */
+  densifyBoundary(t, n) {
+    const e = [], r = t.length;
+    for (let i = 0; i < r; i++) {
+      const [s, a] = t[i], [o, l] = t[(i + 1) % r], c = new L(
+        f.fromDegrees(s, a),
+        f.fromDegrees(o, l)
+      ), g = Math.max(1, Math.ceil(c.surfaceDistance / n));
+      for (let u = 0; u < g; u++) {
+        const h = c.interpolateUsingFraction(u / g);
+        e.push({
+          lon: x.toDegrees(h.longitude),
+          lat: x.toDegrees(h.latitude),
+          carto: h
+        });
+      }
+    }
+    return e;
+  }
+  /** 画一张近似土壤的贴图，侧面和底部共用 */
+  createSoilImage() {
+    const n = document.createElement("canvas");
+    n.width = n.height = 128;
+    const e = n.getContext("2d"), r = e.createImageData(128, 128), i = r.data;
+    for (let s = 0; s < i.length; s += 4) {
+      const a = Math.random();
+      i[s] = 100 + a * 60, i[s + 1] = 58 + a * 36, i[s + 2] = 26 + a * 18, i[s + 3] = 255;
+    }
+    return e.putImageData(r, 0, 0), n;
+  }
+  soilMaterial(t, n) {
+    return new A({
+      image: this.createSoilImage(),
+      repeat: new B(t, n)
+    });
+  }
+}
+const F = 10;
+class G extends v {
+  //最低高度向下的高度差（terrainMinH不一定是实际的最低高度）
+  constructor(t, n, e) {
+    super(t, n), this.lonLats = [], this.waterHeight = 0, this.terrainMinH = 0, this.terrainMaxH = 0, this.downwardDistance = 50, this.upwardDistance = 100, e && (this.downwardDistance = e.downwardDistance || 50, this.upwardDistance = e.upwardDistance || 100);
+  }
+  init(t) {
+    return this.lonLats = super.cartesianToLonLats(this.positions), this.initFlood(t);
+  }
+  getMinHight() {
+    return this.terrainMinH - this.downwardDistance;
+  }
+  getMaxHight() {
+    return this.terrainMaxH + this.upwardDistance;
+  }
+  getWaterHight() {
+    return this.waterHeight;
+  }
+  setWaterHeight(t) {
+    this.terrainMinH - this.downwardDistance > t && (t = this.terrainMinH - this.downwardDistance), this.terrainMaxH + this.upwardDistance < t && (t = this.terrainMaxH + this.upwardDistance), this.waterHeight = t;
+  }
+  /**
+   * 沿闭合多边形边线按间距加密，得到贴地采样点
+   * 只采边界（贴地线），不采多边形内部
+   */
+  densifyBoundary(t, n) {
+    const e = [], r = t.length;
+    console.log(r);
+    for (let i = 0; i < r; i++) {
+      const [s, a] = t[i], [o, l] = t[(i + 1) % r], c = new L(
+        f.fromDegrees(s, a),
+        f.fromDegrees(o, l)
+      ), g = Math.max(1, Math.ceil(c.surfaceDistance / n));
+      for (let u = 0; u < g; u++)
+        e.push(c.interpolateUsingFraction(u / g));
+    }
+    return e;
+  }
+  /** 采样贴地高程 → 定水位范围 → 画范围线与立体水体 */
+  initFlood(t) {
+    return new Promise((n, e) => {
+      this.viewer.scene.globe.depthTestAgainstTerrain = !0, y(
+        t,
+        this.densifyBoundary(this.lonLats, F)
+      ).then((r) => {
+        const i = r.map((a) => a.height);
+        this.terrainMinH = Math.round(Math.min(...i)), this.terrainMaxH = Math.round(Math.max(...i)), this.waterHeight = Math.round(this.terrainMinH / 2 + this.terrainMaxH / 2);
+        let s = this.getWaterEntity();
+        n(s);
+      }).catch((r) => {
+        e(r);
+      });
+    });
+  }
+  getWaterEntity() {
+    return this.viewer.entities.add({
+      polygon: {
+        hierarchy: this.positions,
+        height: new T(() => this.terrainMinH - this.downwardDistance, !1),
+        extrudedHeight: new T(() => this.waterHeight, !1),
+        material: D.fromCssColorString("#1e90ff").withAlpha(0.45),
+        outline: !0,
+        outlineColor: D.CYAN,
+        closeTop: !0,
+        closeBottom: !0
+      }
+    });
+  }
+}
+export {
+  j as C,
+  G as S
+};

package/src/drawer/util.d.ts

@@ -1,9 +0,0 @@
-import { Cartesian3, Label, Viewer } from 'cesium';
-export declare const getTimeStr: () => string;
-export declare const getGroundDistance: (cartesian1: Cartesian3, cartesian2: Cartesian3) => number;
-export declare const getCenterPosition: (cartesian1: Cartesian3, cartesian2: Cartesian3) => Cartesian3;
-export declare const getTextlabel: (viewer: Viewer, cartesian: Cartesian3, text: string, label?: Label | null) => import('cesium').Entity;
-export declare const getDistanceLabel: (distance: number) => string;
-export declare const getAreaLabel: (area: number) => string;
-export declare const getCentroid: (positions: Cartesian3[]) => Cartesian3 | null;
-export declare const calculatePlanarArea: (positions: Cartesian3[]) => number;