public void AdjacentEdges_Throws()
{
var wrappedGraph = new BidirectionalGraph <EquatableTestVertex, Edge <EquatableTestVertex> >();
var graph = new UndirectedBidirectionalGraph <EquatableTestVertex, Edge <EquatableTestVertex> >(wrappedGraph);
AdjacentEdges_Throws_Test(graph);
}
public void BinarySerialization_BidirectionalGraph([NotNull] BidirectionalGraph <int, EquatableEdge <int> > graph)
{
BidirectionalGraph <int, EquatableEdge <int> > deserializedGraph =
SerializeDeserialize <int, EquatableEdge <int>, BidirectionalGraph <int, EquatableEdge <int> > >(graph);
Assert.IsTrue(EquateGraphs.Equate(graph, deserializedGraph));
var arrayGraph = new ArrayBidirectionalGraph <int, EquatableEdge <int> >(graph);
ArrayBidirectionalGraph <int, EquatableEdge <int> > deserializedGraph2 =
SerializeDeserialize <int, EquatableEdge <int>, ArrayBidirectionalGraph <int, EquatableEdge <int> > >(arrayGraph);
Assert.IsTrue(EquateGraphs.Equate(arrayGraph, deserializedGraph2));
var reversedGraph = new ReversedBidirectionalGraph <int, EquatableEdge <int> >(graph);
ReversedBidirectionalGraph <int, EquatableEdge <int> > deserializedGraph3 =
SerializeDeserialize <int, SReversedEdge <int, EquatableEdge <int> >, ReversedBidirectionalGraph <int, EquatableEdge <int> > >(reversedGraph);
Assert.IsTrue(EquateGraphs.Equate(reversedGraph, deserializedGraph3));
var undirectedBidirectionalGraph = new UndirectedBidirectionalGraph <int, EquatableEdge <int> >(graph);
UndirectedBidirectionalGraph <int, EquatableEdge <int> > deserializedGraph4 =
SerializeDeserialize <int, EquatableEdge <int>, UndirectedBidirectionalGraph <int, EquatableEdge <int> > >(undirectedBidirectionalGraph);
Assert.IsTrue(EquateGraphs.Equate(undirectedBidirectionalGraph, deserializedGraph4));
}
public void ReLayoutGraph()
{
//dane potrzebne w metodach obsługujących macierz
MatrixMethod.NumberOfVertices = _numberOfVertices;
MatrixMethod.ProbabilityValue = _probabilityValue;
Graph = new Graph(true); //nowy graf
_matrix = MatrixMethod.FillTheMatrix(); //macierz incydencji
_existingVertices = new List <Vertex>(); //lista przechowująca wierzchołki
//wygenerowanie odpowiedniej ilości wierzchołków
for (int i = 0; i < _numberOfVertices; i++)
{
_existingVertices.Add(new Vertex((i + 1).ToString(), i));
Graph.AddVertex(_existingVertices[i]);
}
//generowanie krawędzi na podstawie macierzy
EdgeMethod.GenerateEdges(_matrix, _existingVertices, Graph);
//suma jest zapisana w ostatniej kolumnie macierzy oraz we właściwości obiektu vertex(VertexDegree)<=potrzebne w naprawie
VertexMethod.CalculateTheSum(_matrix, _existingVertices);
//zapisanie wierzołków sąsiadujących ze sobą(potrzebne w naprawie)
VertexMethod.SetVertexNeighbors(_matrix, _existingVertices);
UndirectedGraph = new UndirectedBidirectionalGraph <Vertex, Edge>(Graph);//coś jak canvas
RefreshMatrixUi();//odświeżenie UI
}
public void GraphMLSerialization_BidirectionalGraph([NotNull] BidirectionalGraph <int, EquatableEdge <int> > graph)
{
AdjacencyGraph <int, EquatableEdge <int> > deserializedGraph =
SerializeDeserialize <BidirectionalGraph <int, EquatableEdge <int> >, AdjacencyGraph <int, EquatableEdge <int> > >(graph);
Assert.IsTrue(EquateGraphs.Equate(graph, deserializedGraph));
var arrayGraph = new ArrayBidirectionalGraph <int, EquatableEdge <int> >(graph);
AdjacencyGraph <int, EquatableEdge <int> > deserializedGraph2 =
SerializeDeserialize <ArrayBidirectionalGraph <int, EquatableEdge <int> >, AdjacencyGraph <int, EquatableEdge <int> > >(arrayGraph);
Assert.IsTrue(EquateGraphs.Equate(arrayGraph, deserializedGraph2));
var reversedGraph = new ReversedBidirectionalGraph <int, EquatableEdge <int> >(graph);
BidirectionalGraph <int, EquatableEdge <int> > deserializedGraph3 =
SerializeDeserialize_Reversed <ReversedBidirectionalGraph <int, EquatableEdge <int> >, BidirectionalGraph <int, EquatableEdge <int> > >(reversedGraph);
Assert.IsTrue(
EquateGraphs.Equate(
graph,
deserializedGraph3,
EqualityComparer <int> .Default,
LambdaEqualityComparer <EquatableEdge <int> > .Create(
(edge1, edge2) => Equals(edge1.Source, edge2.Target) && Equals(edge1.Target, edge2.Source),
edge => edge.GetHashCode())));
var undirectedBidirectionalGraph = new UndirectedBidirectionalGraph <int, EquatableEdge <int> >(graph);
UndirectedGraph <int, EquatableEdge <int> > deserializedGraph4 =
SerializeDeserialize <UndirectedBidirectionalGraph <int, EquatableEdge <int> >, UndirectedGraph <int, EquatableEdge <int> > >(undirectedBidirectionalGraph);
Assert.IsTrue(EquateGraphs.Equate(undirectedBidirectionalGraph, deserializedGraph4));
}
public void ContainsVertex_Throws()
{
var wrappedGraph = new BidirectionalGraph <TestVertex, Edge <TestVertex> >();
var graph = new UndirectedBidirectionalGraph <TestVertex, Edge <TestVertex> >(wrappedGraph);
ContainsVertex_Throws_Test(graph);
}
public void BinarySerialization_BidirectionalGraph_Complex([NotNull] BidirectionalGraph <EquatableTestVertex, EquatableTestEdge> graph)
{
BidirectionalGraph <EquatableTestVertex, EquatableTestEdge> deserializedGraph =
SerializeDeserialize <EquatableTestVertex, EquatableTestEdge, BidirectionalGraph <EquatableTestVertex, EquatableTestEdge> >(graph);
Assert.IsTrue(EquateGraphs.Equate(graph, deserializedGraph));
var arrayGraph = new ArrayBidirectionalGraph <EquatableTestVertex, EquatableTestEdge>(graph);
ArrayBidirectionalGraph <EquatableTestVertex, EquatableTestEdge> deserializedGraph2 =
SerializeDeserialize <EquatableTestVertex, EquatableTestEdge, ArrayBidirectionalGraph <EquatableTestVertex, EquatableTestEdge> >(arrayGraph);
Assert.IsTrue(EquateGraphs.Equate(arrayGraph, deserializedGraph2));
var reversedGraph = new ReversedBidirectionalGraph <EquatableTestVertex, EquatableTestEdge>(graph);
ReversedBidirectionalGraph <EquatableTestVertex, EquatableTestEdge> deserializedGraph3 =
SerializeDeserialize <EquatableTestVertex, SReversedEdge <EquatableTestVertex, EquatableTestEdge>, ReversedBidirectionalGraph <EquatableTestVertex, EquatableTestEdge> >(reversedGraph);
Assert.IsTrue(EquateGraphs.Equate(reversedGraph, deserializedGraph3));
var undirectedBidirectionalGraph = new UndirectedBidirectionalGraph <EquatableTestVertex, EquatableTestEdge>(graph);
UndirectedBidirectionalGraph <EquatableTestVertex, EquatableTestEdge> deserializedGraph4 =
SerializeDeserialize <EquatableTestVertex, EquatableTestEdge, UndirectedBidirectionalGraph <EquatableTestVertex, EquatableTestEdge> >(undirectedBidirectionalGraph);
Assert.IsTrue(EquateGraphs.Equate(undirectedBidirectionalGraph, deserializedGraph4));
}
public void TryGetEdge_Throws()
{
var wrappedGraph = new BidirectionalGraph <TestVertex, Edge <TestVertex> >();
var graph = new UndirectedBidirectionalGraph <TestVertex, Edge <TestVertex> >(wrappedGraph);
TryGetEdge_Throws_UndirectedGraph_Test(graph);
}
public void AdjacentEdge_Throws()
{
var wrappedGraph = new BidirectionalGraph <int, Edge <int> >();
var graph = new UndirectedBidirectionalGraph <int, Edge <int> >(wrappedGraph);
// ReSharper disable once ReturnValueOfPureMethodIsNotUsed
Assert.Throws <NotSupportedException>(() => graph.AdjacentEdge(1, 0));
}
public void ContainsEdge_Throws()
{
var wrappedGraph = new BidirectionalGraph <TestVertex, Edge <TestVertex> >();
var graph = new UndirectedBidirectionalGraph <TestVertex, Edge <TestVertex> >(wrappedGraph);
ContainsEdge_NullThrows_Test(graph);
ContainsEdge_SourceTarget_Throws_UndirectedGraph_Test(graph);
}
public override void Compute(CancellationToken cancellationToken)
{
Sizes = new Dictionary <TVertex, Size>(VertexSizes);
if (Parameters.Direction == LayoutDirection.LeftToRight || Parameters.Direction == LayoutDirection.RightToLeft)
{
//change the sizes
foreach (var sizePair in Sizes.ToArray())
{
Sizes[sizePair.Key] = new Size(sizePair.Value.Height, sizePair.Value.Width);
}
}
if (Parameters.Direction == LayoutDirection.RightToLeft || Parameters.Direction == LayoutDirection.BottomToTop)
{
_direction = -1;
}
else
{
_direction = 1;
}
GenerateSpanningTree(cancellationToken);
//DoWidthAndHeightOptimization();
var graph = new UndirectedBidirectionalGraph <TVertex, TEdge>(VisitedGraph);
var scca = new QuickGraph.Algorithms.ConnectedComponents.ConnectedComponentsAlgorithm <TVertex, TEdge>(graph);
scca.Compute();
// Order connected components by their vertices count
// Group vertices by connected component (they should be placed together)
// Order vertices inside each conected component by in degree first, then out dregee
// (roots should be placed in the first layer and leafs in the last layer)
var components = from e in scca.Components
group e.Key by e.Value into c
orderby c.Count() descending
select c;
foreach (var c in components)
{
var firstOfComponent = true;
var vertices = from v in c
orderby VisitedGraph.InDegree(v), VisitedGraph.OutDegree(v) descending
select v;
foreach (var source in vertices)
{
CalculatePosition(source, null, 0, firstOfComponent);
if (firstOfComponent)
{
firstOfComponent = false;
}
}
}
AssignPositions(cancellationToken);
}
private void GetDistancesAndWeights(out double[,] d, out double[,] w)
{
d = new double[VisitedGraph.VertexCount, VisitedGraph.VertexCount];
w = new double[VisitedGraph.VertexCount, VisitedGraph.VertexCount];
double maxCost = 0.0001;
var undirected = new UndirectedBidirectionalGraph <TVertex, TEdge>(VisitedGraph);
int i = 0;
foreach (TVertex source in undirected.Vertices)
{
var spa = new UndirectedDijkstraShortestPathAlgorithm <TVertex, TEdge>(undirected, edge => edge is IWeightedEdge <TVertex>?Parameters.WeightAdjustment - (((IWeightedEdge <TVertex>)edge).Weight) : 1.0);
spa.Compute(source);
int j = 0;
foreach (TVertex target in undirected.Vertices)
{
double cost;
if (spa.TryGetDistance(target, out cost))
{
d[i, j] = cost;
if (cost > maxCost)
{
maxCost = cost;
}
}
else
{
d[i, j] = double.NaN;
}
j++;
}
i++;
}
double idealEdgeLength = (Math.Min(Parameters.Width, Parameters.Height) / maxCost) * Parameters.LengthFactor;
double disconnectedCost = maxCost * Parameters.DisconnectedMultiplier;
for (i = 0; i < VisitedGraph.VertexCount; i++)
{
for (int j = 0; j < VisitedGraph.VertexCount; j++)
{
if (double.IsNaN(d[i, j]))
{
d[i, j] = disconnectedCost;
}
else
{
d[i, j] *= idealEdgeLength;
}
w[i, j] = Math.Pow(Math.Max(d[i, j], 0.0001), -Parameters.Alpha);
}
}
}
public void ContainsEdge_UndirectedEdge()
{
var graph = new BidirectionalGraph <int, IEdge <int> >();
var e12 = new EquatableUndirectedEdge <int>(1, 2);
var f12 = new EquatableUndirectedEdge <int>(1, 2);
graph.AddVerticesAndEdge(e12);
BidirectionalContainsEdgeAssertions(graph, e12, f12, null, null);
var undirectedGraph = new UndirectedBidirectionalGraph <int, IEdge <int> >(graph);
ContainsEdgeAssertions(undirectedGraph, e12, f12, null, null);
}
public void ContainsEdgeTest1()
{
var bd = new BidirectionalGraph<int, IEdge<int>>();
var e12 = new SEquatableUndirectedEdge<int>(1, 2);
var f12 = new SEquatableUndirectedEdge<int>(1, 2);
bd.AddVerticesAndEdge(e12);
ContainsEdgeAssertions(bd, e12, f12, null, null);
var u = new UndirectedBidirectionalGraph<int, IEdge<int>>(bd);
UndirectedGraphTest.ContainsEdgeAssertions(u, e12, f12, null, null);
}
//resetowanie danych
public void ResetData()
{
Graph = new Graph(true);
UndirectedGraph = new UndirectedBidirectionalGraph <Vertex, Edge>(Graph);
_matrix = null;
_UIMatrix = null;
_existingVertices = null;
DataView = null;
DataTable = null;
NotifyPropertyChanged("Graph");
NotifyPropertyChanged("UndirectedGraph");
NotifyPropertyChanged("DataView");
}
public void ContainsEdgeTest1()
{
var bd = new BidirectionalGraph <int, IEdge <int> >();
var e12 = new SEquatableUndirectedEdge <int>(1, 2);
var f12 = new SEquatableUndirectedEdge <int>(1, 2);
bd.AddVerticesAndEdge(e12);
ContainsEdgeAssertions(bd, e12, f12, null, null);
var u = new UndirectedBidirectionalGraph <int, IEdge <int> >(bd);
UndirectedGraphTest.ContainsEdgeAssertions(u, e12, f12, null, null);
}
public static double[,] GetDistances <TVertex, TEdge, TGraph>(
[NotNull] this TGraph graph)
where TEdge : IEdge <TVertex>
where TGraph : IBidirectionalGraph <TVertex, TEdge>
{
if (graph == null)
{
throw new ArgumentNullException(nameof(graph));
}
var distances = new double[graph.VertexCount, graph.VertexCount];
for (int k = 0; k < graph.VertexCount; ++k)
{
for (int j = 0; j < graph.VertexCount; ++j)
{
distances[k, j] = double.PositiveInfinity;
}
}
var undirected = new UndirectedBidirectionalGraph <TVertex, TEdge>(graph);
// Compute the distances from every vertex: O(n(n^2 + e)) complexity
int i = 0;
foreach (TVertex source in graph.Vertices)
{
// Compute the distances from the 'source'
// Each edge is taken into account as 1 (unweighted)
var dijkstra = new UndirectedDijkstraShortestPathAlgorithm <TVertex, TEdge>(
undirected,
edge => 1.0,
DistanceRelaxers.ShortestDistance);
dijkstra.Compute(source);
int j = 0;
foreach (TVertex vertex in undirected.Vertices)
{
double distance = dijkstra.Distances[vertex];
distances[i, j] = Math.Min(distances[i, j], distance);
distances[i, j] = Math.Min(distances[i, j], distances[j, i]);
distances[j, i] = Math.Min(distances[i, j], distances[j, i]);
++j;
}
++i;
}
return(distances);
}
/// <param name="g">The graph.</param>
/// <returns>Returns with the distance between the vertices (distance: number of the edges).</returns>
public static double[,] GetDistances <Vertex, Edge, Graph>(Graph g)
where Edge : IEdge <Vertex>
where Graph : IBidirectionalGraph <Vertex, Edge>
{
var distances = new double[g.VertexCount, g.VertexCount];
for (int k = 0; k < g.VertexCount; k++)
{
for (int j = 0; j < g.VertexCount; j++)
{
distances[k, j] = double.PositiveInfinity;
}
}
var undirected = new UndirectedBidirectionalGraph <Vertex, Edge>(g);
//minden élet egy hosszal veszünk figyelembe - unweighted
var weights = new Dictionary <Edge, double>();
foreach (Edge edge in undirected.Edges)
{
weights[edge] = 1;
}
//compute the distances from every vertex: O(n(n^2 + e)) complexity
int i = 0;
foreach (Vertex source in g.Vertices)
{
//compute the distances from the 'source'
var spaDijkstra =
new UndirectedDijkstraShortestPathAlgorithm <Vertex, Edge>(undirected, (edge) => weights[edge], DistanceRelaxers.ShortestDistance);
spaDijkstra.Compute(source);
int j = 0;
foreach (Vertex v in undirected.Vertices)
{
double d = spaDijkstra.Distances[v];
distances[i, j] = Math.Min(distances[i, j], d);
distances[i, j] = Math.Min(distances[i, j], distances[j, i]);
distances[j, i] = Math.Min(distances[i, j], distances[j, i]);
j++;
}
i++;
}
return(distances);
}
public GraphHelperTest()
{
#region create directedGraph
directedGraph = new BidirectionalGraph<string, Edge<string>>( );
directedGraph.AddVertex( one ); directedGraph.AddVertex( two ); directedGraph.AddVertex( three ); directedGraph.AddVertex( four );
directedGraph.AddEdge( new Edge<string>( one, four ) );
directedGraph.AddEdge( new Edge<string>( one, three ) );
directedGraph.AddEdge( new Edge<string>( four, two ) );
directedGraph.AddEdge( new Edge<string>( one, two ) );
#endregion
#region create undirected graph
undirectedGraph = new UndirectedBidirectionalGraph<string, Edge<string>>( directedGraph );
#endregion
}
public GraphHelperTest()
{
#region create directedGraph
directedGraph = new BidirectionalGraph <string, Edge <string> >( );
directedGraph.AddVertex(one); directedGraph.AddVertex(two); directedGraph.AddVertex(three); directedGraph.AddVertex(four);
directedGraph.AddEdge(new Edge <string>(one, four));
directedGraph.AddEdge(new Edge <string>(one, three));
directedGraph.AddEdge(new Edge <string>(four, two));
directedGraph.AddEdge(new Edge <string>(one, two));
#endregion
#region create undirected graph
undirectedGraph = new UndirectedBidirectionalGraph <string, Edge <string> >(directedGraph);
#endregion
}
/// <param name="g">The graph.</param>
/// <returns>Returns with the distance between the vertices (distance: number of the edges).</returns>
private static double[,] GetDistances <TVertex, TEdge, TGraph>(TGraph g)
where TEdge : IEdge <TVertex>
where TGraph : IBidirectionalGraph <TVertex, TEdge>
{
var distances = new double[g.VertexCount, g.VertexCount];
for (var k = 0; k < g.VertexCount; k++)
{
for (var j = 0; j < g.VertexCount; j++)
{
distances[k, j] = double.PositiveInfinity;
}
}
var undirected = new UndirectedBidirectionalGraph <TVertex, TEdge>(g);
//minden йlet egy hosszal veszьnk figyelembe - unweighted
var weights = new Dictionary <TEdge, double>();
foreach (var edge in undirected.Edges)
{
weights[edge] = 1;
}
//compute the distances from every vertex: O(n(n^2 + e)) complexity
var i = 0;
foreach (var source in g.Vertices)
{
//compute the distances from the 'source'
var spaDijkstra =
new UndirectedDijkstraShortestPathAlgorithm <TVertex, TEdge>(undirected, edge => weights[edge], QuickGraph.Algorithms.DistanceRelaxers.ShortestDistance);
spaDijkstra.Compute(source);
var j = 0;
foreach (var v in undirected.Vertices)
{
var d = spaDijkstra.Distances[v];
distances[i, j] = Math.Min(distances[i, j], d);
distances[i, j] = Math.Min(distances[i, j], distances[j, i]);
distances[j, i] = Math.Min(distances[i, j], distances[j, i]);
j++;
}
i++;
}
return(distances);
}
public void ContainsEdgeTest2()
{
var bd = new BidirectionalGraph <int, IEdge <int> >();
var e12 = new EquatableEdge <int>(1, 2);
var f12 = new EquatableEdge <int>(1, 2);
var e21 = new EquatableEdge <int>(2, 1);
var f21 = new EquatableEdge <int>(2, 1);
bd.AddVerticesAndEdge(e12);
ContainsEdgeAssertions(bd, e12, f12, e21, f21);
var u = new UndirectedBidirectionalGraph <int, IEdge <int> >(bd);
UndirectedGraphTest.ContainsEdgeAssertions(u, e12, f12, e21, f21);
}
public void Construction()
{
var wrappedGraph = new BidirectionalGraph <int, Edge <int> >(true);
var graph = new UndirectedBidirectionalGraph <int, Edge <int> >(wrappedGraph);
AssertGraphProperties(graph);
wrappedGraph = new BidirectionalGraph <int, Edge <int> >(false);
graph = new UndirectedBidirectionalGraph <int, Edge <int> >(wrappedGraph);
AssertGraphProperties(graph, false);
#region Local function
void AssertGraphProperties <TVertex, TEdge>(UndirectedBidirectionalGraph <TVertex, TEdge> g, bool parallelEdges = true)
where TEdge : IEdge <TVertex>
{
Assert.IsFalse(g.IsDirected);
Assert.AreEqual(parallelEdges, g.AllowParallelEdges);
Assert.IsNotNull(g.OriginalGraph);
AssertEmptyGraph(g);
}
#endregion
}
public void ContainsEdgeTest2()
{
var bd = new BidirectionalGraph<int, IEdge<int>>();
var e12 = new EquatableEdge<int>(1, 2);
var f12 = new EquatableEdge<int>(1, 2);
var e21 = new EquatableEdge<int>(2, 1);
var f21 = new EquatableEdge<int>(2, 1);
bd.AddVerticesAndEdge(e12);
ContainsEdgeAssertions(bd, e12, f12, e21, f21);
var u = new UndirectedBidirectionalGraph<int, IEdge<int>>(bd);
UndirectedGraphTest.ContainsEdgeAssertions(u, e12, f12, e21, f21);
}
public int CalcMinDistToTarget(int[,] erosion)
{
var board = BuildBoard(erosion);
var rooms = new Room[Size.Width, Size.Height];
var graph = new BidirectionalGraph <Handle, Edge <Handle> >();
for (var y = 0; y < Size.Height; ++y)
{
for (var x = 0; x < Size.Width; ++x)
{
var room = new Room();
var pos = new Point(x, y);
if (board[x, y] == '.')
{
graph.AddVertex(room.Climbing = new Handle {
Pos = pos, Equip = Equip.Climbing
});
graph.AddVertex(room.Torch = new Handle {
Pos = pos, Equip = Equip.Torch
});
graph.AddEdge(new Edge <Handle>(room.Climbing, room.Torch));
}
else if (board[x, y] == '=')
{
graph.AddVertex(room.Climbing = new Handle {
Pos = pos, Equip = Equip.Climbing
});
graph.AddVertex(room.Neither = new Handle {
Pos = pos, Equip = Equip.Neither
});
graph.AddEdge(new Edge <Handle>(room.Climbing, room.Neither));
}
else
{
graph.AddVertex(room.Torch = new Handle {
Pos = pos, Equip = Equip.Torch
});
graph.AddVertex(room.Neither = new Handle {
Pos = pos, Equip = Equip.Neither
});
graph.AddEdge(new Edge <Handle>(room.Torch, room.Neither));
}
rooms[x, y] = room;
if (x > 0)
{
var left = rooms[x - 1, y];
if (room.Climbing != null && left.Climbing != null)
{
graph.AddEdge(new Edge <Handle>(left.Climbing, room.Climbing));
}
if (room.Torch != null && left.Torch != null)
{
graph.AddEdge(new Edge <Handle>(left.Torch, room.Torch));
}
if (room.Neither != null && left.Neither != null)
{
graph.AddEdge(new Edge <Handle>(left.Neither, room.Neither));
}
}
if (y > 0)
{
var up = rooms[x, y - 1];
if (room.Climbing != null && up.Climbing != null)
{
graph.AddEdge(new Edge <Handle>(up.Climbing, room.Climbing));
}
if (room.Torch != null && up.Torch != null)
{
graph.AddEdge(new Edge <Handle>(up.Torch, room.Torch));
}
if (room.Neither != null && up.Neither != null)
{
graph.AddEdge(new Edge <Handle>(up.Neither, room.Neither));
}
}
}
}
var sourceVertex = rooms[0, 0].Torch;
var targetVertex = rooms[TargetPos.X, TargetPos.Y].Torch;
double EdgeWeight(Edge <Handle> edge) => edge.Source.Equip == edge.Target.Equip ? 1 : 7;
var undirected = new UndirectedBidirectionalGraph <Handle, Edge <Handle> >(graph);
undirected.ShortestPathsDijkstra(EdgeWeight, sourceVertex)(targetVertex, out var path);
var iter = sourceVertex;
var cost = 0;
foreach (var p in path)
{
cost += (int)EdgeWeight(p);
iter = p.GetOtherVertex(iter);
//$"{iter.Pos.X},{iter.Pos.Y}: {iter.Equip}".Dump();
}
return(cost);
}