Working on animation of DCBSS.

Author: coderodde

src/main/java/io/github/coderodde/pathfinding/app/SettingsPane.java

@@ -376,7 +376,7 @@ protected List<Cell> call() throws Exception {
                     try {
                         this.path.clear();
                         this.path.addAll(task.get());
-                        System.out.println("PATH: " + this.path);
+//                        System.out.println("PATH: " + this.path);
                     } catch (InterruptedException | ExecutionException ex) {
                         System.getLogger(
                                 SettingsPane.class.getName()).log(

src/main/java/io/github/coderodde/pathfinding/finders/BeamStackSearchFinder.java

@@ -1,12 +1,14 @@
 package io.github.coderodde.pathfinding.finders;
 
+import static io.github.coderodde.pathfinding.finders.Finder.searchSleep;
 import io.github.coderodde.pathfinding.heuristics.HeuristicFunction;
 import io.github.coderodde.pathfinding.logic.GridCellNeighbourIterable;
 import io.github.coderodde.pathfinding.logic.PathfindingSettings;
 import io.github.coderodde.pathfinding.logic.SearchState;
 import io.github.coderodde.pathfinding.logic.SearchStatistics;
 import io.github.coderodde.pathfinding.model.GridModel;
 import io.github.coderodde.pathfinding.utils.Cell;
+import io.github.coderodde.pathfinding.utils.CellType;
 import java.util.ArrayDeque;
 import java.util.ArrayList;
 import java.util.Collections;
@@ -40,14 +42,35 @@ public List<Cell> findPath(GridModel model,
         U.value = Double.POSITIVE_INFINITY;
 
         while (!beamStack.isEmpty()) {
-            List<Cell> path = search(model, 
-                                     U,
-                                     beamStack,
-                                     neighbourIterable,
-                                     pathfindingSettings);
+            List<Cell> path = null;
+            
+            try {
+                path = search(model, 
+                              U,
+                              beamStack,
+                              neighbourIterable,
+                              pathfindingSettings,
+                              searchState,
+                              searchStatistics);
+                
+            } catch (HaltRequestedException ex) {
+                return List.of();
+            }
 
             System.out.println("bye bye");
 
+            if (searchState.haltRequested()) {
+                return List.of();
+            }
+            
+            while (searchState.pauseRequested()) {
+                searchSleep(pathfindingSettings);
+                
+                if (searchState.haltRequested()) {
+                    return List.of();
+                }
+            }
+            
             if (path != null) {
                 optimalPath = path;
                 U.value = getPathCost(path, pathfindingSettings);
@@ -71,6 +94,7 @@ public List<Cell> findPath(GridModel model,
     private static double 
         getPathCost(List<Cell> path,
                     PathfindingSettings pathsPathfindingSettings) {
+           
         double cost = 0.0;
 
         for (int i = 0; i < path.size() - 1; ++i) {
@@ -86,7 +110,9 @@ private static List<Cell> search(GridModel model,
                                      DoubleHolder U,
                                      Deque<BeamStackEntry> beamStack,
                                      GridCellNeighbourIterable iterable,
-                                     PathfindingSettings pathfindingSettings) {
+                                     PathfindingSettings pathfindingSettings,
+                                     SearchState searchState,
+                                     SearchStatistics searchStatistics) {
 
         Map<Integer, PriorityQueue<HeapNode>> open = new HashMap<>();
         Map<Integer, Set<Cell>> closed             = new HashMap<>();
@@ -97,22 +123,43 @@ private static List<Cell> search(GridModel model,
         Cell source = model.getSourceGridCell();
         Cell target = model.getTargetGridCell();
 
+        Cell bestGoal = null;
+        int layerIndex = 0;
+        
         open.put(0, new PriorityQueue<>());
         open.put(1, new PriorityQueue<>());
         open.get(0).add(new HeapNode(source, 0.0));
 
         closed.put(0, new HashSet<>());
         g.put(source, 0.0);
         p.put(source, null);
-        Cell bestGoal = null;
-        int layerIndex = 0;
+        
+        searchStatistics.incrementOpened();
 
         while (!open.get(layerIndex).isEmpty() ||
                !open.get(layerIndex + 1).isEmpty()) {
 
             while (!open.get(layerIndex).isEmpty()) {
+                
+                if (searchState.haltRequested()) {
+                    throw new HaltRequestedException();
+                }
+                
+                if (searchState.pauseRequested()) {
+                    continue;
+                }
+                
+                searchSleep(pathfindingSettings);
+                
                 Cell cell = open.get(layerIndex).remove().cell;
                 closed.get(layerIndex).add(cell);
+                searchStatistics.decrementOpened();
+                searchStatistics.incrementVisited();
+                
+                if (!cell.getCellType().equals(CellType.SOURCE)) {
+                    model.setCellType(cell, CellType.VISITED);
+                }
+                
                 System.out.println("shit!");
 
                 if (cell.equals(target)) {
@@ -125,17 +172,33 @@ private static List<Cell> search(GridModel model,
                 BeamStackEntry beamStackEntry = beamStack.peek();
 
                 for (Cell child : iterable) {
+                    if (searchState.haltRequested()) {
+                        throw new HaltRequestedException();
+                    }
+                    
+                    while (searchState.pauseRequested()) {
+                        searchSleep(pathfindingSettings);
+                        
+                        if (searchState.haltRequested()) {
+                            throw new HaltRequestedException();
+                        }
+                    }
+                    
                     if (g.containsKey(child)) {
                         continue;
                     }
 
+                    searchSleep(pathfindingSettings);
+                    
                     double gscore = g.get(cell) 
                                   + pathfindingSettings.getWeight(cell, 
                                                                   child);
 
                     double f = gscore + h.estimate(child, target);
 
                     if (beamStackEntry.fmin <= f && f <= beamStackEntry.fmax) {
+                        searchStatistics.incrementOpened();
+                        
                         open.get(layerIndex + 1).add(new HeapNode(child, f));
                         g.put(child, gscore);
                         p.put(child, cell);
@@ -145,24 +208,46 @@ private static List<Cell> search(GridModel model,
                 if (open.get(layerIndex + 1).size() > 
                         pathfindingSettings.getBeamWidth()) {
 
-                    pruneLayer(open.get(layerIndex + 1),
-                                        beamStack,
-                                        pathfindingSettings);
+                    pruneLayer(model,
+                               open.get(layerIndex + 1),
+                               beamStack,
+                               pathfindingSettings,
+                               searchStatistics);
                 }
             }
 
-//            if ((1 < layerIndex && layerIndex <= relay) ||
-//                (layerIndex > relay + 1)) {
-//                closed.get(layerIndex - 1).clear();
-//            }
-            
             layerIndex++;
             open.put(layerIndex + 1, new PriorityQueue<>());
             closed.put(layerIndex, new HashSet<>());
             beamStack.push(new BeamStackEntry(0, U.value));
             System.out.println("hello");
         }
 
+        for (PriorityQueue<HeapNode> queue : open.values()) {
+            for (HeapNode heapNode : queue) {
+                Cell cell = heapNode.cell;
+                
+                if (cell.getCellType().equals(CellType.SOURCE)) {
+                    System.err.println("cell.getCellType().equals(CellType.SOURCE)");
+                }
+                
+                if (cell.getCellType().equals(CellType.TARGET)) {
+                    System.err.println("cell.getCellType().equals(CellType.TARGET)");
+                }
+                
+                model.setCellType(cell, CellType.FREE);
+            }
+        }
+        
+        for (Set<Cell> closedSet : closed.values()) {
+            for (Cell cell : closedSet) {
+                
+                if (!cell.getCellType().equals(CellType.SOURCE)) {
+                    model.setCellType(cell, CellType.FREE); 
+                }
+            }
+        }
+        
         if (bestGoal != null) {
             List<Cell> path = new ArrayList<>();
             Cell cell = bestGoal;
@@ -180,19 +265,36 @@ private static List<Cell> search(GridModel model,
         return null;
     }
 
-    private static void pruneLayer(PriorityQueue<HeapNode> open,
+    private static void pruneLayer(GridModel model,
+                                   PriorityQueue<HeapNode> open,
                                    Deque<BeamStackEntry> beamStack,
-                                   PathfindingSettings pathfindingSettings) {
+                                   PathfindingSettings pathfindingSettings,
+                                   SearchStatistics searchStatistics) {
         List<HeapNode> keep = new ArrayList<>(open);
+        searchStatistics.addToOpened(-keep.size());
+        for (HeapNode node : keep) {
+            Cell cell = node.cell;
+            
+            if (!cell.getCellType().equals(CellType.TARGET)) {
+                model.setCellType(cell, CellType.FREE);
+            }
+        }
+        
         keep.sort((a, b) -> {
             return Double.compare(a.f, b.f);
         });
 
         keep = keep.subList(0, pathfindingSettings.getBeamWidth());
+        searchStatistics.addToOpened(keep.size());
         Set<Cell> keepSet = new HashSet<>();
 
         for (HeapNode heapNode : keep) {
-            keepSet.add(heapNode.cell);
+            Cell cell = heapNode.cell;
+            keepSet.add(cell);
+            
+            if (!cell.getCellType().equals(CellType.TARGET)) {
+                model.setCellType(cell, CellType.OPENED);
+            }
         }
 
         Set<HeapNode> pruned = new HashSet<>();