Map only required osm way ids

Author: Karl Hübner

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

@@ -20,8 +20,12 @@
 import static com.graphhopper.util.Helper.nf;
 import gnu.trove.list.TLongList;
 import gnu.trove.list.array.TLongArrayList;
+import gnu.trove.map.TIntLongMap;
 import gnu.trove.map.TLongLongMap;
+import gnu.trove.map.hash.TIntLongHashMap;
 import gnu.trove.map.hash.TLongLongHashMap;
+import gnu.trove.set.TLongSet;
+import gnu.trove.set.hash.TLongHashSet;
 
 import java.io.File;
 import java.io.IOException;
@@ -44,7 +48,6 @@
 import com.graphhopper.storage.GraphHopperStorage;
 import com.graphhopper.storage.GraphStorage;
 import com.graphhopper.storage.TurnCostStorage;
-import com.graphhopper.util.BitUtil;
 import com.graphhopper.util.DistanceCalc;
 import com.graphhopper.util.DistanceCalcEarth;
 import com.graphhopper.util.DouglasPeucker;
@@ -106,20 +109,21 @@ public class OSMReader
     private LongIntMap osmNodeIdToInternalNodeMap;
     private TLongLongHashMap osmNodeIdToNodeFlagsMap;
     private TLongLongHashMap osmWayIdToRouteWeightMap;
+    private TLongHashSet osmIdStoreRequiredSet; //stores osm ids used by relations to identify which edge ids needs to be mapped later
+    private TIntLongMap edgeIdToOsmidMap;
     private final TLongList barrierNodeIDs = new TLongArrayList();
     protected DataAccess pillarLats;
     protected DataAccess pillarLons;
-    protected DataAccess edgeOsmIds;
     private final DistanceCalc distCalc = new DistanceCalcEarth();
     private final DouglasPeucker simplifyAlgo = new DouglasPeucker();
     private int nextTowerId = 0;
     private int nextPillarId = 0;
     // negative but increasing to avoid clash with custom created OSM files
     private long newUniqueOSMId = -Long.MAX_VALUE;
     private boolean exitOnlyPillarNodeException = true;
+
     //relation factory specifies an arbitrary osm relation
     private OSMRelationFactory relationFactory = new OSMRelationFactory();
-    private final BitUtil bitUtil;
 
     public OSMReader( GraphStorage storage, long expectedCap )
     {
@@ -133,13 +137,10 @@ public OSMReader( GraphStorage storage, long expectedCap )
         dir = graphStorage.getDirectory();
         pillarLats = dir.find("tmpLatitudes");
         pillarLons = dir.find("tmpLongitudes");
-        edgeOsmIds = dir.find("tmpEdgeOsmIds");
         pillarLats.create(Math.max(expectedCap, 100));
         pillarLons.create(Math.max(expectedCap, 100));
-        edgeOsmIds.create(Math.max(expectedCap, 100));
 
         relationFactory = new OSMRelationFactory();
-        bitUtil = BitUtil.get(dir.getByteOrder());
     }
 
     public void doOSM2Graph( File osmFile ) throws IOException
@@ -203,6 +204,11 @@ void preProcess( File osmFile )
                         prepareWaysWithRelationInfo(relation);
                     }
 
+                    if (relation.hasTag("type", "restriction"))
+                    {
+                        prepareRestrictionRelation(relation);
+                    }
+
                     if (++tmpRelationCounter % 50000 == 0)
                     {
                         logger.info(nf(tmpRelationCounter) + " (preprocess), osmWayMap:" + nf(getRelFlagsMap().size())
@@ -220,6 +226,34 @@ void preProcess( File osmFile )
         }
     }
 
