source: proiecte/ptvs/src/vnsim/vehicular/simulator/intersections/IntersectionWithoutTrafficLights.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.util.Collections;
import java.util.Comparator;
import java.util.Random;
import java.util.ArrayList;

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



public class IntersectionWithoutTrafficLights extends Intersection {
        
        /** <code>serialVersionUID</code> */
        private static final long serialVersionUID = -5883719321862303634L;

        public ArrayList<Boolean> mustStop; //indices corresponding with "segments" = must stop or not

        public IntersectionWithoutTrafficLights() {
        }

        public void addCrossingSegment(DirectedRoadSegment drs) {
                if(segments==null) {
                        segments=new ArrayList<DirectedRoadSegment> ();
                        mustStop=new ArrayList<Boolean> ();
                }
                if(!segments.contains(drs)) {
                        segments.add(drs);
                        mustStop.add(true);
                }
        }

        public boolean mustStop(RouteSegment seg1, RouteSegment seg2) {
                for(int i=0;i<segments.size();i++) {
                        if(segments.get(i).isSameSegment(seg1))
                                return mustStop.get(i);
                }
                System.out.println("ERROR! mustStop called, but segment not found in that intersection!");
                System.out.println("Segment called: "+seg1+"; MY SEGS="+segments);
                return false;
        }

        public boolean havePriority(RouteSegment seg1, RouteSegment seg2){
                //have absolute priority? (yield to nobody)
                //look through "segments"; the first 2 have priority
                if((segments.get(0).isSameSegment(seg1)) && (segments.get(1).isSameSegment(seg2)))
                        return true;
                if((segments.get(0).isSameSegment(seg2)) && (segments.get(1).isSameSegment(seg1)))
                        return true;
                return false;
        }

        public double getMaximumSpeed(RouteSegment seg1, RouteSegment seg2) {
                //look through "segments"
                if(havePriority(seg1, seg2))
                        return 40.0; //speed adjustment
                if(mustStop(seg1, seg2))
                        return 0.0;
                return 20.0;
        }

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

        public ArrayList<DirectedRoadSegment> yieldFor(RouteSegment seg1,
                        RouteSegment seg2) {
                //a vehicle coming on "seg1", going on "seg2"
                //must yield to vehicles coming on which segments?

                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!");
                //priority
                if((i==0 && j==1) || (i==1 && j==0))
                        return new ArrayList<DirectedRoadSegment>(); 

                if(i==0 || i==1) {
                        //yield to the other priority road, and only if going on "seg2"
                        //means crossing it (to the left)
                        if(i==0) {
                                if(isOrder(0,1,j)) {
                                        ArrayList<DirectedRoadSegment> ret=new ArrayList<DirectedRoadSegment> ();
                                        ret.add(segments.get(1));
                                        return ret;
                                } else
                                        return new ArrayList<DirectedRoadSegment> ();
                        }
                        if(i==1) {
                                if(isOrder(1,0,j)) {
                                        ArrayList<DirectedRoadSegment> ret=new ArrayList<DirectedRoadSegment> ();
                                        ret.add(segments.get(0));
                                        return ret;
                                } else
                                        return new ArrayList<DirectedRoadSegment> ();
                        }
                }

                //I have an "yield" sign
                ArrayList<DirectedRoadSegment> ret=new ArrayList<DirectedRoadSegment> ();

                //I must yield to all roads which are between "seg1" and "seg2" 
                //(counter-clock-wise);
                //Furthermore, if one of the priority roads is between "seg1" and "seg2", including "seg2",
                //then I must also yield to the other priority road!
                for(int k=0;k<segments.size();k++) {
                        if(k==1 && ret.contains(segments.get(1)))
                                continue;
                        if(k!=j) {
                                if(isOrder(i,k,j)) {
                                        ret.add(segments.get(k));
                                        if(k==0) {
                                                ret.add(segments.get(1));
                                        }
                                        if(k==1) {
                                                if(!ret.contains(segments.get(0)))
                                                        ret.add(segments.get(0));
                                        }
                                }
                        }
                }

                if(j==1) {
                        //yield to 0
                        if(!ret.contains(segments.get(0)))
                                ret.add(segments.get(0));
                }
                if(j==0) {
                        //yield to 1
                        if(!ret.contains(segments.get(1)))
                                ret.add(segments.get(1));
                }
                return ret;
        }

        public boolean hasTrafficLights() {
                return false;
        }

        public void sort(Random generator){
                Collections.sort(this.segments,new Comparator<DirectedRoadSegment>(){
                        public int compare(DirectedRoadSegment s1,DirectedRoadSegment s2){
                                int r1,r2,p1,p2;
                                //System.out.println("COMPAR: "+s1+" CU "+s2);
                                r1=s1.roadIndex;
                                r2=s2.roadIndex;                                
                                byte b1[];
                                byte b2[];
                                
                                b1=Globals.map.roads.get(r1).getRoadinfo();
                                b2=Globals.map.roads.get(r2).getRoadinfo();
                                if(b1[1]<b2[1]){
                                        return -1;
                                }else{
                                        if(b1[1]>b2[1]){
                                                return 1;
                                        }else{
                                                p1=Globals.map.roads.get(r1).getPoints().size();
                                                p2=Globals.map.roads.get(r2).getPoints().size();
                                                if(p1>p2){
                                                        return -1;
                                                } else {
                                                        if(p1<p2){
                                                                return 1;
                                                        }else{
                                                                return 0;
                                                        }
                                                }
                                        }
                                }
                        }
                });
                //System.out.println("Sort over1");

                this.mustStop=new ArrayList<Boolean>();
                this.mustStop.add(false);
                this.mustStop.add(false);

                for(int ll=2;ll<this.segments.size();ll++){
                        this.mustStop.add(generator.nextBoolean());
                }
                //System.out.println("Sort over2");
        }

        public String toString() {
                String ret="";
                ret=ret+"Segs:"+segments+";MustStop="+mustStop;
                return ret;
        }
}