/// <summary>
/// Adds a contracted graph in the old (broken) way, to test backwards compat. with previous itinero versions.
/// </summary>
/// <param name="db"></param>
/// <param name="profile"></param>
public static void AddContractedOldEdgeBased(this RouterDb db, Profile profile)
{
var weightHandler = profile.DefaultWeightHandlerCached(db);
var contracted = new DirectedDynamicGraph(weightHandler.DynamicSize);
var directedGraphBuilder = new Itinero.Algorithms.Contracted.EdgeBased.DirectedGraphBuilder <float>(db.Network.GeometricGraph.Graph, contracted,
weightHandler);
directedGraphBuilder.Run();
// contract the graph.
var priorityCalculator = new Itinero.Algorithms.Contracted.EdgeBased.EdgeDifferencePriorityCalculator <float>(contracted, weightHandler,
new Itinero.Algorithms.Contracted.EdgeBased.Witness.DykstraWitnessCalculator <float>(weightHandler, 4, 64));
priorityCalculator.DifferenceFactor = 5;
priorityCalculator.DepthFactor = 5;
priorityCalculator.ContractedFactor = 8;
var hierarchyBuilder = new Itinero.Algorithms.Contracted.EdgeBased.HierarchyBuilder <float>(contracted, priorityCalculator,
new Itinero.Algorithms.Contracted.EdgeBased.Witness.DykstraWitnessCalculator <float>(weightHandler, int.MaxValue, 64), weightHandler, db.GetGetRestrictions(profile, null));
hierarchyBuilder.Run();
var contractedDb = new ContractedDb(contracted);
db.AddContracted(profile, contractedDb);
}
/// <summary>
/// Deserializes contraction data from the given stream.
/// </summary>
public static ContractedDb Deserialize(Stream stream, ContractedDbProfile profile)
{
// read version # first:
// 1: means regular non-edge contracted data.
// 2: means regular edge contracted data.
var version = stream.ReadByte();
if (version == 1)
{
return(new ContractedDb(DirectedMetaGraph.Deserialize(stream, profile == null ? null : profile.NodeBasedProfile), false));
}
else if (version == 2)
{
return(new ContractedDb(DirectedDynamicGraph.Deserialize(stream, profile == null ? null : profile.EdgeBasedProfile)));
}
else if (version == 3)
{
return(new ContractedDb(DirectedMetaGraph.Deserialize(stream, profile == null ? null : profile.NodeBasedProfile), true));
}
else
{
throw new Exception(string.Format("Cannot deserialize contracted graph: Invalid version #: {0}.", version));
}
}
public void Test3Vertices()
{
// build graph.
var graph = new DirectedDynamicGraph(ContractedEdgeDataSerializer.DynamicFixedSize);
graph.AddEdge(0, 1, 100, null);
graph.AddEdge(1, 0, 100, null);
graph.AddEdge(1, 2, 100, null);
graph.AddEdge(2, 1, 100, null);
graph.Compress();
// contract graph.
var hierarchyBuilder = new HierarchyBuilder(graph, new EdgeDifferencePriorityCalculator(graph, new DykstraWitnessCalculator(int.MaxValue)),
new DykstraWitnessCalculator(int.MaxValue), (i) => Enumerable.Empty <uint[]>());
hierarchyBuilder.Run();
// check edges.
var edges01 = graph.GetEdgeEnumerator(0).FirstOrDefault(x => x.Neighbour == 1);
Assert.IsNotNull(edges01);
var edge10 = graph.GetEdgeEnumerator(1).FirstOrDefault(x => x.Neighbour == 0);
Assert.IsNull(edge10);
var edge12 = graph.GetEdgeEnumerator(1).FirstOrDefault(x => x.Neighbour == 0);
Assert.IsNull(edge12);
var edges21 = graph.GetEdgeEnumerator(2).FirstOrDefault(x => x.Neighbour == 1);
Assert.IsNotNull(edges21);
}
public void TestRemoveEdge()
{
var graph = new DirectedDynamicGraph();
graph.AddEdge(1, 2, 0102, 010200);
graph.AddEdge(1, 3, 0103);
Assert.AreEqual(1, graph.RemoveEdge(1, 2));
Assert.AreEqual(1, graph.EdgeCount);
var enumerator = graph.GetEdgeEnumerator();
Assert.IsTrue(enumerator.MoveTo(1));
Assert.IsTrue(enumerator.MoveNext());
Assert.AreEqual(3, enumerator.Neighbour);
Assert.AreEqual(0103, enumerator.Data0);
graph = new DirectedDynamicGraph();
graph.AddEdge(1, 2, 0102, 010200);
graph.AddEdge(1, 3, 0103);
graph.AddEdge(1, 4, 0104, 010400, 01040000);
Assert.AreEqual(1, graph.RemoveEdge(1, 3));
enumerator = graph.GetEdgeEnumerator();
Assert.IsTrue(enumerator.MoveTo(1));
Assert.IsTrue(enumerator.MoveNext());
Assert.AreEqual(2, enumerator.Neighbour);
Assert.AreEqual(0102, enumerator.Data0);
Assert.AreEqual(010200, enumerator.DynamicData[0]);
Assert.IsTrue(enumerator.MoveNext());
Assert.AreEqual(4, enumerator.Neighbour);
Assert.AreEqual(0104, enumerator.Data0);
Assert.AreEqual(010400, enumerator.DynamicData[0]);
Assert.AreEqual(01040000, enumerator.DynamicData[1]);
}
/// <summary>
/// Adds a new edge with the given direction and weight.
/// </summary>
public sealed override void AddEdge(DirectedDynamicGraph graph, uint vertex1, uint vertex2, bool?direction, float weight)
{
var data = Data.Contracted.Edges.ContractedEdgeDataSerializer.Serialize(
weight, direction);
graph.AddEdge(vertex1, vertex2, data);
}
public void TestTwoEdgeInfiniteHops()
{
// build graph.
var graph = new DirectedDynamicGraph(ContractedEdgeDataSerializer.DynamicFixedSize);
graph.AddEdge(0, 1, 100, null);
graph.AddEdge(1, 2, 100, null);
var witnessCalculator = new DykstraWitnessCalculator(int.MaxValue);
// calculate witness for weight of 200.
var forwardWitnesses = new EdgePath <float> [1];
var backwardWitnesses = new EdgePath <float> [1];
witnessCalculator.Calculate(graph, (i) => null, 0, new List <uint>(new uint[] { 2 }), new List <float>(new float[] { 1000 }),
ref forwardWitnesses, ref backwardWitnesses, uint.MaxValue);
Assert.AreEqual(2, forwardWitnesses[0].Vertex);
Assert.AreEqual(2, backwardWitnesses[0].Vertex);
// calculate witness for weight of 50.
forwardWitnesses = new EdgePath <float> [1];
backwardWitnesses = new EdgePath <float> [1];
witnessCalculator.Calculate(graph, (i) => null, 0, new List <uint>(new uint[] { 2 }), new List <float>(new float[] { 50 }),
ref forwardWitnesses, ref backwardWitnesses, uint.MaxValue);
Assert.AreEqual(Constants.NO_VERTEX, forwardWitnesses[0].Vertex);
Assert.AreEqual(Constants.NO_VERTEX, backwardWitnesses[0].Vertex);
}
public void TestQuadrilateralOneWay()
{
// build graph.
var graph = new DirectedDynamicGraph(ContractedEdgeDataSerializer.DynamicFixedSize);
graph.AddEdge(0, 2, 100, true);
graph.AddEdge(2, 0, 100, false);
graph.AddEdge(0, 3, 10, false);
graph.AddEdge(3, 0, 10, true);
graph.AddEdge(1, 2, 1000, false);
graph.AddEdge(2, 1, 1000, true);
graph.AddEdge(1, 3, 10000, true);
graph.AddEdge(3, 1, 10000, false);
graph.Compress();
// create a witness calculator and the priority calculator.
var contractedFlags = new BitArray32(graph.VertexCount);
var priorityCalculator = new EdgeDifferencePriorityCalculator(graph,
new Itinero.Algorithms.Contracted.EdgeBased.Witness.DykstraWitnessCalculator(10));
//var priorityCalculator = new EdgeDifferencePriorityCalculator(graph,
// new WitnessCalculatorMock(new uint[][]
// {
// new uint[] { 1, 3, 2, 1 },
// new uint[] { 3, 0, 1, 1 }
// }));
Assert.AreEqual(0, priorityCalculator.Calculate(contractedFlags, (i) => null, 0));
Assert.AreEqual(0, priorityCalculator.Calculate(contractedFlags, (i) => null, 1));
Assert.AreEqual(0, priorityCalculator.Calculate(contractedFlags, (i) => null, 2));
Assert.AreEqual(0, priorityCalculator.Calculate(contractedFlags, (i) => null, 3));
}
/// <summary>
/// Creates a new algorithm.
/// </summary>
public ManyToManyWeightsBidirectionalDykstra(RouterDb routerDb, Profile profile, WeightHandler <T> weightHandler, RouterPoint[] sources,
RouterPoint[] targets, T max)
{
_routerDb = routerDb;
_weightHandler = weightHandler;
_sources = sources;
_targets = targets;
_profile = profile;
_max = max;
ContractedDb contractedDb;
if (!_routerDb.TryGetContracted(profile, out contractedDb))
{
throw new NotSupportedException(
"Contraction-based many-to-many calculates are not supported in the given router db for the given profile.");
}
if (!contractedDb.HasEdgeBasedGraph)
{
throw new NotSupportedException(
"Contraction-based edge-based many-to-many calculates are not supported in the given router db for the given profile.");
}
_graph = contractedDb.EdgeBasedGraph;
weightHandler.CheckCanUse(contractedDb);
_buckets = new Dictionary <uint, Dictionary <int, T> >();
}
public void TestVertexCountAndTrim()
{
var graph = new DirectedDynamicGraph(10, 1);
// add edge.
graph.AddEdge(0, 1, 1);
// trim.
graph.Trim();
Assert.AreEqual(2, graph.VertexCount);
graph = new DirectedDynamicGraph(10, 1);
// add edge.
graph.AddEdge(0, 1, 1);
graph.AddEdge(0, 11001, 1);
// trim.
graph.Trim();
Assert.AreEqual(11002, graph.VertexCount);
graph = new DirectedDynamicGraph(10, 1);
// trim.
graph.Trim(); // keep minimum one vertex.
Assert.AreEqual(1, graph.VertexCount);
}
/// <summary>
/// Creates a new weight-matrix algorithm.
/// </summary>
public DirectedWeightMatrixAlgorithm(RouterBase router, IProfileInstance profile, WeightHandler <T> weightHandler, IMassResolvingAlgorithm massResolver, T?max = null)
{
_router = router;
_profile = profile;
_weightHandler = weightHandler;
_massResolver = massResolver;
ContractedDb contractedDb;
if (!router.Db.TryGetContracted(profile.Profile, out contractedDb))
{
throw new NotSupportedException(
"Contraction-based many-to-many calculates are not supported in the given router db for the given profile.");
}
if (!contractedDb.HasEdgeBasedGraph)
{
throw new NotSupportedException(
"Contraction-based edge-based many-to-many calculates are not supported in the given router db for the given profile.");
}
_graph = contractedDb.EdgeBasedGraph;
weightHandler.CheckCanUse(contractedDb);
if (max.HasValue)
{
_max = max.Value;
}
else
{
_max = weightHandler.Infinite;
}
_buckets = new Dictionary <uint, Dictionary <int, LinkedEdgePath <T> > >();
}
public void Calculate(DirectedDynamicGraph graph, Func <uint, IEnumerable <uint[]> > getRestrictions, uint source, List <uint> targets, List <float> weights,
ref EdgePath <float>[] forwardWitness, ref EdgePath <float>[] backwardWitness, uint vertexToSkip)
{
for (var i = 0; i < forwardWitness.Length; i++)
{
if (forwardWitness[i] == null)
{
forwardWitness[i] = new EdgePath <float>();
}
if (backwardWitness[i] == null)
{
backwardWitness[i] = new EdgePath <float>();
}
}
if (_witnesses != null)
{
for (var i = 0; i < targets.Count; i++)
{
var target = targets[i];
var witnesses = _witnesses(source, target);
if (witnesses != null)
{
forwardWitness[i] = witnesses.Item1;
backwardWitness[i] = witnesses.Item2;
}
}
}
}
/// <summary>
/// Creates a new contracted graph and adds it to the router db for the given profile.
/// </summary>
public static void AddEdgeBasedContractedForTesting <T>(this RouterDb db, Profile profile, WeightHandler <T> weightHandler)
where T : struct
{
// create the raw directed graph.
ContractedDb contractedDb = null;
var contracted = new DirectedDynamicGraph(weightHandler.DynamicSize);
var directedGraphBuilder = new Itinero.Algorithms.Contracted.EdgeBased.DirectedGraphBuilder <T>(db.Network.GeometricGraph.Graph, contracted,
weightHandler);
directedGraphBuilder.Run();
// contract the graph.
var priorityCalculator = new Itinero.Algorithms.Contracted.EdgeBased.EdgeDifferencePriorityCalculator <T>(contracted, weightHandler,
new Itinero.Algorithms.Contracted.EdgeBased.Witness.DykstraWitnessCalculator <T>(weightHandler, 4, 64));
priorityCalculator.DifferenceFactor = 5;
priorityCalculator.DepthFactor = 5;
priorityCalculator.ContractedFactor = 8;
var hierarchyBuilder = new Itinero.Algorithms.Contracted.EdgeBased.HierarchyBuilder <T>(contracted, priorityCalculator,
new Itinero.Algorithms.Contracted.EdgeBased.Witness.DykstraWitnessCalculator <T>(weightHandler, int.MaxValue, 64), weightHandler, db.GetGetRestrictions(profile, null));
hierarchyBuilder.Run();
contractedDb = new ContractedDb(contracted);
// add the graph.
db.AddContracted(profile, contractedDb);
}
public void TestDoubleContractionOneway()
{
// build graph.
var graph = new DirectedDynamicGraph(ContractedEdgeDataSerializer.DynamicFixedSize);
graph.AddEdge(0, 1, 100, null);
graph.AddEdge(1, 0, 100, null);
graph.AddEdge(1, 2, 100, null);
graph.AddEdge(2, 1, 100, null);
graph.AddEdge(1, 3, 10, null);
graph.AddEdge(3, 1, 10, null);
graph.AddEdge(3, 2, 10, null);
graph.AddEdge(2, 3, 10, null);
graph.Compress();
// contract graph.
var priorities = new Dictionary <uint, float>();
priorities.Add(1, 0);
priorities.Add(0, 1);
priorities.Add(2, 2);
priorities.Add(3, 3);
var hierarchyBuilder = new HierarchyBuilder(graph,
new MockPriorityCalculator(priorities),
new DykstraWitnessCalculator(int.MaxValue), (i) => Enumerable.Empty <uint[]>());
hierarchyBuilder.Run();
// edges 1->2 and 2->1 should have been removed.
var edge = graph.GetEdgeEnumerator(0).FirstOrDefault(x => x.Neighbour == 3);
Assert.IsNotNull(edge);
var edgeData = ContractedEdgeDataSerializer.Deserialize(edge.Data[0], Constants.NO_VERTEX);
Assert.AreEqual(110, edgeData.Weight);
Assert.AreEqual(null, edgeData.Direction);
Assert.AreEqual(1, edge.GetContracted());
edge = graph.GetEdgeEnumerator(1).FirstOrDefault(x => x.Neighbour == 0);
Assert.IsNotNull(edge);
edgeData = ContractedEdgeDataSerializer.Deserialize(edge.Data[0], Constants.NO_VERTEX);
Assert.AreEqual(100, edgeData.Weight);
Assert.AreEqual(null, edgeData.Direction);
Assert.AreEqual(Constants.NO_VERTEX, edgeData.ContractedId);
edge = graph.GetEdgeEnumerator(1).FirstOrDefault(x => x.Neighbour == 3);
Assert.IsNotNull(edge);
edgeData = ContractedEdgeDataSerializer.Deserialize(edge.Data[0], Constants.NO_VERTEX);
Assert.AreEqual(10, edgeData.Weight);
Assert.AreEqual(null, edgeData.Direction);
Assert.AreEqual(Constants.NO_VERTEX, edgeData.ContractedId);
edge = graph.GetEdgeEnumerator(2).FirstOrDefault(x => x.Neighbour == 3);
Assert.IsNotNull(edge);
edgeData = ContractedEdgeDataSerializer.Deserialize(edge.Data[0], Constants.NO_VERTEX);
Assert.AreEqual(10, edgeData.Weight);
Assert.AreEqual(null, edgeData.Direction);
Assert.AreEqual(Constants.NO_VERTEX, edgeData.ContractedId);
}
/// <summary>
/// Creates a new graph builder.
/// </summary>
public DirectedGraphBuilder(Itinero.Graphs.Graph source, DirectedDynamicGraph target, WeightHandler <T> weightHandler)
{
weightHandler.CheckCanUse(target);
_source = source;
_target = target;
_weightHandler = weightHandler;
}
public void TestOneEdgeAugmented()
{
// build graph.
var graph = new Itinero.Graphs.Graph(EdgeDataSerializer.Size);
graph.AddVertex(0);
graph.AddVertex(1);
graph.AddEdge(0, 1, EdgeDataSerializer.Serialize(new EdgeData()
{
Distance = 100,
Profile = 1
}));
// build speed profile function.
var speed = 100f / 3.6f;
Func <ushort, FactorAndSpeed> getFactor = (x) =>
{
return(new FactorAndSpeed()
{
Direction = 0,
SpeedFactor = 1.0f / speed,
Value = 1.0f / speed
});
};
// convert graph.
var directedGraph = new DirectedDynamicGraph(ContractedEdgeDataSerializer.DynamicAugmentedFixedSize);
var algorithm = new DirectedGraphBuilder <Weight>(graph, directedGraph, new WeightHandler(getFactor));
algorithm.Run();
// check result.
Assert.IsTrue(algorithm.HasRun);
Assert.IsTrue(algorithm.HasSucceeded);
directedGraph.Compress();
Assert.AreEqual(2, directedGraph.VertexCount);
Assert.AreEqual(2, directedGraph.EdgeCount);
// verify all edges.
var edges = directedGraph.GetEdgeEnumerator(0);
Assert.AreEqual(1, edges.Count());
var data = ContractedEdgeDataSerializer.SerializeDynamicAugmented(100 * getFactor(1).Value, null, 100, 100 * getFactor(1).Value);
Assert.AreEqual(data[0], edges.First().Data[0]);
Assert.AreEqual(data[1], edges.First().Data[1]);
Assert.AreEqual(data[2], edges.First().Data[2]);
Assert.AreEqual(1, edges.First().Neighbour);
edges = directedGraph.GetEdgeEnumerator(1);
Assert.AreEqual(1, edges.Count());
data = ContractedEdgeDataSerializer.SerializeDynamicAugmented(100 * getFactor(1).Value, null, 100, 100 * getFactor(1).Value);
Assert.AreEqual(data[0], edges.First().Data[0]);
Assert.AreEqual(data[1], edges.First().Data[1]);
Assert.AreEqual(data[2], edges.First().Data[2]);
Assert.AreEqual(0, edges.First().Neighbour);
}
public void TestTwoNeighboursOneWayOpposite()
{
// build graph.
var graph = new DirectedDynamicGraph(ContractedEdgeDataSerializer.DynamicFixedSize);
graph.AddEdge(0, 1, 100, true);
graph.AddEdge(1, 0, 100, false);
graph.AddEdge(0, 2, 100, true);
graph.AddEdge(2, 0, 100, false);
// create a witness calculator and the priority calculator.
var priorityCalculator = new EdgeDifferencePriorityCalculator(graph,
new WitnessCalculatorMock((source, target) =>
{
if (source == 0 && target == 1)
{
return(new Tuple <EdgePath <float>, EdgePath <float> >(
new EdgePath <float>(0, 100, new EdgePath <float>(1)),
new EdgePath <float>()));
}
if (source == 0 && target == 2)
{
return(new Tuple <EdgePath <float>, EdgePath <float> >(
new EdgePath <float>(0, 100, new EdgePath <float>(2)),
new EdgePath <float>()));
}
if (source == 1 && target == 0)
{
return(new Tuple <EdgePath <float>, EdgePath <float> >(
new EdgePath <float>(),
new EdgePath <float>(0, 100, new EdgePath <float>(1))));
}
if (source == 2 && target == 0)
{
return(new Tuple <EdgePath <float>, EdgePath <float> >(
new EdgePath <float>(),
new EdgePath <float>(0, 100, new EdgePath <float>(2))));
}
if (source == 1 && target == 2)
{
return(new Tuple <EdgePath <float>, EdgePath <float> >(
new EdgePath <float>(),
new EdgePath <float>()));
}
if (source == 2 && target == 1)
{
return(new Tuple <EdgePath <float>, EdgePath <float> >(
new EdgePath <float>(),
new EdgePath <float>()));
}
return(null);
}));
var priority = priorityCalculator.Calculate(new BitArray32(graph.VertexCount), (i) => null, 0);
Assert.AreEqual(-2, priority);
}
/// <summary>
/// Creates a new node-based contracted db.
/// </summary>
public ContractedDb(DirectedMetaGraph nodeBasedGraph)
{
if (nodeBasedGraph == null)
{
throw new ArgumentNullException("nodeBasedGraph");
}
_nodeBasedGraph = nodeBasedGraph;
_edgeBasedGraph = null;
}
/// <summary>
/// Creates a new edge-based contracted db.
/// </summary>
public ContractedDb(DirectedDynamicGraph edgeBasedGraph)
{
if (edgeBasedGraph == null)
{
throw new ArgumentNullException("edgeBasedGraph");
}
_nodeBasedGraph = null;
_edgeBasedGraph = edgeBasedGraph;
}
/// <summary>
/// Creates a new hierarchy builder.
/// </summary>
public HierarchyBuilder(DirectedDynamicGraph graph, IPriorityCalculator priorityCalculator, IWitnessCalculator <T> witnessCalculator,
WeightHandler <T> weightHandler, Func <uint, IEnumerable <uint[]> > getRestrictions)
{
weightHandler.CheckCanUse(graph);
_graph = graph;
_priorityCalculator = priorityCalculator;
_witnessCalculator = witnessCalculator;
_getRestrictions = getRestrictions;
_weightHandler = weightHandler;
}
public void TestDeserialize()
{
var graph = new DirectedDynamicGraph(10, 1);
graph.AddEdge(0, 1, 1);
// serialize.
using (var stream = new System.IO.MemoryStream())
{
var size = graph.Serialize(stream);
stream.Seek(0, System.IO.SeekOrigin.Begin);
var deserializedGraph = DirectedDynamicGraph.Deserialize(stream, DirectedGraphProfile.Aggressive24);
Assert.AreEqual(size, stream.Position);
Assert.AreEqual(2, deserializedGraph.VertexCount);
Assert.AreEqual(1, deserializedGraph.EdgeCount);
// verify all edges.
var edges = deserializedGraph.GetEdgeEnumerator(0);
Assert.AreEqual(1, edges.Count());
Assert.AreEqual(1, edges.First().Data[0]);
Assert.AreEqual(1, edges.First().Neighbour);
edges = deserializedGraph.GetEdgeEnumerator(1);
Assert.IsFalse(edges.MoveNext());
}
graph = new DirectedDynamicGraph(10, 1);
graph.AddEdge(0, 1, 1);
graph.AddEdge(0, 2, 2);
graph.AddEdge(0, 3, 3);
graph.AddEdge(0, 4, 4);
graph.AddEdge(5, 1, 5);
graph.AddEdge(5, 2, 6);
graph.AddEdge(5, 3, 7);
graph.AddEdge(5, 4, 8);
// serialize.
using (var stream = new System.IO.MemoryStream())
{
var size = graph.Serialize(stream);
stream.Seek(0, System.IO.SeekOrigin.Begin);
var deserializedGraph = DirectedDynamicGraph.Deserialize(stream, DirectedGraphProfile.Aggressive24);
Assert.AreEqual(size, stream.Position);
Assert.AreEqual(6, deserializedGraph.VertexCount);
Assert.AreEqual(8, deserializedGraph.EdgeCount);
}
}
public void TestTwoEdgesMiddleHighest()
{
// build graph.
var graph = new DirectedDynamicGraph(ContractedEdgeDataSerializer.DynamicFixedSize);
graph.AddEdge(0, 1, 100, null);
graph.AddEdge(2, 1, 100, null);
// create algorithm and run.
var algorithm = new Itinero.Algorithms.Contracted.EdgeBased.Dykstra(graph,
new EdgePath <float>[] { new EdgePath <float>(0) },
(v) => null, true);
algorithm.Run();
// check results.
Assert.IsTrue(algorithm.HasRun);
Assert.IsTrue(algorithm.HasSucceeded);
EdgePath <float> visit;
Assert.IsTrue(algorithm.TryGetVisit(0, out visit));
Assert.AreEqual(0, visit.Weight);
Assert.AreEqual(0, visit.Vertex);
Assert.AreEqual(null, visit.From);
Assert.IsTrue(algorithm.TryGetVisit(1, out visit));
Assert.AreEqual(100, visit.Weight);
Assert.AreEqual(1, visit.Vertex);
Assert.IsNotNull(visit.From);
Assert.AreEqual(0, visit.From.Vertex);
Assert.IsFalse(algorithm.TryGetVisit(2, out visit));
// create algorithm and run.
algorithm = new Itinero.Algorithms.Contracted.EdgeBased.Dykstra(graph,
new EdgePath <float>[] { new EdgePath <float>(0) },
(v) => null, false);
algorithm.Run();
// check results.
Assert.IsTrue(algorithm.HasRun);
Assert.IsTrue(algorithm.HasSucceeded);
Assert.IsTrue(algorithm.TryGetVisit(0, out visit));
Assert.AreEqual(0, visit.Weight);
Assert.AreEqual(0, visit.Vertex);
Assert.AreEqual(null, visit.From);
Assert.IsTrue(algorithm.TryGetVisit(1, out visit));
Assert.AreEqual(100, visit.Weight);
Assert.AreEqual(1, visit.Vertex);
Assert.IsNotNull(visit.From);
Assert.AreEqual(0, visit.From.Vertex);
Assert.IsFalse(algorithm.TryGetVisit(2, out visit));
}
/// <summary>
/// Creates a new contracted graph and adds it to the router db for the given profile.
/// </summary>
public static void AddContracted <T>(this RouterDb db, Profiles.Profile profile, WeightHandler <T> weightHandler, bool forceEdgeBased = false)
where T : struct
{
// create the raw directed graph.
ContractedDb contractedDb = null;
lock (db)
{
if (forceEdgeBased)
{ // edge-based is needed when complex restrictions found.
var contracted = new DirectedDynamicGraph(weightHandler.DynamicSize);
var directedGraphBuilder = new Itinero.Algorithms.Contracted.EdgeBased.DirectedGraphBuilder <T>(db.Network.GeometricGraph.Graph, contracted,
weightHandler);
directedGraphBuilder.Run();
// contract the graph.
var priorityCalculator = new Itinero.Algorithms.Contracted.EdgeBased.EdgeDifferencePriorityCalculator <T>(contracted, weightHandler,
new Itinero.Algorithms.Contracted.EdgeBased.Witness.DykstraWitnessCalculator <T>(weightHandler, int.MaxValue));
priorityCalculator.DifferenceFactor = 5;
priorityCalculator.DepthFactor = 5;
priorityCalculator.ContractedFactor = 8;
var hierarchyBuilder = new Itinero.Algorithms.Contracted.EdgeBased.HierarchyBuilder <T>(contracted, priorityCalculator,
new Itinero.Algorithms.Contracted.EdgeBased.Witness.DykstraWitnessCalculator <T>(weightHandler, int.MaxValue), weightHandler, db.GetGetRestrictions(profile, null));
hierarchyBuilder.Run();
contractedDb = new ContractedDb(contracted);
}
else
{ // vertex-based is ok when no complex restrictions found.
var contracted = new DirectedMetaGraph(ContractedEdgeDataSerializer.Size, weightHandler.MetaSize);
var directedGraphBuilder = new DirectedGraphBuilder <T>(db.Network.GeometricGraph.Graph, contracted, weightHandler);
directedGraphBuilder.Run();
// contract the graph.
var priorityCalculator = new EdgeDifferencePriorityCalculator(contracted,
new DykstraWitnessCalculator(int.MaxValue));
priorityCalculator.DifferenceFactor = 5;
priorityCalculator.DepthFactor = 5;
priorityCalculator.ContractedFactor = 8;
var hierarchyBuilder = new HierarchyBuilder <T>(contracted, priorityCalculator,
new DykstraWitnessCalculator(int.MaxValue), weightHandler);
hierarchyBuilder.Run();
contractedDb = new ContractedDb(contracted);
}
}
// add the graph.
lock (db)
{
db.AddContracted(profile, contractedDb);
}
}
/// <summary>
/// Creates a new priority calculator.
/// </summary>
public EdgeDifferencePriorityCalculator(DirectedDynamicGraph graph, WeightHandler <T> weightHandler, IWitnessCalculator <T> witnessCalculator)
{
_graph = graph;
_witnessCalculator = witnessCalculator;
_contractionCount = new Dictionary <uint, int>();
_depth = new Dictionary <long, int>();
_weightHandler = weightHandler;
this.DifferenceFactor = 1;
this.DepthFactor = 2;
this.ContractedFactor = 1;
}
public void TestNoNeighbours()
{
// build graph.
var graph = new DirectedDynamicGraph(ContractedEdgeDataSerializer.DynamicFixedSize);
graph.AddEdge(1, 0, 100, null);
// create a witness calculator and the priority calculator.
var priorityCalculator = new EdgeDifferencePriorityCalculator(graph,
new WitnessCalculatorMock());
var priority = priorityCalculator.Calculate(new BitArray32(graph.VertexCount), (i) => null, 0);
Assert.AreEqual(0, priority);
}
/// <summary>
/// Creates a new routing algorithm instance.
/// </summary>
public Dykstra(DirectedDynamicGraph graph, WeightHandler <T> weightHandler, IEnumerable <EdgePath <T> > sources,
Func <uint, IEnumerable <uint[]> > getRestrictions, bool backward)
{
weightHandler.CheckCanUse(graph);
_graph = graph;
_getRestrictions = getRestrictions;
_sources = sources.Select(x => {
x.StripEdges();
return(x);
});
_backward = backward;
_weightHandler = weightHandler;
}
public void TestDoubleContraction()
{
// build graph.
var graph = new DirectedDynamicGraph(ContractedEdgeDataSerializer.DynamicFixedSize);
graph.AddEdge(0, 2, 100, null);
graph.AddEdge(2, 0, 100, null);
graph.AddEdge(0, 3, 100, null);
graph.AddEdge(3, 0, 100, null);
graph.AddEdge(1, 2, 200, null);
graph.AddEdge(2, 1, 200, null);
graph.AddEdge(1, 3, 200, null);
graph.AddEdge(3, 1, 200, null);
graph.Compress();
// contract graph.
var priorityCalculator = new EdgeDifferencePriorityCalculator(graph, new DykstraWitnessCalculator(int.MaxValue));
priorityCalculator.DepthFactor = 0;
priorityCalculator.ContractedFactor = 0;
var hierarchyBuilder = new HierarchyBuilder(graph, priorityCalculator,
new DykstraWitnessCalculator(int.MaxValue), (i) => Enumerable.Empty <uint[]>());
hierarchyBuilder.Run();
// check edges.
var edge = graph.GetEdgeEnumerator(0).FirstOrDefault(x => x.Neighbour == 2);
Assert.IsNull(edge);
edge = graph.GetEdgeEnumerator(2).FirstOrDefault(x => x.Neighbour == 0);
Assert.IsNotNull(edge);
edge = graph.GetEdgeEnumerator(0).FirstOrDefault(x => x.Neighbour == 3);
Assert.IsNull(edge);
edge = graph.GetEdgeEnumerator(3).FirstOrDefault(x => x.Neighbour == 0);
Assert.IsNotNull(edge);
edge = graph.GetEdgeEnumerator(2).FirstOrDefault(x => x.Neighbour == 1);
Assert.IsNull(edge);
edge = graph.GetEdgeEnumerator(1).FirstOrDefault(x => x.Neighbour == 2);
Assert.IsNotNull(edge);
edge = graph.GetEdgeEnumerator(3).FirstOrDefault(x => x.Neighbour == 1);
Assert.IsNull(edge);
edge = graph.GetEdgeEnumerator(1).FirstOrDefault(x => x.Neighbour == 3);
Assert.IsNotNull(edge);
}
/// <summary>
/// Creates a new contracted bidirectional router.
/// </summary>
public BidirectionalDykstra(DirectedDynamicGraph graph, WeightHandler <T> weightHandler, IEnumerable <EdgePath <T> > sources, IEnumerable <EdgePath <T> > targets,
Func <uint, IEnumerable <uint[]> > getRestrictions)
{
weightHandler.CheckCanUse(graph);
_graph = graph;
_weightHandler = weightHandler;
_sources = sources.Select(x => {
x.StripEdges();
return(x);
});
_targets = targets.Select(x => {
x.StripEdges();
return(x);
});
_getRestrictions = getRestrictions;
}
public void TestGetSequence2()
{
// build graph.
var graph = new DirectedDynamicGraph(ContractedEdgeDataSerializer.DynamicFixedSize);
var e1 = graph.AddEdge(0, 1, 100, null);
var e2 = graph.AddEdge(1, 2, 100, null);
var e3 = graph.AddEdge(2, 6, 100, null, 4, new uint[] { 3 }, new uint[] { 5 });
var e4 = graph.AddEdge(6, 16, 100, null, 11, new uint[] { 7, 8, 9, 10 }, new uint[] { 12, 13, 14, 15 });
var enumerator = graph.GetEdgeEnumerator();
// build and test getting sequences from paths.
var path = new EdgePath <float>(0);
var s = path.GetSequence2(enumerator);
Assert.IsNotNull(s);
Assert.AreEqual(0, s.Length);
path = new EdgePath <float>(1, 100, new EdgePath <float>(0));
s = path.GetSequence2(enumerator);
Assert.IsNotNull(s);
Assert.AreEqual(1, s.Length);
Assert.AreEqual(0, s[0]);
path = new EdgePath <float>(2, 200, e2 + 1, new EdgePath <float>(1, 100, new EdgePath <float>(0)));
s = path.GetSequence2(enumerator);
Assert.IsNotNull(s);
Assert.AreEqual(2, s.Length);
Assert.AreEqual(0, s[0]);
Assert.AreEqual(1, s[1]);
path = new EdgePath <float>(6, 300, e3 + 1, new EdgePath <float>(2, 200, e2 + 1, new EdgePath <float>(1, 100, new EdgePath <float>(0))));
s = path.GetSequence2(enumerator);
Assert.IsNotNull(s);
Assert.AreEqual(1, s.Length);
Assert.AreEqual(5, s[0]);
path = new EdgePath <float>(16, 400, e4 + 1, new EdgePath <float>(6, 300, e3 + 1, new EdgePath <float>(2, 200, e2 + 1, new EdgePath <float>(1, 100, new EdgePath <float>(0)))));
s = path.GetSequence2(enumerator);
Assert.IsNotNull(s);
Assert.AreEqual(4, s.Length);
Assert.AreEqual(12, s[0]);
Assert.AreEqual(13, s[1]);
Assert.AreEqual(14, s[2]);
Assert.AreEqual(15, s[3]);
}
public void TestOneNeighboursContracted()
{
// build graph.
var graph = new DirectedDynamicGraph(ContractedEdgeDataSerializer.DynamicFixedSize);
graph.AddEdge(0, 1, 100, true);
graph.AddEdge(1, 0, 100, false);
// create a witness calculator and the priority calculator.
var contractedFlags = new BitArray32(graph.VertexCount);
contractedFlags[1] = true;
var priorityCalculator = new EdgeDifferencePriorityCalculator(graph,
new WitnessCalculatorMock());
var priority = priorityCalculator.Calculate(contractedFlags, (i) => null, 0);
Assert.AreEqual(-2, priority);
}
public void TestSerialize()
{
var graph = new DirectedDynamicGraph(10, 1);
// add and compress.
graph.AddEdge(0, 1, 1);
graph.Compress();
var expectedSize = 1 + 8 + 8 + 8 + 4 + // the header: version byte two longs representing vertex, edge count and the size of the edge array and one int for minimum edge size.
graph.VertexCount * 1 * 4 + // the bytes for the vertex-index: 1 uint.
graph.EdgeCount * 2 * 4; // the bytes for the edges: one edge 2 uint's.
using (var stream = new System.IO.MemoryStream())
{
Assert.AreEqual(expectedSize, graph.Serialize(stream));
Assert.AreEqual(expectedSize, stream.Position);
}
// verify all edges.
var edges = graph.GetEdgeEnumerator(0);
Assert.AreEqual(1, edges.Count());
Assert.AreEqual(1, edges.First().Data[0]);
Assert.AreEqual(1, edges.First().Neighbour);
graph = new DirectedDynamicGraph(10, 1);
// add and compress.
graph.AddEdge(0, 1, 10);
graph.AddEdge(1, 2, 20);
graph.AddEdge(2, 3, 30);
graph.AddEdge(3, 4, 40);
graph.RemoveEdge(1, 2);
graph.Compress();
expectedSize = 1 + 8 + 8 + 8 + 4 + // the header: version bytes, three longs representing vertex and edge count and the size of the edge array and one int for fixed edge size.
graph.VertexCount * 4 + // the bytes for the vertex-index: 2 uint's.
graph.EdgeCount * 2 * 4; // the bytes for the edges: one edge 1 uint.
using (var stream = new System.IO.MemoryStream())
{
Assert.AreEqual(expectedSize, graph.Serialize(stream));
Assert.AreEqual(expectedSize, stream.Position);
}
}