padre_SimTrafico.pde

//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();



	}

}