Skip to content

Instantly share code, notes, and snippets.

Embed
What would you like to do?
//simulacion de trafico afectado por el cansancio de los conductores
//Encuentro de Processing 30 y 31 de Mayo
//controles globales del circuito
float curv=20;//curvatura del circuito: 100 = curvas muy cerradas, 0 = curvas muy abiertas
float ncurv=0.2;//numero de curvas: solo va bien con los valores 0.2, 0.1 y 0.05
float ancho=10;//distancia entre los dos carriles
//Arrays de los puntos de la carretera
Vertice[] puntosInt=new Vertice[0];//lista que contiene todos los puntos del carril interior
Vertice[] puntosExt=new Vertice[0];//lista que contine todos los puntos del carril exterior
float[] curvArray = new float[0];
//ArrayLists de los coches
ArrayList<Car>listaCar=new ArrayList<Car>();
Graph test;
float[] arraytest;
////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////
void setup() {
size(600, 600);
background(0);
loadRoad();
calculateCurv();//asigna el atributo de curvatura a cada punto de los carriles del circuito
PVector gLoc;
gLoc = new PVector(3,height-100);
test = new Graph(gLoc,width,200,25,25,curvArray,100);
}
void draw() {
background(0);
drawRoad();
test.display();
}
///////////////////////////////////////////////////////////////////
//funciones generales para el setup()
///////////////////////////////////////////////////////////////////
void loadRoad(){//esta funcion define el circuito/carretera para los coches
float step=PI/100;
float moveY = 100;
float radius = 150;
for(float i=0;i<2*PI;i=i+step){
/////carril interior
float r=radius+curv*sin(i/ncurv);//radio variable
float x=width/2+r*cos(i);//circunferencia, coordenada x
float y=height/2+r*sin(i)-moveY;//circunferencia, coordenada y
PVector loc1=new PVector(x,y,0);
float curvatura1=0;//despues calcularemos su valor
String carril1="interior";
Vertice vertInt=new Vertice(loc1, curvatura1, carril1);
puntosInt=(Vertice[])append(puntosInt, vertInt);//añade el vertice a la lista de vertices del carril interior
/////carril exterior
float r2=radius+curv*sin(i/ncurv)+ancho;
float x2=width/2+r2*cos(i);
float y2=height/2+r2*sin(i)-moveY;
PVector loc2=new PVector(x2,y2,0);
float curvatura2=0;//despues calcularemos su valor
String carril2="exterior";
Vertice vertExt=new Vertice(loc2, curvatura2, carril2);
puntosExt=(Vertice[])append(puntosExt, vertExt);//añade el vertice a la lista de vertices del carril interior
}
}
void calculateCurv(){
//esta funcion calcula la curvatura de cada punto de los carriles del circuito
//digamos que re-asigna el valor del atributo curvatura que se habia fijado como "0
for (int i = 0; i<puntosInt.length-2; i++){
PVector p0 = puntosInt[i].loc;
PVector p1 = puntosInt[i+1].loc;
PVector p2 = puntosInt[i+2].loc;
PVector v0 = PVector.sub(p1,p0);
PVector v1 = PVector.sub(p2,p1);
float curv = (v0.heading()-v1.heading());
puntosInt[i+1].curvatura = curv;
println("curv: "+curv);
}
PVector v0esp = PVector.sub(puntosInt[0].loc,puntosInt[puntosInt.length-1].loc);
PVector v1esp = PVector.sub(puntosInt[1].loc,puntosInt[0].loc);
PVector v2esp = PVector.sub(puntosInt[puntosInt.length-1].loc,puntosInt[puntosInt.length-2].loc);
puntosInt[0].curvatura = (v0esp.heading()-v1esp.heading());
puntosInt[puntosInt.length-1].curvatura = (v2esp.heading()-v0esp.heading());
for (int i = 0; i<puntosInt.length-1; i++){
curvArray=(float[])append(curvArray, puntosInt[i].curvatura);
}
}
void loadCars(){
//crea instancias de la clase Car y los mete en el ArrayList ListaCar
}
/////////////////////////////////////////////////////////////////////////
//funciones generales para el draw()
////////////////////////////////////////////////////////////////////////
void drawRoad(){//dibuja la carretera / falta un segemento si alguien lo puede arreglar / gracias!
stroke(255,100);//color de las lineas
for(int i=1;i<puntosInt.length;i++){
Vertice v1=puntosInt[i];
Vertice v2=puntosInt[i-1];
//Conectar el primero con el ultimo.
line(v1.loc.x,v1.loc.y,v2.loc.x,v2.loc.y);
}
line(puntosInt[0].loc.x, puntosInt[0].loc.y, puntosInt[puntosInt.length-1].loc.x, puntosInt[puntosInt.length-1].loc.y);
for(int i=1;i<puntosExt.length;i++){
Vertice v1=puntosExt[i];
Vertice v2=puntosExt[i-1];
line(v1.loc.x,v1.loc.y,v2.loc.x,v2.loc.y);
}
line(puntosExt[0].loc.x, puntosExt[0].loc.y, puntosExt[puntosExt.length-1].loc.x, puntosExt[puntosExt.length-1].loc.y);
}
class Vertice{
PVector loc;//coordenadas x y de cada punto del carril
float curvatura;//curvatura en cada punto del carril
String carril;//interior o exterior
Vertice(PVector _loc, float _curvatura, String _carril){
loc=_loc;
curvatura=_curvatura;
carril=_carril;
}
}
class Car{
//parametros propios
PVector loc;//posicion del coche en cada momento
PVector vel;//velocidad del coche en cada momento
PVector acc;//aceleracion del coche en cada momento
PVector velint;//velocidad [intencionada] deseada por el conductor
String carril;//izquierdo o derecho
int coefseg;//distancia de seguridad que procura el conductor, en funcion de la velocidad (a mas velocidad, mas distancia)
//parametros que afectan la atencion
int cansancio;//nivel de cansancio de 1 a 100
int time;//tiempo acumulado de conduccion
//parametros de terceros
int distdel;//distancia percibida del coche de delante
int distx_tras;//distancia percibida del coche de delante en el otro carril
int distx_del;//distancia percibida del coche de detras en el otro carril
PVector veldel;//velocidad percibida del coche de delante
PVector velx_tras;//velocidad percibida del coche de delante en el otro carril
PVector velx_del;//velocidad percibida del coche de detras en el otro carril
Car (PVector _loc, PVector _vel, PVector _acc, PVector _velint, String _carril, int _coefseg, int _cansancio, int _time,
int _distdel, int _distx_tras, int _distx_del, PVector _veldel, PVector _velx_tras, PVector _velx_del){
loc=_loc;
vel=_vel;
acc=_acc;
velint=_velint;
carril=_carril;
coefseg=_coefseg;
cansancio=_cansancio;
time=_time;
distdel=_distdel;
distx_tras=_distx_tras;
distx_del=_distx_del;
veldel=_veldel;
velx_tras=_velx_tras;
velx_del=_velx_del;
}
void drive(){
//esta funcion lee los puntos de la curva para obtener la direccion del vector velocidad
//debe usar la funcion changeLane definida mas abajo
}
void getFrontInfo(){
//esta funcion detecta la distancia y la velocidad del coche de delante. Puede introducirse un coeficiente de desviacion en funcion del cansancio
}
void getxLaneInfo(){
//esta funcion detecta la distancia y la velocidad del coche de delante y de atras del otro carril. Puede introducirse un coeficiente de desviacion en funcion del cansancio
}
void adjustSpeed(){
//esta funcion calcula la magnitud de la velocidad en funcion de:
// 1. la velocidad deseada
// 2. la curvatura de la carretera en el punto siguiente (la curvatura se ha definido como un atributo de la clase Vertice)
// 3. la del coche de delante
}
void changeLane(){
//esta funcion hace cambiar al coche de carril, si la velocidad es menor que la deseada cambia al carril izquierdo.
//para cambiar al carril izquierdo, primero debe comprobar la distancia y velocidad de los coches del carril izquierdo por delante y por detras.
//una vez cambiado de carril debe volver al derecho cuando le sea posible aplicando la misma comprobacion anterior, añadiendo una condicion: que haya adelantado al menos a un coche.
}
void crash(){
//detecta cuando un coche ha colisionado con otro... puede dejar una mancha roja en la pantalla y llevar un contador de accidentes,..
}
void render(){
//esta funcion dibuja el coche, puede incluir lineas de conexion con otros coches en casos de distancias peligrosas etc,.. tambien se pueden colorear los coches en funcion del cansancio etc..
}
}
/*
Crea un gráfico lineal de dos ejes opaco usando:
- data: array de datos de entrada.
- loc: punto de referencia para la creación del gráfico.
- lenX y lenY: longitudes de los dos ejes de referencia.
- divX y divY: número de divisiones de cada eje.
- opacity: opacidad del gráfico (pensado para superponerlos)
- drawAxis: conmutador para desactivar los ejes de referencia.
*/
class Graph{
//Propiedades de la clase
PVector loc;
float lenX, lenY, opacity;
boolean drawAxis;
int divX, divY;
float[] data;
//Constructor
Graph(PVector _loc, float _lenX, float _lenY, int _divX, int _divY, float[] _data, float _opacity)
{
loc = _loc;
lenX = _lenX;
lenY = _lenY;
divX = _divX;
divY = _divY;
opacity = _opacity;
data = _data;
}
void display()
{
// Se dibujarán los elementos del gráfico: ejes, lineas de datos...
pushMatrix();
//Ejes principales.
fill(255);
noStroke();
translate(loc.x, loc.y);
rectMode(CENTER);
rect(-3/2, 0, 3, lenY);
//Divisiones
for (int i = 0; i<=divX; i++)
{
stroke(255, 150);
strokeWeight(0.2);
line(i*(lenX/divX), lenY/2, i*(lenX/divX), -lenY/2);
}
for (int j = 0; j<=int(divY/2); j++)
{
stroke(255, 150);
strokeWeight(0.2);
line(0, j*(lenY/divY), lenX, j*(lenY/divY));
line(0, -j*(lenY/divY), lenX, -j*(lenY/divY));
}
for (int i = 0; i<data.length-1; i++){
//noStroke();
ellipse(i*(lenX/data.length), data[i]*100, 4, 4);
textSize(7);
//text(data[i],(i*(lenX/data.length))+5, (data[i]*10)+5);
if (i<data.length-2){
strokeWeight(0.7);
line(i*(lenX/data.length), data[i]*10, (i+1)*(lenX/data.length), data[i+1]*10);
}
}
popMatrix();
}
}
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment
You can’t perform that action at this time.