leiting-bim 2.1.36 → 2.1.39

package/plugins/plugins/cesium-core/src/components/roaming/CameraRoamTool.ts

@@ -0,0 +1,286 @@
+import { IRoamTool, ViewRoamOptions, Waypoint } from './types';
+
+export class CameraRoamTool implements IRoamTool {
+  private Cesium: any;
+  private viewer: any;
+  private options: ViewRoamOptions | null = null;
+  private entity: any = null;
+  private viewEntities: any[] = [];
+  private startTime: any = null;
+  private stopTime: any = null;
+  private isPaused = false;
+  private lastTime: any = null;
+
+  constructor({ Cesium, viewer }: { Cesium: any; viewer: any }) {
+    this.Cesium = Cesium;
+    this.viewer = viewer;
+  }
+
+  get Viewer() {
+    return this.viewer;
+  }
+
+  get CesiumInstance() {
+    return this.Cesium;
+  }
+
+  start(options: ViewRoamOptions) {
+    this.clear();
+    this.options = options;
+    const waypoints = options.waypoints || [];
+    if (waypoints.length < 2) return;
+
+    this._setupEntities(options);
+
+    // Setup Clock
+    this.viewer.clock.startTime = this.startTime.clone();
+    this.viewer.clock.stopTime = this.stopTime.clone();
+    this.viewer.clock.currentTime = this.startTime.clone();
+    this.viewer.clock.clockRange = options.loop ? this.Cesium.ClockRange.LOOP_STOP : this.Cesium.ClockRange.CLAMPED;
+    this.viewer.clock.multiplier = 1;
+    this.viewer.clock.shouldAnimate = true;
+
+    this.viewer.clock.onTick.addEventListener(this.onTick);
+  }
+
+  preview(options: ViewRoamOptions) {
+     this.clear();
+     this.options = options;
+     const waypoints = options.waypoints || [];
+     if (waypoints.length < 2) return;
+     
+     this._setupEntities(options);
+     
+     // Ensure availability logic works without playing
+     // We might want to set clock to start time so user sees the start point
+     // but do NOT start animation
+     // this.viewer.clock.currentTime = this.startTime.clone();
+     // this.viewer.clock.shouldAnimate = false; 
+     // ^ Calling this might disrupt user's current time if they are looking at something else?
+     // Actually, if the path is based on JulianDate.now(), it is in the future relative to when setupEntities is called.
+     // So if the clock is "now", it should be visible.
+  }
+
+  private _setupEntities(options: ViewRoamOptions) {
+    const waypoints = options.waypoints || [];
+
+    // Calculate times and properties
+    const property = new this.Cesium.SampledPositionProperty();
+    const orientationProperty = new this.Cesium.SampledProperty(this.Cesium.Quaternion);
+    
+    // Normalize waypoints to Cartesian3 and Quaternion
+    const points: { position: any; orientation: any }[] = [];
+    
+    for (const w of waypoints) {
+      let position;
+      if (w.destination) {
+        if (w.destination.x !== undefined) {
+           position = new this.Cesium.Cartesian3(w.destination.x, w.destination.y, w.destination.z);
+        } else {
+           position = w.destination;
+        }
+      } else if (w.lon !== undefined && w.lat !== undefined) {
+        position = this.Cesium.Cartesian3.fromDegrees(w.lon, w.lat, w.height ?? 0);
+      }
+
+      let hpr;
+      if (w.orientation) {
+         hpr = new this.Cesium.HeadingPitchRoll(w.orientation.heading, w.orientation.pitch, w.orientation.roll);
+      } else {
+         hpr = this.Cesium.HeadingPitchRoll.fromDegrees(w.heading ?? 0, w.pitch ?? -30, w.roll ?? 0);
+      }
+      const orientation = this.Cesium.Transforms.headingPitchRollQuaternion(position, hpr);
+      points.push({ position, orientation });
+    }
+
+    // Build Time
+    const start = this.Cesium.JulianDate.now();
+    const speed = options.speed || 100; // Default speed if not specified
+    let accTime = 0;
+    const times = [];
+
+    for (let i = 0; i < points.length; i++) {
+      if (i === 0) {
+        times.push(start.clone());
+      } else {
+        const dist = this.Cesium.Cartesian3.distance(points[i-1].position, points[i].position);
+        const duration = dist / Math.max(speed, 0.1);
+        accTime += duration;
+        times.push(this.Cesium.JulianDate.addSeconds(start, accTime, new this.Cesium.JulianDate()));
+      }
+      property.addSample(times[i], points[i].position);
+      orientationProperty.addSample(times[i], points[i].orientation);
+    }
+
+    this.startTime = times[0];
+    this.stopTime = times[times.length - 1];
+
+    // Create Main Entity (Drone)
+    const entityOptions: any = {
+      availability: new this.Cesium.TimeIntervalCollection([
+        new this.Cesium.TimeInterval({ start: this.startTime, stop: this.stopTime }),
+      ]),
+      position: property,
+      orientation: orientationProperty,
+    };
+
+    if (options.modelUrl) {
+      entityOptions.model = {
+        uri: options.modelUrl,
+        scale: options.modelScale ?? 1.0,
+        minimumPixelSize: 64,
+        runAnimations: options.modelAnimate ?? true,
+      };
+    } else {
+      // Invisible point if no model, or maybe a small pixel
+       entityOptions.point = { pixelSize: 1, color: this.Cesium.Color.TRANSPARENT };
+    }
+
+    // Removed entityOptions.path to use static Polyline instead for better visibility
+    if (options.showPath) {
+      this.viewEntities.push(this.viewer.entities.add({
+        polyline: {
+          positions: points.map(p => p.position),
+          width: 3,
+          material: this.Cesium.Color.GREEN,
+          // clampToGround: false
+        }
+      }));
+    }
+
+    this.entity = this.viewer.entities.add(entityOptions);
+
+    // Show Stops (Viewpoint Icons)
+    if (options.showStops) {
+      points.forEach((p, index) => {
+        // Calculate ground position for drop line
+        const carto = this.Cesium.Cartographic.fromCartesian(p.position);
+        const groundPos = this.Cesium.Cartesian3.fromRadians(carto.longitude, carto.latitude, 0);
+
+        this.viewEntities.push(this.viewer.entities.add({
+          position: p.position,
+          point: {
+             pixelSize: 8,
+             color: this.Cesium.Color.YELLOW,
+             outlineColor: this.Cesium.Color.BLACK,
+             outlineWidth: 1
+          },
+          label: {
+            text: '' + (index + 1),
+            font: '12px sans-serif',
+            pixelOffset: new this.Cesium.Cartesian2(0, -15),
+            fillColor: this.Cesium.Color.WHITE,
+            outlineColor: this.Cesium.Color.BLACK,
+            outlineWidth: 2,
+            style: this.Cesium.LabelStyle.FILL_AND_OUTLINE,
+          },
+          polyline: {
+            positions: [p.position, groundPos],
+            width: 2,
+            material: new this.Cesium.PolylineDashMaterialProperty({
+                color: this.Cesium.Color.RED,
+                dashLength: 16
+            })
+          }
+        }));
+      });
+    }
+  }
+
+  private onTick = (clock: any) => {
+    if (!this.options || !this.entity) return;
+    const t = clock.currentTime;
+    
+    // Check bounds
+    if (this.Cesium.JulianDate.lessThan(t, this.startTime) || 
+        this.Cesium.JulianDate.greaterThan(t, this.stopTime)) {
+        if (!this.options.loop && this.Cesium.JulianDate.greaterThan(t, this.stopTime)) {
+             // End
+             if (this.viewer.clock.shouldAnimate) {
+                this.viewer.clock.shouldAnimate = false;
+                if (this.options.onComplete) this.options.onComplete();
+             }
+        }
+        return;
+    }
+
+    const pos = this.entity.position.getValue(t);
+    const ori = this.entity.orientation.getValue(t);
+
+    if (pos && ori) {
+      // Sync Camera
+      // Calculate Heading Pitch Roll from Quaternion
+      // We need to convert the Global Quaternion back to Local HeadingPitchRoll
+      // 1. Create Model Matrix from Position and Orientation
+      const modelMatrix = this.Cesium.Matrix4.fromTranslationQuaternionRotationScale(
+        pos,
+        ori,
+        new this.Cesium.Cartesian3(1, 1, 1),
+        new this.Cesium.Matrix4()
+      );
+
+      // 2. Extract Local HPR
+      const hpr = this.Cesium.Transforms.fixedFrameToHeadingPitchRoll(
+        modelMatrix,
+        this.viewer.scene.globe.ellipsoid,
+        this.Cesium.Transforms.eastNorthUpToFixedFrame,
+        new this.Cesium.HeadingPitchRoll()
+      );
+      
+      this.viewer.camera.setView({
+        destination: pos,
+        orientation: {
+           heading: hpr.heading,
+           pitch: hpr.pitch,
+           roll: hpr.roll
+        }
+      });
+      
+      if (this.options.onTick) this.options.onTick(t, pos, hpr);
+    }
+  }
+
+  stop() {
+    this.viewer.clock.shouldAnimate = false;
+    this.viewer.clock.onTick.removeEventListener(this.onTick);
+  }
+
+  pause() {
+    this.viewer.clock.shouldAnimate = false;
+    this.isPaused = true;
+  }
+
+  resume() {
+    this.viewer.clock.shouldAnimate = true;
+    this.isPaused = false;
+  }
+
+  clear() {
+    this.stop();
+    if (this.entity) {
+      this.viewer.entities.remove(this.entity);
+      this.entity = null;
+    }
+    for (const e of this.viewEntities) {
+      this.viewer.entities.remove(e);
+    }
+    this.viewEntities = [];
+    this.options = null;
+  }
+  
+  // Helper to capture current view in the format we want
+  captureCurrentView(): Waypoint {
+    const destination = this.viewer.camera.position.clone(); // Cartesian3
+    const h = this.viewer.camera.heading;
+    const p = this.viewer.camera.pitch;
+    const r = this.viewer.camera.roll;
+    
+    return {
+      destination: { x: destination.x, y: destination.y, z: destination.z },
+      orientation: { heading: h, pitch: p, roll: r }
+    };
+  }
+
+  // Legacy/Helper methods compatibility if needed, but we are refactoring.
+  // We'll keep minimal interface compliance.
+}

