/// <summary>
/// Запуск алгоритма расчета
/// </summary>
/// <param name="beginp"></param>
public void AlgoritmRun(PointG beginp)
{
if (this.PointGs.Count() == 0 || this.rebra.Count() == 0)
{
throw new DekstraException("Массив вершин или ребер не задан!");
}
else
{
BeginPointG = beginp;
OneStep(beginp);
foreach (PointG PointG in PointGs)
{
PointG anotherP = GetAnotherUncheckedPointG();
if (anotherP != null)
{
OneStep(anotherP);
}
else
{
break;
}
}
}
}
/// <summary>
/// Задаем начальную и конечную станции для движения поезда.
/// </summary>
/// <param name="begin"></param>
/// <param name="end"></param>
public Train(PointG begin, PointG end)
{
beginPointG = nowPointG = begin;
endPointG = end;
StartCoordinate = new Point(begin.X,begin.Y);
FinishCoordinate= new Point(end.X,end.Y);
NextCoordinate = new Point(begin.X, begin.Y);
}
public PointG(int value, bool ischecked, string name, int x,int y)
{
ValueMetka = value;
IsChecked = ischecked;
Name = name;
X = x;
Y = y;
predPointG = new PointG();
}
/// <summary>
/// Получаем ребро, соединяющее 2 входные точки
/// </summary>
/// <param name="Первая вершина"></param>
/// <param name="Вторая вершина"></param>
/// <returns></returns>
public Rebro GetMyRebro(PointG a, PointG b)
{
//ищем ребро по 2 точкам
IEnumerable<Rebro> myr = from reb in rebra
where
(reb.FirstPointG == a & reb.SecondPointG == b) ||
(reb.SecondPointG == a & reb.FirstPointG == b)
select reb;
if (myr.Count() > 1 || myr.Count() == 0)
{
return null;
throw new DekstraException("Не найдено ребро между соседями!");
}
else
{
return myr.First();
}
}
/// <summary>
/// Получаем маршрут.
/// </summary>
public void GetPath(PointG[] pointGs,Rebro[] rebros)
{
foreach (PointG point in pointGs)
{
point.ValueMetka = point == beginPointG ? 0 : 999;
point.IsChecked = false;
}
DekstraAlgorim da = new DekstraAlgorim(pointGs,rebros);
da.AlgoritmRun(beginPointG);
path = da.MinPath1(endPointG);
inPointG = path[path.Count - 2];
FinishCoordinate.X = path[path.Count - 2].X;
FinishCoordinate.Y = path[path.Count - 2].Y;
}
/// <summary>
/// Поиск соседей для вершины. Для неориентированного графа ищутся все соседи.
/// </summary>
/// <param name="currPointG"></param>
/// <returns></returns>
private IEnumerable<PointG> Pred(PointG currPointG)
{
IEnumerable<PointG> firstPointGs = from ff in rebra
where ff.FirstPointG == currPointG
select ff.SecondPointG;
IEnumerable<PointG> secondPointGs = from sp in rebra
where sp.SecondPointG == currPointG
select sp.FirstPointG;
IEnumerable<PointG> totalPointGs = firstPointGs.Concat<PointG>(secondPointGs);
return totalPointGs;
}
public DekstraAlgorim(PointG[] PointGsOfgrath, Rebro[] rebraOfgrath)
{
PointGs = PointGsOfgrath;
rebra = rebraOfgrath;
}
/// <summary>
/// Метод, делающий один шаг алгоритма. Принимает на вход вершину
/// </summary>
/// <param name="beginPointG"></param>
public void OneStep(PointG beginPointG)
{
foreach (PointG nextp in Pred(beginPointG))
{
if (nextp.IsChecked == false) //не отмечена
{
float newmetka;
try
{
newmetka = beginPointG.ValueMetka + GetMyRebro(nextp, beginPointG).Weight;
}
catch (Exception)
{
newmetka = beginPointG.ValueMetka;
}
if (nextp.ValueMetka > newmetka)
{
nextp.ValueMetka = newmetka;
nextp.predPointG = beginPointG;
}
else
{
}
}
}
beginPointG.IsChecked = true; //вычеркиваем
}
/// <summary>
/// Получаем минимальный путь.
/// </summary>
/// <param name="end"></param>
/// <returns>Вершина до которой проложить путь</returns>
public List<PointG> MinPath1(PointG end)
{
List<PointG> listOfPointGs = new List<PointG>();
PointG tempp = end;
while (tempp != this.BeginPointG)
{
if (tempp == null)
{
return listOfPointGs;
}
listOfPointGs.Add(tempp);
tempp = tempp.predPointG;
}
listOfPointGs.Add(tempp);
return listOfPointGs;
}
private void Create_Click(object sender, EventArgs e)
{
ListStation.Clear();
listTrain.Clear();
threads.Clear();
int stationCount = Convert.ToInt32(numericStationCount.Value);
int trainCount = Convert.ToInt32(numericTrainCount.Value);
double alfa = 0;
double stepAlfa = 360 / stationCount * Math.PI / 180;
int A_widht = 370;
int B_height = 220;
double radius;
tops = new PointG[stationCount];
for (int i = 0; i < stationCount; i++)
{
radius = B_height * A_widht /
Math.Sqrt(B_height * B_height * Math.Cos(alfa) * Math.Cos(alfa) +
A_widht * A_widht * Math.Sin(alfa) * Math.Sin(alfa));
ListStation.Add(new Station(new Point(Convert.ToInt32(radius * Math.Cos(alfa)), Convert.ToInt32(-radius * Math.Sin(alfa))),
i.ToString()));
tops[i] = new PointG(999, false, (i).ToString(CultureInfo.InvariantCulture),
Convert.ToInt32(radius * Math.Cos(alfa)), Convert.ToInt32(-radius * Math.Sin(alfa)));
alfa += stepAlfa;
}
//dataGridViewTrain.Rows.Add(trainCount);
dataGridViewTrain.Rows.Clear();
((DataGridViewComboBoxColumn)dataGridViewTrain.Columns[1]).Items.Clear();
((DataGridViewComboBoxColumn)dataGridViewTrain.Columns[2]).Items.Clear();
//var cell = new DataGridViewComboBoxCell();
//GridItemCollection It;
for (int i = 0; i < stationCount; i++)
{
((DataGridViewComboBoxColumn)dataGridViewTrain.Columns[1]).Items.Add(ListStation[i].name);
((DataGridViewComboBoxColumn)dataGridViewTrain.Columns[2]).Items.Add(ListStation[i].name);
}
for (int i = 0; i < trainCount; i++)
{
//((DataGridViewComboBoxColumn)dataGridViewTrain.Columns[1]).Items.Add(ListStation[i].name);
//((DataGridViewComboBoxColumn)dataGridViewTrain.Columns[2]).Items.Add(ListStation[i].name);
dataGridViewTrain.Rows.Add();
dataGridViewTrain[0, i].Value = i + 1;
}
GenerateGraph();
graphics = new GraphicsMy(this, ListStation, rebro, listTrain);
graphics.RenderingTest();
}
/// <summary>
/// Задаем ребро.
/// </summary>
/// <param name="first"></param>
/// <param name="second"></param>
/// <param name="valueOfWeight"></param>
/// <returns></returns>
public Rebro(PointG first, PointG second, float valueOfWeight)
{
FirstPointG = first;
SecondPointG = second;
Weight = valueOfWeight;
}
public PointG(int value, bool ischecked)
{
ValueMetka = value;
IsChecked = ischecked;
predPointG = new PointG();
}
