From beb476733eaff1f3a76ec1be772337655803cccb Mon Sep 17 00:00:00 2001
From: luxiaotao1123 <t1341870251@163.com>
Date: 星期五, 25 十月 2024 10:53:10 +0800
Subject: [PATCH] #

---
 zy-acs-manager/src/main/java/com/zy/acs/manager/core/DispatcherTestController.java |   80 +++++++++++++++++++++++++-
 zy-acs-manager/src/main/java/com/zy/acs/manager/core/domain/Lane.java              |   76 ++++++++++++++++++++++++
 2 files changed, 149 insertions(+), 7 deletions(-)

diff --git a/zy-acs-manager/src/main/java/com/zy/acs/manager/core/DispatcherTestController.java b/zy-acs-manager/src/main/java/com/zy/acs/manager/core/DispatcherTestController.java
index cf46e47..928cb40 100644
--- a/zy-acs-manager/src/main/java/com/zy/acs/manager/core/DispatcherTestController.java
+++ b/zy-acs-manager/src/main/java/com/zy/acs/manager/core/DispatcherTestController.java
@@ -38,13 +38,13 @@
         Map<String, List<String>> adjacencyCodeMap = new HashMap<>();
         for (Code code : codeList) {
             List<Long> adjacencyNode = routeService.getAdjacencyNode(code.getId());
-            adjacencyCodeMap.put(code.getData(), adjacencyNode.stream().map(node -> {
-                return codeService.getById(node).getData();
-            }).collect(Collectors.toList()));
+            adjacencyCodeMap.put(code.getData(), adjacencyNode.stream().map(node -> (
+                    codeService.getById(node).getData()
+            )).collect(Collectors.toList()));
         }
         List<String> codeDataList = codeList.stream().map(Code::getData).collect(Collectors.toList());
-        System.out.println(codeDataList.toString());
-        System.out.println(adjacencyCodeMap.toString());
+//        System.out.println(codeDataList.toString());
+//        System.out.println(adjacencyCodeMap.toString());
 
 
         Set<String> visited = new HashSet<>();
@@ -74,6 +74,76 @@
             }
         }
 
+        /**
+         * 1.explore a dead end lane and checkout end point that is not dead point
+         * 2.if this point has two near points and one of those points which not in current lane was also have two near points too
+         * 3.then merge above two lane because they can connect each other
+         */
+        Iterator<Lane> iterator = lanes.iterator();
+        while (iterator.hasNext()) {
+            Lane lane = iterator.next();
+            String[] endPoints = lane.queryEndPoints();
+            if (null == endPoints) {
+                continue;
+            }
+            String startPoint = endPoints[0];
+            String endPoint = endPoints[1];
+
+            boolean isDeadEndLane = false;
+            String deadEndPoint = null;
+            Integer anotherPointNearsCount = null;
+            if (adjacencyCodeMap.get(startPoint).size() == 1) {
+                isDeadEndLane = true;
+                deadEndPoint = startPoint;
+                anotherPointNearsCount = adjacencyCodeMap.get(endPoint).size();
+            }
+            if (adjacencyCodeMap.get(endPoint).size() == 1) {
+                isDeadEndLane = true;
+                deadEndPoint = endPoint;
+                anotherPointNearsCount = adjacencyCodeMap.get(startPoint).size();
+            }
+
+            if (!isDeadEndLane) {
+                continue;
+            }
+
+            if (anotherPointNearsCount == 2) {
+                String anotherPoint = deadEndPoint.equals(startPoint) ? endPoint : startPoint;
+                List<String> anotherPointNears = adjacencyCodeMap.get(anotherPoint);
+                for (String anotherPointNear : anotherPointNears) {
+                    if (!lane.getCodes().contains(anotherPointNear) && adjacencyCodeMap.get(anotherPointNear).size() == 2) {
+
+                        for (Lane lane0 : lanes) {
+                            if (lane0.getCodes().contains(anotherPointNear)) {
+
+                                lane0.getCodes().addAll(lane.getCodes());
+                                iterator.remove();
+
+
+                                Collections.shuffle(lane0.getCodes());
+                                System.out.println(lane0.getCodes().toString());
+                                for (String code : lane0.getCodes()) {
+                                    System.out.println("key: " + code + "; val" + adjacencyCodeMap.get(code).toString());
+                                }
+                                lane0.sortUsingDfs(adjacencyCodeMap);
+                                System.out.println(lane0.getCodes().toString());
+
+
+                            }
+
+                        }
+
+                    }
+                }
+            }
+
+        }
+
+        for (Lane lane : lanes) {
+            lane.removeInteraction(adjacencyCodeMap);
+        }
+
+        lanes.removeIf(next -> next.getCodes().size() <= 2);
 
         System.out.println(GsonUtils.toJson(lanes));
         return R.ok().add(lanes);