package/plugins/plugins/cesium-core/src/components/roaming/PathRoamTool.ts

@@ -0,0 +1,174 @@
+import { IRoamTool, PathRoamOptions } from './types';
+
+export class PathRoamTool implements IRoamTool {
+  private Cesium: any;
+  private viewer: any;
+  private entity: any = null;
+  private positionProperty: any = null;
+  private startTime: any = null;
+  private stopTime: any = null;
+  private options: PathRoamOptions | null = null;
+  private cameraOffset: any = null;
+
+  constructor({ Cesium, viewer }: { Cesium: any; viewer: any }) {
+    this.Cesium = Cesium;
+    this.viewer = viewer;
+  }
+
+  get Viewer() {
+    return this.viewer;
+  }
+
+  get CesiumInstance() {
+    return this.Cesium;
+  }
+
+  start(options: PathRoamOptions) {
+    this.clear();
+    this.options = options;
+    const positions = this.normalizePositions(options.positions || []);
+    if (!positions.length) return;
+    const speed = options.speed ?? 30;
+    const times = this.buildTimes(positions, speed);
+    const property = new this.Cesium.SampledPositionProperty();
+    for (let i = 0; i < positions.length; i++) {
+      property.addSample(times[i], positions[i]);
+    }
+    this.positionProperty = property;
+    const orientation = new this.Cesium.VelocityOrientationProperty(property);
+    const showPath = options.showPath ?? true;
+    const pathColor = options.pathColor ?? this.Cesium.Color.YELLOW;
+    const pathWidth = options.pathWidth ?? 3;
+    const pointColor = options.pointColor ?? this.Cesium.Color.RED;
+    const pointPixelSize = options.pointPixelSize ?? 8;
+
+    const entityOptions: any = {
+      availability: new this.Cesium.TimeIntervalCollection([
+        new this.Cesium.TimeInterval({ start: this.startTime, stop: this.stopTime }),
+      ]),
+      position: property,
+      orientation,
+      path: showPath ? { material: pathColor, width: pathWidth, leadTime: 0 } : undefined,
+    };
+
+    if (options.modelUrl) {
+      entityOptions.model = {
+        uri: options.modelUrl,
+        scale: options.modelScale ?? 1.0,
+        minimumPixelSize: 64,
+        runAnimations: options.modelAnimate ?? true,
+      };
+    } else {
+      entityOptions.point = { color: pointColor, pixelSize: pointPixelSize };
+    }
+
+    this.entity = this.viewer.entities.add(entityOptions);
+    this.viewer.clock.startTime = this.startTime.clone();
+    this.viewer.clock.stopTime = this.stopTime.clone();
+    this.viewer.clock.currentTime = this.startTime.clone();
+    this.viewer.clock.clockRange = options.loop
+      ? this.Cesium.ClockRange.LOOP_STOP
+      : this.Cesium.ClockRange.CLAMPED;
+    this.viewer.clock.multiplier = 1;
+    this.viewer.clock.shouldAnimate = true;
+    if (options.initialView) {
+      this.viewer.camera.setView({
+        destination: options.initialView.destination,
+        orientation: options.initialView.orientation,
+      });
+      this.cameraOffset = null; // Reset offset
+    } else if (options.followCamera) {
+      this.viewer.trackedEntity = this.entity;
+    } else if (options.lookAtOffset) {
+      this.viewer.camera.lookAt(this.entity.position, options.lookAtOffset);
+    }
+    this.viewer.clock.onTick.addEventListener(this.onTick);
+  }
+
+  stop() {
+    this.viewer.clock.shouldAnimate = false;
+    this.viewer.clock.onTick.removeEventListener(this.onTick);
+    if (this.viewer.trackedEntity === this.entity) this.viewer.trackedEntity = undefined;
+  }
+
+  clear() {
+    this.stop();
+    if (this.entity) {
+      this.viewer.entities.remove(this.entity);
+      this.entity = null;
+    }
+    this.positionProperty = null;
+    this.startTime = null;
+    this.stopTime = null;
+    this.options = null;
+    try {
+      this.viewer.camera.lookAtTransform(this.Cesium.Matrix4.IDENTITY);
+    } catch {}
+  }
+
+  private normalizePositions(arr: Array<[number, number, number?]> | any[]) {
+    const out: any[] = [];
+    for (const p of arr) {
+      if (Array.isArray(p)) {
+        const [lon, lat, height] = p as [number, number, number?];
+        out.push(this.Cesium.Cartesian3.fromDegrees(lon, lat, height ?? 0));
+      } else if (p?.x !== undefined && p?.y !== undefined && p?.z !== undefined) {
+        out.push(p);
+      }
+    }
+    return out;
+  }
+
+  private buildTimes(positions: any[], speed: number) {
+    const times: any[] = [];
+    const start = this.Cesium.JulianDate.now();
+    let acc = 0;
+    for (let i = 0; i < positions.length; i++) {
+      if (i === 0) {
+        times.push(start.clone());
+      } else {
+        const d = this.Cesium.Cartesian3.distance(positions[i - 1], positions[i]);
+        acc += d / Math.max(speed, 0.1);
+        times.push(this.Cesium.JulianDate.addSeconds(start, acc, new this.Cesium.JulianDate()));
+      }
+    }
+    this.startTime = times[0];
+    this.stopTime = times[times.length - 1];
+    return times;
+  }
+
+  private onTick = (clock: any) => {
+    if (!this.options || !this.positionProperty) return;
+    const t = clock.currentTime;
+    const pos = this.positionProperty.getValue(t);
+
+    // Custom Camera Follow Logic (Initial View + Follow)
+    if (this.options.followCamera && this.options.initialView && pos) {
+      if (!this.cameraOffset) {
+        // Calculate offset on first valid position relative to initial view
+        this.cameraOffset = this.Cesium.Cartesian3.subtract(
+          this.options.initialView.destination,
+          pos,
+          new this.Cesium.Cartesian3(),
+        );
+      }
+      const newCamPos = this.Cesium.Cartesian3.add(
+        pos,
+        this.cameraOffset,
+        new this.Cesium.Cartesian3(),
+      );
+      this.viewer.camera.setView({
+        destination: newCamPos,
+        orientation: this.options.initialView.orientation,
+      });
+    }
+
+    if (pos && this.options.onTick) this.options.onTick(t, pos);
+    if (this.Cesium.JulianDate.greaterThanOrEquals(t, this.stopTime)) {
+      if (!this.options.loop) {
+        if (this.options.onComplete) this.options.onComplete();
+        this.stop();
+      }
+    }
+  };
+}

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

