leiting-bim 2.1.35 → 2.1.37

package/plugins/plugins/cesium-core/src/components/entity/EntityLayer.ts

@@ -0,0 +1,453 @@
+import { BufferedHierarchicalAggregator } from '../BufferedHierarchicalAggregator';
+import { HtmlOverlayLabelPool } from '../HtmlOverlayLabelPool';
+import { MarkerEventKey } from '../MarkerEvent';
+import { MaterialManager } from '../Material/MaterialManager';
+
+interface EntityGroupOptions {
+  id: string;
+  entities?: any[]; // 默认值为空数组
+  primitives?: any[]; // 默认值为空数组
+  dataItem?: any; // 默认值为空对象
+  aggregator?: BufferedHierarchicalAggregator;
+  cardPool: HtmlOverlayLabelPool;
+}
+
+export class EntityGroup {
+  id: string;
+  entities: any[] = [];
+  primitives: any[] = [];
+  dataItem: any = {};
+  aggregator?: BufferedHierarchicalAggregator;
+  cardPool: HtmlOverlayLabelPool;
+
+  constructor(options: EntityGroupOptions) {
+    // 从 options 中解构参数并设置默认值
+    const { id, entities = [], primitives = [], dataItem = {}, aggregator, cardPool } = options;
+
+    this.id = id;
+    this.entities = entities;
+    this.primitives = primitives;
+    this.dataItem = dataItem;
+    this.aggregator = aggregator;
+    this.cardPool = cardPool;
+  }
+
+  // 改造 setVisible 方法，支持 Entity 和 Primitive 的可见性控制
+  setVisible(visible: boolean) {
+    // 控制 Cesium 原生实体
+    this.entities.forEach((entity) => {
+      if (entity) {
+        entity.show = visible;
+      }
+    });
+
+    // 控制 Cesium 原生 Primitive
+    this.primitives.forEach((primitive) => {
+      if (primitive) {
+        primitive.show = visible;
+      }
+    });
+
+    // 控制 billboard 聚合点（通过 aggregator）
+    if (this.aggregator && Array.isArray(this.dataItem.billboard)) {
+      const updated = this.dataItem.billboard.map((bill: any, index: number) => {
+        const id = this.dataItem.id;
+        return {
+          id,
+          data: {
+            ...this.dataItem,
+            show: visible && (bill.data?.show ?? true),
+          },
+        };
+      });
+      updated.forEach((p: any) => {
+        this.aggregator?.updatePoint(p);
+      });
+    }
+
+    // 控制 HTML 标签池
+    if (this.cardPool && this.dataItem.card) {
+      visible
+        ? this.cardPool.showByIds([this.dataItem.id])
+        : this.cardPool.hideByIds([this.dataItem.id]);
+    }
+  }
+
+  // 改造 removeAll 方法，支持 Entity 和 Primitive 的移除
+  removeAll(viewer: any, immediately = true) {
+    // 移除 Entity
+    this.entities.forEach((entity) => {
+      if (entity) viewer.entities.remove(entity);
+    });
+    this.entities = [];
+
+    // 移除 Primitive
+    this.primitives.forEach((primitive) => {
+      if (primitive) viewer.scene.primitives.remove(primitive);
+    });
+    this.primitives = [];
+
+    // 移除 billboard 聚合点
+    if (immediately && this.aggregator && Array.isArray(this.dataItem.billboard)) {
+      this.aggregator.removePointsById([this.dataItem.id]);
+    }
+
+    // 移除 HTML 标签池中的卡片
+    if (immediately && this.cardPool && this.dataItem.card) {
+      this.cardPool.removeByIds([this.dataItem.id]);
+    }
+
+    return this.dataItem.id;
+  }
+}
+
+export class EntityLayer {
+  id: string;
+  groupMap: Map<string, EntityGroup> = new Map();
+  Cesium: any;
+  viewer: any;
+  materialManager: MaterialManager;
+  aggregator: BufferedHierarchicalAggregator;
+  cardPool: HtmlOverlayLabelPool;
+  constructor(
+    id: string,
+    Cesium: any,
+    viewer: any,
+    materialManager: MaterialManager,
+    aggregator: BufferedHierarchicalAggregator,
+    cardPool: HtmlOverlayLabelPool,
+  ) {
+    this.id = id;
+    this.Cesium = Cesium;
+    this.viewer = viewer;
+    this.materialManager = materialManager;
+    this.aggregator = aggregator;
+    this.cardPool = cardPool;
+
+    this.aggregator.labelPool.eventBus.addListener(MarkerEventKey.Click, {
+      name: 'BufferedHierarchicalAggregator_maker_click',
+      fn: (info, e) => {
+        this.cardPool.showByIds([info.data.id]);
+      },
+    });
+
+    const handler = new Cesium.ScreenSpaceEventHandler(viewer.scene.canvas);
+
+    handler.setInputAction(() => {
+      this.cardPool.hideFilter((data) => {
+        if (data.initShow) return false;
+        return true;
+      });
+    }, Cesium.ScreenSpaceEventType.LEFT_CLICK);
+  }
+
+  /** ====== 下面是抽出的创建函数 ====== */
+  private createPolyline(line: any, show: boolean) {
+    if (!line.positions || line.positions.length < 1) return null;
+    const material = this.materialManager.get({
+      themeKey: line.theme,
+      category: 'polyline',
+      options: line,
+    });
+    const positions = Array.isArray(line.positions[0]) ? line.positions.flat() : line.positions;
+    let opt = {
+      ...line,
+    };
+    if (material) opt.material = material;
+    return this.viewer.entities.add({
+      polyline: {
+        ...opt,
+        positions: this.Cesium.Cartesian3.fromDegreesArrayHeights(positions),
+      },
+      show: (line.show ?? true) && show,
+    });
+  }
+
+  private createWall(wall: any, show: boolean) {
+    if (!wall.positions || wall.positions.length < 1) return null;
+    const material = this.materialManager.get({
+      themeKey: wall.theme,
+      category: 'wall',
+      options: wall,
+    });
+
+    const minHeights =
+      wall.positions.length === wall.minimumHeights?.length
+        ? wall.minimumHeights.map((n: any) => n - Number(wall.minHeight || 0))
+        : wall.positions.map((n: any) => (n[2] || 0) - Number(wall.minHeight || 0));
+
+    const maxHeights =
+      wall.positions.length === wall.maximumHeights?.length
+        ? wall.maximumHeights.map((n: any) => n + Number(wall.maxHeight || 0))
+        : wall.positions.map((n: any) => (n[2] || 0) + Number(wall.maxHeight || 0));
+
+    const pos = wall.positions.map((p: any) =>
+      this.Cesium.Cartesian3.fromDegrees(p[0], p[1], p[2] || 0),
+    );
+    let opt = {
+      ...wall,
+    };
+    if (material) opt.material = material;
+    return this.viewer.entities.add({
+      wall: {
+        ...opt,
+        positions: pos,
+        minimumHeights: minHeights,
+        maximumHeights: maxHeights,
+      },
+      show: (wall.show ?? true) && show,
+    });
+  }
+
+  private createPolygon(poly: any, show: boolean) {
+    // 确保多边形数据有效
+    if (!poly.hierarchy || poly.hierarchy.length < 1) return null;
+
+    // 获取材质
+    const material = this.materialManager.get({
+      themeKey: poly.theme,
+      category: 'polygon',
+      options: poly,
+    });
+
+    // 处理外环（外环是第一个元素）
+    const outerRing = Array.isArray(poly.hierarchy[0]) ? poly.hierarchy.flat() : poly.hierarchy;
+    const outerCartesian = this.Cesium.Cartesian3.fromDegreesArrayHeights(outerRing);
+
+    // 处理孔数据（如果有孔数据）
+    const holes =
+      poly.holes?.map((hole: any) => {
+        let _hole = Array.isArray(hole[0]) ? poly.hierarchy.flat() : poly.hole;
+        return this.Cesium.Cartesian3.fromDegreesArrayHeights(_hole.flat());
+      }) || [];
+
+    // 使用 PolygonHierarchy 来构建多边形
+    const polygonHierarchy = new this.Cesium.PolygonHierarchy(outerCartesian, holes);
+    let opt = {
+      ...poly,
+    };
+    if (material) opt.material = material;
+    // 创建并返回实体
+    return this.viewer.entities.add({
+      polygon: {
+        ...opt,
+        hierarchy: polygonHierarchy, // 使用构建好的 PolygonHierarchy
+      },
+      show: (poly.show ?? true) && show,
+    });
+  }
+
+  private createBillboardPoints(dataItem: any) {
+    if (!dataItem.billboard?.length || !this.aggregator) return [];
+    return dataItem.billboard.map((bill: any) => {
+      const [lon, lat, height = 0] = bill.position || [0, 0, 0];
+      return {
+        id: dataItem.id,
+        lon,
+        lat,
+        height,
+        name: bill.options?.text || '',
+        data: dataItem,
+        style: { zIndex: dataItem.zIndex || '1' },
+      };
+    });
+  }
+
+  private createCard(dataItem: any) {
+    if (!dataItem.card?.data?.length) return;
+    this.cardPool.add(dataItem.card, {
+      id: dataItem.id,
+      lon: dataItem.card.position[0],
+      lat: dataItem.card.position[1],
+      height: dataItem.card.position[3] || 0,
+      theme: dataItem.card.theme,
+      show: dataItem.show ? (dataItem.card.initShow ?? false) : false,
+      notCreateElement: true,
+      style: { width: '0', height: '0', zIndex: dataItem?.card?.zIndex || '110' },
+    });
+  }
+
+  /** ====== 主入口：仅保留循环，内部调用独立函数 ====== */
+  addGroup(dataItem: any, isAppendPoints = true) {
+    const groupId = dataItem.id || `${Date.now()}`;
+    this.removeGroup(groupId);
+    const entities: any[] = [];
+    const show = dataItem.show !== false;
+
+    (dataItem.polyline || []).forEach((l: any) => {
+      const e = this.createPolyline(l, show);
+      if (e) entities.push(e);
+    });
+
+    (dataItem.wall || []).forEach((w: any) => {
+      const e = this.createWall(w, show);
+      if (e) entities.push(e);
+    });
+
+    (dataItem.polygon || []).forEach((p: any) => {
+      const e = this.createPolygon(p, show);
+      if (e) entities.push(e);
+    });
+
+    const pointList = this.createBillboardPoints(dataItem);
+    if (pointList.length && isAppendPoints) this.aggregator.appendPoints(pointList, false);
+
+    this.createCard(dataItem);
+
+    const group = new EntityGroup({
+      id: groupId,
+      entities,
+      primitives: [],
+      dataItem,
+      aggregator: this.aggregator,
+      cardPool: this.cardPool,
+    });
+    this.groupMap.set(groupId, group);
+    return pointList;
+  }
+
+  async addGroups(dataItemList: any) {
+    let dataLists = dataItemList.map((dataItem: any) => {
+      return this.addGroup(dataItem, false);
+    });
+
+    // 拉平二维数组
+    const allPoints = dataLists.flat();
+    if (allPoints.length > 0 && this.aggregator) {
+      this.aggregator.appendPoints(allPoints, false);
+    }
+  }
+
+  removeGroup(groupId: string) {
+    const group = this.groupMap.get(groupId);
+    if (group) {
+      group.removeAll(this.viewer);
+      this.groupMap.delete(groupId);
+    }
+  }
+  removeGroups(groupIds: string[]) {
+    let ids = [];
+    for (const groupId of groupIds) {
+      const group = this.groupMap.get(groupId);
+      if (group) {
+        let id = group.removeAll(this.viewer, false);
+        this.groupMap.delete(groupId);
+        ids.push(id);
+      }
+    }
+    this.aggregator.removePointsById(ids);
+    this.cardPool.removeByIds(ids);
+  }
+  updateGroup(dataItem: any) {
+    const group = this.groupMap.get(dataItem.id);
+    if (group) {
+      group.removeAll(this.viewer);
+      this.groupMap.delete(dataItem.id);
+    }
+    this.addGroup(dataItem);
+  }
+
+  async updateGroups(dataItemList: Array<any>) {
+    this.aggregator.removePointsById(dataItemList.map((n: any) => n.id));
+    this.cardPool.removeByIds(dataItemList.map((n: any) => n.id));
+    let dataLists = dataItemList.map((dataItem: any) => {
+      const group = this.groupMap.get(dataItem.id);
+      if (group) {
+        group.removeAll(this.viewer, false);
+        this.groupMap.delete(dataItem.id);
+      }
+      return this.addGroup(dataItem, false);
+    });
+
+    // 拉平二维数组
+    const allPoints = dataLists.flat();
+    if (allPoints.length > 0 && this.aggregator) {
+      this.aggregator.appendPoints(allPoints, false);
+    }
+  }
+
+  setGroupVisible(groupId: string, visible: boolean) {
+    this.groupMap.get(groupId)?.setVisible(visible);
+  }
+
+  clearAllGroups() {
+    this.groupMap.forEach((group) => group.removeAll(this.viewer));
+    this.groupMap.clear();
+  }
+}
+
+export class EntityLayerManager {
+  Cesium: any;
+  viewer: any;
+  layerMap: Map<string, EntityLayer> = new Map();
+  materialManager: MaterialManager;
+  aggregator: BufferedHierarchicalAggregator;
+  cardPool: HtmlOverlayLabelPool;
+  constructor(
+    Cesium: any,
+    viewer: any,
+    materialManager: MaterialManager,
+    aggregator: BufferedHierarchicalAggregator,
+    cardPool: HtmlOverlayLabelPool,
+  ) {
+    this.Cesium = Cesium;
+    this.viewer = viewer;
+    this.materialManager = materialManager;
+    this.aggregator = aggregator;
+    this.cardPool = cardPool;
+  }
+
+  addLayer(layerId: string) {
+    if (!this.layerMap.has(layerId)) {
+      this.layerMap.set(
+        layerId,
+        new EntityLayer(
+          layerId,
+          this.Cesium,
+          this.viewer,
+          this.materialManager,
+          this.aggregator,
+          this.cardPool,
+        ),
+      );
+    }
+  }
+
+  removeLayer(layerId: string) {
+    const layer = this.layerMap.get(layerId);
+    if (layer) {
+      layer.clearAllGroups();
+      this.layerMap.delete(layerId);
+    }
+  }
+
+  getLayer(layerId: string): EntityLayer | undefined {
+    return this.layerMap.get(layerId);
+  }
+
+  async addGroupsToLayer(layerId: string, dataList: any[]) {
+    const layer = this.layerMap.get(layerId);
+    if (!layer) return;
+    // dataList.forEach((data) => layer.addGroup(data));
+    layer.addGroups(dataList);
+    this.aggregator.refresh();
+  }
+  updateGroupToLayer(layerId: string, dataList: any[]) {
+    const layer = this.layerMap.get(layerId);
+    if (!layer) return;
+
+    layer.updateGroups(dataList);
+    this.aggregator.refresh();
+  }
+
+  setGroupVisible(layerId: string, groupId: string, visible: boolean) {
+    this.layerMap.get(layerId)?.setGroupVisible(groupId, visible);
+  }
+
+  removeGroup(layerId: string, groupId: string) {
+    this.layerMap.get(layerId)?.removeGroup(groupId);
+  }
+  removeGroups(layerId: string, groupIds: string[]) {
+    this.layerMap.get(layerId)?.removeGroups(groupIds);
+  }
+}