Remove turn cost storage optimization for edge-based CH

Author: easbar

core/src/main/java/com/graphhopper/routing/ch/CHPreparationGraph.java

@@ -107,63 +107,12 @@ public static void buildFromGraph(CHPreparationGraph prepareGraph, Graph graph,
         prepareGraph.prepareForContraction();
     }
 
-    /**
-     * Builds a turn cost function for a given graph('s turn cost storage) and given uTurnCosts.
-     * The trivial implementation would be simply using {@link Weighting#calcTurnWeight}. However, it turned out
-     * that storing all turn costs in separate arrays upfront speeds up edge-based CH preparation by about 25%. See #2084
-     */
     public static TurnCostFunction buildTurnCostFunctionFromTurnCostStorage(Graph graph, Weighting weighting) {
-        if (!(weighting instanceof AbstractWeighting))
-            return weighting::calcTurnWeight;
-        TurnCostProvider turnCostProvider = ((AbstractWeighting) weighting).getTurnCostProvider();
-        if (!(turnCostProvider instanceof DefaultTurnCostProvider))
-            return weighting::calcTurnWeight;
-        DecimalEncodedValue turnCostEnc = ((DefaultTurnCostProvider) turnCostProvider).getTurnCostEnc();
-        TurnCostStorage turnCostStorage = graph.getTurnCostStorage();
-        // we maintain a list of inEdge/outEdge/turn-cost triples (we use two arrays for this) that is sorted by nodes
-        LongArrayList turnCostEdgePairs = new LongArrayList();
-        DoubleArrayList turnCosts = new DoubleArrayList();
-        // for each node we store the index of the first turn cost entry/triple in the list
-        final int[] turnCostNodes = new int[graph.getNodes() + 1];
-        TurnCostStorage.Iterator tcIter = turnCostStorage.getAllTurnCosts();
-        int lastNode = -1;
-        while (tcIter.next()) {
-            int viaNode = tcIter.getViaNode();
-            if (viaNode < lastNode)
-                throw new IllegalStateException();
-            long edgePair = BitUtil.LITTLE.toLong(tcIter.getFromEdge(), tcIter.getToEdge());
-            // note that as long as we only use OSM turn restrictions all the turn costs are infinite anyway
-            double turnCost = tcIter.getCost(turnCostEnc);
-            int index = turnCostEdgePairs.size();
-            turnCostEdgePairs.add(edgePair);
-            turnCosts.add(turnCost);
-            if (viaNode != lastNode) {
-                for (int i = lastNode + 1; i <= viaNode; i++) {
-                    turnCostNodes[i] = index;
-                }
-            }
-            lastNode = viaNode;
-        }
-        for (int i = lastNode + 1; i <= turnCostNodes.length - 1; i++) {
-            turnCostNodes[i] = turnCostEdgePairs.size();
-        }
-        turnCostNodes[turnCostNodes.length - 1] = turnCostEdgePairs.size();
-
-        // currently the u-turn costs are the same for all junctions, so for now we just get them for one of them
-        double uTurnCosts = weighting.calcTurnWeight(1, 0, 1);
-        return (inEdge, viaNode, outEdge) -> {
-            if (!EdgeIterator.Edge.isValid(inEdge) || !EdgeIterator.Edge.isValid(outEdge))
-                return 0;
-            else if (inEdge == outEdge)
-                return uTurnCosts;
-            // traverse all turn cost entries we have for this viaNode and return the turn costs if we find a match
-            for (int i = turnCostNodes[viaNode]; i < turnCostNodes[viaNode + 1]; i++) {
-                long l = turnCostEdgePairs.get(i);
-                if (inEdge == BitUtil.LITTLE.getIntLow(l) && outEdge == BitUtil.LITTLE.getIntHigh(l))
-                    return turnCosts.get(i);
-            }
-            return 0;
-        };
+        // At some point we used an optimized version where we copied the turn costs to sorted arrays
+        // temporarily. This seemed to be around 25% faster according to measurements on the Bavaria
+        // map, but later this turned out to be no real improvement for large maps (planet, Europe, a
+        // and even Germany). See also #2084
+        return weighting::calcTurnWeight;
     }
 
     public int getNodes() {