@@ -0,0 +1,3 @@
+export { CameraRoamTool } from './CameraRoamTool';
+export { PathRoamTool } from './PathRoamTool';
+export * from './types';

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

@@ -0,0 +1,71 @@
+export type EasingType = 'linear' | 'easeInOut' | ((t: number) => number);
+
+export interface Waypoint {
+  lon?: number;
+  lat?: number;
+  height?: number;
+  destination?: any; // Cartesian3
+  heading?: number;
+  pitch?: number;
+  roll?: number;
+  orientation?: any; // { heading, pitch, roll }
+  duration?: number;
+  transition?: number;
+  stay?: number;
+}
+
+export interface ViewRoamOptions {
+  waypoints: Waypoint[];
+  speed?: number; // Global speed multiplier or m/s
+  startTime?: any;
+  loop?: boolean;
+  showPath?: boolean;
+  showStops?: boolean;
+  modelUrl?: string;
+  modelScale?: number;
+  modelAnimate?: boolean;
+  onWaypoint?: (index: number, waypoint: Waypoint) => void;
+  onComplete?: () => void;
+  onTick?: (time: any, position: any, orientation: any) => void;
+}
+
+export interface ViewRoamConfig {
+  waypoints: Waypoint[];
+  loop?: boolean;
+  easing?: EasingType;
+  transitionMode?: 'flyTo' | 'lerp';
+  fps?: number;
+}
+
+export interface PathRoamOptions {
+  positions: Array<[number, number, number?]> | any[];
+  speed?: number;
+  loop?: boolean;
+  clampToGround?: boolean;
+  followCamera?: boolean;
+  lookAtOffset?: any;
+  showPath?: boolean;
+  pathColor?: any;
+  pathWidth?: number;
+  pointColor?: any;
+  pointPixelSize?: number;
+  modelUrl?: string;
+  modelScale?: number;
+  modelAnimate?: boolean;
+  initialView?: {
+    destination: any;
+    orientation?: {
+      heading: number;
+      pitch: number;
+      roll: number;
+    };
+  };
+  onTick?: (time: any, position: any) => void;
+  onComplete?: () => void;
+}
+
+export interface IRoamTool {
+  start(options: any): void;
+  stop(): void;
+  clear(): void;
+}

