source: proiecte/ptvs/src/vnsim/vehicular/simulator/intersections/IntersectionWithTrafficLights.java @ 31

/************************************************************************************
 * Copyright (C) 2008 by Politehnica University of Bucharest and Rutgers University
 * All rights reserved.
 * Refer to LICENSE for terms and conditions of use.
 ***********************************************************************************/
package vnsim.vehicular.simulator.intersections;

import java.io.File;
import java.util.ArrayList;

import vnsim.map.object.Globals;
import vnsim.vehicular.simulator.*;

public class IntersectionWithTrafficLights extends Intersection {

        /** <code>serialVersionUID</code> */
        private static final long serialVersionUID = -5883719321862303634L;

        // indices corresponding with the "segments" Vector
        // public ArrayList<TrafficLightInfo> lightInfos;
        public ArrayList<Integer> currentColor; // 1=RED, 2=YELLOW, 3=GREEN

        public int lastCycleStartTime = 0;
        public int cycleLength;

        public void addCrossingSegment(DirectedRoadSegment drs) {
                if (segments == null) {
                        segments = new ArrayList<DirectedRoadSegment>();
                        currentColor = new ArrayList<Integer>();
                }
                if (!segments.contains(drs)) {
                        segments.add(drs);
                        currentColor.add(0);
                }
        }

        // public void addTrafficLightInfo(TrafficLightInfo info) {
        // if(lightInfos==null) {
        // lightInfos=new ArrayList<TrafficLightInfo> ();
        // }
        // lightInfos.add(info);
        // }

        public synchronized boolean isGreen(RouteSegment src) {
                for (int i = 0; i < segments.size(); i++) {
                        if (segments.get(i).isSameSegment(src)) {
                                if (currentColor.get(i).intValue() == 3)
                                        return true;
                                else
                                        return false;
                        }
                }
                System.err.println("ERROR! isGreen called, but segment not found in intersection!");
                System.err.println("->"+src.roadIndex+" "+src.pt1+" "+src.pt2);
                for (int i = 0; i < segments.size(); i++) {
                        System.err.println("\t->"+segments.get(i).roadIndex+" "+segments.get(i).pointIndex);    
                }
                return false;
        }

        public synchronized boolean isGreen(int k) {
                if (currentColor.get(k).intValue() == 3)
                        return true;
                return false;
        }

        public synchronized boolean isRed(int k) {
                if (currentColor.get(k).intValue() == 1)
                        return true;
                return false;
        }

        public synchronized boolean isYellow(RouteSegment src) {
                for (int i = 0; i < segments.size(); i++) {
                        if (segments.get(i).isSameSegment(src)) {
                                if (currentColor.get(i).intValue() == 2)
                                        return true;
                                else
                                        return false;
                        }
                }
                System.out.println("ERROR! isYellow called, but segment not found in intersection!");
                return false;
        }

        public boolean mustStop(RouteSegment src, RouteSegment dst) {
                return false;
        }

        public boolean havePriority(RouteSegment seg1, RouteSegment seg2) {
                return false;
        }

        public synchronized ArrayList<DirectedRoadSegment> yieldFor(RouteSegment seg1, RouteSegment seg2) {
                // a vehicle coming on "seg1", going on "seg2"
                // must yield to vehicles coming on which segments?
                ArrayList<DirectedRoadSegment> ret = new ArrayList<DirectedRoadSegment>();
                int i;
                for (i = 0; i < segments.size(); i++) {
                        if (segments.get(i).isSameSegment(seg1))
                                break;
                }
                int j;
                for (j = 0; j < segments.size(); j++) {
                        if (segments.get(j).isSameSegment(seg2))
                                break;
                }
                if (i == segments.size() || j == segments.size())
                        System.out.println("*** ERROR! yieldFor - wrong parameters!");
                for (int k = 0; k < segments.size(); k++) {
                        if (k == i || k == j)
                                continue;
                        if (isOrder(i, k, j) && isGreen(k)) {
                                ret.add(segments.get(k));
                        }
                }
                return ret;
        }

        public boolean isLeftTurn(RouteSegment seg1, RouteSegment seg2) {
                DirectedRoadSegment s1 = null, s2 = null;
                int i;
                for (i = 0; i < segments.size(); i++) {
                        if (segments.get(i).isSameSegment(seg1)) {
                                s1 = segments.get(i);
                                break;
                        }
                }
                int j;
                for (j = 0; j < segments.size(); j++) {
                        if (segments.get(j).isSameSegment(seg2)) {
                                s2 = segments.get(j);
                                break;
                        }
                }
                if (s1 != null && s1.left != null && s1.left.equals(s2))
                        return true;
                return false;
        }

        // returns the maximum allowed speed when the light is green
        public double getMaximumSpeed(RouteSegment seg1, RouteSegment seg2) {
                return 20.0;
        }

        public double getInfluenceDistance(RouteSegment seg1, RouteSegment seg2) {
                return 0.100;
        }

        public double getInfluenceDistanceLaneChange(RouteSegment seg1, RouteSegment seg2) {
                return 0.200;
        }

        public boolean hasTrafficLights() {
                return true;
        }

        public String toString() {
                String ret = "";
                ret = ret + segments + " - " + currentColor;
                return ret;
        }

        public void step(int crtTime) {

                int thisSec = (int) (crtTime / (Globals.executionFPS));
                int prevSec = (int) ((crtTime - 1) / (Globals.executionFPS));
                int aux = thisSec % this.cycleLength;
                int prev = prevSec % this.cycleLength;

                synchronized (this) {
                        this.currentColor = new ArrayList<Integer>();
                        for (int k = 0; k < this.segments.size(); k++) {
                                TrafficLightInfo info = segments.get(k).lightInfo;
                                int color = info.getColor(aux);
                                this.currentColor.add(new Integer(color));
                                if (info.getColor(prev) != color) {
                                        segments.get(k).changePhase(null, crtTime, color);
                                }
                        }
                }
        }

}