航点列表 中化建 右侧联动 待测试联调

jihongshun

3 天以前 71627d89045c5bf3c50030751d93ae519f5dbb8d

 src/views/system/shootPoint/components/shootPointDialog.vue

@@ -12,29 +12,76 @@
                <div class="chooseModel">
                  <el-button type="primary" @click='chooseModel'>选择模型</el-button>
                  <div class="modelType">
                    模型名称：模型塔1
                    模型名称：{{ modelName }}
                  </div>
                  <div>
                    模型类型：电塔
                    模型类型：{{ templateType }}
                  </div>
                  <el-form label-width="70px" :model="form">
                    <el-form-item label="模板名称">
                      <el-input v-model="form.templateName"></el-input>
                    </el-form-item>
                  </el-form>
                </div>
                <div class="modelTree">
                  <div class='modelTreeTitle'>巡检点目录</div>
                  <el-tree
                    class="filter-tree"
                    :data="treeData"
                    :props="defaultProps"
                    draggable                                   
                    :allow-drop="allowDrop"
                    @node-drop="handleDrop"
                    default-expand-all
                    ref="tree">
                  </el-tree>
                  <el-tabs v-model="activeName">
                    <el-tab-pane label="航点树" name="first">
                        <el-tree
                          class="filter-tree"
                          :data="treeData"
                          :props="defaultProps"
                          draggable                                   
                          :allow-drop="allowDrop"
                          @node-drop="handleDrop"
                          default-expand-all
                          @node-click="handleNodeClick"
                          ref="tree">
                        </el-tree>
                    </el-tab-pane>
                    <el-tab-pane label="航点列表" name="second">
                      <div class="waypoint-panel">

                        <!-- 航点列表 -->
                        <div class="waypoints">
                          <div 
                            v-for="(wp, index) in waypoints" 
                            :key="index" 
                            class="waypoint-item"
                            :class="{ active: selectedIndex === index }"
                            @click="toggleSelect(wp,index)"
                          >
                            <div class="waypoint-header">
                              <i 
                                class="el-icon-success" 
                              ></i>
                              <div class="waypoint-contnet">
                                <span class="waypoint-index">{{ wp.label }}</span>
                                <span v-for="(action, aIndex) in wp.actions" 
                                      :key="action.id" 
                                      class="action-icon"
                                      @click="clickItem(action)">
                  
                                  <img src="@/assets/images/xuanting.svg" alt="svg图片" v-if="action.type==='悬停'" />
                                  <img src="@/assets/images/photo.svg" alt="svg图片" v-if="action.type==='拍照'" />
                                  <img src="@/assets/images/startVideo.svg" alt="svg图片" v-if="action.type==='开始录像'" />
                                  <img src="@/assets/images/stopVideo.svg" alt="svg图片" v-if="action.type==='结束录像'" />
                                  <img src="@/assets/images/zoom.svg" alt="svg图片" v-if="action.type==='变焦'" />
                                  <!-- <i v-if="action.type==='拍照'" class="el-icon-video-camera"></i> -->
                                </span>
                              </div>
                            </div>
                          </div>
                        </div>
                      </div>
                    </el-tab-pane>
                  </el-tabs>
                  
                </div>
              </el-card>
          </el-col>
          <el-col :span="20">
              <InitMap v-if="showMap" @mergePoint="mergePoint" @renderData="renderData" :towerUrl="towerUrl"></InitMap>
              <InitMap v-if="showMap" @mergePoint="mergePoint" :towerUrl="towerUrl"  :deviceData="deviceData"  @dealTreeData="dealTreeData" ref="initMap" :chooseItem="chooseItem" @dealAction = 'dealAction'></InitMap>
          </el-col>
      </el-row>
      <span slot="footer" class="dialog-footer">
