leiting-bim 2.1.35 → 2.1.37

package/plugins/cesium-core/src/components/draw/handlers/LineDrawer.ts

@@ -0,0 +1,113 @@
+import { DrawOptions, DrawResult, IDrawer } from '../types';
+import { TooltipManager } from '../../TooltipManager';
+
+export default class LineDrawer implements IDrawer {
+  private Cesium: any;
+  private viewer: any;
+  private handler: any = null;
+  private positions: any[] = [];
+  private entity: any = null;
+  private tooltip: TooltipManager | null = null;
+  private tempPoints: any[] = [];
+
+  constructor(Cesium: any, viewer: any) {
+    this.Cesium = Cesium;
+    this.viewer = viewer;
+  }
+
+  startDrawing(options: DrawOptions) {
+    const { Cesium, viewer } = this;
+    this.positions = [];
+    this.tempPoints = [];
+    this.tooltip = new TooltipManager();
+    this.tooltip.show('单击左键添加点，双击左键结束');
+
+    this.handler = new Cesium.ScreenSpaceEventHandler(viewer.canvas);
+
+    // 左键点击添加点
+    this.handler.setInputAction((movement: any) => {
+      const pos = viewer.scene.pickPosition(movement.position);
+      if (!pos) return;
+
+      this.positions.push(pos);
+
+      // 添加点标记
+      const point = viewer.entities.add({
+        position: pos,
+        point: {
+          pixelSize: 8,
+          color: Cesium.Color.YELLOW,
+          disableDepthTestDistance: Number.POSITIVE_INFINITY,
+        },
+      });
+      this.tempPoints.push(point);
+
+      // 第一次点击时初始化线段 entity
+      if (!this.entity) {
+        this.entity = viewer.entities.add({
+          polyline: {
+            positions: new Cesium.CallbackProperty(() => this.positions, false),
+            width: 3,
+            material: options.color || Cesium.Color.YELLOW,
+            disableDepthTestDistance: Number.POSITIVE_INFINITY,
+            depthFailMaterial:
+              options.color?.withAlpha?.(0.5) || Cesium.Color.YELLOW.withAlpha(0.5),
+          },
+        });
+      }
+    }, Cesium.ScreenSpaceEventType.LEFT_CLICK);
+
+    // 右键完成绘制
+    this.handler.setInputAction(() => {
+      this.stopDrawing();
+
+      this.tooltip?.hide();
+      this.tooltip = null;
+
+      if (this.positions.length < 2) return;
+      this.positions.length = this.positions.length - 1;
+      const lnglats = this.positions.map((p) => {
+        const carto = Cesium.Cartographic.fromCartesian(p);
+        return {
+          lng: Cesium.Math.toDegrees(carto.longitude),
+          lat: Cesium.Math.toDegrees(carto.latitude),
+          height: carto.height,
+        };
+      });
+
+      const result: DrawResult = {
+        entity: this.entity,
+        positions: this.positions,
+        lnglats,
+        clear: () => {
+          this.clear();
+        },
+      };
+
+      options.onComplete?.(result);
+    }, Cesium.ScreenSpaceEventType.LEFT_DOUBLE_CLICK);
+  }
+
+  stopDrawing() {
+    this.handler?.destroy();
+    this.handler = null;
+  }
+
+  clear() {
+    const { viewer } = this;
+
+    if (this.entity) {
+      viewer.entities.remove(this.entity);
+      this.entity = null;
+    }
+
+    this.tempPoints.forEach((p) => viewer.entities.remove(p));
+    this.tempPoints = [];
+
+    this.tooltip?.hide();
+    this.tooltip = null;
+
+    this.positions = [];
+    this.stopDrawing();
+  }
+}

package/plugins/cesium-core/src/components/draw/handlers/PointDrawer.ts

