#优化运行速度

Junjie

15 小时以前 45052042f06689096093fc86cae36560b2eeb1f0

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

@@ -7,8 +7,10 @@
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Map;
import java.util.PriorityQueue;
import java.util.Set;

import com.zy.asrs.domain.path.StationPathCalcMode;
import com.zy.asrs.domain.path.StationPathProfileConfig;
import com.zy.asrs.domain.path.StationPathResolvedPolicy;
import com.zy.asrs.domain.path.StationPathRuleConfig;
@@ -32,6 +34,7 @@
import org.springframework.stereotype.Component;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.core.common.SpringUtils;
@@ -72,125 +75,92 @@
    @Autowired
    private StationTaskTraceRegistry stationTaskTraceRegistry;

    public synchronized List<NavigateNode> calcByStationId(Integer startStationId, Integer endStationId) {
        return calcByStationId(startStationId, endStationId, null, false);
    public List<NavigateNode> calcOptimalPathByStationId(Integer startStationId,
                                                         Integer endStationId,
                                                         Integer currentTaskNo,
                                                         Double pathLenFactor) {
        return calcPathByStationId(startStationId, endStationId, currentTaskNo, pathLenFactor, StationPathCalcMode.OPTIMAL);
    }

    public synchronized List<NavigateNode> calcByStationId(Integer startStationId, Integer endStationId, Integer currentTaskNo) {
        return calcByStationId(startStationId, endStationId, currentTaskNo, false);
    public List<NavigateNode> calcReachablePathByStationId(Integer startStationId, Integer endStationId) {
        return calcPathByStationId(startStationId, endStationId, null, null, StationPathCalcMode.REACHABILITY);
    }

    public synchronized List<NavigateNode> calcReachablePathByStationId(Integer startStationId, Integer endStationId) {
        return calcByStationId(startStationId, endStationId, null, true);
    }

    private synchronized List<NavigateNode> calcByStationId(Integer startStationId,
                                                            Integer endStationId,
                                                            Integer currentTaskNo,
                                                            boolean reachabilityOnly) {
        BasStation startStation = basStationService.getById(startStationId);
        if (startStation == null) {
            throw new CoolException("未找到该 起点 对应的站点数据");
        }
        Integer lev = startStation.getStationLev();

        NavigateSolution navigateSolution = new NavigateSolution();
        List<List<NavigateNode>> stationMap = navigateSolution.getStationMap(lev);

        NavigateNode startNode = navigateSolution.findStationNavigateNode(stationMap, startStationId);
        if (startNode == null) {
            throw new CoolException("未找到该 起点 对应的节点");
        }

        NavigateNode endNode = navigateSolution.findStationNavigateNode(stationMap, endStationId);
        if (endNode == null) {
            throw new CoolException("未找到该 终点 对应的节点");
        }

    public List<List<NavigateNode>> calcCandidatePathByStationId(Integer startStationId,
                                                                 Integer endStationId,
                                                                 Integer currentTaskNo,
                                                                 Double pathLenFactor) {
        StationPathResolvedPolicy resolvedPolicy = resolveStationPathPolicy(startStationId, endStationId);
        StationPathProfileConfig profileConfig = resolvedPolicy.getProfileConfig() == null
                ? StationPathProfileConfig.defaultConfig()
                : resolvedPolicy.getProfileConfig();

        long startTime = System.currentTimeMillis();
        News.info("[WCS Debug] 站点路径开始计算,startStationId={},endStationId={}", startStationId, endStationId);
        int calcMaxDepth = safeInt(profileConfig.getCalcMaxDepth(), 120);
        int calcMaxPaths = safeInt(profileConfig.getCalcMaxPaths(), 500);
        int calcMaxCost = safeInt(profileConfig.getCalcMaxCost(), 300);
        List<Integer> guideStationSequence = buildGuideStationSequence(startStationId, endStationId, resolvedPolicy.getRuleConfig());
        List<List<NavigateNode>> allList = navigateSolution.allSimplePaths(
                stationMap,
                startNode,
                endNode,
                calcMaxDepth,
                calcMaxPaths,
                calcMaxCost,
                guideStationSequence
        StationPathSearchContext context = buildStationPathSearchContext(
                startStationId,
                endStationId,
                resolvedPolicy,
                StationPathCalcMode.REROUTE
        );
        if (allList.isEmpty()) {
//            throw new CoolException("未找到该路径");
        if (context.allList.isEmpty()) {
            return new ArrayList<>();
        }
        Map<Integer, StationProtocol> statusMap = loadStationStatusMap();
        allList = filterNonAutoStationPaths(allList, statusMap);
        if (allList.isEmpty()) {
            News.info("[WCS Debug] 站点路径候选全部被过滤，存在非自动站点,startStationId={},endStationId={}", startStationId, endStationId);
            return new ArrayList<>();
        }
        News.info("[WCS Debug] 站点路径计算完成，耗时：{}ms", System.currentTimeMillis() - startTime);

        startTime = System.currentTimeMillis();
        News.info("[WCS Debug] 站点路径权重开始分析,startStationId={},endStationId={}", startStationId, endStationId);
        List<NavigateNode> list = reachabilityOnly
                ? findStationReachablePath(allList, resolvedPolicy, startStationId, endStationId)
                : findStationBestPathTwoStage(allList, resolvedPolicy, currentTaskNo, startStationId, endStationId);
        News.info("[WCS Debug] 站点路径权重分析完成，耗时：{}ms", System.currentTimeMillis() - startTime);
        List<List<NavigateNode>> orderedPathList = orderStationPathCandidates(
                context.allList,
                context.resolvedPolicy,
                currentTaskNo,
                pathLenFactor,
                startStationId,
                endStationId
        );
        return normalizeCandidatePaths(orderedPathList);
    }

        //去重
        HashSet<Integer> set = new HashSet<>();
        List<NavigateNode> fitlerList = new ArrayList<>();
        for (NavigateNode navigateNode : list) {
            JSONObject valuObject = JSON.parseObject(navigateNode.getNodeValue());
            if (valuObject.containsKey("rgvCalcFlag")) {
    public Map<Integer, Set<Integer>> loadUndirectedStationGraphSnapshot() {
        Map<Integer, Set<Integer>> graph = loadUndirectedStationGraph();
        Map<Integer, Set<Integer>> snapshot = new HashMap<>();
        for (Map.Entry<Integer, Set<Integer>> entry : graph.entrySet()) {
            Integer stationId = entry.getKey();
            if (stationId == null) {
                continue;
            }
            if (set.add(valuObject.getInteger("stationId"))) {
                fitlerList.add(navigateNode);
            }
            snapshot.put(stationId, new LinkedHashSet<>(entry.getValue() == null ? Collections.emptySet() : entry.getValue()));
        }

        for (int i = 0; i < fitlerList.size(); i++) {
            NavigateNode currentNode = fitlerList.get(i);
            currentNode.setIsInflectionPoint(false);
            currentNode.setIsLiftTransferPoint(false);

            try {
                JSONObject valueObject = JSON.parseObject(currentNode.getNodeValue());
                if (valueObject != null) {
                    Object isLiftTransfer = valueObject.get("isLiftTransfer");
                    if (isLiftTransfer != null) {
                        String isLiftTransferStr = isLiftTransfer.toString();
                        if ("1".equals(isLiftTransferStr) || "true".equalsIgnoreCase(isLiftTransferStr)) {
                            currentNode.setIsLiftTransferPoint(true);
                        }
                    }
                }
            } catch (Exception ignore) {}

            NavigateNode nextNode = (i + 1 < fitlerList.size()) ? fitlerList.get(i + 1) : null;
            NavigateNode prevNode = (i - 1 >= 0) ? fitlerList.get(i - 1) : null;

            HashMap<String, Object> result = searchInflectionPoint(currentNode, nextNode, prevNode);
            if (Boolean.parseBoolean(result.get("result").toString())) {
                currentNode.setIsInflectionPoint(true);
                currentNode.setDirection(result.get("direction").toString());
            }
        }

        return fitlerList;
        return snapshot;
    }

    public synchronized List<NavigateNode> calcByTrackSiteNo(int lev, Integer startTrackSiteNo, Integer endTrackSiteNo) {
    private List<NavigateNode> calcPathByStationId(Integer startStationId,
                                                   Integer endStationId,
                                                   Integer currentTaskNo,
                                                   Double pathLenFactor,
                                                   StationPathCalcMode calcMode) {
        StationPathResolvedPolicy resolvedPolicy = resolveStationPathPolicy(startStationId, endStationId);
        if (calcMode != StationPathCalcMode.REROUTE) {
            List<NavigateNode> directPath = findStationDirectPath(
                    startStationId,
                    endStationId,
                    currentTaskNo,
                    pathLenFactor,
                    calcMode,
                    resolvedPolicy
            );
            if (!directPath.isEmpty()) {
                return normalizeStationPath(directPath);
            }
        }

        StationPathSearchContext context = buildStationPathSearchContext(
                startStationId,
                endStationId,
                resolvedPolicy,
                calcMode
        );
        if (context.allList.isEmpty()) {
            return new ArrayList<>();
        }
        List<NavigateNode> list = calcMode == StationPathCalcMode.REACHABILITY
                ? findStationReachablePath(context.allList, context.resolvedPolicy, startStationId, endStationId)
                : findStationBestPathTwoStage(context.allList, context.resolvedPolicy, currentTaskNo, pathLenFactor, startStationId, endStationId);
        return normalizeStationPath(list);
    }

    public List<NavigateNode> calcByTrackSiteNo(int lev, Integer startTrackSiteNo, Integer endTrackSiteNo) {
        NavigateSolution navigateSolution = new NavigateSolution();
        List<List<NavigateNode>> rgvTrackMap = navigateSolution.getRgvTrackMap(lev);

@@ -260,7 +230,7 @@
        return fitlerList;
    }

    public synchronized List<NavigateNode> findLiftStationList(int lev) {
    public List<NavigateNode> findLiftStationList(int lev) {
        NavigateSolution navigateSolution = new NavigateSolution();
        List<List<NavigateNode>> stationMap = navigateSolution.getStationMap(lev);

@@ -301,6 +271,502 @@
        return new StationPathResolvedPolicy();
    }

    private List<NavigateNode> findStationDirectPath(Integer startStationId,
                                                     Integer endStationId,
                                                     Integer currentTaskNo,
                                                     Double pathLenFactor,
                                                     StationPathCalcMode calcMode,
                                                     StationPathResolvedPolicy resolvedPolicy) {
        if (!supportsDirectPathMode(calcMode, resolvedPolicy, pathLenFactor)) {
            return new ArrayList<>();
        }

        DirectStationPathContext context = buildDirectStationPathContext(
                startStationId,
                endStationId,
                currentTaskNo,
                calcMode,
                resolvedPolicy
        );
        if (context == null) {
            return new ArrayList<>();
        }

        long startTime = System.currentTimeMillis();
        News.info("[WCS Debug] 站点路径快速计算开始,startStationId={},endStationId={},mode={}",
                startStationId,
                endStationId,
                calcMode.name());

        DirectPathSearchResult searchResult = searchDirectPathWithFallback(
                context,
                true,
                calcMode == StationPathCalcMode.OPTIMAL
        );
        if (searchResult.path.isEmpty() && hasWaypoint(context.ruleConfig) && !strictWaypoint(context.ruleConfig)) {
            searchResult = searchDirectPathWithFallback(
                    context,
                    false,
                    calcMode == StationPathCalcMode.OPTIMAL
            );
            if (!searchResult.path.isEmpty()) {
                News.info("[WCS Debug] 站点路径快速计算已降级，忽略关键途经点约束后重试");
            }
        }
        if (searchResult.path.isEmpty()) {
            return new ArrayList<>();
        }

        if (!isDirectPathValid(
                searchResult.path,
                context,
                searchResult.includeWaypoint,
                searchResult.includeSoftPreference)) {
            return new ArrayList<>();
        }

        News.info("[WCS Debug] 站点路径快速计算完成，耗时：{}ms,startStationId={},endStationId={},mode={}",
                System.currentTimeMillis() - startTime,
                startStationId,
                endStationId,
                calcMode.name());
        return searchResult.path;
    }

    private DirectPathSearchResult searchDirectPathWithFallback(DirectStationPathContext context,
                                                                boolean includeWaypoint,
                                                                boolean includeSoftPreference) {
        List<NavigateNode> path = searchDirectPath(context, includeWaypoint, includeSoftPreference);
        if (!path.isEmpty()) {
            return new DirectPathSearchResult(path, includeWaypoint, includeSoftPreference);
        }
        if (includeSoftPreference && hasSoftPreference(context.ruleConfig) && allowSoftDegrade(context.ruleConfig)) {
            List<NavigateNode> degradedPath = searchDirectPath(context, includeWaypoint, false);
            if (!degradedPath.isEmpty()) {
                News.info("[WCS Debug] 站点路径快速计算已降级，忽略软偏好约束后重试");
            }
            return new DirectPathSearchResult(degradedPath, includeWaypoint, false);
        }
        return DirectPathSearchResult.empty(includeWaypoint, includeSoftPreference);
    }

    private List<NavigateNode> searchDirectPath(DirectStationPathContext context,
                                                boolean includeWaypoint,
                                                boolean includeSoftPreference) {
        List<Integer> guideStationSequence = buildDirectGuideStationSequence(
                context.startStationId,
                context.endStationId,
                context.ruleConfig,
                includeWaypoint,
                includeSoftPreference
        );
        if (guideStationSequence.isEmpty()) {
            guideStationSequence = new ArrayList<>();
            guideStationSequence.add(context.startStationId);
            guideStationSequence.add(context.endStationId);
        }

        List<NavigateNode> result = new ArrayList<>();
        for (int i = 1; i < guideStationSequence.size(); i++) {
            Integer segmentStartStationId = guideStationSequence.get(i - 1);
            Integer segmentEndStationId = guideStationSequence.get(i);
            if (segmentStartStationId == null || segmentEndStationId == null) {
                return new ArrayList<>();
            }

            NavigateNode segmentStartNode = context.navigateSolution.findStationNavigateNode(context.stationMap, segmentStartStationId);
            NavigateNode segmentEndNode = context.navigateSolution.findStationNavigateNode(context.stationMap, segmentEndStationId);
            if (segmentStartNode == null || segmentEndNode == null) {
                return new ArrayList<>();
            }

            List<NavigateNode> segmentPath = searchDirectPathSegment(
                    context,
                    segmentStartNode,
                    segmentEndNode,
                    includeSoftPreference
            );
            if (segmentPath.isEmpty()) {
                return new ArrayList<>();
            }
            mergeSegmentPath(result, segmentPath);
        }
        return result;
    }

    private List<NavigateNode> searchDirectPathSegment(DirectStationPathContext context,
                                                       NavigateNode startNode,
                                                       NavigateNode endNode,
                                                       boolean includeSoftPreference) {
        PriorityQueue<DirectPathState> openQueue = new PriorityQueue<>((left, right) -> {
            int compare = Double.compare(left.fScore, right.fScore);
            if (compare != 0) {
                return compare;
            }
            return Double.compare(left.gScore, right.gScore);
        });
        Map<String, Double> bestScoreMap = new HashMap<>();
        DirectPathState startState = new DirectPathState(startNode, null, 0.0d, calcHeuristicScore(startNode, endNode));
        openQueue.offer(startState);
        bestScoreMap.put(buildDirectStateKey(startState), 0.0d);

        while (!openQueue.isEmpty()) {
            DirectPathState currentState = openQueue.poll();
            if (sameCoordinate(currentState.node, endNode)) {
                return buildDirectPath(currentState);
            }

            List<NavigateNode> nextNodeList = context.navigateSolution.extend_current_node(context.stationMap, currentState.node);
            for (NavigateNode nextNode : safeList(nextNodeList)) {
                if (!isDirectTransitionAllowed(context, currentState.node, nextNode, endNode)) {
                    continue;
                }

                double stepCost = calcDirectStepCost(
                        context,
                        currentState.parent == null ? null : currentState.parent.node,
                        currentState.node,
                        nextNode,
                        endNode,
                        includeSoftPreference
                );
                double nextGScore = currentState.gScore + stepCost;
                DirectPathState nextState = new DirectPathState(
                        nextNode,
                        currentState,
                        nextGScore,
                        nextGScore + calcHeuristicScore(nextNode, endNode)
                );
                String stateKey = buildDirectStateKey(nextState);
                Double recordedScore = bestScoreMap.get(stateKey);
                if (recordedScore != null && recordedScore <= nextGScore) {
                    continue;
                }
                bestScoreMap.put(stateKey, nextGScore);
                openQueue.offer(nextState);
            }
        }
        return new ArrayList<>();
    }

    private boolean isDirectTransitionAllowed(DirectStationPathContext context,
                                              NavigateNode currentNode,
                                              NavigateNode nextNode,
                                              NavigateNode endNode) {
        if (nextNode == null) {
            return false;
        }
        Integer nextStationId = extractStationId(nextNode);
        Integer currentStationId = extractStationId(currentNode);
        Integer endStationId = extractStationId(endNode);

        if (nextStationId != null && !nextStationId.equals(endStationId)) {
            if (context.forbidStationIdSet.contains(nextStationId)) {
                return false;
            }
            StationProtocol protocol = context.statusMap.get(nextStationId);
            if (protocol != null && !protocol.isAutoing()) {
                return false;
            }
            if (context.globalPolicy.forceSkipPassOtherOutStation
                    && context.outStationIdSet.contains(nextStationId)
                    && !nextStationId.equals(context.startStationId)
                    && !nextStationId.equals(context.endStationId)) {
                return false;
            }
        }

        if (currentStationId != null && nextStationId != null) {
            String edgeKey = currentStationId + "->" + nextStationId;
            if (context.forbidEdgeSet.contains(edgeKey)) {
                return false;
            }
        }
        return true;
    }

    private double calcDirectStepCost(DirectStationPathContext context,
                                      NavigateNode prevNode,
                                      NavigateNode currentNode,
                                      NavigateNode nextNode,
                                      NavigateNode endNode,
                                      boolean includeSoftPreference) {
        double stepCost = safeDouble(context.profileConfig.getS1LenWeight(), 1.0d) * context.globalPolicy.lenWeightFactor;
        stepCost += safeDouble(context.profileConfig.getS1TurnWeight(), 3.0d)
                * calcDirectTurnPenalty(prevNode, currentNode, nextNode, endNode);
        stepCost += safeDouble(context.profileConfig.getS1LiftWeight(), 8.0d) * calcLiftTransferPenalty(nextNode);

        if (context.calcMode == StationPathCalcMode.REACHABILITY) {
            return Math.max(stepCost, 1.0d);
        }

        Integer stationId = extractStationId(nextNode);
        if (stationId != null) {
            double congWeightFactor = context.globalPolicy.congWeightFactor;
            stepCost += safeDouble(context.profileConfig.getS2BusyWeight(), 2.0d)
                    * congWeightFactor
                    * context.trafficSnapshot.congestionScoreMap.getOrDefault(stationId, 0.0d);
            stepCost += safeDouble(context.profileConfig.getS2QueueWeight(), 2.5d)
                    * context.trafficSnapshot.queueDepthMap.getOrDefault(stationId, 0);
            stepCost += safeDouble(context.profileConfig.getS2WaitWeight(), 1.5d)
                    * (context.trafficSnapshot.estimatedWaitSecondsMap.getOrDefault(stationId, 0.0d) / 60.0d);
            StationProtocol protocol = context.statusMap.get(stationId);
            if (protocol != null && protocol.isRunBlock()) {
                stepCost += safeDouble(context.profileConfig.getS2RunBlockWeight(), 10.0d);
            }
            stepCost += safeDouble(context.profileConfig.getS2LoopLoadWeight(), 12.0d)
                    * context.stationLoopLoadMap.getOrDefault(stationId, 0.0d);
            if (context.outStationIdSet.contains(stationId)
                    && !stationId.equals(context.startStationId)
                    && !stationId.equals(context.endStationId)) {
                stepCost += context.globalPolicy.passOtherOutStationPenaltyWeight;
            }

            if (includeSoftPreference && context.softReferenceStationSet.contains(stationId)) {
                stepCost -= 0.25d;
            } else if (includeSoftPreference
                    && stationId != null
                    && !stationId.equals(context.startStationId)
                    && !stationId.equals(context.endStationId)
                    && !context.softReferenceStationSet.isEmpty()) {
                double softDeviationWeight = safeDouble(context.profileConfig.getS1SoftDeviationWeight(), 4.0d);
                if (context.ruleConfig.getSoft() != null && context.ruleConfig.getSoft().getDeviationWeight() != null) {
                    softDeviationWeight = context.ruleConfig.getSoft().getDeviationWeight();
                }
                stepCost += softDeviationWeight;
            }
        }

        return Math.max(stepCost, 1.0d);
    }

    private int calcDirectTurnPenalty(NavigateNode prevNode,
                                      NavigateNode currentNode,
                                      NavigateNode nextNode,
                                      NavigateNode endNode) {
        if (prevNode == null || currentNode == null || nextNode == null) {
            return 0;
        }
        if (nextNode.getX() == prevNode.getX() || nextNode.getY() == prevNode.getY()) {
            return 0;
        }
        return (endNode != null && (nextNode.getX() == endNode.getX() || nextNode.getY() == endNode.getY())) ? 1 : 1;
    }

    private int calcLiftTransferPenalty(NavigateNode node) {
        if (node == null || node.getNodeValue() == null) {
            return 0;
        }
        try {
            JSONObject valueObject = JSON.parseObject(node.getNodeValue());
            if (valueObject == null) {
                return 0;
            }
            Object isLiftTransfer = valueObject.get("isLiftTransfer");
            if (isLiftTransfer == null) {
                return 0;
            }
            String text = String.valueOf(isLiftTransfer);
            return ("1".equals(text) || "true".equalsIgnoreCase(text)) ? 1 : 0;
        } catch (Exception ignore) {
            return 0;
        }
    }

    private double calcHeuristicScore(NavigateNode currentNode, NavigateNode endNode) {
        if (currentNode == null || endNode == null) {
            return 0.0d;
        }
        return Math.abs(endNode.getX() - currentNode.getX()) + Math.abs(endNode.getY() - currentNode.getY());
    }

    private boolean sameCoordinate(NavigateNode left, NavigateNode right) {
        return left != null
                && right != null
                && left.getX() == right.getX()
                && left.getY() == right.getY();
    }

    private String buildDirectStateKey(DirectPathState state) {
        if (state == null || state.node == null) {
            return "";
        }
        String currentKey = state.node.getX() + "_" + state.node.getY();
        if (state.parent == null || state.parent.node == null) {
            return currentKey + "|S";
        }
        return currentKey + "|" + state.parent.node.getX() + "_" + state.parent.node.getY();
    }

    private List<NavigateNode> buildDirectPath(DirectPathState endState) {
        List<NavigateNode> path = new ArrayList<>();
        DirectPathState cursor = endState;
        while (cursor != null) {
            NavigateNode clonedNode = cursor.node == null ? null : cursor.node.clone();
            if (clonedNode != null) {
                path.add(clonedNode);
            }
            cursor = cursor.parent;
        }
        Collections.reverse(path);
        return path;
    }

    private void mergeSegmentPath(List<NavigateNode> target, List<NavigateNode> segmentPath) {
        if (target == null || segmentPath == null || segmentPath.isEmpty()) {
            return;
        }
        if (target.isEmpty()) {
            target.addAll(segmentPath);
            return;
        }
        for (int i = 0; i < segmentPath.size(); i++) {
            if (i == 0 && sameCoordinate(target.get(target.size() - 1), segmentPath.get(i))) {
                continue;
            }
            target.add(segmentPath.get(i));
        }
    }

    private List<Integer> buildDirectGuideStationSequence(Integer startStationId,
                                                          Integer endStationId,
                                                          StationPathRuleConfig ruleConfig,
                                                          boolean includeWaypoint,
                                                          boolean includeSoftPreference) {
        List<Integer> sequence = new ArrayList<>();
        appendGuideStation(sequence, startStationId);
        if (ruleConfig == null) {
            appendGuideStation(sequence, endStationId);
            return sequence;
        }

        if (includeSoftPreference) {
            List<Integer> preferredPath = safeList(ruleConfig.getSoft() == null ? null : ruleConfig.getSoft().getPreferredPath());
            if (!preferredPath.isEmpty() && startStationId.equals(preferredPath.get(0))) {
                for (int i = 1; i < preferredPath.size(); i++) {
                    appendGuideStation(sequence, preferredPath.get(i));
                }
                if (sequence.get(sequence.size() - 1).equals(endStationId)) {
                    return sequence;
                }
                sequence.clear();
                appendGuideStation(sequence, startStationId);
            }
        }

        if (includeWaypoint) {
            for (Integer stationId : safeList(ruleConfig.getWaypoint() == null ? null : ruleConfig.getWaypoint().getStations())) {
                appendGuideStation(sequence, stationId);
            }
        }
        if (includeSoftPreference) {
            for (Integer stationId : safeList(ruleConfig.getSoft() == null ? null : ruleConfig.getSoft().getKeyStations())) {
                appendGuideStation(sequence, stationId);
            }
        }
        appendGuideStation(sequence, endStationId);
        return sequence;
    }

    private boolean isDirectPathValid(List<NavigateNode> path,
                                      DirectStationPathContext context,
                                      boolean includeWaypoint,
                                      boolean includeSoftPreference) {
        if (path == null || path.isEmpty()) {
            return false;
        }
        List<Integer> stationIdList = extractStationIdList(path);
        if (!matchHardConstraint(stationIdList, context.ruleConfig.getHard())) {
            return false;
        }
        if (includeWaypoint && !matchWaypointConstraint(stationIdList, context.ruleConfig.getWaypoint())) {
            return false;
        }
        if (includeSoftPreference && !matchSoftConstraint(stationIdList, context.ruleConfig.getSoft())) {
            return false;
        }
        if (!isLoopMergePathAllowed(
                path,
                context.statusMap,
                context.trafficSnapshot,
                context.loopMergeGuardContext,
                Collections.emptySet())) {
            return false;
        }

        if (context.globalPolicy.forceSkipPassOtherOutStation
                && countPassOtherOutStations(path, context.outStationIdSet) > 0) {
            return false;
        }
        return true;
    }

    private boolean supportsDirectPathMode(StationPathCalcMode calcMode,
                                           StationPathResolvedPolicy resolvedPolicy,
                                           Double pathLenFactor) {
        if (calcMode == null || calcMode == StationPathCalcMode.REROUTE) {
            return false;
        }
        if (calcMode == StationPathCalcMode.OPTIMAL && normalizePathLenFactor(pathLenFactor) > 0.0d) {
            return false;
        }
        StationPathRuleConfig ruleConfig = resolvedPolicy == null || resolvedPolicy.getRuleConfig() == null
                ? new StationPathRuleConfig()
                : resolvedPolicy.getRuleConfig();
        return safeList(ruleConfig.getHard() == null ? null : ruleConfig.getHard().getMustPassStations()).isEmpty()
                && safeList(ruleConfig.getHard() == null ? null : ruleConfig.getHard().getMustPassEdges()).isEmpty();
    }

    private DirectStationPathContext buildDirectStationPathContext(Integer startStationId,
                                                                   Integer endStationId,
                                                                   Integer currentTaskNo,
                                                                   StationPathCalcMode calcMode,
                                                                   StationPathResolvedPolicy resolvedPolicy) {
        BasStation startStation = basStationService.getById(startStationId);
        if (startStation == null) {
            throw new CoolException("未找到该 起点 对应的站点数据");
        }

        NavigateSolution navigateSolution = new NavigateSolution();
        List<List<NavigateNode>> stationMap = navigateSolution.getStationMap(startStation.getStationLev());
        NavigateNode startNode = navigateSolution.findStationNavigateNode(stationMap, startStationId);
        NavigateNode endNode = navigateSolution.findStationNavigateNode(stationMap, endStationId);
        if (startNode == null || endNode == null) {
            throw new CoolException("未找到该 起点 或 终点 对应的节点");
        }

        DirectStationPathContext context = new DirectStationPathContext();
        context.calcMode = calcMode;
        context.startStationId = startStationId;
        context.endStationId = endStationId;
        context.navigateSolution = navigateSolution;
        context.stationMap = stationMap;
        context.startNode = startNode;
        context.endNode = endNode;
        context.resolvedPolicy = resolvedPolicy == null ? new StationPathResolvedPolicy() : resolvedPolicy;
        context.ruleConfig = context.resolvedPolicy.getRuleConfig() == null
                ? new StationPathRuleConfig()
                : context.resolvedPolicy.getRuleConfig();
        context.profileConfig = context.resolvedPolicy.getProfileConfig() == null
                ? StationPathProfileConfig.defaultConfig()
                : context.resolvedPolicy.getProfileConfig();
        context.globalPolicy = loadPathGlobalPolicy(context.profileConfig);
        context.statusMap = loadStationStatusMap();
        context.stationLoopLoadMap = loadStationLoopLoadMap();
        context.trafficSnapshot = loadStationTrafficSnapshot(context.statusMap, currentTaskNo);
        context.loopMergeGuardContext = loadLoopMergeGuardContext();
        context.outStationIdSet = loadAllOutStationIdSet();
        context.forbidStationIdSet = new HashSet<>(safeList(context.ruleConfig.getHard() == null ? null : context.ruleConfig.getHard().getForbidStations()));
        context.forbidEdgeSet = new HashSet<>();
        for (String edgeText : safeList(context.ruleConfig.getHard() == null ? null : context.ruleConfig.getHard().getForbidEdges())) {
            if (notBlank(edgeText)) {
                context.forbidEdgeSet.add(edgeText.replace(" ", ""));
            }
        }
        context.softReferenceStationSet = new HashSet<>(getSoftReferencePath(context.ruleConfig.getSoft()));
        return context;
    }

    private List<NavigateNode> findStationReachablePath(List<List<NavigateNode>> allList,
                                                        StationPathResolvedPolicy resolvedPolicy,
                                                        Integer startStationId,
@@ -335,8 +801,22 @@
    private List<NavigateNode> findStationBestPathTwoStage(List<List<NavigateNode>> allList,
                                                           StationPathResolvedPolicy resolvedPolicy,
                                                           Integer currentTaskNo,
                                                           Double pathLenFactor,
                                                           Integer startStationId,
                                                           Integer endStationId) {
        List<List<NavigateNode>> orderedPathList = orderStationPathCandidates(allList, resolvedPolicy, currentTaskNo, pathLenFactor, startStationId, endStationId);
        if (orderedPathList.isEmpty()) {
            return new ArrayList<>();
        }
        return orderedPathList.get(0);
    }

    private List<List<NavigateNode>> orderStationPathCandidates(List<List<NavigateNode>> allList,
                                                                StationPathResolvedPolicy resolvedPolicy,
                                                                Integer currentTaskNo,
                                                                Double pathLenFactor,
                                                                Integer startStationId,
                                                                Integer endStationId) {
        if (allList == null || allList.isEmpty()) {
            return new ArrayList<>();
        }
@@ -407,7 +887,8 @@
            return new ArrayList<>();
        }

        metricsList.sort((a, b) -> compareDouble(a.staticCost, b.staticCost, a.turnCount, b.turnCount, a.pathLen, b.pathLen));
        applyPathLengthPreference(metricsList, profileConfig, globalPolicy, pathLenFactor);
        metricsList.sort((a, b) -> compareStaticCandidateMetrics(a, b, pathLenFactor));
        PathCandidateMetrics preferred = metricsList.get(0);
        int maxLen = (int) Math.ceil(preferred.pathLen * safeDouble(profileConfig.getS1MaxLenRatio(), 1.15d));
        int maxTurns = preferred.turnCount + safeInt(profileConfig.getS1MaxTurnDiff(), 1);
@@ -423,12 +904,41 @@
        }

        int topK = safeInt(profileConfig.getS1TopK(), 5);
        if (topK > 0 && stage1Selected.size() > topK) {
            stage1Selected = new ArrayList<>(stage1Selected.subList(0, topK));
        List<PathCandidateMetrics> primaryMetrics = new ArrayList<>(stage1Selected);
        List<PathCandidateMetrics> secondaryMetrics = new ArrayList<>();
        if (topK > 0 && primaryMetrics.size() > topK) {
            secondaryMetrics.addAll(primaryMetrics.subList(topK, primaryMetrics.size()));
            primaryMetrics = new ArrayList<>(primaryMetrics.subList(0, topK));
        }

        stage1Selected.sort((a, b) -> compareDouble(a.dynamicCost, b.dynamicCost, a.pathLen, b.pathLen, a.turnCount, b.turnCount));
        return stage1Selected.get(0).path;
        primaryMetrics.sort((a, b) -> compareDynamicCandidateMetrics(a, b, pathLenFactor));
        secondaryMetrics.sort((a, b) -> compareDynamicCandidateMetrics(a, b, pathLenFactor));

        List<PathCandidateMetrics> remainingMetrics = new ArrayList<>();
        for (PathCandidateMetrics metrics : metricsList) {
            if (!stage1Selected.contains(metrics)) {
                remainingMetrics.add(metrics);
            }
        }
        remainingMetrics.sort((a, b) -> compareDynamicCandidateMetrics(a, b, pathLenFactor));

        List<List<NavigateNode>> orderedPathList = new ArrayList<>();
        appendCandidatePathList(orderedPathList, primaryMetrics);
        appendCandidatePathList(orderedPathList, secondaryMetrics);
        appendCandidatePathList(orderedPathList, remainingMetrics);
        return orderedPathList;
    }

    private void appendCandidatePathList(List<List<NavigateNode>> orderedPathList,
                                         List<PathCandidateMetrics> metricsList) {
        if (orderedPathList == null || metricsList == null) {
            return;
        }
        for (PathCandidateMetrics metrics : metricsList) {
            if (metrics != null && metrics.path != null && !metrics.path.isEmpty()) {
                orderedPathList.add(metrics.path);
            }
        }
    }

    private List<List<NavigateNode>> applyRuleFilters(List<List<NavigateNode>> allList,
@@ -681,9 +1191,9 @@
        double congWeightFactor = globalPolicy == null ? 1.0d : globalPolicy.congWeightFactor;
        double passOtherOutStationPenaltyWeight = globalPolicy == null ? 0.0d : globalPolicy.passOtherOutStationPenaltyWeight;

        metrics.staticCost =
                safeDouble(profileConfig.getS1LenWeight(), 1.0d) * lenWeightFactor * metrics.pathLen
                        + safeDouble(profileConfig.getS1TurnWeight(), 3.0d) * metrics.turnCount
        metrics.baseLengthWeight = safeDouble(profileConfig.getS1LenWeight(), 1.0d) * lenWeightFactor;
        metrics.otherStaticCost =
                safeDouble(profileConfig.getS1TurnWeight(), 3.0d) * metrics.turnCount
                        + safeDouble(profileConfig.getS1LiftWeight(), 8.0d) * metrics.liftTransferCount
                        + passOtherOutStationPenaltyWeight * metrics.passOtherOutStationCount
                        + softDeviationWeight * metrics.softDeviationCount;
@@ -724,6 +1234,105 @@
        int leftLiftCount = countLiftTransferCount(left);
        int rightLiftCount = countLiftTransferCount(right);
        return compareDouble(leftLen, rightLen, leftTurnCount, rightTurnCount, leftLiftCount, rightLiftCount);
    }

    private void applyPathLengthPreference(List<PathCandidateMetrics> metricsList,
                                           StationPathProfileConfig profileConfig,
                                           PathGlobalPolicy globalPolicy,
                                           Double pathLenFactor) {
        if (metricsList == null || metricsList.isEmpty()) {
            return;
        }
        double normalizedFactor = normalizePathLenFactor(pathLenFactor);
        int minPathLen = Integer.MAX_VALUE;
        int maxPathLen = Integer.MIN_VALUE;
        for (PathCandidateMetrics metrics : metricsList) {
            if (metrics == null) {
                continue;
            }
            minPathLen = Math.min(minPathLen, metrics.pathLen);
            maxPathLen = Math.max(maxPathLen, metrics.pathLen);
        }
        if (minPathLen == Integer.MAX_VALUE || maxPathLen == Integer.MIN_VALUE) {
            return;
        }
        double targetPathLen = normalizedFactor <= 0.0d || maxPathLen <= minPathLen
                ? minPathLen
                : minPathLen + normalizedFactor * (maxPathLen - minPathLen);
        for (PathCandidateMetrics metrics : metricsList) {
            if (metrics == null) {
                continue;
            }
            metrics.pathLenPreferenceDistance = normalizedFactor <= 0.0d
                    ? metrics.pathLen
                    : Math.abs(metrics.pathLen - targetPathLen);
            metrics.staticCost = metrics.baseLengthWeight * metrics.pathLenPreferenceDistance + metrics.otherStaticCost;
        }
    }

    private int compareStaticCandidateMetrics(PathCandidateMetrics left,
                                              PathCandidateMetrics right,
                                              Double pathLenFactor) {
        if (left == right) {
            return 0;
        }
        if (left == null) {
            return 1;
        }
        if (right == null) {
            return -1;
        }
        int result = Double.compare(left.staticCost, right.staticCost);
        if (result != 0) {
            return result;
        }
        result = Double.compare(left.pathLenPreferenceDistance, right.pathLenPreferenceDistance);
        if (result != 0) {
            return result;
        }
        result = Integer.compare(left.turnCount, right.turnCount);
        if (result != 0) {
            return result;
        }
        return comparePathLenTie(left.pathLen, right.pathLen, pathLenFactor);
    }

    private int compareDynamicCandidateMetrics(PathCandidateMetrics left,
                                               PathCandidateMetrics right,
                                               Double pathLenFactor) {
        if (left == right) {
            return 0;
        }
        if (left == null) {
            return 1;
        }
        if (right == null) {
            return -1;
        }
        int result = Double.compare(left.dynamicCost, right.dynamicCost);
        if (result != 0) {
            return result;
        }
        result = Double.compare(left.pathLenPreferenceDistance, right.pathLenPreferenceDistance);
        if (result != 0) {
            return result;
        }
        result = comparePathLenTie(left.pathLen, right.pathLen, pathLenFactor);
        if (result != 0) {
            return result;
        }
        return Integer.compare(left.turnCount, right.turnCount);
    }

    private int comparePathLenTie(int leftPathLen, int rightPathLen, Double pathLenFactor) {
        double normalizedFactor = normalizePathLenFactor(pathLenFactor);
        if (normalizedFactor <= 0.0d) {
            return Integer.compare(leftPathLen, rightPathLen);
        }
        if (normalizedFactor >= 0.5d) {
            return Integer.compare(rightPathLen, leftPathLen);
        }
        return Integer.compare(leftPathLen, rightPathLen);
    }

    private int countLiftTransferCount(List<NavigateNode> path) {
@@ -1120,18 +1729,46 @@
                    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;
                        for (Integer nextStationId : resolveConnectedStationIds(stationId, nextNode)) {
                            if (nextStationId == null || stationId.equals(nextStationId)) {
                                continue;
                            }
                            graph.computeIfAbsent(nextStationId, key -> new LinkedHashSet<>());
                            graph.get(stationId).add(nextStationId);
                            graph.get(nextStationId).add(stationId);
                        }
                        graph.computeIfAbsent(nextStationId, key -> new LinkedHashSet<>());
                        graph.get(stationId).add(nextStationId);
                        graph.get(nextStationId).add(stationId);
                    }
                }
            }
        }
        return graph;
    }

    private Set<Integer> resolveConnectedStationIds(Integer currentStationId, NavigateNode nextNode) {
        Set<Integer> stationIdSet = new LinkedHashSet<>();
        if (nextNode == null || nextNode.getNodeValue() == null) {
            return stationIdSet;
        }
        try {
            JSONObject value = JSON.parseObject(nextNode.getNodeValue());
            if (value == null) {
                return stationIdSet;
            }
            Integer directStationId = value.getInteger("stationId");
            if (directStationId != null && !directStationId.equals(currentStationId)) {
                stationIdSet.add(directStationId);
            }
            JSONArray bridgeStationIds = value.getJSONArray("bridgeStationIds");
            if (bridgeStationIds != null) {
                for (Integer bridgeStationId : bridgeStationIds.toJavaList(Integer.class)) {
                    if (bridgeStationId != null && !bridgeStationId.equals(currentStationId)) {
                        stationIdSet.add(bridgeStationId);
                    }
                }
            }
        } catch (Exception ignore) {
        }
        return stationIdSet;
    }

    private List<Integer> loadStationLevList() {
@@ -1250,42 +1887,7 @@
                                           StationTrafficSnapshot trafficSnapshot,
                                           LoopMergeGuardContext loopMergeGuardContext,
                                           Set<LoopMergeEntry> mandatoryLoopMergeEntrySet) {
        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;
            }

            LoopMergeEntry currentEntry = new LoopMergeEntry(prevStationId, currentStationId);
            for (Integer trunkNeighborStationId : trunkNeighborSet) {
                if (isStationOccupiedForLoopMerge(trunkNeighborStationId, statusMap, trafficSnapshot)) {
                    return false;
                }
            }
            boolean mandatoryEntry = mandatoryLoopMergeEntrySet != null && mandatoryLoopMergeEntrySet.contains(currentEntry);
            if (!mandatoryEntry && !isLoopTrunkVeryIdle(currentStationId, loopMergeGuardContext, statusMap, trafficSnapshot)) {
                return false;
            }
        }
        // 环线并入保护已停用：允许候选路径直接参与后续评分。
        return true;
    }

@@ -1808,12 +2410,258 @@
        return value == null ? defaultValue : value;
    }

    private double normalizePathLenFactor(Double pathLenFactor) {
        if (pathLenFactor == null) {
            return 0.0d;
        }
        if (pathLenFactor < 0.0d) {
            return 0.0d;
        }
        if (pathLenFactor > 1.0d) {
            return 1.0d;
        }
        return pathLenFactor;
    }

    private boolean notBlank(String text) {
        return text != null && !text.trim().isEmpty();
    }

    private StationPathSearchContext buildStationPathSearchContext(Integer startStationId,
                                                                   Integer endStationId,
                                                                   StationPathResolvedPolicy resolvedPolicy,
                                                                   StationPathCalcMode calcMode) {
        BasStation startStation = basStationService.getById(startStationId);
        if (startStation == null) {
            throw new CoolException("未找到该 起点 对应的站点数据");
        }
        Integer lev = startStation.getStationLev();

        NavigateSolution navigateSolution = new NavigateSolution();
        List<List<NavigateNode>> stationMap = navigateSolution.getStationMap(lev);

        NavigateNode startNode = navigateSolution.findStationNavigateNode(stationMap, startStationId);
        if (startNode == null) {
            throw new CoolException("未找到该 起点 对应的节点");
        }

        NavigateNode endNode = navigateSolution.findStationNavigateNode(stationMap, endStationId);
        if (endNode == null) {
            throw new CoolException("未找到该 终点 对应的节点");
        }

        StationPathProfileConfig profileConfig = resolvedPolicy.getProfileConfig() == null
                ? StationPathProfileConfig.defaultConfig()
                : resolvedPolicy.getProfileConfig();

        long startTime = System.currentTimeMillis();
        News.info("[WCS Debug] 站点路径开始计算,startStationId={},endStationId={},mode={}",
                startStationId,
                endStationId,
                calcMode == null ? "" : calcMode.name());
        int calcMaxDepth = safeInt(profileConfig.getCalcMaxDepth(), 120);
        int calcMaxPaths = safeInt(profileConfig.getCalcMaxPaths(), 500);
        int calcMaxCost = safeInt(profileConfig.getCalcMaxCost(), 300);
        List<Integer> guideStationSequence = buildGuideStationSequence(startStationId, endStationId, resolvedPolicy.getRuleConfig());
        List<List<NavigateNode>> allList = navigateSolution.allSimplePaths(
                stationMap,
                startNode,
                endNode,
                calcMaxDepth,
                calcMaxPaths,
                calcMaxCost,
                guideStationSequence
        );
        if (allList.isEmpty()) {
            return StationPathSearchContext.empty(resolvedPolicy);
        }
        Map<Integer, StationProtocol> statusMap = loadStationStatusMap();
        allList = filterNonAutoStationPaths(allList, statusMap);
        if (allList.isEmpty()) {
            News.info("[WCS Debug] 站点路径候选全部被过滤，存在非自动站点,startStationId={},endStationId={}", startStationId, endStationId);
            return StationPathSearchContext.empty(resolvedPolicy);
        }
        News.info("[WCS Debug] 站点路径计算完成，耗时：{}ms,startStationId={},endStationId={},mode={}",
                System.currentTimeMillis() - startTime,
                startStationId,
                endStationId,
                calcMode == null ? "" : calcMode.name());
        return new StationPathSearchContext(allList, resolvedPolicy);
    }

    private List<List<NavigateNode>> normalizeCandidatePaths(List<List<NavigateNode>> orderedPathList) {
        List<List<NavigateNode>> result = new ArrayList<>();
        if (orderedPathList == null || orderedPathList.isEmpty()) {
            return result;
        }
        Set<String> seenPathSignatures = new LinkedHashSet<>();
        for (List<NavigateNode> path : orderedPathList) {
            List<NavigateNode> normalizedPath = normalizeStationPath(path);
            String pathSignature = buildPathSignature(normalizedPath);
            if (pathSignature.isEmpty() || !seenPathSignatures.add(pathSignature)) {
                continue;
            }
            result.add(normalizedPath);
        }
        return result;
    }

    private List<NavigateNode> normalizeStationPath(List<NavigateNode> path) {
        List<NavigateNode> filterList = new ArrayList<>();
        Integer lastStationId = null;
        for (NavigateNode navigateNode : safeList(path)) {
            if (navigateNode == null) {
                continue;
            }
            JSONObject valueObject;
            try {
                valueObject = JSON.parseObject(navigateNode.getNodeValue());
            } catch (Exception ignore) {
                continue;
            }
            if (valueObject == null || valueObject.containsKey("rgvCalcFlag")) {
                continue;
            }
            Integer stationId = valueObject.getInteger("stationId");
            if (stationId == null) {
                continue;
            }
            // 仅压缩连续重复站点，保留环线重算场景下后续再次经过的同一站点。
            if (lastStationId != null && lastStationId.equals(stationId)) {
                continue;
            }
            lastStationId = stationId;
            NavigateNode clonedNode = navigateNode.clone();
            if (clonedNode == null) {
                continue;
            }
            filterList.add(clonedNode);
        }

        for (int i = 0; i < filterList.size(); i++) {
            NavigateNode currentNode = filterList.get(i);
            currentNode.setIsInflectionPoint(false);
            currentNode.setIsLiftTransferPoint(false);

            try {
                JSONObject valueObject = JSON.parseObject(currentNode.getNodeValue());
                if (valueObject != null) {
                    Object isLiftTransfer = valueObject.get("isLiftTransfer");
                    if (isLiftTransfer != null) {
                        String isLiftTransferStr = isLiftTransfer.toString();
                        if ("1".equals(isLiftTransferStr) || "true".equalsIgnoreCase(isLiftTransferStr)) {
                            currentNode.setIsLiftTransferPoint(true);
                        }
                    }
                }
            } catch (Exception ignore) {
            }

            NavigateNode nextNode = (i + 1 < filterList.size()) ? filterList.get(i + 1) : null;
            NavigateNode prevNode = (i - 1 >= 0) ? filterList.get(i - 1) : null;

            HashMap<String, Object> searchResult = searchInflectionPoint(currentNode, nextNode, prevNode);
            if (Boolean.parseBoolean(searchResult.get("result").toString())) {
                currentNode.setIsInflectionPoint(true);
                currentNode.setDirection(searchResult.get("direction").toString());
            }
        }
        return filterList;
    }

    private String buildPathSignature(List<NavigateNode> path) {
        List<Integer> stationIdList = extractStationIdList(path);
        if (stationIdList.isEmpty()) {
            return "";
        }
        StringBuilder builder = new StringBuilder();
        for (Integer stationId : stationIdList) {
            if (stationId == null) {
                continue;
            }
            if (builder.length() > 0) {
                builder.append("->");
            }
            builder.append(stationId);
        }
        return builder.toString();
    }

    private <T> List<T> safeList(List<T> list) {
        return list == null ? Collections.emptyList() : list;
    }

    private static class StationPathSearchContext {
        private final List<List<NavigateNode>> allList;
        private final StationPathResolvedPolicy resolvedPolicy;

        private StationPathSearchContext(List<List<NavigateNode>> allList,
                                         StationPathResolvedPolicy resolvedPolicy) {
            this.allList = allList == null ? new ArrayList<>() : allList;
            this.resolvedPolicy = resolvedPolicy == null ? new StationPathResolvedPolicy() : resolvedPolicy;
        }

        private static StationPathSearchContext empty(StationPathResolvedPolicy resolvedPolicy) {
            return new StationPathSearchContext(new ArrayList<>(), resolvedPolicy);
        }
    }

    private static class DirectStationPathContext {
        private StationPathCalcMode calcMode;
        private Integer startStationId;
        private Integer endStationId;
        private NavigateSolution navigateSolution;
        private List<List<NavigateNode>> stationMap;
        private NavigateNode startNode;
        private NavigateNode endNode;
        private StationPathResolvedPolicy resolvedPolicy;
        private StationPathRuleConfig ruleConfig;
        private StationPathProfileConfig profileConfig;
        private PathGlobalPolicy globalPolicy;
        private Map<Integer, StationProtocol> statusMap = new HashMap<>();
        private Map<Integer, Double> stationLoopLoadMap = new HashMap<>();
        private StationTrafficSnapshot trafficSnapshot = new StationTrafficSnapshot();
        private LoopMergeGuardContext loopMergeGuardContext = new LoopMergeGuardContext();
        private Set<Integer> outStationIdSet = new HashSet<>();
        private Set<Integer> forbidStationIdSet = new HashSet<>();
        private Set<String> forbidEdgeSet = new HashSet<>();
        private Set<Integer> softReferenceStationSet = new HashSet<>();
    }

    private static class DirectPathState {
        private final NavigateNode node;
        private final DirectPathState parent;
        private final double gScore;
        private final double fScore;

        private DirectPathState(NavigateNode node,
                                DirectPathState parent,
                                double gScore,
                                double fScore) {
            this.node = node;
            this.parent = parent;
            this.gScore = gScore;
            this.fScore = fScore;
        }
    }

    private static class DirectPathSearchResult {
        private final List<NavigateNode> path;
        private final boolean includeWaypoint;
        private final boolean includeSoftPreference;

        private DirectPathSearchResult(List<NavigateNode> path,
                                       boolean includeWaypoint,
                                       boolean includeSoftPreference) {
            this.path = path == null ? new ArrayList<>() : path;
            this.includeWaypoint = includeWaypoint;
            this.includeSoftPreference = includeSoftPreference;
        }

        private static DirectPathSearchResult empty(boolean includeWaypoint,
                                                    boolean includeSoftPreference) {
            return new DirectPathSearchResult(new ArrayList<>(), includeWaypoint, includeSoftPreference);
        }
    }

    private static class PathCandidateMetrics {
@@ -1829,6 +2677,9 @@
        private int runBlockCount;
        private int softDeviationCount;
        private double loopPenalty;
        private double baseLengthWeight;
        private double otherStaticCost;
        private double pathLenPreferenceDistance;
        private double staticCost;
        private double dynamicCost;
    }