Add working LCC

mapbuilder/src/main/java/map/builder/App.java

@@ -16,7 +16,7 @@ import map.builder.utilities.FileHandler;
 public class App {
     public static void main(String[] args) throws IOException {
         RoadNetwork.Builder roadNetworkBuilder = RoadNetwork.newBuilder();
-        OSMParser parser = new OSMParser(roadNetworkBuilder);
+        OSMParser parser = new OSMParser();
 
         // A small BBox inside Cottbus
         /*
@@ -53,21 +53,20 @@ public class App {
         restrictions = null;
         roads = null;
         bbox = null;
-        parser = null;
 
         // create the nodes graph in order to run LCC on it
         ConnectedComponentGraph graph = new ConnectedComponentGraph();
-        OSMConnectedComponentParser.addNodes(roadNetworkBuilder, graph);
-        OSMConnectedComponentParser.addEdges(roadNetworkBuilder, graph);
+        OSMConnectedComponentParser.addNodes(parser.nodes, graph);
+        OSMConnectedComponentParser.addEdges(parser.segments, graph);
 
         ArrayList<Long> component = graph.getSCCs();
-        System.out.println(component.toString());
 
         // cleanup
         graph = null;
-        OSMConnectedComponentParser.cleanUp(roadNetworkBuilder, component);
+        OSMConnectedComponentParser.cleanUp(parser.nodes, parser.segments, component);
 
-        RoadNetwork roadNetwork = roadNetworkBuilder.build();
+        RoadNetwork roadNetwork = roadNetworkBuilder.putAllNodes(parser.nodes).putAllSegments(parser.segments)
+                .addAllTurnRestrictions(parser.restrictions).build();
         System.out.println("Turn restrictions count: " + roadNetwork.getTurnRestrictionsCount());
         System.out.println("Nodes count: " + roadNetwork.getNodesCount());
         System.out.println("Segments count: " + roadNetwork.getSegmentsCount());

mapbuilder/src/main/java/map/builder/osm/OSMConnectedComponentParser.java

 package map.builder.osm;
 
 import java.util.ArrayList;
-import java.util.Iterator;
+import java.util.Collections;
 import java.util.Map;
 
 import de.fuberlin.navigator.protos.map_builder.Node;
-import de.fuberlin.navigator.protos.map_builder.RoadNetwork;
 import de.fuberlin.navigator.protos.map_builder.Segment;
 import map.builder.utilities.ConnectedComponentGraph;
 
 public class OSMConnectedComponentParser {
 
-    public static void addNodes(RoadNetwork.Builder roadnetwowrBuilder, ConnectedComponentGraph graph) {
-        for (Long nodeId : roadnetwowrBuilder.getNodesMap().keySet()) {
+    public static void addNodes(Map<Long, Node> nodesMap, ConnectedComponentGraph graph) {
+        for (Long nodeId : nodesMap.keySet()) {
             graph.addNode(nodeId);
         }
     }
 
-    public static void addEdges(RoadNetwork.Builder roadnetworkbuilder, ConnectedComponentGraph graph) {
-        for (Long edgeId : roadnetworkbuilder.getSegmentsMap().keySet()) {
-            Segment segment = roadnetworkbuilder.getSegmentsMap().get(edgeId);
+    public static void addEdges(Map<Long, Segment> segmentsMap, ConnectedComponentGraph graph) {
+        for (Long edgeId : segmentsMap.keySet()) {
+            Segment segment = segmentsMap.get(edgeId);
             Long startNode = segment.getStartNode();
             Long endNode = segment.getEndNode();
             graph.addEdge(startNode, endNode);
@@ -29,26 +28,19 @@ public class OSMConnectedComponentParser {
         }
     }
 
-    public static void cleanUp(RoadNetwork.Builder roadNetworkBuilder, ArrayList<Long> component) {
-        Map<Long, Node> nodesMap = roadNetworkBuilder.getNodesMap();
-        for (Iterator<Long> iterator = nodesMap.keySet().iterator(); iterator.hasNext();) {
-            Long key = iterator.next();
-            System.out.println(component.contains(key));
-            if (!component.contains(key)) {
-                iterator.remove();
-                ;
-            }
-        }
-        Map<Long, Segment> segmentsMap = roadNetworkBuilder.getSegmentsMap();
-        for (Iterator<Long> iterator = segmentsMap.keySet().iterator(); iterator.hasNext();) {
-            Long key = iterator.next();
-            Long startNodeID = segmentsMap.get(key).getStartNode();
-            Long endNodeID = segmentsMap.get(key).getEndNode();
+    public static void cleanUp(Map<Long, Node> nodesMap, Map<Long, Segment> segmentsMap, ArrayList<Long> component) {
+        nodesMap.keySet().retainAll(Collections.unmodifiableCollection(component));
+
+        ArrayList<Long> segmentIDsToRemove = new ArrayList<Long>();
+        for (Long key : segmentsMap.keySet()) {
+            Segment segment = segmentsMap.get(key);
+            Long startNodeID = segment.getStartNode();
+            Long endNodeID = segment.getEndNode();
             if ((!component.contains(startNodeID)) && (!component.contains(endNodeID))) {
-                iterator.remove();
-                ;
+                segmentIDsToRemove.add(key);
             }
         }
+        segmentsMap.keySet().removeAll(segmentIDsToRemove);
     }
 
 }
\ No newline at end of file

mapbuilder/src/main/java/map/builder/osm/OSMParser.java

@@ -9,18 +9,20 @@ import org.json.JSONObject;
 import de.fuberlin.navigator.protos.map_builder.Coordinates;
 import de.fuberlin.navigator.protos.map_builder.Node;
 import de.fuberlin.navigator.protos.map_builder.Restriction;
-import de.fuberlin.navigator.protos.map_builder.RoadNetwork;
 import de.fuberlin.navigator.protos.map_builder.Segment;
 import map.builder.utilities.ComputationalUtils;
 
 public class OSMParser {
     private final Coordinates.Builder coordinatesBuilder;
     private final HashMap<Long, Node> nodesDump;
-    public RoadNetwork.Builder roadNetworkBuilder;
 
-    public OSMParser(RoadNetwork.Builder roadNetworkBuilder) {
-        this.roadNetworkBuilder = roadNetworkBuilder;
+    // maps to put the entries
 
+    public HashMap<Long, Node> nodes = new HashMap<Long, Node>();
+    public HashMap<Long, Segment> segments = new HashMap<Long, Segment>();
+    public ArrayList<Restriction> restrictions = new ArrayList<Restriction>();
+
+    public OSMParser() {
         this.coordinatesBuilder = Coordinates.newBuilder();
         this.nodesDump = new HashMap<>();
     }
@@ -85,10 +87,10 @@ public class OSMParser {
 
         System.out.printf("Max speed: %d \n", maxSpeed);
         System.out.printf("Way id: %d, Start node id : %d, End node id: %d \n", osmId,
-                this.roadNetworkBuilder.getNodesMap().get(startNodeId).getId(),
-                this.roadNetworkBuilder.getNodesMap().get(endNodeId).getId());
+                this.nodes.get(startNodeId).getId(),
+                this.nodes.get(endNodeId).getId());
 
-        long internalId = this.roadNetworkBuilder.getSegmentsCount();
+        long internalId = this.segments.size();
 
         Segment segment = Segment.newBuilder()
                 .setOsmId(osmId)
@@ -102,7 +104,7 @@ public class OSMParser {
                 .setLength(this.computeSegmentLength(line))
                 .build();
 
-        this.roadNetworkBuilder.putSegments(internalId, segment);
+        this.segments.put(internalId, segment);
     }
 
     private boolean isOneWay(JSONObject element) {
@@ -113,7 +115,7 @@ public class OSMParser {
 
     private void moveNodeToProto(Node node) {
         long osmId = node.getOsmId();
-        this.roadNetworkBuilder.putNodes(node.getOsmId(), node);
+        this.nodes.put(osmId, node);
     }
 
     private void createNode(JSONObject element) {
@@ -121,7 +123,7 @@ public class OSMParser {
         long osmId = element.getLong(OSMKey.id.name());
 
         Node node = Node.newBuilder()
-                .setId(this.roadNetworkBuilder.getNodesCount() + this.nodesDump.size())
+                .setId(this.nodes.size() + this.nodesDump.size())
                 .setOsmId(osmId)
                 .setPosition(position)
                 .build();
@@ -181,8 +183,8 @@ public class OSMParser {
             return node;
         }
 
-        if (this.roadNetworkBuilder.getNodesMap().containsKey(osmId)) {
-            return this.roadNetworkBuilder.getNodesMap().get(osmId);
+        if (this.nodes.containsKey(osmId)) {
+            return this.nodes.get(osmId);
         }
 
         throw new NullPointerException("Node with id " + osmId + " not found!");
@@ -221,7 +223,7 @@ public class OSMParser {
                 }
             }
             Restriction restriction = Restriction.newBuilder().setFromId(from).setToId(to).build();
-            this.roadNetworkBuilder.addTurnRestrictions(restriction);
+            this.restrictions.add(restriction);
         }
     }