/// <summary> Проверяет эквивалентность неориентированных графов </summary>
private bool Equals(UndirectedGraph g)
{
if (g == null)
{
return(false);
}
if (ReferenceEquals(this, g))
{
return(true);
}
if (VerticesCount != g.VerticesCount || EdgesCount != g.EdgesCount)
{
return(false);
}
if (Vertices.Any(v => g.Vertices.SingleOrDefault(v.Equals) == null))
{
return(false);
}
var eq = true;
Vertices.ForEach(v1 =>
Vertices.ForEach(v2 =>
eq &= (this[v1, v2] != null && g[
g.Vertices.SingleOrDefault(v1.Equals),
g.Vertices.SingleOrDefault(v2.Equals)] != null) ^
(this[v1, v2] == null && g[
g.Vertices.SingleOrDefault(v1.Equals),
g.Vertices.SingleOrDefault(v2.Equals)] == null)
)
);
return(eq);
}
public bool IsRegular()
{
if (!Vertices.Any())
{
throw new InvalidOperationException("The graph has no vertices defined.");
}
bool isRegular = true;
if (IsDirected)
{
var expectedOrder = Vertices.Values.First().AdjacentEdges.Count();
foreach (var edge in Vertices.Values)
{
if (isRegular)
{
isRegular =
edge.AdjacentEdges.Count(x => x.From == edge) == edge.AdjacentEdges.Count(x => x.From == edge) &&
edge.AdjacentEdges.Count(x => x.From == edge) + edge.AdjacentEdges.Count(x => x.From == edge) == expectedOrder;
}
}
}
else
{
var expectedOrder = Vertices.Values.First().Degree;
isRegular = Vertices.Values.All(x => x.Degree == expectedOrder);
}
return(isRegular);
}
public bool GetVisited()
{
// See if any nodes have not been visited
var x =
from vert in Vertices
where vert.Visited == false
select vert;
var visits = Vertices.Any(lam => lam.Visited == false);
return(!visits);
}
private void InitializeIds()
{
if (Edges.Any())
{
nextEdgeId = edges.Keys.Max() + 1;
}
if (Vertices.Any())
{
nextVertexId = vertices.Keys.Max() + 1;
}
idsAreInitialized = true;
}
private void AddVertex(Vertex vertex)
{
try
{
if (!Vertices.Any(v => v.Name.Equals(vertex.Name)))
{
Vertices.Add(vertex);
}
}
catch
{
throw;
}
}
public void DockVertices(IEnumerable <Vertex> vertices)
{
// does vertex order matther?
if (!_vertices.Any())
{
Append(vertices);
return;
}
// sort the vertices to make connection possible
var connector = new PathConnector(this.ToVertices(), vertices);
Clear();
Append(connector.ConnectPaths());
}
public void AdicionarVertice()
{
MensagemDeErro = string.Empty;
if (Vertices.Any(v => v.Identificador == Vertice.Identificador))
{
MensagemDeErro = "Existe um vertice já cadastrado com esse identificador.";
return;
}
Vertice.Codigo = Vertices.Any() ? Vertices.Last().Codigo++ : 0;
Vertices.Add(Vertice);
Vertice = new Vertice();
}
//*********************************************************************************
public void DrawTrianglesOnDebug()
{
if (!Vertices.Any())
{
return;
}
Vector3 pivot = Vertices[0];
for (int i = 1; i < Vertices.Count - 1; i++)
{
new Line(pivot, Vertices[i]).DrawOnDebug(Color.green);
new Line(pivot, Vertices[i + 1]).DrawOnDebug(Color.green);
new Line(Vertices[i], Vertices[i + 1]).DrawOnDebug(Color.green);
}
}
/// <summary>
/// Subdividing the quadrilateral
/// </summary
/// <returns></returns>
public override Face[] SubdivideFace()
{
Face[] interpolatedFaces = new Face[4];
SortVertices();
try
{
var middle01 = Vertices[0].GetMiddlePoint(Vertices[1]);
var middle12 = Vertices[1].GetMiddlePoint(Vertices[2]);
var middle23 = Vertices[2].GetMiddlePoint(Vertices[3]);
var middle30 = Vertices[3].GetMiddlePoint(Vertices[0]);
var center = GetCircumCentre();
if (Vertices.Any(x => x.IsExterior))
{
middle01.IsExterior = true;
middle12.IsExterior = true;
middle23.IsExterior = true;
middle30.IsExterior = true;
center.IsExterior = true;
}
interpolatedFaces[0] = new Quadrilateral(Vertices[0], middle01, center, middle30);
interpolatedFaces[1] = new Quadrilateral(middle01, Vertices[1], middle12, center);
interpolatedFaces[2] = new Quadrilateral(middle12, Vertices[2], middle23, center);
interpolatedFaces[3] = new Quadrilateral(middle30, center, middle23, Vertices[3]);
interpolatedFaces[0].FaceType = FaceType.Quadrilateral;
interpolatedFaces[1].FaceType = FaceType.Quadrilateral;
interpolatedFaces[2].FaceType = FaceType.Quadrilateral;
interpolatedFaces[3].FaceType = FaceType.Quadrilateral;
}
catch
{
}
return(interpolatedFaces);
}
/// <summary>
/// Indicates whenever current graph in acyclic.
/// </summary>
public bool IsAcyclic()
{
return(Vertices.Any(x => x.InDegree() == 0) &&
Vertices.Any(x => x.OutDegree() == 0));
}
public bool ContainsVertex(Vector3 pos, float tolerance)
{
return(Vertices.Any(x => x.Position.Equals(pos, tolerance)));
}
public bool ContainsVertex(Vector3 pos)
{
return(Vertices.Any(x => x.Position.Equals(pos)));
}
public static bool Exist(int index)
{
return(Vertices.Any(x => x.Index == index));
}
public Terrain(int frequency, int turnaroundTime, int switchDelay, IEnumerable <InputRow> frequencies)
{
var names = new List <string>()
{
T1, "Vaartscherijn", "Galgenwaard", "Kromme Rijn", "Padualaan",
"Heidelberglaan", "UMC", "WKZ", T2
};
//travelling times forward
var forward = new List <int>()
{
134, 243, 59, 101, 60, 86, 78, 113
};
var backwards = new List <int>()
{
110, 78, 82, 60, 100, 59, 243, 135
};
var id = 0;
//For both directions
for (var x = 0; x < 2; x++)
{
var vertices = new List <Station>();
//reverse to make it into the correct order
if (x == 1)
{
names.Reverse();
}
// add vertices temporarily (not in the graph yet)
names.ForEach(name =>
{
var isTerminal = name == T1 || name == T2;
if (isTerminal)
{
//Note upper case!!
if (Vertices.Any(vertex => vertex.Name == name))
{
return;
}
}
vertices.Add(new Station(switchDelay)
{
Name = name,
IsTerminal = name == T1 || name == T2,
Id = id
});
id++;
});
// add the to the graph
foreach (var item in vertices)
{
AddVertex(item);
}
// Add the edge weights
for (var j = 0; j < vertices.Count - 1; j++)
{
var weight = -1;
if (x == 0)
{
weight = forward[j];
}
else
{
weight = backwards[j];
}
var edge = new UEdge(vertices[j], vertices[j + 1])
{
Weight = weight
};
AddEdge(edge);
}
}
var pr = GetPR();
var afterPR = Vertices.FirstOrDefault(x => x.Id == 9);
AddEdge(new UEdge(pr, afterPR)
{
Weight = backwards[0]
});
AddEdge(new UEdge(Vertices.FirstOrDefault(x => x.Id == 15), GetCS())
{
Weight = backwards[backwards.Count - 1]
});
AddVertex(new Station(switchDelay)
{
Name = "Depot",
Id = -1,
});
AddEdge(new UEdge(Vertices.Single(x => x.Id == -1), Vertices.SingleOrDefault(x => x.Name == T2))
{
Weight = 0
});
foreach (var vertex in Vertices)
{
vertex.OutEdges = Edges.Where(x => x.Source == vertex).ToList();
vertex.InEdges = Edges.Where(x => x.Target == vertex).ToList();
}
//an offset for the issuing of trams from the second terminal
var offset = (int)TimeSpan.FromMinutes(17).TotalSeconds + turnaroundTime;
var fifteenMin = (int)TimeSpan.FromMinutes(15).TotalSeconds;
var hour = (int)TimeSpan.FromHours(1).TotalSeconds;
var peakHours = (int)TimeSpan.FromHours(12).TotalSeconds;
/// this is the total working time in seconds
var totalWorkTime = 54000;
var timetablePR = new Timetable(new[]
{
new FrequencyInterval {
Start = 0, End = hour, Frequency = fifteenMin
},
new FrequencyInterval {
Start = hour, End = totalWorkTime - (int)TimeSpan.FromHours(2).TotalSeconds, Frequency = frequency
},
new FrequencyInterval {
Start = totalWorkTime - (int)TimeSpan.FromHours(2).TotalSeconds, End = totalWorkTime, Frequency = fifteenMin
}
});
var timeTableUithof = new Timetable(new[]
{
new FrequencyInterval {
Start = offset, End = hour, Frequency = fifteenMin
},
new FrequencyInterval {
Start = hour, End = totalWorkTime - (int)TimeSpan.FromHours(2).TotalSeconds, Frequency = frequency
},
new FrequencyInterval {
Start = totalWorkTime - (int)TimeSpan.FromHours(2).TotalSeconds, End = totalWorkTime, Frequency = fifteenMin
}
});
//--------- this section builds the timetables at the terminal stations
// the frequency intervals at the PR
Vertices.FirstOrDefault(x => x.Name == T2).SetTimetable(timetablePR);
Vertices.FirstOrDefault(x => x.Name == T1).SetTimetable(timeTableUithof);
//Just for debug :)
var psr = Vertices.FirstOrDefault(x => x.Name == T2).Timetable.ToString();
var uff = Vertices.FirstOrDefault(x => x.Name == T1).Timetable.ToString();
if (frequencies != null)
{
var stationFrequencies = frequencies.ToLookup(v => v.Direction);
var going = stationFrequencies[0].ToList().GroupBy(x => x.Stop);
var coming = stationFrequencies[1].ToList().GroupBy(x => x.Stop);
foreach (var goingSt in Vertices)
{
var forStation = going.FirstOrDefault(x => x.Key.Replace(".", " ") == goingSt.Name);
if (forStation != null)
{
foreach (var val in forStation)
{
goingSt.ComingDistrubutions.Add(val);
}
}
}
foreach (var comingSt in Vertices)
{
var forStation = coming.FirstOrDefault(x => x.Key.Replace(".", " ") == comingSt.Name);
if (forStation != null)
{
foreach (var val in forStation)
{
comingSt.GoingDistrubutions.Add(val);
}
}
}
foreach (var station in Vertices)
{
station.ComingDistrubutions = new List <InputRow>(station.ComingDistrubutions.OrderBy(x => x.From));
station.GoingDistrubutions = new List <InputRow>(station.GoingDistrubutions.OrderBy(x => x.From));
}
}
}
public bool ContainsVertex(string value)
{
return(Vertices.Any(x => x.Value == value));
}
/// <summary> /// Checks whenever graph contains vertex with specified data. /// </summary> public bool ContainsVertex(T data) => Vertices.Any(x => x.Data.Equals(data));
public bool HasAnyTwoWayEdge()
{
return(Vertices.Any(vertex => vertex.Neighbours.Any(vertex.HasTwoWayConnectionWith)));
}
