新增充电桩

zhang

2025-05-20 1313906bb1eb983d3beece810035e7fc28d6a92f

 zy-acs-manager/src/main/java/com/zy/acs/manager/core/service/MapService.java

@@ -2,7 +2,6 @@

import com.zy.acs.common.enums.AgvDirectionType;
import com.zy.acs.framework.common.Cools;
import com.zy.acs.manager.common.utils.MapDataUtils;
import com.zy.acs.manager.core.constant.MapDataConstant;
import com.zy.acs.manager.core.domain.SortCodeDto;
import com.zy.acs.manager.core.domain.UnlockPathTask;
@@ -13,6 +12,7 @@
import com.zy.acs.manager.manager.entity.Code;
import com.zy.acs.manager.manager.entity.Loc;
import com.zy.acs.manager.manager.entity.Segment;
import com.zy.acs.manager.manager.entity.Sta;
import com.zy.acs.manager.manager.service.ActionService;
import com.zy.acs.manager.manager.service.CodeService;
import com.zy.acs.manager.system.service.ConfigService;
@@ -34,6 +34,8 @@
@Slf4j
@Component("mapService")
public class MapService {

    private final static int[][] DIRECTIONS = {{0,1},{0,-1},{-1,0},{1,0}};

    @Value("${floyd.enable}")
    private Boolean floydEnable;
@@ -122,6 +124,18 @@
        }).collect(Collectors.toList());
    }

    public static Double mapToNearest(Double angle) {
        if (null == angle) {
            return null;
        }
        angle = (angle + 360) % 360;
        double remainder = angle % 45;
        if (remainder < 22.5) {
            return angle - remainder;
        } else {
            return angle + (45 - remainder);
        }
    }

    // 角度计算
    public Double calculateDirection(Code startCode, Code endCode, int angleOffsetVal) {
@@ -133,7 +147,7 @@

        double deltaX = x1 - x0;
        double deltaY = y1 - y0;
        double angle = -Math.atan2(deltaX, deltaY);
        double angle = Math.atan2(deltaX, deltaY);
        angle = Math.toDegrees(angle) + angleOffsetVal;
        angle = (angle + 360) % 360; // 将角度转换为正值

@@ -141,7 +155,7 @@
    }

    // 坐标货架阈值 todo:luxiaotao
    public AgvDirectionType calculateAgvWorkDirection(Loc loc, Code code) {
    public AgvDirectionType calculateAgvWorkDirectionByShelf(Loc loc, Code code) {
        Integer compDirect = loc.getCompDirect();
        AgvDirectionType agvDirectionType = null;
        if (compDirect == 0) {
@@ -153,6 +167,19 @@
        return agvDirectionType;
    }

    public Double getStaAngle(Sta sta, Double workDirection) {
        if (null == sta) {
            return null;
        }
        if (Cools.isEmpty(sta.getAngle())) {
            return workDirection;
        }
        return Double.parseDouble(sta.getAngle());
    }

    public Double calculateAgvWorkDirectionByStation(Double staWorkDirection, Double lastDirection) {
        return Math.abs(staWorkDirection - lastDirection) + 90.0D;
    }

    public double calculateDistance(double x1, double y1, double x2, double y2) {
        double deltaX = x2 - x1;
@@ -182,8 +209,46 @@
    }

    public void unlockPath(String agvNo, String codeData) {
        if (Cools.isEmpty(agvNo, codeData)) {
            return;
        }
        try {
            unlockTaskQueue.offer(new UnlockPathTask(agvNo, codeData), 5, TimeUnit.SECONDS);

//            Integer lev = null;
//
//            String[][] codeMatrix = mapDataDispatcher.getCodeMatrix(null);
//            int[] codeMatrixIdx = mapDataDispatcher.getCodeMatrixIdx(lev, codeData);
//
//
//            DynamicNode[][] dynamicMatrix = mapDataDispatcher.getDynamicMatrix(lev);
//
//            DynamicNode dynamicNode = dynamicMatrix[codeMatrixIdx[0]][codeMatrixIdx[1]];
//
//
//            int serial = dynamicNode.getSerial();
//
//            List<int[]> resetCodeIdxList = new ArrayList<>();
//
//            for (int i = 0; i < dynamicMatrix.length; i++) {
//                for (int j = 0; j < dynamicMatrix[i].length; j++) {
//
////                    if (i == codeMatrixIdx[0] && j == codeMatrixIdx[1]) { continue; }
//
//                    DynamicNode node = dynamicMatrix[i][j];
//                    if (node.getVehicle().equals(agvNo)) {
//                        if (node.getSerial() < serial) {
//                            resetCodeIdxList.add(new int[] {i, j});
//                        }
//                    }
//                }
//            }
//
//            if (!Cools.isEmpty(resetCodeIdxList)) {
//
//                mapDataDispatcher.clearDynamicMatrixByCodeList(lev, resetCodeIdxList);
//            }

        } catch (InterruptedException e) {
            log.error("unlockTaskQueue", e);
        }
@@ -209,8 +274,10 @@

    // v1 BFS ------------------------------------------------------------------------------
    public List<NavigateNode> getWaveScopeByCode(Integer lev, String code, Double radiusLen) {
        double radiusLenSquared = Math.pow(radiusLen, 2);

        String[][] codeMatrix = mapDataDispatcher.getCodeMatrix(lev);
        String[][] cdaMatrix = mapDataDispatcher.getCdaMatrix(lev);
        Double[][][] cdaMatrix = mapDataDispatcher.getCdaMatrix(lev);

        int[] codeMatrixIdx = mapDataDispatcher.getCodeMatrixIdx(lev, code);
        NavigateNode originNode = new NavigateNode(codeMatrixIdx[0], codeMatrixIdx[1], code);
@@ -221,25 +288,25 @@
        includeList.add(originNode);
        existNodes.add(originNode);

        this.spreadWaveNode(originNode, originNode, codeMatrix, cdaMatrix, radiusLen, includeList, existNodes);
        this.spreadWaveNode(originNode, originNode, codeMatrix, cdaMatrix, radiusLenSquared, includeList, existNodes);

        return includeList;
    }

    public void spreadWaveNode(NavigateNode originNode, NavigateNode currNode
            , String[][] codeMatrix, String[][] cdaMatrix, Double radiusLen
            , String[][] codeMatrix, Double[][][] cdaMatrix, Double radiusLenSquared
            , List<NavigateNode> includeList, Set<NavigateNode> existNodes) {
        int x = currNode.getX();
        int y = currNode.getY();

        this.extendNeighborNodes(originNode, new NavigateNode(x, y + 1), codeMatrix, cdaMatrix, radiusLen, includeList, existNodes);
        this.extendNeighborNodes(originNode, new NavigateNode(x, y - 1), codeMatrix, cdaMatrix, radiusLen, includeList, existNodes);
        this.extendNeighborNodes(originNode, new NavigateNode(x - 1, y), codeMatrix, cdaMatrix, radiusLen, includeList, existNodes);
        this.extendNeighborNodes(originNode, new NavigateNode(x + 1, y), codeMatrix, cdaMatrix, radiusLen, includeList, existNodes);
        this.extendNeighborNodes(originNode, new NavigateNode(x, y + 1), codeMatrix, cdaMatrix, radiusLenSquared, includeList, existNodes);
        this.extendNeighborNodes(originNode, new NavigateNode(x, y - 1), codeMatrix, cdaMatrix, radiusLenSquared, includeList, existNodes);
        this.extendNeighborNodes(originNode, new NavigateNode(x - 1, y), codeMatrix, cdaMatrix, radiusLenSquared, includeList, existNodes);
        this.extendNeighborNodes(originNode, new NavigateNode(x + 1, y), codeMatrix, cdaMatrix, radiusLenSquared, includeList, existNodes);
    }

    public void extendNeighborNodes(NavigateNode originNode, NavigateNode nextNode
            , String[][] codeMatrix, String[][] cdaMatrix, Double radiusLen
            , String[][] codeMatrix, Double[][][] cdaMatrix, Double radiusLenSquared
            , List<NavigateNode> includeList, Set<NavigateNode> existNodes) {

        int x = nextNode.getX();
@@ -256,100 +323,98 @@

        existNodes.add(nextNode);


        List<Double> o1Cda = MapDataUtils.parseCdaNode(cdaMatrix[originNode.getX()][originNode.getY()]);
        List<Double> o2Cda = MapDataUtils.parseCdaNode(cdaMatrix[x][y]);

        if (Math.pow(o1Cda.get(0) - o2Cda.get(0), 2) + Math.pow(o1Cda.get(1) - o2Cda.get(1), 2) <= Math.pow(radiusLen, 2)) {
        Double[] o1Cda = cdaMatrix[originNode.getX()][originNode.getY()];
        Double[] o2Cda = cdaMatrix[x][y];
        if (Math.pow(o1Cda[0] - o2Cda[0], 2) + Math.pow(o1Cda[1] - o2Cda[1], 2) <= radiusLenSquared) {
            nextNode.setCodeData(codeMatrix[x][y]);

            if (!nextNode.getCodeData().equals(CodeNodeType.NONE.val)) {
                includeList.add(nextNode);
            }

            this.spreadWaveNode(originNode, nextNode, codeMatrix, cdaMatrix, radiusLen, includeList, existNodes);
            this.spreadWaveNode(originNode, nextNode, codeMatrix, cdaMatrix, radiusLenSquared, includeList, existNodes);
        }

    }

    // v2 BFS ------------------------------------------------------------------------------
    public List<NavigateNode> getWaveScopeByCode0(Integer lev, String code, Double radiusLen) {
        String[][] codeMatrix = mapDataDispatcher.getCodeMatrix(lev);

        int[] codeMatrixIdx = mapDataDispatcher.getCodeMatrixIdx(lev, code);
        NavigateNode originNode = new NavigateNode(codeMatrixIdx[0], codeMatrixIdx[1], code);

        List<NavigateNode> includeList = new ArrayList<>();
        Set<NavigateNode> visited = new HashSet<>(); // Track visited nodes to avoid re-processing
        Queue<NavigateNode> queue = new LinkedList<>();

        includeList.add(originNode);
        visited.add(originNode);
        queue.offer(originNode);

        while (!queue.isEmpty()) {
            NavigateNode currNode = queue.poll();
            this.spreadWaveNode0(originNode, currNode, codeMatrix, radiusLen, includeList, visited, queue);
        }

        return includeList;
    }

    public void spreadWaveNode0(NavigateNode originNode, NavigateNode currNode,
                               String[][] codeMatrix, Double radiusLen,
                               List<NavigateNode> includeList, Set<NavigateNode> visited, Queue<NavigateNode> queue) {

        int x = currNode.getX();
        int y = currNode.getY();

        // Expand neighbors in all four directions (up, down, left, right)
        this.extendNeighborNodes0(originNode, new NavigateNode(x, y + 1), codeMatrix, radiusLen, includeList, visited, queue);
        this.extendNeighborNodes0(originNode, new NavigateNode(x, y - 1), codeMatrix, radiusLen, includeList, visited, queue);
        this.extendNeighborNodes0(originNode, new NavigateNode(x - 1, y), codeMatrix, radiusLen, includeList, visited, queue);
        this.extendNeighborNodes0(originNode, new NavigateNode(x + 1, y), codeMatrix, radiusLen, includeList, visited, queue);
    }

    public void extendNeighborNodes0(NavigateNode originNode, NavigateNode nextNode,
                                    String[][] codeMatrix, Double radiusLen,
                                    List<NavigateNode> includeList, Set<NavigateNode> visited, Queue<NavigateNode> queue) {
        int x = nextNode.getX();
        int y = nextNode.getY();

        // Check if the node is out of bounds
        if (x < 0 || x >= codeMatrix.length || y < 0 || y >= codeMatrix[0].length) {
            return;
        }

        // If the node has already been visited, skip it
        if (visited.contains(nextNode)) {
            return;
        }

        visited.add(nextNode);

        String nextNodeCodeData = codeMatrix[x][y];

        // If it's a NONE node, we still need to check its surroundings
        if (nextNodeCodeData.equals(CodeNodeType.NONE.val)) {
            this.spreadWaveNode0(originNode, nextNode, codeMatrix, radiusLen, includeList, visited, queue);
        } else {
            Integer lev = MapDataDispatcher.MAP_DEFAULT_LEV;
            String[][] cdaMatrix = mapDataDispatcher.getCdaMatrix(lev);

            // Check if the distance between nodes is within the radius length
            List<Double> o1Cda = MapDataUtils.parseCdaNode(cdaMatrix[originNode.getX()][originNode.getY()]);
            List<Double> o2Cda = MapDataUtils.parseCdaNode(cdaMatrix[nextNode.getX()][nextNode.getY()]);

            // Calculate Euclidean distance between the nodes
            if (Math.pow(o1Cda.get(0) - o2Cda.get(0), 2) + Math.pow(o1Cda.get(1) - o2Cda.get(1), 2) <= Math.pow(radiusLen, 2)) {
                nextNode.setCodeData(nextNodeCodeData);
                includeList.add(nextNode);

                // Add the node to the queue to expand its neighbors
                queue.offer(nextNode);
            }
        }
    }
//    public List<NavigateNode> getWaveScopeByCode0(Integer lev, String code, Double radiusLen) {
//        String[][] codeMatrix = mapDataDispatcher.getCodeMatrix(lev);
//
//        int[] codeMatrixIdx = mapDataDispatcher.getCodeMatrixIdx(lev, code);
//        NavigateNode originNode = new NavigateNode(codeMatrixIdx[0], codeMatrixIdx[1], code);
//
//        List<NavigateNode> includeList = new ArrayList<>();
//        Set<NavigateNode> visited = new HashSet<>(); // Track visited nodes to avoid re-processing
//        Queue<NavigateNode> queue = new LinkedList<>();
//
//        includeList.add(originNode);
//        visited.add(originNode);
//        queue.offer(originNode);
//
//        while (!queue.isEmpty()) {
//            NavigateNode currNode = queue.poll();
//            this.spreadWaveNode0(originNode, currNode, codeMatrix, radiusLen, includeList, visited, queue);
//        }
//
//        return includeList;
//    }
//
//    public void spreadWaveNode0(NavigateNode originNode, NavigateNode currNode,
//                               String[][] codeMatrix, Double radiusLen,
//                               List<NavigateNode> includeList, Set<NavigateNode> visited, Queue<NavigateNode> queue) {
//
//        int x = currNode.getX();
//        int y = currNode.getY();
//
//        // Expand neighbors in all four directions (up, down, left, right)
//        this.extendNeighborNodes0(originNode, new NavigateNode(x, y + 1), codeMatrix, radiusLen, includeList, visited, queue);
//        this.extendNeighborNodes0(originNode, new NavigateNode(x, y - 1), codeMatrix, radiusLen, includeList, visited, queue);
//        this.extendNeighborNodes0(originNode, new NavigateNode(x - 1, y), codeMatrix, radiusLen, includeList, visited, queue);
//        this.extendNeighborNodes0(originNode, new NavigateNode(x + 1, y), codeMatrix, radiusLen, includeList, visited, queue);
//    }
//
//    public void extendNeighborNodes0(NavigateNode originNode, NavigateNode nextNode,
//                                    String[][] codeMatrix, Double radiusLen,
//                                    List<NavigateNode> includeList, Set<NavigateNode> visited, Queue<NavigateNode> queue) {
//        int x = nextNode.getX();
//        int y = nextNode.getY();
//
//        // Check if the node is out of bounds
//        if (x < 0 || x >= codeMatrix.length || y < 0 || y >= codeMatrix[0].length) {
//            return;
//        }
//
//        // If the node has already been visited, skip it
//        if (visited.contains(nextNode)) {
//            return;
//        }
//
//        visited.add(nextNode);
//
//        String nextNodeCodeData = codeMatrix[x][y];
//
//        // If it's a NONE node, we still need to check its surroundings
//        if (nextNodeCodeData.equals(CodeNodeType.NONE.val)) {
//            this.spreadWaveNode0(originNode, nextNode, codeMatrix, radiusLen, includeList, visited, queue);
//        } else {
//            Integer lev = MapDataDispatcher.MAP_DEFAULT_LEV;
//            String[][] cdaMatrix = mapDataDispatcher.getCdaMatrix(lev);
//
//            // Check if the distance between nodes is within the radius length
//            List<Double> o1Cda = MapDataUtils.parseCdaNode(cdaMatrix[originNode.getX()][originNode.getY()]);
//            List<Double> o2Cda = MapDataUtils.parseCdaNode(cdaMatrix[nextNode.getX()][nextNode.getY()]);
//
//            // Calculate Euclidean distance between the nodes
//            if (Math.pow(o1Cda.get(0) - o2Cda.get(0), 2) + Math.pow(o1Cda.get(1) - o2Cda.get(1), 2) <= Math.pow(radiusLen, 2)) {
//                nextNode.setCodeData(nextNodeCodeData);
//                includeList.add(nextNode);
//
//                // Add the node to the queue to expand its neighbors
//                queue.offer(nextNode);
//            }
//        }
//    }


    public Boolean isTurnCorner(String codeData) {