public void search_breadth_first()
{
var a = new Vertex <string>
{
Value = "Cat"
};
var b = new Vertex <string>
{
Value = "Rat"
};
var c = new Vertex <string>
{
Value = "Dog"
};
var d = new Vertex <string>
{
Value = "Dog"
};
a.AddEdge(b);
b.AddEdge(c);
a.AddEdge(d);
var graph = new Graph <string>();
graph.AddVertex(a);
graph.AddVertex(b);
graph.AddVertex(c);
graph.AddVertex(d);
var bfsSearcher = new BreadthFirstSearcher <string>();
var result = bfsSearcher.Search(graph, a, s => s == "Dog");
result.Should().Be(d);
}
public void only_search_nodes_on_graph()
{
var a = new Vertex <string>
{
Value = "Cat"
};
var b = new Vertex <string>
{
Value = "Rat"
};
var c = new Vertex <string>
{
Value = "Dog"
};
var d = new Vertex <string>
{
Value = "Dog"
};
a.AddEdge(b);
b.AddEdge(c);
a.AddEdge(d);
var graph = new Graph <string>();
graph.AddVertex(a);
graph.AddVertex(b);
graph.AddVertex(c);
var dfsSearcher = new DepthFirstSearcher <string>();
var result = dfsSearcher.Search(graph, a, s => s == "Dog");
result.Should().Be(c);
}
private static void PrimAlgorithmn()
{
List <Vertex> graph = new List <Vertex>();
Vertex a = new Vertex("A");
Vertex b = new Vertex("B");
Vertex c = new Vertex("C");
Vertex d = new Vertex("D");
Vertex e = new Vertex("E");
Edge ab = new Edge(2);
a.AddEdge(b, ab);
b.AddEdge(a, ab);
Edge ac = new Edge(3);
a.AddEdge(c, ac);
c.AddEdge(a, ac);
Edge bc = new Edge(2);
b.AddEdge(c, bc);
c.AddEdge(b, bc);
Edge be = new Edge(5);
b.AddEdge(e, be);
e.AddEdge(b, be);
Edge cd = new Edge(1);
c.AddEdge(d, cd);
d.AddEdge(c, cd);
Edge ce = new Edge(1);
c.AddEdge(e, ce);
e.AddEdge(c, ce);
graph.Add(a);
graph.Add(b);
graph.Add(c);
graph.Add(d);
graph.Add(e);
Console.WriteLine("****************");
Console.WriteLine("\n");
Prim MyPrimAlgo = new Prim(graph);
Console.WriteLine("Graph before Prim");
Console.WriteLine(MyPrimAlgo.OriginalGraphToString());
Console.ReadLine();
Console.WriteLine("Graph after Prim");
MyPrimAlgo.Run();
MyPrimAlgo.ResetPrintHistory();
Console.WriteLine(MyPrimAlgo.MinimumSpanningTreeToString());
Console.WriteLine("****************");
Console.WriteLine("\n");
Console.ReadLine();
}
public void search_depth_first()
{
var a = new Vertex <string>
{
Value = "Cat"
};
var b = new Vertex <string>
{
Value = "Rat"
};
var c = new Vertex <string>
{
Value = "Dog"
};
var d = new Vertex <string>
{
Value = "Turtle"
};
var e = new Vertex <string>
{
Value = "Parrot"
};
var f = new Vertex <string>
{
Value = "Raccoon"
};
var g = new Vertex <string>
{
Value = "Dog"
};
a.AddEdge(b);
b.AddEdge(c);
a.AddEdge(d);
d.AddEdge(e);
e.AddEdge(f);
f.AddEdge(g);
var graph = new Graph <string>();
graph.AddVertex(a);
graph.AddVertex(b);
graph.AddVertex(c);
graph.AddVertex(d);
graph.AddVertex(e);
graph.AddVertex(f);
graph.AddVertex(g);
var dfsSearcher = new DepthFirstSearcher <string>();
var result = dfsSearcher.Search(graph, a, s => s == "Dog");
result.Should().Be(g);
}
// Adds an edge without weights if Weighted layer is not present
public void AddEdge(Vertex start, Neighbor theNeighbor)
{
start.AddEdge(theNeighbor);
Vertex end = theNeighbor.neighbor;
end.AddEdge(new Neighbor(start));
}
public void return_null_if_starting_vertex_not_in_graph()
{
var a = new Vertex <string>
{
Value = "Dog"
};
var b = new Vertex <string>
{
Value = "Dog"
};
var c = new Vertex <string>
{
Value = "Dog"
};
a.AddEdge(b);
b.AddEdge(c);
var graph = new Graph <string>();
graph.AddVertex(b);
var dfsSearcher = new DepthFirstSearcher <string>();
var result = dfsSearcher.Search(graph, a, s => s == "Dog");
result.Should().Be(null);
}
public Edge(Vertex v1, Vertex v2)
{
Debug.LogFormat("Creating new edge between {0} and {1}", v1.number, v2.number);
this.v1 = v1;
this.v2 = v2;
v1.AddEdge(this);
v2.AddEdge(this);
linepiece = CalculateLinepieceValues();
lineObject = new GameObject();
lineObject.name = "EdgeDebugObject";
lineRenderer = lineObject.AddComponent <LineRenderer>();
lineRenderer.material = Paper.Instance.LineMaterial;
lineRenderer.startWidth = 0.05f;
lineRenderer.endWidth = 0.05f;
UpdateLineRenderer(null);
debugText = lineObject.AddComponent <TextMesh>();
debugText.color = Color.black;
debugText.characterSize = 0.2f;
lineObject.transform.position = (v1.transform.position + v2.transform.position) / 2f;
Paper.Instance.NewEdge(this, out number);
}
public void AddNeighbor(Vertex <T> vertex1, Vertex <T> vertex2)
{
if (!vertex1.Neighbors.Contains(vertex2))
{
vertex1.AddEdge(vertex2);
}
}
private void AddNeighbor(Vertex <T> first, Vertex <T> second)
{
if (!first.Neighbors.Contains(second))
{
first.AddEdge(second);
}
}
public bool AddEdge(int v1, int v2, float cost)
{
// Check if edge already exists
foreach (Edge edge in edges)
{
if (cost == edge.cost)
{
if ((edge.vertex1.id == v1 && edge.vertex2.id == v2) || (edge.vertex1.id == v2 && edge.vertex2.id == v1))
{
// Edge already exists
return(false);
}
}
}
Vertex ver1 = GauranteeVertex(v1);
Vertex ver2 = GauranteeVertex(v2);
Transform trans = Instantiate(edgePrefab.transform);
Edge newEdge = trans.GetComponent <Edge>();
newEdge.vertex1 = ver1;
newEdge.vertex2 = ver2;
newEdge.cost = cost;
newEdge.RefreshConnection();
edges.Add(newEdge);
ver1.AddEdge(newEdge);
ver2.AddEdge(newEdge);
UpdateEncoding();
return(true);
}
/// <summary>
/// Adds an edge from "from" to "to". If an edge already exists, the "flagged" value is merged (using boolean OR) into
/// the existing edge.
/// </summary>
public void AddEdge(P from, P to, bool flagged)
{
Vertex fromVertex = GetVertex(from);
Vertex toVertex = GetVertex(to);
fromVertex.AddEdge(toVertex, flagged);
return;
}
public void RemoveEdge_byVertexName_fail_noEdge()
{
var vertex1 = new Vertex("vertex1", 0);
var vertex2 = new Vertex("vertex2", 0);
vertex1.AddEdge(vertex2);
Assert.ThrowsException <ArgumentException>(() => vertex1.RemoveEdge("vertex3"));
}
public IEdge AddEdge(object id, string label, IVertex vertex)
{
if (vertex is WrappedVertex)
{
return(new WrappedEdge(Vertex.AddEdge(id, label, (vertex as WrappedVertex).Vertex)));
}
return(new WrappedEdge(Vertex.AddEdge(id, label, vertex)));
}
public void RemoveEdge_byVertexName_fail_vertexNull()
{
var vertex1 = new Vertex("vertex1", 0);
var vertex2 = new Vertex("vertex2", 0);
vertex1.AddEdge(vertex2);
Assert.ThrowsException <ArgumentNullException>(() => vertex1.RemoveEdge(null as string));
}
public void GetEdge_byVertexRef_fail_vertexNull()
{
var vertex1 = new Vertex("vertex1", 0);
var vertex2 = new Vertex("vertex2", 0);
vertex1.AddEdge(vertex2);
Assert.ThrowsException <ArgumentNullException>(() => vertex1.GetEdge(null as Vertex));
}
public void GetEdge_byVertexRef_ok()
{
var vertex1 = new Vertex("vertex1", 0);
var vertex2 = new Vertex("vertex2", 0);
var edge1 = vertex1.AddEdge(vertex2);
var edge2 = vertex1.GetEdge(vertex2);
Assert.AreSame(edge1, edge2);
}
public void RemoveEdge_byEdgeRef_fail_edgeNull()
{
var vertex1 = new Vertex("vertex1", 0);
var vertex2 = new Vertex("vertex2", 0);
vertex1.AddEdge(vertex2);
Assert.ThrowsException <ArgumentNullException>(() => vertex1.RemoveEdge(null as Edge));
}
public void RemoveEdge_byVertexName_ok()
{
var vertex1 = new Vertex("vertex1", 0);
var vertex2 = new Vertex("vertex2", 0);
vertex1.AddEdge(vertex2);
vertex1.RemoveEdge("vertex2");
Assert.AreEqual(0, vertex1.Edges.Count);
}
public void RemoveEdge_byEdgeRef_ok()
{
var vertex1 = new Vertex("vertex1", 0);
var vertex2 = new Vertex("vertex2", 0);
var edge = vertex1.AddEdge(vertex2);
vertex1.RemoveEdge(edge);
Assert.AreEqual(0, vertex1.Edges.Count);
}
public void RemoveEdge_byEdgeRef_fail_noEdge()
{
var vertex1 = new Vertex("vertex1", 0);
var vertex2 = new Vertex("vertex2", 0);
vertex1.AddEdge(vertex2);
var edge = new Edge(vertex1, new Vertex("vertex3", 0));
Assert.ThrowsException <ArgumentException>(() => vertex1.RemoveEdge(edge));
}
public void AddEdge_ok()
{
var vertex1 = new Vertex("vertex1", 0);
var vertex2 = new Vertex("vertex2", 0);
var edge1 = vertex1.AddEdge(vertex2);
var edge2 = vertex1.Edges[0];
Assert.AreSame(edge2.VertexTo, vertex2);
Assert.AreSame(edge1, edge2);
}
public void GetEdge_byVertexRef_fail_noVertex()
{
var vertex1 = new Vertex("vertex1", 0);
var vertex2 = new Vertex("vertex2", 0);
vertex1.AddEdge(vertex2);
var edge = vertex1.GetEdge(new Vertex("vertex3", 0));
Assert.IsNull(edge);
}
/// <summary>Adds an edge between the specified vertices.</summary>
/// <param name="source">The source vertex.</param>
/// <param name="destination">The destination vertex.</param>
/// <remarks>The edge is inserted from Source -> Destination.</remarks>
/// <returns>
/// True if an edge was established, False if one or more arguments
/// could not be resolved to valid vertices.
/// </returns>
public bool AddEdge(Vertex source, Vertex destination)
{
if (source == null || destination == null)
{
return(false);
}
source.AddEdge(destination);
return(true);
}
public void Vertex_AddEdge_OneEdge_Success()
{
// Arrange
var vertex1 = new Vertex<string>("Vertex 1");
var vertex2 = new Vertex<string>("Vertex 2");
var edge = new Edge<string>("Edge 1-2", 100, vertex1, vertex2);
var expected = 1;
// Act
vertex1.AddEdge(edge);
var result = vertex1.EdgeCount();
// Assert
Assert.AreEqual(result, expected);
}
public void AddEdge(string start, string end, int cost)
{
if (!vertexNames.ContainsKey(start))
{
throw new ArgumentException("Vertex name does not exist");
}
if (!vertexNames.ContainsKey(end))
{
throw new ArgumentException("Vertex name does not exist");
}
Vertex sourceVertex = vertexNames[start];
Vertex targetVertex = vertexNames[end];
Edge newEdge = new Edge(sourceVertex, targetVertex, cost);
sourceVertex.AddEdge(newEdge);
edges.Add(newEdge);
}
public void BreadthFirstSearchReturnsTrueWhenGraphContainsValueAndVerticesAreConnectedInCircle()
{
var value = 32;
var searchedVertex = new Vertex <int>(value);
var otherVertex = new Vertex <int>(3, new Vertex <int>(5));
searchedVertex.AddEdge(otherVertex);
otherVertex.AddEdge(searchedVertex);
var graph = new Graph <int>(new List <Vertex <int> >()
{
otherVertex
});
var actualResult = graph.ContainsValue(value);
Assert.True(actualResult);
}
public void Start()
{
GameObject roads = GameObject.FindGameObjectWithTag("Roads");
Vertex[] vertices = roads.GetComponentsInChildren <Vertex>();
Bounds bounds = new Bounds(transform.position, Vector3.zero);
Vector3 offset;
foreach (Transform child in transform)
{
bounds.Encapsulate(child.gameObject.GetComponent <Renderer>().bounds);
}
if (bounds.extents.x > bounds.extents.z)
{
offset = new Vector3(bounds.extents.x / 2 + 30, 0, 0);
length = (int)bounds.extents.x + 30;
}
else
{
offset = new Vector3(0, 0, bounds.extents.z / 2 + 30);
length = (int)bounds.extents.z + 30;
}
positionA = transform.position + offset;
positionB = transform.position - offset;
foreach (Vertex vertex in vertices)
{
if (Vector3.Distance(vertex.transform.position, positionA) < MARGIN)
{
vertexA = vertex;
}
else if (Vector3.Distance(vertex.transform.position, positionB) < MARGIN)
{
vertexB = vertex;
}
}
if (vertexA != null && vertexB != null)
{
vertexA.AddEdge(this);
vertexB.AddEdge(this);
}
}
Edge3 GetEdge(List <Edge3> edges, Vertex v0, Vertex v1)
{
Edge3 match = v0.edges.Find(e => {
return(e.Has(v1));
});
if (match != null)
{
return(match);
}
Edge3 ne = new Edge3(v0, v1);
v0.AddEdge(ne);
v1.AddEdge(ne);
edges.Add(ne);
return(ne);
}
public void UpdateEdge(Vertex v1, Vertex v2)
{
Debug.LogFormat("Edge {0} contains vertices {1} and {2}, checking for {3} and {4}", number, this.v1.number, this.v2.number, v1.number, v2.number);
if (v1 != this.v1 && v2 != this.v1)
{
this.v1.RemoveEdge(this);
}
if (v1 != this.v2 && v2 != this.v2)
{
this.v2.RemoveEdge(this);
}
this.v1 = v1;
this.v2 = v2;
v1.AddEdge(this);
v2.AddEdge(this);
UpdateLineRenderer(null);
lineObject.transform.position = (v1.transform.position + v2.transform.position) / 2f;
}
Edge3 GetEdge(Vertex v0, Vertex v1)
{
Edge3 match = v0.edges.Find(e =>
{
return(e.a == v1 || e.b == v1);
});
if (match != null)
{
return(match);
}
Edge3 ne = new Edge3(v0, v1);
edges.Add(ne);
v0.AddEdge(ne);
v1.AddEdge(ne);
return(ne);
}
public void AddEdge(Vector3 v1Coord, Vector3 v2Coord)
{
Vertex v1 = null, v2 = null;
for (int i = Vertices.Count - 1; i >= 0; --i)
{
if (Vertices[i].Coord == v1Coord)
{
v1 = Vertices[i];
}
else if (Vertices[i].Coord == v2Coord)
{
v2 = Vertices[i];
}
if (v1 != null && v2 != null)
{
break;
}
}
if (v1 == null || v2 == null)
{
return;
}
float length = 1.0f;
if ((int)v2.Coord.x != (int)v1.Coord.x && (int)v2.Coord.z != (int)v1.Coord.z)
{
length = 1.4f;
}
var edge = new Edge(v1, v2, length); //(float)Math.Sqrt(Math.Pow(Math.Abs(v2.Coord.x - v1.Coord.x),2) + Math.Pow(Math.Abs(v2.Coord.z - v1.Coord.z),2)));
if (!v1.Edges.Exists(e => e.CompareTo(edge) == 0))
{
v1.AddEdge(edge);
}
if (!v2.Edges.Exists(e => e.CompareTo(edge) == 0))
{
v2.AddEdge(edge);
}
}
public virtual void AddEdge( Vertex start, Neighbor theNeighbor )
{
start.AddEdge( theNeighbor );
}
// Adds an edge without weights if Weighted layer is not present
public void AddEdge( Vertex start, Neighbor theNeighbor )
{
start.AddEdge( theNeighbor );
Vertex end = theNeighbor.neighbor;
end.AddEdge( new Neighbor( start ) );
}
