leiting-bim 2.1.35 → 2.1.37

package/plugins/cesium-core/src/components/primitive/PrimitiveManager.ts

@@ -0,0 +1,556 @@
+import { EntityLayerManager } from '../entity/EntityLayer';
+import { MaterialManager } from '../Material/MaterialManager';
+import { cloneDeep } from 'lodash-es';
+export class PrimitiveManager {
+  private Cesium: any;
+  private viewer: any; // Cesium.Viewer
+  private layerMap: Map<string, Map<string, any>>;
+  private hideLayerMap: Map<string, Set<string>>;
+  entityLayerManager: EntityLayerManager;
+  private PrimitiveThemeMap: Map<
+    string,
+    {
+      Primitive: any;
+      ids: Map<string, any>;
+      geometryInstances: Map<string, any>;
+      appearance: any;
+    }
+  >; // theme -> 合并后的 Primitive 和图元 ID 的映射
+  materialManager: MaterialManager;
+
+  constructor(options: {
+    Cesium: any;
+    viewer: any;
+    materialManager: MaterialManager;
+    entityLayerManager: EntityLayerManager;
+  }) {
+    let { Cesium, viewer, materialManager, entityLayerManager } = options;
+    this.Cesium = Cesium;
+    this.viewer = viewer;
+    this.layerMap = new Map();
+    this.PrimitiveThemeMap = new Map(); // 存储 theme -> { Primitive, ids, geometryInstances }
+    this.hideLayerMap = new Map();
+    this.materialManager = materialManager;
+    this.entityLayerManager = entityLayerManager;
+  }
+
+  //创建图元
+  private createGeometryInstance(item: any): any {
+    let geometryInstance: any;
+    if (item.category === 'polyline' && item.positions) {
+      geometryInstance = this.createPolyline(item);
+    } else if (item.category === 'polygon' && item.hierarchy) {
+      geometryInstance = this.createPolygon(item);
+    }
+    return geometryInstance;
+  }
+
+  // 创建或获取 材质图元组
+  private carateThemePrimitive(_item: any) {
+    let item = cloneDeep(_item);
+    let themePrimitive = this.PrimitiveThemeMap.get(item.theme);
+    if (!themePrimitive) {
+      this.initTheme(item);
+      // 如果没有，则初始化一个新的 entry
+      let appearance = this.createAppearance(item);
+      themePrimitive = {
+        Primitive: null,
+        ids: new Map(),
+        appearance: appearance,
+        geometryInstances: new Map(),
+      };
+      this.PrimitiveThemeMap.set(item.theme, themePrimitive);
+    }
+    return themePrimitive;
+  }
+
+  //注册主题
+  initTheme(item: any) {
+    let materialManager = this.materialManager;
+    let Cesium = this.Cesium;
+    if (item.category == 'polyline') {
+      const isDashed =
+        item.properties?.lineType?.pattern && item.properties?.lineType?.patternLength;
+      let lineMaterialKey = '';
+      if (isDashed) {
+        const dashPattern = item.properties?.lineType?.pattern || [0.25, -0.125];
+        const dashLength = item.properties?.lineType?.patternLength || 0.375;
+        let cesiumDash = this.convertCadPatternToCesiumDash(dashPattern, dashLength);
+        lineMaterialKey = `DashedLineMaterial_pattern_${cesiumDash.dashPattern}_dashLength_${cesiumDash.dashLength}_color_${item.properties?.color}`;
+        if (!materialManager.has(lineMaterialKey)) {
+          materialManager.register({
+            themeKey: lineMaterialKey,
+            material: Cesium.Material.fromType('PolylineDash', {
+              color: Cesium.Color.fromCssColorString(item.properties.color || '#FFFFFF').withAlpha(
+                0.8,
+              ),
+              dashLength: cesiumDash.dashLength, // ← 注意，这里填总长度
+              dashPattern: cesiumDash.dashPattern, // ← 这里才是 16-bit 掩码
+            }),
+          });
+        }
+      } else {
+        lineMaterialKey = `LineMaterial_color_${item.properties?.color}`;
+        if (!materialManager.has(lineMaterialKey)) {
+          materialManager.register({
+            themeKey: lineMaterialKey,
+            material: Cesium.Material.fromType('Color', {
+              color: Cesium.Color.fromCssColorString(item.properties.color || '#FFFFFF').withAlpha(
+                0.8,
+              ),
+            }),
+          });
+        }
+      }
+    } else if (item.category == 'polygon') {
+      let polygonMaterialKey = `polygonMaterial_color_${item.properties?.color}`;
+      if (!materialManager.has(polygonMaterialKey)) {
+        materialManager.register({
+          themeKey: polygonMaterialKey,
+          material: Cesium.Material.fromType('Color', {
+            color: Cesium.Color.fromCssColorString(item.properties?.color || '#FFFFFF').withAlpha(
+              0.8,
+            ),
+          }),
+        });
+      }
+    }
+  }
+
+  convertCadPatternToCesiumDash(pattern: Array<number>, patternLength: number) {
+    const segmentCount = 16;
+    const unitLength = patternLength / segmentCount;
+
+    // 第一步：先用 floor 分配位数，统计已经分配的位数
+    let dashBits = [] as Array<number>;
+    let assigned = 0;
+    for (let len of pattern) {
+      const count = Math.floor(Math.abs(len) / unitLength);
+      const bit = len >= 0 ? 1 : 0;
+      for (let i = 0; i < count; i++) {
+        dashBits.push(bit);
+        assigned++;
+        if (assigned >= segmentCount) break;
+      }
+      if (assigned >= segmentCount) break;
+    }
+
+    // 如果分配不到 16 位，用 “空” 填满；如果多了，则截断
+    while (dashBits.length < segmentCount) {
+      dashBits.push(0);
+    }
+    if (dashBits.length > segmentCount) {
+      dashBits.length = segmentCount;
+    }
+
+    // 第二步：把 16 位数组变成一个整数
+    let dashPattern = 0;
+    for (let i = 0; i < segmentCount; i++) {
+      dashPattern = (dashPattern << 1) | dashBits[i];
+    }
+
+    return {
+      dashPattern: dashPattern,
+      dashLength: patternLength,
+    };
+  }
+
+  // 创建或更新图层并添加几何体
+  public async processBatch(data: Array<{ layerId: string; dataList: any[] }>): Promise<void> {
+    const materialThemes = new Map(); // 用于记录所有出现的材质 theme
+    data.forEach((item) => {
+      let { layerId, dataList } = item;
+      let batch = cloneDeep(dataList);
+      batch.forEach((item) => {
+        let geometryInstance = this.createGeometryInstance(item);
+
+        if (geometryInstance) {
+          // 检查是否已有相同 theme 的 Primitive
+          let themePrimitive = this.carateThemePrimitive(item);
+
+          // 将当前 item 的 id 添加到 themePrimitive.ids 中
+          themePrimitive.ids.set(item.id, item);
+          themePrimitive.geometryInstances.set(item.id, geometryInstance); // 添加到几何实例集合中
+
+          const layer = this.layerMap.get(layerId);
+          if (layer) {
+            layer.set(item.id, item);
+          } else {
+            let map = new Map();
+            this.layerMap.set(layerId, map);
+            map.set(item.id, item);
+          }
+
+          // 记录 materialTheme
+          materialThemes.set(item.theme, item);
+        }
+      });
+    });
+    // 循环结束后，统一调用 updatePrimitive
+    materialThemes.forEach((item) => {
+      this.updatePrimitive(item);
+    });
+  }
+
+  // 创建折线几何体（不再获取材质）
+  private createPolyline(item: any): any {
+    const positions = Array.isArray(item.positions[0]) ? item.positions.flat() : item.positions;
+    return new this.Cesium.GeometryInstance({
+      id: item.id,
+      geometry: new this.Cesium.GroundPolylineGeometry({
+        positions: this.Cesium.Cartesian3.fromDegreesArrayHeights(positions),
+        // width: 10,
+        width: Math.max(item.width || 2, 2),
+      }),
+    });
+  }
+
+  // 创建多边形几何体（不再获取材质）
+  private createPolygon(item: any): any {
+    const outerRing = Array.isArray(item.hierarchy[0]) ? item.hierarchy.flat() : item.hierarchy;
+    const outerCartesian = this.Cesium.Cartesian3.fromDegreesArrayHeights(outerRing);
+    const holes =
+      item.holes?.map((hole: any) => {
+        let _hole = Array.isArray(hole[0]) ? hole.flat() : hole;
+        let _holeDegrees = this.Cesium.Cartesian3.fromDegreesArrayHeights(_hole.flat());
+        return new this.Cesium.PolygonHierarchy(_holeDegrees);
+      }) || [];
+
+    const polygonHierarchy = new this.Cesium.PolygonHierarchy(outerCartesian, holes);
+
+    return new this.Cesium.GeometryInstance({
+      id: item.id,
+      geometry: new this.Cesium.PolygonGeometry({
+        polygonHierarchy: polygonHierarchy,
+      }),
+    });
+  }
+
+  // 获取材质（在 updatePrimitive 中处理）
+  private getMaterial(item: any): any {
+    let material = this.materialManager.get({
+      themeKey: item.theme,
+      options: item,
+    });
+
+    if (!material) {
+      material = this.Cesium.Material.fromType('Color', {
+        color: new this.Cesium.Color(1.0, 0.0, 0.0, 1.0), // 默认红色
+      });
+    }
+
+    return material;
+  }
+
+  // 更新图元
+  public updateGeometryInstance(_item: any): void {
+    let item = cloneDeep(_item);
+
+    const layer = this.layerMap.get(item.layerId);
+    if (!layer) {
+      console.warn(`没有找到图层 ${item.layerId}`);
+      return;
+    }
+
+    let geometryInstanceInfo = layer.get(item.id);
+    layer.set(item.id, item);
+    if (!geometryInstanceInfo) {
+      console.warn(`没有找到图元 ${item.id} 在图层 ${item.layerId} 中`);
+      return;
+    }
+    if (geometryInstanceInfo.theme !== item.theme) {
+      //更新旧的主题
+      let oldThemePrimitive = this.PrimitiveThemeMap.get(geometryInstanceInfo.theme);
+      oldThemePrimitive?.geometryInstances.delete(item.id);
+      oldThemePrimitive?.ids.delete(item.id);
+      this.updatePrimitive(geometryInstanceInfo);
+    }
+    //更新新的主题
+    let themePrimitive = this.carateThemePrimitive(item);
+    if (themePrimitive) {
+      const geometryInstance = this.createGeometryInstance(item);
+      themePrimitive.geometryInstances.set(item.id, geometryInstance);
+      themePrimitive.ids.set(item.id, item);
+      // 调用更新图元的方法
+      this.updatePrimitive(item);
+    }
+  }
+
+  // 删除图元
+  public deleteGeometryInstance(data: Array<{ layerId: string; ids: string[] }>): void {
+    let themeMap = new Set();
+    data.forEach((item) => {
+      let { layerId, ids } = item;
+      const layer = this.layerMap.get(layerId);
+      if (!layer) {
+        console.warn(`没有找到图层 ${layerId}`);
+        return;
+      }
+      ids.forEach((id) => {
+        let geometryInstanceInfo = layer.get(id);
+
+        if (!geometryInstanceInfo) {
+          console.warn(`没有找到图元 ${id} 在图层 ${layerId} 中`);
+          return;
+        }
+
+        //更新新的主题
+        let themePrimitive = this.PrimitiveThemeMap.get(geometryInstanceInfo.theme);
+        if (themePrimitive) {
+          themePrimitive.geometryInstances.delete(geometryInstanceInfo.id);
+          themePrimitive.ids.delete(geometryInstanceInfo.id);
+          // 调用更新图元的方法
+          themeMap.add(geometryInstanceInfo);
+        }
+      });
+    });
+    Array.from(themeMap.values()).forEach((item) => {
+      this.updatePrimitive(item);
+    });
+  }
+  // 添加图元
+  public addGeometryInstance(_item: any): void {
+    let item = cloneDeep(_item);
+
+    const layer = this.layerMap.get(item.layerId);
+    if (!layer) {
+      console.warn(`没有找到图层 ${item.layerId}`);
+      return;
+    }
+
+    let geometryInstanceInfo = layer.get(item.id);
+
+    if (geometryInstanceInfo) {
+      console.warn(`图元 ${item.id} 已经存在图层 ${item.layerId} 中`);
+      return;
+    }
+    layer.set(item.id, item);
+    //更新新的主题
+    let themePrimitive = this.carateThemePrimitive(item);
+    if (themePrimitive) {
+      const geometryInstance = this.createGeometryInstance(item);
+      themePrimitive.geometryInstances.set(item.id, geometryInstance);
+      themePrimitive.ids.set(item.id, item);
+      // 调用更新图元的方法
+      this.updatePrimitive(item);
+    }
+  }
+
+  // 创建外观
+  private createAppearance(item: any) {
+    let material = this.getMaterial({ theme: item.theme });
+    let appearance;
+    if (item.category === 'polyline') {
+      appearance = new this.Cesium.PolylineMaterialAppearance({
+        material: material, // 传入材质
+        translucent: true,
+      });
+    } else if (item.category === 'polygon') {
+      appearance = new this.Cesium.MaterialAppearance({
+        material: material,
+        translucent: true,
+      });
+    }
+    return appearance;
+  }
+
+  // 根据 theme 更新对应的 Primitive
+  private updatePrimitive(item: any): void {
+    const themePrimitive = this.PrimitiveThemeMap.get(item.theme);
+    if (!themePrimitive) {
+      return;
+    }
+
+    // 如果当前没有创建 Primitive，则创建新的
+    if (themePrimitive.Primitive) {
+      this.viewer.scene.primitives.remove(themePrimitive.Primitive);
+      themePrimitive.Primitive = null;
+    }
+    // 更新已存在的 Primitive
+    let arrayFromMap = Array.from(themePrimitive.geometryInstances, ([key, value]) => ({
+      key,
+      value,
+    }));
+    // let layer = this.hideLayerMap.get(item.layerId);
+    let geometryInstances = arrayFromMap
+      .filter((n) => {
+        return !Array.from(this.hideLayerMap.values()).some((layer) => layer.has(n.key));
+      })
+      .map((n) => {
+        return n.value;
+      });
+    if (geometryInstances.length <= 0) return;
+    if (item.category === 'polyline') {
+      themePrimitive.Primitive = new this.Cesium.GroundPolylinePrimitive({
+        geometryInstances: geometryInstances, // 使用所有的 GeometryInstance
+        appearance: themePrimitive.appearance,
+      });
+      this.viewer.scene.primitives.add(themePrimitive.Primitive); // 添加到场景
+    } else {
+      themePrimitive.Primitive = new this.Cesium.GroundPrimitive({
+        geometryInstances: geometryInstances, // 使用所有的 GeometryInstance
+        appearance: themePrimitive.appearance,
+      });
+
+      this.viewer.scene.primitives.add(themePrimitive.Primitive); // 添加到场景
+    }
+  }
+
+  //隐藏
+  public hideByLayerAndId(data: Array<{ layerId: string; ids: string[] }>) {
+    let themeMap = new Map();
+
+    data.forEach((item) => {
+      let { layerId, ids } = item;
+      let layer = this.hideLayerMap.get(layerId);
+      if (!layer) {
+        layer = new Set();
+        this.hideLayerMap.set(layerId, layer);
+      }
+      ids.forEach((value) => {
+        layer.add(value);
+        let info = this.getGeometryInstanceInfo(layerId, value);
+        if (info) themeMap.set(info.theme, info);
+      });
+    });
+    Array.from(themeMap.values()).forEach((item) => {
+      this.updatePrimitive(item);
+    });
+  }
+
+  //显示
+  public showByLayerAndId(data: Array<{ layerId: string; ids: string[] }>) {
+    let themeMap = new Map();
+    data.forEach((item) => {
+      let { layerId, ids } = item;
+      let layer = this.hideLayerMap.get(layerId);
+      if (!layer) {
+        layer = new Set();
+        this.hideLayerMap.set(layerId, layer);
+      }
+      ids.forEach((value) => {
+        layer.delete(value);
+        let info = this.getGeometryInstanceInfo(layerId, value);
+        if (info) themeMap.set(info.theme, info);
+      });
+    });
+    Array.from(themeMap.values()).forEach((item) => {
+      this.updatePrimitive(item);
+    });
+  }
+
+  //查询是否存在图元
+  public hasGeometryInstance(layerId: string, id: string) {
+    // 获取图层
+    const layer = this.layerMap.get(layerId);
+    if (!layer) {
+      return false;
+    }
+
+    // 获取图元
+    const geometryInstanceInfo = layer.get(id);
+    if (!geometryInstanceInfo) {
+      return false;
+    }
+
+    let themePrimitive = this.PrimitiveThemeMap.get(geometryInstanceInfo.theme);
+    if (!themePrimitive) {
+      return false;
+    }
+    // 获取图元的几何体
+    const geometryInstance = themePrimitive.geometryInstances.get(id);
+    if (!geometryInstance) {
+      return false;
+    }
+
+    return true;
+  }
+
+  //查询图元信息
+  public getGeometryInstanceInfo(layerId: string, id: string) {
+    // 获取图层
+    const layer = this.layerMap.get(layerId);
+    if (!layer) {
+      return null;
+    }
+
+    // 获取图元
+    const geometryInstanceInfo = layer.get(id);
+    return geometryInstanceInfo;
+  }
+
+  public focusOnGeometryInstance(layerId: string, id: string): void {
+    // 获取图层
+    const layer = this.layerMap.get(layerId);
+    if (!layer) {
+      console.warn(`图层 ${layerId} 不存在`);
+      return;
+    }
+
+    // 获取图元
+    const geometryInstanceInfo = layer.get(id);
+    if (!geometryInstanceInfo) {
+      console.warn(`没有找到图元 ${id} 在图层 ${layerId} 中`);
+      return;
+    }
+
+    let themePrimitive = this.PrimitiveThemeMap.get(geometryInstanceInfo.theme);
+    if (!themePrimitive) {
+      console.warn(`没有找到 ${id} 图元相关的Primitive`);
+      return;
+    }
+    // 获取图元的几何体
+    const geometryInstance = themePrimitive.geometryInstances.get(id);
+    if (!geometryInstance) {
+      console.warn(`没有找到图元的几何体 ${id}`);
+      return;
+    }
+
+    const geometry = geometryInstance.geometry;
+    const positions = geometry._positions || geometry._polygonHierarchy.positions;
+
+    if (positions && positions.length > 0) {
+      // 计算包围盒的最小和最大点
+      let minX = positions[0].x,
+        minY = positions[0].y,
+        minZ = positions[0].z;
+      let maxX = positions[0].x,
+        maxY = positions[0].y,
+        maxZ = positions[0].z;
+
+      positions.forEach((position: any) => {
+        minX = Math.min(minX, position.x);
+        minY = Math.min(minY, position.y);
+        minZ = Math.min(minZ, position.z);
+
+        maxX = Math.max(maxX, position.x);
+        maxY = Math.max(maxY, position.y);
+        maxZ = Math.max(maxZ, position.z);
+      });
+
+      // 计算包围盒的中心和尺寸
+      const center = new this.Cesium.Cartesian3(
+        (minX + maxX) / 2,
+        (minY + maxY) / 2,
+        (minZ + maxZ) / 2,
+      );
+      const dimensions = new this.Cesium.Cartesian3(maxX - minX, maxY - minY, maxZ - minZ);
+
+      // 计算偏移量（使用包围盒的高度作为偏移）
+      const height = dimensions.z; // 高度对应 Z 轴
+      const offsetHeight = Math.abs(height || 1) * 1.5; // 使用包围盒高度的 1.5 倍作为偏移量
+
+      // 使用摄像机平滑定位到包围盒中心
+      this.viewer.camera.flyTo({
+        destination: center,
+        duration: 2, // 平滑移动的持续时间（秒）
+        complete: () => {
+          console.log(`已定位到图元 ${id}`);
+        },
+        offset: new this.Cesium.Cartesian3(0, 0, offsetHeight), // 使用动态计算的偏移高度
+      });
+    } else {
+      console.warn(`无法获取图元 ${id} 的顶点信息`);
+    }
+  }
+}