Главная
База знаний "Allbest"
Программирование, компьютеры и кибернетика
Моделирование транспортных потоков в среде Borland C++ Builder
Моделирование транспортных потоков в среде Borland C++ Builder
Классификация моделей транспортных потоков. Моделирования структуры проезжих частей и допустимых траекторий движения на перекрестке. Общие сведения о программной платформе. Структура классов, стадии и этапы разработки. Алгоритм следования за лидером.
| Рубрика | Программирование, компьютеры и кибернетика |
| Вид | курсовая работа |
| Язык | русский |
| Дата добавления | 04.06.2013 |
| Размер файла | 75,3 K |
Отправить свою хорошую работу в базу знаний просто. Используйте форму, расположенную ниже
Студенты, аспиранты, молодые ученые, использующие базу знаний в своей учебе и работе, будут вам очень благодарны.
e_c->you_major = 1;
}
else{
e_c->you_major = 0;
}
}
else{
//2 приоритет "едешь прямо" / "поворачиваешь"
if (E_->linear != E->linear) {
e_c->you_major = E->linear;
}
else{
//3 приоритет "помеха справа"
//!!!
}
}
crosses->Add(e_c);
}
}
return crosses;
}
void graph::find_crosses(){
for (int i = 0; i < this->Edges->Count; i++) {
edge *E = (edge*)Edges->Items[i];
E->cross_pts = this->find_cross_pts(E);
}
}
//---------------------------------------------------------------------------
#ifndef CarsH
#define CarsH
#include "Graphs.h"
#include "Main.h"
#include <vcl.h>
#include <systdate.h>
class car{
public:
edge *line;
edge *next_line;
vertex *Aim;
vertex *start;
TList *otherCars;
TList *path_edges;
bool pomeha;
bool stop_on_red;
double place;//[0..1]
int e_index;
int cX,cY;
car *main_car;
e_cross *danger_cross;
float max_speed; //m/msec
float curr_speed; //m/msec
float max_uskor; //m/msec^2
float max_zamedl; //m/msec^2
float curr_uskor; //m/msec^2
float curr_zamedl; //m/msec^2
TDateTime PrevTime;
graph *road;
car::car(double m_s, double m_u, double m_z, double c_s, vertex *Start, vertex *Finish, graph *Road, TList *otCars);
void car::start_first_line(vertex *V, vertex *Vn);
void car::get_state();
void car::move();
void car::get_next_line(double Ln);
void car::draw();
double car::dX_now();
double car::next_pos_now();
double car::crit_dist();
double car::dist_by_time(double accel, double time_ms);
double car::dist_to_stop(double accel);
double car::accel_by_dist_to_stop(double Ln);
double car::accel_by_next_car(double s_next, double dist41, double realdist);
double car::time_for_dist(double dist);
double car::check_distance(double &next_speed);
double car::nearest_car_dist();
void car::follow();
void car::is_danger();
void car::is_not_danger();
void car::check_light();
car *car::take_prev_car(double &prev_dist);
};
TList *Path_to_edges(TList *Path);
//---------------------------------------------------------------------------
#endif
//---------------------------------------------------------------------------
#pragma hdrstop
#include "Cars.h"
//---------------------------------------------------------------------------
#pragma package(smart_init)
#include <systdate.h>
TList *Path_to_edges(TList *P){
TList *Edges = new TList;
if (P->Count > 0) {
for (int i = 0; i < P->Count-1; i++) {
vertex *V = (vertex *)P->Items[i];
vertex *V_n = (vertex *)P->Items[i+1];
for (int j = 0; j < V->s_owners->Count; j++) {
edge *E = (edge *)V->s_owners->Items[j];
if (E->end->X == V_n->X && E->end->Y == V_n->Y) {
//
Edges->Add(E);
}
}
}
}
return Edges;
}
car::car(double m_s, double m_u, double m_z, double c_s, vertex *Start, vertex *Finish, graph *Road, TList *otCars){
max_speed = m_s;
max_uskor = m_u;
max_zamedl = m_z;
curr_speed = c_s;
curr_uskor = 0;
curr_zamedl = 0;
this->road = Road;
this->otherCars = otCars;
otCars->Add(this);
start_first_line(Start,Finish);
this->pomeha = 0;
this->stop_on_red = 0;
}
double car::dX_now(){
double nX, nY;
TDateTime tm = Time();
unsigned short h,m,s,ms;
tm.DecodeTime(&h,&m,&s,&ms);
int currtime = h*3600000+m*60000+s*1000+ms;
this->PrevTime.DecodeTime(&h,&m,&s,&ms);
int ptime = h*3600000+m*60000+s*1000+ms;
int dT = currtime-ptime;
double dL = dT*curr_speed + (curr_uskor+curr_zamedl)*dT*dT/2;
return dL;
}
double car::next_pos_now(){
double dL = dX_now();
double p_ = dL/line->r_length;
if (place+p_ >= 1) {
return 1;
}
return place+p_;
}
double car::crit_dist(){
return this->dist_to_stop(max_zamedl);
}
double car::dist_by_time(double accel, double time_ms){
return curr_speed*time_ms + accel*time_ms*time_ms/2;
}
double car::dist_to_stop(double accel){
return curr_speed*curr_speed/fabs(accel) + accel*(curr_speed/fabs(accel))*(curr_speed/fabs(accel))/2;
}
double car::accel_by_dist_to_stop(double Ln){
return -curr_speed*curr_speed/2/Ln;
}
double car::time_for_dist(double dist){
if (curr_speed*curr_speed + 2*(curr_uskor+curr_zamedl)*dist < 0) {
return 1000000000;
}
else{
if (curr_uskor+curr_zamedl == 0) {
if (curr_speed ==0) {
return 1000000000;
}
return dist/this->curr_speed;
}
return (-curr_speed + sqrt(curr_speed*curr_speed + 2*(curr_uskor+curr_zamedl)*dist))/(curr_uskor+curr_zamedl);
}
}
bool is_right(double X, double Y, double X_, double Y_){
if (X==0 && Y > 0) {
if (X_ < 0) {
return 1;
}
else{
return 0;
}
}
if (X==0 && Y < 0) {
if (X_ < 0) {
return 0;
}
else{
return 1;
}
}
if (Y==0 && X > 0) {
if (Y_ < 0) {
return 1;
}
else{
return 0;
}
}
if (Y==0 && X < 0) {
if (Y_ < 0) {
return 0;
}
else{
return 1;
}
}
bool is_upper;
if (Y/X*X_ > Y) {
is_upper=1;
}
else{
is_upper=0;
}
if (X > 0 && is_upper || X < 0 && !is_upper) {
return 1;
}
else{
return 0;
}
}
void car::start_first_line(vertex *V, vertex *Vn){
TList *Path = road->path(V,Vn);
if (Path->Count>1) {
TList *ep = Path_to_edges(Path);
path_edges = ep;
line = (edge *)ep->Items[0];
next_line = (edge *)ep->Items[1];
Aim = Vn;
start = V;
place = 0;
line->cars->Add(this);
e_index = line->cars->IndexOf(this);
PrevTime = Time();
}
else{
line=NULL;
}
}
void car::get_next_line(double Ln){
if (line->cars->Items[0] == this) {
line->cars->Delete(0);
for (int i = 0; i < line->cars->Count; i++) {
car *Car = (car*)line->cars->Items[i];
Car->e_index--;
}
}
vertex *V = line->end;
while (road->finding){
//ждемс...
}
TList *Path = road->path(V,Aim);
TList *ep = Path_to_edges(Path);
path_edges->Clear();
delete path_edges;
this->path_edges = ep;
if (ep->Count >= 2) {
line = (edge *)ep->Items[0];
next_line = (edge *)ep->Items[1];
place=Ln/line->r_length;
}
else{
if (ep->Count == 1) {
line = (edge *)ep->Items[0];
next_line = NULL;
place=Ln/line->r_length;
}
if (ep->Count == 0) {
line = NULL;
next_line = NULL;
//this->place=Ln/line->r_length;
}
}
if (line) {
line->cars->Add(this);
e_index = line->cars->IndexOf(this);
}
}
double car::check_distance(double &next_speed){
if (line->cars->Count > 1 && this->e_index > 0) {
car *C = (car*)line->cars->Items[e_index-1];
next_speed = C->curr_speed;
return line->r_length*(C->place - this->place);
}
else{
return -1;
}
}
double car::accel_by_next_car(double s_next, double dist41, double realdist){
return -(this->curr_speed - s_next)*(this->curr_speed - s_next)/2/fabs(realdist - dist41);
}
double car::nearest_car_dist(){
if (line==0) {
return -1;
}
else{
double nearest_car_dist = (1-place)*line->r_length;
if (next_line != NULL) {
if (this->next_line->cars->Count > 0) {
car *C = (car*)next_line->cars->Items[next_line->cars->Count-1];
nearest_car_dist +=(1-C->place)*next_line->r_length;
}
else{
nearest_car_dist+=next_line->r_length;
}
}
return nearest_car_dist;
}
}
void car::follow(){
double length_to=0;
car *C=NULL;
if (this->e_index > 0) {
//есть машина на этом ребре
C = (car *)line->cars->Items[e_index-1];
length_to = (C->place - place)*line->r_length;
}
else{
//ищем далее
for (int i = 1; i < this->path_edges->Count; i++) {
edge *E = (edge*)path_edges->Items[i];
if (E->cars->Count > 0) {
C = (car*)E->cars->Items[E->cars->Count-1];
length_to+=C->place*E->r_length;
break;
}
else{
length_to+=E->r_length;
}
}
}
if (curr_speed < max_speed && curr_uskor < max_uskor) {
curr_uskor = max_uskor;
curr_zamedl = 0;
}
if (C != NULL) {
//есть машина
if (length_to < 10) {
//критическая дистанция
curr_uskor = 0;
if (C->curr_speed == curr_speed) {
curr_zamedl = C->curr_zamedl*1.1;
if (curr_zamedl < max_zamedl) {
curr_zamedl = max_zamedl;
}
}
if (curr_speed > C->curr_speed) {
curr_zamedl = max_zamedl;
}
}
else{
//нормальная дистанция
if (curr_speed > C->curr_speed) {
curr_uskor=0;
curr_zamedl = -(curr_speed*curr_speed)/2/(length_to-10);
}
}
}
}
void car::is_not_danger(){
if (this->main_car && this->danger_cross) {
if (main_car->place > danger_cross->p_ + 10/main_car->line->r_length && main_car->line == danger_cross->E_) {
this->pomeha = 0;
}
}
}
void car::is_danger(){
//пока не все пересечения для текщего ребра выбраны
//если нужно уступать
//начало условия
//найти ближайшую к пересечению машину на текущем ребре
//найти время достижения пересечения t1
//пока есть машина или не найдена помеха
//начало цикла
//найти время достижения машиной пересечения t2
//если модуль разности |t1-t2|<4
//флаг помехи =1
//установить ускорение =0
//установить замедление, достаточное для остановки за 5 метров до пересечения
//устаносить main_car = текущая машина
//установить danger_cross = текущее пересечение
//return;
//иначе - перейти к следующей машине
//конец цикла
//перейти к след шагу цикла
//конец условия
//иначе
//перейти к след шагу цикла
if (line->cross_pts->Count > 0) {
for (int i = 0; i < line->cross_pts->Count; i++) {
e_cross *ec = (e_cross*)line->cross_pts->Items[i];
if (ec->you_major || ec->p < this->place) {
continue;
}
if (ec->E_->cars->Count>0) {
car *CC=NULL;
//double d2 = (ec->p_ - CC->place)*CC->line->r_length;
double d2 = 1000;
for (int j = 0; j < ec->E_->cars->Count; j++) {
car *C = (car*)ec->E_->cars->Items[j];
if (C->place < ec->p_ && !C->stop_on_red) {
CC = C;
break;
}
}
if (CC==NULL) {
for (int j = 0; j < ec->E_->start->e_owners->Count; j++) {
edge *E = (edge*)ec->E_->start->e_owners->Items[j];
for (int k = 0; k < E->cars->Count; k++) {
car *C = (car*)E->cars->Items[k];
double D2 = (1-C->place)*C->line->r_length + ec->p_*ec->E_->r_length;
if (!C->stop_on_red && D2 < d2) {
CC = C;
d2 = D2;
break;
}
}
}
if (CC==NULL) {
return;
}
}
else{
d2 = (ec->p_ - CC->place)*CC->line->r_length;
}
double d1 = (ec->p-place)*line->r_length;
double t1 = this->time_for_dist(d1);
while(CC) {
double t2 = CC->time_for_dist(d2);
if (fabs(t1-t2) < 10000) {
this->pomeha=1;
this->curr_uskor = 0;
curr_zamedl = -(curr_speed*curr_speed)/2/(d1-5);
main_car = CC;
danger_cross = ec;
return;
}
CC = CC->take_prev_car(d2);
}
}
}
}
if (next_line==NULL) {
return;
}
if (next_line->cross_pts->Count == 0) {
return;
}
for (int i = 0; i < next_line->cross_pts->Count; i++) {
e_cross *ec = (e_cross*) next_line->cross_pts->Items[i];
if (ec->you_major) {
continue;
}
if (ec->E_->cars->Count>0) {
car *CC=NULL;
//double d2 = (ec->p_ - CC->place)*CC->line->r_length;
double d2 = 1000;
for (int j = 0; j < ec->E_->cars->Count; j++) {
car *C = (car*)ec->E_->cars->Items[j];
if (C->place < ec->p_ && !C->stop_on_red) {
CC = C;
break;
}
}
if (CC==NULL) {
for (int j = 0; j < ec->E_->start->e_owners->Count; j++) {
edge *E = (edge*)ec->E_->start->e_owners->Items[j];
for (int k = 0; k < E->cars->Count; k++) {
car *C = (car*)E->cars->Items[k];
double D2 = (1-C->place)*C->line->r_length + ec->p_*ec->E_->r_length;
if (!C->stop_on_red && D2 < d2) {
CC = C;
d2 = D2;
break;
}
}
}
if (CC==NULL) {
return;
}
}
else{
d2 = (ec->p_ - CC->place)*CC->line->r_length;
}
double d1 = (ec->p)*next_line->r_length + (1-place)*line->r_length;
double t1 = this->time_for_dist(d1);
while(CC) {
double t2 = CC->time_for_dist(d2);
if (fabs(t1-t2) < 10000) {
this->pomeha=1;
this->curr_uskor = 0;
curr_zamedl = -(curr_speed*curr_speed)/2/(d1-5);
main_car = CC;
danger_cross = ec;
return;
}
CC = CC->take_prev_car(d2);
}
}
}
}
car *car::take_prev_car(double &prev_dist){
car *CC=NULL;
if (this->line->cars->Count == this->e_index+1) {
//на других ребрах
prev_dist+=place*line->r_length;
double d = 1000;
for (int j = 0; j < line->start->e_owners->Count; j++) {
edge *E = (edge*)line->start->e_owners->Items[j];
for (int k = 0; k < E->cars->Count; k++) {
car *C = (car*)E->cars->Items[k];
double D = (1-C->place)*C->line->r_length + prev_dist;
if (!C->stop_on_red && D < d) {
CC = C;
d = D;
break;
}
}
}
prev_dist+=d;
}
else{
car* C = (car*)line->cars->Items[e_index+1];
prev_dist += (place-C->place)*line->r_length;
CC=C;
}
return CC;
}
void car::check_light(){
//
}
void car::get_state(){
/*
имеем текущую скорость
//следование:
проверяем дистанцию до ближайшей машины впереди ()
если в состоянии помехи
проверить отмену помехи ()
если текущая помеха миновала
проверить наличие новой помехи ()
конец
иначе
проверить наличие помехи()
конец
проверяем состояние конца ребра и конца следующего ребра()
*/
this->follow();
this->check_light();
if (this->pomeha) {
this->is_not_danger();
if (!this->pomeha) {
this->is_danger();
}
}
else{
this->is_danger();
}
}
void car::move(){
if(line){
this->get_state();
TDateTime tm = Time();
unsigned short h,m,s,ms;
tm.DecodeTime(&h,&m,&s,&ms);
int currtime = h*3600000+m*60000+s*1000+ms;
this->PrevTime.DecodeTime(&h,&m,&s,&ms);
int ptime = h*3600000+m*60000+s*1000+ms;
int dT = currtime-ptime;
//---
double dX = this->curr_speed*dT + (this->curr_uskor+this->curr_zamedl)*dT*dT/2;
double dP = dX/line->r_length;
this->curr_speed+=(this->curr_uskor+this->curr_zamedl)*dT;
if (curr_speed < 0) {
curr_speed = 0;
curr_zamedl = 0;
}
if (curr_speed > max_speed) {
curr_speed = max_speed;
curr_uskor = 0;
}
this->PrevTime = tm;
this->place+=dP;
if (this->place >=1 && this->e_index ==0) {
double Ln = line->r_length*this->place-line->r_length;
this->get_next_line(Ln);
}
double CX, CY;
if (this->line) {
this->line->get_point(this->place,CX,CY);
this->cX = CX;
this->cY = CY;
}
}
}
Размещено на Allbest.ru
Подобные документы
Работа в Borland C++ Builder. Среда разработки и компоненты C++ Builder. Свойства компонентов. Менеджер проектов. Создание приложений в C++ Builder. Выбор компонентов для групповых операций. Работа с базами данных в Borland C++ Builder.
курсовая работа [35,8 K], добавлен 11.06.2007Понятие баз данных, их место в сфере обработки информации. Разработка базы данных транспортных потоков для работы в геоинформационной системе ArcGis. Учет и анализ интенсивности движения на участках улично-дорожной сети на примере г. Ростова-на-Дону.
курсовая работа [4,0 M], добавлен 06.12.2012Разработка программного продукта (лабиринт с входом и выходом, состоящий из комнат) в среде разработки Borland C++ Builder 6. Требования пользователя к программному изделию. Программные ограничения, совместимость. Основные процессы разработки программы.
курсовая работа [819,9 K], добавлен 14.01.2013AnyLogic как инструмент компьютерного моделирования нового поколения. Процесс разработки моделей и реализация имитационных моделей для распространения эпидемического заболевания. Разработка систем обратной связи (диаграммы потоков и накопителей).
контрольная работа [1,8 M], добавлен 21.07.2014Разработка граф-схемы имитационной модели финансовых потоков предприятия и реализация модели программными средствами Pilgrim. Алгоритм моделирования с постоянным шагом. Выполнение моделирования на полученной программе, разработка программного кода.
курсовая работа [1,8 M], добавлен 22.11.2013Основные этапы имитационного моделирования станции мойки: определение условий задачи, разработка структурной, укрупненной и детальной схем ее реализации; написание математической и программной моделей ее решения. Представление результатов моделирования.
курсовая работа [137,4 K], добавлен 29.06.2011Общие сведения по использованию базы данных. Описание предметной области программы. Выбор средств программирования для разработки приложений, технология работы. Оценка автоматизированного рабочего места продавца компакт-дисков в среде Borland C++ Builder.
курсовая работа [1,3 M], добавлен 24.12.2010Разработка приложений для работы с графикой в Borland C++ Builder. Вывод изображения на экран, изменение цвета и толщины линии контура, перемещение объекта по экрану, получение нового объекта вычитанием двух существующих. Основные обработчики событий.
контрольная работа [1,5 M], добавлен 28.03.2012Использование моделирования в программной инженерии в процессе разработки программного обеспечения. Основные этапы процесса разработки программного обеспечения, их характеристика. Моделирование процессов, их определение фазами и видами деятельности.
реферат [2,2 M], добавлен 25.12.2017Разработка концептуальной модели компьютерной имитации транспортных потоков на двухполосных автомобильных дорогах. Методы оценки уровня безопасности движения; функциональное и информационное обеспечение моделирования конфликтных ситуаций на пересечениях.
дипломная работа [1,5 M], добавлен 28.11.2012
