Make use of node tags like 'highway' or 'crossing'

CHANGELOG.md

@@ -1,5 +1,6 @@
 ### 7.0 [not yet released]
 
+- access node tags via List instead of Map: List<Map<String, Object>> nodeTags = way.getTag("node_tags", emptyList()), see #2705
 - remove StringEncodedValue support from custom model due to insufficient usage/testing
 - handle also node_tags in handleWayTags, when extending AbstractAccessParser call handleNodeTags, #2738
 - Format of 'areas' in CustomModel changed to 'FeatureCollection'. The old format is deprecated and will be removed in a later version, #2734

core/src/main/java/com/graphhopper/reader/osm/OSMNodeData.java

@@ -18,6 +18,8 @@
 
 package com.graphhopper.reader.osm;
 
+import com.carrotsearch.hppc.LongScatterSet;
+import com.carrotsearch.hppc.LongSet;
 import com.graphhopper.coll.GHLongIntBTree;
 import com.graphhopper.coll.LongIntMap;
 import com.graphhopper.reader.ReaderNode;
@@ -26,15 +28,10 @@
 import com.graphhopper.util.PointList;
 import com.graphhopper.util.shapes.GHPoint3D;
 
-import java.util.ArrayList;
-import java.util.Collections;
-import java.util.List;
-import java.util.Map;
+import java.util.*;
 import java.util.function.DoubleSupplier;
 import java.util.function.IntUnaryOperator;
 
-import static java.util.Collections.emptyMap;
-
 /**
  * This class stores OSM node data while reading an OSM file in {@link WaySegmentParser}. It is not trivial to do this
  * in a memory-efficient way. We use the following approach:
@@ -68,11 +65,12 @@ class OSMNodeData {
     private final PointAccess towerNodes;
 
     // this map stores an index for each OSM node we keep the node tags of. a value of -1 means there is no entry
-    // yet and a value of -2 means there was an entry but it was removed again
+    // yet.
     private final LongIntMap nodeTagIndicesByOsmNodeIds;
 
     // stores node tags
     private final List<Map<String, Object>> nodeTags;
+    private final LongSet nodesToBeSplit;
 
     private int nextTowerId = 0;
     private int nextPillarId = 0;
@@ -88,6 +86,7 @@ public OSMNodeData(PointAccess nodeAccess, Directory directory) {
         pillarNodes = new PillarInfo(towerNodes.is3D(), directory);
 
         nodeTagIndicesByOsmNodeIds = new GHLongIntBTree(200);
+        nodesToBeSplit = new LongScatterSet();
         nodeTags = new ArrayList<>();
     }
 
@@ -187,7 +186,7 @@ SegmentNode addCopyOfNode(SegmentNode node) {
         if (idsByOsmNodeIds.put(newOsmId, INTERMEDIATE_NODE) != EMPTY_NODE)
             throw new IllegalStateException("Artificial osm node id already exists: " + newOsmId);
         int id = addPillarNode(newOsmId, point.getLat(), point.getLon(), point.getEle());
-        return new SegmentNode(newOsmId, id);
+        return new SegmentNode(newOsmId, id, new HashMap<>(node.tags));
     }
 
     int convertPillarToTowerNode(int id, long osmNodeId) {
@@ -241,9 +240,7 @@ public void addCoordinatesToPointList(int id, PointList pointList) {
 
     public void setTags(ReaderNode node) {
         int tagIndex = nodeTagIndicesByOsmNodeIds.get(node.getId());
-        if (tagIndex == -2)
-            throw new IllegalStateException("Cannot add tags after they were removed");
-        else if (tagIndex == -1) {
+        if (tagIndex == -1) {
             nodeTagIndicesByOsmNodeIds.put(node.getId(), nodeTags.size());
             nodeTags.add(node.getTags());
         } else {
@@ -258,11 +255,6 @@ public Map<String, Object> getTags(long osmNodeId) {
         return nodeTags.get(tagIndex);
     }
 
-    public void removeTags(long osmNodeId) {
-        int prev = nodeTagIndicesByOsmNodeIds.put(osmNodeId, -2);
-        nodeTags.set(prev, emptyMap());
-    }
-
     public void release() {
         pillarNodes.clear();
     }
@@ -282,4 +274,18 @@ public int pillarNodeToId(int pillarId) {
     public int idToPillarNode(int id) {
         return id - 3;
     }
+
+    public boolean setSplitNode(long osmNodeId) {
+        return nodesToBeSplit.add(osmNodeId);
+    }
+
+    public void unsetSplitNode(long osmNodeId) {
+        int removed = nodesToBeSplit.removeAll(osmNodeId);
+        if (removed == 0)
+            throw new IllegalStateException("Node " + osmNodeId + " was not a split node");
+    }
+
+    public boolean isSplitNode(long osmNodeId) {
+        return nodesToBeSplit.contains(osmNodeId);
+    }
 }

core/src/main/java/com/graphhopper/reader/osm/OSMReader.java

@@ -228,7 +228,7 @@ private boolean isFerry(ReaderWay way) {
      * This method is called during the second pass of {@link WaySegmentParser} and provides an entry point to enrich
      * the given OSM way with additional tags before it is passed on to the tag parsers.
      */
