1.增加缓存航线信息。

Xiajijian

2025-11-26 d85eddf40bc7d5db0c8f4ec6cd74ade775ff2c57

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
package com.ard.work.domain.dto.converter.wayline;
 
import com.ard.common.utils.bean.BeanUtils;
import com.ard.work.domain.dto.state.PointData;
import com.ard.work.domain.dto.wayline.HangarPoint;
import com.ard.work.domain.dto.wayline.NormalModel;
import com.ard.work.domain.dto.wayline.PlanLineData;
import com.ard.work.domain.dto.wayline.SurroundModel;
import com.ard.work.component.netty.protobuf.TelemetryDataPB;
 
import java.util.List;
import java.util.stream.Collectors;
 
public class PlanLineDataConverter {
 
    // 将 Protobuf 对象转换为实体对象
    public static PlanLineData convertProtoToEntity(TelemetryDataPB.PlanLineData proto) {
        PlanLineData planLineData = new PlanLineData();
        
        // 使用 BeanUtils 复制属性
        BeanUtils.copyProperties(proto, planLineData);
        
        // 处理 repeated fields
        if (proto.getPointsCount() > 0) {
            List<PointData> points = proto.getPointsList().stream()
                .map(PointDataConverter::convertProtoToEntity)
                .collect(Collectors.toList());
            planLineData.setPoints(points);
        }
        
        if (proto.getInterestsCount() > 0) {
            List<PointData> interests = proto.getInterestsList().stream()
                .map(PointDataConverter::convertProtoToEntity)
                .collect(Collectors.toList());
            planLineData.setInterests(interests);
        }
        
        // 处理 HangarPoint
        if (proto.hasTakePoint()) {
            HangarPoint takePoint = HangarPointConverter.convertProtoToEntity(proto.getTakePoint());
            planLineData.setTakePoint(takePoint);
        }
        
        if (proto.hasLandPoint()) {
            HangarPoint landPoint = HangarPointConverter.convertProtoToEntity(proto.getLandPoint());
            planLineData.setLandPoint(landPoint);
        }
        
        // 处理 NormalModel 和 SurroundModel
        if (proto.hasNormalModel()) {
            NormalModel normalModel = NormalModelConverter.convertProtoToEntity(proto.getNormalModel());
            planLineData.setNormalModel(normalModel);
        }
        
        if (proto.hasSurroundModel()) {
            SurroundModel surroundModel = SurroundModelConverter.convertProtoToEntity(proto.getSurroundModel());
            planLineData.setSurroundModel(surroundModel);
        }
        
        // 处理起飞点
        if (proto.hasTakeOffPoint()) {
            PointData takeOffPoint = PointDataConverter.convertProtoToEntity(proto.getTakeOffPoint());
            planLineData.setTakeOffPoint(takeOffPoint);
        }
 
        return planLineData;
    }
 
    // 将实体对象转换为 Protobuf 对象
    public static TelemetryDataPB.PlanLineData convertEntityToProto(PlanLineData planLineData) {
        // 创建 Protobuf 的构建器
        TelemetryDataPB.PlanLineData.Builder builder = TelemetryDataPB.PlanLineData.newBuilder();
 
        // 复制基本属性
        builder.setFinishedAction(planLineData.getFinishedAction());
        builder.setMaxSpeed(planLineData.getMaxSpeed());
        builder.setAutoSpeed(planLineData.getAutoSpeed());
        builder.setLoseAction(planLineData.getLoseAction());
        builder.setHomeHeight(planLineData.getHomeHeight());
        builder.setIsSaveEnergyMode(planLineData.getIsSaveEnergyMode());
 
        // 处理 repeated fields
        if (planLineData.getPoints() != null) {
            List<TelemetryDataPB.PointData> points = planLineData.getPoints().stream()
                .map(PointDataConverter::convertEntityToProto)
                .collect(Collectors.toList());
            builder.addAllPoints(points);
        }
        
        if (planLineData.getInterests() != null) {
            List<TelemetryDataPB.PointData> interests = planLineData.getInterests().stream()
                .map(PointDataConverter::convertEntityToProto)
                .collect(Collectors.toList());
            builder.addAllInterests(interests);
        }
        
        // 处理 HangarPoint
        if (planLineData.getTakePoint() != null) {
            TelemetryDataPB.HangarPoint takePoint = HangarPointConverter.convertEntityToProto(planLineData.getTakePoint());
            builder.setTakePoint(takePoint);
        }
        
        if (planLineData.getLandPoint() != null) {
            TelemetryDataPB.HangarPoint landPoint = HangarPointConverter.convertEntityToProto(planLineData.getLandPoint());
            builder.setLandPoint(landPoint);
        }
        
        // 处理 NormalModel 和 SurroundModel
        if (planLineData.getNormalModel() != null) {
            TelemetryDataPB.NormalModel normalModel = NormalModelConverter.convertEntityToProto(planLineData.getNormalModel());
            builder.setNormalModel(normalModel);
        }
        
        if (planLineData.getSurroundModel() != null) {
            TelemetryDataPB.SurroundModel surroundModel = SurroundModelConverter.convertEntityToProto(planLineData.getSurroundModel());
            builder.setSurroundModel(surroundModel);
        }
        
        // 处理起飞点
        if (planLineData.getTakeOffPoint() != null) {
            TelemetryDataPB.PointData takeOffPoint = PointDataConverter.convertEntityToProto(planLineData.getTakeOffPoint());
            builder.setTakeOffPoint(takeOffPoint);
        }
 
        // 构建并返回 Protobuf 对象
        return builder.build();
    }
}