From 2bdbfd1ac24d4e9a87daf6fb8b99ec32264d5752 Mon Sep 17 00:00:00 2001
From: luxiaotao1123 <t1341870251@163.com>
Date: 星期六, 21 十二月 2024 11:25:27 +0800
Subject: [PATCH] #

---
 zy-acs-manager/src/main/java/com/zy/acs/manager/core/service/RetreatNavigateService.java |  116 ++++++++++++++++++++++++++++++++++-----------------------
 1 files changed, 69 insertions(+), 47 deletions(-)

diff --git a/zy-acs-manager/src/main/java/com/zy/acs/manager/core/service/RetreatNavigateService.java b/zy-acs-manager/src/main/java/com/zy/acs/manager/core/service/RetreatNavigateService.java
index 4e66ed4..1583ceb 100644
--- a/zy-acs-manager/src/main/java/com/zy/acs/manager/core/service/RetreatNavigateService.java
+++ b/zy-acs-manager/src/main/java/com/zy/acs/manager/core/service/RetreatNavigateService.java
@@ -1,5 +1,7 @@
 package com.zy.acs.manager.core.service;
 
+import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
+import com.zy.acs.common.constant.RedisConstant;
 import com.zy.acs.common.utils.RedisSupport;
 import com.zy.acs.common.utils.Utils;
 import com.zy.acs.framework.common.Cools;
@@ -8,12 +10,13 @@
 import com.zy.acs.manager.core.domain.Lane;
 import com.zy.acs.manager.core.service.astart.*;
 import com.zy.acs.manager.core.service.astart.domain.DynamicNode;
+import com.zy.acs.manager.core.utils.RouteGenerator;
+import com.zy.acs.manager.manager.entity.Code;
 import com.zy.acs.manager.manager.entity.Jam;
 import com.zy.acs.manager.manager.entity.Route;
-import com.zy.acs.manager.manager.service.AgvModelService;
-import com.zy.acs.manager.manager.service.AgvService;
-import com.zy.acs.manager.manager.service.CodeService;
-import com.zy.acs.manager.manager.service.RouteService;
+import com.zy.acs.manager.manager.entity.Segment;
+import com.zy.acs.manager.manager.enums.JamStateType;
+import com.zy.acs.manager.manager.service.*;
 import com.zy.acs.manager.system.service.ConfigService;
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.beans.factory.annotation.Autowired;
@@ -31,7 +34,7 @@
 
     private final RedisSupport redis = RedisSupport.defaultRedisSupport;
 
-    public static final int WEIGHT_CALC_COEFFICIENT = 10000;
+    public static final int WEIGHT_CALC_FACTOR = 10000;
 
     @Autowired
     private CodeService codeService;
@@ -49,6 +52,10 @@
     private LaneService laneService;
     @Autowired
     private ConfigService configService;