package/plugins/plugins/cesium-core/src/components/utils/convertGeoJsonToEntityData.ts

@@ -0,0 +1,98 @@
+export function convertGeoJsonToEntityData(geoJson: any): any[] {
+  const dataList: any[] = [];
+
+  // 遍历 GeoJSON 中的所有特性
+  geoJson.features.forEach((feature: any, index: number) => {
+    if (feature.geometry && feature.properties) {
+      const geometry = feature.geometry;
+      const properties = feature.properties;
+
+      // 初始化数据项
+      const dataItem: any = {
+        id: properties.id || `${Date.now()}`,
+        show: true, // 默认为显示
+        zIndex: properties.zIndex || 1, // 默认为 1
+        name: `${properties.layer}_${index}` || '',
+        billboard: [],
+        polyline: [],
+        wall: [],
+        polygon: [],
+        card: properties.card || null, // 如果存在 card 数据则加入
+      };
+
+      // 根据几何类型转换数据
+      switch (geometry.type) {
+        case 'Point':
+          // 处理 Point 类型
+          dataItem.billboard.push({
+            position: geometry.coordinates, // GeoJSON 的坐标格式 [lon, lat]
+            options: properties, // 可以传递一些附加属性
+            name: `${properties.layer}_${index}`,
+          });
+          break;
+
+        case 'LineString':
+          // 处理 LineString 类型
+          dataItem.polyline.push({
+            positions: geometry.coordinates, // GeoJSON 的坐标数组
+            theme: properties.theme || 'default', // 传递 theme 信息
+          });
+          break;
+
+        case 'Polygon':
+          // 处理 Polygon 类型
+          dataItem.polygon.push({
+            hierarchy: geometry.coordinates[0], // GeoJSON 的多边形坐标数组
+            theme: properties.theme || 'default',
+          });
+          break;
+
+        case 'MultiLineString':
+          // 处理 MultiLineString 类型
+          geometry.coordinates.forEach((line: any[]) => {
+            dataItem.polyline.push({
+              positions: line,
+            });
+          });
+          break;
+
+        case 'MultiPolygon':
+          // 处理 MultiPolygon 类型
+          geometry.coordinates.forEach((polygon: any[]) => {
+            dataItem.polygon.push({
+              hierarchy: polygon[0], // 多个多边形时，取第一个
+            });
+          });
+          break;
+
+        case 'GeometryCollection':
+          // 处理 GeometryCollection 类型（多种几何类型组合）
+          geometry.geometries.forEach((geom: any) => {
+            if (geom.type === 'Point') {
+              dataItem.billboard.push({
+                position: geom.coordinates,
+              });
+            } else if (geom.type === 'LineString') {
+              dataItem.polyline.push({
+                positions: geom.coordinates,
+              });
+            } else if (geom.type === 'Polygon') {
+              dataItem.polygon.push({
+                hierarchy: geom.coordinates[0],
+              });
+            }
+          });
+          break;
+
+        default:
+          console.warn(`Unsupported geometry type: ${geometry.type}`);
+          break;
+      }
+
+      // 将转换后的数据项添加到数据列表
+      dataList.push(dataItem);
+    }
+  });
+
+  return dataList;
+}

package/plugins/plugins/cesium-core/src/components/utils/uuid.ts

@@ -0,0 +1,7 @@
+export function generateUUID() {
+  return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, function (c) {
+    const r = (Math.random() * 16) | 0;
+    const v = c === "x" ? r : (r & 0x3) | 0x8;
+    return v.toString(16);
+  });
+}

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

@@ -0,0 +1,17 @@
+export * from './components/BufferedHierarchicalAggregator';
+export * from './components/HtmlOverlayLabelPool';
+export * from './components/MarkerEvent';
+export { DrawTool } from './components/draw/DrawTool';
+export { TooltipManager } from './components/TooltipManager';
+export * from './components/gltf/index';
+export {
+  MaterialManager,
+  getDynamicImgMaterial,
+  getPolylineFlowMaterialProperty,
+  getWallMaterial,
+} from './components/Material/index';
+export { EntityLayerManager } from './components/entity/EntityLayer';
+export { convertGeoJsonToEntityData } from './components/utils/convertGeoJsonToEntityData';
+export { PrimitiveManager } from './components/primitive/PrimitiveManager';
+export * from './components/measurement/index';
+export * from './components/roaming/index';