Merge pull request graphhopper#134 from khuebner/master

Preparing support of turn restrictions (2): Encode turn costs depending on vehicle type

Author: Peter

core/src/main/java/com/graphhopper/routing/util/AbstractTurnCostEncoder.java

@@ -0,0 +1,68 @@
+package com.graphhopper.routing.util;
+
+/**
+ * Very simple turn cost encoder, which stores the turn restriction in the first bit,
+ * and the turn costs (in seconds) in x additional bits (0..2^x-1)
+ * 
+ * @author karl.huebner
+ */
+public abstract class AbstractTurnCostEncoder implements TurnCostEncoder
+{
+    private final int maxCostsBits;
+    private final int costsMask;
+
+    protected int restrictionBit;
+    protected int costShift;
+
+    public AbstractTurnCostEncoder( int maxCostsBits )
+    {
+        this.maxCostsBits = maxCostsBits;
+
+        int mask = 0;
+        for (int i = 0; i < this.maxCostsBits; i++)
+        {
+            mask |= (1 << i);
+        }
+        this.costsMask = mask;
+
+        defineBits(0, 0);
+    }
+
+    @Override
+    public int defineBits( int index, int shift )
+    {
+        restrictionBit = 1 << shift;
+        costShift = shift + 1;
+        return shift + maxCostsBits + 1;
+    }
+
+    @Override
+    public boolean isRestricted( int flag )
+    {
+        return (flag & restrictionBit) != 0;
+    }
+
+    @Override
+    public int getCosts( int flag )
+    {
+        int result = (flag >> costShift) & costsMask;
+        if (result >= Math.pow(2, maxCostsBits) || result < 0)
+        {
+            throw new IllegalStateException("Wrong encoding of turn costs");
+        }
+        return result;
+    }
+
+    @Override
+    public int flags( boolean restricted, int costs )
+    {
+        costs = Math.min(costs, (int) (Math.pow(2, maxCostsBits) - 1));
+        int encode = costs << costShift;
+        if (restricted)
+        {
+            encode |= restrictionBit;
+        }
+        return encode;
+    }
+
+}

core/src/main/java/com/graphhopper/routing/util/DefaultTurnCostEncoder.java

@@ -0,0 +1,42 @@
+package com.graphhopper.routing.util;
+
+/**
+ * Default implementation of {@link AbstractTurnCostEncoder} which 
+ * does not encode any costs yet, but only restrictions in one bit.
+ * Therefore, each turn cost encoder requires only 1 bit storage size
+ * at the moment.
+ * 
+ * @author karl.huebner
+ */
+public class DefaultTurnCostEncoder extends AbstractTurnCostEncoder
+{
+    /**
+     * no costs, but only restrictions will be encoded
+     */
+    public DefaultTurnCostEncoder()
+    {
+        this(0); //we don't need costs yet
+    }
+
+    /**
+     * Next to restrictions, turn costs will be encoded as well
+     * 
+     * @param maxCosts the maximum costs to be encoded by this encoder, everything above this costs will be encoded as maxCosts
+     */
+    public DefaultTurnCostEncoder( int maxCosts )
+    {
+        super(determineRequiredBits(maxCosts)); //determine the number of bits required to store maxCosts
+    }
+
+    private static int determineRequiredBits( int number )
+    {
+        int bits = 0;
+        while (number > 0)
+        {
+            number = number >> 1;
+            bits++;
+        }
+        return bits;
+    }
+
+}