+    @Autowired
+    private SegmentService segmentService;
+    @Autowired
+    private JamService jamService;
 
     /**
      * avoidPathList ===>>  [ minor vehicle ] [wave] [ curr vehicle ] [ code2 ] [ code3 ] ......
@@ -65,7 +72,7 @@
         List<String> blackList = Utils.singletonList(sponsor);
 
         Double avoidDistance = MapDataUtils.getVehicleWaveSafeDistance(agvModelService.getById(agvService.selectByUuid(sponsor).getAgvModel()).getDiameter()
-                , MapDataConstant.IDLE_DISTANCE_COE);
+                , MapDataConstant.MAX_DISTANCE_BETWEEN_ADJACENT_AGV_FACTOR);
         List<String> avoidPathListWave = mapService.getWaveScopeByCodeList(lev, avoidPathList, avoidDistance);
 
         DynamicNode[][] dynamicMatrix = mapDataDispatcher.getDynamicMatrix(lev);
@@ -75,20 +82,23 @@
         RetreatNavigateNode finialNode = null;
 
         PriorityQueue<RetreatNavigateNode> openQueue = new PriorityQueue<>();
-        ArrayList<RetreatNavigateNode> existNodes = new ArrayList<>();
+        Set<RetreatNavigateNode> existNodes = new HashSet<>();
 
         openQueue.add(start);
         existNodes.add(start);
+        boolean phaseSecond = true;
 
-        while (openQueue.size() > 0 && null == finialNode) {
+        while (!openQueue.isEmpty() && null == finialNode) {
 
             RetreatNavigateNode currentNode = openQueue.poll();
 
             List<RetreatNavigateNode> enableNodes = new ArrayList<>();
 
             ArrayList<RetreatNavigateNode> neighborNodes = this.getNeighborNodes(currentNode, existNodes);
+            boolean pointOfTurn = neighborNodes.size() >= 2;
             label: for (RetreatNavigateNode node : neighborNodes) {
                 if (node.getCodeData().equals(breakPoint)) { continue; }
+                Code code = codeService.selectByData(node.getCodeData());
 
                 int weight = 0;
 
@@ -103,35 +113,59 @@
                             continue label;
                         }
                         if (1 < mapDataDispatcher.queryCodeListFromDynamicNode(lev, otherWave).size()) {
+                            phaseSecond = false;    // there is a running way
                             continue label;
                         } else {
-                            weight += WEIGHT_CALC_COEFFICIENT;
+                            weight += WEIGHT_CALC_FACTOR;
                         }
                     }
                 }
 
                 // lane
-                Lane lane = laneService.search(node.getCodeData());
-                if (null != lane) {
-                    Set<String> lanVehicleSet = new HashSet<>();
+                if (pointOfTurn) {
+                    Lane lane = laneService.search(node.getCodeData());
+                    if (null != lane) {
+                        Set<String> lanVehicleSet = new HashSet<>();
 
-                    List<String> laneCodes = lane.getCodes();
-                    for (String laneCodeData : laneCodes) {
-                        int[] laneCodeMatrixIdx = mapDataDispatcher.getCodeMatrixIdx(null, laneCodeData);
-                        // scan dynamicMatrix or WaveMatrix
-                        DynamicNode laneDynamicNode = dynamicMatrix[laneCodeMatrixIdx[0]][laneCodeMatrixIdx[1]];
-                        String laneVehicle = laneDynamicNode.getVehicle();
-                        assert !laneVehicle.equals(DynamicNodeType.BLOCK.val);
-                        if (!laneVehicle.equals(DynamicNodeType.ACCESS.val)) {
-                            if (!laneVehicle.equals(agvNo)) {
-                                lanVehicleSet.add(laneVehicle);
-//                                redis.setObject(RedisConstant.AGV_TO_STANDBY_FLAG, laneVehicle, true, 30);
+                        for (String laneCodeData : lane.getCodes()) {
+                            // overlap with sponsor
+                            if (avoidPathList.contains(laneCodeData)) {
+                                lanVehicleSet.add(sponsor);
+                            }
+
+                            int[] laneCodeMatrixIdx = mapDataDispatcher.getCodeMatrixIdx(null, laneCodeData);
+                            // scan dynamicMatrix or WaveMatrix
+                            DynamicNode laneDynamicNode = dynamicMatrix[laneCodeMatrixIdx[0]][laneCodeMatrixIdx[1]];
+                            String laneVehicle = laneDynamicNode.getVehicle();
+                            assert !laneVehicle.equals(DynamicNodeType.BLOCK.val);
+                            if (!laneVehicle.equals(DynamicNodeType.ACCESS.val)) {
+                                if (!laneVehicle.equals(agvNo)) {
+                                    lanVehicleSet.add(laneVehicle);
+//                                    redis.setObject(RedisConstant.AGV_TO_STANDBY_FLAG, laneVehicle, true, 30);
+                                }
                             }
                         }
-                    }
 
-                    if (lanVehicleSet.size() + 1 > maxAgvCountInLane) {
-                        continue;
+                        if (lanVehicleSet.size() + 1 > maxAgvCountInLane) {
+                            phaseSecond = false;    // there is a running way
+                            continue;
+                        }
+                        if (lanVehicleSet.contains(sponsor)) {
+                            weight += WEIGHT_CALC_FACTOR * 2;
+                        }
+                    }
+                }
+
+                // judge whether the node has already been marked as a retreat node?
+                // This is a very troublesome matter, if the node be repeatedly mark as a retreat node
+                List<Segment> runningSegments = segmentService.getRunningByEndCode(code.getId());
+                for (Segment runningSeg : runningSegments) {
+                    if (0 < jamService.count(new LambdaQueryWrapper<Jam>()
+                            .eq(Jam::getAvoSeg, runningSeg.getId())
+                            .ne(Jam::getState, JamStateType.DEPRECATED.toString()))) {
+                        weight += WEIGHT_CALC_FACTOR * 3;
+                    } else {
+                        weight += WEIGHT_CALC_FACTOR;
                     }
                 }
 
@@ -159,7 +193,7 @@
         }
 
 
-        if (null == finialNode) {
+        if (null == finialNode && phaseSecond) {
 //            assert openQueue.size() == 0;
 
             existNodes.clear();
@@ -171,7 +205,7 @@
             int actualLanesOfTurn = 0;
             int filterPointOfTurnTimes = 0;
 
-            while (openQueue.size() > 0 && null == finialNode) {
+            while (!openQueue.isEmpty() && null == finialNode) {
 
                 RetreatNavigateNode currentNode = openQueue.poll();
                 List<RetreatNavigateNode> enableNodes = new ArrayList<>();
@@ -245,7 +279,7 @@
                                 }
                                 continue label;
                             } else {
-                                weight += WEIGHT_CALC_COEFFICIENT;
+                                weight += WEIGHT_CALC_FACTOR;
                             }
                         }
                     }
@@ -283,7 +317,7 @@
     }
 
     // 鑾峰彇鍥涘懆鑺傜偣
-    private ArrayList<RetreatNavigateNode> getNeighborNodes(RetreatNavigateNode currentNode, List<RetreatNavigateNode> existNodes) {
+    private ArrayList<RetreatNavigateNode> getNeighborNodes(RetreatNavigateNode currentNode, Set<RetreatNavigateNode> existNodes) {
 
         int x = currentNode.getX();
         int y = currentNode.getY();
@@ -313,7 +347,7 @@
         return neighbourNodes;
     }
 
-    private RetreatNavigateNode extendNeighborNodes(RetreatNavigateNode currentNode, RetreatNavigateNode extendNode, List<RetreatNavigateNode> existNodes, Integer dx, Integer dy) {
+    private RetreatNavigateNode extendNeighborNodes(RetreatNavigateNode currentNode, RetreatNavigateNode extendNode, Set<RetreatNavigateNode> existNodes, Integer dx, Integer dy) {
         RetreatNavigateNode nextNode;
 
         if (null == dx || null == dy) {
@@ -339,7 +373,7 @@
             return extendNeighborNodes(currentNode, nextNode, existNodes, dx, dy);
 
         } else {
-            if (this.isExist(nextNode, existNodes)) {
+            if (existNodes.contains(nextNode)) {
                 return null;
             }
 
@@ -354,26 +388,14 @@
             nextNode.setCodeData(nextNodeCodeData);
 
             // 鍒ゆ柇閫氳繃鎬�
-            Route route = routeService.findByCodeOfBoth(
-                    codeService.selectByData(currentNodeCodeData).getId(),
-                    codeService.selectByData(nextNodeCodeData).getId()
-            );
-            if (null == route) {
+            String routeKey = RouteGenerator.generateRouteKey(currentNodeCodeData, nextNodeCodeData);
+            Object routeVal = redis.getMap(RedisConstant.AGV_MAP_ROUTE_HASH_FLAG, routeKey);
+            if (routeVal == null || !(Boolean) routeVal) {
                 return null;
             }
-
         }
 
         return nextNode;
-    }
-
-    private boolean isExist(RetreatNavigateNode node, List<RetreatNavigateNode> existNodes) {
-        for (RetreatNavigateNode existNode : existNodes) {
-            if (this.isSame(node, existNode)) {
-                return true;
-            }
-        }
-        return false;
     }
 
     private boolean isSame(RetreatNavigateNode o1, RetreatNavigateNode o2) {

--
Gitblit v1.9.1