 |
Алгоритм принятия решения для отдельного участника потока
|
|
|
|
Для реализации более реалистичного поведения отдельной машины алгоритм следования за лидером был доработан следующим образом:
После принятия параметров нового состояния, необходимых для поддержания безопасной дистанции до лидера добавляются еще два пункта:
· Анализ состояния ближайшего светофора на пути следования
· Анализ помех на пересечениях текущего ребра и следующего ребра маршрута.
На выходе мы имеем 3 пары параметров:
· Ускорение и замедление для поддержания дистанции
· Ускорение и замедление для своевременного проезда светофора
· Ускорение и замедление для уступания дороги помехе.
Если хотя бы одно из замедлений больше 0, то в качестве текущего параметра выбирается максимальное из замедлений.
Если все ускорения больше 0, а все замедления равны 0, то в качестве текущего параметра выбирается наименьшее из ускорений.
Наличие помехи проверяется следующим образом:
пока (не все пересечения для текщего ребра проверены)
если (на выбранном пересечении нужно уступать)
начало условия
найти ближайшую к пересечению машину (Car)
найти время достижения пересечения t1
пока (есть машина или не найдена помеха)
начало цикла
найти время достижения машиной пересечения t2
если (модуль разности |t1-t2| < 8 секунд)
флаг помехи = 1
установить ускорение = 0
установить достаточное замедление
иначе
перейти к следующей за текущей (Car) машине
конец цикла
перейти к след шагу цикла
конец условия
перейти к след шагу цикла
Для ускорения работы данного алгоритма приоритеты между ребрами на их пересечении вычисляются на этапе создания графа. Таким образом алгоритм определения наличия помехи сводится только к проверке расхождения машин во времени при проезде пересечения.
|
|
|
ТЕХНОЛОГИЧЕСКАЯ ЧАСТЬ
Назначение программы
Данная программа предназначена для моделирования транспортных потоков на перекрестке.
Программа позволяет смоделировать сложный регулируемый перекресток, задать периоды работы светофоров.
Программа позволяет графически отображать текущее состояние системы, с учетом заданных плотностей входящих потоков машин на въездах на перекресток.
Запуск и выполнение
Для запуска программы необходимо запустить исполняемый.exe файл. Далее с помощью встроенного редактора построить граф допустимых траекторий движения на перекрестке, создать светофоры и задать периоды их переключений, задать плотности потока на въездах на перекресток.
После чего нажав кнопку Start Redraw запустить цикл расчета и отображения состояний системы.
Системные требования
. процессор Pentium-4, не менее 2400MHz;
. оперативную память объемом, 128 Мегабайт, не менее;
. HDD, 2 Гигабайт, не менее;
. операционную систему семейства Windows, начиная с версии Windows 95;
. Монитор, поддерживающий разрешение от 1024х768 и выше;
. Клавиатура и мышь;
Заключение и выводы
В результате выполнения данной курсовой работы мною были получены следующие выводы:
· Выбранная мной модель поведения отдельной машины удовлетворяет требованиям данной модели.
· Полученная система масштабируема в ущерб производительности программы.
· Существует максимальное допустимое количество одновременно корректно обрабатываемых машин. Чем больше машин одновременно обрабатывается, тем больше временной интервал между смежными рассчитанными состояниями каждой машины, что отрицательно сказывается на работе алгоритмов принятия решений.
· Разработанный алгоритм поведения отдельной машины исключает возможность обгонов, что является существенным допущением.
|
|
|
Дальнейшая работа может быть связана с оптимизацией алгоритмов с целью увеличения допустимого количества одновременно обрабатываемых машин, а так же с расширением допустимой структуры дорог.
перекресток алгоритм транспортный поток
Список литературы
ШвецовВ.И.Математическое моделирование транспортных потоков // Автоматика и телемеханика. - 2003. -№11
Семенов В.В. Математическое моделирование динамики транспортных потоков мегаполиса
Харари Ф. Теория графов // Едиториал УРСС 2003г.
4. Ермолаев В., Сорока Т. C++ BLILDER:Книга рецептов// москва 2006
Приложение
//---------------------------------------------------------------------------
#include <vcl.h>
#pragma hdrstop
#include "Graphs.h"
#include "Main.h"
#include <math.h>
#include "Cars.h"
#include "Car_thr.h"
#include "Redraw.h"
//---------------------------------------------------------------------------
#pragma package(smart_init)
#pragma resource "*.dfm"*Form1;*G;
//TList *AllCars;*V1, *V2;start;move;dist(int X, int Y, vertex *V){sqrt((V->X-X)*(V->X-X) + (V->Y-Y)*(V->Y-Y));
}
//---------------------------------------------------------------------------
__fastcall TForm1::TForm1(TComponent* Owner)
: TForm(Owner)
{= new graph();>scale = Form1->Edit1->Text.ToDouble();=NULL;=NULL;= 0;>Cars = new TList;=0;
}
//---------------------------------------------------------------------------
__fastcall TForm1::Button1Click(TObject *Sender)
{->RadioButton1->Checked=false;->RadioButton2->Checked=false;->RadioButton3->Checked=false;->RadioButton4->Checked=false;(int i = 0; i < G->Edges->Count; i++) {*E = (edge *)G->Edges->Items[i];>C = 0xaaaaaa;>w = 1;
}>draw();
}
//---------------------------------------------------------------------------
__fastcall TForm1::Image1MouseDown(TObject *Sender, TMouseButton Button, TShiftState Shift,X, int Y)
{>scale = Form1->Edit1->Text.ToDouble();(Form1->RadioButton1->Checked) { //vertexes*V = new vertex();>X = X;>Y = Y;>add_v(V);
}(Form1->RadioButton2->Checked) { //line(int i = 0; i < G->Verts->Count; i++) {*V = (vertex*)G->Verts->Items[i];R = dist(X,Y,V);(R < 5) {(V1) {= V;>connect_v(V1,V2,true);=NULL;=NULL;
}{= V;
}
}
}
}(Form1->RadioButton3->Checked) {(int i = 0; i < G->Verts->Count; i++) {*V = (vertex*)G->Verts->Items[i];R = dist(X,Y,V);(R < 5) {(V1) {= V;>connect_v(V1,V2,false);=NULL;=NULL;
}{= V;
}
}
}
}(Form1->RadioButton4->Checked) {(int i = 0; i < G->Verts->Count; i++) {*V = (vertex*)G->Verts->Items[i];R = dist(X,Y,V);(R < 5) {(V1) {= V;*P = G->path(V1,V2);(P->Count > 0) {(int i = 0; i < P->Count-1; i++) {*V = (vertex *)P->Items[i];*V_n = (vertex *)P->Items[i+1];(int j = 0; j < V->s_owners->Count; j++) {*E = (edge *)V->s_owners->Items[j];(E->end->X == V_n->X && E->end->Y == V_n->Y) {>C = 0x00ff00;>w = 2;
}
}
}
}=NULL;=NULL;
}{(int i = 0; i < G->Edges->Count; i++) {*E = (edge *)G->Edges->Items[i];>C = 0xaaaaaa;>w = 1;
}= V;
}
}
}
}
(!Form1->RadioButton1->Checked &&!Form1->RadioButton2->Checked &&!Form1->RadioButton3->Checked &&!Form1->RadioButton4->Checked) {(int i = 0; i < G->Verts->Count; i++) {*V = (vertex*)G->Verts->Items[i];R = dist(X,Y,V);(R < 5) {= 1;= V;(Button == mbRight) {>main =!V->main;
|
|
|
}
}
}
}>reconnect();>find_crosses();>draw();
}
//---------------------------------------------------------------------------
__fastcall TForm1::Image1MouseMove(TObject *Sender, TShiftState Shift, int X,Y)
{(move) {->X = X;->Y = Y;>find_crosses();>reconnect();>draw();
}
}
//---------------------------------------------------------------------------
__fastcall TForm1::Image1MouseUp(TObject *Sender, TMouseButton Button, TShiftState Shift,X, int Y)
{(move) {=0;=NULL;
}
}
//---------------------------------------------------------------------------__fastcall TForm1::FormResize(TObject *Sender)
{->ScrollBox1->Width = Form1->ClientWidth - Form1->ScrollBox1->Left;->ScrollBox1->Height = Form1->ClientHeight - Form1->ScrollBox1->Top;
}
//---------------------------------------------------------------------------
__fastcall TForm1::Button2Click(TObject *Sender)
{*s, *f;
//car *C = new car(0.0194,1.85e-6,-3.7e-6,0.016,s,f);*Sta, *Fin;= new TList;= new TList;(int i = 0; i < G->Verts->Count; i++) {*V = (vertex*)G->Verts->Items[i];(V->s_owners->Count > 0 && V->e_owners->Count ==0) {>Add(V);
}(V->s_owners->Count == 0 && V->e_owners->Count > 0) {>Add(V);
}
}sn = rand()%(Sta->Count);fn = rand()%(Fin->Count);= (vertex*)Sta->Items[sn];= (vertex*)Fin->Items[fn];*C = new car(0.0194,0.00000185,-0.0000037,0.01,s,f,G,G->Cars);
//Car_thr *CT = new Car_thr(0,C);
}
//---------------------------------------------------------------------------
__fastcall TForm1::Button3Click(TObject *Sender)
{=1;(start){(int i = 0; i < G->Cars->Count; i++) {*C = (car *)G->Cars->Items[i];>move();(C->line == NULL) {>Cars->Delete(G->Cars->IndexOf(C));C;
}>draw();>ProcessMessages();
}>ProcessMessages();
}
}
//---------------------------------------------------------------------------
__fastcall TForm1::Button4Click(TObject *Sender)
{= 0;
}
//---------------------------------------------------------------------------
#ifndef GraphsH
#define GraphsH
#include <vcl.h>
#include <math.h>
#include <systdate.h>
vertex{:X,Y;*s_owners;*e_owners;
//for pathchecked;W;*path;
//for carsis_open;LastCh;period_in_msec; //-1 = бесконечность
float closed_to_per; //процентное соотношение закрытого времени к периоду
bool main;in_out; //въезд или выезд;::vertex();vertex::time_to_change();
};
edge{r_length;*start;*end;angles[2];angle;*cars;*cross_pts;linear;C;w;scale;edge::get_point(double p, double &X, double &Y);
};
e_cross{p;*E;p_;*E_;you_major;
};
graph{:finding;scale;*Verts;*Edges;*Cars;::graph();graph::add_v(vertex *V);graph::connect_v(vertex *V1, vertex *V2, bool l);graph::draw();graph::reconnect();*graph::path(vertex *V1, vertex *V2);graph::is_reachable(vertex *V1, vertex *V2);graph::find_crosses();*graph::find_cross_pts(edge *E);
};
edges_cross(edge *e1, edge *e2, int acc, double &x1, double &x2);
//---------------------------------------------------------------------------
#endif
//---------------------------------------------------------------------------
#pragma hdrstop
#include "Graphs.h"
#include "Main.h"
|
|
|
#include <vcl.h>
#include <math.h>
#include "Cars.h"
//---------------------------------------------------------------------------
#pragma package(smart_init)::TBitmap *map;
::vertex(){_owners = new TList;_owners = new TList;>main = false;>is_open = true;= new TList;>period_in_msec = -1;
}draw_v(vertex *v){r;(v->main) {= 5;
}{=3;
}x,y;= v->X;= v->Y;(v->is_open) {->Image1->Canvas->Pen->Color = (TColor)0x449944;->Image1->Canvas->Brush->Color = (TColor)0x22ff22;->Image1->Canvas->Ellipse(x-r,y-r,x+r,y+r);
}{->Image1->Canvas->Pen->Color = (TColor)0x444499;->Image1->Canvas->Brush->Color = (TColor)0x2222ff;->Image1->Canvas->Ellipse(x-r,y-r,x+r,y+r);
}
};
get_angle(vertex *s, vertex *e){A = -2*M_PI;(s->X == e->X) {(s->Y < e->Y) {= M_PI/2;
}{= -M_PI/2;
}
}(s->Y == e->Y) {(s->X < e->X) {= 0;
}{= M_PI;
}
}(A == -2*M_PI) {= atan(fabs(e->Y-s->Y)/fabs(e->X-s->X));(e->X < s->X && e->Y > s->Y) {= M_PI - A;
}(e->X < s->X && e->Y < s->Y) {= -(M_PI-A);
}(e->X > s->X && e->Y < s->Y) {= -A;
}
}A;
}
is_line(vertex *s, vertex *e, double a[2]){(fabs(a[0])!=fabs(a[1])) {0;
}{A = get_angle(s,e);(fabs(a[0]) == fabs(a[1]) && fabs(a[0]) == fabs(A)) {1;
}
}0;
}
dist_v(vertex *v1, vertex *v2){sqrt((v1->X-v2->X)*(v1->X-v2->X)+(v1->Y-v2->Y)*(v1->Y-v2->Y));
}
draw_besier(vertex *s, vertex *e, double a[2], double scale, TColor C, int w){x0,y0,x1,y1,x2,y2,x3,y3;R = dist_v(s,e);= s->X;= s->Y;= x0 + (R/2)*cos(a[0]);= y0 + (R/2)*sin(a[0]);= e->X;= e->Y;= x3 - (R/2)*cos(a[1]);= y3 - (R/2)*sin(a[1]);x_0,y_0,x_1,y_1,x_2,y_2,x_3,y_3,x_4,y_4,X,Y;= x0;= y0;(Form1->Image1->Canvas->TryLock()){}->Image1->Canvas->Pen->= C;->Image1->Canvas->MoveTo(X,Y);len=0;(double x = 0; x < 1; x+=0.01) {_0 = x0 + x*(x1-x0);_0 = y0 + x*(y1-y0);_1 = x1 + x*(x2-x1);_1 = y1 + x*(y2-y1);_2 = x2 + x*(x3-x2);_2 = y2 + x*(y3-y2);
_3 = x_0 + x*(x_1-x_0);_3 = y_0 + x*(y_1-y_0);_4 = x_1 + x*(x_2-x_1);_4 = y_1 + x*(y_2-y_1);
X1,Y1;= x_3 + x*(x_4-x_3);= y_3 + x*(y_4-y_3);
->Image1->Canvas->LineTo(X1,Y1);
dl = sqrt((X1-X)*(X1-X) + (Y1-Y)*(Y1-Y))*scale;+=dl;=X1;=Y1;
}len;
}draw_e(edge* e, double scale){x1,y1,x2,y2;= e->start->X;= e->start->Y;= e->end->X;= e->end->Y;(is_line(e->start,e->end,e->angles)) {->Image1->Canvas->Pen->Color = e->C;(e->cross_pts->Count > 0) {->Image1->Canvas->Pen->Color = 0xffffff - e->C;
}->Image1->Canvas->Pen->Width = e->w;->Image1->Canvas->MoveTo(x1,y1);->Image1->Canvas->LineTo(x2,y2);>r_length = sqrt((x2-x1)*(x2-x1)+(y2-y1)*(y2-y1))*scale;
}{(e->cross_pts->Count > 0) {>r_length = draw_besier(e->start,e->end,e->angles,scale,0xffffff-e->C,e->w);
}{>r_length = draw_besier(e->start,e->end,e->angles,scale,e->C,e->w);
}
}->Image1->Canvas->Pen->Width = 1;
}
edge::get_point(double p, double &X, double &Y){(linear) {= (this->end->X - this->start->X)*p+this->start->X;= (this->end->Y - this->start->Y)*p+this->start->Y;
}{x0,y0,x1,y1,x2,y2,x3,y3;R = dist_v(start,end);= start->X;= start->Y;= x0 + (R/2)*cos(angles[0]);= y0 + (R/2)*sin(angles[0]);= end->X;= end->Y;= x3 - (R/2)*cos(angles[1]);= y3 - (R/2)*sin(angles[1]);x_0,y_0,x_1,y_1,x_2,y_2,x_3,y_3,x_4,y_4;_0 = x0 + p*(x1-x0);_0 = y0 + p*(y1-y0);_1 = x1 + p*(x2-x1);_1 = y1 + p*(y2-y1);_2 = x2 + p*(x3-x2);_2 = y2 + p*(y3-y2);_3 = x_0 + p*(x_1-x_0);_3 = y_0 + p*(y_1-y_0);_4 = x_1 + p*(x_2-x_1);_4 = y_1 + p*(y_2-y_1);= x_3 + p*(x_4-x_3);= y_3 + p*(y_4-y_3);
}
}::graph(){= new TList;= new TList;= false;= new Graphics::TBitmap;>LoadFromFile("map.bmp");->Image1->Width = map->Width;->Image1->Height = map->Height;
}
graph::add_v(vertex *V){>Add(V);
}
graph::connect_v(vertex *V1, vertex *V2, bool l){*E = new edge;>angle = get_angle(V1, V2);>start = V1;>end = V2;>cars = new TList;->s_owners->Add(E);->e_owners->Add(E);>angles[0] = E->angle;>angles[1] = E->angle;>w = 1;>C = 0xaaaaaa;>scale = this->scale;(l) {>linear = true;
}{>linear = false;(E->start->e_owners->Count > 0) {* eo = (edge*)E->start->e_owners->Items[0];>angles[0] = eo->angle;
}(E->end->s_owners->Count > 0) {* so = (edge*)E->end->s_owners->Items[0];>angles[1] = so->angle;
|
|
|
}
}>Add(E);>cross_pts = new TList;_e(E,this->scale);>find_crosses();
}
graph::reconnect(){(int i = 0; i < Edges->Count; i++) {*E;= (edge *)Edges->Items[i];(E->linear) {>angle = get_angle(E->start, E->end);>angles[0] = E->angle;>angles[1] = E->angle;
}
}(int i = 0; i < Edges->Count; i++) {*E;= (edge *)Edges->Items[i];(!E->linear) {(E->start->e_owners->Count > 0) {* eo = (edge*)E->start->e_owners->Items[0];>angles[0] = eo->angle;
}(E->end->s_owners->Count > 0) {* so = (edge*)E->end->s_owners->Items[0];>angles[1] = so->angle;
}
}
}
}
draw_c(car *C, double scale){->Image1->Canvas->Pen->Color = 0xff0000;->Image1->Canvas->Brush->Color = 0xaa0000;->Image1->Canvas->Rectangle(C->cX-2, C->cY-2, C->cX+2, C->cY+2);
}
graph::draw(){->Image1->Canvas->Brush->Color = 0xffffff;->Image1->Canvas->Pen->Color = 0xffffff;->Image1->Canvas->Rectangle(0,0,Form1->Image1->Width, Form1->Image1->Height);(int i = 0; i < Verts->Count; i++) {*V = (vertex *)Verts->Items[i];_v(V);
}(int i = 0; i < Edges->Count; i++) {*E = (edge*)Edges->Items[i];_e(E,scale);
}(int i = 0; i < Cars->Count; i++) {*C = (car *)Cars->Items[i];_c(C,scale);
}
}
check(vertex *V1){ //deep(int i = 0; i < V1->s_owners->Count; i++) {*E = (edge *)V1->s_owners->Items[i];*V = E->end;(!V->checked) {P = E->r_length + V1->W;(V->W == -1) {>W = P;>path->Clear();
//V->path = V1->path;(int k = 0; k < V1->path->Count; k++) {>path->Add(V1->path->Items[k]);
}>path->Add(V);
}{(V->W > P) {>W = P;>path->Clear();
//V->path = V1->path;(int k = 0; k < V1->path->Count; k++) {>path->Add(V1->path->Items[k]);
}>path->Add(V);
}
}
}
}->checked = 1;(V1->s_owners->Count > 0) {(int i = 0; i < V1->s_owners->Count; i++) {*E = (edge *)V1->s_owners->Items[i];*V = E->end;(!V->checked) {(V);
}
}
}
}
check_w(TList *Vs){ //width(Vs->Count > 0) {*V1 = (vertex *)Vs->Items[0];(int i = 0; i < V1->s_owners->Count; i++) {*E = (edge *)V1->s_owners->Items[i];*V = E->end;(!V->checked) {P = E->r_length + V1->W;(V->W == -1) {>W = P;>path->Clear();
//V->path = V1->path;(int k = 0; k < V1->path->Count; k++) {>path->Add(V1->path->Items[k]);
}>path->Add(V);
}{(V->W > P) {>W = P;>path->Clear();
//V->path = V1->path;(int k = 0; k < V1->path->Count; k++) {>path->Add(V1->path->Items[k]);
}>path->Add(V);
}
}
}
}->checked = 1;>Delete(0);(V1->s_owners->Count > 0) {(int i = 0; i < V1->s_owners->Count; i++) {*E = (edge *)V1->s_owners->Items[i];*V = E->end;(!V->checked) {>Add(V);
}
}
}
}
}
*graph::path(vertex *V1, vertex *V2){>finding = true;(int i = 0; i < Verts->Count; i++) {*V = (vertex*)Verts->Items[i];>W = -1;>checked = 0;>path->Clear();
}->W = 0;->path->Add(V1);*Q = new TList;>Add(V1);_w(Q);*P = new TList;(int i = 0; i < V2->path->Count; i++) {>Add(V2->path->Items[i]);
}>Clear();Q;>finding = false;P;
}
edges_cross(edge *e1, edge *e2, int acc, double &x1, double &x2){(e1 == e2) {0;
}step1 = 1/e1->r_length/acc;step2 = 1/e2->r_length/acc;R = 5/e1->scale;=-1; x2=-1;(double i = 0; i < 1; i+=step1) {(double j = 0; j < 1; j+=step2) {X1,Y1,X2,Y2;->get_point(i,X1,Y1);->get_point(j,X2,Y2);R1 = sqrt((X2-X1)*(X2-X1)+(Y2-Y1)*(Y2-Y1));(R1 < R) {= i;= j;=R1;
}
}
}(x1 > 0 && x2 > 0 && x1 < 1 && x2 < 1) {1;
}{0;
}
}
vertex::time_to_change(){(this->period_in_msec == -1) {-1;
}{short h,m,s,ms;>LastCh.DecodeTime(&h,&m,&s,&ms);Time0 = h*3600000 + m*60000+s*1000+ms;CurT = Time();.DecodeTime(&h,&m,&s,&ms);Time1 = h*3600000 + m*60000+s*1000+ms;this->period_in_msec - Time1 + Time0;
}
}
*graph::find_cross_pts(edge *E){_cross *e_c;*crosses = new TList;(int i = 0; i < this->Edges->Count; i++) {*E_ = (edge*)Edges->Items[i];x, x_;(edges_cross(E,E_,1,x,x_)) {_c = new e_cross;_c->p = x;_c->E = E;_c->p_ = x_;
e_c->E_ = E_;
//проверка на главность траектории в этом пересечении
//1 приоритет "главная дорога" / "уступи дорогу"
if (E_->start->main!= E->start->main) {(E->start->main) {_c->you_major = 1;
}{_c->you_major = 0;
}
}{
//2 приоритет "едешь прямо" / "поворачиваешь"
if (E_->linear!= E->linear) {_c->you_major = E->linear;
}{
//3 приоритет "помеха справа"
//!!!
}
}>Add(e_c);
}
}crosses;
}
graph::find_crosses(){(int i = 0; i < this->Edges->Count; i++) {*E = (edge*)Edges->Items[i];>cross_pts = this->find_cross_pts(E);
}
}
//---------------------------------------------------------------------------
#ifndef CarsH
#define CarsH
#include "Graphs.h"
#include "Main.h"
#include <vcl.h>
#include <systdate.h>
car{:*line;*next_line;*Aim;*start;*otherCars;*path_edges;pomeha;stop_on_red;place;//[0..1]e_index;cX,cY;*main_car;_cross *danger_cross;max_speed; //m/mseccurr_speed; //m/msecmax_uskor; //m/msec^2max_zamedl; //m/msec^2curr_uskor; //m/msec^2curr_zamedl; //m/msec^2PrevTime;*road;::car(double m_s, double m_u, double m_z, double c_s, vertex *Start, vertex *Finish, graph *Road, TList *otCars);car::start_first_line(vertex *V, vertex *Vn);car::get_state();car::move();car::get_next_line(double Ln);car::draw();car::dX_now();car::next_pos_now();car::crit_dist();car::dist_by_time(double accel, double time_ms);car::dist_to_stop(double accel);car::accel_by_dist_to_stop(double Ln);car::accel_by_next_car(double s_next, double dist41, double realdist);car::time_for_dist(double dist);car::check_distance(double &next_speed);car::nearest_car_dist();car::follow();car::is_danger();car::is_not_danger();car::check_light();*car::take_prev_car(double &prev_dist);
};
*Path_to_edges(TList *Path);
//---------------------------------------------------------------------------
#endif
//---------------------------------------------------------------------------
#pragma hdrstop
#include "Cars.h"
//---------------------------------------------------------------------------
#pragma package(smart_init)
#include <systdate.h>*Path_to_edges(TList *P){*Edges = new TList;(P->Count > 0) {(int i = 0; i < P->Count-1; i++) {*V = (vertex *)P->Items[i];*V_n = (vertex *)P->Items[i+1];(int j = 0; j < V->s_owners->Count; j++) {*E = (edge *)V->s_owners->Items[j];(E->end->X == V_n->X && E->end->Y == V_n->Y) {
//>Add(E);
}
}
}
}Edges;
}
::car(double m_s, double m_u, double m_z, double c_s, vertex *Start, vertex *Finish, graph *Road, TList *otCars){_speed = m_s;_uskor = m_u;_zamedl = m_z;_speed = c_s;_uskor = 0;_zamedl = 0;>road = Road;>otherCars = otCars;>Add(this);_first_line(Start,Finish);>pomeha = 0;>stop_on_red = 0;
}
car::dX_now(){nX, nY;tm = Time();short h,m,s,ms;.DecodeTime(&h,&m,&s,&ms);currtime = h*3600000+m*60000+s*1000+ms;>PrevTime.DecodeTime(&h,&m,&s,&ms);ptime = h*3600000+m*60000+s*1000+ms;dT = currtime-ptime;dL = dT*curr_speed + (curr_uskor+curr_zamedl)*dT*dT/2;dL;
}
car::next_pos_now(){dL = dX_now();p_ = dL/line->r_length;(place+p_ >= 1) {1;
}place+p_;
}
car::crit_dist(){this->dist_to_stop(max_zamedl);
}
car::dist_by_time(double accel, double time_ms){curr_speed*time_ms + accel*time_ms*time_ms/2;
}
car::dist_to_stop(double accel){curr_speed*curr_speed/fabs(accel) + accel*(curr_speed/fabs(accel))*(curr_speed/fabs(accel))/2;
}
car::accel_by_dist_to_stop(double Ln){-curr_speed*curr_speed/2/Ln;
}
car::time_for_dist(double dist){(curr_speed*curr_speed + 2*(curr_uskor+curr_zamedl)*dist < 0) {1000000000;
}{(curr_uskor+curr_zamedl == 0) {(curr_speed ==0) {1000000000;
}dist/this->curr_speed;
}(-curr_speed + sqrt(curr_speed*curr_speed + 2*(curr_uskor+curr_zamedl)*dist))/(curr_uskor+curr_zamedl);
}
}
is_right(double X, double Y, double X_, double Y_){(X==0 && Y > 0) {(X_ < 0) {1;
}{0;
}
}(X==0 && Y < 0) {(X_ < 0) {0;
}{1;
}
}(Y==0 && X > 0) {(Y_ < 0) {1;
}{0;
}
}(Y==0 && X < 0) {(Y_ < 0) {0;
}{1;
}
}is_upper;(Y/X*X_ > Y) {_upper=1;
}{_upper=0;
}(X > 0 && is_upper || X < 0 &&!is_upper) {1;
}{0;
}
}
car::start_first_line(vertex *V, vertex *Vn){*Path = road->path(V,Vn);(Path->Count>1) {*ep = Path_to_edges(Path);_edges = ep;= (edge *)ep->Items[0];_line = (edge *)ep->Items[1];= Vn;= V;= 0;>cars->Add(this);_index = line->cars->IndexOf(this);= Time();
}{=NULL;
}
}
car::get_next_line(double Ln){(line->cars->Items[0] == this) {>cars->Delete(0);(int i = 0; i < line->cars->Count; i++) {*Car = (car*)line->cars->Items[i];>e_index--;
}
}*V = line->end;(road->finding){
//ждемс...
}*Path = road->path(V,Aim);*ep = Path_to_edges(Path);_edges->Clear();path_edges;>path_edges = ep;(ep->Count >= 2) {= (edge *)ep->Items[0];_line = (edge *)ep->Items[1];=Ln/line->r_length;
}{(ep->Count == 1) {= (edge *)ep->Items[0];_line = NULL;=Ln/line->r_length;
}(ep->Count == 0) {= NULL;_line = NULL;
//this->place=Ln/line->r_length;
}
}(line) {>cars->Add(this);_index = line->cars->IndexOf(this);
}
}
car::check_distance(double &next_speed){(line->cars->Count > 1 && this->e_index > 0) {*C = (car*)line->cars->Items[e_index-1];_speed = C->curr_speed;line->r_length*(C->place - this->place);
}{-1;
}
}
car::accel_by_next_car(double s_next, double dist41, double realdist){-(this->curr_speed - s_next)*(this->curr_speed - s_next)/2/fabs(realdist - dist41);
}
car::nearest_car_dist(){(line==0) {-1;
}{nearest_car_dist = (1-place)*line->r_length;(next_line!= NULL) {(this->next_line->cars->Count > 0) {*C = (car*)next_line->cars->Items[next_line->cars->Count-1];_car_dist +=(1-C->place)*next_line->r_length;
}{_car_dist+=next_line->r_length;
}
}nearest_car_dist;
}
}
car::follow(){length_to=0;*C=NULL;
if (this->e_index > 0) {
//есть машина на этом ребре
C = (car *)line->cars->Items[e_index-1];_to = (C->place - place)*line->r_length;
}{
//ищем далее(int i = 1; i < this->path_edges->Count; i++) {*E = (edge*)path_edges->Items[i];(E->cars->Count > 0) {= (car*)E->cars->Items[E->cars->Count-1];_to+=C->place*E->r_length;;
}{_to+=E->r_length;
}
}
}(curr_speed < max_speed && curr_uskor < max_uskor) {_uskor = max_uskor;_zamedl = 0;
}(C!= NULL) {
//есть машина(length_to < 10) {
//критическая дистанция_uskor = 0;(C->curr_speed == curr_speed) {_zamedl = C->curr_zamedl*1.1;(curr_zamedl < max_zamedl) {_zamedl = max_zamedl;
}
}(curr_speed > C->curr_speed) {_zamedl = max_zamedl;
}
}{
//нормальная дистанция(curr_speed > C->curr_speed) {_uskor=0;_zamedl = -(curr_speed*curr_speed)/2/(length_to-10);
}
}
}
}
car::is_not_danger(){(this->main_car && this->danger_cross) {(main_car->place > danger_cross->p_ + 10/main_car->line->r_length && main_car->line == danger_cross->E_) {>pomeha = 0;
}
}
}
car::is_danger(){
//пока не все пересечения для текщего ребра выбраны
//если нужно уступать
//начало условия
//найти ближайшую к пересечению машину на текущем ребре
//найти время достижения пересечения t1
//пока есть машина или не найдена помеха
//начало цикла
//найти время достижения машиной пересечения t2
//если модуль разности |t1-t2|<4
//флаг помехи =1
//установить ускорение =0
//установить замедление, достаточное для остановки за 5 метров до пересечения
//устаносить main_car = текущая машина
//установить danger_cross = текущее пересечение
//return;
//иначе - перейти к следующей машине
//конец цикла
//перейти к след шагу цикла
//конец условия
//иначе
//перейти к след шагу цикла
if (line->cross_pts->Count > 0) {(int i = 0; i < line->cross_pts->Count; i++) {_cross *ec = (e_cross*)line->cross_pts->Items[i];(ec->you_major || ec->p < this->place) {;
}(ec->E_->cars->Count>0) {*CC=NULL;
//double d2 = (ec->p_ - CC->place)*CC->line->r_length;d2 = 1000;(int j = 0; j < ec->E_->cars->Count; j++) {*C = (car*)ec->E_->cars->Items[j];(C->place < ec->p_ &&!C->stop_on_red) {= C;;
}
}(CC==NULL) {(int j = 0; j < ec->E_->start->e_owners->Count; j++) {*E = (edge*)ec->E_->start->e_owners->Items[j];(int k = 0; k < E->cars->Count; k++) {*C = (car*)E->cars->Items[k];D2 = (1-C->place)*C->line->r_length + ec->p_*ec->E_->r_length;(!C->stop_on_red && D2 < d2) {= C;= D2;;
}
}
}(CC==NULL) {;
}
}{= (ec->p_ - CC->place)*CC->line->r_length;
}d1 = (ec->p-place)*line->r_length;t1 = this->time_for_dist(d1);(CC) {t2 = CC->time_for_dist(d2);(fabs(t1-t2) < 10000) {>pomeha=1;>curr_uskor = 0;_zamedl = -(curr_speed*curr_speed)/2/(d1-5);_car = CC;_cross = ec;;
}= CC->take_prev_car(d2);
}
}
}
}(next_line==NULL) {;
}(next_line->cross_pts->Count == 0) {;
}(int i = 0; i < next_line->cross_pts->Count; i++) {_cross *ec = (e_cross*) next_line->cross_pts->Items[i];(ec->you_major) {;
}(ec->E_->cars->Count>0) {*CC=NULL;
//double d2 = (ec->p_ - CC->place)*CC->line->r_length;d2 = 1000;(int j = 0; j < ec->E_->cars->Count; j++) {*C = (car*)ec->E_->cars->Items[j];(C->place < ec->p_ &&!C->stop_on_red) {= C;;
}
}(CC==NULL) {(int j = 0; j < ec->E_->start->e_owners->Count; j++) {*E = (edge*)ec->E_->start->e_owners->Items[j];(int k = 0; k < E->cars->Count; k++) {*C = (car*)E->cars->Items[k];D2 = (1-C->place)*C->line->r_length + ec->p_*ec->E_->r_length;(!C->stop_on_red && D2 < d2) {= C;= D2;;
}
}
}(CC==NULL) {;
}
}{= (ec->p_ - CC->place)*CC->line->r_length;
}d1 = (ec->p)*next_line->r_length + (1-place)*line->r_length;t1 = this->time_for_dist(d1);(CC) {t2 = CC->time_for_dist(d2);(fabs(t1-t2) < 10000) {>pomeha=1;>curr_uskor = 0;_zamedl = -(curr_speed*curr_speed)/2/(d1-5);_car = CC;_cross = ec;;
}= CC->take_prev_car(d2);
}
}
}
}
*car::take_prev_car(double &prev_dist){*CC=NULL;(this->line->cars->Count == this->e_index+1) {
//на других ребрах_dist+=place*line->r_length;d = 1000;(int j = 0; j < line->start->e_owners->Count; j++) {*E = (edge*)line->start->e_owners->Items[j];(int k = 0; k < E->cars->Count; k++) {*C = (car*)E->cars->Items[k];D = (1-C->place)*C->line->r_length + prev_dist;(!C->stop_on_red && D < d) {= C;= D;;
}
}
}_dist+=d;
}{* C = (car*)line->cars->Items[e_index+1];_dist += (place-C->place)*line->r_length;=C;
}CC;
}
car::check_light(){
//
}
car::get_state(){
/*
имеем текущую скорость
//следование:
проверяем дистанцию до ближайшей машины впереди ()
если в состоянии помехи
проверить отмену помехи ()
если текущая помеха миновала
проверить наличие новой помехи ()
конец
иначе
проверить наличие помехи()
конец
проверяем состояние конца ребра и конца следующего ребра()
*/
>follow();>check_light();(this->pomeha) {>is_not_danger();(!this->pomeha) {>is_danger();
}
}{>is_danger();
}
}
car::move(){(line){>get_state();tm = Time();short h,m,s,ms;.DecodeTime(&h,&m,&s,&ms);currtime = h*3600000+m*60000+s*1000+ms;>PrevTime.DecodeTime(&h,&m,&s,&ms);ptime = h*3600000+m*60000+s*1000+ms;dT = currtime-ptime;
//---dX = this->curr_speed*dT + (this->curr_uskor+this->curr_zamedl)*dT*dT/2;dP = dX/line->r_length;>curr_speed+=(this->curr_uskor+this->curr_zamedl)*dT;(curr_speed < 0) {_speed = 0;_zamedl = 0;
}(curr_speed > max_speed) {_speed = max_speed;_uskor = 0;
}>PrevTime = tm;>place+=dP;(this->place >=1 && this->e_index ==0) {Ln = line->r_length*this->place-line->r_length;>get_next_line(Ln);
}CX, CY;(this->line) {>line->get_point(this->place,CX,CY);>cX = CX;>cY = CY;
}
}
}
|
|
|