-    protected void setArtificialWayTags(PointList pointList, ReaderWay way, double distance, Map<String, Object> nodeTags) {
+    protected void setArtificialWayTags(PointList pointList, ReaderWay way, double distance, List<Map<String, Object>> nodeTags) {
         way.setTag("node_tags", nodeTags);
         way.setTag("edge_distance", distance);
         way.setTag("point_list", pointList);
@@ -293,14 +293,16 @@ protected void setArtificialWayTags(PointList pointList, ReaderWay way, double d
      * @param toIndex   a unique integer id for the last node of this segment
      * @param pointList coordinates of this segment
      * @param way       the OSM way this segment was taken from
-     * @param nodeTags  node tags of this segment if it is an artificial edge, empty otherwise
+     * @param nodeTags  node tags of this segment. there is one map of tags for each point.
      */
-    protected void addEdge(int fromIndex, int toIndex, PointList pointList, ReaderWay way, Map<String, Object> nodeTags) {
+    protected void addEdge(int fromIndex, int toIndex, PointList pointList, ReaderWay way, List<Map<String, Object>> nodeTags) {
         // sanity checks
         if (fromIndex < 0 || toIndex < 0)
             throw new AssertionError("to or from index is invalid for this edge " + fromIndex + "->" + toIndex + ", points:" + pointList);
         if (pointList.getDimension() != nodeAccess.getDimension())
             throw new AssertionError("Dimension does not match for pointList vs. nodeAccess " + pointList.getDimension() + " <-> " + nodeAccess.getDimension());
+        if (pointList.size() != nodeTags.size())
+            throw new AssertionError("there should be as many maps of node tags as there are points. node tags: " + nodeTags.size() + ", points: " + pointList.size());
 
         // todo: in principle it should be possible to delay elevation calculation so we do not need to store
         // elevations during import (saves memory in pillar info during import). also note that we already need to

core/src/main/java/com/graphhopper/reader/osm/SegmentNode.java

@@ -18,12 +18,16 @@
 
 package com.graphhopper.reader.osm;
 
+import java.util.Map;
+
 class SegmentNode {
     long osmNodeId;
     int id;
+    Map<String, Object> tags;
 
-    public SegmentNode(long osmNodeId, int id) {
+    public SegmentNode(long osmNodeId, int id, Map<String, Object> tags) {
         this.osmNodeId = osmNodeId;
         this.id = id;
+        this.tags = tags;
     }
 }

core/src/main/java/com/graphhopper/reader/osm/WaySegmentParser.java

@@ -38,17 +38,13 @@
 import java.io.File;
 import java.io.IOException;
 import java.text.ParseException;
-import java.util.ArrayList;
-import java.util.Date;
-import java.util.List;
-import java.util.Map;
+import java.util.*;
 import java.util.function.Consumer;
 import java.util.function.LongToIntFunction;
 import java.util.function.Predicate;
 
 import static com.graphhopper.reader.osm.OSMNodeData.*;
 import static com.graphhopper.util.Helper.nf;
-import static java.util.Collections.emptyMap;
 
 /**
  * This class parses a given OSM file and splits OSM ways into 'segments' at all intersections (or 'junctions').
@@ -68,6 +64,7 @@
  */
 public class WaySegmentParser {
     private static final Logger LOGGER = LoggerFactory.getLogger(WaySegmentParser.class);
+    private static final Set<String> INCLUDE_IF_NODE_TAGS = new HashSet<>(Arrays.asList("barrier", "highway", "railway", "crossing", "ford"));
 
     private final ElevationProvider eleProvider;
     private final Predicate<ReaderWay> wayFilter;
@@ -224,14 +221,27 @@ public void handleNode(ReaderNode node) {
 
             acceptedNodes++;
 
-            // we keep node tags for barrier nodes
+            // remember which nodes we want to split
             if (splitNodeFilter.test(node)) {
                 if (nodeType == JUNCTION_NODE) {
                     LOGGER.debug("OSM node {} at {},{} is a barrier node at a junction. The barrier will be ignored",
                             node.getId(), Helper.round(node.getLat(), 7), Helper.round(node.getLon(), 7));
                     ignoredSplitNodes++;
                 } else
+                    nodeData.setSplitNode(node.getId());
+            }
+
+            // store node tags if at least one important tag is included and make this available for the edge handler
+            for (Map.Entry<String, Object> e : node.getTags().entrySet()) {
+                if (INCLUDE_IF_NODE_TAGS.contains(e.getKey())) {
+                    node.removeTag("created_by");
+                    node.removeTag("source");
+                    node.removeTag("note");
+                    node.removeTag("fixme");
+                    node.setTags(new HashMap<>(node.getTags())); // create compact Map
                     nodeData.setTags(node);
+                    break;
+                }
             }
         }
 
@@ -251,7 +261,7 @@ public void handleWay(ReaderWay way) {
                 return;
             List<SegmentNode> segment = new ArrayList<>(way.getNodes().size());
             for (LongCursor node : way.getNodes())
-                segment.add(new SegmentNode(node.value, nodeData.getId(node.value)));
+                segment.add(new SegmentNode(node.value, nodeData.getId(node.value), nodeData.getTags(node.value)));
             wayPreprocessor.preprocessWay(way, osmNodeId -> nodeData.getCoordinates(nodeData.getId(osmNodeId)));
             splitWayAtJunctionsAndEmptySections(segment, way);
         }
@@ -304,9 +314,11 @@ private void splitSegmentAtSplitNodes(List<SegmentNode> parentSegment, ReaderWay
             List<SegmentNode> segment = new ArrayList<>();
             for (int i = 0; i < parentSegment.size(); i++) {
                 SegmentNode node = parentSegment.get(i);
-                Map<String, Object> nodeTags = nodeData.getTags(node.osmNodeId);
-                // so far we only consider node tags of split nodes, so if there are node tags we split the node
-                if (!nodeTags.isEmpty()) {
+                if (nodeData.isSplitNode(node.osmNodeId)) {
+                    // do not split this node again. for example a barrier can be connecting two ways (appear in both
+                    // ways) and we only want to add a barrier edge once (but we want to add one).
+                    nodeData.unsetSplitNode(node.osmNodeId);
+
                     // this node is a barrier. we will copy it and add an extra edge
                     SegmentNode barrierFrom = node;
                     SegmentNode barrierTo = nodeData.addCopyOfNode(node);
@@ -318,28 +330,30 @@ private void splitSegmentAtSplitNodes(List<SegmentNode> parentSegment, ReaderWay
                     }
                     if (!segment.isEmpty()) {
                         segment.add(barrierFrom);
-                        handleSegment(segment, way, emptyMap());
+                        handleSegment(segment, way);
                         segment = new ArrayList<>();
                     }
+
+                    // mark barrier edge
+                    way.setTag("gh:barrier_edge", true);
                     segment.add(barrierFrom);
                     segment.add(barrierTo);
-                    handleSegment(segment, way, nodeTags);
+                    handleSegment(segment, way);
+                    way.removeTag("gh:barrier_edge");
+
                     segment = new ArrayList<>();
                     segment.add(barrierTo);
-
-                    // ignore this barrier node from now. for example a barrier can be connecting two ways (appear in both
-                    // ways) and we only want to add a barrier edge once (but we want to add one).
-                    nodeData.removeTags(node.osmNodeId);
                 } else {
                     segment.add(node);
                 }
             }
             if (segment.size() > 1)
-                handleSegment(segment, way, emptyMap());
+                handleSegment(segment, way);
         }
 
-        void handleSegment(List<SegmentNode> segment, ReaderWay way, Map<String, Object> nodeTags) {
+        void handleSegment(List<SegmentNode> segment, ReaderWay way) {
             final PointList pointList = new PointList(segment.size(), nodeData.is3D());
+            final List<Map<String, Object>> nodeTags = new ArrayList<>(segment.size());
             int from = -1;
             int to = -1;
             for (int i = 0; i < segment.size(); i++) {
@@ -359,6 +373,7 @@ else if (i == segment.size() - 1)
                 else if (isTowerNode(id))
                     throw new IllegalStateException("Tower nodes should only appear at the end of segments, way: " + way.getId());
                 nodeData.addCoordinatesToPointList(id, pointList);
+                nodeTags.add(node.tags);
             }
             if (from < 0 || to < 0)
                 throw new IllegalStateException("The first and last nodes of a segment must be tower nodes, way: " + way.getId());
@@ -547,7 +562,7 @@ default void onFinish() {
     }
 
     public interface EdgeHandler {
-        void handleEdge(int from, int to, PointList pointList, ReaderWay way, Map<String, Object> nodeTags);
+        void handleEdge(int from, int to, PointList pointList, ReaderWay way, List<Map<String, Object>> nodeTags);
     }
 
     public interface RelationProcessor {

core/src/main/java/com/graphhopper/routing/ev/Crossing.java

@@ -0,0 +1,30 @@
+package com.graphhopper.routing.ev;
+
+import com.graphhopper.util.Helper;
+
+public enum Crossing {
+    MISSING, // no information
+    RAILWAY_BARRIER, // railway crossing with barrier
+    RAILWAY, // railway crossing with road
+    TRAFFIC_SIGNALS, // with light signals
+    UNCONTROLLED, // with crosswalk, without traffic lights
+    MARKED, // with crosswalk, with or without traffic lights
+    UNMARKED, // without markings or traffic lights
+    NO; // crossing is impossible or illegal
+    public static final String KEY = "crossing";
+
+    @Override
+    public String toString() {
+        return Helper.toLowerCase(name());
+    }
+
+    public static Crossing find(String name) {
+        if (name == null)
+            return MISSING;
+        try {
+            return Crossing.valueOf(Helper.toUpperCase(name));
+        } catch (IllegalArgumentException ex) {
+            return MISSING;
+        }
+    }
+}

core/src/main/java/com/graphhopper/routing/ev/DefaultEncodedValueFactory.java

@@ -87,7 +87,10 @@ public EncodedValue create(String name, PMap properties) {
             return AverageSlope.create();
         } else if (Curvature.KEY.equals(name)) {
             return Curvature.create();
-        } else
+        } else if (Crossing.KEY.equals(name)) {
+            return new EnumEncodedValue<>(Crossing.KEY, Crossing.class);
+        } else {
             throw new IllegalArgumentException("DefaultEncodedValueFactory cannot find EncodedValue " + name);
+        }
     }
 }

core/src/main/java/com/graphhopper/routing/util/parsers/AbstractAccessParser.java

@@ -79,15 +79,13 @@ public ConditionalTagInspector getConditionalTagInspector() {
      * Updates the given edge flags based on node tags
      */
     protected void handleNodeTags(IntsRef edgeFlags, Map<String, Object> nodeTags) {
-        if (!nodeTags.isEmpty()) {
-            // for now we just create a dummy reader node, because our encoders do not make use of the coordinates anyway
-            ReaderNode readerNode = new ReaderNode(0, 0, 0, nodeTags);
-            // block access for barriers
-            if (isBarrier(readerNode)) {
-                BooleanEncodedValue accessEnc = getAccessEnc();
-                accessEnc.setBool(false, edgeFlags, false);
-                accessEnc.setBool(true, edgeFlags, false);
-            }
+        // for now we just create a dummy reader node, because our encoders do not make use of the coordinates anyway
+        ReaderNode readerNode = new ReaderNode(0, 0, 0, nodeTags);
+        // block access for barriers
+        if (isBarrier(readerNode)) {
+            BooleanEncodedValue accessEnc = getAccessEnc();
+            accessEnc.setBool(false, edgeFlags, false);
+            accessEnc.setBool(true, edgeFlags, false);
         }
     }
 

core/src/main/java/com/graphhopper/routing/util/parsers/BikeCommonAccessParser.java

@@ -6,12 +6,7 @@
 import com.graphhopper.routing.util.WayAccess;
 import com.graphhopper.storage.IntsRef;
 
-import java.util.Arrays;
-import java.util.HashSet;
-import java.util.Map;
-import java.util.Set;
-
-import static java.util.Collections.emptyMap;
+import java.util.*;
 
 public abstract class BikeCommonAccessParser extends AbstractAccessParser implements TagParser {
 
@@ -133,8 +128,10 @@ public void handleWayTags(IntsRef edgeFlags, ReaderWay way) {
             handleAccess(edgeFlags, way);
         }
 
-        Map<String, Object> nodeTags = way.getTag("node_tags", emptyMap());
-        handleNodeTags(edgeFlags, nodeTags);
+        if (way.hasTag("gh:barrier_edge")) {
+            List<Map<String, Object>> nodeTags = way.getTag("node_tags", Collections.emptyList());
+            handleNodeTags(edgeFlags, nodeTags.get(0));
+        }
     }
 
     protected void handleAccess(IntsRef edgeFlags, ReaderWay way) {