From b6a5196e33123840bb4472993816ba2fd9d72cc3 Mon Sep 17 00:00:00 2001
From: Junjie <fallin.jie@qq.com>
Date: 星期四, 02 四月 2026 13:31:23 +0800
Subject: [PATCH] #算法优化
---
src/main/java/com/zy/core/thread/impl/ZyStationV5Thread.java | 2
src/main/java/com/zy/core/utils/station/StationDispatchLoadSupport.java | 6
src/main/java/com/zy/asrs/controller/BasStationPathPolicyController.java | 4
src/main/java/com/zy/core/thread/impl/ZyStationV3Thread.java | 2
src/main/java/com/zy/core/thread/impl/ZyStationV4Thread.java | 2
src/main/java/com/zy/core/utils/station/StationOutboundDecisionSupport.java | 4
src/main/java/com/zy/asrs/domain/path/StationPathCalcMode.java | 13 +
src/main/java/com/zy/common/utils/NavigateUtils.java | 647 ++++++++++++++++++++++++++++++++++++++++++++++++++---
8 files changed, 632 insertions(+), 48 deletions(-)
diff --git a/src/main/java/com/zy/asrs/controller/BasStationPathPolicyController.java b/src/main/java/com/zy/asrs/controller/BasStationPathPolicyController.java
index 33d83e2..d5c8db0 100644
--- a/src/main/java/com/zy/asrs/controller/BasStationPathPolicyController.java
+++ b/src/main/java/com/zy/asrs/controller/BasStationPathPolicyController.java
@@ -172,7 +172,7 @@
@RequestParam Integer endStationId,
@RequestParam(required = false, defaultValue = "false") Boolean includeMapData) {
StationPathResolvedPolicy resolved = stationPathPolicyService.resolvePolicy(startStationId, endStationId);
- List<NavigateNode> nodes = navigateUtils.calcByStationId(startStationId, endStationId);
+ List<NavigateNode> nodes = navigateUtils.calcOptimalPathByStationId(startStationId, endStationId, null, null);
List<Integer> stationIdList = new ArrayList<>();
List<Map<String, Object>> nodeList = new ArrayList<>();
Set<Integer> seen = new HashSet<>();
@@ -238,7 +238,7 @@
}
continue;
}
- List<NavigateNode> segmentNodes = navigateUtils.calcByStationId(segmentStart, segmentEnd);
+ List<NavigateNode> segmentNodes = navigateUtils.calcOptimalPathByStationId(segmentStart, segmentEnd, null, null);
List<Integer> segmentStationIds = extractStationIds(segmentNodes);
if (segmentStationIds.isEmpty()) {
return R.error("鏈壘鍒� " + segmentStart + " 鍒� " + segmentEnd + " 鐨勫彲琛岃矾寰�");
diff --git a/src/main/java/com/zy/asrs/domain/path/StationPathCalcMode.java b/src/main/java/com/zy/asrs/domain/path/StationPathCalcMode.java
new file mode 100644
index 0000000..14e6dec
--- /dev/null
+++ b/src/main/java/com/zy/asrs/domain/path/StationPathCalcMode.java
@@ -0,0 +1,13 @@
+package com.zy.asrs.domain.path;
+
+/**
+ * 杈撻�佺珯鐐硅矾寰勮绠楁ā寮忋��
+ * REACHABILITY: 鍙垽鏂彲杈撅紝涓嶈�冭檻鎷ュ牭绛夊姩鎬佸洜绱狅紝浼樺厛杩斿洖鏈�蹇彲琛岃矾寰勩��
+ * OPTIMAL: 姝ｅ父鍛戒护鐢熸垚鍦烘櫙锛屽彧璁＄畻鍗曟潯鏈�浼樿矾寰勶紝涓嶆灇涓惧叏閮ㄥ�欓�夈��
+ * REROUTE: 閲嶈鍒掑満鏅紝闇�瑕佹灇涓惧�欓�夎矾绾垮悗鍐嶅仛鎷╀紭銆�
+ */
+public enum StationPathCalcMode {
+ REACHABILITY,
+ OPTIMAL,
+ REROUTE
+}
diff --git a/src/main/java/com/zy/common/utils/NavigateUtils.java b/src/main/java/com/zy/common/utils/NavigateUtils.java
index 541c143..74c70f6 100644
--- a/src/main/java/com/zy/common/utils/NavigateUtils.java
+++ b/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;
@@ -73,42 +75,28 @@
@Autowired
private StationTaskTraceRegistry stationTaskTraceRegistry;
- public synchronized List<NavigateNode> calcByStationId(Integer startStationId, Integer endStationId) {
- return calcByStationId(startStationId, endStationId, null, null, false);
- }
-
- public synchronized List<NavigateNode> calcByStationId(Integer startStationId,
- Integer endStationId,
- Double pathLenFactor) {
- return calcByStationId(startStationId, endStationId, null, pathLenFactor, false);
- }
-
- public synchronized List<NavigateNode> calcByStationId(Integer startStationId, Integer endStationId, Integer currentTaskNo) {
- return calcByStationId(startStationId, endStationId, currentTaskNo, null, false);
- }
-
- public synchronized List<NavigateNode> calcByStationId(Integer startStationId,
- Integer endStationId,
- Integer currentTaskNo,
- Double pathLenFactor) {
- return calcByStationId(startStationId, endStationId, currentTaskNo, pathLenFactor, false);
+ public synchronized List<NavigateNode> calcOptimalPathByStationId(Integer startStationId,
+ Integer endStationId,
+ Integer currentTaskNo,
+ Double pathLenFactor) {
+ return calcPathByStationId(startStationId, endStationId, currentTaskNo, pathLenFactor, StationPathCalcMode.OPTIMAL);
}
public synchronized List<NavigateNode> calcReachablePathByStationId(Integer startStationId, Integer endStationId) {
- return calcByStationId(startStationId, endStationId, null, null, true);
- }
-
- public synchronized List<List<NavigateNode>> calcCandidatePathByStationId(Integer startStationId,
- Integer endStationId,
- Integer currentTaskNo) {
- return calcCandidatePathByStationId(startStationId, endStationId, currentTaskNo, null);
+ return calcPathByStationId(startStationId, endStationId, null, null, StationPathCalcMode.REACHABILITY);
}
public synchronized List<List<NavigateNode>> calcCandidatePathByStationId(Integer startStationId,
Integer endStationId,
Integer currentTaskNo,
Double pathLenFactor) {
- StationPathSearchContext context = buildStationPathSearchContext(startStationId, endStationId);
+ StationPathResolvedPolicy resolvedPolicy = resolveStationPathPolicy(startStationId, endStationId);
+ StationPathSearchContext context = buildStationPathSearchContext(
+ startStationId,
+ endStationId,
+ resolvedPolicy,
+ StationPathCalcMode.REROUTE
+ );
if (context.allList.isEmpty()) {
return new ArrayList<>();
}
@@ -137,16 +125,36 @@
return snapshot;
}
- private synchronized List<NavigateNode> calcByStationId(Integer startStationId,
- Integer endStationId,
- Integer currentTaskNo,
- Double pathLenFactor,
- boolean reachabilityOnly) {
- StationPathSearchContext context = buildStationPathSearchContext(startStationId, endStationId);
+ private synchronized 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 = reachabilityOnly
+ 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);
@@ -261,6 +269,502 @@
News.warn("绔欑偣璺緞绛栫暐鍔犺浇澶辫触锛屽洖閫�榛樿 twoStage: {}", e.getMessage());
}
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,
@@ -1923,7 +2427,10 @@
return text != null && !text.trim().isEmpty();
}
- private StationPathSearchContext buildStationPathSearchContext(Integer startStationId, Integer endStationId) {
+ private StationPathSearchContext buildStationPathSearchContext(Integer startStationId,
+ Integer endStationId,
+ StationPathResolvedPolicy resolvedPolicy,
+ StationPathCalcMode calcMode) {
BasStation startStation = basStationService.getById(startStationId);
if (startStation == null) {
throw new CoolException("鏈壘鍒拌 璧风偣 瀵瑰簲鐨勭珯鐐规暟鎹�");
@@ -1943,13 +2450,15 @@
throw new CoolException("鏈壘鍒拌 缁堢偣 瀵瑰簲鐨勮妭鐐�");
}
- 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);
+ 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);
@@ -1972,7 +2481,11 @@
News.info("[WCS Debug] 绔欑偣璺緞鍊欓�夊叏閮ㄨ杩囨护锛屽瓨鍦ㄩ潪鑷姩绔欑偣,startStationId={},endStationId={}", startStationId, endStationId);
return StationPathSearchContext.empty(resolvedPolicy);
}
- News.info("[WCS Debug] 绔欑偣璺緞璁＄畻瀹屾垚锛岃�楁椂锛歿}ms", System.currentTimeMillis() - startTime);
+ News.info("[WCS Debug] 绔欑偣璺緞璁＄畻瀹屾垚锛岃�楁椂锛歿}ms,startStationId={},endStationId={},mode={}",
+ System.currentTimeMillis() - startTime,
+ startStationId,
+ endStationId,
+ calcMode == null ? "" : calcMode.name());
return new StationPathSearchContext(allList, resolvedPolicy);
}
@@ -2093,6 +2606,64 @@
}
}
+ 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 {
private List<NavigateNode> path;
private int pathLen;
diff --git a/src/main/java/com/zy/core/thread/impl/ZyStationV3Thread.java b/src/main/java/com/zy/core/thread/impl/ZyStationV3Thread.java
index 5abc04a..8914dd1 100644
--- a/src/main/java/com/zy/core/thread/impl/ZyStationV3Thread.java
+++ b/src/main/java/com/zy/core/thread/impl/ZyStationV3Thread.java
@@ -310,7 +310,7 @@
if (navigateUtils == null) {
return new ArrayList<>();
}
- List<NavigateNode> nodes = navigateUtils.calcByStationId(startStationId, targetStationId, taskNo, pathLenFactor);
+ List<NavigateNode> nodes = navigateUtils.calcOptimalPathByStationId(startStationId, targetStationId, taskNo, pathLenFactor);
List<Integer> ids = new ArrayList<>();
for (NavigateNode n : nodes) {
JSONObject v = JSONObject.parseObject(n.getNodeValue());
diff --git a/src/main/java/com/zy/core/thread/impl/ZyStationV4Thread.java b/src/main/java/com/zy/core/thread/impl/ZyStationV4Thread.java
index a08a715..4a11023 100644
--- a/src/main/java/com/zy/core/thread/impl/ZyStationV4Thread.java
+++ b/src/main/java/com/zy/core/thread/impl/ZyStationV4Thread.java
@@ -337,7 +337,7 @@
if (navigateUtils == null) {
return new ArrayList<>();
}
- return navigateUtils.calcByStationId(startStationId, targetStationId, taskNo, pathLenFactor);
+ return navigateUtils.calcOptimalPathByStationId(startStationId, targetStationId, taskNo, pathLenFactor);
}
private void executeMoveWithSeg(StationCommand original) {
diff --git a/src/main/java/com/zy/core/thread/impl/ZyStationV5Thread.java b/src/main/java/com/zy/core/thread/impl/ZyStationV5Thread.java
index 17bd7f8..5166a7b 100644
--- a/src/main/java/com/zy/core/thread/impl/ZyStationV5Thread.java
+++ b/src/main/java/com/zy/core/thread/impl/ZyStationV5Thread.java
@@ -351,7 +351,7 @@
if (navigateUtils == null) {
return new ArrayList<>();
}
- return navigateUtils.calcByStationId(startStationId, targetStationId, taskNo, pathLenFactor);
+ return navigateUtils.calcOptimalPathByStationId(startStationId, targetStationId, taskNo, pathLenFactor);
}
private List<List<NavigateNode>> calcCandidatePathNavigateNodes(Integer taskNo,
diff --git a/src/main/java/com/zy/core/utils/station/StationDispatchLoadSupport.java b/src/main/java/com/zy/core/utils/station/StationDispatchLoadSupport.java
index 55d951c..d7a77a4 100644
--- a/src/main/java/com/zy/core/utils/station/StationDispatchLoadSupport.java
+++ b/src/main/java/com/zy/core/utils/station/StationDispatchLoadSupport.java
@@ -141,7 +141,7 @@
try {
List<NavigateNode> nodes = wrkMast == null
- ? navigateUtils.calcByStationId(sourceStationId, targetStationId)
+ ? navigateUtils.calcOptimalPathByStationId(sourceStationId, targetStationId, null, null)
: calcOutboundNavigatePath(wrkMast, sourceStationId, targetStationId, pathLenFactor);
if (nodes == null || nodes.isEmpty()) {
return LoopHitResult.noHit();
@@ -213,9 +213,9 @@
Double normalizedFactor = normalizePathLenFactor(pathLenFactor);
Integer currentTaskNo = wrkMast == null ? null : wrkMast.getWrkNo();
if (currentTaskNo == null) {
- return navigateUtils.calcByStationId(sourceStationId, targetStationId, normalizedFactor);
+ return navigateUtils.calcOptimalPathByStationId(sourceStationId, targetStationId, null, normalizedFactor);
}
- return navigateUtils.calcByStationId(sourceStationId, targetStationId, currentTaskNo, normalizedFactor);
+ return navigateUtils.calcOptimalPathByStationId(sourceStationId, targetStationId, currentTaskNo, normalizedFactor);
}
private Integer getStationIdFromNode(NavigateNode node) {
diff --git a/src/main/java/com/zy/core/utils/station/StationOutboundDecisionSupport.java b/src/main/java/com/zy/core/utils/station/StationOutboundDecisionSupport.java
index 5bfc4a0..3a1450c 100644
--- a/src/main/java/com/zy/core/utils/station/StationOutboundDecisionSupport.java
+++ b/src/main/java/com/zy/core/utils/station/StationOutboundDecisionSupport.java
@@ -200,9 +200,9 @@
Double normalizedFactor = normalizePathLenFactor(pathLenFactor);
Integer currentTaskNo = wrkMast == null ? null : wrkMast.getWrkNo();
if (currentTaskNo == null) {
- return navigateUtils.calcByStationId(sourceStationId, targetStationId, normalizedFactor);
+ return navigateUtils.calcOptimalPathByStationId(sourceStationId, targetStationId, null, normalizedFactor);
}
- return navigateUtils.calcByStationId(sourceStationId, targetStationId, currentTaskNo, normalizedFactor);
+ return navigateUtils.calcOptimalPathByStationId(sourceStationId, targetStationId, currentTaskNo, normalizedFactor);
}
private boolean isBatchOutboundTaskWithSeq(WrkMast wrkMast) {
--
Gitblit v1.9.1