#

Junjie

昨天 7a6292c5e99ce5bed133687c9f21235836025783

 src/main/java/com/zy/common/utils/NavigateUtils.java

@@ -4,6 +4,7 @@
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
@@ -328,11 +329,17 @@
        Map<Integer, StationProtocol> statusMap = loadStationStatusMap();
        Map<Integer, Double> stationLoopLoadMap = loadStationLoopLoadMap();
        StationTrafficSnapshot trafficSnapshot = loadStationTrafficSnapshot(statusMap, currentTaskNo);
        LoopMergeGuardContext loopMergeGuardContext = loadLoopMergeGuardContext();
        Set<Integer> outStationIdSet = loadAllOutStationIdSet();
        List<PathCandidateMetrics> metricsList = new ArrayList<>();
        int skippedByOtherOutStation = 0;
        int skippedByLoopMergeGuard = 0;
        for (List<NavigateNode> path : filteredCandidates) {
            if (path == null || path.isEmpty()) {
                continue;
            }
            if (!isLoopMergePathAllowed(path, statusMap, trafficSnapshot, loopMergeGuardContext)) {
                skippedByLoopMergeGuard++;
                continue;
            }
            PathCandidateMetrics metrics = buildCandidateMetrics(path, statusMap, stationLoopLoadMap, trafficSnapshot, profileConfig, ruleConfig, globalPolicy, outStationIdSet);
@@ -345,6 +352,10 @@
        if (metricsList.isEmpty()) {
            if (globalPolicy.forceSkipPassOtherOutStation && skippedByOtherOutStation > 0) {
                News.warn("[WCS Debug] 站点路径候选全部被过滤，因经过其他出库站点,startStationId={},endStationId={}",
                        resolvedPolicy.getRuleEntity() == null ? null : resolvedPolicy.getRuleEntity().getStartStationId(),
                        resolvedPolicy.getRuleEntity() == null ? null : resolvedPolicy.getRuleEntity().getEndStationId());
            } else if (skippedByLoopMergeGuard > 0) {
                News.warn("[WCS Debug] 站点路径候选全部被过滤，因分叉口插入环线主干会影响主干道,startStationId={},endStationId={}",
                        resolvedPolicy.getRuleEntity() == null ? null : resolvedPolicy.getRuleEntity().getStartStationId(),
                        resolvedPolicy.getRuleEntity() == null ? null : resolvedPolicy.getRuleEntity().getEndStationId());
            }
@@ -936,6 +947,113 @@
        return stationLoopLoadMap;
    }

    private LoopMergeGuardContext loadLoopMergeGuardContext() {
        LoopMergeGuardContext context = new LoopMergeGuardContext();
        try {
            if (stationCycleCapacityService == null) {
                return context;
            }
            StationCycleCapacityVo capacityVo = stationCycleCapacityService.getLatestSnapshot();
            if (capacityVo == null || capacityVo.getLoopList() == null || capacityVo.getLoopList().isEmpty()) {
                return context;
            }

            Map<Integer, Set<Integer>> stationGraph = loadUndirectedStationGraph();
            if (stationGraph.isEmpty()) {
                return context;
            }

            for (StationCycleLoopVo loopVo : capacityVo.getLoopList()) {
                List<Integer> rawStationIdList = loopVo == null ? Collections.emptyList() : loopVo.getStationIdList();
                List<Integer> loopStationIdList = distinctPositiveStationIds(rawStationIdList);
                if (loopStationIdList.size() < 3) {
                    continue;
                }
                Set<Integer> loopStationSet = new HashSet<>(loopStationIdList);
                for (Integer stationId : loopStationSet) {
                    context.loopStationIdSet.add(stationId);
                    Set<Integer> graphNeighborSet = stationGraph.getOrDefault(stationId, Collections.emptySet());
                    Set<Integer> loopNeighborSet = new LinkedHashSet<>();
                    for (Integer neighborStationId : graphNeighborSet) {
                        if (neighborStationId != null && loopStationSet.contains(neighborStationId)) {
                            loopNeighborSet.add(neighborStationId);
                        }
                    }
                    if (!loopNeighborSet.isEmpty()) {
                        context.loopNeighborMap.computeIfAbsent(stationId, key -> new LinkedHashSet<>()).addAll(loopNeighborSet);
                    }
                }
            }
        } catch (Exception ignore) {
        }
        return context;
    }

    private Map<Integer, Set<Integer>> loadUndirectedStationGraph() {
        Map<Integer, Set<Integer>> graph = new HashMap<>();
        List<Integer> levList = loadStationLevList();
        if (levList.isEmpty()) {
            return graph;
        }

        NavigateSolution navigateSolution = new NavigateSolution();
        for (Integer lev : levList) {
            if (lev == null) {
                continue;
            }
            List<List<NavigateNode>> stationMap;
            try {
                stationMap = navigateSolution.getStationMap(lev);
            } catch (Exception ignore) {
                continue;
            }
            if (stationMap == null || stationMap.isEmpty()) {
                continue;
            }

            for (List<NavigateNode> row : stationMap) {
                for (NavigateNode node : safeList(row)) {
                    Integer stationId = extractStationId(node);
                    if (stationId == null) {
                        continue;
                    }
                    graph.computeIfAbsent(stationId, key -> new LinkedHashSet<>());
                    List<NavigateNode> nextNodeList = navigateSolution.extend_current_node(stationMap, node);
                    for (NavigateNode nextNode : safeList(nextNodeList)) {
                        Integer nextStationId = extractStationId(nextNode);
                        if (nextStationId == null || stationId.equals(nextStationId)) {
                            continue;
                        }
                        graph.computeIfAbsent(nextStationId, key -> new LinkedHashSet<>());
                        graph.get(stationId).add(nextStationId);
                        graph.get(nextStationId).add(stationId);
                    }
                }
            }
        }
        return graph;
    }

    private List<Integer> loadStationLevList() {
        List<Integer> levList = new ArrayList<>();
        if (basStationService == null) {
            return levList;
        }
        try {
            List<BasStation> stationList = basStationService.list(new QueryWrapper<BasStation>().select("station_lev"));
            Set<Integer> seen = new HashSet<>();
            for (BasStation station : safeList(stationList)) {
                Integer lev = station == null ? null : station.getStationLev();
                if (lev != null && seen.add(lev)) {
                    levList.add(lev);
                }
            }
            Collections.sort(levList);
        } catch (Exception ignore) {
        }
        return levList;
    }

    private StationTrafficSnapshot loadStationTrafficSnapshot(Map<Integer, StationProtocol> statusMap, Integer currentTaskNo) {
        StationTrafficSnapshot snapshot = new StationTrafficSnapshot();
        Map<Integer, Integer> busyMap = new HashMap<>();
@@ -1025,6 +1143,92 @@
            }
        }
        return snapshot;
    }

    private boolean isLoopMergePathAllowed(List<NavigateNode> path,
                                           Map<Integer, StationProtocol> statusMap,
                                           StationTrafficSnapshot trafficSnapshot,
                                           LoopMergeGuardContext loopMergeGuardContext) {
        if (path == null || path.size() < 2 || loopMergeGuardContext == null || loopMergeGuardContext.loopStationIdSet.isEmpty()) {
            return true;
        }

        List<Integer> stationIdList = extractStationIdList(path);
        if (stationIdList.size() < 2) {
            return true;
        }

        for (int i = 1; i < stationIdList.size(); i++) {
            Integer prevStationId = stationIdList.get(i - 1);
            Integer currentStationId = stationIdList.get(i);
            if (prevStationId == null || currentStationId == null) {
                continue;
            }
            if (loopMergeGuardContext.loopStationIdSet.contains(prevStationId)
                    || !loopMergeGuardContext.loopStationIdSet.contains(currentStationId)) {
                continue;
            }

            Set<Integer> trunkNeighborSet = loopMergeGuardContext.loopNeighborMap.getOrDefault(currentStationId, Collections.emptySet());
            if (trunkNeighborSet.size() < 2) {
                continue;
            }

            for (Integer trunkNeighborStationId : trunkNeighborSet) {
                if (isStationOccupiedForLoopMerge(trunkNeighborStationId, statusMap, trafficSnapshot)) {
                    return false;
                }
            }
        }
        return true;
    }

    private boolean isStationOccupiedForLoopMerge(Integer stationId,
                                                  Map<Integer, StationProtocol> statusMap,
                                                  StationTrafficSnapshot trafficSnapshot) {
        if (stationId == null) {
            return false;
        }

        StationProtocol protocol = statusMap == null ? null : statusMap.get(stationId);
        if (protocol != null) {
            if ((protocol.getTaskNo() != null && protocol.getTaskNo() > 0) || protocol.isRunBlock()) {
                return true;
            }
        }

        if (trafficSnapshot == null) {
            return false;
        }
        if (trafficSnapshot.queueDepthMap.getOrDefault(stationId, 0) > 0) {
            return true;
        }

        for (TraceRouteSnapshot routeSnapshot : trafficSnapshot.traceRouteList) {
            if (routeSnapshot == null) {
                continue;
            }
            if (stationId.equals(routeSnapshot.currentStationId)) {
                return true;
            }
            if (containsStation(routeSnapshot.issuedStationIds, stationId)
                    || containsStation(routeSnapshot.pendingStationIds, stationId)) {
                return true;
            }
        }
        return false;
    }

    private boolean containsStation(List<Integer> stationIdList, Integer stationId) {
        if (stationId == null || stationIdList == null || stationIdList.isEmpty()) {
            return false;
        }
        for (Integer currentStationId : stationIdList) {
            if (stationId.equals(currentStationId)) {
                return true;
            }
        }
        return false;
    }

    private List<StationTaskTraceVo> loadActiveTraceList(Integer currentTaskNo, Map<Integer, StationProtocol> statusMap) {
@@ -1506,6 +1710,11 @@
        private Date sendTime;
    }

    private static class LoopMergeGuardContext {
        private final Set<Integer> loopStationIdSet = new HashSet<>();
        private final Map<Integer, Set<Integer>> loopNeighborMap = new HashMap<>();
    }

    private static class PathGlobalPolicy {
        private double lenWeightFactor = 1.0d;
        private double congWeightFactor = 1.0d;