@@ -0,0 +1,70 @@
+import { TooltipManager } from '../../TooltipManager';
+import { DrawOptions, IDrawer, DrawResult } from '../types';
+
+export default class PointDrawer implements IDrawer {
+  private Cesium: any;
+  private viewer: any;
+  private handler: any = null;
+  private entity: any = null;
+  private tooltip: TooltipManager | null = null;
+  constructor(Cesium: any, viewer: any) {
+    this.Cesium = Cesium;
+    this.viewer = viewer;
+  }
+
+  startDrawing(options: DrawOptions) {
+    const { Cesium, viewer } = this;
+    this.tooltip = new TooltipManager();
+    this.tooltip.show('左键添加点');
+    this.handler = new Cesium.ScreenSpaceEventHandler(viewer.canvas);
+
+    this.handler.setInputAction((movement: any) => {
+      const position = viewer.scene.pickPosition(movement.position);
+      if (!position) return;
+
+      const cartographic = Cesium.Cartographic.fromCartesian(position);
+      const lng = Cesium.Math.toDegrees(cartographic.longitude);
+      const lat = Cesium.Math.toDegrees(cartographic.latitude);
+      const height = cartographic.height;
+
+      const entity = viewer.entities.add({
+        position,
+        point: {
+          pixelSize: 10,
+          color: options.color || Cesium.Color.YELLOW,
+          disableDepthTestDistance: Number.POSITIVE_INFINITY,
+        },
+      });
+
+      this.entity = entity;
+
+      const result: DrawResult = {
+        entity,
+        position,
+        lnglat: { lng, lat, height },
+        clear: () => {
+          this.clear();
+        },
+      };
+
+      options.onComplete?.(result);
+
+      this.stopDrawing();
+      this.tooltip?.hide();
+      this.tooltip = null;
+    }, Cesium.ScreenSpaceEventType.LEFT_CLICK);
+  }
+
+  stopDrawing() {
+    this.handler?.destroy();
+    this.handler = null;
+  }
+
+  clear() {
+    if (this.entity) {
+      this.viewer.entities.remove(this.entity);
+      this.entity = null;
+    }
+    this.stopDrawing();
+  }
+}

package/plugins/cesium-core/src/components/draw/handlers/PolygonDrawer.ts

@@ -0,0 +1,112 @@
+import { DrawOptions, DrawResult, IDrawer } from '../types';
+import { TooltipManager } from '../../TooltipManager';
+
+export default class PolygonDrawer implements IDrawer {
+  private Cesium: any;
+  private viewer: any;
+  private handler: any = null;
+  private positions: any[] = [];
+  private entity: any = null;
+  private tooltip: TooltipManager | null = null;
+  private tempPoints: any[] = [];
+
+  constructor(Cesium: any, viewer: any) {
+    this.Cesium = Cesium;
+    this.viewer = viewer;
+  }
+
+  startDrawing(options: DrawOptions) {
+    const { Cesium, viewer } = this;
+    this.positions = [];
+    this.tempPoints = [];
+    this.tooltip = new TooltipManager();
+    this.tooltip.show('单击左键添加点，双击左键结束');
+
+    this.handler = new Cesium.ScreenSpaceEventHandler(viewer.canvas);
+
+    // 左键点击添加点
+    this.handler.setInputAction((movement: any) => {
+      const pos = viewer.scene.pickPosition(movement.position);
+      if (!pos) return;
+
+      this.positions.push(pos);
+
+      const point = viewer.entities.add({
+        position: pos,
+        point: {
+          pixelSize: 8,
+          color: Cesium.Color.YELLOW,
+          disableDepthTestDistance: Number.POSITIVE_INFINITY,
+          heightReference: Cesium.HeightReference.CLAMP_TO_GROUND,
+        },
+      });
+      this.tempPoints.push(point);
+
+      if (!this.entity) {
+        this.entity = viewer.entities.add({
+          polygon: {
+            hierarchy: new Cesium.CallbackProperty(
+              () => ({
+                positions: this.positions,
+              }),
+              false,
+            ),
+            material: options.color || Cesium.Color.YELLOW.withAlpha(0.5),
+          },
+        });
+      }
+    }, Cesium.ScreenSpaceEventType.LEFT_CLICK);
+
+    // 右键完成绘制
+    this.handler.setInputAction(() => {
+      this.stopDrawing();
+      this.tooltip?.hide();
+      this.tooltip = null;
+
+      if (this.positions.length < 3) return;
+      this.positions.length = this.positions.length - 1;
+      const lnglats = this.positions.map((p) => {
+        const carto = Cesium.Cartographic.fromCartesian(p);
+        return {
+          lng: Cesium.Math.toDegrees(carto.longitude),
+          lat: Cesium.Math.toDegrees(carto.latitude),
+          height: carto.height,
+        };
+      });
+
+      const result: DrawResult = {
+        entity: this.entity,
+        positions: this.positions,
+        lnglats,
+        clear: () => {
+          this.clear();
+        },
+      };
+
+      options.onComplete?.(result);
+    }, Cesium.ScreenSpaceEventType.LEFT_DOUBLE_CLICK);
+  }
+
+  stopDrawing() {
+    this.handler?.destroy();
+    this.handler = null;
+  }
+
+  clear() {
+    const { viewer } = this;
+
+    if (this.entity) {
+      viewer.entities.remove(this.entity);
+      this.entity = null;
+    }
+
+    this.tempPoints.forEach((p) => viewer.entities.remove(p));
+    this.tempPoints = [];
+
+    this.tooltip?.hide();
+    this.tooltip = null;
+
+    this.positions = [];
+    this.stopDrawing();
+  }
+}

package/plugins/cesium-core/src/components/draw/handlers/RectangleDrawer.ts