diff --git a/zy-acs-manager/src/main/java/com/zy/acs/manager/core/domain/Lane.java b/zy-acs-manager/src/main/java/com/zy/acs/manager/core/domain/Lane.java
index 1f40536..123b768 100644
--- a/zy-acs-manager/src/main/java/com/zy/acs/manager/core/domain/Lane.java
+++ b/zy-acs-manager/src/main/java/com/zy/acs/manager/core/domain/Lane.java
@@ -1,9 +1,9 @@
 package com.zy.acs.manager.core.domain;
 
+import com.zy.acs.framework.common.Cools;
 import lombok.Data;
 
-import java.util.ArrayList;
-import java.util.List;
+import java.util.*;
 
 /**
  * Created by vincent on 10/24/2024
@@ -22,4 +22,76 @@
         this.laneId = laneId;
     }
 
+    public String[] queryEndPoints() {
+        if (Cools.isEmpty(this.codes)) {
+            return null;
+        }
+        String[] endPoints = new String[2];
+        if (this.codes.size() == 1) {
+            endPoints[0] = this.codes.get(0);
+            endPoints[1] = this.codes.get(0);
+        } else {
+            endPoints[0] = this.codes.get(0);
+            endPoints[1] = this.codes.get(this.codes.size() - 1);
+        }
+        return endPoints;
+    }
+
+    public void sortUsingDfs(Map<String, List<String>> adjacencyCodeMap) {
+        if (Cools.isEmpty(this.codes) || this.codes.size() < 2) {
+            return;
+        }
+        Set<String> visited = new HashSet<>();
+        List<String> result = new ArrayList<>();
+
+        String startNode = findStartNode(adjacencyCodeMap);
+        dfs(startNode, adjacencyCodeMap, visited, result);
+
+        for (String code : this.codes) {
+            if (!visited.contains(code)) {
+                dfs(code, adjacencyCodeMap, visited, result);
+            }
+        }
+
+        this.codes = result;
+    }
+
+    private String findStartNode(Map<String, List<String>> adjacencyCodeMap) {
+        for (String code : this.codes) {
+            List<String> neighbors = adjacencyCodeMap.get(code);
+            if (!Cools.isEmpty(neighbors)) {
+                int count = 0;
+                for (String neighbor : neighbors) {
+                    if (this.codes.contains(neighbor)) {
+                        count++;
+                    }
+                }
+                if (count == 1) {
+                    return code;
+                }
+            }
+        }
+        return null;
+    }
+
+    private static void dfs(String node, Map<String, List<String>> adjacencyCodeMap, Set<String> visited, List<String> result) {
+        visited.add(node);
+        result.add(node);
+
+        if (adjacencyCodeMap.containsKey(node)) {
+            for (String neighbor : adjacencyCodeMap.get(node)) {
+                if (!visited.contains(neighbor)) {
+                    dfs(neighbor, adjacencyCodeMap, visited, result);
+                }
+            }
+        }
+    }
+
+    public void removeInteraction(Map<String, List<String>> adjacencyCodeMap) {
+        if (Cools.isEmpty(this.codes)) {
+            return;
+        }
+        this.codes.removeIf(code -> adjacencyCodeMap.get(code).size() > 2);
+    }
+
 }

--
Gitblit v1.9.1