+    private void prepareRestrictionRelation( OSMRelation relation )
+    {
+        OSMRelation specifiedRelation = relationFactory.specify(relation);
+        if (specifiedRelation != null && specifiedRelation instanceof OSMTurnRelation)
+        {
+            getOsmIdStoreRequiredSet().add(((OSMTurnRelation) specifiedRelation).getOsmIdFrom());
+            getOsmIdStoreRequiredSet().add(((OSMTurnRelation) specifiedRelation).getOsmIdTo());
+        }
+    }
+
+    private TLongSet getOsmIdStoreRequiredSet()
+    {
+        if (osmIdStoreRequiredSet == null)
+        {
+            osmIdStoreRequiredSet = new TLongHashSet();
+        }
+        return osmIdStoreRequiredSet;
+    }
+
+    private TIntLongMap getEdgeIdToOsmidMap()
+    {
+        if (edgeIdToOsmidMap == null)
+        {
+            edgeIdToOsmidMap = new TIntLongHashMap(getOsmIdStoreRequiredSet().size());
+        }
+        return edgeIdToOsmidMap;
+    }
+
     /**
      * Filter ways but do not analyze properties wayNodes will be filled with participating node
      * ids.
@@ -453,9 +487,7 @@ public void processRelation( OSMRelation relation ) throws XMLStreamException
 
     public long getOsmIdOfInternalEdge( int edgeId )
     {
-        byte[] bytesOsmWayId = new byte[8];
-        edgeOsmIds.getBytes(edgeId * 8, bytesOsmWayId, 8);
-        return bitUtil.toLong(bytesOsmWayId);
+        return getEdgeIdToOsmidMap().get(edgeId);
     }
 
     public int getInternalNodeIdOfOsmNode( long nodeOsmId )
@@ -735,9 +767,10 @@ EdgeIteratorState addEdge( int fromIndex, int toIndex, PointList pointList, long
 
     private void storeOSMWayID( int edgeId, long osmWayID )
     {
-        long ptr = (long) edgeId * 8;
-        edgeOsmIds.incCapacity(ptr + 8);
-        edgeOsmIds.setBytes(ptr, bitUtil.fromLong(osmWayID), 8);
+        if (getOsmIdStoreRequiredSet().contains(osmWayID))
+        {
+            getEdgeIdToOsmidMap().put(edgeId, osmWayID);
+        }
     }
 
     /**
@@ -776,10 +809,8 @@ void finishedReading()
         printInfo("way");
         dir.remove(pillarLats);
         dir.remove(pillarLons);
-        dir.remove(edgeOsmIds);
         pillarLons = null;
         pillarLats = null;
-        edgeOsmIds = null;
         osmNodeIdToInternalNodeMap = null;
         osmNodeIdToNodeFlagsMap = null;
         osmWayIdToRouteWeightMap = null;

core/src/main/java/com/graphhopper/reader/OSMTurnRelation.java

@@ -18,13 +18,8 @@ public class OSMTurnRelation extends OSMRelation
 {
 
     public static final int TYPE_UNSUPPORTED = 0;
-    public static final int TYPE_NO_LEFT_TURN = 1;
-    public static final int TYPE_NO_RIGHT_TURN = 2;
-    public static final int TYPE_NO_STRAIGHT_ON = 3;
-    public static final int TYPE_ONLY_RIGHT_TURN = 4;
-    public static final int TYPE_ONLY_LEFT_TURN = 5;
-    public static final int TYPE_ONLY_STRAIGHT_ON = 6;
-    public static final int TYPE_NO_U_TURN = 7;
+    public static final int TYPE_NOT = 1;
+    public static final int TYPE_ONLY = 2;
 
     private long fromOsm;
     private long viaOsm;
@@ -42,6 +37,16 @@ private boolean isValid()
         return restriction != TYPE_UNSUPPORTED && viaOsm >= 0 && fromOsm >= 0 && toOsm >= 0;
     }
 
+    long getOsmIdFrom()
+    {
+        return fromOsm;
+    }
+    
+    long getOsmIdTo()
+    {
+        return toOsm;
+    }
+
     /**
      * transforms this relation into a collection of node cost entries
      * <p>
@@ -81,8 +86,7 @@ public Collection<TurnCostTableEntry> getRestrictionAsEntries( TurnCostEncoder e
             iter = edgeOutExplorer.setBaseNode(viaNodeId);
             if (edgeIdFrom != EdgeIterator.NO_EDGE)
             {
-                if (this.restriction == TYPE_NO_U_TURN || this.restriction == TYPE_NO_LEFT_TURN
-                        || this.restriction == TYPE_NO_RIGHT_TURN || this.restriction == TYPE_NO_STRAIGHT_ON)
+                if (this.restriction == TYPE_NOT)
                 {
                     // if we have a restriction of TYPE_NO_* we add restriction only to
                     // the given turn (from, via, to)  
@@ -99,8 +103,7 @@ public Collection<TurnCostTableEntry> getRestrictionAsEntries( TurnCostEncoder e
                         }
                     }
 
-                } else if (this.restriction == TYPE_ONLY_RIGHT_TURN || this.restriction == TYPE_ONLY_LEFT_TURN
-                        || this.restriction == TYPE_ONLY_STRAIGHT_ON)
+                } else if (this.restriction == TYPE_ONLY)
                 {
                     // if we have a restriction of TYPE_ONLY_* we add restriction to
                     // any turn possibility (from, via, * ) except the given turn
@@ -188,25 +191,25 @@ private int getRestrictionType( String restrictionType )
         {
             if ("no_left_turn".equals(restrictionType))
             {
-                return OSMTurnRelation.TYPE_NO_LEFT_TURN;
+                return OSMTurnRelation.TYPE_NOT;
             } else if ("no_right_turn".equals(restrictionType))
             {
-                return OSMTurnRelation.TYPE_NO_RIGHT_TURN;
+                return OSMTurnRelation.TYPE_NOT;
             } else if ("no_straight_on".equals(restrictionType))
             {
-                return OSMTurnRelation.TYPE_NO_STRAIGHT_ON;
+                return OSMTurnRelation.TYPE_NOT;
             } else if ("no_u_turn".equals(restrictionType))
             {
-                return OSMTurnRelation.TYPE_NO_U_TURN;
+                return OSMTurnRelation.TYPE_ONLY;
             } else if ("only_right_turn".equals(restrictionType))
             {
-                return OSMTurnRelation.TYPE_ONLY_RIGHT_TURN;
+                return OSMTurnRelation.TYPE_ONLY;
             } else if ("only_left_turn".equals(restrictionType))
             {
-                return OSMTurnRelation.TYPE_ONLY_LEFT_TURN;
+                return OSMTurnRelation.TYPE_ONLY;
             } else if ("only_straight_on".equals(restrictionType))
             {
-                return OSMTurnRelation.TYPE_ONLY_STRAIGHT_ON;
+                return OSMTurnRelation.TYPE_ONLY;
             }
             return OSMTurnRelation.TYPE_UNSUPPORTED;
         }