@@ -0,0 +1,115 @@
+import { DrawOptions, DrawResult, IDrawer } from '../types';
+
+export default class RectangleDrawer implements IDrawer {
+  private Cesium: any;
+  private viewer: any;
+  private handler: any = null;
+  private startPoint: any = null;
+  private endPoint: any = null;
+  private entity: any = null;
+
+  constructor(Cesium: any, viewer: any) {
+    this.Cesium = Cesium;
+    this.viewer = viewer;
+  }
+
+  startDrawing(options: DrawOptions) {
+    const { Cesium, viewer } = this;
+
+    this.handler = new Cesium.ScreenSpaceEventHandler(viewer.canvas);
+
+    this.handler.setInputAction((movement: any) => {
+      const pos = viewer.scene.pickPosition(movement.position);
+      if (!pos) return;
+
+      if (!this.startPoint) {
+        this.startPoint = pos;
+
+        // 初始化实体，使用 CallbackProperty 安全包装
+        this.entity = viewer.entities.add({
+          rectangle: {
+            coordinates: new Cesium.CallbackProperty(() => {
+              if (!this.startPoint || !this.endPoint) return undefined;
+
+              try {
+                const c1 = Cesium.Cartographic.fromCartesian(this.startPoint);
+                const c2 = Cesium.Cartographic.fromCartesian(this.endPoint);
+
+                const west = Math.min(c1.longitude, c2.longitude);
+                const east = Math.max(c1.longitude, c2.longitude);
+                const south = Math.min(c1.latitude, c2.latitude);
+                const north = Math.max(c1.latitude, c2.latitude);
+
+                return new Cesium.Rectangle(west, south, east, north);
+              } catch (e) {
+                console.warn('Rectangle calculation error:', e);
+                return undefined;
+              }
+            }, false),
+            material: options.color || Cesium.Color.YELLOW.withAlpha(0.5),
+            outline: true,
+            outlineColor: Cesium.Color.BLACK,
+            disableDepthTestDistance: Number.POSITIVE_INFINITY,
+          },
+        });
+      } else {
+        this.stopDrawing();
+
+        const c1 = Cesium.Cartographic.fromCartesian(this.startPoint);
+        const c2 = Cesium.Cartographic.fromCartesian(this.endPoint);
+
+        const sw = {
+          lng: Cesium.Math.toDegrees(Math.min(c1.longitude, c2.longitude)),
+          lat: Cesium.Math.toDegrees(Math.min(c1.latitude, c2.latitude)),
+          height: 0,
+        };
+        const ne = {
+          lng: Cesium.Math.toDegrees(Math.max(c1.longitude, c2.longitude)),
+          lat: Cesium.Math.toDegrees(Math.max(c1.latitude, c2.latitude)),
+          height: 0,
+        };
+
+        const result: DrawResult = {
+          entity: this.entity,
+          position: this.startPoint,
+          lnglat: {
+            lng: Cesium.Math.toDegrees(c1.longitude),
+            lat: Cesium.Math.toDegrees(c1.latitude),
+            height: c1.height,
+          },
+          positions: [this.startPoint, this.endPoint],
+          lnglats: [sw, ne],
+          clear: () => {
+            this.clear();
+          },
+        };
+
+        options.onComplete?.(result);
+      }
+    }, Cesium.ScreenSpaceEventType.LEFT_CLICK);
+
+    this.handler.setInputAction((movement: any) => {
+      if (!this.startPoint) return;
+
+      const pos = viewer.scene.pickPosition(movement.endPosition);
+      if (pos) {
+        this.endPoint = pos;
+      }
+    }, Cesium.ScreenSpaceEventType.MOUSE_MOVE);
+  }
+
+  stopDrawing() {
+    this.handler?.destroy();
+    this.handler = null;
+  }
+
+  clear() {
+    if (this.entity) {
+      this.viewer.entities.remove(this.entity);
+      this.entity = null;
+    }
+    this.startPoint = null;
+    this.endPoint = null;
+    this.stopDrawing();
+  }
+}

package/plugins/cesium-core/src/components/draw/types.ts

@@ -0,0 +1,28 @@
+export type DrawType = 'point' | 'line' | 'rectangle' | 'circle' | 'square' | 'polygon';
+
+export interface DrawOptions {
+  clampToGround?: boolean;
+  color?: any;
+  width?: number;
+  step?: number;
+  onComplete?: (entity: any) => void;
+}
+
+export interface IDrawer {
+  startDrawing(options: DrawOptions): void;
+  stopDrawing(): void;
+  clear(): void;
+}
+
+export interface DrawResult {
+  entity: any;
+  position?: Number[];
+  lnglat?: {
+    lng: number;
+    lat: number;
+    height: number;
+  };
+  positions?: Number[];
+  lnglats?: { lng: number; lat: number; height: number }[];
+  clear: Function;
+}