leiting-bim 2.1.48 → 2.1.52

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

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

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

@@ -1,416 +0,0 @@
-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;
-  }
-}