Merge pull request #155 from DevKor-github/develop

innerroute main 통합

Author: dlwls423

src/main/java/devkor/com/teamcback/domain/routes/entity/Edge.java

@@ -2,6 +2,7 @@
 
 import devkor.com.teamcback.domain.common.BaseEntity;
 import lombok.Getter;
+import lombok.Setter;
 
 @Getter
 public class Edge extends BaseEntity {
@@ -11,9 +12,14 @@ public class Edge extends BaseEntity {
 
     private Long endNode;
 
-    public Edge(long distance, Long startNode, Long endNode) {
+    @Setter
+    private long weight;
+
+    public Edge(long distance, long weight, Long startNode, Long endNode) {
         this.distance = distance;
+        this.weight = weight;
         this.startNode = startNode;
         this.endNode = endNode;
     }
+
 }

src/main/java/devkor/com/teamcback/domain/routes/service/RouteService.java

@@ -39,14 +39,18 @@ public class RouteService {
     private static final Double INIT_OUTDOOR_DISTANCE = Double.MAX_VALUE;
     private static final Double MAX_OUTDOOR_DISTANCE = 0.003;
     private static final Double MIN_OUTDOOR_DISTANCE = 0.0001;
+    private static final Double INDOOR_ROUTE_WEIGHT = 0.3;
 
     /**
      * 메인 경로탐색 메서드
      */
     @Transactional(readOnly = true)
     public List<GetRouteRes> findRoute(LocationType startType, Long startId, Double startLat, Double startLong,
-        LocationType endType, Long endId, Double endLat, Double endLong, List<Conditions> conditions){
+                                       LocationType endType, Long endId, Double endLat, Double endLong, List<Conditions> conditions){
 
+        if (conditions == null){
+            conditions = new ArrayList<>();
+        }
         // 출발, 도착 노드 검색
         Node startNode = getNodeByType(startType, startId, startLat, startLong);
         Node endNode = getNodeByType(endType, endId, endLat, endLong);
@@ -64,10 +68,6 @@ public List<GetRouteRes> findRoute(LocationType startType, Long startId, Double
         GetGraphRes graphRes = getGraph(buildingList, startNode, endNode, conditions);
         DijkstraRes route = dijkstra(graphRes, startNode, endNode);
 
-        // 경로를 하나만 반환한다면 경로가 없을 때 예외 처리
-        if (route.getPath().isEmpty()) {
-            throw new GlobalException(NOT_FOUND_ROUTE);
-        }
         routeRes.add(buildRouteResponse(route, startType == LocationType.BUILDING, endType == LocationType.BUILDING));
 
         // 베리어프리만 추가로 적용하는 경우(임시)
@@ -171,18 +171,32 @@ private List<Building> getBuildingsForRoute(Node startNode, Node endNode) {
     }
 
     /**
-     * 출발/도착지에 직접적으로 연결된 건물들이 있는 경우 buildingList에 추가하는 메서드
+     * 출발/도착지에 연결된 건물들이 있는 경우 buildingList에 추가하는 메서드
+     * 연쇄적으로 연결된 건물들도 반영하도록(ex: 엘포관-백기-중지-SK미래관...) 수정
      */
-    private void addConnectedBuildings(Building building, List<Building> buildingList) {
-        List<Long> connectedBuildingIds = connectedBuildingRepository.findConnectedBuildingsByBuilding(building);
-        for (Long connectedBuildingId : connectedBuildingIds) {
-            if (buildingList.stream()
-                .noneMatch(existingBuilding -> existingBuilding.getId().equals(connectedBuildingId))) {
-                buildingList.add(findBuilding(connectedBuildingId));
+    private void addConnectedBuildings(Building startBuilding, List<Building> buildingList) {
+        Queue<Building> queue = new LinkedList<>();
+        Set<Long> visited = new HashSet<>();
+
+        queue.add(startBuilding);
+        visited.add(startBuilding.getId());
+
+        while (!queue.isEmpty()) {
+            Building currentBuilding = queue.poll();
+
+            List<Long> connectedBuildingIds = connectedBuildingRepository.findConnectedBuildingsByBuilding(currentBuilding);
+            for (Long connectedBuildingId : connectedBuildingIds) {
+                if (!visited.contains(connectedBuildingId)) {
+                    Building connectedBuilding = findBuilding(connectedBuildingId);
+                    buildingList.add(connectedBuilding);
+                    queue.add(connectedBuilding);
+                    visited.add(connectedBuildingId);
+                }
             }
         }
     }
 
+
     /**
      * 그래프 요소 찾기(node, edge 묶음)
      * 노드 테이블의 String 인접 노드와 거리를 그래프로 변환
@@ -228,7 +242,9 @@ private GetGraphRes getGraph(List<Building> buildingList, Node startNode, Node e
                 graphEdge.put(node.getId(), new ArrayList<>());
             }
             for (int i = 0; i < nextNodeId.length; i++) {
-                graphEdge.get(node.getId()).add(new Edge(distance[i], node.getId(), nextNodeId[i]));
+                long weight = (conditions.contains(Conditions.INNERROUTE) && node.getBuilding().getId() != OUTDOOR_ID) ? Math.round(distance[i] * INDOOR_ROUTE_WEIGHT) : distance[i];
+                Edge edge = new Edge(distance[i], weight, node.getId(), nextNodeId[i]);
+                graphEdge.get(node.getId()).add(edge);
             }
         }
         return new GetGraphRes(graphNode, graphEdge);
@@ -257,12 +273,12 @@ else if (conditions.contains(Conditions.SHUTTLE)){
     private DijkstraRes dijkstra(GetGraphRes graphRes, Node startNode, Node endNode) {
         List<Node> nodes = graphRes.getGraphNode();
         Map<Long, List<Edge>> edges = graphRes.getGraphEdge();
-        Map<Long, Long> distances = new HashMap<>(); // 출발 노드부터의 거리
-        Map<Long, Long> previousNodes = new HashMap<>(); // 경로 반환을 위해 다시 거꾸로 추적하기 위한 노드 순서 저장
-        PriorityQueue<NodeDistancePair> priorityQueue = new PriorityQueue<>(); // 시작 노드와 거리가 짧은 노드 순으로 선택 가능
-        Set<Long> visitedNodes = new HashSet<>(); // 이미 방문한 노드 id 체크
+        Map<Long, Long> distances = new HashMap<>();
+        Map<Long, Long> previousNodes = new HashMap<>();
+        PriorityQueue<NodeDistancePair> priorityQueue = new PriorityQueue<>();
+        Set<Long> visitedNodes = new HashSet<>();
 
-        // 모든 노드를 초기화
+        // 모든 노드 초기화
         for (Node node : nodes) {
             if (node.equals(startNode)) {
                 distances.put(node.getId(), 0L);
@@ -273,27 +289,23 @@ private DijkstraRes dijkstra(GetGraphRes graphRes, Node startNode, Node endNode)
             previousNodes.put(node.getId(), null);
         }
 
+        // Dijkstra 실행 (weight 기준)
         while (!priorityQueue.isEmpty()) {
             NodeDistancePair currentPair = priorityQueue.poll();
             Long currentNode = currentPair.node;
 
-            if (visitedNodes.contains(currentNode)) { // 방문한 노드면 패스
-                continue;
-            }
+            if (visitedNodes.contains(currentNode)) continue;
             visitedNodes.add(currentNode);
 
-            if (currentNode.equals(endNode.getId())) { // 도착하면 종료
-                break;
-            }
+            if (currentNode.equals(endNode.getId())) break;
 
-            if(!edges.containsKey(currentNode)) continue;
+            if (!edges.containsKey(currentNode)) continue;
             for (Edge edge : edges.get(currentNode)) {
                 Long neighbor = edge.getEndNode();
                 Long currentDistance = distances.get(currentNode);
-                if (currentDistance == null) {
-                    continue; // currentNode가 distances에 존재하지 않는 경우를 대비
-                }
-                Long newDist = currentDistance + edge.getDistance();
+                if (currentDistance == null) continue;
+
+                Long newDist = currentDistance + edge.getWeight(); //weight 기반 탐색으로 수정
                 Long neighborDist = distances.get(neighbor);
                 if (neighborDist == null || newDist < neighborDist) {
                     distances.put(neighbor, newDist);
@@ -303,21 +315,34 @@ private DijkstraRes dijkstra(GetGraphRes graphRes, Node startNode, Node endNode)
             }
         }
 
-        // 경로 생성
+        //path 생성
         List<Node> path = new ArrayList<>();
-        Long finalDistance = distances.get(endNode.getId());
-        if (finalDistance.equals(INF)) {
-            return new DijkstraRes(-1L, Collections.emptyList()); // 경로가 존재하지 않을 때
-        }
-
+        Node pathPrevNode = null;
+        Long finalDistance = 0L;
         for (Long at = endNode.getId(); at != null; at = previousNodes.get(at)) {
             Node node = nodeRepository.findById(at).orElseThrow(() -> new GlobalException(NOT_FOUND_ROUTE));
+            if (pathPrevNode != null) {
+                Edge edge = findEdge(edges, node.getId(), pathPrevNode.getId());
+                finalDistance += edge.getDistance();
+            }
             path.add(node);
+            pathPrevNode = node;
         }
         Collections.reverse(path);
 
+        //예외처리: path가 제대로 나오지 않는 경우. 즉, 경로가 존재하지 않는 경우
+        if (path.isEmpty() || !path.get(0).equals(startNode)) {
+            throw new GlobalException(NOT_FOUND_ROUTE);
+        }
+
         return new DijkstraRes(finalDistance, path);
     }
+    private Edge findEdge(Map<Long, List<Edge>> edges, Long from, Long to) {
+        return edges.get(from).stream()
+                .filter(edge -> edge.getEndNode().equals(to))
+                .findFirst()
+                .orElse(null);
+    }
 
     /**
      * 경로를 분할하고 응답 형식에 맞게 변환
@@ -328,7 +353,6 @@ private GetRouteRes buildRouteResponse(DijkstraRes route, boolean isStartBuildin
         Long duration = route.getDistance();
         List<List<Node>> path = cutRoute(route.getPath()); // 분할된 경로
 
-        //시작, 끝이 건물인 경우 해당 노드 지우기
         //시작, 끝이 건물인 경우 해당 노드 지우기
         if (isStartBuilding) {
             // 첫번째 path의 길이에 따라 삭제 다르게 하기
@@ -338,7 +362,10 @@ private GetRouteRes buildRouteResponse(DijkstraRes route, boolean isStartBuildin
                 path.remove(0);
             }
         }
-        if (isEndBuilding) path.get(path.size()-1).remove(path.get(path.size()-1).size()-1);
+
+        if (isEndBuilding && path.get(path.size()-1).size() != 1) {
+            path.get(path.size()-1).remove(path.get(path.size()-1).size()-1);
+        }
 
         List<PartialRouteRes> totalRoute = new ArrayList<>();
 
@@ -350,8 +377,8 @@ private GetRouteRes buildRouteResponse(DijkstraRes route, boolean isStartBuildin
             List<List<Double>> partialRoute = convertNodesToCoordinates(thisPath, isOutside);
 
             PartialRouteRes partialRouteRes = isOutside
-                ? new PartialRouteRes(partialRoute) // 야외 경로
-                : new PartialRouteRes(thisPath.get(0).getBuilding().getId(), thisPath.get(0).getFloor(), partialRoute); // 실내 경로
+                    ? new PartialRouteRes(partialRoute) // 야외 경로
+                    : new PartialRouteRes(thisPath.get(0).getBuilding().getId(), thisPath.get(0).getFloor(), partialRoute); // 실내 경로
 
             // 부분 경로의 마지막 노드인 경우 설명 추가
             if (i + 1 == path.size()) {
@@ -384,8 +411,8 @@ private List<List<Node>> cutRoute(List<Node> route) {
 
             // 새로운 건물로 이동할 때 & 체크포인트일때 & 외부에서 새로운 건물로 들어갈 때(입구 분리) 경로분할
             if ((!thisNode.getBuilding().equals(nextNode.getBuilding()) && thisNode.getBuilding().getId() != OUTDOOR_ID)
-                || (thisNode.getType() != nextNode.getType() && thisNode.getType() == NodeType.CHECKPOINT)
-                || (thisNode.getBuilding().getId() == OUTDOOR_ID && nextNode.getType() == NodeType.ENTRANCE)) {
+                    || (thisNode.getType() != nextNode.getType() && thisNode.getType() == NodeType.CHECKPOINT)
+                    || (thisNode.getBuilding().getId() == OUTDOOR_ID && nextNode.getType() == NodeType.ENTRANCE)) {
                 partialRoute.add(thisNode);
                 returnRoute.add(new ArrayList<>(partialRoute));
                 partialRoute.clear();
@@ -488,7 +515,7 @@ private String makeInfo(Node prevNode, Node nextNode){
     private Building findLinkedBuilding(Node node){
         Long[] adjacentNodeIds = convertStringToArray(node.getAdjacentNode());
         return buildingRepository.findByNodeIdIn(adjacentNodeIds)
-            .orElseThrow(() -> new AdminException(INCORRECT_NODE_DATA,node.getId() + "번 노드에 연결된 건물이 없습니다"));
+                .orElseThrow(() -> new AdminException(INCORRECT_NODE_DATA,node.getId() + "번 노드에 연결된 건물이 없습니다"));
     }
 
     /**