leiting-bim 2.1.36 → 2.1.39

package/plugins/cesium-core/src/components/gltf/index.ts

@@ -0,0 +1 @@
+export * from './GLTFManage';

package/plugins/cesium-core/src/components/measurement/MeasurementTool.ts

@@ -0,0 +1,416 @@
+import {
+  IMeasure,
+  MeasurementOptions,
+  MeasurementType,
+  MeasurementRecord,
+  MeasurementsConfig,
+} from './types';
+import HorizontalMeasure from './handlers/HorizontalMeasure';
+import VerticalMeasure from './handlers/VerticalMeasure';
+import TriangleMeasure from './handlers/TriangleMeasure';
+import SpaceMeasure from './handlers/SpaceMeasure';
+import AreaMeasure from './handlers/AreaMeasure';
+import CircleMeasure from './handlers/CircleMeasure';
+import PolylineDistanceMeasure from './handlers/PolylineDistanceMeasure';
+import TerrainHeightMeasure from './handlers/TerrainHeightMeasure';
+import CoordinateMeasure from './handlers/CoordinateMeasure';
+import RectangleMeasure from './handlers/RectangleMeasure';
+import RegularPolygonMeasure from './handlers/RegularPolygonMeasure';
+import { HtmlOverlayLabelPool } from '../HtmlOverlayLabelPool';
+import { MarkerEventKey } from '../MarkerEvent';
+
+export class MeasurementTool {
+  private Cesium: any;
+  private viewer: any;
+  private actives: IMeasure[] = [];
+  private measurements: MeasurementRecord[] = [];
+  private htmlLabelPool: any = null;
+  private recordHandlers: Map<string, IMeasure> = new Map();
+  private specifiedClear: boolean = false;
+  private deleteLabelPool: HtmlOverlayLabelPool | null = null;
+  private deleteLabelIds: Map<string, string> = new Map();
+
+  constructor({ Cesium, viewer }: { Cesium: any; viewer: any }) {
+    this.Cesium = Cesium;
+    this.viewer = viewer;
+    viewer.screenSpaceEventHandler.removeInputAction(Cesium.ScreenSpaceEventType.LEFT_DOUBLE_CLICK);
+  }
+
+  measure(type: MeasurementType, options: MeasurementOptions) {
+    let handler: IMeasure | null = null;
+    switch (type) {
+      case 'horizontal':
+        handler = new HorizontalMeasure(this.Cesium, this.viewer);
+        break;
+      case 'vertical':
+        handler = new VerticalMeasure(this.Cesium, this.viewer);
+        break;
+      case 'triangle':
+        handler = new TriangleMeasure(this.Cesium, this.viewer);
+        break;
+      case 'space':
+        handler = new SpaceMeasure(this.Cesium, this.viewer);
+        break;
+      case 'area':
+        handler = new AreaMeasure(this.Cesium, this.viewer);
+        break;
+      case 'circle':
+        handler = new CircleMeasure(this.Cesium, this.viewer);
+        break;
+      case 'polyline':
+        handler = new PolylineDistanceMeasure(this.Cesium, this.viewer);
+        break;
+      case 'terrainHeight':
+        handler = new TerrainHeightMeasure(this.Cesium, this.viewer);
+        break;
+      case 'coordinate':
+        handler = new CoordinateMeasure(this.Cesium, this.viewer);
+        break;
+      case 'rectangle':
+        handler = new RectangleMeasure(this.Cesium, this.viewer);
+        break;
+      case 'regularPolygon':
+        handler = new RegularPolygonMeasure(this.Cesium, this.viewer);
+        break;
+      default:
+        throw new Error(`Unsupported measurement type: ${type}`);
+    }
+    if (!handler) return;
+    this.actives.push(handler);
+    const currentHandler = handler;
+    const wrapped: MeasurementOptions = {
+      ...options,
+      onComplete: (result: any) => {
+        const record: MeasurementRecord = {
+          id: `m_${Date.now()}_${this.measurements.length}`,
+          type,
+          options: (() => {
+            const o: any = { ...options };
+            if ('onComplete' in o) {
+              delete o.onComplete;
+            }
+            return o;
+          })(),
+          positions: (() => {
+            if (Array.isArray(result?.positions)) {
+              return result.positions.map((p: any) => [p.x, p.y, p.z]);
+            }
+            switch (type) {
+              case 'terrainHeight': {
+                const pos = (result as any)?.position;
+                if (pos) return [[pos.x, pos.y, pos.z]];
+                return undefined;
+              }
+              case 'coordinate': {
+                const ll = (result as any)?.lnglat;
+                if (ll && typeof ll.lng === 'number' && typeof ll.lat === 'number') {
+                  const c = this.Cesium.Cartesian3.fromDegrees(ll.lng, ll.lat, ll.height || 0);
+                  return [[c.x, c.y, c.z]];
+                }
+                return undefined;
+              }
+              default:
+                return undefined;
+            }
+          })(),
+          data: this._serializeMetrics(type, result),
+        };
+        this.measurements.push(record);
+        if (currentHandler) {
+          this.recordHandlers.set(record.id, currentHandler);
+        }
+        if (this.specifiedClear) {
+          this._showDeleteLabels('html-label-container');
+        }
+        options.onComplete?.(result);
+        const idx = this.actives.indexOf(currentHandler);
+        if (idx >= 0) this.actives.splice(idx, 1);
+      },
+    };
+    handler.start(wrapped);
+  }
+
+  clear() {
+    const h = this.actives.pop();
+    if (h) h.clear();
+    this._removeAllDeleteLabels();
+    this.specifiedClear = false;
+  }
+
+  cancel() {
+    const h = this.actives.pop();
+    if (h) h.stop();
+  }
+
+  disableDefaultSelection({ disableLeftClick = false, disableDoubleClick = true } = {}) {
+    const handler = this.viewer?.cesiumWidget?.screenSpaceEventHandler;
+    if (!handler) return;
+    if (disableDoubleClick) {
+      handler.removeInputAction(this.Cesium.ScreenSpaceEventType.LEFT_DOUBLE_CLICK);
+    }
+    if (disableLeftClick) {
+      handler.removeInputAction(this.Cesium.ScreenSpaceEventType.LEFT_CLICK);
+    }
+  }
+
+  clearAll() {
+    while (this.actives.length) {
+      const h = this.actives.pop();
+      try {
+        h?.clear();
+      } catch {}
+    }
+    for (const [, handler] of this.recordHandlers) {
+      try {
+        handler.clear();
+      } catch {}
+    }
+    this.recordHandlers.clear();
+    this.measurements = [];
+    this._removeAllDeleteLabels();
+    this.specifiedClear = false;
+  }
+
+  public getMeasurementsConfig(): MeasurementsConfig {
+    return {
+      measurements: this.measurements.map((m) => ({
+        ...m,
+        options: m.options ? { ...(m.options as any) } : m.options,
+        positions: m.positions ? m.positions.map((p) => [p[0], p[1], p[2]]) : m.positions,
+        data: m.data ? { ...(m.data as any) } : m.data,
+      })),
+    };
+  }
+
+  public setMeasurementsConfig(config: MeasurementsConfig) {
+    if (!config?.measurements?.length) return;
+    for (const rec of config.measurements) {
+      let handler: IMeasure | null = null;
+      switch (rec.type) {
+        case 'horizontal':
+          handler = new HorizontalMeasure(this.Cesium, this.viewer);
+          break;
+        case 'vertical':
+          handler = new VerticalMeasure(this.Cesium, this.viewer);
+          break;
+        case 'triangle':
+          handler = new TriangleMeasure(this.Cesium, this.viewer);
+          break;
+        case 'space':
+          handler = new SpaceMeasure(this.Cesium, this.viewer);
+          break;
+        case 'area':
+          handler = new AreaMeasure(this.Cesium, this.viewer);
+          break;
+        case 'circle':
+          handler = new CircleMeasure(this.Cesium, this.viewer);
+          break;
+        case 'polyline':
+          handler = new PolylineDistanceMeasure(this.Cesium, this.viewer);
+          break;
+        case 'terrainHeight':
+          handler = new TerrainHeightMeasure(this.Cesium, this.viewer);
+          break;
+        case 'coordinate':
+          handler = new CoordinateMeasure(this.Cesium, this.viewer);
+          break;
+        case 'rectangle':
+          handler = new RectangleMeasure(this.Cesium, this.viewer);
+          break;
+        case 'regularPolygon':
+          handler = new RegularPolygonMeasure(this.Cesium, this.viewer);
+          break;
+        default:
+          handler = null;
+      }
+      handler?.rehydrate?.(rec, undefined);
+      if (handler && rec.id) {
+        this.recordHandlers.set(rec.id, handler);
+      }
+      const exists = this.measurements.find((r) => r.id === rec.id);
+      if (!exists) this.measurements.push(rec);
+    }
+    if (this.specifiedClear) {
+      this._showDeleteLabels('html-label-container');
+    }
+  }
+
+  private _serializeMetrics(type: MeasurementType, result: any) {
+    switch (type) {
+      case 'space':
+        return { distance: result?.distance };
+      case 'horizontal':
+        return { distance: result?.distance };
+      case 'vertical':
+        return { vertical: result?.vertical };
+      case 'polyline':
+        return { distance: result?.distance };
+      case 'area':
+        return { area: result?.area };
+      case 'circle':
+        return { radius: result?.radius, area: result?.area, perimeter: result?.perimeter };
+      case 'rectangle':
+        return { width: result?.width, height: result?.height, area: result?.area };
+      case 'regularPolygon':
+        return {
+          sides: result?.sides,
+          radius: result?.radius,
+          perimeter: result?.perimeter,
+          area: result?.area,
+        };
+      case 'triangle':
+        return { lengths: result?.lengths, angles: result?.angles };
+      case 'terrainHeight':
+        return {
+          terrainHeight: result?.terrainHeight,
+          difference: result?.difference,
+          position: result?.position,
+          zeroPosition: result?.zeroPosition,
+        };
+      case 'coordinate':
+        return { lnglat: result?.lnglat };
+      default:
+        return {};
+    }
+  }
+
+  private _toCartesian(arr: [number, number, number]) {
+    const Cesium = this.Cesium;
+    return new Cesium.Cartesian3(arr[0], arr[1], arr[2]);
+  }
+
+  private _removeRecordVisual(_rec: MeasurementRecord) {
+    const viewer = this.viewer;
+    const Cesium = this.Cesium;
+    const entities = viewer.entities.values;
+    for (let i = entities.length - 1; i >= 0; i--) {
+      const e = entities[i];
+      try {
+        viewer.entities.remove(e);
+      } catch {}
+    }
+    const primitives = viewer.scene.primitives;
+    const arr: any[] = [];
+    primitives._primitives && primitives._primitives.forEach((p: any) => arr.push(p));
+    for (const p of arr) {
+      try {
+        viewer.scene.primitives.remove(p);
+      } catch {}
+    }
+    if (this.htmlLabelPool) {
+      this.htmlLabelPool.removeAll();
+    }
+  }
+
+  public toggleSpecifiedClear(containerId?: string) {
+    if (!this.specifiedClear) {
+      this.specifiedClear = true;
+      if (!this.deleteLabelPool) {
+        const cid = containerId || 'html-label-container';
+        this.deleteLabelPool = new HtmlOverlayLabelPool(this.Cesium, this.viewer, cid);
+        this.deleteLabelPool.registerTheme('measure-delete-label', {
+          createElement: (el: HTMLDivElement, ctx: any) => {
+            el.innerHTML = '删除';
+            el.style.background = 'rgba(255,0,0,0.7)';
+            el.style.color = '#fff';
+            el.style.font = '12px sans-serif';
+            el.style.padding = '2px 6px';
+            el.style.borderRadius = '4px';
+            el.style.whiteSpace = 'nowrap';
+          },
+          options: { offset: { x: 0, y: -10 } },
+        });
+        this.deleteLabelPool.eventBus.addListener(
+          MarkerEventKey.Click,
+          {
+            name: 'measurement_delete_label_click',
+            fn: (info: any) => {
+              if (!info || info.theme !== 'measure-delete-label') return;
+              const rid = info?.data?.recordId;
+              if (rid) this.deleteMeasurement(rid);
+            },
+          },
+          true,
+        );
+      }
+      this._showDeleteLabels(containerId || 'html-label-container');
+    } else {
+      this._removeAllDeleteLabels();
+      this.specifiedClear = false;
+    }
+  }
+
+  public deleteMeasurement(recordId: string) {
+    const handler = this.recordHandlers.get(recordId);
+    if (handler) {
+      try {
+        handler.clear();
+      } catch {}
+    }
+    this.recordHandlers.delete(recordId);
+    this.measurements = this.measurements.filter((m) => m.id !== recordId);
+    const did = this.deleteLabelIds.get(recordId);
+    if (did && this.deleteLabelPool) {
+      this.deleteLabelPool.removeByIds([did]);
+    }
+    this.deleteLabelIds.delete(recordId);
+  }
+
+  private _showDeleteLabels(containerId?: string) {
+    if (!this.deleteLabelPool) return;
+    const Cesium = this.Cesium;
+    for (const rec of this.measurements) {
+      const id = 'm_del_' + rec.id;
+      if (this.deleteLabelIds.has(rec.id)) continue;
+      const center = this._computeRecordCenter(rec);
+      if (!center) continue;
+      const carto = Cesium.Cartographic.fromCartesian(center);
+      const lon = Cesium.Math.toDegrees(carto.longitude);
+      const lat = Cesium.Math.toDegrees(carto.latitude);
+      const h = carto.height || 0;
+      this.deleteLabelPool.add(
+        { recordId: rec.id },
+        {
+          id,
+          lon,
+          lat,
+          height: h,
+          theme: 'measure-delete-label',
+          show: true,
+          style: { zIndex: '1000' },
+        },
+      );
+      this.deleteLabelIds.set(rec.id, id);
+    }
+  }
+
+  private _removeAllDeleteLabels() {
+    if (this.deleteLabelPool) {
+      const ids = Array.from(this.deleteLabelIds.values());
+      if (ids.length) this.deleteLabelPool.removeByIds(ids);
+    }
+    this.deleteLabelIds.clear();
+  }
+
+  private _computeRecordCenter(rec: MeasurementRecord) {
+    const Cesium = this.Cesium;
+    const posList = (rec.positions || []).map((p) => this._toCartesian(p));
+    if (posList.length > 0) {
+      const cx = posList.reduce((s, p) => s + p.x, 0) / posList.length;
+      const cy = posList.reduce((s, p) => s + p.y, 0) / posList.length;
+      const cz = posList.reduce((s, p) => s + p.z, 0) / posList.length;
+      return new Cesium.Cartesian3(cx, cy, cz);
+    }
+    if (rec.type === 'coordinate' && rec.data?.lnglat) {
+      const lng = rec.data.lnglat.lng;
+      const lat = rec.data.lnglat.lat;
+      const height = rec.data.lnglat.height || 0;
+      return Cesium.Cartesian3.fromDegrees(lng, lat, height);
+    }
+    if (rec.type === 'terrainHeight' && rec.data?.position) {
+      const p = rec.data.position;
+      return new Cesium.Cartesian3(p.x, p.y, p.z);
+    }
+    return null;
+  }
+}