@@ -42,26 +89,32 @@
        <el-button type="primary" @click="submit()" >确 定</el-button>
      </span>
    </el-dialog>
    <ChooseModelDialog v-if="showModel" @cancel ='cancel' @getRowData="getRowData" ></ChooseModelDialog>
    <ChooseModelDialog v-if="showModel" @cancel ='cancel' @getRowData="getRowData"></ChooseModelDialog>
  </div>
</template>
<script>
import { compileToFunctions } from "vue-template-compiler";
import CesiumMap from "../../../../utils/components/cesium-map.vue";
import InitMap from "../../../../utils/components/init-map.vue";
import ChooseModelDialog from './chooseModelDialog.vue';
// const centerCartesian = Cesium.Cartesian3.fromDegrees(0,0, 236)
// const centerCartesian = Cesium.Cartesian3.fromDegrees(125.1949, 46.5143, 0)
 let globalon  = 125.1949
let globalat = 46.5143
const centerCartesian = Cesium.Cartesian3.fromDegrees(globalon,globalat , 236)

let relativeData 
import { addPoint , getPointInfo} from "@/api/system/template"
let globalon  = 0
let globalat = 0
let towerHeight = 45
//塔的朝向算法所用到的 旋转度数
let rotationAngle = Cesium.Math.toRadians(0)
export default{
  name:'shootPointDialog',
   components: {
    CesiumMap,
    ChooseModelDialog,
    InitMap
  },
  props: {
    templateId: {
      type: String,
      defaule: null
    }
  },
  data(){
    return{
@@ -78,44 +131,205 @@
        animationFrameId: null,
        showMap:false,
        towerUrl:null,
        chooseModelId:null
        chooseModelId:null,
        modelName:null,
        templateType:null,
        form:{},
        deviceData:null,
        activeName: 'first',
        totalDistance: 3054.9,
        totalTime: '5m 56s',
        totalPoints: 11,
        totalPhotos: 3,
        waypoints:[],
        selectedIndex:null,
        chooseItem: null,
        lastTableArr:[]
    }
  },
  mounted(){
    console.log(this.templateId)
    if(this.templateId) {
      //预览逻辑
      getPointInfo(this.templateId).then(res=>{
        if(res.code == 200 ) {
          console.log(res.data)
          this.getRowData(res.data)
          let drawArr = this.convertToTree(res.data.ardListWayPointsLS)
          setTimeout(() => {
            //渲染时间问题 加个延时器
            this.drawLines(drawArr)
          }, 500);
        }
      })
    }
  },  
  methods:{
    renderRelativePoints(viewer, data) {
      const airPoints = [];
    toggleSelect(wq,index) {
      this.chooseItem = wq
      console.log(this.treeData)
      console.log(wq)
      // 如果点击的是当前行，则取消选中
      if (this.selectedIndex === index) {
        this.selectedIndex = null
      } else {
        this.selectedIndex = index
      }
      const result = this.treeData.filter(item =>
          item.children && item.children.some(child => child.label === wq.label)
      );
      const dataObj = result[0]
      const from = [dataObj.children[0]?.longitude,dataObj.children[0]?.latitude, dataObj.children[0]?.height]; 
      const to = [dataObj.longitude,dataObj.latitude, dataObj.height]; 
      this.flyToAndLookAt(from, to);
      this.$refs.initMap.DealVisualCone(dataObj)
    },
   // 计算 heading（偏航角）
    computeHeading(fromCartesian, toCartesian) {
      const transform = Cesium.Transforms.eastNorthUpToFixedFrame(fromCartesian);
      const direction = Cesium.Cartesian3.subtract(
        toCartesian,
        fromCartesian,
        new Cesium.Cartesian3()
      );
      const directionLocal = Cesium.Matrix4.multiplyByPointAsVector(
        Cesium.Matrix4.inverseTransformation(transform, new Cesium.Matrix4()),
        direction,
        new Cesium.Cartesian3()
      );
      Cesium.Cartesian3.normalize(directionLocal, directionLocal);
      return Math.atan2(directionLocal.x, directionLocal.y);
    },

      data.forEach(item => {
        const groundRel = item.relativePosition;
        const groundPos = Cesium.Cartesian3.add(
          centerCartesian,
          new Cesium.Cartesian3(groundRel.x, groundRel.y, groundRel.z),
          new Cesium.Cartesian3()
    // 计算 pitch（俯仰角）
    computePitch(fromCartesian, toCartesian) {
      const transform = Cesium.Transforms.eastNorthUpToFixedFrame(fromCartesian);
      const direction = Cesium.Cartesian3.subtract(
        toCartesian,
        fromCartesian,
        new Cesium.Cartesian3()
      );
      const directionLocal = Cesium.Matrix4.multiplyByPointAsVector(
        Cesium.Matrix4.inverseTransformation(transform, new Cesium.Matrix4()),
        direction,
        new Cesium.Cartesian3()
      );
      Cesium.Cartesian3.normalize(directionLocal, directionLocal);
      return Math.asin(directionLocal.z); // z轴向上
    },

    // 飞到 from 看向 to
    flyToAndLookAt(from, to) {
      const fromCartesian = Cesium.Cartesian3.fromDegrees(from[0], from[1], from[2]);
      const toCartesian = Cesium.Cartesian3.fromDegrees(to[0], to[1], to[2]);

      const heading = this.computeHeading(fromCartesian, toCartesian);
      const pitch = this.computePitch(fromCartesian, toCartesian);
      let viewer = window.viewerM
      viewer.camera.flyTo({
        destination: fromCartesian,
        orientation: {
          heading: heading,
          pitch: pitch,
          roll: 0.0
        },
        duration: 3
      });
    },
    handleNodeClick(data,node) {
      if(data.children && data.children.length >0) {
        //点击父级
        const from = [data.children[0].longitude,data.children[0].latitude, data.children[0].height];
        const to = [data.longitude,data.latitude, data.height];      
        // this.flyToAndLookAt(from, to);
      } else  {
        //点击子级
        const from = [data.longitude,data.latitude, data.height]; 
        const to = [node.parent?.data?.longitude,node.parent?.data?.latitude, node.parent?.data?.height]; 
        // this.flyToAndLookAt(from, to);
      }
      this.$refs.initMap.DealVisualCone(data,node)
    },
    dealTreeData(arrList){
      console.log(arrList)
      this.treeData = arrList
      const childrenArr = arrList
        .filter(item => Array.isArray(item.children))
        .map(item => item.children)
        .reduce((acc, cur) => acc.concat(cur), []);

      childrenArr?.forEach((ele)=>{
        if(ele.actions) {
        }else {
          ele.actions = []
        }
      })
      this.waypoints = childrenArr
      console.log(childrenArr)
      console.log(this.treeData)
    },
    convertToTree(data) {
      return data.map((item, index) => {
        const parentId = 'air_' + index;
        return {
          id: parentId,
          label: item.targetName,
          longitude: item.longitude,
          latitude: item.latitude,
          height: item.altitude,
          children: (item.ardGroundPoint || []).map((g, i) => {
            return {
              id: parentId + '_ground_' + i,
              label: g.targetName,
              longitude: g.longitude,
              latitude: g.latitude,
              height: g.height
            }
          })
        }
      });
    },
    drawLines(treeData) {
      console.log(treeData)
      console.log(window)
      console.log(window.viewerM)
      let viewer = window.viewerM

      // 收集空中点位置
      const airPositions = treeData.map(point => {
        return Cesium.Cartesian3.fromDegrees(
          point.longitude,
          point.latitude,
          point.height
        );
        this.addPoint(viewer, groundPos, Cesium.Color.BLUE, item.label);

        item.children?.forEach(child => {
          const airRel = child.relativePosition;
          const airPos = Cesium.Cartesian3.add(
            centerCartesian,
            new Cesium.Cartesian3(airRel.x, airRel.y, airRel.z),
            new Cesium.Cartesian3()
          );
          this.addPoint(viewer, airPos, Cesium.Color.YELLOW, child.label);

          // 地面点到空中点用虚线
          this.drawLine(viewer, [groundPos, airPos], Cesium.Color.GRAY, true);

          airPoints.push(airPos);
        });
      });

      // 空中点之间连黄线
      if (airPoints.length > 1) {
        this.drawLine(viewer, airPoints, Cesium.Color.YELLOW);
      }
      // 1. 空中点之间用黄色实线连接
      viewer.entities.add({
        polyline: {
          positions: airPositions,
          width: 2,
          material: Cesium.Color.YELLOW
        }
      });

      // 2. 每个空中点与地面点用蓝色虚线连接
      treeData.forEach(point => {
        const airPos = Cesium.Cartesian3.fromDegrees(point.longitude, point.latitude, point.height);
        point.children.forEach(child => {
          const groundPos = Cesium.Cartesian3.fromDegrees(child.longitude, child.latitude, child.height);
          viewer.entities.add({
            polyline: {
              positions: [airPos, groundPos],
              width: 1,
              material: new Cesium.PolylineDashMaterialProperty({
                color: Cesium.Color.BLUE,
                dashLength: 8
              })
            }
          });
        });
      });
    },
    addPoint(viewer, position, color, label) {
      viewer.entities.add({
@@ -150,220 +364,6 @@
        }
      });
    },
    //空间坐标反渲染
    renderData(viewerM){
      let data = [
    {
        "id": "197ced8ed37d58af",
        "label": "地面点0",
        "longitude": 125.15396706149502,
        "latitude": 46.5542193007498,
        "height": 110.34582699579633,
        "children": [
            {
                "id": "197ced8ed37d12bf",
                "label": "空中点0",
                "longitude": 125.15269101779384,
                "latitude": 46.554404555297005,
                "height": 110.34669117272557,
                "relativePosition": {
                    "x": 147.6013223491609,
                    "y": -21.93333655036986,
                    "z": -75.59047747310251
                }
            }
        ],
        "relativePosition": {
            "x": 58.98418062273413,
            "y": -66.05175063293427,
            "z": -89.7526711942628
        }
    },
    {
        "id": "197ced8ed372ae58",
        "label": "地面点1",
        "longitude": 125.15396775899208,
        "latitude": 46.55421205599431,
        "height": 129.0598176992881,
        "children": [
            {
                "id": "197ced8ed3796b97",
                "label": "空中点1",
                "longitude": 125.15267500755259,
                "latitude": 46.55432990371885,
                "height": 129.06068032390132,
                "relativePosition": {
                    "x": 137.72684245044366,
                    "y": -5.778328162617981,
                    "z": -67.71026689186692
                }
            }
        ],
        "relativePosition": {
            "x": 51.19412293517962,
            "y": -55.08268230734393,
            "z": -76.7196572907269
        }
    },
    {
        "id": "197ced8ed373aacd",
        "label": "地面点2",
        "longitude": 125.15398622045456,
        "latitude": 46.55420774953827,
        "height": 147.7039314240401,
        "children": [
            {
                "id": "197ced8ed3744bed",
                "label": "空中点2",
                "longitude": 125.15268854335208,
                "latitude": 46.5542961263164,
                "height": 147.70478259476405,
                "relativePosition": {
                    "x": 127.92680113529786,
                    "y": 6.335606334730983,
                    "z": -56.756238551810384
                }
            }
        ],
        "relativePosition": {
            "x": 42.45445924857631,
            "y": -45.13116115285084,
            "z": -63.51276256516576
        }
    },
    {
        "id": "id_v5g7eyc8",
        "label": "地面点2-加高",
        "longitude": 125.15398622045456,
        "latitude": 46.55420774953827,
        "height": 147.7039314240401,
        "children": [
            {
                "id": "id_6w8bt6y5",
                "label": "空中点2-加高",
                "longitude": 125.15268854335208,
                "latitude": 46.5542961263164,
                "height": 197.70478259476405,
                "relativePosition": {
                    "x": 108.13033775659278,
                    "y": 34.448136328253895,
                    "z": -20.454920462332666
                }
            }
        ],
        "relativePosition": {
            "x": 42.45445924857631,
            "y": -45.13116115285084,
            "z": -63.51276256516576
        }
    },
    {
        "id": "id_wztyoy7w",
        "label": "地面点3",
        "longitude": 125.15421307297069,
        "latitude": 46.55421685854876,
        "height": 148.48833812454288,
        "children": [
            {
                "id": "id_cu78b9f1",
                "label": "空中点3-加高",
                "longitude": 125.15548763490776,
                "latitude": 46.55440688016316,
                "height": 198.48919020619783,
                "relativePosition": {
                    "x": -62.53922047605738,
                    "y": -96.01450884295627,
                    "z": -11.418861056677997
                }
            }
        ],
        "relativePosition": {
            "x": 28.343377863056958,
            "y": -55.307947248686105,
            "z": -62.246930407360196
        }
    },
    {
        "id": "197ced8ed37d0c3c",
        "label": "地面点3",
        "longitude": 125.15421307297069,
        "latitude": 46.55421685854876,
        "height": 148.48833812454288,
        "children": [
            {
                "id": "197ced8ed376225d",
                "label": "空中点3",
                "longitude": 125.15548763490776,
                "latitude": 46.55440688016316,
                "height": 148.48919020619783,
                "relativePosition": {
                    "x": -42.741424133535475,
                    "y": -124.12601430807263,
                    "z": -47.72024560905993
                }
            }
        ],
        "relativePosition": {
            "x": 28.343377863056958,
            "y": -55.307947248686105,
            "z": -62.246930407360196
        }
    },
    {
        "id": "197ced8ed378f22b",
        "label": "地面点4",
        "longitude": 125.15423241198647,
        "latitude": 46.55421195661101,
        "height": 129.07723014528972,
        "children": [
            {
                "id": "197ced8ed37bbaff",
                "label": "空中点4",
                "longitude": 125.1555253737729,
                "latitude": 46.55432870085922,
                "height": 129.07809286219634,
                "relativePosition": {
                    "x": -41.05480555212125,
                    "y": -131.5471526850015,
                    "z": -67.78957635723054
                }
            }
        ],
        "relativePosition": {
            "x": 34.58874865854159,
            "y": -66.75211867084727,
            "z": -76.71461268886924
        }
    },
    {
        "id": "197ced8ed372f8ad",
        "label": "地面点5",
        "longitude": 125.15423571155253,
        "latitude": 46.55422768619577,
        "height": 111.12748104722147,
        "children": [
            {
                "id": "197ced8ed373e993",
                "label": "空中点5",
                "longitude": 125.15551594222936,
                "latitude": 46.554398406019274,
                "height": 112.12216624922397,
                "relativePosition": {
                    "x": -30.5103326481767,
                    "y": -145.26342066843063,
                    "z": -74.77150713000447
                }
            }
        ],
        "relativePosition": {
            "x": 42.219932773150504,
            "y": -78.02784454869106,
            "z": -88.54415378533304
        }
    }
]
      this.renderRelativePoints(viewerM,data)
    },
    handleClose(){
      this.dialogVisible = false
    },
@@ -376,18 +376,52 @@
    cancel(){
      this.showModel = false
    },
    rotateAllPoints(dataList) {
      return dataList.map(item => {
        console.log(item)
        const groundPoint = Cesium.Cartesian3.fromDegrees(item.longitude, item.latitude, item.height);
        const towerPoint = Cesium.Cartesian3.fromDegrees(0, 0, 0);
        
        // 旋转地面点本身（会变，但绕自身旋转不会移动）
        const newGroundPoint = this.rotateAroundPoint( groundPoint,towerPoint, rotationAngle);
        const newGroundCarto = Cesium.Cartographic.fromCartesian(newGroundPoint);
        const newGround = {
          ...item,
          longitude: Cesium.Math.toDegrees(newGroundCarto.longitude),
          latitude: Cesium.Math.toDegrees(newGroundCarto.latitude),
          height: newGroundCarto.height
        };
        console.log(newGround)
        // 处理子空中点
        newGround.children = item.children.map(child => {
          const airPoint = Cesium.Cartesian3.fromDegrees(child.longitude, child.latitude, child.height);
          const rotatedAirPoint = this.rotateAroundPoint( airPoint,towerPoint, rotationAngle);
          const rotatedAirCarto = Cesium.Cartographic.fromCartesian(rotatedAirPoint);

          return {
            ...child,
            longitude: Cesium.Math.toDegrees(rotatedAirCarto.longitude),
            latitude: Cesium.Math.toDegrees(rotatedAirCarto.latitude),
            height: rotatedAirCarto.height
          };
        });

        return newGround;
      });
    },
    //合并逻辑  将附近n米范围内的点合并 并且处理成数据
    mergePoint(arr,mergeNumber,viewer){
      this.treeData = arr
      const result = this.replaceCloseChildrenWithHighestPoint(this.treeData,mergeNumber);
      // const updated = this.insertRaisedPoints(result, 0,0, 236, 130);
      const updated = this.insertRaisedPoints(result, globalon, globalat, 236, 130);
      const updated = this.insertRaisedPoints(result, globalon, globalat, towerHeight);
      this.treeData = updated
      const airPoints = []
      this.treeData.forEach(item => {
        const ground = item
        const air = item.children[0]

        // 地面点到空中点 — 白色虚线
        // 地面点到7空中点 — 白色虚线
        viewer.entities.add({
          polyline: {
            positions: Cesium.Cartesian3.fromDegreesArrayHeights([
@@ -415,10 +449,9 @@
        })
      }
      console.log(this.treeData)
      // this.conversionPosition()
      this.dealData()
    },
    insertRaisedPoints(data, centerLon, centerLat, centerHeight, radius = 130) {
    //数组 塔的精度 塔的纬度  塔的高度  半径
    insertRaisedPoints(data, centerLon, centerLat, centerHeight, radius = 10) {
      const center = Cesium.Cartesian3.fromDegrees(centerLon, centerLat, centerHeight);
      const result = JSON.parse(JSON.stringify(data)); // 深拷贝避免污染原数据
      const inserts = []; // 用于存储插入项及其目标位置
@@ -564,10 +597,21 @@
    },
    getRowData(row){
      console.log(row)
      this.modelName = row.modelName
      this.templateType = row.modelType
      this.deviceData = row
      if(this.templateId){
        this.form.templateName = row.templateName || ''
      }
      this.chooseModelId = row.id
      towerHeight = row.modelHeight || 45
      this.showMap =false
      this.$nextTick(()=>{
        this.towerUrl = row.modelRoute
        if(this.templateId){
          this.towerUrl = row.ardTowerModel.modelRoute
        }else {
          this.towerUrl = row.modelRoute
        }
        this.showMap = true
      })
    },
@@ -603,95 +647,103 @@
    handleDrop (draggingNode, dropNode, dropType, ev) {
      console.log('拖拽完成', { draggingNode, dropNode, dropType })
    },
    toRelativePosition(lon, lat, height, centerCartesian) {
      const worldPos = Cesium.Cartesian3.fromDegrees(lon, lat, height);
      const relative = new Cesium.Cartesian3();
      Cesium.Cartesian3.subtract(worldPos, centerCartesian, relative);
      return relative;
    },
     wgs84ToCartesian(longitude, latitude, height) {
      return Cesium.Cartesian3.fromDegrees(longitude, latitude, height);
    },
    getOffsetFromTower(lon, lat, height, tower) {
      const point = this.wgs84ToCartesian(lon, lat, height);
      const towerPoint = this.wgs84ToCartesian(tower.longitude, tower.latitude, tower.height);

      const offset = Cesium.Cartesian3.subtract(point, towerPoint, new Cesium.Cartesian3());
      return {
        x: offset.x,
        y: offset.y,
        z: offset.z
      };
    },
    dealData(){
      const rawData = this.treeData
      let tower  ={
        longitude:globalon,
        latitude:globalat,
        height:0
      }
      relativeData= rawData.forEach(item => {
        item.offset = this.getOffsetFromTower(item.longitude, item.latitude, item.height, tower);

        item.children?.forEach(child => {
          child.offset = this.getOffsetFromTower(child.longitude, child.latitude, child.height, tower);
        });
      })
      console.log(relativeData)
    },
    // conversionPosition(){
    //   const rawData = this.treeData
    //   // const centerCartesian = Cesium.Cartesian3.fromDegrees(0,0, 236);
    //   const centerCartesian = Cesium.Cartesian3.fromDegrees(globalon, globalat, 236);
    //   relativeData= rawData.map(ground => {
    //     const relativeGround = this.toRelativePosition(
    //       ground.longitude,
    //       ground.latitude,
    //       ground.height,
    //       centerCartesian
    //     );

    //     const children = ground.children?.map(child => {
    //       const relativeChild = this.toRelativePosition(
    //         child.longitude,
    //         child.latitude,
    //         child.height,
    //         centerCartesian
    //       );
    //       return {
    //         ...child,
    //         relativePosition: {
    //           x: relativeChild.x,
    //           y: relativeChild.y,
    //           z: relativeChild.z,
    //         }
    //       };
    //     });

    //     return {
    //       ...ground,
    //       relativePosition: {
    //         x: relativeGround.x,
    //         y: relativeGround.y,
    //         z: relativeGround.z,
    //       },
    //       children
    //     };
    //   });
    //   console.log(relativeData)
    // },
    submit(){
      if(!this.form.templateName){
        return  this.$message({
          message: '请先输入模板名称再保存',
          type: 'warning'
        })
      }
      // this.dialogVisible = false
      this.$emit('close')
      console.log(this.chooseModelId)
      console.log(relativeData)
      // const dealArr = this.submitDealData()
      const transformed = this.treeData.map((ground, index) => {
        const pointNumber = index + 1;
        const child = ground.children?.[0] || {};

        return {
          altitude: child.height,
          ardGroundPoint: [
            {
              height: ground.height,
              latitude: ground.latitude,
              longitude: ground.longitude,
              pointNumber: 1,
              targetName: ground.label
            }
          ],
          latitude: child.latitude,
          longitude: child.longitude,
          pointNumber: pointNumber,
          targetName: child.label
        };
    })
    console.log(transformed)
    let parmas = {
      templateName:this.form.templateName,
      modelId:this.chooseModelId,
      ardListWayPointsLS:transformed
    }
    addPoint(parmas).then(res=>{
      console.log(res)
      if(res.code == 200) {
        this.$message({
          message: '新增模板成功',
          type: 'success'
        })
        this.$emit('on-submit')
        this.$emit('close')
      }
    })
    console.log(parmas)
    },
    // 计算点A绕点B逆时针旋转指定角度后的新位置
    //  空中点或者地面点笛卡尔坐标 塔的笛卡尔坐标    塔的朝向值
    rotateAroundPoint(startPoint,pivotPoint,rotationAngle) {
      // 创建一个从B点到本地坐标系的转换矩阵（东方向为X轴，北方向为Y轴，垂直方向为Z轴）
     const transformationMatrix = Cesium.Transforms.eastNorthUpToFixedFrame(pivotPoint);
      // 获取世界坐标系到本地坐标系的转换矩阵
     const inverseTransformationMatrix = Cesium.Matrix4.inverse(transformationMatrix,new Cesium.Matrix4());
      // 将A点转换到局部坐标系中
     const localStartPoint = Cesium.Matrix4.multiplyByPoint(inverseTransformationMatrix, startPoint,new Cesium.Cartesian3());
      // 计算A点在局部坐标系中逆时针旋转指定角度后的新位置
     const rotatedX = localStartPoint.x * Math.cos(rotationAngle) + localStartPoint.y * Math.sin(rotationAngle);
     const rotatedY = localStartPoint.y * Math.cos(rotationAngle) - localStartPoint.x * Math.sin(rotationAngle);
     const rotatedZ = localStartPoint.z; // Z轴坐标保持不变
      // 将旋转后的局部坐标转换回世界坐标系
     return Cesium.Matrix4.multiplyByPoint(transformationMatrix, new Cesium.Cartesian3(rotatedX, rotatedY, rotatedZ), new Cesium.Cartesian3());
    },
    dealAction(data){
      console.log(this.treeData)
      console.log(this.waypoints)
      console.log(data)
      const byLabel = this.addOrUpdate(this.lastTableArr, data, 'label', this)
      this.waypoints  = this.lastTableArr
      console.log(byLabel)
      console.log(this.lastTableArr)
      console.log( this.waypoints)
    },
    addOrUpdate(list, newItem, key = 'label', vm = null) {
      let index = list.findIndex(item => item[key] === newItem[key]);
      console.log(index)
      if (index !== -1) {
        if (vm) {
          vm.$set(list, index, newItem); // Vue2 响应式替换
        } else {
          list.splice(index, 1, newItem);
        }
      } else {
        list.push(newItem);
      }
    },
    clickItem(value){
        this.$refs.initMap.editAction(value);  
    }
  }
}
</script>
<style scoped>
.noScroll{
    height: calc(100vh - 185px);
    height: calc(100vh - 175px);
    overflow: auto;
    position: relative;
}
@@ -702,7 +754,7 @@
  text-align: center;
}
.chooseModel{
  height: 100px;
  height: 120px;
  /* border: 1px solid #dddddd; */
}
.cameraView{
@@ -804,4 +856,83 @@
  background: transparent;
  box-shadow: none;
}
</style>
</style>
<style scoped>
.waypoint-panel {
  width: 300px;
  /* background: #1e1e1e;
  color: white; */
  font-size: 14px;
  height: 500px;
  overflow-y: scroll;
  /* overflow: scroll; */
}
.waypoint-panel  .waypoints {
  min-height: 50px;
}

.stats {
  display: flex;
  justify-content: space-around;
  padding: 8px;
  border-bottom: 1px solid #333;
}

.stat-item {
  display: flex;
  align-items: center;
}

.stat-item i {
  margin-right: 4px;
}

.waypoint-item {
  border-bottom: 1px solid #333;
  min-height: 40px;
  line-height: 40px;
}

.waypoint-item.active {
  background-color: rgba(0, 122, 255, 0.3); /* 高亮色 */
}

.waypoint-header {
  display: flex;
  align-items: center;
  cursor: pointer;
  padding: 4px 8px;
  width: 280px;
  word-wrap: break-word;
}
.waypoint-header i {
  margin-right: 6px;
  height: 36px;
  line-height: 36x;
  transition: transform 0.2s;
  font-size: 24px; 

}


.waypoint-header .waypoint-index {
  font-size: 24px;
}
.rotated {
  transform: rotate(-90deg);
}

.waypoint-content {
  flex: 1;
  background: rgb(73, 76, 128);
  display: flex;
  flex-wrap: wrap;
  align-items: center;
}

.waypoint-contnet img{
  height: 25px;
  margin-left: 5px;
}

</style>